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 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"
27 #include "gdb_assert.h"
34 #include "gdb_string.h"
36 #include "dummy-frame.h"
38 #include "gdbthread.h"
39 #include "exceptions.h"
41 /* If we can't find a function's name from its address,
42 we print this instead. */
43 #define RAW_FUNCTION_ADDRESS_FORMAT "at 0x%s"
44 #define RAW_FUNCTION_ADDRESS_SIZE (sizeof (RAW_FUNCTION_ADDRESS_FORMAT) \
45 + 2 * sizeof (CORE_ADDR))
47 /* NOTE: cagney/2003-04-16: What's the future of this code?
49 GDB needs an asynchronous expression evaluator, that means an
50 asynchronous inferior function call implementation, and that in
51 turn means restructuring the code so that it is event driven. */
53 /* How you should pass arguments to a function depends on whether it
54 was defined in K&R style or prototype style. If you define a
55 function using the K&R syntax that takes a `float' argument, then
56 callers must pass that argument as a `double'. If you define the
57 function using the prototype syntax, then you must pass the
58 argument as a `float', with no promotion.
60 Unfortunately, on certain older platforms, the debug info doesn't
61 indicate reliably how each function was defined. A function type's
62 TYPE_FLAG_PROTOTYPED flag may be clear, even if the function was
63 defined in prototype style. When calling a function whose
64 TYPE_FLAG_PROTOTYPED flag is clear, GDB consults this flag to
67 For modern targets, it is proper to assume that, if the prototype
68 flag is clear, that can be trusted: `float' arguments should be
69 promoted to `double'. For some older targets, if the prototype
70 flag is clear, that doesn't tell us anything. The default is to
71 trust the debug information; the user can override this behavior
72 with "set coerce-float-to-double 0". */
74 static int coerce_float_to_double_p
= 1;
76 show_coerce_float_to_double_p (struct ui_file
*file
, int from_tty
,
77 struct cmd_list_element
*c
, const char *value
)
79 fprintf_filtered (file
, _("\
80 Coercion of floats to doubles when calling functions is %s.\n"),
84 /* This boolean tells what gdb should do if a signal is received while
85 in a function called from gdb (call dummy). If set, gdb unwinds
86 the stack and restore the context to what as it was before the
89 The default is to stop in the frame where the signal was received. */
91 int unwind_on_signal_p
= 0;
93 show_unwind_on_signal_p (struct ui_file
*file
, int from_tty
,
94 struct cmd_list_element
*c
, const char *value
)
96 fprintf_filtered (file
, _("\
97 Unwinding of stack if a signal is received while in a call dummy is %s.\n"),
101 /* This boolean tells what gdb should do if a std::terminate call is
102 made while in a function called from gdb (call dummy).
103 As the confines of a single dummy stack prohibit out-of-frame
104 handlers from handling a raised exception, and as out-of-frame
105 handlers are common in C++, this can lead to no handler being found
106 by the unwinder, and a std::terminate call. This is a false positive.
107 If set, gdb unwinds the stack and restores the context to what it
110 The default is to unwind the frame if a std::terminate call is
113 static int unwind_on_terminating_exception_p
= 1;
116 show_unwind_on_terminating_exception_p (struct ui_file
*file
, int from_tty
,
117 struct cmd_list_element
*c
,
121 fprintf_filtered (file
, _("\
122 Unwind stack if a C++ exception is unhandled while in a call dummy is %s.\n"),
126 /* Perform the standard coercions that are specified
127 for arguments to be passed to C or Ada functions.
129 If PARAM_TYPE is non-NULL, it is the expected parameter type.
130 IS_PROTOTYPED is non-zero if the function declaration is prototyped.
131 SP is the stack pointer were additional data can be pushed (updating
132 its value as needed). */
134 static struct value
*
135 value_arg_coerce (struct gdbarch
*gdbarch
, struct value
*arg
,
136 struct type
*param_type
, int is_prototyped
, CORE_ADDR
*sp
)
138 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
139 struct type
*arg_type
= check_typedef (value_type (arg
));
141 = param_type
? check_typedef (param_type
) : arg_type
;
143 /* Perform any Ada-specific coercion first. */
144 if (current_language
->la_language
== language_ada
)
145 arg
= ada_convert_actual (arg
, type
, gdbarch
, sp
);
147 /* Force the value to the target if we will need its address. At
148 this point, we could allocate arguments on the stack instead of
149 calling malloc if we knew that their addresses would not be
150 saved by the called function. */
151 arg
= value_coerce_to_target (arg
);
153 switch (TYPE_CODE (type
))
157 struct value
*new_value
;
159 if (TYPE_CODE (arg_type
) == TYPE_CODE_REF
)
160 return value_cast_pointers (type
, arg
);
162 /* Cast the value to the reference's target type, and then
163 convert it back to a reference. This will issue an error
164 if the value was not previously in memory - in some cases
165 we should clearly be allowing this, but how? */
166 new_value
= value_cast (TYPE_TARGET_TYPE (type
), arg
);
167 new_value
= value_ref (new_value
);
174 /* If we don't have a prototype, coerce to integer type if necessary. */
177 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin
->builtin_int
))
178 type
= builtin
->builtin_int
;
180 /* Currently all target ABIs require at least the width of an integer
181 type for an argument. We may have to conditionalize the following
182 type coercion for future targets. */
183 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin
->builtin_int
))
184 type
= builtin
->builtin_int
;
187 if (!is_prototyped
&& coerce_float_to_double_p
)
189 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin
->builtin_double
))
190 type
= builtin
->builtin_double
;
191 else if (TYPE_LENGTH (type
) > TYPE_LENGTH (builtin
->builtin_double
))
192 type
= builtin
->builtin_long_double
;
196 type
= lookup_pointer_type (type
);
198 case TYPE_CODE_ARRAY
:
199 /* Arrays are coerced to pointers to their first element, unless
200 they are vectors, in which case we want to leave them alone,
201 because they are passed by value. */
202 if (current_language
->c_style_arrays
)
203 if (!TYPE_VECTOR (type
))
204 type
= lookup_pointer_type (TYPE_TARGET_TYPE (type
));
206 case TYPE_CODE_UNDEF
:
208 case TYPE_CODE_STRUCT
:
209 case TYPE_CODE_UNION
:
212 case TYPE_CODE_RANGE
:
213 case TYPE_CODE_STRING
:
214 case TYPE_CODE_BITSTRING
:
215 case TYPE_CODE_ERROR
:
216 case TYPE_CODE_MEMBERPTR
:
217 case TYPE_CODE_METHODPTR
:
218 case TYPE_CODE_METHOD
:
219 case TYPE_CODE_COMPLEX
:
224 return value_cast (type
, arg
);
227 /* Determine a function's address and its return type from its value.
228 Calls error() if the function is not valid for calling. */
231 find_function_addr (struct value
*function
, struct type
**retval_type
)
233 struct type
*ftype
= check_typedef (value_type (function
));
234 enum type_code code
= TYPE_CODE (ftype
);
235 struct type
*value_type
= NULL
;
238 /* If it's a member function, just look at the function
241 /* Determine address to call. */
242 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
244 funaddr
= value_address (function
);
245 value_type
= TYPE_TARGET_TYPE (ftype
);
247 else if (code
== TYPE_CODE_PTR
)
249 funaddr
= value_as_address (function
);
250 ftype
= check_typedef (TYPE_TARGET_TYPE (ftype
));
251 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
252 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
254 funaddr
= gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
257 value_type
= TYPE_TARGET_TYPE (ftype
);
260 else if (code
== TYPE_CODE_INT
)
262 /* Handle the case of functions lacking debugging info.
263 Their values are characters since their addresses are char */
264 if (TYPE_LENGTH (ftype
) == 1)
265 funaddr
= value_as_address (value_addr (function
));
268 /* Handle function descriptors lacking debug info. */
269 int found_descriptor
= 0;
270 funaddr
= 0; /* pacify "gcc -Werror" */
271 if (VALUE_LVAL (function
) == lval_memory
)
274 funaddr
= value_as_address (value_addr (function
));
276 funaddr
= gdbarch_convert_from_func_ptr_addr (current_gdbarch
,
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 (current_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 /* All this stuff with a dummy frame may seem unnecessarily complicated
407 (why not just save registers in GDB?). The purpose of pushing a dummy
408 frame which looks just like a real frame is so that if you call a
409 function and then hit a breakpoint (get a signal, etc), "backtrace"
410 will look right. Whether the backtrace needs to actually show the
411 stack at the time the inferior function was called is debatable, but
412 it certainly needs to not display garbage. So if you are contemplating
413 making dummy frames be different from normal frames, consider that. */
415 /* Perform a function call in the inferior.
416 ARGS is a vector of values of arguments (NARGS of them).
417 FUNCTION is a value, the function to be called.
418 Returns a value representing what the function returned.
419 May fail to return, if a breakpoint or signal is hit
420 during the execution of the function.
422 ARGS is modified to contain coerced values. */
425 call_function_by_hand (struct value
*function
, int nargs
, struct value
**args
)
428 struct type
*values_type
, *target_values_type
;
429 unsigned char struct_return
= 0, lang_struct_return
= 0;
430 CORE_ADDR struct_addr
= 0;
431 struct inferior_status
*inf_status
;
432 struct cleanup
*inf_status_cleanup
;
433 struct inferior_thread_state
*caller_state
;
434 struct cleanup
*caller_state_cleanup
;
437 struct type
*ftype
= check_typedef (value_type (function
));
439 struct frame_id dummy_id
;
440 struct cleanup
*args_cleanup
;
441 struct frame_info
*frame
;
442 struct gdbarch
*gdbarch
;
443 struct breakpoint
*terminate_bp
= NULL
;
444 struct minimal_symbol
*tm
;
445 ptid_t call_thread_ptid
;
446 struct gdb_exception e
;
448 char name_buf
[RAW_FUNCTION_ADDRESS_SIZE
];
450 if (TYPE_CODE (ftype
) == TYPE_CODE_PTR
)
451 ftype
= check_typedef (TYPE_TARGET_TYPE (ftype
));
453 if (!target_has_execution
)
456 frame
= get_current_frame ();
457 gdbarch
= get_frame_arch (frame
);
459 if (!gdbarch_push_dummy_call_p (gdbarch
))
460 error (_("This target does not support function calls."));
462 /* A cleanup for the inferior status.
463 This is only needed while we're preparing the inferior function call. */
464 inf_status
= save_inferior_status ();
465 inf_status_cleanup
= make_cleanup_restore_inferior_status (inf_status
);
467 /* Save the caller's registers and other state associated with the
468 inferior itself so that they can be restored once the
469 callee returns. To allow nested calls the registers are (further
470 down) pushed onto a dummy frame stack. Include a cleanup (which
471 is tossed once the regcache has been pushed). */
472 caller_state
= save_inferior_thread_state ();
473 caller_state_cleanup
= make_cleanup_restore_inferior_thread_state (caller_state
);
475 /* Ensure that the initial SP is correctly aligned. */
477 CORE_ADDR old_sp
= get_frame_sp (frame
);
478 if (gdbarch_frame_align_p (gdbarch
))
480 sp
= gdbarch_frame_align (gdbarch
, old_sp
);
481 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
482 ABIs, a function can use memory beyond the inner most stack
483 address. AMD64 called that region the "red zone". Skip at
484 least the "red zone" size before allocating any space on
486 if (gdbarch_inner_than (gdbarch
, 1, 2))
487 sp
-= gdbarch_frame_red_zone_size (gdbarch
);
489 sp
+= gdbarch_frame_red_zone_size (gdbarch
);
491 gdb_assert (sp
== gdbarch_frame_align (gdbarch
, sp
));
492 /* NOTE: cagney/2002-09-18:
494 On a RISC architecture, a void parameterless generic dummy
495 frame (i.e., no parameters, no result) typically does not
496 need to push anything the stack and hence can leave SP and
497 FP. Similarly, a frameless (possibly leaf) function does
498 not push anything on the stack and, hence, that too can
499 leave FP and SP unchanged. As a consequence, a sequence of
500 void parameterless generic dummy frame calls to frameless
501 functions will create a sequence of effectively identical
502 frames (SP, FP and TOS and PC the same). This, not
503 suprisingly, results in what appears to be a stack in an
504 infinite loop --- when GDB tries to find a generic dummy
505 frame on the internal dummy frame stack, it will always
508 To avoid this problem, the code below always grows the
509 stack. That way, two dummy frames can never be identical.
510 It does burn a few bytes of stack but that is a small price
514 if (gdbarch_inner_than (gdbarch
, 1, 2))
515 /* Stack grows down. */
516 sp
= gdbarch_frame_align (gdbarch
, old_sp
- 1);
518 /* Stack grows up. */
519 sp
= gdbarch_frame_align (gdbarch
, old_sp
+ 1);
521 gdb_assert ((gdbarch_inner_than (gdbarch
, 1, 2)
523 || (gdbarch_inner_than (gdbarch
, 2, 1)
527 /* FIXME: cagney/2002-09-18: Hey, you loose!
529 Who knows how badly aligned the SP is!
531 If the generic dummy frame ends up empty (because nothing is
532 pushed) GDB won't be able to correctly perform back traces.
533 If a target is having trouble with backtraces, first thing to
534 do is add FRAME_ALIGN() to the architecture vector. If that
535 fails, try dummy_id().
537 If the ABI specifies a "Red Zone" (see the doco) the code
538 below will quietly trash it. */
542 funaddr
= find_function_addr (function
, &values_type
);
544 values_type
= builtin_type (gdbarch
)->builtin_int
;
546 CHECK_TYPEDEF (values_type
);
548 /* Are we returning a value using a structure return (passing a
549 hidden argument pointing to storage) or a normal value return?
550 There are two cases: language-mandated structure return and
551 target ABI structure return. The variable STRUCT_RETURN only
552 describes the latter. The language version is handled by passing
553 the return location as the first parameter to the function,
554 even preceding "this". This is different from the target
555 ABI version, which is target-specific; for instance, on ia64
556 the first argument is passed in out0 but the hidden structure
557 return pointer would normally be passed in r8. */
559 if (language_pass_by_reference (values_type
))
561 lang_struct_return
= 1;
563 /* Tell the target specific argument pushing routine not to
565 target_values_type
= builtin_type_void
;
569 struct_return
= using_struct_return (gdbarch
,
570 value_type (function
), values_type
);
571 target_values_type
= values_type
;
574 /* Determine the location of the breakpoint (and possibly other
575 stuff) that the called function will return to. The SPARC, for a
576 function returning a structure or union, needs to make space for
577 not just the breakpoint but also an extra word containing the
578 size (?) of the structure being passed. */
580 /* The actual breakpoint (at BP_ADDR) is inserted separatly so there
581 is no need to write that out. */
583 switch (gdbarch_call_dummy_location (gdbarch
))
586 sp
= push_dummy_code (gdbarch
, sp
, funaddr
,
587 args
, nargs
, target_values_type
,
588 &real_pc
, &bp_addr
, get_current_regcache ());
592 CORE_ADDR dummy_addr
;
595 dummy_addr
= entry_point_address ();
596 /* Make certain that the address points at real code, and not a
597 function descriptor. */
598 dummy_addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
,
601 /* A call dummy always consists of just a single breakpoint, so
602 its address is the same as the address of the dummy. */
603 bp_addr
= dummy_addr
;
607 /* Some executables define a symbol __CALL_DUMMY_ADDRESS whose
608 address is the location where the breakpoint should be
609 placed. Once all targets are using the overhauled frame code
610 this can be deleted - ON_STACK is a better option. */
612 struct minimal_symbol
*sym
;
613 CORE_ADDR dummy_addr
;
615 sym
= lookup_minimal_symbol ("__CALL_DUMMY_ADDRESS", NULL
, NULL
);
618 dummy_addr
= SYMBOL_VALUE_ADDRESS (sym
);
620 dummy_addr
= entry_point_address ();
621 /* Make certain that the address points at real code, and not
622 a function descriptor. */
623 dummy_addr
= gdbarch_convert_from_func_ptr_addr (gdbarch
,
626 /* A call dummy always consists of just a single breakpoint,
627 so it's address is the same as the address of the dummy. */
628 bp_addr
= dummy_addr
;
632 internal_error (__FILE__
, __LINE__
, _("bad switch"));
635 if (nargs
< TYPE_NFIELDS (ftype
))
636 error (_("Too few arguments in function call."));
640 for (i
= nargs
- 1; i
>= 0; i
--)
643 struct type
*param_type
;
645 /* FIXME drow/2002-05-31: Should just always mark methods as
646 prototyped. Can we respect TYPE_VARARGS? Probably not. */
647 if (TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
649 else if (i
< TYPE_NFIELDS (ftype
))
650 prototyped
= TYPE_PROTOTYPED (ftype
);
654 if (i
< TYPE_NFIELDS (ftype
))
655 param_type
= TYPE_FIELD_TYPE (ftype
, i
);
659 args
[i
] = value_arg_coerce (gdbarch
, args
[i
],
660 param_type
, prototyped
, &sp
);
662 if (param_type
!= NULL
&& language_pass_by_reference (param_type
))
663 args
[i
] = value_addr (args
[i
]);
667 /* Reserve space for the return structure to be written on the
668 stack, if necessary. Make certain that the value is correctly
671 if (struct_return
|| lang_struct_return
)
673 int len
= TYPE_LENGTH (values_type
);
674 if (gdbarch_inner_than (gdbarch
, 1, 2))
676 /* Stack grows downward. Align STRUCT_ADDR and SP after
677 making space for the return value. */
679 if (gdbarch_frame_align_p (gdbarch
))
680 sp
= gdbarch_frame_align (gdbarch
, sp
);
685 /* Stack grows upward. Align the frame, allocate space, and
686 then again, re-align the frame??? */
687 if (gdbarch_frame_align_p (gdbarch
))
688 sp
= gdbarch_frame_align (gdbarch
, sp
);
691 if (gdbarch_frame_align_p (gdbarch
))
692 sp
= gdbarch_frame_align (gdbarch
, sp
);
696 if (lang_struct_return
)
698 struct value
**new_args
;
700 /* Add the new argument to the front of the argument list. */
701 new_args
= xmalloc (sizeof (struct value
*) * (nargs
+ 1));
702 new_args
[0] = value_from_pointer (lookup_pointer_type (values_type
),
704 memcpy (&new_args
[1], &args
[0], sizeof (struct value
*) * nargs
);
707 args_cleanup
= make_cleanup (xfree
, args
);
710 args_cleanup
= make_cleanup (null_cleanup
, NULL
);
712 /* Create the dummy stack frame. Pass in the call dummy address as,
713 presumably, the ABI code knows where, in the call dummy, the
714 return address should be pointed. */
715 sp
= gdbarch_push_dummy_call (gdbarch
, function
, get_current_regcache (),
716 bp_addr
, nargs
, args
,
717 sp
, struct_return
, struct_addr
);
719 do_cleanups (args_cleanup
);
721 /* Set up a frame ID for the dummy frame so we can pass it to
722 set_momentary_breakpoint. We need to give the breakpoint a frame
723 ID so that the breakpoint code can correctly re-identify the
725 /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL,
726 saved as the dummy-frame TOS, and used by dummy_id to form
727 the frame ID's stack address. */
728 dummy_id
= frame_id_build (sp
, bp_addr
);
730 /* Create a momentary breakpoint at the return address of the
731 inferior. That way it breaks when it returns. */
734 struct breakpoint
*bpt
;
735 struct symtab_and_line sal
;
736 init_sal (&sal
); /* initialize to zeroes */
738 sal
.section
= find_pc_overlay (sal
.pc
);
739 /* Sanity. The exact same SP value is returned by
740 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
741 dummy_id to form the frame ID's stack address. */
742 bpt
= set_momentary_breakpoint (sal
, dummy_id
, bp_call_dummy
);
743 bpt
->disposition
= disp_del
;
746 /* Create a breakpoint in std::terminate.
747 If a C++ exception is raised in the dummy-frame, and the
748 exception handler is (normally, and expected to be) out-of-frame,
749 the default C++ handler will (wrongly) be called in an inferior
750 function call. This is wrong, as an exception can be normally
751 and legally handled out-of-frame. The confines of the dummy frame
752 prevent the unwinder from finding the correct handler (or any
753 handler, unless it is in-frame). The default handler calls
754 std::terminate. This will kill the inferior. Assert that
755 terminate should never be called in an inferior function
756 call. Place a momentary breakpoint in the std::terminate function
757 and if triggered in the call, rewind. */
758 if (unwind_on_terminating_exception_p
)
760 struct minimal_symbol
*tm
= lookup_minimal_symbol ("std::terminate()",
763 terminate_bp
= set_momentary_breakpoint_at_pc
764 (SYMBOL_VALUE_ADDRESS (tm
), bp_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. */
779 make_cleanup_delete_breakpoint (terminate_bp
);
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
)
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
)
937 /* Check if unwind on terminating exception behaviour is on. */
938 if (unwind_on_terminating_exception_p
)
940 /* Check that the breakpoint is our special std::terminate
941 breakpoint. If it is, we do not want to kill the inferior
942 in an inferior function call. Rewind, and warn the
945 if (terminate_bp
!= NULL
946 && (inferior_thread()->stop_bpstat
->breakpoint_at
->address
947 == terminate_bp
->loc
->address
))
949 /* We must get back to the frame we were before the
951 dummy_frame_pop (dummy_id
);
953 /* We also need to restore inferior status to that before the
955 restore_inferior_status (inf_status
);
958 The program being debugged entered a std::terminate call, most likely\n\
959 caused by an unhandled C++ exception. GDB blocked this call in order\n\
960 to prevent the program from being terminated, and has restored the\n\
961 context to its original state before the call.\n\
962 To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
963 Evaluation of the expression containing the function (%s)\n\
964 will be abandoned."),
968 /* We hit a breakpoint inside the FUNCTION.
969 Keep the dummy frame, the user may want to examine its state.
970 Discard inferior status, we're not at the same point
972 discard_inferior_status (inf_status
);
974 /* The following error message used to say "The expression
975 which contained the function call has been discarded."
976 It is a hard concept to explain in a few words. Ideally,
977 GDB would be able to resume evaluation of the expression
978 when the function finally is done executing. Perhaps
979 someday this will be implemented (it would not be easy). */
980 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
981 a C++ name with arguments and stuff. */
983 The program being debugged stopped while in a function called from GDB.\n\
984 Evaluation of the expression containing the function\n\
985 (%s) will be abandoned.\n\
986 When the function is done executing, GDB will silently stop."),
990 /* The above code errors out, so ... */
991 internal_error (__FILE__
, __LINE__
, _("... should not be here"));
994 /* If we get here the called FUNCTION ran to completion,
995 and the dummy frame has already been popped. */
998 struct regcache
*retbuf
= regcache_xmalloc (gdbarch
);
999 struct cleanup
*retbuf_cleanup
= make_cleanup_regcache_xfree (retbuf
);
1000 struct value
*retval
= NULL
;
1002 regcache_cpy_no_passthrough (retbuf
, stop_registers
);
1004 /* Inferior call is successful. Restore the inferior status.
1005 At this stage, leave the RETBUF alone. */
1006 restore_inferior_status (inf_status
);
1008 /* Figure out the value returned by the function. */
1010 if (lang_struct_return
)
1011 retval
= value_at (values_type
, struct_addr
);
1012 else if (TYPE_CODE (target_values_type
) == TYPE_CODE_VOID
)
1014 /* If the function returns void, don't bother fetching the
1016 retval
= allocate_value (values_type
);
1020 switch (gdbarch_return_value (gdbarch
, value_type (function
),
1021 target_values_type
, NULL
, NULL
, NULL
))
1023 case RETURN_VALUE_REGISTER_CONVENTION
:
1024 case RETURN_VALUE_ABI_RETURNS_ADDRESS
:
1025 case RETURN_VALUE_ABI_PRESERVES_ADDRESS
:
1026 retval
= allocate_value (values_type
);
1027 gdbarch_return_value (gdbarch
, value_type (function
), values_type
,
1028 retbuf
, value_contents_raw (retval
), NULL
);
1030 case RETURN_VALUE_STRUCT_CONVENTION
:
1031 retval
= value_at (values_type
, struct_addr
);
1036 do_cleanups (retbuf_cleanup
);
1038 gdb_assert (retval
);
1044 /* Provide a prototype to silence -Wmissing-prototypes. */
1045 void _initialize_infcall (void);
1048 _initialize_infcall (void)
1050 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure
,
1051 &coerce_float_to_double_p
, _("\
1052 Set coercion of floats to doubles when calling functions."), _("\
1053 Show coercion of floats to doubles when calling functions"), _("\
1054 Variables of type float should generally be converted to doubles before\n\
1055 calling an unprototyped function, and left alone when calling a prototyped\n\
1056 function. However, some older debug info formats do not provide enough\n\
1057 information to determine that a function is prototyped. If this flag is\n\
1058 set, GDB will perform the conversion for a function it considers\n\
1060 The default is to perform the conversion.\n"),
1062 show_coerce_float_to_double_p
,
1063 &setlist
, &showlist
);
1065 add_setshow_boolean_cmd ("unwindonsignal", no_class
,
1066 &unwind_on_signal_p
, _("\
1067 Set unwinding of stack if a signal is received while in a call dummy."), _("\
1068 Show unwinding of stack if a signal is received while in a call dummy."), _("\
1069 The unwindonsignal lets the user determine what gdb should do if a signal\n\
1070 is received while in a function called from gdb (call dummy). If set, gdb\n\
1071 unwinds the stack and restore the context to what as it was before the call.\n\
1072 The default is to stop in the frame where the signal was received."),
1074 show_unwind_on_signal_p
,
1075 &setlist
, &showlist
);
1077 add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class
,
1078 &unwind_on_terminating_exception_p
, _("\
1079 Set unwinding of stack if std::terminate is called while in call dummy."), _("\
1080 Show unwinding of stack if std::terminate() is called while in a call dummy."), _("\
1081 The unwind on terminating exception flag lets the user determine\n\
1082 what gdb should do if a std::terminate() call is made from the\n\
1083 default exception handler. If set, gdb unwinds the stack and restores\n\
1084 the context to what it was before the call. If unset, gdb allows the\n\
1085 std::terminate call to proceed.\n\
1086 The default is to unwind the frame."),
1088 show_unwind_on_terminating_exception_p
,
1089 &setlist
, &showlist
);