1 /* Perform an inferior function call, for GDB, the GNU debugger.
3 Copyright (C) 1986-2018 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"
36 #include "gdbthread.h"
37 #include "event-top.h"
38 #include "observable.h"
41 #include "thread-fsm.h"
44 /* If we can't find a function's name from its address,
45 we print this instead. */
46 #define RAW_FUNCTION_ADDRESS_FORMAT "at 0x%s"
47 #define RAW_FUNCTION_ADDRESS_SIZE (sizeof (RAW_FUNCTION_ADDRESS_FORMAT) \
48 + 2 * sizeof (CORE_ADDR))
50 /* NOTE: cagney/2003-04-16: What's the future of this code?
52 GDB needs an asynchronous expression evaluator, that means an
53 asynchronous inferior function call implementation, and that in
54 turn means restructuring the code so that it is event driven. */
56 /* How you should pass arguments to a function depends on whether it
57 was defined in K&R style or prototype style. If you define a
58 function using the K&R syntax that takes a `float' argument, then
59 callers must pass that argument as a `double'. If you define the
60 function using the prototype syntax, then you must pass the
61 argument as a `float', with no promotion.
63 Unfortunately, on certain older platforms, the debug info doesn't
64 indicate reliably how each function was defined. A function type's
65 TYPE_PROTOTYPED flag may be clear, even if the function was defined
66 in prototype style. When calling a function whose TYPE_PROTOTYPED
67 flag is clear, GDB consults this flag to decide what to do.
69 For modern targets, it is proper to assume that, if the prototype
70 flag is clear, that can be trusted: `float' arguments should be
71 promoted to `double'. For some older targets, if the prototype
72 flag is clear, that doesn't tell us anything. The default is to
73 trust the debug information; the user can override this behavior
74 with "set coerce-float-to-double 0". */
76 static int coerce_float_to_double_p
= 1;
78 show_coerce_float_to_double_p (struct ui_file
*file
, int from_tty
,
79 struct cmd_list_element
*c
, const char *value
)
81 fprintf_filtered (file
,
82 _("Coercion of floats to doubles "
83 "when calling functions is %s.\n"),
87 /* This boolean tells what gdb should do if a signal is received while
88 in a function called from gdb (call dummy). If set, gdb unwinds
89 the stack and restore the context to what as it was before the
92 The default is to stop in the frame where the signal was received. */
94 static int unwind_on_signal_p
= 0;
96 show_unwind_on_signal_p (struct ui_file
*file
, int from_tty
,
97 struct cmd_list_element
*c
, const char *value
)
99 fprintf_filtered (file
,
100 _("Unwinding of stack if a signal is "
101 "received while in a call dummy is %s.\n"),
105 /* This boolean tells what gdb should do if a std::terminate call is
106 made while in a function called from gdb (call dummy).
107 As the confines of a single dummy stack prohibit out-of-frame
108 handlers from handling a raised exception, and as out-of-frame
109 handlers are common in C++, this can lead to no handler being found
110 by the unwinder, and a std::terminate call. This is a false positive.
111 If set, gdb unwinds the stack and restores the context to what it
114 The default is to unwind the frame if a std::terminate call is
117 static int unwind_on_terminating_exception_p
= 1;
120 show_unwind_on_terminating_exception_p (struct ui_file
*file
, int from_tty
,
121 struct cmd_list_element
*c
,
125 fprintf_filtered (file
,
126 _("Unwind stack if a C++ exception is "
127 "unhandled while in a call dummy is %s.\n"),
131 /* Perform the standard coercions that are specified
132 for arguments to be passed to C or Ada functions.
134 If PARAM_TYPE is non-NULL, it is the expected parameter type.
135 IS_PROTOTYPED is non-zero if the function declaration is prototyped.
136 SP is the stack pointer were additional data can be pushed (updating
137 its value as needed). */
139 static struct value
*
140 value_arg_coerce (struct gdbarch
*gdbarch
, struct value
*arg
,
141 struct type
*param_type
, int is_prototyped
, CORE_ADDR
*sp
)
143 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
144 struct type
*arg_type
= check_typedef (value_type (arg
));
146 = param_type
? check_typedef (param_type
) : arg_type
;
148 /* Perform any Ada-specific coercion first. */
149 if (current_language
->la_language
== language_ada
)
150 arg
= ada_convert_actual (arg
, type
);
152 /* Force the value to the target if we will need its address. At
153 this point, we could allocate arguments on the stack instead of
154 calling malloc if we knew that their addresses would not be
155 saved by the called function. */
156 arg
= value_coerce_to_target (arg
);
158 switch (TYPE_CODE (type
))
161 case TYPE_CODE_RVALUE_REF
:
163 struct value
*new_value
;
165 if (TYPE_IS_REFERENCE (arg_type
))
166 return value_cast_pointers (type
, arg
, 0);
168 /* Cast the value to the reference's target type, and then
169 convert it back to a reference. This will issue an error
170 if the value was not previously in memory - in some cases
171 we should clearly be allowing this, but how? */
172 new_value
= value_cast (TYPE_TARGET_TYPE (type
), arg
);
173 new_value
= value_ref (new_value
, TYPE_CODE (type
));
180 /* If we don't have a prototype, coerce to integer type if necessary. */
183 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin
->builtin_int
))
184 type
= builtin
->builtin_int
;
186 /* Currently all target ABIs require at least the width of an integer
187 type for an argument. We may have to conditionalize the following
188 type coercion for future targets. */
189 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin
->builtin_int
))
190 type
= builtin
->builtin_int
;
193 if (!is_prototyped
&& coerce_float_to_double_p
)
195 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin
->builtin_double
))
196 type
= builtin
->builtin_double
;
197 else if (TYPE_LENGTH (type
) > TYPE_LENGTH (builtin
->builtin_double
))
198 type
= builtin
->builtin_long_double
;
202 type
= lookup_pointer_type (type
);
204 case TYPE_CODE_ARRAY
:
205 /* Arrays are coerced to pointers to their first element, unless
206 they are vectors, in which case we want to leave them alone,
207 because they are passed by value. */
208 if (current_language
->c_style_arrays
)
209 if (!TYPE_VECTOR (type
))
210 type
= lookup_pointer_type (TYPE_TARGET_TYPE (type
));
212 case TYPE_CODE_UNDEF
:
214 case TYPE_CODE_STRUCT
:
215 case TYPE_CODE_UNION
:
218 case TYPE_CODE_RANGE
:
219 case TYPE_CODE_STRING
:
220 case TYPE_CODE_ERROR
:
221 case TYPE_CODE_MEMBERPTR
:
222 case TYPE_CODE_METHODPTR
:
223 case TYPE_CODE_METHOD
:
224 case TYPE_CODE_COMPLEX
:
229 return value_cast (type
, arg
);
232 /* Return the return type of a function with its first instruction exactly at
233 the PC address. Return NULL otherwise. */
236 find_function_return_type (CORE_ADDR pc
)
238 struct symbol
*sym
= find_pc_function (pc
);
240 if (sym
!= NULL
&& BLOCK_START (SYMBOL_BLOCK_VALUE (sym
)) == pc
241 && SYMBOL_TYPE (sym
) != NULL
)
242 return TYPE_TARGET_TYPE (SYMBOL_TYPE (sym
));
247 /* Determine a function's address and its return type from its value.
248 Calls error() if the function is not valid for calling. */
251 find_function_addr (struct value
*function
, struct type
**retval_type
)
253 struct type
*ftype
= check_typedef (value_type (function
));
254 struct gdbarch
*gdbarch
= get_type_arch (ftype
);
255 struct type
*value_type
= NULL
;
256 /* Initialize it just to avoid a GCC false warning. */
257 CORE_ADDR funaddr
= 0;
259 /* If it's a member function, just look at the function
262 /* Determine address to call. */
263 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
264 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
265 funaddr
= value_address (function
);
266 else if (TYPE_CODE (ftype
) == TYPE_CODE_PTR
)
268 funaddr
= value_as_address (function
);
269 ftype
= check_typedef (TYPE_TARGET_TYPE (ftype
));
270 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
271 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
272 funaddr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, funaddr
,
275 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
276 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
278 value_type
= TYPE_TARGET_TYPE (ftype
);
280 if (TYPE_GNU_IFUNC (ftype
))
282 funaddr
= gnu_ifunc_resolve_addr (gdbarch
, funaddr
);
284 /* Skip querying the function symbol if no RETVAL_TYPE has been
287 value_type
= find_function_return_type (funaddr
);
290 else if (TYPE_CODE (ftype
) == TYPE_CODE_INT
)
292 /* Handle the case of functions lacking debugging info.
293 Their values are characters since their addresses are char. */
294 if (TYPE_LENGTH (ftype
) == 1)
295 funaddr
= value_as_address (value_addr (function
));
298 /* Handle function descriptors lacking debug info. */
299 int found_descriptor
= 0;
301 funaddr
= 0; /* pacify "gcc -Werror" */
302 if (VALUE_LVAL (function
) == lval_memory
)
306 funaddr
= value_as_address (value_addr (function
));
308 funaddr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, funaddr
,
310 if (funaddr
!= nfunaddr
)
311 found_descriptor
= 1;
313 if (!found_descriptor
)
314 /* Handle integer used as address of a function. */
315 funaddr
= (CORE_ADDR
) value_as_long (function
);
319 error (_("Invalid data type for function to be called."));
321 if (retval_type
!= NULL
)
322 *retval_type
= value_type
;
323 return funaddr
+ gdbarch_deprecated_function_start_offset (gdbarch
);
326 /* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called
327 function returns to. */
330 push_dummy_code (struct gdbarch
*gdbarch
,
331 CORE_ADDR sp
, CORE_ADDR funaddr
,
332 struct value
**args
, int nargs
,
333 struct type
*value_type
,
334 CORE_ADDR
*real_pc
, CORE_ADDR
*bp_addr
,
335 struct regcache
*regcache
)
337 gdb_assert (gdbarch_push_dummy_code_p (gdbarch
));
339 return gdbarch_push_dummy_code (gdbarch
, sp
, funaddr
,
340 args
, nargs
, value_type
, real_pc
, bp_addr
,
347 error_call_unknown_return_type (const char *func_name
)
349 if (func_name
!= NULL
)
350 error (_("'%s' has unknown return type; "
351 "cast the call to its declared return type"),
354 error (_("function has unknown return type; "
355 "cast the call to its declared return type"));
358 /* Fetch the name of the function at FUNADDR.
359 This is used in printing an error message for call_function_by_hand.
360 BUF is used to print FUNADDR in hex if the function name cannot be
361 determined. It must be large enough to hold formatted result of
362 RAW_FUNCTION_ADDRESS_FORMAT. */
365 get_function_name (CORE_ADDR funaddr
, char *buf
, int buf_size
)
368 struct symbol
*symbol
= find_pc_function (funaddr
);
371 return SYMBOL_PRINT_NAME (symbol
);
375 /* Try the minimal symbols. */
376 struct bound_minimal_symbol msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
379 return MSYMBOL_PRINT_NAME (msymbol
.minsym
);
383 char *tmp
= xstrprintf (_(RAW_FUNCTION_ADDRESS_FORMAT
),
384 hex_string (funaddr
));
386 gdb_assert (strlen (tmp
) + 1 <= buf_size
);
393 /* All the meta data necessary to extract the call's return value. */
395 struct call_return_meta_info
397 /* The caller frame's architecture. */
398 struct gdbarch
*gdbarch
;
400 /* The called function. */
401 struct value
*function
;
403 /* The return value's type. */
404 struct type
*value_type
;
406 /* Are we returning a value using a structure return or a normal
410 /* If using a structure return, this is the structure's address. */
411 CORE_ADDR struct_addr
;
414 /* Extract the called function's return value. */
416 static struct value
*
417 get_call_return_value (struct call_return_meta_info
*ri
)
419 struct value
*retval
= NULL
;
420 bool stack_temporaries
= thread_stack_temporaries_enabled_p (inferior_ptid
);
422 if (TYPE_CODE (ri
->value_type
) == TYPE_CODE_VOID
)
423 retval
= allocate_value (ri
->value_type
);
424 else if (ri
->struct_return_p
)
426 if (stack_temporaries
)
428 retval
= value_from_contents_and_address (ri
->value_type
, NULL
,
430 push_thread_stack_temporary (inferior_ptid
, retval
);
434 retval
= allocate_value (ri
->value_type
);
435 read_value_memory (retval
, 0, 1, ri
->struct_addr
,
436 value_contents_raw (retval
),
437 TYPE_LENGTH (ri
->value_type
));
442 retval
= allocate_value (ri
->value_type
);
443 gdbarch_return_value (ri
->gdbarch
, ri
->function
, ri
->value_type
,
444 get_current_regcache (),
445 value_contents_raw (retval
), NULL
);
446 if (stack_temporaries
&& class_or_union_p (ri
->value_type
))
448 /* Values of class type returned in registers are copied onto
449 the stack and their lval_type set to lval_memory. This is
450 required because further evaluation of the expression
451 could potentially invoke methods on the return value
452 requiring GDB to evaluate the "this" pointer. To evaluate
453 the this pointer, GDB needs the memory address of the
455 value_force_lval (retval
, ri
->struct_addr
);
456 push_thread_stack_temporary (inferior_ptid
, retval
);
460 gdb_assert (retval
!= NULL
);
464 /* Data for the FSM that manages an infcall. It's main job is to
465 record the called function's return value. */
467 struct call_thread_fsm
469 /* The base class. */
470 struct thread_fsm thread_fsm
;
472 /* All the info necessary to be able to extract the return
474 struct call_return_meta_info return_meta_info
;
476 /* The called function's return value. This is extracted from the
477 target before the dummy frame is popped. */
478 struct value
*return_value
;
480 /* The top level that started the infcall (and is synchronously
481 waiting for it to end). */
482 struct ui
*waiting_ui
;
485 static int call_thread_fsm_should_stop (struct thread_fsm
*self
,
486 struct thread_info
*thread
);
487 static int call_thread_fsm_should_notify_stop (struct thread_fsm
*self
);
489 /* call_thread_fsm's vtable. */
491 static struct thread_fsm_ops call_thread_fsm_ops
=
495 call_thread_fsm_should_stop
,
496 NULL
, /* return_value */
497 NULL
, /* async_reply_reason*/
498 call_thread_fsm_should_notify_stop
,
501 /* Allocate a new call_thread_fsm object. */
503 static struct call_thread_fsm
*
504 new_call_thread_fsm (struct ui
*waiting_ui
, struct interp
*cmd_interp
,
505 struct gdbarch
*gdbarch
, struct value
*function
,
506 struct type
*value_type
,
507 int struct_return_p
, CORE_ADDR struct_addr
)
509 struct call_thread_fsm
*sm
;
511 sm
= XCNEW (struct call_thread_fsm
);
512 thread_fsm_ctor (&sm
->thread_fsm
, &call_thread_fsm_ops
, cmd_interp
);
514 sm
->return_meta_info
.gdbarch
= gdbarch
;
515 sm
->return_meta_info
.function
= function
;
516 sm
->return_meta_info
.value_type
= value_type
;
517 sm
->return_meta_info
.struct_return_p
= struct_return_p
;
518 sm
->return_meta_info
.struct_addr
= struct_addr
;
520 sm
->waiting_ui
= waiting_ui
;
525 /* Implementation of should_stop method for infcalls. */
528 call_thread_fsm_should_stop (struct thread_fsm
*self
,
529 struct thread_info
*thread
)
531 struct call_thread_fsm
*f
= (struct call_thread_fsm
*) self
;
533 if (stop_stack_dummy
== STOP_STACK_DUMMY
)
536 thread_fsm_set_finished (self
);
538 /* Stash the return value before the dummy frame is popped and
539 registers are restored to what they were before the
541 f
->return_value
= get_call_return_value (&f
->return_meta_info
);
543 /* Break out of wait_sync_command_done. */
544 scoped_restore save_ui
= make_scoped_restore (¤t_ui
, f
->waiting_ui
);
545 target_terminal::ours ();
546 f
->waiting_ui
->prompt_state
= PROMPT_NEEDED
;
552 /* Implementation of should_notify_stop method for infcalls. */
555 call_thread_fsm_should_notify_stop (struct thread_fsm
*self
)
557 if (thread_fsm_finished_p (self
))
559 /* Infcall succeeded. Be silent and proceed with evaluating the
564 /* Something wrong happened. E.g., an unexpected breakpoint
565 triggered, or a signal was intercepted. Notify the stop. */
569 /* Subroutine of call_function_by_hand to simplify it.
570 Start up the inferior and wait for it to stop.
571 Return the exception if there's an error, or an exception with
572 reason >= 0 if there's no error.
574 This is done inside a TRY_CATCH so the caller needn't worry about
575 thrown errors. The caller should rethrow if there's an error. */
577 static struct gdb_exception
578 run_inferior_call (struct call_thread_fsm
*sm
,
579 struct thread_info
*call_thread
, CORE_ADDR real_pc
)
581 struct gdb_exception caught_error
= exception_none
;
582 int saved_in_infcall
= call_thread
->control
.in_infcall
;
583 ptid_t call_thread_ptid
= call_thread
->ptid
;
584 enum prompt_state saved_prompt_state
= current_ui
->prompt_state
;
585 int was_running
= call_thread
->state
== THREAD_RUNNING
;
586 int saved_ui_async
= current_ui
->async
;
588 /* Infcalls run synchronously, in the foreground. */
589 current_ui
->prompt_state
= PROMPT_BLOCKED
;
590 /* So that we don't print the prompt prematurely in
591 fetch_inferior_event. */
592 current_ui
->async
= 0;
594 delete_file_handler (current_ui
->input_fd
);
596 call_thread
->control
.in_infcall
= 1;
598 clear_proceed_status (0);
600 /* Associate the FSM with the thread after clear_proceed_status
601 (otherwise it'd clear this FSM), and before anything throws, so
602 we don't leak it (and any resources it manages). */
603 call_thread
->thread_fsm
= &sm
->thread_fsm
;
605 disable_watchpoints_before_interactive_call_start ();
607 /* We want to print return value, please... */
608 call_thread
->control
.proceed_to_finish
= 1;
612 proceed (real_pc
, GDB_SIGNAL_0
);
614 /* Inferior function calls are always synchronous, even if the
615 target supports asynchronous execution. */
616 wait_sync_command_done ();
618 CATCH (e
, RETURN_MASK_ALL
)
624 /* If GDB has the prompt blocked before, then ensure that it remains
625 so. normal_stop calls async_enable_stdin, so reset the prompt
626 state again here. In other cases, stdin will be re-enabled by
627 inferior_event_handler, when an exception is thrown. */
628 current_ui
->prompt_state
= saved_prompt_state
;
629 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
630 delete_file_handler (current_ui
->input_fd
);
632 ui_register_input_event_handler (current_ui
);
633 current_ui
->async
= saved_ui_async
;
635 /* At this point the current thread may have changed. Refresh
636 CALL_THREAD as it could be invalid if its thread has exited. */
637 call_thread
= find_thread_ptid (call_thread_ptid
);
639 /* If the infcall does NOT succeed, normal_stop will have already
640 finished the thread states. However, on success, normal_stop
641 defers here, so that we can set back the thread states to what
642 they were before the call. Note that we must also finish the
643 state of new threads that might have spawned while the call was
644 running. The main cases to handle are:
646 - "(gdb) print foo ()", or any other command that evaluates an
647 expression at the prompt. (The thread was marked stopped before.)
649 - "(gdb) break foo if return_false()" or similar cases where we
650 do an infcall while handling an event (while the thread is still
651 marked running). In this example, whether the condition
652 evaluates true and thus we'll present a user-visible stop is
653 decided elsewhere. */
655 && ptid_equal (call_thread_ptid
, inferior_ptid
)
656 && stop_stack_dummy
== STOP_STACK_DUMMY
)
657 finish_thread_state (user_visible_resume_ptid (0));
659 enable_watchpoints_after_interactive_call_stop ();
661 /* Call breakpoint_auto_delete on the current contents of the bpstat
662 of inferior call thread.
663 If all error()s out of proceed ended up calling normal_stop
664 (and perhaps they should; it already does in the special case
665 of error out of resume()), then we wouldn't need this. */
666 if (caught_error
.reason
< 0)
668 if (call_thread
!= NULL
)
669 breakpoint_auto_delete (call_thread
->control
.stop_bpstat
);
672 if (call_thread
!= NULL
)
673 call_thread
->control
.in_infcall
= saved_in_infcall
;
678 /* A cleanup function that calls delete_std_terminate_breakpoint. */
680 cleanup_delete_std_terminate_breakpoint (void *ignore
)
682 delete_std_terminate_breakpoint ();
688 call_function_by_hand (struct value
*function
,
689 type
*default_return_type
,
690 int nargs
, struct value
**args
)
692 return call_function_by_hand_dummy (function
, default_return_type
,
693 nargs
, args
, NULL
, NULL
);
696 /* All this stuff with a dummy frame may seem unnecessarily complicated
697 (why not just save registers in GDB?). The purpose of pushing a dummy
698 frame which looks just like a real frame is so that if you call a
699 function and then hit a breakpoint (get a signal, etc), "backtrace"
700 will look right. Whether the backtrace needs to actually show the
701 stack at the time the inferior function was called is debatable, but
702 it certainly needs to not display garbage. So if you are contemplating
703 making dummy frames be different from normal frames, consider that. */
705 /* Perform a function call in the inferior.
706 ARGS is a vector of values of arguments (NARGS of them).
707 FUNCTION is a value, the function to be called.
708 Returns a value representing what the function returned.
709 May fail to return, if a breakpoint or signal is hit
710 during the execution of the function.
712 ARGS is modified to contain coerced values. */
715 call_function_by_hand_dummy (struct value
*function
,
716 type
*default_return_type
,
717 int nargs
, struct value
**args
,
718 dummy_frame_dtor_ftype
*dummy_dtor
,
719 void *dummy_dtor_data
)
722 struct type
*values_type
, *target_values_type
;
723 unsigned char struct_return
= 0, hidden_first_param_p
= 0;
724 CORE_ADDR struct_addr
= 0;
725 struct infcall_control_state
*inf_status
;
726 struct cleanup
*inf_status_cleanup
;
727 struct infcall_suspend_state
*caller_state
;
730 struct type
*ftype
= check_typedef (value_type (function
));
732 struct frame_id dummy_id
;
733 struct frame_info
*frame
;
734 struct gdbarch
*gdbarch
;
735 struct cleanup
*terminate_bp_cleanup
;
736 ptid_t call_thread_ptid
;
737 struct gdb_exception e
;
738 char name_buf
[RAW_FUNCTION_ADDRESS_SIZE
];
739 bool stack_temporaries
= thread_stack_temporaries_enabled_p (inferior_ptid
);
741 if (TYPE_CODE (ftype
) == TYPE_CODE_PTR
)
742 ftype
= check_typedef (TYPE_TARGET_TYPE (ftype
));
744 if (!target_has_execution
)
747 if (get_traceframe_number () >= 0)
748 error (_("May not call functions while looking at trace frames."));
750 if (execution_direction
== EXEC_REVERSE
)
751 error (_("Cannot call functions in reverse mode."));
753 frame
= get_current_frame ();
754 gdbarch
= get_frame_arch (frame
);
756 if (!gdbarch_push_dummy_call_p (gdbarch
))
757 error (_("This target does not support function calls."));
759 /* A cleanup for the inferior status.
760 This is only needed while we're preparing the inferior function call. */
761 inf_status
= save_infcall_control_state ();
763 = make_cleanup_restore_infcall_control_state (inf_status
);
765 /* Save the caller's registers and other state associated with the
766 inferior itself so that they can be restored once the
767 callee returns. To allow nested calls the registers are (further
768 down) pushed onto a dummy frame stack. Include a cleanup (which
769 is tossed once the regcache has been pushed). */
770 caller_state
= save_infcall_suspend_state ();
771 make_cleanup_restore_infcall_suspend_state (caller_state
);
773 /* Ensure that the initial SP is correctly aligned. */
775 CORE_ADDR old_sp
= get_frame_sp (frame
);
777 if (gdbarch_frame_align_p (gdbarch
))
779 sp
= gdbarch_frame_align (gdbarch
, old_sp
);
780 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
781 ABIs, a function can use memory beyond the inner most stack
782 address. AMD64 called that region the "red zone". Skip at
783 least the "red zone" size before allocating any space on
785 if (gdbarch_inner_than (gdbarch
, 1, 2))
786 sp
-= gdbarch_frame_red_zone_size (gdbarch
);
788 sp
+= gdbarch_frame_red_zone_size (gdbarch
);
790 gdb_assert (sp
== gdbarch_frame_align (gdbarch
, sp
));
791 /* NOTE: cagney/2002-09-18:
793 On a RISC architecture, a void parameterless generic dummy
794 frame (i.e., no parameters, no result) typically does not
795 need to push anything the stack and hence can leave SP and
796 FP. Similarly, a frameless (possibly leaf) function does
797 not push anything on the stack and, hence, that too can
798 leave FP and SP unchanged. As a consequence, a sequence of
799 void parameterless generic dummy frame calls to frameless
800 functions will create a sequence of effectively identical
801 frames (SP, FP and TOS and PC the same). This, not
802 suprisingly, results in what appears to be a stack in an
803 infinite loop --- when GDB tries to find a generic dummy
804 frame on the internal dummy frame stack, it will always
807 To avoid this problem, the code below always grows the
808 stack. That way, two dummy frames can never be identical.
809 It does burn a few bytes of stack but that is a small price
813 if (gdbarch_inner_than (gdbarch
, 1, 2))
814 /* Stack grows down. */
815 sp
= gdbarch_frame_align (gdbarch
, old_sp
- 1);
817 /* Stack grows up. */
818 sp
= gdbarch_frame_align (gdbarch
, old_sp
+ 1);
820 /* SP may have underflown address zero here from OLD_SP. Memory access
821 functions will probably fail in such case but that is a target's
825 /* FIXME: cagney/2002-09-18: Hey, you loose!
827 Who knows how badly aligned the SP is!
829 If the generic dummy frame ends up empty (because nothing is
830 pushed) GDB won't be able to correctly perform back traces.
831 If a target is having trouble with backtraces, first thing to
832 do is add FRAME_ALIGN() to the architecture vector. If that
833 fails, try dummy_id().
835 If the ABI specifies a "Red Zone" (see the doco) the code
836 below will quietly trash it. */
839 /* Skip over the stack temporaries that might have been generated during
840 the evaluation of an expression. */
841 if (stack_temporaries
)
843 struct value
*lastval
;
845 lastval
= get_last_thread_stack_temporary (inferior_ptid
);
848 CORE_ADDR lastval_addr
= value_address (lastval
);
850 if (gdbarch_inner_than (gdbarch
, 1, 2))
852 gdb_assert (sp
>= lastval_addr
);
857 gdb_assert (sp
<= lastval_addr
);
858 sp
= lastval_addr
+ TYPE_LENGTH (value_type (lastval
));
861 if (gdbarch_frame_align_p (gdbarch
))
862 sp
= gdbarch_frame_align (gdbarch
, sp
);
867 funaddr
= find_function_addr (function
, &values_type
);
868 if (values_type
== NULL
)
869 values_type
= default_return_type
;
870 if (values_type
== NULL
)
872 const char *name
= get_function_name (funaddr
,
873 name_buf
, sizeof (name_buf
));
874 error (_("'%s' has unknown return type; "
875 "cast the call to its declared return type"),
879 values_type
= check_typedef (values_type
);
881 /* Are we returning a value using a structure return (passing a
882 hidden argument pointing to storage) or a normal value return?
883 There are two cases: language-mandated structure return and
884 target ABI structure return. The variable STRUCT_RETURN only
885 describes the latter. The language version is handled by passing
886 the return location as the first parameter to the function,
887 even preceding "this". This is different from the target
888 ABI version, which is target-specific; for instance, on ia64
889 the first argument is passed in out0 but the hidden structure
890 return pointer would normally be passed in r8. */
892 if (gdbarch_return_in_first_hidden_param_p (gdbarch
, values_type
))
894 hidden_first_param_p
= 1;
896 /* Tell the target specific argument pushing routine not to
898 target_values_type
= builtin_type (gdbarch
)->builtin_void
;
902 struct_return
= using_struct_return (gdbarch
, function
, values_type
);
903 target_values_type
= values_type
;
906 gdb::observers::inferior_call_pre
.notify (inferior_ptid
, funaddr
);
908 /* Determine the location of the breakpoint (and possibly other
909 stuff) that the called function will return to. The SPARC, for a
910 function returning a structure or union, needs to make space for
911 not just the breakpoint but also an extra word containing the
912 size (?) of the structure being passed. */
914 switch (gdbarch_call_dummy_location (gdbarch
))
918 const gdb_byte
*bp_bytes
;
919 CORE_ADDR bp_addr_as_address
;
922 /* Be careful BP_ADDR is in inferior PC encoding while
923 BP_ADDR_AS_ADDRESS is a plain memory address. */
925 sp
= push_dummy_code (gdbarch
, sp
, funaddr
, args
, nargs
,
926 target_values_type
, &real_pc
, &bp_addr
,
927 get_current_regcache ());
929 /* Write a legitimate instruction at the point where the infcall
930 breakpoint is going to be inserted. While this instruction
931 is never going to be executed, a user investigating the
932 memory from GDB would see this instruction instead of random
933 uninitialized bytes. We chose the breakpoint instruction
934 as it may look as the most logical one to the user and also
935 valgrind 3.7.0 needs it for proper vgdb inferior calls.
937 If software breakpoints are unsupported for this target we
938 leave the user visible memory content uninitialized. */
940 bp_addr_as_address
= bp_addr
;
941 bp_bytes
= gdbarch_breakpoint_from_pc (gdbarch
, &bp_addr_as_address
,
943 if (bp_bytes
!= NULL
)
944 write_memory (bp_addr_as_address
, bp_bytes
, bp_size
);
949 CORE_ADDR dummy_addr
;
952 dummy_addr
= entry_point_address ();
954 /* A call dummy always consists of just a single breakpoint, so
955 its address is the same as the address of the dummy.
957 The actual breakpoint is inserted separatly so there is no need to
959 bp_addr
= dummy_addr
;
963 internal_error (__FILE__
, __LINE__
, _("bad switch"));
966 if (nargs
< TYPE_NFIELDS (ftype
))
967 error (_("Too few arguments in function call."));
972 for (i
= nargs
- 1; i
>= 0; i
--)
975 struct type
*param_type
;
977 /* FIXME drow/2002-05-31: Should just always mark methods as
978 prototyped. Can we respect TYPE_VARARGS? Probably not. */
979 if (TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
981 if (TYPE_TARGET_TYPE (ftype
) == NULL
&& TYPE_NFIELDS (ftype
) == 0
982 && default_return_type
!= NULL
)
984 /* Calling a no-debug function with the return type
985 explicitly cast. Assume the function is prototyped,
986 with a prototype matching the types of the arguments.
988 float mult (float v1, float v2) { return v1 * v2; }
990 (gdb) p (float) mult (2.0f, 3.0f)
991 Is a simpler alternative to:
992 (gdb) p ((float (*) (float, float)) mult) (2.0f, 3.0f)
996 else if (i
< TYPE_NFIELDS (ftype
))
997 prototyped
= TYPE_PROTOTYPED (ftype
);
1001 if (i
< TYPE_NFIELDS (ftype
))
1002 param_type
= TYPE_FIELD_TYPE (ftype
, i
);
1006 args
[i
] = value_arg_coerce (gdbarch
, args
[i
],
1007 param_type
, prototyped
, &sp
);
1009 if (param_type
!= NULL
&& language_pass_by_reference (param_type
))
1010 args
[i
] = value_addr (args
[i
]);
1014 /* Reserve space for the return structure to be written on the
1015 stack, if necessary. Make certain that the value is correctly
1018 While evaluating expressions, we reserve space on the stack for
1019 return values of class type even if the language ABI and the target
1020 ABI do not require that the return value be passed as a hidden first
1021 argument. This is because we want to store the return value as an
1022 on-stack temporary while the expression is being evaluated. This
1023 enables us to have chained function calls in expressions.
1025 Keeping the return values as on-stack temporaries while the expression
1026 is being evaluated is OK because the thread is stopped until the
1027 expression is completely evaluated. */
1029 if (struct_return
|| hidden_first_param_p
1030 || (stack_temporaries
&& class_or_union_p (values_type
)))
1032 if (gdbarch_inner_than (gdbarch
, 1, 2))
1034 /* Stack grows downward. Align STRUCT_ADDR and SP after
1035 making space for the return value. */
1036 sp
-= TYPE_LENGTH (values_type
);
1037 if (gdbarch_frame_align_p (gdbarch
))
1038 sp
= gdbarch_frame_align (gdbarch
, sp
);
1043 /* Stack grows upward. Align the frame, allocate space, and
1044 then again, re-align the frame??? */
1045 if (gdbarch_frame_align_p (gdbarch
))
1046 sp
= gdbarch_frame_align (gdbarch
, sp
);
1048 sp
+= TYPE_LENGTH (values_type
);
1049 if (gdbarch_frame_align_p (gdbarch
))
1050 sp
= gdbarch_frame_align (gdbarch
, sp
);
1054 std::vector
<struct value
*> new_args
;
1055 if (hidden_first_param_p
)
1057 /* Add the new argument to the front of the argument list. */
1059 (value_from_pointer (lookup_pointer_type (values_type
), struct_addr
));
1060 std::copy (&args
[0], &args
[nargs
], std::back_inserter (new_args
));
1061 args
= new_args
.data ();
1065 /* Create the dummy stack frame. Pass in the call dummy address as,
1066 presumably, the ABI code knows where, in the call dummy, the
1067 return address should be pointed. */
1068 sp
= gdbarch_push_dummy_call (gdbarch
, function
, get_current_regcache (),
1069 bp_addr
, nargs
, args
,
1070 sp
, struct_return
, struct_addr
);
1072 /* Set up a frame ID for the dummy frame so we can pass it to
1073 set_momentary_breakpoint. We need to give the breakpoint a frame
1074 ID so that the breakpoint code can correctly re-identify the
1075 dummy breakpoint. */
1076 /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL,
1077 saved as the dummy-frame TOS, and used by dummy_id to form
1078 the frame ID's stack address. */
1079 dummy_id
= frame_id_build (sp
, bp_addr
);
1081 /* Create a momentary breakpoint at the return address of the
1082 inferior. That way it breaks when it returns. */
1085 symtab_and_line sal
;
1086 sal
.pspace
= current_program_space
;
1088 sal
.section
= find_pc_overlay (sal
.pc
);
1090 /* Sanity. The exact same SP value is returned by
1091 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
1092 dummy_id to form the frame ID's stack address. */
1094 = set_momentary_breakpoint (gdbarch
, sal
,
1095 dummy_id
, bp_call_dummy
).release ();
1097 /* set_momentary_breakpoint invalidates FRAME. */
1100 bpt
->disposition
= disp_del
;
1101 gdb_assert (bpt
->related_breakpoint
== bpt
);
1103 breakpoint
*longjmp_b
= set_longjmp_breakpoint_for_call_dummy ();
1106 /* Link BPT into the chain of LONGJMP_B. */
1107 bpt
->related_breakpoint
= longjmp_b
;
1108 while (longjmp_b
->related_breakpoint
!= bpt
->related_breakpoint
)
1109 longjmp_b
= longjmp_b
->related_breakpoint
;
1110 longjmp_b
->related_breakpoint
= bpt
;
1114 /* Create a breakpoint in std::terminate.
1115 If a C++ exception is raised in the dummy-frame, and the
1116 exception handler is (normally, and expected to be) out-of-frame,
1117 the default C++ handler will (wrongly) be called in an inferior
1118 function call. This is wrong, as an exception can be normally
1119 and legally handled out-of-frame. The confines of the dummy frame
1120 prevent the unwinder from finding the correct handler (or any
1121 handler, unless it is in-frame). The default handler calls
1122 std::terminate. This will kill the inferior. Assert that
1123 terminate should never be called in an inferior function
1124 call. Place a momentary breakpoint in the std::terminate function
1125 and if triggered in the call, rewind. */
1126 if (unwind_on_terminating_exception_p
)
1127 set_std_terminate_breakpoint ();
1129 /* Discard both inf_status and caller_state cleanups.
1130 From this point on we explicitly restore the associated state
1132 discard_cleanups (inf_status_cleanup
);
1134 /* Everything's ready, push all the info needed to restore the
1135 caller (and identify the dummy-frame) onto the dummy-frame
1137 dummy_frame_push (caller_state
, &dummy_id
, inferior_ptid
);
1138 if (dummy_dtor
!= NULL
)
1139 register_dummy_frame_dtor (dummy_id
, inferior_ptid
,
1140 dummy_dtor
, dummy_dtor_data
);
1142 /* Register a clean-up for unwind_on_terminating_exception_breakpoint. */
1143 terminate_bp_cleanup
= make_cleanup (cleanup_delete_std_terminate_breakpoint
,
1146 /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP -
1147 If you're looking to implement asynchronous dummy-frames, then
1148 just below is the place to chop this function in two.. */
1150 /* TP is invalid after run_inferior_call returns, so enclose this
1151 in a block so that it's only in scope during the time it's valid. */
1153 struct thread_info
*tp
= inferior_thread ();
1154 struct thread_fsm
*saved_sm
;
1155 struct call_thread_fsm
*sm
;
1157 /* Save the current FSM. We'll override it. */
1158 saved_sm
= tp
->thread_fsm
;
1159 tp
->thread_fsm
= NULL
;
1161 /* Save this thread's ptid, we need it later but the thread
1163 call_thread_ptid
= tp
->ptid
;
1165 /* Run the inferior until it stops. */
1167 /* Create the FSM used to manage the infcall. It tells infrun to
1168 not report the stop to the user, and captures the return value
1169 before the dummy frame is popped. run_inferior_call registers
1170 it with the thread ASAP. */
1171 sm
= new_call_thread_fsm (current_ui
, command_interp (),
1174 struct_return
|| hidden_first_param_p
,
1177 e
= run_inferior_call (sm
, tp
, real_pc
);
1179 gdb::observers::inferior_call_post
.notify (call_thread_ptid
, funaddr
);
1181 tp
= find_thread_ptid (call_thread_ptid
);
1184 /* The FSM should still be the same. */
1185 gdb_assert (tp
->thread_fsm
== &sm
->thread_fsm
);
1187 if (thread_fsm_finished_p (tp
->thread_fsm
))
1189 struct value
*retval
;
1191 /* The inferior call is successful. Pop the dummy frame,
1192 which runs its destructors and restores the inferior's
1193 suspend state, and restore the inferior control
1195 dummy_frame_pop (dummy_id
, call_thread_ptid
);
1196 restore_infcall_control_state (inf_status
);
1198 /* Get the return value. */
1199 retval
= sm
->return_value
;
1201 /* Clean up / destroy the call FSM, and restore the
1203 thread_fsm_clean_up (tp
->thread_fsm
, tp
);
1204 thread_fsm_delete (tp
->thread_fsm
);
1205 tp
->thread_fsm
= saved_sm
;
1207 maybe_remove_breakpoints ();
1209 do_cleanups (terminate_bp_cleanup
);
1210 gdb_assert (retval
!= NULL
);
1214 /* Didn't complete. Restore previous state machine, and
1215 handle the error. */
1216 tp
->thread_fsm
= saved_sm
;
1220 /* Rethrow an error if we got one trying to run the inferior. */
1224 const char *name
= get_function_name (funaddr
,
1225 name_buf
, sizeof (name_buf
));
1227 discard_infcall_control_state (inf_status
);
1229 /* We could discard the dummy frame here if the program exited,
1230 but it will get garbage collected the next time the program is
1236 throw_error (e
.error
, _("%s\n\
1237 An error occurred while in a function called from GDB.\n\
1238 Evaluation of the expression containing the function\n\
1239 (%s) will be abandoned.\n\
1240 When the function is done executing, GDB will silently stop."),
1244 throw_exception (e
);
1248 /* If the program has exited, or we stopped at a different thread,
1249 exit and inform the user. */
1251 if (! target_has_execution
)
1253 const char *name
= get_function_name (funaddr
,
1254 name_buf
, sizeof (name_buf
));
1256 /* If we try to restore the inferior status,
1257 we'll crash as the inferior is no longer running. */
1258 discard_infcall_control_state (inf_status
);
1260 /* We could discard the dummy frame here given that the program exited,
1261 but it will get garbage collected the next time the program is
1264 error (_("The program being debugged exited while in a function "
1265 "called from GDB.\n"
1266 "Evaluation of the expression containing the function\n"
1267 "(%s) will be abandoned."),
1271 if (! ptid_equal (call_thread_ptid
, inferior_ptid
))
1273 const char *name
= get_function_name (funaddr
,
1274 name_buf
, sizeof (name_buf
));
1276 /* We've switched threads. This can happen if another thread gets a
1277 signal or breakpoint while our thread was running.
1278 There's no point in restoring the inferior status,
1279 we're in a different thread. */
1280 discard_infcall_control_state (inf_status
);
1281 /* Keep the dummy frame record, if the user switches back to the
1282 thread with the hand-call, we'll need it. */
1283 if (stopped_by_random_signal
)
1285 The program received a signal in another thread while\n\
1286 making a function call from GDB.\n\
1287 Evaluation of the expression containing the function\n\
1288 (%s) will be abandoned.\n\
1289 When the function is done executing, GDB will silently stop."),
1293 The program stopped in another thread while making a function call from GDB.\n\
1294 Evaluation of the expression containing the function\n\
1295 (%s) will be abandoned.\n\
1296 When the function is done executing, GDB will silently stop."),
1301 /* Make a copy as NAME may be in an objfile freed by dummy_frame_pop. */
1302 std::string name
= get_function_name (funaddr
, name_buf
,
1305 if (stopped_by_random_signal
)
1307 /* We stopped inside the FUNCTION because of a random
1308 signal. Further execution of the FUNCTION is not
1311 if (unwind_on_signal_p
)
1313 /* The user wants the context restored. */
1315 /* We must get back to the frame we were before the
1317 dummy_frame_pop (dummy_id
, call_thread_ptid
);
1319 /* We also need to restore inferior status to that before the
1321 restore_infcall_control_state (inf_status
);
1323 /* FIXME: Insert a bunch of wrap_here; name can be very
1324 long if it's a C++ name with arguments and stuff. */
1326 The program being debugged was signaled while in a function called from GDB.\n\
1327 GDB has restored the context to what it was before the call.\n\
1328 To change this behavior use \"set unwindonsignal off\".\n\
1329 Evaluation of the expression containing the function\n\
1330 (%s) will be abandoned."),
1335 /* The user wants to stay in the frame where we stopped
1337 Discard inferior status, we're not at the same point
1339 discard_infcall_control_state (inf_status
);
1341 /* FIXME: Insert a bunch of wrap_here; name can be very
1342 long if it's a C++ name with arguments and stuff. */
1344 The program being debugged was signaled while in a function called from GDB.\n\
1345 GDB remains in the frame where the signal was received.\n\
1346 To change this behavior use \"set unwindonsignal on\".\n\
1347 Evaluation of the expression containing the function\n\
1348 (%s) will be abandoned.\n\
1349 When the function is done executing, GDB will silently stop."),
1354 if (stop_stack_dummy
== STOP_STD_TERMINATE
)
1356 /* We must get back to the frame we were before the dummy
1358 dummy_frame_pop (dummy_id
, call_thread_ptid
);
1360 /* We also need to restore inferior status to that before
1362 restore_infcall_control_state (inf_status
);
1365 The program being debugged entered a std::terminate call, most likely\n\
1366 caused by an unhandled C++ exception. GDB blocked this call in order\n\
1367 to prevent the program from being terminated, and has restored the\n\
1368 context to its original state before the call.\n\
1369 To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
1370 Evaluation of the expression containing the function (%s)\n\
1371 will be abandoned."),
1374 else if (stop_stack_dummy
== STOP_NONE
)
1377 /* We hit a breakpoint inside the FUNCTION.
1378 Keep the dummy frame, the user may want to examine its state.
1379 Discard inferior status, we're not at the same point
1381 discard_infcall_control_state (inf_status
);
1383 /* The following error message used to say "The expression
1384 which contained the function call has been discarded."
1385 It is a hard concept to explain in a few words. Ideally,
1386 GDB would be able to resume evaluation of the expression
1387 when the function finally is done executing. Perhaps
1388 someday this will be implemented (it would not be easy). */
1389 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1390 a C++ name with arguments and stuff. */
1392 The program being debugged stopped while in a function called from GDB.\n\
1393 Evaluation of the expression containing the function\n\
1394 (%s) will be abandoned.\n\
1395 When the function is done executing, GDB will silently stop."),
1401 /* The above code errors out, so ... */
1402 gdb_assert_not_reached ("... should not be here");
1406 _initialize_infcall (void)
1408 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure
,
1409 &coerce_float_to_double_p
, _("\
1410 Set coercion of floats to doubles when calling functions."), _("\
1411 Show coercion of floats to doubles when calling functions"), _("\
1412 Variables of type float should generally be converted to doubles before\n\
1413 calling an unprototyped function, and left alone when calling a prototyped\n\
1414 function. However, some older debug info formats do not provide enough\n\
1415 information to determine that a function is prototyped. If this flag is\n\
1416 set, GDB will perform the conversion for a function it considers\n\
1418 The default is to perform the conversion.\n"),
1420 show_coerce_float_to_double_p
,
1421 &setlist
, &showlist
);
1423 add_setshow_boolean_cmd ("unwindonsignal", no_class
,
1424 &unwind_on_signal_p
, _("\
1425 Set unwinding of stack if a signal is received while in a call dummy."), _("\
1426 Show unwinding of stack if a signal is received while in a call dummy."), _("\
1427 The unwindonsignal lets the user determine what gdb should do if a signal\n\
1428 is received while in a function called from gdb (call dummy). If set, gdb\n\
1429 unwinds the stack and restore the context to what as it was before the call.\n\
1430 The default is to stop in the frame where the signal was received."),
1432 show_unwind_on_signal_p
,
1433 &setlist
, &showlist
);
1435 add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class
,
1436 &unwind_on_terminating_exception_p
, _("\
1437 Set unwinding of stack if std::terminate is called while in call dummy."), _("\
1438 Show unwinding of stack if std::terminate() is called while in a call dummy."),
1440 The unwind on terminating exception flag lets the user determine\n\
1441 what gdb should do if a std::terminate() call is made from the\n\
1442 default exception handler. If set, gdb unwinds the stack and restores\n\
1443 the context to what it was before the call. If unset, gdb allows the\n\
1444 std::terminate call to proceed.\n\
1445 The default is to unwind the frame."),
1447 show_unwind_on_terminating_exception_p
,
1448 &setlist
, &showlist
);