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