X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Finfcall.c;h=537596984c159216dcf526e6b02f57d441265780;hb=064f515651b1e730c60652eaf07f94c22841d475;hp=7695c6ab6791b0951d05c8ad473d0212aeccb3f6;hpb=ce2826aa7a697eed52dcb0aee57d087b285ebef0;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/infcall.c b/gdb/infcall.c index 7695c6ab67..537596984c 100644 --- a/gdb/infcall.c +++ b/gdb/infcall.c @@ -1,8 +1,8 @@ /* Perform an inferior function call, for GDB, the GNU debugger. - Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, - 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 Free Software - Foundation, Inc. + Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, + 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 + Free Software Foundation, Inc. This file is part of GDB. @@ -18,8 +18,8 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, - Boston, MA 02111-1307, USA. */ + Foundation, Inc., 51 Franklin Street, Fifth Floor, + Boston, MA 02110-1301, USA. */ #include "defs.h" #include "breakpoint.h" @@ -30,11 +30,12 @@ #include "block.h" #include "gdbcore.h" #include "language.h" -#include "symfile.h" +#include "objfiles.h" #include "gdbcmd.h" #include "command.h" #include "gdb_string.h" #include "infcall.h" +#include "dummy-frame.h" /* NOTE: cagney/2003-04-16: What's the future of this code? @@ -64,6 +65,14 @@ with "set coerce-float-to-double 0". */ static int coerce_float_to_double_p = 1; +static void +show_coerce_float_to_double_p (struct ui_file *file, int from_tty, + struct cmd_list_element *c, const char *value) +{ + fprintf_filtered (file, _("\ +Coercion of floats to doubles when calling functions is %s.\n"), + value); +} /* This boolean tells what gdb should do if a signal is received while in a function called from gdb (call dummy). If set, gdb unwinds @@ -73,6 +82,15 @@ static int coerce_float_to_double_p = 1; The default is to stop in the frame where the signal was received. */ int unwind_on_signal_p = 0; +static void +show_unwind_on_signal_p (struct ui_file *file, int from_tty, + struct cmd_list_element *c, const char *value) +{ + fprintf_filtered (file, _("\ +Unwinding of stack if a signal is received while in a call dummy is %s.\n"), + value); +} + /* Perform the standard coercions that are specified for arguments to be passed to C functions. @@ -84,21 +102,27 @@ static struct value * value_arg_coerce (struct value *arg, struct type *param_type, int is_prototyped) { - struct type *arg_type = check_typedef (VALUE_TYPE (arg)); + struct type *arg_type = check_typedef (value_type (arg)); struct type *type = param_type ? check_typedef (param_type) : arg_type; switch (TYPE_CODE (type)) { case TYPE_CODE_REF: - if (TYPE_CODE (arg_type) != TYPE_CODE_REF - && TYPE_CODE (arg_type) != TYPE_CODE_PTR) - { - arg = value_addr (arg); - VALUE_TYPE (arg) = param_type; - return arg; - } - break; + { + struct value *new_value; + + if (TYPE_CODE (arg_type) == TYPE_CODE_REF) + return value_cast_pointers (type, arg); + + /* Cast the value to the reference's target type, and then + convert it back to a reference. This will issue an error + if the value was not previously in memory - in some cases + we should clearly be allowing this, but how? */ + new_value = value_cast (TYPE_TARGET_TYPE (type), arg); + new_value = value_ref (new_value); + return new_value; + } case TYPE_CODE_INT: case TYPE_CODE_CHAR: case TYPE_CODE_BOOL: @@ -145,7 +169,8 @@ value_arg_coerce (struct value *arg, struct type *param_type, case TYPE_CODE_STRING: case TYPE_CODE_BITSTRING: case TYPE_CODE_ERROR: - case TYPE_CODE_MEMBER: + case TYPE_CODE_MEMBERPTR: + case TYPE_CODE_METHODPTR: case TYPE_CODE_METHOD: case TYPE_CODE_COMPLEX: default: @@ -161,7 +186,7 @@ value_arg_coerce (struct value *arg, struct type *param_type, CORE_ADDR find_function_addr (struct value *function, struct type **retval_type) { - struct type *ftype = check_typedef (VALUE_TYPE (function)); + struct type *ftype = check_typedef (value_type (function)); enum type_code code = TYPE_CODE (ftype); struct type *value_type; CORE_ADDR funaddr; @@ -203,10 +228,11 @@ find_function_addr (struct value *function, struct type **retval_type) value_type = builtin_type_int; } else - error ("Invalid data type for function to be called."); + error (_("Invalid data type for function to be called.")); - *retval_type = value_type; - return funaddr; + if (retval_type != NULL) + *retval_type = value_type; + return funaddr + gdbarch_deprecated_function_start_offset (current_gdbarch); } /* Call breakpoint_auto_delete on the current contents of the bpstat @@ -218,93 +244,13 @@ breakpoint_auto_delete_contents (void *arg) breakpoint_auto_delete (*(bpstat *) arg); } -static CORE_ADDR -legacy_push_dummy_code (struct gdbarch *gdbarch, - CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, - struct value **args, int nargs, - struct type *value_type, - CORE_ADDR *real_pc, CORE_ADDR *bp_addr) -{ - /* CALL_DUMMY is an array of words (DEPRECATED_REGISTER_SIZE), but - each word is in host byte order. Before calling - DEPRECATED_FIX_CALL_DUMMY, we byteswap it and remove any extra - bytes which might exist because ULONGEST is bigger than - DEPRECATED_REGISTER_SIZE. */ - /* NOTE: This is pretty wierd, as the call dummy is actually a - sequence of instructions. But CISC machines will have to pack - the instructions into DEPRECATED_REGISTER_SIZE units (and so will - RISC machines for which INSTRUCTION_SIZE is not - DEPRECATED_REGISTER_SIZE). */ - /* NOTE: This is pretty stupid. CALL_DUMMY should be in strict - target byte order. */ - CORE_ADDR start_sp; - ULONGEST *dummy = alloca (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS); - int sizeof_dummy1 = (DEPRECATED_REGISTER_SIZE - * DEPRECATED_SIZEOF_CALL_DUMMY_WORDS - / sizeof (ULONGEST)); - char *dummy1 = alloca (sizeof_dummy1); - memcpy (dummy, DEPRECATED_CALL_DUMMY_WORDS, - DEPRECATED_SIZEOF_CALL_DUMMY_WORDS); - if (INNER_THAN (1, 2)) - { - /* Stack grows down */ - sp -= sizeof_dummy1; - start_sp = sp; - } - else - { - /* Stack grows up */ - start_sp = sp; - sp += sizeof_dummy1; - } - /* NOTE: cagney/2002-09-10: Don't bother re-adjusting the stack - after allocating space for the call dummy. A target can specify - a SIZEOF_DUMMY1 (via DEPRECATED_SIZEOF_CALL_DUMMY_WORDS) such - that all local alignment requirements are met. */ - /* Create a call sequence customized for this function and the - number of arguments for it. */ - { - int i; - for (i = 0; i < (int) (DEPRECATED_SIZEOF_CALL_DUMMY_WORDS / sizeof (dummy[0])); - i++) - store_unsigned_integer (&dummy1[i * DEPRECATED_REGISTER_SIZE], - DEPRECATED_REGISTER_SIZE, - (ULONGEST) dummy[i]); - } - /* NOTE: cagney/2003-04-22: This computation of REAL_PC, BP_ADDR and - DUMMY_ADDR is pretty messed up. It comes from constant tinkering - with the values. Instead a DEPRECATED_FIX_CALL_DUMMY replacement - (PUSH_DUMMY_BREAKPOINT?) should just do everything. */ -#ifdef GDB_TARGET_IS_HPPA - (*real_pc) = DEPRECATED_FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, - args, value_type, using_gcc); -#else - if (DEPRECATED_FIX_CALL_DUMMY_P ()) - { - /* gdb_assert (CALL_DUMMY_LOCATION == ON_STACK) true? */ - DEPRECATED_FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args, - value_type, using_gcc); - } - (*real_pc) = start_sp; -#endif - /* Yes, the offset is applied to the real_pc and not the dummy addr. - Ulgh! Blame the HP/UX target. */ - (*bp_addr) = (*real_pc) + DEPRECATED_CALL_DUMMY_BREAKPOINT_OFFSET; - /* Yes, the offset is applied to the real_pc and not the - dummy_addr. Ulgh! Blame the HP/UX target. */ - (*real_pc) += DEPRECATED_CALL_DUMMY_START_OFFSET; - write_memory (start_sp, (char *) dummy1, sizeof_dummy1); - if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES) - generic_save_call_dummy_addr (start_sp, start_sp + sizeof_dummy1); - return sp; -} - static CORE_ADDR generic_push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, - CORE_ADDR *real_pc, CORE_ADDR *bp_addr) + CORE_ADDR *real_pc, CORE_ADDR *bp_addr, + struct regcache *regcache) { /* Something here to findout the size of a breakpoint and then allocate space for it on the stack. */ @@ -335,25 +281,25 @@ generic_push_dummy_code (struct gdbarch *gdbarch, return sp; } -/* Provide backward compatibility. Once DEPRECATED_FIX_CALL_DUMMY is - eliminated, this can be simplified. */ +/* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called + function returns to. */ static CORE_ADDR push_dummy_code (struct gdbarch *gdbarch, CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc, struct value **args, int nargs, struct type *value_type, - CORE_ADDR *real_pc, CORE_ADDR *bp_addr) + CORE_ADDR *real_pc, CORE_ADDR *bp_addr, + struct regcache *regcache) { if (gdbarch_push_dummy_code_p (gdbarch)) return gdbarch_push_dummy_code (gdbarch, sp, funaddr, using_gcc, - args, nargs, value_type, real_pc, bp_addr); - else if (DEPRECATED_FIX_CALL_DUMMY_P ()) - return legacy_push_dummy_code (gdbarch, sp, funaddr, using_gcc, - args, nargs, value_type, real_pc, bp_addr); + args, nargs, value_type, real_pc, bp_addr, + regcache); else return generic_push_dummy_code (gdbarch, sp, funaddr, using_gcc, - args, nargs, value_type, real_pc, bp_addr); + args, nargs, value_type, real_pc, bp_addr, + regcache); } /* All this stuff with a dummy frame may seem unnecessarily complicated @@ -379,7 +325,7 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) { CORE_ADDR sp; CORE_ADDR dummy_addr; - struct type *value_type; + struct type *values_type; unsigned char struct_return; CORE_ADDR struct_addr = 0; struct regcache *retbuf; @@ -389,12 +335,21 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) CORE_ADDR funaddr; int using_gcc; /* Set to version of gcc in use, or zero if not gcc */ CORE_ADDR real_pc; - struct type *ftype = check_typedef (SYMBOL_TYPE (function)); + struct type *ftype = check_typedef (value_type (function)); CORE_ADDR bp_addr; + struct regcache *caller_regcache; + struct cleanup *caller_regcache_cleanup; + struct frame_id dummy_id; + + if (TYPE_CODE (ftype) == TYPE_CODE_PTR) + ftype = check_typedef (TYPE_TARGET_TYPE (ftype)); if (!target_has_execution) noprocess (); + if (!gdbarch_push_dummy_call_p (current_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 @@ -408,38 +363,16 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) inf_status = save_inferior_status (1); inf_status_cleanup = make_cleanup_restore_inferior_status (inf_status); - if (DEPRECATED_PUSH_DUMMY_FRAME_P ()) - { - /* DEPRECATED_PUSH_DUMMY_FRAME is responsible for saving the - inferior registers (and frame_pop() for restoring them). (At - least on most machines) they are saved on the stack in the - inferior. */ - DEPRECATED_PUSH_DUMMY_FRAME; - } - else - { - /* FIXME: cagney/2003-02-26: Step zero of this little tinker is - to extract the generic dummy frame code from the architecture - vector. Hence this direct call. - - A follow-on change is to modify this interface so that it takes - thread OR frame OR ptid as a parameter, and returns a dummy - frame handle. The handle can then be used further down as a - parameter to generic_save_dummy_frame_tos(). Hmm, thinking - about it, since everything is ment to be using generic dummy - frames, why not even use some of the dummy frame code to here - - do a regcache dup and then pass the duped regcache, along with - all the other stuff, at one single point. - - In fact, you can even save the structure's return address in the - dummy frame and fix one of those nasty lost struct return edge - conditions. */ - generic_push_dummy_frame (); - } + /* Save the caller's registers so that they can be restored once the + 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_cleanup = make_cleanup_regcache_xfree (caller_regcache); /* Ensure that the initial SP is correctly aligned. */ { - CORE_ADDR old_sp = read_sp (); + CORE_ADDR old_sp = get_frame_sp (get_current_frame ()); if (gdbarch_frame_align_p (current_gdbarch)) { sp = gdbarch_frame_align (current_gdbarch, old_sp); @@ -448,7 +381,7 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) address. AMD64 called that region the "red zone". Skip at least the "red zone" size before allocating any space on the stack. */ - if (INNER_THAN (1, 2)) + if (gdbarch_inner_than (current_gdbarch, 1, 2)) sp -= gdbarch_frame_red_zone_size (current_gdbarch); else sp += gdbarch_frame_red_zone_size (current_gdbarch); @@ -476,15 +409,17 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) to pay :-). */ if (sp == old_sp) { - if (INNER_THAN (1, 2)) + if (gdbarch_inner_than (current_gdbarch, 1, 2)) /* Stack grows down. */ sp = gdbarch_frame_align (current_gdbarch, old_sp - 1); else /* Stack grows up. */ sp = gdbarch_frame_align (current_gdbarch, old_sp + 1); } - gdb_assert ((INNER_THAN (1, 2) && sp <= old_sp) - || (INNER_THAN (2, 1) && sp >= old_sp)); + gdb_assert ((gdbarch_inner_than (current_gdbarch, 1, 2) + && sp <= old_sp) + || (gdbarch_inner_than (current_gdbarch, 2, 1) + && sp >= old_sp)); } else /* FIXME: cagney/2002-09-18: Hey, you loose! @@ -502,8 +437,8 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) sp = old_sp; } - funaddr = find_function_addr (function, &value_type); - CHECK_TYPEDEF (value_type); + funaddr = find_function_addr (function, &values_type); + CHECK_TYPEDEF (values_type); { struct block *b = block_for_pc (funaddr); @@ -514,7 +449,7 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) /* Are we returning a value using a structure return or a normal value return? */ - struct_return = using_struct_return (value_type, using_gcc); + struct_return = using_struct_return (values_type, using_gcc); /* Determine the location of the breakpoint (and possibly other stuff) that the called function will return to. The SPARC, for a @@ -525,43 +460,29 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) /* The actual breakpoint (at BP_ADDR) is inserted separatly so there is no need to write that out. */ - switch (CALL_DUMMY_LOCATION) + switch (gdbarch_call_dummy_location (current_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 (INNER_THAN (1, 2)) + if (gdbarch_inner_than (current_gdbarch, 1, 2)) { sp = push_dummy_code (current_gdbarch, sp, funaddr, - using_gcc, args, nargs, value_type, - &real_pc, &bp_addr); + using_gcc, args, nargs, values_type, + &real_pc, &bp_addr, get_current_regcache ()); dummy_addr = sp; } else { dummy_addr = sp; sp = push_dummy_code (current_gdbarch, sp, funaddr, - using_gcc, args, nargs, value_type, - &real_pc, &bp_addr); + using_gcc, args, nargs, values_type, + &real_pc, &bp_addr, get_current_regcache ()); } break; case AT_ENTRY_POINT: - if (DEPRECATED_FIX_CALL_DUMMY_P ()) - { - /* Sigh. Some targets use DEPRECATED_FIX_CALL_DUMMY to - shove extra stuff onto the stack or into registers. That - code should be in PUSH_DUMMY_CALL, however, in the mean - time ... */ - /* If the target is manipulating DUMMY1, it looses big time. */ - void *dummy1 = NULL; - DEPRECATED_FIX_CALL_DUMMY (dummy1, sp, funaddr, nargs, args, - value_type, using_gcc); - } real_pc = funaddr; dummy_addr = entry_point_address (); - if (DEPRECATED_CALL_DUMMY_ADDRESS_P ()) - /* Override it. */ - dummy_addr = DEPRECATED_CALL_DUMMY_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, @@ -596,16 +517,11 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) break; } default: - internal_error (__FILE__, __LINE__, "bad switch"); + internal_error (__FILE__, __LINE__, _("bad switch")); } - if (DEPRECATED_USE_GENERIC_DUMMY_FRAMES) - /* Save where the breakpoint is going to be inserted so that the - dummy-frame code is later able to re-identify it. */ - generic_save_call_dummy_addr (bp_addr, bp_addr + 1); - if (nargs < TYPE_NFIELDS (ftype)) - error ("too few arguments in function call"); + error (_("too few arguments in function call")); { int i; @@ -656,27 +572,28 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) this point. */ /* Go see if the actual parameter is a variable of type pointer to function or just a function. */ - if (args[i]->lval == not_lval) + if (VALUE_LVAL (args[i]) == not_lval) { char *arg_name; - if (find_pc_partial_function ((CORE_ADDR) args[i]->aligner.contents[0], &arg_name, NULL, NULL)) - error ("\ + /* NOTE: cagney/2005-01-02: THIS IS BOGUS. */ + if (find_pc_partial_function ((CORE_ADDR) value_contents (args[i])[0], &arg_name, NULL, NULL)) + error (_("\ You cannot use function <%s> as argument. \n\ -You must use a pointer to function type variable. Command ignored.", arg_name); +You must use a pointer to function type variable. Command ignored."), arg_name); } } } } } - if (DEPRECATED_REG_STRUCT_HAS_ADDR_P ()) + if (gdbarch_deprecated_reg_struct_has_addr_p (current_gdbarch)) { int i; /* This is a machine like the sparc, where we may need to pass a pointer to the structure, not the structure itself. */ for (i = nargs - 1; i >= 0; i--) { - struct type *arg_type = check_typedef (VALUE_TYPE (args[i])); + struct type *arg_type = check_typedef (value_type (args[i])); if ((TYPE_CODE (arg_type) == TYPE_CODE_STRUCT || TYPE_CODE (arg_type) == TYPE_CODE_UNION || TYPE_CODE (arg_type) == TYPE_CODE_ARRAY @@ -686,23 +603,17 @@ You must use a pointer to function type variable. Command ignored.", arg_name); || (TYPE_CODE (arg_type) == TYPE_CODE_FLT && TYPE_LENGTH (arg_type) > 8) ) - && DEPRECATED_REG_STRUCT_HAS_ADDR (using_gcc, arg_type)) + && gdbarch_deprecated_reg_struct_has_addr + (current_gdbarch, using_gcc, arg_type)) { CORE_ADDR addr; int len; /* = TYPE_LENGTH (arg_type); */ int aligned_len; - arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i])); + arg_type = check_typedef (value_enclosing_type (args[i])); len = TYPE_LENGTH (arg_type); - if (DEPRECATED_STACK_ALIGN_P ()) - /* MVS 11/22/96: I think at least some of this - stack_align code is really broken. Better to let - PUSH_ARGUMENTS adjust the stack in a target-defined - manner. */ - aligned_len = DEPRECATED_STACK_ALIGN (len); - else - aligned_len = len; - if (INNER_THAN (1, 2)) + aligned_len = len; + if (gdbarch_inner_than (current_gdbarch, 1, 2)) { /* stack grows downward */ sp -= aligned_len; @@ -718,10 +629,10 @@ You must use a pointer to function type variable. Command ignored.", arg_name); sp += aligned_len; } /* Push the structure. */ - write_memory (addr, VALUE_CONTENTS_ALL (args[i]), len); + write_memory (addr, value_contents_all (args[i]), len); /* The value we're going to pass is the address of the thing we just pushed. */ - /*args[i] = value_from_longest (lookup_pointer_type (value_type), + /*args[i] = value_from_longest (lookup_pointer_type (values_type), (LONGEST) addr); */ args[i] = value_from_pointer (lookup_pointer_type (arg_type), addr); @@ -736,12 +647,8 @@ You must use a pointer to function type variable. Command ignored.", arg_name); if (struct_return) { - int len = TYPE_LENGTH (value_type); - if (DEPRECATED_STACK_ALIGN_P ()) - /* NOTE: cagney/2003-03-22: Should rely on frame align, rather - than stack align to force the alignment of the stack. */ - len = DEPRECATED_STACK_ALIGN (len); - if (INNER_THAN (1, 2)) + int len = TYPE_LENGTH (values_type); + if (gdbarch_inner_than (current_gdbarch, 1, 2)) { /* Stack grows downward. Align STRUCT_ADDR and SP after making space for the return value. */ @@ -763,168 +670,51 @@ You must use a pointer to function type variable. Command ignored.", arg_name); } } - /* elz: on HPPA no need for this extra alignment, maybe it is needed - on other architectures. This is because all the alignment is - taken care of in the above code (ifdef DEPRECATED_REG_STRUCT_HAS_ADDR) - and in hppa_push_arguments */ - /* NOTE: cagney/2003-03-24: The below code is very broken. Given an - odd sized parameter the below will mis-align the stack. As was - suggested back in '96, better to let PUSH_ARGUMENTS handle it. */ - if (DEPRECATED_EXTRA_STACK_ALIGNMENT_NEEDED) - { - /* MVS 11/22/96: I think at least some of this stack_align code - is really broken. Better to let push_dummy_call() adjust the - stack in a target-defined manner. */ - if (DEPRECATED_STACK_ALIGN_P () && INNER_THAN (1, 2)) - { - /* If stack grows down, we must leave a hole at the top. */ - int len = 0; - int i; - for (i = nargs - 1; i >= 0; i--) - len += TYPE_LENGTH (VALUE_ENCLOSING_TYPE (args[i])); - if (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ()) - len += DEPRECATED_CALL_DUMMY_STACK_ADJUST; - sp -= DEPRECATED_STACK_ALIGN (len) - len; - } - } - /* 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. */ - if (gdbarch_push_dummy_call_p (current_gdbarch)) - /* When there is no push_dummy_call method, should this code - simply error out. That would the implementation of this method - for all ABIs (which is probably a good thing). */ - sp = gdbarch_push_dummy_call (current_gdbarch, funaddr, current_regcache, - bp_addr, nargs, args, sp, struct_return, - struct_addr); - else if (DEPRECATED_PUSH_ARGUMENTS_P ()) - /* Keep old targets working. */ - sp = DEPRECATED_PUSH_ARGUMENTS (nargs, args, sp, struct_return, - struct_addr); - else - sp = legacy_push_arguments (nargs, args, sp, struct_return, struct_addr); - - if (DEPRECATED_PUSH_RETURN_ADDRESS_P ()) - /* for targets that use no CALL_DUMMY */ - /* There are a number of targets now which actually don't write - any CALL_DUMMY instructions into the target, but instead just - save the machine state, push the arguments, and jump directly - to the callee function. Since this doesn't actually involve - executing a JSR/BSR instruction, the return address must be set - up by hand, either by pushing onto the stack or copying into a - return-address register as appropriate. Formerly this has been - done in PUSH_ARGUMENTS, but that's overloading its - functionality a bit, so I'm making it explicit to do it here. */ - /* NOTE: cagney/2003-04-22: The first parameter ("real_pc") has - been replaced with zero, it turns out that no implementation - used that parameter. This occured because the value being - supplied - the address of the called function's entry point - instead of the address of the breakpoint that the called - function should return to - wasn't useful. */ - sp = DEPRECATED_PUSH_RETURN_ADDRESS (0, sp); - - /* NOTE: cagney/2003-03-23: Diable this code when there is a - push_dummy_call() method. Since that method will have already - handled any alignment issues, the code below is entirely - redundant. */ - if (!gdbarch_push_dummy_call_p (current_gdbarch) - && DEPRECATED_STACK_ALIGN_P () && !INNER_THAN (1, 2)) - { - /* If stack grows up, we must leave a hole at the bottom, note - that sp already has been advanced for the arguments! */ - if (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ()) - sp += DEPRECATED_CALL_DUMMY_STACK_ADJUST; - sp = DEPRECATED_STACK_ALIGN (sp); - } - -/* XXX This seems wrong. For stacks that grow down we shouldn't do - anything here! */ - /* MVS 11/22/96: I think at least some of this stack_align code is - really broken. Better to let PUSH_ARGUMENTS adjust the stack in - a target-defined manner. */ - if (DEPRECATED_CALL_DUMMY_STACK_ADJUST_P ()) - if (INNER_THAN (1, 2)) - { - /* stack grows downward */ - sp -= DEPRECATED_CALL_DUMMY_STACK_ADJUST; - } + sp = gdbarch_push_dummy_call (current_gdbarch, function, + get_current_regcache (), bp_addr, nargs, args, + sp, struct_return, struct_addr); + + /* Set up a frame ID for the dummy frame so we can pass it to + set_momentary_breakpoint. We need to give the breakpoint a frame + ID so that the breakpoint code can correctly re-identify the + dummy breakpoint. */ + /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL, + saved as the dummy-frame TOS, and used by unwind_dummy_id to form + the frame ID's stack address. */ + dummy_id = frame_id_build (sp, bp_addr); - /* Store the address at which the structure is supposed to be - written. */ - /* NOTE: 2003-03-24: Since PUSH_ARGUMENTS can (and typically does) - store the struct return address, this call is entirely redundant. */ - if (struct_return && DEPRECATED_STORE_STRUCT_RETURN_P ()) - DEPRECATED_STORE_STRUCT_RETURN (struct_addr, sp); - - /* Write the stack pointer. This is here because the statements - above might fool with it. On SPARC, this write also stores the - register window into the right place in the new stack frame, - which otherwise wouldn't happen (see store_inferior_registers in - sparc-nat.c). */ - /* NOTE: cagney/2003-03-23: Since the architecture method - push_dummy_call() should have already stored the stack pointer - (as part of creating the fake call frame), and none of the code - following that call adjusts the stack-pointer value, the below - call is entirely redundant. */ - if (DEPRECATED_DUMMY_WRITE_SP_P ()) - DEPRECATED_DUMMY_WRITE_SP (sp); - - if (gdbarch_unwind_dummy_id_p (current_gdbarch)) - { - /* Sanity. The exact same SP value is returned by - PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by - unwind_dummy_id to form the frame ID's stack address. */ - gdb_assert (DEPRECATED_USE_GENERIC_DUMMY_FRAMES); - generic_save_dummy_frame_tos (sp); - } - else if (DEPRECATED_SAVE_DUMMY_FRAME_TOS_P ()) - DEPRECATED_SAVE_DUMMY_FRAME_TOS (sp); - - /* Now proceed, having reached the desired place. */ - clear_proceed_status (); - /* Create a momentary breakpoint at the return address of the inferior. That way it breaks when it returns. */ { struct breakpoint *bpt; struct symtab_and_line sal; - struct frame_id frame; init_sal (&sal); /* initialize to zeroes */ sal.pc = bp_addr; sal.section = find_pc_overlay (sal.pc); - /* Set up a frame ID for the dummy frame so we can pass it to - set_momentary_breakpoint. We need to give the breakpoint a - frame ID so that the breakpoint code can correctly re-identify - the dummy breakpoint. */ - if (gdbarch_unwind_dummy_id_p (current_gdbarch)) - { - /* Sanity. The exact same SP value is returned by - PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by - unwind_dummy_id to form the frame ID's stack address. */ - gdb_assert (DEPRECATED_USE_GENERIC_DUMMY_FRAMES); - frame = frame_id_build (sp, sal.pc); - } - else - { - /* The assumption here is that push_dummy_call() returned the - stack part of the frame ID. Unfortunately, many older - architectures were, via a convoluted mess, relying on the - poorly defined and greatly overloaded - DEPRECATED_TARGET_READ_FP or DEPRECATED_FP_REGNUM to supply - the value. */ - if (DEPRECATED_TARGET_READ_FP_P ()) - frame = frame_id_build (DEPRECATED_TARGET_READ_FP (), sal.pc); - else if (DEPRECATED_FP_REGNUM >= 0) - frame = frame_id_build (read_register (DEPRECATED_FP_REGNUM), sal.pc); - else - frame = frame_id_build (sp, sal.pc); - } - bpt = set_momentary_breakpoint (sal, frame, bp_call_dummy); + /* Sanity. The exact same SP value is returned by + PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by + unwind_dummy_id to form the frame ID's stack address. */ + bpt = set_momentary_breakpoint (sal, dummy_id, bp_call_dummy); bpt->disposition = disp_del; } + /* Everything's ready, push all the info needed to restore the + caller (and identify the dummy-frame) onto the dummy-frame + stack. */ + dummy_frame_push (caller_regcache, &dummy_id); + discard_cleanups (caller_regcache_cleanup); + + /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - + If you're looking to implement asynchronous dummy-frames, then + just below is the place to chop this function in two.. */ + + /* Now proceed, having reached the desired place. */ + clear_proceed_status (); + /* Execute a "stack dummy", a piece of code stored in the stack by the debugger to be executed in the inferior. @@ -984,7 +774,7 @@ You must use a pointer to function type variable. Command ignored.", arg_name); { /* Can't use a cleanup here. It is discarded, instead use an alloca. */ - char *tmp = xstrprintf ("at %s", local_hex_string (funaddr)); + char *tmp = xstrprintf ("at %s", hex_string (funaddr)); char *a = alloca (strlen (tmp) + 1); strcpy (a, tmp); xfree (tmp); @@ -1007,11 +797,11 @@ You must use a pointer to function type variable. Command ignored.", arg_name); /* FIXME: Insert a bunch of wrap_here; name can be very long if it's a C++ name with arguments and stuff. */ - error ("\ + error (_("\ The program being debugged was signaled while in a function called from GDB.\n\ GDB has restored the context to what it was before the call.\n\ To change this behavior use \"set unwindonsignal off\"\n\ -Evaluation of the expression containing the function (%s) will be abandoned.", +Evaluation of the expression containing the function (%s) will be abandoned."), name); } else @@ -1027,11 +817,11 @@ Evaluation of the expression containing the function (%s) will be abandoned.", discard_inferior_status (inf_status); /* FIXME: Insert a bunch of wrap_here; name can be very long if it's a C++ name with arguments and stuff. */ - error ("\ + error (_("\ The program being debugged was signaled while in a function called from GDB.\n\ GDB remains in the frame where the signal was received.\n\ To change this behavior use \"set unwindonsignal on\"\n\ -Evaluation of the expression containing the function (%s) will be abandoned.", +Evaluation of the expression containing the function (%s) will be abandoned."), name); } } @@ -1054,15 +844,15 @@ Evaluation of the expression containing the function (%s) will be abandoned.", someday this will be implemented (it would not be easy). */ /* FIXME: Insert a bunch of wrap_here; name can be very long if it's a C++ name with arguments and stuff. */ - error ("\ + error (_("\ The program being debugged stopped while in a function called from GDB.\n\ When the function (%s) is done executing, GDB will silently\n\ stop (instead of continuing to evaluate the expression containing\n\ -the function call).", name); +the function call)."), name); } /* The above code errors out, so ... */ - internal_error (__FILE__, __LINE__, "... should not be here"); + internal_error (__FILE__, __LINE__, _("... should not be here")); } /* If we get here the called FUNCTION run to completion. */ @@ -1075,82 +865,72 @@ the function call).", name); do_cleanups (inf_status_cleanup); /* Figure out the value returned by the function. */ - /* elz: I defined this new macro for the hppa architecture only. - this gives us a way to get the value returned by the function - from the stack, at the same address we told the function to put - it. We cannot assume on the pa that r28 still contains the - address of the returned structure. Usually this will be - overwritten by the callee. I don't know about other - architectures, so I defined this macro */ - /* FIXME: cagney/2003-09-27: This is no longer needed. The problem - is now handled directly be by the code below. */ -#ifdef DEPRECATED_VALUE_RETURNED_FROM_STACK - if (struct_return) - { - do_cleanups (retbuf_cleanup); - return DEPRECATED_VALUE_RETURNED_FROM_STACK (value_type, struct_addr); - } -#endif - if (struct_return) - { - /* NOTE: cagney/2003-09-27: This assumes that PUSH_DUMMY_CALL - has correctly stored STRUCT_ADDR in the target. In the past - that hasn't been the case, the old MIPS PUSH_ARGUMENTS - (PUSH_DUMMY_CALL precursor) would silently move the location - of the struct return value making STRUCT_ADDR bogus. If - you're seeing problems with values being returned using the - "struct return convention", check that PUSH_DUMMY_CALL isn't - playing tricks. */ - struct value *retval = value_at (value_type, struct_addr, NULL); - do_cleanups (retbuf_cleanup); - return retval; - } - else - { - /* The non-register case was handled above. */ - struct value *retval = register_value_being_returned (value_type, - retbuf); - do_cleanups (retbuf_cleanup); - return retval; - } + { + struct value *retval = NULL; + + if (TYPE_CODE (values_type) == TYPE_CODE_VOID) + { + /* If the function returns void, don't bother fetching the + return value. */ + retval = allocate_value (values_type); + } + else + { + struct gdbarch *arch = current_gdbarch; + + switch (gdbarch_return_value (arch, 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, + value_contents_raw (retval), NULL); + break; + case RETURN_VALUE_STRUCT_CONVENTION: + retval = value_at (values_type, struct_addr); + break; + } + } + + do_cleanups (retbuf_cleanup); + + gdb_assert(retval); + return retval; + } } + +/* Provide a prototype to silence -Wmissing-prototypes. */ void _initialize_infcall (void); void _initialize_infcall (void) { add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure, - &coerce_float_to_double_p, "\ -Set coercion of floats to doubles when calling functions\n\ -Variables of type float should generally be converted to doubles before\n\ -calling an unprototyped function, and left alone when calling a prototyped\n\ -function. However, some older debug info formats do not provide enough\n\ -information to determine that a function is prototyped. If this flag is\n\ -set, GDB will perform the conversion for a function it considers\n\ -unprototyped.\n\ -The default is to perform the conversion.\n", "\ -Show coercion of floats to doubles when calling functions\n\ + &coerce_float_to_double_p, _("\ +Set coercion of floats to doubles when calling functions."), _("\ +Show coercion of floats to doubles when calling functions"), _("\ Variables of type float should generally be converted to doubles before\n\ calling an unprototyped function, and left alone when calling a prototyped\n\ function. However, some older debug info formats do not provide enough\n\ information to determine that a function is prototyped. If this flag is\n\ set, GDB will perform the conversion for a function it considers\n\ unprototyped.\n\ -The default is to perform the conversion.\n", - NULL, NULL, &setlist, &showlist); +The default is to perform the conversion.\n"), + NULL, + show_coerce_float_to_double_p, + &setlist, &showlist); add_setshow_boolean_cmd ("unwindonsignal", no_class, - &unwind_on_signal_p, "\ -Set unwinding of stack if a signal is received while in a call dummy.\n\ -The unwindonsignal lets the user determine what gdb should do if a signal\n\ -is received while in a function called from gdb (call dummy). If set, gdb\n\ -unwinds the stack and restore the context to what as it was before the call.\n\ -The default is to stop in the frame where the signal was received.", "\ -Set unwinding of stack if a signal is received while in a call dummy.\n\ + &unwind_on_signal_p, _("\ +Set unwinding of stack if a signal is received while in a call dummy."), _("\ +Show unwinding of stack if a signal is received while in a call dummy."), _("\ The unwindonsignal lets the user determine what gdb should do if a signal\n\ is received while in a function called from gdb (call dummy). If set, gdb\n\ unwinds the stack and restore the context to what as it was before the call.\n\ -The default is to stop in the frame where the signal was received.", - NULL, NULL, &setlist, &showlist); +The default is to stop in the frame where the signal was received."), + NULL, + show_unwind_on_signal_p, + &setlist, &showlist); }