1 /* Perform an inferior function call, for GDB, the GNU debugger.
3 Copyright (C) 1986-2023 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_current_regcache (),
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
);
567 /* Break out of wait_sync_command_done. */
568 scoped_restore save_ui
= make_scoped_restore (¤t_ui
, waiting_ui
);
569 target_terminal::ours ();
570 waiting_ui
->prompt_state
= PROMPT_NEEDED
;
576 /* Implementation of should_notify_stop method for infcalls. */
579 call_thread_fsm::should_notify_stop ()
583 /* Infcall succeeded. Be silent and proceed with evaluating the
588 /* Something wrong happened. E.g., an unexpected breakpoint
589 triggered, or a signal was intercepted. Notify the stop. */
593 /* Subroutine of call_function_by_hand to simplify it.
594 Start up the inferior and wait for it to stop.
595 Return the exception if there's an error, or an exception with
596 reason >= 0 if there's no error.
598 This is done inside a TRY_CATCH so the caller needn't worry about
599 thrown errors. The caller should rethrow if there's an error. */
601 static struct gdb_exception
602 run_inferior_call (std::unique_ptr
<call_thread_fsm
> sm
,
603 struct thread_info
*call_thread
, CORE_ADDR real_pc
)
605 INFCALL_SCOPED_DEBUG_ENTER_EXIT
;
607 struct gdb_exception caught_error
;
608 ptid_t call_thread_ptid
= call_thread
->ptid
;
609 int was_running
= call_thread
->state
== THREAD_RUNNING
;
611 infcall_debug_printf ("call function at %s in thread %s, was_running = %d",
612 core_addr_to_string (real_pc
),
613 call_thread_ptid
.to_string ().c_str (),
616 current_ui
->unregister_file_handler ();
618 scoped_restore restore_in_infcall
619 = make_scoped_restore (&call_thread
->control
.in_infcall
, 1);
621 clear_proceed_status (0);
623 /* Associate the FSM with the thread after clear_proceed_status
624 (otherwise it'd clear this FSM). */
625 call_thread
->set_thread_fsm (std::move (sm
));
627 disable_watchpoints_before_interactive_call_start ();
629 /* We want to print return value, please... */
630 call_thread
->control
.proceed_to_finish
= 1;
634 /* Infcalls run synchronously, in the foreground. */
635 scoped_restore restore_prompt_state
636 = make_scoped_restore (¤t_ui
->prompt_state
, PROMPT_BLOCKED
);
638 /* So that we don't print the prompt prematurely in
639 fetch_inferior_event. */
640 scoped_restore restore_ui_async
641 = make_scoped_restore (¤t_ui
->async
, 0);
643 proceed (real_pc
, GDB_SIGNAL_0
);
645 infrun_debug_show_threads ("non-exited threads after proceed for inferior-call",
646 all_non_exited_threads ());
648 /* Inferior function calls are always synchronous, even if the
649 target supports asynchronous execution. */
650 wait_sync_command_done ();
652 infcall_debug_printf ("inferior call completed successfully");
654 catch (gdb_exception
&e
)
656 infcall_debug_printf ("exception while making inferior call (%d): %s",
657 e
.reason
, e
.what ());
658 caught_error
= std::move (e
);
661 infcall_debug_printf ("thread is now: %s",
662 inferior_ptid
.to_string ().c_str ());
664 /* If GDB has the prompt blocked before, then ensure that it remains
665 so. normal_stop calls async_enable_stdin, so reset the prompt
666 state again here. In other cases, stdin will be re-enabled by
667 inferior_event_handler, when an exception is thrown. */
668 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
669 current_ui
->unregister_file_handler ();
671 current_ui
->register_file_handler ();
673 /* If the infcall does NOT succeed, normal_stop will have already
674 finished the thread states. However, on success, normal_stop
675 defers here, so that we can set back the thread states to what
676 they were before the call. Note that we must also finish the
677 state of new threads that might have spawned while the call was
678 running. The main cases to handle are:
680 - "(gdb) print foo ()", or any other command that evaluates an
681 expression at the prompt. (The thread was marked stopped before.)
683 - "(gdb) break foo if return_false()" or similar cases where we
684 do an infcall while handling an event (while the thread is still
685 marked running). In this example, whether the condition
686 evaluates true and thus we'll present a user-visible stop is
687 decided elsewhere. */
689 && call_thread_ptid
== inferior_ptid
690 && stop_stack_dummy
== STOP_STACK_DUMMY
)
691 finish_thread_state (call_thread
->inf
->process_target (),
692 user_visible_resume_ptid (0));
694 enable_watchpoints_after_interactive_call_stop ();
696 /* Call breakpoint_auto_delete on the current contents of the bpstat
697 of inferior call thread.
698 If all error()s out of proceed ended up calling normal_stop
699 (and perhaps they should; it already does in the special case
700 of error out of resume()), then we wouldn't need this. */
701 if (caught_error
.reason
< 0)
703 if (call_thread
->state
!= THREAD_EXITED
)
704 breakpoint_auto_delete (call_thread
->control
.stop_bpstat
);
710 /* Reserve space on the stack for a value of the given type.
711 Return the address of the allocated space.
712 Make certain that the value is correctly aligned.
713 The SP argument is modified. */
716 reserve_stack_space (const type
*values_type
, CORE_ADDR
&sp
)
718 frame_info_ptr frame
= get_current_frame ();
719 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
722 if (gdbarch_inner_than (gdbarch
, 1, 2))
724 /* Stack grows downward. Align STRUCT_ADDR and SP after
726 sp
-= values_type
->length ();
727 if (gdbarch_frame_align_p (gdbarch
))
728 sp
= gdbarch_frame_align (gdbarch
, sp
);
733 /* Stack grows upward. Align the frame, allocate space, and
734 then again, re-align the frame??? */
735 if (gdbarch_frame_align_p (gdbarch
))
736 sp
= gdbarch_frame_align (gdbarch
, sp
);
738 sp
+= values_type
->length ();
739 if (gdbarch_frame_align_p (gdbarch
))
740 sp
= gdbarch_frame_align (gdbarch
, sp
);
746 /* The data structure which keeps a destructor function and
747 its implicit 'this' parameter. */
749 struct destructor_info
751 destructor_info (struct value
*function
, struct value
*self
)
752 : function (function
), self (self
) { }
754 struct value
*function
;
759 /* Auxiliary function that takes a list of destructor functions
760 with their 'this' parameters, and invokes the functions. */
763 call_destructors (const std::list
<destructor_info
> &dtors_to_invoke
,
764 struct type
*default_return_type
)
766 for (auto vals
: dtors_to_invoke
)
768 call_function_by_hand (vals
.function
, default_return_type
,
769 gdb::make_array_view (&(vals
.self
), 1));
776 call_function_by_hand (struct value
*function
,
777 type
*default_return_type
,
778 gdb::array_view
<value
*> args
)
780 return call_function_by_hand_dummy (function
, default_return_type
,
784 /* All this stuff with a dummy frame may seem unnecessarily complicated
785 (why not just save registers in GDB?). The purpose of pushing a dummy
786 frame which looks just like a real frame is so that if you call a
787 function and then hit a breakpoint (get a signal, etc), "backtrace"
788 will look right. Whether the backtrace needs to actually show the
789 stack at the time the inferior function was called is debatable, but
790 it certainly needs to not display garbage. So if you are contemplating
791 making dummy frames be different from normal frames, consider that. */
793 /* Perform a function call in the inferior.
794 ARGS is a vector of values of arguments.
795 FUNCTION is a value, the function to be called.
796 Returns a value representing what the function returned.
797 May fail to return, if a breakpoint or signal is hit
798 during the execution of the function.
800 ARGS is modified to contain coerced values. */
803 call_function_by_hand_dummy (struct value
*function
,
804 type
*default_return_type
,
805 gdb::array_view
<value
*> args
,
806 dummy_frame_dtor_ftype
*dummy_dtor
,
807 void *dummy_dtor_data
)
809 INFCALL_SCOPED_DEBUG_ENTER_EXIT
;
812 struct type
*target_values_type
;
813 function_call_return_method return_method
= return_method_normal
;
814 CORE_ADDR struct_addr
= 0;
817 struct frame_id dummy_id
;
818 frame_info_ptr frame
;
819 struct gdbarch
*gdbarch
;
820 ptid_t call_thread_ptid
;
821 struct gdb_exception e
;
822 char name_buf
[RAW_FUNCTION_ADDRESS_SIZE
];
824 if (!may_call_functions_p
)
825 error (_("Cannot call functions in the program: "
826 "may-call-functions is off."));
828 if (!target_has_execution ())
831 if (get_traceframe_number () >= 0)
832 error (_("May not call functions while looking at trace frames."));
834 if (execution_direction
== EXEC_REVERSE
)
835 error (_("Cannot call functions in reverse mode."));
837 /* We're going to run the target, and inspect the thread's state
838 afterwards. Hold a strong reference so that the pointer remains
839 valid even if the thread exits. */
840 thread_info_ref call_thread
841 = thread_info_ref::new_reference (inferior_thread ());
843 bool stack_temporaries
= thread_stack_temporaries_enabled_p (call_thread
.get ());
845 frame
= get_current_frame ();
846 gdbarch
= get_frame_arch (frame
);
848 if (!gdbarch_push_dummy_call_p (gdbarch
))
849 error (_("This target does not support function calls."));
851 /* Find the function type and do a sanity check. */
854 CORE_ADDR funaddr
= find_function_addr (function
, &values_type
, &ftype
);
856 if (is_nocall_function (ftype
))
857 error (_("Cannot call the function '%s' which does not follow the "
858 "target calling convention."),
859 get_function_name (funaddr
, name_buf
, sizeof (name_buf
)));
861 if (values_type
== NULL
|| values_type
->is_stub ())
862 values_type
= default_return_type
;
863 if (values_type
== NULL
)
865 const char *name
= get_function_name (funaddr
,
866 name_buf
, sizeof (name_buf
));
867 error (_("'%s' has unknown return type; "
868 "cast the call to its declared return type"),
872 values_type
= check_typedef (values_type
);
874 if (args
.size () < ftype
->num_fields ())
875 error (_("Too few arguments in function call."));
877 infcall_debug_printf ("calling %s", get_function_name (funaddr
, name_buf
,
880 /* A holder for the inferior status.
881 This is only needed while we're preparing the inferior function call. */
882 infcall_control_state_up
inf_status (save_infcall_control_state ());
884 /* Save the caller's registers and other state associated with the
885 inferior itself so that they can be restored once the
886 callee returns. To allow nested calls the registers are (further
887 down) pushed onto a dummy frame stack. This unique pointer
888 is released once the regcache has been pushed). */
889 infcall_suspend_state_up
caller_state (save_infcall_suspend_state ());
891 /* Ensure that the initial SP is correctly aligned. */
893 CORE_ADDR old_sp
= get_frame_sp (frame
);
895 if (gdbarch_frame_align_p (gdbarch
))
897 sp
= gdbarch_frame_align (gdbarch
, old_sp
);
898 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
899 ABIs, a function can use memory beyond the inner most stack
900 address. AMD64 called that region the "red zone". Skip at
901 least the "red zone" size before allocating any space on
903 if (gdbarch_inner_than (gdbarch
, 1, 2))
904 sp
-= gdbarch_frame_red_zone_size (gdbarch
);
906 sp
+= gdbarch_frame_red_zone_size (gdbarch
);
908 gdb_assert (sp
== gdbarch_frame_align (gdbarch
, sp
));
909 /* NOTE: cagney/2002-09-18:
911 On a RISC architecture, a void parameterless generic dummy
912 frame (i.e., no parameters, no result) typically does not
913 need to push anything the stack and hence can leave SP and
914 FP. Similarly, a frameless (possibly leaf) function does
915 not push anything on the stack and, hence, that too can
916 leave FP and SP unchanged. As a consequence, a sequence of
917 void parameterless generic dummy frame calls to frameless
918 functions will create a sequence of effectively identical
919 frames (SP, FP and TOS and PC the same). This, not
920 surprisingly, results in what appears to be a stack in an
921 infinite loop --- when GDB tries to find a generic dummy
922 frame on the internal dummy frame stack, it will always
925 To avoid this problem, the code below always grows the
926 stack. That way, two dummy frames can never be identical.
927 It does burn a few bytes of stack but that is a small price
931 if (gdbarch_inner_than (gdbarch
, 1, 2))
932 /* Stack grows down. */
933 sp
= gdbarch_frame_align (gdbarch
, old_sp
- 1);
935 /* Stack grows up. */
936 sp
= gdbarch_frame_align (gdbarch
, old_sp
+ 1);
938 /* SP may have underflown address zero here from OLD_SP. Memory access
939 functions will probably fail in such case but that is a target's
943 /* FIXME: cagney/2002-09-18: Hey, you loose!
945 Who knows how badly aligned the SP is!
947 If the generic dummy frame ends up empty (because nothing is
948 pushed) GDB won't be able to correctly perform back traces.
949 If a target is having trouble with backtraces, first thing to
950 do is add FRAME_ALIGN() to the architecture vector. If that
951 fails, try dummy_id().
953 If the ABI specifies a "Red Zone" (see the doco) the code
954 below will quietly trash it. */
957 /* Skip over the stack temporaries that might have been generated during
958 the evaluation of an expression. */
959 if (stack_temporaries
)
961 struct value
*lastval
;
963 lastval
= get_last_thread_stack_temporary (call_thread
.get ());
966 CORE_ADDR lastval_addr
= lastval
->address ();
968 if (gdbarch_inner_than (gdbarch
, 1, 2))
970 gdb_assert (sp
>= lastval_addr
);
975 gdb_assert (sp
<= lastval_addr
);
976 sp
= lastval_addr
+ lastval
->type ()->length ();
979 if (gdbarch_frame_align_p (gdbarch
))
980 sp
= gdbarch_frame_align (gdbarch
, sp
);
985 /* Are we returning a value using a structure return? */
987 if (gdbarch_return_in_first_hidden_param_p (gdbarch
, values_type
))
989 return_method
= return_method_hidden_param
;
991 /* Tell the target specific argument pushing routine not to
993 target_values_type
= builtin_type (gdbarch
)->builtin_void
;
997 if (using_struct_return (gdbarch
, function
, values_type
))
998 return_method
= return_method_struct
;
999 target_values_type
= values_type
;
1002 gdb::observers::inferior_call_pre
.notify (inferior_ptid
, funaddr
);
1004 /* Determine the location of the breakpoint (and possibly other
1005 stuff) that the called function will return to. The SPARC, for a
1006 function returning a structure or union, needs to make space for
1007 not just the breakpoint but also an extra word containing the
1008 size (?) of the structure being passed. */
1010 switch (gdbarch_call_dummy_location (gdbarch
))
1014 const gdb_byte
*bp_bytes
;
1015 CORE_ADDR bp_addr_as_address
;
1018 /* Be careful BP_ADDR is in inferior PC encoding while
1019 BP_ADDR_AS_ADDRESS is a plain memory address. */
1021 sp
= push_dummy_code (gdbarch
, sp
, funaddr
, args
,
1022 target_values_type
, &real_pc
, &bp_addr
,
1023 get_current_regcache ());
1025 /* Write a legitimate instruction at the point where the infcall
1026 breakpoint is going to be inserted. While this instruction
1027 is never going to be executed, a user investigating the
1028 memory from GDB would see this instruction instead of random
1029 uninitialized bytes. We chose the breakpoint instruction
1030 as it may look as the most logical one to the user and also
1031 valgrind 3.7.0 needs it for proper vgdb inferior calls.
1033 If software breakpoints are unsupported for this target we
1034 leave the user visible memory content uninitialized. */
1036 bp_addr_as_address
= bp_addr
;
1037 bp_bytes
= gdbarch_breakpoint_from_pc (gdbarch
, &bp_addr_as_address
,
1039 if (bp_bytes
!= NULL
)
1040 write_memory (bp_addr_as_address
, bp_bytes
, bp_size
);
1043 case AT_ENTRY_POINT
:
1045 CORE_ADDR dummy_addr
;
1048 dummy_addr
= entry_point_address ();
1050 /* A call dummy always consists of just a single breakpoint, so
1051 its address is the same as the address of the dummy.
1053 The actual breakpoint is inserted separatly so there is no need to
1055 bp_addr
= dummy_addr
;
1059 internal_error (_("bad switch"));
1062 /* Coerce the arguments and handle pass-by-reference.
1063 We want to remember the destruction required for pass-by-ref values.
1064 For these, store the dtor function and the 'this' argument
1065 in DTORS_TO_INVOKE. */
1066 std::list
<destructor_info
> dtors_to_invoke
;
1068 for (int i
= args
.size () - 1; i
>= 0; i
--)
1071 struct type
*param_type
;
1073 /* FIXME drow/2002-05-31: Should just always mark methods as
1074 prototyped. Can we respect TYPE_VARARGS? Probably not. */
1075 if (ftype
->code () == TYPE_CODE_METHOD
)
1077 else if (ftype
->target_type () == NULL
&& ftype
->num_fields () == 0
1078 && default_return_type
!= NULL
)
1080 /* Calling a no-debug function with the return type
1081 explicitly cast. Assume the function is prototyped,
1082 with a prototype matching the types of the arguments.
1084 float mult (float v1, float v2) { return v1 * v2; }
1086 (gdb) p (float) mult (2.0f, 3.0f)
1087 Is a simpler alternative to:
1088 (gdb) p ((float (*) (float, float)) mult) (2.0f, 3.0f)
1092 else if (i
< ftype
->num_fields ())
1093 prototyped
= ftype
->is_prototyped ();
1097 if (i
< ftype
->num_fields ())
1098 param_type
= ftype
->field (i
).type ();
1102 value
*original_arg
= args
[i
];
1103 args
[i
] = value_arg_coerce (gdbarch
, args
[i
],
1104 param_type
, prototyped
);
1106 if (param_type
== NULL
)
1109 auto info
= language_pass_by_reference (param_type
);
1110 if (!info
.copy_constructible
)
1111 error (_("expression cannot be evaluated because the type '%s' "
1112 "is not copy constructible"), param_type
->name ());
1114 if (!info
.destructible
)
1115 error (_("expression cannot be evaluated because the type '%s' "
1116 "is not destructible"), param_type
->name ());
1118 if (info
.trivially_copyable
)
1121 /* Make a copy of the argument on the stack. If the argument is
1122 trivially copy ctor'able, copy bit by bit. Otherwise, call
1123 the copy ctor to initialize the clone. */
1124 CORE_ADDR addr
= reserve_stack_space (param_type
, sp
);
1126 = value_from_contents_and_address (param_type
, nullptr, addr
);
1127 push_thread_stack_temporary (call_thread
.get (), clone
);
1129 = value_from_pointer (lookup_pointer_type (param_type
), addr
);
1131 if (info
.trivially_copy_constructible
)
1133 int length
= param_type
->length ();
1134 write_memory (addr
, args
[i
]->contents ().data (), length
);
1139 value
*cctor_args
[2] = { clone_ptr
, original_arg
};
1140 find_overload_match (gdb::make_array_view (cctor_args
, 2),
1141 param_type
->name (), METHOD
,
1142 &clone_ptr
, nullptr, ©_ctor
, nullptr,
1143 nullptr, 0, EVAL_NORMAL
);
1145 if (copy_ctor
== nullptr)
1146 error (_("expression cannot be evaluated because a copy "
1147 "constructor for the type '%s' could not be found "
1148 "(maybe inlined?)"), param_type
->name ());
1150 call_function_by_hand (copy_ctor
, default_return_type
,
1151 gdb::make_array_view (cctor_args
, 2));
1154 /* If the argument has a destructor, remember it so that we
1155 invoke it after the infcall is complete. */
1156 if (!info
.trivially_destructible
)
1158 /* Looking up the function via overload resolution does not
1159 work because the compiler (in particular, gcc) adds an
1160 artificial int parameter in some cases. So we look up
1161 the function by using the "~" name. This should be OK
1162 because there can be only one dtor definition. */
1163 const char *dtor_name
= nullptr;
1164 for (int fieldnum
= 0;
1165 fieldnum
< TYPE_NFN_FIELDS (param_type
);
1169 = TYPE_FN_FIELDLIST1 (param_type
, fieldnum
);
1170 const char *field_name
1171 = TYPE_FN_FIELDLIST_NAME (param_type
, fieldnum
);
1173 if (field_name
[0] == '~')
1174 dtor_name
= TYPE_FN_FIELD_PHYSNAME (fn
, 0);
1177 if (dtor_name
== nullptr)
1178 error (_("expression cannot be evaluated because a destructor "
1179 "for the type '%s' could not be found "
1180 "(maybe inlined?)"), param_type
->name ());
1183 = find_function_in_inferior (dtor_name
, 0);
1185 /* Insert the dtor to the front of the list to call them
1186 in reverse order later. */
1187 dtors_to_invoke
.emplace_front (dtor
, clone_ptr
);
1190 args
[i
] = clone_ptr
;
1193 /* Reserve space for the return structure to be written on the
1194 stack, if necessary.
1196 While evaluating expressions, we reserve space on the stack for
1197 return values of class type even if the language ABI and the target
1198 ABI do not require that the return value be passed as a hidden first
1199 argument. This is because we want to store the return value as an
1200 on-stack temporary while the expression is being evaluated. This
1201 enables us to have chained function calls in expressions.
1203 Keeping the return values as on-stack temporaries while the expression
1204 is being evaluated is OK because the thread is stopped until the
1205 expression is completely evaluated. */
1207 if (return_method
!= return_method_normal
1208 || (stack_temporaries
&& class_or_union_p (values_type
)))
1209 struct_addr
= reserve_stack_space (values_type
, sp
);
1211 std::vector
<struct value
*> new_args
;
1212 if (return_method
== return_method_hidden_param
)
1214 /* Add the new argument to the front of the argument list. */
1215 new_args
.reserve (args
.size ());
1217 (value_from_pointer (lookup_pointer_type (values_type
), struct_addr
));
1218 new_args
.insert (new_args
.end (), args
.begin (), args
.end ());
1222 /* Create the dummy stack frame. Pass in the call dummy address as,
1223 presumably, the ABI code knows where, in the call dummy, the
1224 return address should be pointed. */
1225 sp
= gdbarch_push_dummy_call (gdbarch
, function
, get_current_regcache (),
1226 bp_addr
, args
.size (), args
.data (),
1227 sp
, return_method
, struct_addr
);
1229 /* Set up a frame ID for the dummy frame so we can pass it to
1230 set_momentary_breakpoint. We need to give the breakpoint a frame
1231 ID so that the breakpoint code can correctly re-identify the
1232 dummy breakpoint. */
1233 /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL,
1234 saved as the dummy-frame TOS, and used by dummy_id to form
1235 the frame ID's stack address. */
1236 dummy_id
= frame_id_build (sp
, bp_addr
);
1238 /* Create a momentary breakpoint at the return address of the
1239 inferior. That way it breaks when it returns. */
1242 symtab_and_line sal
;
1243 sal
.pspace
= current_program_space
;
1245 sal
.section
= find_pc_overlay (sal
.pc
);
1247 /* Sanity. The exact same SP value is returned by
1248 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
1249 dummy_id to form the frame ID's stack address. */
1251 = set_momentary_breakpoint (gdbarch
, sal
,
1252 dummy_id
, bp_call_dummy
).release ();
1254 /* set_momentary_breakpoint invalidates FRAME. */
1257 bpt
->disposition
= disp_del
;
1258 gdb_assert (bpt
->related_breakpoint
== bpt
);
1260 breakpoint
*longjmp_b
= set_longjmp_breakpoint_for_call_dummy ();
1263 /* Link BPT into the chain of LONGJMP_B. */
1264 bpt
->related_breakpoint
= longjmp_b
;
1265 while (longjmp_b
->related_breakpoint
!= bpt
->related_breakpoint
)
1266 longjmp_b
= longjmp_b
->related_breakpoint
;
1267 longjmp_b
->related_breakpoint
= bpt
;
1271 /* Create a breakpoint in std::terminate.
1272 If a C++ exception is raised in the dummy-frame, and the
1273 exception handler is (normally, and expected to be) out-of-frame,
1274 the default C++ handler will (wrongly) be called in an inferior
1275 function call. This is wrong, as an exception can be normally
1276 and legally handled out-of-frame. The confines of the dummy frame
1277 prevent the unwinder from finding the correct handler (or any
1278 handler, unless it is in-frame). The default handler calls
1279 std::terminate. This will kill the inferior. Assert that
1280 terminate should never be called in an inferior function
1281 call. Place a momentary breakpoint in the std::terminate function
1282 and if triggered in the call, rewind. */
1283 if (unwind_on_terminating_exception_p
)
1284 set_std_terminate_breakpoint ();
1286 /* Everything's ready, push all the info needed to restore the
1287 caller (and identify the dummy-frame) onto the dummy-frame
1289 dummy_frame_push (caller_state
.release (), &dummy_id
, call_thread
.get ());
1290 if (dummy_dtor
!= NULL
)
1291 register_dummy_frame_dtor (dummy_id
, call_thread
.get (),
1292 dummy_dtor
, dummy_dtor_data
);
1294 /* Register a clean-up for unwind_on_terminating_exception_breakpoint. */
1295 SCOPE_EXIT
{ delete_std_terminate_breakpoint (); };
1297 /* The stopped_by_random_signal variable is global. If we are here
1298 as part of a breakpoint condition check then the global will have
1299 already been setup as part of the original breakpoint stop. By
1300 making the inferior call the global will be changed when GDB
1301 handles the stop after the inferior call. Avoid confusion by
1302 restoring the current value after the inferior call. */
1303 scoped_restore restore_stopped_by_random_signal
1304 = make_scoped_restore (&stopped_by_random_signal
, 0);
1306 /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP -
1307 If you're looking to implement asynchronous dummy-frames, then
1308 just below is the place to chop this function in two.. */
1311 /* Save the current FSM. We'll override it. */
1312 std::unique_ptr
<thread_fsm
> saved_sm
= call_thread
->release_thread_fsm ();
1313 struct call_thread_fsm
*sm
;
1315 /* Save this thread's ptid, we need it later but the thread
1317 call_thread_ptid
= call_thread
->ptid
;
1319 /* Run the inferior until it stops. */
1321 /* Create the FSM used to manage the infcall. It tells infrun to
1322 not report the stop to the user, and captures the return value
1323 before the dummy frame is popped. run_inferior_call registers
1324 it with the thread ASAP. */
1325 sm
= new call_thread_fsm (current_ui
, command_interp (),
1328 return_method
!= return_method_normal
,
1331 std::unique_ptr
<call_thread_fsm
> sm_up (sm
);
1332 e
= run_inferior_call (std::move (sm_up
), call_thread
.get (), real_pc
);
1336 infcall_debug_printf ("after inferior call, exception (%d): %s",
1337 e
.reason
, e
.what ());
1338 infcall_debug_printf ("after inferior call, thread state is: %s",
1339 thread_state_string (call_thread
->state
));
1341 gdb::observers::inferior_call_post
.notify (call_thread_ptid
, funaddr
);
1343 if (call_thread
->state
!= THREAD_EXITED
)
1345 /* The FSM should still be the same. */
1346 gdb_assert (call_thread
->thread_fsm () == sm
);
1348 if (call_thread
->thread_fsm ()->finished_p ())
1350 struct value
*retval
;
1352 infcall_debug_printf ("call completed");
1354 /* The inferior call is successful. Pop the dummy frame,
1355 which runs its destructors and restores the inferior's
1356 suspend state, and restore the inferior control
1358 dummy_frame_pop (dummy_id
, call_thread
.get ());
1359 restore_infcall_control_state (inf_status
.release ());
1361 /* Get the return value. */
1362 retval
= sm
->return_value
;
1364 /* Restore the original FSM and clean up / destroy the call FSM.
1365 Doing it in this order ensures that if the call to clean_up
1366 throws, the original FSM is properly restored. */
1368 std::unique_ptr
<thread_fsm
> finalizing
1369 = call_thread
->release_thread_fsm ();
1370 call_thread
->set_thread_fsm (std::move (saved_sm
));
1372 finalizing
->clean_up (call_thread
.get ());
1375 maybe_remove_breakpoints ();
1377 gdb_assert (retval
!= NULL
);
1379 /* Destruct the pass-by-ref argument clones. */
1380 call_destructors (dtors_to_invoke
, default_return_type
);
1385 infcall_debug_printf ("call did not complete");
1387 /* Didn't complete. Clean up / destroy the call FSM, and restore the
1388 previous state machine, and handle the error. */
1390 std::unique_ptr
<thread_fsm
> finalizing
1391 = call_thread
->release_thread_fsm ();
1392 call_thread
->set_thread_fsm (std::move (saved_sm
));
1394 finalizing
->clean_up (call_thread
.get ());
1399 /* Rethrow an error if we got one trying to run the inferior. */
1403 const char *name
= get_function_name (funaddr
,
1404 name_buf
, sizeof (name_buf
));
1406 discard_infcall_control_state (inf_status
.release ());
1408 /* We could discard the dummy frame here if the program exited,
1409 but it will get garbage collected the next time the program is
1415 throw_error (e
.error
, _("%s\n\
1416 An error occurred while in a function called from GDB.\n\
1417 Evaluation of the expression containing the function\n\
1418 (%s) will be abandoned.\n\
1419 When the function is done executing, GDB will silently stop."),
1423 throw_exception (std::move (e
));
1427 /* If the program has exited, or we stopped at a different thread,
1428 exit and inform the user. */
1430 if (! target_has_execution ())
1432 const char *name
= get_function_name (funaddr
,
1433 name_buf
, sizeof (name_buf
));
1435 /* If we try to restore the inferior status,
1436 we'll crash as the inferior is no longer running. */
1437 discard_infcall_control_state (inf_status
.release ());
1439 /* We could discard the dummy frame here given that the program exited,
1440 but it will get garbage collected the next time the program is
1443 error (_("The program being debugged exited while in a function "
1444 "called from GDB.\n"
1445 "Evaluation of the expression containing the function\n"
1446 "(%s) will be abandoned."),
1450 if (call_thread_ptid
!= inferior_ptid
)
1452 const char *name
= get_function_name (funaddr
,
1453 name_buf
, sizeof (name_buf
));
1455 /* We've switched threads. This can happen if another thread gets a
1456 signal or breakpoint while our thread was running.
1457 There's no point in restoring the inferior status,
1458 we're in a different thread. */
1459 discard_infcall_control_state (inf_status
.release ());
1460 /* Keep the dummy frame record, if the user switches back to the
1461 thread with the hand-call, we'll need it. */
1462 if (stopped_by_random_signal
)
1464 The program received a signal in another thread while\n\
1465 making a function call from GDB.\n\
1466 Evaluation of the expression containing the function\n\
1467 (%s) will be abandoned.\n\
1468 When the function is done executing, GDB will silently stop."),
1472 The program stopped in another thread while making a function call 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."),
1480 /* Make a copy as NAME may be in an objfile freed by dummy_frame_pop. */
1481 std::string name
= get_function_name (funaddr
, name_buf
,
1484 if (stopped_by_random_signal
)
1486 /* We stopped inside the FUNCTION because of a random
1487 signal. Further execution of the FUNCTION is not
1490 if (unwind_on_signal_p
)
1492 /* The user wants the context restored. */
1494 /* We must get back to the frame we were before the
1496 dummy_frame_pop (dummy_id
, call_thread
.get ());
1498 /* We also need to restore inferior status to that before the
1500 restore_infcall_control_state (inf_status
.release ());
1502 /* FIXME: Insert a bunch of wrap_here; name can be very
1503 long if it's a C++ name with arguments and stuff. */
1505 The program being debugged was signaled while in a function called from GDB.\n\
1506 GDB has restored the context to what it was before the call.\n\
1507 To change this behavior use \"set unwindonsignal off\".\n\
1508 Evaluation of the expression containing the function\n\
1509 (%s) will be abandoned."),
1514 /* The user wants to stay in the frame where we stopped
1516 Discard inferior status, we're not at the same point
1518 discard_infcall_control_state (inf_status
.release ());
1520 /* FIXME: Insert a bunch of wrap_here; name can be very
1521 long if it's a C++ name with arguments and stuff. */
1523 The program being debugged was signaled while in a function called from GDB.\n\
1524 GDB remains in the frame where the signal was received.\n\
1525 To change this behavior use \"set unwindonsignal on\".\n\
1526 Evaluation of the expression containing the function\n\
1527 (%s) will be abandoned.\n\
1528 When the function is done executing, GDB will silently stop."),
1533 if (stop_stack_dummy
== STOP_STD_TERMINATE
)
1535 /* We must get back to the frame we were before the dummy
1537 dummy_frame_pop (dummy_id
, call_thread
.get ());
1539 /* We also need to restore inferior status to that before
1541 restore_infcall_control_state (inf_status
.release ());
1544 The program being debugged entered a std::terminate call, most likely\n\
1545 caused by an unhandled C++ exception. GDB blocked this call in order\n\
1546 to prevent the program from being terminated, and has restored the\n\
1547 context to its original state before the call.\n\
1548 To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
1549 Evaluation of the expression containing the function (%s)\n\
1550 will be abandoned."),
1553 else if (stop_stack_dummy
== STOP_NONE
)
1556 /* We hit a breakpoint inside the FUNCTION.
1557 Keep the dummy frame, the user may want to examine its state.
1558 Discard inferior status, we're not at the same point
1560 discard_infcall_control_state (inf_status
.release ());
1562 /* The following error message used to say "The expression
1563 which contained the function call has been discarded."
1564 It is a hard concept to explain in a few words. Ideally,
1565 GDB would be able to resume evaluation of the expression
1566 when the function finally is done executing. Perhaps
1567 someday this will be implemented (it would not be easy). */
1568 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1569 a C++ name with arguments and stuff. */
1571 The program being debugged stopped while in a function called from GDB.\n\
1572 Evaluation of the expression containing the function\n\
1573 (%s) will be abandoned.\n\
1574 When the function is done executing, GDB will silently stop."),
1580 /* The above code errors out, so ... */
1581 gdb_assert_not_reached ("... should not be here");
1584 void _initialize_infcall ();
1586 _initialize_infcall ()
1588 add_setshow_boolean_cmd ("may-call-functions", no_class
,
1589 &may_call_functions_p
, _("\
1590 Set permission to call functions in the program."), _("\
1591 Show permission to call functions in the program."), _("\
1592 When this permission is on, GDB may call functions in the program.\n\
1593 Otherwise, any sort of attempt to call a function in the program\n\
1594 will result in an error."),
1596 show_may_call_functions_p
,
1597 &setlist
, &showlist
);
1599 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure
,
1600 &coerce_float_to_double_p
, _("\
1601 Set coercion of floats to doubles when calling functions."), _("\
1602 Show coercion of floats to doubles when calling functions."), _("\
1603 Variables of type float should generally be converted to doubles before\n\
1604 calling an unprototyped function, and left alone when calling a prototyped\n\
1605 function. However, some older debug info formats do not provide enough\n\
1606 information to determine that a function is prototyped. If this flag is\n\
1607 set, GDB will perform the conversion for a function it considers\n\
1609 The default is to perform the conversion."),
1611 show_coerce_float_to_double_p
,
1612 &setlist
, &showlist
);
1614 add_setshow_boolean_cmd ("unwindonsignal", no_class
,
1615 &unwind_on_signal_p
, _("\
1616 Set unwinding of stack if a signal is received while in a call dummy."), _("\
1617 Show unwinding of stack if a signal is received while in a call dummy."), _("\
1618 The unwindonsignal lets the user determine what gdb should do if a signal\n\
1619 is received while in a function called from gdb (call dummy). If set, gdb\n\
1620 unwinds the stack and restore the context to what as it was before the call.\n\
1621 The default is to stop in the frame where the signal was received."),
1623 show_unwind_on_signal_p
,
1624 &setlist
, &showlist
);
1626 add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class
,
1627 &unwind_on_terminating_exception_p
, _("\
1628 Set unwinding of stack if std::terminate is called while in call dummy."), _("\
1629 Show unwinding of stack if std::terminate() is called while in a call dummy."),
1631 The unwind on terminating exception flag lets the user determine\n\
1632 what gdb should do if a std::terminate() call is made from the\n\
1633 default exception handler. If set, gdb unwinds the stack and restores\n\
1634 the context to what it was before the call. If unset, gdb allows the\n\
1635 std::terminate call to proceed.\n\
1636 The default is to unwind the frame."),
1638 show_unwind_on_terminating_exception_p
,
1639 &setlist
, &showlist
);
1641 add_setshow_boolean_cmd
1642 ("infcall", class_maintenance
, &debug_infcall
,
1643 _("Set inferior call debugging."),
1644 _("Show inferior call debugging."),
1645 _("When on, inferior function call specific debugging is enabled."),
1646 NULL
, show_debug_infcall
, &setdebuglist
, &showdebuglist
);