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 ();
459 /* All this stuff with a dummy frame may seem unnecessarily complicated
460 (why not just save registers in GDB?). The purpose of pushing a dummy
461 frame which looks just like a real frame is so that if you call a
462 function and then hit a breakpoint (get a signal, etc), "backtrace"
463 will look right. Whether the backtrace needs to actually show the
464 stack at the time the inferior function was called is debatable, but
465 it certainly needs to not display garbage. So if you are contemplating
466 making dummy frames be different from normal frames, consider that. */
468 /* Perform a function call in the inferior.
469 ARGS is a vector of values of arguments (NARGS of them).
470 FUNCTION is a value, the function to be called.
471 Returns a value representing what the function returned.
472 May fail to return, if a breakpoint or signal is hit
473 during the execution of the function.
475 ARGS is modified to contain coerced values. */
478 call_function_by_hand (struct value *function, int nargs, struct value **args)
481 struct type *values_type, *target_values_type;
482 unsigned char struct_return = 0, hidden_first_param_p = 0;
483 CORE_ADDR struct_addr = 0;
484 struct infcall_control_state *inf_status;
485 struct cleanup *inf_status_cleanup;
486 struct infcall_suspend_state *caller_state;
489 struct type *ftype = check_typedef (value_type (function));
491 struct frame_id dummy_id;
492 struct cleanup *args_cleanup;
493 struct frame_info *frame;
494 struct gdbarch *gdbarch;
495 struct cleanup *terminate_bp_cleanup;
496 ptid_t call_thread_ptid;
497 struct gdb_exception e;
498 char name_buf[RAW_FUNCTION_ADDRESS_SIZE];
499 int stack_temporaries = thread_stack_temporaries_enabled_p (inferior_ptid);
501 if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
502 ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
504 if (!target_has_execution)
507 if (get_traceframe_number () >= 0)
508 error (_("May not call functions while looking at trace frames."));
510 if (execution_direction == EXEC_REVERSE)
511 error (_("Cannot call functions in reverse mode."));
513 frame = get_current_frame ();
514 gdbarch = get_frame_arch (frame);
516 if (!gdbarch_push_dummy_call_p (gdbarch))
517 error (_("This target does not support function calls."));
519 /* A cleanup for the inferior status.
520 This is only needed while we're preparing the inferior function call. */
521 inf_status = save_infcall_control_state ();
523 = make_cleanup_restore_infcall_control_state (inf_status);
525 /* Save the caller's registers and other state associated with the
526 inferior itself so that they can be restored once the
527 callee returns. To allow nested calls the registers are (further
528 down) pushed onto a dummy frame stack. Include a cleanup (which
529 is tossed once the regcache has been pushed). */
530 caller_state = save_infcall_suspend_state ();
531 make_cleanup_restore_infcall_suspend_state (caller_state);
533 /* Ensure that the initial SP is correctly aligned. */
535 CORE_ADDR old_sp = get_frame_sp (frame);
537 if (gdbarch_frame_align_p (gdbarch))
539 sp = gdbarch_frame_align (gdbarch, old_sp);
540 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
541 ABIs, a function can use memory beyond the inner most stack
542 address. AMD64 called that region the "red zone". Skip at
543 least the "red zone" size before allocating any space on
545 if (gdbarch_inner_than (gdbarch, 1, 2))
546 sp -= gdbarch_frame_red_zone_size (gdbarch);
548 sp += gdbarch_frame_red_zone_size (gdbarch);
550 gdb_assert (sp == gdbarch_frame_align (gdbarch, sp));
551 /* NOTE: cagney/2002-09-18:
553 On a RISC architecture, a void parameterless generic dummy
554 frame (i.e., no parameters, no result) typically does not
555 need to push anything the stack and hence can leave SP and
556 FP. Similarly, a frameless (possibly leaf) function does
557 not push anything on the stack and, hence, that too can
558 leave FP and SP unchanged. As a consequence, a sequence of
559 void parameterless generic dummy frame calls to frameless
560 functions will create a sequence of effectively identical
561 frames (SP, FP and TOS and PC the same). This, not
562 suprisingly, results in what appears to be a stack in an
563 infinite loop --- when GDB tries to find a generic dummy
564 frame on the internal dummy frame stack, it will always
567 To avoid this problem, the code below always grows the
568 stack. That way, two dummy frames can never be identical.
569 It does burn a few bytes of stack but that is a small price
573 if (gdbarch_inner_than (gdbarch, 1, 2))
574 /* Stack grows down. */
575 sp = gdbarch_frame_align (gdbarch, old_sp - 1);
577 /* Stack grows up. */
578 sp = gdbarch_frame_align (gdbarch, old_sp + 1);
580 /* SP may have underflown address zero here from OLD_SP. Memory access
581 functions will probably fail in such case but that is a target's
585 /* FIXME: cagney/2002-09-18: Hey, you loose!
587 Who knows how badly aligned the SP is!
589 If the generic dummy frame ends up empty (because nothing is
590 pushed) GDB won't be able to correctly perform back traces.
591 If a target is having trouble with backtraces, first thing to
592 do is add FRAME_ALIGN() to the architecture vector. If that
593 fails, try dummy_id().
595 If the ABI specifies a "Red Zone" (see the doco) the code
596 below will quietly trash it. */
599 /* Skip over the stack temporaries that might have been generated during
600 the evaluation of an expression. */
601 if (stack_temporaries)
603 struct value *lastval;
605 lastval = get_last_thread_stack_temporary (inferior_ptid);
608 CORE_ADDR lastval_addr = value_address (lastval);
610 if (gdbarch_inner_than (gdbarch, 1, 2))
612 gdb_assert (sp >= lastval_addr);
617 gdb_assert (sp <= lastval_addr);
618 sp = lastval_addr + TYPE_LENGTH (value_type (lastval));
621 if (gdbarch_frame_align_p (gdbarch))
622 sp = gdbarch_frame_align (gdbarch, sp);
627 funaddr = find_function_addr (function, &values_type);
629 values_type = builtin_type (gdbarch)->builtin_int;
631 CHECK_TYPEDEF (values_type);
633 /* Are we returning a value using a structure return (passing a
634 hidden argument pointing to storage) or a normal value return?
635 There are two cases: language-mandated structure return and
636 target ABI structure return. The variable STRUCT_RETURN only
637 describes the latter. The language version is handled by passing
638 the return location as the first parameter to the function,
639 even preceding "this". This is different from the target
640 ABI version, which is target-specific; for instance, on ia64
641 the first argument is passed in out0 but the hidden structure
642 return pointer would normally be passed in r8. */
644 if (gdbarch_return_in_first_hidden_param_p (gdbarch, values_type))
646 hidden_first_param_p = 1;
648 /* Tell the target specific argument pushing routine not to
650 target_values_type = builtin_type (gdbarch)->builtin_void;
654 struct_return = using_struct_return (gdbarch, function, values_type);
655 target_values_type = values_type;
658 observer_notify_inferior_call_pre (inferior_ptid, funaddr);
660 /* Determine the location of the breakpoint (and possibly other
661 stuff) that the called function will return to. The SPARC, for a
662 function returning a structure or union, needs to make space for
663 not just the breakpoint but also an extra word containing the
664 size (?) of the structure being passed. */
666 switch (gdbarch_call_dummy_location (gdbarch))
670 const gdb_byte *bp_bytes;
671 CORE_ADDR bp_addr_as_address;
674 /* Be careful BP_ADDR is in inferior PC encoding while
675 BP_ADDR_AS_ADDRESS is a plain memory address. */
677 sp = push_dummy_code (gdbarch, sp, funaddr, args, nargs,
678 target_values_type, &real_pc, &bp_addr,
679 get_current_regcache ());
681 /* Write a legitimate instruction at the point where the infcall
682 breakpoint is going to be inserted. While this instruction
683 is never going to be executed, a user investigating the
684 memory from GDB would see this instruction instead of random
685 uninitialized bytes. We chose the breakpoint instruction
686 as it may look as the most logical one to the user and also
687 valgrind 3.7.0 needs it for proper vgdb inferior calls.
689 If software breakpoints are unsupported for this target we
690 leave the user visible memory content uninitialized. */
692 bp_addr_as_address = bp_addr;
693 bp_bytes = gdbarch_breakpoint_from_pc (gdbarch, &bp_addr_as_address,
695 if (bp_bytes != NULL)
696 write_memory (bp_addr_as_address, bp_bytes, bp_size);
701 CORE_ADDR dummy_addr;
704 dummy_addr = entry_point_address ();
706 /* A call dummy always consists of just a single breakpoint, so
707 its address is the same as the address of the dummy.
709 The actual breakpoint is inserted separatly so there is no need to
711 bp_addr = dummy_addr;
715 internal_error (__FILE__, __LINE__, _("bad switch"));
718 if (nargs < TYPE_NFIELDS (ftype))
719 error (_("Too few arguments in function call."));
724 for (i = nargs - 1; i >= 0; i--)
727 struct type *param_type;
729 /* FIXME drow/2002-05-31: Should just always mark methods as
730 prototyped. Can we respect TYPE_VARARGS? Probably not. */
731 if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
733 else if (i < TYPE_NFIELDS (ftype))
734 prototyped = TYPE_PROTOTYPED (ftype);
738 if (i < TYPE_NFIELDS (ftype))
739 param_type = TYPE_FIELD_TYPE (ftype, i);
743 args[i] = value_arg_coerce (gdbarch, args[i],
744 param_type, prototyped, &sp);
746 if (param_type != NULL && language_pass_by_reference (param_type))
747 args[i] = value_addr (args[i]);
751 /* Reserve space for the return structure to be written on the
752 stack, if necessary. Make certain that the value is correctly
755 While evaluating expressions, we reserve space on the stack for
756 return values of class type even if the language ABI and the target
757 ABI do not require that the return value be passed as a hidden first
758 argument. This is because we want to store the return value as an
759 on-stack temporary while the expression is being evaluated. This
760 enables us to have chained function calls in expressions.
762 Keeping the return values as on-stack temporaries while the expression
763 is being evaluated is OK because the thread is stopped until the
764 expression is completely evaluated. */
766 if (struct_return || hidden_first_param_p
767 || (stack_temporaries && class_or_union_p (values_type)))
769 if (gdbarch_inner_than (gdbarch, 1, 2))
771 /* Stack grows downward. Align STRUCT_ADDR and SP after
772 making space for the return value. */
773 sp -= TYPE_LENGTH (values_type);
774 if (gdbarch_frame_align_p (gdbarch))
775 sp = gdbarch_frame_align (gdbarch, sp);
780 /* Stack grows upward. Align the frame, allocate space, and
781 then again, re-align the frame??? */
782 if (gdbarch_frame_align_p (gdbarch))
783 sp = gdbarch_frame_align (gdbarch, sp);
785 sp += TYPE_LENGTH (values_type);
786 if (gdbarch_frame_align_p (gdbarch))
787 sp = gdbarch_frame_align (gdbarch, sp);
791 if (hidden_first_param_p)
793 struct value **new_args;
795 /* Add the new argument to the front of the argument list. */
796 new_args = xmalloc (sizeof (struct value *) * (nargs + 1));
797 new_args[0] = value_from_pointer (lookup_pointer_type (values_type),
799 memcpy (&new_args[1], &args[0], sizeof (struct value *) * nargs);
802 args_cleanup = make_cleanup (xfree, args);
805 args_cleanup = make_cleanup (null_cleanup, NULL);
807 /* Create the dummy stack frame. Pass in the call dummy address as,
808 presumably, the ABI code knows where, in the call dummy, the
809 return address should be pointed. */
810 sp = gdbarch_push_dummy_call (gdbarch, function, get_current_regcache (),
811 bp_addr, nargs, args,
812 sp, struct_return, struct_addr);
814 do_cleanups (args_cleanup);
816 /* Set up a frame ID for the dummy frame so we can pass it to
817 set_momentary_breakpoint. We need to give the breakpoint a frame
818 ID so that the breakpoint code can correctly re-identify the
820 /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL,
821 saved as the dummy-frame TOS, and used by dummy_id to form
822 the frame ID's stack address. */
823 dummy_id = frame_id_build (sp, bp_addr);
825 /* Create a momentary breakpoint at the return address of the
826 inferior. That way it breaks when it returns. */
829 struct breakpoint *bpt, *longjmp_b;
830 struct symtab_and_line sal;
832 init_sal (&sal); /* initialize to zeroes */
833 sal.pspace = current_program_space;
835 sal.section = find_pc_overlay (sal.pc);
836 /* Sanity. The exact same SP value is returned by
837 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
838 dummy_id to form the frame ID's stack address. */
839 bpt = set_momentary_breakpoint (gdbarch, sal, dummy_id, bp_call_dummy);
841 /* set_momentary_breakpoint invalidates FRAME. */
844 bpt->disposition = disp_del;
845 gdb_assert (bpt->related_breakpoint == bpt);
847 longjmp_b = set_longjmp_breakpoint_for_call_dummy ();
850 /* Link BPT into the chain of LONGJMP_B. */
851 bpt->related_breakpoint = longjmp_b;
852 while (longjmp_b->related_breakpoint != bpt->related_breakpoint)
853 longjmp_b = longjmp_b->related_breakpoint;
854 longjmp_b->related_breakpoint = bpt;
858 /* Create a breakpoint in std::terminate.
859 If a C++ exception is raised in the dummy-frame, and the
860 exception handler is (normally, and expected to be) out-of-frame,
861 the default C++ handler will (wrongly) be called in an inferior
862 function call. This is wrong, as an exception can be normally
863 and legally handled out-of-frame. The confines of the dummy frame
864 prevent the unwinder from finding the correct handler (or any
865 handler, unless it is in-frame). The default handler calls
866 std::terminate. This will kill the inferior. Assert that
867 terminate should never be called in an inferior function
868 call. Place a momentary breakpoint in the std::terminate function
869 and if triggered in the call, rewind. */
870 if (unwind_on_terminating_exception_p)
871 set_std_terminate_breakpoint ();
873 /* Everything's ready, push all the info needed to restore the
874 caller (and identify the dummy-frame) onto the dummy-frame
876 dummy_frame_push (caller_state, &dummy_id, inferior_ptid);
878 /* Discard both inf_status and caller_state cleanups.
879 From this point on we explicitly restore the associated state
881 discard_cleanups (inf_status_cleanup);
883 /* Register a clean-up for unwind_on_terminating_exception_breakpoint. */
884 terminate_bp_cleanup = make_cleanup (cleanup_delete_std_terminate_breakpoint,
887 /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP -
888 If you're looking to implement asynchronous dummy-frames, then
889 just below is the place to chop this function in two.. */
891 /* TP is invalid after run_inferior_call returns, so enclose this
892 in a block so that it's only in scope during the time it's valid. */
894 struct thread_info *tp = inferior_thread ();
896 /* Save this thread's ptid, we need it later but the thread
898 call_thread_ptid = tp->ptid;
900 /* Run the inferior until it stops. */
902 e = run_inferior_call (tp, real_pc);
905 observer_notify_inferior_call_post (call_thread_ptid, funaddr);
907 /* Rethrow an error if we got one trying to run the inferior. */
911 const char *name = get_function_name (funaddr,
912 name_buf, sizeof (name_buf));
914 discard_infcall_control_state (inf_status);
916 /* We could discard the dummy frame here if the program exited,
917 but it will get garbage collected the next time the program is
923 throw_error (e.error, _("%s\n\
924 An error occurred while in a function called from GDB.\n\
925 Evaluation of the expression containing the function\n\
926 (%s) will be abandoned.\n\
927 When the function is done executing, GDB will silently stop."),
935 /* If the program has exited, or we stopped at a different thread,
936 exit and inform the user. */
938 if (! target_has_execution)
940 const char *name = get_function_name (funaddr,
941 name_buf, sizeof (name_buf));
943 /* If we try to restore the inferior status,
944 we'll crash as the inferior is no longer running. */
945 discard_infcall_control_state (inf_status);
947 /* We could discard the dummy frame here given that the program exited,
948 but it will get garbage collected the next time the program is
951 error (_("The program being debugged exited while in a function "
953 "Evaluation of the expression containing the function\n"
954 "(%s) will be abandoned."),
958 if (! ptid_equal (call_thread_ptid, inferior_ptid))
960 const char *name = get_function_name (funaddr,
961 name_buf, sizeof (name_buf));
963 /* We've switched threads. This can happen if another thread gets a
964 signal or breakpoint while our thread was running.
965 There's no point in restoring the inferior status,
966 we're in a different thread. */
967 discard_infcall_control_state (inf_status);
968 /* Keep the dummy frame record, if the user switches back to the
969 thread with the hand-call, we'll need it. */
970 if (stopped_by_random_signal)
972 The program received a signal in another thread while\n\
973 making a function call from GDB.\n\
974 Evaluation of the expression containing the function\n\
975 (%s) will be abandoned.\n\
976 When the function is done executing, GDB will silently stop."),
980 The program stopped in another thread while making a function call from GDB.\n\
981 Evaluation of the expression containing the function\n\
982 (%s) will be abandoned.\n\
983 When the function is done executing, GDB will silently stop."),
987 if (stopped_by_random_signal || stop_stack_dummy != STOP_STACK_DUMMY)
989 const char *name = get_function_name (funaddr,
990 name_buf, sizeof (name_buf));
992 if (stopped_by_random_signal)
994 /* We stopped inside the FUNCTION because of a random
995 signal. Further execution of the FUNCTION is not
998 if (unwind_on_signal_p)
1000 /* The user wants the context restored. */
1002 /* We must get back to the frame we were before the
1004 dummy_frame_pop (dummy_id, call_thread_ptid);
1006 /* We also need to restore inferior status to that before the
1008 restore_infcall_control_state (inf_status);
1010 /* FIXME: Insert a bunch of wrap_here; name can be very
1011 long if it's a C++ name with arguments and stuff. */
1013 The program being debugged was signaled while in a function called from GDB.\n\
1014 GDB has restored the context to what it was before the call.\n\
1015 To change this behavior use \"set unwindonsignal off\".\n\
1016 Evaluation of the expression containing the function\n\
1017 (%s) will be abandoned."),
1022 /* The user wants to stay in the frame where we stopped
1024 Discard inferior status, we're not at the same point
1026 discard_infcall_control_state (inf_status);
1028 /* FIXME: Insert a bunch of wrap_here; name can be very
1029 long if it's a C++ name with arguments and stuff. */
1031 The program being debugged was signaled while in a function called from GDB.\n\
1032 GDB remains in the frame where the signal was received.\n\
1033 To change this behavior use \"set unwindonsignal on\".\n\
1034 Evaluation of the expression containing the function\n\
1035 (%s) will be abandoned.\n\
1036 When the function is done executing, GDB will silently stop."),
1041 if (stop_stack_dummy == STOP_STD_TERMINATE)
1043 /* We must get back to the frame we were before the dummy
1045 dummy_frame_pop (dummy_id, call_thread_ptid);
1047 /* We also need to restore inferior status to that before
1049 restore_infcall_control_state (inf_status);
1052 The program being debugged entered a std::terminate call, most likely\n\
1053 caused by an unhandled C++ exception. GDB blocked this call in order\n\
1054 to prevent the program from being terminated, and has restored the\n\
1055 context to its original state before the call.\n\
1056 To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
1057 Evaluation of the expression containing the function (%s)\n\
1058 will be abandoned."),
1061 else if (stop_stack_dummy == STOP_NONE)
1064 /* We hit a breakpoint inside the FUNCTION.
1065 Keep the dummy frame, the user may want to examine its state.
1066 Discard inferior status, we're not at the same point
1068 discard_infcall_control_state (inf_status);
1070 /* The following error message used to say "The expression
1071 which contained the function call has been discarded."
1072 It is a hard concept to explain in a few words. Ideally,
1073 GDB would be able to resume evaluation of the expression
1074 when the function finally is done executing. Perhaps
1075 someday this will be implemented (it would not be easy). */
1076 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1077 a C++ name with arguments and stuff. */
1079 The program being debugged stopped while in a function called from GDB.\n\
1080 Evaluation of the expression containing the function\n\
1081 (%s) will be abandoned.\n\
1082 When the function is done executing, GDB will silently stop."),
1086 /* The above code errors out, so ... */
1087 internal_error (__FILE__, __LINE__, _("... should not be here"));
1090 do_cleanups (terminate_bp_cleanup);
1092 /* If we get here the called FUNCTION ran to completion,
1093 and the dummy frame has already been popped. */
1096 struct address_space *aspace = get_regcache_aspace (stop_registers);
1097 struct regcache *retbuf = regcache_xmalloc (gdbarch, aspace);
1098 struct cleanup *retbuf_cleanup = make_cleanup_regcache_xfree (retbuf);
1099 struct value *retval = NULL;
1101 regcache_cpy_no_passthrough (retbuf, stop_registers);
1103 /* Inferior call is successful. Restore the inferior status.
1104 At this stage, leave the RETBUF alone. */
1105 restore_infcall_control_state (inf_status);
1107 if (TYPE_CODE (values_type) == TYPE_CODE_VOID)
1108 retval = allocate_value (values_type);
1109 else if (struct_return || hidden_first_param_p)
1111 if (stack_temporaries)
1113 retval = value_from_contents_and_address (values_type, NULL,
1115 push_thread_stack_temporary (inferior_ptid, retval);
1119 retval = allocate_value (values_type);
1120 read_value_memory (retval, 0, 1, struct_addr,
1121 value_contents_raw (retval),
1122 TYPE_LENGTH (values_type));
1127 retval = allocate_value (values_type);
1128 gdbarch_return_value (gdbarch, function, values_type,
1129 retbuf, value_contents_raw (retval), NULL);
1130 if (stack_temporaries && class_or_union_p (values_type))
1132 /* Values of class type returned in registers are copied onto
1133 the stack and their lval_type set to lval_memory. This is
1134 required because further evaluation of the expression
1135 could potentially invoke methods on the return value
1136 requiring GDB to evaluate the "this" pointer. To evaluate
1137 the this pointer, GDB needs the memory address of the
1139 value_force_lval (retval, struct_addr);
1140 push_thread_stack_temporary (inferior_ptid, retval);
1144 do_cleanups (retbuf_cleanup);
1146 gdb_assert (retval);
1152 /* Provide a prototype to silence -Wmissing-prototypes. */
1153 void _initialize_infcall (void);
1156 _initialize_infcall (void)
1158 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure,
1159 &coerce_float_to_double_p, _("\
1160 Set coercion of floats to doubles when calling functions."), _("\
1161 Show coercion of floats to doubles when calling functions"), _("\
1162 Variables of type float should generally be converted to doubles before\n\
1163 calling an unprototyped function, and left alone when calling a prototyped\n\
1164 function. However, some older debug info formats do not provide enough\n\
1165 information to determine that a function is prototyped. If this flag is\n\
1166 set, GDB will perform the conversion for a function it considers\n\
1168 The default is to perform the conversion.\n"),
1170 show_coerce_float_to_double_p,
1171 &setlist, &showlist);
1173 add_setshow_boolean_cmd ("unwindonsignal", no_class,
1174 &unwind_on_signal_p, _("\
1175 Set unwinding of stack if a signal is received while in a call dummy."), _("\
1176 Show unwinding of stack if a signal is received while in a call dummy."), _("\
1177 The unwindonsignal lets the user determine what gdb should do if a signal\n\
1178 is received while in a function called from gdb (call dummy). If set, gdb\n\
1179 unwinds the stack and restore the context to what as it was before the call.\n\
1180 The default is to stop in the frame where the signal was received."),
1182 show_unwind_on_signal_p,
1183 &setlist, &showlist);
1185 add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class,
1186 &unwind_on_terminating_exception_p, _("\
1187 Set unwinding of stack if std::terminate is called while in call dummy."), _("\
1188 Show unwinding of stack if std::terminate() is called while in a call dummy."),
1190 The unwind on terminating exception flag lets the user determine\n\
1191 what gdb should do if a std::terminate() call is made from the\n\
1192 default exception handler. If set, gdb unwinds the stack and restores\n\
1193 the context to what it was before the call. If unset, gdb allows the\n\
1194 std::terminate call to proceed.\n\
1195 The default is to unwind the frame."),
1197 show_unwind_on_terminating_exception_p,
1198 &setlist, &showlist);