1 /* Perform an inferior function call, for GDB, the GNU debugger.
3 Copyright (C) 1986-2018 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/>. */
22 #include "breakpoint.h"
23 #include "tracepoint.h"
34 #include "dummy-frame.h"
36 #include "gdbthread.h"
37 #include "event-top.h"
38 #include "observable.h"
41 #include "thread-fsm.h"
44 /* If we can't find a function's name from its address,
45 we print this instead. */
46 #define RAW_FUNCTION_ADDRESS_FORMAT "at 0x%s"
47 #define RAW_FUNCTION_ADDRESS_SIZE (sizeof (RAW_FUNCTION_ADDRESS_FORMAT) \
48 + 2 * sizeof (CORE_ADDR))
50 /* NOTE: cagney/2003-04-16: What's the future of this code?
52 GDB needs an asynchronous expression evaluator, that means an
53 asynchronous inferior function call implementation, and that in
54 turn means restructuring the code so that it is event driven. */
56 /* How you should pass arguments to a function depends on whether it
57 was defined in K&R style or prototype style. If you define a
58 function using the K&R syntax that takes a `float' argument, then
59 callers must pass that argument as a `double'. If you define the
60 function using the prototype syntax, then you must pass the
61 argument as a `float', with no promotion.
63 Unfortunately, on certain older platforms, the debug info doesn't
64 indicate reliably how each function was defined. A function type's
65 TYPE_PROTOTYPED flag may be clear, even if the function was defined
66 in prototype style. When calling a function whose TYPE_PROTOTYPED
67 flag is clear, GDB consults this flag to decide what to do.
69 For modern targets, it is proper to assume that, if the prototype
70 flag is clear, that can be trusted: `float' arguments should be
71 promoted to `double'. For some older targets, if the prototype
72 flag is clear, that doesn't tell us anything. The default is to
73 trust the debug information; the user can override this behavior
74 with "set coerce-float-to-double 0". */
76 static int coerce_float_to_double_p
= 1;
78 show_coerce_float_to_double_p (struct ui_file
*file
, int from_tty
,
79 struct cmd_list_element
*c
, const char *value
)
81 fprintf_filtered (file
,
82 _("Coercion of floats to doubles "
83 "when calling functions is %s.\n"),
87 /* This boolean tells what gdb should do if a signal is received while
88 in a function called from gdb (call dummy). If set, gdb unwinds
89 the stack and restore the context to what as it was before the
92 The default is to stop in the frame where the signal was received. */
94 static int unwind_on_signal_p
= 0;
96 show_unwind_on_signal_p (struct ui_file
*file
, int from_tty
,
97 struct cmd_list_element
*c
, const char *value
)
99 fprintf_filtered (file
,
100 _("Unwinding of stack if a signal is "
101 "received while in a call dummy is %s.\n"),
105 /* This boolean tells what gdb should do if a std::terminate call is
106 made while in a function called from gdb (call dummy).
107 As the confines of a single dummy stack prohibit out-of-frame
108 handlers from handling a raised exception, and as out-of-frame
109 handlers are common in C++, this can lead to no handler being found
110 by the unwinder, and a std::terminate call. This is a false positive.
111 If set, gdb unwinds the stack and restores the context to what it
114 The default is to unwind the frame if a std::terminate call is
117 static int unwind_on_terminating_exception_p
= 1;
120 show_unwind_on_terminating_exception_p (struct ui_file
*file
, int from_tty
,
121 struct cmd_list_element
*c
,
125 fprintf_filtered (file
,
126 _("Unwind stack if a C++ exception is "
127 "unhandled while in a call dummy is %s.\n"),
131 /* Perform the standard coercions that are specified
132 for arguments to be passed to C or Ada functions.
134 If PARAM_TYPE is non-NULL, it is the expected parameter type.
135 IS_PROTOTYPED is non-zero if the function declaration is prototyped.
136 SP is the stack pointer were additional data can be pushed (updating
137 its value as needed). */
139 static struct value
*
140 value_arg_coerce (struct gdbarch
*gdbarch
, struct value
*arg
,
141 struct type
*param_type
, int is_prototyped
, CORE_ADDR
*sp
)
143 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
144 struct type
*arg_type
= check_typedef (value_type (arg
));
146 = param_type
? check_typedef (param_type
) : arg_type
;
148 /* Perform any Ada-specific coercion first. */
149 if (current_language
->la_language
== language_ada
)
150 arg
= ada_convert_actual (arg
, type
);
152 /* Force the value to the target if we will need its address. At
153 this point, we could allocate arguments on the stack instead of
154 calling malloc if we knew that their addresses would not be
155 saved by the called function. */
156 arg
= value_coerce_to_target (arg
);
158 switch (TYPE_CODE (type
))
161 case TYPE_CODE_RVALUE_REF
:
163 struct value
*new_value
;
165 if (TYPE_IS_REFERENCE (arg_type
))
166 return value_cast_pointers (type
, arg
, 0);
168 /* Cast the value to the reference's target type, and then
169 convert it back to a reference. This will issue an error
170 if the value was not previously in memory - in some cases
171 we should clearly be allowing this, but how? */
172 new_value
= value_cast (TYPE_TARGET_TYPE (type
), arg
);
173 new_value
= value_ref (new_value
, TYPE_CODE (type
));
180 /* If we don't have a prototype, coerce to integer type if necessary. */
183 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin
->builtin_int
))
184 type
= builtin
->builtin_int
;
186 /* Currently all target ABIs require at least the width of an integer
187 type for an argument. We may have to conditionalize the following
188 type coercion for future targets. */
189 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin
->builtin_int
))
190 type
= builtin
->builtin_int
;
193 if (!is_prototyped
&& coerce_float_to_double_p
)
195 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin
->builtin_double
))
196 type
= builtin
->builtin_double
;
197 else if (TYPE_LENGTH (type
) > TYPE_LENGTH (builtin
->builtin_double
))
198 type
= builtin
->builtin_long_double
;
202 type
= lookup_pointer_type (type
);
204 case TYPE_CODE_ARRAY
:
205 /* Arrays are coerced to pointers to their first element, unless
206 they are vectors, in which case we want to leave them alone,
207 because they are passed by value. */
208 if (current_language
->c_style_arrays
)
209 if (!TYPE_VECTOR (type
))
210 type
= lookup_pointer_type (TYPE_TARGET_TYPE (type
));
212 case TYPE_CODE_UNDEF
:
214 case TYPE_CODE_STRUCT
:
215 case TYPE_CODE_UNION
:
218 case TYPE_CODE_RANGE
:
219 case TYPE_CODE_STRING
:
220 case TYPE_CODE_ERROR
:
221 case TYPE_CODE_MEMBERPTR
:
222 case TYPE_CODE_METHODPTR
:
223 case TYPE_CODE_METHOD
:
224 case TYPE_CODE_COMPLEX
:
229 return value_cast (type
, arg
);
235 find_function_addr (struct value
*function
,
236 struct type
**retval_type
,
237 struct type
**function_type
)
239 struct type
*ftype
= check_typedef (value_type (function
));
240 struct gdbarch
*gdbarch
= get_type_arch (ftype
);
241 struct type
*value_type
= NULL
;
242 /* Initialize it just to avoid a GCC false warning. */
243 CORE_ADDR funaddr
= 0;
245 /* If it's a member function, just look at the function
248 /* Determine address to call. */
249 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
250 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
251 funaddr
= value_address (function
);
252 else if (TYPE_CODE (ftype
) == TYPE_CODE_PTR
)
254 funaddr
= value_as_address (function
);
255 ftype
= check_typedef (TYPE_TARGET_TYPE (ftype
));
256 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
257 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
258 funaddr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, funaddr
,
259 current_top_target ());
261 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
262 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
264 if (TYPE_GNU_IFUNC (ftype
))
266 CORE_ADDR resolver_addr
= funaddr
;
268 /* Resolve the ifunc. Note this may call the resolver
269 function in the inferior. */
270 funaddr
= gnu_ifunc_resolve_addr (gdbarch
, resolver_addr
);
272 /* Skip querying the function symbol if no RETVAL_TYPE or
273 FUNCTION_TYPE have been asked for. */
274 if (retval_type
!= NULL
|| function_type
!= NULL
)
276 type
*target_ftype
= find_function_type (funaddr
);
277 /* If we don't have debug info for the target function,
278 see if we can instead extract the target function's
279 type from the type that the resolver returns. */
280 if (target_ftype
== NULL
)
281 target_ftype
= find_gnu_ifunc_target_type (resolver_addr
);
282 if (target_ftype
!= NULL
)
284 value_type
= TYPE_TARGET_TYPE (check_typedef (target_ftype
));
285 ftype
= target_ftype
;
290 value_type
= TYPE_TARGET_TYPE (ftype
);
292 else if (TYPE_CODE (ftype
) == TYPE_CODE_INT
)
294 /* Handle the case of functions lacking debugging info.
295 Their values are characters since their addresses are char. */
296 if (TYPE_LENGTH (ftype
) == 1)
297 funaddr
= value_as_address (value_addr (function
));
300 /* Handle function descriptors lacking debug info. */
301 int found_descriptor
= 0;
303 funaddr
= 0; /* pacify "gcc -Werror" */
304 if (VALUE_LVAL (function
) == lval_memory
)
308 funaddr
= value_as_address (value_addr (function
));
311 = gdbarch_convert_from_func_ptr_addr (gdbarch
, funaddr
,
312 current_top_target ());
313 if (funaddr
!= nfunaddr
)
314 found_descriptor
= 1;
316 if (!found_descriptor
)
317 /* Handle integer used as address of a function. */
318 funaddr
= (CORE_ADDR
) value_as_long (function
);
322 error (_("Invalid data type for function to be called."));
324 if (retval_type
!= NULL
)
325 *retval_type
= value_type
;
326 if (function_type
!= NULL
)
327 *function_type
= ftype
;
328 return funaddr
+ gdbarch_deprecated_function_start_offset (gdbarch
);
331 /* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called
332 function returns to. */
335 push_dummy_code (struct gdbarch
*gdbarch
,
336 CORE_ADDR sp
, CORE_ADDR funaddr
,
337 struct value
**args
, int nargs
,
338 struct type
*value_type
,
339 CORE_ADDR
*real_pc
, CORE_ADDR
*bp_addr
,
340 struct regcache
*regcache
)
342 gdb_assert (gdbarch_push_dummy_code_p (gdbarch
));
344 return gdbarch_push_dummy_code (gdbarch
, sp
, funaddr
,
345 args
, nargs
, value_type
, real_pc
, bp_addr
,
352 error_call_unknown_return_type (const char *func_name
)
354 if (func_name
!= NULL
)
355 error (_("'%s' has unknown return type; "
356 "cast the call to its declared return type"),
359 error (_("function has unknown return type; "
360 "cast the call to its declared return type"));
363 /* Fetch the name of the function at FUNADDR.
364 This is used in printing an error message for call_function_by_hand.
365 BUF is used to print FUNADDR in hex if the function name cannot be
366 determined. It must be large enough to hold formatted result of
367 RAW_FUNCTION_ADDRESS_FORMAT. */
370 get_function_name (CORE_ADDR funaddr
, char *buf
, int buf_size
)
373 struct symbol
*symbol
= find_pc_function (funaddr
);
376 return SYMBOL_PRINT_NAME (symbol
);
380 /* Try the minimal symbols. */
381 struct bound_minimal_symbol msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
384 return MSYMBOL_PRINT_NAME (msymbol
.minsym
);
388 char *tmp
= xstrprintf (_(RAW_FUNCTION_ADDRESS_FORMAT
),
389 hex_string (funaddr
));
391 gdb_assert (strlen (tmp
) + 1 <= buf_size
);
398 /* All the meta data necessary to extract the call's return value. */
400 struct call_return_meta_info
402 /* The caller frame's architecture. */
403 struct gdbarch
*gdbarch
;
405 /* The called function. */
406 struct value
*function
;
408 /* The return value's type. */
409 struct type
*value_type
;
411 /* Are we returning a value using a structure return or a normal
415 /* If using a structure return, this is the structure's address. */
416 CORE_ADDR struct_addr
;
419 /* Extract the called function's return value. */
421 static struct value
*
422 get_call_return_value (struct call_return_meta_info
*ri
)
424 struct value
*retval
= NULL
;
425 thread_info
*thr
= inferior_thread ();
426 bool stack_temporaries
= thread_stack_temporaries_enabled_p (thr
);
428 if (TYPE_CODE (ri
->value_type
) == TYPE_CODE_VOID
)
429 retval
= allocate_value (ri
->value_type
);
430 else if (ri
->struct_return_p
)
432 if (stack_temporaries
)
434 retval
= value_from_contents_and_address (ri
->value_type
, NULL
,
436 push_thread_stack_temporary (thr
, retval
);
440 retval
= allocate_value (ri
->value_type
);
441 read_value_memory (retval
, 0, 1, ri
->struct_addr
,
442 value_contents_raw (retval
),
443 TYPE_LENGTH (ri
->value_type
));
448 retval
= allocate_value (ri
->value_type
);
449 gdbarch_return_value (ri
->gdbarch
, ri
->function
, ri
->value_type
,
450 get_current_regcache (),
451 value_contents_raw (retval
), NULL
);
452 if (stack_temporaries
&& class_or_union_p (ri
->value_type
))
454 /* Values of class type returned in registers are copied onto
455 the stack and their lval_type set to lval_memory. This is
456 required because further evaluation of the expression
457 could potentially invoke methods on the return value
458 requiring GDB to evaluate the "this" pointer. To evaluate
459 the this pointer, GDB needs the memory address of the
461 value_force_lval (retval
, ri
->struct_addr
);
462 push_thread_stack_temporary (thr
, retval
);
466 gdb_assert (retval
!= NULL
);
470 /* Data for the FSM that manages an infcall. It's main job is to
471 record the called function's return value. */
473 struct call_thread_fsm
475 /* The base class. */
476 struct thread_fsm thread_fsm
;
478 /* All the info necessary to be able to extract the return
480 struct call_return_meta_info return_meta_info
;
482 /* The called function's return value. This is extracted from the
483 target before the dummy frame is popped. */
484 struct value
*return_value
;
486 /* The top level that started the infcall (and is synchronously
487 waiting for it to end). */
488 struct ui
*waiting_ui
;
491 static int call_thread_fsm_should_stop (struct thread_fsm
*self
,
492 struct thread_info
*thread
);
493 static int call_thread_fsm_should_notify_stop (struct thread_fsm
*self
);
495 /* call_thread_fsm's vtable. */
497 static struct thread_fsm_ops call_thread_fsm_ops
=
501 call_thread_fsm_should_stop
,
502 NULL
, /* return_value */
503 NULL
, /* async_reply_reason*/
504 call_thread_fsm_should_notify_stop
,
507 /* Allocate a new call_thread_fsm object. */
509 static struct call_thread_fsm
*
510 new_call_thread_fsm (struct ui
*waiting_ui
, struct interp
*cmd_interp
,
511 struct gdbarch
*gdbarch
, struct value
*function
,
512 struct type
*value_type
,
513 int struct_return_p
, CORE_ADDR struct_addr
)
515 struct call_thread_fsm
*sm
;
517 sm
= XCNEW (struct call_thread_fsm
);
518 thread_fsm_ctor (&sm
->thread_fsm
, &call_thread_fsm_ops
, cmd_interp
);
520 sm
->return_meta_info
.gdbarch
= gdbarch
;
521 sm
->return_meta_info
.function
= function
;
522 sm
->return_meta_info
.value_type
= value_type
;
523 sm
->return_meta_info
.struct_return_p
= struct_return_p
;
524 sm
->return_meta_info
.struct_addr
= struct_addr
;
526 sm
->waiting_ui
= waiting_ui
;
531 /* Implementation of should_stop method for infcalls. */
534 call_thread_fsm_should_stop (struct thread_fsm
*self
,
535 struct thread_info
*thread
)
537 struct call_thread_fsm
*f
= (struct call_thread_fsm
*) self
;
539 if (stop_stack_dummy
== STOP_STACK_DUMMY
)
542 thread_fsm_set_finished (self
);
544 /* Stash the return value before the dummy frame is popped and
545 registers are restored to what they were before the
547 f
->return_value
= get_call_return_value (&f
->return_meta_info
);
549 /* Break out of wait_sync_command_done. */
550 scoped_restore save_ui
= make_scoped_restore (¤t_ui
, f
->waiting_ui
);
551 target_terminal::ours ();
552 f
->waiting_ui
->prompt_state
= PROMPT_NEEDED
;
558 /* Implementation of should_notify_stop method for infcalls. */
561 call_thread_fsm_should_notify_stop (struct thread_fsm
*self
)
563 if (thread_fsm_finished_p (self
))
565 /* Infcall succeeded. Be silent and proceed with evaluating the
570 /* Something wrong happened. E.g., an unexpected breakpoint
571 triggered, or a signal was intercepted. Notify the stop. */
575 /* Subroutine of call_function_by_hand to simplify it.
576 Start up the inferior and wait for it to stop.
577 Return the exception if there's an error, or an exception with
578 reason >= 0 if there's no error.
580 This is done inside a TRY_CATCH so the caller needn't worry about
581 thrown errors. The caller should rethrow if there's an error. */
583 static struct gdb_exception
584 run_inferior_call (struct call_thread_fsm
*sm
,
585 struct thread_info
*call_thread
, CORE_ADDR real_pc
)
587 struct gdb_exception caught_error
= exception_none
;
588 int saved_in_infcall
= call_thread
->control
.in_infcall
;
589 ptid_t call_thread_ptid
= call_thread
->ptid
;
590 enum prompt_state saved_prompt_state
= current_ui
->prompt_state
;
591 int was_running
= call_thread
->state
== THREAD_RUNNING
;
592 int saved_ui_async
= current_ui
->async
;
594 /* Infcalls run synchronously, in the foreground. */
595 current_ui
->prompt_state
= PROMPT_BLOCKED
;
596 /* So that we don't print the prompt prematurely in
597 fetch_inferior_event. */
598 current_ui
->async
= 0;
600 delete_file_handler (current_ui
->input_fd
);
602 call_thread
->control
.in_infcall
= 1;
604 clear_proceed_status (0);
606 /* Associate the FSM with the thread after clear_proceed_status
607 (otherwise it'd clear this FSM), and before anything throws, so
608 we don't leak it (and any resources it manages). */
609 call_thread
->thread_fsm
= &sm
->thread_fsm
;
611 disable_watchpoints_before_interactive_call_start ();
613 /* We want to print return value, please... */
614 call_thread
->control
.proceed_to_finish
= 1;
618 proceed (real_pc
, GDB_SIGNAL_0
);
620 /* Inferior function calls are always synchronous, even if the
621 target supports asynchronous execution. */
622 wait_sync_command_done ();
624 CATCH (e
, RETURN_MASK_ALL
)
630 /* If GDB has the prompt blocked before, then ensure that it remains
631 so. normal_stop calls async_enable_stdin, so reset the prompt
632 state again here. In other cases, stdin will be re-enabled by
633 inferior_event_handler, when an exception is thrown. */
634 current_ui
->prompt_state
= saved_prompt_state
;
635 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
636 delete_file_handler (current_ui
->input_fd
);
638 ui_register_input_event_handler (current_ui
);
639 current_ui
->async
= saved_ui_async
;
641 /* If the infcall does NOT succeed, normal_stop will have already
642 finished the thread states. However, on success, normal_stop
643 defers here, so that we can set back the thread states to what
644 they were before the call. Note that we must also finish the
645 state of new threads that might have spawned while the call was
646 running. The main cases to handle are:
648 - "(gdb) print foo ()", or any other command that evaluates an
649 expression at the prompt. (The thread was marked stopped before.)
651 - "(gdb) break foo if return_false()" or similar cases where we
652 do an infcall while handling an event (while the thread is still
653 marked running). In this example, whether the condition
654 evaluates true and thus we'll present a user-visible stop is
655 decided elsewhere. */
657 && call_thread_ptid
== inferior_ptid
658 && stop_stack_dummy
== STOP_STACK_DUMMY
)
659 finish_thread_state (user_visible_resume_ptid (0));
661 enable_watchpoints_after_interactive_call_stop ();
663 /* Call breakpoint_auto_delete on the current contents of the bpstat
664 of inferior call thread.
665 If all error()s out of proceed ended up calling normal_stop
666 (and perhaps they should; it already does in the special case
667 of error out of resume()), then we wouldn't need this. */
668 if (caught_error
.reason
< 0)
670 if (call_thread
->state
!= THREAD_EXITED
)
671 breakpoint_auto_delete (call_thread
->control
.stop_bpstat
);
674 call_thread
->control
.in_infcall
= saved_in_infcall
;
679 /* A cleanup function that calls delete_std_terminate_breakpoint. */
681 cleanup_delete_std_terminate_breakpoint (void *ignore
)
683 delete_std_terminate_breakpoint ();
689 call_function_by_hand (struct value
*function
,
690 type
*default_return_type
,
691 int nargs
, struct value
**args
)
693 return call_function_by_hand_dummy (function
, default_return_type
,
694 nargs
, args
, NULL
, NULL
);
697 /* All this stuff with a dummy frame may seem unnecessarily complicated
698 (why not just save registers in GDB?). The purpose of pushing a dummy
699 frame which looks just like a real frame is so that if you call a
700 function and then hit a breakpoint (get a signal, etc), "backtrace"
701 will look right. Whether the backtrace needs to actually show the
702 stack at the time the inferior function was called is debatable, but
703 it certainly needs to not display garbage. So if you are contemplating
704 making dummy frames be different from normal frames, consider that. */
706 /* Perform a function call in the inferior.
707 ARGS is a vector of values of arguments (NARGS of them).
708 FUNCTION is a value, the function to be called.
709 Returns a value representing what the function returned.
710 May fail to return, if a breakpoint or signal is hit
711 during the execution of the function.
713 ARGS is modified to contain coerced values. */
716 call_function_by_hand_dummy (struct value
*function
,
717 type
*default_return_type
,
718 int nargs
, struct value
**args
,
719 dummy_frame_dtor_ftype
*dummy_dtor
,
720 void *dummy_dtor_data
)
723 struct type
*target_values_type
;
724 unsigned char struct_return
= 0, hidden_first_param_p
= 0;
725 CORE_ADDR struct_addr
= 0;
726 struct infcall_control_state
*inf_status
;
727 struct cleanup
*inf_status_cleanup
;
728 struct infcall_suspend_state
*caller_state
;
731 struct frame_id dummy_id
;
732 struct frame_info
*frame
;
733 struct gdbarch
*gdbarch
;
734 struct cleanup
*terminate_bp_cleanup
;
735 ptid_t call_thread_ptid
;
736 struct gdb_exception e
;
737 char name_buf
[RAW_FUNCTION_ADDRESS_SIZE
];
739 if (!target_has_execution
)
742 if (get_traceframe_number () >= 0)
743 error (_("May not call functions while looking at trace frames."));
745 if (execution_direction
== EXEC_REVERSE
)
746 error (_("Cannot call functions in reverse mode."));
748 /* We're going to run the target, and inspect the thread's state
749 afterwards. Hold a strong reference so that the pointer remains
750 valid even if the thread exits. */
751 thread_info_ref call_thread
752 = thread_info_ref::new_reference (inferior_thread ());
754 bool stack_temporaries
= thread_stack_temporaries_enabled_p (call_thread
.get ());
756 frame
= get_current_frame ();
757 gdbarch
= get_frame_arch (frame
);
759 if (!gdbarch_push_dummy_call_p (gdbarch
))
760 error (_("This target does not support function calls."));
762 /* A cleanup for the inferior status.
763 This is only needed while we're preparing the inferior function call. */
764 inf_status
= save_infcall_control_state ();
766 = make_cleanup_restore_infcall_control_state (inf_status
);
768 /* Save the caller's registers and other state associated with the
769 inferior itself so that they can be restored once the
770 callee returns. To allow nested calls the registers are (further
771 down) pushed onto a dummy frame stack. Include a cleanup (which
772 is tossed once the regcache has been pushed). */
773 caller_state
= save_infcall_suspend_state ();
774 make_cleanup_restore_infcall_suspend_state (caller_state
);
776 /* Ensure that the initial SP is correctly aligned. */
778 CORE_ADDR old_sp
= get_frame_sp (frame
);
780 if (gdbarch_frame_align_p (gdbarch
))
782 sp
= gdbarch_frame_align (gdbarch
, old_sp
);
783 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
784 ABIs, a function can use memory beyond the inner most stack
785 address. AMD64 called that region the "red zone". Skip at
786 least the "red zone" size before allocating any space on
788 if (gdbarch_inner_than (gdbarch
, 1, 2))
789 sp
-= gdbarch_frame_red_zone_size (gdbarch
);
791 sp
+= gdbarch_frame_red_zone_size (gdbarch
);
793 gdb_assert (sp
== gdbarch_frame_align (gdbarch
, sp
));
794 /* NOTE: cagney/2002-09-18:
796 On a RISC architecture, a void parameterless generic dummy
797 frame (i.e., no parameters, no result) typically does not
798 need to push anything the stack and hence can leave SP and
799 FP. Similarly, a frameless (possibly leaf) function does
800 not push anything on the stack and, hence, that too can
801 leave FP and SP unchanged. As a consequence, a sequence of
802 void parameterless generic dummy frame calls to frameless
803 functions will create a sequence of effectively identical
804 frames (SP, FP and TOS and PC the same). This, not
805 suprisingly, results in what appears to be a stack in an
806 infinite loop --- when GDB tries to find a generic dummy
807 frame on the internal dummy frame stack, it will always
810 To avoid this problem, the code below always grows the
811 stack. That way, two dummy frames can never be identical.
812 It does burn a few bytes of stack but that is a small price
816 if (gdbarch_inner_than (gdbarch
, 1, 2))
817 /* Stack grows down. */
818 sp
= gdbarch_frame_align (gdbarch
, old_sp
- 1);
820 /* Stack grows up. */
821 sp
= gdbarch_frame_align (gdbarch
, old_sp
+ 1);
823 /* SP may have underflown address zero here from OLD_SP. Memory access
824 functions will probably fail in such case but that is a target's
828 /* FIXME: cagney/2002-09-18: Hey, you loose!
830 Who knows how badly aligned the SP is!
832 If the generic dummy frame ends up empty (because nothing is
833 pushed) GDB won't be able to correctly perform back traces.
834 If a target is having trouble with backtraces, first thing to
835 do is add FRAME_ALIGN() to the architecture vector. If that
836 fails, try dummy_id().
838 If the ABI specifies a "Red Zone" (see the doco) the code
839 below will quietly trash it. */
842 /* Skip over the stack temporaries that might have been generated during
843 the evaluation of an expression. */
844 if (stack_temporaries
)
846 struct value
*lastval
;
848 lastval
= get_last_thread_stack_temporary (call_thread
.get ());
851 CORE_ADDR lastval_addr
= value_address (lastval
);
853 if (gdbarch_inner_than (gdbarch
, 1, 2))
855 gdb_assert (sp
>= lastval_addr
);
860 gdb_assert (sp
<= lastval_addr
);
861 sp
= lastval_addr
+ TYPE_LENGTH (value_type (lastval
));
864 if (gdbarch_frame_align_p (gdbarch
))
865 sp
= gdbarch_frame_align (gdbarch
, sp
);
872 CORE_ADDR funaddr
= find_function_addr (function
, &values_type
, &ftype
);
874 if (values_type
== NULL
)
875 values_type
= default_return_type
;
876 if (values_type
== NULL
)
878 const char *name
= get_function_name (funaddr
,
879 name_buf
, sizeof (name_buf
));
880 error (_("'%s' has unknown return type; "
881 "cast the call to its declared return type"),
885 values_type
= check_typedef (values_type
);
887 /* Are we returning a value using a structure return (passing a
888 hidden argument pointing to storage) or a normal value return?
889 There are two cases: language-mandated structure return and
890 target ABI structure return. The variable STRUCT_RETURN only
891 describes the latter. The language version is handled by passing
892 the return location as the first parameter to the function,
893 even preceding "this". This is different from the target
894 ABI version, which is target-specific; for instance, on ia64
895 the first argument is passed in out0 but the hidden structure
896 return pointer would normally be passed in r8. */
898 if (gdbarch_return_in_first_hidden_param_p (gdbarch
, values_type
))
900 hidden_first_param_p
= 1;
902 /* Tell the target specific argument pushing routine not to
904 target_values_type
= builtin_type (gdbarch
)->builtin_void
;
908 struct_return
= using_struct_return (gdbarch
, function
, values_type
);
909 target_values_type
= values_type
;
912 gdb::observers::inferior_call_pre
.notify (inferior_ptid
, funaddr
);
914 /* Determine the location of the breakpoint (and possibly other
915 stuff) that the called function will return to. The SPARC, for a
916 function returning a structure or union, needs to make space for
917 not just the breakpoint but also an extra word containing the
918 size (?) of the structure being passed. */
920 switch (gdbarch_call_dummy_location (gdbarch
))
924 const gdb_byte
*bp_bytes
;
925 CORE_ADDR bp_addr_as_address
;
928 /* Be careful BP_ADDR is in inferior PC encoding while
929 BP_ADDR_AS_ADDRESS is a plain memory address. */
931 sp
= push_dummy_code (gdbarch
, sp
, funaddr
, args
, nargs
,
932 target_values_type
, &real_pc
, &bp_addr
,
933 get_current_regcache ());
935 /* Write a legitimate instruction at the point where the infcall
936 breakpoint is going to be inserted. While this instruction
937 is never going to be executed, a user investigating the
938 memory from GDB would see this instruction instead of random
939 uninitialized bytes. We chose the breakpoint instruction
940 as it may look as the most logical one to the user and also
941 valgrind 3.7.0 needs it for proper vgdb inferior calls.
943 If software breakpoints are unsupported for this target we
944 leave the user visible memory content uninitialized. */
946 bp_addr_as_address
= bp_addr
;
947 bp_bytes
= gdbarch_breakpoint_from_pc (gdbarch
, &bp_addr_as_address
,
949 if (bp_bytes
!= NULL
)
950 write_memory (bp_addr_as_address
, bp_bytes
, bp_size
);
955 CORE_ADDR dummy_addr
;
958 dummy_addr
= entry_point_address ();
960 /* A call dummy always consists of just a single breakpoint, so
961 its address is the same as the address of the dummy.
963 The actual breakpoint is inserted separatly so there is no need to
965 bp_addr
= dummy_addr
;
969 internal_error (__FILE__
, __LINE__
, _("bad switch"));
972 if (nargs
< TYPE_NFIELDS (ftype
))
973 error (_("Too few arguments in function call."));
978 for (i
= nargs
- 1; i
>= 0; i
--)
981 struct type
*param_type
;
983 /* FIXME drow/2002-05-31: Should just always mark methods as
984 prototyped. Can we respect TYPE_VARARGS? Probably not. */
985 if (TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
987 if (TYPE_TARGET_TYPE (ftype
) == NULL
&& TYPE_NFIELDS (ftype
) == 0
988 && default_return_type
!= NULL
)
990 /* Calling a no-debug function with the return type
991 explicitly cast. Assume the function is prototyped,
992 with a prototype matching the types of the arguments.
994 float mult (float v1, float v2) { return v1 * v2; }
996 (gdb) p (float) mult (2.0f, 3.0f)
997 Is a simpler alternative to:
998 (gdb) p ((float (*) (float, float)) mult) (2.0f, 3.0f)
1002 else if (i
< TYPE_NFIELDS (ftype
))
1003 prototyped
= TYPE_PROTOTYPED (ftype
);
1007 if (i
< TYPE_NFIELDS (ftype
))
1008 param_type
= TYPE_FIELD_TYPE (ftype
, i
);
1012 args
[i
] = value_arg_coerce (gdbarch
, args
[i
],
1013 param_type
, prototyped
, &sp
);
1015 if (param_type
!= NULL
&& language_pass_by_reference (param_type
))
1016 args
[i
] = value_addr (args
[i
]);
1020 /* Reserve space for the return structure to be written on the
1021 stack, if necessary. Make certain that the value is correctly
1024 While evaluating expressions, we reserve space on the stack for
1025 return values of class type even if the language ABI and the target
1026 ABI do not require that the return value be passed as a hidden first
1027 argument. This is because we want to store the return value as an
1028 on-stack temporary while the expression is being evaluated. This
1029 enables us to have chained function calls in expressions.
1031 Keeping the return values as on-stack temporaries while the expression
1032 is being evaluated is OK because the thread is stopped until the
1033 expression is completely evaluated. */
1035 if (struct_return
|| hidden_first_param_p
1036 || (stack_temporaries
&& class_or_union_p (values_type
)))
1038 if (gdbarch_inner_than (gdbarch
, 1, 2))
1040 /* Stack grows downward. Align STRUCT_ADDR and SP after
1041 making space for the return value. */
1042 sp
-= TYPE_LENGTH (values_type
);
1043 if (gdbarch_frame_align_p (gdbarch
))
1044 sp
= gdbarch_frame_align (gdbarch
, sp
);
1049 /* Stack grows upward. Align the frame, allocate space, and
1050 then again, re-align the frame??? */
1051 if (gdbarch_frame_align_p (gdbarch
))
1052 sp
= gdbarch_frame_align (gdbarch
, sp
);
1054 sp
+= TYPE_LENGTH (values_type
);
1055 if (gdbarch_frame_align_p (gdbarch
))
1056 sp
= gdbarch_frame_align (gdbarch
, sp
);
1060 std::vector
<struct value
*> new_args
;
1061 if (hidden_first_param_p
)
1063 /* Add the new argument to the front of the argument list. */
1065 (value_from_pointer (lookup_pointer_type (values_type
), struct_addr
));
1066 std::copy (&args
[0], &args
[nargs
], std::back_inserter (new_args
));
1067 args
= new_args
.data ();
1071 /* Create the dummy stack frame. Pass in the call dummy address as,
1072 presumably, the ABI code knows where, in the call dummy, the
1073 return address should be pointed. */
1074 sp
= gdbarch_push_dummy_call (gdbarch
, function
, get_current_regcache (),
1075 bp_addr
, nargs
, args
,
1076 sp
, struct_return
, struct_addr
);
1078 /* Set up a frame ID for the dummy frame so we can pass it to
1079 set_momentary_breakpoint. We need to give the breakpoint a frame
1080 ID so that the breakpoint code can correctly re-identify the
1081 dummy breakpoint. */
1082 /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL,
1083 saved as the dummy-frame TOS, and used by dummy_id to form
1084 the frame ID's stack address. */
1085 dummy_id
= frame_id_build (sp
, bp_addr
);
1087 /* Create a momentary breakpoint at the return address of the
1088 inferior. That way it breaks when it returns. */
1091 symtab_and_line sal
;
1092 sal
.pspace
= current_program_space
;
1094 sal
.section
= find_pc_overlay (sal
.pc
);
1096 /* Sanity. The exact same SP value is returned by
1097 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
1098 dummy_id to form the frame ID's stack address. */
1100 = set_momentary_breakpoint (gdbarch
, sal
,
1101 dummy_id
, bp_call_dummy
).release ();
1103 /* set_momentary_breakpoint invalidates FRAME. */
1106 bpt
->disposition
= disp_del
;
1107 gdb_assert (bpt
->related_breakpoint
== bpt
);
1109 breakpoint
*longjmp_b
= set_longjmp_breakpoint_for_call_dummy ();
1112 /* Link BPT into the chain of LONGJMP_B. */
1113 bpt
->related_breakpoint
= longjmp_b
;
1114 while (longjmp_b
->related_breakpoint
!= bpt
->related_breakpoint
)
1115 longjmp_b
= longjmp_b
->related_breakpoint
;
1116 longjmp_b
->related_breakpoint
= bpt
;
1120 /* Create a breakpoint in std::terminate.
1121 If a C++ exception is raised in the dummy-frame, and the
1122 exception handler is (normally, and expected to be) out-of-frame,
1123 the default C++ handler will (wrongly) be called in an inferior
1124 function call. This is wrong, as an exception can be normally
1125 and legally handled out-of-frame. The confines of the dummy frame
1126 prevent the unwinder from finding the correct handler (or any
1127 handler, unless it is in-frame). The default handler calls
1128 std::terminate. This will kill the inferior. Assert that
1129 terminate should never be called in an inferior function
1130 call. Place a momentary breakpoint in the std::terminate function
1131 and if triggered in the call, rewind. */
1132 if (unwind_on_terminating_exception_p
)
1133 set_std_terminate_breakpoint ();
1135 /* Discard both inf_status and caller_state cleanups.
1136 From this point on we explicitly restore the associated state
1138 discard_cleanups (inf_status_cleanup
);
1140 /* Everything's ready, push all the info needed to restore the
1141 caller (and identify the dummy-frame) onto the dummy-frame
1143 dummy_frame_push (caller_state
, &dummy_id
, call_thread
.get ());
1144 if (dummy_dtor
!= NULL
)
1145 register_dummy_frame_dtor (dummy_id
, call_thread
.get (),
1146 dummy_dtor
, dummy_dtor_data
);
1148 /* Register a clean-up for unwind_on_terminating_exception_breakpoint. */
1149 terminate_bp_cleanup
= make_cleanup (cleanup_delete_std_terminate_breakpoint
,
1152 /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP -
1153 If you're looking to implement asynchronous dummy-frames, then
1154 just below is the place to chop this function in two.. */
1157 struct thread_fsm
*saved_sm
;
1158 struct call_thread_fsm
*sm
;
1160 /* Save the current FSM. We'll override it. */
1161 saved_sm
= call_thread
->thread_fsm
;
1162 call_thread
->thread_fsm
= NULL
;
1164 /* Save this thread's ptid, we need it later but the thread
1166 call_thread_ptid
= call_thread
->ptid
;
1168 /* Run the inferior until it stops. */
1170 /* Create the FSM used to manage the infcall. It tells infrun to
1171 not report the stop to the user, and captures the return value
1172 before the dummy frame is popped. run_inferior_call registers
1173 it with the thread ASAP. */
1174 sm
= new_call_thread_fsm (current_ui
, command_interp (),
1177 struct_return
|| hidden_first_param_p
,
1180 e
= run_inferior_call (sm
, call_thread
.get (), real_pc
);
1182 gdb::observers::inferior_call_post
.notify (call_thread_ptid
, funaddr
);
1184 if (call_thread
->state
!= THREAD_EXITED
)
1186 /* The FSM should still be the same. */
1187 gdb_assert (call_thread
->thread_fsm
== &sm
->thread_fsm
);
1189 if (thread_fsm_finished_p (call_thread
->thread_fsm
))
1191 struct value
*retval
;
1193 /* The inferior call is successful. Pop the dummy frame,
1194 which runs its destructors and restores the inferior's
1195 suspend state, and restore the inferior control
1197 dummy_frame_pop (dummy_id
, call_thread
.get ());
1198 restore_infcall_control_state (inf_status
);
1200 /* Get the return value. */
1201 retval
= sm
->return_value
;
1203 /* Clean up / destroy the call FSM, and restore the
1205 thread_fsm_clean_up (call_thread
->thread_fsm
, call_thread
.get ());
1206 thread_fsm_delete (call_thread
->thread_fsm
);
1207 call_thread
->thread_fsm
= saved_sm
;
1209 maybe_remove_breakpoints ();
1211 do_cleanups (terminate_bp_cleanup
);
1212 gdb_assert (retval
!= NULL
);
1216 /* Didn't complete. Restore previous state machine, and
1217 handle the error. */
1218 call_thread
->thread_fsm
= saved_sm
;
1222 /* Rethrow an error if we got one trying to run the inferior. */
1226 const char *name
= get_function_name (funaddr
,
1227 name_buf
, sizeof (name_buf
));
1229 discard_infcall_control_state (inf_status
);
1231 /* We could discard the dummy frame here if the program exited,
1232 but it will get garbage collected the next time the program is
1238 throw_error (e
.error
, _("%s\n\
1239 An error occurred while in a function called from GDB.\n\
1240 Evaluation of the expression containing the function\n\
1241 (%s) will be abandoned.\n\
1242 When the function is done executing, GDB will silently stop."),
1246 throw_exception (e
);
1250 /* If the program has exited, or we stopped at a different thread,
1251 exit and inform the user. */
1253 if (! target_has_execution
)
1255 const char *name
= get_function_name (funaddr
,
1256 name_buf
, sizeof (name_buf
));
1258 /* If we try to restore the inferior status,
1259 we'll crash as the inferior is no longer running. */
1260 discard_infcall_control_state (inf_status
);
1262 /* We could discard the dummy frame here given that the program exited,
1263 but it will get garbage collected the next time the program is
1266 error (_("The program being debugged exited while in a function "
1267 "called from GDB.\n"
1268 "Evaluation of the expression containing the function\n"
1269 "(%s) will be abandoned."),
1273 if (call_thread_ptid
!= inferior_ptid
)
1275 const char *name
= get_function_name (funaddr
,
1276 name_buf
, sizeof (name_buf
));
1278 /* We've switched threads. This can happen if another thread gets a
1279 signal or breakpoint while our thread was running.
1280 There's no point in restoring the inferior status,
1281 we're in a different thread. */
1282 discard_infcall_control_state (inf_status
);
1283 /* Keep the dummy frame record, if the user switches back to the
1284 thread with the hand-call, we'll need it. */
1285 if (stopped_by_random_signal
)
1287 The program received a signal in another thread while\n\
1288 making a function call from GDB.\n\
1289 Evaluation of the expression containing the function\n\
1290 (%s) will be abandoned.\n\
1291 When the function is done executing, GDB will silently stop."),
1295 The program stopped in another thread while making a function call from GDB.\n\
1296 Evaluation of the expression containing the function\n\
1297 (%s) will be abandoned.\n\
1298 When the function is done executing, GDB will silently stop."),
1303 /* Make a copy as NAME may be in an objfile freed by dummy_frame_pop. */
1304 std::string name
= get_function_name (funaddr
, name_buf
,
1307 if (stopped_by_random_signal
)
1309 /* We stopped inside the FUNCTION because of a random
1310 signal. Further execution of the FUNCTION is not
1313 if (unwind_on_signal_p
)
1315 /* The user wants the context restored. */
1317 /* We must get back to the frame we were before the
1319 dummy_frame_pop (dummy_id
, call_thread
.get ());
1321 /* We also need to restore inferior status to that before the
1323 restore_infcall_control_state (inf_status
);
1325 /* FIXME: Insert a bunch of wrap_here; name can be very
1326 long if it's a C++ name with arguments and stuff. */
1328 The program being debugged was signaled while in a function called from GDB.\n\
1329 GDB has restored the context to what it was before the call.\n\
1330 To change this behavior use \"set unwindonsignal off\".\n\
1331 Evaluation of the expression containing the function\n\
1332 (%s) will be abandoned."),
1337 /* The user wants to stay in the frame where we stopped
1339 Discard inferior status, we're not at the same point
1341 discard_infcall_control_state (inf_status
);
1343 /* FIXME: Insert a bunch of wrap_here; name can be very
1344 long if it's a C++ name with arguments and stuff. */
1346 The program being debugged was signaled while in a function called from GDB.\n\
1347 GDB remains in the frame where the signal was received.\n\
1348 To change this behavior use \"set unwindonsignal on\".\n\
1349 Evaluation of the expression containing the function\n\
1350 (%s) will be abandoned.\n\
1351 When the function is done executing, GDB will silently stop."),
1356 if (stop_stack_dummy
== STOP_STD_TERMINATE
)
1358 /* We must get back to the frame we were before the dummy
1360 dummy_frame_pop (dummy_id
, call_thread
.get ());
1362 /* We also need to restore inferior status to that before
1364 restore_infcall_control_state (inf_status
);
1367 The program being debugged entered a std::terminate call, most likely\n\
1368 caused by an unhandled C++ exception. GDB blocked this call in order\n\
1369 to prevent the program from being terminated, and has restored the\n\
1370 context to its original state before the call.\n\
1371 To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
1372 Evaluation of the expression containing the function (%s)\n\
1373 will be abandoned."),
1376 else if (stop_stack_dummy
== STOP_NONE
)
1379 /* We hit a breakpoint inside the FUNCTION.
1380 Keep the dummy frame, the user may want to examine its state.
1381 Discard inferior status, we're not at the same point
1383 discard_infcall_control_state (inf_status
);
1385 /* The following error message used to say "The expression
1386 which contained the function call has been discarded."
1387 It is a hard concept to explain in a few words. Ideally,
1388 GDB would be able to resume evaluation of the expression
1389 when the function finally is done executing. Perhaps
1390 someday this will be implemented (it would not be easy). */
1391 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1392 a C++ name with arguments and stuff. */
1394 The program being debugged stopped while in a function called from GDB.\n\
1395 Evaluation of the expression containing the function\n\
1396 (%s) will be abandoned.\n\
1397 When the function is done executing, GDB will silently stop."),
1403 /* The above code errors out, so ... */
1404 gdb_assert_not_reached ("... should not be here");
1408 _initialize_infcall (void)
1410 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure
,
1411 &coerce_float_to_double_p
, _("\
1412 Set coercion of floats to doubles when calling functions."), _("\
1413 Show coercion of floats to doubles when calling functions"), _("\
1414 Variables of type float should generally be converted to doubles before\n\
1415 calling an unprototyped function, and left alone when calling a prototyped\n\
1416 function. However, some older debug info formats do not provide enough\n\
1417 information to determine that a function is prototyped. If this flag is\n\
1418 set, GDB will perform the conversion for a function it considers\n\
1420 The default is to perform the conversion.\n"),
1422 show_coerce_float_to_double_p
,
1423 &setlist
, &showlist
);
1425 add_setshow_boolean_cmd ("unwindonsignal", no_class
,
1426 &unwind_on_signal_p
, _("\
1427 Set unwinding of stack if a signal is received while in a call dummy."), _("\
1428 Show unwinding of stack if a signal is received while in a call dummy."), _("\
1429 The unwindonsignal lets the user determine what gdb should do if a signal\n\
1430 is received while in a function called from gdb (call dummy). If set, gdb\n\
1431 unwinds the stack and restore the context to what as it was before the call.\n\
1432 The default is to stop in the frame where the signal was received."),
1434 show_unwind_on_signal_p
,
1435 &setlist
, &showlist
);
1437 add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class
,
1438 &unwind_on_terminating_exception_p
, _("\
1439 Set unwinding of stack if std::terminate is called while in call dummy."), _("\
1440 Show unwinding of stack if std::terminate() is called while in a call dummy."),
1442 The unwind on terminating exception flag lets the user determine\n\
1443 what gdb should do if a std::terminate() call is made from the\n\
1444 default exception handler. If set, gdb unwinds the stack and restores\n\
1445 the context to what it was before the call. If unset, gdb allows the\n\
1446 std::terminate call to proceed.\n\
1447 The default is to unwind the frame."),
1449 show_unwind_on_terminating_exception_p
,
1450 &setlist
, &showlist
);