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, 2009 Free Software Foundation, Inc.
+ 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
This file is part of GDB.
#include "defs.h"
#include "breakpoint.h"
+#include "tracepoint.h"
#include "target.h"
#include "regcache.h"
#include "inferior.h"
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);
}
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.
/* 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
find_function_addr (struct value *function, struct type **retval_type)
{
struct type *ftype = check_typedef (value_type (function));
+ struct gdbarch *gdbarch = get_type_arch (ftype);
enum type_code code = TYPE_CODE (ftype);
struct type *value_type = NULL;
CORE_ADDR funaddr;
/* Determine address to call. */
if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)
{
- funaddr = VALUE_ADDRESS (function);
+ 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 = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
- funaddr,
+ funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr,
¤t_target);
value_type = TYPE_TARGET_TYPE (ftype);
}
{
/* 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;
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);
}
/* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called
{
{
struct symbol *symbol = find_pc_function (funaddr);
+
if (symbol)
return SYMBOL_PRINT_NAME (symbol);
}
{
/* Try the minimal symbols. */
struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr);
+
if (msymbol)
return SYMBOL_PRINT_NAME (msymbol);
}
{
char *tmp = xstrprintf (_(RAW_FUNCTION_ADDRESS_FORMAT),
hex_string (funaddr));
+
gdb_assert (strlen (tmp) + 1 <= buf_size);
strcpy (buf, tmp);
xfree (tmp);
{
volatile struct gdb_exception e;
int saved_async = 0;
- int saved_in_infcall = call_thread->in_infcall;
+ int saved_in_infcall = call_thread->control.in_infcall;
ptid_t call_thread_ptid = call_thread->ptid;
char *saved_target_shortname = xstrdup (target_shortname);
- call_thread->in_infcall = 1;
+ call_thread->control.in_infcall = 1;
clear_proceed_status ();
disable_watchpoints_before_interactive_call_start ();
- call_thread->proceed_to_finish = 1; /* We want stop_registers, please... */
+
+ /* We want stop_registers, please... */
+ call_thread->control.proceed_to_finish = 1;
if (target_can_async_p ())
saved_async = target_async_mask (0);
if (e.reason < 0)
{
if (call_thread != NULL)
- breakpoint_auto_delete (call_thread->stop_bpstat);
+ breakpoint_auto_delete (call_thread->control.stop_bpstat);
}
if (call_thread != NULL)
- call_thread->in_infcall = saved_in_infcall;
+ call_thread->control.in_infcall = saved_in_infcall;
xfree (saved_target_shortname);
return e;
}
+/* A cleanup function that calls delete_std_terminate_breakpoint. */
+static void
+cleanup_delete_std_terminate_breakpoint (void *ignore)
+{
+ delete_std_terminate_breakpoint ();
+}
+
/* 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
struct type *values_type, *target_values_type;
unsigned char struct_return = 0, lang_struct_return = 0;
CORE_ADDR struct_addr = 0;
- struct inferior_status *inf_status;
+ struct infcall_control_state *inf_status;
struct cleanup *inf_status_cleanup;
- struct inferior_thread_state *caller_state;
- struct cleanup *caller_state_cleanup;
+ struct infcall_suspend_state *caller_state;
CORE_ADDR funaddr;
CORE_ADDR real_pc;
struct type *ftype = check_typedef (value_type (function));
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;
- const char *name;
char name_buf[RAW_FUNCTION_ADDRESS_SIZE];
if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
if (!target_has_execution)
noprocess ();
+ if (get_traceframe_number () >= 0)
+ error (_("May not call functions while looking at trace frames."));
+
frame = get_current_frame ();
gdbarch = get_frame_arch (frame);
/* A cleanup for the inferior status.
This is only needed while we're preparing the inferior function call. */
- inf_status = save_inferior_status ();
- inf_status_cleanup = make_cleanup_restore_inferior_status (inf_status);
+ inf_status = save_infcall_control_state ();
+ inf_status_cleanup
+ = make_cleanup_restore_infcall_control_state (inf_status);
/* 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_state = save_inferior_thread_state ();
- caller_state_cleanup = make_cleanup_restore_inferior_thread_state (caller_state);
+ 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);
/* 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!
/* 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,
+ value_type (function), values_type);
target_values_type = values_type;
}
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;
sym = lookup_minimal_symbol ("__CALL_DUMMY_ADDRESS", NULL, NULL);
real_pc = funaddr;
if (sym)
- dummy_addr = SYMBOL_VALUE_ADDRESS (sym);
+ {
+ dummy_addr = SYMBOL_VALUE_ADDRESS (sym);
+ /* 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);
+ }
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. */
bp_addr = dummy_addr;
{
int i;
+
for (i = nargs - 1; i >= 0; i--)
{
int prototyped;
if (struct_return || lang_struct_return)
{
int len = TYPE_LENGTH (values_type);
+
if (gdbarch_inner_than (gdbarch, 1, 2))
{
/* Stack grows downward. Align STRUCT_ADDR and SP after
{
struct breakpoint *bpt;
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);
bpt->disposition = disp_del;
}
+ /* 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 ();
+
/* Everything's ready, push all the info needed to restore the
caller (and identify the dummy-frame) onto the dummy-frame
stack. */
or discard it. */
discard_cleanups (inf_status_cleanup);
+ /* 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.. */
const char *name = get_function_name (funaddr,
name_buf, sizeof (name_buf));
- discard_inferior_status (inf_status);
+ 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
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."),
+ throw_error (e.error,
+ _("%s\nAn error occurred while in a "
+ "function called from GDB.\n Evaluation "
+ "of the expression containing the function\n "
+ "(%s) will be abandoned.\nWhen the function "
+ "is done executing, GDB will silently stop."),
e.message, name);
case RETURN_QUIT:
default:
/* If we try to restore the inferior status,
we'll crash as the inferior is no longer running. */
- discard_inferior_status (inf_status);
+ 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."),
+ 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);
}
signal or breakpoint while our thread was running.
There's no point in restoring the inferior status,
we're in a different thread. */
- discard_inferior_status (inf_status);
+ 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."),
+ error (_("The program received a signal in another thread while\n"
+ "making a function call from GDB.\nEvaluation "
+ "of the expression containing the function\n"
+ "(%s) will be abandoned.\nWhen 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."),
+ error (_("The program stopped in another thread while making "
+ "a function call from GDB.\nEvaluation "
+ "of the expression containing the function\n"
+ "(%s) will be abandoned.\nWhen the function "
+ "is done executing, GDB will silently stop."),
name);
}
- if (stopped_by_random_signal || !stop_stack_dummy)
+ if (stopped_by_random_signal || stop_stack_dummy != STOP_STACK_DUMMY)
{
const char *name = get_function_name (funaddr,
name_buf, sizeof (name_buf));
/* We also need to restore inferior status to that before the
dummy call. */
- restore_inferior_status (inf_status);
+ 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. */
- 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\n\
-(%s) will be abandoned."),
+ error (_("The program being debugged was signaled while "
+ "in a function called from GDB.\nGDB has restored "
+ "the context to what it was before the call.\n "
+ "To change this behavior use \"set unwindonsignal "
+ "off\".\nEvaluation of the expression containing "
+ "the function\n(%s) will be abandoned."),
name);
}
else
(default).
Discard inferior status, we're not at the same point
we started at. */
- discard_inferior_status (inf_status);
+ 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\n\
-(%s) will be abandoned.\n\
-When the function is done executing, GDB will silently stop."),
+ error (_("The program being debugged was signaled while "
+ "in a function called from GDB.\nGDB remains in "
+ "the frame where the signal was received.\nTo change "
+ "this behavior use \"set unwindonsignal on\".\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 (!stop_stack_dummy)
+ if (stop_stack_dummy == STOP_STD_TERMINATE)
{
+ /* We must get back to the frame we were before the dummy
+ call. */
+ dummy_frame_pop (dummy_id);
+
+ /* 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_inferior_status (inf_status);
+ discard_infcall_control_state (inf_status);
/* The following error message used to say "The expression
which contained the function call has been discarded."
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 (_("\
-The program being debugged stopped 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."),
+ error (_("The program being debugged stopped "
+ "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."),
name);
}
internal_error (__FILE__, __LINE__, _("... should not be here"));
}
+ do_cleanups (terminate_bp_cleanup);
+
/* If we get here the called FUNCTION ran to completion,
and the dummy frame has already been popped. */
{
- struct regcache *retbuf = regcache_xmalloc (gdbarch);
+ struct address_space *aspace = get_regcache_aspace (stop_registers);
+ struct regcache *retbuf = regcache_xmalloc (gdbarch, aspace);
struct cleanup *retbuf_cleanup = make_cleanup_regcache_xfree (retbuf);
struct value *retval = NULL;
/* Inferior call is successful. Restore the inferior status.
At this stage, leave the RETBUF alone. */
- restore_inferior_status (inf_status);
+ restore_infcall_control_state (inf_status);
/* Figure out the value returned by the function. */
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);
+
}
projects / deliverable / binutils-gdb.git / blobdiff