1 /* Perform an inferior function call, for GDB, the GNU debugger.
3 Copyright (C) 1986-2014 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "breakpoint.h"
22 #include "tracepoint.h"
34 #include "dummy-frame.h"
36 #include "gdbthread.h"
37 #include "event-top.h"
39 /* If we can't find a function's name from its address,
40 we print this instead. */
41 #define RAW_FUNCTION_ADDRESS_FORMAT "at 0x%s"
42 #define RAW_FUNCTION_ADDRESS_SIZE (sizeof (RAW_FUNCTION_ADDRESS_FORMAT) \
43 + 2 * sizeof (CORE_ADDR))
45 /* NOTE: cagney/2003-04-16: What's the future of this code?
47 GDB needs an asynchronous expression evaluator, that means an
48 asynchronous inferior function call implementation, and that in
49 turn means restructuring the code so that it is event driven. */
51 /* How you should pass arguments to a function depends on whether it
52 was defined in K&R style or prototype style. If you define a
53 function using the K&R syntax that takes a `float' argument, then
54 callers must pass that argument as a `double'. If you define the
55 function using the prototype syntax, then you must pass the
56 argument as a `float', with no promotion.
58 Unfortunately, on certain older platforms, the debug info doesn't
59 indicate reliably how each function was defined. A function type's
60 TYPE_FLAG_PROTOTYPED flag may be clear, even if the function was
61 defined in prototype style. When calling a function whose
62 TYPE_FLAG_PROTOTYPED flag is clear, GDB consults this flag to
65 For modern targets, it is proper to assume that, if the prototype
66 flag is clear, that can be trusted: `float' arguments should be
67 promoted to `double'. For some older targets, if the prototype
68 flag is clear, that doesn't tell us anything. The default is to
69 trust the debug information; the user can override this behavior
70 with "set coerce-float-to-double 0". */
72 static int coerce_float_to_double_p
= 1;
74 show_coerce_float_to_double_p (struct ui_file
*file
, int from_tty
,
75 struct cmd_list_element
*c
, const char *value
)
77 fprintf_filtered (file
,
78 _("Coercion of floats to doubles "
79 "when calling functions is %s.\n"),
83 /* This boolean tells what gdb should do if a signal is received while
84 in a function called from gdb (call dummy). If set, gdb unwinds
85 the stack and restore the context to what as it was before the
88 The default is to stop in the frame where the signal was received. */
90 static int unwind_on_signal_p
= 0;
92 show_unwind_on_signal_p (struct ui_file
*file
, int from_tty
,
93 struct cmd_list_element
*c
, const char *value
)
95 fprintf_filtered (file
,
96 _("Unwinding of stack if a signal is "
97 "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 "
123 "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
);
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
, 0);
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_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 /* Return the return type of a function with its first instruction exactly at
228 the PC address. Return NULL otherwise. */
231 find_function_return_type (CORE_ADDR pc
)
233 struct symbol
*sym
= find_pc_function (pc
);
235 if (sym
!= NULL
&& BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) == pc
236 && SYMBOL_TYPE (sym
) != NULL
)
237 return TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
));
242 /* Determine a function's address and its return type from its value.
243 Calls error() if the function is not valid for calling. */
246 find_function_addr (struct value
*function
, struct type
**retval_type
)
248 struct type
*ftype
= check_typedef (value_type (function
));
249 struct gdbarch
*gdbarch
= get_type_arch (ftype
);
250 struct type
*value_type
= NULL
;
251 /* Initialize it just to avoid a GCC false warning. */
252 CORE_ADDR funaddr
= 0;
254 /* If it's a member function, just look at the function
257 /* Determine address to call. */
258 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
259 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
260 funaddr
= value_address (function
);
261 else if (TYPE_CODE (ftype
) == TYPE_CODE_PTR
)
263 funaddr
= value_as_address (function
);
264 ftype
= check_typedef (TYPE_TARGET_TYPE (ftype
));
265 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
266 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
267 funaddr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, funaddr
,
270 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
271 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
273 value_type
= TYPE_TARGET_TYPE (ftype
);
275 if (TYPE_GNU_IFUNC (ftype
))
277 funaddr
= gnu_ifunc_resolve_addr (gdbarch
, funaddr
);
279 /* Skip querying the function symbol if no RETVAL_TYPE has been
282 value_type
= find_function_return_type (funaddr
);
285 else if (TYPE_CODE (ftype
) == TYPE_CODE_INT
)
287 /* Handle the case of functions lacking debugging info.
288 Their values are characters since their addresses are char. */
289 if (TYPE_LENGTH (ftype
) == 1)
290 funaddr
= value_as_address (value_addr (function
));
293 /* Handle function descriptors lacking debug info. */
294 int found_descriptor
= 0;
296 funaddr
= 0; /* pacify "gcc -Werror" */
297 if (VALUE_LVAL (function
) == lval_memory
)
301 funaddr
= value_as_address (value_addr (function
));
303 funaddr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, funaddr
,
305 if (funaddr
!= nfunaddr
)
306 found_descriptor
= 1;
308 if (!found_descriptor
)
309 /* Handle integer used as address of a function. */
310 funaddr
= (CORE_ADDR
) value_as_long (function
);
314 error (_("Invalid data type for function to be called."));
316 if (retval_type
!= NULL
)
317 *retval_type
= value_type
;
318 return funaddr
+ gdbarch_deprecated_function_start_offset (gdbarch
);
321 /* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called
322 function returns to. */
325 push_dummy_code (struct gdbarch
*gdbarch
,
326 CORE_ADDR sp
, CORE_ADDR funaddr
,
327 struct value
**args
, int nargs
,
328 struct type
*value_type
,
329 CORE_ADDR
*real_pc
, CORE_ADDR
*bp_addr
,
330 struct regcache
*regcache
)
332 gdb_assert (gdbarch_push_dummy_code_p (gdbarch
));
334 return gdbarch_push_dummy_code (gdbarch
, sp
, funaddr
,
335 args
, nargs
, value_type
, real_pc
, bp_addr
,
339 /* Fetch the name of the function at FUNADDR.
340 This is used in printing an error message for call_function_by_hand.
341 BUF is used to print FUNADDR in hex if the function name cannot be
342 determined. It must be large enough to hold formatted result of
343 RAW_FUNCTION_ADDRESS_FORMAT. */
346 get_function_name (CORE_ADDR funaddr
, char *buf
, int buf_size
)
349 struct symbol
*symbol
= find_pc_function (funaddr
);
352 return SYMBOL_PRINT_NAME (symbol
);
356 /* Try the minimal symbols. */
357 struct bound_minimal_symbol msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
360 return MSYMBOL_PRINT_NAME (msymbol
.minsym
);
364 char *tmp
= xstrprintf (_(RAW_FUNCTION_ADDRESS_FORMAT
),
365 hex_string (funaddr
));
367 gdb_assert (strlen (tmp
) + 1 <= buf_size
);
374 /* Subroutine of call_function_by_hand to simplify it.
375 Start up the inferior and wait for it to stop.
376 Return the exception if there's an error, or an exception with
377 reason >= 0 if there's no error.
379 This is done inside a TRY_CATCH so the caller needn't worry about
380 thrown errors. The caller should rethrow if there's an error. */
382 static struct gdb_exception
383 run_inferior_call (struct thread_info
*call_thread
, CORE_ADDR real_pc
)
385 volatile struct gdb_exception e
;
386 int saved_in_infcall
= call_thread
->control
.in_infcall
;
387 ptid_t call_thread_ptid
= call_thread
->ptid
;
388 int saved_sync_execution
= sync_execution
;
390 /* Infcalls run synchronously, in the foreground. */
391 if (target_can_async_p ())
394 call_thread
->control
.in_infcall
= 1;
396 clear_proceed_status (0);
398 disable_watchpoints_before_interactive_call_start ();
400 /* We want stop_registers, please... */
401 call_thread
->control
.proceed_to_finish
= 1;
403 TRY_CATCH (e
, RETURN_MASK_ALL
)
405 int was_sync
= sync_execution
;
407 proceed (real_pc
, GDB_SIGNAL_0
, 0);
409 /* Inferior function calls are always synchronous, even if the
410 target supports asynchronous execution. Do here what
411 `proceed' itself does in sync mode. */
412 if (target_can_async_p ())
414 wait_for_inferior ();
416 /* If GDB was previously in sync execution mode, then ensure
417 that it remains so. normal_stop calls
418 async_enable_stdin, so reset it again here. In other
419 cases, stdin will be re-enabled by
420 inferior_event_handler, when an exception is thrown. */
422 async_disable_stdin ();
426 /* At this point the current thread may have changed. Refresh
427 CALL_THREAD as it could be invalid if its thread has exited. */
428 call_thread
= find_thread_ptid (call_thread_ptid
);
430 enable_watchpoints_after_interactive_call_stop ();
432 /* Call breakpoint_auto_delete on the current contents of the bpstat
433 of inferior call thread.
434 If all error()s out of proceed ended up calling normal_stop
435 (and perhaps they should; it already does in the special case
436 of error out of resume()), then we wouldn't need this. */
439 if (call_thread
!= NULL
)
440 breakpoint_auto_delete (call_thread
->control
.stop_bpstat
);
443 if (call_thread
!= NULL
)
444 call_thread
->control
.in_infcall
= saved_in_infcall
;
446 sync_execution
= saved_sync_execution
;
451 /* A cleanup function that calls delete_std_terminate_breakpoint. */
453 cleanup_delete_std_terminate_breakpoint (void *ignore
)
455 delete_std_terminate_breakpoint ();
458 /* All this stuff with a dummy frame may seem unnecessarily complicated
459 (why not just save registers in GDB?). The purpose of pushing a dummy
460 frame which looks just like a real frame is so that if you call a
461 function and then hit a breakpoint (get a signal, etc), "backtrace"
462 will look right. Whether the backtrace needs to actually show the
463 stack at the time the inferior function was called is debatable, but
464 it certainly needs to not display garbage. So if you are contemplating
465 making dummy frames be different from normal frames, consider that. */
467 /* Perform a function call in the inferior.
468 ARGS is a vector of values of arguments (NARGS of them).
469 FUNCTION is a value, the function to be called.
470 Returns a value representing what the function returned.
471 May fail to return, if a breakpoint or signal is hit
472 during the execution of the function.
474 ARGS is modified to contain coerced values. */
477 call_function_by_hand (struct value
*function
, int nargs
, struct value
**args
)
480 struct type
*values_type
, *target_values_type
;
481 unsigned char struct_return
= 0, hidden_first_param_p
= 0;
482 CORE_ADDR struct_addr
= 0;
483 struct infcall_control_state
*inf_status
;
484 struct cleanup
*inf_status_cleanup
;
485 struct infcall_suspend_state
*caller_state
;
488 struct type
*ftype
= check_typedef (value_type (function
));
490 struct frame_id dummy_id
;
491 struct cleanup
*args_cleanup
;
492 struct frame_info
*frame
;
493 struct gdbarch
*gdbarch
;
494 struct cleanup
*terminate_bp_cleanup
;
495 ptid_t call_thread_ptid
;
496 struct gdb_exception e
;
497 char name_buf
[RAW_FUNCTION_ADDRESS_SIZE
];
498 int stack_temporaries
= thread_stack_temporaries_enabled_p (inferior_ptid
);
500 if (TYPE_CODE (ftype
) == TYPE_CODE_PTR
)
501 ftype
= check_typedef (TYPE_TARGET_TYPE (ftype
));
503 if (!target_has_execution
)
506 if (get_traceframe_number () >= 0)
507 error (_("May not call functions while looking at trace frames."));
509 if (execution_direction
== EXEC_REVERSE
)
510 error (_("Cannot call functions in reverse mode."));
512 frame
= get_current_frame ();
513 gdbarch
= get_frame_arch (frame
);
515 if (!gdbarch_push_dummy_call_p (gdbarch
))
516 error (_("This target does not support function calls."));
518 /* A cleanup for the inferior status.
519 This is only needed while we're preparing the inferior function call. */
520 inf_status
= save_infcall_control_state ();
522 = make_cleanup_restore_infcall_control_state (inf_status
);
524 /* Save the caller's registers and other state associated with the
525 inferior itself so that they can be restored once the
526 callee returns. To allow nested calls the registers are (further
527 down) pushed onto a dummy frame stack. Include a cleanup (which
528 is tossed once the regcache has been pushed). */
529 caller_state
= save_infcall_suspend_state ();
530 make_cleanup_restore_infcall_suspend_state (caller_state
);
532 /* Ensure that the initial SP is correctly aligned. */
534 CORE_ADDR old_sp
= get_frame_sp (frame
);
536 if (gdbarch_frame_align_p (gdbarch
))
538 sp
= gdbarch_frame_align (gdbarch
, old_sp
);
539 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
540 ABIs, a function can use memory beyond the inner most stack
541 address. AMD64 called that region the "red zone". Skip at
542 least the "red zone" size before allocating any space on
544 if (gdbarch_inner_than (gdbarch
, 1, 2))
545 sp
-= gdbarch_frame_red_zone_size (gdbarch
);
547 sp
+= gdbarch_frame_red_zone_size (gdbarch
);
549 gdb_assert (sp
== gdbarch_frame_align (gdbarch
, sp
));
550 /* NOTE: cagney/2002-09-18:
552 On a RISC architecture, a void parameterless generic dummy
553 frame (i.e., no parameters, no result) typically does not
554 need to push anything the stack and hence can leave SP and
555 FP. Similarly, a frameless (possibly leaf) function does
556 not push anything on the stack and, hence, that too can
557 leave FP and SP unchanged. As a consequence, a sequence of
558 void parameterless generic dummy frame calls to frameless
559 functions will create a sequence of effectively identical
560 frames (SP, FP and TOS and PC the same). This, not
561 suprisingly, results in what appears to be a stack in an
562 infinite loop --- when GDB tries to find a generic dummy
563 frame on the internal dummy frame stack, it will always
566 To avoid this problem, the code below always grows the
567 stack. That way, two dummy frames can never be identical.
568 It does burn a few bytes of stack but that is a small price
572 if (gdbarch_inner_than (gdbarch
, 1, 2))
573 /* Stack grows down. */
574 sp
= gdbarch_frame_align (gdbarch
, old_sp
- 1);
576 /* Stack grows up. */
577 sp
= gdbarch_frame_align (gdbarch
, old_sp
+ 1);
579 /* SP may have underflown address zero here from OLD_SP. Memory access
580 functions will probably fail in such case but that is a target's
584 /* FIXME: cagney/2002-09-18: Hey, you loose!
586 Who knows how badly aligned the SP is!
588 If the generic dummy frame ends up empty (because nothing is
589 pushed) GDB won't be able to correctly perform back traces.
590 If a target is having trouble with backtraces, first thing to
591 do is add FRAME_ALIGN() to the architecture vector. If that
592 fails, try dummy_id().
594 If the ABI specifies a "Red Zone" (see the doco) the code
595 below will quietly trash it. */
598 /* Skip over the stack temporaries that might have been generated during
599 the evaluation of an expression. */
600 if (stack_temporaries
)
602 struct value
*lastval
;
604 lastval
= get_last_thread_stack_temporary (inferior_ptid
);
607 CORE_ADDR lastval_addr
= value_address (lastval
);
609 if (gdbarch_inner_than (gdbarch
, 1, 2))
611 gdb_assert (sp
>= lastval_addr
);
616 gdb_assert (sp
<= lastval_addr
);
617 sp
= lastval_addr
+ TYPE_LENGTH (value_type (lastval
));
620 if (gdbarch_frame_align_p (gdbarch
))
621 sp
= gdbarch_frame_align (gdbarch
, sp
);
626 funaddr
= find_function_addr (function
, &values_type
);
628 values_type
= builtin_type (gdbarch
)->builtin_int
;
630 CHECK_TYPEDEF (values_type
);
632 /* Are we returning a value using a structure return (passing a
633 hidden argument pointing to storage) or a normal value return?
634 There are two cases: language-mandated structure return and
635 target ABI structure return. The variable STRUCT_RETURN only
636 describes the latter. The language version is handled by passing
637 the return location as the first parameter to the function,
638 even preceding "this". This is different from the target
639 ABI version, which is target-specific; for instance, on ia64
640 the first argument is passed in out0 but the hidden structure
641 return pointer would normally be passed in r8. */
643 if (gdbarch_return_in_first_hidden_param_p (gdbarch
, values_type
))
645 hidden_first_param_p
= 1;
647 /* Tell the target specific argument pushing routine not to
649 target_values_type
= builtin_type (gdbarch
)->builtin_void
;
653 struct_return
= using_struct_return (gdbarch
, function
, values_type
);
654 target_values_type
= values_type
;
657 /* Determine the location of the breakpoint (and possibly other
658 stuff) that the called function will return to. The SPARC, for a
659 function returning a structure or union, needs to make space for
660 not just the breakpoint but also an extra word containing the
661 size (?) of the structure being passed. */
663 switch (gdbarch_call_dummy_location (gdbarch
))
667 const gdb_byte
*bp_bytes
;
668 CORE_ADDR bp_addr_as_address
;
671 /* Be careful BP_ADDR is in inferior PC encoding while
672 BP_ADDR_AS_ADDRESS is a plain memory address. */
674 sp
= push_dummy_code (gdbarch
, sp
, funaddr
, args
, nargs
,
675 target_values_type
, &real_pc
, &bp_addr
,
676 get_current_regcache ());
678 /* Write a legitimate instruction at the point where the infcall
679 breakpoint is going to be inserted. While this instruction
680 is never going to be executed, a user investigating the
681 memory from GDB would see this instruction instead of random
682 uninitialized bytes. We chose the breakpoint instruction
683 as it may look as the most logical one to the user and also
684 valgrind 3.7.0 needs it for proper vgdb inferior calls.
686 If software breakpoints are unsupported for this target we
687 leave the user visible memory content uninitialized. */
689 bp_addr_as_address
= bp_addr
;
690 bp_bytes
= gdbarch_breakpoint_from_pc (gdbarch
, &bp_addr_as_address
,
692 if (bp_bytes
!= NULL
)
693 write_memory (bp_addr_as_address
, bp_bytes
, bp_size
);
698 CORE_ADDR dummy_addr
;
701 dummy_addr
= entry_point_address ();
703 /* A call dummy always consists of just a single breakpoint, so
704 its address is the same as the address of the dummy.
706 The actual breakpoint is inserted separatly so there is no need to
708 bp_addr
= dummy_addr
;
712 internal_error (__FILE__
, __LINE__
, _("bad switch"));
715 if (nargs
< TYPE_NFIELDS (ftype
))
716 error (_("Too few arguments in function call."));
721 for (i
= nargs
- 1; i
>= 0; i
--)
724 struct type
*param_type
;
726 /* FIXME drow/2002-05-31: Should just always mark methods as
727 prototyped. Can we respect TYPE_VARARGS? Probably not. */
728 if (TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
730 else if (i
< TYPE_NFIELDS (ftype
))
731 prototyped
= TYPE_PROTOTYPED (ftype
);
735 if (i
< TYPE_NFIELDS (ftype
))
736 param_type
= TYPE_FIELD_TYPE (ftype
, i
);
740 args
[i
] = value_arg_coerce (gdbarch
, args
[i
],
741 param_type
, prototyped
, &sp
);
743 if (param_type
!= NULL
&& language_pass_by_reference (param_type
))
744 args
[i
] = value_addr (args
[i
]);
748 /* Reserve space for the return structure to be written on the
749 stack, if necessary. Make certain that the value is correctly
752 While evaluating expressions, we reserve space on the stack for
753 return values of class type even if the language ABI and the target
754 ABI do not require that the return value be passed as a hidden first
755 argument. This is because we want to store the return value as an
756 on-stack temporary while the expression is being evaluated. This
757 enables us to have chained function calls in expressions.
759 Keeping the return values as on-stack temporaries while the expression
760 is being evaluated is OK because the thread is stopped until the
761 expression is completely evaluated. */
763 if (struct_return
|| hidden_first_param_p
764 || (stack_temporaries
&& class_or_union_p (values_type
)))
766 if (gdbarch_inner_than (gdbarch
, 1, 2))
768 /* Stack grows downward. Align STRUCT_ADDR and SP after
769 making space for the return value. */
770 sp
-= TYPE_LENGTH (values_type
);
771 if (gdbarch_frame_align_p (gdbarch
))
772 sp
= gdbarch_frame_align (gdbarch
, sp
);
777 /* Stack grows upward. Align the frame, allocate space, and
778 then again, re-align the frame??? */
779 if (gdbarch_frame_align_p (gdbarch
))
780 sp
= gdbarch_frame_align (gdbarch
, sp
);
782 sp
+= TYPE_LENGTH (values_type
);
783 if (gdbarch_frame_align_p (gdbarch
))
784 sp
= gdbarch_frame_align (gdbarch
, sp
);
788 if (hidden_first_param_p
)
790 struct value
**new_args
;
792 /* Add the new argument to the front of the argument list. */
793 new_args
= xmalloc (sizeof (struct value
*) * (nargs
+ 1));
794 new_args
[0] = value_from_pointer (lookup_pointer_type (values_type
),
796 memcpy (&new_args
[1], &args
[0], sizeof (struct value
*) * nargs
);
799 args_cleanup
= make_cleanup (xfree
, args
);
802 args_cleanup
= make_cleanup (null_cleanup
, NULL
);
804 /* Create the dummy stack frame. Pass in the call dummy address as,
805 presumably, the ABI code knows where, in the call dummy, the
806 return address should be pointed. */
807 sp
= gdbarch_push_dummy_call (gdbarch
, function
, get_current_regcache (),
808 bp_addr
, nargs
, args
,
809 sp
, struct_return
, struct_addr
);
811 do_cleanups (args_cleanup
);
813 /* Set up a frame ID for the dummy frame so we can pass it to
814 set_momentary_breakpoint. We need to give the breakpoint a frame
815 ID so that the breakpoint code can correctly re-identify the
817 /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL,
818 saved as the dummy-frame TOS, and used by dummy_id to form
819 the frame ID's stack address. */
820 dummy_id
= frame_id_build (sp
, bp_addr
);
822 /* Create a momentary breakpoint at the return address of the
823 inferior. That way it breaks when it returns. */
826 struct breakpoint
*bpt
, *longjmp_b
;
827 struct symtab_and_line sal
;
829 init_sal (&sal
); /* initialize to zeroes */
830 sal
.pspace
= current_program_space
;
832 sal
.section
= find_pc_overlay (sal
.pc
);
833 /* Sanity. The exact same SP value is returned by
834 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
835 dummy_id to form the frame ID's stack address. */
836 bpt
= set_momentary_breakpoint (gdbarch
, sal
, dummy_id
, bp_call_dummy
);
838 /* set_momentary_breakpoint invalidates FRAME. */
841 bpt
->disposition
= disp_del
;
842 gdb_assert (bpt
->related_breakpoint
== bpt
);
844 longjmp_b
= set_longjmp_breakpoint_for_call_dummy ();
847 /* Link BPT into the chain of LONGJMP_B. */
848 bpt
->related_breakpoint
= longjmp_b
;
849 while (longjmp_b
->related_breakpoint
!= bpt
->related_breakpoint
)
850 longjmp_b
= longjmp_b
->related_breakpoint
;
851 longjmp_b
->related_breakpoint
= bpt
;
855 /* Create a breakpoint in std::terminate.
856 If a C++ exception is raised in the dummy-frame, and the
857 exception handler is (normally, and expected to be) out-of-frame,
858 the default C++ handler will (wrongly) be called in an inferior
859 function call. This is wrong, as an exception can be normally
860 and legally handled out-of-frame. The confines of the dummy frame
861 prevent the unwinder from finding the correct handler (or any
862 handler, unless it is in-frame). The default handler calls
863 std::terminate. This will kill the inferior. Assert that
864 terminate should never be called in an inferior function
865 call. Place a momentary breakpoint in the std::terminate function
866 and if triggered in the call, rewind. */
867 if (unwind_on_terminating_exception_p
)
868 set_std_terminate_breakpoint ();
870 /* Everything's ready, push all the info needed to restore the
871 caller (and identify the dummy-frame) onto the dummy-frame
873 dummy_frame_push (caller_state
, &dummy_id
, inferior_ptid
);
875 /* Discard both inf_status and caller_state cleanups.
876 From this point on we explicitly restore the associated state
878 discard_cleanups (inf_status_cleanup
);
880 /* Register a clean-up for unwind_on_terminating_exception_breakpoint. */
881 terminate_bp_cleanup
= make_cleanup (cleanup_delete_std_terminate_breakpoint
,
884 /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP -
885 If you're looking to implement asynchronous dummy-frames, then
886 just below is the place to chop this function in two.. */
888 /* TP is invalid after run_inferior_call returns, so enclose this
889 in a block so that it's only in scope during the time it's valid. */
891 struct thread_info
*tp
= inferior_thread ();
893 /* Save this thread's ptid, we need it later but the thread
895 call_thread_ptid
= tp
->ptid
;
897 /* Run the inferior until it stops. */
899 e
= run_inferior_call (tp
, real_pc
);
902 /* Rethrow an error if we got one trying to run the inferior. */
906 const char *name
= get_function_name (funaddr
,
907 name_buf
, sizeof (name_buf
));
909 discard_infcall_control_state (inf_status
);
911 /* We could discard the dummy frame here if the program exited,
912 but it will get garbage collected the next time the program is
918 throw_error (e
.error
, _("%s\n\
919 An error occurred while in a function called from GDB.\n\
920 Evaluation of the expression containing the function\n\
921 (%s) will be abandoned.\n\
922 When the function is done executing, GDB will silently stop."),
930 /* If the program has exited, or we stopped at a different thread,
931 exit and inform the user. */
933 if (! target_has_execution
)
935 const char *name
= get_function_name (funaddr
,
936 name_buf
, sizeof (name_buf
));
938 /* If we try to restore the inferior status,
939 we'll crash as the inferior is no longer running. */
940 discard_infcall_control_state (inf_status
);
942 /* We could discard the dummy frame here given that the program exited,
943 but it will get garbage collected the next time the program is
946 error (_("The program being debugged exited while in a function "
948 "Evaluation of the expression containing the function\n"
949 "(%s) will be abandoned."),
953 if (! ptid_equal (call_thread_ptid
, inferior_ptid
))
955 const char *name
= get_function_name (funaddr
,
956 name_buf
, sizeof (name_buf
));
958 /* We've switched threads. This can happen if another thread gets a
959 signal or breakpoint while our thread was running.
960 There's no point in restoring the inferior status,
961 we're in a different thread. */
962 discard_infcall_control_state (inf_status
);
963 /* Keep the dummy frame record, if the user switches back to the
964 thread with the hand-call, we'll need it. */
965 if (stopped_by_random_signal
)
967 The program received a signal in another thread while\n\
968 making a function call from GDB.\n\
969 Evaluation of the expression containing the function\n\
970 (%s) will be abandoned.\n\
971 When the function is done executing, GDB will silently stop."),
975 The program stopped in another thread while making a function call from GDB.\n\
976 Evaluation of the expression containing the function\n\
977 (%s) will be abandoned.\n\
978 When the function is done executing, GDB will silently stop."),
982 if (stopped_by_random_signal
|| stop_stack_dummy
!= STOP_STACK_DUMMY
)
984 const char *name
= get_function_name (funaddr
,
985 name_buf
, sizeof (name_buf
));
987 if (stopped_by_random_signal
)
989 /* We stopped inside the FUNCTION because of a random
990 signal. Further execution of the FUNCTION is not
993 if (unwind_on_signal_p
)
995 /* The user wants the context restored. */
997 /* We must get back to the frame we were before the
999 dummy_frame_pop (dummy_id
, call_thread_ptid
);
1001 /* We also need to restore inferior status to that before the
1003 restore_infcall_control_state (inf_status
);
1005 /* FIXME: Insert a bunch of wrap_here; name can be very
1006 long if it's a C++ name with arguments and stuff. */
1008 The program being debugged was signaled while in a function called from GDB.\n\
1009 GDB has restored the context to what it was before the call.\n\
1010 To change this behavior use \"set unwindonsignal off\".\n\
1011 Evaluation of the expression containing the function\n\
1012 (%s) will be abandoned."),
1017 /* The user wants to stay in the frame where we stopped
1019 Discard inferior status, we're not at the same point
1021 discard_infcall_control_state (inf_status
);
1023 /* FIXME: Insert a bunch of wrap_here; name can be very
1024 long if it's a C++ name with arguments and stuff. */
1026 The program being debugged was signaled while in a function called from GDB.\n\
1027 GDB remains in the frame where the signal was received.\n\
1028 To change this behavior use \"set unwindonsignal on\".\n\
1029 Evaluation of the expression containing the function\n\
1030 (%s) will be abandoned.\n\
1031 When the function is done executing, GDB will silently stop."),
1036 if (stop_stack_dummy
== STOP_STD_TERMINATE
)
1038 /* We must get back to the frame we were before the dummy
1040 dummy_frame_pop (dummy_id
, call_thread_ptid
);
1042 /* We also need to restore inferior status to that before
1044 restore_infcall_control_state (inf_status
);
1047 The program being debugged entered a std::terminate call, most likely\n\
1048 caused by an unhandled C++ exception. GDB blocked this call in order\n\
1049 to prevent the program from being terminated, and has restored the\n\
1050 context to its original state before the call.\n\
1051 To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
1052 Evaluation of the expression containing the function (%s)\n\
1053 will be abandoned."),
1056 else if (stop_stack_dummy
== STOP_NONE
)
1059 /* We hit a breakpoint inside the FUNCTION.
1060 Keep the dummy frame, the user may want to examine its state.
1061 Discard inferior status, we're not at the same point
1063 discard_infcall_control_state (inf_status
);
1065 /* The following error message used to say "The expression
1066 which contained the function call has been discarded."
1067 It is a hard concept to explain in a few words. Ideally,
1068 GDB would be able to resume evaluation of the expression
1069 when the function finally is done executing. Perhaps
1070 someday this will be implemented (it would not be easy). */
1071 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1072 a C++ name with arguments and stuff. */
1074 The program being debugged stopped while in a function called from GDB.\n\
1075 Evaluation of the expression containing the function\n\
1076 (%s) will be abandoned.\n\
1077 When the function is done executing, GDB will silently stop."),
1081 /* The above code errors out, so ... */
1082 internal_error (__FILE__
, __LINE__
, _("... should not be here"));
1085 do_cleanups (terminate_bp_cleanup
);
1087 /* If we get here the called FUNCTION ran to completion,
1088 and the dummy frame has already been popped. */
1091 struct address_space
*aspace
= get_regcache_aspace (stop_registers
);
1092 struct regcache
*retbuf
= regcache_xmalloc (gdbarch
, aspace
);
1093 struct cleanup
*retbuf_cleanup
= make_cleanup_regcache_xfree (retbuf
);
1094 struct value
*retval
= NULL
;
1096 regcache_cpy_no_passthrough (retbuf
, stop_registers
);
1098 /* Inferior call is successful. Restore the inferior status.
1099 At this stage, leave the RETBUF alone. */
1100 restore_infcall_control_state (inf_status
);
1102 if (TYPE_CODE (values_type
) == TYPE_CODE_VOID
)
1103 retval
= allocate_value (values_type
);
1104 else if (struct_return
|| hidden_first_param_p
)
1106 if (stack_temporaries
)
1108 retval
= value_from_contents_and_address (values_type
, NULL
,
1110 push_thread_stack_temporary (inferior_ptid
, retval
);
1114 retval
= allocate_value (values_type
);
1115 read_value_memory (retval
, 0, 1, struct_addr
,
1116 value_contents_raw (retval
),
1117 TYPE_LENGTH (values_type
));
1122 retval
= allocate_value (values_type
);
1123 gdbarch_return_value (gdbarch
, function
, values_type
,
1124 retbuf
, value_contents_raw (retval
), NULL
);
1125 if (stack_temporaries
&& class_or_union_p (values_type
))
1127 /* Values of class type returned in registers are copied onto
1128 the stack and their lval_type set to lval_memory. This is
1129 required because further evaluation of the expression
1130 could potentially invoke methods on the return value
1131 requiring GDB to evaluate the "this" pointer. To evaluate
1132 the this pointer, GDB needs the memory address of the
1134 value_force_lval (retval
, struct_addr
);
1135 push_thread_stack_temporary (inferior_ptid
, retval
);
1139 do_cleanups (retbuf_cleanup
);
1141 gdb_assert (retval
);
1147 /* Provide a prototype to silence -Wmissing-prototypes. */
1148 void _initialize_infcall (void);
1151 _initialize_infcall (void)
1153 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure
,
1154 &coerce_float_to_double_p
, _("\
1155 Set coercion of floats to doubles when calling functions."), _("\
1156 Show coercion of floats to doubles when calling functions"), _("\
1157 Variables of type float should generally be converted to doubles before\n\
1158 calling an unprototyped function, and left alone when calling a prototyped\n\
1159 function. However, some older debug info formats do not provide enough\n\
1160 information to determine that a function is prototyped. If this flag is\n\
1161 set, GDB will perform the conversion for a function it considers\n\
1163 The default is to perform the conversion.\n"),
1165 show_coerce_float_to_double_p
,
1166 &setlist
, &showlist
);
1168 add_setshow_boolean_cmd ("unwindonsignal", no_class
,
1169 &unwind_on_signal_p
, _("\
1170 Set unwinding of stack if a signal is received while in a call dummy."), _("\
1171 Show unwinding of stack if a signal is received while in a call dummy."), _("\
1172 The unwindonsignal lets the user determine what gdb should do if a signal\n\
1173 is received while in a function called from gdb (call dummy). If set, gdb\n\
1174 unwinds the stack and restore the context to what as it was before the call.\n\
1175 The default is to stop in the frame where the signal was received."),
1177 show_unwind_on_signal_p
,
1178 &setlist
, &showlist
);
1180 add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class
,
1181 &unwind_on_terminating_exception_p
, _("\
1182 Set unwinding of stack if std::terminate is called while in call dummy."), _("\
1183 Show unwinding of stack if std::terminate() is called while in a call dummy."),
1185 The unwind on terminating exception flag lets the user determine\n\
1186 what gdb should do if a std::terminate() call is made from the\n\
1187 default exception handler. If set, gdb unwinds the stack and restores\n\
1188 the context to what it was before the call. If unset, gdb allows the\n\
1189 std::terminate call to proceed.\n\
1190 The default is to unwind the frame."),
1192 show_unwind_on_terminating_exception_p
,
1193 &setlist
, &showlist
);