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_suppress_resume_observer = suppress_resume_observer;
 334   int saved_suppress_stop_observer = suppress_stop_observer;
 335   ptid_t call_thread_ptid = call_thread->ptid;
 336   char *saved_target_shortname = xstrdup (target_shortname);
 337
 338   clear_proceed_status ();
 339
 340   disable_watchpoints_before_interactive_call_start ();
 341   call_thread->proceed_to_finish = 1; /* We want stop_registers, please... */
 342
 343   if (target_can_async_p ())
 344     saved_async = target_async_mask (0);
 345
 346   suppress_resume_observer = 1;
 347   suppress_stop_observer = 1;
 348
 349   TRY_CATCH (e, RETURN_MASK_ALL)
 350     proceed (real_pc, TARGET_SIGNAL_0, 0);
 351
 352   /* At this point the current thread may have changed.
 353      CALL_THREAD is no longer usable as its thread may have exited.
 354      Set it to NULL to prevent its further use.  */
 355   call_thread = NULL;
 356
 357   suppress_resume_observer = saved_suppress_resume_observer;
 358   suppress_stop_observer = saved_suppress_stop_observer;
 359
 360   /* Don't restore the async mask if the target has changed,
 361      saved_async is for the original target.  */
 362   if (saved_async
 363       && strcmp (saved_target_shortname, target_shortname) == 0)
 364     target_async_mask (saved_async);
 365
 366   enable_watchpoints_after_interactive_call_stop ();
 367
 368   /* Call breakpoint_auto_delete on the current contents of the bpstat
 369      of inferior call thread.
 370      If all error()s out of proceed ended up calling normal_stop
 371      (and perhaps they should; it already does in the special case
 372      of error out of resume()), then we wouldn't need this.  */
 373   if (e.reason < 0)
 374     {
 375       struct thread_info *tp = find_thread_pid (call_thread_ptid);
 376       if (tp != NULL)
 377         breakpoint_auto_delete (tp->stop_bpstat);
 378     }
 379
 380   xfree (saved_target_shortname);
 381
 382   return e;
 383 }
 384
 385 /* All this stuff with a dummy frame may seem unnecessarily complicated
 386    (why not just save registers in GDB?).  The purpose of pushing a dummy
 387    frame which looks just like a real frame is so that if you call a
 388    function and then hit a breakpoint (get a signal, etc), "backtrace"
 389    will look right.  Whether the backtrace needs to actually show the
 390    stack at the time the inferior function was called is debatable, but
 391    it certainly needs to not display garbage.  So if you are contemplating
 392    making dummy frames be different from normal frames, consider that.  */
 393
 394 /* Perform a function call in the inferior.
 395    ARGS is a vector of values of arguments (NARGS of them).
 396    FUNCTION is a value, the function to be called.
 397    Returns a value representing what the function returned.
 398    May fail to return, if a breakpoint or signal is hit
 399    during the execution of the function.
 400
 401    ARGS is modified to contain coerced values. */
 402
 403 struct value *
 404 call_function_by_hand (struct value *function, int nargs, struct value **args)
 405 {
 406   CORE_ADDR sp;
 407   struct type *values_type, *target_values_type;
 408   unsigned char struct_return = 0, lang_struct_return = 0;
 409   CORE_ADDR struct_addr = 0;
 410   struct inferior_status *inf_status;
 411   struct cleanup *inf_status_cleanup;
 412   struct inferior_thread_state *caller_state;
 413   struct cleanup *caller_state_cleanup;
 414   CORE_ADDR funaddr;
 415   CORE_ADDR real_pc;
 416   struct type *ftype = check_typedef (value_type (function));
 417   CORE_ADDR bp_addr;
 418   struct frame_id dummy_id;
 419   struct cleanup *args_cleanup;
 420   struct frame_info *frame;
 421   struct gdbarch *gdbarch;
 422   ptid_t call_thread_ptid;
 423   struct gdb_exception e;
 424   const char *name;
 425   char name_buf[RAW_FUNCTION_ADDRESS_SIZE];
 426
 427   if (TYPE_CODE (ftype) == TYPE_CODE_PTR)
 428     ftype = check_typedef (TYPE_TARGET_TYPE (ftype));
 429
 430   if (!target_has_execution)
 431     noprocess ();
 432
 433   frame = get_current_frame ();
 434   gdbarch = get_frame_arch (frame);
 435
 436   if (!gdbarch_push_dummy_call_p (gdbarch))
 437     error (_("This target does not support function calls."));
 438
 439   /* A cleanup for the inferior status.
 440      This is only needed while we're preparing the inferior function call.  */
 441   inf_status = save_inferior_status ();
 442   inf_status_cleanup = make_cleanup_restore_inferior_status (inf_status);
 443
 444   /* Save the caller's registers and other state associated with the
 445      inferior itself so that they can be restored once the
 446      callee returns.  To allow nested calls the registers are (further
 447      down) pushed onto a dummy frame stack.  Include a cleanup (which
 448      is tossed once the regcache has been pushed).  */
 449   caller_state = save_inferior_thread_state ();
 450   caller_state_cleanup = make_cleanup_restore_inferior_thread_state (caller_state);
 451
 452   /* Ensure that the initial SP is correctly aligned.  */
 453   {
 454     CORE_ADDR old_sp = get_frame_sp (frame);
 455     if (gdbarch_frame_align_p (gdbarch))
 456       {
 457         sp = gdbarch_frame_align (gdbarch, old_sp);
 458         /* NOTE: cagney/2003-08-13: Skip the "red zone".  For some
 459            ABIs, a function can use memory beyond the inner most stack
 460            address.  AMD64 called that region the "red zone".  Skip at
 461            least the "red zone" size before allocating any space on
 462            the stack.  */
 463         if (gdbarch_inner_than (gdbarch, 1, 2))
 464           sp -= gdbarch_frame_red_zone_size (gdbarch);
 465         else
 466           sp += gdbarch_frame_red_zone_size (gdbarch);
 467         /* Still aligned?  */
 468         gdb_assert (sp == gdbarch_frame_align (gdbarch, sp));
 469         /* NOTE: cagney/2002-09-18:
 470
 471            On a RISC architecture, a void parameterless generic dummy
 472            frame (i.e., no parameters, no result) typically does not
 473            need to push anything the stack and hence can leave SP and
 474            FP.  Similarly, a frameless (possibly leaf) function does
 475            not push anything on the stack and, hence, that too can
 476            leave FP and SP unchanged.  As a consequence, a sequence of
 477            void parameterless generic dummy frame calls to frameless
 478            functions will create a sequence of effectively identical
 479            frames (SP, FP and TOS and PC the same).  This, not
 480            suprisingly, results in what appears to be a stack in an
 481            infinite loop --- when GDB tries to find a generic dummy
 482            frame on the internal dummy frame stack, it will always
 483            find the first one.
 484
 485            To avoid this problem, the code below always grows the
 486            stack.  That way, two dummy frames can never be identical.
 487            It does burn a few bytes of stack but that is a small price
 488            to pay :-).  */
 489         if (sp == old_sp)
 490           {
 491             if (gdbarch_inner_than (gdbarch, 1, 2))
 492               /* Stack grows down.  */
 493               sp = gdbarch_frame_align (gdbarch, old_sp - 1);
 494             else
 495               /* Stack grows up.  */
 496               sp = gdbarch_frame_align (gdbarch, old_sp + 1);
 497           }
 498         gdb_assert ((gdbarch_inner_than (gdbarch, 1, 2)
 499                     && sp <= old_sp)
 500                     || (gdbarch_inner_than (gdbarch, 2, 1)
 501                        && sp >= old_sp));
 502       }
 503     else
 504       /* FIXME: cagney/2002-09-18: Hey, you loose!
 505
 506          Who knows how badly aligned the SP is!
 507
 508          If the generic dummy frame ends up empty (because nothing is
 509          pushed) GDB won't be able to correctly perform back traces.
 510          If a target is having trouble with backtraces, first thing to
 511          do is add FRAME_ALIGN() to the architecture vector. If that
 512          fails, try dummy_id().
 513
 514          If the ABI specifies a "Red Zone" (see the doco) the code
 515          below will quietly trash it.  */
 516       sp = old_sp;
 517   }
 518
 519   funaddr = find_function_addr (function, &values_type);
 520   if (!values_type)
 521     values_type = builtin_type (gdbarch)->builtin_int;
 522
 523   CHECK_TYPEDEF (values_type);
 524
 525   /* Are we returning a value using a structure return (passing a
 526      hidden argument pointing to storage) or a normal value return?
 527      There are two cases: language-mandated structure return and
 528      target ABI structure return.  The variable STRUCT_RETURN only
 529      describes the latter.  The language version is handled by passing
 530      the return location as the first parameter to the function,
 531      even preceding "this".  This is different from the target
 532      ABI version, which is target-specific; for instance, on ia64
 533      the first argument is passed in out0 but the hidden structure
 534      return pointer would normally be passed in r8.  */
 535
 536   if (language_pass_by_reference (values_type))
 537     {
 538       lang_struct_return = 1;
 539
 540       /* Tell the target specific argument pushing routine not to
 541          expect a value.  */
 542       target_values_type = builtin_type_void;
 543     }
 544   else
 545     {
 546       struct_return = using_struct_return (value_type (function), values_type);
 547       target_values_type = values_type;
 548     }
 549
 550   /* Determine the location of the breakpoint (and possibly other
 551      stuff) that the called function will return to.  The SPARC, for a
 552      function returning a structure or union, needs to make space for
 553      not just the breakpoint but also an extra word containing the
 554      size (?) of the structure being passed.  */
 555
 556   /* The actual breakpoint (at BP_ADDR) is inserted separatly so there
 557      is no need to write that out.  */
 558
 559   switch (gdbarch_call_dummy_location (gdbarch))
 560     {
 561     case ON_STACK:
 562       sp = push_dummy_code (gdbarch, sp, funaddr,
 563                                 args, nargs, target_values_type,
 564                                 &real_pc, &bp_addr, get_current_regcache ());
 565       break;
 566     case AT_ENTRY_POINT:
 567       {
 568         CORE_ADDR dummy_addr;
 569
 570         real_pc = funaddr;
 571         dummy_addr = entry_point_address ();
 572         /* Make certain that the address points at real code, and not a
 573            function descriptor.  */
 574         dummy_addr = gdbarch_convert_from_func_ptr_addr (gdbarch,
 575                                                          dummy_addr,
 576                                                          &current_target);
 577         /* A call dummy always consists of just a single breakpoint, so
 578            its address is the same as the address of the dummy.  */
 579         bp_addr = dummy_addr;
 580         break;
 581       }
 582     case AT_SYMBOL:
 583       /* Some executables define a symbol __CALL_DUMMY_ADDRESS whose
 584          address is the location where the breakpoint should be
 585          placed.  Once all targets are using the overhauled frame code
 586          this can be deleted - ON_STACK is a better option.  */
 587       {
 588         struct minimal_symbol *sym;
 589         CORE_ADDR dummy_addr;
 590
 591         sym = lookup_minimal_symbol ("__CALL_DUMMY_ADDRESS", NULL, NULL);
 592         real_pc = funaddr;
 593         if (sym)
 594           dummy_addr = SYMBOL_VALUE_ADDRESS (sym);
 595         else
 596           dummy_addr = entry_point_address ();
 597         /* Make certain that the address points at real code, and not
 598            a function descriptor.  */
 599         dummy_addr = gdbarch_convert_from_func_ptr_addr (gdbarch,
 600                                                          dummy_addr,
 601                                                          &current_target);
 602         /* A call dummy always consists of just a single breakpoint,
 603            so it's address is the same as the address of the dummy.  */
 604         bp_addr = dummy_addr;
 605         break;
 606       }
 607     default:
 608       internal_error (__FILE__, __LINE__, _("bad switch"));
 609     }
 610
 611   if (nargs < TYPE_NFIELDS (ftype))
 612     error (_("Too few arguments in function call."));
 613
 614   {
 615     int i;
 616     for (i = nargs - 1; i >= 0; i--)
 617       {
 618         int prototyped;
 619         struct type *param_type;
 620
 621         /* FIXME drow/2002-05-31: Should just always mark methods as
 622            prototyped.  Can we respect TYPE_VARARGS?  Probably not.  */
 623         if (TYPE_CODE (ftype) == TYPE_CODE_METHOD)
 624           prototyped = 1;
 625         else if (i < TYPE_NFIELDS (ftype))
 626           prototyped = TYPE_PROTOTYPED (ftype);
 627         else
 628           prototyped = 0;
 629
 630         if (i < TYPE_NFIELDS (ftype))
 631           param_type = TYPE_FIELD_TYPE (ftype, i);
 632         else
 633           param_type = NULL;
 634
 635         args[i] = value_arg_coerce (gdbarch, args[i],
 636                                     param_type, prototyped, &sp);
 637
 638         if (param_type != NULL && language_pass_by_reference (param_type))
 639           args[i] = value_addr (args[i]);
 640       }
 641   }
 642
 643   /* Reserve space for the return structure to be written on the
 644      stack, if necessary.  Make certain that the value is correctly
 645      aligned. */
 646
 647   if (struct_return || lang_struct_return)
 648     {
 649       int len = TYPE_LENGTH (values_type);
 650       if (gdbarch_inner_than (gdbarch, 1, 2))
 651         {
 652           /* Stack grows downward.  Align STRUCT_ADDR and SP after
 653              making space for the return value.  */
 654           sp -= len;
 655           if (gdbarch_frame_align_p (gdbarch))
 656             sp = gdbarch_frame_align (gdbarch, sp);
 657           struct_addr = sp;
 658         }
 659       else
 660         {
 661           /* Stack grows upward.  Align the frame, allocate space, and
 662              then again, re-align the frame??? */
 663           if (gdbarch_frame_align_p (gdbarch))
 664             sp = gdbarch_frame_align (gdbarch, sp);
 665           struct_addr = sp;
 666           sp += len;
 667           if (gdbarch_frame_align_p (gdbarch))
 668             sp = gdbarch_frame_align (gdbarch, sp);
 669         }
 670     }
 671
 672   if (lang_struct_return)
 673     {
 674       struct value **new_args;
 675
 676       /* Add the new argument to the front of the argument list.  */
 677       new_args = xmalloc (sizeof (struct value *) * (nargs + 1));
 678       new_args[0] = value_from_pointer (lookup_pointer_type (values_type),
 679                                         struct_addr);
 680       memcpy (&new_args[1], &args[0], sizeof (struct value *) * nargs);
 681       args = new_args;
 682       nargs++;
 683       args_cleanup = make_cleanup (xfree, args);
 684     }
 685   else
 686     args_cleanup = make_cleanup (null_cleanup, NULL);
 687
 688   /* Create the dummy stack frame.  Pass in the call dummy address as,
 689      presumably, the ABI code knows where, in the call dummy, the
 690      return address should be pointed.  */
 691   sp = gdbarch_push_dummy_call (gdbarch, function, get_current_regcache (),
 692                                 bp_addr, nargs, args,
 693                                 sp, struct_return, struct_addr);
 694
 695   do_cleanups (args_cleanup);
 696
 697   /* Set up a frame ID for the dummy frame so we can pass it to
 698      set_momentary_breakpoint.  We need to give the breakpoint a frame
 699      ID so that the breakpoint code can correctly re-identify the
 700      dummy breakpoint.  */
 701   /* Sanity.  The exact same SP value is returned by PUSH_DUMMY_CALL,
 702      saved as the dummy-frame TOS, and used by dummy_id to form
 703      the frame ID's stack address.  */
 704   dummy_id = frame_id_build (sp, bp_addr);
 705
 706   /* Create a momentary breakpoint at the return address of the
 707      inferior.  That way it breaks when it returns.  */
 708
 709   {
 710     struct breakpoint *bpt;
 711     struct symtab_and_line sal;
 712     init_sal (&sal);            /* initialize to zeroes */
 713     sal.pc = bp_addr;
 714     sal.section = find_pc_overlay (sal.pc);
 715     /* Sanity.  The exact same SP value is returned by
 716        PUSH_DUMMY_CALL, saved as the dummy-frame TOS, and used by
 717        dummy_id to form the frame ID's stack address.  */
 718     bpt = set_momentary_breakpoint (sal, dummy_id, bp_call_dummy);
 719     bpt->disposition = disp_del;
 720   }
 721
 722   /* Everything's ready, push all the info needed to restore the
 723      caller (and identify the dummy-frame) onto the dummy-frame
 724      stack.  */
 725   dummy_frame_push (caller_state, &dummy_id);
 726
 727   /* Discard both inf_status and caller_state cleanups.
 728      From this point on we explicitly restore the associated state
 729      or discard it.  */
 730   discard_cleanups (inf_status_cleanup);
 731
 732   /* - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP - SNIP -
 733      If you're looking to implement asynchronous dummy-frames, then
 734      just below is the place to chop this function in two..  */
 735
 736   /* TP is invalid after run_inferior_call returns, so enclose this
 737      in a block so that it's only in scope during the time it's valid.  */
 738   {
 739     struct thread_info *tp = inferior_thread ();
 740
 741     /* Save this thread's ptid, we need it later but the thread
 742        may have exited.  */
 743     call_thread_ptid = tp->ptid;
 744
 745     /* Run the inferior until it stops.  */
 746
 747     e = run_inferior_call (tp, real_pc);
 748   }
 749
 750   /* Rethrow an error if we got one trying to run the inferior.  */
 751
 752   if (e.reason < 0)
 753     {
 754       const char *name = get_function_name (funaddr,
 755                                             name_buf, sizeof (name_buf));
 756
 757       discard_inferior_status (inf_status);
 758
 759       /* We could discard the dummy frame here if the program exited,
 760          but it will get garbage collected the next time the program is
 761          run anyway.  */
 762
 763       switch (e.reason)
 764         {
 765         case RETURN_ERROR:
 766           throw_error (e.error, _("\
 767 %s\n\
 768 An error occurred while in a function called from GDB.\n\
 769 Evaluation of the expression containing the function\n\
 770 (%s) will be abandoned.\n\
 771 When the function is done executing, GDB will silently stop."),
 772                        e.message, name);
 773         case RETURN_QUIT:
 774         default:
 775           throw_exception (e);
 776         }
 777     }
 778
 779   /* If the program has exited, or we stopped at a different thread,
 780      exit and inform the user.  */
 781
 782   if (! target_has_execution)
 783     {
 784       const char *name = get_function_name (funaddr,
 785                                             name_buf, sizeof (name_buf));
 786
 787       /* If we try to restore the inferior status,
 788          we'll crash as the inferior is no longer running.  */
 789       discard_inferior_status (inf_status);
 790
 791       /* We could discard the dummy frame here given that the program exited,
 792          but it will get garbage collected the next time the program is
 793          run anyway.  */
 794
 795       error (_("\
 796 The program being debugged exited while in a function called from GDB.\n\
 797 Evaluation of the expression containing the function\n\
 798 (%s) will be abandoned."),
 799              name);
 800     }
 801
 802   if (! ptid_equal (call_thread_ptid, inferior_ptid))
 803     {
 804       const char *name = get_function_name (funaddr,
 805                                             name_buf, sizeof (name_buf));
 806
 807       /* We've switched threads.  This can happen if another thread gets a
 808          signal or breakpoint while our thread was running.
 809          There's no point in restoring the inferior status,
 810          we're in a different thread.  */
 811       discard_inferior_status (inf_status);
 812       /* Keep the dummy frame record, if the user switches back to the
 813          thread with the hand-call, we'll need it.  */
 814       if (stopped_by_random_signal)
 815         error (_("\
 816 The program received a signal in another thread while\n\
 817 making a function call from GDB.\n\
 818 Evaluation of the expression containing the function\n\
 819 (%s) will be abandoned.\n\
 820 When the function is done executing, GDB will silently stop."),
 821                name);
 822       else
 823         error (_("\
 824 The program stopped in another thread while making a function call from GDB.\n\
 825 Evaluation of the expression containing the function\n\
 826 (%s) will be abandoned.\n\
 827 When the function is done executing, GDB will silently stop."),
 828                name);
 829     }
 830
 831   if (stopped_by_random_signal || !stop_stack_dummy)
 832     {
 833       const char *name = get_function_name (funaddr,
 834                                             name_buf, sizeof (name_buf));
 835
 836       if (stopped_by_random_signal)
 837         {
 838           /* We stopped inside the FUNCTION because of a random
 839              signal.  Further execution of the FUNCTION is not
 840              allowed. */
 841
 842           if (unwind_on_signal_p)
 843             {
 844               /* The user wants the context restored. */
 845
 846               /* We must get back to the frame we were before the
 847                  dummy call.  */
 848               dummy_frame_pop (dummy_id);
 849
 850               /* We also need to restore inferior status to that before the
 851                  dummy call.  */
 852               restore_inferior_status (inf_status);
 853
 854               /* FIXME: Insert a bunch of wrap_here; name can be very
 855                  long if it's a C++ name with arguments and stuff.  */
 856               error (_("\
 857 The program being debugged was signaled while in a function called from GDB.\n\
 858 GDB has restored the context to what it was before the call.\n\
 859 To change this behavior use \"set unwindonsignal off\".\n\
 860 Evaluation of the expression containing the function\n\
 861 (%s) will be abandoned."),
 862                      name);
 863             }
 864           else
 865             {
 866               /* The user wants to stay in the frame where we stopped
 867                  (default).
 868                  Discard inferior status, we're not at the same point
 869                  we started at.  */
 870               discard_inferior_status (inf_status);
 871
 872               /* FIXME: Insert a bunch of wrap_here; name can be very
 873                  long if it's a C++ name with arguments and stuff.  */
 874               error (_("\
 875 The program being debugged was signaled while in a function called from GDB.\n\
 876 GDB remains in the frame where the signal was received.\n\
 877 To change this behavior use \"set unwindonsignal on\".\n\
 878 Evaluation of the expression containing the function\n\
 879 (%s) will be abandoned.\n\
 880 When the function is done executing, GDB will silently stop."),
 881                      name);
 882             }
 883         }
 884
 885       if (!stop_stack_dummy)
 886         {
 887           /* We hit a breakpoint inside the FUNCTION.
 888              Keep the dummy frame, the user may want to examine its state.
 889              Discard inferior status, we're not at the same point
 890              we started at.  */
 891           discard_inferior_status (inf_status);
 892
 893           /* The following error message used to say "The expression
 894              which contained the function call has been discarded."
 895              It is a hard concept to explain in a few words.  Ideally,
 896              GDB would be able to resume evaluation of the expression
 897              when the function finally is done executing.  Perhaps
 898              someday this will be implemented (it would not be easy).  */
 899           /* FIXME: Insert a bunch of wrap_here; name can be very long if it's
 900              a C++ name with arguments and stuff.  */
 901           error (_("\
 902 The program being debugged stopped while in a function called from GDB.\n\
 903 Evaluation of the expression containing the function\n\
 904 (%s) will be abandoned.\n\
 905 When the function is done executing, GDB will silently stop."),
 906                  name);
 907         }
 908
 909       /* The above code errors out, so ...  */
 910       internal_error (__FILE__, __LINE__, _("... should not be here"));
 911     }
 912
 913   /* If we get here the called FUNCTION ran to completion,
 914      and the dummy frame has already been popped.  */
 915
 916   {
 917     struct regcache *retbuf = regcache_xmalloc (gdbarch);
 918     struct cleanup *retbuf_cleanup = make_cleanup_regcache_xfree (retbuf);
 919     struct value *retval = NULL;
 920
 921     regcache_cpy_no_passthrough (retbuf, stop_registers);
 922
 923     /* Inferior call is successful.  Restore the inferior status.
 924        At this stage, leave the RETBUF alone.  */
 925     restore_inferior_status (inf_status);
 926
 927     /* Figure out the value returned by the function.  */
 928
 929     if (lang_struct_return)
 930       retval = value_at (values_type, struct_addr);
 931     else if (TYPE_CODE (target_values_type) == TYPE_CODE_VOID)
 932       {
 933         /* If the function returns void, don't bother fetching the
 934            return value.  */
 935         retval = allocate_value (values_type);
 936       }
 937     else
 938       {
 939         switch (gdbarch_return_value (gdbarch, value_type (function),
 940                                       target_values_type, NULL, NULL, NULL))
 941           {
 942           case RETURN_VALUE_REGISTER_CONVENTION:
 943           case RETURN_VALUE_ABI_RETURNS_ADDRESS:
 944           case RETURN_VALUE_ABI_PRESERVES_ADDRESS:
 945             retval = allocate_value (values_type);
 946             gdbarch_return_value (gdbarch, value_type (function), values_type,
 947                                   retbuf, value_contents_raw (retval), NULL);
 948             break;
 949           case RETURN_VALUE_STRUCT_CONVENTION:
 950             retval = value_at (values_type, struct_addr);
 951             break;
 952           }
 953       }
 954
 955     do_cleanups (retbuf_cleanup);
 956
 957     gdb_assert (retval);
 958     return retval;
 959   }
 960 }
 961 \f
 962
 963 /* Provide a prototype to silence -Wmissing-prototypes.  */
 964 void _initialize_infcall (void);
 965
 966 void
 967 _initialize_infcall (void)
 968 {
 969   add_setshow_boolean_cmd ("coerce-float-to-double", class_obscure,
 970                            &coerce_float_to_double_p, _("\
 971 Set coercion of floats to doubles when calling functions."), _("\
 972 Show coercion of floats to doubles when calling functions"), _("\
 973 Variables of type float should generally be converted to doubles before\n\
 974 calling an unprototyped function, and left alone when calling a prototyped\n\
 975 function.  However, some older debug info formats do not provide enough\n\
 976 information to determine that a function is prototyped.  If this flag is\n\
 977 set, GDB will perform the conversion for a function it considers\n\
 978 unprototyped.\n\
 979 The default is to perform the conversion.\n"),
 980                            NULL,
 981                            show_coerce_float_to_double_p,
 982                            &setlist, &showlist);
 983
 984   add_setshow_boolean_cmd ("unwindonsignal", no_class,
 985                            &unwind_on_signal_p, _("\
 986 Set unwinding of stack if a signal is received while in a call dummy."), _("\
 987 Show unwinding of stack if a signal is received while in a call dummy."), _("\
 988 The unwindonsignal lets the user determine what gdb should do if a signal\n\
 989 is received while in a function called from gdb (call dummy).  If set, gdb\n\
 990 unwinds the stack and restore the context to what as it was before the call.\n\
 991 The default is to stop in the frame where the signal was received."),
 992                            NULL,
 993                            show_unwind_on_signal_p,
 994                            &setlist, &showlist);
 995 }