1 /* Perform an inferior function call, for GDB, the GNU debugger.
3 Copyright (C) 1986-2019 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "breakpoint.h"
23 #include "tracepoint.h"
34 #include "dummy-frame.h"
36 #include "gdbthread.h"
37 #include "event-top.h"
38 #include "observable.h"
41 #include "thread-fsm.h"
43 #include "common/scope-exit.h"
45 /* If we can't find a function's name from its address,
46 we print this instead. */
47 #define RAW_FUNCTION_ADDRESS_FORMAT "at 0x%s"
48 #define RAW_FUNCTION_ADDRESS_SIZE (sizeof (RAW_FUNCTION_ADDRESS_FORMAT) \
49 + 2 * sizeof (CORE_ADDR))
51 /* NOTE: cagney/2003-04-16: What's the future of this code?
53 GDB needs an asynchronous expression evaluator, that means an
54 asynchronous inferior function call implementation, and that in
55 turn means restructuring the code so that it is event driven. */
57 /* How you should pass arguments to a function depends on whether it
58 was defined in K&R style or prototype style. If you define a
59 function using the K&R syntax that takes a `float' argument, then
60 callers must pass that argument as a `double'. If you define the
61 function using the prototype syntax, then you must pass the
62 argument as a `float', with no promotion.
64 Unfortunately, on certain older platforms, the debug info doesn't
65 indicate reliably how each function was defined. A function type's
66 TYPE_PROTOTYPED flag may be clear, even if the function was defined
67 in prototype style. When calling a function whose TYPE_PROTOTYPED
68 flag is clear, GDB consults this flag to decide what to do.
70 For modern targets, it is proper to assume that, if the prototype
71 flag is clear, that can be trusted: `float' arguments should be
72 promoted to `double'. For some older targets, if the prototype
73 flag is clear, that doesn't tell us anything. The default is to
74 trust the debug information; the user can override this behavior
75 with "set coerce-float-to-double 0". */
77 static int coerce_float_to_double_p
= 1;
79 show_coerce_float_to_double_p (struct ui_file
*file
, int from_tty
,
80 struct cmd_list_element
*c
, const char *value
)
82 fprintf_filtered (file
,
83 _("Coercion of floats to doubles "
84 "when calling functions is %s.\n"),
88 /* This boolean tells what gdb should do if a signal is received while
89 in a function called from gdb (call dummy). If set, gdb unwinds
90 the stack and restore the context to what as it was before the
93 The default is to stop in the frame where the signal was received. */
95 static int unwind_on_signal_p
= 0;
97 show_unwind_on_signal_p (struct ui_file
*file
, int from_tty
,
98 struct cmd_list_element
*c
, const char *value
)
100 fprintf_filtered (file
,
101 _("Unwinding of stack if a signal is "
102 "received while in a call dummy is %s.\n"),
106 /* This boolean tells what gdb should do if a std::terminate call is
107 made while in a function called from gdb (call dummy).
108 As the confines of a single dummy stack prohibit out-of-frame
109 handlers from handling a raised exception, and as out-of-frame
110 handlers are common in C++, this can lead to no handler being found
111 by the unwinder, and a std::terminate call. This is a false positive.
112 If set, gdb unwinds the stack and restores the context to what it
115 The default is to unwind the frame if a std::terminate call is
118 static int unwind_on_terminating_exception_p
= 1;
121 show_unwind_on_terminating_exception_p (struct ui_file
*file
, int from_tty
,
122 struct cmd_list_element
*c
,
126 fprintf_filtered (file
,
127 _("Unwind stack if a C++ exception is "
128 "unhandled while in a call dummy is %s.\n"),
132 /* Perform the standard coercions that are specified
133 for arguments to be passed to C or Ada functions.
135 If PARAM_TYPE is non-NULL, it is the expected parameter type.
136 IS_PROTOTYPED is non-zero if the function declaration is prototyped.
137 SP is the stack pointer were additional data can be pushed (updating
138 its value as needed). */
140 static struct value
*
141 value_arg_coerce (struct gdbarch
*gdbarch
, struct value
*arg
,
142 struct type
*param_type
, int is_prototyped
, CORE_ADDR
*sp
)
144 const struct builtin_type
*builtin
= builtin_type (gdbarch
);
145 struct type
*arg_type
= check_typedef (value_type (arg
));
147 = param_type
? check_typedef (param_type
) : arg_type
;
149 /* Perform any Ada-specific coercion first. */
150 if (current_language
->la_language
== language_ada
)
151 arg
= ada_convert_actual (arg
, type
);
153 /* Force the value to the target if we will need its address. At
154 this point, we could allocate arguments on the stack instead of
155 calling malloc if we knew that their addresses would not be
156 saved by the called function. */
157 arg
= value_coerce_to_target (arg
);
159 switch (TYPE_CODE (type
))
162 case TYPE_CODE_RVALUE_REF
:
164 struct value
*new_value
;
166 if (TYPE_IS_REFERENCE (arg_type
))
167 return value_cast_pointers (type
, arg
, 0);
169 /* Cast the value to the reference's target type, and then
170 convert it back to a reference. This will issue an error
171 if the value was not previously in memory - in some cases
172 we should clearly be allowing this, but how? */
173 new_value
= value_cast (TYPE_TARGET_TYPE (type
), arg
);
174 new_value
= value_ref (new_value
, TYPE_CODE (type
));
181 /* If we don't have a prototype, coerce to integer type if necessary. */
184 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin
->builtin_int
))
185 type
= builtin
->builtin_int
;
187 /* Currently all target ABIs require at least the width of an integer
188 type for an argument. We may have to conditionalize the following
189 type coercion for future targets. */
190 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin
->builtin_int
))
191 type
= builtin
->builtin_int
;
194 if (!is_prototyped
&& coerce_float_to_double_p
)
196 if (TYPE_LENGTH (type
) < TYPE_LENGTH (builtin
->builtin_double
))
197 type
= builtin
->builtin_double
;
198 else if (TYPE_LENGTH (type
) > TYPE_LENGTH (builtin
->builtin_double
))
199 type
= builtin
->builtin_long_double
;
203 type
= lookup_pointer_type (type
);
205 case TYPE_CODE_ARRAY
:
206 /* Arrays are coerced to pointers to their first element, unless
207 they are vectors, in which case we want to leave them alone,
208 because they are passed by value. */
209 if (current_language
->c_style_arrays
)
210 if (!TYPE_VECTOR (type
))
211 type
= lookup_pointer_type (TYPE_TARGET_TYPE (type
));
213 case TYPE_CODE_UNDEF
:
215 case TYPE_CODE_STRUCT
:
216 case TYPE_CODE_UNION
:
219 case TYPE_CODE_RANGE
:
220 case TYPE_CODE_STRING
:
221 case TYPE_CODE_ERROR
:
222 case TYPE_CODE_MEMBERPTR
:
223 case TYPE_CODE_METHODPTR
:
224 case TYPE_CODE_METHOD
:
225 case TYPE_CODE_COMPLEX
:
230 return value_cast (type
, arg
);
236 find_function_addr (struct value
*function
,
237 struct type
**retval_type
,
238 struct type
**function_type
)
240 struct type
*ftype
= check_typedef (value_type (function
));
241 struct gdbarch
*gdbarch
= get_type_arch (ftype
);
242 struct type
*value_type
= NULL
;
243 /* Initialize it just to avoid a GCC false warning. */
244 CORE_ADDR funaddr
= 0;
246 /* If it's a member function, just look at the function
249 /* Determine address to call. */
250 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
251 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
252 funaddr
= value_address (function
);
253 else if (TYPE_CODE (ftype
) == TYPE_CODE_PTR
)
255 funaddr
= value_as_address (function
);
256 ftype
= check_typedef (TYPE_TARGET_TYPE (ftype
));
257 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
258 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
259 funaddr
= gdbarch_convert_from_func_ptr_addr (gdbarch
, funaddr
,
260 current_top_target ());
262 if (TYPE_CODE (ftype
) == TYPE_CODE_FUNC
263 || TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
265 if (TYPE_GNU_IFUNC (ftype
))
267 CORE_ADDR resolver_addr
= funaddr
;
269 /* Resolve the ifunc. Note this may call the resolver
270 function in the inferior. */
271 funaddr
= gnu_ifunc_resolve_addr (gdbarch
, resolver_addr
);
273 /* Skip querying the function symbol if no RETVAL_TYPE or
274 FUNCTION_TYPE have been asked for. */
275 if (retval_type
!= NULL
|| function_type
!= NULL
)
277 type
*target_ftype
= find_function_type (funaddr
);
278 /* If we don't have debug info for the target function,
279 see if we can instead extract the target function's
280 type from the type that the resolver returns. */
281 if (target_ftype
== NULL
)
282 target_ftype
= find_gnu_ifunc_target_type (resolver_addr
);
283 if (target_ftype
!= NULL
)
285 value_type
= TYPE_TARGET_TYPE (check_typedef (target_ftype
));
286 ftype
= target_ftype
;
291 value_type
= TYPE_TARGET_TYPE (ftype
);
293 else if (TYPE_CODE (ftype
) == TYPE_CODE_INT
)
295 /* Handle the case of functions lacking debugging info.
296 Their values are characters since their addresses are char. */
297 if (TYPE_LENGTH (ftype
) == 1)
298 funaddr
= value_as_address (value_addr (function
));
301 /* Handle function descriptors lacking debug info. */
302 int found_descriptor
= 0;
304 funaddr
= 0; /* pacify "gcc -Werror" */
305 if (VALUE_LVAL (function
) == lval_memory
)
309 funaddr
= value_as_address (value_addr (function
));
312 = gdbarch_convert_from_func_ptr_addr (gdbarch
, funaddr
,
313 current_top_target ());
314 if (funaddr
!= nfunaddr
)
315 found_descriptor
= 1;
317 if (!found_descriptor
)
318 /* Handle integer used as address of a function. */
319 funaddr
= (CORE_ADDR
) value_as_long (function
);
323 error (_("Invalid data type for function to be called."));
325 if (retval_type
!= NULL
)
326 *retval_type
= value_type
;
327 if (function_type
!= NULL
)
328 *function_type
= ftype
;
329 return funaddr
+ gdbarch_deprecated_function_start_offset (gdbarch
);
332 /* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called
333 function returns to. */
336 push_dummy_code (struct gdbarch
*gdbarch
,
337 CORE_ADDR sp
, CORE_ADDR funaddr
,
338 gdb::array_view
<value
*> args
,
339 struct type
*value_type
,
340 CORE_ADDR
*real_pc
, CORE_ADDR
*bp_addr
,
341 struct regcache
*regcache
)
343 gdb_assert (gdbarch_push_dummy_code_p (gdbarch
));
345 return gdbarch_push_dummy_code (gdbarch
, sp
, funaddr
,
346 args
.data (), args
.size (),
347 value_type
, real_pc
, bp_addr
,
354 error_call_unknown_return_type (const char *func_name
)
356 if (func_name
!= NULL
)
357 error (_("'%s' has unknown return type; "
358 "cast the call to its declared return type"),
361 error (_("function has unknown return type; "
362 "cast the call to its declared return type"));
365 /* Fetch the name of the function at FUNADDR.
366 This is used in printing an error message for call_function_by_hand.
367 BUF is used to print FUNADDR in hex if the function name cannot be
368 determined. It must be large enough to hold formatted result of
369 RAW_FUNCTION_ADDRESS_FORMAT. */
372 get_function_name (CORE_ADDR funaddr
, char *buf
, int buf_size
)
375 struct symbol
*symbol
= find_pc_function (funaddr
);
378 return SYMBOL_PRINT_NAME (symbol
);
382 /* Try the minimal symbols. */
383 struct bound_minimal_symbol msymbol
= lookup_minimal_symbol_by_pc (funaddr
);
386 return MSYMBOL_PRINT_NAME (msymbol
.minsym
);
390 std::string tmp
= string_printf (_(RAW_FUNCTION_ADDRESS_FORMAT
),
391 hex_string (funaddr
));
393 gdb_assert (tmp
.length () + 1 <= buf_size
);
394 return strcpy (buf
, tmp
.c_str ());
398 /* All the meta data necessary to extract the call's return value. */
400 struct call_return_meta_info
402 /* The caller frame's architecture. */
403 struct gdbarch
*gdbarch
;
405 /* The called function. */
406 struct value
*function
;
408 /* The return value's type. */
409 struct type
*value_type
;
411 /* Are we returning a value using a structure return or a normal
415 /* If using a structure return, this is the structure's address. */
416 CORE_ADDR struct_addr
;
419 /* Extract the called function's return value. */
421 static struct value
*
422 get_call_return_value (struct call_return_meta_info
*ri
)
424 struct value
*retval
= NULL
;
425 thread_info
*thr
= inferior_thread ();
426 bool stack_temporaries
= thread_stack_temporaries_enabled_p (thr
);
428 if (TYPE_CODE (ri
->value_type
) == TYPE_CODE_VOID
)
429 retval
= allocate_value (ri
->value_type
);
430 else if (ri
->struct_return_p
)
432 if (stack_temporaries
)
434 retval
= value_from_contents_and_address (ri
->value_type
, NULL
,
436 push_thread_stack_temporary (thr
, retval
);
440 retval
= allocate_value (ri
->value_type
);
441 read_value_memory (retval
, 0, 1, ri
->struct_addr
,
442 value_contents_raw (retval
),
443 TYPE_LENGTH (ri
->value_type
));
448 retval
= allocate_value (ri
->value_type
);
449 gdbarch_return_value (ri
->gdbarch
, ri
->function
, ri
->value_type
,
450 get_current_regcache (),
451 value_contents_raw (retval
), NULL
);
452 if (stack_temporaries
&& class_or_union_p (ri
->value_type
))
454 /* Values of class type returned in registers are copied onto
455 the stack and their lval_type set to lval_memory. This is
456 required because further evaluation of the expression
457 could potentially invoke methods on the return value
458 requiring GDB to evaluate the "this" pointer. To evaluate
459 the this pointer, GDB needs the memory address of the
461 value_force_lval (retval
, ri
->struct_addr
);
462 push_thread_stack_temporary (thr
, retval
);
466 gdb_assert (retval
!= NULL
);
470 /* Data for the FSM that manages an infcall. It's main job is to
471 record the called function's return value. */
473 struct call_thread_fsm
475 /* The base class. */
476 struct thread_fsm thread_fsm
;
478 /* All the info necessary to be able to extract the return
480 struct call_return_meta_info return_meta_info
;
482 /* The called function's return value. This is extracted from the
483 target before the dummy frame is popped. */
484 struct value
*return_value
;
486 /* The top level that started the infcall (and is synchronously
487 waiting for it to end). */
488 struct ui
*waiting_ui
;
491 static int call_thread_fsm_should_stop (struct thread_fsm
*self
,
492 struct thread_info
*thread
);
493 static int call_thread_fsm_should_notify_stop (struct thread_fsm
*self
);
495 /* call_thread_fsm's vtable. */
497 static struct thread_fsm_ops call_thread_fsm_ops
=
501 call_thread_fsm_should_stop
,
502 NULL
, /* return_value */
503 NULL
, /* async_reply_reason*/
504 call_thread_fsm_should_notify_stop
,
507 /* Allocate a new call_thread_fsm object. */
509 static struct call_thread_fsm
*
510 new_call_thread_fsm (struct ui
*waiting_ui
, struct interp
*cmd_interp
,
511 struct gdbarch
*gdbarch
, struct value
*function
,
512 struct type
*value_type
,
513 int struct_return_p
, CORE_ADDR struct_addr
)
515 struct call_thread_fsm
*sm
;
517 sm
= XCNEW (struct call_thread_fsm
);
518 thread_fsm_ctor (&sm
->thread_fsm
, &call_thread_fsm_ops
, cmd_interp
);
520 sm
->return_meta_info
.gdbarch
= gdbarch
;
521 sm
->return_meta_info
.function
= function
;
522 sm
->return_meta_info
.value_type
= value_type
;
523 sm
->return_meta_info
.struct_return_p
= struct_return_p
;
524 sm
->return_meta_info
.struct_addr
= struct_addr
;
526 sm
->waiting_ui
= waiting_ui
;
531 /* Implementation of should_stop method for infcalls. */
534 call_thread_fsm_should_stop (struct thread_fsm
*self
,
535 struct thread_info
*thread
)
537 struct call_thread_fsm
*f
= (struct call_thread_fsm
*) self
;
539 if (stop_stack_dummy
== STOP_STACK_DUMMY
)
542 thread_fsm_set_finished (self
);
544 /* Stash the return value before the dummy frame is popped and
545 registers are restored to what they were before the
547 f
->return_value
= get_call_return_value (&f
->return_meta_info
);
549 /* Break out of wait_sync_command_done. */
550 scoped_restore save_ui
= make_scoped_restore (¤t_ui
, f
->waiting_ui
);
551 target_terminal::ours ();
552 f
->waiting_ui
->prompt_state
= PROMPT_NEEDED
;
558 /* Implementation of should_notify_stop method for infcalls. */
561 call_thread_fsm_should_notify_stop (struct thread_fsm
*self
)
563 if (thread_fsm_finished_p (self
))
565 /* Infcall succeeded. Be silent and proceed with evaluating the
570 /* Something wrong happened. E.g., an unexpected breakpoint
571 triggered, or a signal was intercepted. Notify the stop. */
575 /* Subroutine of call_function_by_hand to simplify it.
576 Start up the inferior and wait for it to stop.
577 Return the exception if there's an error, or an exception with
578 reason >= 0 if there's no error.
580 This is done inside a TRY_CATCH so the caller needn't worry about
581 thrown errors. The caller should rethrow if there's an error. */
583 static struct gdb_exception
584 run_inferior_call (struct call_thread_fsm
*sm
,
585 struct thread_info
*call_thread
, CORE_ADDR real_pc
)
587 struct gdb_exception caught_error
= exception_none
;
588 int saved_in_infcall
= call_thread
->control
.in_infcall
;
589 ptid_t call_thread_ptid
= call_thread
->ptid
;
590 enum prompt_state saved_prompt_state
= current_ui
->prompt_state
;
591 int was_running
= call_thread
->state
== THREAD_RUNNING
;
592 int saved_ui_async
= current_ui
->async
;
594 /* Infcalls run synchronously, in the foreground. */
595 current_ui
->prompt_state
= PROMPT_BLOCKED
;
596 /* So that we don't print the prompt prematurely in
597 fetch_inferior_event. */
598 current_ui
->async
= 0;
600 delete_file_handler (current_ui
->input_fd
);
602 call_thread
->control
.in_infcall
= 1;
604 clear_proceed_status (0);
606 /* Associate the FSM with the thread after clear_proceed_status
607 (otherwise it'd clear this FSM), and before anything throws, so
608 we don't leak it (and any resources it manages). */
609 call_thread
->thread_fsm
= &sm
->thread_fsm
;
611 disable_watchpoints_before_interactive_call_start ();
613 /* We want to print return value, please... */
614 call_thread
->control
.proceed_to_finish
= 1;
618 proceed (real_pc
, GDB_SIGNAL_0
);
620 /* Inferior function calls are always synchronous, even if the
621 target supports asynchronous execution. */
622 wait_sync_command_done ();
624 CATCH (e
, RETURN_MASK_ALL
)
630 /* If GDB has the prompt blocked before, then ensure that it remains
631 so. normal_stop calls async_enable_stdin, so reset the prompt
632 state again here. In other cases, stdin will be re-enabled by
633 inferior_event_handler, when an exception is thrown. */
634 current_ui
->prompt_state
= saved_prompt_state
;
635 if (current_ui
->prompt_state
== PROMPT_BLOCKED
)
636 delete_file_handler (current_ui
->input_fd
);
638 ui_register_input_event_handler (current_ui
);
639 current_ui
->async
= saved_ui_async
;
641 /* If the infcall does NOT succeed, normal_stop will have already
642 finished the thread states. However, on success, normal_stop
643 defers here, so that we can set back the thread states to what
644 they were before the call. Note that we must also finish the
645 state of new threads that might have spawned while the call was
646 running. The main cases to handle are:
648 - "(gdb) print foo ()", or any other command that evaluates an
649 expression at the prompt. (The thread was marked stopped before.)
651 - "(gdb) break foo if return_false()" or similar cases where we
652 do an infcall while handling an event (while the thread is still
653 marked running). In this example, whether the condition
654 evaluates true and thus we'll present a user-visible stop is
655 decided elsewhere. */
657 && call_thread_ptid
== inferior_ptid
658 && stop_stack_dummy
== STOP_STACK_DUMMY
)
659 finish_thread_state (user_visible_resume_ptid (0));
661 enable_watchpoints_after_interactive_call_stop ();
663 /* Call breakpoint_auto_delete on the current contents of the bpstat
664 of inferior call thread.
665 If all error()s out of proceed ended up calling normal_stop
666 (and perhaps they should; it already does in the special case
667 of error out of resume()), then we wouldn't need this. */
668 if (caught_error
.reason
< 0)
670 if (call_thread
->state
!= THREAD_EXITED
)
671 breakpoint_auto_delete (call_thread
->control
.stop_bpstat
);
674 call_thread
->control
.in_infcall
= saved_in_infcall
;
682 call_function_by_hand (struct value
*function
,
683 type
*default_return_type
,
684 gdb::array_view
<value
*> args
)
686 return call_function_by_hand_dummy (function
, default_return_type
,
690 /* All this stuff with a dummy frame may seem unnecessarily complicated
691 (why not just save registers in GDB?). The purpose of pushing a dummy
692 frame which looks just like a real frame is so that if you call a
693 function and then hit a breakpoint (get a signal, etc), "backtrace"
694 will look right. Whether the backtrace needs to actually show the
695 stack at the time the inferior function was called is debatable, but
696 it certainly needs to not display garbage. So if you are contemplating
697 making dummy frames be different from normal frames, consider that. */
699 /* Perform a function call in the inferior.
700 ARGS is a vector of values of arguments (NARGS of them).
701 FUNCTION is a value, the function to be called.
702 Returns a value representing what the function returned.
703 May fail to return, if a breakpoint or signal is hit
704 during the execution of the function.
706 ARGS is modified to contain coerced values. */
709 call_function_by_hand_dummy (struct value
*function
,
710 type
*default_return_type
,
711 gdb::array_view
<value
*> args
,
712 dummy_frame_dtor_ftype
*dummy_dtor
,
713 void *dummy_dtor_data
)
716 struct type
*target_values_type
;
717 function_call_return_method return_method
= return_method_normal
;
718 CORE_ADDR struct_addr
= 0;
721 struct frame_id dummy_id
;
722 struct frame_info
*frame
;
723 struct gdbarch
*gdbarch
;
724 ptid_t call_thread_ptid
;
725 struct gdb_exception e
;
726 char name_buf
[RAW_FUNCTION_ADDRESS_SIZE
];
728 if (!target_has_execution
)
731 if (get_traceframe_number () >= 0)
732 error (_("May not call functions while looking at trace frames."));
734 if (execution_direction
== EXEC_REVERSE
)
735 error (_("Cannot call functions in reverse mode."));
737 /* We're going to run the target, and inspect the thread's state
738 afterwards. Hold a strong reference so that the pointer remains
739 valid even if the thread exits. */
740 thread_info_ref call_thread
741 = thread_info_ref::new_reference (inferior_thread ());
743 bool stack_temporaries
= thread_stack_temporaries_enabled_p (call_thread
.get ());
745 frame
= get_current_frame ();
746 gdbarch
= get_frame_arch (frame
);
748 if (!gdbarch_push_dummy_call_p (gdbarch
))
749 error (_("This target does not support function calls."));
751 /* A holder for the inferior status.
752 This is only needed while we're preparing the inferior function call. */
753 infcall_control_state_up
inf_status (save_infcall_control_state ());
755 /* Save the caller's registers and other state associated with the
756 inferior itself so that they can be restored once the
757 callee returns. To allow nested calls the registers are (further
758 down) pushed onto a dummy frame stack. This unique pointer
759 is released once the regcache has been pushed). */
760 infcall_suspend_state_up
caller_state (save_infcall_suspend_state ());
762 /* Ensure that the initial SP is correctly aligned. */
764 CORE_ADDR old_sp
= get_frame_sp (frame
);
766 if (gdbarch_frame_align_p (gdbarch
))
768 sp
= gdbarch_frame_align (gdbarch
, old_sp
);
769 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
770 ABIs, a function can use memory beyond the inner most stack
771 address. AMD64 called that region the "red zone". Skip at
772 least the "red zone" size before allocating any space on
774 if (gdbarch_inner_than (gdbarch
, 1, 2))
775 sp
-= gdbarch_frame_red_zone_size (gdbarch
);
777 sp
+= gdbarch_frame_red_zone_size (gdbarch
);
779 gdb_assert (sp
== gdbarch_frame_align (gdbarch
, sp
));
780 /* NOTE: cagney/2002-09-18:
782 On a RISC architecture, a void parameterless generic dummy
783 frame (i.e., no parameters, no result) typically does not
784 need to push anything the stack and hence can leave SP and
785 FP. Similarly, a frameless (possibly leaf) function does
786 not push anything on the stack and, hence, that too can
787 leave FP and SP unchanged. As a consequence, a sequence of
788 void parameterless generic dummy frame calls to frameless
789 functions will create a sequence of effectively identical
790 frames (SP, FP and TOS and PC the same). This, not
791 suprisingly, results in what appears to be a stack in an
792 infinite loop --- when GDB tries to find a generic dummy
793 frame on the internal dummy frame stack, it will always
796 To avoid this problem, the code below always grows the
797 stack. That way, two dummy frames can never be identical.
798 It does burn a few bytes of stack but that is a small price
802 if (gdbarch_inner_than (gdbarch
, 1, 2))
803 /* Stack grows down. */
804 sp
= gdbarch_frame_align (gdbarch
, old_sp
- 1);
806 /* Stack grows up. */
807 sp
= gdbarch_frame_align (gdbarch
, old_sp
+ 1);
809 /* SP may have underflown address zero here from OLD_SP. Memory access
810 functions will probably fail in such case but that is a target's
814 /* FIXME: cagney/2002-09-18: Hey, you loose!
816 Who knows how badly aligned the SP is!
818 If the generic dummy frame ends up empty (because nothing is
819 pushed) GDB won't be able to correctly perform back traces.
820 If a target is having trouble with backtraces, first thing to
821 do is add FRAME_ALIGN() to the architecture vector. If that
822 fails, try dummy_id().
824 If the ABI specifies a "Red Zone" (see the doco) the code
825 below will quietly trash it. */
828 /* Skip over the stack temporaries that might have been generated during
829 the evaluation of an expression. */
830 if (stack_temporaries
)
832 struct value
*lastval
;
834 lastval
= get_last_thread_stack_temporary (call_thread
.get ());
837 CORE_ADDR lastval_addr
= value_address (lastval
);
839 if (gdbarch_inner_than (gdbarch
, 1, 2))
841 gdb_assert (sp
>= lastval_addr
);
846 gdb_assert (sp
<= lastval_addr
);
847 sp
= lastval_addr
+ TYPE_LENGTH (value_type (lastval
));
850 if (gdbarch_frame_align_p (gdbarch
))
851 sp
= gdbarch_frame_align (gdbarch
, sp
);
858 CORE_ADDR funaddr
= find_function_addr (function
, &values_type
, &ftype
);
860 if (values_type
== NULL
)
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 /* Are we returning a value using a structure return? */
875 if (gdbarch_return_in_first_hidden_param_p (gdbarch
, values_type
))
877 return_method
= return_method_hidden_param
;
879 /* Tell the target specific argument pushing routine not to
881 target_values_type
= builtin_type (gdbarch
)->builtin_void
;
885 if (using_struct_return (gdbarch
, function
, values_type
))
886 return_method
= return_method_struct
;
887 target_values_type
= values_type
;
890 gdb::observers::inferior_call_pre
.notify (inferior_ptid
, funaddr
);
892 /* Determine the location of the breakpoint (and possibly other
893 stuff) that the called function will return to. The SPARC, for a
894 function returning a structure or union, needs to make space for
895 not just the breakpoint but also an extra word containing the
896 size (?) of the structure being passed. */
898 switch (gdbarch_call_dummy_location (gdbarch
))
902 const gdb_byte
*bp_bytes
;
903 CORE_ADDR bp_addr_as_address
;
906 /* Be careful BP_ADDR is in inferior PC encoding while
907 BP_ADDR_AS_ADDRESS is a plain memory address. */
909 sp
= push_dummy_code (gdbarch
, sp
, funaddr
, args
,
910 target_values_type
, &real_pc
, &bp_addr
,
911 get_current_regcache ());
913 /* Write a legitimate instruction at the point where the infcall
914 breakpoint is going to be inserted. While this instruction
915 is never going to be executed, a user investigating the
916 memory from GDB would see this instruction instead of random
917 uninitialized bytes. We chose the breakpoint instruction
918 as it may look as the most logical one to the user and also
919 valgrind 3.7.0 needs it for proper vgdb inferior calls.
921 If software breakpoints are unsupported for this target we
922 leave the user visible memory content uninitialized. */
924 bp_addr_as_address
= bp_addr
;
925 bp_bytes
= gdbarch_breakpoint_from_pc (gdbarch
, &bp_addr_as_address
,
927 if (bp_bytes
!= NULL
)
928 write_memory (bp_addr_as_address
, bp_bytes
, bp_size
);
933 CORE_ADDR dummy_addr
;
936 dummy_addr
= entry_point_address ();
938 /* A call dummy always consists of just a single breakpoint, so
939 its address is the same as the address of the dummy.
941 The actual breakpoint is inserted separatly so there is no need to
943 bp_addr
= dummy_addr
;
947 internal_error (__FILE__
, __LINE__
, _("bad switch"));
950 if (args
.size () < TYPE_NFIELDS (ftype
))
951 error (_("Too few arguments in function call."));
953 for (int i
= args
.size () - 1; i
>= 0; i
--)
956 struct type
*param_type
;
958 /* FIXME drow/2002-05-31: Should just always mark methods as
959 prototyped. Can we respect TYPE_VARARGS? Probably not. */
960 if (TYPE_CODE (ftype
) == TYPE_CODE_METHOD
)
962 if (TYPE_TARGET_TYPE (ftype
) == NULL
&& TYPE_NFIELDS (ftype
) == 0
963 && default_return_type
!= NULL
)
965 /* Calling a no-debug function with the return type
966 explicitly cast. Assume the function is prototyped,
967 with a prototype matching the types of the arguments.
969 float mult (float v1, float v2) { return v1 * v2; }
971 (gdb) p (float) mult (2.0f, 3.0f)
972 Is a simpler alternative to:
973 (gdb) p ((float (*) (float, float)) mult) (2.0f, 3.0f)
977 else if (i
< TYPE_NFIELDS (ftype
))
978 prototyped
= TYPE_PROTOTYPED (ftype
);
982 if (i
< TYPE_NFIELDS (ftype
))
983 param_type
= TYPE_FIELD_TYPE (ftype
, i
);
987 args
[i
] = value_arg_coerce (gdbarch
, args
[i
],
988 param_type
, prototyped
, &sp
);
990 if (param_type
!= NULL
&& language_pass_by_reference (param_type
))
991 args
[i
] = value_addr (args
[i
]);
994 /* Reserve space for the return structure to be written on the
995 stack, if necessary. Make certain that the value is correctly
998 While evaluating expressions, we reserve space on the stack for
999 return values of class type even if the language ABI and the target
1000 ABI do not require that the return value be passed as a hidden first
1001 argument. This is because we want to store the return value as an
1002 on-stack temporary while the expression is being evaluated. This
1003 enables us to have chained function calls in expressions.
1005 Keeping the return values as on-stack temporaries while the expression
1006 is being evaluated is OK because the thread is stopped until the
1007 expression is completely evaluated. */
1009 if (return_method
!= return_method_normal
1010 || (stack_temporaries
&& class_or_union_p (values_type
)))
1012 if (gdbarch_inner_than (gdbarch
, 1, 2))
1014 /* Stack grows downward. Align STRUCT_ADDR and SP after
1015 making space for the return value. */
1016 sp
-= TYPE_LENGTH (values_type
);
1017 if (gdbarch_frame_align_p (gdbarch
))
1018 sp
= gdbarch_frame_align (gdbarch
, sp
);
1023 /* Stack grows upward. Align the frame, allocate space, and
1024 then again, re-align the frame??? */
1025 if (gdbarch_frame_align_p (gdbarch
))
1026 sp
= gdbarch_frame_align (gdbarch
, sp
);
1028 sp
+= TYPE_LENGTH (values_type
);
1029 if (gdbarch_frame_align_p (gdbarch
))
1030 sp
= gdbarch_frame_align (gdbarch
, sp
);
1034 std::vector
<struct value
*> new_args
;
1035 if (return_method
== return_method_hidden_param
)
1037 /* Add the new argument to the front of the argument list. */
1038 new_args
.reserve (args
.size ());
1040 (value_from_pointer (lookup_pointer_type (values_type
), struct_addr
));
1041 new_args
.insert (new_args
.end (), args
.begin (), args
.end ());
1045 /* Create the dummy stack frame. Pass in the call dummy address as,
1046 presumably, the ABI code knows where, in the call dummy, the
1047 return address should be pointed. */
1048 sp
= gdbarch_push_dummy_call (gdbarch
, function
, get_current_regcache (),
1049 bp_addr
, args
.size (), args
.data (),
1050 sp
, return_method
, struct_addr
);
1052 /* Set up a frame ID for the dummy frame so we can pass it to
1053 set_momentary_breakpoint. We need to give the breakpoint a frame
1054 ID so that the breakpoint code can correctly re-identify the
1055 dummy breakpoint. */
1056 /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL,
1057 saved as the dummy-frame TOS, and used by dummy_id to form
1058 the frame ID's stack address. */
1059 dummy_id
= frame_id_build (sp
, bp_addr
);
1061 /* Create a momentary breakpoint at the return address of the
1062 inferior. That way it breaks when it returns. */
1065 symtab_and_line sal
;
1066 sal
.pspace
= current_program_space
;
1068 sal
.section
= find_pc_overlay (sal
.pc
);
1070 /* Sanity. The exact same SP value is returned by
1071 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
1072 dummy_id to form the frame ID's stack address. */
1074 = set_momentary_breakpoint (gdbarch
, sal
,
1075 dummy_id
, bp_call_dummy
).release ();
1077 /* set_momentary_breakpoint invalidates FRAME. */
1080 bpt
->disposition
= disp_del
;
1081 gdb_assert (bpt
->related_breakpoint
== bpt
);
1083 breakpoint
*longjmp_b
= set_longjmp_breakpoint_for_call_dummy ();
1086 /* Link BPT into the chain of LONGJMP_B. */
1087 bpt
->related_breakpoint
= longjmp_b
;
1088 while (longjmp_b
->related_breakpoint
!= bpt
->related_breakpoint
)
1089 longjmp_b
= longjmp_b
->related_breakpoint
;
1090 longjmp_b
->related_breakpoint
= bpt
;
1094 /* Create a breakpoint in std::terminate.
1095 If a C++ exception is raised in the dummy-frame, and the
1096 exception handler is (normally, and expected to be) out-of-frame,
1097 the default C++ handler will (wrongly) be called in an inferior
1098 function call. This is wrong, as an exception can be normally
1099 and legally handled out-of-frame. The confines of the dummy frame
1100 prevent the unwinder from finding the correct handler (or any
1101 handler, unless it is in-frame). The default handler calls
1102 std::terminate. This will kill the inferior. Assert that
1103 terminate should never be called in an inferior function
1104 call. Place a momentary breakpoint in the std::terminate function
1105 and if triggered in the call, rewind. */
1106 if (unwind_on_terminating_exception_p
)
1107 set_std_terminate_breakpoint ();
1109 /* Everything's ready, push all the info needed to restore the
1110 caller (and identify the dummy-frame) onto the dummy-frame
1112 dummy_frame_push (caller_state
.release (), &dummy_id
, call_thread
.get ());
1113 if (dummy_dtor
!= NULL
)
1114 register_dummy_frame_dtor (dummy_id
, call_thread
.get (),
1115 dummy_dtor
, dummy_dtor_data
);
1117 /* Register a clean-up for unwind_on_terminating_exception_breakpoint. */
1118 SCOPE_EXIT
{ delete_std_terminate_breakpoint (); };
1120 /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP -
1121 If you're looking to implement asynchronous dummy-frames, then
1122 just below is the place to chop this function in two.. */
1125 struct thread_fsm
*saved_sm
;
1126 struct call_thread_fsm
*sm
;
1128 /* Save the current FSM. We'll override it. */
1129 saved_sm
= call_thread
->thread_fsm
;
1130 call_thread
->thread_fsm
= NULL
;
1132 /* Save this thread's ptid, we need it later but the thread
1134 call_thread_ptid
= call_thread
->ptid
;
1136 /* Run the inferior until it stops. */
1138 /* Create the FSM used to manage the infcall. It tells infrun to
1139 not report the stop to the user, and captures the return value
1140 before the dummy frame is popped. run_inferior_call registers
1141 it with the thread ASAP. */
1142 sm
= new_call_thread_fsm (current_ui
, command_interp (),
1145 return_method
!= return_method_normal
,
1148 e
= run_inferior_call (sm
, call_thread
.get (), real_pc
);
1150 gdb::observers::inferior_call_post
.notify (call_thread_ptid
, funaddr
);
1152 if (call_thread
->state
!= THREAD_EXITED
)
1154 /* The FSM should still be the same. */
1155 gdb_assert (call_thread
->thread_fsm
== &sm
->thread_fsm
);
1157 if (thread_fsm_finished_p (call_thread
->thread_fsm
))
1159 struct value
*retval
;
1161 /* The inferior call is successful. Pop the dummy frame,
1162 which runs its destructors and restores the inferior's
1163 suspend state, and restore the inferior control
1165 dummy_frame_pop (dummy_id
, call_thread
.get ());
1166 restore_infcall_control_state (inf_status
.release ());
1168 /* Get the return value. */
1169 retval
= sm
->return_value
;
1171 /* Clean up / destroy the call FSM, and restore the
1173 thread_fsm_clean_up (call_thread
->thread_fsm
, call_thread
.get ());
1174 thread_fsm_delete (call_thread
->thread_fsm
);
1175 call_thread
->thread_fsm
= saved_sm
;
1177 maybe_remove_breakpoints ();
1179 gdb_assert (retval
!= NULL
);
1183 /* Didn't complete. Clean up / destroy the call FSM, and restore the
1184 previous state machine, and handle the error. */
1185 thread_fsm_clean_up (call_thread
->thread_fsm
, call_thread
.get ());
1186 thread_fsm_delete (call_thread
->thread_fsm
);
1187 call_thread
->thread_fsm
= saved_sm
;
1191 /* Rethrow an error if we got one trying to run the inferior. */
1195 const char *name
= get_function_name (funaddr
,
1196 name_buf
, sizeof (name_buf
));
1198 discard_infcall_control_state (inf_status
.release ());
1200 /* We could discard the dummy frame here if the program exited,
1201 but it will get garbage collected the next time the program is
1207 throw_error (e
.error
, _("%s\n\
1208 An error occurred while in a function called from GDB.\n\
1209 Evaluation of the expression containing the function\n\
1210 (%s) will be abandoned.\n\
1211 When the function is done executing, GDB will silently stop."),
1215 throw_exception (e
);
1219 /* If the program has exited, or we stopped at a different thread,
1220 exit and inform the user. */
1222 if (! target_has_execution
)
1224 const char *name
= get_function_name (funaddr
,
1225 name_buf
, sizeof (name_buf
));
1227 /* If we try to restore the inferior status,
1228 we'll crash as the inferior is no longer running. */
1229 discard_infcall_control_state (inf_status
.release ());
1231 /* We could discard the dummy frame here given that the program exited,
1232 but it will get garbage collected the next time the program is
1235 error (_("The program being debugged exited while in a function "
1236 "called from GDB.\n"
1237 "Evaluation of the expression containing the function\n"
1238 "(%s) will be abandoned."),
1242 if (call_thread_ptid
!= inferior_ptid
)
1244 const char *name
= get_function_name (funaddr
,
1245 name_buf
, sizeof (name_buf
));
1247 /* We've switched threads. This can happen if another thread gets a
1248 signal or breakpoint while our thread was running.
1249 There's no point in restoring the inferior status,
1250 we're in a different thread. */
1251 discard_infcall_control_state (inf_status
.release ());
1252 /* Keep the dummy frame record, if the user switches back to the
1253 thread with the hand-call, we'll need it. */
1254 if (stopped_by_random_signal
)
1256 The program received a signal in another thread while\n\
1257 making a function call from GDB.\n\
1258 Evaluation of the expression containing the function\n\
1259 (%s) will be abandoned.\n\
1260 When the function is done executing, GDB will silently stop."),
1264 The program stopped in another thread while making a function call from GDB.\n\
1265 Evaluation of the expression containing the function\n\
1266 (%s) will be abandoned.\n\
1267 When the function is done executing, GDB will silently stop."),
1272 /* Make a copy as NAME may be in an objfile freed by dummy_frame_pop. */
1273 std::string name
= get_function_name (funaddr
, name_buf
,
1276 if (stopped_by_random_signal
)
1278 /* We stopped inside the FUNCTION because of a random
1279 signal. Further execution of the FUNCTION is not
1282 if (unwind_on_signal_p
)
1284 /* The user wants the context restored. */
1286 /* We must get back to the frame we were before the
1288 dummy_frame_pop (dummy_id
, call_thread
.get ());
1290 /* We also need to restore inferior status to that before the
1292 restore_infcall_control_state (inf_status
.release ());
1294 /* FIXME: Insert a bunch of wrap_here; name can be very
1295 long if it's a C++ name with arguments and stuff. */
1297 The program being debugged was signaled while in a function called from GDB.\n\
1298 GDB has restored the context to what it was before the call.\n\
1299 To change this behavior use \"set unwindonsignal off\".\n\
1300 Evaluation of the expression containing the function\n\
1301 (%s) will be abandoned."),
1306 /* The user wants to stay in the frame where we stopped
1308 Discard inferior status, we're not at the same point
1310 discard_infcall_control_state (inf_status
.release ());
1312 /* FIXME: Insert a bunch of wrap_here; name can be very
1313 long if it's a C++ name with arguments and stuff. */
1315 The program being debugged was signaled while in a function called from GDB.\n\
1316 GDB remains in the frame where the signal was received.\n\
1317 To change this behavior use \"set unwindonsignal on\".\n\
1318 Evaluation of the expression containing the function\n\
1319 (%s) will be abandoned.\n\
1320 When the function is done executing, GDB will silently stop."),
1325 if (stop_stack_dummy
== STOP_STD_TERMINATE
)
1327 /* We must get back to the frame we were before the dummy
1329 dummy_frame_pop (dummy_id
, call_thread
.get ());
1331 /* We also need to restore inferior status to that before
1333 restore_infcall_control_state (inf_status
.release ());
1336 The program being debugged entered a std::terminate call, most likely\n\
1337 caused by an unhandled C++ exception. GDB blocked this call in order\n\
1338 to prevent the program from being terminated, and has restored the\n\
1339 context to its original state before the call.\n\
1340 To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
1341 Evaluation of the expression containing the function (%s)\n\
1342 will be abandoned."),
1345 else if (stop_stack_dummy
== STOP_NONE
)
1348 /* We hit a breakpoint inside the FUNCTION.
1349 Keep the dummy frame, the user may want to examine its state.
1350 Discard inferior status, we're not at the same point
1352 discard_infcall_control_state (inf_status
.release ());
1354 /* The following error message used to say "The expression
1355 which contained the function call has been discarded."
1356 It is a hard concept to explain in a few words. Ideally,
1357 GDB would be able to resume evaluation of the expression
1358 when the function finally is done executing. Perhaps
1359 someday this will be implemented (it would not be easy). */
1360 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1361 a C++ name with arguments and stuff. */
1363 The program being debugged stopped while in a function called from GDB.\n\
1364 Evaluation of the expression containing the function\n\
1365 (%s) will be abandoned.\n\
1366 When the function is done executing, GDB will silently stop."),
1372 /* The above code errors out, so ... */
1373 gdb_assert_not_reached ("... should not be here");
1377 _initialize_infcall (void)
1379 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure
,
1380 &coerce_float_to_double_p
, _("\
1381 Set coercion of floats to doubles when calling functions."), _("\
1382 Show coercion of floats to doubles when calling functions"), _("\
1383 Variables of type float should generally be converted to doubles before\n\
1384 calling an unprototyped function, and left alone when calling a prototyped\n\
1385 function. However, some older debug info formats do not provide enough\n\
1386 information to determine that a function is prototyped. If this flag is\n\
1387 set, GDB will perform the conversion for a function it considers\n\
1389 The default is to perform the conversion.\n"),
1391 show_coerce_float_to_double_p
,
1392 &setlist
, &showlist
);
1394 add_setshow_boolean_cmd ("unwindonsignal", no_class
,
1395 &unwind_on_signal_p
, _("\
1396 Set unwinding of stack if a signal is received while in a call dummy."), _("\
1397 Show unwinding of stack if a signal is received while in a call dummy."), _("\
1398 The unwindonsignal lets the user determine what gdb should do if a signal\n\
1399 is received while in a function called from gdb (call dummy). If set, gdb\n\
1400 unwinds the stack and restore the context to what as it was before the call.\n\
1401 The default is to stop in the frame where the signal was received."),
1403 show_unwind_on_signal_p
,
1404 &setlist
, &showlist
);
1406 add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class
,
1407 &unwind_on_terminating_exception_p
, _("\
1408 Set unwinding of stack if std::terminate is called while in call dummy."), _("\
1409 Show unwinding of stack if std::terminate() is called while in a call dummy."),
1411 The unwind on terminating exception flag lets the user determine\n\
1412 what gdb should do if a std::terminate() call is made from the\n\
1413 default exception handler. If set, gdb unwinds the stack and restores\n\
1414 the context to what it was before the call. If unset, gdb allows the\n\
1415 std::terminate call to proceed.\n\
1416 The default is to unwind the frame."),
1418 show_unwind_on_terminating_exception_p
,
1419 &setlist
, &showlist
);