gcc/calls.c

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