1 /* Perform an inferior function call, for GDB, the GNU debugger.
3 Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5 2008, 2009, 2010 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "breakpoint.h"
24 #include "tracepoint.h"
28 #include "gdb_assert.h"
35 #include "gdb_string.h"
37 #include "dummy-frame.h"
39 #include "gdbthread.h"
40 #include "exceptions.h"
42 /* If we can't find a function's name from its address,
43 we print this instead. */
44 #define RAW_FUNCTION_ADDRESS_FORMAT "at 0x%s"
45 #define RAW_FUNCTION_ADDRESS_SIZE (sizeof (RAW_FUNCTION_ADDRESS_FORMAT) \
46 + 2 * sizeof (CORE_ADDR))
48 /* NOTE: cagney/2003-04-16: What's the future of this code?
50 GDB needs an asynchronous expression evaluator, that means an
51 asynchronous inferior function call implementation, and that in
52 turn means restructuring the code so that it is event driven. */
54 /* How you should pass arguments to a function depends on whether it
55 was defined in K&R style or prototype style. If you define a
56 function using the K&R syntax that takes a `float' argument, then
57 callers must pass that argument as a `double'. If you define the
58 function using the prototype syntax, then you must pass the
59 argument as a `float', with no promotion.
61 Unfortunately, on certain older platforms, the debug info doesn't
62 indicate reliably how each function was defined. A function type's
63 TYPE_FLAG_PROTOTYPED flag may be clear, even if the function was
64 defined in prototype style. When calling a function whose
65 TYPE_FLAG_PROTOTYPED flag is clear, GDB consults this flag to
68 For modern targets, it is proper to assume that, if the prototype
69 flag is clear, that can be trusted: `float' arguments should be
70 promoted to `double'. For some older targets, if the prototype
71 flag is clear, that doesn't tell us anything. The default is to
72 trust the debug information; the user can override this behavior
73 with "set coerce-float-to-double 0". */
75 static int coerce_float_to_double_p = 1;
77 show_coerce_float_to_double_p (struct ui_file *file, int from_tty,
78 struct cmd_list_element *c, const char *value)
80 fprintf_filtered (file, _("\
81 Coercion of floats to doubles when calling functions is %s.\n"),
85 /* This boolean tells what gdb should do if a signal is received while
86 in a function called from gdb (call dummy). If set, gdb unwinds
87 the stack and restore the context to what as it was before the
90 The default is to stop in the frame where the signal was received. */
92 int unwind_on_signal_p = 0;
94 show_unwind_on_signal_p (struct ui_file *file, int from_tty,
95 struct cmd_list_element *c, const char *value)
97 fprintf_filtered (file, _("\
98 Unwinding of stack if a signal is received while in a call dummy is %s.\n"),
102 /* This boolean tells what gdb should do if a std::terminate call is
103 made while in a function called from gdb (call dummy).
104 As the confines of a single dummy stack prohibit out-of-frame
105 handlers from handling a raised exception, and as out-of-frame
106 handlers are common in C++, this can lead to no handler being found
107 by the unwinder, and a std::terminate call. This is a false positive.
108 If set, gdb unwinds the stack and restores the context to what it
111 The default is to unwind the frame if a std::terminate call is
114 static int unwind_on_terminating_exception_p = 1;
117 show_unwind_on_terminating_exception_p (struct ui_file *file, int from_tty,
118 struct cmd_list_element *c,
122 fprintf_filtered (file, _("\
123 Unwind stack if a C++ exception is unhandled while in a call dummy is %s.\n"),
127 /* Perform the standard coercions that are specified
128 for arguments to be passed to C or Ada functions.
130 If PARAM_TYPE is non-NULL, it is the expected parameter type.
131 IS_PROTOTYPED is non-zero if the function declaration is prototyped.
132 SP is the stack pointer were additional data can be pushed (updating
133 its value as needed). */
135 static struct value *
136 value_arg_coerce (struct gdbarch *gdbarch, struct value *arg,
137 struct type *param_type, int is_prototyped, CORE_ADDR *sp)
139 const struct builtin_type *builtin = builtin_type (gdbarch);
140 struct type *arg_type = check_typedef (value_type (arg));
142 = param_type ? check_typedef (param_type) : arg_type;
144 /* Perform any Ada-specific coercion first. */
145 if (current_language->la_language == language_ada)
146 arg = ada_convert_actual (arg, type, gdbarch, sp);
148 /* Force the value to the target if we will need its address. At
149 this point, we could allocate arguments on the stack instead of
150 calling malloc if we knew that their addresses would not be
151 saved by the called function. */
152 arg = value_coerce_to_target (arg);
154 switch (TYPE_CODE (type))
158 struct value *new_value;
160 if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
161 return value_cast_pointers (type, arg);
163 /* Cast the value to the reference's target type, and then
164 convert it back to a reference. This will issue an error
165 if the value was not previously in memory - in some cases
166 we should clearly be allowing this, but how? */
167 new_value = value_cast (TYPE_TARGET_TYPE (type), arg);
168 new_value = value_ref (new_value);
175 /* If we don't have a prototype, coerce to integer type if necessary. */
178 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_int))
179 type = builtin->builtin_int;
181 /* Currently all target ABIs require at least the width of an integer
182 type for an argument. We may have to conditionalize the following
183 type coercion for future targets. */
184 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_int))
185 type = builtin->builtin_int;
188 if (!is_prototyped && coerce_float_to_double_p)
190 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_double))
191 type = builtin->builtin_double;
192 else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin->builtin_double))
193 type = builtin->builtin_long_double;
197 type = lookup_pointer_type (type);
199 case TYPE_CODE_ARRAY:
200 /* Arrays are coerced to pointers to their first element, unless
201 they are vectors, in which case we want to leave them alone,
202 because they are passed by value. */
203 if (current_language->c_style_arrays)
204 if (!TYPE_VECTOR (type))
205 type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
207 case TYPE_CODE_UNDEF:
209 case TYPE_CODE_STRUCT:
210 case TYPE_CODE_UNION:
213 case TYPE_CODE_RANGE:
214 case TYPE_CODE_STRING:
215 case TYPE_CODE_BITSTRING:
216 case TYPE_CODE_ERROR:
217 case TYPE_CODE_MEMBERPTR:
218 case TYPE_CODE_METHODPTR:
219 case TYPE_CODE_METHOD:
220 case TYPE_CODE_COMPLEX:
225 return value_cast (type, arg);
228 /* Determine a function's address and its return type from its value.
229 Calls error() if the function is not valid for calling. */
232 find_function_addr (struct value *function, struct type **retval_type)
234 struct type *ftype = check_typedef (value_type (function));
235 struct gdbarch *gdbarch = get_type_arch (ftype);
236 enum type_code code = TYPE_CODE (ftype);
237 struct type *value_type = NULL;
240 /* If it's a member function, just look at the function
243 /* Determine address to call. */
244 if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)
246 funaddr = value_address (function);
247 value_type = TYPE_TARGET_TYPE (ftype);
249 else if (code == TYPE_CODE_PTR)
251 funaddr = value_as_address (function);
252 ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
253 if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
254 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
256 funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr,
258 value_type = TYPE_TARGET_TYPE (ftype);
261 else if (code == TYPE_CODE_INT)
263 /* Handle the case of functions lacking debugging info.
264 Their values are characters since their addresses are char */
265 if (TYPE_LENGTH (ftype) == 1)
266 funaddr = value_as_address (value_addr (function));
269 /* Handle function descriptors lacking debug info. */
270 int found_descriptor = 0;
271 funaddr = 0; /* pacify "gcc -Werror" */
272 if (VALUE_LVAL (function) == lval_memory)
275 funaddr = value_as_address (value_addr (function));
277 funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr,
279 if (funaddr != nfunaddr)
280 found_descriptor = 1;
282 if (!found_descriptor)
283 /* Handle integer used as address of a function. */
284 funaddr = (CORE_ADDR) value_as_long (function);
288 error (_("Invalid data type for function to be called."));
290 if (retval_type != NULL)
291 *retval_type = value_type;
292 return funaddr + gdbarch_deprecated_function_start_offset (gdbarch);
295 /* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called
296 function returns to. */
299 push_dummy_code (struct gdbarch *gdbarch,
300 CORE_ADDR sp, CORE_ADDR funaddr,
301 struct value **args, int nargs,
302 struct type *value_type,
303 CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
304 struct regcache *regcache)
306 gdb_assert (gdbarch_push_dummy_code_p (gdbarch));
308 return gdbarch_push_dummy_code (gdbarch, sp, funaddr,
309 args, nargs, value_type, real_pc, bp_addr,
313 /* Fetch the name of the function at FUNADDR.
314 This is used in printing an error message for call_function_by_hand.
315 BUF is used to print FUNADDR in hex if the function name cannot be
316 determined. It must be large enough to hold formatted result of
317 RAW_FUNCTION_ADDRESS_FORMAT. */
320 get_function_name (CORE_ADDR funaddr, char *buf, int buf_size)
323 struct symbol *symbol = find_pc_function (funaddr);
325 return SYMBOL_PRINT_NAME (symbol);
329 /* Try the minimal symbols. */
330 struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr);
332 return SYMBOL_PRINT_NAME (msymbol);
336 char *tmp = xstrprintf (_(RAW_FUNCTION_ADDRESS_FORMAT),
337 hex_string (funaddr));
338 gdb_assert (strlen (tmp) + 1 <= buf_size);
345 /* Subroutine of call_function_by_hand to simplify it.
346 Start up the inferior and wait for it to stop.
347 Return the exception if there's an error, or an exception with
348 reason >= 0 if there's no error.
350 This is done inside a TRY_CATCH so the caller needn't worry about
351 thrown errors. The caller should rethrow if there's an error. */
353 static struct gdb_exception
354 run_inferior_call (struct thread_info *call_thread, CORE_ADDR real_pc)
356 volatile struct gdb_exception e;
358 int saved_in_infcall = call_thread->in_infcall;
359 ptid_t call_thread_ptid = call_thread->ptid;
360 char *saved_target_shortname = xstrdup (target_shortname);
362 call_thread->in_infcall = 1;
364 clear_proceed_status ();
366 disable_watchpoints_before_interactive_call_start ();
367 call_thread->proceed_to_finish = 1; /* We want stop_registers, please... */
369 if (target_can_async_p ())
370 saved_async = target_async_mask (0);
372 TRY_CATCH (e, RETURN_MASK_ALL)
373 proceed (real_pc, TARGET_SIGNAL_0, 0);
375 /* At this point the current thread may have changed. Refresh
376 CALL_THREAD as it could be invalid if its thread has exited. */
377 call_thread = find_thread_ptid (call_thread_ptid);
379 /* Don't restore the async mask if the target has changed,
380 saved_async is for the original target. */
382 && strcmp (saved_target_shortname, target_shortname) == 0)
383 target_async_mask (saved_async);
385 enable_watchpoints_after_interactive_call_stop ();
387 /* Call breakpoint_auto_delete on the current contents of the bpstat
388 of inferior call thread.
389 If all error()s out of proceed ended up calling normal_stop
390 (and perhaps they should; it already does in the special case
391 of error out of resume()), then we wouldn't need this. */
394 if (call_thread != NULL)
395 breakpoint_auto_delete (call_thread->stop_bpstat);
398 if (call_thread != NULL)
399 call_thread->in_infcall = saved_in_infcall;
401 xfree (saved_target_shortname);
406 /* A cleanup function that calls delete_std_terminate_breakpoint. */
408 cleanup_delete_std_terminate_breakpoint (void *ignore)
410 delete_std_terminate_breakpoint ();
413 /* All this stuff with a dummy frame may seem unnecessarily complicated
414 (why not just save registers in GDB?). The purpose of pushing a dummy
415 frame which looks just like a real frame is so that if you call a
416 function and then hit a breakpoint (get a signal, etc), "backtrace"
417 will look right. Whether the backtrace needs to actually show the
418 stack at the time the inferior function was called is debatable, but
419 it certainly needs to not display garbage. So if you are contemplating
420 making dummy frames be different from normal frames, consider that. */
422 /* Perform a function call in the inferior.
423 ARGS is a vector of values of arguments (NARGS of them).
424 FUNCTION is a value, the function to be called.
425 Returns a value representing what the function returned.
426 May fail to return, if a breakpoint or signal is hit
427 during the execution of the function.
429 ARGS is modified to contain coerced values. */
432 call_function_by_hand (struct value *function, int nargs, struct value **args)
435 struct type *values_type, *target_values_type;
436 unsigned char struct_return = 0, lang_struct_return = 0;
437 CORE_ADDR struct_addr = 0;
438 struct inferior_status *inf_status;
439 struct cleanup *inf_status_cleanup;
440 struct inferior_thread_state *caller_state;
441 struct cleanup *caller_state_cleanup;
444 struct type *ftype = check_typedef (value_type (function));
446 struct frame_id dummy_id;
447 struct cleanup *args_cleanup;
448 struct frame_info *frame;
449 struct gdbarch *gdbarch;
450 struct cleanup *terminate_bp_cleanup;
451 ptid_t call_thread_ptid;
452 struct gdb_exception e;
454 char name_buf[RAW_FUNCTION_ADDRESS_SIZE];
456 if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
457 ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
459 if (!target_has_execution)
462 if (get_traceframe_number () >= 0)
463 error (_("May not call functions while looking at trace frames."));
465 frame = get_current_frame ();
466 gdbarch = get_frame_arch (frame);
468 if (!gdbarch_push_dummy_call_p (gdbarch))
469 error (_("This target does not support function calls."));
471 /* A cleanup for the inferior status.
472 This is only needed while we're preparing the inferior function call. */
473 inf_status = save_inferior_status ();
474 inf_status_cleanup = make_cleanup_restore_inferior_status (inf_status);
476 /* Save the caller's registers and other state associated with the
477 inferior itself so that they can be restored once the
478 callee returns. To allow nested calls the registers are (further
479 down) pushed onto a dummy frame stack. Include a cleanup (which
480 is tossed once the regcache has been pushed). */
481 caller_state = save_inferior_thread_state ();
482 caller_state_cleanup = make_cleanup_restore_inferior_thread_state (caller_state);
484 /* Ensure that the initial SP is correctly aligned. */
486 CORE_ADDR old_sp = get_frame_sp (frame);
487 if (gdbarch_frame_align_p (gdbarch))
489 sp = gdbarch_frame_align (gdbarch, old_sp);
490 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
491 ABIs, a function can use memory beyond the inner most stack
492 address. AMD64 called that region the "red zone". Skip at
493 least the "red zone" size before allocating any space on
495 if (gdbarch_inner_than (gdbarch, 1, 2))
496 sp -= gdbarch_frame_red_zone_size (gdbarch);
498 sp += gdbarch_frame_red_zone_size (gdbarch);
500 gdb_assert (sp == gdbarch_frame_align (gdbarch, sp));
501 /* NOTE: cagney/2002-09-18:
503 On a RISC architecture, a void parameterless generic dummy
504 frame (i.e., no parameters, no result) typically does not
505 need to push anything the stack and hence can leave SP and
506 FP. Similarly, a frameless (possibly leaf) function does
507 not push anything on the stack and, hence, that too can
508 leave FP and SP unchanged. As a consequence, a sequence of
509 void parameterless generic dummy frame calls to frameless
510 functions will create a sequence of effectively identical
511 frames (SP, FP and TOS and PC the same). This, not
512 suprisingly, results in what appears to be a stack in an
513 infinite loop --- when GDB tries to find a generic dummy
514 frame on the internal dummy frame stack, it will always
517 To avoid this problem, the code below always grows the
518 stack. That way, two dummy frames can never be identical.
519 It does burn a few bytes of stack but that is a small price
523 if (gdbarch_inner_than (gdbarch, 1, 2))
524 /* Stack grows down. */
525 sp = gdbarch_frame_align (gdbarch, old_sp - 1);
527 /* Stack grows up. */
528 sp = gdbarch_frame_align (gdbarch, old_sp + 1);
530 /* SP may have underflown address zero here from OLD_SP. Memory access
531 functions will probably fail in such case but that is a target's
535 /* FIXME: cagney/2002-09-18: Hey, you loose!
537 Who knows how badly aligned the SP is!
539 If the generic dummy frame ends up empty (because nothing is
540 pushed) GDB won't be able to correctly perform back traces.
541 If a target is having trouble with backtraces, first thing to
542 do is add FRAME_ALIGN() to the architecture vector. If that
543 fails, try dummy_id().
545 If the ABI specifies a "Red Zone" (see the doco) the code
546 below will quietly trash it. */
550 funaddr = find_function_addr (function, &values_type);
552 values_type = builtin_type (gdbarch)->builtin_int;
554 CHECK_TYPEDEF (values_type);
556 /* Are we returning a value using a structure return (passing a
557 hidden argument pointing to storage) or a normal value return?
558 There are two cases: language-mandated structure return and
559 target ABI structure return. The variable STRUCT_RETURN only
560 describes the latter. The language version is handled by passing
561 the return location as the first parameter to the function,
562 even preceding "this". This is different from the target
563 ABI version, which is target-specific; for instance, on ia64
564 the first argument is passed in out0 but the hidden structure
565 return pointer would normally be passed in r8. */
567 if (language_pass_by_reference (values_type))
569 lang_struct_return = 1;
571 /* Tell the target specific argument pushing routine not to
573 target_values_type = builtin_type (gdbarch)->builtin_void;
577 struct_return = using_struct_return (gdbarch,
578 value_type (function), values_type);
579 target_values_type = values_type;
582 /* Determine the location of the breakpoint (and possibly other
583 stuff) that the called function will return to. The SPARC, for a
584 function returning a structure or union, needs to make space for
585 not just the breakpoint but also an extra word containing the
586 size (?) of the structure being passed. */
588 /* The actual breakpoint (at BP_ADDR) is inserted separatly so there
589 is no need to write that out. */
591 switch (gdbarch_call_dummy_location (gdbarch))
594 sp = push_dummy_code (gdbarch, sp, funaddr,
595 args, nargs, target_values_type,
596 &real_pc, &bp_addr, get_current_regcache ());
600 CORE_ADDR dummy_addr;
603 dummy_addr = entry_point_address ();
604 /* A call dummy always consists of just a single breakpoint, so
605 its address is the same as the address of the dummy. */
606 bp_addr = dummy_addr;
610 /* Some executables define a symbol __CALL_DUMMY_ADDRESS whose
611 address is the location where the breakpoint should be
612 placed. Once all targets are using the overhauled frame code
613 this can be deleted - ON_STACK is a better option. */
615 struct minimal_symbol *sym;
616 CORE_ADDR dummy_addr;
618 sym = lookup_minimal_symbol ("__CALL_DUMMY_ADDRESS", NULL, NULL);
622 dummy_addr = SYMBOL_VALUE_ADDRESS (sym);
623 /* Make certain that the address points at real code, and not
624 a function descriptor. */
625 dummy_addr = gdbarch_convert_from_func_ptr_addr (gdbarch,
630 dummy_addr = entry_point_address ();
631 /* A call dummy always consists of just a single breakpoint,
632 so it's address is the same as the address of the dummy. */
633 bp_addr = dummy_addr;
637 internal_error (__FILE__, __LINE__, _("bad switch"));
640 if (nargs < TYPE_NFIELDS (ftype))
641 error (_("Too few arguments in function call."));
645 for (i = nargs - 1; i >= 0; i--)
648 struct type *param_type;
650 /* FIXME drow/2002-05-31: Should just always mark methods as
651 prototyped. Can we respect TYPE_VARARGS? Probably not. */
652 if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
654 else if (i < TYPE_NFIELDS (ftype))
655 prototyped = TYPE_PROTOTYPED (ftype);
659 if (i < TYPE_NFIELDS (ftype))
660 param_type = TYPE_FIELD_TYPE (ftype, i);
664 args[i] = value_arg_coerce (gdbarch, args[i],
665 param_type, prototyped, &sp);
667 if (param_type != NULL && language_pass_by_reference (param_type))
668 args[i] = value_addr (args[i]);
672 /* Reserve space for the return structure to be written on the
673 stack, if necessary. Make certain that the value is correctly
676 if (struct_return || lang_struct_return)
678 int len = TYPE_LENGTH (values_type);
679 if (gdbarch_inner_than (gdbarch, 1, 2))
681 /* Stack grows downward. Align STRUCT_ADDR and SP after
682 making space for the return value. */
684 if (gdbarch_frame_align_p (gdbarch))
685 sp = gdbarch_frame_align (gdbarch, sp);
690 /* Stack grows upward. Align the frame, allocate space, and
691 then again, re-align the frame??? */
692 if (gdbarch_frame_align_p (gdbarch))
693 sp = gdbarch_frame_align (gdbarch, sp);
696 if (gdbarch_frame_align_p (gdbarch))
697 sp = gdbarch_frame_align (gdbarch, sp);
701 if (lang_struct_return)
703 struct value **new_args;
705 /* Add the new argument to the front of the argument list. */
706 new_args = xmalloc (sizeof (struct value *) * (nargs + 1));
707 new_args[0] = value_from_pointer (lookup_pointer_type (values_type),
709 memcpy (&new_args[1], &args[0], sizeof (struct value *) * nargs);
712 args_cleanup = make_cleanup (xfree, args);
715 args_cleanup = make_cleanup (null_cleanup, NULL);
717 /* Create the dummy stack frame. Pass in the call dummy address as,
718 presumably, the ABI code knows where, in the call dummy, the
719 return address should be pointed. */
720 sp = gdbarch_push_dummy_call (gdbarch, function, get_current_regcache (),
721 bp_addr, nargs, args,
722 sp, struct_return, struct_addr);
724 do_cleanups (args_cleanup);
726 /* Set up a frame ID for the dummy frame so we can pass it to
727 set_momentary_breakpoint. We need to give the breakpoint a frame
728 ID so that the breakpoint code can correctly re-identify the
730 /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL,
731 saved as the dummy-frame TOS, and used by dummy_id to form
732 the frame ID's stack address. */
733 dummy_id = frame_id_build (sp, bp_addr);
735 /* Create a momentary breakpoint at the return address of the
736 inferior. That way it breaks when it returns. */
739 struct breakpoint *bpt;
740 struct symtab_and_line sal;
741 init_sal (&sal); /* initialize to zeroes */
742 sal.pspace = current_program_space;
744 sal.section = find_pc_overlay (sal.pc);
745 /* Sanity. The exact same SP value is returned by
746 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
747 dummy_id to form the frame ID's stack address. */
748 bpt = set_momentary_breakpoint (gdbarch, sal, dummy_id, bp_call_dummy);
749 bpt->disposition = disp_del;
752 /* Create a breakpoint in std::terminate.
753 If a C++ exception is raised in the dummy-frame, and the
754 exception handler is (normally, and expected to be) out-of-frame,
755 the default C++ handler will (wrongly) be called in an inferior
756 function call. This is wrong, as an exception can be normally
757 and legally handled out-of-frame. The confines of the dummy frame
758 prevent the unwinder from finding the correct handler (or any
759 handler, unless it is in-frame). The default handler calls
760 std::terminate. This will kill the inferior. Assert that
761 terminate should never be called in an inferior function
762 call. Place a momentary breakpoint in the std::terminate function
763 and if triggered in the call, rewind. */
764 if (unwind_on_terminating_exception_p)
765 set_std_terminate_breakpoint ();
767 /* Everything's ready, push all the info needed to restore the
768 caller (and identify the dummy-frame) onto the dummy-frame
770 dummy_frame_push (caller_state, &dummy_id);
772 /* Discard both inf_status and caller_state cleanups.
773 From this point on we explicitly restore the associated state
775 discard_cleanups (inf_status_cleanup);
777 /* Register a clean-up for unwind_on_terminating_exception_breakpoint. */
778 terminate_bp_cleanup = make_cleanup (cleanup_delete_std_terminate_breakpoint,
781 /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP -
782 If you're looking to implement asynchronous dummy-frames, then
783 just below is the place to chop this function in two.. */
785 /* TP is invalid after run_inferior_call returns, so enclose this
786 in a block so that it's only in scope during the time it's valid. */
788 struct thread_info *tp = inferior_thread ();
790 /* Save this thread's ptid, we need it later but the thread
792 call_thread_ptid = tp->ptid;
794 /* Run the inferior until it stops. */
796 e = run_inferior_call (tp, real_pc);
799 /* Rethrow an error if we got one trying to run the inferior. */
803 const char *name = get_function_name (funaddr,
804 name_buf, sizeof (name_buf));
806 discard_inferior_status (inf_status);
808 /* We could discard the dummy frame here if the program exited,
809 but it will get garbage collected the next time the program is
815 throw_error (e.error, _("\
817 An error occurred while in a function called from GDB.\n\
818 Evaluation of the expression containing the function\n\
819 (%s) will be abandoned.\n\
820 When the function is done executing, GDB will silently stop."),
828 /* If the program has exited, or we stopped at a different thread,
829 exit and inform the user. */
831 if (! target_has_execution)
833 const char *name = get_function_name (funaddr,
834 name_buf, sizeof (name_buf));
836 /* If we try to restore the inferior status,
837 we'll crash as the inferior is no longer running. */
838 discard_inferior_status (inf_status);
840 /* We could discard the dummy frame here given that the program exited,
841 but it will get garbage collected the next time the program is
845 The program being debugged exited while in a function called from GDB.\n\
846 Evaluation of the expression containing the function\n\
847 (%s) will be abandoned."),
851 if (! ptid_equal (call_thread_ptid, inferior_ptid))
853 const char *name = get_function_name (funaddr,
854 name_buf, sizeof (name_buf));
856 /* We've switched threads. This can happen if another thread gets a
857 signal or breakpoint while our thread was running.
858 There's no point in restoring the inferior status,
859 we're in a different thread. */
860 discard_inferior_status (inf_status);
861 /* Keep the dummy frame record, if the user switches back to the
862 thread with the hand-call, we'll need it. */
863 if (stopped_by_random_signal)
865 The program received a signal in another thread while\n\
866 making a function call from GDB.\n\
867 Evaluation of the expression containing the function\n\
868 (%s) will be abandoned.\n\
869 When the function is done executing, GDB will silently stop."),
873 The program stopped in another thread while making a function call from GDB.\n\
874 Evaluation of the expression containing the function\n\
875 (%s) will be abandoned.\n\
876 When the function is done executing, GDB will silently stop."),
880 if (stopped_by_random_signal || stop_stack_dummy != STOP_STACK_DUMMY)
882 const char *name = get_function_name (funaddr,
883 name_buf, sizeof (name_buf));
885 if (stopped_by_random_signal)
887 /* We stopped inside the FUNCTION because of a random
888 signal. Further execution of the FUNCTION is not
891 if (unwind_on_signal_p)
893 /* The user wants the context restored. */
895 /* We must get back to the frame we were before the
897 dummy_frame_pop (dummy_id);
899 /* We also need to restore inferior status to that before the
901 restore_inferior_status (inf_status);
903 /* FIXME: Insert a bunch of wrap_here; name can be very
904 long if it's a C++ name with arguments and stuff. */
906 The program being debugged was signaled while in a function called from GDB.\n\
907 GDB has restored the context to what it was before the call.\n\
908 To change this behavior use \"set unwindonsignal off\".\n\
909 Evaluation of the expression containing the function\n\
910 (%s) will be abandoned."),
915 /* The user wants to stay in the frame where we stopped
917 Discard inferior status, we're not at the same point
919 discard_inferior_status (inf_status);
921 /* FIXME: Insert a bunch of wrap_here; name can be very
922 long if it's a C++ name with arguments and stuff. */
924 The program being debugged was signaled while in a function called from GDB.\n\
925 GDB remains in the frame where the signal was received.\n\
926 To change this behavior use \"set unwindonsignal on\".\n\
927 Evaluation of the expression containing the function\n\
928 (%s) will be abandoned.\n\
929 When the function is done executing, GDB will silently stop."),
934 if (stop_stack_dummy == STOP_STD_TERMINATE)
936 /* We must get back to the frame we were before the dummy
938 dummy_frame_pop (dummy_id);
940 /* We also need to restore inferior status to that before
942 restore_inferior_status (inf_status);
945 The program being debugged entered a std::terminate call, most likely\n\
946 caused by an unhandled C++ exception. GDB blocked this call in order\n\
947 to prevent the program from being terminated, and has restored the\n\
948 context to its original state before the call.\n\
949 To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
950 Evaluation of the expression containing the function (%s)\n\
951 will be abandoned."),
954 else if (stop_stack_dummy == STOP_NONE)
957 /* We hit a breakpoint inside the FUNCTION.
958 Keep the dummy frame, the user may want to examine its state.
959 Discard inferior status, we're not at the same point
961 discard_inferior_status (inf_status);
963 /* The following error message used to say "The expression
964 which contained the function call has been discarded."
965 It is a hard concept to explain in a few words. Ideally,
966 GDB would be able to resume evaluation of the expression
967 when the function finally is done executing. Perhaps
968 someday this will be implemented (it would not be easy). */
969 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
970 a C++ name with arguments and stuff. */
972 The program being debugged stopped while in a function called from GDB.\n\
973 Evaluation of the expression containing the function\n\
974 (%s) will be abandoned.\n\
975 When the function is done executing, GDB will silently stop."),
979 /* The above code errors out, so ... */
980 internal_error (__FILE__, __LINE__, _("... should not be here"));
983 do_cleanups (terminate_bp_cleanup);
985 /* If we get here the called FUNCTION ran to completion,
986 and the dummy frame has already been popped. */
989 struct address_space *aspace = get_regcache_aspace (stop_registers);
990 struct regcache *retbuf = regcache_xmalloc (gdbarch, aspace);
991 struct cleanup *retbuf_cleanup = make_cleanup_regcache_xfree (retbuf);
992 struct value *retval = NULL;
994 regcache_cpy_no_passthrough (retbuf, stop_registers);
996 /* Inferior call is successful. Restore the inferior status.
997 At this stage, leave the RETBUF alone. */
998 restore_inferior_status (inf_status);
1000 /* Figure out the value returned by the function. */
1002 if (lang_struct_return)
1003 retval = value_at (values_type, struct_addr);
1004 else if (TYPE_CODE (target_values_type) == TYPE_CODE_VOID)
1006 /* If the function returns void, don't bother fetching the
1008 retval = allocate_value (values_type);
1012 switch (gdbarch_return_value (gdbarch, value_type (function),
1013 target_values_type, NULL, NULL, NULL))
1015 case RETURN_VALUE_REGISTER_CONVENTION:
1016 case RETURN_VALUE_ABI_RETURNS_ADDRESS:
1017 case RETURN_VALUE_ABI_PRESERVES_ADDRESS:
1018 retval = allocate_value (values_type);
1019 gdbarch_return_value (gdbarch, value_type (function), values_type,
1020 retbuf, value_contents_raw (retval), NULL);
1022 case RETURN_VALUE_STRUCT_CONVENTION:
1023 retval = value_at (values_type, struct_addr);
1028 do_cleanups (retbuf_cleanup);
1030 gdb_assert (retval);
1036 /* Provide a prototype to silence -Wmissing-prototypes. */
1037 void _initialize_infcall (void);
1040 _initialize_infcall (void)
1042 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure,
1043 &coerce_float_to_double_p, _("\
1044 Set coercion of floats to doubles when calling functions."), _("\
1045 Show coercion of floats to doubles when calling functions"), _("\
1046 Variables of type float should generally be converted to doubles before\n\
1047 calling an unprototyped function, and left alone when calling a prototyped\n\
1048 function. However, some older debug info formats do not provide enough\n\
1049 information to determine that a function is prototyped. If this flag is\n\
1050 set, GDB will perform the conversion for a function it considers\n\
1052 The default is to perform the conversion.\n"),
1054 show_coerce_float_to_double_p,
1055 &setlist, &showlist);
1057 add_setshow_boolean_cmd ("unwindonsignal", no_class,
1058 &unwind_on_signal_p, _("\
1059 Set unwinding of stack if a signal is received while in a call dummy."), _("\
1060 Show unwinding of stack if a signal is received while in a call dummy."), _("\
1061 The unwindonsignal lets the user determine what gdb should do if a signal\n\
1062 is received while in a function called from gdb (call dummy). If set, gdb\n\
1063 unwinds the stack and restore the context to what as it was before the call.\n\
1064 The default is to stop in the frame where the signal was received."),
1066 show_unwind_on_signal_p,
1067 &setlist, &showlist);
1069 add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class,
1070 &unwind_on_terminating_exception_p, _("\
1071 Set unwinding of stack if std::terminate is called while in call dummy."), _("\
1072 Show unwinding of stack if std::terminate() is called while in a call dummy."), _("\
1073 The unwind on terminating exception flag lets the user determine\n\
1074 what gdb should do if a std::terminate() call is made from the\n\
1075 default exception handler. If set, gdb unwinds the stack and restores\n\
1076 the context to what it was before the call. If unset, gdb allows the\n\
1077 std::terminate call to proceed.\n\
1078 The default is to unwind the frame."),
1080 show_unwind_on_terminating_exception_p,
1081 &setlist, &showlist);