1 /* Perform an inferior function call, for GDB, the GNU debugger.
3 Copyright (C) 1986-2014 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/>. */
21 #include "breakpoint.h"
22 #include "tracepoint.h"
34 #include "dummy-frame.h"
36 #include "gdbthread.h"
37 #include "event-top.h"
40 /* If we can't find a function's name from its address,
41 we print this instead. */
42 #define RAW_FUNCTION_ADDRESS_FORMAT "at 0x%s"
43 #define RAW_FUNCTION_ADDRESS_SIZE (sizeof (RAW_FUNCTION_ADDRESS_FORMAT) \
44 + 2 * sizeof (CORE_ADDR))
46 /* NOTE: cagney/2003-04-16: What's the future of this code?
48 GDB needs an asynchronous expression evaluator, that means an
49 asynchronous inferior function call implementation, and that in
50 turn means restructuring the code so that it is event driven. */
52 /* How you should pass arguments to a function depends on whether it
53 was defined in K&R style or prototype style. If you define a
54 function using the K&R syntax that takes a `float' argument, then
55 callers must pass that argument as a `double'. If you define the
56 function using the prototype syntax, then you must pass the
57 argument as a `float', with no promotion.
59 Unfortunately, on certain older platforms, the debug info doesn't
60 indicate reliably how each function was defined. A function type's
61 TYPE_FLAG_PROTOTYPED flag may be clear, even if the function was
62 defined in prototype style. When calling a function whose
63 TYPE_FLAG_PROTOTYPED flag is clear, GDB consults this flag to
66 For modern targets, it is proper to assume that, if the prototype
67 flag is clear, that can be trusted: `float' arguments should be
68 promoted to `double'. For some older targets, if the prototype
69 flag is clear, that doesn't tell us anything. The default is to
70 trust the debug information; the user can override this behavior
71 with "set coerce-float-to-double 0". */
73 static int coerce_float_to_double_p = 1;
75 show_coerce_float_to_double_p (struct ui_file *file, int from_tty,
76 struct cmd_list_element *c, const char *value)
78 fprintf_filtered (file,
79 _("Coercion of floats to doubles "
80 "when calling functions is %s.\n"),
84 /* This boolean tells what gdb should do if a signal is received while
85 in a function called from gdb (call dummy). If set, gdb unwinds
86 the stack and restore the context to what as it was before the
89 The default is to stop in the frame where the signal was received. */
91 static int unwind_on_signal_p = 0;
93 show_unwind_on_signal_p (struct ui_file *file, int from_tty,
94 struct cmd_list_element *c, const char *value)
96 fprintf_filtered (file,
97 _("Unwinding of stack if a signal is "
98 "received while in a call dummy is %s.\n"),
102 /* This boolean tells what gdb should do if a std::terminate call is
103 made while in a function called from gdb (call dummy).
104 As the confines of a single dummy stack prohibit out-of-frame
105 handlers from handling a raised exception, and as out-of-frame
106 handlers are common in C++, this can lead to no handler being found
107 by the unwinder, and a std::terminate call. This is a false positive.
108 If set, gdb unwinds the stack and restores the context to what it
111 The default is to unwind the frame if a std::terminate call is
114 static int unwind_on_terminating_exception_p = 1;
117 show_unwind_on_terminating_exception_p (struct ui_file *file, int from_tty,
118 struct cmd_list_element *c,
122 fprintf_filtered (file,
123 _("Unwind stack if a C++ exception is "
124 "unhandled while in a call dummy is %s.\n"),
128 /* Perform the standard coercions that are specified
129 for arguments to be passed to C or Ada functions.
131 If PARAM_TYPE is non-NULL, it is the expected parameter type.
132 IS_PROTOTYPED is non-zero if the function declaration is prototyped.
133 SP is the stack pointer were additional data can be pushed (updating
134 its value as needed). */
136 static struct value *
137 value_arg_coerce (struct gdbarch *gdbarch, struct value *arg,
138 struct type *param_type, int is_prototyped, CORE_ADDR *sp)
140 const struct builtin_type *builtin = builtin_type (gdbarch);
141 struct type *arg_type = check_typedef (value_type (arg));
143 = param_type ? check_typedef (param_type) : arg_type;
145 /* Perform any Ada-specific coercion first. */
146 if (current_language->la_language == language_ada)
147 arg = ada_convert_actual (arg, type);
149 /* Force the value to the target if we will need its address. At
150 this point, we could allocate arguments on the stack instead of
151 calling malloc if we knew that their addresses would not be
152 saved by the called function. */
153 arg = value_coerce_to_target (arg);
155 switch (TYPE_CODE (type))
159 struct value *new_value;
161 if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
162 return value_cast_pointers (type, arg, 0);
164 /* Cast the value to the reference's target type, and then
165 convert it back to a reference. This will issue an error
166 if the value was not previously in memory - in some cases
167 we should clearly be allowing this, but how? */
168 new_value = value_cast (TYPE_TARGET_TYPE (type), arg);
169 new_value = value_ref (new_value);
176 /* If we don't have a prototype, coerce to integer type if necessary. */
179 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_int))
180 type = builtin->builtin_int;
182 /* Currently all target ABIs require at least the width of an integer
183 type for an argument. We may have to conditionalize the following
184 type coercion for future targets. */
185 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_int))
186 type = builtin->builtin_int;
189 if (!is_prototyped && coerce_float_to_double_p)
191 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_double))
192 type = builtin->builtin_double;
193 else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin->builtin_double))
194 type = builtin->builtin_long_double;
198 type = lookup_pointer_type (type);
200 case TYPE_CODE_ARRAY:
201 /* Arrays are coerced to pointers to their first element, unless
202 they are vectors, in which case we want to leave them alone,
203 because they are passed by value. */
204 if (current_language->c_style_arrays)
205 if (!TYPE_VECTOR (type))
206 type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
208 case TYPE_CODE_UNDEF:
210 case TYPE_CODE_STRUCT:
211 case TYPE_CODE_UNION:
214 case TYPE_CODE_RANGE:
215 case TYPE_CODE_STRING:
216 case TYPE_CODE_ERROR:
217 case TYPE_CODE_MEMBERPTR:
218 case TYPE_CODE_METHODPTR:
219 case TYPE_CODE_METHOD:
220 case TYPE_CODE_COMPLEX:
225 return value_cast (type, arg);
228 /* Return the return type of a function with its first instruction exactly at
229 the PC address. Return NULL otherwise. */
232 find_function_return_type (CORE_ADDR pc)
234 struct symbol *sym = find_pc_function (pc);
236 if (sym != NULL && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) == pc
237 && SYMBOL_TYPE (sym) != NULL)
238 return TYPE_TARGET_TYPE (SYMBOL_TYPE (sym));
243 /* Determine a function's address and its return type from its value.
244 Calls error() if the function is not valid for calling. */
247 find_function_addr (struct value *function, struct type **retval_type)
249 struct type *ftype = check_typedef (value_type (function));
250 struct gdbarch *gdbarch = get_type_arch (ftype);
251 struct type *value_type = NULL;
252 /* Initialize it just to avoid a GCC false warning. */
253 CORE_ADDR funaddr = 0;
255 /* If it's a member function, just look at the function
258 /* Determine address to call. */
259 if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
260 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
261 funaddr = value_address (function);
262 else if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
264 funaddr = value_as_address (function);
265 ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
266 if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
267 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
268 funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr,
271 if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
272 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
274 value_type = TYPE_TARGET_TYPE (ftype);
276 if (TYPE_GNU_IFUNC (ftype))
278 funaddr = gnu_ifunc_resolve_addr (gdbarch, funaddr);
280 /* Skip querying the function symbol if no RETVAL_TYPE has been
283 value_type = find_function_return_type (funaddr);
286 else if (TYPE_CODE (ftype) == TYPE_CODE_INT)
288 /* Handle the case of functions lacking debugging info.
289 Their values are characters since their addresses are char. */
290 if (TYPE_LENGTH (ftype) == 1)
291 funaddr = value_as_address (value_addr (function));
294 /* Handle function descriptors lacking debug info. */
295 int found_descriptor = 0;
297 funaddr = 0; /* pacify "gcc -Werror" */
298 if (VALUE_LVAL (function) == lval_memory)
302 funaddr = value_as_address (value_addr (function));
304 funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr,
306 if (funaddr != nfunaddr)
307 found_descriptor = 1;
309 if (!found_descriptor)
310 /* Handle integer used as address of a function. */
311 funaddr = (CORE_ADDR) value_as_long (function);
315 error (_("Invalid data type for function to be called."));
317 if (retval_type != NULL)
318 *retval_type = value_type;
319 return funaddr + gdbarch_deprecated_function_start_offset (gdbarch);
322 /* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called
323 function returns to. */
326 push_dummy_code (struct gdbarch *gdbarch,
327 CORE_ADDR sp, CORE_ADDR funaddr,
328 struct value **args, int nargs,
329 struct type *value_type,
330 CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
331 struct regcache *regcache)
333 gdb_assert (gdbarch_push_dummy_code_p (gdbarch));
335 return gdbarch_push_dummy_code (gdbarch, sp, funaddr,
336 args, nargs, value_type, real_pc, bp_addr,
340 /* Fetch the name of the function at FUNADDR.
341 This is used in printing an error message for call_function_by_hand.
342 BUF is used to print FUNADDR in hex if the function name cannot be
343 determined. It must be large enough to hold formatted result of
344 RAW_FUNCTION_ADDRESS_FORMAT. */
347 get_function_name (CORE_ADDR funaddr, char *buf, int buf_size)
350 struct symbol *symbol = find_pc_function (funaddr);
353 return SYMBOL_PRINT_NAME (symbol);
357 /* Try the minimal symbols. */
358 struct bound_minimal_symbol msymbol = lookup_minimal_symbol_by_pc (funaddr);
361 return MSYMBOL_PRINT_NAME (msymbol.minsym);
365 char *tmp = xstrprintf (_(RAW_FUNCTION_ADDRESS_FORMAT),
366 hex_string (funaddr));
368 gdb_assert (strlen (tmp) + 1 <= buf_size);
375 /* Subroutine of call_function_by_hand to simplify it.
376 Start up the inferior and wait for it to stop.
377 Return the exception if there's an error, or an exception with
378 reason >= 0 if there's no error.
380 This is done inside a TRY_CATCH so the caller needn't worry about
381 thrown errors. The caller should rethrow if there's an error. */
383 static struct gdb_exception
384 run_inferior_call (struct thread_info *call_thread, CORE_ADDR real_pc)
386 volatile struct gdb_exception e;
387 int saved_in_infcall = call_thread->control.in_infcall;
388 ptid_t call_thread_ptid = call_thread->ptid;
389 int saved_sync_execution = sync_execution;
391 /* Infcalls run synchronously, in the foreground. */
392 if (target_can_async_p ())
395 call_thread->control.in_infcall = 1;
397 clear_proceed_status (0);
399 disable_watchpoints_before_interactive_call_start ();
401 /* We want stop_registers, please... */
402 call_thread->control.proceed_to_finish = 1;
404 TRY_CATCH (e, RETURN_MASK_ALL)
406 int was_sync = sync_execution;
408 proceed (real_pc, GDB_SIGNAL_0, 0);
410 /* Inferior function calls are always synchronous, even if the
411 target supports asynchronous execution. Do here what
412 `proceed' itself does in sync mode. */
413 if (target_can_async_p ())
415 wait_for_inferior ();
417 /* If GDB was previously in sync execution mode, then ensure
418 that it remains so. normal_stop calls
419 async_enable_stdin, so reset it again here. In other
420 cases, stdin will be re-enabled by
421 inferior_event_handler, when an exception is thrown. */
423 async_disable_stdin ();
427 /* At this point the current thread may have changed. Refresh
428 CALL_THREAD as it could be invalid if its thread has exited. */
429 call_thread = find_thread_ptid (call_thread_ptid);
431 enable_watchpoints_after_interactive_call_stop ();
433 /* Call breakpoint_auto_delete on the current contents of the bpstat
434 of inferior call thread.
435 If all error()s out of proceed ended up calling normal_stop
436 (and perhaps they should; it already does in the special case
437 of error out of resume()), then we wouldn't need this. */
440 if (call_thread != NULL)
441 breakpoint_auto_delete (call_thread->control.stop_bpstat);
444 if (call_thread != NULL)
445 call_thread->control.in_infcall = saved_in_infcall;
447 sync_execution = saved_sync_execution;
452 /* A cleanup function that calls delete_std_terminate_breakpoint. */
454 cleanup_delete_std_terminate_breakpoint (void *ignore)
456 delete_std_terminate_breakpoint ();
462 call_function_by_hand (struct value *function, int nargs, struct value **args)
464 return call_function_by_hand_dummy (function, nargs, args, NULL, NULL);
467 /* All this stuff with a dummy frame may seem unnecessarily complicated
468 (why not just save registers in GDB?). The purpose of pushing a dummy
469 frame which looks just like a real frame is so that if you call a
470 function and then hit a breakpoint (get a signal, etc), "backtrace"
471 will look right. Whether the backtrace needs to actually show the
472 stack at the time the inferior function was called is debatable, but
473 it certainly needs to not display garbage. So if you are contemplating
474 making dummy frames be different from normal frames, consider that. */
476 /* Perform a function call in the inferior.
477 ARGS is a vector of values of arguments (NARGS of them).
478 FUNCTION is a value, the function to be called.
479 Returns a value representing what the function returned.
480 May fail to return, if a breakpoint or signal is hit
481 during the execution of the function.
483 ARGS is modified to contain coerced values. */
486 call_function_by_hand_dummy (struct value *function,
487 int nargs, struct value **args,
488 call_function_by_hand_dummy_dtor_ftype *dummy_dtor,
489 void *dummy_dtor_data)
492 struct type *values_type, *target_values_type;
493 unsigned char struct_return = 0, hidden_first_param_p = 0;
494 CORE_ADDR struct_addr = 0;
495 struct infcall_control_state *inf_status;
496 struct cleanup *inf_status_cleanup;
497 struct infcall_suspend_state *caller_state;
500 struct type *ftype = check_typedef (value_type (function));
502 struct frame_id dummy_id;
503 struct cleanup *args_cleanup;
504 struct frame_info *frame;
505 struct gdbarch *gdbarch;
506 struct cleanup *terminate_bp_cleanup;
507 ptid_t call_thread_ptid;
508 struct gdb_exception e;
509 char name_buf[RAW_FUNCTION_ADDRESS_SIZE];
510 int stack_temporaries = thread_stack_temporaries_enabled_p (inferior_ptid);
512 if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
513 ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
515 if (!target_has_execution)
518 if (get_traceframe_number () >= 0)
519 error (_("May not call functions while looking at trace frames."));
521 if (execution_direction == EXEC_REVERSE)
522 error (_("Cannot call functions in reverse mode."));
524 frame = get_current_frame ();
525 gdbarch = get_frame_arch (frame);
527 if (!gdbarch_push_dummy_call_p (gdbarch))
528 error (_("This target does not support function calls."));
530 /* A cleanup for the inferior status.
531 This is only needed while we're preparing the inferior function call. */
532 inf_status = save_infcall_control_state ();
534 = make_cleanup_restore_infcall_control_state (inf_status);
536 /* Save the caller's registers and other state associated with the
537 inferior itself so that they can be restored once the
538 callee returns. To allow nested calls the registers are (further
539 down) pushed onto a dummy frame stack. Include a cleanup (which
540 is tossed once the regcache has been pushed). */
541 caller_state = save_infcall_suspend_state ();
542 make_cleanup_restore_infcall_suspend_state (caller_state);
544 /* Ensure that the initial SP is correctly aligned. */
546 CORE_ADDR old_sp = get_frame_sp (frame);
548 if (gdbarch_frame_align_p (gdbarch))
550 sp = gdbarch_frame_align (gdbarch, old_sp);
551 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
552 ABIs, a function can use memory beyond the inner most stack
553 address. AMD64 called that region the "red zone". Skip at
554 least the "red zone" size before allocating any space on
556 if (gdbarch_inner_than (gdbarch, 1, 2))
557 sp -= gdbarch_frame_red_zone_size (gdbarch);
559 sp += gdbarch_frame_red_zone_size (gdbarch);
561 gdb_assert (sp == gdbarch_frame_align (gdbarch, sp));
562 /* NOTE: cagney/2002-09-18:
564 On a RISC architecture, a void parameterless generic dummy
565 frame (i.e., no parameters, no result) typically does not
566 need to push anything the stack and hence can leave SP and
567 FP. Similarly, a frameless (possibly leaf) function does
568 not push anything on the stack and, hence, that too can
569 leave FP and SP unchanged. As a consequence, a sequence of
570 void parameterless generic dummy frame calls to frameless
571 functions will create a sequence of effectively identical
572 frames (SP, FP and TOS and PC the same). This, not
573 suprisingly, results in what appears to be a stack in an
574 infinite loop --- when GDB tries to find a generic dummy
575 frame on the internal dummy frame stack, it will always
578 To avoid this problem, the code below always grows the
579 stack. That way, two dummy frames can never be identical.
580 It does burn a few bytes of stack but that is a small price
584 if (gdbarch_inner_than (gdbarch, 1, 2))
585 /* Stack grows down. */
586 sp = gdbarch_frame_align (gdbarch, old_sp - 1);
588 /* Stack grows up. */
589 sp = gdbarch_frame_align (gdbarch, old_sp + 1);
591 /* SP may have underflown address zero here from OLD_SP. Memory access
592 functions will probably fail in such case but that is a target's
596 /* FIXME: cagney/2002-09-18: Hey, you loose!
598 Who knows how badly aligned the SP is!
600 If the generic dummy frame ends up empty (because nothing is
601 pushed) GDB won't be able to correctly perform back traces.
602 If a target is having trouble with backtraces, first thing to
603 do is add FRAME_ALIGN() to the architecture vector. If that
604 fails, try dummy_id().
606 If the ABI specifies a "Red Zone" (see the doco) the code
607 below will quietly trash it. */
610 /* Skip over the stack temporaries that might have been generated during
611 the evaluation of an expression. */
612 if (stack_temporaries)
614 struct value *lastval;
616 lastval = get_last_thread_stack_temporary (inferior_ptid);
619 CORE_ADDR lastval_addr = value_address (lastval);
621 if (gdbarch_inner_than (gdbarch, 1, 2))
623 gdb_assert (sp >= lastval_addr);
628 gdb_assert (sp <= lastval_addr);
629 sp = lastval_addr + TYPE_LENGTH (value_type (lastval));
632 if (gdbarch_frame_align_p (gdbarch))
633 sp = gdbarch_frame_align (gdbarch, sp);
638 funaddr = find_function_addr (function, &values_type);
640 values_type = builtin_type (gdbarch)->builtin_int;
642 CHECK_TYPEDEF (values_type);
644 /* Are we returning a value using a structure return (passing a
645 hidden argument pointing to storage) or a normal value return?
646 There are two cases: language-mandated structure return and
647 target ABI structure return. The variable STRUCT_RETURN only
648 describes the latter. The language version is handled by passing
649 the return location as the first parameter to the function,
650 even preceding "this". This is different from the target
651 ABI version, which is target-specific; for instance, on ia64
652 the first argument is passed in out0 but the hidden structure
653 return pointer would normally be passed in r8. */
655 if (gdbarch_return_in_first_hidden_param_p (gdbarch, values_type))
657 hidden_first_param_p = 1;
659 /* Tell the target specific argument pushing routine not to
661 target_values_type = builtin_type (gdbarch)->builtin_void;
665 struct_return = using_struct_return (gdbarch, function, values_type);
666 target_values_type = values_type;
669 observer_notify_inferior_call_pre (inferior_ptid, funaddr);
671 /* Determine the location of the breakpoint (and possibly other
672 stuff) that the called function will return to. The SPARC, for a
673 function returning a structure or union, needs to make space for
674 not just the breakpoint but also an extra word containing the
675 size (?) of the structure being passed. */
677 switch (gdbarch_call_dummy_location (gdbarch))
681 const gdb_byte *bp_bytes;
682 CORE_ADDR bp_addr_as_address;
685 /* Be careful BP_ADDR is in inferior PC encoding while
686 BP_ADDR_AS_ADDRESS is a plain memory address. */
688 sp = push_dummy_code (gdbarch, sp, funaddr, args, nargs,
689 target_values_type, &real_pc, &bp_addr,
690 get_current_regcache ());
692 /* Write a legitimate instruction at the point where the infcall
693 breakpoint is going to be inserted. While this instruction
694 is never going to be executed, a user investigating the
695 memory from GDB would see this instruction instead of random
696 uninitialized bytes. We chose the breakpoint instruction
697 as it may look as the most logical one to the user and also
698 valgrind 3.7.0 needs it for proper vgdb inferior calls.
700 If software breakpoints are unsupported for this target we
701 leave the user visible memory content uninitialized. */
703 bp_addr_as_address = bp_addr;
704 bp_bytes = gdbarch_breakpoint_from_pc (gdbarch, &bp_addr_as_address,
706 if (bp_bytes != NULL)
707 write_memory (bp_addr_as_address, bp_bytes, bp_size);
712 CORE_ADDR dummy_addr;
715 dummy_addr = entry_point_address ();
717 /* A call dummy always consists of just a single breakpoint, so
718 its address is the same as the address of the dummy.
720 The actual breakpoint is inserted separatly so there is no need to
722 bp_addr = dummy_addr;
726 internal_error (__FILE__, __LINE__, _("bad switch"));
729 if (nargs < TYPE_NFIELDS (ftype))
730 error (_("Too few arguments in function call."));
735 for (i = nargs - 1; i >= 0; i--)
738 struct type *param_type;
740 /* FIXME drow/2002-05-31: Should just always mark methods as
741 prototyped. Can we respect TYPE_VARARGS? Probably not. */
742 if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
744 else if (i < TYPE_NFIELDS (ftype))
745 prototyped = TYPE_PROTOTYPED (ftype);
749 if (i < TYPE_NFIELDS (ftype))
750 param_type = TYPE_FIELD_TYPE (ftype, i);
754 args[i] = value_arg_coerce (gdbarch, args[i],
755 param_type, prototyped, &sp);
757 if (param_type != NULL && language_pass_by_reference (param_type))
758 args[i] = value_addr (args[i]);
762 /* Reserve space for the return structure to be written on the
763 stack, if necessary. Make certain that the value is correctly
766 While evaluating expressions, we reserve space on the stack for
767 return values of class type even if the language ABI and the target
768 ABI do not require that the return value be passed as a hidden first
769 argument. This is because we want to store the return value as an
770 on-stack temporary while the expression is being evaluated. This
771 enables us to have chained function calls in expressions.
773 Keeping the return values as on-stack temporaries while the expression
774 is being evaluated is OK because the thread is stopped until the
775 expression is completely evaluated. */
777 if (struct_return || hidden_first_param_p
778 || (stack_temporaries && class_or_union_p (values_type)))
780 if (gdbarch_inner_than (gdbarch, 1, 2))
782 /* Stack grows downward. Align STRUCT_ADDR and SP after
783 making space for the return value. */
784 sp -= TYPE_LENGTH (values_type);
785 if (gdbarch_frame_align_p (gdbarch))
786 sp = gdbarch_frame_align (gdbarch, sp);
791 /* Stack grows upward. Align the frame, allocate space, and
792 then again, re-align the frame??? */
793 if (gdbarch_frame_align_p (gdbarch))
794 sp = gdbarch_frame_align (gdbarch, sp);
796 sp += TYPE_LENGTH (values_type);
797 if (gdbarch_frame_align_p (gdbarch))
798 sp = gdbarch_frame_align (gdbarch, sp);
802 if (hidden_first_param_p)
804 struct value **new_args;
806 /* Add the new argument to the front of the argument list. */
807 new_args = xmalloc (sizeof (struct value *) * (nargs + 1));
808 new_args[0] = value_from_pointer (lookup_pointer_type (values_type),
810 memcpy (&new_args[1], &args[0], sizeof (struct value *) * nargs);
813 args_cleanup = make_cleanup (xfree, args);
816 args_cleanup = make_cleanup (null_cleanup, NULL);
818 /* Create the dummy stack frame. Pass in the call dummy address as,
819 presumably, the ABI code knows where, in the call dummy, the
820 return address should be pointed. */
821 sp = gdbarch_push_dummy_call (gdbarch, function, get_current_regcache (),
822 bp_addr, nargs, args,
823 sp, struct_return, struct_addr);
825 do_cleanups (args_cleanup);
827 /* Set up a frame ID for the dummy frame so we can pass it to
828 set_momentary_breakpoint. We need to give the breakpoint a frame
829 ID so that the breakpoint code can correctly re-identify the
831 /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL,
832 saved as the dummy-frame TOS, and used by dummy_id to form
833 the frame ID's stack address. */
834 dummy_id = frame_id_build (sp, bp_addr);
836 /* Create a momentary breakpoint at the return address of the
837 inferior. That way it breaks when it returns. */
840 struct breakpoint *bpt, *longjmp_b;
841 struct symtab_and_line sal;
843 init_sal (&sal); /* initialize to zeroes */
844 sal.pspace = current_program_space;
846 sal.section = find_pc_overlay (sal.pc);
847 /* Sanity. The exact same SP value is returned by
848 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
849 dummy_id to form the frame ID's stack address. */
850 bpt = set_momentary_breakpoint (gdbarch, sal, dummy_id, bp_call_dummy);
852 /* set_momentary_breakpoint invalidates FRAME. */
855 bpt->disposition = disp_del;
856 gdb_assert (bpt->related_breakpoint == bpt);
858 longjmp_b = set_longjmp_breakpoint_for_call_dummy ();
861 /* Link BPT into the chain of LONGJMP_B. */
862 bpt->related_breakpoint = longjmp_b;
863 while (longjmp_b->related_breakpoint != bpt->related_breakpoint)
864 longjmp_b = longjmp_b->related_breakpoint;
865 longjmp_b->related_breakpoint = bpt;
869 /* Create a breakpoint in std::terminate.
870 If a C++ exception is raised in the dummy-frame, and the
871 exception handler is (normally, and expected to be) out-of-frame,
872 the default C++ handler will (wrongly) be called in an inferior
873 function call. This is wrong, as an exception can be normally
874 and legally handled out-of-frame. The confines of the dummy frame
875 prevent the unwinder from finding the correct handler (or any
876 handler, unless it is in-frame). The default handler calls
877 std::terminate. This will kill the inferior. Assert that
878 terminate should never be called in an inferior function
879 call. Place a momentary breakpoint in the std::terminate function
880 and if triggered in the call, rewind. */
881 if (unwind_on_terminating_exception_p)
882 set_std_terminate_breakpoint ();
884 /* Everything's ready, push all the info needed to restore the
885 caller (and identify the dummy-frame) onto the dummy-frame
887 dummy_frame_push (caller_state, &dummy_id, inferior_ptid);
888 if (dummy_dtor != NULL)
889 register_dummy_frame_dtor (dummy_id, inferior_ptid,
890 dummy_dtor, dummy_dtor_data);
892 /* Discard both inf_status and caller_state cleanups.
893 From this point on we explicitly restore the associated state
895 discard_cleanups (inf_status_cleanup);
897 /* Register a clean-up for unwind_on_terminating_exception_breakpoint. */
898 terminate_bp_cleanup = make_cleanup (cleanup_delete_std_terminate_breakpoint,
901 /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP -
902 If you're looking to implement asynchronous dummy-frames, then
903 just below is the place to chop this function in two.. */
905 /* TP is invalid after run_inferior_call returns, so enclose this
906 in a block so that it's only in scope during the time it's valid. */
908 struct thread_info *tp = inferior_thread ();
910 /* Save this thread's ptid, we need it later but the thread
912 call_thread_ptid = tp->ptid;
914 /* Run the inferior until it stops. */
916 e = run_inferior_call (tp, real_pc);
919 observer_notify_inferior_call_post (call_thread_ptid, funaddr);
921 /* Rethrow an error if we got one trying to run the inferior. */
925 const char *name = get_function_name (funaddr,
926 name_buf, sizeof (name_buf));
928 discard_infcall_control_state (inf_status);
930 /* We could discard the dummy frame here if the program exited,
931 but it will get garbage collected the next time the program is
937 throw_error (e.error, _("%s\n\
938 An error occurred while in a function called from GDB.\n\
939 Evaluation of the expression containing the function\n\
940 (%s) will be abandoned.\n\
941 When the function is done executing, GDB will silently stop."),
949 /* If the program has exited, or we stopped at a different thread,
950 exit and inform the user. */
952 if (! target_has_execution)
954 const char *name = get_function_name (funaddr,
955 name_buf, sizeof (name_buf));
957 /* If we try to restore the inferior status,
958 we'll crash as the inferior is no longer running. */
959 discard_infcall_control_state (inf_status);
961 /* We could discard the dummy frame here given that the program exited,
962 but it will get garbage collected the next time the program is
965 error (_("The program being debugged exited while in a function "
967 "Evaluation of the expression containing the function\n"
968 "(%s) will be abandoned."),
972 if (! ptid_equal (call_thread_ptid, inferior_ptid))
974 const char *name = get_function_name (funaddr,
975 name_buf, sizeof (name_buf));
977 /* We've switched threads. This can happen if another thread gets a
978 signal or breakpoint while our thread was running.
979 There's no point in restoring the inferior status,
980 we're in a different thread. */
981 discard_infcall_control_state (inf_status);
982 /* Keep the dummy frame record, if the user switches back to the
983 thread with the hand-call, we'll need it. */
984 if (stopped_by_random_signal)
986 The program received a signal in another thread while\n\
987 making a function call from GDB.\n\
988 Evaluation of the expression containing the function\n\
989 (%s) will be abandoned.\n\
990 When the function is done executing, GDB will silently stop."),
994 The program stopped in another thread while making a function call from GDB.\n\
995 Evaluation of the expression containing the function\n\
996 (%s) will be abandoned.\n\
997 When the function is done executing, GDB will silently stop."),
1001 if (stopped_by_random_signal || stop_stack_dummy != STOP_STACK_DUMMY)
1003 const char *name = get_function_name (funaddr,
1004 name_buf, sizeof (name_buf));
1006 if (stopped_by_random_signal)
1008 /* We stopped inside the FUNCTION because of a random
1009 signal. Further execution of the FUNCTION is not
1012 if (unwind_on_signal_p)
1014 /* The user wants the context restored. */
1016 /* We must get back to the frame we were before the
1018 dummy_frame_pop (dummy_id, call_thread_ptid);
1020 /* We also need to restore inferior status to that before the
1022 restore_infcall_control_state (inf_status);
1024 /* FIXME: Insert a bunch of wrap_here; name can be very
1025 long if it's a C++ name with arguments and stuff. */
1027 The program being debugged was signaled while in a function called from GDB.\n\
1028 GDB has restored the context to what it was before the call.\n\
1029 To change this behavior use \"set unwindonsignal off\".\n\
1030 Evaluation of the expression containing the function\n\
1031 (%s) will be abandoned."),
1036 /* The user wants to stay in the frame where we stopped
1038 Discard inferior status, we're not at the same point
1040 discard_infcall_control_state (inf_status);
1042 /* FIXME: Insert a bunch of wrap_here; name can be very
1043 long if it's a C++ name with arguments and stuff. */
1045 The program being debugged was signaled while in a function called from GDB.\n\
1046 GDB remains in the frame where the signal was received.\n\
1047 To change this behavior use \"set unwindonsignal on\".\n\
1048 Evaluation of the expression containing the function\n\
1049 (%s) will be abandoned.\n\
1050 When the function is done executing, GDB will silently stop."),
1055 if (stop_stack_dummy == STOP_STD_TERMINATE)
1057 /* We must get back to the frame we were before the dummy
1059 dummy_frame_pop (dummy_id, call_thread_ptid);
1061 /* We also need to restore inferior status to that before
1063 restore_infcall_control_state (inf_status);
1066 The program being debugged entered a std::terminate call, most likely\n\
1067 caused by an unhandled C++ exception. GDB blocked this call in order\n\
1068 to prevent the program from being terminated, and has restored the\n\
1069 context to its original state before the call.\n\
1070 To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
1071 Evaluation of the expression containing the function (%s)\n\
1072 will be abandoned."),
1075 else if (stop_stack_dummy == STOP_NONE)
1078 /* We hit a breakpoint inside the FUNCTION.
1079 Keep the dummy frame, the user may want to examine its state.
1080 Discard inferior status, we're not at the same point
1082 discard_infcall_control_state (inf_status);
1084 /* The following error message used to say "The expression
1085 which contained the function call has been discarded."
1086 It is a hard concept to explain in a few words. Ideally,
1087 GDB would be able to resume evaluation of the expression
1088 when the function finally is done executing. Perhaps
1089 someday this will be implemented (it would not be easy). */
1090 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1091 a C++ name with arguments and stuff. */
1093 The program being debugged stopped while in a function called from GDB.\n\
1094 Evaluation of the expression containing the function\n\
1095 (%s) will be abandoned.\n\
1096 When the function is done executing, GDB will silently stop."),
1100 /* The above code errors out, so ... */
1101 internal_error (__FILE__, __LINE__, _("... should not be here"));
1104 do_cleanups (terminate_bp_cleanup);
1106 /* If we get here the called FUNCTION ran to completion,
1107 and the dummy frame has already been popped. */
1110 struct address_space *aspace = get_regcache_aspace (stop_registers);
1111 struct regcache *retbuf = regcache_xmalloc (gdbarch, aspace);
1112 struct cleanup *retbuf_cleanup = make_cleanup_regcache_xfree (retbuf);
1113 struct value *retval = NULL;
1115 regcache_cpy_no_passthrough (retbuf, stop_registers);
1117 /* Inferior call is successful. Restore the inferior status.
1118 At this stage, leave the RETBUF alone. */
1119 restore_infcall_control_state (inf_status);
1121 if (TYPE_CODE (values_type) == TYPE_CODE_VOID)
1122 retval = allocate_value (values_type);
1123 else if (struct_return || hidden_first_param_p)
1125 if (stack_temporaries)
1127 retval = value_from_contents_and_address (values_type, NULL,
1129 push_thread_stack_temporary (inferior_ptid, retval);
1133 retval = allocate_value (values_type);
1134 read_value_memory (retval, 0, 1, struct_addr,
1135 value_contents_raw (retval),
1136 TYPE_LENGTH (values_type));
1141 retval = allocate_value (values_type);
1142 gdbarch_return_value (gdbarch, function, values_type,
1143 retbuf, value_contents_raw (retval), NULL);
1144 if (stack_temporaries && class_or_union_p (values_type))
1146 /* Values of class type returned in registers are copied onto
1147 the stack and their lval_type set to lval_memory. This is
1148 required because further evaluation of the expression
1149 could potentially invoke methods on the return value
1150 requiring GDB to evaluate the "this" pointer. To evaluate
1151 the this pointer, GDB needs the memory address of the
1153 value_force_lval (retval, struct_addr);
1154 push_thread_stack_temporary (inferior_ptid, retval);
1158 do_cleanups (retbuf_cleanup);
1160 gdb_assert (retval);
1166 /* Provide a prototype to silence -Wmissing-prototypes. */
1167 void _initialize_infcall (void);
1170 _initialize_infcall (void)
1172 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure,
1173 &coerce_float_to_double_p, _("\
1174 Set coercion of floats to doubles when calling functions."), _("\
1175 Show coercion of floats to doubles when calling functions"), _("\
1176 Variables of type float should generally be converted to doubles before\n\
1177 calling an unprototyped function, and left alone when calling a prototyped\n\
1178 function. However, some older debug info formats do not provide enough\n\
1179 information to determine that a function is prototyped. If this flag is\n\
1180 set, GDB will perform the conversion for a function it considers\n\
1182 The default is to perform the conversion.\n"),
1184 show_coerce_float_to_double_p,
1185 &setlist, &showlist);
1187 add_setshow_boolean_cmd ("unwindonsignal", no_class,
1188 &unwind_on_signal_p, _("\
1189 Set unwinding of stack if a signal is received while in a call dummy."), _("\
1190 Show unwinding of stack if a signal is received while in a call dummy."), _("\
1191 The unwindonsignal lets the user determine what gdb should do if a signal\n\
1192 is received while in a function called from gdb (call dummy). If set, gdb\n\
1193 unwinds the stack and restore the context to what as it was before the call.\n\
1194 The default is to stop in the frame where the signal was received."),
1196 show_unwind_on_signal_p,
1197 &setlist, &showlist);
1199 add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class,
1200 &unwind_on_terminating_exception_p, _("\
1201 Set unwinding of stack if std::terminate is called while in call dummy."), _("\
1202 Show unwinding of stack if std::terminate() is called while in a call dummy."),
1204 The unwind on terminating exception flag lets the user determine\n\
1205 what gdb should do if a std::terminate() call is made from the\n\
1206 default exception handler. If set, gdb unwinds the stack and restores\n\
1207 the context to what it was before the call. If unset, gdb allows the\n\
1208 std::terminate call to proceed.\n\
1209 The default is to unwind the frame."),
1211 show_unwind_on_terminating_exception_p,
1212 &setlist, &showlist);