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;
453 char name_buf[RAW_FUNCTION_ADDRESS_SIZE];
455 if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
456 ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
458 if (!target_has_execution)
461 if (get_traceframe_number () >= 0)
462 error (_("May not call functions while looking at trace frames."));
464 frame = get_current_frame ();
465 gdbarch = get_frame_arch (frame);
467 if (!gdbarch_push_dummy_call_p (gdbarch))
468 error (_("This target does not support function calls."));
470 /* A cleanup for the inferior status.
471 This is only needed while we're preparing the inferior function call. */
472 inf_status = save_inferior_status ();
473 inf_status_cleanup = make_cleanup_restore_inferior_status (inf_status);
475 /* Save the caller's registers and other state associated with the
476 inferior itself so that they can be restored once the
477 callee returns. To allow nested calls the registers are (further
478 down) pushed onto a dummy frame stack. Include a cleanup (which
479 is tossed once the regcache has been pushed). */
480 caller_state = save_inferior_thread_state ();
481 caller_state_cleanup = make_cleanup_restore_inferior_thread_state (caller_state);
483 /* Ensure that the initial SP is correctly aligned. */
485 CORE_ADDR old_sp = get_frame_sp (frame);
486 if (gdbarch_frame_align_p (gdbarch))
488 sp = gdbarch_frame_align (gdbarch, old_sp);
489 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
490 ABIs, a function can use memory beyond the inner most stack
491 address. AMD64 called that region the "red zone". Skip at
492 least the "red zone" size before allocating any space on
494 if (gdbarch_inner_than (gdbarch, 1, 2))
495 sp -= gdbarch_frame_red_zone_size (gdbarch);
497 sp += gdbarch_frame_red_zone_size (gdbarch);
499 gdb_assert (sp == gdbarch_frame_align (gdbarch, sp));
500 /* NOTE: cagney/2002-09-18:
502 On a RISC architecture, a void parameterless generic dummy
503 frame (i.e., no parameters, no result) typically does not
504 need to push anything the stack and hence can leave SP and
505 FP. Similarly, a frameless (possibly leaf) function does
506 not push anything on the stack and, hence, that too can
507 leave FP and SP unchanged. As a consequence, a sequence of
508 void parameterless generic dummy frame calls to frameless
509 functions will create a sequence of effectively identical
510 frames (SP, FP and TOS and PC the same). This, not
511 suprisingly, results in what appears to be a stack in an
512 infinite loop --- when GDB tries to find a generic dummy
513 frame on the internal dummy frame stack, it will always
516 To avoid this problem, the code below always grows the
517 stack. That way, two dummy frames can never be identical.
518 It does burn a few bytes of stack but that is a small price
522 if (gdbarch_inner_than (gdbarch, 1, 2))
523 /* Stack grows down. */
524 sp = gdbarch_frame_align (gdbarch, old_sp - 1);
526 /* Stack grows up. */
527 sp = gdbarch_frame_align (gdbarch, old_sp + 1);
529 /* SP may have underflown address zero here from OLD_SP. Memory access
530 functions will probably fail in such case but that is a target's
534 /* FIXME: cagney/2002-09-18: Hey, you loose!
536 Who knows how badly aligned the SP is!
538 If the generic dummy frame ends up empty (because nothing is
539 pushed) GDB won't be able to correctly perform back traces.
540 If a target is having trouble with backtraces, first thing to
541 do is add FRAME_ALIGN() to the architecture vector. If that
542 fails, try dummy_id().
544 If the ABI specifies a "Red Zone" (see the doco) the code
545 below will quietly trash it. */
549 funaddr = find_function_addr (function, &values_type);
551 values_type = builtin_type (gdbarch)->builtin_int;
553 CHECK_TYPEDEF (values_type);
555 /* Are we returning a value using a structure return (passing a
556 hidden argument pointing to storage) or a normal value return?
557 There are two cases: language-mandated structure return and
558 target ABI structure return. The variable STRUCT_RETURN only
559 describes the latter. The language version is handled by passing
560 the return location as the first parameter to the function,
561 even preceding "this". This is different from the target
562 ABI version, which is target-specific; for instance, on ia64
563 the first argument is passed in out0 but the hidden structure
564 return pointer would normally be passed in r8. */
566 if (language_pass_by_reference (values_type))
568 lang_struct_return = 1;
570 /* Tell the target specific argument pushing routine not to
572 target_values_type = builtin_type (gdbarch)->builtin_void;
576 struct_return = using_struct_return (gdbarch,
577 value_type (function), values_type);
578 target_values_type = values_type;
581 /* Determine the location of the breakpoint (and possibly other
582 stuff) that the called function will return to. The SPARC, for a
583 function returning a structure or union, needs to make space for
584 not just the breakpoint but also an extra word containing the
585 size (?) of the structure being passed. */
587 /* The actual breakpoint (at BP_ADDR) is inserted separatly so there
588 is no need to write that out. */
590 switch (gdbarch_call_dummy_location (gdbarch))
593 sp = push_dummy_code (gdbarch, sp, funaddr,
594 args, nargs, target_values_type,
595 &real_pc, &bp_addr, get_current_regcache ());
599 CORE_ADDR dummy_addr;
602 dummy_addr = entry_point_address ();
603 /* A call dummy always consists of just a single breakpoint, so
604 its address is the same as the address of the dummy. */
605 bp_addr = dummy_addr;
609 /* Some executables define a symbol __CALL_DUMMY_ADDRESS whose
610 address is the location where the breakpoint should be
611 placed. Once all targets are using the overhauled frame code
612 this can be deleted - ON_STACK is a better option. */
614 struct minimal_symbol *sym;
615 CORE_ADDR dummy_addr;
617 sym = lookup_minimal_symbol ("__CALL_DUMMY_ADDRESS", NULL, NULL);
621 dummy_addr = SYMBOL_VALUE_ADDRESS (sym);
622 /* Make certain that the address points at real code, and not
623 a function descriptor. */
624 dummy_addr = gdbarch_convert_from_func_ptr_addr (gdbarch,
629 dummy_addr = entry_point_address ();
630 /* A call dummy always consists of just a single breakpoint,
631 so it's address is the same as the address of the dummy. */
632 bp_addr = dummy_addr;
636 internal_error (__FILE__, __LINE__, _("bad switch"));
639 if (nargs < TYPE_NFIELDS (ftype))
640 error (_("Too few arguments in function call."));
644 for (i = nargs - 1; i >= 0; i--)
647 struct type *param_type;
649 /* FIXME drow/2002-05-31: Should just always mark methods as
650 prototyped. Can we respect TYPE_VARARGS? Probably not. */
651 if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
653 else if (i < TYPE_NFIELDS (ftype))
654 prototyped = TYPE_PROTOTYPED (ftype);
658 if (i < TYPE_NFIELDS (ftype))
659 param_type = TYPE_FIELD_TYPE (ftype, i);
663 args[i] = value_arg_coerce (gdbarch, args[i],
664 param_type, prototyped, &sp);
666 if (param_type != NULL && language_pass_by_reference (param_type))
667 args[i] = value_addr (args[i]);
671 /* Reserve space for the return structure to be written on the
672 stack, if necessary. Make certain that the value is correctly
675 if (struct_return || lang_struct_return)
677 int len = TYPE_LENGTH (values_type);
678 if (gdbarch_inner_than (gdbarch, 1, 2))
680 /* Stack grows downward. Align STRUCT_ADDR and SP after
681 making space for the return value. */
683 if (gdbarch_frame_align_p (gdbarch))
684 sp = gdbarch_frame_align (gdbarch, sp);
689 /* Stack grows upward. Align the frame, allocate space, and
690 then again, re-align the frame??? */
691 if (gdbarch_frame_align_p (gdbarch))
692 sp = gdbarch_frame_align (gdbarch, sp);
695 if (gdbarch_frame_align_p (gdbarch))
696 sp = gdbarch_frame_align (gdbarch, sp);
700 if (lang_struct_return)
702 struct value **new_args;
704 /* Add the new argument to the front of the argument list. */
705 new_args = xmalloc (sizeof (struct value *) * (nargs + 1));
706 new_args[0] = value_from_pointer (lookup_pointer_type (values_type),
708 memcpy (&new_args[1], &args[0], sizeof (struct value *) * nargs);
711 args_cleanup = make_cleanup (xfree, args);
714 args_cleanup = make_cleanup (null_cleanup, NULL);
716 /* Create the dummy stack frame. Pass in the call dummy address as,
717 presumably, the ABI code knows where, in the call dummy, the
718 return address should be pointed. */
719 sp = gdbarch_push_dummy_call (gdbarch, function, get_current_regcache (),
720 bp_addr, nargs, args,
721 sp, struct_return, struct_addr);
723 do_cleanups (args_cleanup);
725 /* Set up a frame ID for the dummy frame so we can pass it to
726 set_momentary_breakpoint. We need to give the breakpoint a frame
727 ID so that the breakpoint code can correctly re-identify the
729 /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL,
730 saved as the dummy-frame TOS, and used by dummy_id to form
731 the frame ID's stack address. */
732 dummy_id = frame_id_build (sp, bp_addr);
734 /* Create a momentary breakpoint at the return address of the
735 inferior. That way it breaks when it returns. */
738 struct breakpoint *bpt;
739 struct symtab_and_line sal;
740 init_sal (&sal); /* initialize to zeroes */
741 sal.pspace = current_program_space;
743 sal.section = find_pc_overlay (sal.pc);
744 /* Sanity. The exact same SP value is returned by
745 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
746 dummy_id to form the frame ID's stack address. */
747 bpt = set_momentary_breakpoint (gdbarch, sal, dummy_id, bp_call_dummy);
748 bpt->disposition = disp_del;
751 /* Create a breakpoint in std::terminate.
752 If a C++ exception is raised in the dummy-frame, and the
753 exception handler is (normally, and expected to be) out-of-frame,
754 the default C++ handler will (wrongly) be called in an inferior
755 function call. This is wrong, as an exception can be normally
756 and legally handled out-of-frame. The confines of the dummy frame
757 prevent the unwinder from finding the correct handler (or any
758 handler, unless it is in-frame). The default handler calls
759 std::terminate. This will kill the inferior. Assert that
760 terminate should never be called in an inferior function
761 call. Place a momentary breakpoint in the std::terminate function
762 and if triggered in the call, rewind. */
763 if (unwind_on_terminating_exception_p)
764 set_std_terminate_breakpoint ();
766 /* Everything's ready, push all the info needed to restore the
767 caller (and identify the dummy-frame) onto the dummy-frame
769 dummy_frame_push (caller_state, &dummy_id);
771 /* Discard both inf_status and caller_state cleanups.
772 From this point on we explicitly restore the associated state
774 discard_cleanups (inf_status_cleanup);
776 /* Register a clean-up for unwind_on_terminating_exception_breakpoint. */
777 terminate_bp_cleanup = make_cleanup (cleanup_delete_std_terminate_breakpoint,
780 /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP -
781 If you're looking to implement asynchronous dummy-frames, then
782 just below is the place to chop this function in two.. */
784 /* TP is invalid after run_inferior_call returns, so enclose this
785 in a block so that it's only in scope during the time it's valid. */
787 struct thread_info *tp = inferior_thread ();
789 /* Save this thread's ptid, we need it later but the thread
791 call_thread_ptid = tp->ptid;
793 /* Run the inferior until it stops. */
795 e = run_inferior_call (tp, real_pc);
798 /* Rethrow an error if we got one trying to run the inferior. */
802 const char *name = get_function_name (funaddr,
803 name_buf, sizeof (name_buf));
805 discard_inferior_status (inf_status);
807 /* We could discard the dummy frame here if the program exited,
808 but it will get garbage collected the next time the program is
814 throw_error (e.error, _("\
816 An error occurred while in a function called from GDB.\n\
817 Evaluation of the expression containing the function\n\
818 (%s) will be abandoned.\n\
819 When the function is done executing, GDB will silently stop."),
827 /* If the program has exited, or we stopped at a different thread,
828 exit and inform the user. */
830 if (! target_has_execution)
832 const char *name = get_function_name (funaddr,
833 name_buf, sizeof (name_buf));
835 /* If we try to restore the inferior status,
836 we'll crash as the inferior is no longer running. */
837 discard_inferior_status (inf_status);
839 /* We could discard the dummy frame here given that the program exited,
840 but it will get garbage collected the next time the program is
844 The program being debugged exited while in a function called from GDB.\n\
845 Evaluation of the expression containing the function\n\
846 (%s) will be abandoned."),
850 if (! ptid_equal (call_thread_ptid, inferior_ptid))
852 const char *name = get_function_name (funaddr,
853 name_buf, sizeof (name_buf));
855 /* We've switched threads. This can happen if another thread gets a
856 signal or breakpoint while our thread was running.
857 There's no point in restoring the inferior status,
858 we're in a different thread. */
859 discard_inferior_status (inf_status);
860 /* Keep the dummy frame record, if the user switches back to the
861 thread with the hand-call, we'll need it. */
862 if (stopped_by_random_signal)
864 The program received a signal in another thread while\n\
865 making a function call from GDB.\n\
866 Evaluation of the expression containing the function\n\
867 (%s) will be abandoned.\n\
868 When the function is done executing, GDB will silently stop."),
872 The program stopped in another thread while making a function call from GDB.\n\
873 Evaluation of the expression containing the function\n\
874 (%s) will be abandoned.\n\
875 When the function is done executing, GDB will silently stop."),
879 if (stopped_by_random_signal || stop_stack_dummy != STOP_STACK_DUMMY)
881 const char *name = get_function_name (funaddr,
882 name_buf, sizeof (name_buf));
884 if (stopped_by_random_signal)
886 /* We stopped inside the FUNCTION because of a random
887 signal. Further execution of the FUNCTION is not
890 if (unwind_on_signal_p)
892 /* The user wants the context restored. */
894 /* We must get back to the frame we were before the
896 dummy_frame_pop (dummy_id);
898 /* We also need to restore inferior status to that before the
900 restore_inferior_status (inf_status);
902 /* FIXME: Insert a bunch of wrap_here; name can be very
903 long if it's a C++ name with arguments and stuff. */
905 The program being debugged was signaled while in a function called from GDB.\n\
906 GDB has restored the context to what it was before the call.\n\
907 To change this behavior use \"set unwindonsignal off\".\n\
908 Evaluation of the expression containing the function\n\
909 (%s) will be abandoned."),
914 /* The user wants to stay in the frame where we stopped
916 Discard inferior status, we're not at the same point
918 discard_inferior_status (inf_status);
920 /* FIXME: Insert a bunch of wrap_here; name can be very
921 long if it's a C++ name with arguments and stuff. */
923 The program being debugged was signaled while in a function called from GDB.\n\
924 GDB remains in the frame where the signal was received.\n\
925 To change this behavior use \"set unwindonsignal on\".\n\
926 Evaluation of the expression containing the function\n\
927 (%s) will be abandoned.\n\
928 When the function is done executing, GDB will silently stop."),
933 if (stop_stack_dummy == STOP_STD_TERMINATE)
935 /* We must get back to the frame we were before the dummy
937 dummy_frame_pop (dummy_id);
939 /* We also need to restore inferior status to that before
941 restore_inferior_status (inf_status);
944 The program being debugged entered a std::terminate call, most likely\n\
945 caused by an unhandled C++ exception. GDB blocked this call in order\n\
946 to prevent the program from being terminated, and has restored the\n\
947 context to its original state before the call.\n\
948 To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
949 Evaluation of the expression containing the function (%s)\n\
950 will be abandoned."),
953 else if (stop_stack_dummy == STOP_NONE)
956 /* We hit a breakpoint inside the FUNCTION.
957 Keep the dummy frame, the user may want to examine its state.
958 Discard inferior status, we're not at the same point
960 discard_inferior_status (inf_status);
962 /* The following error message used to say "The expression
963 which contained the function call has been discarded."
964 It is a hard concept to explain in a few words. Ideally,
965 GDB would be able to resume evaluation of the expression
966 when the function finally is done executing. Perhaps
967 someday this will be implemented (it would not be easy). */
968 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
969 a C++ name with arguments and stuff. */
971 The program being debugged stopped while in a function called from GDB.\n\
972 Evaluation of the expression containing the function\n\
973 (%s) will be abandoned.\n\
974 When the function is done executing, GDB will silently stop."),
978 /* The above code errors out, so ... */
979 internal_error (__FILE__, __LINE__, _("... should not be here"));
982 do_cleanups (terminate_bp_cleanup);
984 /* If we get here the called FUNCTION ran to completion,
985 and the dummy frame has already been popped. */
988 struct address_space *aspace = get_regcache_aspace (stop_registers);
989 struct regcache *retbuf = regcache_xmalloc (gdbarch, aspace);
990 struct cleanup *retbuf_cleanup = make_cleanup_regcache_xfree (retbuf);
991 struct value *retval = NULL;
993 regcache_cpy_no_passthrough (retbuf, stop_registers);
995 /* Inferior call is successful. Restore the inferior status.
996 At this stage, leave the RETBUF alone. */
997 restore_inferior_status (inf_status);
999 /* Figure out the value returned by the function. */
1001 if (lang_struct_return)
1002 retval = value_at (values_type, struct_addr);
1003 else if (TYPE_CODE (target_values_type) == TYPE_CODE_VOID)
1005 /* If the function returns void, don't bother fetching the
1007 retval = allocate_value (values_type);
1011 switch (gdbarch_return_value (gdbarch, value_type (function),
1012 target_values_type, NULL, NULL, NULL))
1014 case RETURN_VALUE_REGISTER_CONVENTION:
1015 case RETURN_VALUE_ABI_RETURNS_ADDRESS:
1016 case RETURN_VALUE_ABI_PRESERVES_ADDRESS:
1017 retval = allocate_value (values_type);
1018 gdbarch_return_value (gdbarch, value_type (function), values_type,
1019 retbuf, value_contents_raw (retval), NULL);
1021 case RETURN_VALUE_STRUCT_CONVENTION:
1022 retval = value_at (values_type, struct_addr);
1027 do_cleanups (retbuf_cleanup);
1029 gdb_assert (retval);
1035 /* Provide a prototype to silence -Wmissing-prototypes. */
1036 void _initialize_infcall (void);
1039 _initialize_infcall (void)
1041 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure,
1042 &coerce_float_to_double_p, _("\
1043 Set coercion of floats to doubles when calling functions."), _("\
1044 Show coercion of floats to doubles when calling functions"), _("\
1045 Variables of type float should generally be converted to doubles before\n\
1046 calling an unprototyped function, and left alone when calling a prototyped\n\
1047 function. However, some older debug info formats do not provide enough\n\
1048 information to determine that a function is prototyped. If this flag is\n\
1049 set, GDB will perform the conversion for a function it considers\n\
1051 The default is to perform the conversion.\n"),
1053 show_coerce_float_to_double_p,
1054 &setlist, &showlist);
1056 add_setshow_boolean_cmd ("unwindonsignal", no_class,
1057 &unwind_on_signal_p, _("\
1058 Set unwinding of stack if a signal is received while in a call dummy."), _("\
1059 Show unwinding of stack if a signal is received while in a call dummy."), _("\
1060 The unwindonsignal lets the user determine what gdb should do if a signal\n\
1061 is received while in a function called from gdb (call dummy). If set, gdb\n\
1062 unwinds the stack and restore the context to what as it was before the call.\n\
1063 The default is to stop in the frame where the signal was received."),
1065 show_unwind_on_signal_p,
1066 &setlist, &showlist);
1068 add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class,
1069 &unwind_on_terminating_exception_p, _("\
1070 Set unwinding of stack if std::terminate is called while in call dummy."), _("\
1071 Show unwinding of stack if std::terminate() is called while in a call dummy."), _("\
1072 The unwind on terminating exception flag lets the user determine\n\
1073 what gdb should do if a std::terminate() call is made from the\n\
1074 default exception handler. If set, gdb unwinds the stack and restores\n\
1075 the context to what it was before the call. If unset, gdb allows the\n\
1076 std::terminate call to proceed.\n\
1077 The default is to unwind the frame."),
1079 show_unwind_on_terminating_exception_p,
1080 &setlist, &showlist);