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