1 /* Perform an inferior function call, for GDB, the GNU debugger.
3 Copyright (C) 1986-2019 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"
37 #include "gdbthread.h"
38 #include "event-top.h"
39 #include "observable.h"
42 #include "thread-fsm.h"
44 #include "gdbsupport/scope-exit.h"
46 /* If we can't find a function's name from its address,
47 we print this instead. */
48 #define RAW_FUNCTION_ADDRESS_FORMAT "at 0x%s"
49 #define RAW_FUNCTION_ADDRESS_SIZE (sizeof (RAW_FUNCTION_ADDRESS_FORMAT) \
50 + 2 * sizeof (CORE_ADDR))
52 /* NOTE: cagney/2003-04-16: What's the future of this code?
54 GDB needs an asynchronous expression evaluator, that means an
55 asynchronous inferior function call implementation, and that in
56 turn means restructuring the code so that it is event driven. */
58 static bool may_call_functions_p
= true;
60 show_may_call_functions_p (struct ui_file
*file
, int from_tty
,
61 struct cmd_list_element
*c
,
64 fprintf_filtered (file
,
65 _("Permission to call functions in the program is %s.\n"),
69 /* How you should pass arguments to a function depends on whether it
70 was defined in K&R style or prototype style. If you define a
71 function using the K&R syntax that takes a `float' argument, then
72 callers must pass that argument as a `double'. If you define the
73 function using the prototype syntax, then you must pass the
74 argument as a `float', with no promotion.
76 Unfortunately, on certain older platforms, the debug info doesn't
77 indicate reliably how each function was defined. A function type's
78 TYPE_PROTOTYPED flag may be clear, even if the function was defined
79 in prototype style. When calling a function whose TYPE_PROTOTYPED
80 flag is clear, GDB consults this flag to decide what to do.
82 For modern targets, it is proper to assume that, if the prototype
83 flag is clear, that can be trusted: `float' arguments should be
84 promoted to `double'. For some older targets, if the prototype
85 flag is clear, that doesn't tell us anything. The default is to
86 trust the debug information; the user can override this behavior
87 with "set coerce-float-to-double 0". */
89 static bool coerce_float_to_double_p
= true;
91 show_coerce_float_to_double_p (struct ui_file
*file
, int from_tty
,
92 struct cmd_list_element
*c
, const char *value
)
94 fprintf_filtered (file
,
95 _("Coercion of floats to doubles "
96 "when calling functions is %s.\n"),
100 /* This boolean tells what gdb should do if a signal is received while
101 in a function called from gdb (call dummy). If set, gdb unwinds
102 the stack and restore the context to what as it was before the
105 The default is to stop in the frame where the signal was received. */
107 static bool unwind_on_signal_p
= false;
109 show_unwind_on_signal_p (struct ui_file
*file
, int from_tty
,
110 struct cmd_list_element
*c
, const char *value
)
112 fprintf_filtered (file
,
113 _("Unwinding of stack if a signal is "
114 "received while in a call dummy is %s.\n"),
118 /* This boolean tells what gdb should do if a std::terminate call is
119 made while in a function called from gdb (call dummy).
120 As the confines of a single dummy stack prohibit out-of-frame
121 handlers from handling a raised exception, and as out-of-frame
122 handlers are common in C++, this can lead to no handler being found
123 by the unwinder, and a std::terminate call. This is a false positive.
124 If set, gdb unwinds the stack and restores the context to what it
127 The default is to unwind the frame if a std::terminate call is
130 static bool unwind_on_terminating_exception_p
= true;
133 show_unwind_on_terminating_exception_p (struct ui_file
*file
, int from_tty
,
134 struct cmd_list_element
*c
,
138 fprintf_filtered (file
,
139 _("Unwind stack if a C++ exception is "
140 "unhandled while in a call dummy is %s.\n"),
144 /* Perform the standard coercions that are specified
145 for arguments to be passed to C, Ada or Fortran functions.
147 If PARAM_TYPE is non-NULL, it is the expected parameter type.
148 IS_PROTOTYPED is non-zero if the function declaration is prototyped.
149 SP is the stack pointer were additional data can be pushed (updating
150 its value as needed). */
152 static struct value
*
153 value_arg_coerce (struct gdbarch
*gdbarch
, struct value
*arg
,
154 struct type
*param_type
, int is_prototyped
, CORE_ADDR
*sp
)
156 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
157 struct type
*arg_type
= check_typedef (value_type (arg
));
159 = param_type
? check_typedef (param_type
) : arg_type
;
161 /* Perform any Ada- and Fortran-specific coercion first. */
162 if (current_language
->la_language
== language_ada
)
163 arg
= ada_convert_actual (arg
, type
);
164 else if (current_language
->la_language
== language_fortran
)
165 type
= fortran_preserve_arg_pointer (arg
, type
);
167 /* Force the value to the target if we will need its address. At
168 this point, we could allocate arguments on the stack instead of
169 calling malloc if we knew that their addresses would not be
170 saved by the called function. */
171 arg
= value_coerce_to_target (arg
);
173 switch (TYPE_CODE (type
))
176 case TYPE_CODE_RVALUE_REF
:
178 struct value
*new_value
;
180 if (TYPE_IS_REFERENCE (arg_type
))
181 return value_cast_pointers (type
, arg
, 0);
183 /* Cast the value to the reference's target type, and then
184 convert it back to a reference. This will issue an error
185 if the value was not previously in memory - in some cases
186 we should clearly be allowing this, but how? */
187 new_value
= value_cast (TYPE_TARGET_TYPE (type
), arg
);
188 new_value
= value_ref (new_value
, TYPE_CODE (type
));
195 /* If we don't have a prototype, coerce to integer type if necessary. */
198 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin
->builtin_int
))
199 type
= builtin
->builtin_int
;
201 /* Currently all target ABIs require at least the width of an integer
202 type for an argument. We may have to conditionalize the following
203 type coercion for future targets. */
204 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin
->builtin_int
))
205 type
= builtin
->builtin_int
;
208 if (!is_prototyped
&& coerce_float_to_double_p
)
210 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin
->builtin_double
))
211 type
= builtin
->builtin_double
;
212 else if (TYPE_LENGTH (type
) > TYPE_LENGTH (builtin
->builtin_double
))
213 type
= builtin
->builtin_long_double
;
217 type
= lookup_pointer_type (type
);
219 case TYPE_CODE_ARRAY
:
220 /* Arrays are coerced to pointers to their first element, unless
221 they are vectors, in which case we want to leave them alone,
222 because they are passed by value. */
223 if (current_language
->c_style_arrays
)
224 if (!TYPE_VECTOR (type
))
225 type
= lookup_pointer_type (TYPE_TARGET_TYPE (type
));
227 case TYPE_CODE_UNDEF
:
229 case TYPE_CODE_STRUCT
:
230 case TYPE_CODE_UNION
:
233 case TYPE_CODE_RANGE
:
234 case TYPE_CODE_STRING
:
235 case TYPE_CODE_ERROR
:
236 case TYPE_CODE_MEMBERPTR
:
237 case TYPE_CODE_METHODPTR
:
238 case TYPE_CODE_METHOD
:
239 case TYPE_CODE_COMPLEX
:
244 return value_cast (type
, arg
);
250 find_function_addr (struct value
*function
,
251 struct type
**retval_type
,
252 struct type
**function_type
)
254 struct type
*ftype
= check_typedef (value_type (function
));
255 struct gdbarch
*gdbarch
= get_type_arch (ftype
);
256 struct type
*value_type
= NULL
;
257 /* Initialize it just to avoid a GCC false warning. */
258 CORE_ADDR funaddr
= 0;
260 /* If it's a member function, just look at the function
263 /* Determine address to call. */
264 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
265 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
266 funaddr
= value_address (function
);
267 else if (TYPE_CODE (ftype
) == TYPE_CODE_PTR
)
269 funaddr
= value_as_address (function
);
270 ftype
= check_typedef (TYPE_TARGET_TYPE (ftype
));
271 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
272 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
273 funaddr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, funaddr
,
274 current_top_target ());
276 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
277 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
279 if (TYPE_GNU_IFUNC (ftype
))
281 CORE_ADDR resolver_addr
= funaddr
;
283 /* Resolve the ifunc. Note this may call the resolver
284 function in the inferior. */
285 funaddr
= gnu_ifunc_resolve_addr (gdbarch
, resolver_addr
);
287 /* Skip querying the function symbol if no RETVAL_TYPE or
288 FUNCTION_TYPE have been asked for. */
289 if (retval_type
!= NULL
|| function_type
!= NULL
)
291 type
*target_ftype
= find_function_type (funaddr
);
292 /* If we don't have debug info for the target function,
293 see if we can instead extract the target function's
294 type from the type that the resolver returns. */
295 if (target_ftype
== NULL
)
296 target_ftype
= find_gnu_ifunc_target_type (resolver_addr
);
297 if (target_ftype
!= NULL
)
299 value_type
= TYPE_TARGET_TYPE (check_typedef (target_ftype
));
300 ftype
= target_ftype
;
305 value_type
= TYPE_TARGET_TYPE (ftype
);
307 else if (TYPE_CODE (ftype
) == TYPE_CODE_INT
)
309 /* Handle the case of functions lacking debugging info.
310 Their values are characters since their addresses are char. */
311 if (TYPE_LENGTH (ftype
) == 1)
312 funaddr
= value_as_address (value_addr (function
));
315 /* Handle function descriptors lacking debug info. */
316 int found_descriptor
= 0;
318 funaddr
= 0; /* pacify "gcc -Werror" */
319 if (VALUE_LVAL (function
) == lval_memory
)
323 funaddr
= value_as_address (value_addr (function
));
326 = gdbarch_convert_from_func_ptr_addr (gdbarch
, funaddr
,
327 current_top_target ());
328 if (funaddr
!= nfunaddr
)
329 found_descriptor
= 1;
331 if (!found_descriptor
)
332 /* Handle integer used as address of a function. */
333 funaddr
= (CORE_ADDR
) value_as_long (function
);
337 error (_("Invalid data type for function to be called."));
339 if (retval_type
!= NULL
)
340 *retval_type
= value_type
;
341 if (function_type
!= NULL
)
342 *function_type
= ftype
;
343 return funaddr
+ gdbarch_deprecated_function_start_offset (gdbarch
);
346 /* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called
347 function returns to. */
350 push_dummy_code (struct gdbarch
*gdbarch
,
351 CORE_ADDR sp
, CORE_ADDR funaddr
,
352 gdb::array_view
<value
*> args
,
353 struct type
*value_type
,
354 CORE_ADDR
*real_pc
, CORE_ADDR
*bp_addr
,
355 struct regcache
*regcache
)
357 gdb_assert (gdbarch_push_dummy_code_p (gdbarch
));
359 return gdbarch_push_dummy_code (gdbarch
, sp
, funaddr
,
360 args
.data (), args
.size (),
361 value_type
, real_pc
, bp_addr
,
368 error_call_unknown_return_type (const char *func_name
)
370 if (func_name
!= NULL
)
371 error (_("'%s' has unknown return type; "
372 "cast the call to its declared return type"),
375 error (_("function has unknown return type; "
376 "cast the call to its declared return type"));
379 /* Fetch the name of the function at FUNADDR.
380 This is used in printing an error message for call_function_by_hand.
381 BUF is used to print FUNADDR in hex if the function name cannot be
382 determined. It must be large enough to hold formatted result of
383 RAW_FUNCTION_ADDRESS_FORMAT. */
386 get_function_name (CORE_ADDR funaddr
, char *buf
, int buf_size
)
389 struct symbol
*symbol
= find_pc_function (funaddr
);
392 return SYMBOL_PRINT_NAME (symbol
);
396 /* Try the minimal symbols. */
397 struct bound_minimal_symbol msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
400 return MSYMBOL_PRINT_NAME (msymbol
.minsym
);
404 std::string tmp
= string_printf (_(RAW_FUNCTION_ADDRESS_FORMAT
),
405 hex_string (funaddr
));
407 gdb_assert (tmp
.length () + 1 <= buf_size
);
408 return strcpy (buf
, tmp
.c_str ());
412 /* All the meta data necessary to extract the call's return value. */
414 struct call_return_meta_info
416 /* The caller frame's architecture. */
417 struct gdbarch
*gdbarch
;
419 /* The called function. */
420 struct value
*function
;
422 /* The return value's type. */
423 struct type
*value_type
;
425 /* Are we returning a value using a structure return or a normal
429 /* If using a structure return, this is the structure's address. */
430 CORE_ADDR struct_addr
;
433 /* Extract the called function's return value. */
435 static struct value
*
436 get_call_return_value (struct call_return_meta_info
*ri
)
438 struct value
*retval
= NULL
;
439 thread_info
*thr
= inferior_thread ();
440 bool stack_temporaries
= thread_stack_temporaries_enabled_p (thr
);
442 if (TYPE_CODE (ri
->value_type
) == TYPE_CODE_VOID
)
443 retval
= allocate_value (ri
->value_type
);
444 else if (ri
->struct_return_p
)
446 if (stack_temporaries
)
448 retval
= value_from_contents_and_address (ri
->value_type
, NULL
,
450 push_thread_stack_temporary (thr
, retval
);
454 retval
= allocate_value (ri
->value_type
);
455 read_value_memory (retval
, 0, 1, ri
->struct_addr
,
456 value_contents_raw (retval
),
457 TYPE_LENGTH (ri
->value_type
));
462 retval
= allocate_value (ri
->value_type
);
463 gdbarch_return_value (ri
->gdbarch
, ri
->function
, ri
->value_type
,
464 get_current_regcache (),
465 value_contents_raw (retval
), NULL
);
466 if (stack_temporaries
&& class_or_union_p (ri
->value_type
))
468 /* Values of class type returned in registers are copied onto
469 the stack and their lval_type set to lval_memory. This is
470 required because further evaluation of the expression
471 could potentially invoke methods on the return value
472 requiring GDB to evaluate the "this" pointer. To evaluate
473 the this pointer, GDB needs the memory address of the
475 value_force_lval (retval
, ri
->struct_addr
);
476 push_thread_stack_temporary (thr
, retval
);
480 gdb_assert (retval
!= NULL
);
484 /* Data for the FSM that manages an infcall. It's main job is to
485 record the called function's return value. */
487 struct call_thread_fsm
: public thread_fsm
489 /* All the info necessary to be able to extract the return
491 struct call_return_meta_info return_meta_info
;
493 /* The called function's return value. This is extracted from the
494 target before the dummy frame is popped. */
495 struct value
*return_value
= nullptr;
497 /* The top level that started the infcall (and is synchronously
498 waiting for it to end). */
499 struct ui
*waiting_ui
;
501 call_thread_fsm (struct ui
*waiting_ui
, struct interp
*cmd_interp
,
502 struct gdbarch
*gdbarch
, struct value
*function
,
503 struct type
*value_type
,
504 int struct_return_p
, CORE_ADDR struct_addr
);
506 bool should_stop (struct thread_info
*thread
) override
;
508 bool should_notify_stop () override
;
511 /* Allocate a new call_thread_fsm object. */
513 call_thread_fsm::call_thread_fsm (struct ui
*waiting_ui
,
514 struct interp
*cmd_interp
,
515 struct gdbarch
*gdbarch
,
516 struct value
*function
,
517 struct type
*value_type
,
518 int struct_return_p
, CORE_ADDR struct_addr
)
519 : thread_fsm (cmd_interp
),
520 waiting_ui (waiting_ui
)
522 return_meta_info
.gdbarch
= gdbarch
;
523 return_meta_info
.function
= function
;
524 return_meta_info
.value_type
= value_type
;
525 return_meta_info
.struct_return_p
= struct_return_p
;
526 return_meta_info
.struct_addr
= struct_addr
;
529 /* Implementation of should_stop method for infcalls. */
532 call_thread_fsm::should_stop (struct thread_info
*thread
)
534 if (stop_stack_dummy
== STOP_STACK_DUMMY
)
539 /* Stash the return value before the dummy frame is popped and
540 registers are restored to what they were before the
542 return_value
= get_call_return_value (&return_meta_info
);
544 /* Break out of wait_sync_command_done. */
545 scoped_restore save_ui
= make_scoped_restore (¤t_ui
, waiting_ui
);
546 target_terminal::ours ();
547 waiting_ui
->prompt_state
= PROMPT_NEEDED
;
553 /* Implementation of should_notify_stop method for infcalls. */
556 call_thread_fsm::should_notify_stop ()
560 /* Infcall succeeded. Be silent and proceed with evaluating the
565 /* Something wrong happened. E.g., an unexpected breakpoint
566 triggered, or a signal was intercepted. Notify the stop. */
570 /* Subroutine of call_function_by_hand to simplify it.
571 Start up the inferior and wait for it to stop.
572 Return the exception if there's an error, or an exception with
573 reason >= 0 if there's no error.
575 This is done inside a TRY_CATCH so the caller needn't worry about
576 thrown errors. The caller should rethrow if there's an error. */
578 static struct gdb_exception
579 run_inferior_call (struct call_thread_fsm
*sm
,
580 struct thread_info
*call_thread
, CORE_ADDR real_pc
)
582 struct gdb_exception caught_error
;
583 int saved_in_infcall
= call_thread
->control
.in_infcall
;
584 ptid_t call_thread_ptid
= call_thread
->ptid
;
585 enum prompt_state saved_prompt_state
= current_ui
->prompt_state
;
586 int was_running
= call_thread
->state
== THREAD_RUNNING
;
587 int saved_ui_async
= current_ui
->async
;
589 /* Infcalls run synchronously, in the foreground. */
590 current_ui
->prompt_state
= PROMPT_BLOCKED
;
591 /* So that we don't print the prompt prematurely in
592 fetch_inferior_event. */
593 current_ui
->async
= 0;
595 delete_file_handler (current_ui
->input_fd
);
597 call_thread
->control
.in_infcall
= 1;
599 clear_proceed_status (0);
601 /* Associate the FSM with the thread after clear_proceed_status
602 (otherwise it'd clear this FSM), and before anything throws, so
603 we don't leak it (and any resources it manages). */
604 call_thread
->thread_fsm
= sm
;
606 disable_watchpoints_before_interactive_call_start ();
608 /* We want to print return value, please... */
609 call_thread
->control
.proceed_to_finish
= 1;
613 proceed (real_pc
, GDB_SIGNAL_0
);
615 /* Inferior function calls are always synchronous, even if the
616 target supports asynchronous execution. */
617 wait_sync_command_done ();
619 catch (gdb_exception
&e
)
621 caught_error
= std::move (e
);
624 /* If GDB has the prompt blocked before, then ensure that it remains
625 so. normal_stop calls async_enable_stdin, so reset the prompt
626 state again here. In other cases, stdin will be re-enabled by
627 inferior_event_handler, when an exception is thrown. */
628 current_ui
->prompt_state
= saved_prompt_state
;
629 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
630 delete_file_handler (current_ui
->input_fd
);
632 ui_register_input_event_handler (current_ui
);
633 current_ui
->async
= saved_ui_async
;
635 /* If the infcall does NOT succeed, normal_stop will have already
636 finished the thread states. However, on success, normal_stop
637 defers here, so that we can set back the thread states to what
638 they were before the call. Note that we must also finish the
639 state of new threads that might have spawned while the call was
640 running. The main cases to handle are:
642 - "(gdb) print foo ()", or any other command that evaluates an
643 expression at the prompt. (The thread was marked stopped before.)
645 - "(gdb) break foo if return_false()" or similar cases where we
646 do an infcall while handling an event (while the thread is still
647 marked running). In this example, whether the condition
648 evaluates true and thus we'll present a user-visible stop is
649 decided elsewhere. */
651 && call_thread_ptid
== inferior_ptid
652 && stop_stack_dummy
== STOP_STACK_DUMMY
)
653 finish_thread_state (user_visible_resume_ptid (0));
655 enable_watchpoints_after_interactive_call_stop ();
657 /* Call breakpoint_auto_delete on the current contents of the bpstat
658 of inferior call thread.
659 If all error()s out of proceed ended up calling normal_stop
660 (and perhaps they should; it already does in the special case
661 of error out of resume()), then we wouldn't need this. */
662 if (caught_error
.reason
< 0)
664 if (call_thread
->state
!= THREAD_EXITED
)
665 breakpoint_auto_delete (call_thread
->control
.stop_bpstat
);
668 call_thread
->control
.in_infcall
= saved_in_infcall
;
676 call_function_by_hand (struct value
*function
,
677 type
*default_return_type
,
678 gdb::array_view
<value
*> args
)
680 return call_function_by_hand_dummy (function
, default_return_type
,
684 /* All this stuff with a dummy frame may seem unnecessarily complicated
685 (why not just save registers in GDB?). The purpose of pushing a dummy
686 frame which looks just like a real frame is so that if you call a
687 function and then hit a breakpoint (get a signal, etc), "backtrace"
688 will look right. Whether the backtrace needs to actually show the
689 stack at the time the inferior function was called is debatable, but
690 it certainly needs to not display garbage. So if you are contemplating
691 making dummy frames be different from normal frames, consider that. */
693 /* Perform a function call in the inferior.
694 ARGS is a vector of values of arguments (NARGS of them).
695 FUNCTION is a value, the function to be called.
696 Returns a value representing what the function returned.
697 May fail to return, if a breakpoint or signal is hit
698 during the execution of the function.
700 ARGS is modified to contain coerced values. */
703 call_function_by_hand_dummy (struct value
*function
,
704 type
*default_return_type
,
705 gdb::array_view
<value
*> args
,
706 dummy_frame_dtor_ftype
*dummy_dtor
,
707 void *dummy_dtor_data
)
710 struct type
*target_values_type
;
711 function_call_return_method return_method
= return_method_normal
;
712 CORE_ADDR struct_addr
= 0;
715 struct frame_id dummy_id
;
716 struct frame_info
*frame
;
717 struct gdbarch
*gdbarch
;
718 ptid_t call_thread_ptid
;
719 struct gdb_exception e
;
720 char name_buf
[RAW_FUNCTION_ADDRESS_SIZE
];
722 if (!may_call_functions_p
)
723 error (_("Cannot call functions in the program: "
724 "may-call-functions is off."));
726 if (!target_has_execution
)
729 if (get_traceframe_number () >= 0)
730 error (_("May not call functions while looking at trace frames."));
732 if (execution_direction
== EXEC_REVERSE
)
733 error (_("Cannot call functions in reverse mode."));
735 /* We're going to run the target, and inspect the thread's state
736 afterwards. Hold a strong reference so that the pointer remains
737 valid even if the thread exits. */
738 thread_info_ref call_thread
739 = thread_info_ref::new_reference (inferior_thread ());
741 bool stack_temporaries
= thread_stack_temporaries_enabled_p (call_thread
.get ());
743 frame
= get_current_frame ();
744 gdbarch
= get_frame_arch (frame
);
746 if (!gdbarch_push_dummy_call_p (gdbarch
))
747 error (_("This target does not support function calls."));
749 /* Find the function type and do a sanity check. */
752 CORE_ADDR funaddr
= find_function_addr (function
, &values_type
, &ftype
);
754 if (values_type
== NULL
)
755 values_type
= default_return_type
;
756 if (values_type
== NULL
)
758 const char *name
= get_function_name (funaddr
,
759 name_buf
, sizeof (name_buf
));
760 error (_("'%s' has unknown return type; "
761 "cast the call to its declared return type"),
765 values_type
= check_typedef (values_type
);
767 if (args
.size () < TYPE_NFIELDS (ftype
))
768 error (_("Too few arguments in function call."));
770 /* A holder for the inferior status.
771 This is only needed while we're preparing the inferior function call. */
772 infcall_control_state_up
inf_status (save_infcall_control_state ());
774 /* Save the caller's registers and other state associated with the
775 inferior itself so that they can be restored once the
776 callee returns. To allow nested calls the registers are (further
777 down) pushed onto a dummy frame stack. This unique pointer
778 is released once the regcache has been pushed). */
779 infcall_suspend_state_up
caller_state (save_infcall_suspend_state ());
781 /* Ensure that the initial SP is correctly aligned. */
783 CORE_ADDR old_sp
= get_frame_sp (frame
);
785 if (gdbarch_frame_align_p (gdbarch
))
787 sp
= gdbarch_frame_align (gdbarch
, old_sp
);
788 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
789 ABIs, a function can use memory beyond the inner most stack
790 address. AMD64 called that region the "red zone". Skip at
791 least the "red zone" size before allocating any space on
793 if (gdbarch_inner_than (gdbarch
, 1, 2))
794 sp
-= gdbarch_frame_red_zone_size (gdbarch
);
796 sp
+= gdbarch_frame_red_zone_size (gdbarch
);
798 gdb_assert (sp
== gdbarch_frame_align (gdbarch
, sp
));
799 /* NOTE: cagney/2002-09-18:
801 On a RISC architecture, a void parameterless generic dummy
802 frame (i.e., no parameters, no result) typically does not
803 need to push anything the stack and hence can leave SP and
804 FP. Similarly, a frameless (possibly leaf) function does
805 not push anything on the stack and, hence, that too can
806 leave FP and SP unchanged. As a consequence, a sequence of
807 void parameterless generic dummy frame calls to frameless
808 functions will create a sequence of effectively identical
809 frames (SP, FP and TOS and PC the same). This, not
810 suprisingly, results in what appears to be a stack in an
811 infinite loop --- when GDB tries to find a generic dummy
812 frame on the internal dummy frame stack, it will always
815 To avoid this problem, the code below always grows the
816 stack. That way, two dummy frames can never be identical.
817 It does burn a few bytes of stack but that is a small price
821 if (gdbarch_inner_than (gdbarch
, 1, 2))
822 /* Stack grows down. */
823 sp
= gdbarch_frame_align (gdbarch
, old_sp
- 1);
825 /* Stack grows up. */
826 sp
= gdbarch_frame_align (gdbarch
, old_sp
+ 1);
828 /* SP may have underflown address zero here from OLD_SP. Memory access
829 functions will probably fail in such case but that is a target's
833 /* FIXME: cagney/2002-09-18: Hey, you loose!
835 Who knows how badly aligned the SP is!
837 If the generic dummy frame ends up empty (because nothing is
838 pushed) GDB won't be able to correctly perform back traces.
839 If a target is having trouble with backtraces, first thing to
840 do is add FRAME_ALIGN() to the architecture vector. If that
841 fails, try dummy_id().
843 If the ABI specifies a "Red Zone" (see the doco) the code
844 below will quietly trash it. */
847 /* Skip over the stack temporaries that might have been generated during
848 the evaluation of an expression. */
849 if (stack_temporaries
)
851 struct value
*lastval
;
853 lastval
= get_last_thread_stack_temporary (call_thread
.get ());
856 CORE_ADDR lastval_addr
= value_address (lastval
);
858 if (gdbarch_inner_than (gdbarch
, 1, 2))
860 gdb_assert (sp
>= lastval_addr
);
865 gdb_assert (sp
<= lastval_addr
);
866 sp
= lastval_addr
+ TYPE_LENGTH (value_type (lastval
));
869 if (gdbarch_frame_align_p (gdbarch
))
870 sp
= gdbarch_frame_align (gdbarch
, sp
);
875 /* Are we returning a value using a structure return? */
877 if (gdbarch_return_in_first_hidden_param_p (gdbarch
, values_type
))
879 return_method
= return_method_hidden_param
;
881 /* Tell the target specific argument pushing routine not to
883 target_values_type
= builtin_type (gdbarch
)->builtin_void
;
887 if (using_struct_return (gdbarch
, function
, values_type
))
888 return_method
= return_method_struct
;
889 target_values_type
= values_type
;
892 gdb::observers::inferior_call_pre
.notify (inferior_ptid
, funaddr
);
894 /* Determine the location of the breakpoint (and possibly other
895 stuff) that the called function will return to. The SPARC, for a
896 function returning a structure or union, needs to make space for
897 not just the breakpoint but also an extra word containing the
898 size (?) of the structure being passed. */
900 switch (gdbarch_call_dummy_location (gdbarch
))
904 const gdb_byte
*bp_bytes
;
905 CORE_ADDR bp_addr_as_address
;
908 /* Be careful BP_ADDR is in inferior PC encoding while
909 BP_ADDR_AS_ADDRESS is a plain memory address. */
911 sp
= push_dummy_code (gdbarch
, sp
, funaddr
, args
,
912 target_values_type
, &real_pc
, &bp_addr
,
913 get_current_regcache ());
915 /* Write a legitimate instruction at the point where the infcall
916 breakpoint is going to be inserted. While this instruction
917 is never going to be executed, a user investigating the
918 memory from GDB would see this instruction instead of random
919 uninitialized bytes. We chose the breakpoint instruction
920 as it may look as the most logical one to the user and also
921 valgrind 3.7.0 needs it for proper vgdb inferior calls.
923 If software breakpoints are unsupported for this target we
924 leave the user visible memory content uninitialized. */
926 bp_addr_as_address
= bp_addr
;
927 bp_bytes
= gdbarch_breakpoint_from_pc (gdbarch
, &bp_addr_as_address
,
929 if (bp_bytes
!= NULL
)
930 write_memory (bp_addr_as_address
, bp_bytes
, bp_size
);
935 CORE_ADDR dummy_addr
;
938 dummy_addr
= entry_point_address ();
940 /* A call dummy always consists of just a single breakpoint, so
941 its address is the same as the address of the dummy.
943 The actual breakpoint is inserted separatly so there is no need to
945 bp_addr
= dummy_addr
;
949 internal_error (__FILE__
, __LINE__
, _("bad switch"));
952 for (int i
= args
.size () - 1; i
>= 0; i
--)
955 struct type
*param_type
;
957 /* FIXME drow/2002-05-31: Should just always mark methods as
958 prototyped. Can we respect TYPE_VARARGS? Probably not. */
959 if (TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
961 if (TYPE_TARGET_TYPE (ftype
) == NULL
&& TYPE_NFIELDS (ftype
) == 0
962 && default_return_type
!= NULL
)
964 /* Calling a no-debug function with the return type
965 explicitly cast. Assume the function is prototyped,
966 with a prototype matching the types of the arguments.
968 float mult (float v1, float v2) { return v1 * v2; }
970 (gdb) p (float) mult (2.0f, 3.0f)
971 Is a simpler alternative to:
972 (gdb) p ((float (*) (float, float)) mult) (2.0f, 3.0f)
976 else if (i
< TYPE_NFIELDS (ftype
))
977 prototyped
= TYPE_PROTOTYPED (ftype
);
981 if (i
< TYPE_NFIELDS (ftype
))
982 param_type
= TYPE_FIELD_TYPE (ftype
, i
);
986 args
[i
] = value_arg_coerce (gdbarch
, args
[i
],
987 param_type
, prototyped
, &sp
);
989 if (param_type
!= NULL
&& language_pass_by_reference (param_type
))
990 args
[i
] = value_addr (args
[i
]);
993 /* Reserve space for the return structure to be written on the
994 stack, if necessary. Make certain that the value is correctly
997 While evaluating expressions, we reserve space on the stack for
998 return values of class type even if the language ABI and the target
999 ABI do not require that the return value be passed as a hidden first
1000 argument. This is because we want to store the return value as an
1001 on-stack temporary while the expression is being evaluated. This
1002 enables us to have chained function calls in expressions.
1004 Keeping the return values as on-stack temporaries while the expression
1005 is being evaluated is OK because the thread is stopped until the
1006 expression is completely evaluated. */
1008 if (return_method
!= return_method_normal
1009 || (stack_temporaries
&& class_or_union_p (values_type
)))
1011 if (gdbarch_inner_than (gdbarch
, 1, 2))
1013 /* Stack grows downward. Align STRUCT_ADDR and SP after
1014 making space for the return value. */
1015 sp
-= TYPE_LENGTH (values_type
);
1016 if (gdbarch_frame_align_p (gdbarch
))
1017 sp
= gdbarch_frame_align (gdbarch
, sp
);
1022 /* Stack grows upward. Align the frame, allocate space, and
1023 then again, re-align the frame??? */
1024 if (gdbarch_frame_align_p (gdbarch
))
1025 sp
= gdbarch_frame_align (gdbarch
, sp
);
1027 sp
+= TYPE_LENGTH (values_type
);
1028 if (gdbarch_frame_align_p (gdbarch
))
1029 sp
= gdbarch_frame_align (gdbarch
, sp
);
1033 std::vector
<struct value
*> new_args
;
1034 if (return_method
== return_method_hidden_param
)
1036 /* Add the new argument to the front of the argument list. */
1037 new_args
.reserve (args
.size ());
1039 (value_from_pointer (lookup_pointer_type (values_type
), struct_addr
));
1040 new_args
.insert (new_args
.end (), args
.begin (), args
.end ());
1044 /* Create the dummy stack frame. Pass in the call dummy address as,
1045 presumably, the ABI code knows where, in the call dummy, the
1046 return address should be pointed. */
1047 sp
= gdbarch_push_dummy_call (gdbarch
, function
, get_current_regcache (),
1048 bp_addr
, args
.size (), args
.data (),
1049 sp
, return_method
, struct_addr
);
1051 /* Set up a frame ID for the dummy frame so we can pass it to
1052 set_momentary_breakpoint. We need to give the breakpoint a frame
1053 ID so that the breakpoint code can correctly re-identify the
1054 dummy breakpoint. */
1055 /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL,
1056 saved as the dummy-frame TOS, and used by dummy_id to form
1057 the frame ID's stack address. */
1058 dummy_id
= frame_id_build (sp
, bp_addr
);
1060 /* Create a momentary breakpoint at the return address of the
1061 inferior. That way it breaks when it returns. */
1064 symtab_and_line sal
;
1065 sal
.pspace
= current_program_space
;
1067 sal
.section
= find_pc_overlay (sal
.pc
);
1069 /* Sanity. The exact same SP value is returned by
1070 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
1071 dummy_id to form the frame ID's stack address. */
1073 = set_momentary_breakpoint (gdbarch
, sal
,
1074 dummy_id
, bp_call_dummy
).release ();
1076 /* set_momentary_breakpoint invalidates FRAME. */
1079 bpt
->disposition
= disp_del
;
1080 gdb_assert (bpt
->related_breakpoint
== bpt
);
1082 breakpoint
*longjmp_b
= set_longjmp_breakpoint_for_call_dummy ();
1085 /* Link BPT into the chain of LONGJMP_B. */
1086 bpt
->related_breakpoint
= longjmp_b
;
1087 while (longjmp_b
->related_breakpoint
!= bpt
->related_breakpoint
)
1088 longjmp_b
= longjmp_b
->related_breakpoint
;
1089 longjmp_b
->related_breakpoint
= bpt
;
1093 /* Create a breakpoint in std::terminate.
1094 If a C++ exception is raised in the dummy-frame, and the
1095 exception handler is (normally, and expected to be) out-of-frame,
1096 the default C++ handler will (wrongly) be called in an inferior
1097 function call. This is wrong, as an exception can be normally
1098 and legally handled out-of-frame. The confines of the dummy frame
1099 prevent the unwinder from finding the correct handler (or any
1100 handler, unless it is in-frame). The default handler calls
1101 std::terminate. This will kill the inferior. Assert that
1102 terminate should never be called in an inferior function
1103 call. Place a momentary breakpoint in the std::terminate function
1104 and if triggered in the call, rewind. */
1105 if (unwind_on_terminating_exception_p
)
1106 set_std_terminate_breakpoint ();
1108 /* Everything's ready, push all the info needed to restore the
1109 caller (and identify the dummy-frame) onto the dummy-frame
1111 dummy_frame_push (caller_state
.release (), &dummy_id
, call_thread
.get ());
1112 if (dummy_dtor
!= NULL
)
1113 register_dummy_frame_dtor (dummy_id
, call_thread
.get (),
1114 dummy_dtor
, dummy_dtor_data
);
1116 /* Register a clean-up for unwind_on_terminating_exception_breakpoint. */
1117 SCOPE_EXIT
{ delete_std_terminate_breakpoint (); };
1119 /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP -
1120 If you're looking to implement asynchronous dummy-frames, then
1121 just below is the place to chop this function in two.. */
1124 struct thread_fsm
*saved_sm
;
1125 struct call_thread_fsm
*sm
;
1127 /* Save the current FSM. We'll override it. */
1128 saved_sm
= call_thread
->thread_fsm
;
1129 call_thread
->thread_fsm
= NULL
;
1131 /* Save this thread's ptid, we need it later but the thread
1133 call_thread_ptid
= call_thread
->ptid
;
1135 /* Run the inferior until it stops. */
1137 /* Create the FSM used to manage the infcall. It tells infrun to
1138 not report the stop to the user, and captures the return value
1139 before the dummy frame is popped. run_inferior_call registers
1140 it with the thread ASAP. */
1141 sm
= new call_thread_fsm (current_ui
, command_interp (),
1144 return_method
!= return_method_normal
,
1147 e
= run_inferior_call (sm
, call_thread
.get (), real_pc
);
1149 gdb::observers::inferior_call_post
.notify (call_thread_ptid
, funaddr
);
1151 if (call_thread
->state
!= THREAD_EXITED
)
1153 /* The FSM should still be the same. */
1154 gdb_assert (call_thread
->thread_fsm
== sm
);
1156 if (call_thread
->thread_fsm
->finished_p ())
1158 struct value
*retval
;
1160 /* The inferior call is successful. Pop the dummy frame,
1161 which runs its destructors and restores the inferior's
1162 suspend state, and restore the inferior control
1164 dummy_frame_pop (dummy_id
, call_thread
.get ());
1165 restore_infcall_control_state (inf_status
.release ());
1167 /* Get the return value. */
1168 retval
= sm
->return_value
;
1170 /* Clean up / destroy the call FSM, and restore the
1172 call_thread
->thread_fsm
->clean_up (call_thread
.get ());
1173 delete call_thread
->thread_fsm
;
1174 call_thread
->thread_fsm
= saved_sm
;
1176 maybe_remove_breakpoints ();
1178 gdb_assert (retval
!= NULL
);
1182 /* Didn't complete. Clean up / destroy the call FSM, and restore the
1183 previous state machine, and handle the error. */
1184 call_thread
->thread_fsm
->clean_up (call_thread
.get ());
1185 delete call_thread
->thread_fsm
;
1186 call_thread
->thread_fsm
= saved_sm
;
1190 /* Rethrow an error if we got one trying to run the inferior. */
1194 const char *name
= get_function_name (funaddr
,
1195 name_buf
, sizeof (name_buf
));
1197 discard_infcall_control_state (inf_status
.release ());
1199 /* We could discard the dummy frame here if the program exited,
1200 but it will get garbage collected the next time the program is
1206 throw_error (e
.error
, _("%s\n\
1207 An error occurred while in a function called from GDB.\n\
1208 Evaluation of the expression containing the function\n\
1209 (%s) will be abandoned.\n\
1210 When the function is done executing, GDB will silently stop."),
1214 throw_exception (std::move (e
));
1218 /* If the program has exited, or we stopped at a different thread,
1219 exit and inform the user. */
1221 if (! target_has_execution
)
1223 const char *name
= get_function_name (funaddr
,
1224 name_buf
, sizeof (name_buf
));
1226 /* If we try to restore the inferior status,
1227 we'll crash as the inferior is no longer running. */
1228 discard_infcall_control_state (inf_status
.release ());
1230 /* We could discard the dummy frame here given that the program exited,
1231 but it will get garbage collected the next time the program is
1234 error (_("The program being debugged exited while in a function "
1235 "called from GDB.\n"
1236 "Evaluation of the expression containing the function\n"
1237 "(%s) will be abandoned."),
1241 if (call_thread_ptid
!= inferior_ptid
)
1243 const char *name
= get_function_name (funaddr
,
1244 name_buf
, sizeof (name_buf
));
1246 /* We've switched threads. This can happen if another thread gets a
1247 signal or breakpoint while our thread was running.
1248 There's no point in restoring the inferior status,
1249 we're in a different thread. */
1250 discard_infcall_control_state (inf_status
.release ());
1251 /* Keep the dummy frame record, if the user switches back to the
1252 thread with the hand-call, we'll need it. */
1253 if (stopped_by_random_signal
)
1255 The program received a signal in another thread while\n\
1256 making a function call from GDB.\n\
1257 Evaluation of the expression containing the function\n\
1258 (%s) will be abandoned.\n\
1259 When the function is done executing, GDB will silently stop."),
1263 The program stopped in another thread while making a function call from GDB.\n\
1264 Evaluation of the expression containing the function\n\
1265 (%s) will be abandoned.\n\
1266 When the function is done executing, GDB will silently stop."),
1271 /* Make a copy as NAME may be in an objfile freed by dummy_frame_pop. */
1272 std::string name
= get_function_name (funaddr
, name_buf
,
1275 if (stopped_by_random_signal
)
1277 /* We stopped inside the FUNCTION because of a random
1278 signal. Further execution of the FUNCTION is not
1281 if (unwind_on_signal_p
)
1283 /* The user wants the context restored. */
1285 /* We must get back to the frame we were before the
1287 dummy_frame_pop (dummy_id
, call_thread
.get ());
1289 /* We also need to restore inferior status to that before the
1291 restore_infcall_control_state (inf_status
.release ());
1293 /* FIXME: Insert a bunch of wrap_here; name can be very
1294 long if it's a C++ name with arguments and stuff. */
1296 The program being debugged was signaled while in a function called from GDB.\n\
1297 GDB has restored the context to what it was before the call.\n\
1298 To change this behavior use \"set unwindonsignal off\".\n\
1299 Evaluation of the expression containing the function\n\
1300 (%s) will be abandoned."),
1305 /* The user wants to stay in the frame where we stopped
1307 Discard inferior status, we're not at the same point
1309 discard_infcall_control_state (inf_status
.release ());
1311 /* FIXME: Insert a bunch of wrap_here; name can be very
1312 long if it's a C++ name with arguments and stuff. */
1314 The program being debugged was signaled while in a function called from GDB.\n\
1315 GDB remains in the frame where the signal was received.\n\
1316 To change this behavior use \"set unwindonsignal on\".\n\
1317 Evaluation of the expression containing the function\n\
1318 (%s) will be abandoned.\n\
1319 When the function is done executing, GDB will silently stop."),
1324 if (stop_stack_dummy
== STOP_STD_TERMINATE
)
1326 /* We must get back to the frame we were before the dummy
1328 dummy_frame_pop (dummy_id
, call_thread
.get ());
1330 /* We also need to restore inferior status to that before
1332 restore_infcall_control_state (inf_status
.release ());
1335 The program being debugged entered a std::terminate call, most likely\n\
1336 caused by an unhandled C++ exception. GDB blocked this call in order\n\
1337 to prevent the program from being terminated, and has restored the\n\
1338 context to its original state before the call.\n\
1339 To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
1340 Evaluation of the expression containing the function (%s)\n\
1341 will be abandoned."),
1344 else if (stop_stack_dummy
== STOP_NONE
)
1347 /* We hit a breakpoint inside the FUNCTION.
1348 Keep the dummy frame, the user may want to examine its state.
1349 Discard inferior status, we're not at the same point
1351 discard_infcall_control_state (inf_status
.release ());
1353 /* The following error message used to say "The expression
1354 which contained the function call has been discarded."
1355 It is a hard concept to explain in a few words. Ideally,
1356 GDB would be able to resume evaluation of the expression
1357 when the function finally is done executing. Perhaps
1358 someday this will be implemented (it would not be easy). */
1359 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1360 a C++ name with arguments and stuff. */
1362 The program being debugged stopped while in a function called from GDB.\n\
1363 Evaluation of the expression containing the function\n\
1364 (%s) will be abandoned.\n\
1365 When the function is done executing, GDB will silently stop."),
1371 /* The above code errors out, so ... */
1372 gdb_assert_not_reached ("... should not be here");
1376 _initialize_infcall (void)
1378 add_setshow_boolean_cmd ("may-call-functions", no_class
,
1379 &may_call_functions_p
, _("\
1380 Set permission to call functions in the program."), _("\
1381 Show permission to call functions in the program."), _("\
1382 When this permission is on, GDB may call functions in the program.\n\
1383 Otherwise, any sort of attempt to call a function in the program\n\
1384 will result in an error."),
1386 show_may_call_functions_p
,
1387 &setlist
, &showlist
);
1389 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure
,
1390 &coerce_float_to_double_p
, _("\
1391 Set coercion of floats to doubles when calling functions."), _("\
1392 Show coercion of floats to doubles when calling functions."), _("\
1393 Variables of type float should generally be converted to doubles before\n\
1394 calling an unprototyped function, and left alone when calling a prototyped\n\
1395 function. However, some older debug info formats do not provide enough\n\
1396 information to determine that a function is prototyped. If this flag is\n\
1397 set, GDB will perform the conversion for a function it considers\n\
1399 The default is to perform the conversion."),
1401 show_coerce_float_to_double_p
,
1402 &setlist
, &showlist
);
1404 add_setshow_boolean_cmd ("unwindonsignal", no_class
,
1405 &unwind_on_signal_p
, _("\
1406 Set unwinding of stack if a signal is received while in a call dummy."), _("\
1407 Show unwinding of stack if a signal is received while in a call dummy."), _("\
1408 The unwindonsignal lets the user determine what gdb should do if a signal\n\
1409 is received while in a function called from gdb (call dummy). If set, gdb\n\
1410 unwinds the stack and restore the context to what as it was before the call.\n\
1411 The default is to stop in the frame where the signal was received."),
1413 show_unwind_on_signal_p
,
1414 &setlist
, &showlist
);
1416 add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class
,
1417 &unwind_on_terminating_exception_p
, _("\
1418 Set unwinding of stack if std::terminate is called while in call dummy."), _("\
1419 Show unwinding of stack if std::terminate() is called while in a call dummy."),
1421 The unwind on terminating exception flag lets the user determine\n\
1422 what gdb should do if a std::terminate() call is made from the\n\
1423 default exception handler. If set, gdb unwinds the stack and restores\n\
1424 the context to what it was before the call. If unset, gdb allows the\n\
1425 std::terminate call to proceed.\n\
1426 The default is to unwind the frame."),
1428 show_unwind_on_terminating_exception_p
,
1429 &setlist
, &showlist
);