gdb/infcall.c

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