X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Finfcall.c;h=d7515dd5f49b2614454c7ea32d0f95d3ab4a3533;hb=8a6c40311297f60ad13827650fdde13da301b505;hp=d50bcca978ac96e46f0c4125dba2b659056e61eb;hpb=3b676233580b7e047388e8c9ba3ad8b6b8eaeabb;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/infcall.c b/gdb/infcall.c index d50bcca978..d7515dd5f4 100644 --- a/gdb/infcall.c +++ b/gdb/infcall.c @@ -1,8 +1,6 @@ /* Perform an inferior function call, for GDB, the GNU debugger. - Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, - 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, - 2008 Free Software Foundation, Inc. + Copyright (C) 1986-2015 Free Software Foundation, Inc. This file is part of GDB. @@ -21,21 +19,29 @@ #include "defs.h" #include "breakpoint.h" +#include "tracepoint.h" #include "target.h" #include "regcache.h" #include "inferior.h" -#include "gdb_assert.h" +#include "infrun.h" #include "block.h" #include "gdbcore.h" #include "language.h" #include "objfiles.h" #include "gdbcmd.h" #include "command.h" -#include "gdb_string.h" #include "infcall.h" #include "dummy-frame.h" #include "ada-lang.h" #include "gdbthread.h" +#include "event-top.h" +#include "observer.h" + +/* If we can't find a function's name from its address, + we print this instead. */ +#define RAW_FUNCTION_ADDRESS_FORMAT "at 0x%s" +#define RAW_FUNCTION_ADDRESS_SIZE (sizeof (RAW_FUNCTION_ADDRESS_FORMAT) \ + + 2 * sizeof (CORE_ADDR)) /* NOTE: cagney/2003-04-16: What's the future of this code? @@ -69,8 +75,9 @@ 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"), + fprintf_filtered (file, + _("Coercion of floats to doubles " + "when calling functions is %s.\n"), value); } @@ -79,18 +86,44 @@ Coercion of floats to doubles when calling functions is %s.\n"), the stack and restore the context to what as it was before the call. - The default is to stop in the frame where the signal was received. */ + The default is to stop in the frame where the signal was received. */ -int unwind_on_signal_p = 0; +static 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"), + fprintf_filtered (file, + _("Unwinding of stack if a signal is " + "received while in a call dummy is %s.\n"), value); } +/* This boolean tells what gdb should do if a std::terminate call is + made while in a function called from gdb (call dummy). + As the confines of a single dummy stack prohibit out-of-frame + handlers from handling a raised exception, and as out-of-frame + handlers are common in C++, this can lead to no handler being found + by the unwinder, and a std::terminate call. This is a false positive. + If set, gdb unwinds the stack and restores the context to what it + was before the call. + + The default is to unwind the frame if a std::terminate call is + made. */ + +static int unwind_on_terminating_exception_p = 1; + +static void +show_unwind_on_terminating_exception_p (struct ui_file *file, int from_tty, + struct cmd_list_element *c, + const char *value) + +{ + fprintf_filtered (file, + _("Unwind stack if a C++ exception is " + "unhandled while in a call dummy is %s.\n"), + value); +} /* Perform the standard coercions that are specified for arguments to be passed to C or Ada functions. @@ -111,7 +144,7 @@ value_arg_coerce (struct gdbarch *gdbarch, struct value *arg, /* Perform any Ada-specific coercion first. */ if (current_language->la_language == language_ada) - arg = ada_convert_actual (arg, type, sp); + arg = ada_convert_actual (arg, type); /* Force the value to the target if we will need its address. At this point, we could allocate arguments on the stack instead of @@ -126,7 +159,7 @@ value_arg_coerce (struct gdbarch *gdbarch, struct value *arg, struct value *new_value; if (TYPE_CODE (arg_type) == TYPE_CODE_REF) - return value_cast_pointers (type, arg); + return value_cast_pointers (type, arg, 0); /* Cast the value to the reference's target type, and then convert it back to a reference. This will issue an error @@ -180,7 +213,6 @@ value_arg_coerce (struct gdbarch *gdbarch, struct value *arg, case TYPE_CODE_SET: case TYPE_CODE_RANGE: case TYPE_CODE_STRING: - case TYPE_CODE_BITSTRING: case TYPE_CODE_ERROR: case TYPE_CODE_MEMBERPTR: case TYPE_CODE_METHODPTR: @@ -193,6 +225,21 @@ value_arg_coerce (struct gdbarch *gdbarch, struct value *arg, return value_cast (type, arg); } +/* Return the return type of a function with its first instruction exactly at + the PC address. Return NULL otherwise. */ + +static struct type * +find_function_return_type (CORE_ADDR pc) +{ + struct symbol *sym = find_pc_function (pc); + + if (sym != NULL && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) == pc + && SYMBOL_TYPE (sym) != NULL) + return TYPE_TARGET_TYPE (SYMBOL_TYPE (sym)); + + return NULL; +} + /* Determine a function's address and its return type from its value. Calls error() if the function is not valid for calling. */ @@ -200,49 +247,61 @@ CORE_ADDR find_function_addr (struct value *function, struct type **retval_type) { struct type *ftype = check_typedef (value_type (function)); - enum type_code code = TYPE_CODE (ftype); + struct gdbarch *gdbarch = get_type_arch (ftype); struct type *value_type = NULL; - CORE_ADDR funaddr; + /* Initialize it just to avoid a GCC false warning. */ + CORE_ADDR funaddr = 0; /* If it's a member function, just look at the function part of it. */ /* Determine address to call. */ - if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD) - { - funaddr = VALUE_ADDRESS (function); - value_type = TYPE_TARGET_TYPE (ftype); - } - else if (code == TYPE_CODE_PTR) + if (TYPE_CODE (ftype) == TYPE_CODE_FUNC + || TYPE_CODE (ftype) == TYPE_CODE_METHOD) + funaddr = value_address (function); + else if (TYPE_CODE (ftype) == TYPE_CODE_PTR) { funaddr = value_as_address (function); ftype = check_typedef (TYPE_TARGET_TYPE (ftype)); if (TYPE_CODE (ftype) == TYPE_CODE_FUNC || TYPE_CODE (ftype) == TYPE_CODE_METHOD) + funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr, + ¤t_target); + } + if (TYPE_CODE (ftype) == TYPE_CODE_FUNC + || TYPE_CODE (ftype) == TYPE_CODE_METHOD) + { + value_type = TYPE_TARGET_TYPE (ftype); + + if (TYPE_GNU_IFUNC (ftype)) { - funaddr = gdbarch_convert_from_func_ptr_addr (current_gdbarch, - funaddr, - ¤t_target); - value_type = TYPE_TARGET_TYPE (ftype); + funaddr = gnu_ifunc_resolve_addr (gdbarch, funaddr); + + /* Skip querying the function symbol if no RETVAL_TYPE has been + asked for. */ + if (retval_type) + value_type = find_function_return_type (funaddr); } } - else if (code == TYPE_CODE_INT) + else if (TYPE_CODE (ftype) == TYPE_CODE_INT) { /* Handle the case of functions lacking debugging info. - Their values are characters since their addresses are char */ + Their values are characters since their addresses are char. */ if (TYPE_LENGTH (ftype) == 1) funaddr = value_as_address (value_addr (function)); else { /* Handle function descriptors lacking debug info. */ int found_descriptor = 0; + + funaddr = 0; /* pacify "gcc -Werror" */ if (VALUE_LVAL (function) == lval_memory) { CORE_ADDR nfunaddr; + funaddr = value_as_address (value_addr (function)); nfunaddr = funaddr; - funaddr = gdbarch_convert_from_func_ptr_addr (current_gdbarch, - funaddr, + funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr, ¤t_target); if (funaddr != nfunaddr) found_descriptor = 1; @@ -257,17 +316,7 @@ find_function_addr (struct value *function, struct type **retval_type) 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 - of the current thread. */ - -static void -breakpoint_auto_delete_contents (void *arg) -{ - if (!ptid_equal (inferior_ptid, null_ptid)) - breakpoint_auto_delete (inferior_thread ()->stop_bpstat); + return funaddr + gdbarch_deprecated_function_start_offset (gdbarch); } /* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called @@ -288,6 +337,228 @@ push_dummy_code (struct gdbarch *gdbarch, regcache); } +/* Fetch the name of the function at FUNADDR. + This is used in printing an error message for call_function_by_hand. + BUF is used to print FUNADDR in hex if the function name cannot be + determined. It must be large enough to hold formatted result of + RAW_FUNCTION_ADDRESS_FORMAT. */ + +static const char * +get_function_name (CORE_ADDR funaddr, char *buf, int buf_size) +{ + { + struct symbol *symbol = find_pc_function (funaddr); + + if (symbol) + return SYMBOL_PRINT_NAME (symbol); + } + + { + /* Try the minimal symbols. */ + struct bound_minimal_symbol msymbol = lookup_minimal_symbol_by_pc (funaddr); + + if (msymbol.minsym) + return MSYMBOL_PRINT_NAME (msymbol.minsym); + } + + { + char *tmp = xstrprintf (_(RAW_FUNCTION_ADDRESS_FORMAT), + hex_string (funaddr)); + + gdb_assert (strlen (tmp) + 1 <= buf_size); + strcpy (buf, tmp); + xfree (tmp); + return buf; + } +} + +/* Subroutine of call_function_by_hand to simplify it. + Start up the inferior and wait for it to stop. + Return the exception if there's an error, or an exception with + reason >= 0 if there's no error. + + This is done inside a TRY_CATCH so the caller needn't worry about + thrown errors. The caller should rethrow if there's an error. */ + +static struct gdb_exception +run_inferior_call (struct thread_info *call_thread, CORE_ADDR real_pc) +{ + struct gdb_exception caught_error = exception_none; + int saved_in_infcall = call_thread->control.in_infcall; + ptid_t call_thread_ptid = call_thread->ptid; + int saved_sync_execution = sync_execution; + + /* Infcalls run synchronously, in the foreground. */ + if (target_can_async_p ()) + sync_execution = 1; + + call_thread->control.in_infcall = 1; + + clear_proceed_status (0); + + disable_watchpoints_before_interactive_call_start (); + + /* We want stop_registers, please... */ + call_thread->control.proceed_to_finish = 1; + + TRY + { + int was_sync = sync_execution; + + proceed (real_pc, GDB_SIGNAL_0); + + /* Inferior function calls are always synchronous, even if the + target supports asynchronous execution. Do here what + `proceed' itself does in sync mode. */ + if (target_can_async_p ()) + { + wait_for_inferior (); + normal_stop (); + /* If GDB was previously in sync execution mode, then ensure + that it remains so. normal_stop calls + async_enable_stdin, so reset it again here. In other + cases, stdin will be re-enabled by + inferior_event_handler, when an exception is thrown. */ + if (was_sync) + async_disable_stdin (); + } + } + CATCH (e, RETURN_MASK_ALL) + { + caught_error = e; + } + END_CATCH + + /* At this point the current thread may have changed. Refresh + CALL_THREAD as it could be invalid if its thread has exited. */ + call_thread = find_thread_ptid (call_thread_ptid); + + enable_watchpoints_after_interactive_call_stop (); + + /* Call breakpoint_auto_delete on the current contents of the bpstat + of inferior call thread. + If all error()s out of proceed ended up calling normal_stop + (and perhaps they should; it already does in the special case + of error out of resume()), then we wouldn't need this. */ + if (caught_error.reason < 0) + { + if (call_thread != NULL) + breakpoint_auto_delete (call_thread->control.stop_bpstat); + } + + if (call_thread != NULL) + call_thread->control.in_infcall = saved_in_infcall; + + sync_execution = saved_sync_execution; + + return caught_error; +} + +/* A cleanup function that calls delete_std_terminate_breakpoint. */ +static void +cleanup_delete_std_terminate_breakpoint (void *ignore) +{ + delete_std_terminate_breakpoint (); +} + +/* See infcall.h. */ + +struct value * +call_function_by_hand (struct value *function, int nargs, struct value **args) +{ + return call_function_by_hand_dummy (function, nargs, args, NULL, NULL); +} + +/* Data for dummy_frame_context_saver. Structure can be freed only + after both dummy_frame_context_saver_dtor and + dummy_frame_context_saver_drop have been called for it. */ + +struct dummy_frame_context_saver +{ + /* Inferior registers fetched before associated dummy_frame got freed + and before any other destructors of associated dummy_frame got called. + It is initialized to NULL. */ + struct regcache *retbuf; + + /* It is 1 if this dummy_frame_context_saver_drop has been already + called. */ + int drop_done; +}; + +/* Free struct dummy_frame_context_saver. */ + +static void +dummy_frame_context_saver_free (struct dummy_frame_context_saver *saver) +{ + regcache_xfree (saver->retbuf); + xfree (saver); +} + +/* Destructor for associated dummy_frame. */ + +static void +dummy_frame_context_saver_dtor (void *data_voidp, int registers_valid) +{ + struct dummy_frame_context_saver *data = data_voidp; + + gdb_assert (data->retbuf == NULL); + + if (data->drop_done) + dummy_frame_context_saver_free (data); + else if (registers_valid) + data->retbuf = regcache_dup (get_current_regcache ()); +} + +/* Caller is no longer interested in this + struct dummy_frame_context_saver. After its associated dummy_frame + gets freed struct dummy_frame_context_saver can be also freed. */ + +void +dummy_frame_context_saver_drop (struct dummy_frame_context_saver *saver) +{ + saver->drop_done = 1; + + if (!find_dummy_frame_dtor (dummy_frame_context_saver_dtor, saver)) + dummy_frame_context_saver_free (saver); +} + +/* Stub dummy_frame_context_saver_drop compatible with make_cleanup. */ + +void +dummy_frame_context_saver_cleanup (void *data) +{ + struct dummy_frame_context_saver *saver = data; + + dummy_frame_context_saver_drop (saver); +} + +/* Fetch RETBUF field of possibly opaque DTOR_DATA. + RETBUF must not be NULL. */ + +struct regcache * +dummy_frame_context_saver_get_regs (struct dummy_frame_context_saver *saver) +{ + gdb_assert (saver->retbuf != NULL); + return saver->retbuf; +} + +/* Register provider of inferior registers at the time DUMMY_ID frame of + PTID gets freed (before inferior registers get restored to those + before dummy_frame). */ + +struct dummy_frame_context_saver * +dummy_frame_context_saver_setup (struct frame_id dummy_id, ptid_t ptid) +{ + struct dummy_frame_context_saver *saver; + + saver = xmalloc (sizeof (*saver)); + saver->retbuf = NULL; + saver->drop_done = 0; + register_dummy_frame_dtor (dummy_id, inferior_ptid, + dummy_frame_context_saver_dtor, saver); + return saver; +} + /* All this stuff with a dummy frame may seem unnecessarily complicated (why not just save registers in GDB?). The purpose of pushing a dummy frame which looks just like a real frame is so that if you call a @@ -304,29 +575,36 @@ push_dummy_code (struct gdbarch *gdbarch, May fail to return, if a breakpoint or signal is hit during the execution of the function. - ARGS is modified to contain coerced values. */ + ARGS is modified to contain coerced values. */ struct value * -call_function_by_hand (struct value *function, int nargs, struct value **args) +call_function_by_hand_dummy (struct value *function, + int nargs, struct value **args, + dummy_frame_dtor_ftype *dummy_dtor, + void *dummy_dtor_data) { CORE_ADDR sp; struct type *values_type, *target_values_type; - unsigned char struct_return = 0, lang_struct_return = 0; + unsigned char struct_return = 0, hidden_first_param_p = 0; CORE_ADDR struct_addr = 0; - struct regcache *retbuf; - struct cleanup *retbuf_cleanup; - struct inferior_status *inf_status; + struct infcall_control_state *inf_status; struct cleanup *inf_status_cleanup; + struct infcall_suspend_state *caller_state; CORE_ADDR funaddr; CORE_ADDR real_pc; 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; struct cleanup *args_cleanup; struct frame_info *frame; struct gdbarch *gdbarch; + struct cleanup *terminate_bp_cleanup; + ptid_t call_thread_ptid; + struct gdb_exception e; + char name_buf[RAW_FUNCTION_ADDRESS_SIZE]; + int stack_temporaries = thread_stack_temporaries_enabled_p (inferior_ptid); + struct dummy_frame_context_saver *context_saver; + struct cleanup *context_saver_cleanup; if (TYPE_CODE (ftype) == TYPE_CODE_PTR) ftype = check_typedef (TYPE_TARGET_TYPE (ftype)); @@ -334,35 +612,36 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) if (!target_has_execution) noprocess (); + if (get_traceframe_number () >= 0) + error (_("May not call functions while looking at trace frames.")); + + if (execution_direction == EXEC_REVERSE) + error (_("Cannot call functions in reverse mode.")); + 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 (gdbarch); - retbuf_cleanup = make_cleanup_regcache_xfree (retbuf); + /* A cleanup for the inferior status. + This is only needed while we're preparing the inferior function call. */ + inf_status = save_infcall_control_state (); + inf_status_cleanup + = make_cleanup_restore_infcall_control_state (inf_status); - /* A cleanup for the inferior status. Create this AFTER the retbuf - so that this can be discarded or applied without interfering with - the regbuf. */ - inf_status = save_inferior_status (1); - inf_status_cleanup = make_cleanup_restore_inferior_status (inf_status); - - /* Save the caller's registers so that they can be restored once the + /* Save the caller's registers and other state associated with the + inferior itself 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 (frame); - caller_regcache_cleanup = make_cleanup_regcache_xfree (caller_regcache); + caller_state = save_infcall_suspend_state (); + make_cleanup_restore_infcall_suspend_state (caller_state); /* Ensure that the initial SP is correctly aligned. */ { CORE_ADDR old_sp = get_frame_sp (frame); + if (gdbarch_frame_align_p (gdbarch)) { sp = gdbarch_frame_align (gdbarch, old_sp); @@ -406,10 +685,9 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) /* Stack grows up. */ sp = gdbarch_frame_align (gdbarch, old_sp + 1); } - gdb_assert ((gdbarch_inner_than (gdbarch, 1, 2) - && sp <= old_sp) - || (gdbarch_inner_than (gdbarch, 2, 1) - && sp >= old_sp)); + /* SP may have underflown address zero here from OLD_SP. Memory access + functions will probably fail in such case but that is a target's + problem. */ } else /* FIXME: cagney/2002-09-18: Hey, you loose! @@ -419,12 +697,39 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) If the generic dummy frame ends up empty (because nothing is pushed) GDB won't be able to correctly perform back traces. If a target is having trouble with backtraces, first thing to - do is add FRAME_ALIGN() to the architecture vector. If that + do is add FRAME_ALIGN() to the architecture vector. If that fails, try dummy_id(). If the ABI specifies a "Red Zone" (see the doco) the code below will quietly trash it. */ sp = old_sp; + + /* Skip over the stack temporaries that might have been generated during + the evaluation of an expression. */ + if (stack_temporaries) + { + struct value *lastval; + + lastval = get_last_thread_stack_temporary (inferior_ptid); + if (lastval != NULL) + { + CORE_ADDR lastval_addr = value_address (lastval); + + if (gdbarch_inner_than (gdbarch, 1, 2)) + { + gdb_assert (sp >= lastval_addr); + sp = lastval_addr; + } + else + { + gdb_assert (sp <= lastval_addr); + sp = lastval_addr + TYPE_LENGTH (value_type (lastval)); + } + + if (gdbarch_frame_align_p (gdbarch)) + sp = gdbarch_frame_align (gdbarch, sp); + } + } } funaddr = find_function_addr (function, &values_type); @@ -444,35 +749,60 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) the first argument is passed in out0 but the hidden structure return pointer would normally be passed in r8. */ - if (language_pass_by_reference (values_type)) + if (gdbarch_return_in_first_hidden_param_p (gdbarch, values_type)) { - lang_struct_return = 1; + hidden_first_param_p = 1; /* Tell the target specific argument pushing routine not to expect a value. */ - target_values_type = builtin_type_void; + target_values_type = builtin_type (gdbarch)->builtin_void; } else { - struct_return = using_struct_return (value_type (function), values_type); + struct_return = using_struct_return (gdbarch, function, values_type); target_values_type = values_type; } + observer_notify_inferior_call_pre (inferior_ptid, funaddr); + /* Determine the location of the breakpoint (and possibly other stuff) that the called function will return to. The SPARC, for a function returning a structure or union, needs to make space for not just the breakpoint but also an extra word containing the size (?) of the structure being passed. */ - /* The actual breakpoint (at BP_ADDR) is inserted separatly so there - is no need to write that out. */ - switch (gdbarch_call_dummy_location (gdbarch)) { case ON_STACK: - sp = push_dummy_code (gdbarch, sp, funaddr, - args, nargs, target_values_type, - &real_pc, &bp_addr, get_current_regcache ()); + { + const gdb_byte *bp_bytes; + CORE_ADDR bp_addr_as_address; + int bp_size; + + /* Be careful BP_ADDR is in inferior PC encoding while + BP_ADDR_AS_ADDRESS is a plain memory address. */ + + sp = push_dummy_code (gdbarch, sp, funaddr, args, nargs, + target_values_type, &real_pc, &bp_addr, + get_current_regcache ()); + + /* Write a legitimate instruction at the point where the infcall + breakpoint is going to be inserted. While this instruction + is never going to be executed, a user investigating the + memory from GDB would see this instruction instead of random + uninitialized bytes. We chose the breakpoint instruction + as it may look as the most logical one to the user and also + valgrind 3.7.0 needs it for proper vgdb inferior calls. + + If software breakpoints are unsupported for this target we + leave the user visible memory content uninitialized. */ + + bp_addr_as_address = bp_addr; + bp_bytes = gdbarch_breakpoint_from_pc (gdbarch, &bp_addr_as_address, + &bp_size); + if (bp_bytes != NULL) + write_memory (bp_addr_as_address, bp_bytes, bp_size); + } break; case AT_ENTRY_POINT: { @@ -480,38 +810,12 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) real_pc = funaddr; 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 (gdbarch, - dummy_addr, - ¤t_target); + /* A call dummy always consists of just a single breakpoint, so - its address is the same as the address of the dummy. */ - bp_addr = dummy_addr; - break; - } - case AT_SYMBOL: - /* Some executables define a symbol __CALL_DUMMY_ADDRESS whose - address is the location where the breakpoint should be - placed. Once all targets are using the overhauled frame code - this can be deleted - ON_STACK is a better option. */ - { - struct minimal_symbol *sym; - CORE_ADDR dummy_addr; + its address is the same as the address of the dummy. - sym = lookup_minimal_symbol ("__CALL_DUMMY_ADDRESS", NULL, NULL); - real_pc = funaddr; - if (sym) - dummy_addr = SYMBOL_VALUE_ADDRESS (sym); - else - 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 (gdbarch, - dummy_addr, - ¤t_target); - /* A call dummy always consists of just a single breakpoint, - so it's address is the same as the address of the dummy. */ + The actual breakpoint is inserted separatly so there is no need to + write that out. */ bp_addr = dummy_addr; break; } @@ -524,6 +828,7 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) { int i; + for (i = nargs - 1; i >= 0; i--) { int prototyped; @@ -553,16 +858,27 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) /* Reserve space for the return structure to be written on the stack, if necessary. Make certain that the value is correctly - aligned. */ + aligned. + + While evaluating expressions, we reserve space on the stack for + return values of class type even if the language ABI and the target + ABI do not require that the return value be passed as a hidden first + argument. This is because we want to store the return value as an + on-stack temporary while the expression is being evaluated. This + enables us to have chained function calls in expressions. - if (struct_return || lang_struct_return) + Keeping the return values as on-stack temporaries while the expression + is being evaluated is OK because the thread is stopped until the + expression is completely evaluated. */ + + if (struct_return || hidden_first_param_p + || (stack_temporaries && class_or_union_p (values_type))) { - int len = TYPE_LENGTH (values_type); if (gdbarch_inner_than (gdbarch, 1, 2)) { /* Stack grows downward. Align STRUCT_ADDR and SP after making space for the return value. */ - sp -= len; + sp -= TYPE_LENGTH (values_type); if (gdbarch_frame_align_p (gdbarch)) sp = gdbarch_frame_align (gdbarch, sp); struct_addr = sp; @@ -570,17 +886,17 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) else { /* Stack grows upward. Align the frame, allocate space, and - then again, re-align the frame??? */ + then again, re-align the frame??? */ if (gdbarch_frame_align_p (gdbarch)) sp = gdbarch_frame_align (gdbarch, sp); struct_addr = sp; - sp += len; + sp += TYPE_LENGTH (values_type); if (gdbarch_frame_align_p (gdbarch)) sp = gdbarch_frame_align (gdbarch, sp); } } - if (lang_struct_return) + if (hidden_first_param_p) { struct value **new_args; @@ -618,127 +934,196 @@ call_function_by_hand (struct value *function, int nargs, struct value **args) inferior. That way it breaks when it returns. */ { - struct breakpoint *bpt; + struct breakpoint *bpt, *longjmp_b; struct symtab_and_line sal; + init_sal (&sal); /* initialize to zeroes */ + sal.pspace = current_program_space; sal.pc = bp_addr; sal.section = find_pc_overlay (sal.pc); /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by dummy_id to form the frame ID's stack address. */ - bpt = set_momentary_breakpoint (sal, dummy_id, bp_call_dummy); + bpt = set_momentary_breakpoint (gdbarch, sal, dummy_id, bp_call_dummy); + + /* set_momentary_breakpoint invalidates FRAME. */ + frame = NULL; + bpt->disposition = disp_del; + gdb_assert (bpt->related_breakpoint == bpt); + + longjmp_b = set_longjmp_breakpoint_for_call_dummy (); + if (longjmp_b) + { + /* Link BPT into the chain of LONGJMP_B. */ + bpt->related_breakpoint = longjmp_b; + while (longjmp_b->related_breakpoint != bpt->related_breakpoint) + longjmp_b = longjmp_b->related_breakpoint; + longjmp_b->related_breakpoint = bpt; + } } + /* Create a breakpoint in std::terminate. + If a C++ exception is raised in the dummy-frame, and the + exception handler is (normally, and expected to be) out-of-frame, + the default C++ handler will (wrongly) be called in an inferior + function call. This is wrong, as an exception can be normally + and legally handled out-of-frame. The confines of the dummy frame + prevent the unwinder from finding the correct handler (or any + handler, unless it is in-frame). The default handler calls + std::terminate. This will kill the inferior. Assert that + terminate should never be called in an inferior function + call. Place a momentary breakpoint in the std::terminate function + and if triggered in the call, rewind. */ + if (unwind_on_terminating_exception_p) + set_std_terminate_breakpoint (); + + /* Discard both inf_status and caller_state cleanups. + From this point on we explicitly restore the associated state + or discard it. */ + discard_cleanups (inf_status_cleanup); + /* 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); + dummy_frame_push (caller_state, &dummy_id, inferior_ptid); + if (dummy_dtor != NULL) + register_dummy_frame_dtor (dummy_id, inferior_ptid, + dummy_dtor, dummy_dtor_data); + + /* dummy_frame_context_saver_setup must be called last so that its + saving of inferior registers gets called first (before possible + DUMMY_DTOR destructor). */ + context_saver = dummy_frame_context_saver_setup (dummy_id, inferior_ptid); + context_saver_cleanup = make_cleanup (dummy_frame_context_saver_cleanup, + context_saver); + + /* Register a clean-up for unwind_on_terminating_exception_breakpoint. */ + terminate_bp_cleanup = make_cleanup (cleanup_delete_std_terminate_breakpoint, + NULL); /* - 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. - - The dummy's frame is automatically popped whenever that break is - hit. If that is the first time the program stops, - call_function_by_hand returns to its caller with that frame - already gone and sets RC to 0. - - Otherwise, set RC to a non-zero value. If the called function - receives a random signal, we do not allow the user to continue - executing it as this may not work. The dummy frame is poped and - we return 1. If we hit a breakpoint, we leave the frame in place - and return 2 (the frame will eventually be popped when we do hit - the dummy end breakpoint). */ - + /* TP is invalid after run_inferior_call returns, so enclose this + in a block so that it's only in scope during the time it's valid. */ { - struct cleanup *old_cleanups = make_cleanup (null_cleanup, 0); - struct cleanup *old_cleanups2; - int saved_async = 0; struct thread_info *tp = inferior_thread (); - /* If all error()s out of proceed ended up calling normal_stop - (and perhaps they should; it already does in the special case - of error out of resume()), then we wouldn't need this. */ - make_cleanup (breakpoint_auto_delete_contents, NULL); - - disable_watchpoints_before_interactive_call_start (); - tp->proceed_to_finish = 1; /* We want stop_registers, please... */ - - if (target_can_async_p ()) - saved_async = target_async_mask (0); - - old_cleanups2 = make_cleanup_restore_integer (&suppress_resume_observer); - suppress_resume_observer = 1; - make_cleanup_restore_integer (&suppress_stop_observer); - suppress_stop_observer = 1; - proceed (real_pc, TARGET_SIGNAL_0, 0); - do_cleanups (old_cleanups2); - - if (saved_async) - target_async_mask (saved_async); - - enable_watchpoints_after_interactive_call_stop (); - - discard_cleanups (old_cleanups); + /* Save this thread's ptid, we need it later but the thread + may have exited. */ + call_thread_ptid = tp->ptid; + + /* Run the inferior until it stops. */ + + e = run_inferior_call (tp, real_pc); } + observer_notify_inferior_call_post (call_thread_ptid, funaddr); + + /* Rethrow an error if we got one trying to run the inferior. */ + + if (e.reason < 0) + { + const char *name = get_function_name (funaddr, + name_buf, sizeof (name_buf)); + + discard_infcall_control_state (inf_status); + + /* We could discard the dummy frame here if the program exited, + but it will get garbage collected the next time the program is + run anyway. */ + + switch (e.reason) + { + case RETURN_ERROR: + throw_error (e.error, _("%s\n\ +An error occurred while in a function called from GDB.\n\ +Evaluation of the expression containing the function\n\ +(%s) will be abandoned.\n\ +When the function is done executing, GDB will silently stop."), + e.message, name); + case RETURN_QUIT: + default: + throw_exception (e); + } + } + + /* If the program has exited, or we stopped at a different thread, + exit and inform the user. */ + if (! target_has_execution) { - /* If we try to restore the inferior status (via the cleanup), + const char *name = get_function_name (funaddr, + name_buf, sizeof (name_buf)); + + /* If we try to restore the inferior status, we'll crash as the inferior is no longer running. */ - discard_cleanups (inf_status_cleanup); - discard_inferior_status (inf_status); - error (_("\ -The program being debugged exited while in a function called from GDB.")); + discard_infcall_control_state (inf_status); + + /* We could discard the dummy frame here given that the program exited, + but it will get garbage collected the next time the program is + run anyway. */ + + error (_("The program being debugged exited while in a function " + "called from GDB.\n" + "Evaluation of the expression containing the function\n" + "(%s) will be abandoned."), + name); } - if (stopped_by_random_signal || !stop_stack_dummy) + if (! ptid_equal (call_thread_ptid, inferior_ptid)) { - /* Find the name of the function we're about to complain about. */ - const char *name = NULL; - { - struct symbol *symbol = find_pc_function (funaddr); - if (symbol) - name = SYMBOL_PRINT_NAME (symbol); - else - { - /* Try the minimal symbols. */ - struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr); - if (msymbol) - name = SYMBOL_PRINT_NAME (msymbol); - } - if (name == NULL) - { - /* Can't use a cleanup here. It is discarded, instead use - an alloca. */ - char *tmp = xstrprintf ("at %s", hex_string (funaddr)); - char *a = alloca (strlen (tmp) + 1); - strcpy (a, tmp); - xfree (tmp); - name = a; - } - } + const char *name = get_function_name (funaddr, + name_buf, sizeof (name_buf)); + + /* We've switched threads. This can happen if another thread gets a + signal or breakpoint while our thread was running. + There's no point in restoring the inferior status, + we're in a different thread. */ + discard_infcall_control_state (inf_status); + /* Keep the dummy frame record, if the user switches back to the + thread with the hand-call, we'll need it. */ + if (stopped_by_random_signal) + error (_("\ +The program received a signal in another thread while\n\ +making a function call from GDB.\n\ +Evaluation of the expression containing the function\n\ +(%s) will be abandoned.\n\ +When the function is done executing, GDB will silently stop."), + name); + else + error (_("\ +The program stopped in another thread while making a function call from GDB.\n\ +Evaluation of the expression containing the function\n\ +(%s) will be abandoned.\n\ +When the function is done executing, GDB will silently stop."), + name); + } + + if (stopped_by_random_signal || stop_stack_dummy != STOP_STACK_DUMMY) + { + const char *name = get_function_name (funaddr, + name_buf, sizeof (name_buf)); + if (stopped_by_random_signal) { /* We stopped inside the FUNCTION because of a random signal. Further execution of the FUNCTION is not - allowed. */ + allowed. */ if (unwind_on_signal_p) { - /* The user wants the context restored. */ + /* The user wants the context restored. */ /* We must get back to the frame we were before the - dummy call. */ - frame_pop (get_current_frame ()); + dummy call. */ + dummy_frame_pop (dummy_id, call_thread_ptid); + + /* We also need to restore inferior status to that before the + dummy call. */ + restore_infcall_control_state (inf_status); /* FIXME: Insert a bunch of wrap_here; name can be very long if it's a C++ name with arguments and stuff. */ @@ -746,41 +1131,60 @@ The program being debugged exited while in a function called from GDB.")); 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\n\ +(%s) will be abandoned."), name); } else { /* The user wants to stay in the frame where we stopped - (default).*/ - /* If we restored the inferior status (via the cleanup), - we would print a spurious error message (Unable to - restore previously selected frame), would write the - registers from the inf_status (which is wrong), and - would do other wrong things. */ - discard_cleanups (inf_status_cleanup); - discard_inferior_status (inf_status); + (default). + Discard inferior status, we're not at the same point + we started at. */ + discard_infcall_control_state (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 (_("\ 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\n\ +(%s) will be abandoned.\n\ +When the function is done executing, GDB will silently stop."), name); } } - if (!stop_stack_dummy) + if (stop_stack_dummy == STOP_STD_TERMINATE) { - /* We hit a breakpoint inside the FUNCTION. */ - /* If we restored the inferior status (via the cleanup), we - would print a spurious error message (Unable to restore - previously selected frame), would write the registers - from the inf_status (which is wrong), and would do other - wrong things. */ - discard_cleanups (inf_status_cleanup); - discard_inferior_status (inf_status); + /* We must get back to the frame we were before the dummy + call. */ + dummy_frame_pop (dummy_id, call_thread_ptid); + + /* We also need to restore inferior status to that before + the dummy call. */ + restore_infcall_control_state (inf_status); + + error (_("\ +The program being debugged entered a std::terminate call, most likely\n\ +caused by an unhandled C++ exception. GDB blocked this call in order\n\ +to prevent the program from being terminated, and has restored the\n\ +context to its original state before the call.\n\ +To change this behaviour use \"set unwind-on-terminating-exception off\".\n\ +Evaluation of the expression containing the function (%s)\n\ +will be abandoned."), + name); + } + else if (stop_stack_dummy == STOP_NONE) + { + + /* We hit a breakpoint inside the FUNCTION. + Keep the dummy frame, the user may want to examine its state. + Discard inferior status, we're not at the same point + we started at. */ + discard_infcall_control_state (inf_status); + /* The following error message used to say "The expression which contained the function call has been discarded." It is a hard concept to explain in a few words. Ideally, @@ -791,57 +1195,69 @@ Evaluation of the expression containing the function (%s) will be abandoned."), a C++ name with arguments and stuff. */ 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); +Evaluation of the expression containing the function\n\ +(%s) will be abandoned.\n\ +When the function is done executing, GDB will silently stop."), + name); } /* The above code errors out, so ... */ internal_error (__FILE__, __LINE__, _("... should not be here")); } - /* If we get here the called FUNCTION run to completion. */ - - /* On normal return, the stack dummy has been popped already. */ - regcache_cpy_no_passthrough (retbuf, stop_registers); + do_cleanups (terminate_bp_cleanup); - /* Restore the inferior status, via its cleanup. At this stage, - leave the RETBUF alone. */ - do_cleanups (inf_status_cleanup); + /* If we get here the called FUNCTION ran to completion, + and the dummy frame has already been popped. */ - /* Figure out the value returned by the function. */ { struct value *retval = NULL; - if (lang_struct_return) - retval = value_at (values_type, struct_addr); - else if (TYPE_CODE (target_values_type) == TYPE_CODE_VOID) + /* Inferior call is successful. Restore the inferior status. + At this stage, leave the RETBUF alone. */ + restore_infcall_control_state (inf_status); + + if (TYPE_CODE (values_type) == TYPE_CODE_VOID) + retval = allocate_value (values_type); + else if (struct_return || hidden_first_param_p) { - /* If the function returns void, don't bother fetching the - return value. */ - retval = allocate_value (values_type); + if (stack_temporaries) + { + retval = value_from_contents_and_address (values_type, NULL, + struct_addr); + push_thread_stack_temporary (inferior_ptid, retval); + } + else + { + retval = allocate_value (values_type); + read_value_memory (retval, 0, 1, struct_addr, + value_contents_raw (retval), + TYPE_LENGTH (values_type)); + } } else { - switch (gdbarch_return_value (gdbarch, value_type (function), - target_values_type, NULL, NULL, NULL)) + retval = allocate_value (values_type); + gdbarch_return_value (gdbarch, function, values_type, + dummy_frame_context_saver_get_regs (context_saver), + value_contents_raw (retval), NULL); + if (stack_temporaries && class_or_union_p (values_type)) { - 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 (gdbarch, value_type (function), values_type, - retbuf, value_contents_raw (retval), NULL); - break; - case RETURN_VALUE_STRUCT_CONVENTION: - retval = value_at (values_type, struct_addr); - break; + /* Values of class type returned in registers are copied onto + the stack and their lval_type set to lval_memory. This is + required because further evaluation of the expression + could potentially invoke methods on the return value + requiring GDB to evaluate the "this" pointer. To evaluate + the this pointer, GDB needs the memory address of the + value. */ + value_force_lval (retval, struct_addr); + push_thread_stack_temporary (inferior_ptid, retval); } } - do_cleanups (retbuf_cleanup); + do_cleanups (context_saver_cleanup); - gdb_assert(retval); + gdb_assert (retval); return retval; } } @@ -879,4 +1295,20 @@ The default is to stop in the frame where the signal was received."), NULL, show_unwind_on_signal_p, &setlist, &showlist); + + add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class, + &unwind_on_terminating_exception_p, _("\ +Set unwinding of stack if std::terminate is called while in call dummy."), _("\ +Show unwinding of stack if std::terminate() is called while in a call dummy."), + _("\ +The unwind on terminating exception flag lets the user determine\n\ +what gdb should do if a std::terminate() call is made from the\n\ +default exception handler. If set, gdb unwinds the stack and restores\n\ +the context to what it was before the call. If unset, gdb allows the\n\ +std::terminate call to proceed.\n\ +The default is to unwind the frame."), + NULL, + show_unwind_on_terminating_exception_p, + &setlist, &showlist); + }