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