gcc/calls.c

   1 /* Convert function calls to rtl insns, for GNU C compiler.
   2    Copyright (C) 1989, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 #include "config.h"
  22 #include "rtl.h"
  23 #include "tree.h"
  24 #include "flags.h"
  25 #include "expr.h"
  26 #ifdef __STDC__
  27 #include <stdarg.h>
  28 #else
  29 #include <varargs.h>
  30 #endif
  31 #include "insn-flags.h"
  32
  33 /* Decide whether a function's arguments should be processed
  34    from first to last or from last to first.
  35
  36    They should if the stack and args grow in opposite directions, but
  37    only if we have push insns.  */
  38
  39 #ifdef PUSH_ROUNDING
  40
  41 #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD)
  42 #define PUSH_ARGS_REVERSED      /* If it's last to first */
  43 #endif
  44
  45 #endif
  46
  47 /* Like STACK_BOUNDARY but in units of bytes, not bits.  */
  48 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
  49
  50 /* Data structure and subroutines used within expand_call.  */
  51
  52 struct arg_data
  53 {
  54   /* Tree node for this argument.  */
  55   tree tree_value;
  56   /* Mode for value; TYPE_MODE unless promoted.  */
  57   enum machine_mode mode;
  58   /* Current RTL value for argument, or 0 if it isn't precomputed.  */
  59   rtx value;
  60   /* Initially-compute RTL value for argument; only for const functions.  */
  61   rtx initial_value;
  62   /* Register to pass this argument in, 0 if passed on stack, or an
  63      EXPR_LIST if the arg is to be copied into multiple different
  64      registers.  */
  65   rtx reg;
  66   /* If REG was promoted from the actual mode of the argument expression,
  67      indicates whether the promotion is sign- or zero-extended.  */
  68   int unsignedp;
  69   /* Number of registers to use.  0 means put the whole arg in registers.
  70      Also 0 if not passed in registers.  */
  71   int partial;
  72   /* Non-zero if argument must be passed on stack.
  73      Note that some arguments may be passed on the stack
  74      even though pass_on_stack is zero, just because FUNCTION_ARG says so.
  75      pass_on_stack identifies arguments that *cannot* go in registers.  */
  76   int pass_on_stack;
  77   /* Offset of this argument from beginning of stack-args.  */
  78   struct args_size offset;
  79   /* Similar, but offset to the start of the stack slot.  Different from
  80      OFFSET if this arg pads downward.  */
  81   struct args_size slot_offset;
  82   /* Size of this argument on the stack, rounded up for any padding it gets,
  83      parts of the argument passed in registers do not count.
  84      If REG_PARM_STACK_SPACE is defined, then register parms
  85      are counted here as well.  */
  86   struct args_size size;
  87   /* Location on the stack at which parameter should be stored.  The store
  88      has already been done if STACK == VALUE.  */
  89   rtx stack;
  90   /* Location on the stack of the start of this argument slot.  This can
  91      differ from STACK if this arg pads downward.  This location is known
  92      to be aligned to FUNCTION_ARG_BOUNDARY.  */
  93   rtx stack_slot;
  94 #ifdef ACCUMULATE_OUTGOING_ARGS
  95   /* Place that this stack area has been saved, if needed.  */
  96   rtx save_area;
  97 #endif
  98   /* If an argument's alignment does not permit direct copying into registers,
  99      copy in smaller-sized pieces into pseudos.  These are stored in a
 100      block pointed to by this field.  The next field says how many
 101      word-sized pseudos we made.  */
 102   rtx *aligned_regs;
 103   int n_aligned_regs;
 104 };
 105
 106 #ifdef ACCUMULATE_OUTGOING_ARGS
 107 /* A vector of one char per byte of stack space.  A byte if non-zero if
 108    the corresponding stack location has been used.
 109    This vector is used to prevent a function call within an argument from
 110    clobbering any stack already set up.  */
 111 static char *stack_usage_map;
 112
 113 /* Size of STACK_USAGE_MAP.  */
 114 static int highest_outgoing_arg_in_use;
 115
 116 /* stack_arg_under_construction is nonzero when an argument may be
 117    initialized with a constructor call (including a C function that
 118    returns a BLKmode struct) and expand_call must take special action
 119    to make sure the object being constructed does not overlap the
 120    argument list for the constructor call.  */
 121 int stack_arg_under_construction;
 122 #endif
 123
 124 static int calls_function       PROTO((tree, int));
 125 static int calls_function_1     PROTO((tree, int));
 126 static void emit_call_1         PROTO((rtx, tree, tree, int, int, rtx, rtx,
 127                                        int, rtx, int));
 128 static void store_one_arg       PROTO ((struct arg_data *, rtx, int, int,
 129                                         tree, int));
 130 \f
 131 /* If WHICH is 1, return 1 if EXP contains a call to the built-in function
 132    `alloca'.
 133
 134    If WHICH is 0, return 1 if EXP contains a call to any function.
 135    Actually, we only need return 1 if evaluating EXP would require pushing
 136    arguments on the stack, but that is too difficult to compute, so we just
 137    assume any function call might require the stack.  */
 138
 139 static tree calls_function_save_exprs;
 140
 141 static int
 142 calls_function (exp, which)
 143      tree exp;
 144      int which;
 145 {
 146   int val;
 147   calls_function_save_exprs = 0;
 148   val = calls_function_1 (exp, which);
 149   calls_function_save_exprs = 0;
 150   return val;
 151 }
 152
 153 static int
 154 calls_function_1 (exp, which)
 155      tree exp;
 156      int which;
 157 {
 158   register int i;
 159   enum tree_code code = TREE_CODE (exp);
 160   int type = TREE_CODE_CLASS (code);
 161   int length = tree_code_length[(int) code];
 162
 163   /* If this code is language-specific, we don't know what it will do.  */
 164   if ((int) code >= NUM_TREE_CODES)
 165     return 1;
 166
 167   /* Only expressions and references can contain calls.  */
 168   if (type != 'e' && type != '<' && type != '1' && type != '2' && type != 'r'
 169       && type != 'b')
 170     return 0;
 171
 172   switch (code)
 173     {
 174     case CALL_EXPR:
 175       if (which == 0)
 176         return 1;
 177       else if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
 178                && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
 179                    == FUNCTION_DECL))
 180         {
 181           tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
 182
 183           if ((DECL_BUILT_IN (fndecl)
 184                && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_ALLOCA)
 185               || (DECL_SAVED_INSNS (fndecl)
 186                   && (FUNCTION_FLAGS (DECL_SAVED_INSNS (fndecl))
 187                       & FUNCTION_FLAGS_CALLS_ALLOCA)))
 188             return 1;
 189         }
 190
 191       /* Third operand is RTL.  */
 192       length = 2;
 193       break;
 194
 195     case SAVE_EXPR:
 196       if (SAVE_EXPR_RTL (exp) != 0)
 197         return 0;
 198       if (value_member (exp, calls_function_save_exprs))
 199         return 0;
 200       calls_function_save_exprs = tree_cons (NULL_TREE, exp,
 201                                              calls_function_save_exprs);
 202       return (TREE_OPERAND (exp, 0) != 0
 203               && calls_function_1 (TREE_OPERAND (exp, 0), which));
 204
 205     case BLOCK:
 206       {
 207         register tree local;
 208
 209         for (local = BLOCK_VARS (exp); local; local = TREE_CHAIN (local))
 210           if (DECL_INITIAL (local) != 0
 211               && calls_function_1 (DECL_INITIAL (local), which))
 212             return 1;
 213       }
 214       {
 215         register tree subblock;
 216
 217         for (subblock = BLOCK_SUBBLOCKS (exp);
 218              subblock;
 219              subblock = TREE_CHAIN (subblock))
 220           if (calls_function_1 (subblock, which))
 221             return 1;
 222       }
 223       return 0;
 224
 225     case METHOD_CALL_EXPR:
 226       length = 3;
 227       break;
 228
 229     case WITH_CLEANUP_EXPR:
 230       length = 1;
 231       break;
 232
 233     case RTL_EXPR:
 234       return 0;
 235     }
 236
 237   for (i = 0; i < length; i++)
 238     if (TREE_OPERAND (exp, i) != 0
 239         && calls_function_1 (TREE_OPERAND (exp, i), which))
 240       return 1;
 241
 242   return 0;
 243 }
 244 \f
 245 /* Force FUNEXP into a form suitable for the address of a CALL,
 246    and return that as an rtx.  Also load the static chain register
 247    if FNDECL is a nested function.
 248
 249    CALL_FUSAGE points to a variable holding the prospective
 250    CALL_INSN_FUNCTION_USAGE information.  */
 251
 252 rtx
 253 prepare_call_address (funexp, fndecl, call_fusage, reg_parm_seen)
 254      rtx funexp;
 255      tree fndecl;
 256      rtx *call_fusage;
 257      int reg_parm_seen;
 258 {
 259   rtx static_chain_value = 0;
 260
 261   funexp = protect_from_queue (funexp, 0);
 262
 263   if (fndecl != 0)
 264     /* Get possible static chain value for nested function in C. */
 265     static_chain_value = lookup_static_chain (fndecl);
 266
 267   /* Make a valid memory address and copy constants thru pseudo-regs,
 268      but not for a constant address if -fno-function-cse.  */
 269   if (GET_CODE (funexp) != SYMBOL_REF)
 270     funexp =
 271 #ifdef SMALL_REGISTER_CLASSES
 272     /* If we are using registers for parameters, force the
 273          function address into a register now.  */
 274       reg_parm_seen ? force_not_mem (memory_address (FUNCTION_MODE, funexp))
 275                     :
 276 #endif
 277                       memory_address (FUNCTION_MODE, funexp);
 278   else
 279     {
 280 #ifndef NO_FUNCTION_CSE
 281       if (optimize && ! flag_no_function_cse)
 282 #ifdef NO_RECURSIVE_FUNCTION_CSE
 283         if (fndecl != current_function_decl)
 284 #endif
 285           funexp = force_reg (Pmode, funexp);
 286 #endif
 287     }
 288
 289   if (static_chain_value != 0)
 290     {
 291       emit_move_insn (static_chain_rtx, static_chain_value);
 292
 293       if (GET_CODE (static_chain_rtx) == REG)
 294         use_reg (call_fusage, static_chain_rtx);
 295     }
 296
 297   return funexp;
 298 }
 299
 300 /* Generate instructions to call function FUNEXP,
 301    and optionally pop the results.
 302    The CALL_INSN is the first insn generated.
 303
 304    FNDECL is the declaration node of the function.  This is given ot the
 305    macro RETURN_POPS_ARGS to determine whether this function pops its own args.
 306
 307    FUNTYPE is the data type of the function, or, for a library call,
 308    the identifier for the name of the call.  This is given to the
 309    macro RETURN_POPS_ARGS to determine whether this function pops its own args.
 310
 311    STACK_SIZE is the number of bytes of arguments on the stack,
 312    rounded up to STACK_BOUNDARY; zero if the size is variable.
 313    This is both to put into the call insn and
 314    to generate explicit popping code if necessary.
 315
 316    STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
 317    It is zero if this call doesn't want a structure value.
 318
 319    NEXT_ARG_REG is the rtx that results from executing
 320      FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1)
 321    just after all the args have had their registers assigned.
 322    This could be whatever you like, but normally it is the first
 323    arg-register beyond those used for args in this call,
 324    or 0 if all the arg-registers are used in this call.
 325    It is passed on to `gen_call' so you can put this info in the call insn.
 326
 327    VALREG is a hard register in which a value is returned,
 328    or 0 if the call does not return a value.
 329
 330    OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before
 331    the args to this call were processed.
 332    We restore `inhibit_defer_pop' to that value.
 333
 334    CALL_FUSAGE is either empty or an EXPR_LIST of USE expressions that
 335    denote registers used by the called function.
 336
 337    IS_CONST is true if this is a `const' call.  */
 338
 339 static void
 340 emit_call_1 (funexp, fndecl, funtype, stack_size, struct_value_size,
 341              next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
 342              is_const)
 343      rtx funexp;
 344      tree fndecl;
 345      tree funtype;
 346      int stack_size;
 347      int struct_value_size;
 348      rtx next_arg_reg;
 349      rtx valreg;
 350      int old_inhibit_defer_pop;
 351      rtx call_fusage;
 352      int is_const;
 353 {
 354   rtx stack_size_rtx = GEN_INT (stack_size);
 355   rtx struct_value_size_rtx = GEN_INT (struct_value_size);
 356   rtx call_insn;
 357   int already_popped = 0;
 358
 359   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
 360      and we don't want to load it into a register as an optimization,
 361      because prepare_call_address already did it if it should be done.  */
 362   if (GET_CODE (funexp) != SYMBOL_REF)
 363     funexp = memory_address (FUNCTION_MODE, funexp);
 364
 365 #ifndef ACCUMULATE_OUTGOING_ARGS
 366 #if defined (HAVE_call_pop) && defined (HAVE_call_value_pop)
 367   if (HAVE_call_pop && HAVE_call_value_pop
 368       && (RETURN_POPS_ARGS (fndecl, funtype, stack_size) > 0
 369           || stack_size == 0))
 370     {
 371       rtx n_pop = GEN_INT (RETURN_POPS_ARGS (fndecl, funtype, stack_size));
 372       rtx pat;
 373
 374       /* If this subroutine pops its own args, record that in the call insn
 375          if possible, for the sake of frame pointer elimination.  */
 376
 377       if (valreg)
 378         pat = gen_call_value_pop (valreg,
 379                                   gen_rtx (MEM, FUNCTION_MODE, funexp),
 380                                   stack_size_rtx, next_arg_reg, n_pop);
 381       else
 382         pat = gen_call_pop (gen_rtx (MEM, FUNCTION_MODE, funexp),
 383                             stack_size_rtx, next_arg_reg, n_pop);
 384
 385       emit_call_insn (pat);
 386       already_popped = 1;
 387     }
 388   else
 389 #endif
 390 #endif
 391
 392 #if defined (HAVE_call) && defined (HAVE_call_value)
 393   if (HAVE_call && HAVE_call_value)
 394     {
 395       if (valreg)
 396         emit_call_insn (gen_call_value (valreg,
 397                                         gen_rtx (MEM, FUNCTION_MODE, funexp),
 398                                         stack_size_rtx, next_arg_reg,
 399                                         NULL_RTX));
 400       else
 401         emit_call_insn (gen_call (gen_rtx (MEM, FUNCTION_MODE, funexp),
 402                                   stack_size_rtx, next_arg_reg,
 403                                   struct_value_size_rtx));
 404     }
 405   else
 406 #endif
 407     abort ();
 408
 409   /* Find the CALL insn we just emitted.  */
 410   for (call_insn = get_last_insn ();
 411        call_insn && GET_CODE (call_insn) != CALL_INSN;
 412        call_insn = PREV_INSN (call_insn))
 413     ;
 414
 415   if (! call_insn)
 416     abort ();
 417
 418   /* Put the register usage information on the CALL.  If there is already
 419      some usage information, put ours at the end.  */
 420   if (CALL_INSN_FUNCTION_USAGE (call_insn))
 421     {
 422       rtx link;
 423
 424       for (link = CALL_INSN_FUNCTION_USAGE (call_insn); XEXP (link, 1) != 0;
 425            link = XEXP (link, 1))
 426         ;
 427
 428       XEXP (link, 1) = call_fusage;
 429     }
 430   else
 431     CALL_INSN_FUNCTION_USAGE (call_insn) = call_fusage;
 432
 433   /* If this is a const call, then set the insn's unchanging bit.  */
 434   if (is_const)
 435     CONST_CALL_P (call_insn) = 1;
 436
 437   /* Restore this now, so that we do defer pops for this call's args
 438      if the context of the call as a whole permits.  */
 439   inhibit_defer_pop = old_inhibit_defer_pop;
 440
 441 #ifndef ACCUMULATE_OUTGOING_ARGS
 442   /* If returning from the subroutine does not automatically pop the args,
 443      we need an instruction to pop them sooner or later.
 444      Perhaps do it now; perhaps just record how much space to pop later.
 445
 446      If returning from the subroutine does pop the args, indicate that the
 447      stack pointer will be changed.  */
 448
 449   if (stack_size != 0 && RETURN_POPS_ARGS (fndecl, funtype, stack_size) > 0)
 450     {
 451       if (!already_popped)
 452         CALL_INSN_FUNCTION_USAGE (call_insn) =
 453            gen_rtx (EXPR_LIST, VOIDmode,
 454                     gen_rtx (CLOBBER, VOIDmode, stack_pointer_rtx),
 455                     CALL_INSN_FUNCTION_USAGE (call_insn));
 456       stack_size -= RETURN_POPS_ARGS (fndecl, funtype, stack_size);
 457       stack_size_rtx = GEN_INT (stack_size);
 458     }
 459
 460   if (stack_size != 0)
 461     {
 462       if (flag_defer_pop && inhibit_defer_pop == 0 && !is_const)
 463         pending_stack_adjust += stack_size;
 464       else
 465         adjust_stack (stack_size_rtx);
 466     }
 467 #endif
 468 }
 469
 470 /* Generate all the code for a function call
 471    and return an rtx for its value.
 472    Store the value in TARGET (specified as an rtx) if convenient.
 473    If the value is stored in TARGET then TARGET is returned.
 474    If IGNORE is nonzero, then we ignore the value of the function call.  */
 475
 476 rtx
 477 expand_call (exp, target, ignore)
 478      tree exp;
 479      rtx target;
 480      int ignore;
 481 {
 482   /* List of actual parameters.  */
 483   tree actparms = TREE_OPERAND (exp, 1);
 484   /* RTX for the function to be called.  */
 485   rtx funexp;
 486   /* Tree node for the function to be called (not the address!).  */
 487   tree funtree;
 488   /* Data type of the function.  */
 489   tree funtype;
 490   /* Declaration of the function being called,
 491      or 0 if the function is computed (not known by name).  */
 492   tree fndecl = 0;
 493   char *name = 0;
 494
 495   /* Register in which non-BLKmode value will be returned,
 496      or 0 if no value or if value is BLKmode.  */
 497   rtx valreg;
 498   /* Address where we should return a BLKmode value;
 499      0 if value not BLKmode.  */
 500   rtx structure_value_addr = 0;
 501   /* Nonzero if that address is being passed by treating it as
 502      an extra, implicit first parameter.  Otherwise,
 503      it is passed by being copied directly into struct_value_rtx.  */
 504   int structure_value_addr_parm = 0;
 505   /* Size of aggregate value wanted, or zero if none wanted
 506      or if we are using the non-reentrant PCC calling convention
 507      or expecting the value in registers.  */
 508   int struct_value_size = 0;
 509   /* Nonzero if called function returns an aggregate in memory PCC style,
 510      by returning the address of where to find it.  */
 511   int pcc_struct_value = 0;
 512
 513   /* Number of actual parameters in this call, including struct value addr.  */
 514   int num_actuals;
 515   /* Number of named args.  Args after this are anonymous ones
 516      and they must all go on the stack.  */
 517   int n_named_args;
 518   /* Count arg position in order args appear.  */
 519   int argpos;
 520
 521   /* Vector of information about each argument.
 522      Arguments are numbered in the order they will be pushed,
 523      not the order they are written.  */
 524   struct arg_data *args;
 525
 526   /* Total size in bytes of all the stack-parms scanned so far.  */
 527   struct args_size args_size;
 528   /* Size of arguments before any adjustments (such as rounding).  */
 529   struct args_size original_args_size;
 530   /* Data on reg parms scanned so far.  */
 531   CUMULATIVE_ARGS args_so_far;
 532   /* Nonzero if a reg parm has been scanned.  */
 533   int reg_parm_seen;
 534   /* Nonzero if this is an indirect function call.  */
 535   int current_call_is_indirect = 0;
 536
 537   /* Nonzero if we must avoid push-insns in the args for this call.
 538      If stack space is allocated for register parameters, but not by the
 539      caller, then it is preallocated in the fixed part of the stack frame.
 540      So the entire argument block must then be preallocated (i.e., we
 541      ignore PUSH_ROUNDING in that case).  */
 542
 543 #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
 544   int must_preallocate = 1;
 545 #else
 546 #ifdef PUSH_ROUNDING
 547   int must_preallocate = 0;
 548 #else
 549   int must_preallocate = 1;
 550 #endif
 551 #endif
 552
 553   /* Size of the stack reserved for parameter registers.  */
 554   int reg_parm_stack_space = 0;
 555
 556   /* 1 if scanning parms front to back, -1 if scanning back to front.  */
 557   int inc;
 558   /* Address of space preallocated for stack parms
 559      (on machines that lack push insns), or 0 if space not preallocated.  */
 560   rtx argblock = 0;
 561
 562   /* Nonzero if it is plausible that this is a call to alloca.  */
 563   int may_be_alloca;
 564   /* Nonzero if this is a call to setjmp or a related function.  */
 565   int returns_twice;
 566   /* Nonzero if this is a call to `longjmp'.  */
 567   int is_longjmp;
 568   /* Nonzero if this is a call to an inline function.  */
 569   int is_integrable = 0;
 570   /* Nonzero if this is a call to a `const' function.
 571      Note that only explicitly named functions are handled as `const' here.  */
 572   int is_const = 0;
 573   /* Nonzero if this is a call to a `volatile' function.  */
 574   int is_volatile = 0;
 575 #if defined(ACCUMULATE_OUTGOING_ARGS) && defined(REG_PARM_STACK_SPACE)
 576   /* Define the boundary of the register parm stack space that needs to be
 577      save, if any.  */
 578   int low_to_save = -1, high_to_save;
 579   rtx save_area = 0;            /* Place that it is saved */
 580 #endif
 581
 582 #ifdef ACCUMULATE_OUTGOING_ARGS
 583   int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
 584   char *initial_stack_usage_map = stack_usage_map;
 585 #endif
 586
 587   rtx old_stack_level = 0;
 588   int old_pending_adj = 0;
 589   int old_stack_arg_under_construction;
 590   int old_inhibit_defer_pop = inhibit_defer_pop;
 591   tree old_cleanups = cleanups_this_call;
 592   rtx call_fusage = 0;
 593   register tree p;
 594   register int i, j;
 595
 596   /* See if we can find a DECL-node for the actual function.
 597      As a result, decide whether this is a call to an integrable function.  */
 598
 599   p = TREE_OPERAND (exp, 0);
 600   if (TREE_CODE (p) == ADDR_EXPR)
 601     {
 602       fndecl = TREE_OPERAND (p, 0);
 603       if (TREE_CODE (fndecl) != FUNCTION_DECL)
 604         fndecl = 0;
 605       else
 606         {
 607           if (!flag_no_inline
 608               && fndecl != current_function_decl
 609               && DECL_INLINE (fndecl)
 610               && DECL_SAVED_INSNS (fndecl)
 611               && RTX_INTEGRATED_P (DECL_SAVED_INSNS (fndecl)))
 612             is_integrable = 1;
 613           else if (! TREE_ADDRESSABLE (fndecl))
 614             {
 615               /* In case this function later becomes inlinable,
 616                  record that there was already a non-inline call to it.
 617
 618                  Use abstraction instead of setting TREE_ADDRESSABLE
 619                  directly.  */
 620               if (DECL_INLINE (fndecl) && warn_inline && !flag_no_inline
 621                   && optimize > 0)
 622                 {
 623                   warning_with_decl (fndecl, "can't inline call to `%s'");
 624                   warning ("called from here");
 625                 }
 626               mark_addressable (fndecl);
 627             }
 628
 629           if (TREE_READONLY (fndecl) && ! TREE_THIS_VOLATILE (fndecl)
 630               && TYPE_MODE (TREE_TYPE (exp)) != VOIDmode)
 631             is_const = 1;
 632
 633           if (TREE_THIS_VOLATILE (fndecl))
 634             is_volatile = 1;
 635         }
 636     }
 637
 638   /* If we don't have specific function to call, see if we have a
 639      constant or `noreturn' function from the type.  */
 640   if (fndecl == 0)
 641     {
 642       is_const = TREE_READONLY (TREE_TYPE (TREE_TYPE (p)));
 643       is_volatile = TREE_THIS_VOLATILE (TREE_TYPE (TREE_TYPE (p)));
 644     }
 645
 646 #ifdef REG_PARM_STACK_SPACE
 647 #ifdef MAYBE_REG_PARM_STACK_SPACE
 648   reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
 649 #else
 650   reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
 651 #endif
 652 #endif
 653
 654   /* Warn if this value is an aggregate type,
 655      regardless of which calling convention we are using for it.  */
 656   if (warn_aggregate_return && AGGREGATE_TYPE_P (TREE_TYPE (exp)))
 657     warning ("function call has aggregate value");
 658
 659   /* Set up a place to return a structure.  */
 660
 661   /* Cater to broken compilers.  */
 662   if (aggregate_value_p (exp))
 663     {
 664       /* This call returns a big structure.  */
 665       is_const = 0;
 666
 667 #ifdef PCC_STATIC_STRUCT_RETURN
 668       {
 669         pcc_struct_value = 1;
 670         /* Easier than making that case work right.  */
 671         if (is_integrable)
 672           {
 673             /* In case this is a static function, note that it has been
 674                used.  */
 675             if (! TREE_ADDRESSABLE (fndecl))
 676               mark_addressable (fndecl);
 677             is_integrable = 0;
 678           }
 679       }
 680 #else /* not PCC_STATIC_STRUCT_RETURN */
 681       {
 682         struct_value_size = int_size_in_bytes (TREE_TYPE (exp));
 683
 684         if (target && GET_CODE (target) == MEM)
 685           structure_value_addr = XEXP (target, 0);
 686         else
 687           {
 688             /* Assign a temporary on the stack to hold the value.  */
 689
 690             /* For variable-sized objects, we must be called with a target
 691                specified.  If we were to allocate space on the stack here,
 692                we would have no way of knowing when to free it.  */
 693
 694             if (struct_value_size < 0)
 695               abort ();
 696
 697             structure_value_addr
 698               = XEXP (assign_stack_temp (BLKmode, struct_value_size, 1), 0);
 699             MEM_IN_STRUCT_P (structure_value_addr)
 700               = AGGREGATE_TYPE_P (TREE_TYPE (exp));
 701             target = 0;
 702           }
 703       }
 704 #endif /* not PCC_STATIC_STRUCT_RETURN */
 705     }
 706
 707   /* If called function is inline, try to integrate it.  */
 708
 709   if (is_integrable)
 710     {
 711       rtx temp;
 712       rtx before_call = get_last_insn ();
 713
 714       temp = expand_inline_function (fndecl, actparms, target,
 715                                      ignore, TREE_TYPE (exp),
 716                                      structure_value_addr);
 717
 718       /* If inlining succeeded, return.  */
 719       if ((HOST_WIDE_INT) temp != -1)
 720         {
 721           if (flag_short_temps)
 722             {
 723               /* Perform all cleanups needed for the arguments of this
 724                  call (i.e. destructors in C++).  It is ok if these
 725                  destructors clobber RETURN_VALUE_REG, because the
 726                  only time we care about this is when TARGET is that
 727                  register.  But in C++, we take care to never return
 728                  that register directly.  */
 729               expand_cleanups_to (old_cleanups);
 730             }
 731
 732 #ifdef ACCUMULATE_OUTGOING_ARGS
 733           /* If the outgoing argument list must be preserved, push
 734              the stack before executing the inlined function if it
 735              makes any calls.  */
 736
 737           for (i = reg_parm_stack_space - 1; i >= 0; i--)
 738             if (i < highest_outgoing_arg_in_use && stack_usage_map[i] != 0)
 739               break;
 740
 741           if (stack_arg_under_construction || i >= 0)
 742             {
 743               rtx insn = NEXT_INSN (before_call), seq;
 744
 745               /* Look for a call in the inline function code.
 746                  If OUTGOING_ARGS_SIZE (DECL_SAVED_INSNS (fndecl)) is
 747                  nonzero then there is a call and it is not necessary
 748                  to scan the insns.  */
 749
 750               if (OUTGOING_ARGS_SIZE (DECL_SAVED_INSNS (fndecl)) == 0)
 751                 for (; insn; insn = NEXT_INSN (insn))
 752                   if (GET_CODE (insn) == CALL_INSN)
 753                     break;
 754
 755               if (insn)
 756                 {
 757                   /* Reserve enough stack space so that the largest
 758                      argument list of any function call in the inline
 759                      function does not overlap the argument list being
 760                      evaluated.  This is usually an overestimate because
 761                      allocate_dynamic_stack_space reserves space for an
 762                      outgoing argument list in addition to the requested
 763                      space, but there is no way to ask for stack space such
 764                      that an argument list of a certain length can be
 765                      safely constructed.  */
 766
 767                   int adjust = OUTGOING_ARGS_SIZE (DECL_SAVED_INSNS (fndecl));
 768 #ifdef REG_PARM_STACK_SPACE
 769                   /* Add the stack space reserved for register arguments
 770                      in the inline function.  What is really needed is the
 771                      largest value of reg_parm_stack_space in the inline
 772                      function, but that is not available.  Using the current
 773                      value of reg_parm_stack_space is wrong, but gives
 774                      correct results on all supported machines.  */
 775                   adjust += reg_parm_stack_space;
 776 #endif
 777                   start_sequence ();
 778                   emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
 779                   allocate_dynamic_stack_space (GEN_INT (adjust),
 780                                                 NULL_RTX, BITS_PER_UNIT);
 781                   seq = get_insns ();
 782                   end_sequence ();
 783                   emit_insns_before (seq, NEXT_INSN (before_call));
 784                   emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
 785                 }
 786             }
 787 #endif
 788
 789           /* If the result is equivalent to TARGET, return TARGET to simplify
 790              checks in store_expr.  They can be equivalent but not equal in the
 791              case of a function that returns BLKmode.  */
 792           if (temp != target && rtx_equal_p (temp, target))
 793             return target;
 794           return temp;
 795         }
 796
 797       /* If inlining failed, mark FNDECL as needing to be compiled
 798          separately after all.  If function was declared inline,
 799          give a warning.  */
 800       if (DECL_INLINE (fndecl) && warn_inline && !flag_no_inline
 801           && optimize > 0 && ! TREE_ADDRESSABLE (fndecl))
 802         {
 803           warning_with_decl (fndecl, "inlining failed in call to `%s'");
 804           warning ("called from here");
 805         }
 806       mark_addressable (fndecl);
 807     }
 808
 809   /* When calling a const function, we must pop the stack args right away,
 810      so that the pop is deleted or moved with the call.  */
 811   if (is_const)
 812     NO_DEFER_POP;
 813
 814   function_call_count++;
 815
 816   if (fndecl && DECL_NAME (fndecl))
 817     name = IDENTIFIER_POINTER (DECL_NAME (fndecl));
 818
 819   /* On some machines (such as the PA) indirect calls have a different
 820      calling convention than normal calls.  FUNCTION_ARG in the target
 821      description can look at current_call_is_indirect to determine which
 822      calling convention to use.  */
 823   current_call_is_indirect = (fndecl == 0);
 824 #if 0
 825     = TREE_CODE (TREE_OPERAND (exp, 0)) == NON_LVALUE_EXPR ? 1 : 0;
 826 #endif
 827
 828 #if 0
 829   /* Unless it's a call to a specific function that isn't alloca,
 830      if it has one argument, we must assume it might be alloca.  */
 831
 832   may_be_alloca =
 833     (!(fndecl != 0 && strcmp (name, "alloca"))
 834      && actparms != 0
 835      && TREE_CHAIN (actparms) == 0);
 836 #else
 837   /* We assume that alloca will always be called by name.  It
 838      makes no sense to pass it as a pointer-to-function to
 839      anything that does not understand its behavior.  */
 840   may_be_alloca =
 841     (name && ((IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 6
 842                  && name[0] == 'a'
 843                  && ! strcmp (name, "alloca"))
 844                 || (IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 16
 845                     && name[0] == '_'
 846                     && ! strcmp (name, "__builtin_alloca"))));
 847 #endif
 848
 849   /* See if this is a call to a function that can return more than once
 850      or a call to longjmp.  */
 851
 852   returns_twice = 0;
 853   is_longjmp = 0;
 854
 855   if (name != 0 && IDENTIFIER_LENGTH (DECL_NAME (fndecl)) <= 15)
 856     {
 857       char *tname = name;
 858
 859       /* Disregard prefix _, __ or __x.  */
 860       if (name[0] == '_')
 861         {
 862           if (name[1] == '_' && name[2] == 'x')
 863             tname += 3;
 864           else if (name[1] == '_')
 865             tname += 2;
 866           else
 867             tname += 1;
 868         }
 869
 870       if (tname[0] == 's')
 871         {
 872           returns_twice
 873             = ((tname[1] == 'e'
 874                 && (! strcmp (tname, "setjmp")
 875                     || ! strcmp (tname, "setjmp_syscall")))
 876                || (tname[1] == 'i'
 877                    && ! strcmp (tname, "sigsetjmp"))
 878                || (tname[1] == 'a'
 879                    && ! strcmp (tname, "savectx")));
 880           if (tname[1] == 'i'
 881               && ! strcmp (tname, "siglongjmp"))
 882             is_longjmp = 1;
 883         }
 884       else if ((tname[0] == 'q' && tname[1] == 's'
 885                 && ! strcmp (tname, "qsetjmp"))
 886                || (tname[0] == 'v' && tname[1] == 'f'
 887                    && ! strcmp (tname, "vfork")))
 888         returns_twice = 1;
 889
 890       else if (tname[0] == 'l' && tname[1] == 'o'
 891                && ! strcmp (tname, "longjmp"))
 892         is_longjmp = 1;
 893     }
 894
 895   if (may_be_alloca)
 896     current_function_calls_alloca = 1;
 897
 898   /* Don't let pending stack adjusts add up to too much.
 899      Also, do all pending adjustments now
 900      if there is any chance this might be a call to alloca.  */
 901
 902   if (pending_stack_adjust >= 32
 903       || (pending_stack_adjust > 0 && may_be_alloca))
 904     do_pending_stack_adjust ();
 905
 906   /* Operand 0 is a pointer-to-function; get the type of the function.  */
 907   funtype = TREE_TYPE (TREE_OPERAND (exp, 0));
 908   if (TREE_CODE (funtype) != POINTER_TYPE)
 909     abort ();
 910   funtype = TREE_TYPE (funtype);
 911
 912   /* Push the temporary stack slot level so that we can free any temporaries
 913      we make.  */
 914   push_temp_slots ();
 915
 916   /* Start updating where the next arg would go.  */
 917   INIT_CUMULATIVE_ARGS (args_so_far, funtype, NULL_RTX);
 918
 919   /* If struct_value_rtx is 0, it means pass the address
 920      as if it were an extra parameter.  */
 921   if (structure_value_addr && struct_value_rtx == 0)
 922     {
 923       /* If structure_value_addr is a REG other than
 924          virtual_outgoing_args_rtx, we can use always use it.  If it
 925          is not a REG, we must always copy it into a register.
 926          If it is virtual_outgoing_args_rtx, we must copy it to another
 927          register in some cases.  */
 928       rtx temp = (GET_CODE (structure_value_addr) != REG
 929 #ifdef ACCUMULATE_OUTGOING_ARGS
 930                   || (stack_arg_under_construction
 931                       && structure_value_addr == virtual_outgoing_args_rtx)
 932 #endif
 933                   ? copy_addr_to_reg (structure_value_addr)
 934                   : structure_value_addr);
 935
 936       actparms
 937         = tree_cons (error_mark_node,
 938                      make_tree (build_pointer_type (TREE_TYPE (funtype)),
 939                                 temp),
 940                      actparms);
 941       structure_value_addr_parm = 1;
 942     }
 943
 944   /* Count the arguments and set NUM_ACTUALS.  */
 945   for (p = actparms, i = 0; p; p = TREE_CHAIN (p)) i++;
 946   num_actuals = i;
 947
 948   /* Compute number of named args.
 949      Normally, don't include the last named arg if anonymous args follow.
 950      We do include the last named arg if STRICT_ARGUMENT_NAMING is defined.
 951      (If no anonymous args follow, the result of list_length is actually
 952      one too large.  This is harmless.)
 953
 954      If SETUP_INCOMING_VARARGS is defined and STRICT_ARGUMENT_NAMING is not,
 955      this machine will be able to place unnamed args that were passed in
 956      registers into the stack.  So treat all args as named.  This allows the
 957      insns emitting for a specific argument list to be independent of the
 958      function declaration.
 959
 960      If SETUP_INCOMING_VARARGS is not defined, we do not have any reliable
 961      way to pass unnamed args in registers, so we must force them into
 962      memory.  */
 963 #if !defined(SETUP_INCOMING_VARARGS) || defined(STRICT_ARGUMENT_NAMING)
 964   if (TYPE_ARG_TYPES (funtype) != 0)
 965     n_named_args
 966       = (list_length (TYPE_ARG_TYPES (funtype))
 967 #ifndef STRICT_ARGUMENT_NAMING
 968          /* Don't include the last named arg.  */
 969          - 1
 970 #endif
 971          /* Count the struct value address, if it is passed as a parm.  */
 972          + structure_value_addr_parm);
 973   else
 974 #endif
 975     /* If we know nothing, treat all args as named.  */
 976     n_named_args = num_actuals;
 977
 978   /* Make a vector to hold all the information about each arg.  */
 979   args = (struct arg_data *) alloca (num_actuals * sizeof (struct arg_data));
 980   bzero ((char *) args, num_actuals * sizeof (struct arg_data));
 981
 982   args_size.constant = 0;
 983   args_size.var = 0;
 984
 985   /* In this loop, we consider args in the order they are written.
 986      We fill up ARGS from the front or from the back if necessary
 987      so that in any case the first arg to be pushed ends up at the front.  */
 988
 989 #ifdef PUSH_ARGS_REVERSED
 990   i = num_actuals - 1, inc = -1;
 991   /* In this case, must reverse order of args
 992      so that we compute and push the last arg first.  */
 993 #else
 994   i = 0, inc = 1;
 995 #endif
 996
 997   /* I counts args in order (to be) pushed; ARGPOS counts in order written.  */
 998   for (p = actparms, argpos = 0; p; p = TREE_CHAIN (p), i += inc, argpos++)
 999     {
1000       tree type = TREE_TYPE (TREE_VALUE (p));
1001       int unsignedp;
1002       enum machine_mode mode;
1003
1004       args[i].tree_value = TREE_VALUE (p);
1005
1006       /* Replace erroneous argument with constant zero.  */
1007       if (type == error_mark_node || TYPE_SIZE (type) == 0)
1008         args[i].tree_value = integer_zero_node, type = integer_type_node;
1009
1010       /* If TYPE is a transparent union, pass things the way we would
1011          pass the first field of the union.  We have already verified that
1012          the modes are the same.  */
1013       if (TYPE_TRANSPARENT_UNION (type))
1014         type = TREE_TYPE (TYPE_FIELDS (type));
1015
1016       /* Decide where to pass this arg.
1017
1018          args[i].reg is nonzero if all or part is passed in registers.
1019
1020          args[i].partial is nonzero if part but not all is passed in registers,
1021          and the exact value says how many words are passed in registers.
1022
1023          args[i].pass_on_stack is nonzero if the argument must at least be
1024          computed on the stack.  It may then be loaded back into registers
1025          if args[i].reg is nonzero.
1026
1027          These decisions are driven by the FUNCTION_... macros and must agree
1028          with those made by function.c.  */
1029
1030       /* See if this argument should be passed by invisible reference.  */
1031       if ((TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST
1032            && contains_placeholder_p (TYPE_SIZE (type)))
1033           || TREE_ADDRESSABLE (type)
1034 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
1035           || FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, TYPE_MODE (type),
1036                                              type, argpos < n_named_args)
1037 #endif
1038           )
1039         {
1040 #ifdef FUNCTION_ARG_CALLEE_COPIES
1041           if (FUNCTION_ARG_CALLEE_COPIES (args_so_far, TYPE_MODE (type), type,
1042                                           argpos < n_named_args)
1043               /* If it's in a register, we must make a copy of it too.  */
1044               /* ??? Is this a sufficient test?  Is there a better one? */
1045               && !(TREE_CODE (args[i].tree_value) == VAR_DECL
1046                    && REG_P (DECL_RTL (args[i].tree_value)))
1047               && ! TREE_ADDRESSABLE (type))
1048             {
1049               args[i].tree_value = build1 (ADDR_EXPR,
1050                                            build_pointer_type (type),
1051                                            args[i].tree_value);
1052               type = build_pointer_type (type);
1053             }
1054           else
1055 #endif
1056             {
1057               /* We make a copy of the object and pass the address to the
1058                  function being called.  */
1059               rtx copy;
1060
1061               if (TYPE_SIZE (type) == 0
1062                   || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
1063                 {
1064                   /* This is a variable-sized object.  Make space on the stack
1065                      for it.  */
1066                   rtx size_rtx = expr_size (TREE_VALUE (p));
1067
1068                   if (old_stack_level == 0)
1069                     {
1070                       emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1071                       old_pending_adj = pending_stack_adjust;
1072                       pending_stack_adjust = 0;
1073                     }
1074
1075                   copy = gen_rtx (MEM, BLKmode,
1076                                   allocate_dynamic_stack_space (size_rtx,
1077                                                                 NULL_RTX,
1078                                                                 TYPE_ALIGN (type)));
1079                 }
1080               else
1081                 {
1082                   int size = int_size_in_bytes (type);
1083                   copy = assign_stack_temp (TYPE_MODE (type), size, 0);
1084                 }
1085
1086               MEM_IN_STRUCT_P (copy) = AGGREGATE_TYPE_P (type);
1087
1088               store_expr (args[i].tree_value, copy, 0);
1089               is_const = 0;
1090
1091               args[i].tree_value = build1 (ADDR_EXPR,
1092                                            build_pointer_type (type),
1093                                            make_tree (type, copy));
1094               type = build_pointer_type (type);
1095             }
1096         }
1097
1098       mode = TYPE_MODE (type);
1099       unsignedp = TREE_UNSIGNED (type);
1100
1101 #ifdef PROMOTE_FUNCTION_ARGS
1102       mode = promote_mode (type, mode, &unsignedp, 1);
1103 #endif
1104
1105       args[i].unsignedp = unsignedp;
1106       args[i].mode = mode;
1107       args[i].reg = FUNCTION_ARG (args_so_far, mode, type,
1108                                   argpos < n_named_args);
1109 #ifdef FUNCTION_ARG_PARTIAL_NREGS
1110       if (args[i].reg)
1111         args[i].partial
1112           = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, type,
1113                                         argpos < n_named_args);
1114 #endif
1115
1116       args[i].pass_on_stack = MUST_PASS_IN_STACK (mode, type);
1117
1118       /* If FUNCTION_ARG returned an (expr_list (nil) FOO), it means that
1119          we are to pass this arg in the register(s) designated by FOO, but
1120          also to pass it in the stack.  */
1121       if (args[i].reg && GET_CODE (args[i].reg) == EXPR_LIST
1122           && XEXP (args[i].reg, 0) == 0)
1123         args[i].pass_on_stack = 1, args[i].reg = XEXP (args[i].reg, 1);
1124
1125       /* If this is an addressable type, we must preallocate the stack
1126          since we must evaluate the object into its final location.
1127
1128          If this is to be passed in both registers and the stack, it is simpler
1129          to preallocate.  */
1130       if (TREE_ADDRESSABLE (type)
1131           || (args[i].pass_on_stack && args[i].reg != 0))
1132         must_preallocate = 1;
1133
1134       /* If this is an addressable type, we cannot pre-evaluate it.  Thus,
1135          we cannot consider this function call constant.  */
1136       if (TREE_ADDRESSABLE (type))
1137         is_const = 0;
1138
1139       /* Compute the stack-size of this argument.  */
1140       if (args[i].reg == 0 || args[i].partial != 0
1141 #ifdef REG_PARM_STACK_SPACE
1142           || reg_parm_stack_space > 0
1143 #endif
1144           || args[i].pass_on_stack)
1145         locate_and_pad_parm (mode, type,
1146 #ifdef STACK_PARMS_IN_REG_PARM_AREA
1147                              1,
1148 #else
1149                              args[i].reg != 0,
1150 #endif
1151                              fndecl, &args_size, &args[i].offset,
1152                              &args[i].size);
1153
1154 #ifndef ARGS_GROW_DOWNWARD
1155       args[i].slot_offset = args_size;
1156 #endif
1157
1158 #ifndef REG_PARM_STACK_SPACE
1159       /* If a part of the arg was put into registers,
1160          don't include that part in the amount pushed.  */
1161       if (! args[i].pass_on_stack)
1162         args[i].size.constant -= ((args[i].partial * UNITS_PER_WORD)
1163                                   / (PARM_BOUNDARY / BITS_PER_UNIT)
1164                                   * (PARM_BOUNDARY / BITS_PER_UNIT));
1165 #endif
1166
1167       /* Update ARGS_SIZE, the total stack space for args so far.  */
1168
1169       args_size.constant += args[i].size.constant;
1170       if (args[i].size.var)
1171         {
1172           ADD_PARM_SIZE (args_size, args[i].size.var);
1173         }
1174
1175       /* Since the slot offset points to the bottom of the slot,
1176          we must record it after incrementing if the args grow down.  */
1177 #ifdef ARGS_GROW_DOWNWARD
1178       args[i].slot_offset = args_size;
1179
1180       args[i].slot_offset.constant = -args_size.constant;
1181       if (args_size.var)
1182         {
1183           SUB_PARM_SIZE (args[i].slot_offset, args_size.var);
1184         }
1185 #endif
1186
1187       /* Increment ARGS_SO_FAR, which has info about which arg-registers
1188          have been used, etc.  */
1189
1190       FUNCTION_ARG_ADVANCE (args_so_far, TYPE_MODE (type), type,
1191                             argpos < n_named_args);
1192     }
1193
1194 #ifdef FINAL_REG_PARM_STACK_SPACE
1195   reg_parm_stack_space = FINAL_REG_PARM_STACK_SPACE (args_size.constant,
1196                                                      args_size.var);
1197 #endif
1198
1199   /* Compute the actual size of the argument block required.  The variable
1200      and constant sizes must be combined, the size may have to be rounded,
1201      and there may be a minimum required size.  */
1202
1203   original_args_size = args_size;
1204   if (args_size.var)
1205     {
1206       /* If this function requires a variable-sized argument list, don't try to
1207          make a cse'able block for this call.  We may be able to do this
1208          eventually, but it is too complicated to keep track of what insns go
1209          in the cse'able block and which don't.  */
1210
1211       is_const = 0;
1212       must_preallocate = 1;
1213
1214       args_size.var = ARGS_SIZE_TREE (args_size);
1215       args_size.constant = 0;
1216
1217 #ifdef STACK_BOUNDARY
1218       if (STACK_BOUNDARY != BITS_PER_UNIT)
1219         args_size.var = round_up (args_size.var, STACK_BYTES);
1220 #endif
1221
1222 #ifdef REG_PARM_STACK_SPACE
1223       if (reg_parm_stack_space > 0)
1224         {
1225           args_size.var
1226             = size_binop (MAX_EXPR, args_size.var,
1227                           size_int (REG_PARM_STACK_SPACE (fndecl)));
1228
1229 #ifndef OUTGOING_REG_PARM_STACK_SPACE
1230           /* The area corresponding to register parameters is not to count in
1231              the size of the block we need.  So make the adjustment.  */
1232           args_size.var
1233             = size_binop (MINUS_EXPR, args_size.var,
1234                           size_int (reg_parm_stack_space));
1235 #endif
1236         }
1237 #endif
1238     }
1239   else
1240     {
1241 #ifdef STACK_BOUNDARY
1242       args_size.constant = (((args_size.constant + (STACK_BYTES - 1))
1243                              / STACK_BYTES) * STACK_BYTES);
1244 #endif
1245
1246 #ifdef REG_PARM_STACK_SPACE
1247       args_size.constant = MAX (args_size.constant,
1248                                 reg_parm_stack_space);
1249 #ifdef MAYBE_REG_PARM_STACK_SPACE
1250       if (reg_parm_stack_space == 0)
1251         args_size.constant = 0;
1252 #endif
1253 #ifndef OUTGOING_REG_PARM_STACK_SPACE
1254       args_size.constant -= reg_parm_stack_space;
1255 #endif
1256 #endif
1257     }
1258
1259   /* See if we have or want to preallocate stack space.
1260
1261      If we would have to push a partially-in-regs parm
1262      before other stack parms, preallocate stack space instead.
1263
1264      If the size of some parm is not a multiple of the required stack
1265      alignment, we must preallocate.
1266
1267      If the total size of arguments that would otherwise create a copy in
1268      a temporary (such as a CALL) is more than half the total argument list
1269      size, preallocation is faster.
1270
1271      Another reason to preallocate is if we have a machine (like the m88k)
1272      where stack alignment is required to be maintained between every
1273      pair of insns, not just when the call is made.  However, we assume here
1274      that such machines either do not have push insns (and hence preallocation
1275      would occur anyway) or the problem is taken care of with
1276      PUSH_ROUNDING.  */
1277
1278   if (! must_preallocate)
1279     {
1280       int partial_seen = 0;
1281       int copy_to_evaluate_size = 0;
1282
1283       for (i = 0; i < num_actuals && ! must_preallocate; i++)
1284         {
1285           if (args[i].partial > 0 && ! args[i].pass_on_stack)
1286             partial_seen = 1;
1287           else if (partial_seen && args[i].reg == 0)
1288             must_preallocate = 1;
1289
1290           if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
1291               && (TREE_CODE (args[i].tree_value) == CALL_EXPR
1292                   || TREE_CODE (args[i].tree_value) == TARGET_EXPR
1293                   || TREE_CODE (args[i].tree_value) == COND_EXPR
1294                   || TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value))))
1295             copy_to_evaluate_size
1296               += int_size_in_bytes (TREE_TYPE (args[i].tree_value));
1297         }
1298
1299       if (copy_to_evaluate_size * 2 >= args_size.constant
1300           && args_size.constant > 0)
1301         must_preallocate = 1;
1302     }
1303
1304   /* If the structure value address will reference the stack pointer, we must
1305      stabilize it.  We don't need to do this if we know that we are not going
1306      to adjust the stack pointer in processing this call.  */
1307
1308   if (structure_value_addr
1309       && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
1310        || reg_mentioned_p (virtual_outgoing_args_rtx, structure_value_addr))
1311       && (args_size.var
1312 #ifndef ACCUMULATE_OUTGOING_ARGS
1313           || args_size.constant
1314 #endif
1315           ))
1316     structure_value_addr = copy_to_reg (structure_value_addr);
1317
1318   /* If this function call is cse'able, precompute all the parameters.
1319      Note that if the parameter is constructed into a temporary, this will
1320      cause an additional copy because the parameter will be constructed
1321      into a temporary location and then copied into the outgoing arguments.
1322      If a parameter contains a call to alloca and this function uses the
1323      stack, precompute the parameter.  */
1324
1325   /* If we preallocated the stack space, and some arguments must be passed
1326      on the stack, then we must precompute any parameter which contains a
1327      function call which will store arguments on the stack.
1328      Otherwise, evaluating the parameter may clobber previous parameters
1329      which have already been stored into the stack.  */
1330
1331   for (i = 0; i < num_actuals; i++)
1332     if (is_const
1333         || ((args_size.var != 0 || args_size.constant != 0)
1334             && calls_function (args[i].tree_value, 1))
1335         || (must_preallocate && (args_size.var != 0 || args_size.constant != 0)
1336             && calls_function (args[i].tree_value, 0)))
1337       {
1338         /* If this is an addressable type, we cannot pre-evaluate it.  */
1339         if (TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value)))
1340           abort ();
1341
1342         push_temp_slots ();
1343
1344         args[i].initial_value = args[i].value
1345           = expand_expr (args[i].tree_value, NULL_RTX, VOIDmode, 0);
1346
1347         preserve_temp_slots (args[i].value);
1348         pop_temp_slots ();
1349
1350         /* ANSI doesn't require a sequence point here,
1351            but PCC has one, so this will avoid some problems.  */
1352         emit_queue ();
1353
1354         args[i].initial_value = args[i].value
1355           = protect_from_queue (args[i].initial_value, 0);
1356
1357         if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) != args[i].mode)
1358           args[i].value
1359             = convert_modes (args[i].mode,
1360                              TYPE_MODE (TREE_TYPE (args[i].tree_value)),
1361                              args[i].value, args[i].unsignedp);
1362       }
1363
1364   /* Now we are about to start emitting insns that can be deleted
1365      if a libcall is deleted.  */
1366   if (is_const)
1367     start_sequence ();
1368
1369   /* If we have no actual push instructions, or shouldn't use them,
1370      make space for all args right now.  */
1371
1372   if (args_size.var != 0)
1373     {
1374       if (old_stack_level == 0)
1375         {
1376           emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1377           old_pending_adj = pending_stack_adjust;
1378           pending_stack_adjust = 0;
1379 #ifdef ACCUMULATE_OUTGOING_ARGS
1380           /* stack_arg_under_construction says whether a stack arg is
1381              being constructed at the old stack level.  Pushing the stack
1382              gets a clean outgoing argument block.  */
1383           old_stack_arg_under_construction = stack_arg_under_construction;
1384           stack_arg_under_construction = 0;
1385 #endif
1386         }
1387       argblock = push_block (ARGS_SIZE_RTX (args_size), 0, 0);
1388     }
1389   else
1390     {
1391       /* Note that we must go through the motions of allocating an argument
1392          block even if the size is zero because we may be storing args
1393          in the area reserved for register arguments, which may be part of
1394          the stack frame.  */
1395
1396       int needed = args_size.constant;
1397
1398       /* Store the maximum argument space used.  It will be pushed by the
1399          prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow checking). */
1400
1401       if (needed > current_function_outgoing_args_size)
1402         current_function_outgoing_args_size = needed;
1403
1404       if (must_preallocate)
1405         {
1406 #ifdef ACCUMULATE_OUTGOING_ARGS
1407           /* Since the stack pointer will never be pushed, it is possible for
1408              the evaluation of a parm to clobber something we have already
1409              written to the stack.  Since most function calls on RISC machines
1410              do not use the stack, this is uncommon, but must work correctly.
1411
1412              Therefore, we save any area of the stack that was already written
1413              and that we are using.  Here we set up to do this by making a new
1414              stack usage map from the old one.  The actual save will be done
1415              by store_one_arg.
1416
1417              Another approach might be to try to reorder the argument
1418              evaluations to avoid this conflicting stack usage.  */
1419
1420 #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
1421           /* Since we will be writing into the entire argument area, the
1422              map must be allocated for its entire size, not just the part that
1423              is the responsibility of the caller.  */
1424           needed += reg_parm_stack_space;
1425 #endif
1426
1427 #ifdef ARGS_GROW_DOWNWARD
1428           highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
1429                                              needed + 1);
1430 #else
1431           highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
1432                                              needed);
1433 #endif
1434           stack_usage_map = (char *) alloca (highest_outgoing_arg_in_use);
1435
1436           if (initial_highest_arg_in_use)
1437             bcopy (initial_stack_usage_map, stack_usage_map,
1438                    initial_highest_arg_in_use);
1439
1440           if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
1441             bzero (&stack_usage_map[initial_highest_arg_in_use],
1442                    highest_outgoing_arg_in_use - initial_highest_arg_in_use);
1443           needed = 0;
1444
1445           /* The address of the outgoing argument list must not be copied to a
1446              register here, because argblock would be left pointing to the
1447              wrong place after the call to allocate_dynamic_stack_space below.
1448              */
1449
1450           argblock = virtual_outgoing_args_rtx;
1451
1452 #else /* not ACCUMULATE_OUTGOING_ARGS */
1453           if (inhibit_defer_pop == 0)
1454             {
1455               /* Try to reuse some or all of the pending_stack_adjust
1456                  to get this space.  Maybe we can avoid any pushing.  */
1457               if (needed > pending_stack_adjust)
1458                 {
1459                   needed -= pending_stack_adjust;
1460                   pending_stack_adjust = 0;
1461                 }
1462               else
1463                 {
1464                   pending_stack_adjust -= needed;
1465                   needed = 0;
1466                 }
1467             }
1468           /* Special case this because overhead of `push_block' in this
1469              case is non-trivial.  */
1470           if (needed == 0)
1471             argblock = virtual_outgoing_args_rtx;
1472           else
1473             argblock = push_block (GEN_INT (needed), 0, 0);
1474
1475           /* We only really need to call `copy_to_reg' in the case where push
1476              insns are going to be used to pass ARGBLOCK to a function
1477              call in ARGS.  In that case, the stack pointer changes value
1478              from the allocation point to the call point, and hence
1479              the value of VIRTUAL_OUTGOING_ARGS_RTX changes as well.
1480              But might as well always do it.  */
1481           argblock = copy_to_reg (argblock);
1482 #endif /* not ACCUMULATE_OUTGOING_ARGS */
1483         }
1484     }
1485
1486 #ifdef ACCUMULATE_OUTGOING_ARGS
1487   /* The save/restore code in store_one_arg handles all cases except one:
1488      a constructor call (including a C function returning a BLKmode struct)
1489      to initialize an argument.  */
1490   if (stack_arg_under_construction)
1491     {
1492 #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
1493       rtx push_size = GEN_INT (reg_parm_stack_space + args_size.constant);
1494 #else
1495       rtx push_size = GEN_INT (args_size.constant);
1496 #endif
1497       if (old_stack_level == 0)
1498         {
1499           emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1500           old_pending_adj = pending_stack_adjust;
1501           pending_stack_adjust = 0;
1502           /* stack_arg_under_construction says whether a stack arg is
1503              being constructed at the old stack level.  Pushing the stack
1504              gets a clean outgoing argument block.  */
1505           old_stack_arg_under_construction = stack_arg_under_construction;
1506           stack_arg_under_construction = 0;
1507           /* Make a new map for the new argument list.  */
1508           stack_usage_map = (char *)alloca (highest_outgoing_arg_in_use);
1509           bzero (stack_usage_map, highest_outgoing_arg_in_use);
1510           highest_outgoing_arg_in_use = 0;
1511         }
1512       allocate_dynamic_stack_space (push_size, NULL_RTX, BITS_PER_UNIT);
1513     }
1514   /* If argument evaluation might modify the stack pointer, copy the
1515      address of the argument list to a register.  */
1516   for (i = 0; i < num_actuals; i++)
1517     if (args[i].pass_on_stack)
1518       {
1519         argblock = copy_addr_to_reg (argblock);
1520         break;
1521       }
1522 #endif
1523
1524
1525   /* If we preallocated stack space, compute the address of each argument.
1526      We need not ensure it is a valid memory address here; it will be
1527      validized when it is used.  */
1528   if (argblock)
1529     {
1530       rtx arg_reg = argblock;
1531       int arg_offset = 0;
1532
1533       if (GET_CODE (argblock) == PLUS)
1534         arg_reg = XEXP (argblock, 0), arg_offset = INTVAL (XEXP (argblock, 1));
1535
1536       for (i = 0; i < num_actuals; i++)
1537         {
1538           rtx offset = ARGS_SIZE_RTX (args[i].offset);
1539           rtx slot_offset = ARGS_SIZE_RTX (args[i].slot_offset);
1540           rtx addr;
1541
1542           /* Skip this parm if it will not be passed on the stack.  */
1543           if (! args[i].pass_on_stack && args[i].reg != 0)
1544             continue;
1545
1546           if (GET_CODE (offset) == CONST_INT)
1547             addr = plus_constant (arg_reg, INTVAL (offset));
1548           else
1549             addr = gen_rtx (PLUS, Pmode, arg_reg, offset);
1550
1551           addr = plus_constant (addr, arg_offset);
1552           args[i].stack = gen_rtx (MEM, args[i].mode, addr);
1553           MEM_IN_STRUCT_P (args[i].stack)
1554             = AGGREGATE_TYPE_P (TREE_TYPE (args[i].tree_value));
1555
1556           if (GET_CODE (slot_offset) == CONST_INT)
1557             addr = plus_constant (arg_reg, INTVAL (slot_offset));
1558           else
1559             addr = gen_rtx (PLUS, Pmode, arg_reg, slot_offset);
1560
1561           addr = plus_constant (addr, arg_offset);
1562           args[i].stack_slot = gen_rtx (MEM, args[i].mode, addr);
1563         }
1564     }
1565
1566 #ifdef PUSH_ARGS_REVERSED
1567 #ifdef STACK_BOUNDARY
1568   /* If we push args individually in reverse order, perform stack alignment
1569      before the first push (the last arg).  */
1570   if (argblock == 0)
1571     anti_adjust_stack (GEN_INT (args_size.constant
1572                                 - original_args_size.constant));
1573 #endif
1574 #endif
1575
1576   /* Don't try to defer pops if preallocating, not even from the first arg,
1577      since ARGBLOCK probably refers to the SP.  */
1578   if (argblock)
1579     NO_DEFER_POP;
1580
1581   /* Get the function to call, in the form of RTL.  */
1582   if (fndecl)
1583     {
1584       /* If this is the first use of the function, see if we need to
1585          make an external definition for it.  */
1586       if (! TREE_USED (fndecl))
1587         {
1588           assemble_external (fndecl);
1589           TREE_USED (fndecl) = 1;
1590         }
1591
1592       /* Get a SYMBOL_REF rtx for the function address.  */
1593       funexp = XEXP (DECL_RTL (fndecl), 0);
1594     }
1595   else
1596     /* Generate an rtx (probably a pseudo-register) for the address.  */
1597     {
1598       push_temp_slots ();
1599       funexp = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
1600       pop_temp_slots ();        /* FUNEXP can't be BLKmode */
1601       emit_queue ();
1602     }
1603
1604   /* Figure out the register where the value, if any, will come back.  */
1605   valreg = 0;
1606   if (TYPE_MODE (TREE_TYPE (exp)) != VOIDmode
1607       && ! structure_value_addr)
1608     {
1609       if (pcc_struct_value)
1610         valreg = hard_function_value (build_pointer_type (TREE_TYPE (exp)),
1611                                       fndecl);
1612       else
1613         valreg = hard_function_value (TREE_TYPE (exp), fndecl);
1614     }
1615
1616   /* Precompute all register parameters.  It isn't safe to compute anything
1617      once we have started filling any specific hard regs. */
1618   reg_parm_seen = 0;
1619   for (i = 0; i < num_actuals; i++)
1620     if (args[i].reg != 0 && ! args[i].pass_on_stack)
1621       {
1622         reg_parm_seen = 1;
1623
1624         if (args[i].value == 0)
1625           {
1626             push_temp_slots ();
1627             args[i].value = expand_expr (args[i].tree_value, NULL_RTX,
1628                                          VOIDmode, 0);
1629             preserve_temp_slots (args[i].value);
1630             pop_temp_slots ();
1631
1632             /* ANSI doesn't require a sequence point here,
1633                but PCC has one, so this will avoid some problems.  */
1634             emit_queue ();
1635           }
1636
1637         /* If we are to promote the function arg to a wider mode,
1638            do it now.  */
1639
1640         if (args[i].mode != TYPE_MODE (TREE_TYPE (args[i].tree_value)))
1641           args[i].value
1642             = convert_modes (args[i].mode,
1643                              TYPE_MODE (TREE_TYPE (args[i].tree_value)),
1644                              args[i].value, args[i].unsignedp);
1645
1646         /* If the value is expensive, and we are inside an appropriately
1647            short loop, put the value into a pseudo and then put the pseudo
1648            into the hard reg.
1649
1650            For small register classes, also do this if this call uses
1651            register parameters.  This is to avoid reload conflicts while
1652            loading the parameters registers.  */
1653
1654         if ((! (GET_CODE (args[i].value) == REG
1655                 || (GET_CODE (args[i].value) == SUBREG
1656                     && GET_CODE (SUBREG_REG (args[i].value)) == REG)))
1657             && args[i].mode != BLKmode
1658             && rtx_cost (args[i].value, SET) > 2
1659 #ifdef SMALL_REGISTER_CLASSES
1660             && (reg_parm_seen || preserve_subexpressions_p ())
1661 #else
1662             && preserve_subexpressions_p ()
1663 #endif
1664             )
1665           args[i].value = copy_to_mode_reg (args[i].mode, args[i].value);
1666       }
1667
1668 #if defined(ACCUMULATE_OUTGOING_ARGS) && defined(REG_PARM_STACK_SPACE)
1669   /* The argument list is the property of the called routine and it
1670      may clobber it.  If the fixed area has been used for previous
1671      parameters, we must save and restore it.
1672
1673      Here we compute the boundary of the that needs to be saved, if any.  */
1674
1675 #ifdef ARGS_GROW_DOWNWARD
1676   for (i = 0; i < reg_parm_stack_space + 1; i++)
1677 #else
1678   for (i = 0; i < reg_parm_stack_space; i++)
1679 #endif
1680     {
1681       if (i >=  highest_outgoing_arg_in_use
1682           || stack_usage_map[i] == 0)
1683         continue;
1684
1685       if (low_to_save == -1)
1686         low_to_save = i;
1687
1688       high_to_save = i;
1689     }
1690
1691   if (low_to_save >= 0)
1692     {
1693       int num_to_save = high_to_save - low_to_save + 1;
1694       enum machine_mode save_mode
1695         = mode_for_size (num_to_save * BITS_PER_UNIT, MODE_INT, 1);
1696       rtx stack_area;
1697
1698       /* If we don't have the required alignment, must do this in BLKmode.  */
1699       if ((low_to_save & (MIN (GET_MODE_SIZE (save_mode),
1700                                BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1)))
1701         save_mode = BLKmode;
1702
1703       stack_area = gen_rtx (MEM, save_mode,
1704                             memory_address (save_mode,
1705
1706 #ifdef ARGS_GROW_DOWNWARD
1707                                             plus_constant (argblock,
1708                                                            - high_to_save)
1709 #else
1710                                             plus_constant (argblock,
1711                                                            low_to_save)
1712 #endif
1713                                             ));
1714       if (save_mode == BLKmode)
1715         {
1716           save_area = assign_stack_temp (BLKmode, num_to_save, 0);
1717           MEM_IN_STRUCT_P (save_area) = 0;
1718           emit_block_move (validize_mem (save_area), stack_area,
1719                            GEN_INT (num_to_save),
1720                            PARM_BOUNDARY / BITS_PER_UNIT);
1721         }
1722       else
1723         {
1724           save_area = gen_reg_rtx (save_mode);
1725           emit_move_insn (save_area, stack_area);
1726         }
1727     }
1728 #endif
1729
1730
1731   /* Now store (and compute if necessary) all non-register parms.
1732      These come before register parms, since they can require block-moves,
1733      which could clobber the registers used for register parms.
1734      Parms which have partial registers are not stored here,
1735      but we do preallocate space here if they want that.  */
1736
1737   for (i = 0; i < num_actuals; i++)
1738     if (args[i].reg == 0 || args[i].pass_on_stack)
1739       store_one_arg (&args[i], argblock, may_be_alloca,
1740                      args_size.var != 0, fndecl, reg_parm_stack_space);
1741
1742   /* If we have a parm that is passed in registers but not in memory
1743      and whose alignment does not permit a direct copy into registers,
1744      make a group of pseudos that correspond to each register that we
1745      will later fill.  */
1746
1747   if (STRICT_ALIGNMENT)
1748     for (i = 0; i < num_actuals; i++)
1749       if (args[i].reg != 0 && ! args[i].pass_on_stack
1750         && args[i].mode == BLKmode
1751           && (TYPE_ALIGN (TREE_TYPE (args[i].tree_value))
1752               < MIN (BIGGEST_ALIGNMENT, BITS_PER_WORD)))
1753         {
1754           int bytes = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
1755           int big_endian_correction = 0;
1756
1757           args[i].n_aligned_regs
1758             = args[i].partial ? args[i].partial
1759               : (bytes + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
1760
1761           args[i].aligned_regs = (rtx *) alloca (sizeof (rtx)
1762                                                  * args[i].n_aligned_regs);
1763
1764           /* Structures smaller than a word are aligned to the least
1765              significant byte (to the right).  On a BYTES_BIG_ENDIAN machine,
1766              this means we must skip the empty high order bytes when
1767              calculating the bit offset.  */
1768           if (BYTES_BIG_ENDIAN && bytes < UNITS_PER_WORD)
1769             big_endian_correction = (BITS_PER_WORD  - (bytes * BITS_PER_UNIT));
1770
1771           for (j = 0; j < args[i].n_aligned_regs; j++)
1772             {
1773               rtx reg = gen_reg_rtx (word_mode);
1774               rtx word = operand_subword_force (args[i].value, j, BLKmode);
1775               int bitsize = TYPE_ALIGN (TREE_TYPE (args[i].tree_value));
1776               int bitpos;
1777
1778               args[i].aligned_regs[j] = reg;
1779
1780               /* Clobber REG and move each partword into it.  Ensure we don't
1781                  go past the end of the structure.  Note that the loop below
1782                  works because we've already verified that padding
1783                  and endianness are compatible.  */
1784
1785               emit_insn (gen_rtx (CLOBBER, VOIDmode, reg));
1786
1787               for (bitpos = 0;
1788                    bitpos < BITS_PER_WORD && bytes > 0;
1789                    bitpos += bitsize, bytes -= bitsize / BITS_PER_UNIT)
1790                 {
1791                   int xbitpos = bitpos + big_endian_correction;
1792
1793                   store_bit_field (reg, bitsize, xbitpos, word_mode,
1794                                    extract_bit_field (word, bitsize, bitpos, 1,
1795                                                       NULL_RTX, word_mode,
1796                                                       word_mode,
1797                                                       bitsize / BITS_PER_UNIT,
1798                                                       BITS_PER_WORD),
1799                                    bitsize / BITS_PER_UNIT, BITS_PER_WORD);
1800                 }
1801             }
1802         }
1803
1804   /* Now store any partially-in-registers parm.
1805      This is the last place a block-move can happen.  */
1806   if (reg_parm_seen)
1807     for (i = 0; i < num_actuals; i++)
1808       if (args[i].partial != 0 && ! args[i].pass_on_stack)
1809         store_one_arg (&args[i], argblock, may_be_alloca,
1810                        args_size.var != 0, fndecl, reg_parm_stack_space);
1811
1812 #ifndef PUSH_ARGS_REVERSED
1813 #ifdef STACK_BOUNDARY
1814   /* If we pushed args in forward order, perform stack alignment
1815      after pushing the last arg.  */
1816   if (argblock == 0)
1817     anti_adjust_stack (GEN_INT (args_size.constant
1818                                 - original_args_size.constant));
1819 #endif
1820 #endif
1821
1822   /* If register arguments require space on the stack and stack space
1823      was not preallocated, allocate stack space here for arguments
1824      passed in registers.  */
1825 #if ! defined(ACCUMULATE_OUTGOING_ARGS) && defined(OUTGOING_REG_PARM_STACK_SPACE)
1826   if (must_preallocate == 0 && reg_parm_stack_space > 0)
1827     anti_adjust_stack (GEN_INT (reg_parm_stack_space));
1828 #endif
1829
1830   /* Pass the function the address in which to return a structure value.  */
1831   if (structure_value_addr && ! structure_value_addr_parm)
1832     {
1833       emit_move_insn (struct_value_rtx,
1834                       force_reg (Pmode,
1835                                  force_operand (structure_value_addr,
1836                                                 NULL_RTX)));
1837       if (GET_CODE (struct_value_rtx) == REG)
1838           use_reg (&call_fusage, struct_value_rtx);
1839     }
1840
1841   funexp = prepare_call_address (funexp, fndecl, &call_fusage, reg_parm_seen);
1842
1843   /* Now do the register loads required for any wholly-register parms or any
1844      parms which are passed both on the stack and in a register.  Their
1845      expressions were already evaluated.
1846
1847      Mark all register-parms as living through the call, putting these USE
1848      insns in the CALL_INSN_FUNCTION_USAGE field.  */
1849
1850   for (i = 0; i < num_actuals; i++)
1851     {
1852       rtx list = args[i].reg;
1853       int partial = args[i].partial;
1854
1855       while (list)
1856         {
1857           rtx reg;
1858           int nregs;
1859
1860           /* Process each register that needs to get this arg.  */
1861           if (GET_CODE (list) == EXPR_LIST)
1862             reg = XEXP (list, 0), list = XEXP (list, 1);
1863           else
1864             reg = list, list = 0;
1865
1866           /* Set to non-negative if must move a word at a time, even if just
1867              one word (e.g, partial == 1 && mode == DFmode).  Set to -1 if
1868              we just use a normal move insn.  This value can be zero if the
1869              argument is a zero size structure with no fields.  */
1870           nregs = (partial ? partial
1871                    : (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
1872                       ? ((int_size_in_bytes (TREE_TYPE (args[i].tree_value))
1873                           + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
1874                       : -1));
1875
1876           /* If simple case, just do move.  If normal partial, store_one_arg
1877              has already loaded the register for us.  In all other cases,
1878              load the register(s) from memory.  */
1879
1880           if (nregs == -1)
1881             emit_move_insn (reg, args[i].value);
1882
1883           /* If we have pre-computed the values to put in the registers in
1884              the case of non-aligned structures, copy them in now.  */
1885
1886           else if (args[i].n_aligned_regs != 0)
1887             for (j = 0; j < args[i].n_aligned_regs; j++)
1888               emit_move_insn (gen_rtx (REG, word_mode, REGNO (reg) + j),
1889                               args[i].aligned_regs[j]);
1890
1891           else if (args[i].partial == 0 || args[i].pass_on_stack)
1892             move_block_to_reg (REGNO (reg),
1893                                validize_mem (args[i].value), nregs,
1894                                args[i].mode);
1895
1896           if (nregs == -1)
1897             use_reg (&call_fusage, reg);
1898           else
1899             use_regs (&call_fusage, REGNO (reg), nregs == 0 ? 1 : nregs);
1900
1901           /* PARTIAL referred only to the first register, so clear it for the
1902              next time.  */
1903           partial = 0;
1904         }
1905     }
1906
1907   /* Perform postincrements before actually calling the function.  */
1908   emit_queue ();
1909
1910   /* All arguments and registers used for the call must be set up by now!  */
1911
1912   /* Generate the actual call instruction.  */
1913   emit_call_1 (funexp, fndecl, funtype, args_size.constant, struct_value_size,
1914                FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
1915                valreg, old_inhibit_defer_pop, call_fusage, is_const);
1916
1917   /* If call is cse'able, make appropriate pair of reg-notes around it.
1918      Test valreg so we don't crash; may safely ignore `const'
1919      if return type is void.  */
1920   if (is_const && valreg != 0)
1921     {
1922       rtx note = 0;
1923       rtx temp = gen_reg_rtx (GET_MODE (valreg));
1924       rtx insns;
1925
1926       /* Construct an "equal form" for the value which mentions all the
1927          arguments in order as well as the function name.  */
1928 #ifdef PUSH_ARGS_REVERSED
1929       for (i = 0; i < num_actuals; i++)
1930         note = gen_rtx (EXPR_LIST, VOIDmode, args[i].initial_value, note);
1931 #else
1932       for (i = num_actuals - 1; i >= 0; i--)
1933         note = gen_rtx (EXPR_LIST, VOIDmode, args[i].initial_value, note);
1934 #endif
1935       note = gen_rtx (EXPR_LIST, VOIDmode, funexp, note);
1936
1937       insns = get_insns ();
1938       end_sequence ();
1939
1940       emit_libcall_block (insns, temp, valreg, note);
1941
1942       valreg = temp;
1943     }
1944   else if (is_const)
1945     {
1946       /* Otherwise, just write out the sequence without a note.  */
1947       rtx insns = get_insns ();
1948
1949       end_sequence ();
1950       emit_insns (insns);
1951     }
1952
1953   /* For calls to `setjmp', etc., inform flow.c it should complain
1954      if nonvolatile values are live.  */
1955
1956   if (returns_twice)
1957     {
1958       emit_note (name, NOTE_INSN_SETJMP);
1959       current_function_calls_setjmp = 1;
1960     }
1961
1962   if (is_longjmp)
1963     current_function_calls_longjmp = 1;
1964
1965   /* Notice functions that cannot return.
1966      If optimizing, insns emitted below will be dead.
1967      If not optimizing, they will exist, which is useful
1968      if the user uses the `return' command in the debugger.  */
1969
1970   if (is_volatile || is_longjmp)
1971     emit_barrier ();
1972
1973   /* If value type not void, return an rtx for the value.  */
1974
1975   /* If there are cleanups to be called, don't use a hard reg as target.  */
1976   if (cleanups_this_call != old_cleanups
1977       && target && REG_P (target)
1978       && REGNO (target) < FIRST_PSEUDO_REGISTER)
1979     target = 0;
1980
1981   if (TYPE_MODE (TREE_TYPE (exp)) == VOIDmode
1982       || ignore)
1983     {
1984       target = const0_rtx;
1985     }
1986   else if (structure_value_addr)
1987     {
1988       if (target == 0 || GET_CODE (target) != MEM)
1989         {
1990           target = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)),
1991                             memory_address (TYPE_MODE (TREE_TYPE (exp)),
1992                                             structure_value_addr));
1993           MEM_IN_STRUCT_P (target) = AGGREGATE_TYPE_P (TREE_TYPE (exp));
1994         }
1995     }
1996   else if (pcc_struct_value)
1997     {
1998       if (target == 0)
1999         {
2000           /* We used leave the value in the location that it is
2001              returned in, but that causes problems if it is used more
2002              than once in one expression.  Rather than trying to track
2003              when a copy is required, we always copy when TARGET is
2004              not specified.  This calling sequence is only used on
2005              a few machines and TARGET is usually nonzero.  */
2006           if (TYPE_MODE (TREE_TYPE (exp)) == BLKmode)
2007             {
2008               target = assign_stack_temp (BLKmode,
2009                                           int_size_in_bytes (TREE_TYPE (exp)),
2010                                           0);
2011
2012               MEM_IN_STRUCT_P (target) = AGGREGATE_TYPE_P (TREE_TYPE (exp));
2013
2014               /* Save this temp slot around the pop below.  */
2015               preserve_temp_slots (target);
2016             }
2017           else
2018             target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
2019         }
2020
2021       if (TYPE_MODE (TREE_TYPE (exp)) != BLKmode)
2022         emit_move_insn (target, gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)),
2023                                          copy_to_reg (valreg)));
2024       else
2025         emit_block_move (target, gen_rtx (MEM, BLKmode, copy_to_reg (valreg)),
2026                          expr_size (exp),
2027                          TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT);
2028     }
2029   else if (target && GET_MODE (target) == TYPE_MODE (TREE_TYPE (exp))
2030            && GET_MODE (target) == GET_MODE (valreg))
2031     /* TARGET and VALREG cannot be equal at this point because the latter
2032        would not have REG_FUNCTION_VALUE_P true, while the former would if
2033        it were referring to the same register.
2034
2035        If they refer to the same register, this move will be a no-op, except
2036        when function inlining is being done.  */
2037     emit_move_insn (target, valreg);
2038   else if (TYPE_MODE (TREE_TYPE (exp)) == BLKmode)
2039     {
2040       /* Some machines (the PA for example) want to return all small
2041          structures in registers regardless of the structure's alignment.
2042
2043          Deal with them explicitly by copying from the return registers
2044          into the target MEM locations.  */
2045       int bytes = int_size_in_bytes (TREE_TYPE (exp));
2046       int n_regs = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
2047       int i;
2048       enum machine_mode tmpmode;
2049       rtx src, dst;
2050       int bitsize = MIN (TYPE_ALIGN (TREE_TYPE (exp)), BITS_PER_WORD);
2051       int bitpos, xbitpos, big_endian_correction = 0;
2052
2053       if (target == 0)
2054         {
2055           target = assign_stack_temp (BLKmode, bytes, 0);
2056           MEM_IN_STRUCT_P (target) = AGGREGATE_TYPE_P (TREE_TYPE (exp));
2057           preserve_temp_slots (target);
2058         }
2059
2060       /* This code assumes valreg is at least a full word.  If it isn't,
2061          copy it into a new pseudo which is a full word.  */
2062       if (GET_MODE (valreg) != BLKmode
2063           && GET_MODE_SIZE (GET_MODE (valreg)) < UNITS_PER_WORD)
2064         valreg = convert_to_mode (SImode, valreg,
2065                                   TREE_UNSIGNED (TREE_TYPE (exp)));
2066
2067       /* Structures whose size is not a multiple of a word are aligned
2068          to the least significant byte (to the right).  On a BYTES_BIG_ENDIAN
2069          machine, this means we must skip the empty high order bytes when
2070          calculating the bit offset.  */
2071       if (BYTES_BIG_ENDIAN && bytes % UNITS_PER_WORD)
2072         big_endian_correction = (BITS_PER_WORD - ((bytes % UNITS_PER_WORD)
2073                                                   * BITS_PER_UNIT));
2074
2075       /* Copy the structure BITSIZE bites at a time.
2076
2077          We could probably emit more efficient code for machines
2078          which do not use strict alignment, but it doesn't seem
2079          worth the effort at the current time.  */
2080       for (bitpos = 0, xbitpos = big_endian_correction;
2081            bitpos < bytes * BITS_PER_UNIT;
2082            bitpos += bitsize, xbitpos += bitsize)
2083         {
2084
2085           /* We need a new source operand each time xbitpos is on a
2086              word boundary and when xbitpos == big_endian_correction
2087              (the first time through).  */
2088           if (xbitpos % BITS_PER_WORD == 0
2089               || xbitpos == big_endian_correction)
2090             src = operand_subword_force (valreg,
2091                                          xbitpos / BITS_PER_WORD,
2092                                          BLKmode);
2093
2094           /* We need a new destination operand each time bitpos is on
2095              a word boundary.  */
2096           if (bitpos % BITS_PER_WORD == 0)
2097             dst = operand_subword (target, bitpos / BITS_PER_WORD, 1, BLKmode);
2098
2099           /* Use xbitpos for the source extraction (right justified) and
2100              xbitpos for the destination store (left justified).  */
2101           store_bit_field (dst, bitsize, bitpos % BITS_PER_WORD, word_mode,
2102                            extract_bit_field (src, bitsize,
2103                                               xbitpos % BITS_PER_WORD, 1,
2104                                               NULL_RTX, word_mode,
2105                                               word_mode,
2106                                               bitsize / BITS_PER_UNIT,
2107                                               BITS_PER_WORD),
2108                            bitsize / BITS_PER_UNIT, BITS_PER_WORD);
2109         }
2110     }
2111   else
2112     target = copy_to_reg (valreg);
2113
2114 #ifdef PROMOTE_FUNCTION_RETURN
2115   /* If we promoted this return value, make the proper SUBREG.  TARGET
2116      might be const0_rtx here, so be careful.  */
2117   if (GET_CODE (target) == REG
2118       && TYPE_MODE (TREE_TYPE (exp)) != BLKmode
2119       && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
2120     {
2121       tree type = TREE_TYPE (exp);
2122       int unsignedp = TREE_UNSIGNED (type);
2123
2124       /* If we don't promote as expected, something is wrong.  */
2125       if (GET_MODE (target)
2126           != promote_mode (type, TYPE_MODE (type), &unsignedp, 1))
2127         abort ();
2128
2129       target = gen_rtx (SUBREG, TYPE_MODE (type), target, 0);
2130       SUBREG_PROMOTED_VAR_P (target) = 1;
2131       SUBREG_PROMOTED_UNSIGNED_P (target) = unsignedp;
2132     }
2133 #endif
2134
2135   if (flag_short_temps)
2136     {
2137       /* Perform all cleanups needed for the arguments of this call
2138          (i.e. destructors in C++).  */
2139       expand_cleanups_to (old_cleanups);
2140     }
2141
2142   /* If size of args is variable or this was a constructor call for a stack
2143      argument, restore saved stack-pointer value.  */
2144
2145   if (old_stack_level)
2146     {
2147       emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
2148       pending_stack_adjust = old_pending_adj;
2149 #ifdef ACCUMULATE_OUTGOING_ARGS
2150       stack_arg_under_construction = old_stack_arg_under_construction;
2151       highest_outgoing_arg_in_use = initial_highest_arg_in_use;
2152       stack_usage_map = initial_stack_usage_map;
2153 #endif
2154     }
2155 #ifdef ACCUMULATE_OUTGOING_ARGS
2156   else
2157     {
2158 #ifdef REG_PARM_STACK_SPACE
2159       if (save_area)
2160         {
2161           enum machine_mode save_mode = GET_MODE (save_area);
2162           rtx stack_area
2163             = gen_rtx (MEM, save_mode,
2164                        memory_address (save_mode,
2165 #ifdef ARGS_GROW_DOWNWARD
2166                                        plus_constant (argblock, - high_to_save)
2167 #else
2168                                        plus_constant (argblock, low_to_save)
2169 #endif
2170                                        ));
2171
2172           if (save_mode != BLKmode)
2173             emit_move_insn (stack_area, save_area);
2174           else
2175             emit_block_move (stack_area, validize_mem (save_area),
2176                              GEN_INT (high_to_save - low_to_save + 1),
2177                              PARM_BOUNDARY / BITS_PER_UNIT);
2178         }
2179 #endif
2180
2181       /* If we saved any argument areas, restore them.  */
2182       for (i = 0; i < num_actuals; i++)
2183         if (args[i].save_area)
2184           {
2185             enum machine_mode save_mode = GET_MODE (args[i].save_area);
2186             rtx stack_area
2187               = gen_rtx (MEM, save_mode,
2188                          memory_address (save_mode,
2189                                          XEXP (args[i].stack_slot, 0)));
2190
2191             if (save_mode != BLKmode)
2192               emit_move_insn (stack_area, args[i].save_area);
2193             else
2194               emit_block_move (stack_area, validize_mem (args[i].save_area),
2195                                GEN_INT (args[i].size.constant),
2196                                PARM_BOUNDARY / BITS_PER_UNIT);
2197           }
2198
2199       highest_outgoing_arg_in_use = initial_highest_arg_in_use;
2200       stack_usage_map = initial_stack_usage_map;
2201     }
2202 #endif
2203
2204   /* If this was alloca, record the new stack level for nonlocal gotos.
2205      Check for the handler slots since we might not have a save area
2206      for non-local gotos. */
2207
2208   if (may_be_alloca && nonlocal_goto_handler_slot != 0)
2209     emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
2210
2211   pop_temp_slots ();
2212
2213   return target;
2214 }
2215 \f
2216 /* Output a library call to function FUN (a SYMBOL_REF rtx)
2217    (emitting the queue unless NO_QUEUE is nonzero),
2218    for a value of mode OUTMODE,
2219    with NARGS different arguments, passed as alternating rtx values
2220    and machine_modes to convert them to.
2221    The rtx values should have been passed through protect_from_queue already.
2222
2223    NO_QUEUE will be true if and only if the library call is a `const' call
2224    which will be enclosed in REG_LIBCALL/REG_RETVAL notes; it is equivalent
2225    to the variable is_const in expand_call.
2226
2227    NO_QUEUE must be true for const calls, because if it isn't, then
2228    any pending increment will be emitted between REG_LIBCALL/REG_RETVAL notes,
2229    and will be lost if the libcall sequence is optimized away.
2230
2231    NO_QUEUE must be false for non-const calls, because if it isn't, the
2232    call insn will have its CONST_CALL_P bit set, and it will be incorrectly
2233    optimized.  For instance, the instruction scheduler may incorrectly
2234    move memory references across the non-const call.  */
2235
2236 void
2237 emit_library_call VPROTO((rtx orgfun, int no_queue, enum machine_mode outmode,
2238                           int nargs, ...))
2239 {
2240 #ifndef __STDC__
2241   rtx orgfun;
2242   int no_queue;
2243   enum machine_mode outmode;
2244   int nargs;
2245 #endif
2246   va_list p;
2247   /* Total size in bytes of all the stack-parms scanned so far.  */
2248   struct args_size args_size;
2249   /* Size of arguments before any adjustments (such as rounding).  */
2250   struct args_size original_args_size;
2251   register int argnum;
2252   rtx fun;
2253   int inc;
2254   int count;
2255   rtx argblock = 0;
2256   CUMULATIVE_ARGS args_so_far;
2257   struct arg { rtx value; enum machine_mode mode; rtx reg; int partial;
2258                struct args_size offset; struct args_size size; };
2259   struct arg *argvec;
2260   int old_inhibit_defer_pop = inhibit_defer_pop;
2261   rtx call_fusage = 0;
2262   /* library calls are never indirect calls.  */
2263   int current_call_is_indirect = 0;
2264
2265   VA_START (p, nargs);
2266
2267 #ifndef __STDC__
2268   orgfun = va_arg (p, rtx);
2269   no_queue = va_arg (p, int);
2270   outmode = va_arg (p, enum machine_mode);
2271   nargs = va_arg (p, int);
2272 #endif
2273
2274   fun = orgfun;
2275
2276   /* Copy all the libcall-arguments out of the varargs data
2277      and into a vector ARGVEC.
2278
2279      Compute how to pass each argument.  We only support a very small subset
2280      of the full argument passing conventions to limit complexity here since
2281      library functions shouldn't have many args.  */
2282
2283   argvec = (struct arg *) alloca (nargs * sizeof (struct arg));
2284
2285   INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE, fun);
2286
2287   args_size.constant = 0;
2288   args_size.var = 0;
2289
2290   push_temp_slots ();
2291
2292   for (count = 0; count < nargs; count++)
2293     {
2294       rtx val = va_arg (p, rtx);
2295       enum machine_mode mode = va_arg (p, enum machine_mode);
2296
2297       /* We cannot convert the arg value to the mode the library wants here;
2298          must do it earlier where we know the signedness of the arg.  */
2299       if (mode == BLKmode
2300           || (GET_MODE (val) != mode && GET_MODE (val) != VOIDmode))
2301         abort ();
2302
2303       /* On some machines, there's no way to pass a float to a library fcn.
2304          Pass it as a double instead.  */
2305 #ifdef LIBGCC_NEEDS_DOUBLE
2306       if (LIBGCC_NEEDS_DOUBLE && mode == SFmode)
2307         val = convert_modes (DFmode, SFmode, val, 0), mode = DFmode;
2308 #endif
2309
2310       /* There's no need to call protect_from_queue, because
2311          either emit_move_insn or emit_push_insn will do that.  */
2312
2313       /* Make sure it is a reasonable operand for a move or push insn.  */
2314       if (GET_CODE (val) != REG && GET_CODE (val) != MEM
2315           && ! (CONSTANT_P (val) && LEGITIMATE_CONSTANT_P (val)))
2316         val = force_operand (val, NULL_RTX);
2317
2318 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
2319       if (FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, mode, NULL_TREE, 1))
2320         {
2321           /* We do not support FUNCTION_ARG_CALLEE_COPIES here since it can
2322              be viewed as just an efficiency improvement.  */
2323           rtx slot = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0);
2324           emit_move_insn (slot, val);
2325           val = force_operand (XEXP (slot, 0), NULL_RTX);
2326           mode = Pmode;
2327         }
2328 #endif
2329
2330       argvec[count].value = val;
2331       argvec[count].mode = mode;
2332
2333       argvec[count].reg = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1);
2334       if (argvec[count].reg && GET_CODE (argvec[count].reg) == EXPR_LIST)
2335         abort ();
2336 #ifdef FUNCTION_ARG_PARTIAL_NREGS
2337       argvec[count].partial
2338         = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, NULL_TREE, 1);
2339 #else
2340       argvec[count].partial = 0;
2341 #endif
2342
2343       locate_and_pad_parm (mode, NULL_TREE,
2344                            argvec[count].reg && argvec[count].partial == 0,
2345                            NULL_TREE, &args_size, &argvec[count].offset,
2346                            &argvec[count].size);
2347
2348       if (argvec[count].size.var)
2349         abort ();
2350
2351 #ifndef REG_PARM_STACK_SPACE
2352       if (argvec[count].partial)
2353         argvec[count].size.constant -= argvec[count].partial * UNITS_PER_WORD;
2354 #endif
2355
2356       if (argvec[count].reg == 0 || argvec[count].partial != 0
2357 #ifdef REG_PARM_STACK_SPACE
2358           || 1
2359 #endif
2360           )
2361         args_size.constant += argvec[count].size.constant;
2362
2363 #ifdef ACCUMULATE_OUTGOING_ARGS
2364       /* If this arg is actually passed on the stack, it might be
2365          clobbering something we already put there (this library call might
2366          be inside the evaluation of an argument to a function whose call
2367          requires the stack).  This will only occur when the library call
2368          has sufficient args to run out of argument registers.  Abort in
2369          this case; if this ever occurs, code must be added to save and
2370          restore the arg slot.  */
2371
2372       if (argvec[count].reg == 0 || argvec[count].partial != 0)
2373         abort ();
2374 #endif
2375
2376       FUNCTION_ARG_ADVANCE (args_so_far, mode, (tree)0, 1);
2377     }
2378   va_end (p);
2379
2380   /* If this machine requires an external definition for library
2381      functions, write one out.  */
2382   assemble_external_libcall (fun);
2383
2384   original_args_size = args_size;
2385 #ifdef STACK_BOUNDARY
2386   args_size.constant = (((args_size.constant + (STACK_BYTES - 1))
2387                          / STACK_BYTES) * STACK_BYTES);
2388 #endif
2389
2390 #ifdef REG_PARM_STACK_SPACE
2391   args_size.constant = MAX (args_size.constant,
2392                             REG_PARM_STACK_SPACE (NULL_TREE));
2393 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2394   args_size.constant -= REG_PARM_STACK_SPACE (NULL_TREE);
2395 #endif
2396 #endif
2397
2398   if (args_size.constant > current_function_outgoing_args_size)
2399     current_function_outgoing_args_size = args_size.constant;
2400
2401 #ifdef ACCUMULATE_OUTGOING_ARGS
2402   args_size.constant = 0;
2403 #endif
2404
2405 #ifndef PUSH_ROUNDING
2406   argblock = push_block (GEN_INT (args_size.constant), 0, 0);
2407 #endif
2408
2409 #ifdef PUSH_ARGS_REVERSED
2410 #ifdef STACK_BOUNDARY
2411   /* If we push args individually in reverse order, perform stack alignment
2412      before the first push (the last arg).  */
2413   if (argblock == 0)
2414     anti_adjust_stack (GEN_INT (args_size.constant
2415                                 - original_args_size.constant));
2416 #endif
2417 #endif
2418
2419 #ifdef PUSH_ARGS_REVERSED
2420   inc = -1;
2421   argnum = nargs - 1;
2422 #else
2423   inc = 1;
2424   argnum = 0;
2425 #endif
2426
2427   /* Push the args that need to be pushed.  */
2428
2429   for (count = 0; count < nargs; count++, argnum += inc)
2430     {
2431       register enum machine_mode mode = argvec[argnum].mode;
2432       register rtx val = argvec[argnum].value;
2433       rtx reg = argvec[argnum].reg;
2434       int partial = argvec[argnum].partial;
2435
2436       if (! (reg != 0 && partial == 0))
2437         emit_push_insn (val, mode, NULL_TREE, NULL_RTX, 0, partial, reg, 0,
2438                         argblock, GEN_INT (argvec[count].offset.constant));
2439       NO_DEFER_POP;
2440     }
2441
2442 #ifndef PUSH_ARGS_REVERSED
2443 #ifdef STACK_BOUNDARY
2444   /* If we pushed args in forward order, perform stack alignment
2445      after pushing the last arg.  */
2446   if (argblock == 0)
2447     anti_adjust_stack (GEN_INT (args_size.constant
2448                                 - original_args_size.constant));
2449 #endif
2450 #endif
2451
2452 #ifdef PUSH_ARGS_REVERSED
2453   argnum = nargs - 1;
2454 #else
2455   argnum = 0;
2456 #endif
2457
2458   fun = prepare_call_address (fun, NULL_TREE, &call_fusage, 0);
2459
2460   /* Now load any reg parms into their regs.  */
2461
2462   for (count = 0; count < nargs; count++, argnum += inc)
2463     {
2464       register enum machine_mode mode = argvec[argnum].mode;
2465       register rtx val = argvec[argnum].value;
2466       rtx reg = argvec[argnum].reg;
2467       int partial = argvec[argnum].partial;
2468
2469       if (reg != 0 && partial == 0)
2470         emit_move_insn (reg, val);
2471       NO_DEFER_POP;
2472     }
2473
2474   /* For version 1.37, try deleting this entirely.  */
2475   if (! no_queue)
2476     emit_queue ();
2477
2478   /* Any regs containing parms remain in use through the call.  */
2479   for (count = 0; count < nargs; count++)
2480     if (argvec[count].reg != 0)
2481        use_reg (&call_fusage, argvec[count].reg);
2482
2483   /* Don't allow popping to be deferred, since then
2484      cse'ing of library calls could delete a call and leave the pop.  */
2485   NO_DEFER_POP;
2486
2487   /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
2488      will set inhibit_defer_pop to that value.  */
2489
2490   emit_call_1 (fun,
2491                get_identifier (XSTR (orgfun, 0)),
2492                get_identifier (XSTR (orgfun, 0)), args_size.constant, 0,
2493                FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
2494                outmode != VOIDmode ? hard_libcall_value (outmode) : NULL_RTX,
2495                old_inhibit_defer_pop + 1, call_fusage, no_queue);
2496
2497   pop_temp_slots ();
2498
2499   /* Now restore inhibit_defer_pop to its actual original value.  */
2500   OK_DEFER_POP;
2501 }
2502 \f
2503 /* Like emit_library_call except that an extra argument, VALUE,
2504    comes second and says where to store the result.
2505    (If VALUE is zero, this function chooses a convenient way
2506    to return the value.
2507
2508    This function returns an rtx for where the value is to be found.
2509    If VALUE is nonzero, VALUE is returned.  */
2510
2511 rtx
2512 emit_library_call_value VPROTO((rtx orgfun, rtx value, int no_queue,
2513                                 enum machine_mode outmode, int nargs, ...))
2514 {
2515 #ifndef __STDC__
2516   rtx orgfun;
2517   rtx value;
2518   int no_queue;
2519   enum machine_mode outmode;
2520   int nargs;
2521 #endif
2522   va_list p;
2523   /* Total size in bytes of all the stack-parms scanned so far.  */
2524   struct args_size args_size;
2525   /* Size of arguments before any adjustments (such as rounding).  */
2526   struct args_size original_args_size;
2527   register int argnum;
2528   rtx fun;
2529   int inc;
2530   int count;
2531   rtx argblock = 0;
2532   CUMULATIVE_ARGS args_so_far;
2533   struct arg { rtx value; enum machine_mode mode; rtx reg; int partial;
2534                struct args_size offset; struct args_size size; };
2535   struct arg *argvec;
2536   int old_inhibit_defer_pop = inhibit_defer_pop;
2537   rtx call_fusage = 0;
2538   rtx mem_value = 0;
2539   int pcc_struct_value = 0;
2540   int struct_value_size = 0;
2541   /* library calls are never indirect calls.  */
2542   int current_call_is_indirect = 0;
2543   int is_const;
2544
2545   VA_START (p, nargs);
2546
2547 #ifndef __STDC__
2548   orgfun = va_arg (p, rtx);
2549   value = va_arg (p, rtx);
2550   no_queue = va_arg (p, int);
2551   outmode = va_arg (p, enum machine_mode);
2552   nargs = va_arg (p, int);
2553 #endif
2554
2555   is_const = no_queue;
2556   fun = orgfun;
2557
2558   /* If this kind of value comes back in memory,
2559      decide where in memory it should come back.  */
2560   if (aggregate_value_p (type_for_mode (outmode, 0)))
2561     {
2562 #ifdef PCC_STATIC_STRUCT_RETURN
2563       rtx pointer_reg
2564         = hard_function_value (build_pointer_type (type_for_mode (outmode, 0)),
2565                                0);
2566       mem_value = gen_rtx (MEM, outmode, pointer_reg);
2567       pcc_struct_value = 1;
2568       if (value == 0)
2569         value = gen_reg_rtx (outmode);
2570 #else /* not PCC_STATIC_STRUCT_RETURN */
2571       struct_value_size = GET_MODE_SIZE (outmode);
2572       if (value != 0 && GET_CODE (value) == MEM)
2573         mem_value = value;
2574       else
2575         mem_value = assign_stack_temp (outmode, GET_MODE_SIZE (outmode), 0);
2576 #endif
2577
2578       /* This call returns a big structure.  */
2579       is_const = 0;
2580     }
2581
2582   /* ??? Unfinished: must pass the memory address as an argument.  */
2583
2584   /* Copy all the libcall-arguments out of the varargs data
2585      and into a vector ARGVEC.
2586
2587      Compute how to pass each argument.  We only support a very small subset
2588      of the full argument passing conventions to limit complexity here since
2589      library functions shouldn't have many args.  */
2590
2591   argvec = (struct arg *) alloca ((nargs + 1) * sizeof (struct arg));
2592
2593   INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE, fun);
2594
2595   args_size.constant = 0;
2596   args_size.var = 0;
2597
2598   count = 0;
2599
2600   push_temp_slots ();
2601
2602   /* If there's a structure value address to be passed,
2603      either pass it in the special place, or pass it as an extra argument.  */
2604   if (mem_value && struct_value_rtx == 0 && ! pcc_struct_value)
2605     {
2606       rtx addr = XEXP (mem_value, 0);
2607       nargs++;
2608
2609       /* Make sure it is a reasonable operand for a move or push insn.  */
2610       if (GET_CODE (addr) != REG && GET_CODE (addr) != MEM
2611           && ! (CONSTANT_P (addr) && LEGITIMATE_CONSTANT_P (addr)))
2612         addr = force_operand (addr, NULL_RTX);
2613
2614       argvec[count].value = addr;
2615       argvec[count].mode = Pmode;
2616       argvec[count].partial = 0;
2617
2618       argvec[count].reg = FUNCTION_ARG (args_so_far, Pmode, NULL_TREE, 1);
2619 #ifdef FUNCTION_ARG_PARTIAL_NREGS
2620       if (FUNCTION_ARG_PARTIAL_NREGS (args_so_far, Pmode, NULL_TREE, 1))
2621         abort ();
2622 #endif
2623
2624       locate_and_pad_parm (Pmode, NULL_TREE,
2625                            argvec[count].reg && argvec[count].partial == 0,
2626                            NULL_TREE, &args_size, &argvec[count].offset,
2627                            &argvec[count].size);
2628
2629
2630       if (argvec[count].reg == 0 || argvec[count].partial != 0
2631 #ifdef REG_PARM_STACK_SPACE
2632           || 1
2633 #endif
2634           )
2635         args_size.constant += argvec[count].size.constant;
2636
2637       FUNCTION_ARG_ADVANCE (args_so_far, Pmode, (tree)0, 1);
2638
2639       count++;
2640     }
2641
2642   for (; count < nargs; count++)
2643     {
2644       rtx val = va_arg (p, rtx);
2645       enum machine_mode mode = va_arg (p, enum machine_mode);
2646
2647       /* We cannot convert the arg value to the mode the library wants here;
2648          must do it earlier where we know the signedness of the arg.  */
2649       if (mode == BLKmode
2650           || (GET_MODE (val) != mode && GET_MODE (val) != VOIDmode))
2651         abort ();
2652
2653       /* On some machines, there's no way to pass a float to a library fcn.
2654          Pass it as a double instead.  */
2655 #ifdef LIBGCC_NEEDS_DOUBLE
2656       if (LIBGCC_NEEDS_DOUBLE && mode == SFmode)
2657         val = convert_modes (DFmode, SFmode, val, 0), mode = DFmode;
2658 #endif
2659
2660       /* There's no need to call protect_from_queue, because
2661          either emit_move_insn or emit_push_insn will do that.  */
2662
2663       /* Make sure it is a reasonable operand for a move or push insn.  */
2664       if (GET_CODE (val) != REG && GET_CODE (val) != MEM
2665           && ! (CONSTANT_P (val) && LEGITIMATE_CONSTANT_P (val)))
2666         val = force_operand (val, NULL_RTX);
2667
2668 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
2669       if (FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, mode, NULL_TREE, 1))
2670         {
2671           /* We do not support FUNCTION_ARG_CALLEE_COPIES here since it can
2672              be viewed as just an efficiency improvement.  */
2673           rtx slot = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0);
2674           emit_move_insn (slot, val);
2675           val = XEXP (slot, 0);
2676           mode = Pmode;
2677         }
2678 #endif
2679
2680       argvec[count].value = val;
2681       argvec[count].mode = mode;
2682
2683       argvec[count].reg = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1);
2684       if (argvec[count].reg && GET_CODE (argvec[count].reg) == EXPR_LIST)
2685         abort ();
2686 #ifdef FUNCTION_ARG_PARTIAL_NREGS
2687       argvec[count].partial
2688         = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, NULL_TREE, 1);
2689 #else
2690       argvec[count].partial = 0;
2691 #endif
2692
2693       locate_and_pad_parm (mode, NULL_TREE,
2694                            argvec[count].reg && argvec[count].partial == 0,
2695                            NULL_TREE, &args_size, &argvec[count].offset,
2696                            &argvec[count].size);
2697
2698       if (argvec[count].size.var)
2699         abort ();
2700
2701 #ifndef REG_PARM_STACK_SPACE
2702       if (argvec[count].partial)
2703         argvec[count].size.constant -= argvec[count].partial * UNITS_PER_WORD;
2704 #endif
2705
2706       if (argvec[count].reg == 0 || argvec[count].partial != 0
2707 #ifdef REG_PARM_STACK_SPACE
2708           || 1
2709 #endif
2710           )
2711         args_size.constant += argvec[count].size.constant;
2712
2713 #ifdef ACCUMULATE_OUTGOING_ARGS
2714       /* If this arg is actually passed on the stack, it might be
2715          clobbering something we already put there (this library call might
2716          be inside the evaluation of an argument to a function whose call
2717          requires the stack).  This will only occur when the library call
2718          has sufficient args to run out of argument registers.  Abort in
2719          this case; if this ever occurs, code must be added to save and
2720          restore the arg slot.  */
2721
2722       if (argvec[count].reg == 0 || argvec[count].partial != 0)
2723         abort ();
2724 #endif
2725
2726       FUNCTION_ARG_ADVANCE (args_so_far, mode, (tree)0, 1);
2727     }
2728   va_end (p);
2729
2730   /* If this machine requires an external definition for library
2731      functions, write one out.  */
2732   assemble_external_libcall (fun);
2733
2734   original_args_size = args_size;
2735 #ifdef STACK_BOUNDARY
2736   args_size.constant = (((args_size.constant + (STACK_BYTES - 1))
2737                          / STACK_BYTES) * STACK_BYTES);
2738 #endif
2739
2740 #ifdef REG_PARM_STACK_SPACE
2741   args_size.constant = MAX (args_size.constant,
2742                             REG_PARM_STACK_SPACE (NULL_TREE));
2743 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2744   args_size.constant -= REG_PARM_STACK_SPACE (NULL_TREE);
2745 #endif
2746 #endif
2747
2748   if (args_size.constant > current_function_outgoing_args_size)
2749     current_function_outgoing_args_size = args_size.constant;
2750
2751 #ifdef ACCUMULATE_OUTGOING_ARGS
2752   args_size.constant = 0;
2753 #endif
2754
2755 #ifndef PUSH_ROUNDING
2756   argblock = push_block (GEN_INT (args_size.constant), 0, 0);
2757 #endif
2758
2759 #ifdef PUSH_ARGS_REVERSED
2760 #ifdef STACK_BOUNDARY
2761   /* If we push args individually in reverse order, perform stack alignment
2762      before the first push (the last arg).  */
2763   if (argblock == 0)
2764     anti_adjust_stack (GEN_INT (args_size.constant
2765                                 - original_args_size.constant));
2766 #endif
2767 #endif
2768
2769 #ifdef PUSH_ARGS_REVERSED
2770   inc = -1;
2771   argnum = nargs - 1;
2772 #else
2773   inc = 1;
2774   argnum = 0;
2775 #endif
2776
2777   /* Push the args that need to be pushed.  */
2778
2779   for (count = 0; count < nargs; count++, argnum += inc)
2780     {
2781       register enum machine_mode mode = argvec[argnum].mode;
2782       register rtx val = argvec[argnum].value;
2783       rtx reg = argvec[argnum].reg;
2784       int partial = argvec[argnum].partial;
2785
2786       if (! (reg != 0 && partial == 0))
2787         emit_push_insn (val, mode, NULL_TREE, NULL_RTX, 0, partial, reg, 0,
2788                         argblock, GEN_INT (argvec[count].offset.constant));
2789       NO_DEFER_POP;
2790     }
2791
2792 #ifndef PUSH_ARGS_REVERSED
2793 #ifdef STACK_BOUNDARY
2794   /* If we pushed args in forward order, perform stack alignment
2795      after pushing the last arg.  */
2796   if (argblock == 0)
2797     anti_adjust_stack (GEN_INT (args_size.constant
2798                                 - original_args_size.constant));
2799 #endif
2800 #endif
2801
2802 #ifdef PUSH_ARGS_REVERSED
2803   argnum = nargs - 1;
2804 #else
2805   argnum = 0;
2806 #endif
2807
2808   fun = prepare_call_address (fun, NULL_TREE, &call_fusage, 0);
2809
2810   /* Now load any reg parms into their regs.  */
2811
2812   for (count = 0; count < nargs; count++, argnum += inc)
2813     {
2814       register enum machine_mode mode = argvec[argnum].mode;
2815       register rtx val = argvec[argnum].value;
2816       rtx reg = argvec[argnum].reg;
2817       int partial = argvec[argnum].partial;
2818
2819       if (reg != 0 && partial == 0)
2820         emit_move_insn (reg, val);
2821       NO_DEFER_POP;
2822     }
2823
2824 #if 0
2825   /* For version 1.37, try deleting this entirely.  */
2826   if (! no_queue)
2827     emit_queue ();
2828 #endif
2829
2830   /* Any regs containing parms remain in use through the call.  */
2831   for (count = 0; count < nargs; count++)
2832     if (argvec[count].reg != 0)
2833        use_reg (&call_fusage, argvec[count].reg);
2834
2835   /* Pass the function the address in which to return a structure value.  */
2836   if (mem_value != 0 && struct_value_rtx != 0 && ! pcc_struct_value)
2837     {
2838       emit_move_insn (struct_value_rtx,
2839                       force_reg (Pmode,
2840                                  force_operand (XEXP (mem_value, 0),
2841                                                 NULL_RTX)));
2842       if (GET_CODE (struct_value_rtx) == REG)
2843           use_reg (&call_fusage, struct_value_rtx);
2844     }
2845
2846   /* Don't allow popping to be deferred, since then
2847      cse'ing of library calls could delete a call and leave the pop.  */
2848   NO_DEFER_POP;
2849
2850   /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
2851      will set inhibit_defer_pop to that value.  */
2852
2853   emit_call_1 (fun,
2854                get_identifier (XSTR (orgfun, 0)),
2855                get_identifier (XSTR (orgfun, 0)), args_size.constant,
2856                struct_value_size,
2857                FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
2858                (outmode != VOIDmode && mem_value == 0
2859                 ? hard_libcall_value (outmode) : NULL_RTX),
2860                old_inhibit_defer_pop + 1, call_fusage, is_const);
2861
2862   /* Now restore inhibit_defer_pop to its actual original value.  */
2863   OK_DEFER_POP;
2864
2865   pop_temp_slots ();
2866
2867   /* Copy the value to the right place.  */
2868   if (outmode != VOIDmode)
2869     {
2870       if (mem_value)
2871         {
2872           if (value == 0)
2873             value = mem_value;
2874           if (value != mem_value)
2875             emit_move_insn (value, mem_value);
2876         }
2877       else if (value != 0)
2878         emit_move_insn (value, hard_libcall_value (outmode));
2879       else
2880         value = hard_libcall_value (outmode);
2881     }
2882
2883   return value;
2884 }
2885 \f
2886 #if 0
2887 /* Return an rtx which represents a suitable home on the stack
2888    given TYPE, the type of the argument looking for a home.
2889    This is called only for BLKmode arguments.
2890
2891    SIZE is the size needed for this target.
2892    ARGS_ADDR is the address of the bottom of the argument block for this call.
2893    OFFSET describes this parameter's offset into ARGS_ADDR.  It is meaningless
2894    if this machine uses push insns.  */
2895
2896 static rtx
2897 target_for_arg (type, size, args_addr, offset)
2898      tree type;
2899      rtx size;
2900      rtx args_addr;
2901      struct args_size offset;
2902 {
2903   rtx target;
2904   rtx offset_rtx = ARGS_SIZE_RTX (offset);
2905
2906   /* We do not call memory_address if possible,
2907      because we want to address as close to the stack
2908      as possible.  For non-variable sized arguments,
2909      this will be stack-pointer relative addressing.  */
2910   if (GET_CODE (offset_rtx) == CONST_INT)
2911     target = plus_constant (args_addr, INTVAL (offset_rtx));
2912   else
2913     {
2914       /* I have no idea how to guarantee that this
2915          will work in the presence of register parameters.  */
2916       target = gen_rtx (PLUS, Pmode, args_addr, offset_rtx);
2917       target = memory_address (QImode, target);
2918     }
2919
2920   return gen_rtx (MEM, BLKmode, target);
2921 }
2922 #endif
2923 \f
2924 /* Store a single argument for a function call
2925    into the register or memory area where it must be passed.
2926    *ARG describes the argument value and where to pass it.
2927
2928    ARGBLOCK is the address of the stack-block for all the arguments,
2929    or 0 on a machine where arguments are pushed individually.
2930
2931    MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
2932    so must be careful about how the stack is used.
2933
2934    VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
2935    argument stack.  This is used if ACCUMULATE_OUTGOING_ARGS to indicate
2936    that we need not worry about saving and restoring the stack.
2937
2938    FNDECL is the declaration of the function we are calling.  */
2939
2940 static void
2941 store_one_arg (arg, argblock, may_be_alloca, variable_size, fndecl,
2942                reg_parm_stack_space)
2943      struct arg_data *arg;
2944      rtx argblock;
2945      int may_be_alloca;
2946      int variable_size;
2947      tree fndecl;
2948      int reg_parm_stack_space;
2949 {
2950   register tree pval = arg->tree_value;
2951   rtx reg = 0;
2952   int partial = 0;
2953   int used = 0;
2954   int i, lower_bound, upper_bound;
2955
2956   if (TREE_CODE (pval) == ERROR_MARK)
2957     return;
2958
2959   /* Push a new temporary level for any temporaries we make for
2960      this argument.  */
2961   push_temp_slots ();
2962
2963 #ifdef ACCUMULATE_OUTGOING_ARGS
2964   /* If this is being stored into a pre-allocated, fixed-size, stack area,
2965      save any previous data at that location.  */
2966   if (argblock && ! variable_size && arg->stack)
2967     {
2968 #ifdef ARGS_GROW_DOWNWARD
2969       /* stack_slot is negative, but we want to index stack_usage_map */
2970       /* with positive values. */
2971       if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
2972         upper_bound = -INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1)) + 1;
2973       else
2974         abort ();
2975
2976       lower_bound = upper_bound - arg->size.constant;
2977 #else
2978       if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
2979         lower_bound = INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1));
2980       else
2981         lower_bound = 0;
2982
2983       upper_bound = lower_bound + arg->size.constant;
2984 #endif
2985
2986       for (i = lower_bound; i < upper_bound; i++)
2987         if (stack_usage_map[i]
2988 #ifdef REG_PARM_STACK_SPACE
2989             /* Don't store things in the fixed argument area at this point;
2990                it has already been saved.  */
2991             && i > reg_parm_stack_space
2992 #endif
2993             )
2994           break;
2995
2996       if (i != upper_bound)
2997         {
2998           /* We need to make a save area.  See what mode we can make it.  */
2999           enum machine_mode save_mode
3000             = mode_for_size (arg->size.constant * BITS_PER_UNIT, MODE_INT, 1);
3001           rtx stack_area
3002             = gen_rtx (MEM, save_mode,
3003                        memory_address (save_mode, XEXP (arg->stack_slot, 0)));
3004
3005           if (save_mode == BLKmode)
3006             {
3007               arg->save_area = assign_stack_temp (BLKmode,
3008                                                   arg->size.constant, 0);
3009               MEM_IN_STRUCT_P (arg->save_area)
3010                 = AGGREGATE_TYPE_P (TREE_TYPE (arg->tree_value));
3011               preserve_temp_slots (arg->save_area);
3012               emit_block_move (validize_mem (arg->save_area), stack_area,
3013                                GEN_INT (arg->size.constant),
3014                                PARM_BOUNDARY / BITS_PER_UNIT);
3015             }
3016           else
3017             {
3018               arg->save_area = gen_reg_rtx (save_mode);
3019               emit_move_insn (arg->save_area, stack_area);
3020             }
3021         }
3022     }
3023 #endif
3024
3025   /* If this isn't going to be placed on both the stack and in registers,
3026      set up the register and number of words.  */
3027   if (! arg->pass_on_stack)
3028     reg = arg->reg, partial = arg->partial;
3029
3030   if (reg != 0 && partial == 0)
3031     /* Being passed entirely in a register.  We shouldn't be called in
3032        this case.   */
3033     abort ();
3034
3035   /* If this arg needs special alignment, don't load the registers
3036      here.  */
3037   if (arg->n_aligned_regs != 0)
3038     reg = 0;
3039
3040   /* If this is being partially passed in a register, but multiple locations
3041      are specified, we assume that the one partially used is the one that is
3042      listed first.  */
3043   if (reg && GET_CODE (reg) == EXPR_LIST)
3044     reg = XEXP (reg, 0);
3045
3046   /* If this is being passed partially in a register, we can't evaluate
3047      it directly into its stack slot.  Otherwise, we can.  */
3048   if (arg->value == 0)
3049     {
3050 #ifdef ACCUMULATE_OUTGOING_ARGS
3051       /* stack_arg_under_construction is nonzero if a function argument is
3052          being evaluated directly into the outgoing argument list and
3053          expand_call must take special action to preserve the argument list
3054          if it is called recursively.
3055
3056          For scalar function arguments stack_usage_map is sufficient to
3057          determine which stack slots must be saved and restored.  Scalar
3058          arguments in general have pass_on_stack == 0.
3059
3060          If this argument is initialized by a function which takes the
3061          address of the argument (a C++ constructor or a C function
3062          returning a BLKmode structure), then stack_usage_map is
3063          insufficient and expand_call must push the stack around the
3064          function call.  Such arguments have pass_on_stack == 1.
3065
3066          Note that it is always safe to set stack_arg_under_construction,
3067          but this generates suboptimal code if set when not needed.  */
3068
3069       if (arg->pass_on_stack)
3070         stack_arg_under_construction++;
3071 #endif
3072       arg->value = expand_expr (pval,
3073                                 (partial
3074                                  || TYPE_MODE (TREE_TYPE (pval)) != arg->mode)
3075                                 ? NULL_RTX : arg->stack,
3076                                 VOIDmode, 0);
3077
3078       /* If we are promoting object (or for any other reason) the mode
3079          doesn't agree, convert the mode.  */
3080
3081       if (arg->mode != TYPE_MODE (TREE_TYPE (pval)))
3082         arg->value = convert_modes (arg->mode, TYPE_MODE (TREE_TYPE (pval)),
3083                                     arg->value, arg->unsignedp);
3084
3085 #ifdef ACCUMULATE_OUTGOING_ARGS
3086       if (arg->pass_on_stack)
3087         stack_arg_under_construction--;
3088 #endif
3089     }
3090
3091   /* Don't allow anything left on stack from computation
3092      of argument to alloca.  */
3093   if (may_be_alloca)
3094     do_pending_stack_adjust ();
3095
3096   if (arg->value == arg->stack)
3097     /* If the value is already in the stack slot, we are done.  */
3098     ;
3099   else if (arg->mode != BLKmode)
3100     {
3101       register int size;
3102
3103       /* Argument is a scalar, not entirely passed in registers.
3104          (If part is passed in registers, arg->partial says how much
3105          and emit_push_insn will take care of putting it there.)
3106
3107          Push it, and if its size is less than the
3108          amount of space allocated to it,
3109          also bump stack pointer by the additional space.
3110          Note that in C the default argument promotions
3111          will prevent such mismatches.  */
3112
3113       size = GET_MODE_SIZE (arg->mode);
3114       /* Compute how much space the push instruction will push.
3115          On many machines, pushing a byte will advance the stack
3116          pointer by a halfword.  */
3117 #ifdef PUSH_ROUNDING
3118       size = PUSH_ROUNDING (size);
3119 #endif
3120       used = size;
3121
3122       /* Compute how much space the argument should get:
3123          round up to a multiple of the alignment for arguments.  */
3124       if (none != FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)))
3125         used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1)
3126                  / (PARM_BOUNDARY / BITS_PER_UNIT))
3127                 * (PARM_BOUNDARY / BITS_PER_UNIT));
3128
3129       /* This isn't already where we want it on the stack, so put it there.
3130          This can either be done with push or copy insns.  */
3131       emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX,
3132                       0, partial, reg, used - size,
3133                       argblock, ARGS_SIZE_RTX (arg->offset));
3134     }
3135   else
3136     {
3137       /* BLKmode, at least partly to be pushed.  */
3138
3139       register int excess;
3140       rtx size_rtx;
3141
3142       /* Pushing a nonscalar.
3143          If part is passed in registers, PARTIAL says how much
3144          and emit_push_insn will take care of putting it there.  */
3145
3146       /* Round its size up to a multiple
3147          of the allocation unit for arguments.  */
3148
3149       if (arg->size.var != 0)
3150         {
3151           excess = 0;
3152           size_rtx = ARGS_SIZE_RTX (arg->size);
3153         }
3154       else
3155         {
3156           /* PUSH_ROUNDING has no effect on us, because
3157              emit_push_insn for BLKmode is careful to avoid it.  */
3158           excess = (arg->size.constant - int_size_in_bytes (TREE_TYPE (pval))
3159                     + partial * UNITS_PER_WORD);
3160           size_rtx = expr_size (pval);
3161         }
3162
3163       emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
3164                       TYPE_ALIGN (TREE_TYPE (pval)) / BITS_PER_UNIT, partial,
3165                       reg, excess, argblock, ARGS_SIZE_RTX (arg->offset));
3166     }
3167
3168
3169   /* Unless this is a partially-in-register argument, the argument is now
3170      in the stack.
3171
3172      ??? Note that this can change arg->value from arg->stack to
3173      arg->stack_slot and it matters when they are not the same.
3174      It isn't totally clear that this is correct in all cases.  */
3175   if (partial == 0)
3176     arg->value = arg->stack_slot;
3177
3178   /* Once we have pushed something, pops can't safely
3179      be deferred during the rest of the arguments.  */
3180   NO_DEFER_POP;
3181
3182   /* ANSI doesn't require a sequence point here,
3183      but PCC has one, so this will avoid some problems.  */
3184   emit_queue ();
3185
3186   /* Free any temporary slots made in processing this argument.  Show
3187      that we might have taken the address of something and pushed that
3188      as an operand.  */
3189   preserve_temp_slots (NULL_RTX);
3190   free_temp_slots ();
3191   pop_temp_slots ();
3192
3193 #ifdef ACCUMULATE_OUTGOING_ARGS
3194   /* Now mark the segment we just used.  */
3195   if (argblock && ! variable_size && arg->stack)
3196     for (i = lower_bound; i < upper_bound; i++)
3197       stack_usage_map[i] = 1;
3198 #endif
3199 }