1 /* Perform an inferior function call, for GDB, the GNU debugger.
3 Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
4 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004
5 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 #include "breakpoint.h"
29 #include "gdb_assert.h"
36 #include "gdb_string.h"
39 /* NOTE: cagney/2003-04-16: What's the future of this code?
41 GDB needs an asynchronous expression evaluator, that means an
42 asynchronous inferior function call implementation, and that in
43 turn means restructuring the code so that it is event driven. */
45 /* How you should pass arguments to a function depends on whether it
46 was defined in K&R style or prototype style. If you define a
47 function using the K&R syntax that takes a `float' argument, then
48 callers must pass that argument as a `double'. If you define the
49 function using the prototype syntax, then you must pass the
50 argument as a `float', with no promotion.
52 Unfortunately, on certain older platforms, the debug info doesn't
53 indicate reliably how each function was defined. A function type's
54 TYPE_FLAG_PROTOTYPED flag may be clear, even if the function was
55 defined in prototype style. When calling a function whose
56 TYPE_FLAG_PROTOTYPED flag is clear, GDB consults this flag to
59 For modern targets, it is proper to assume that, if the prototype
60 flag is clear, that can be trusted: `float' arguments should be
61 promoted to `double'. For some older targets, if the prototype
62 flag is clear, that doesn't tell us anything. The default is to
63 trust the debug information; the user can override this behavior
64 with "set coerce-float-to-double 0". */
66 static int coerce_float_to_double_p = 1;
68 /* This boolean tells what gdb should do if a signal is received while
69 in a function called from gdb (call dummy). If set, gdb unwinds
70 the stack and restore the context to what as it was before the
73 The default is to stop in the frame where the signal was received. */
75 int unwind_on_signal_p = 0;
77 /* Perform the standard coercions that are specified
78 for arguments to be passed to C functions.
80 If PARAM_TYPE is non-NULL, it is the expected parameter type.
81 IS_PROTOTYPED is non-zero if the function declaration is prototyped. */
84 value_arg_coerce (struct value *arg, struct type *param_type,
87 struct type *arg_type = check_typedef (VALUE_TYPE (arg));
89 = param_type ? check_typedef (param_type) : arg_type;
91 switch (TYPE_CODE (type))
94 if (TYPE_CODE (arg_type) != TYPE_CODE_REF
95 && TYPE_CODE (arg_type) != TYPE_CODE_PTR)
97 arg = value_addr (arg);
98 VALUE_TYPE (arg) = param_type;
106 /* If we don't have a prototype, coerce to integer type if necessary. */
109 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
110 type = builtin_type_int;
112 /* Currently all target ABIs require at least the width of an integer
113 type for an argument. We may have to conditionalize the following
114 type coercion for future targets. */
115 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_int))
116 type = builtin_type_int;
119 if (!is_prototyped && coerce_float_to_double_p)
121 if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin_type_double))
122 type = builtin_type_double;
123 else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin_type_double))
124 type = builtin_type_long_double;
128 type = lookup_pointer_type (type);
130 case TYPE_CODE_ARRAY:
131 /* Arrays are coerced to pointers to their first element, unless
132 they are vectors, in which case we want to leave them alone,
133 because they are passed by value. */
134 if (current_language->c_style_arrays)
135 if (!TYPE_VECTOR (type))
136 type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
138 case TYPE_CODE_UNDEF:
140 case TYPE_CODE_STRUCT:
141 case TYPE_CODE_UNION:
144 case TYPE_CODE_RANGE:
145 case TYPE_CODE_STRING:
146 case TYPE_CODE_BITSTRING:
147 case TYPE_CODE_ERROR:
148 case TYPE_CODE_MEMBER:
149 case TYPE_CODE_METHOD:
150 case TYPE_CODE_COMPLEX:
155 return value_cast (type, arg);
158 /* Determine a function's address and its return type from its value.
159 Calls error() if the function is not valid for calling. */
162 find_function_addr (struct value *function, struct type **retval_type)
164 struct type *ftype = check_typedef (VALUE_TYPE (function));
165 enum type_code code = TYPE_CODE (ftype);
166 struct type *value_type;
169 /* If it's a member function, just look at the function
172 /* Determine address to call. */
173 if (code == TYPE_CODE_FUNC || code == TYPE_CODE_METHOD)
175 funaddr = VALUE_ADDRESS (function);
176 value_type = TYPE_TARGET_TYPE (ftype);
178 else if (code == TYPE_CODE_PTR)
180 funaddr = value_as_address (function);
181 ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
182 if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
183 || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
185 funaddr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
188 value_type = TYPE_TARGET_TYPE (ftype);
191 value_type = builtin_type_int;
193 else if (code == TYPE_CODE_INT)
195 /* Handle the case of functions lacking debugging info.
196 Their values are characters since their addresses are char */
197 if (TYPE_LENGTH (ftype) == 1)
198 funaddr = value_as_address (value_addr (function));
200 /* Handle integer used as address of a function. */
201 funaddr = (CORE_ADDR) value_as_long (function);
203 value_type = builtin_type_int;
206 error ("Invalid data type for function to be called.");
208 if (retval_type != NULL)
209 *retval_type = value_type;
210 return funaddr + DEPRECATED_FUNCTION_START_OFFSET;
213 /* Call breakpoint_auto_delete on the current contents of the bpstat
214 pointed to by arg (which is really a bpstat *). */
217 breakpoint_auto_delete_contents (void *arg)
219 breakpoint_auto_delete (*(bpstat *) arg);
223 generic_push_dummy_code (struct gdbarch *gdbarch,
224 CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc,
225 struct value **args, int nargs,
226 struct type *value_type,
227 CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
229 /* Something here to findout the size of a breakpoint and then
230 allocate space for it on the stack. */
232 /* This code assumes frame align. */
233 gdb_assert (gdbarch_frame_align_p (gdbarch));
234 /* Force the stack's alignment. The intent is to ensure that the SP
235 is aligned to at least a breakpoint instruction's boundary. */
236 sp = gdbarch_frame_align (gdbarch, sp);
237 /* Allocate space for, and then position the breakpoint on the
239 if (gdbarch_inner_than (gdbarch, 1, 2))
242 gdbarch_breakpoint_from_pc (gdbarch, &bppc, &bplen);
243 sp = gdbarch_frame_align (gdbarch, sp - bplen);
245 /* Should the breakpoint size/location be re-computed here? */
250 gdbarch_breakpoint_from_pc (gdbarch, bp_addr, &bplen);
251 sp = gdbarch_frame_align (gdbarch, sp + bplen);
253 /* Inferior resumes at the function entry point. */
254 (*real_pc) = funaddr;
258 /* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called
259 function returns to. */
262 push_dummy_code (struct gdbarch *gdbarch,
263 CORE_ADDR sp, CORE_ADDR funaddr, int using_gcc,
264 struct value **args, int nargs,
265 struct type *value_type,
266 CORE_ADDR *real_pc, CORE_ADDR *bp_addr)
268 if (gdbarch_push_dummy_code_p (gdbarch))
269 return gdbarch_push_dummy_code (gdbarch, sp, funaddr, using_gcc,
270 args, nargs, value_type, real_pc, bp_addr);
272 return generic_push_dummy_code (gdbarch, sp, funaddr, using_gcc,
273 args, nargs, value_type, real_pc, bp_addr);
276 /* All this stuff with a dummy frame may seem unnecessarily complicated
277 (why not just save registers in GDB?). The purpose of pushing a dummy
278 frame which looks just like a real frame is so that if you call a
279 function and then hit a breakpoint (get a signal, etc), "backtrace"
280 will look right. Whether the backtrace needs to actually show the
281 stack at the time the inferior function was called is debatable, but
282 it certainly needs to not display garbage. So if you are contemplating
283 making dummy frames be different from normal frames, consider that. */
285 /* Perform a function call in the inferior.
286 ARGS is a vector of values of arguments (NARGS of them).
287 FUNCTION is a value, the function to be called.
288 Returns a value representing what the function returned.
289 May fail to return, if a breakpoint or signal is hit
290 during the execution of the function.
292 ARGS is modified to contain coerced values. */
295 call_function_by_hand (struct value *function, int nargs, struct value **args)
298 CORE_ADDR dummy_addr;
299 struct type *value_type;
300 unsigned char struct_return;
301 CORE_ADDR struct_addr = 0;
302 struct regcache *retbuf;
303 struct cleanup *retbuf_cleanup;
304 struct inferior_status *inf_status;
305 struct cleanup *inf_status_cleanup;
307 int using_gcc; /* Set to version of gcc in use, or zero if not gcc */
309 struct type *ftype = check_typedef (SYMBOL_TYPE (function));
312 if (!target_has_execution)
315 /* Create a cleanup chain that contains the retbuf (buffer
316 containing the register values). This chain is create BEFORE the
317 inf_status chain so that the inferior status can cleaned up
318 (restored or discarded) without having the retbuf freed. */
319 retbuf = regcache_xmalloc (current_gdbarch);
320 retbuf_cleanup = make_cleanup_regcache_xfree (retbuf);
322 /* A cleanup for the inferior status. Create this AFTER the retbuf
323 so that this can be discarded or applied without interfering with
325 inf_status = save_inferior_status (1);
326 inf_status_cleanup = make_cleanup_restore_inferior_status (inf_status);
328 /* FIXME: cagney/2003-02-26: Step zero of this little tinker is to
329 extract the generic dummy frame code from the architecture
330 vector. Hence this direct call.
332 A follow-on change is to modify this interface so that it takes
333 thread OR frame OR ptid as a parameter, and returns a dummy frame
334 handle. The handle can then be used further down as a parameter
335 to generic_save_dummy_frame_tos(). Hmm, thinking about it, since
336 everything is ment to be using generic dummy frames, why not even
337 use some of the dummy frame code to here - do a regcache dup and
338 then pass the duped regcache, along with all the other stuff, at
341 In fact, you can even save the structure's return address in the
342 dummy frame and fix one of those nasty lost struct return edge
344 generic_push_dummy_frame ();
346 /* Ensure that the initial SP is correctly aligned. */
348 CORE_ADDR old_sp = read_sp ();
349 if (gdbarch_frame_align_p (current_gdbarch))
351 sp = gdbarch_frame_align (current_gdbarch, old_sp);
352 /* NOTE: cagney/2003-08-13: Skip the "red zone". For some
353 ABIs, a function can use memory beyond the inner most stack
354 address. AMD64 called that region the "red zone". Skip at
355 least the "red zone" size before allocating any space on
357 if (INNER_THAN (1, 2))
358 sp -= gdbarch_frame_red_zone_size (current_gdbarch);
360 sp += gdbarch_frame_red_zone_size (current_gdbarch);
362 gdb_assert (sp == gdbarch_frame_align (current_gdbarch, sp));
363 /* NOTE: cagney/2002-09-18:
365 On a RISC architecture, a void parameterless generic dummy
366 frame (i.e., no parameters, no result) typically does not
367 need to push anything the stack and hence can leave SP and
368 FP. Similarly, a frameless (possibly leaf) function does
369 not push anything on the stack and, hence, that too can
370 leave FP and SP unchanged. As a consequence, a sequence of
371 void parameterless generic dummy frame calls to frameless
372 functions will create a sequence of effectively identical
373 frames (SP, FP and TOS and PC the same). This, not
374 suprisingly, results in what appears to be a stack in an
375 infinite loop --- when GDB tries to find a generic dummy
376 frame on the internal dummy frame stack, it will always
379 To avoid this problem, the code below always grows the
380 stack. That way, two dummy frames can never be identical.
381 It does burn a few bytes of stack but that is a small price
385 if (INNER_THAN (1, 2))
386 /* Stack grows down. */
387 sp = gdbarch_frame_align (current_gdbarch, old_sp - 1);
389 /* Stack grows up. */
390 sp = gdbarch_frame_align (current_gdbarch, old_sp + 1);
392 gdb_assert ((INNER_THAN (1, 2) && sp <= old_sp)
393 || (INNER_THAN (2, 1) && sp >= old_sp));
396 /* FIXME: cagney/2002-09-18: Hey, you loose!
398 Who knows how badly aligned the SP is!
400 If the generic dummy frame ends up empty (because nothing is
401 pushed) GDB won't be able to correctly perform back traces.
402 If a target is having trouble with backtraces, first thing to
403 do is add FRAME_ALIGN() to the architecture vector. If that
404 fails, try unwind_dummy_id().
406 If the ABI specifies a "Red Zone" (see the doco) the code
407 below will quietly trash it. */
411 funaddr = find_function_addr (function, &value_type);
412 CHECK_TYPEDEF (value_type);
415 struct block *b = block_for_pc (funaddr);
416 /* If compiled without -g, assume GCC 2. */
417 using_gcc = (b == NULL ? 2 : BLOCK_GCC_COMPILED (b));
420 /* Are we returning a value using a structure return or a normal
423 struct_return = using_struct_return (value_type, using_gcc);
425 /* Determine the location of the breakpoint (and possibly other
426 stuff) that the called function will return to. The SPARC, for a
427 function returning a structure or union, needs to make space for
428 not just the breakpoint but also an extra word containing the
429 size (?) of the structure being passed. */
431 /* The actual breakpoint (at BP_ADDR) is inserted separatly so there
432 is no need to write that out. */
434 switch (CALL_DUMMY_LOCATION)
437 /* "dummy_addr" is here just to keep old targets happy. New
438 targets return that same information via "sp" and "bp_addr". */
439 if (INNER_THAN (1, 2))
441 sp = push_dummy_code (current_gdbarch, sp, funaddr,
442 using_gcc, args, nargs, value_type,
449 sp = push_dummy_code (current_gdbarch, sp, funaddr,
450 using_gcc, args, nargs, value_type,
456 dummy_addr = entry_point_address ();
457 /* Make certain that the address points at real code, and not a
458 function descriptor. */
459 dummy_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
462 /* A call dummy always consists of just a single breakpoint, so
463 it's address is the same as the address of the dummy. */
464 bp_addr = dummy_addr;
467 /* Some executables define a symbol __CALL_DUMMY_ADDRESS whose
468 address is the location where the breakpoint should be
469 placed. Once all targets are using the overhauled frame code
470 this can be deleted - ON_STACK is a better option. */
472 struct minimal_symbol *sym;
474 sym = lookup_minimal_symbol ("__CALL_DUMMY_ADDRESS", NULL, NULL);
477 dummy_addr = SYMBOL_VALUE_ADDRESS (sym);
479 dummy_addr = entry_point_address ();
480 /* Make certain that the address points at real code, and not
481 a function descriptor. */
482 dummy_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
485 /* A call dummy always consists of just a single breakpoint,
486 so it's address is the same as the address of the dummy. */
487 bp_addr = dummy_addr;
491 internal_error (__FILE__, __LINE__, "bad switch");
494 /* Save where the breakpoint is going to be inserted so that the
495 dummy-frame code is later able to re-identify it. */
496 generic_save_call_dummy_addr (bp_addr, bp_addr + 1);
498 if (nargs < TYPE_NFIELDS (ftype))
499 error ("too few arguments in function call");
503 for (i = nargs - 1; i >= 0; i--)
506 struct type *param_type;
508 /* FIXME drow/2002-05-31: Should just always mark methods as
509 prototyped. Can we respect TYPE_VARARGS? Probably not. */
510 if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
512 else if (i < TYPE_NFIELDS (ftype))
513 prototyped = TYPE_PROTOTYPED (ftype);
517 if (i < TYPE_NFIELDS (ftype))
518 param_type = TYPE_FIELD_TYPE (ftype, i);
522 args[i] = value_arg_coerce (args[i], param_type, prototyped);
524 /* elz: this code is to handle the case in which the function
525 to be called has a pointer to function as parameter and the
526 corresponding actual argument is the address of a function
527 and not a pointer to function variable. In aCC compiled
528 code, the calls through pointers to functions (in the body
529 of the function called by hand) are made via
530 $$dyncall_external which requires some registers setting,
531 this is taken care of if we call via a function pointer
532 variable, but not via a function address. In cc this is
537 if (param_type != NULL && TYPE_CODE (ftype) != TYPE_CODE_METHOD)
539 /* if this parameter is a pointer to function. */
540 if (TYPE_CODE (param_type) == TYPE_CODE_PTR)
541 if (TYPE_CODE (TYPE_TARGET_TYPE (param_type)) == TYPE_CODE_FUNC)
542 /* elz: FIXME here should go the test about the
543 compiler used to compile the target. We want to
544 issue the error message only if the compiler
545 used was HP's aCC. If we used HP's cc, then
546 there is no problem and no need to return at
548 /* Go see if the actual parameter is a variable of
549 type pointer to function or just a function. */
550 if (args[i]->lval == not_lval)
553 if (find_pc_partial_function ((CORE_ADDR) args[i]->aligner.contents[0], &arg_name, NULL, NULL))
555 You cannot use function <%s> as argument. \n\
556 You must use a pointer to function type variable. Command ignored.", arg_name);
563 if (DEPRECATED_REG_STRUCT_HAS_ADDR_P ())
566 /* This is a machine like the sparc, where we may need to pass a
567 pointer to the structure, not the structure itself. */
568 for (i = nargs - 1; i >= 0; i--)
570 struct type *arg_type = check_typedef (VALUE_TYPE (args[i]));
571 if ((TYPE_CODE (arg_type) == TYPE_CODE_STRUCT
572 || TYPE_CODE (arg_type) == TYPE_CODE_UNION
573 || TYPE_CODE (arg_type) == TYPE_CODE_ARRAY
574 || TYPE_CODE (arg_type) == TYPE_CODE_STRING
575 || TYPE_CODE (arg_type) == TYPE_CODE_BITSTRING
576 || TYPE_CODE (arg_type) == TYPE_CODE_SET
577 || (TYPE_CODE (arg_type) == TYPE_CODE_FLT
578 && TYPE_LENGTH (arg_type) > 8)
580 && DEPRECATED_REG_STRUCT_HAS_ADDR (using_gcc, arg_type))
583 int len; /* = TYPE_LENGTH (arg_type); */
585 arg_type = check_typedef (VALUE_ENCLOSING_TYPE (args[i]));
586 len = TYPE_LENGTH (arg_type);
588 if (DEPRECATED_STACK_ALIGN_P ())
589 /* MVS 11/22/96: I think at least some of this
590 stack_align code is really broken. Better to let
591 PUSH_ARGUMENTS adjust the stack in a target-defined
593 aligned_len = DEPRECATED_STACK_ALIGN (len);
596 if (INNER_THAN (1, 2))
598 /* stack grows downward */
600 /* ... so the address of the thing we push is the
601 stack pointer after we push it. */
606 /* The stack grows up, so the address of the thing
607 we push is the stack pointer before we push it. */
611 /* Push the structure. */
612 write_memory (addr, VALUE_CONTENTS_ALL (args[i]), len);
613 /* The value we're going to pass is the address of the
614 thing we just pushed. */
615 /*args[i] = value_from_longest (lookup_pointer_type (value_type),
617 args[i] = value_from_pointer (lookup_pointer_type (arg_type),
624 /* Reserve space for the return structure to be written on the
625 stack, if necessary. Make certain that the value is correctly
630 int len = TYPE_LENGTH (value_type);
631 if (DEPRECATED_STACK_ALIGN_P ())
632 /* NOTE: cagney/2003-03-22: Should rely on frame align, rather
633 than stack align to force the alignment of the stack. */
634 len = DEPRECATED_STACK_ALIGN (len);
635 if (INNER_THAN (1, 2))
637 /* Stack grows downward. Align STRUCT_ADDR and SP after
638 making space for the return value. */
640 if (gdbarch_frame_align_p (current_gdbarch))
641 sp = gdbarch_frame_align (current_gdbarch, sp);
646 /* Stack grows upward. Align the frame, allocate space, and
647 then again, re-align the frame??? */
648 if (gdbarch_frame_align_p (current_gdbarch))
649 sp = gdbarch_frame_align (current_gdbarch, sp);
652 if (gdbarch_frame_align_p (current_gdbarch))
653 sp = gdbarch_frame_align (current_gdbarch, sp);
657 /* Create the dummy stack frame. Pass in the call dummy address as,
658 presumably, the ABI code knows where, in the call dummy, the
659 return address should be pointed. */
660 if (gdbarch_push_dummy_call_p (current_gdbarch))
661 /* When there is no push_dummy_call method, should this code
662 simply error out. That would the implementation of this method
663 for all ABIs (which is probably a good thing). */
664 sp = gdbarch_push_dummy_call (current_gdbarch, function, current_regcache,
665 bp_addr, nargs, args, sp, struct_return,
667 else if (DEPRECATED_PUSH_ARGUMENTS_P ())
668 /* Keep old targets working. */
669 sp = DEPRECATED_PUSH_ARGUMENTS (nargs, args, sp, struct_return,
672 error ("This target does not support function calls");
674 if (DEPRECATED_PUSH_RETURN_ADDRESS_P ())
675 /* for targets that use no CALL_DUMMY */
676 /* There are a number of targets now which actually don't write
677 any CALL_DUMMY instructions into the target, but instead just
678 save the machine state, push the arguments, and jump directly
679 to the callee function. Since this doesn't actually involve
680 executing a JSR/BSR instruction, the return address must be set
681 up by hand, either by pushing onto the stack or copying into a
682 return-address register as appropriate. Formerly this has been
683 done in PUSH_ARGUMENTS, but that's overloading its
684 functionality a bit, so I'm making it explicit to do it here. */
685 /* NOTE: cagney/2003-04-22: The first parameter ("real_pc") has
686 been replaced with zero, it turns out that no implementation
687 used that parameter. This occured because the value being
688 supplied - the address of the called function's entry point
689 instead of the address of the breakpoint that the called
690 function should return to - wasn't useful. */
691 sp = DEPRECATED_PUSH_RETURN_ADDRESS (0, sp);
693 /* NOTE: cagney/2003-03-23: Diable this code when there is a
694 push_dummy_call() method. Since that method will have already
695 handled any alignment issues, the code below is entirely
697 if (!gdbarch_push_dummy_call_p (current_gdbarch)
698 && DEPRECATED_STACK_ALIGN_P () && !INNER_THAN (1, 2))
700 /* If stack grows up, we must leave a hole at the bottom, note
701 that sp already has been advanced for the arguments! */
702 sp = DEPRECATED_STACK_ALIGN (sp);
705 /* Store the address at which the structure is supposed to be
707 /* NOTE: 2003-03-24: Since PUSH_ARGUMENTS can (and typically does)
708 store the struct return address, this call is entirely redundant. */
709 if (struct_return && DEPRECATED_STORE_STRUCT_RETURN_P ())
710 DEPRECATED_STORE_STRUCT_RETURN (struct_addr, sp);
712 /* Write the stack pointer. This is here because the statements
713 above might fool with it. On SPARC, this write also stores the
714 register window into the right place in the new stack frame,
715 which otherwise wouldn't happen (see store_inferior_registers in
717 /* NOTE: cagney/2003-03-23: Since the architecture method
718 push_dummy_call() should have already stored the stack pointer
719 (as part of creating the fake call frame), and none of the code
720 following that call adjusts the stack-pointer value, the below
721 call is entirely redundant. */
722 if (DEPRECATED_DUMMY_WRITE_SP_P ())
723 DEPRECATED_DUMMY_WRITE_SP (sp);
725 if (DEPRECATED_SAVE_DUMMY_FRAME_TOS_P ())
726 DEPRECATED_SAVE_DUMMY_FRAME_TOS (sp);
728 /* Sanity. The exact same SP value is returned by
729 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
730 unwind_dummy_id to form the frame ID's stack address. */
731 generic_save_dummy_frame_tos (sp);
733 /* Now proceed, having reached the desired place. */
734 clear_proceed_status ();
736 /* Create a momentary breakpoint at the return address of the
737 inferior. That way it breaks when it returns. */
740 struct breakpoint *bpt;
741 struct symtab_and_line sal;
742 struct frame_id frame;
743 init_sal (&sal); /* initialize to zeroes */
745 sal.section = find_pc_overlay (sal.pc);
746 /* Set up a frame ID for the dummy frame so we can pass it to
747 set_momentary_breakpoint. We need to give the breakpoint a
748 frame ID so that the breakpoint code can correctly re-identify
749 the dummy breakpoint. */
750 if (gdbarch_unwind_dummy_id_p (current_gdbarch))
752 /* Sanity. The exact same SP value is returned by
753 PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
754 unwind_dummy_id to form the frame ID's stack address. */
755 frame = frame_id_build (sp, sal.pc);
759 /* The assumption here is that push_dummy_call() returned the
760 stack part of the frame ID. Unfortunately, many older
761 architectures were, via a convoluted mess, relying on the
762 poorly defined and greatly overloaded
763 DEPRECATED_TARGET_READ_FP or DEPRECATED_FP_REGNUM to supply
765 if (DEPRECATED_TARGET_READ_FP_P ())
766 frame = frame_id_build (DEPRECATED_TARGET_READ_FP (), sal.pc);
767 else if (DEPRECATED_FP_REGNUM >= 0)
768 frame = frame_id_build (read_register (DEPRECATED_FP_REGNUM), sal.pc);
770 frame = frame_id_build (sp, sal.pc);
772 bpt = set_momentary_breakpoint (sal, frame, bp_call_dummy);
773 bpt->disposition = disp_del;
776 /* Execute a "stack dummy", a piece of code stored in the stack by
777 the debugger to be executed in the inferior.
779 The dummy's frame is automatically popped whenever that break is
780 hit. If that is the first time the program stops,
781 call_function_by_hand returns to its caller with that frame
782 already gone and sets RC to 0.
784 Otherwise, set RC to a non-zero value. If the called function
785 receives a random signal, we do not allow the user to continue
786 executing it as this may not work. The dummy frame is poped and
787 we return 1. If we hit a breakpoint, we leave the frame in place
788 and return 2 (the frame will eventually be popped when we do hit
789 the dummy end breakpoint). */
792 struct cleanup *old_cleanups = make_cleanup (null_cleanup, 0);
795 /* If all error()s out of proceed ended up calling normal_stop
796 (and perhaps they should; it already does in the special case
797 of error out of resume()), then we wouldn't need this. */
798 make_cleanup (breakpoint_auto_delete_contents, &stop_bpstat);
800 disable_watchpoints_before_interactive_call_start ();
801 proceed_to_finish = 1; /* We want stop_registers, please... */
803 if (target_can_async_p ())
804 saved_async = target_async_mask (0);
806 proceed (real_pc, TARGET_SIGNAL_0, 0);
809 target_async_mask (saved_async);
811 enable_watchpoints_after_interactive_call_stop ();
813 discard_cleanups (old_cleanups);
816 if (stopped_by_random_signal || !stop_stack_dummy)
818 /* Find the name of the function we're about to complain about. */
819 const char *name = NULL;
821 struct symbol *symbol = find_pc_function (funaddr);
823 name = SYMBOL_PRINT_NAME (symbol);
826 /* Try the minimal symbols. */
827 struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr);
829 name = SYMBOL_PRINT_NAME (msymbol);
833 /* Can't use a cleanup here. It is discarded, instead use
835 char *tmp = xstrprintf ("at %s", local_hex_string (funaddr));
836 char *a = alloca (strlen (tmp) + 1);
842 if (stopped_by_random_signal)
844 /* We stopped inside the FUNCTION because of a random
845 signal. Further execution of the FUNCTION is not
848 if (unwind_on_signal_p)
850 /* The user wants the context restored. */
852 /* We must get back to the frame we were before the
854 frame_pop (get_current_frame ());
856 /* FIXME: Insert a bunch of wrap_here; name can be very
857 long if it's a C++ name with arguments and stuff. */
859 The program being debugged was signaled while in a function called from GDB.\n\
860 GDB has restored the context to what it was before the call.\n\
861 To change this behavior use \"set unwindonsignal off\"\n\
862 Evaluation of the expression containing the function (%s) will be abandoned.",
867 /* The user wants to stay in the frame where we stopped
869 /* If we restored the inferior status (via the cleanup),
870 we would print a spurious error message (Unable to
871 restore previously selected frame), would write the
872 registers from the inf_status (which is wrong), and
873 would do other wrong things. */
874 discard_cleanups (inf_status_cleanup);
875 discard_inferior_status (inf_status);
876 /* FIXME: Insert a bunch of wrap_here; name can be very
877 long if it's a C++ name with arguments and stuff. */
879 The program being debugged was signaled while in a function called from GDB.\n\
880 GDB remains in the frame where the signal was received.\n\
881 To change this behavior use \"set unwindonsignal on\"\n\
882 Evaluation of the expression containing the function (%s) will be abandoned.",
887 if (!stop_stack_dummy)
889 /* We hit a breakpoint inside the FUNCTION. */
890 /* If we restored the inferior status (via the cleanup), we
891 would print a spurious error message (Unable to restore
892 previously selected frame), would write the registers
893 from the inf_status (which is wrong), and would do other
895 discard_cleanups (inf_status_cleanup);
896 discard_inferior_status (inf_status);
897 /* The following error message used to say "The expression
898 which contained the function call has been discarded."
899 It is a hard concept to explain in a few words. Ideally,
900 GDB would be able to resume evaluation of the expression
901 when the function finally is done executing. Perhaps
902 someday this will be implemented (it would not be easy). */
903 /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
904 a C++ name with arguments and stuff. */
906 The program being debugged stopped while in a function called from GDB.\n\
907 When the function (%s) is done executing, GDB will silently\n\
908 stop (instead of continuing to evaluate the expression containing\n\
909 the function call).", name);
912 /* The above code errors out, so ... */
913 internal_error (__FILE__, __LINE__, "... should not be here");
916 /* If we get here the called FUNCTION run to completion. */
918 /* On normal return, the stack dummy has been popped already. */
919 regcache_cpy_no_passthrough (retbuf, stop_registers);
921 /* Restore the inferior status, via its cleanup. At this stage,
922 leave the RETBUF alone. */
923 do_cleanups (inf_status_cleanup);
925 /* Figure out the value returned by the function, return that. */
927 struct value *retval;
928 if (TYPE_CODE (value_type) == TYPE_CODE_VOID)
929 /* If the function returns void, don't bother fetching the
931 retval = allocate_value (value_type);
932 else if (struct_return)
933 /* NOTE: cagney/2003-09-27: This assumes that PUSH_DUMMY_CALL
934 has correctly stored STRUCT_ADDR in the target. In the past
935 that hasn't been the case, the old MIPS PUSH_ARGUMENTS
936 (PUSH_DUMMY_CALL precursor) would silently move the location
937 of the struct return value making STRUCT_ADDR bogus. If
938 you're seeing problems with values being returned using the
939 "struct return convention", check that PUSH_DUMMY_CALL isn't
941 retval = value_at (value_type, struct_addr, NULL);
942 else if (gdbarch_return_value_p (current_gdbarch))
944 /* This code only handles "register convention". */
945 retval = allocate_value (value_type);
946 gdb_assert (gdbarch_return_value (current_gdbarch, value_type,
948 == RETURN_VALUE_REGISTER_CONVENTION);
949 gdbarch_return_value (current_gdbarch, value_type, retbuf,
950 VALUE_CONTENTS_RAW (retval) /*read*/,
955 /* NOTE: cagney/2003-10-20: Unlike "gdbarch_return_value", the
956 EXTRACT_RETURN_VALUE and DEPRECATED_USE_STRUCT_CONVENTION
957 methods do not handle the edge case of a function returning
958 a small structure / union in registers. */
959 retval = allocate_value (value_type);
960 EXTRACT_RETURN_VALUE (value_type, retbuf, VALUE_CONTENTS_RAW (retval));
962 do_cleanups (retbuf_cleanup);
967 void _initialize_infcall (void);
970 _initialize_infcall (void)
972 add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure,
973 &coerce_float_to_double_p, "\
974 Set coercion of floats to doubles when calling functions\n\
975 Variables of type float should generally be converted to doubles before\n\
976 calling an unprototyped function, and left alone when calling a prototyped\n\
977 function. However, some older debug info formats do not provide enough\n\
978 information to determine that a function is prototyped. If this flag is\n\
979 set, GDB will perform the conversion for a function it considers\n\
981 The default is to perform the conversion.\n", "\
982 Show coercion of floats to doubles when calling functions\n\
983 Variables of type float should generally be converted to doubles before\n\
984 calling an unprototyped function, and left alone when calling a prototyped\n\
985 function. However, some older debug info formats do not provide enough\n\
986 information to determine that a function is prototyped. If this flag is\n\
987 set, GDB will perform the conversion for a function it considers\n\
989 The default is to perform the conversion.\n",
990 NULL, NULL, &setlist, &showlist);
992 add_setshow_boolean_cmd ("unwindonsignal", no_class,
993 &unwind_on_signal_p, "\
994 Set unwinding of stack if a signal is received while in a call dummy.\n\
995 The unwindonsignal lets the user determine what gdb should do if a signal\n\
996 is received while in a function called from gdb (call dummy). If set, gdb\n\
997 unwinds the stack and restore the context to what as it was before the call.\n\
998 The default is to stop in the frame where the signal was received.", "\
999 Show unwinding of stack if a signal is received while in a call dummy.\n\
1000 The unwindonsignal lets the user determine what gdb should do if a signal\n\
1001 is received while in a function called from gdb (call dummy). If set, gdb\n\
1002 unwinds the stack and restore the context to what as it was before the call.\n\
1003 The default is to stop in the frame where the signal was received.",
1004 NULL, NULL, &setlist, &showlist);