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"
39 /* If we can't find a function's name from its address,
40 we print this instead. */
41 #define RAW_FUNCTION_ADDRESS_FORMAT "at 0x%s"
42 #define RAW_FUNCTION_ADDRESS_SIZE (sizeof (RAW_FUNCTION_ADDRESS_FORMAT) \
43 + 2 * sizeof (CORE_ADDR))
45 /* NOTE: cagney/2003-04-16: What's the future of this code?
47 GDB needs an asynchronous expression evaluator, that means an
48 asynchronous inferior function call implementation, and that in
49 turn means restructuring the code so that it is event driven. */
51 /* How you should pass arguments to a function depends on whether it
52 was defined in K&R style or prototype style. If you define a
53 function using the K&R syntax that takes a `float' argument, then
54 callers must pass that argument as a `double'. If you define the
55 function using the prototype syntax, then you must pass the
56 argument as a `float', with no promotion.
58 Unfortunately, on certain older platforms, the debug info doesn't
59 indicate reliably how each function was defined. A function type's
60 TYPE_FLAG_PROTOTYPED flag may be clear, even if the function was
61 defined in prototype style. When calling a function whose
62 TYPE_FLAG_PROTOTYPED flag is clear, GDB consults this flag to
65 For modern targets, it is proper to assume that, if the prototype
66 flag is clear, that can be trusted: `float' arguments should be
67 promoted to `double'. For some older targets, if the prototype
68 flag is clear, that doesn't tell us anything. The default is to
69 trust the debug information; the user can override this behavior
70 with "set coerce-float-to-double 0". */
72 static int coerce_float_to_double_p = 1;
74 show_coerce_float_to_double_p (struct ui_file *file, int from_tty,
75 struct cmd_list_element *c, const char *value)
77 fprintf_filtered (file,
78 _("Coercion of floats to doubles "
79 "when calling functions is %s.\n"),
83 /* This boolean tells what gdb should do if a signal is received while
84 in a function called from gdb (call dummy). If set, gdb unwinds
85 the stack and restore the context to what as it was before the
88 The default is to stop in the frame where the signal was received. */
90 static int unwind_on_signal_p = 0;
92 show_unwind_on_signal_p (struct ui_file *file, int from_tty,
93 struct cmd_list_element *c, const char *value)
95 fprintf_filtered (file,
96 _("Unwinding of stack if a signal is "
97 "received while in a call dummy is %s.\n"),
101 /* This boolean tells what gdb should do if a std::terminate call is
102 made while in a function called from gdb (call dummy).
103 As the confines of a single dummy stack prohibit out-of-frame
104 handlers from handling a raised exception, and as out-of-frame
105 handlers are common in C++, this can lead to no handler being found
106 by the unwinder, and a std::terminate call. This is a false positive.
107 If set, gdb unwinds the stack and restores the context to what it
110 The default is to unwind the frame if a std::terminate call is
113 static int unwind_on_terminating_exception_p = 1;
116 show_unwind_on_terminating_exception_p (struct ui_file *file, int from_tty,
117 struct cmd_list_element *c,
121 fprintf_filtered (file,
122 _("Unwind stack if a C++ exception is "
123 "unhandled while in a call dummy is %s.\n"),
127 /* Perform the standard coercions that are specified
128 for arguments to be passed to C or Ada functions.
130 If PARAM_TYPE is non-NULL, it is the expected parameter type.
131 IS_PROTOTYPED is non-zero if the function declaration is prototyped.
132 SP is the stack pointer were additional data can be pushed (updating
133 its value as needed). */
135 static struct value *
136 value_arg_coerce (struct gdbarch *gdbarch, struct value *arg,
137 struct type *param_type, int is_prototyped, CORE_ADDR *sp)
139 const struct builtin_type *builtin = builtin_type (gdbarch);
140 struct type *arg_type = check_typedef (value_type (arg));
142 = param_type ? check_typedef (param_type) : arg_type;
144 /* Perform any Ada-specific coercion first. */
145 if (current_language->la_language == language_ada)
146 arg = ada_convert_actual (arg, type);
148 /* Force the value to the target if we will need its address. At
149 this point, we could allocate arguments on the stack instead of
150 calling malloc if we knew that their addresses would not be
151 saved by the called function. */
152 arg = value_coerce_to_target (arg);
154 switch (TYPE_CODE (type))
158 struct value *new_value;
160 if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
161 return value_cast_pointers (type, arg, 0);
163 /* Cast the value to the reference's target type, and then
164 convert it back to a reference. This will issue an error
165 if the value was not previously in memory - in some cases
166 we should clearly be allowing this, but how? */
167 new_value = value_cast (TYPE_TARGET_TYPE (type), arg);
168 new_value = value_ref (new_value);
175 /* If we don't have a prototype, coerce to integer type if necessary. */
178 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_int))
179 type = builtin->builtin_int;
181 /* Currently all target ABIs require at least the width of an integer
182 type for an argument. We may have to conditionalize the following
183 type coercion for future targets. */
184 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_int))
185 type = builtin->builtin_int;
188 if (!is_prototyped && coerce_float_to_double_p)
190 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_double))
191 type = builtin->builtin_double;
192 else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin->builtin_double))
193 type = builtin->builtin_long_double;
197 type = lookup_pointer_type (type);
199 case TYPE_CODE_ARRAY:
200 /* Arrays are coerced to pointers to their first element, unless
201 they are vectors, in which case we want to leave them alone,
202 because they are passed by value. */
203 if (current_language->c_style_arrays)
204 if (!TYPE_VECTOR (type))
205 type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
207 case TYPE_CODE_UNDEF:
209 case TYPE_CODE_STRUCT:
210 case TYPE_CODE_UNION:
213 case TYPE_CODE_RANGE:
214 case TYPE_CODE_STRING:
215 case TYPE_CODE_ERROR:
216 case TYPE_CODE_MEMBERPTR:
217 case TYPE_CODE_METHODPTR:
218 case TYPE_CODE_METHOD:
219 case TYPE_CODE_COMPLEX:
224 return value_cast (type, arg);
227 /* Return the return type of a function with its first instruction exactly at
228 the PC address. Return NULL otherwise. */
231 find_function_return_type (CORE_ADDR pc)
233 struct symbol *sym = find_pc_function (pc);
235 if (sym != NULL && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) == pc
236 && SYMBOL_TYPE (sym) != NULL)
237 return TYPE_TARGET_TYPE (SYMBOL_TYPE (sym));
242 /* Determine a function's address and its return type from its value.
243 Calls error() if the function is not valid for calling. */
246 find_function_addr (struct value *function, struct type **retval_type)
248 struct type *ftype = check_typedef (value_type (function));
249 struct gdbarch *gdbarch = get_type_arch (ftype);
250 struct type *value_type = NULL;
251 /* Initialize it just to avoid a GCC false warning. */
252 CORE_ADDR funaddr = 0;
254 /* If it's a member function, just look at the function
257 /* Determine address to call. */
258 if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
259 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
260 funaddr = value_address (function);
261 else if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
263 funaddr = value_as_address (function);
264 ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
265 if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
266 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
267 funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr,
270 if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
271 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
273 value_type = TYPE_TARGET_TYPE (ftype);
275 if (TYPE_GNU_IFUNC (ftype))
277 funaddr = gnu_ifunc_resolve_addr (gdbarch, funaddr);
279 /* Skip querying the function symbol if no RETVAL_TYPE has been
282 value_type = find_function_return_type (funaddr);
285 else if (TYPE_CODE (ftype) == TYPE_CODE_INT)
287 /* Handle the case of functions lacking debugging info.
288 Their values are characters since their addresses are char. */
289 if (TYPE_LENGTH (ftype) == 1)
290 funaddr = value_as_address (value_addr (function));
293 /* Handle function descriptors lacking debug info. */
294 int found_descriptor = 0;
296 funaddr = 0; /* pacify "gcc -Werror" */
297 if (VALUE_LVAL (function) == lval_memory)
301 funaddr = value_as_address (value_addr (function));
303 funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr,
305 if (funaddr != nfunaddr)
306 found_descriptor = 1;
308 if (!found_descriptor)
309 /* Handle integer used as address of a function. */
310 funaddr = (CORE_ADDR) value_as_long (function);
314 error (_("Invalid data type for function to be called."));
316 if (retval_type != NULL)
317 *retval_type = value_type;
318 return funaddr + gdbarch_deprecated_function_start_offset (gdbarch);
321 /* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called
322 function returns to. */
325 push_dummy_code (struct gdbarch *gdbarch,
326 CORE_ADDR sp, CORE_ADDR funaddr,
327 struct value **args, int nargs,
328 struct type *value_type,
329 CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
330 struct regcache *regcache)
332 gdb_assert (gdbarch_push_dummy_code_p (gdbarch));
334 return gdbarch_push_dummy_code (gdbarch, sp, funaddr,
335 args, nargs, value_type, real_pc, bp_addr,
339 /* Fetch the name of the function at FUNADDR.
340 This is used in printing an error message for call_function_by_hand.
341 BUF is used to print FUNADDR in hex if the function name cannot be
342 determined. It must be large enough to hold formatted result of
343 RAW_FUNCTION_ADDRESS_FORMAT. */
346 get_function_name (CORE_ADDR funaddr, char *buf, int buf_size)
349 struct symbol *symbol = find_pc_function (funaddr);
352 return SYMBOL_PRINT_NAME (symbol);
356 /* Try the minimal symbols. */
357 struct bound_minimal_symbol msymbol = lookup_minimal_symbol_by_pc (funaddr);
360 return MSYMBOL_PRINT_NAME (msymbol.minsym);
364 char *tmp = xstrprintf (_(RAW_FUNCTION_ADDRESS_FORMAT),
365 hex_string (funaddr));
367 gdb_assert (strlen (tmp) + 1 <= buf_size);
374 /* Subroutine of call_function_by_hand to simplify it.
375 Start up the inferior and wait for it to stop.
376 Return the exception if there's an error, or an exception with
377 reason >= 0 if there's no error.
379 This is done inside a TRY_CATCH so the caller needn't worry about
380 thrown errors. The caller should rethrow if there's an error. */
382 static struct gdb_exception
383 run_inferior_call (struct thread_info *call_thread, CORE_ADDR real_pc)
385 volatile struct gdb_exception e;
386 int saved_in_infcall = call_thread->control.in_infcall;
387 ptid_t call_thread_ptid = call_thread->ptid;
388 int saved_sync_execution = sync_execution;
390 /* Infcalls run synchronously, in the foreground. */
391 if (target_can_async_p ())
394 call_thread->control.in_infcall = 1;
396 clear_proceed_status (0);
398 disable_watchpoints_before_interactive_call_start ();
400 /* We want stop_registers, please... */
401 call_thread->control.proceed_to_finish = 1;
403 TRY_CATCH (e, RETURN_MASK_ALL)
405 int was_sync = sync_execution;
407 proceed (real_pc, GDB_SIGNAL_0, 0);
409 /* Inferior function calls are always synchronous, even if the
410 target supports asynchronous execution. Do here what
411 `proceed' itself does in sync mode. */
412 if (target_can_async_p ())
414 wait_for_inferior ();
416 /* If GDB was previously in sync execution mode, then ensure
417 that it remains so. normal_stop calls
418 async_enable_stdin, so reset it again here. In other
419 cases, stdin will be re-enabled by
420 inferior_event_handler, when an exception is thrown. */
422 async_disable_stdin ();
426 /* At this point the current thread may have changed. Refresh
427 CALL_THREAD as it could be invalid if its thread has exited. */
428 call_thread = find_thread_ptid (call_thread_ptid);
430 enable_watchpoints_after_interactive_call_stop ();
432 /* Call breakpoint_auto_delete on the current contents of the bpstat
433 of inferior call thread.
434 If all error()s out of proceed ended up calling normal_stop
435 (and perhaps they should; it already does in the special case
436 of error out of resume()), then we wouldn't need this. */
439 if (call_thread != NULL)
440 breakpoint_auto_delete (call_thread->control.stop_bpstat);
443 if (call_thread != NULL)
444 call_thread->control.in_infcall = saved_in_infcall;
446 sync_execution = saved_sync_execution;
451 /* A cleanup function that calls delete_std_terminate_breakpoint. */
453 cleanup_delete_std_terminate_breakpoint (void *ignore)
455 delete_std_terminate_breakpoint ();
458 /* All this stuff with a dummy frame may seem unnecessarily complicated
459 (why not just save registers in GDB?). The purpose of pushing a dummy
460 frame which looks just like a real frame is so that if you call a
461 function and then hit a breakpoint (get a signal, etc), "backtrace"
462 will look right. Whether the backtrace needs to actually show the
463 stack at the time the inferior function was called is debatable, but
464 it certainly needs to not display garbage. So if you are contemplating
465 making dummy frames be different from normal frames, consider that. */
467 /* Perform a function call in the inferior.
468 ARGS is a vector of values of arguments (NARGS of them).
469 FUNCTION is a value, the function to be called.
470 Returns a value representing what the function returned.
471 May fail to return, if a breakpoint or signal is hit
472 during the execution of the function.
474 ARGS is modified to contain coerced values. */
477 call_function_by_hand (struct value *function, int nargs, struct value **args)
480 struct type *values_type, *target_values_type;
481 unsigned char struct_return = 0, hidden_first_param_p = 0;
482 CORE_ADDR struct_addr = 0;
483 struct infcall_control_state *inf_status;
484 struct cleanup *inf_status_cleanup;
485 struct infcall_suspend_state *caller_state;
488 struct type *ftype = check_typedef (value_type (function));
490 struct frame_id dummy_id;
491 struct cleanup *args_cleanup;
492 struct frame_info *frame;
493 struct gdbarch *gdbarch;
494 struct cleanup *terminate_bp_cleanup;
495 ptid_t call_thread_ptid;
496 struct gdb_exception e;
497 char name_buf[RAW_FUNCTION_ADDRESS_SIZE];
499 if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
500 ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
502 if (!target_has_execution)
505 if (get_traceframe_number () >= 0)
506 error (_("May not call functions while looking at trace frames."));
508 if (execution_direction == EXEC_REVERSE)
509 error (_("Cannot call functions in reverse mode."));
511 frame = get_current_frame ();
512 gdbarch = get_frame_arch (frame);
514 if (!gdbarch_push_dummy_call_p (gdbarch))
515 error (_("This target does not support function calls."));
517 /* A cleanup for the inferior status.
518 This is only needed while we're preparing the inferior function call. */
519 inf_status = save_infcall_control_state ();
521 = make_cleanup_restore_infcall_control_state (inf_status);
523 /* Save the caller's registers and other state associated with the
524 inferior itself so that they can be restored once the
525 callee returns. To allow nested calls the registers are (further
526 down) pushed onto a dummy frame stack. Include a cleanup (which
527 is tossed once the regcache has been pushed). */
528 caller_state = save_infcall_suspend_state ();
529 make_cleanup_restore_infcall_suspend_state (caller_state);
531 /* Ensure that the initial SP is correctly aligned. */
533 CORE_ADDR old_sp = get_frame_sp (frame);
535 if (gdbarch_frame_align_p (gdbarch))
537 sp = gdbarch_frame_align (gdbarch, old_sp);
538 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
539 ABIs, a function can use memory beyond the inner most stack
540 address. AMD64 called that region the "red zone". Skip at
541 least the "red zone" size before allocating any space on
543 if (gdbarch_inner_than (gdbarch, 1, 2))
544 sp -= gdbarch_frame_red_zone_size (gdbarch);
546 sp += gdbarch_frame_red_zone_size (gdbarch);
548 gdb_assert (sp == gdbarch_frame_align (gdbarch, sp));
549 /* NOTE: cagney/2002-09-18:
551 On a RISC architecture, a void parameterless generic dummy
552 frame (i.e., no parameters, no result) typically does not
553 need to push anything the stack and hence can leave SP and
554 FP. Similarly, a frameless (possibly leaf) function does
555 not push anything on the stack and, hence, that too can
556 leave FP and SP unchanged. As a consequence, a sequence of
557 void parameterless generic dummy frame calls to frameless
558 functions will create a sequence of effectively identical
559 frames (SP, FP and TOS and PC the same). This, not
560 suprisingly, results in what appears to be a stack in an
561 infinite loop --- when GDB tries to find a generic dummy
562 frame on the internal dummy frame stack, it will always
565 To avoid this problem, the code below always grows the
566 stack. That way, two dummy frames can never be identical.
567 It does burn a few bytes of stack but that is a small price
571 if (gdbarch_inner_than (gdbarch, 1, 2))
572 /* Stack grows down. */
573 sp = gdbarch_frame_align (gdbarch, old_sp - 1);
575 /* Stack grows up. */
576 sp = gdbarch_frame_align (gdbarch, old_sp + 1);
578 /* SP may have underflown address zero here from OLD_SP. Memory access
579 functions will probably fail in such case but that is a target's
583 /* FIXME: cagney/2002-09-18: Hey, you loose!
585 Who knows how badly aligned the SP is!
587 If the generic dummy frame ends up empty (because nothing is
588 pushed) GDB won't be able to correctly perform back traces.
589 If a target is having trouble with backtraces, first thing to
590 do is add FRAME_ALIGN() to the architecture vector. If that
591 fails, try dummy_id().
593 If the ABI specifies a "Red Zone" (see the doco) the code
594 below will quietly trash it. */
598 funaddr = find_function_addr (function, &values_type);
600 values_type = builtin_type (gdbarch)->builtin_int;
602 CHECK_TYPEDEF (values_type);
604 /* Are we returning a value using a structure return (passing a
605 hidden argument pointing to storage) or a normal value return?
606 There are two cases: language-mandated structure return and
607 target ABI structure return. The variable STRUCT_RETURN only
608 describes the latter. The language version is handled by passing
609 the return location as the first parameter to the function,
610 even preceding "this". This is different from the target
611 ABI version, which is target-specific; for instance, on ia64
612 the first argument is passed in out0 but the hidden structure
613 return pointer would normally be passed in r8. */
615 if (gdbarch_return_in_first_hidden_param_p (gdbarch, values_type))
617 hidden_first_param_p = 1;
619 /* Tell the target specific argument pushing routine not to
621 target_values_type = builtin_type (gdbarch)->builtin_void;
625 struct_return = using_struct_return (gdbarch, function, values_type);
626 target_values_type = values_type;
629 /* Determine the location of the breakpoint (and possibly other
630 stuff) that the called function will return to. The SPARC, for a
631 function returning a structure or union, needs to make space for
632 not just the breakpoint but also an extra word containing the
633 size (?) of the structure being passed. */
635 switch (gdbarch_call_dummy_location (gdbarch))
639 const gdb_byte *bp_bytes;
640 CORE_ADDR bp_addr_as_address;
643 /* Be careful BP_ADDR is in inferior PC encoding while
644 BP_ADDR_AS_ADDRESS is a plain memory address. */
646 sp = push_dummy_code (gdbarch, sp, funaddr, args, nargs,
647 target_values_type, &real_pc, &bp_addr,
648 get_current_regcache ());
650 /* Write a legitimate instruction at the point where the infcall
651 breakpoint is going to be inserted. While this instruction
652 is never going to be executed, a user investigating the
653 memory from GDB would see this instruction instead of random
654 uninitialized bytes. We chose the breakpoint instruction
655 as it may look as the most logical one to the user and also
656 valgrind 3.7.0 needs it for proper vgdb inferior calls.
658 If software breakpoints are unsupported for this target we
659 leave the user visible memory content uninitialized. */
661 bp_addr_as_address = bp_addr;
662 bp_bytes = gdbarch_breakpoint_from_pc (gdbarch, &bp_addr_as_address,
664 if (bp_bytes != NULL)
665 write_memory (bp_addr_as_address, bp_bytes, bp_size);
670 CORE_ADDR dummy_addr;
673 dummy_addr = entry_point_address ();
675 /* A call dummy always consists of just a single breakpoint, so
676 its address is the same as the address of the dummy.
678 The actual breakpoint is inserted separatly so there is no need to
680 bp_addr = dummy_addr;
684 internal_error (__FILE__, __LINE__, _("bad switch"));
687 if (nargs < TYPE_NFIELDS (ftype))
688 error (_("Too few arguments in function call."));
693 for (i = nargs - 1; i >= 0; i--)
696 struct type *param_type;
698 /* FIXME drow/2002-05-31: Should just always mark methods as
699 prototyped. Can we respect TYPE_VARARGS? Probably not. */
700 if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
702 else if (i < TYPE_NFIELDS (ftype))
703 prototyped = TYPE_PROTOTYPED (ftype);
707 if (i < TYPE_NFIELDS (ftype))
708 param_type = TYPE_FIELD_TYPE (ftype, i);
712 args[i] = value_arg_coerce (gdbarch, args[i],
713 param_type, prototyped, &sp);
715 if (param_type != NULL && language_pass_by_reference (param_type))
716 args[i] = value_addr (args[i]);
720 /* Reserve space for the return structure to be written on the
721 stack, if necessary. Make certain that the value is correctly
724 if (struct_return || hidden_first_param_p)
726 if (gdbarch_inner_than (gdbarch, 1, 2))
728 /* Stack grows downward. Align STRUCT_ADDR and SP after
729 making space for the return value. */
730 sp -= TYPE_LENGTH (values_type);
731 if (gdbarch_frame_align_p (gdbarch))
732 sp = gdbarch_frame_align (gdbarch, sp);
737 /* Stack grows upward. Align the frame, allocate space, and
738 then again, re-align the frame??? */
739 if (gdbarch_frame_align_p (gdbarch))
740 sp = gdbarch_frame_align (gdbarch, sp);
742 sp += TYPE_LENGTH (values_type);
743 if (gdbarch_frame_align_p (gdbarch))
744 sp = gdbarch_frame_align (gdbarch, sp);
748 if (hidden_first_param_p)
750 struct value **new_args;
752 /* Add the new argument to the front of the argument list. */
753 new_args = xmalloc (sizeof (struct value *) * (nargs + 1));
754 new_args[0] = value_from_pointer (lookup_pointer_type (values_type),
756 memcpy (&new_args[1], &args[0], sizeof (struct value *) * nargs);
759 args_cleanup = make_cleanup (xfree, args);
762 args_cleanup = make_cleanup (null_cleanup, NULL);
764 /* Create the dummy stack frame. Pass in the call dummy address as,
765 presumably, the ABI code knows where, in the call dummy, the
766 return address should be pointed. */
767 sp = gdbarch_push_dummy_call (gdbarch, function, get_current_regcache (),
768 bp_addr, nargs, args,
769 sp, struct_return, struct_addr);
771 do_cleanups (args_cleanup);
773 /* Set up a frame ID for the dummy frame so we can pass it to
774 set_momentary_breakpoint. We need to give the breakpoint a frame
775 ID so that the breakpoint code can correctly re-identify the
777 /* Sanity. The exact same SP value is returned by PUSH_DUMMY_CALL,
778 saved as the dummy-frame TOS, and used by dummy_id to form
779 the frame ID's stack address. */
780 dummy_id = frame_id_build (sp, bp_addr);
782 /* Create a momentary breakpoint at the return address of the
783 inferior. That way it breaks when it returns. */
786 struct breakpoint *bpt, *longjmp_b;
787 struct symtab_and_line sal;
789 init_sal (&sal); /* initialize to zeroes */
790 sal.pspace = current_program_space;
792 sal.section = find_pc_overlay (sal.pc);
793 /* Sanity. The exact same SP value is returned by
794 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
795 dummy_id to form the frame ID's stack address. */
796 bpt = set_momentary_breakpoint (gdbarch, sal, dummy_id, bp_call_dummy);
798 /* set_momentary_breakpoint invalidates FRAME. */
801 bpt->disposition = disp_del;
802 gdb_assert (bpt->related_breakpoint == bpt);
804 longjmp_b = set_longjmp_breakpoint_for_call_dummy ();
807 /* Link BPT into the chain of LONGJMP_B. */
808 bpt->related_breakpoint = longjmp_b;
809 while (longjmp_b->related_breakpoint != bpt->related_breakpoint)
810 longjmp_b = longjmp_b->related_breakpoint;
811 longjmp_b->related_breakpoint = bpt;
815 /* Create a breakpoint in std::terminate.
816 If a C++ exception is raised in the dummy-frame, and the
817 exception handler is (normally, and expected to be) out-of-frame,
818 the default C++ handler will (wrongly) be called in an inferior
819 function call. This is wrong, as an exception can be normally
820 and legally handled out-of-frame. The confines of the dummy frame
821 prevent the unwinder from finding the correct handler (or any
822 handler, unless it is in-frame). The default handler calls
823 std::terminate. This will kill the inferior. Assert that
824 terminate should never be called in an inferior function
825 call. Place a momentary breakpoint in the std::terminate function
826 and if triggered in the call, rewind. */
827 if (unwind_on_terminating_exception_p)
828 set_std_terminate_breakpoint ();
830 /* Everything's ready, push all the info needed to restore the
831 caller (and identify the dummy-frame) onto the dummy-frame
833 dummy_frame_push (caller_state, &dummy_id, inferior_ptid);
835 /* Discard both inf_status and caller_state cleanups.
836 From this point on we explicitly restore the associated state
838 discard_cleanups (inf_status_cleanup);
840 /* Register a clean-up for unwind_on_terminating_exception_breakpoint. */
841 terminate_bp_cleanup = make_cleanup (cleanup_delete_std_terminate_breakpoint,
844 /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP -
845 If you're looking to implement asynchronous dummy-frames, then
846 just below is the place to chop this function in two.. */
848 /* TP is invalid after run_inferior_call returns, so enclose this
849 in a block so that it's only in scope during the time it's valid. */
851 struct thread_info *tp = inferior_thread ();
853 /* Save this thread's ptid, we need it later but the thread
855 call_thread_ptid = tp->ptid;
857 /* Run the inferior until it stops. */
859 e = run_inferior_call (tp, real_pc);
862 /* Rethrow an error if we got one trying to run the inferior. */
866 const char *name = get_function_name (funaddr,
867 name_buf, sizeof (name_buf));
869 discard_infcall_control_state (inf_status);
871 /* We could discard the dummy frame here if the program exited,
872 but it will get garbage collected the next time the program is
878 throw_error (e.error, _("%s\n\
879 An error occurred while in a function called from GDB.\n\
880 Evaluation of the expression containing the function\n\
881 (%s) will be abandoned.\n\
882 When the function is done executing, GDB will silently stop."),
890 /* If the program has exited, or we stopped at a different thread,
891 exit and inform the user. */
893 if (! target_has_execution)
895 const char *name = get_function_name (funaddr,
896 name_buf, sizeof (name_buf));
898 /* If we try to restore the inferior status,
899 we'll crash as the inferior is no longer running. */
900 discard_infcall_control_state (inf_status);
902 /* We could discard the dummy frame here given that the program exited,
903 but it will get garbage collected the next time the program is
906 error (_("The program being debugged exited while in a function "
908 "Evaluation of the expression containing the function\n"
909 "(%s) will be abandoned."),
913 if (! ptid_equal (call_thread_ptid, inferior_ptid))
915 const char *name = get_function_name (funaddr,
916 name_buf, sizeof (name_buf));
918 /* We've switched threads. This can happen if another thread gets a
919 signal or breakpoint while our thread was running.
920 There's no point in restoring the inferior status,
921 we're in a different thread. */
922 discard_infcall_control_state (inf_status);
923 /* Keep the dummy frame record, if the user switches back to the
924 thread with the hand-call, we'll need it. */
925 if (stopped_by_random_signal)
927 The program received a signal in another thread while\n\
928 making a function call from GDB.\n\
929 Evaluation of the expression containing the function\n\
930 (%s) will be abandoned.\n\
931 When the function is done executing, GDB will silently stop."),
935 The program stopped in another thread while making a function call from GDB.\n\
936 Evaluation of the expression containing the function\n\
937 (%s) will be abandoned.\n\
938 When the function is done executing, GDB will silently stop."),
942 if (stopped_by_random_signal || stop_stack_dummy != STOP_STACK_DUMMY)
944 const char *name = get_function_name (funaddr,
945 name_buf, sizeof (name_buf));
947 if (stopped_by_random_signal)
949 /* We stopped inside the FUNCTION because of a random
950 signal. Further execution of the FUNCTION is not
953 if (unwind_on_signal_p)
955 /* The user wants the context restored. */
957 /* We must get back to the frame we were before the
959 dummy_frame_pop (dummy_id, call_thread_ptid);
961 /* We also need to restore inferior status to that before the
963 restore_infcall_control_state (inf_status);
965 /* FIXME: Insert a bunch of wrap_here; name can be very
966 long if it's a C++ name with arguments and stuff. */
968 The program being debugged was signaled while in a function called from GDB.\n\
969 GDB has restored the context to what it was before the call.\n\
970 To change this behavior use \"set unwindonsignal off\".\n\
971 Evaluation of the expression containing the function\n\
972 (%s) will be abandoned."),
977 /* The user wants to stay in the frame where we stopped
979 Discard inferior status, we're not at the same point
981 discard_infcall_control_state (inf_status);
983 /* FIXME: Insert a bunch of wrap_here; name can be very
984 long if it's a C++ name with arguments and stuff. */
986 The program being debugged was signaled while in a function called from GDB.\n\
987 GDB remains in the frame where the signal was received.\n\
988 To change this behavior use \"set unwindonsignal on\".\n\
989 Evaluation of the expression containing the function\n\
990 (%s) will be abandoned.\n\
991 When the function is done executing, GDB will silently stop."),
996 if (stop_stack_dummy == STOP_STD_TERMINATE)
998 /* We must get back to the frame we were before the dummy
1000 dummy_frame_pop (dummy_id, call_thread_ptid);
1002 /* We also need to restore inferior status to that before
1004 restore_infcall_control_state (inf_status);
1007 The program being debugged entered a std::terminate call, most likely\n\
1008 caused by an unhandled C++ exception. GDB blocked this call in order\n\
1009 to prevent the program from being terminated, and has restored the\n\
1010 context to its original state before the call.\n\
1011 To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
1012 Evaluation of the expression containing the function (%s)\n\
1013 will be abandoned."),
1016 else if (stop_stack_dummy == STOP_NONE)
1019 /* We hit a breakpoint inside the FUNCTION.
1020 Keep the dummy frame, the user may want to examine its state.
1021 Discard inferior status, we're not at the same point
1023 discard_infcall_control_state (inf_status);
1025 /* The following error message used to say "The expression
1026 which contained the function call has been discarded."
1027 It is a hard concept to explain in a few words. Ideally,
1028 GDB would be able to resume evaluation of the expression
1029 when the function finally is done executing. Perhaps
1030 someday this will be implemented (it would not be easy). */
1031 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1032 a C++ name with arguments and stuff. */
1034 The program being debugged stopped while in a function called from GDB.\n\
1035 Evaluation of the expression containing the function\n\
1036 (%s) will be abandoned.\n\
1037 When the function is done executing, GDB will silently stop."),
1041 /* The above code errors out, so ... */
1042 internal_error (__FILE__, __LINE__, _("... should not be here"));
1045 do_cleanups (terminate_bp_cleanup);
1047 /* If we get here the called FUNCTION ran to completion,
1048 and the dummy frame has already been popped. */
1051 struct address_space *aspace = get_regcache_aspace (stop_registers);
1052 struct regcache *retbuf = regcache_xmalloc (gdbarch, aspace);
1053 struct cleanup *retbuf_cleanup = make_cleanup_regcache_xfree (retbuf);
1054 struct value *retval = NULL;
1056 regcache_cpy_no_passthrough (retbuf, stop_registers);
1058 /* Inferior call is successful. Restore the inferior status.
1059 At this stage, leave the RETBUF alone. */
1060 restore_infcall_control_state (inf_status);
1062 /* Figure out the value returned by the function. */
1063 retval = allocate_value (values_type);
1065 if (hidden_first_param_p)
1066 read_value_memory (retval, 0, 1, struct_addr,
1067 value_contents_raw (retval),
1068 TYPE_LENGTH (values_type));
1069 else if (TYPE_CODE (target_values_type) != TYPE_CODE_VOID)
1071 /* If the function returns void, don't bother fetching the
1073 switch (gdbarch_return_value (gdbarch, function, target_values_type,
1076 case RETURN_VALUE_REGISTER_CONVENTION:
1077 case RETURN_VALUE_ABI_RETURNS_ADDRESS:
1078 case RETURN_VALUE_ABI_PRESERVES_ADDRESS:
1079 gdbarch_return_value (gdbarch, function, values_type,
1080 retbuf, value_contents_raw (retval), NULL);
1082 case RETURN_VALUE_STRUCT_CONVENTION:
1083 read_value_memory (retval, 0, 1, struct_addr,
1084 value_contents_raw (retval),
1085 TYPE_LENGTH (values_type));
1090 do_cleanups (retbuf_cleanup);
1092 gdb_assert (retval);
1098 /* Provide a prototype to silence -Wmissing-prototypes. */
1099 void _initialize_infcall (void);
1102 _initialize_infcall (void)
1104 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure,
1105 &coerce_float_to_double_p, _("\
1106 Set coercion of floats to doubles when calling functions."), _("\
1107 Show coercion of floats to doubles when calling functions"), _("\
1108 Variables of type float should generally be converted to doubles before\n\
1109 calling an unprototyped function, and left alone when calling a prototyped\n\
1110 function. However, some older debug info formats do not provide enough\n\
1111 information to determine that a function is prototyped. If this flag is\n\
1112 set, GDB will perform the conversion for a function it considers\n\
1114 The default is to perform the conversion.\n"),
1116 show_coerce_float_to_double_p,
1117 &setlist, &showlist);
1119 add_setshow_boolean_cmd ("unwindonsignal", no_class,
1120 &unwind_on_signal_p, _("\
1121 Set unwinding of stack if a signal is received while in a call dummy."), _("\
1122 Show unwinding of stack if a signal is received while in a call dummy."), _("\
1123 The unwindonsignal lets the user determine what gdb should do if a signal\n\
1124 is received while in a function called from gdb (call dummy). If set, gdb\n\
1125 unwinds the stack and restore the context to what as it was before the call.\n\
1126 The default is to stop in the frame where the signal was received."),
1128 show_unwind_on_signal_p,
1129 &setlist, &showlist);
1131 add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class,
1132 &unwind_on_terminating_exception_p, _("\
1133 Set unwinding of stack if std::terminate is called while in call dummy."), _("\
1134 Show unwinding of stack if std::terminate() is called while in a call dummy."),
1136 The unwind on terminating exception flag lets the user determine\n\
1137 what gdb should do if a std::terminate() call is made from the\n\
1138 default exception handler. If set, gdb unwinds the stack and restores\n\
1139 the context to what it was before the call. If unset, gdb allows the\n\
1140 std::terminate call to proceed.\n\
1141 The default is to unwind the frame."),
1143 show_unwind_on_terminating_exception_p,
1144 &setlist, &showlist);