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"
42 #include "thread-fsm.h"
44 #include "gdbsupport/scope-exit.h"
47 /* True if we are debugging inferior calls. */
49 static bool debug_infcall
= false;
51 /* Print an "infcall" debug statement. */
53 #define infcall_debug_printf(fmt, ...) \
54 debug_prefixed_printf_cond (debug_infcall, "infcall", fmt, ##__VA_ARGS__)
56 /* Print "infcall" enter/exit debug statements. */
58 #define INFCALL_SCOPED_DEBUG_ENTER_EXIT \
59 scoped_debug_enter_exit (debug_infcall, "infcall")
61 /* Print "infcall" start/end debug statements. */
63 #define INFCALL_SCOPED_DEBUG_START_END(fmt, ...) \
64 scoped_debug_start_end (debug_infrun, "infcall", fmt, ##__VA_ARGS__)
66 /* Implement 'show debug infcall'. */
69 show_debug_infcall (struct ui_file
*file
, int from_tty
,
70 struct cmd_list_element
*c
, const char *value
)
72 gdb_printf (file
, _("Inferior call debugging is %s.\n"), value
);
75 /* If we can't find a function's name from its address,
76 we print this instead. */
77 #define RAW_FUNCTION_ADDRESS_FORMAT "at 0x%s"
78 #define RAW_FUNCTION_ADDRESS_SIZE (sizeof (RAW_FUNCTION_ADDRESS_FORMAT) \
79 + 2 * sizeof (CORE_ADDR))
81 /* NOTE: cagney/2003-04-16: What's the future of this code?
83 GDB needs an asynchronous expression evaluator, that means an
84 asynchronous inferior function call implementation, and that in
85 turn means restructuring the code so that it is event driven. */
87 static bool may_call_functions_p
= true;
89 show_may_call_functions_p (struct ui_file
*file
, int from_tty
,
90 struct cmd_list_element
*c
,
94 _("Permission to call functions in the program is %s.\n"),
98 /* How you should pass arguments to a function depends on whether it
99 was defined in K&R style or prototype style. If you define a
100 function using the K&R syntax that takes a `float' argument, then
101 callers must pass that argument as a `double'. If you define the
102 function using the prototype syntax, then you must pass the
103 argument as a `float', with no promotion.
105 Unfortunately, on certain older platforms, the debug info doesn't
106 indicate reliably how each function was defined. A function type's
107 TYPE_PROTOTYPED flag may be clear, even if the function was defined
108 in prototype style. When calling a function whose TYPE_PROTOTYPED
109 flag is clear, GDB consults this flag to decide what to do.
111 For modern targets, it is proper to assume that, if the prototype
112 flag is clear, that can be trusted: `float' arguments should be
113 promoted to `double'. For some older targets, if the prototype
114 flag is clear, that doesn't tell us anything. The default is to
115 trust the debug information; the user can override this behavior
116 with "set coerce-float-to-double 0". */
118 static bool coerce_float_to_double_p
= true;
120 show_coerce_float_to_double_p (struct ui_file
*file
, int from_tty
,
121 struct cmd_list_element
*c
, const char *value
)
124 _("Coercion of floats to doubles "
125 "when calling functions is %s.\n"),
129 /* This boolean tells what gdb should do if a signal is received while
130 in a function called from gdb (call dummy). If set, gdb unwinds
131 the stack and restore the context to what as it was before the
134 The default is to stop in the frame where the signal was received. */
136 static bool unwind_on_signal_p
= false;
138 show_unwind_on_signal_p (struct ui_file
*file
, int from_tty
,
139 struct cmd_list_element
*c
, const char *value
)
142 _("Unwinding of stack if a signal is "
143 "received while in a call dummy is %s.\n"),
147 /* This boolean tells what gdb should do if a std::terminate call is
148 made while in a function called from gdb (call dummy).
149 As the confines of a single dummy stack prohibit out-of-frame
150 handlers from handling a raised exception, and as out-of-frame
151 handlers are common in C++, this can lead to no handler being found
152 by the unwinder, and a std::terminate call. This is a false positive.
153 If set, gdb unwinds the stack and restores the context to what it
156 The default is to unwind the frame if a std::terminate call is
159 static bool unwind_on_terminating_exception_p
= true;
162 show_unwind_on_terminating_exception_p (struct ui_file
*file
, int from_tty
,
163 struct cmd_list_element
*c
,
168 _("Unwind stack if a C++ exception is "
169 "unhandled while in a call dummy is %s.\n"),
173 /* Perform the standard coercions that are specified
174 for arguments to be passed to C, Ada or Fortran functions.
176 If PARAM_TYPE is non-NULL, it is the expected parameter type.
177 IS_PROTOTYPED is non-zero if the function declaration is prototyped. */
179 static struct value
*
180 value_arg_coerce (struct gdbarch
*gdbarch
, struct value
*arg
,
181 struct type
*param_type
, int is_prototyped
)
183 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
184 struct type
*arg_type
= check_typedef (arg
->type ());
186 = param_type
? check_typedef (param_type
) : arg_type
;
188 /* Perform any Ada- and Fortran-specific coercion first. */
189 if (current_language
->la_language
== language_ada
)
190 arg
= ada_convert_actual (arg
, type
);
191 else if (current_language
->la_language
== language_fortran
)
192 type
= fortran_preserve_arg_pointer (arg
, type
);
194 /* Force the value to the target if we will need its address. At
195 this point, we could allocate arguments on the stack instead of
196 calling malloc if we knew that their addresses would not be
197 saved by the called function. */
198 arg
= value_coerce_to_target (arg
);
200 switch (type
->code ())
203 case TYPE_CODE_RVALUE_REF
:
205 struct value
*new_value
;
207 if (TYPE_IS_REFERENCE (arg_type
))
208 return value_cast_pointers (type
, arg
, 0);
210 /* Cast the value to the reference's target type, and then
211 convert it back to a reference. This will issue an error
212 if the value was not previously in memory - in some cases
213 we should clearly be allowing this, but how? */
214 new_value
= value_cast (type
->target_type (), arg
);
215 new_value
= value_ref (new_value
, type
->code ());
222 /* If we don't have a prototype, coerce to integer type if necessary. */
225 if (type
->length () < builtin
->builtin_int
->length ())
226 type
= builtin
->builtin_int
;
228 /* Currently all target ABIs require at least the width of an integer
229 type for an argument. We may have to conditionalize the following
230 type coercion for future targets. */
231 if (type
->length () < builtin
->builtin_int
->length ())
232 type
= builtin
->builtin_int
;
235 if (!is_prototyped
&& coerce_float_to_double_p
)
237 if (type
->length () < builtin
->builtin_double
->length ())
238 type
= builtin
->builtin_double
;
239 else if (type
->length () > builtin
->builtin_double
->length ())
240 type
= builtin
->builtin_long_double
;
244 type
= lookup_pointer_type (type
);
246 case TYPE_CODE_ARRAY
:
247 /* Arrays are coerced to pointers to their first element, unless
248 they are vectors, in which case we want to leave them alone,
249 because they are passed by value. */
250 if (current_language
->c_style_arrays_p ())
251 if (!type
->is_vector ())
252 type
= lookup_pointer_type (type
->target_type ());
254 case TYPE_CODE_UNDEF
:
256 case TYPE_CODE_STRUCT
:
257 case TYPE_CODE_UNION
:
260 case TYPE_CODE_RANGE
:
261 case TYPE_CODE_STRING
:
262 case TYPE_CODE_ERROR
:
263 case TYPE_CODE_MEMBERPTR
:
264 case TYPE_CODE_METHODPTR
:
265 case TYPE_CODE_METHOD
:
266 case TYPE_CODE_COMPLEX
:
271 return value_cast (type
, arg
);
277 find_function_addr (struct value
*function
,
278 struct type
**retval_type
,
279 struct type
**function_type
)
281 struct type
*ftype
= check_typedef (function
->type ());
282 struct gdbarch
*gdbarch
= ftype
->arch ();
283 struct type
*value_type
= NULL
;
284 /* Initialize it just to avoid a GCC false warning. */
285 CORE_ADDR funaddr
= 0;
287 /* If it's a member function, just look at the function
290 /* Determine address to call. */
291 if (ftype
->code () == TYPE_CODE_FUNC
292 || ftype
->code () == TYPE_CODE_METHOD
)
293 funaddr
= function
->address ();
294 else if (ftype
->code () == TYPE_CODE_PTR
)
296 funaddr
= value_as_address (function
);
297 ftype
= check_typedef (ftype
->target_type ());
298 if (ftype
->code () == TYPE_CODE_FUNC
299 || ftype
->code () == TYPE_CODE_METHOD
)
300 funaddr
= gdbarch_convert_from_func_ptr_addr
301 (gdbarch
, funaddr
, current_inferior ()->top_target());
303 if (ftype
->code () == TYPE_CODE_FUNC
304 || ftype
->code () == TYPE_CODE_METHOD
)
306 if (ftype
->is_gnu_ifunc ())
308 CORE_ADDR resolver_addr
= funaddr
;
310 /* Resolve the ifunc. Note this may call the resolver
311 function in the inferior. */
312 funaddr
= gnu_ifunc_resolve_addr (gdbarch
, resolver_addr
);
314 /* Skip querying the function symbol if no RETVAL_TYPE or
315 FUNCTION_TYPE have been asked for. */
316 if (retval_type
!= NULL
|| function_type
!= NULL
)
318 type
*target_ftype
= find_function_type (funaddr
);
319 /* If we don't have debug info for the target function,
320 see if we can instead extract the target function's
321 type from the type that the resolver returns. */
322 if (target_ftype
== NULL
)
323 target_ftype
= find_gnu_ifunc_target_type (resolver_addr
);
324 if (target_ftype
!= NULL
)
326 value_type
= check_typedef (target_ftype
)->target_type ();
327 ftype
= target_ftype
;
332 value_type
= ftype
->target_type ();
334 else if (ftype
->code () == TYPE_CODE_INT
)
336 /* Handle the case of functions lacking debugging info.
337 Their values are characters since their addresses are char. */
338 if (ftype
->length () == 1)
339 funaddr
= value_as_address (value_addr (function
));
342 /* Handle function descriptors lacking debug info. */
343 int found_descriptor
= 0;
345 funaddr
= 0; /* pacify "gcc -Werror" */
346 if (function
->lval () == lval_memory
)
350 funaddr
= value_as_address (value_addr (function
));
352 funaddr
= gdbarch_convert_from_func_ptr_addr
353 (gdbarch
, funaddr
, current_inferior ()->top_target ());
354 if (funaddr
!= nfunaddr
)
355 found_descriptor
= 1;
357 if (!found_descriptor
)
358 /* Handle integer used as address of a function. */
359 funaddr
= (CORE_ADDR
) value_as_long (function
);
363 error (_("Invalid data type for function to be called."));
365 if (retval_type
!= NULL
)
366 *retval_type
= value_type
;
367 if (function_type
!= NULL
)
368 *function_type
= ftype
;
369 return funaddr
+ gdbarch_deprecated_function_start_offset (gdbarch
);
372 /* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called
373 function returns to. */
376 push_dummy_code (struct gdbarch
*gdbarch
,
377 CORE_ADDR sp
, CORE_ADDR funaddr
,
378 gdb::array_view
<value
*> args
,
379 struct type
*value_type
,
380 CORE_ADDR
*real_pc
, CORE_ADDR
*bp_addr
,
381 struct regcache
*regcache
)
383 gdb_assert (gdbarch_push_dummy_code_p (gdbarch
));
385 return gdbarch_push_dummy_code (gdbarch
, sp
, funaddr
,
386 args
.data (), args
.size (),
387 value_type
, real_pc
, bp_addr
,
394 error_call_unknown_return_type (const char *func_name
)
396 if (func_name
!= NULL
)
397 error (_("'%s' has unknown return type; "
398 "cast the call to its declared return type"),
401 error (_("function has unknown return type; "
402 "cast the call to its declared return type"));
405 /* Fetch the name of the function at FUNADDR.
406 This is used in printing an error message for call_function_by_hand.
407 BUF is used to print FUNADDR in hex if the function name cannot be
408 determined. It must be large enough to hold formatted result of
409 RAW_FUNCTION_ADDRESS_FORMAT. */
412 get_function_name (CORE_ADDR funaddr
, char *buf
, int buf_size
)
415 struct symbol
*symbol
= find_pc_function (funaddr
);
418 return symbol
->print_name ();
422 /* Try the minimal symbols. */
423 struct bound_minimal_symbol msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
426 return msymbol
.minsym
->print_name ();
430 std::string tmp
= string_printf (_(RAW_FUNCTION_ADDRESS_FORMAT
),
431 hex_string (funaddr
));
433 gdb_assert (tmp
.length () + 1 <= buf_size
);
434 return strcpy (buf
, tmp
.c_str ());
438 /* All the meta data necessary to extract the call's return value. */
440 struct call_return_meta_info
442 /* The caller frame's architecture. */
443 struct gdbarch
*gdbarch
;
445 /* The called function. */
446 struct value
*function
;
448 /* The return value's type. */
449 struct type
*value_type
;
451 /* Are we returning a value using a structure return or a normal
455 /* If using a structure return, this is the structure's address. */
456 CORE_ADDR struct_addr
;
459 /* Extract the called function's return value. */
461 static struct value
*
462 get_call_return_value (struct call_return_meta_info
*ri
)
464 struct value
*retval
= NULL
;
465 thread_info
*thr
= inferior_thread ();
466 bool stack_temporaries
= thread_stack_temporaries_enabled_p (thr
);
468 if (ri
->value_type
->code () == TYPE_CODE_VOID
)
469 retval
= value::allocate (ri
->value_type
);
470 else if (ri
->struct_return_p
)
472 if (stack_temporaries
)
474 retval
= value_from_contents_and_address (ri
->value_type
, NULL
,
476 push_thread_stack_temporary (thr
, retval
);
479 retval
= value_at_non_lval (ri
->value_type
, ri
->struct_addr
);
483 gdbarch_return_value_as_value (ri
->gdbarch
, ri
->function
, ri
->value_type
,
484 get_current_regcache (),
486 if (stack_temporaries
&& class_or_union_p (ri
->value_type
))
488 /* Values of class type returned in registers are copied onto
489 the stack and their lval_type set to lval_memory. This is
490 required because further evaluation of the expression
491 could potentially invoke methods on the return value
492 requiring GDB to evaluate the "this" pointer. To evaluate
493 the this pointer, GDB needs the memory address of the
495 retval
->force_lval (ri
->struct_addr
);
496 push_thread_stack_temporary (thr
, retval
);
500 gdb_assert (retval
!= NULL
);
504 /* Data for the FSM that manages an infcall. It's main job is to
505 record the called function's return value. */
507 struct call_thread_fsm
: public thread_fsm
509 /* All the info necessary to be able to extract the return
511 struct call_return_meta_info return_meta_info
;
513 /* The called function's return value. This is extracted from the
514 target before the dummy frame is popped. */
515 struct value
*return_value
= nullptr;
517 /* The top level that started the infcall (and is synchronously
518 waiting for it to end). */
519 struct ui
*waiting_ui
;
521 call_thread_fsm (struct ui
*waiting_ui
, struct interp
*cmd_interp
,
522 struct gdbarch
*gdbarch
, struct value
*function
,
523 struct type
*value_type
,
524 int struct_return_p
, CORE_ADDR struct_addr
);
526 bool should_stop (struct thread_info
*thread
) override
;
528 bool should_notify_stop () override
;
531 /* Allocate a new call_thread_fsm object. */
533 call_thread_fsm::call_thread_fsm (struct ui
*waiting_ui
,
534 struct interp
*cmd_interp
,
535 struct gdbarch
*gdbarch
,
536 struct value
*function
,
537 struct type
*value_type
,
538 int struct_return_p
, CORE_ADDR struct_addr
)
539 : thread_fsm (cmd_interp
),
540 waiting_ui (waiting_ui
)
542 return_meta_info
.gdbarch
= gdbarch
;
543 return_meta_info
.function
= function
;
544 return_meta_info
.value_type
= value_type
;
545 return_meta_info
.struct_return_p
= struct_return_p
;
546 return_meta_info
.struct_addr
= struct_addr
;
549 /* Implementation of should_stop method for infcalls. */
552 call_thread_fsm::should_stop (struct thread_info
*thread
)
554 INFCALL_SCOPED_DEBUG_ENTER_EXIT
;
556 if (stop_stack_dummy
== STOP_STACK_DUMMY
)
561 /* Stash the return value before the dummy frame is popped and
562 registers are restored to what they were before the
564 return_value
= get_call_return_value (&return_meta_info
);
566 /* Break out of wait_sync_command_done. */
567 scoped_restore save_ui
= make_scoped_restore (¤t_ui
, waiting_ui
);
568 target_terminal::ours ();
569 waiting_ui
->prompt_state
= PROMPT_NEEDED
;
575 /* Implementation of should_notify_stop method for infcalls. */
578 call_thread_fsm::should_notify_stop ()
582 /* Infcall succeeded. Be silent and proceed with evaluating the
587 /* Something wrong happened. E.g., an unexpected breakpoint
588 triggered, or a signal was intercepted. Notify the stop. */
592 /* Subroutine of call_function_by_hand to simplify it.
593 Start up the inferior and wait for it to stop.
594 Return the exception if there's an error, or an exception with
595 reason >= 0 if there's no error.
597 This is done inside a TRY_CATCH so the caller needn't worry about
598 thrown errors. The caller should rethrow if there's an error. */
600 static struct gdb_exception
601 run_inferior_call (std::unique_ptr
<call_thread_fsm
> sm
,
602 struct thread_info
*call_thread
, CORE_ADDR real_pc
)
604 INFCALL_SCOPED_DEBUG_ENTER_EXIT
;
606 struct gdb_exception caught_error
;
607 ptid_t call_thread_ptid
= call_thread
->ptid
;
608 int was_running
= call_thread
->state
== THREAD_RUNNING
;
610 infcall_debug_printf ("call function at %s in thread %s, was_running = %d",
611 core_addr_to_string (real_pc
),
612 call_thread_ptid
.to_string ().c_str (),
615 current_ui
->unregister_file_handler ();
617 scoped_restore restore_in_infcall
618 = make_scoped_restore (&call_thread
->control
.in_infcall
, 1);
620 clear_proceed_status (0);
622 /* Associate the FSM with the thread after clear_proceed_status
623 (otherwise it'd clear this FSM). */
624 call_thread
->set_thread_fsm (std::move (sm
));
626 disable_watchpoints_before_interactive_call_start ();
628 /* We want to print return value, please... */
629 call_thread
->control
.proceed_to_finish
= 1;
633 /* Infcalls run synchronously, in the foreground. */
634 scoped_restore restore_prompt_state
635 = make_scoped_restore (¤t_ui
->prompt_state
, PROMPT_BLOCKED
);
637 /* So that we don't print the prompt prematurely in
638 fetch_inferior_event. */
639 scoped_restore restore_ui_async
640 = make_scoped_restore (¤t_ui
->async
, 0);
642 proceed (real_pc
, GDB_SIGNAL_0
);
644 infrun_debug_show_threads ("non-exited threads after proceed for inferior-call",
645 all_non_exited_threads ());
647 /* Inferior function calls are always synchronous, even if the
648 target supports asynchronous execution. */
649 wait_sync_command_done ();
651 infcall_debug_printf ("inferior call completed successfully");
653 catch (gdb_exception
&e
)
655 infcall_debug_printf ("exception while making inferior call (%d): %s",
656 e
.reason
, e
.what ());
657 caught_error
= std::move (e
);
660 infcall_debug_printf ("thread is now: %s",
661 inferior_ptid
.to_string ().c_str ());
663 /* If GDB has the prompt blocked before, then ensure that it remains
664 so. normal_stop calls async_enable_stdin, so reset the prompt
665 state again here. In other cases, stdin will be re-enabled by
666 inferior_event_handler, when an exception is thrown. */
667 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
668 current_ui
->unregister_file_handler ();
670 current_ui
->register_file_handler ();
672 /* If the infcall does NOT succeed, normal_stop will have already
673 finished the thread states. However, on success, normal_stop
674 defers here, so that we can set back the thread states to what
675 they were before the call. Note that we must also finish the
676 state of new threads that might have spawned while the call was
677 running. The main cases to handle are:
679 - "(gdb) print foo ()", or any other command that evaluates an
680 expression at the prompt. (The thread was marked stopped before.)
682 - "(gdb) break foo if return_false()" or similar cases where we
683 do an infcall while handling an event (while the thread is still
684 marked running). In this example, whether the condition
685 evaluates true and thus we'll present a user-visible stop is
686 decided elsewhere. */
688 && call_thread_ptid
== inferior_ptid
689 && stop_stack_dummy
== STOP_STACK_DUMMY
)
690 finish_thread_state (call_thread
->inf
->process_target (),
691 user_visible_resume_ptid (0));
693 enable_watchpoints_after_interactive_call_stop ();
695 /* Call breakpoint_auto_delete on the current contents of the bpstat
696 of inferior call thread.
697 If all error()s out of proceed ended up calling normal_stop
698 (and perhaps they should; it already does in the special case
699 of error out of resume()), then we wouldn't need this. */
700 if (caught_error
.reason
< 0)
702 if (call_thread
->state
!= THREAD_EXITED
)
703 breakpoint_auto_delete (call_thread
->control
.stop_bpstat
);
709 /* Reserve space on the stack for a value of the given type.
710 Return the address of the allocated space.
711 Make certain that the value is correctly aligned.
712 The SP argument is modified. */
715 reserve_stack_space (const type
*values_type
, CORE_ADDR
&sp
)
717 frame_info_ptr frame
= get_current_frame ();
718 struct gdbarch
*gdbarch
= get_frame_arch (frame
);
721 if (gdbarch_inner_than (gdbarch
, 1, 2))
723 /* Stack grows downward. Align STRUCT_ADDR and SP after
725 sp
-= values_type
->length ();
726 if (gdbarch_frame_align_p (gdbarch
))
727 sp
= gdbarch_frame_align (gdbarch
, sp
);
732 /* Stack grows upward. Align the frame, allocate space, and
733 then again, re-align the frame??? */
734 if (gdbarch_frame_align_p (gdbarch
))
735 sp
= gdbarch_frame_align (gdbarch
, sp
);
737 sp
+= values_type
->length ();
738 if (gdbarch_frame_align_p (gdbarch
))
739 sp
= gdbarch_frame_align (gdbarch
, sp
);
745 /* The data structure which keeps a destructor function and
746 its implicit 'this' parameter. */
748 struct destructor_info
750 destructor_info (struct value
*function
, struct value
*self
)
751 : function (function
), self (self
) { }
753 struct value
*function
;
758 /* Auxiliary function that takes a list of destructor functions
759 with their 'this' parameters, and invokes the functions. */
762 call_destructors (const std::list
<destructor_info
> &dtors_to_invoke
,
763 struct type
*default_return_type
)
765 for (auto vals
: dtors_to_invoke
)
767 call_function_by_hand (vals
.function
, default_return_type
,
768 gdb::make_array_view (&(vals
.self
), 1));
775 call_function_by_hand (struct value
*function
,
776 type
*default_return_type
,
777 gdb::array_view
<value
*> args
)
779 return call_function_by_hand_dummy (function
, default_return_type
,
783 /* All this stuff with a dummy frame may seem unnecessarily complicated
784 (why not just save registers in GDB?). The purpose of pushing a dummy
785 frame which looks just like a real frame is so that if you call a
786 function and then hit a breakpoint (get a signal, etc), "backtrace"
787 will look right. Whether the backtrace needs to actually show the
788 stack at the time the inferior function was called is debatable, but
789 it certainly needs to not display garbage. So if you are contemplating
790 making dummy frames be different from normal frames, consider that. */
792 /* Perform a function call in the inferior.
793 ARGS is a vector of values of arguments.
794 FUNCTION is a value, the function to be called.
795 Returns a value representing what the function returned.
796 May fail to return, if a breakpoint or signal is hit
797 during the execution of the function.
799 ARGS is modified to contain coerced values. */
802 call_function_by_hand_dummy (struct value
*function
,
803 type
*default_return_type
,
804 gdb::array_view
<value
*> args
,
805 dummy_frame_dtor_ftype
*dummy_dtor
,
806 void *dummy_dtor_data
)
808 INFCALL_SCOPED_DEBUG_ENTER_EXIT
;
811 struct type
*target_values_type
;
812 function_call_return_method return_method
= return_method_normal
;
813 CORE_ADDR struct_addr
= 0;
816 struct frame_id dummy_id
;
817 frame_info_ptr frame
;
818 struct gdbarch
*gdbarch
;
819 ptid_t call_thread_ptid
;
820 struct gdb_exception e
;
821 char name_buf
[RAW_FUNCTION_ADDRESS_SIZE
];
823 if (!may_call_functions_p
)
824 error (_("Cannot call functions in the program: "
825 "may-call-functions is off."));
827 if (!target_has_execution ())
830 if (get_traceframe_number () >= 0)
831 error (_("May not call functions while looking at trace frames."));
833 if (execution_direction
== EXEC_REVERSE
)
834 error (_("Cannot call functions in reverse mode."));
836 /* We're going to run the target, and inspect the thread's state
837 afterwards. Hold a strong reference so that the pointer remains
838 valid even if the thread exits. */
839 thread_info_ref call_thread
840 = thread_info_ref::new_reference (inferior_thread ());
842 bool stack_temporaries
= thread_stack_temporaries_enabled_p (call_thread
.get ());
844 frame
= get_current_frame ();
845 gdbarch
= get_frame_arch (frame
);
847 if (!gdbarch_push_dummy_call_p (gdbarch
))
848 error (_("This target does not support function calls."));
850 /* Find the function type and do a sanity check. */
853 CORE_ADDR funaddr
= find_function_addr (function
, &values_type
, &ftype
);
855 if (is_nocall_function (ftype
))
856 error (_("Cannot call the function '%s' which does not follow the "
857 "target calling convention."),
858 get_function_name (funaddr
, name_buf
, sizeof (name_buf
)));
860 if (values_type
== NULL
|| values_type
->is_stub ())
861 values_type
= default_return_type
;
862 if (values_type
== NULL
)
864 const char *name
= get_function_name (funaddr
,
865 name_buf
, sizeof (name_buf
));
866 error (_("'%s' has unknown return type; "
867 "cast the call to its declared return type"),
871 values_type
= check_typedef (values_type
);
873 if (args
.size () < ftype
->num_fields ())
874 error (_("Too few arguments in function call."));
876 infcall_debug_printf ("calling %s", get_function_name (funaddr
, name_buf
,
879 /* A holder for the inferior status.
880 This is only needed while we're preparing the inferior function call. */
881 infcall_control_state_up
inf_status (save_infcall_control_state ());
883 /* Save the caller's registers and other state associated with the
884 inferior itself so that they can be restored once the
885 callee returns. To allow nested calls the registers are (further
886 down) pushed onto a dummy frame stack. This unique pointer
887 is released once the regcache has been pushed). */
888 infcall_suspend_state_up
caller_state (save_infcall_suspend_state ());
890 /* Ensure that the initial SP is correctly aligned. */
892 CORE_ADDR old_sp
= get_frame_sp (frame
);
894 if (gdbarch_frame_align_p (gdbarch
))
896 sp
= gdbarch_frame_align (gdbarch
, old_sp
);
897 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
898 ABIs, a function can use memory beyond the inner most stack
899 address. AMD64 called that region the "red zone". Skip at
900 least the "red zone" size before allocating any space on
902 if (gdbarch_inner_than (gdbarch
, 1, 2))
903 sp
-= gdbarch_frame_red_zone_size (gdbarch
);
905 sp
+= gdbarch_frame_red_zone_size (gdbarch
);
907 gdb_assert (sp
== gdbarch_frame_align (gdbarch
, sp
));
908 /* NOTE: cagney/2002-09-18:
910 On a RISC architecture, a void parameterless generic dummy
911 frame (i.e., no parameters, no result) typically does not
912 need to push anything the stack and hence can leave SP and
913 FP. Similarly, a frameless (possibly leaf) function does
914 not push anything on the stack and, hence, that too can
915 leave FP and SP unchanged. As a consequence, a sequence of
916 void parameterless generic dummy frame calls to frameless
917 functions will create a sequence of effectively identical
918 frames (SP, FP and TOS and PC the same). This, not
919 surprisingly, results in what appears to be a stack in an
920 infinite loop --- when GDB tries to find a generic dummy
921 frame on the internal dummy frame stack, it will always
924 To avoid this problem, the code below always grows the
925 stack. That way, two dummy frames can never be identical.
926 It does burn a few bytes of stack but that is a small price
930 if (gdbarch_inner_than (gdbarch
, 1, 2))
931 /* Stack grows down. */
932 sp
= gdbarch_frame_align (gdbarch
, old_sp
- 1);
934 /* Stack grows up. */
935 sp
= gdbarch_frame_align (gdbarch
, old_sp
+ 1);
937 /* SP may have underflown address zero here from OLD_SP. Memory access
938 functions will probably fail in such case but that is a target's
942 /* FIXME: cagney/2002-09-18: Hey, you loose!
944 Who knows how badly aligned the SP is!
946 If the generic dummy frame ends up empty (because nothing is
947 pushed) GDB won't be able to correctly perform back traces.
948 If a target is having trouble with backtraces, first thing to
949 do is add FRAME_ALIGN() to the architecture vector. If that
950 fails, try dummy_id().
952 If the ABI specifies a "Red Zone" (see the doco) the code
953 below will quietly trash it. */
956 /* Skip over the stack temporaries that might have been generated during
957 the evaluation of an expression. */
958 if (stack_temporaries
)
960 struct value
*lastval
;
962 lastval
= get_last_thread_stack_temporary (call_thread
.get ());
965 CORE_ADDR lastval_addr
= lastval
->address ();
967 if (gdbarch_inner_than (gdbarch
, 1, 2))
969 gdb_assert (sp
>= lastval_addr
);
974 gdb_assert (sp
<= lastval_addr
);
975 sp
= lastval_addr
+ lastval
->type ()->length ();
978 if (gdbarch_frame_align_p (gdbarch
))
979 sp
= gdbarch_frame_align (gdbarch
, sp
);
984 /* Are we returning a value using a structure return? */
986 if (gdbarch_return_in_first_hidden_param_p (gdbarch
, values_type
))
988 return_method
= return_method_hidden_param
;
990 /* Tell the target specific argument pushing routine not to
992 target_values_type
= builtin_type (gdbarch
)->builtin_void
;
996 if (using_struct_return (gdbarch
, function
, values_type
))
997 return_method
= return_method_struct
;
998 target_values_type
= values_type
;
1001 gdb::observers::inferior_call_pre
.notify (inferior_ptid
, funaddr
);
1003 /* Determine the location of the breakpoint (and possibly other
1004 stuff) that the called function will return to. The SPARC, for a
1005 function returning a structure or union, needs to make space for
1006 not just the breakpoint but also an extra word containing the
1007 size (?) of the structure being passed. */
1009 switch (gdbarch_call_dummy_location (gdbarch
))
1013 const gdb_byte
*bp_bytes
;
1014 CORE_ADDR bp_addr_as_address
;
1017 /* Be careful BP_ADDR is in inferior PC encoding while
1018 BP_ADDR_AS_ADDRESS is a plain memory address. */
1020 sp
= push_dummy_code (gdbarch
, sp
, funaddr
, args
,
1021 target_values_type
, &real_pc
, &bp_addr
,
1022 get_current_regcache ());
1024 /* Write a legitimate instruction at the point where the infcall
1025 breakpoint is going to be inserted. While this instruction
1026 is never going to be executed, a user investigating the
1027 memory from GDB would see this instruction instead of random
1028 uninitialized bytes. We chose the breakpoint instruction
1029 as it may look as the most logical one to the user and also
1030 valgrind 3.7.0 needs it for proper vgdb inferior calls.
1032 If software breakpoints are unsupported for this target we
1033 leave the user visible memory content uninitialized. */
1035 bp_addr_as_address
= bp_addr
;
1036 bp_bytes
= gdbarch_breakpoint_from_pc (gdbarch
, &bp_addr_as_address
,
1038 if (bp_bytes
!= NULL
)
1039 write_memory (bp_addr_as_address
, bp_bytes
, bp_size
);
1042 case AT_ENTRY_POINT
:
1044 CORE_ADDR dummy_addr
;
1047 dummy_addr
= entry_point_address ();
1049 /* A call dummy always consists of just a single breakpoint, so
1050 its address is the same as the address of the dummy.
1052 The actual breakpoint is inserted separatly so there is no need to
1054 bp_addr
= dummy_addr
;
1058 internal_error (_("bad switch"));
1061 /* Coerce the arguments and handle pass-by-reference.
1062 We want to remember the destruction required for pass-by-ref values.
1063 For these, store the dtor function and the 'this' argument
1064 in DTORS_TO_INVOKE. */
1065 std::list
<destructor_info
> dtors_to_invoke
;
1067 for (int i
= args
.size () - 1; i
>= 0; i
--)
1070 struct type
*param_type
;
1072 /* FIXME drow/2002-05-31: Should just always mark methods as
1073 prototyped. Can we respect TYPE_VARARGS? Probably not. */
1074 if (ftype
->code () == TYPE_CODE_METHOD
)
1076 else if (ftype
->target_type () == NULL
&& ftype
->num_fields () == 0
1077 && default_return_type
!= NULL
)
1079 /* Calling a no-debug function with the return type
1080 explicitly cast. Assume the function is prototyped,
1081 with a prototype matching the types of the arguments.
1083 float mult (float v1, float v2) { return v1 * v2; }
1085 (gdb) p (float) mult (2.0f, 3.0f)
1086 Is a simpler alternative to:
1087 (gdb) p ((float (*) (float, float)) mult) (2.0f, 3.0f)
1091 else if (i
< ftype
->num_fields ())
1092 prototyped
= ftype
->is_prototyped ();
1096 if (i
< ftype
->num_fields ())
1097 param_type
= ftype
->field (i
).type ();
1101 value
*original_arg
= args
[i
];
1102 args
[i
] = value_arg_coerce (gdbarch
, args
[i
],
1103 param_type
, prototyped
);
1105 if (param_type
== NULL
)
1108 auto info
= language_pass_by_reference (param_type
);
1109 if (!info
.copy_constructible
)
1110 error (_("expression cannot be evaluated because the type '%s' "
1111 "is not copy constructible"), param_type
->name ());
1113 if (!info
.destructible
)
1114 error (_("expression cannot be evaluated because the type '%s' "
1115 "is not destructible"), param_type
->name ());
1117 if (info
.trivially_copyable
)
1120 /* Make a copy of the argument on the stack. If the argument is
1121 trivially copy ctor'able, copy bit by bit. Otherwise, call
1122 the copy ctor to initialize the clone. */
1123 CORE_ADDR addr
= reserve_stack_space (param_type
, sp
);
1125 = value_from_contents_and_address (param_type
, nullptr, addr
);
1126 push_thread_stack_temporary (call_thread
.get (), clone
);
1128 = value_from_pointer (lookup_pointer_type (param_type
), addr
);
1130 if (info
.trivially_copy_constructible
)
1132 int length
= param_type
->length ();
1133 write_memory (addr
, args
[i
]->contents ().data (), length
);
1138 value
*cctor_args
[2] = { clone_ptr
, original_arg
};
1139 find_overload_match (gdb::make_array_view (cctor_args
, 2),
1140 param_type
->name (), METHOD
,
1141 &clone_ptr
, nullptr, ©_ctor
, nullptr,
1142 nullptr, 0, EVAL_NORMAL
);
1144 if (copy_ctor
== nullptr)
1145 error (_("expression cannot be evaluated because a copy "
1146 "constructor for the type '%s' could not be found "
1147 "(maybe inlined?)"), param_type
->name ());
1149 call_function_by_hand (copy_ctor
, default_return_type
,
1150 gdb::make_array_view (cctor_args
, 2));
1153 /* If the argument has a destructor, remember it so that we
1154 invoke it after the infcall is complete. */
1155 if (!info
.trivially_destructible
)
1157 /* Looking up the function via overload resolution does not
1158 work because the compiler (in particular, gcc) adds an
1159 artificial int parameter in some cases. So we look up
1160 the function by using the "~" name. This should be OK
1161 because there can be only one dtor definition. */
1162 const char *dtor_name
= nullptr;
1163 for (int fieldnum
= 0;
1164 fieldnum
< TYPE_NFN_FIELDS (param_type
);
1168 = TYPE_FN_FIELDLIST1 (param_type
, fieldnum
);
1169 const char *field_name
1170 = TYPE_FN_FIELDLIST_NAME (param_type
, fieldnum
);
1172 if (field_name
[0] == '~')
1173 dtor_name
= TYPE_FN_FIELD_PHYSNAME (fn
, 0);
1176 if (dtor_name
== nullptr)
1177 error (_("expression cannot be evaluated because a destructor "
1178 "for the type '%s' could not be found "
1179 "(maybe inlined?)"), param_type
->name ());
1182 = find_function_in_inferior (dtor_name
, 0);
1184 /* Insert the dtor to the front of the list to call them
1185 in reverse order later. */
1186 dtors_to_invoke
.emplace_front (dtor
, clone_ptr
);
1189 args
[i
] = clone_ptr
;
1192 /* Reserve space for the return structure to be written on the
1193 stack, if necessary.
1195 While evaluating expressions, we reserve space on the stack for
1196 return values of class type even if the language ABI and the target
1197 ABI do not require that the return value be passed as a hidden first
1198 argument. This is because we want to store the return value as an
1199 on-stack temporary while the expression is being evaluated. This
1200 enables us to have chained function calls in expressions.
1202 Keeping the return values as on-stack temporaries while the expression
1203 is being evaluated is OK because the thread is stopped until the
1204 expression is completely evaluated. */
1206 if (return_method
!= return_method_normal
1207 || (stack_temporaries
&& class_or_union_p (values_type
)))
1208 struct_addr
= reserve_stack_space (values_type
, sp
);
1210 std::vector
<struct value
*> new_args
;
1211 if (return_method
== return_method_hidden_param
)
1213 /* Add the new argument to the front of the argument list. */
1214 new_args
.reserve (args
.size ());
1216 (value_from_pointer (lookup_pointer_type (values_type
), struct_addr
));
1217 new_args
.insert (new_args
.end (), args
.begin (), args
.end ());
1221 /* Create the dummy stack frame. Pass in the call dummy address as,
1222 presumably, the ABI code knows where, in the call dummy, the
1223 return address should be pointed. */
1224 sp
= gdbarch_push_dummy_call (gdbarch
, function
, get_current_regcache (),
1225 bp_addr
, args
.size (), args
.data (),
1226 sp
, return_method
, struct_addr
);
1228 /* Set up a frame ID for the dummy frame so we can pass it to
1229 set_momentary_breakpoint. We need to give the breakpoint a frame
1230 ID so that the breakpoint code can correctly re-identify the
1231 dummy breakpoint. */
1232 /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL,
1233 saved as the dummy-frame TOS, and used by dummy_id to form
1234 the frame ID's stack address. */
1235 dummy_id
= frame_id_build (sp
, bp_addr
);
1237 /* Create a momentary breakpoint at the return address of the
1238 inferior. That way it breaks when it returns. */
1241 symtab_and_line sal
;
1242 sal
.pspace
= current_program_space
;
1244 sal
.section
= find_pc_overlay (sal
.pc
);
1246 /* Sanity. The exact same SP value is returned by
1247 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
1248 dummy_id to form the frame ID's stack address. */
1250 = set_momentary_breakpoint (gdbarch
, sal
,
1251 dummy_id
, bp_call_dummy
).release ();
1253 /* set_momentary_breakpoint invalidates FRAME. */
1256 bpt
->disposition
= disp_del
;
1257 gdb_assert (bpt
->related_breakpoint
== bpt
);
1259 breakpoint
*longjmp_b
= set_longjmp_breakpoint_for_call_dummy ();
1262 /* Link BPT into the chain of LONGJMP_B. */
1263 bpt
->related_breakpoint
= longjmp_b
;
1264 while (longjmp_b
->related_breakpoint
!= bpt
->related_breakpoint
)
1265 longjmp_b
= longjmp_b
->related_breakpoint
;
1266 longjmp_b
->related_breakpoint
= bpt
;
1270 /* Create a breakpoint in std::terminate.
1271 If a C++ exception is raised in the dummy-frame, and the
1272 exception handler is (normally, and expected to be) out-of-frame,
1273 the default C++ handler will (wrongly) be called in an inferior
1274 function call. This is wrong, as an exception can be normally
1275 and legally handled out-of-frame. The confines of the dummy frame
1276 prevent the unwinder from finding the correct handler (or any
1277 handler, unless it is in-frame). The default handler calls
1278 std::terminate. This will kill the inferior. Assert that
1279 terminate should never be called in an inferior function
1280 call. Place a momentary breakpoint in the std::terminate function
1281 and if triggered in the call, rewind. */
1282 if (unwind_on_terminating_exception_p
)
1283 set_std_terminate_breakpoint ();
1285 /* Everything's ready, push all the info needed to restore the
1286 caller (and identify the dummy-frame) onto the dummy-frame
1288 dummy_frame_push (caller_state
.release (), &dummy_id
, call_thread
.get ());
1289 if (dummy_dtor
!= NULL
)
1290 register_dummy_frame_dtor (dummy_id
, call_thread
.get (),
1291 dummy_dtor
, dummy_dtor_data
);
1293 /* Register a clean-up for unwind_on_terminating_exception_breakpoint. */
1294 SCOPE_EXIT
{ delete_std_terminate_breakpoint (); };
1296 /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP -
1297 If you're looking to implement asynchronous dummy-frames, then
1298 just below is the place to chop this function in two.. */
1301 /* Save the current FSM. We'll override it. */
1302 std::unique_ptr
<thread_fsm
> saved_sm
= call_thread
->release_thread_fsm ();
1303 struct call_thread_fsm
*sm
;
1305 /* Save this thread's ptid, we need it later but the thread
1307 call_thread_ptid
= call_thread
->ptid
;
1309 /* Run the inferior until it stops. */
1311 /* Create the FSM used to manage the infcall. It tells infrun to
1312 not report the stop to the user, and captures the return value
1313 before the dummy frame is popped. run_inferior_call registers
1314 it with the thread ASAP. */
1315 sm
= new call_thread_fsm (current_ui
, command_interp (),
1318 return_method
!= return_method_normal
,
1321 std::unique_ptr
<call_thread_fsm
> sm_up (sm
);
1322 e
= run_inferior_call (std::move (sm_up
), call_thread
.get (), real_pc
);
1326 infcall_debug_printf ("after inferior call, exception (%d): %s",
1327 e
.reason
, e
.what ());
1328 infcall_debug_printf ("after inferior call, thread state is: %s",
1329 thread_state_string (call_thread
->state
));
1331 gdb::observers::inferior_call_post
.notify (call_thread_ptid
, funaddr
);
1333 if (call_thread
->state
!= THREAD_EXITED
)
1335 /* The FSM should still be the same. */
1336 gdb_assert (call_thread
->thread_fsm () == sm
);
1338 if (call_thread
->thread_fsm ()->finished_p ())
1340 struct value
*retval
;
1342 infcall_debug_printf ("call completed");
1344 /* The inferior call is successful. Pop the dummy frame,
1345 which runs its destructors and restores the inferior's
1346 suspend state, and restore the inferior control
1348 dummy_frame_pop (dummy_id
, call_thread
.get ());
1349 restore_infcall_control_state (inf_status
.release ());
1351 /* Get the return value. */
1352 retval
= sm
->return_value
;
1354 /* Restore the original FSM and clean up / destroh the call FSM.
1355 Doing it in this order ensures that if the call to clean_up
1356 throws, the original FSM is properly restored. */
1358 std::unique_ptr
<thread_fsm
> finalizing
1359 = call_thread
->release_thread_fsm ();
1360 call_thread
->set_thread_fsm (std::move (saved_sm
));
1362 finalizing
->clean_up (call_thread
.get ());
1365 maybe_remove_breakpoints ();
1367 gdb_assert (retval
!= NULL
);
1369 /* Destruct the pass-by-ref argument clones. */
1370 call_destructors (dtors_to_invoke
, default_return_type
);
1375 infcall_debug_printf ("call did not complete");
1377 /* Didn't complete. Clean up / destroy the call FSM, and restore the
1378 previous state machine, and handle the error. */
1380 std::unique_ptr
<thread_fsm
> finalizing
1381 = call_thread
->release_thread_fsm ();
1382 call_thread
->set_thread_fsm (std::move (saved_sm
));
1384 finalizing
->clean_up (call_thread
.get ());
1389 /* Rethrow an error if we got one trying to run the inferior. */
1393 const char *name
= get_function_name (funaddr
,
1394 name_buf
, sizeof (name_buf
));
1396 discard_infcall_control_state (inf_status
.release ());
1398 /* We could discard the dummy frame here if the program exited,
1399 but it will get garbage collected the next time the program is
1405 throw_error (e
.error
, _("%s\n\
1406 An error occurred while in a function called from GDB.\n\
1407 Evaluation of the expression containing the function\n\
1408 (%s) will be abandoned.\n\
1409 When the function is done executing, GDB will silently stop."),
1413 throw_exception (std::move (e
));
1417 /* If the program has exited, or we stopped at a different thread,
1418 exit and inform the user. */
1420 if (! target_has_execution ())
1422 const char *name
= get_function_name (funaddr
,
1423 name_buf
, sizeof (name_buf
));
1425 /* If we try to restore the inferior status,
1426 we'll crash as the inferior is no longer running. */
1427 discard_infcall_control_state (inf_status
.release ());
1429 /* We could discard the dummy frame here given that the program exited,
1430 but it will get garbage collected the next time the program is
1433 error (_("The program being debugged exited while in a function "
1434 "called from GDB.\n"
1435 "Evaluation of the expression containing the function\n"
1436 "(%s) will be abandoned."),
1440 if (call_thread_ptid
!= inferior_ptid
)
1442 const char *name
= get_function_name (funaddr
,
1443 name_buf
, sizeof (name_buf
));
1445 /* We've switched threads. This can happen if another thread gets a
1446 signal or breakpoint while our thread was running.
1447 There's no point in restoring the inferior status,
1448 we're in a different thread. */
1449 discard_infcall_control_state (inf_status
.release ());
1450 /* Keep the dummy frame record, if the user switches back to the
1451 thread with the hand-call, we'll need it. */
1452 if (stopped_by_random_signal
)
1454 The program received a signal in another thread while\n\
1455 making a function call from GDB.\n\
1456 Evaluation of the expression containing the function\n\
1457 (%s) will be abandoned.\n\
1458 When the function is done executing, GDB will silently stop."),
1462 The program stopped in another thread while making a function call from GDB.\n\
1463 Evaluation of the expression containing the function\n\
1464 (%s) will be abandoned.\n\
1465 When the function is done executing, GDB will silently stop."),
1470 /* Make a copy as NAME may be in an objfile freed by dummy_frame_pop. */
1471 std::string name
= get_function_name (funaddr
, name_buf
,
1474 if (stopped_by_random_signal
)
1476 /* We stopped inside the FUNCTION because of a random
1477 signal. Further execution of the FUNCTION is not
1480 if (unwind_on_signal_p
)
1482 /* The user wants the context restored. */
1484 /* We must get back to the frame we were before the
1486 dummy_frame_pop (dummy_id
, call_thread
.get ());
1488 /* We also need to restore inferior status to that before the
1490 restore_infcall_control_state (inf_status
.release ());
1492 /* FIXME: Insert a bunch of wrap_here; name can be very
1493 long if it's a C++ name with arguments and stuff. */
1495 The program being debugged was signaled while in a function called from GDB.\n\
1496 GDB has restored the context to what it was before the call.\n\
1497 To change this behavior use \"set unwindonsignal off\".\n\
1498 Evaluation of the expression containing the function\n\
1499 (%s) will be abandoned."),
1504 /* The user wants to stay in the frame where we stopped
1506 Discard inferior status, we're not at the same point
1508 discard_infcall_control_state (inf_status
.release ());
1510 /* FIXME: Insert a bunch of wrap_here; name can be very
1511 long if it's a C++ name with arguments and stuff. */
1513 The program being debugged was signaled while in a function called from GDB.\n\
1514 GDB remains in the frame where the signal was received.\n\
1515 To change this behavior use \"set unwindonsignal on\".\n\
1516 Evaluation of the expression containing the function\n\
1517 (%s) will be abandoned.\n\
1518 When the function is done executing, GDB will silently stop."),
1523 if (stop_stack_dummy
== STOP_STD_TERMINATE
)
1525 /* We must get back to the frame we were before the dummy
1527 dummy_frame_pop (dummy_id
, call_thread
.get ());
1529 /* We also need to restore inferior status to that before
1531 restore_infcall_control_state (inf_status
.release ());
1534 The program being debugged entered a std::terminate call, most likely\n\
1535 caused by an unhandled C++ exception. GDB blocked this call in order\n\
1536 to prevent the program from being terminated, and has restored the\n\
1537 context to its original state before the call.\n\
1538 To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
1539 Evaluation of the expression containing the function (%s)\n\
1540 will be abandoned."),
1543 else if (stop_stack_dummy
== STOP_NONE
)
1546 /* We hit a breakpoint inside the FUNCTION.
1547 Keep the dummy frame, the user may want to examine its state.
1548 Discard inferior status, we're not at the same point
1550 discard_infcall_control_state (inf_status
.release ());
1552 /* The following error message used to say "The expression
1553 which contained the function call has been discarded."
1554 It is a hard concept to explain in a few words. Ideally,
1555 GDB would be able to resume evaluation of the expression
1556 when the function finally is done executing. Perhaps
1557 someday this will be implemented (it would not be easy). */
1558 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1559 a C++ name with arguments and stuff. */
1561 The program being debugged stopped while in a function called from GDB.\n\
1562 Evaluation of the expression containing the function\n\
1563 (%s) will be abandoned.\n\
1564 When the function is done executing, GDB will silently stop."),
1570 /* The above code errors out, so ... */
1571 gdb_assert_not_reached ("... should not be here");
1574 void _initialize_infcall ();
1576 _initialize_infcall ()
1578 add_setshow_boolean_cmd ("may-call-functions", no_class
,
1579 &may_call_functions_p
, _("\
1580 Set permission to call functions in the program."), _("\
1581 Show permission to call functions in the program."), _("\
1582 When this permission is on, GDB may call functions in the program.\n\
1583 Otherwise, any sort of attempt to call a function in the program\n\
1584 will result in an error."),
1586 show_may_call_functions_p
,
1587 &setlist
, &showlist
);
1589 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure
,
1590 &coerce_float_to_double_p
, _("\
1591 Set coercion of floats to doubles when calling functions."), _("\
1592 Show coercion of floats to doubles when calling functions."), _("\
1593 Variables of type float should generally be converted to doubles before\n\
1594 calling an unprototyped function, and left alone when calling a prototyped\n\
1595 function. However, some older debug info formats do not provide enough\n\
1596 information to determine that a function is prototyped. If this flag is\n\
1597 set, GDB will perform the conversion for a function it considers\n\
1599 The default is to perform the conversion."),
1601 show_coerce_float_to_double_p
,
1602 &setlist
, &showlist
);
1604 add_setshow_boolean_cmd ("unwindonsignal", no_class
,
1605 &unwind_on_signal_p
, _("\
1606 Set unwinding of stack if a signal is received while in a call dummy."), _("\
1607 Show unwinding of stack if a signal is received while in a call dummy."), _("\
1608 The unwindonsignal lets the user determine what gdb should do if a signal\n\
1609 is received while in a function called from gdb (call dummy). If set, gdb\n\
1610 unwinds the stack and restore the context to what as it was before the call.\n\
1611 The default is to stop in the frame where the signal was received."),
1613 show_unwind_on_signal_p
,
1614 &setlist
, &showlist
);
1616 add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class
,
1617 &unwind_on_terminating_exception_p
, _("\
1618 Set unwinding of stack if std::terminate is called while in call dummy."), _("\
1619 Show unwinding of stack if std::terminate() is called while in a call dummy."),
1621 The unwind on terminating exception flag lets the user determine\n\
1622 what gdb should do if a std::terminate() call is made from the\n\
1623 default exception handler. If set, gdb unwinds the stack and restores\n\
1624 the context to what it was before the call. If unset, gdb allows the\n\
1625 std::terminate call to proceed.\n\
1626 The default is to unwind the frame."),
1628 show_unwind_on_terminating_exception_p
,
1629 &setlist
, &showlist
);
1631 add_setshow_boolean_cmd
1632 ("infcall", class_maintenance
, &debug_infcall
,
1633 _("Set inferior call debugging."),
1634 _("Show inferior call debugging."),
1635 _("When on, inferior function call specific debugging is enabled."),
1636 NULL
, show_debug_infcall
, &setdebuglist
, &showdebuglist
);