1 /* Perform an inferior function call, for GDB, the GNU debugger.
3 Copyright (C) 1986-2024 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"
43 #include "thread-fsm.h"
45 #include "gdbsupport/scope-exit.h"
48 /* True if we are debugging inferior calls. */
50 static bool debug_infcall
= false;
52 /* Print an "infcall" debug statement. */
54 #define infcall_debug_printf(fmt, ...) \
55 debug_prefixed_printf_cond (debug_infcall, "infcall", fmt, ##__VA_ARGS__)
57 /* Print "infcall" enter/exit debug statements. */
59 #define INFCALL_SCOPED_DEBUG_ENTER_EXIT \
60 scoped_debug_enter_exit (debug_infcall, "infcall")
62 /* Print "infcall" start/end debug statements. */
64 #define INFCALL_SCOPED_DEBUG_START_END(fmt, ...) \
65 scoped_debug_start_end (debug_infrun, "infcall", fmt, ##__VA_ARGS__)
67 /* Implement 'show debug infcall'. */
70 show_debug_infcall (struct ui_file
*file
, int from_tty
,
71 struct cmd_list_element
*c
, const char *value
)
73 gdb_printf (file
, _("Inferior call debugging is %s.\n"), value
);
76 /* If we can't find a function's name from its address,
77 we print this instead. */
78 #define RAW_FUNCTION_ADDRESS_FORMAT "at 0x%s"
79 #define RAW_FUNCTION_ADDRESS_SIZE (sizeof (RAW_FUNCTION_ADDRESS_FORMAT) \
80 + 2 * sizeof (CORE_ADDR))
82 /* NOTE: cagney/2003-04-16: What's the future of this code?
84 GDB needs an asynchronous expression evaluator, that means an
85 asynchronous inferior function call implementation, and that in
86 turn means restructuring the code so that it is event driven. */
88 static bool may_call_functions_p
= true;
90 show_may_call_functions_p (struct ui_file
*file
, int from_tty
,
91 struct cmd_list_element
*c
,
95 _("Permission to call functions in the program is %s.\n"),
99 /* How you should pass arguments to a function depends on whether it
100 was defined in K&R style or prototype style. If you define a
101 function using the K&R syntax that takes a `float' argument, then
102 callers must pass that argument as a `double'. If you define the
103 function using the prototype syntax, then you must pass the
104 argument as a `float', with no promotion.
106 Unfortunately, on certain older platforms, the debug info doesn't
107 indicate reliably how each function was defined. A function type's
108 TYPE_PROTOTYPED flag may be clear, even if the function was defined
109 in prototype style. When calling a function whose TYPE_PROTOTYPED
110 flag is clear, GDB consults this flag to decide what to do.
112 For modern targets, it is proper to assume that, if the prototype
113 flag is clear, that can be trusted: `float' arguments should be
114 promoted to `double'. For some older targets, if the prototype
115 flag is clear, that doesn't tell us anything. The default is to
116 trust the debug information; the user can override this behavior
117 with "set coerce-float-to-double 0". */
119 static bool coerce_float_to_double_p
= true;
121 show_coerce_float_to_double_p (struct ui_file
*file
, int from_tty
,
122 struct cmd_list_element
*c
, const char *value
)
125 _("Coercion of floats to doubles "
126 "when calling functions is %s.\n"),
130 /* This boolean tells what gdb should do if a signal is received while
131 in a function called from gdb (call dummy). If set, gdb unwinds
132 the stack and restore the context to what as it was before the
135 The default is to stop in the frame where the signal was received. */
137 static bool unwind_on_signal_p
= false;
139 show_unwind_on_signal_p (struct ui_file
*file
, int from_tty
,
140 struct cmd_list_element
*c
, const char *value
)
143 _("Unwinding of stack if a signal is "
144 "received while in a call dummy is %s.\n"),
148 /* This boolean tells what gdb should do if a std::terminate call is
149 made while in a function called from gdb (call dummy).
150 As the confines of a single dummy stack prohibit out-of-frame
151 handlers from handling a raised exception, and as out-of-frame
152 handlers are common in C++, this can lead to no handler being found
153 by the unwinder, and a std::terminate call. This is a false positive.
154 If set, gdb unwinds the stack and restores the context to what it
157 The default is to unwind the frame if a std::terminate call is
160 static bool unwind_on_terminating_exception_p
= true;
163 show_unwind_on_terminating_exception_p (struct ui_file
*file
, int from_tty
,
164 struct cmd_list_element
*c
,
169 _("Unwind stack if a C++ exception is "
170 "unhandled while in a call dummy is %s.\n"),
174 /* Perform the standard coercions that are specified
175 for arguments to be passed to C, Ada or Fortran functions.
177 If PARAM_TYPE is non-NULL, it is the expected parameter type.
178 IS_PROTOTYPED is non-zero if the function declaration is prototyped. */
180 static struct value
*
181 value_arg_coerce (struct gdbarch
*gdbarch
, struct value
*arg
,
182 struct type
*param_type
, int is_prototyped
)
184 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
185 struct type
*arg_type
= check_typedef (arg
->type ());
187 = param_type
? check_typedef (param_type
) : arg_type
;
189 /* Perform any Ada- and Fortran-specific coercion first. */
190 if (current_language
->la_language
== language_ada
)
191 arg
= ada_convert_actual (arg
, type
);
192 else if (current_language
->la_language
== language_fortran
)
193 type
= fortran_preserve_arg_pointer (arg
, type
);
195 /* Force the value to the target if we will need its address. At
196 this point, we could allocate arguments on the stack instead of
197 calling malloc if we knew that their addresses would not be
198 saved by the called function. */
199 arg
= value_coerce_to_target (arg
);
201 switch (type
->code ())
204 case TYPE_CODE_RVALUE_REF
:
206 struct value
*new_value
;
208 if (TYPE_IS_REFERENCE (arg_type
))
209 return value_cast_pointers (type
, arg
, 0);
211 /* Cast the value to the reference's target type, and then
212 convert it back to a reference. This will issue an error
213 if the value was not previously in memory - in some cases
214 we should clearly be allowing this, but how? */
215 new_value
= value_cast (type
->target_type (), arg
);
216 new_value
= value_ref (new_value
, type
->code ());
223 /* If we don't have a prototype, coerce to integer type if necessary. */
226 if (type
->length () < builtin
->builtin_int
->length ())
227 type
= builtin
->builtin_int
;
229 /* Currently all target ABIs require at least the width of an integer
230 type for an argument. We may have to conditionalize the following
231 type coercion for future targets. */
232 if (type
->length () < builtin
->builtin_int
->length ())
233 type
= builtin
->builtin_int
;
236 if (!is_prototyped
&& coerce_float_to_double_p
)
238 if (type
->length () < builtin
->builtin_double
->length ())
239 type
= builtin
->builtin_double
;
240 else if (type
->length () > builtin
->builtin_double
->length ())
241 type
= builtin
->builtin_long_double
;
245 type
= lookup_pointer_type (type
);
247 case TYPE_CODE_ARRAY
:
248 /* Arrays are coerced to pointers to their first element, unless
249 they are vectors, in which case we want to leave them alone,
250 because they are passed by value. */
251 if (current_language
->c_style_arrays_p ())
252 if (!type
->is_vector ())
253 type
= lookup_pointer_type (type
->target_type ());
255 case TYPE_CODE_UNDEF
:
257 case TYPE_CODE_STRUCT
:
258 case TYPE_CODE_UNION
:
261 case TYPE_CODE_RANGE
:
262 case TYPE_CODE_STRING
:
263 case TYPE_CODE_ERROR
:
264 case TYPE_CODE_MEMBERPTR
:
265 case TYPE_CODE_METHODPTR
:
266 case TYPE_CODE_METHOD
:
267 case TYPE_CODE_COMPLEX
:
272 return value_cast (type
, arg
);
278 find_function_addr (struct value
*function
,
279 struct type
**retval_type
,
280 struct type
**function_type
)
282 struct type
*ftype
= check_typedef (function
->type ());
283 struct gdbarch
*gdbarch
= ftype
->arch ();
284 struct type
*value_type
= NULL
;
285 /* Initialize it just to avoid a GCC false warning. */
286 CORE_ADDR funaddr
= 0;
288 /* If it's a member function, just look at the function
291 /* Determine address to call. */
292 if (ftype
->code () == TYPE_CODE_FUNC
293 || ftype
->code () == TYPE_CODE_METHOD
)
294 funaddr
= function
->address ();
295 else if (ftype
->code () == TYPE_CODE_PTR
)
297 funaddr
= value_as_address (function
);
298 ftype
= check_typedef (ftype
->target_type ());
299 if (ftype
->code () == TYPE_CODE_FUNC
300 || ftype
->code () == TYPE_CODE_METHOD
)
301 funaddr
= gdbarch_convert_from_func_ptr_addr
302 (gdbarch
, funaddr
, current_inferior ()->top_target());
304 if (ftype
->code () == TYPE_CODE_FUNC
305 || ftype
->code () == TYPE_CODE_METHOD
)
307 if (ftype
->is_gnu_ifunc ())
309 CORE_ADDR resolver_addr
= funaddr
;
311 /* Resolve the ifunc. Note this may call the resolver
312 function in the inferior. */
313 funaddr
= gnu_ifunc_resolve_addr (gdbarch
, resolver_addr
);
315 /* Skip querying the function symbol if no RETVAL_TYPE or
316 FUNCTION_TYPE have been asked for. */
317 if (retval_type
!= NULL
|| function_type
!= NULL
)
319 type
*target_ftype
= find_function_type (funaddr
);
320 /* If we don't have debug info for the target function,
321 see if we can instead extract the target function's
322 type from the type that the resolver returns. */
323 if (target_ftype
== NULL
)
324 target_ftype
= find_gnu_ifunc_target_type (resolver_addr
);
325 if (target_ftype
!= NULL
)
327 value_type
= check_typedef (target_ftype
)->target_type ();
328 ftype
= target_ftype
;
333 value_type
= ftype
->target_type ();
335 else if (ftype
->code () == TYPE_CODE_INT
)
337 /* Handle the case of functions lacking debugging info.
338 Their values are characters since their addresses are char. */
339 if (ftype
->length () == 1)
340 funaddr
= value_as_address (value_addr (function
));
343 /* Handle function descriptors lacking debug info. */
344 int found_descriptor
= 0;
346 funaddr
= 0; /* pacify "gcc -Werror" */
347 if (function
->lval () == lval_memory
)
351 funaddr
= value_as_address (value_addr (function
));
353 funaddr
= gdbarch_convert_from_func_ptr_addr
354 (gdbarch
, funaddr
, current_inferior ()->top_target ());
355 if (funaddr
!= nfunaddr
)
356 found_descriptor
= 1;
358 if (!found_descriptor
)
359 /* Handle integer used as address of a function. */
360 funaddr
= (CORE_ADDR
) value_as_long (function
);
364 error (_("Invalid data type for function to be called."));
366 if (retval_type
!= NULL
)
367 *retval_type
= value_type
;
368 if (function_type
!= NULL
)
369 *function_type
= ftype
;
370 return funaddr
+ gdbarch_deprecated_function_start_offset (gdbarch
);
373 /* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called
374 function returns to. */
377 push_dummy_code (struct gdbarch
*gdbarch
,
378 CORE_ADDR sp
, CORE_ADDR funaddr
,
379 gdb::array_view
<value
*> args
,
380 struct type
*value_type
,
381 CORE_ADDR
*real_pc
, CORE_ADDR
*bp_addr
,
382 struct regcache
*regcache
)
384 gdb_assert (gdbarch_push_dummy_code_p (gdbarch
));
386 return gdbarch_push_dummy_code (gdbarch
, sp
, funaddr
,
387 args
.data (), args
.size (),
388 value_type
, real_pc
, bp_addr
,
395 error_call_unknown_return_type (const char *func_name
)
397 if (func_name
!= NULL
)
398 error (_("'%s' has unknown return type; "
399 "cast the call to its declared return type"),
402 error (_("function has unknown return type; "
403 "cast the call to its declared return type"));
406 /* Fetch the name of the function at FUNADDR.
407 This is used in printing an error message for call_function_by_hand.
408 BUF is used to print FUNADDR in hex if the function name cannot be
409 determined. It must be large enough to hold formatted result of
410 RAW_FUNCTION_ADDRESS_FORMAT. */
413 get_function_name (CORE_ADDR funaddr
, char *buf
, int buf_size
)
416 struct symbol
*symbol
= find_pc_function (funaddr
);
419 return symbol
->print_name ();
423 /* Try the minimal symbols. */
424 struct bound_minimal_symbol msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
427 return msymbol
.minsym
->print_name ();
431 std::string tmp
= string_printf (_(RAW_FUNCTION_ADDRESS_FORMAT
),
432 hex_string (funaddr
));
434 gdb_assert (tmp
.length () + 1 <= buf_size
);
435 return strcpy (buf
, tmp
.c_str ());
439 /* All the meta data necessary to extract the call's return value. */
441 struct call_return_meta_info
443 /* The caller frame's architecture. */
444 struct gdbarch
*gdbarch
;
446 /* The called function. */
447 struct value
*function
;
449 /* The return value's type. */
450 struct type
*value_type
;
452 /* Are we returning a value using a structure return or a normal
456 /* If using a structure return, this is the structure's address. */
457 CORE_ADDR struct_addr
;
460 /* Extract the called function's return value. */
462 static struct value
*
463 get_call_return_value (struct call_return_meta_info
*ri
)
465 struct value
*retval
= NULL
;
466 thread_info
*thr
= inferior_thread ();
467 bool stack_temporaries
= thread_stack_temporaries_enabled_p (thr
);
469 if (ri
->value_type
->code () == TYPE_CODE_VOID
)
470 retval
= value::allocate (ri
->value_type
);
471 else if (ri
->struct_return_p
)
473 if (stack_temporaries
)
475 retval
= value_from_contents_and_address (ri
->value_type
, NULL
,
477 push_thread_stack_temporary (thr
, retval
);
480 retval
= value_at_non_lval (ri
->value_type
, ri
->struct_addr
);
484 gdbarch_return_value_as_value (ri
->gdbarch
, ri
->function
, ri
->value_type
,
485 get_thread_regcache (inferior_thread ()),
487 if (stack_temporaries
&& class_or_union_p (ri
->value_type
))
489 /* Values of class type returned in registers are copied onto
490 the stack and their lval_type set to lval_memory. This is
491 required because further evaluation of the expression
492 could potentially invoke methods on the return value
493 requiring GDB to evaluate the "this" pointer. To evaluate
494 the this pointer, GDB needs the memory address of the
496 retval
->force_lval (ri
->struct_addr
);
497 push_thread_stack_temporary (thr
, retval
);
501 gdb_assert (retval
!= NULL
);
505 /* Data for the FSM that manages an infcall. It's main job is to
506 record the called function's return value. */
508 struct call_thread_fsm
: public thread_fsm
510 /* All the info necessary to be able to extract the return
512 struct call_return_meta_info return_meta_info
;
514 /* The called function's return value. This is extracted from the
515 target before the dummy frame is popped. */
516 struct value
*return_value
= nullptr;
518 /* The top level that started the infcall (and is synchronously
519 waiting for it to end). */
520 struct ui
*waiting_ui
;
522 call_thread_fsm (struct ui
*waiting_ui
, struct interp
*cmd_interp
,
523 struct gdbarch
*gdbarch
, struct value
*function
,
524 struct type
*value_type
,
525 int struct_return_p
, CORE_ADDR struct_addr
);
527 bool should_stop (struct thread_info
*thread
) override
;
529 bool should_notify_stop () override
;
532 /* Allocate a new call_thread_fsm object. */
534 call_thread_fsm::call_thread_fsm (struct ui
*waiting_ui
,
535 struct interp
*cmd_interp
,
536 struct gdbarch
*gdbarch
,
537 struct value
*function
,
538 struct type
*value_type
,
539 int struct_return_p
, CORE_ADDR struct_addr
)
540 : thread_fsm (cmd_interp
),
541 waiting_ui (waiting_ui
)
543 return_meta_info
.gdbarch
= gdbarch
;
544 return_meta_info
.function
= function
;
545 return_meta_info
.value_type
= value_type
;
546 return_meta_info
.struct_return_p
= struct_return_p
;
547 return_meta_info
.struct_addr
= struct_addr
;
550 /* Implementation of should_stop method for infcalls. */
553 call_thread_fsm::should_stop (struct thread_info
*thread
)
555 INFCALL_SCOPED_DEBUG_ENTER_EXIT
;
557 if (stop_stack_dummy
== STOP_STACK_DUMMY
)
562 /* Stash the return value before the dummy frame is popped and
563 registers are restored to what they were before the
565 return_value
= get_call_return_value (&return_meta_info
);
568 /* We are always going to stop this thread, but we might not be planning
569 to call call normal_stop, which is only done if should_notify_stop
572 As normal_stop is responsible for calling async_enable_stdin, which
573 would break us out of wait_sync_command_done, then, if we don't plan
574 to call normal_stop, we should call async_enable_stdin here instead.
576 Unlike normal_stop, we only call async_enable_stdin on WAITING_UI, but
577 that is sufficient for wait_sync_command_done. */
578 if (!this->should_notify_stop ())
580 scoped_restore save_ui
= make_scoped_restore (¤t_ui
, waiting_ui
);
581 gdb_assert (current_ui
->prompt_state
== PROMPT_BLOCKED
);
582 async_enable_stdin ();
588 /* Implementation of should_notify_stop method for infcalls. */
591 call_thread_fsm::should_notify_stop ()
593 INFCALL_SCOPED_DEBUG_ENTER_EXIT
;
597 /* Infcall succeeded. Be silent and proceed with evaluating the
599 infcall_debug_printf ("inferior call has finished, don't notify");
603 infcall_debug_printf ("inferior call didn't complete fully");
605 if (stopped_by_random_signal
&& unwind_on_signal_p
)
607 infcall_debug_printf ("unwind-on-signal is on, don't notify");
611 if (stop_stack_dummy
== STOP_STD_TERMINATE
612 && unwind_on_terminating_exception_p
)
614 infcall_debug_printf ("unwind-on-terminating-exception is on, don't notify");
618 /* Something wrong happened. E.g., an unexpected breakpoint
619 triggered, or a signal was intercepted. Notify the stop. */
623 /* Subroutine of call_function_by_hand to simplify it.
624 Start up the inferior and wait for it to stop.
625 Return the exception if there's an error, or an exception with
626 reason >= 0 if there's no error.
628 This is done inside a TRY_CATCH so the caller needn't worry about
629 thrown errors. The caller should rethrow if there's an error. */
631 static struct gdb_exception
632 run_inferior_call (std::unique_ptr
<call_thread_fsm
> sm
,
633 struct thread_info
*call_thread
, CORE_ADDR real_pc
)
635 INFCALL_SCOPED_DEBUG_ENTER_EXIT
;
637 struct gdb_exception caught_error
;
638 ptid_t call_thread_ptid
= call_thread
->ptid
;
639 int was_running
= call_thread
->state
== THREAD_RUNNING
;
641 infcall_debug_printf ("call function at %s in thread %s, was_running = %d",
642 core_addr_to_string (real_pc
),
643 call_thread_ptid
.to_string ().c_str (),
646 current_ui
->unregister_file_handler ();
648 scoped_restore restore_in_infcall
649 = make_scoped_restore (&call_thread
->control
.in_infcall
, 1);
651 clear_proceed_status (0);
653 /* Associate the FSM with the thread after clear_proceed_status
654 (otherwise it'd clear this FSM). */
655 call_thread
->set_thread_fsm (std::move (sm
));
657 disable_watchpoints_before_interactive_call_start ();
659 /* We want to print return value, please... */
660 call_thread
->control
.proceed_to_finish
= 1;
664 /* Infcalls run synchronously, in the foreground. */
665 scoped_restore restore_prompt_state
666 = make_scoped_restore (¤t_ui
->prompt_state
, PROMPT_BLOCKED
);
668 /* So that we don't print the prompt prematurely in
669 fetch_inferior_event. */
670 scoped_restore restore_ui_async
671 = make_scoped_restore (¤t_ui
->async
, 0);
673 proceed (real_pc
, GDB_SIGNAL_0
);
675 infrun_debug_show_threads ("non-exited threads after proceed for inferior-call",
676 all_non_exited_threads ());
678 /* Inferior function calls are always synchronous, even if the
679 target supports asynchronous execution. */
680 wait_sync_command_done ();
682 infcall_debug_printf ("inferior call completed successfully");
684 catch (gdb_exception
&e
)
686 infcall_debug_printf ("exception while making inferior call (%d): %s",
687 e
.reason
, e
.what ());
688 caught_error
= std::move (e
);
691 infcall_debug_printf ("thread is now: %s",
692 inferior_ptid
.to_string ().c_str ());
694 /* After the inferior call finished, async_enable_stdin has been
695 called, either from normal_stop or from
696 call_thread_fsm::should_stop, and the prompt state has been
697 restored by the scoped_restore in the try block above.
699 If the inferior call finished successfully, then we should
700 disable stdin as we don't know yet whether the inferior will be
701 stopping. Calling async_disable_stdin restores things to how
702 they were when this function was called.
704 If the inferior call didn't complete successfully, then
705 normal_stop has already been called, and we know for sure that we
706 are going to present this stop to the user. In this case, we
707 call async_enable_stdin. This changes the prompt state to
710 If the previous prompt state was PROMPT_NEEDED, then as
711 async_enable_stdin has already been called, nothing additional
712 needs to be done here. */
713 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
715 if (call_thread
->thread_fsm ()->finished_p ())
716 async_disable_stdin ();
718 async_enable_stdin ();
721 /* If the infcall does NOT succeed, normal_stop will have already
722 finished the thread states. However, on success, normal_stop
723 defers here, so that we can set back the thread states to what
724 they were before the call. Note that we must also finish the
725 state of new threads that might have spawned while the call was
726 running. The main cases to handle are:
728 - "(gdb) print foo ()", or any other command that evaluates an
729 expression at the prompt. (The thread was marked stopped before.)
731 - "(gdb) break foo if return_false()" or similar cases where we
732 do an infcall while handling an event (while the thread is still
733 marked running). In this example, whether the condition
734 evaluates true and thus we'll present a user-visible stop is
735 decided elsewhere. */
737 && call_thread_ptid
== inferior_ptid
738 && stop_stack_dummy
== STOP_STACK_DUMMY
)
739 finish_thread_state (call_thread
->inf
->process_target (),
740 user_visible_resume_ptid (0));
742 enable_watchpoints_after_interactive_call_stop ();
744 /* Call breakpoint_auto_delete on the current contents of the bpstat
745 of inferior call thread.
746 If all error()s out of proceed ended up calling normal_stop
747 (and perhaps they should; it already does in the special case
748 of error out of resume()), then we wouldn't need this. */
749 if (caught_error
.reason
< 0)
751 if (call_thread
->state
!= THREAD_EXITED
)
752 breakpoint_auto_delete (call_thread
->control
.stop_bpstat
);
758 /* Reserve space on the stack for a value of the given type.
759 Return the address of the allocated space.
760 Make certain that the value is correctly aligned.
761 The SP argument is modified. */
764 reserve_stack_space (const type
*values_type
, CORE_ADDR
&sp
)
766 frame_info_ptr frame
= get_current_frame ();
767 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
770 if (gdbarch_inner_than (gdbarch
, 1, 2))
772 /* Stack grows downward. Align STRUCT_ADDR and SP after
774 sp
-= values_type
->length ();
775 if (gdbarch_frame_align_p (gdbarch
))
776 sp
= gdbarch_frame_align (gdbarch
, sp
);
781 /* Stack grows upward. Align the frame, allocate space, and
782 then again, re-align the frame??? */
783 if (gdbarch_frame_align_p (gdbarch
))
784 sp
= gdbarch_frame_align (gdbarch
, sp
);
786 sp
+= values_type
->length ();
787 if (gdbarch_frame_align_p (gdbarch
))
788 sp
= gdbarch_frame_align (gdbarch
, sp
);
794 /* The data structure which keeps a destructor function and
795 its implicit 'this' parameter. */
797 struct destructor_info
799 destructor_info (struct value
*function
, struct value
*self
)
800 : function (function
), self (self
) { }
802 struct value
*function
;
807 /* Auxiliary function that takes a list of destructor functions
808 with their 'this' parameters, and invokes the functions. */
811 call_destructors (const std::list
<destructor_info
> &dtors_to_invoke
,
812 struct type
*default_return_type
)
814 for (auto vals
: dtors_to_invoke
)
816 call_function_by_hand (vals
.function
, default_return_type
,
817 gdb::make_array_view (&(vals
.self
), 1));
824 call_function_by_hand (struct value
*function
,
825 type
*default_return_type
,
826 gdb::array_view
<value
*> args
)
828 return call_function_by_hand_dummy (function
, default_return_type
,
832 /* All this stuff with a dummy frame may seem unnecessarily complicated
833 (why not just save registers in GDB?). The purpose of pushing a dummy
834 frame which looks just like a real frame is so that if you call a
835 function and then hit a breakpoint (get a signal, etc), "backtrace"
836 will look right. Whether the backtrace needs to actually show the
837 stack at the time the inferior function was called is debatable, but
838 it certainly needs to not display garbage. So if you are contemplating
839 making dummy frames be different from normal frames, consider that. */
841 /* Perform a function call in the inferior.
842 ARGS is a vector of values of arguments.
843 FUNCTION is a value, the function to be called.
844 Returns a value representing what the function returned.
845 May fail to return, if a breakpoint or signal is hit
846 during the execution of the function.
848 ARGS is modified to contain coerced values. */
851 call_function_by_hand_dummy (struct value
*function
,
852 type
*default_return_type
,
853 gdb::array_view
<value
*> args
,
854 dummy_frame_dtor_ftype
*dummy_dtor
,
855 void *dummy_dtor_data
)
857 INFCALL_SCOPED_DEBUG_ENTER_EXIT
;
860 struct type
*target_values_type
;
861 function_call_return_method return_method
= return_method_normal
;
862 CORE_ADDR struct_addr
= 0;
865 struct frame_id dummy_id
;
866 frame_info_ptr frame
;
867 struct gdbarch
*gdbarch
;
868 ptid_t call_thread_ptid
;
869 struct gdb_exception e
;
870 char name_buf
[RAW_FUNCTION_ADDRESS_SIZE
];
872 if (!may_call_functions_p
)
873 error (_("Cannot call functions in the program: "
874 "may-call-functions is off."));
876 if (!target_has_execution ())
879 if (get_traceframe_number () >= 0)
880 error (_("May not call functions while looking at trace frames."));
882 if (execution_direction
== EXEC_REVERSE
)
883 error (_("Cannot call functions in reverse mode."));
885 /* We're going to run the target, and inspect the thread's state
886 afterwards. Hold a strong reference so that the pointer remains
887 valid even if the thread exits. */
888 thread_info_ref call_thread
889 = thread_info_ref::new_reference (inferior_thread ());
891 bool stack_temporaries
= thread_stack_temporaries_enabled_p (call_thread
.get ());
893 frame
= get_current_frame ();
894 gdbarch
= get_frame_arch (frame
);
896 if (!gdbarch_push_dummy_call_p (gdbarch
))
897 error (_("This target does not support function calls."));
899 /* Find the function type and do a sanity check. */
902 CORE_ADDR funaddr
= find_function_addr (function
, &values_type
, &ftype
);
904 if (is_nocall_function (ftype
))
905 error (_("Cannot call the function '%s' which does not follow the "
906 "target calling convention."),
907 get_function_name (funaddr
, name_buf
, sizeof (name_buf
)));
909 if (values_type
== NULL
|| values_type
->is_stub ())
910 values_type
= default_return_type
;
911 if (values_type
== NULL
)
913 const char *name
= get_function_name (funaddr
,
914 name_buf
, sizeof (name_buf
));
915 error (_("'%s' has unknown return type; "
916 "cast the call to its declared return type"),
920 values_type
= check_typedef (values_type
);
922 if (args
.size () < ftype
->num_fields ())
923 error (_("Too few arguments in function call."));
925 infcall_debug_printf ("calling %s", get_function_name (funaddr
, name_buf
,
928 /* A holder for the inferior status.
929 This is only needed while we're preparing the inferior function call. */
930 infcall_control_state_up
inf_status (save_infcall_control_state ());
932 /* Save the caller's registers and other state associated with the
933 inferior itself so that they can be restored once the
934 callee returns. To allow nested calls the registers are (further
935 down) pushed onto a dummy frame stack. This unique pointer
936 is released once the regcache has been pushed). */
937 infcall_suspend_state_up
caller_state (save_infcall_suspend_state ());
939 /* Ensure that the initial SP is correctly aligned. */
941 CORE_ADDR old_sp
= get_frame_sp (frame
);
943 if (gdbarch_frame_align_p (gdbarch
))
945 sp
= gdbarch_frame_align (gdbarch
, old_sp
);
946 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
947 ABIs, a function can use memory beyond the inner most stack
948 address. AMD64 called that region the "red zone". Skip at
949 least the "red zone" size before allocating any space on
951 if (gdbarch_inner_than (gdbarch
, 1, 2))
952 sp
-= gdbarch_frame_red_zone_size (gdbarch
);
954 sp
+= gdbarch_frame_red_zone_size (gdbarch
);
956 gdb_assert (sp
== gdbarch_frame_align (gdbarch
, sp
));
957 /* NOTE: cagney/2002-09-18:
959 On a RISC architecture, a void parameterless generic dummy
960 frame (i.e., no parameters, no result) typically does not
961 need to push anything the stack and hence can leave SP and
962 FP. Similarly, a frameless (possibly leaf) function does
963 not push anything on the stack and, hence, that too can
964 leave FP and SP unchanged. As a consequence, a sequence of
965 void parameterless generic dummy frame calls to frameless
966 functions will create a sequence of effectively identical
967 frames (SP, FP and TOS and PC the same). This, not
968 surprisingly, results in what appears to be a stack in an
969 infinite loop --- when GDB tries to find a generic dummy
970 frame on the internal dummy frame stack, it will always
973 To avoid this problem, the code below always grows the
974 stack. That way, two dummy frames can never be identical.
975 It does burn a few bytes of stack but that is a small price
979 if (gdbarch_inner_than (gdbarch
, 1, 2))
980 /* Stack grows down. */
981 sp
= gdbarch_frame_align (gdbarch
, old_sp
- 1);
983 /* Stack grows up. */
984 sp
= gdbarch_frame_align (gdbarch
, old_sp
+ 1);
986 /* SP may have underflown address zero here from OLD_SP. Memory access
987 functions will probably fail in such case but that is a target's
991 /* FIXME: cagney/2002-09-18: Hey, you loose!
993 Who knows how badly aligned the SP is!
995 If the generic dummy frame ends up empty (because nothing is
996 pushed) GDB won't be able to correctly perform back traces.
997 If a target is having trouble with backtraces, first thing to
998 do is add FRAME_ALIGN() to the architecture vector. If that
999 fails, try dummy_id().
1001 If the ABI specifies a "Red Zone" (see the doco) the code
1002 below will quietly trash it. */
1005 /* Skip over the stack temporaries that might have been generated during
1006 the evaluation of an expression. */
1007 if (stack_temporaries
)
1009 struct value
*lastval
;
1011 lastval
= get_last_thread_stack_temporary (call_thread
.get ());
1012 if (lastval
!= NULL
)
1014 CORE_ADDR lastval_addr
= lastval
->address ();
1016 if (gdbarch_inner_than (gdbarch
, 1, 2))
1018 gdb_assert (sp
>= lastval_addr
);
1023 gdb_assert (sp
<= lastval_addr
);
1024 sp
= lastval_addr
+ lastval
->type ()->length ();
1027 if (gdbarch_frame_align_p (gdbarch
))
1028 sp
= gdbarch_frame_align (gdbarch
, sp
);
1033 /* Are we returning a value using a structure return? */
1035 if (gdbarch_return_in_first_hidden_param_p (gdbarch
, values_type
))
1037 return_method
= return_method_hidden_param
;
1039 /* Tell the target specific argument pushing routine not to
1041 target_values_type
= builtin_type (gdbarch
)->builtin_void
;
1045 if (using_struct_return (gdbarch
, function
, values_type
))
1046 return_method
= return_method_struct
;
1047 target_values_type
= values_type
;
1050 gdb::observers::inferior_call_pre
.notify (inferior_ptid
, funaddr
);
1052 /* Determine the location of the breakpoint (and possibly other
1053 stuff) that the called function will return to. The SPARC, for a
1054 function returning a structure or union, needs to make space for
1055 not just the breakpoint but also an extra word containing the
1056 size (?) of the structure being passed. */
1058 switch (gdbarch_call_dummy_location (gdbarch
))
1062 const gdb_byte
*bp_bytes
;
1063 CORE_ADDR bp_addr_as_address
;
1066 /* Be careful BP_ADDR is in inferior PC encoding while
1067 BP_ADDR_AS_ADDRESS is a plain memory address. */
1069 sp
= push_dummy_code (gdbarch
, sp
, funaddr
, args
,
1070 target_values_type
, &real_pc
, &bp_addr
,
1071 get_thread_regcache (inferior_thread ()));
1073 /* Write a legitimate instruction at the point where the infcall
1074 breakpoint is going to be inserted. While this instruction
1075 is never going to be executed, a user investigating the
1076 memory from GDB would see this instruction instead of random
1077 uninitialized bytes. We chose the breakpoint instruction
1078 as it may look as the most logical one to the user and also
1079 valgrind 3.7.0 needs it for proper vgdb inferior calls.
1081 If software breakpoints are unsupported for this target we
1082 leave the user visible memory content uninitialized. */
1084 bp_addr_as_address
= bp_addr
;
1085 bp_bytes
= gdbarch_breakpoint_from_pc (gdbarch
, &bp_addr_as_address
,
1087 if (bp_bytes
!= NULL
)
1088 write_memory (bp_addr_as_address
, bp_bytes
, bp_size
);
1091 case AT_ENTRY_POINT
:
1093 CORE_ADDR dummy_addr
;
1096 dummy_addr
= entry_point_address ();
1098 /* A call dummy always consists of just a single breakpoint, so
1099 its address is the same as the address of the dummy.
1101 The actual breakpoint is inserted separatly so there is no need to
1103 bp_addr
= dummy_addr
;
1107 internal_error (_("bad switch"));
1110 /* Coerce the arguments and handle pass-by-reference.
1111 We want to remember the destruction required for pass-by-ref values.
1112 For these, store the dtor function and the 'this' argument
1113 in DTORS_TO_INVOKE. */
1114 std::list
<destructor_info
> dtors_to_invoke
;
1116 for (int i
= args
.size () - 1; i
>= 0; i
--)
1119 struct type
*param_type
;
1121 /* FIXME drow/2002-05-31: Should just always mark methods as
1122 prototyped. Can we respect TYPE_VARARGS? Probably not. */
1123 if (ftype
->code () == TYPE_CODE_METHOD
)
1125 else if (ftype
->target_type () == NULL
&& ftype
->num_fields () == 0
1126 && default_return_type
!= NULL
)
1128 /* Calling a no-debug function with the return type
1129 explicitly cast. Assume the function is prototyped,
1130 with a prototype matching the types of the arguments.
1132 float mult (float v1, float v2) { return v1 * v2; }
1134 (gdb) p (float) mult (2.0f, 3.0f)
1135 Is a simpler alternative to:
1136 (gdb) p ((float (*) (float, float)) mult) (2.0f, 3.0f)
1140 else if (i
< ftype
->num_fields ())
1141 prototyped
= ftype
->is_prototyped ();
1145 if (i
< ftype
->num_fields ())
1146 param_type
= ftype
->field (i
).type ();
1150 value
*original_arg
= args
[i
];
1151 args
[i
] = value_arg_coerce (gdbarch
, args
[i
],
1152 param_type
, prototyped
);
1154 if (param_type
== NULL
)
1157 auto info
= language_pass_by_reference (param_type
);
1158 if (!info
.copy_constructible
)
1159 error (_("expression cannot be evaluated because the type '%s' "
1160 "is not copy constructible"), param_type
->name ());
1162 if (!info
.destructible
)
1163 error (_("expression cannot be evaluated because the type '%s' "
1164 "is not destructible"), param_type
->name ());
1166 if (info
.trivially_copyable
)
1169 /* Make a copy of the argument on the stack. If the argument is
1170 trivially copy ctor'able, copy bit by bit. Otherwise, call
1171 the copy ctor to initialize the clone. */
1172 CORE_ADDR addr
= reserve_stack_space (param_type
, sp
);
1174 = value_from_contents_and_address (param_type
, nullptr, addr
);
1175 push_thread_stack_temporary (call_thread
.get (), clone
);
1177 = value_from_pointer (lookup_pointer_type (param_type
), addr
);
1179 if (info
.trivially_copy_constructible
)
1181 int length
= param_type
->length ();
1182 write_memory (addr
, args
[i
]->contents ().data (), length
);
1187 value
*cctor_args
[2] = { clone_ptr
, original_arg
};
1188 find_overload_match (gdb::make_array_view (cctor_args
, 2),
1189 param_type
->name (), METHOD
,
1190 &clone_ptr
, nullptr, ©_ctor
, nullptr,
1191 nullptr, 0, EVAL_NORMAL
);
1193 if (copy_ctor
== nullptr)
1194 error (_("expression cannot be evaluated because a copy "
1195 "constructor for the type '%s' could not be found "
1196 "(maybe inlined?)"), param_type
->name ());
1198 call_function_by_hand (copy_ctor
, default_return_type
,
1199 gdb::make_array_view (cctor_args
, 2));
1202 /* If the argument has a destructor, remember it so that we
1203 invoke it after the infcall is complete. */
1204 if (!info
.trivially_destructible
)
1206 /* Looking up the function via overload resolution does not
1207 work because the compiler (in particular, gcc) adds an
1208 artificial int parameter in some cases. So we look up
1209 the function by using the "~" name. This should be OK
1210 because there can be only one dtor definition. */
1211 const char *dtor_name
= nullptr;
1212 for (int fieldnum
= 0;
1213 fieldnum
< TYPE_NFN_FIELDS (param_type
);
1217 = TYPE_FN_FIELDLIST1 (param_type
, fieldnum
);
1218 const char *field_name
1219 = TYPE_FN_FIELDLIST_NAME (param_type
, fieldnum
);
1221 if (field_name
[0] == '~')
1222 dtor_name
= TYPE_FN_FIELD_PHYSNAME (fn
, 0);
1225 if (dtor_name
== nullptr)
1226 error (_("expression cannot be evaluated because a destructor "
1227 "for the type '%s' could not be found "
1228 "(maybe inlined?)"), param_type
->name ());
1231 = find_function_in_inferior (dtor_name
, 0);
1233 /* Insert the dtor to the front of the list to call them
1234 in reverse order later. */
1235 dtors_to_invoke
.emplace_front (dtor
, clone_ptr
);
1238 args
[i
] = clone_ptr
;
1241 /* Reserve space for the return structure to be written on the
1242 stack, if necessary.
1244 While evaluating expressions, we reserve space on the stack for
1245 return values of class type even if the language ABI and the target
1246 ABI do not require that the return value be passed as a hidden first
1247 argument. This is because we want to store the return value as an
1248 on-stack temporary while the expression is being evaluated. This
1249 enables us to have chained function calls in expressions.
1251 Keeping the return values as on-stack temporaries while the expression
1252 is being evaluated is OK because the thread is stopped until the
1253 expression is completely evaluated. */
1255 if (return_method
!= return_method_normal
1256 || (stack_temporaries
&& class_or_union_p (values_type
)))
1257 struct_addr
= reserve_stack_space (values_type
, sp
);
1259 std::vector
<struct value
*> new_args
;
1260 if (return_method
== return_method_hidden_param
)
1262 /* Add the new argument to the front of the argument list. */
1263 new_args
.reserve (1 + args
.size ());
1265 (value_from_pointer (lookup_pointer_type (values_type
), struct_addr
));
1266 new_args
.insert (new_args
.end (), args
.begin (), args
.end ());
1270 /* Create the dummy stack frame. Pass in the call dummy address as,
1271 presumably, the ABI code knows where, in the call dummy, the
1272 return address should be pointed. */
1273 sp
= gdbarch_push_dummy_call (gdbarch
, function
,
1274 get_thread_regcache (inferior_thread ()),
1275 bp_addr
, args
.size (), args
.data (),
1276 sp
, return_method
, struct_addr
);
1278 /* Set up a frame ID for the dummy frame so we can pass it to
1279 set_momentary_breakpoint. We need to give the breakpoint a frame
1280 ID so that the breakpoint code can correctly re-identify the
1281 dummy breakpoint. */
1282 /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL,
1283 saved as the dummy-frame TOS, and used by dummy_id to form
1284 the frame ID's stack address. */
1285 dummy_id
= frame_id_build (sp
, bp_addr
);
1287 /* Create a momentary breakpoint at the return address of the
1288 inferior. That way it breaks when it returns. */
1291 symtab_and_line sal
;
1292 sal
.pspace
= current_program_space
;
1294 sal
.section
= find_pc_overlay (sal
.pc
);
1296 /* Sanity. The exact same SP value is returned by
1297 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
1298 dummy_id to form the frame ID's stack address. */
1300 = set_momentary_breakpoint (gdbarch
, sal
,
1301 dummy_id
, bp_call_dummy
).release ();
1303 /* set_momentary_breakpoint invalidates FRAME. */
1306 bpt
->disposition
= disp_del
;
1307 gdb_assert (bpt
->related_breakpoint
== bpt
);
1309 breakpoint
*longjmp_b
= set_longjmp_breakpoint_for_call_dummy ();
1312 /* Link BPT into the chain of LONGJMP_B. */
1313 bpt
->related_breakpoint
= longjmp_b
;
1314 while (longjmp_b
->related_breakpoint
!= bpt
->related_breakpoint
)
1315 longjmp_b
= longjmp_b
->related_breakpoint
;
1316 longjmp_b
->related_breakpoint
= bpt
;
1320 /* Create a breakpoint in std::terminate.
1321 If a C++ exception is raised in the dummy-frame, and the
1322 exception handler is (normally, and expected to be) out-of-frame,
1323 the default C++ handler will (wrongly) be called in an inferior
1324 function call. This is wrong, as an exception can be normally
1325 and legally handled out-of-frame. The confines of the dummy frame
1326 prevent the unwinder from finding the correct handler (or any
1327 handler, unless it is in-frame). The default handler calls
1328 std::terminate. This will kill the inferior. Assert that
1329 terminate should never be called in an inferior function
1330 call. Place a momentary breakpoint in the std::terminate function
1331 and if triggered in the call, rewind. */
1332 if (unwind_on_terminating_exception_p
)
1333 set_std_terminate_breakpoint ();
1335 /* Everything's ready, push all the info needed to restore the
1336 caller (and identify the dummy-frame) onto the dummy-frame
1338 dummy_frame_push (caller_state
.release (), &dummy_id
, call_thread
.get ());
1339 if (dummy_dtor
!= NULL
)
1340 register_dummy_frame_dtor (dummy_id
, call_thread
.get (),
1341 dummy_dtor
, dummy_dtor_data
);
1343 /* Register a clean-up for unwind_on_terminating_exception_breakpoint. */
1344 SCOPE_EXIT
{ delete_std_terminate_breakpoint (); };
1346 /* The stopped_by_random_signal variable is global. If we are here
1347 as part of a breakpoint condition check then the global will have
1348 already been setup as part of the original breakpoint stop. By
1349 making the inferior call the global will be changed when GDB
1350 handles the stop after the inferior call. Avoid confusion by
1351 restoring the current value after the inferior call. */
1352 scoped_restore restore_stopped_by_random_signal
1353 = make_scoped_restore (&stopped_by_random_signal
, 0);
1355 /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP -
1356 If you're looking to implement asynchronous dummy-frames, then
1357 just below is the place to chop this function in two.. */
1360 /* Save the current FSM. We'll override it. */
1361 std::unique_ptr
<thread_fsm
> saved_sm
= call_thread
->release_thread_fsm ();
1362 struct call_thread_fsm
*sm
;
1364 /* Save this thread's ptid, we need it later but the thread
1366 call_thread_ptid
= call_thread
->ptid
;
1368 /* Run the inferior until it stops. */
1370 /* Create the FSM used to manage the infcall. It tells infrun to
1371 not report the stop to the user, and captures the return value
1372 before the dummy frame is popped. run_inferior_call registers
1373 it with the thread ASAP. */
1374 sm
= new call_thread_fsm (current_ui
, command_interp (),
1377 return_method
!= return_method_normal
,
1380 std::unique_ptr
<call_thread_fsm
> sm_up (sm
);
1381 e
= run_inferior_call (std::move (sm_up
), call_thread
.get (), real_pc
);
1385 infcall_debug_printf ("after inferior call, exception (%d): %s",
1386 e
.reason
, e
.what ());
1387 infcall_debug_printf ("after inferior call, thread state is: %s",
1388 thread_state_string (call_thread
->state
));
1390 gdb::observers::inferior_call_post
.notify (call_thread_ptid
, funaddr
);
1393 /* As the inferior call failed, we are about to throw an error, which
1394 will be caught and printed somewhere else in GDB. We want new threads
1395 to be printed before the error message, otherwise it looks odd; the
1396 threads appear after GDB has reported a stop. */
1397 update_thread_list ();
1399 if (call_thread
->state
!= THREAD_EXITED
)
1401 /* The FSM should still be the same. */
1402 gdb_assert (call_thread
->thread_fsm () == sm
);
1404 if (call_thread
->thread_fsm ()->finished_p ())
1406 struct value
*retval
;
1408 infcall_debug_printf ("call completed");
1410 /* The inferior call is successful. Pop the dummy frame,
1411 which runs its destructors and restores the inferior's
1412 suspend state, and restore the inferior control
1414 dummy_frame_pop (dummy_id
, call_thread
.get ());
1415 restore_infcall_control_state (inf_status
.release ());
1417 /* Get the return value. */
1418 retval
= sm
->return_value
;
1420 /* Restore the original FSM and clean up / destroy the call FSM.
1421 Doing it in this order ensures that if the call to clean_up
1422 throws, the original FSM is properly restored. */
1424 std::unique_ptr
<thread_fsm
> finalizing
1425 = call_thread
->release_thread_fsm ();
1426 call_thread
->set_thread_fsm (std::move (saved_sm
));
1428 finalizing
->clean_up (call_thread
.get ());
1431 maybe_remove_breakpoints ();
1433 gdb_assert (retval
!= NULL
);
1435 /* Destruct the pass-by-ref argument clones. */
1436 call_destructors (dtors_to_invoke
, default_return_type
);
1441 infcall_debug_printf ("call did not complete");
1443 /* Didn't complete. Clean up / destroy the call FSM, and restore the
1444 previous state machine, and handle the error. */
1446 std::unique_ptr
<thread_fsm
> finalizing
1447 = call_thread
->release_thread_fsm ();
1448 call_thread
->set_thread_fsm (std::move (saved_sm
));
1450 finalizing
->clean_up (call_thread
.get ());
1455 /* Rethrow an error if we got one trying to run the inferior. */
1459 const char *name
= get_function_name (funaddr
,
1460 name_buf
, sizeof (name_buf
));
1462 discard_infcall_control_state (inf_status
.release ());
1464 /* We could discard the dummy frame here if the program exited,
1465 but it will get garbage collected the next time the program is
1471 throw_error (e
.error
, _("%s\n\
1472 An error occurred while in a function called from GDB.\n\
1473 Evaluation of the expression containing the function\n\
1474 (%s) will be abandoned.\n\
1475 When the function is done executing, GDB will silently stop."),
1479 throw_exception (std::move (e
));
1483 /* If the program has exited, or we stopped at a different thread,
1484 exit and inform the user. */
1486 if (! target_has_execution ())
1488 const char *name
= get_function_name (funaddr
,
1489 name_buf
, sizeof (name_buf
));
1491 /* If we try to restore the inferior status,
1492 we'll crash as the inferior is no longer running. */
1493 discard_infcall_control_state (inf_status
.release ());
1495 /* We could discard the dummy frame here given that the program exited,
1496 but it will get garbage collected the next time the program is
1499 error (_("The program being debugged exited while in a function "
1500 "called from GDB.\n"
1501 "Evaluation of the expression containing the function\n"
1502 "(%s) will be abandoned."),
1506 if (call_thread_ptid
!= inferior_ptid
)
1508 const char *name
= get_function_name (funaddr
,
1509 name_buf
, sizeof (name_buf
));
1511 /* We've switched threads. This can happen if another thread gets a
1512 signal or breakpoint while our thread was running.
1513 There's no point in restoring the inferior status,
1514 we're in a different thread. */
1515 discard_infcall_control_state (inf_status
.release ());
1516 /* Keep the dummy frame record, if the user switches back to the
1517 thread with the hand-call, we'll need it. */
1518 if (stopped_by_random_signal
)
1520 The program received a signal in another thread while\n\
1521 making a function call from GDB.\n\
1522 Evaluation of the expression containing the function\n\
1523 (%s) will be abandoned.\n\
1524 When the function is done executing, GDB will silently stop."),
1528 The program stopped in another thread while making a function call from GDB.\n\
1529 Evaluation of the expression containing the function\n\
1530 (%s) will be abandoned.\n\
1531 When the function is done executing, GDB will silently stop."),
1536 /* Make a copy as NAME may be in an objfile freed by dummy_frame_pop. */
1537 std::string name
= get_function_name (funaddr
, name_buf
,
1540 if (stopped_by_random_signal
)
1542 /* We stopped inside the FUNCTION because of a random
1543 signal. Further execution of the FUNCTION is not
1546 if (unwind_on_signal_p
)
1548 /* The user wants the context restored. */
1550 /* Capture details of the signal so we can include them in
1551 the error message. Calling dummy_frame_pop will restore
1552 the previous stop signal details. */
1553 gdb_signal stop_signal
= call_thread
->stop_signal ();
1555 /* We must get back to the frame we were before the
1557 dummy_frame_pop (dummy_id
, call_thread
.get ());
1559 /* We also need to restore inferior status to that before the
1561 restore_infcall_control_state (inf_status
.release ());
1563 /* FIXME: Insert a bunch of wrap_here; name can be very
1564 long if it's a C++ name with arguments and stuff. */
1566 The program being debugged received signal %s, %s\n\
1567 while in a function called from GDB. GDB has restored the context\n\
1568 to what it was before the call. To change this behavior use\n\
1569 \"set unwindonsignal off\". Evaluation of the expression containing\n\
1570 the function (%s) will be abandoned."),
1571 gdb_signal_to_name (stop_signal
),
1572 gdb_signal_to_string (stop_signal
),
1577 /* The user wants to stay in the frame where we stopped
1579 Discard inferior status, we're not at the same point
1581 discard_infcall_control_state (inf_status
.release ());
1583 /* FIXME: Insert a bunch of wrap_here; name can be very
1584 long if it's a C++ name with arguments and stuff. */
1586 The program being debugged was signaled while in a function called from GDB.\n\
1587 GDB remains in the frame where the signal was received.\n\
1588 To change this behavior use \"set unwindonsignal on\".\n\
1589 Evaluation of the expression containing the function\n\
1590 (%s) will be abandoned.\n\
1591 When the function is done executing, GDB will silently stop."),
1596 if (stop_stack_dummy
== STOP_STD_TERMINATE
)
1598 /* We must get back to the frame we were before the dummy
1600 dummy_frame_pop (dummy_id
, call_thread
.get ());
1602 /* We also need to restore inferior status to that before
1604 restore_infcall_control_state (inf_status
.release ());
1607 The program being debugged entered a std::terminate call, most likely\n\
1608 caused by an unhandled C++ exception. GDB blocked this call in order\n\
1609 to prevent the program from being terminated, and has restored the\n\
1610 context to its original state before the call.\n\
1611 To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
1612 Evaluation of the expression containing the function (%s)\n\
1613 will be abandoned."),
1616 else if (stop_stack_dummy
== STOP_NONE
)
1619 /* We hit a breakpoint inside the FUNCTION.
1620 Keep the dummy frame, the user may want to examine its state.
1621 Discard inferior status, we're not at the same point
1623 discard_infcall_control_state (inf_status
.release ());
1625 /* The following error message used to say "The expression
1626 which contained the function call has been discarded."
1627 It is a hard concept to explain in a few words. Ideally,
1628 GDB would be able to resume evaluation of the expression
1629 when the function finally is done executing. Perhaps
1630 someday this will be implemented (it would not be easy). */
1631 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1632 a C++ name with arguments and stuff. */
1634 The program being debugged stopped while in a function called from GDB.\n\
1635 Evaluation of the expression containing the function\n\
1636 (%s) will be abandoned.\n\
1637 When the function is done executing, GDB will silently stop."),
1643 /* The above code errors out, so ... */
1644 gdb_assert_not_reached ("... should not be here");
1647 void _initialize_infcall ();
1649 _initialize_infcall ()
1651 add_setshow_boolean_cmd ("may-call-functions", no_class
,
1652 &may_call_functions_p
, _("\
1653 Set permission to call functions in the program."), _("\
1654 Show permission to call functions in the program."), _("\
1655 When this permission is on, GDB may call functions in the program.\n\
1656 Otherwise, any sort of attempt to call a function in the program\n\
1657 will result in an error."),
1659 show_may_call_functions_p
,
1660 &setlist
, &showlist
);
1662 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure
,
1663 &coerce_float_to_double_p
, _("\
1664 Set coercion of floats to doubles when calling functions."), _("\
1665 Show coercion of floats to doubles when calling functions."), _("\
1666 Variables of type float should generally be converted to doubles before\n\
1667 calling an unprototyped function, and left alone when calling a prototyped\n\
1668 function. However, some older debug info formats do not provide enough\n\
1669 information to determine that a function is prototyped. If this flag is\n\
1670 set, GDB will perform the conversion for a function it considers\n\
1672 The default is to perform the conversion."),
1674 show_coerce_float_to_double_p
,
1675 &setlist
, &showlist
);
1677 add_setshow_boolean_cmd ("unwindonsignal", no_class
,
1678 &unwind_on_signal_p
, _("\
1679 Set unwinding of stack if a signal is received while in a call dummy."), _("\
1680 Show unwinding of stack if a signal is received while in a call dummy."), _("\
1681 The unwindonsignal lets the user determine what gdb should do if a signal\n\
1682 is received while in a function called from gdb (call dummy). If set, gdb\n\
1683 unwinds the stack and restore the context to what as it was before the call.\n\
1684 The default is to stop in the frame where the signal was received."),
1686 show_unwind_on_signal_p
,
1687 &setlist
, &showlist
);
1689 add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class
,
1690 &unwind_on_terminating_exception_p
, _("\
1691 Set unwinding of stack if std::terminate is called while in call dummy."), _("\
1692 Show unwinding of stack if std::terminate() is called while in a call dummy."),
1694 The unwind on terminating exception flag lets the user determine\n\
1695 what gdb should do if a std::terminate() call is made from the\n\
1696 default exception handler. If set, gdb unwinds the stack and restores\n\
1697 the context to what it was before the call. If unset, gdb allows the\n\
1698 std::terminate call to proceed.\n\
1699 The default is to unwind the frame."),
1701 show_unwind_on_terminating_exception_p
,
1702 &setlist
, &showlist
);
1704 add_setshow_boolean_cmd
1705 ("infcall", class_maintenance
, &debug_infcall
,
1706 _("Set inferior call debugging."),
1707 _("Show inferior call debugging."),
1708 _("When on, inferior function call specific debugging is enabled."),
1709 NULL
, show_debug_infcall
, &setdebuglist
, &showdebuglist
);