[rfc] [08/09] Get rid of current_gdbarch (infcall)

[rfc] [08/09] Get rid of current_gdbarch (infcall)

[Markus Deuling]

[-- Attachment #1: Type: text/plain, Size: 1068 bytes --]

Hi,

this patch adds gdbarch parameter to find_function_addr from infcall.c and all its callers.

Tested by gdb_mbuild and running testsuite on x86. Ok to commit?


ChangeLog:

	* infcall.c (call_function_by_hand): Use get_frame_arch to get at the
	current architecture by frame_info.
	(find_function_addr): Add gdbarch parameter. Replace current_gdbarch by
	gdbarch.
	* infcall.h (find_function_addr): Add gdbarch parameter.

	* rs6000-tdep.c (rs6000_push_dummy_call): Add gdbarch to
	find_function_addr call.
	* valops.c (value_ind): Likewise.
	* ppc-sysv-tdep.c (ppc64_sysv_abi_push_dummy_call): Likewise.
	* mips-tdep.c (mips_eabi_push_dummy_call)
	(mips_n32n64_push_dummy_call, mips_o32_push_dummy_call)
	(mips_o64_push_dummy_call): Likewise.
	* mep-tdep.c (mep_push_dummy_call): Likewise.
	* frv-tdep.c (frv_push_dummy_call): Likewise.
	* ia64-tdep.c (ia64_push_dummy_call): Likewise.
	* eval.c (evaluate_subexp_standard): Likewise.
	* alpha-tdep.c (alpha_push_dummy_call): Likewise.


-- 
Markus Deuling
GNU Toolchain for Linux on Cell BE
deuling@de.ibm.com




[-- Attachment #2: diff-infcall --]
[-- Type: text/plain, Size: 16507 bytes --]

diff -urpN src/gdb/alpha-tdep.c dev2/gdb/alpha-tdep.c
--- src/gdb/alpha-tdep.c	2007-11-05 05:32:21.000000000 +0100
+++ dev2/gdb/alpha-tdep.c	2007-11-05 11:24:14.000000000 +0100
@@ -270,7 +270,7 @@ alpha_push_dummy_call (struct gdbarch *g
   struct alpha_arg *m_arg;
   gdb_byte arg_reg_buffer[ALPHA_REGISTER_SIZE * ALPHA_NUM_ARG_REGS];
   int required_arg_regs;
-  CORE_ADDR func_addr = find_function_addr (function, NULL);
+  CORE_ADDR func_addr = find_function_addr (gdbarch, function, NULL);
 
   /* The ABI places the address of the called function in T12.  */
   regcache_cooked_write_signed (regcache, ALPHA_T12_REGNUM, func_addr);
diff -urpN src/gdb/eval.c dev2/gdb/eval.c
--- src/gdb/eval.c	2007-10-25 20:01:58.000000000 +0200
+++ dev2/gdb/eval.c	2007-11-05 11:24:14.000000000 +0100
@@ -912,7 +912,7 @@ evaluate_subexp_standard (struct type *e
 	    CORE_ADDR funaddr;
 	    struct type *value_type;
 
-	    funaddr = find_function_addr (method, &value_type);
+	    funaddr = find_function_addr (current_gdbarch, method, &value_type);
 
 	    b = block_for_pc (funaddr);
 
diff -urpN src/gdb/frv-tdep.c dev2/gdb/frv-tdep.c
--- src/gdb/frv-tdep.c	2007-11-05 05:32:21.000000000 +0100
+++ dev2/gdb/frv-tdep.c	2007-11-05 11:24:14.000000000 +0100
@@ -1118,7 +1118,7 @@ frv_push_dummy_call (struct gdbarch *gdb
   int stack_space;
   int stack_offset;
   enum frv_abi abi = frv_abi (gdbarch);
-  CORE_ADDR func_addr = find_function_addr (function, NULL);
+  CORE_ADDR func_addr = find_function_addr (gdbarch, function, NULL);
 
 #if 0
   printf("Push %d args at sp = %x, struct_return=%d (%x)\n",
diff -urpN src/gdb/ia64-tdep.c dev2/gdb/ia64-tdep.c
--- src/gdb/ia64-tdep.c	2007-11-05 05:32:21.000000000 +0100
+++ dev2/gdb/ia64-tdep.c	2007-11-05 11:24:14.000000000 +0100
@@ -3360,7 +3360,7 @@ ia64_push_dummy_call (struct gdbarch *gd
   int floatreg;
   ULONGEST bsp, cfm, pfs, new_bsp;
   CORE_ADDR funcdescaddr, pc, global_pointer;
-  CORE_ADDR func_addr = find_function_addr (function, NULL);
+  CORE_ADDR func_addr = find_function_addr (gdbarch, function, NULL);
 
   nslots = 0;
   nfuncargs = 0;
diff -urpN src/gdb/infcall.c dev2/gdb/infcall.c
--- src/gdb/infcall.c	2007-10-12 17:34:45.000000000 +0200
+++ dev2/gdb/infcall.c	2007-11-05 11:25:01.000000000 +0100
@@ -182,7 +182,8 @@ value_arg_coerce (struct value *arg, str
    Calls error() if the function is not valid for calling.  */
 
 CORE_ADDR
-find_function_addr (struct value *function, struct type **retval_type)
+find_function_addr (struct gdbarch *gdbarch, struct value *function,
+		    struct type **retval_type)
 {
   struct type *ftype = check_typedef (value_type (function));
   enum type_code code = TYPE_CODE (ftype);
@@ -205,7 +206,7 @@ find_function_addr (struct value *functi
       if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
 	  || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
 	{
-	  funaddr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
+	  funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch,
 							funaddr,
 							&current_target);
 	  value_type = TYPE_TARGET_TYPE (ftype);
@@ -228,7 +229,7 @@ find_function_addr (struct value *functi
 	      CORE_ADDR nfunaddr;
 	      funaddr = value_as_address (value_addr (function));
 	      nfunaddr = funaddr;
-	      funaddr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
+	      funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch,
 							    funaddr,
 							    &current_target);
 	      if (funaddr != nfunaddr)
@@ -246,7 +247,7 @@ find_function_addr (struct value *functi
 
   if (retval_type != NULL)
     *retval_type = value_type;
-  return funaddr + gdbarch_deprecated_function_start_offset (current_gdbarch);
+  return funaddr + gdbarch_deprecated_function_start_offset (gdbarch);
 }
 
 /* Call breakpoint_auto_delete on the current contents of the bpstat
@@ -354,6 +355,8 @@ call_function_by_hand (struct value *fun
   struct cleanup *caller_regcache_cleanup;
   struct frame_id dummy_id;
   struct cleanup *args_cleanup;
+  struct frame_info *frame;
+  struct gdbarch *gdbarch;
 
   if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
     ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
@@ -361,14 +364,17 @@ call_function_by_hand (struct value *fun
   if (!target_has_execution)
     noprocess ();
 
-  if (!gdbarch_push_dummy_call_p (current_gdbarch))
+  frame = get_current_frame ();
+  gdbarch = get_frame_arch (frame);
+
+  if (!gdbarch_push_dummy_call_p (gdbarch))
     error (_("This target does not support function calls"));
 
   /* Create a cleanup chain that contains the retbuf (buffer
      containing the register values).  This chain is create BEFORE the
      inf_status chain so that the inferior status can cleaned up
      (restored or discarded) without having the retbuf freed.  */
-  retbuf = regcache_xmalloc (current_gdbarch);
+  retbuf = regcache_xmalloc (gdbarch);
   retbuf_cleanup = make_cleanup_regcache_xfree (retbuf);
 
   /* A cleanup for the inferior status.  Create this AFTER the retbuf
@@ -381,26 +387,26 @@ call_function_by_hand (struct value *fun
      callee returns.  To allow nested calls the registers are (further
      down) pushed onto a dummy frame stack.  Include a cleanup (which
      is tossed once the regcache has been pushed).  */
-  caller_regcache = frame_save_as_regcache (get_current_frame ());
+  caller_regcache = frame_save_as_regcache (frame);
   caller_regcache_cleanup = make_cleanup_regcache_xfree (caller_regcache);
 
   /* Ensure that the initial SP is correctly aligned.  */
   {
-    CORE_ADDR old_sp = get_frame_sp (get_current_frame ());
-    if (gdbarch_frame_align_p (current_gdbarch))
+    CORE_ADDR old_sp = get_frame_sp (frame);
+    if (gdbarch_frame_align_p (gdbarch))
       {
-	sp = gdbarch_frame_align (current_gdbarch, old_sp);
+	sp = gdbarch_frame_align (gdbarch, old_sp);
 	/* NOTE: cagney/2003-08-13: Skip the "red zone".  For some
 	   ABIs, a function can use memory beyond the inner most stack
 	   address.  AMD64 called that region the "red zone".  Skip at
 	   least the "red zone" size before allocating any space on
 	   the stack.  */
-	if (gdbarch_inner_than (current_gdbarch, 1, 2))
-	  sp -= gdbarch_frame_red_zone_size (current_gdbarch);
+	if (gdbarch_inner_than (gdbarch, 1, 2))
+	  sp -= gdbarch_frame_red_zone_size (gdbarch);
 	else
-	  sp += gdbarch_frame_red_zone_size (current_gdbarch);
+	  sp += gdbarch_frame_red_zone_size (gdbarch);
 	/* Still aligned?  */
-	gdb_assert (sp == gdbarch_frame_align (current_gdbarch, sp));
+	gdb_assert (sp == gdbarch_frame_align (gdbarch, sp));
 	/* NOTE: cagney/2002-09-18:
 	   
 	   On a RISC architecture, a void parameterless generic dummy
@@ -423,16 +429,16 @@ call_function_by_hand (struct value *fun
 	   to pay :-).  */
 	if (sp == old_sp)
 	  {
-	    if (gdbarch_inner_than (current_gdbarch, 1, 2))
+	    if (gdbarch_inner_than (gdbarch, 1, 2))
 	      /* Stack grows down.  */
-	      sp = gdbarch_frame_align (current_gdbarch, old_sp - 1);
+	      sp = gdbarch_frame_align (gdbarch, old_sp - 1);
 	    else
 	      /* Stack grows up.  */
-	      sp = gdbarch_frame_align (current_gdbarch, old_sp + 1);
+	      sp = gdbarch_frame_align (gdbarch, old_sp + 1);
 	  }
-	gdb_assert ((gdbarch_inner_than (current_gdbarch, 1, 2)
+	gdb_assert ((gdbarch_inner_than (gdbarch, 1, 2)
 		    && sp <= old_sp)
-		    || (gdbarch_inner_than (current_gdbarch, 2, 1)
+		    || (gdbarch_inner_than (gdbarch, 2, 1)
 		       && sp >= old_sp));
       }
     else
@@ -451,7 +457,7 @@ call_function_by_hand (struct value *fun
       sp = old_sp;
   }
 
-  funaddr = find_function_addr (function, &values_type);
+  funaddr = find_function_addr (gdbarch, function, &values_type);
   CHECK_TYPEDEF (values_type);
 
   /* Are we returning a value using a structure return (passing a
@@ -488,14 +494,14 @@ call_function_by_hand (struct value *fun
   /* The actual breakpoint (at BP_ADDR) is inserted separatly so there
      is no need to write that out.  */
 
-  switch (gdbarch_call_dummy_location (current_gdbarch))
+  switch (gdbarch_call_dummy_location (gdbarch))
     {
     case ON_STACK:
       /* "dummy_addr" is here just to keep old targets happy.  New
 	 targets return that same information via "sp" and "bp_addr".  */
-      if (gdbarch_inner_than (current_gdbarch, 1, 2))
+      if (gdbarch_inner_than (gdbarch, 1, 2))
 	{
-	  sp = push_dummy_code (current_gdbarch, sp, funaddr,
+	  sp = push_dummy_code (gdbarch, sp, funaddr,
 				args, nargs, target_values_type,
 				&real_pc, &bp_addr, get_current_regcache ());
 	  dummy_addr = sp;
@@ -503,7 +509,7 @@ call_function_by_hand (struct value *fun
       else
 	{
 	  dummy_addr = sp;
-	  sp = push_dummy_code (current_gdbarch, sp, funaddr,
+	  sp = push_dummy_code (gdbarch, sp, funaddr,
 				args, nargs, target_values_type,
 				&real_pc, &bp_addr, get_current_regcache ());
 	}
@@ -513,7 +519,7 @@ call_function_by_hand (struct value *fun
       dummy_addr = entry_point_address ();
       /* Make certain that the address points at real code, and not a
          function descriptor.  */
-      dummy_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
+      dummy_addr = gdbarch_convert_from_func_ptr_addr (gdbarch,
 						       dummy_addr,
 						       &current_target);
       /* A call dummy always consists of just a single breakpoint, so
@@ -536,7 +542,7 @@ call_function_by_hand (struct value *fun
 	  dummy_addr = entry_point_address ();
 	/* Make certain that the address points at real code, and not
 	   a function descriptor.  */
-	dummy_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
+	dummy_addr = gdbarch_convert_from_func_ptr_addr (gdbarch,
 							 dummy_addr,
 							 &current_target);
 	/* A call dummy always consists of just a single breakpoint,
@@ -586,25 +592,25 @@ call_function_by_hand (struct value *fun
   if (struct_return || lang_struct_return)
     {
       int len = TYPE_LENGTH (values_type);
-      if (gdbarch_inner_than (current_gdbarch, 1, 2))
+      if (gdbarch_inner_than (gdbarch, 1, 2))
 	{
 	  /* Stack grows downward.  Align STRUCT_ADDR and SP after
              making space for the return value.  */
 	  sp -= len;
-	  if (gdbarch_frame_align_p (current_gdbarch))
-	    sp = gdbarch_frame_align (current_gdbarch, sp);
+	  if (gdbarch_frame_align_p (gdbarch))
+	    sp = gdbarch_frame_align (gdbarch, sp);
 	  struct_addr = sp;
 	}
       else
 	{
 	  /* Stack grows upward.  Align the frame, allocate space, and
              then again, re-align the frame??? */
-	  if (gdbarch_frame_align_p (current_gdbarch))
-	    sp = gdbarch_frame_align (current_gdbarch, sp);
+	  if (gdbarch_frame_align_p (gdbarch))
+	    sp = gdbarch_frame_align (gdbarch, sp);
 	  struct_addr = sp;
 	  sp += len;
-	  if (gdbarch_frame_align_p (current_gdbarch))
-	    sp = gdbarch_frame_align (current_gdbarch, sp);
+	  if (gdbarch_frame_align_p (gdbarch))
+	    sp = gdbarch_frame_align (gdbarch, sp);
 	}
     }
 
@@ -627,7 +633,7 @@ call_function_by_hand (struct value *fun
   /* Create the dummy stack frame.  Pass in the call dummy address as,
      presumably, the ABI code knows where, in the call dummy, the
      return address should be pointed.  */
-  sp = gdbarch_push_dummy_call (current_gdbarch, function,
+  sp = gdbarch_push_dummy_call (gdbarch, function,
 				get_current_regcache (), bp_addr, nargs, args,
 				sp, struct_return, struct_addr);
 
@@ -834,15 +840,14 @@ the function call)."), name);
       }
     else
       {
-	struct gdbarch *arch = current_gdbarch;
-
-	switch (gdbarch_return_value (arch, target_values_type, NULL, NULL, NULL))
+	switch (gdbarch_return_value (gdbarch, target_values_type,
+				      NULL, NULL, NULL))
 	  {
 	  case RETURN_VALUE_REGISTER_CONVENTION:
 	  case RETURN_VALUE_ABI_RETURNS_ADDRESS:
 	  case RETURN_VALUE_ABI_PRESERVES_ADDRESS:
 	    retval = allocate_value (values_type);
-	    gdbarch_return_value (current_gdbarch, values_type, retbuf,
+	    gdbarch_return_value (gdbarch, values_type, retbuf,
 				  value_contents_raw (retval), NULL);
 	    break;
 	  case RETURN_VALUE_STRUCT_CONVENTION:
diff -urpN src/gdb/infcall.h dev2/gdb/infcall.h
--- src/gdb/infcall.h	2007-08-23 20:08:35.000000000 +0200
+++ dev2/gdb/infcall.h	2007-11-05 11:24:14.000000000 +0100
@@ -23,7 +23,8 @@
 struct value;
 struct type;
 
-extern CORE_ADDR find_function_addr (struct value *function, 
+extern CORE_ADDR find_function_addr (struct gdbarch *gdbarch,
+				     struct value *function,
 				     struct type **retval_type);
 
 /* Perform a function call in the inferior.
diff -urpN src/gdb/mep-tdep.c dev2/gdb/mep-tdep.c
--- src/gdb/mep-tdep.c	2007-11-05 05:32:22.000000000 +0100
+++ dev2/gdb/mep-tdep.c	2007-11-05 11:24:14.000000000 +0100
@@ -2305,7 +2305,7 @@ mep_push_dummy_call (struct gdbarch *gdb
                      CORE_ADDR struct_addr)
 {
   CORE_ADDR *copy = (CORE_ADDR *) alloca (argc * sizeof (copy[0]));
-  CORE_ADDR func_addr = find_function_addr (function, NULL);
+  CORE_ADDR func_addr = find_function_addr (gdbarch, function, NULL);
   int i;
 
   /* The number of the next register available to hold an argument.  */
diff -urpN src/gdb/mips-tdep.c dev2/gdb/mips-tdep.c
--- src/gdb/mips-tdep.c	2007-11-05 05:32:22.000000000 +0100
+++ dev2/gdb/mips-tdep.c	2007-11-05 11:24:15.000000000 +0100
@@ -2623,7 +2623,7 @@ mips_eabi_push_dummy_call (struct gdbarc
   int len = 0;
   int stack_offset = 0;
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
-  CORE_ADDR func_addr = find_function_addr (function, NULL);
+  CORE_ADDR func_addr = find_function_addr (gdbarch, function, NULL);
   int regsize = mips_abi_regsize (gdbarch);
 
   /* For shared libraries, "t9" needs to point at the function
@@ -2960,7 +2960,7 @@ mips_n32n64_push_dummy_call (struct gdba
   int len = 0;
   int stack_offset = 0;
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
-  CORE_ADDR func_addr = find_function_addr (function, NULL);
+  CORE_ADDR func_addr = find_function_addr (gdbarch, function, NULL);
 
   /* For shared libraries, "t9" needs to point at the function
      address.  */
@@ -3343,7 +3343,7 @@ mips_o32_push_dummy_call (struct gdbarch
   int len = 0;
   int stack_offset = 0;
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
-  CORE_ADDR func_addr = find_function_addr (function, NULL);
+  CORE_ADDR func_addr = find_function_addr (gdbarch, function, NULL);
 
   /* For shared libraries, "t9" needs to point at the function
      address.  */
@@ -3805,7 +3805,7 @@ mips_o64_push_dummy_call (struct gdbarch
   int len = 0;
   int stack_offset = 0;
   struct gdbarch_tdep *tdep = gdbarch_tdep (gdbarch);
-  CORE_ADDR func_addr = find_function_addr (function, NULL);
+  CORE_ADDR func_addr = find_function_addr (gdbarch, function, NULL);
 
   /* For shared libraries, "t9" needs to point at the function
      address.  */
diff -urpN src/gdb/ppc-sysv-tdep.c dev2/gdb/ppc-sysv-tdep.c
--- src/gdb/ppc-sysv-tdep.c	2007-10-31 05:54:46.000000000 +0100
+++ dev2/gdb/ppc-sysv-tdep.c	2007-11-05 11:24:15.000000000 +0100
@@ -627,7 +627,7 @@ ppc64_sysv_abi_push_dummy_call (struct g
 				int nargs, struct value **args, CORE_ADDR sp,
 				int struct_return, CORE_ADDR struct_addr)
 {
-  CORE_ADDR func_addr = find_function_addr (function, NULL);
+  CORE_ADDR func_addr = find_function_addr (gdbarch, function, NULL);
   struct gdbarch_tdep *tdep = gdbarch_tdep (current_gdbarch);
   ULONGEST back_chain;
   /* See for-loop comment below.  */
diff -urpN src/gdb/rs6000-tdep.c dev2/gdb/rs6000-tdep.c
--- src/gdb/rs6000-tdep.c	2007-11-05 05:32:22.000000000 +0100
+++ dev2/gdb/rs6000-tdep.c	2007-11-05 11:24:15.000000000 +0100
@@ -1861,7 +1861,7 @@ rs6000_push_dummy_call (struct gdbarch *
   gdb_byte tmp_buffer[50];
   int f_argno = 0;		/* current floating point argno */
   int wordsize = gdbarch_tdep (gdbarch)->wordsize;
-  CORE_ADDR func_addr = find_function_addr (function, NULL);
+  CORE_ADDR func_addr = find_function_addr (gdbarch, function, NULL);
 
   struct value *arg = 0;
   struct type *type;
diff -urpN src/gdb/valops.c dev2/gdb/valops.c
--- src/gdb/valops.c	2007-11-05 05:32:22.000000000 +0100
+++ dev2/gdb/valops.c	2007-11-05 11:24:15.000000000 +0100
@@ -942,7 +942,7 @@ value_ind (struct value *arg1)
 	/* For functions, go through find_function_addr, which knows
 	   how to handle function descriptors.  */
 	arg2 = value_at_lazy (enc_type, 
-			      find_function_addr (arg1, NULL));
+			      find_function_addr (current_gdbarch, arg1, NULL));
       else
 	/* Retrieve the enclosing object pointed to */
 	arg2 = value_at_lazy (enc_type, 

Re: [rfc] [08/09] Get rid of current_gdbarch (infcall)

[Ulrich Weigand]

Markus Deuling wrote:

> 	* infcall.c (call_function_by_hand): Use get_frame_arch to get at the
> 	current architecture by frame_info.

This part is fine.

However, I'm not convinced this:

> 	(find_function_addr): Add gdbarch parameter. Replace current_gdbarch by
> 	gdbarch.
> 	* infcall.h (find_function_addr): Add gdbarch parameter.

is the right way to go.  Consider the call to find_function_addr in value_ind:
there is no clear way how that function would know which architecture to use.

I'm hoping that at some point in the future, a "struct value" for a function
would contain enough information to identify the architecture the function
is defined for, determined at the time the value is generated.

If we can make that happen, there will be no need to pass an additional
gdbarch parameter to find_function_addr.  Thus, I'd prefer to defer this
interface change until we have resolved that question.


Bye,
Ulrich

-- 
  Dr. Ulrich Weigand
  GNU Toolchain for Linux on System z and Cell BE
  Ulrich.Weigand@de.ibm.com

Re: [rfc] [08/09] Get rid of current_gdbarch (infcall)

[Markus Deuling]

[-- Attachment #1: Type: text/plain, Size: 814 bytes --]

Ulrich Weigand schrieb:
> Markus Deuling wrote:
> 
>> 	* infcall.c (call_function_by_hand): Use get_frame_arch to get at the
>> 	current architecture by frame_info.
> 
> This part is fine.
> 

> is defined for, determined at the time the value is generated.
> 
> If we can make that happen, there will be no need to pass an additional
> gdbarch parameter to find_function_addr.  Thus, I'd prefer to defer this
> interface change until we have resolved that question.
 
Ok, then I withdraw this part of the patch. Attached is a new version with only the upper part.
Tested by running testsuite on x86. Ok to commit?


ChangeLog:

	* infcall.c (call_function_by_hand): Use get_frame_arch to get at the
	current architecture by frame_info.



-- 
Markus Deuling
GNU Toolchain for Linux on Cell BE
deuling@de.ibm.com


[-- Attachment #2: diff-infcall --]
[-- Type: text/plain, Size: 8169 bytes --]

diff -urpN src/gdb/infcall.c dev/gdb/infcall.c
--- src/gdb/infcall.c	2007-10-12 17:34:45.000000000 +0200
+++ dev/gdb/infcall.c	2007-11-06 10:23:52.000000000 +0100
@@ -354,6 +354,8 @@ call_function_by_hand (struct value *fun
   struct cleanup *caller_regcache_cleanup;
   struct frame_id dummy_id;
   struct cleanup *args_cleanup;
+  struct frame_info *frame;
+  struct gdbarch *gdbarch;
 
   if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
     ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
@@ -361,14 +363,17 @@ call_function_by_hand (struct value *fun
   if (!target_has_execution)
     noprocess ();
 
-  if (!gdbarch_push_dummy_call_p (current_gdbarch))
+  frame = get_current_frame ();
+  gdbarch = get_frame_arch (frame);
+
+  if (!gdbarch_push_dummy_call_p (gdbarch))
     error (_("This target does not support function calls"));
 
   /* Create a cleanup chain that contains the retbuf (buffer
      containing the register values).  This chain is create BEFORE the
      inf_status chain so that the inferior status can cleaned up
      (restored or discarded) without having the retbuf freed.  */
-  retbuf = regcache_xmalloc (current_gdbarch);
+  retbuf = regcache_xmalloc (gdbarch);
   retbuf_cleanup = make_cleanup_regcache_xfree (retbuf);
 
   /* A cleanup for the inferior status.  Create this AFTER the retbuf
@@ -381,26 +386,26 @@ call_function_by_hand (struct value *fun
      callee returns.  To allow nested calls the registers are (further
      down) pushed onto a dummy frame stack.  Include a cleanup (which
      is tossed once the regcache has been pushed).  */
-  caller_regcache = frame_save_as_regcache (get_current_frame ());
+  caller_regcache = frame_save_as_regcache (frame);
   caller_regcache_cleanup = make_cleanup_regcache_xfree (caller_regcache);
 
   /* Ensure that the initial SP is correctly aligned.  */
   {
-    CORE_ADDR old_sp = get_frame_sp (get_current_frame ());
-    if (gdbarch_frame_align_p (current_gdbarch))
+    CORE_ADDR old_sp = get_frame_sp (frame);
+    if (gdbarch_frame_align_p (gdbarch))
       {
-	sp = gdbarch_frame_align (current_gdbarch, old_sp);
+	sp = gdbarch_frame_align (gdbarch, old_sp);
 	/* NOTE: cagney/2003-08-13: Skip the "red zone".  For some
 	   ABIs, a function can use memory beyond the inner most stack
 	   address.  AMD64 called that region the "red zone".  Skip at
 	   least the "red zone" size before allocating any space on
 	   the stack.  */
-	if (gdbarch_inner_than (current_gdbarch, 1, 2))
-	  sp -= gdbarch_frame_red_zone_size (current_gdbarch);
+	if (gdbarch_inner_than (gdbarch, 1, 2))
+	  sp -= gdbarch_frame_red_zone_size (gdbarch);
 	else
-	  sp += gdbarch_frame_red_zone_size (current_gdbarch);
+	  sp += gdbarch_frame_red_zone_size (gdbarch);
 	/* Still aligned?  */
-	gdb_assert (sp == gdbarch_frame_align (current_gdbarch, sp));
+	gdb_assert (sp == gdbarch_frame_align (gdbarch, sp));
 	/* NOTE: cagney/2002-09-18:
 	   
 	   On a RISC architecture, a void parameterless generic dummy
@@ -423,16 +428,16 @@ call_function_by_hand (struct value *fun
 	   to pay :-).  */
 	if (sp == old_sp)
 	  {
-	    if (gdbarch_inner_than (current_gdbarch, 1, 2))
+	    if (gdbarch_inner_than (gdbarch, 1, 2))
 	      /* Stack grows down.  */
-	      sp = gdbarch_frame_align (current_gdbarch, old_sp - 1);
+	      sp = gdbarch_frame_align (gdbarch, old_sp - 1);
 	    else
 	      /* Stack grows up.  */
-	      sp = gdbarch_frame_align (current_gdbarch, old_sp + 1);
+	      sp = gdbarch_frame_align (gdbarch, old_sp + 1);
 	  }
-	gdb_assert ((gdbarch_inner_than (current_gdbarch, 1, 2)
+	gdb_assert ((gdbarch_inner_than (gdbarch, 1, 2)
 		    && sp <= old_sp)
-		    || (gdbarch_inner_than (current_gdbarch, 2, 1)
+		    || (gdbarch_inner_than (gdbarch, 2, 1)
 		       && sp >= old_sp));
       }
     else
@@ -488,14 +493,14 @@ call_function_by_hand (struct value *fun
   /* The actual breakpoint (at BP_ADDR) is inserted separatly so there
      is no need to write that out.  */
 
-  switch (gdbarch_call_dummy_location (current_gdbarch))
+  switch (gdbarch_call_dummy_location (gdbarch))
     {
     case ON_STACK:
       /* "dummy_addr" is here just to keep old targets happy.  New
 	 targets return that same information via "sp" and "bp_addr".  */
-      if (gdbarch_inner_than (current_gdbarch, 1, 2))
+      if (gdbarch_inner_than (gdbarch, 1, 2))
 	{
-	  sp = push_dummy_code (current_gdbarch, sp, funaddr,
+	  sp = push_dummy_code (gdbarch, sp, funaddr,
 				args, nargs, target_values_type,
 				&real_pc, &bp_addr, get_current_regcache ());
 	  dummy_addr = sp;
@@ -503,7 +508,7 @@ call_function_by_hand (struct value *fun
       else
 	{
 	  dummy_addr = sp;
-	  sp = push_dummy_code (current_gdbarch, sp, funaddr,
+	  sp = push_dummy_code (gdbarch, sp, funaddr,
 				args, nargs, target_values_type,
 				&real_pc, &bp_addr, get_current_regcache ());
 	}
@@ -513,7 +518,7 @@ call_function_by_hand (struct value *fun
       dummy_addr = entry_point_address ();
       /* Make certain that the address points at real code, and not a
          function descriptor.  */
-      dummy_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
+      dummy_addr = gdbarch_convert_from_func_ptr_addr (gdbarch,
 						       dummy_addr,
 						       &current_target);
       /* A call dummy always consists of just a single breakpoint, so
@@ -536,7 +541,7 @@ call_function_by_hand (struct value *fun
 	  dummy_addr = entry_point_address ();
 	/* Make certain that the address points at real code, and not
 	   a function descriptor.  */
-	dummy_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
+	dummy_addr = gdbarch_convert_from_func_ptr_addr (gdbarch,
 							 dummy_addr,
 							 &current_target);
 	/* A call dummy always consists of just a single breakpoint,
@@ -586,25 +591,25 @@ call_function_by_hand (struct value *fun
   if (struct_return || lang_struct_return)
     {
       int len = TYPE_LENGTH (values_type);
-      if (gdbarch_inner_than (current_gdbarch, 1, 2))
+      if (gdbarch_inner_than (gdbarch, 1, 2))
 	{
 	  /* Stack grows downward.  Align STRUCT_ADDR and SP after
              making space for the return value.  */
 	  sp -= len;
-	  if (gdbarch_frame_align_p (current_gdbarch))
-	    sp = gdbarch_frame_align (current_gdbarch, sp);
+	  if (gdbarch_frame_align_p (gdbarch))
+	    sp = gdbarch_frame_align (gdbarch, sp);
 	  struct_addr = sp;
 	}
       else
 	{
 	  /* Stack grows upward.  Align the frame, allocate space, and
              then again, re-align the frame??? */
-	  if (gdbarch_frame_align_p (current_gdbarch))
-	    sp = gdbarch_frame_align (current_gdbarch, sp);
+	  if (gdbarch_frame_align_p (gdbarch))
+	    sp = gdbarch_frame_align (gdbarch, sp);
 	  struct_addr = sp;
 	  sp += len;
-	  if (gdbarch_frame_align_p (current_gdbarch))
-	    sp = gdbarch_frame_align (current_gdbarch, sp);
+	  if (gdbarch_frame_align_p (gdbarch))
+	    sp = gdbarch_frame_align (gdbarch, sp);
 	}
     }
 
@@ -627,8 +632,8 @@ call_function_by_hand (struct value *fun
   /* Create the dummy stack frame.  Pass in the call dummy address as,
      presumably, the ABI code knows where, in the call dummy, the
      return address should be pointed.  */
-  sp = gdbarch_push_dummy_call (current_gdbarch, function,
-				get_current_regcache (), bp_addr, nargs, args,
+  sp = gdbarch_push_dummy_call (gdbarch, function, get_current_regcache (),
+				bp_addr, nargs, args,
 				sp, struct_return, struct_addr);
 
   do_cleanups (args_cleanup);
@@ -834,15 +839,14 @@ the function call)."), name);
       }
     else
       {
-	struct gdbarch *arch = current_gdbarch;
-
-	switch (gdbarch_return_value (arch, target_values_type, NULL, NULL, NULL))
+	switch (gdbarch_return_value (gdbarch, target_values_type,
+				      NULL, NULL, NULL))
 	  {
 	  case RETURN_VALUE_REGISTER_CONVENTION:
 	  case RETURN_VALUE_ABI_RETURNS_ADDRESS:
 	  case RETURN_VALUE_ABI_PRESERVES_ADDRESS:
 	    retval = allocate_value (values_type);
-	    gdbarch_return_value (current_gdbarch, values_type, retbuf,
+	    gdbarch_return_value (gdbarch, values_type, retbuf,
 				  value_contents_raw (retval), NULL);
 	    break;
 	  case RETURN_VALUE_STRUCT_CONVENTION:

Re: [rfc] [08/09] Get rid of current_gdbarch (infcall)

[Ulrich Weigand]

Markus Deuling wrote:

> 	* infcall.c (call_function_by_hand): Use get_frame_arch to get at the
> 	current architecture by frame_info.

OK.

Thanks,
Ulrich

-- 
  Dr. Ulrich Weigand
  GNU Toolchain for Linux on System z and Cell BE
  Ulrich.Weigand@de.ibm.com

Re: [rfc] [08/09] Get rid of current_gdbarch (infcall)

[Markus Deuling]

Ulrich Weigand schrieb:
> Markus Deuling wrote:
> 
>> 	* infcall.c (call_function_by_hand): Use get_frame_arch to get at the
>> 	current architecture by frame_info.
> 
> OK.
> 
> Thanks,
> Ulrich
> 

Committed, thank you !

-- 
Markus Deuling
GNU Toolchain for Linux on Cell BE
deuling@de.ibm.com