xref: /dragonfly/contrib/gdb-7/gdb/infcall.c (revision fb151170)
1 /* Perform an inferior function call, for GDB, the GNU debugger.
2 
3    Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4    1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
5    2008, 2009, 2010, 2011 Free Software Foundation, Inc.
6 
7    This file is part of GDB.
8 
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 3 of the License, or
12    (at your option) any later version.
13 
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.
18 
19    You should have received a copy of the GNU General Public License
20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
21 
22 #include "defs.h"
23 #include "breakpoint.h"
24 #include "tracepoint.h"
25 #include "target.h"
26 #include "regcache.h"
27 #include "inferior.h"
28 #include "gdb_assert.h"
29 #include "block.h"
30 #include "gdbcore.h"
31 #include "language.h"
32 #include "objfiles.h"
33 #include "gdbcmd.h"
34 #include "command.h"
35 #include "gdb_string.h"
36 #include "infcall.h"
37 #include "dummy-frame.h"
38 #include "ada-lang.h"
39 #include "gdbthread.h"
40 #include "exceptions.h"
41 
42 /* If we can't find a function's name from its address,
43    we print this instead.  */
44 #define RAW_FUNCTION_ADDRESS_FORMAT "at 0x%s"
45 #define RAW_FUNCTION_ADDRESS_SIZE (sizeof (RAW_FUNCTION_ADDRESS_FORMAT) \
46                                    + 2 * sizeof (CORE_ADDR))
47 
48 /* NOTE: cagney/2003-04-16: What's the future of this code?
49 
50    GDB needs an asynchronous expression evaluator, that means an
51    asynchronous inferior function call implementation, and that in
52    turn means restructuring the code so that it is event driven.  */
53 
54 /* How you should pass arguments to a function depends on whether it
55    was defined in K&R style or prototype style.  If you define a
56    function using the K&R syntax that takes a `float' argument, then
57    callers must pass that argument as a `double'.  If you define the
58    function using the prototype syntax, then you must pass the
59    argument as a `float', with no promotion.
60 
61    Unfortunately, on certain older platforms, the debug info doesn't
62    indicate reliably how each function was defined.  A function type's
63    TYPE_FLAG_PROTOTYPED flag may be clear, even if the function was
64    defined in prototype style.  When calling a function whose
65    TYPE_FLAG_PROTOTYPED flag is clear, GDB consults this flag to
66    decide what to do.
67 
68    For modern targets, it is proper to assume that, if the prototype
69    flag is clear, that can be trusted: `float' arguments should be
70    promoted to `double'.  For some older targets, if the prototype
71    flag is clear, that doesn't tell us anything.  The default is to
72    trust the debug information; the user can override this behavior
73    with "set coerce-float-to-double 0".  */
74 
75 static int coerce_float_to_double_p = 1;
76 static void
77 show_coerce_float_to_double_p (struct ui_file *file, int from_tty,
78 			       struct cmd_list_element *c, const char *value)
79 {
80   fprintf_filtered (file,
81 		    _("Coercion of floats to doubles "
82 		      "when calling functions is %s.\n"),
83 		    value);
84 }
85 
86 /* This boolean tells what gdb should do if a signal is received while
87    in a function called from gdb (call dummy).  If set, gdb unwinds
88    the stack and restore the context to what as it was before the
89    call.
90 
91    The default is to stop in the frame where the signal was received.  */
92 
93 int unwind_on_signal_p = 0;
94 static void
95 show_unwind_on_signal_p (struct ui_file *file, int from_tty,
96 			 struct cmd_list_element *c, const char *value)
97 {
98   fprintf_filtered (file,
99 		    _("Unwinding of stack if a signal is "
100 		      "received while in a call dummy is %s.\n"),
101 		    value);
102 }
103 
104 /* This boolean tells what gdb should do if a std::terminate call is
105    made while in a function called from gdb (call dummy).
106    As the confines of a single dummy stack prohibit out-of-frame
107    handlers from handling a raised exception, and as out-of-frame
108    handlers are common in C++, this can lead to no handler being found
109    by the unwinder, and a std::terminate call.  This is a false positive.
110    If set, gdb unwinds the stack and restores the context to what it
111    was before the call.
112 
113    The default is to unwind the frame if a std::terminate call is
114    made.  */
115 
116 static int unwind_on_terminating_exception_p = 1;
117 
118 static void
119 show_unwind_on_terminating_exception_p (struct ui_file *file, int from_tty,
120 					struct cmd_list_element *c,
121 					const char *value)
122 
123 {
124   fprintf_filtered (file,
125 		    _("Unwind stack if a C++ exception is "
126 		      "unhandled while in a call dummy is %s.\n"),
127 		    value);
128 }
129 
130 /* Perform the standard coercions that are specified
131    for arguments to be passed to C or Ada functions.
132 
133    If PARAM_TYPE is non-NULL, it is the expected parameter type.
134    IS_PROTOTYPED is non-zero if the function declaration is prototyped.
135    SP is the stack pointer were additional data can be pushed (updating
136    its value as needed).  */
137 
138 static struct value *
139 value_arg_coerce (struct gdbarch *gdbarch, struct value *arg,
140 		  struct type *param_type, int is_prototyped, CORE_ADDR *sp)
141 {
142   const struct builtin_type *builtin = builtin_type (gdbarch);
143   struct type *arg_type = check_typedef (value_type (arg));
144   struct type *type
145     = param_type ? check_typedef (param_type) : arg_type;
146 
147   /* Perform any Ada-specific coercion first.  */
148   if (current_language->la_language == language_ada)
149     arg = ada_convert_actual (arg, type);
150 
151   /* Force the value to the target if we will need its address.  At
152      this point, we could allocate arguments on the stack instead of
153      calling malloc if we knew that their addresses would not be
154      saved by the called function.  */
155   arg = value_coerce_to_target (arg);
156 
157   switch (TYPE_CODE (type))
158     {
159     case TYPE_CODE_REF:
160       {
161 	struct value *new_value;
162 
163 	if (TYPE_CODE (arg_type) == TYPE_CODE_REF)
164 	  return value_cast_pointers (type, arg);
165 
166 	/* Cast the value to the reference's target type, and then
167 	   convert it back to a reference.  This will issue an error
168 	   if the value was not previously in memory - in some cases
169 	   we should clearly be allowing this, but how?  */
170 	new_value = value_cast (TYPE_TARGET_TYPE (type), arg);
171 	new_value = value_ref (new_value);
172 	return new_value;
173       }
174     case TYPE_CODE_INT:
175     case TYPE_CODE_CHAR:
176     case TYPE_CODE_BOOL:
177     case TYPE_CODE_ENUM:
178       /* If we don't have a prototype, coerce to integer type if necessary.  */
179       if (!is_prototyped)
180 	{
181 	  if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_int))
182 	    type = builtin->builtin_int;
183 	}
184       /* Currently all target ABIs require at least the width of an integer
185          type for an argument.  We may have to conditionalize the following
186          type coercion for future targets.  */
187       if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_int))
188 	type = builtin->builtin_int;
189       break;
190     case TYPE_CODE_FLT:
191       if (!is_prototyped && coerce_float_to_double_p)
192 	{
193 	  if (TYPE_LENGTH (type) < TYPE_LENGTH (builtin->builtin_double))
194 	    type = builtin->builtin_double;
195 	  else if (TYPE_LENGTH (type) > TYPE_LENGTH (builtin->builtin_double))
196 	    type = builtin->builtin_long_double;
197 	}
198       break;
199     case TYPE_CODE_FUNC:
200       type = lookup_pointer_type (type);
201       break;
202     case TYPE_CODE_ARRAY:
203       /* Arrays are coerced to pointers to their first element, unless
204          they are vectors, in which case we want to leave them alone,
205          because they are passed by value.  */
206       if (current_language->c_style_arrays)
207 	if (!TYPE_VECTOR (type))
208 	  type = lookup_pointer_type (TYPE_TARGET_TYPE (type));
209       break;
210     case TYPE_CODE_UNDEF:
211     case TYPE_CODE_PTR:
212     case TYPE_CODE_STRUCT:
213     case TYPE_CODE_UNION:
214     case TYPE_CODE_VOID:
215     case TYPE_CODE_SET:
216     case TYPE_CODE_RANGE:
217     case TYPE_CODE_STRING:
218     case TYPE_CODE_BITSTRING:
219     case TYPE_CODE_ERROR:
220     case TYPE_CODE_MEMBERPTR:
221     case TYPE_CODE_METHODPTR:
222     case TYPE_CODE_METHOD:
223     case TYPE_CODE_COMPLEX:
224     default:
225       break;
226     }
227 
228   return value_cast (type, arg);
229 }
230 
231 /* Return the return type of a function with its first instruction exactly at
232    the PC address.  Return NULL otherwise.  */
233 
234 static struct type *
235 find_function_return_type (CORE_ADDR pc)
236 {
237   struct symbol *sym = find_pc_function (pc);
238 
239   if (sym != NULL && BLOCK_START (SYMBOL_BLOCK_VALUE (sym)) == pc
240       && SYMBOL_TYPE (sym) != NULL)
241     return TYPE_TARGET_TYPE (SYMBOL_TYPE (sym));
242 
243   return NULL;
244 }
245 
246 /* Determine a function's address and its return type from its value.
247    Calls error() if the function is not valid for calling.  */
248 
249 CORE_ADDR
250 find_function_addr (struct value *function, struct type **retval_type)
251 {
252   struct type *ftype = check_typedef (value_type (function));
253   struct gdbarch *gdbarch = get_type_arch (ftype);
254   struct type *value_type = NULL;
255   /* Initialize it just to avoid a GCC false warning.  */
256   CORE_ADDR funaddr = 0;
257 
258   /* If it's a member function, just look at the function
259      part of it.  */
260 
261   /* Determine address to call.  */
262   if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
263       || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
264     funaddr = value_address (function);
265   else if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
266     {
267       funaddr = value_as_address (function);
268       ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
269       if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
270 	  || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
271 	funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr,
272 						      &current_target);
273     }
274   if (TYPE_CODE (ftype) == TYPE_CODE_FUNC
275       || TYPE_CODE (ftype) == TYPE_CODE_METHOD)
276     {
277       value_type = TYPE_TARGET_TYPE (ftype);
278 
279       if (TYPE_GNU_IFUNC (ftype))
280 	{
281 	  funaddr = gnu_ifunc_resolve_addr (gdbarch, funaddr);
282 
283 	  /* Skip querying the function symbol if no RETVAL_TYPE has been
284 	     asked for.  */
285 	  if (retval_type)
286 	    value_type = find_function_return_type (funaddr);
287 	}
288     }
289   else if (TYPE_CODE (ftype) == TYPE_CODE_INT)
290     {
291       /* Handle the case of functions lacking debugging info.
292          Their values are characters since their addresses are char.  */
293       if (TYPE_LENGTH (ftype) == 1)
294 	funaddr = value_as_address (value_addr (function));
295       else
296 	{
297 	  /* Handle function descriptors lacking debug info.  */
298 	  int found_descriptor = 0;
299 
300 	  funaddr = 0;	/* pacify "gcc -Werror" */
301 	  if (VALUE_LVAL (function) == lval_memory)
302 	    {
303 	      CORE_ADDR nfunaddr;
304 
305 	      funaddr = value_as_address (value_addr (function));
306 	      nfunaddr = funaddr;
307 	      funaddr = gdbarch_convert_from_func_ptr_addr (gdbarch, funaddr,
308 							    &current_target);
309 	      if (funaddr != nfunaddr)
310 		found_descriptor = 1;
311 	    }
312 	  if (!found_descriptor)
313 	    /* Handle integer used as address of a function.  */
314 	    funaddr = (CORE_ADDR) value_as_long (function);
315 	}
316     }
317   else
318     error (_("Invalid data type for function to be called."));
319 
320   if (retval_type != NULL)
321     *retval_type = value_type;
322   return funaddr + gdbarch_deprecated_function_start_offset (gdbarch);
323 }
324 
325 /* For CALL_DUMMY_ON_STACK, push a breakpoint sequence that the called
326    function returns to.  */
327 
328 static CORE_ADDR
329 push_dummy_code (struct gdbarch *gdbarch,
330 		 CORE_ADDR sp, CORE_ADDR funaddr,
331 		 struct value **args, int nargs,
332 		 struct type *value_type,
333 		 CORE_ADDR *real_pc, CORE_ADDR *bp_addr,
334 		 struct regcache *regcache)
335 {
336   gdb_assert (gdbarch_push_dummy_code_p (gdbarch));
337 
338   return gdbarch_push_dummy_code (gdbarch, sp, funaddr,
339 				  args, nargs, value_type, real_pc, bp_addr,
340 				  regcache);
341 }
342 
343 /* Fetch the name of the function at FUNADDR.
344    This is used in printing an error message for call_function_by_hand.
345    BUF is used to print FUNADDR in hex if the function name cannot be
346    determined.  It must be large enough to hold formatted result of
347    RAW_FUNCTION_ADDRESS_FORMAT.  */
348 
349 static const char *
350 get_function_name (CORE_ADDR funaddr, char *buf, int buf_size)
351 {
352   {
353     struct symbol *symbol = find_pc_function (funaddr);
354 
355     if (symbol)
356       return SYMBOL_PRINT_NAME (symbol);
357   }
358 
359   {
360     /* Try the minimal symbols.  */
361     struct minimal_symbol *msymbol = lookup_minimal_symbol_by_pc (funaddr);
362 
363     if (msymbol)
364       return SYMBOL_PRINT_NAME (msymbol);
365   }
366 
367   {
368     char *tmp = xstrprintf (_(RAW_FUNCTION_ADDRESS_FORMAT),
369                             hex_string (funaddr));
370 
371     gdb_assert (strlen (tmp) + 1 <= buf_size);
372     strcpy (buf, tmp);
373     xfree (tmp);
374     return buf;
375   }
376 }
377 
378 /* Subroutine of call_function_by_hand to simplify it.
379    Start up the inferior and wait for it to stop.
380    Return the exception if there's an error, or an exception with
381    reason >= 0 if there's no error.
382 
383    This is done inside a TRY_CATCH so the caller needn't worry about
384    thrown errors.  The caller should rethrow if there's an error.  */
385 
386 static struct gdb_exception
387 run_inferior_call (struct thread_info *call_thread, CORE_ADDR real_pc)
388 {
389   volatile struct gdb_exception e;
390   int saved_async = 0;
391   int saved_in_infcall = call_thread->control.in_infcall;
392   ptid_t call_thread_ptid = call_thread->ptid;
393   char *saved_target_shortname = xstrdup (target_shortname);
394 
395   call_thread->control.in_infcall = 1;
396 
397   clear_proceed_status ();
398 
399   disable_watchpoints_before_interactive_call_start ();
400 
401   /* We want stop_registers, please...  */
402   call_thread->control.proceed_to_finish = 1;
403 
404   if (target_can_async_p ())
405     saved_async = target_async_mask (0);
406 
407   TRY_CATCH (e, RETURN_MASK_ALL)
408     proceed (real_pc, TARGET_SIGNAL_0, 0);
409 
410   /* At this point the current thread may have changed.  Refresh
411      CALL_THREAD as it could be invalid if its thread has exited.  */
412   call_thread = find_thread_ptid (call_thread_ptid);
413 
414   /* Don't restore the async mask if the target has changed,
415      saved_async is for the original target.  */
416   if (saved_async
417       && strcmp (saved_target_shortname, target_shortname) == 0)
418     target_async_mask (saved_async);
419 
420   enable_watchpoints_after_interactive_call_stop ();
421 
422   /* Call breakpoint_auto_delete on the current contents of the bpstat
423      of inferior call thread.
424      If all error()s out of proceed ended up calling normal_stop
425      (and perhaps they should; it already does in the special case
426      of error out of resume()), then we wouldn't need this.  */
427   if (e.reason < 0)
428     {
429       if (call_thread != NULL)
430 	breakpoint_auto_delete (call_thread->control.stop_bpstat);
431     }
432 
433   if (call_thread != NULL)
434     call_thread->control.in_infcall = saved_in_infcall;
435 
436   xfree (saved_target_shortname);
437 
438   return e;
439 }
440 
441 /* A cleanup function that calls delete_std_terminate_breakpoint.  */
442 static void
443 cleanup_delete_std_terminate_breakpoint (void *ignore)
444 {
445   delete_std_terminate_breakpoint ();
446 }
447 
448 /* All this stuff with a dummy frame may seem unnecessarily complicated
449    (why not just save registers in GDB?).  The purpose of pushing a dummy
450    frame which looks just like a real frame is so that if you call a
451    function and then hit a breakpoint (get a signal, etc), "backtrace"
452    will look right.  Whether the backtrace needs to actually show the
453    stack at the time the inferior function was called is debatable, but
454    it certainly needs to not display garbage.  So if you are contemplating
455    making dummy frames be different from normal frames, consider that.  */
456 
457 /* Perform a function call in the inferior.
458    ARGS is a vector of values of arguments (NARGS of them).
459    FUNCTION is a value, the function to be called.
460    Returns a value representing what the function returned.
461    May fail to return, if a breakpoint or signal is hit
462    during the execution of the function.
463 
464    ARGS is modified to contain coerced values.  */
465 
466 struct value *
467 call_function_by_hand (struct value *function, int nargs, struct value **args)
468 {
469   CORE_ADDR sp;
470   struct type *values_type, *target_values_type;
471   unsigned char struct_return = 0, lang_struct_return = 0;
472   CORE_ADDR struct_addr = 0;
473   struct infcall_control_state *inf_status;
474   struct cleanup *inf_status_cleanup;
475   struct infcall_suspend_state *caller_state;
476   CORE_ADDR funaddr;
477   CORE_ADDR real_pc;
478   struct type *ftype = check_typedef (value_type (function));
479   CORE_ADDR bp_addr;
480   struct frame_id dummy_id;
481   struct cleanup *args_cleanup;
482   struct frame_info *frame;
483   struct gdbarch *gdbarch;
484   struct cleanup *terminate_bp_cleanup;
485   ptid_t call_thread_ptid;
486   struct gdb_exception e;
487   char name_buf[RAW_FUNCTION_ADDRESS_SIZE];
488 
489   if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
490     ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
491 
492   if (!target_has_execution)
493     noprocess ();
494 
495   if (get_traceframe_number () >= 0)
496     error (_("May not call functions while looking at trace frames."));
497 
498   frame = get_current_frame ();
499   gdbarch = get_frame_arch (frame);
500 
501   if (!gdbarch_push_dummy_call_p (gdbarch))
502     error (_("This target does not support function calls."));
503 
504   /* A cleanup for the inferior status.
505      This is only needed while we're preparing the inferior function call.  */
506   inf_status = save_infcall_control_state ();
507   inf_status_cleanup
508     = make_cleanup_restore_infcall_control_state (inf_status);
509 
510   /* Save the caller's registers and other state associated with the
511      inferior itself so that they can be restored once the
512      callee returns.  To allow nested calls the registers are (further
513      down) pushed onto a dummy frame stack.  Include a cleanup (which
514      is tossed once the regcache has been pushed).  */
515   caller_state = save_infcall_suspend_state ();
516   make_cleanup_restore_infcall_suspend_state (caller_state);
517 
518   /* Ensure that the initial SP is correctly aligned.  */
519   {
520     CORE_ADDR old_sp = get_frame_sp (frame);
521 
522     if (gdbarch_frame_align_p (gdbarch))
523       {
524 	sp = gdbarch_frame_align (gdbarch, old_sp);
525 	/* NOTE: cagney/2003-08-13: Skip the "red zone".  For some
526 	   ABIs, a function can use memory beyond the inner most stack
527 	   address.  AMD64 called that region the "red zone".  Skip at
528 	   least the "red zone" size before allocating any space on
529 	   the stack.  */
530 	if (gdbarch_inner_than (gdbarch, 1, 2))
531 	  sp -= gdbarch_frame_red_zone_size (gdbarch);
532 	else
533 	  sp += gdbarch_frame_red_zone_size (gdbarch);
534 	/* Still aligned?  */
535 	gdb_assert (sp == gdbarch_frame_align (gdbarch, sp));
536 	/* NOTE: cagney/2002-09-18:
537 
538 	   On a RISC architecture, a void parameterless generic dummy
539 	   frame (i.e., no parameters, no result) typically does not
540 	   need to push anything the stack and hence can leave SP and
541 	   FP.  Similarly, a frameless (possibly leaf) function does
542 	   not push anything on the stack and, hence, that too can
543 	   leave FP and SP unchanged.  As a consequence, a sequence of
544 	   void parameterless generic dummy frame calls to frameless
545 	   functions will create a sequence of effectively identical
546 	   frames (SP, FP and TOS and PC the same).  This, not
547 	   suprisingly, results in what appears to be a stack in an
548 	   infinite loop --- when GDB tries to find a generic dummy
549 	   frame on the internal dummy frame stack, it will always
550 	   find the first one.
551 
552 	   To avoid this problem, the code below always grows the
553 	   stack.  That way, two dummy frames can never be identical.
554 	   It does burn a few bytes of stack but that is a small price
555 	   to pay :-).  */
556 	if (sp == old_sp)
557 	  {
558 	    if (gdbarch_inner_than (gdbarch, 1, 2))
559 	      /* Stack grows down.  */
560 	      sp = gdbarch_frame_align (gdbarch, old_sp - 1);
561 	    else
562 	      /* Stack grows up.  */
563 	      sp = gdbarch_frame_align (gdbarch, old_sp + 1);
564 	  }
565 	/* SP may have underflown address zero here from OLD_SP.  Memory access
566 	   functions will probably fail in such case but that is a target's
567 	   problem.  */
568       }
569     else
570       /* FIXME: cagney/2002-09-18: Hey, you loose!
571 
572 	 Who knows how badly aligned the SP is!
573 
574 	 If the generic dummy frame ends up empty (because nothing is
575 	 pushed) GDB won't be able to correctly perform back traces.
576 	 If a target is having trouble with backtraces, first thing to
577 	 do is add FRAME_ALIGN() to the architecture vector.  If that
578 	 fails, try dummy_id().
579 
580          If the ABI specifies a "Red Zone" (see the doco) the code
581          below will quietly trash it.  */
582       sp = old_sp;
583   }
584 
585   funaddr = find_function_addr (function, &values_type);
586   if (!values_type)
587     values_type = builtin_type (gdbarch)->builtin_int;
588 
589   CHECK_TYPEDEF (values_type);
590 
591   /* Are we returning a value using a structure return (passing a
592      hidden argument pointing to storage) or a normal value return?
593      There are two cases: language-mandated structure return and
594      target ABI structure return.  The variable STRUCT_RETURN only
595      describes the latter.  The language version is handled by passing
596      the return location as the first parameter to the function,
597      even preceding "this".  This is different from the target
598      ABI version, which is target-specific; for instance, on ia64
599      the first argument is passed in out0 but the hidden structure
600      return pointer would normally be passed in r8.  */
601 
602   if (language_pass_by_reference (values_type))
603     {
604       lang_struct_return = 1;
605 
606       /* Tell the target specific argument pushing routine not to
607 	 expect a value.  */
608       target_values_type = builtin_type (gdbarch)->builtin_void;
609     }
610   else
611     {
612       struct_return = using_struct_return (gdbarch,
613 					   value_type (function), values_type);
614       target_values_type = values_type;
615     }
616 
617   /* Determine the location of the breakpoint (and possibly other
618      stuff) that the called function will return to.  The SPARC, for a
619      function returning a structure or union, needs to make space for
620      not just the breakpoint but also an extra word containing the
621      size (?) of the structure being passed.  */
622 
623   /* The actual breakpoint (at BP_ADDR) is inserted separatly so there
624      is no need to write that out.  */
625 
626   switch (gdbarch_call_dummy_location (gdbarch))
627     {
628     case ON_STACK:
629       sp = push_dummy_code (gdbarch, sp, funaddr,
630 				args, nargs, target_values_type,
631 				&real_pc, &bp_addr, get_current_regcache ());
632       break;
633     case AT_ENTRY_POINT:
634       {
635 	CORE_ADDR dummy_addr;
636 
637 	real_pc = funaddr;
638 	dummy_addr = entry_point_address ();
639 	/* A call dummy always consists of just a single breakpoint, so
640 	   its address is the same as the address of the dummy.  */
641 	bp_addr = dummy_addr;
642 	break;
643       }
644     case AT_SYMBOL:
645       /* Some executables define a symbol __CALL_DUMMY_ADDRESS whose
646 	 address is the location where the breakpoint should be
647 	 placed.  Once all targets are using the overhauled frame code
648 	 this can be deleted - ON_STACK is a better option.  */
649       {
650 	struct minimal_symbol *sym;
651 	CORE_ADDR dummy_addr;
652 
653 	sym = lookup_minimal_symbol ("__CALL_DUMMY_ADDRESS", NULL, NULL);
654 	real_pc = funaddr;
655 	if (sym)
656 	  {
657 	    dummy_addr = SYMBOL_VALUE_ADDRESS (sym);
658 	    /* Make certain that the address points at real code, and not
659 	       a function descriptor.  */
660 	    dummy_addr = gdbarch_convert_from_func_ptr_addr (gdbarch,
661 							     dummy_addr,
662 							     &current_target);
663 	  }
664 	else
665 	  dummy_addr = entry_point_address ();
666 	/* A call dummy always consists of just a single breakpoint,
667 	   so it's address is the same as the address of the dummy.  */
668 	bp_addr = dummy_addr;
669 	break;
670       }
671     default:
672       internal_error (__FILE__, __LINE__, _("bad switch"));
673     }
674 
675   if (nargs < TYPE_NFIELDS (ftype))
676     error (_("Too few arguments in function call."));
677 
678   {
679     int i;
680 
681     for (i = nargs - 1; i >= 0; i--)
682       {
683 	int prototyped;
684 	struct type *param_type;
685 
686 	/* FIXME drow/2002-05-31: Should just always mark methods as
687 	   prototyped.  Can we respect TYPE_VARARGS?  Probably not.  */
688 	if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
689 	  prototyped = 1;
690 	else if (i < TYPE_NFIELDS (ftype))
691 	  prototyped = TYPE_PROTOTYPED (ftype);
692 	else
693 	  prototyped = 0;
694 
695 	if (i < TYPE_NFIELDS (ftype))
696 	  param_type = TYPE_FIELD_TYPE (ftype, i);
697 	else
698 	  param_type = NULL;
699 
700 	args[i] = value_arg_coerce (gdbarch, args[i],
701 				    param_type, prototyped, &sp);
702 
703 	if (param_type != NULL && language_pass_by_reference (param_type))
704 	  args[i] = value_addr (args[i]);
705       }
706   }
707 
708   /* Reserve space for the return structure to be written on the
709      stack, if necessary.  Make certain that the value is correctly
710      aligned.  */
711 
712   if (struct_return || lang_struct_return)
713     {
714       int len = TYPE_LENGTH (values_type);
715 
716       if (gdbarch_inner_than (gdbarch, 1, 2))
717 	{
718 	  /* Stack grows downward.  Align STRUCT_ADDR and SP after
719              making space for the return value.  */
720 	  sp -= len;
721 	  if (gdbarch_frame_align_p (gdbarch))
722 	    sp = gdbarch_frame_align (gdbarch, sp);
723 	  struct_addr = sp;
724 	}
725       else
726 	{
727 	  /* Stack grows upward.  Align the frame, allocate space, and
728              then again, re-align the frame???  */
729 	  if (gdbarch_frame_align_p (gdbarch))
730 	    sp = gdbarch_frame_align (gdbarch, sp);
731 	  struct_addr = sp;
732 	  sp += len;
733 	  if (gdbarch_frame_align_p (gdbarch))
734 	    sp = gdbarch_frame_align (gdbarch, sp);
735 	}
736     }
737 
738   if (lang_struct_return)
739     {
740       struct value **new_args;
741 
742       /* Add the new argument to the front of the argument list.  */
743       new_args = xmalloc (sizeof (struct value *) * (nargs + 1));
744       new_args[0] = value_from_pointer (lookup_pointer_type (values_type),
745 					struct_addr);
746       memcpy (&new_args[1], &args[0], sizeof (struct value *) * nargs);
747       args = new_args;
748       nargs++;
749       args_cleanup = make_cleanup (xfree, args);
750     }
751   else
752     args_cleanup = make_cleanup (null_cleanup, NULL);
753 
754   /* Create the dummy stack frame.  Pass in the call dummy address as,
755      presumably, the ABI code knows where, in the call dummy, the
756      return address should be pointed.  */
757   sp = gdbarch_push_dummy_call (gdbarch, function, get_current_regcache (),
758 				bp_addr, nargs, args,
759 				sp, struct_return, struct_addr);
760 
761   do_cleanups (args_cleanup);
762 
763   /* Set up a frame ID for the dummy frame so we can pass it to
764      set_momentary_breakpoint.  We need to give the breakpoint a frame
765      ID so that the breakpoint code can correctly re-identify the
766      dummy breakpoint.  */
767   /* Sanity.  The exact same SP value is returned by PUSH_DUMMY_CALL,
768      saved as the dummy-frame TOS, and used by dummy_id to form
769      the frame ID's stack address.  */
770   dummy_id = frame_id_build (sp, bp_addr);
771 
772   /* Create a momentary breakpoint at the return address of the
773      inferior.  That way it breaks when it returns.  */
774 
775   {
776     struct breakpoint *bpt;
777     struct symtab_and_line sal;
778 
779     init_sal (&sal);		/* initialize to zeroes */
780     sal.pspace = current_program_space;
781     sal.pc = bp_addr;
782     sal.section = find_pc_overlay (sal.pc);
783     /* Sanity.  The exact same SP value is returned by
784        PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
785        dummy_id to form the frame ID's stack address.  */
786     bpt = set_momentary_breakpoint (gdbarch, sal, dummy_id, bp_call_dummy);
787     bpt->disposition = disp_del;
788   }
789 
790   /* Create a breakpoint in std::terminate.
791      If a C++ exception is raised in the dummy-frame, and the
792      exception handler is (normally, and expected to be) out-of-frame,
793      the default C++ handler will (wrongly) be called in an inferior
794      function call.  This is wrong, as an exception can be  normally
795      and legally handled out-of-frame.  The confines of the dummy frame
796      prevent the unwinder from finding the correct handler (or any
797      handler, unless it is in-frame).  The default handler calls
798      std::terminate.  This will kill the inferior.  Assert that
799      terminate should never be called in an inferior function
800      call.  Place a momentary breakpoint in the std::terminate function
801      and if triggered in the call, rewind.  */
802   if (unwind_on_terminating_exception_p)
803     set_std_terminate_breakpoint ();
804 
805   /* Everything's ready, push all the info needed to restore the
806      caller (and identify the dummy-frame) onto the dummy-frame
807      stack.  */
808   dummy_frame_push (caller_state, &dummy_id);
809 
810   /* Discard both inf_status and caller_state cleanups.
811      From this point on we explicitly restore the associated state
812      or discard it.  */
813   discard_cleanups (inf_status_cleanup);
814 
815   /* Register a clean-up for unwind_on_terminating_exception_breakpoint.  */
816   terminate_bp_cleanup = make_cleanup (cleanup_delete_std_terminate_breakpoint,
817 				       NULL);
818 
819   /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP -
820      If you're looking to implement asynchronous dummy-frames, then
821      just below is the place to chop this function in two..  */
822 
823   /* TP is invalid after run_inferior_call returns, so enclose this
824      in a block so that it's only in scope during the time it's valid.  */
825   {
826     struct thread_info *tp = inferior_thread ();
827 
828     /* Save this thread's ptid, we need it later but the thread
829        may have exited.  */
830     call_thread_ptid = tp->ptid;
831 
832     /* Run the inferior until it stops.  */
833 
834     e = run_inferior_call (tp, real_pc);
835   }
836 
837   /* Rethrow an error if we got one trying to run the inferior.  */
838 
839   if (e.reason < 0)
840     {
841       const char *name = get_function_name (funaddr,
842                                             name_buf, sizeof (name_buf));
843 
844       discard_infcall_control_state (inf_status);
845 
846       /* We could discard the dummy frame here if the program exited,
847          but it will get garbage collected the next time the program is
848          run anyway.  */
849 
850       switch (e.reason)
851 	{
852 	case RETURN_ERROR:
853 	  throw_error (e.error, _("%s\n\
854 An error occurred while in a function called from GDB.\n\
855 Evaluation of the expression containing the function\n\
856 (%s) will be abandoned.\n\
857 When the function is done executing, GDB will silently stop."),
858 		       e.message, name);
859 	case RETURN_QUIT:
860 	default:
861 	  throw_exception (e);
862 	}
863     }
864 
865   /* If the program has exited, or we stopped at a different thread,
866      exit and inform the user.  */
867 
868   if (! target_has_execution)
869     {
870       const char *name = get_function_name (funaddr,
871 					    name_buf, sizeof (name_buf));
872 
873       /* If we try to restore the inferior status,
874 	 we'll crash as the inferior is no longer running.  */
875       discard_infcall_control_state (inf_status);
876 
877       /* We could discard the dummy frame here given that the program exited,
878          but it will get garbage collected the next time the program is
879          run anyway.  */
880 
881       error (_("The program being debugged exited while in a function "
882 	       "called from GDB.\n"
883 	       "Evaluation of the expression containing the function\n"
884 	       "(%s) will be abandoned."),
885 	     name);
886     }
887 
888   if (! ptid_equal (call_thread_ptid, inferior_ptid))
889     {
890       const char *name = get_function_name (funaddr,
891 					    name_buf, sizeof (name_buf));
892 
893       /* We've switched threads.  This can happen if another thread gets a
894 	 signal or breakpoint while our thread was running.
895 	 There's no point in restoring the inferior status,
896 	 we're in a different thread.  */
897       discard_infcall_control_state (inf_status);
898       /* Keep the dummy frame record, if the user switches back to the
899 	 thread with the hand-call, we'll need it.  */
900       if (stopped_by_random_signal)
901 	error (_("\
902 The program received a signal in another thread while\n\
903 making a function call from GDB.\n\
904 Evaluation of the expression containing the function\n\
905 (%s) will be abandoned.\n\
906 When the function is done executing, GDB will silently stop."),
907 	       name);
908       else
909 	error (_("\
910 The program stopped in another thread while making a function call from GDB.\n\
911 Evaluation of the expression containing the function\n\
912 (%s) will be abandoned.\n\
913 When the function is done executing, GDB will silently stop."),
914 	       name);
915     }
916 
917   if (stopped_by_random_signal || stop_stack_dummy != STOP_STACK_DUMMY)
918     {
919       const char *name = get_function_name (funaddr,
920 					    name_buf, sizeof (name_buf));
921 
922       if (stopped_by_random_signal)
923 	{
924 	  /* We stopped inside the FUNCTION because of a random
925 	     signal.  Further execution of the FUNCTION is not
926 	     allowed.  */
927 
928 	  if (unwind_on_signal_p)
929 	    {
930 	      /* The user wants the context restored.  */
931 
932 	      /* We must get back to the frame we were before the
933 		 dummy call.  */
934 	      dummy_frame_pop (dummy_id);
935 
936 	      /* We also need to restore inferior status to that before the
937 		 dummy call.  */
938 	      restore_infcall_control_state (inf_status);
939 
940 	      /* FIXME: Insert a bunch of wrap_here; name can be very
941 		 long if it's a C++ name with arguments and stuff.  */
942 	      error (_("\
943 The program being debugged was signaled while in a function called from GDB.\n\
944 GDB has restored the context to what it was before the call.\n\
945 To change this behavior use \"set unwindonsignal off\".\n\
946 Evaluation of the expression containing the function\n\
947 (%s) will be abandoned."),
948 		     name);
949 	    }
950 	  else
951 	    {
952 	      /* The user wants to stay in the frame where we stopped
953 		 (default).
954 		 Discard inferior status, we're not at the same point
955 		 we started at.  */
956 	      discard_infcall_control_state (inf_status);
957 
958 	      /* FIXME: Insert a bunch of wrap_here; name can be very
959 		 long if it's a C++ name with arguments and stuff.  */
960 	      error (_("\
961 The program being debugged was signaled while in a function called from GDB.\n\
962 GDB remains in the frame where the signal was received.\n\
963 To change this behavior use \"set unwindonsignal on\".\n\
964 Evaluation of the expression containing the function\n\
965 (%s) will be abandoned.\n\
966 When the function is done executing, GDB will silently stop."),
967 		     name);
968 	    }
969 	}
970 
971       if (stop_stack_dummy == STOP_STD_TERMINATE)
972 	{
973 	  /* We must get back to the frame we were before the dummy
974 	     call.  */
975 	  dummy_frame_pop (dummy_id);
976 
977 	  /* We also need to restore inferior status to that before
978 	     the dummy call.  */
979 	  restore_infcall_control_state (inf_status);
980 
981 	  error (_("\
982 The program being debugged entered a std::terminate call, most likely\n\
983 caused by an unhandled C++ exception.  GDB blocked this call in order\n\
984 to prevent the program from being terminated, and has restored the\n\
985 context to its original state before the call.\n\
986 To change this behaviour use \"set unwind-on-terminating-exception off\".\n\
987 Evaluation of the expression containing the function (%s)\n\
988 will be abandoned."),
989 		 name);
990 	}
991       else if (stop_stack_dummy == STOP_NONE)
992 	{
993 
994 	  /* We hit a breakpoint inside the FUNCTION.
995 	     Keep the dummy frame, the user may want to examine its state.
996 	     Discard inferior status, we're not at the same point
997 	     we started at.  */
998 	  discard_infcall_control_state (inf_status);
999 
1000 	  /* The following error message used to say "The expression
1001 	     which contained the function call has been discarded."
1002 	     It is a hard concept to explain in a few words.  Ideally,
1003 	     GDB would be able to resume evaluation of the expression
1004 	     when the function finally is done executing.  Perhaps
1005 	     someday this will be implemented (it would not be easy).  */
1006 	  /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
1007 	     a C++ name with arguments and stuff.  */
1008 	  error (_("\
1009 The program being debugged stopped while in a function called from GDB.\n\
1010 Evaluation of the expression containing the function\n\
1011 (%s) will be abandoned.\n\
1012 When the function is done executing, GDB will silently stop."),
1013 		 name);
1014 	}
1015 
1016       /* The above code errors out, so ...  */
1017       internal_error (__FILE__, __LINE__, _("... should not be here"));
1018     }
1019 
1020   do_cleanups (terminate_bp_cleanup);
1021 
1022   /* If we get here the called FUNCTION ran to completion,
1023      and the dummy frame has already been popped.  */
1024 
1025   {
1026     struct address_space *aspace = get_regcache_aspace (stop_registers);
1027     struct regcache *retbuf = regcache_xmalloc (gdbarch, aspace);
1028     struct cleanup *retbuf_cleanup = make_cleanup_regcache_xfree (retbuf);
1029     struct value *retval = NULL;
1030 
1031     regcache_cpy_no_passthrough (retbuf, stop_registers);
1032 
1033     /* Inferior call is successful.  Restore the inferior status.
1034        At this stage, leave the RETBUF alone.  */
1035     restore_infcall_control_state (inf_status);
1036 
1037     /* Figure out the value returned by the function.  */
1038     retval = allocate_value (values_type);
1039 
1040     if (lang_struct_return)
1041       read_value_memory (retval, 0, 1, struct_addr,
1042 			 value_contents_raw (retval),
1043 			 TYPE_LENGTH (values_type));
1044     else if (TYPE_CODE (target_values_type) != TYPE_CODE_VOID)
1045       {
1046 	/* If the function returns void, don't bother fetching the
1047 	   return value.  */
1048 	switch (gdbarch_return_value (gdbarch, value_type (function),
1049 				      target_values_type, NULL, NULL, NULL))
1050 	  {
1051 	  case RETURN_VALUE_REGISTER_CONVENTION:
1052 	  case RETURN_VALUE_ABI_RETURNS_ADDRESS:
1053 	  case RETURN_VALUE_ABI_PRESERVES_ADDRESS:
1054 	    gdbarch_return_value (gdbarch, value_type (function), values_type,
1055 				  retbuf, value_contents_raw (retval), NULL);
1056 	    break;
1057 	  case RETURN_VALUE_STRUCT_CONVENTION:
1058 	    read_value_memory (retval, 0, 1, struct_addr,
1059 			       value_contents_raw (retval),
1060 			       TYPE_LENGTH (values_type));
1061 	    break;
1062 	  }
1063       }
1064 
1065     do_cleanups (retbuf_cleanup);
1066 
1067     gdb_assert (retval);
1068     return retval;
1069   }
1070 }
1071 
1072 
1073 /* Provide a prototype to silence -Wmissing-prototypes.  */
1074 void _initialize_infcall (void);
1075 
1076 void
1077 _initialize_infcall (void)
1078 {
1079   add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure,
1080 			   &coerce_float_to_double_p, _("\
1081 Set coercion of floats to doubles when calling functions."), _("\
1082 Show coercion of floats to doubles when calling functions"), _("\
1083 Variables of type float should generally be converted to doubles before\n\
1084 calling an unprototyped function, and left alone when calling a prototyped\n\
1085 function.  However, some older debug info formats do not provide enough\n\
1086 information to determine that a function is prototyped.  If this flag is\n\
1087 set, GDB will perform the conversion for a function it considers\n\
1088 unprototyped.\n\
1089 The default is to perform the conversion.\n"),
1090 			   NULL,
1091 			   show_coerce_float_to_double_p,
1092 			   &setlist, &showlist);
1093 
1094   add_setshow_boolean_cmd ("unwindonsignal", no_class,
1095 			   &unwind_on_signal_p, _("\
1096 Set unwinding of stack if a signal is received while in a call dummy."), _("\
1097 Show unwinding of stack if a signal is received while in a call dummy."), _("\
1098 The unwindonsignal lets the user determine what gdb should do if a signal\n\
1099 is received while in a function called from gdb (call dummy).  If set, gdb\n\
1100 unwinds the stack and restore the context to what as it was before the call.\n\
1101 The default is to stop in the frame where the signal was received."),
1102 			   NULL,
1103 			   show_unwind_on_signal_p,
1104 			   &setlist, &showlist);
1105 
1106   add_setshow_boolean_cmd ("unwind-on-terminating-exception", no_class,
1107 			   &unwind_on_terminating_exception_p, _("\
1108 Set unwinding of stack if std::terminate is called while in call dummy."), _("\
1109 Show unwinding of stack if std::terminate() is called while in a call dummy."),
1110 			   _("\
1111 The unwind on terminating exception flag lets the user determine\n\
1112 what gdb should do if a std::terminate() call is made from the\n\
1113 default exception handler.  If set, gdb unwinds the stack and restores\n\
1114 the context to what it was before the call.  If unset, gdb allows the\n\
1115 std::terminate call to proceed.\n\
1116 The default is to unwind the frame."),
1117 			   NULL,
1118 			   show_unwind_on_terminating_exception_p,
1119 			   &setlist, &showlist);
1120 
1121 }
1122