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. */
150 static struct value
*
151 value_arg_coerce (struct gdbarch
*gdbarch
, struct value
*arg
,
152 struct type
*param_type
, int is_prototyped
)
154 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
155 struct type
*arg_type
= check_typedef (value_type (arg
));
157 = param_type
? check_typedef (param_type
) : arg_type
;
159 /* Perform any Ada- and Fortran-specific coercion first. */
160 if (current_language
->la_language
== language_ada
)
161 arg
= ada_convert_actual (arg
, type
);
162 else if (current_language
->la_language
== language_fortran
)
163 type
= fortran_preserve_arg_pointer (arg
, type
);
165 /* Force the value to the target if we will need its address. At
166 this point, we could allocate arguments on the stack instead of
167 calling malloc if we knew that their addresses would not be
168 saved by the called function. */
169 arg
= value_coerce_to_target (arg
);
171 switch (TYPE_CODE (type
))
174 case TYPE_CODE_RVALUE_REF
:
176 struct value
*new_value
;
178 if (TYPE_IS_REFERENCE (arg_type
))
179 return value_cast_pointers (type
, arg
, 0);
181 /* Cast the value to the reference's target type, and then
182 convert it back to a reference. This will issue an error
183 if the value was not previously in memory - in some cases
184 we should clearly be allowing this, but how? */
185 new_value
= value_cast (TYPE_TARGET_TYPE (type
), arg
);
186 new_value
= value_ref (new_value
, TYPE_CODE (type
));
193 /* If we don't have a prototype, coerce to integer type if necessary. */
196 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin
->builtin_int
))
197 type
= builtin
->builtin_int
;
199 /* Currently all target ABIs require at least the width of an integer
200 type for an argument. We may have to conditionalize the following
201 type coercion for future targets. */
202 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin
->builtin_int
))
203 type
= builtin
->builtin_int
;
206 if (!is_prototyped
&& coerce_float_to_double_p
)
208 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin
->builtin_double
))
209 type
= builtin
->builtin_double
;
210 else if (TYPE_LENGTH (type
) > TYPE_LENGTH (builtin
->builtin_double
))
211 type
= builtin
->builtin_long_double
;
215 type
= lookup_pointer_type (type
);
217 case TYPE_CODE_ARRAY
:
218 /* Arrays are coerced to pointers to their first element, unless
219 they are vectors, in which case we want to leave them alone,
220 because they are passed by value. */
221 if (current_language
->c_style_arrays
)
222 if (!TYPE_VECTOR (type
))
223 type
= lookup_pointer_type (TYPE_TARGET_TYPE (type
));
225 case TYPE_CODE_UNDEF
:
227 case TYPE_CODE_STRUCT
:
228 case TYPE_CODE_UNION
:
231 case TYPE_CODE_RANGE
:
232 case TYPE_CODE_STRING
:
233 case TYPE_CODE_ERROR
:
234 case TYPE_CODE_MEMBERPTR
:
235 case TYPE_CODE_METHODPTR
:
236 case TYPE_CODE_METHOD
:
237 case TYPE_CODE_COMPLEX
:
242 return value_cast (type
, arg
);
248 find_function_addr (struct value
*function
,
249 struct type
**retval_type
,
250 struct type
**function_type
)
252 struct type
*ftype
= check_typedef (value_type (function
));
253 struct gdbarch
*gdbarch
= get_type_arch (ftype
);
254 struct type
*value_type
= NULL
;
255 /* Initialize it just to avoid a GCC false warning. */
256 CORE_ADDR funaddr
= 0;
258 /* If it's a member function, just look at the function
261 /* Determine address to call. */
262 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
263 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
264 funaddr
= value_address (function
);
265 else if (TYPE_CODE (ftype
) == TYPE_CODE_PTR
)
267 funaddr
= value_as_address (function
);
268 ftype
= check_typedef (TYPE_TARGET_TYPE (ftype
));
269 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
270 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
271 funaddr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, funaddr
,
272 current_top_target ());
274 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
275 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
277 if (TYPE_GNU_IFUNC (ftype
))
279 CORE_ADDR resolver_addr
= funaddr
;
281 /* Resolve the ifunc. Note this may call the resolver
282 function in the inferior. */
283 funaddr
= gnu_ifunc_resolve_addr (gdbarch
, resolver_addr
);
285 /* Skip querying the function symbol if no RETVAL_TYPE or
286 FUNCTION_TYPE have been asked for. */
287 if (retval_type
!= NULL
|| function_type
!= NULL
)
289 type
*target_ftype
= find_function_type (funaddr
);
290 /* If we don't have debug info for the target function,
291 see if we can instead extract the target function's
292 type from the type that the resolver returns. */
293 if (target_ftype
== NULL
)
294 target_ftype
= find_gnu_ifunc_target_type (resolver_addr
);
295 if (target_ftype
!= NULL
)
297 value_type
= TYPE_TARGET_TYPE (check_typedef (target_ftype
));
298 ftype
= target_ftype
;
303 value_type
= TYPE_TARGET_TYPE (ftype
);
305 else if (TYPE_CODE (ftype
) == TYPE_CODE_INT
)
307 /* Handle the case of functions lacking debugging info.
308 Their values are characters since their addresses are char. */
309 if (TYPE_LENGTH (ftype
) == 1)
310 funaddr
= value_as_address (value_addr (function
));
313 /* Handle function descriptors lacking debug info. */
314 int found_descriptor
= 0;
316 funaddr
= 0; /* pacify "gcc -Werror" */
317 if (VALUE_LVAL (function
) == lval_memory
)
321 funaddr
= value_as_address (value_addr (function
));
324 = gdbarch_convert_from_func_ptr_addr (gdbarch
, funaddr
,
325 current_top_target ());
326 if (funaddr
!= nfunaddr
)
327 found_descriptor
= 1;
329 if (!found_descriptor
)
330 /* Handle integer used as address of a function. */
331 funaddr
= (CORE_ADDR
) value_as_long (function
);
335 error (_("Invalid data type for function to be called."));
337 if (retval_type
!= NULL
)
338 *retval_type
= value_type
;
339 if (function_type
!= NULL
)
340 *function_type
= ftype
;
341 return funaddr
+ gdbarch_deprecated_function_start_offset (gdbarch
);
344 /* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called
345 function returns to. */
348 push_dummy_code (struct gdbarch
*gdbarch
,
349 CORE_ADDR sp
, CORE_ADDR funaddr
,
350 gdb::array_view
<value
*> args
,
351 struct type
*value_type
,
352 CORE_ADDR
*real_pc
, CORE_ADDR
*bp_addr
,
353 struct regcache
*regcache
)
355 gdb_assert (gdbarch_push_dummy_code_p (gdbarch
));
357 return gdbarch_push_dummy_code (gdbarch
, sp
, funaddr
,
358 args
.data (), args
.size (),
359 value_type
, real_pc
, bp_addr
,
366 error_call_unknown_return_type (const char *func_name
)
368 if (func_name
!= NULL
)
369 error (_("'%s' has unknown return type; "
370 "cast the call to its declared return type"),
373 error (_("function has unknown return type; "
374 "cast the call to its declared return type"));
377 /* Fetch the name of the function at FUNADDR.
378 This is used in printing an error message for call_function_by_hand.
379 BUF is used to print FUNADDR in hex if the function name cannot be
380 determined. It must be large enough to hold formatted result of
381 RAW_FUNCTION_ADDRESS_FORMAT. */
384 get_function_name (CORE_ADDR funaddr
, char *buf
, int buf_size
)
387 struct symbol
*symbol
= find_pc_function (funaddr
);
390 return SYMBOL_PRINT_NAME (symbol
);
394 /* Try the minimal symbols. */
395 struct bound_minimal_symbol msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
398 return MSYMBOL_PRINT_NAME (msymbol
.minsym
);
402 std::string tmp
= string_printf (_(RAW_FUNCTION_ADDRESS_FORMAT
),
403 hex_string (funaddr
));
405 gdb_assert (tmp
.length () + 1 <= buf_size
);
406 return strcpy (buf
, tmp
.c_str ());
410 /* All the meta data necessary to extract the call's return value. */
412 struct call_return_meta_info
414 /* The caller frame's architecture. */
415 struct gdbarch
*gdbarch
;
417 /* The called function. */
418 struct value
*function
;
420 /* The return value's type. */
421 struct type
*value_type
;
423 /* Are we returning a value using a structure return or a normal
427 /* If using a structure return, this is the structure's address. */
428 CORE_ADDR struct_addr
;
431 /* Extract the called function's return value. */
433 static struct value
*
434 get_call_return_value (struct call_return_meta_info
*ri
)
436 struct value
*retval
= NULL
;
437 thread_info
*thr
= inferior_thread ();
438 bool stack_temporaries
= thread_stack_temporaries_enabled_p (thr
);
440 if (TYPE_CODE (ri
->value_type
) == TYPE_CODE_VOID
)
441 retval
= allocate_value (ri
->value_type
);
442 else if (ri
->struct_return_p
)
444 if (stack_temporaries
)
446 retval
= value_from_contents_and_address (ri
->value_type
, NULL
,
448 push_thread_stack_temporary (thr
, retval
);
452 retval
= allocate_value (ri
->value_type
);
453 read_value_memory (retval
, 0, 1, ri
->struct_addr
,
454 value_contents_raw (retval
),
455 TYPE_LENGTH (ri
->value_type
));
460 retval
= allocate_value (ri
->value_type
);
461 gdbarch_return_value (ri
->gdbarch
, ri
->function
, ri
->value_type
,
462 get_current_regcache (),
463 value_contents_raw (retval
), NULL
);
464 if (stack_temporaries
&& class_or_union_p (ri
->value_type
))
466 /* Values of class type returned in registers are copied onto
467 the stack and their lval_type set to lval_memory. This is
468 required because further evaluation of the expression
469 could potentially invoke methods on the return value
470 requiring GDB to evaluate the "this" pointer. To evaluate
471 the this pointer, GDB needs the memory address of the
473 value_force_lval (retval
, ri
->struct_addr
);
474 push_thread_stack_temporary (thr
, retval
);
478 gdb_assert (retval
!= NULL
);
482 /* Data for the FSM that manages an infcall. It's main job is to
483 record the called function's return value. */
485 struct call_thread_fsm
: public thread_fsm
487 /* All the info necessary to be able to extract the return
489 struct call_return_meta_info return_meta_info
;
491 /* The called function's return value. This is extracted from the
492 target before the dummy frame is popped. */
493 struct value
*return_value
= nullptr;
495 /* The top level that started the infcall (and is synchronously
496 waiting for it to end). */
497 struct ui
*waiting_ui
;
499 call_thread_fsm (struct ui
*waiting_ui
, struct interp
*cmd_interp
,
500 struct gdbarch
*gdbarch
, struct value
*function
,
501 struct type
*value_type
,
502 int struct_return_p
, CORE_ADDR struct_addr
);
504 bool should_stop (struct thread_info
*thread
) override
;
506 bool should_notify_stop () override
;
509 /* Allocate a new call_thread_fsm object. */
511 call_thread_fsm::call_thread_fsm (struct ui
*waiting_ui
,
512 struct interp
*cmd_interp
,
513 struct gdbarch
*gdbarch
,
514 struct value
*function
,
515 struct type
*value_type
,
516 int struct_return_p
, CORE_ADDR struct_addr
)
517 : thread_fsm (cmd_interp
),
518 waiting_ui (waiting_ui
)
520 return_meta_info
.gdbarch
= gdbarch
;
521 return_meta_info
.function
= function
;
522 return_meta_info
.value_type
= value_type
;
523 return_meta_info
.struct_return_p
= struct_return_p
;
524 return_meta_info
.struct_addr
= struct_addr
;
527 /* Implementation of should_stop method for infcalls. */
530 call_thread_fsm::should_stop (struct thread_info
*thread
)
532 if (stop_stack_dummy
== STOP_STACK_DUMMY
)
537 /* Stash the return value before the dummy frame is popped and
538 registers are restored to what they were before the
540 return_value
= get_call_return_value (&return_meta_info
);
542 /* Break out of wait_sync_command_done. */
543 scoped_restore save_ui
= make_scoped_restore (¤t_ui
, waiting_ui
);
544 target_terminal::ours ();
545 waiting_ui
->prompt_state
= PROMPT_NEEDED
;
551 /* Implementation of should_notify_stop method for infcalls. */
554 call_thread_fsm::should_notify_stop ()
558 /* Infcall succeeded. Be silent and proceed with evaluating the
563 /* Something wrong happened. E.g., an unexpected breakpoint
564 triggered, or a signal was intercepted. Notify the stop. */
568 /* Subroutine of call_function_by_hand to simplify it.
569 Start up the inferior and wait for it to stop.
570 Return the exception if there's an error, or an exception with
571 reason >= 0 if there's no error.
573 This is done inside a TRY_CATCH so the caller needn't worry about
574 thrown errors. The caller should rethrow if there's an error. */
576 static struct gdb_exception
577 run_inferior_call (struct call_thread_fsm
*sm
,
578 struct thread_info
*call_thread
, CORE_ADDR real_pc
)
580 struct gdb_exception caught_error
;
581 int saved_in_infcall
= call_thread
->control
.in_infcall
;
582 ptid_t call_thread_ptid
= call_thread
->ptid
;
583 enum prompt_state saved_prompt_state
= current_ui
->prompt_state
;
584 int was_running
= call_thread
->state
== THREAD_RUNNING
;
585 int saved_ui_async
= current_ui
->async
;
587 /* Infcalls run synchronously, in the foreground. */
588 current_ui
->prompt_state
= PROMPT_BLOCKED
;
589 /* So that we don't print the prompt prematurely in
590 fetch_inferior_event. */
591 current_ui
->async
= 0;
593 delete_file_handler (current_ui
->input_fd
);
595 call_thread
->control
.in_infcall
= 1;
597 clear_proceed_status (0);
599 /* Associate the FSM with the thread after clear_proceed_status
600 (otherwise it'd clear this FSM), and before anything throws, so
601 we don't leak it (and any resources it manages). */
602 call_thread
->thread_fsm
= sm
;
604 disable_watchpoints_before_interactive_call_start ();
606 /* We want to print return value, please... */
607 call_thread
->control
.proceed_to_finish
= 1;
611 proceed (real_pc
, GDB_SIGNAL_0
);
613 /* Inferior function calls are always synchronous, even if the
614 target supports asynchronous execution. */
615 wait_sync_command_done ();
617 catch (gdb_exception
&e
)
619 caught_error
= std::move (e
);
622 /* If GDB has the prompt blocked before, then ensure that it remains
623 so. normal_stop calls async_enable_stdin, so reset the prompt
624 state again here. In other cases, stdin will be re-enabled by
625 inferior_event_handler, when an exception is thrown. */
626 current_ui
->prompt_state
= saved_prompt_state
;
627 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
628 delete_file_handler (current_ui
->input_fd
);
630 ui_register_input_event_handler (current_ui
);
631 current_ui
->async
= saved_ui_async
;
633 /* If the infcall does NOT succeed, normal_stop will have already
634 finished the thread states. However, on success, normal_stop
635 defers here, so that we can set back the thread states to what
636 they were before the call. Note that we must also finish the
637 state of new threads that might have spawned while the call was
638 running. The main cases to handle are:
640 - "(gdb) print foo ()", or any other command that evaluates an
641 expression at the prompt. (The thread was marked stopped before.)
643 - "(gdb) break foo if return_false()" or similar cases where we
644 do an infcall while handling an event (while the thread is still
645 marked running). In this example, whether the condition
646 evaluates true and thus we'll present a user-visible stop is
647 decided elsewhere. */
649 && call_thread_ptid
== inferior_ptid
650 && stop_stack_dummy
== STOP_STACK_DUMMY
)
651 finish_thread_state (user_visible_resume_ptid (0));
653 enable_watchpoints_after_interactive_call_stop ();
655 /* Call breakpoint_auto_delete on the current contents of the bpstat
656 of inferior call thread.
657 If all error()s out of proceed ended up calling normal_stop
658 (and perhaps they should; it already does in the special case
659 of error out of resume()), then we wouldn't need this. */
660 if (caught_error
.reason
< 0)
662 if (call_thread
->state
!= THREAD_EXITED
)
663 breakpoint_auto_delete (call_thread
->control
.stop_bpstat
);
666 call_thread
->control
.in_infcall
= saved_in_infcall
;
674 call_function_by_hand (struct value
*function
,
675 type
*default_return_type
,
676 gdb::array_view
<value
*> args
)
678 return call_function_by_hand_dummy (function
, default_return_type
,
682 /* All this stuff with a dummy frame may seem unnecessarily complicated
683 (why not just save registers in GDB?). The purpose of pushing a dummy
684 frame which looks just like a real frame is so that if you call a
685 function and then hit a breakpoint (get a signal, etc), "backtrace"
686 will look right. Whether the backtrace needs to actually show the
687 stack at the time the inferior function was called is debatable, but
688 it certainly needs to not display garbage. So if you are contemplating
689 making dummy frames be different from normal frames, consider that. */
691 /* Perform a function call in the inferior.
692 ARGS is a vector of values of arguments (NARGS of them).
693 FUNCTION is a value, the function to be called.
694 Returns a value representing what the function returned.
695 May fail to return, if a breakpoint or signal is hit
696 during the execution of the function.
698 ARGS is modified to contain coerced values. */
701 call_function_by_hand_dummy (struct value
*function
,
702 type
*default_return_type
,
703 gdb::array_view
<value
*> args
,
704 dummy_frame_dtor_ftype
*dummy_dtor
,
705 void *dummy_dtor_data
)
708 struct type
*target_values_type
;
709 function_call_return_method return_method
= return_method_normal
;
710 CORE_ADDR struct_addr
= 0;
713 struct frame_id dummy_id
;
714 struct frame_info
*frame
;
715 struct gdbarch
*gdbarch
;
716 ptid_t call_thread_ptid
;
717 struct gdb_exception e
;
718 char name_buf
[RAW_FUNCTION_ADDRESS_SIZE
];
720 if (!may_call_functions_p
)
721 error (_("Cannot call functions in the program: "
722 "may-call-functions is off."));
724 if (!target_has_execution
)
727 if (get_traceframe_number () >= 0)
728 error (_("May not call functions while looking at trace frames."));
730 if (execution_direction
== EXEC_REVERSE
)
731 error (_("Cannot call functions in reverse mode."));
733 /* We're going to run the target, and inspect the thread's state
734 afterwards. Hold a strong reference so that the pointer remains
735 valid even if the thread exits. */
736 thread_info_ref call_thread
737 = thread_info_ref::new_reference (inferior_thread ());
739 bool stack_temporaries
= thread_stack_temporaries_enabled_p (call_thread
.get ());
741 frame
= get_current_frame ();
742 gdbarch
= get_frame_arch (frame
);
744 if (!gdbarch_push_dummy_call_p (gdbarch
))
745 error (_("This target does not support function calls."));
747 /* Find the function type and do a sanity check. */
750 CORE_ADDR funaddr
= find_function_addr (function
, &values_type
, &ftype
);
752 if (values_type
== NULL
)
753 values_type
= default_return_type
;
754 if (values_type
== NULL
)
756 const char *name
= get_function_name (funaddr
,
757 name_buf
, sizeof (name_buf
));
758 error (_("'%s' has unknown return type; "
759 "cast the call to its declared return type"),
763 values_type
= check_typedef (values_type
);
765 if (args
.size () < TYPE_NFIELDS (ftype
))
766 error (_("Too few arguments in function call."));
768 /* A holder for the inferior status.
769 This is only needed while we're preparing the inferior function call. */
770 infcall_control_state_up
inf_status (save_infcall_control_state ());
772 /* Save the caller's registers and other state associated with the
773 inferior itself so that they can be restored once the
774 callee returns. To allow nested calls the registers are (further
775 down) pushed onto a dummy frame stack. This unique pointer
776 is released once the regcache has been pushed). */
777 infcall_suspend_state_up
caller_state (save_infcall_suspend_state ());
779 /* Ensure that the initial SP is correctly aligned. */
781 CORE_ADDR old_sp
= get_frame_sp (frame
);
783 if (gdbarch_frame_align_p (gdbarch
))
785 sp
= gdbarch_frame_align (gdbarch
, old_sp
);
786 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
787 ABIs, a function can use memory beyond the inner most stack
788 address. AMD64 called that region the "red zone". Skip at
789 least the "red zone" size before allocating any space on
791 if (gdbarch_inner_than (gdbarch
, 1, 2))
792 sp
-= gdbarch_frame_red_zone_size (gdbarch
);
794 sp
+= gdbarch_frame_red_zone_size (gdbarch
);
796 gdb_assert (sp
== gdbarch_frame_align (gdbarch
, sp
));
797 /* NOTE: cagney/2002-09-18:
799 On a RISC architecture, a void parameterless generic dummy
800 frame (i.e., no parameters, no result) typically does not
801 need to push anything the stack and hence can leave SP and
802 FP. Similarly, a frameless (possibly leaf) function does
803 not push anything on the stack and, hence, that too can
804 leave FP and SP unchanged. As a consequence, a sequence of
805 void parameterless generic dummy frame calls to frameless
806 functions will create a sequence of effectively identical
807 frames (SP, FP and TOS and PC the same). This, not
808 suprisingly, results in what appears to be a stack in an
809 infinite loop --- when GDB tries to find a generic dummy
810 frame on the internal dummy frame stack, it will always
813 To avoid this problem, the code below always grows the
814 stack. That way, two dummy frames can never be identical.
815 It does burn a few bytes of stack but that is a small price
819 if (gdbarch_inner_than (gdbarch
, 1, 2))
820 /* Stack grows down. */
821 sp
= gdbarch_frame_align (gdbarch
, old_sp
- 1);
823 /* Stack grows up. */
824 sp
= gdbarch_frame_align (gdbarch
, old_sp
+ 1);
826 /* SP may have underflown address zero here from OLD_SP. Memory access
827 functions will probably fail in such case but that is a target's
831 /* FIXME: cagney/2002-09-18: Hey, you loose!
833 Who knows how badly aligned the SP is!
835 If the generic dummy frame ends up empty (because nothing is
836 pushed) GDB won't be able to correctly perform back traces.
837 If a target is having trouble with backtraces, first thing to
838 do is add FRAME_ALIGN() to the architecture vector. If that
839 fails, try dummy_id().
841 If the ABI specifies a "Red Zone" (see the doco) the code
842 below will quietly trash it. */
845 /* Skip over the stack temporaries that might have been generated during
846 the evaluation of an expression. */
847 if (stack_temporaries
)
849 struct value
*lastval
;
851 lastval
= get_last_thread_stack_temporary (call_thread
.get ());
854 CORE_ADDR lastval_addr
= value_address (lastval
);
856 if (gdbarch_inner_than (gdbarch
, 1, 2))
858 gdb_assert (sp
>= lastval_addr
);
863 gdb_assert (sp
<= lastval_addr
);
864 sp
= lastval_addr
+ TYPE_LENGTH (value_type (lastval
));
867 if (gdbarch_frame_align_p (gdbarch
))
868 sp
= gdbarch_frame_align (gdbarch
, sp
);
873 /* Are we returning a value using a structure return? */
875 if (gdbarch_return_in_first_hidden_param_p (gdbarch
, values_type
))
877 return_method
= return_method_hidden_param
;
879 /* Tell the target specific argument pushing routine not to
881 target_values_type
= builtin_type (gdbarch
)->builtin_void
;
885 if (using_struct_return (gdbarch
, function
, values_type
))
886 return_method
= return_method_struct
;
887 target_values_type
= values_type
;
890 gdb::observers::inferior_call_pre
.notify (inferior_ptid
, funaddr
);
892 /* Determine the location of the breakpoint (and possibly other
893 stuff) that the called function will return to. The SPARC, for a
894 function returning a structure or union, needs to make space for
895 not just the breakpoint but also an extra word containing the
896 size (?) of the structure being passed. */
898 switch (gdbarch_call_dummy_location (gdbarch
))
902 const gdb_byte
*bp_bytes
;
903 CORE_ADDR bp_addr_as_address
;
906 /* Be careful BP_ADDR is in inferior PC encoding while
907 BP_ADDR_AS_ADDRESS is a plain memory address. */
909 sp
= push_dummy_code (gdbarch
, sp
, funaddr
, args
,
910 target_values_type
, &real_pc
, &bp_addr
,
911 get_current_regcache ());
913 /* Write a legitimate instruction at the point where the infcall
914 breakpoint is going to be inserted. While this instruction
915 is never going to be executed, a user investigating the
916 memory from GDB would see this instruction instead of random
917 uninitialized bytes. We chose the breakpoint instruction
918 as it may look as the most logical one to the user and also
919 valgrind 3.7.0 needs it for proper vgdb inferior calls.
921 If software breakpoints are unsupported for this target we
922 leave the user visible memory content uninitialized. */
924 bp_addr_as_address
= bp_addr
;
925 bp_bytes
= gdbarch_breakpoint_from_pc (gdbarch
, &bp_addr_as_address
,
927 if (bp_bytes
!= NULL
)
928 write_memory (bp_addr_as_address
, bp_bytes
, bp_size
);
933 CORE_ADDR dummy_addr
;
936 dummy_addr
= entry_point_address ();
938 /* A call dummy always consists of just a single breakpoint, so
939 its address is the same as the address of the dummy.
941 The actual breakpoint is inserted separatly so there is no need to
943 bp_addr
= dummy_addr
;
947 internal_error (__FILE__
, __LINE__
, _("bad switch"));
950 for (int i
= args
.size () - 1; i
>= 0; i
--)
953 struct type
*param_type
;
955 /* FIXME drow/2002-05-31: Should just always mark methods as
956 prototyped. Can we respect TYPE_VARARGS? Probably not. */
957 if (TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
959 if (TYPE_TARGET_TYPE (ftype
) == NULL
&& TYPE_NFIELDS (ftype
) == 0
960 && default_return_type
!= NULL
)
962 /* Calling a no-debug function with the return type
963 explicitly cast. Assume the function is prototyped,
964 with a prototype matching the types of the arguments.
966 float mult (float v1, float v2) { return v1 * v2; }
968 (gdb) p (float) mult (2.0f, 3.0f)
969 Is a simpler alternative to:
970 (gdb) p ((float (*) (float, float)) mult) (2.0f, 3.0f)
974 else if (i
< TYPE_NFIELDS (ftype
))
975 prototyped
= TYPE_PROTOTYPED (ftype
);
979 if (i
< TYPE_NFIELDS (ftype
))
980 param_type
= TYPE_FIELD_TYPE (ftype
, i
);
984 args
[i
] = value_arg_coerce (gdbarch
, args
[i
],
985 param_type
, prototyped
);
987 if (param_type
!= NULL
&& language_pass_by_reference (param_type
))
988 args
[i
] = value_addr (args
[i
]);
991 /* Reserve space for the return structure to be written on the
992 stack, if necessary. Make certain that the value is correctly
995 While evaluating expressions, we reserve space on the stack for
996 return values of class type even if the language ABI and the target
997 ABI do not require that the return value be passed as a hidden first
998 argument. This is because we want to store the return value as an
999 on-stack temporary while the expression is being evaluated. This
1000 enables us to have chained function calls in expressions.
1002 Keeping the return values as on-stack temporaries while the expression
1003 is being evaluated is OK because the thread is stopped until the
1004 expression is completely evaluated. */
1006 if (return_method
!= return_method_normal
1007 || (stack_temporaries
&& class_or_union_p (values_type
)))
1009 if (gdbarch_inner_than (gdbarch
, 1, 2))
1011 /* Stack grows downward. Align STRUCT_ADDR and SP after
1012 making space for the return value. */
1013 sp
-= TYPE_LENGTH (values_type
);
1014 if (gdbarch_frame_align_p (gdbarch
))
1015 sp
= gdbarch_frame_align (gdbarch
, sp
);
1020 /* Stack grows upward. Align the frame, allocate space, and
1021 then again, re-align the frame??? */
1022 if (gdbarch_frame_align_p (gdbarch
))
1023 sp
= gdbarch_frame_align (gdbarch
, sp
);
1025 sp
+= TYPE_LENGTH (values_type
);
1026 if (gdbarch_frame_align_p (gdbarch
))
1027 sp
= gdbarch_frame_align (gdbarch
, sp
);
1031 std::vector
<struct value
*> new_args
;
1032 if (return_method
== return_method_hidden_param
)
1034 /* Add the new argument to the front of the argument list. */
1035 new_args
.reserve (args
.size ());
1037 (value_from_pointer (lookup_pointer_type (values_type
), struct_addr
));
1038 new_args
.insert (new_args
.end (), args
.begin (), args
.end ());
1042 /* Create the dummy stack frame. Pass in the call dummy address as,
1043 presumably, the ABI code knows where, in the call dummy, the
1044 return address should be pointed. */
1045 sp
= gdbarch_push_dummy_call (gdbarch
, function
, get_current_regcache (),
1046 bp_addr
, args
.size (), args
.data (),
1047 sp
, return_method
, struct_addr
);
1049 /* Set up a frame ID for the dummy frame so we can pass it to
1050 set_momentary_breakpoint. We need to give the breakpoint a frame
1051 ID so that the breakpoint code can correctly re-identify the
1052 dummy breakpoint. */
1053 /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL,
1054 saved as the dummy-frame TOS, and used by dummy_id to form
1055 the frame ID's stack address. */
1056 dummy_id
= frame_id_build (sp
, bp_addr
);
1058 /* Create a momentary breakpoint at the return address of the
1059 inferior. That way it breaks when it returns. */
1062 symtab_and_line sal
;
1063 sal
.pspace
= current_program_space
;
1065 sal
.section
= find_pc_overlay (sal
.pc
);
1067 /* Sanity. The exact same SP value is returned by
1068 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
1069 dummy_id to form the frame ID's stack address. */
1071 = set_momentary_breakpoint (gdbarch
, sal
,
1072 dummy_id
, bp_call_dummy
).release ();
1074 /* set_momentary_breakpoint invalidates FRAME. */
1077 bpt
->disposition
= disp_del
;
1078 gdb_assert (bpt
->related_breakpoint
== bpt
);
1080 breakpoint
*longjmp_b
= set_longjmp_breakpoint_for_call_dummy ();
1083 /* Link BPT into the chain of LONGJMP_B. */
1084 bpt
->related_breakpoint
= longjmp_b
;
1085 while (longjmp_b
->related_breakpoint
!= bpt
->related_breakpoint
)
1086 longjmp_b
= longjmp_b
->related_breakpoint
;
1087 longjmp_b
->related_breakpoint
= bpt
;
1091 /* Create a breakpoint in std::terminate.
1092 If a C++ exception is raised in the dummy-frame, and the
1093 exception handler is (normally, and expected to be) out-of-frame,
1094 the default C++ handler will (wrongly) be called in an inferior
1095 function call. This is wrong, as an exception can be normally
1096 and legally handled out-of-frame. The confines of the dummy frame
1097 prevent the unwinder from finding the correct handler (or any
1098 handler, unless it is in-frame). The default handler calls
1099 std::terminate. This will kill the inferior. Assert that
1100 terminate should never be called in an inferior function
1101 call. Place a momentary breakpoint in the std::terminate function
1102 and if triggered in the call, rewind. */
1103 if (unwind_on_terminating_exception_p
)
1104 set_std_terminate_breakpoint ();
1106 /* Everything's ready, push all the info needed to restore the
1107 caller (and identify the dummy-frame) onto the dummy-frame
1109 dummy_frame_push (caller_state
.release (), &dummy_id
, call_thread
.get ());
1110 if (dummy_dtor
!= NULL
)
1111 register_dummy_frame_dtor (dummy_id
, call_thread
.get (),
1112 dummy_dtor
, dummy_dtor_data
);
1114 /* Register a clean-up for unwind_on_terminating_exception_breakpoint. */
1115 SCOPE_EXIT
{ delete_std_terminate_breakpoint (); };
1117 /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP -
1118 If you're looking to implement asynchronous dummy-frames, then
1119 just below is the place to chop this function in two.. */
1122 struct thread_fsm
*saved_sm
;
1123 struct call_thread_fsm
*sm
;
1125 /* Save the current FSM. We'll override it. */
1126 saved_sm
= call_thread
->thread_fsm
;
1127 call_thread
->thread_fsm
= NULL
;
1129 /* Save this thread's ptid, we need it later but the thread
1131 call_thread_ptid
= call_thread
->ptid
;
1133 /* Run the inferior until it stops. */
1135 /* Create the FSM used to manage the infcall. It tells infrun to
1136 not report the stop to the user, and captures the return value
1137 before the dummy frame is popped. run_inferior_call registers
1138 it with the thread ASAP. */
1139 sm
= new call_thread_fsm (current_ui
, command_interp (),
1142 return_method
!= return_method_normal
,
1145 e
= run_inferior_call (sm
, call_thread
.get (), real_pc
);
1147 gdb::observers::inferior_call_post
.notify (call_thread_ptid
, funaddr
);
1149 if (call_thread
->state
!= THREAD_EXITED
)
1151 /* The FSM should still be the same. */
1152 gdb_assert (call_thread
->thread_fsm
== sm
);
1154 if (call_thread
->thread_fsm
->finished_p ())
1156 struct value
*retval
;
1158 /* The inferior call is successful. Pop the dummy frame,
1159 which runs its destructors and restores the inferior's
1160 suspend state, and restore the inferior control
1162 dummy_frame_pop (dummy_id
, call_thread
.get ());
1163 restore_infcall_control_state (inf_status
.release ());
1165 /* Get the return value. */
1166 retval
= sm
->return_value
;
1168 /* Clean up / destroy the call FSM, and restore the
1170 call_thread
->thread_fsm
->clean_up (call_thread
.get ());
1171 delete call_thread
->thread_fsm
;
1172 call_thread
->thread_fsm
= saved_sm
;
1174 maybe_remove_breakpoints ();
1176 gdb_assert (retval
!= NULL
);
1180 /* Didn't complete. Clean up / destroy the call FSM, and restore the
1181 previous state machine, and handle the error. */
1182 call_thread
->thread_fsm
->clean_up (call_thread
.get ());
1183 delete call_thread
->thread_fsm
;
1184 call_thread
->thread_fsm
= saved_sm
;
1188 /* Rethrow an error if we got one trying to run the inferior. */
1192 const char *name
= get_function_name (funaddr
,
1193 name_buf
, sizeof (name_buf
));
1195 discard_infcall_control_state (inf_status
.release ());
1197 /* We could discard the dummy frame here if the program exited,
1198 but it will get garbage collected the next time the program is
1204 throw_error (e
.error
, _("%s\n\
1205 An error occurred while in a function called from GDB.\n\
1206 Evaluation of the expression containing the function\n\
1207 (%s) will be abandoned.\n\
1208 When the function is done executing, GDB will silently stop."),
1212 throw_exception (std::move (e
));
1216 /* If the program has exited, or we stopped at a different thread,
1217 exit and inform the user. */
1219 if (! target_has_execution
)
1221 const char *name
= get_function_name (funaddr
,
1222 name_buf
, sizeof (name_buf
));
1224 /* If we try to restore the inferior status,
1225 we'll crash as the inferior is no longer running. */
1226 discard_infcall_control_state (inf_status
.release ());
1228 /* We could discard the dummy frame here given that the program exited,
1229 but it will get garbage collected the next time the program is
1232 error (_("The program being debugged exited while in a function "
1233 "called from GDB.\n"
1234 "Evaluation of the expression containing the function\n"
1235 "(%s) will be abandoned."),
1239 if (call_thread_ptid
!= inferior_ptid
)
1241 const char *name
= get_function_name (funaddr
,
1242 name_buf
, sizeof (name_buf
));
1244 /* We've switched threads. This can happen if another thread gets a
1245 signal or breakpoint while our thread was running.
1246 There's no point in restoring the inferior status,
1247 we're in a different thread. */
1248 discard_infcall_control_state (inf_status
.release ());
1249 /* Keep the dummy frame record, if the user switches back to the
1250 thread with the hand-call, we'll need it. */
1251 if (stopped_by_random_signal
)
1253 The program received a signal in another thread while\n\
1254 making a function call from GDB.\n\
1255 Evaluation of the expression containing the function\n\
1256 (%s) will be abandoned.\n\
1257 When the function is done executing, GDB will silently stop."),
1261 The program stopped in another thread while making a function call from GDB.\n\
1262 Evaluation of the expression containing the function\n\
1263 (%s) will be abandoned.\n\
1264 When the function is done executing, GDB will silently stop."),
1269 /* Make a copy as NAME may be in an objfile freed by dummy_frame_pop. */
1270 std::string name
= get_function_name (funaddr
, name_buf
,
1273 if (stopped_by_random_signal
)
1275 /* We stopped inside the FUNCTION because of a random
1276 signal. Further execution of the FUNCTION is not
1279 if (unwind_on_signal_p
)
1281 /* The user wants the context restored. */
1283 /* We must get back to the frame we were before the
1285 dummy_frame_pop (dummy_id
, call_thread
.get ());
1287 /* We also need to restore inferior status to that before the
1289 restore_infcall_control_state (inf_status
.release ());
1291 /* FIXME: Insert a bunch of wrap_here; name can be very
1292 long if it's a C++ name with arguments and stuff. */
1294 The program being debugged was signaled while in a function called from GDB.\n\
1295 GDB has restored the context to what it was before the call.\n\
1296 To change this behavior use \"set unwindonsignal off\".\n\
1297 Evaluation of the expression containing the function\n\
1298 (%s) will be abandoned."),
1303 /* The user wants to stay in the frame where we stopped
1305 Discard inferior status, we're not at the same point
1307 discard_infcall_control_state (inf_status
.release ());
1309 /* FIXME: Insert a bunch of wrap_here; name can be very
1310 long if it's a C++ name with arguments and stuff. */
1312 The program being debugged was signaled while in a function called from GDB.\n\
1313 GDB remains in the frame where the signal was received.\n\
1314 To change this behavior use \"set unwindonsignal on\".\n\
1315 Evaluation of the expression containing the function\n\
1316 (%s) will be abandoned.\n\
1317 When the function is done executing, GDB will silently stop."),
1322 if (stop_stack_dummy
== STOP_STD_TERMINATE
)
1324 /* We must get back to the frame we were before the dummy
1326 dummy_frame_pop (dummy_id
, call_thread
.get ());
1328 /* We also need to restore inferior status to that before
1330 restore_infcall_control_state (inf_status
.release ());
1333 The program being debugged entered a std::terminate call, most likely\n\
1334 caused by an unhandled C++ exception. GDB blocked this call in order\n\
1335 to prevent the program from being terminated, and has restored the\n\
1336 context to its original state before the call.\n\
1337 To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
1338 Evaluation of the expression containing the function (%s)\n\
1339 will be abandoned."),
1342 else if (stop_stack_dummy
== STOP_NONE
)
1345 /* We hit a breakpoint inside the FUNCTION.
1346 Keep the dummy frame, the user may want to examine its state.
1347 Discard inferior status, we're not at the same point
1349 discard_infcall_control_state (inf_status
.release ());
1351 /* The following error message used to say "The expression
1352 which contained the function call has been discarded."
1353 It is a hard concept to explain in a few words. Ideally,
1354 GDB would be able to resume evaluation of the expression
1355 when the function finally is done executing. Perhaps
1356 someday this will be implemented (it would not be easy). */
1357 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1358 a C++ name with arguments and stuff. */
1360 The program being debugged stopped while in a function called from GDB.\n\
1361 Evaluation of the expression containing the function\n\
1362 (%s) will be abandoned.\n\
1363 When the function is done executing, GDB will silently stop."),
1369 /* The above code errors out, so ... */
1370 gdb_assert_not_reached ("... should not be here");
1374 _initialize_infcall (void)
1376 add_setshow_boolean_cmd ("may-call-functions", no_class
,
1377 &may_call_functions_p
, _("\
1378 Set permission to call functions in the program."), _("\
1379 Show permission to call functions in the program."), _("\
1380 When this permission is on, GDB may call functions in the program.\n\
1381 Otherwise, any sort of attempt to call a function in the program\n\
1382 will result in an error."),
1384 show_may_call_functions_p
,
1385 &setlist
, &showlist
);
1387 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure
,
1388 &coerce_float_to_double_p
, _("\
1389 Set coercion of floats to doubles when calling functions."), _("\
1390 Show coercion of floats to doubles when calling functions."), _("\
1391 Variables of type float should generally be converted to doubles before\n\
1392 calling an unprototyped function, and left alone when calling a prototyped\n\
1393 function. However, some older debug info formats do not provide enough\n\
1394 information to determine that a function is prototyped. If this flag is\n\
1395 set, GDB will perform the conversion for a function it considers\n\
1397 The default is to perform the conversion."),
1399 show_coerce_float_to_double_p
,
1400 &setlist
, &showlist
);
1402 add_setshow_boolean_cmd ("unwindonsignal", no_class
,
1403 &unwind_on_signal_p
, _("\
1404 Set unwinding of stack if a signal is received while in a call dummy."), _("\
1405 Show unwinding of stack if a signal is received while in a call dummy."), _("\
1406 The unwindonsignal lets the user determine what gdb should do if a signal\n\
1407 is received while in a function called from gdb (call dummy). If set, gdb\n\
1408 unwinds the stack and restore the context to what as it was before the call.\n\
1409 The default is to stop in the frame where the signal was received."),
1411 show_unwind_on_signal_p
,
1412 &setlist
, &showlist
);
1414 add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class
,
1415 &unwind_on_terminating_exception_p
, _("\
1416 Set unwinding of stack if std::terminate is called while in call dummy."), _("\
1417 Show unwinding of stack if std::terminate() is called while in a call dummy."),
1419 The unwind on terminating exception flag lets the user determine\n\
1420 what gdb should do if a std::terminate() call is made from the\n\
1421 default exception handler. If set, gdb unwinds the stack and restores\n\
1422 the context to what it was before the call. If unset, gdb allows the\n\
1423 std::terminate call to proceed.\n\
1424 The default is to unwind the frame."),
1426 show_unwind_on_terminating_exception_p
,
1427 &setlist
, &showlist
);