gcc/calls.c

   1 /* Convert function calls to rtl insns, for GNU C compiler.
   2    Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998
   3    1999, 2000 Free Software Foundation, Inc.
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "rtl.h"
  25 #include "tree.h"
  26 #include "flags.h"
  27 #include "expr.h"
  28 #include "function.h"
  29 #include "regs.h"
  30 #include "insn-flags.h"
  31 #include "toplev.h"
  32 #include "output.h"
  33 #include "tm_p.h"
  34
  35 #ifndef ACCUMULATE_OUTGOING_ARGS
  36 #define ACCUMULATE_OUTGOING_ARGS 0
  37 #endif
  38
  39 /* Supply a default definition for PUSH_ARGS.  */
  40 #ifndef PUSH_ARGS
  41 #ifdef PUSH_ROUNDING
  42 #define PUSH_ARGS       !ACCUMULATE_OUTGOING_ARGS
  43 #else
  44 #define PUSH_ARGS       0
  45 #endif
  46 #endif
  47
  48 #if !defined FUNCTION_OK_FOR_SIBCALL
  49 #define FUNCTION_OK_FOR_SIBCALL(DECL) 1
  50 #endif
  51
  52 #if !defined PREFERRED_STACK_BOUNDARY && defined STACK_BOUNDARY
  53 #define PREFERRED_STACK_BOUNDARY STACK_BOUNDARY
  54 #endif
  55
  56 /* Decide whether a function's arguments should be processed
  57    from first to last or from last to first.
  58
  59    They should if the stack and args grow in opposite directions, but
  60    only if we have push insns.  */
  61
  62 #ifdef PUSH_ROUNDING
  63
  64 #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD)
  65 #define PUSH_ARGS_REVERSED  PUSH_ARGS
  66 #endif
  67
  68 #endif
  69
  70 #ifndef PUSH_ARGS_REVERSED
  71 #define PUSH_ARGS_REVERSED 0
  72 #endif
  73
  74 /* Like PREFERRED_STACK_BOUNDARY but in units of bytes, not bits.  */
  75 #define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)
  76
  77 /* Data structure and subroutines used within expand_call.  */
  78
  79 struct arg_data
  80 {
  81   /* Tree node for this argument.  */
  82   tree tree_value;
  83   /* Mode for value; TYPE_MODE unless promoted.  */
  84   enum machine_mode mode;
  85   /* Current RTL value for argument, or 0 if it isn't precomputed.  */
  86   rtx value;
  87   /* Initially-compute RTL value for argument; only for const functions.  */
  88   rtx initial_value;
  89   /* Register to pass this argument in, 0 if passed on stack, or an
  90      PARALLEL if the arg is to be copied into multiple non-contiguous
  91      registers.  */
  92   rtx reg;
  93   /* Register to pass this argument in when generating tail call sequence.
  94      This is not the same register as for normal calls on machines with
  95      register windows.  */
  96   rtx tail_call_reg;
  97   /* If REG was promoted from the actual mode of the argument expression,
  98      indicates whether the promotion is sign- or zero-extended.  */
  99   int unsignedp;
 100   /* Number of registers to use.  0 means put the whole arg in registers.
 101      Also 0 if not passed in registers.  */
 102   int partial;
 103   /* Non-zero if argument must be passed on stack.
 104      Note that some arguments may be passed on the stack
 105      even though pass_on_stack is zero, just because FUNCTION_ARG says so.
 106      pass_on_stack identifies arguments that *cannot* go in registers.  */
 107   int pass_on_stack;
 108   /* Offset of this argument from beginning of stack-args.  */
 109   struct args_size offset;
 110   /* Similar, but offset to the start of the stack slot.  Different from
 111      OFFSET if this arg pads downward.  */
 112   struct args_size slot_offset;
 113   /* Size of this argument on the stack, rounded up for any padding it gets,
 114      parts of the argument passed in registers do not count.
 115      If REG_PARM_STACK_SPACE is defined, then register parms
 116      are counted here as well.  */
 117   struct args_size size;
 118   /* Location on the stack at which parameter should be stored.  The store
 119      has already been done if STACK == VALUE.  */
 120   rtx stack;
 121   /* Location on the stack of the start of this argument slot.  This can
 122      differ from STACK if this arg pads downward.  This location is known
 123      to be aligned to FUNCTION_ARG_BOUNDARY.  */
 124   rtx stack_slot;
 125   /* Place that this stack area has been saved, if needed.  */
 126   rtx save_area;
 127   /* If an argument's alignment does not permit direct copying into registers,
 128      copy in smaller-sized pieces into pseudos.  These are stored in a
 129      block pointed to by this field.  The next field says how many
 130      word-sized pseudos we made.  */
 131   rtx *aligned_regs;
 132   int n_aligned_regs;
 133   /* The amount that the stack pointer needs to be adjusted to
 134      force alignment for the next argument.  */
 135   struct args_size alignment_pad;
 136 };
 137
 138 /* A vector of one char per byte of stack space.  A byte if non-zero if
 139    the corresponding stack location has been used.
 140    This vector is used to prevent a function call within an argument from
 141    clobbering any stack already set up.  */
 142 static char *stack_usage_map;
 143
 144 /* Size of STACK_USAGE_MAP.  */
 145 static int highest_outgoing_arg_in_use;
 146
 147 /* stack_arg_under_construction is nonzero when an argument may be
 148    initialized with a constructor call (including a C function that
 149    returns a BLKmode struct) and expand_call must take special action
 150    to make sure the object being constructed does not overlap the
 151    argument list for the constructor call.  */
 152 int stack_arg_under_construction;
 153
 154 static int calls_function       PARAMS ((tree, int));
 155 static int calls_function_1     PARAMS ((tree, int));
 156
 157 /* Nonzero if this is a call to a `const' function. */
 158 #define ECF_CONST               1
 159 /* Nonzero if this is a call to a `volatile' function.  */
 160 #define ECF_NORETURN            2
 161 /* Nonzero if this is a call to malloc or a related function. */
 162 #define ECF_MALLOC              4
 163 /* Nonzero if it is plausible that this is a call to alloca.  */
 164 #define ECF_MAY_BE_ALLOCA       8
 165 /* Nonzero if this is a call to a function that won't throw an exception.  */
 166 #define ECF_NOTHROW             16
 167 /* Nonzero if this is a call to setjmp or a related function.  */
 168 #define ECF_RETURNS_TWICE       32
 169 /* Nonzero if this is a call to `longjmp'.  */
 170 #define ECF_LONGJMP             64
 171 /* Nonzero if this is a syscall that makes a new process in the image of
 172    the current one.  */
 173 #define ECF_FORK_OR_EXEC        128
 174 #define ECF_SIBCALL             256
 175 /* Nonzero if this is a call to "pure" function (like const function,
 176    but may read memory.  */
 177 #define ECF_PURE                512
 178
 179 static void emit_call_1         PARAMS ((rtx, tree, tree, HOST_WIDE_INT,
 180                                          HOST_WIDE_INT, HOST_WIDE_INT, rtx,
 181                                          rtx, int, rtx, int));
 182 static void precompute_register_parameters      PARAMS ((int,
 183                                                          struct arg_data *,
 184                                                          int *));
 185 static void store_one_arg       PARAMS ((struct arg_data *, rtx, int, int,
 186                                          int));
 187 static void store_unaligned_arguments_into_pseudos PARAMS ((struct arg_data *,
 188                                                             int));
 189 static int finalize_must_preallocate            PARAMS ((int, int,
 190                                                          struct arg_data *,
 191                                                          struct args_size *));
 192 static void precompute_arguments                PARAMS ((int, int,
 193                                                          struct arg_data *));
 194 static int compute_argument_block_size          PARAMS ((int,
 195                                                          struct args_size *,
 196                                                          int));
 197 static void initialize_argument_information     PARAMS ((int,
 198                                                          struct arg_data *,
 199                                                          struct args_size *,
 200                                                          int, tree, tree,
 201                                                          CUMULATIVE_ARGS *,
 202                                                          int, rtx *, int *,
 203                                                          int *, int *));
 204 static void compute_argument_addresses          PARAMS ((struct arg_data *,
 205                                                          rtx, int));
 206 static rtx rtx_for_function_call                PARAMS ((tree, tree));
 207 static void load_register_parameters            PARAMS ((struct arg_data *,
 208                                                          int, rtx *, int));
 209 static int libfunc_nothrow                      PARAMS ((rtx));
 210 static rtx emit_library_call_value_1            PARAMS ((int, rtx, rtx, int,
 211                                                          enum machine_mode,
 212                                                          int, va_list));
 213 static int special_function_p                   PARAMS ((tree, int));
 214 static int flags_from_decl_or_type              PARAMS ((tree));
 215 static rtx try_to_integrate                     PARAMS ((tree, tree, rtx,
 216                                                          int, tree, rtx));
 217 static int combine_pending_stack_adjustment_and_call
 218                                                 PARAMS ((int, struct args_size *, int));
 219
 220 #ifdef REG_PARM_STACK_SPACE
 221 static rtx save_fixed_argument_area     PARAMS ((int, rtx, int *, int *));
 222 static void restore_fixed_argument_area PARAMS ((rtx, rtx, int, int));
 223 #endif
 224 \f
 225 /* If WHICH is 1, return 1 if EXP contains a call to the built-in function
 226    `alloca'.
 227
 228    If WHICH is 0, return 1 if EXP contains a call to any function.
 229    Actually, we only need return 1 if evaluating EXP would require pushing
 230    arguments on the stack, but that is too difficult to compute, so we just
 231    assume any function call might require the stack.  */
 232
 233 static tree calls_function_save_exprs;
 234
 235 static int
 236 calls_function (exp, which)
 237      tree exp;
 238      int which;
 239 {
 240   int val;
 241
 242   calls_function_save_exprs = 0;
 243   val = calls_function_1 (exp, which);
 244   calls_function_save_exprs = 0;
 245   return val;
 246 }
 247
 248 /* Recursive function to do the work of above function.  */
 249
 250 static int
 251 calls_function_1 (exp, which)
 252      tree exp;
 253      int which;
 254 {
 255   register int i;
 256   enum tree_code code = TREE_CODE (exp);
 257   int class = TREE_CODE_CLASS (code);
 258   int length = first_rtl_op (code);
 259
 260   /* If this code is language-specific, we don't know what it will do.  */
 261   if ((int) code >= NUM_TREE_CODES)
 262     return 1;
 263
 264   switch (code)
 265     {
 266     case CALL_EXPR:
 267       if (which == 0)
 268         return 1;
 269       else if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
 270                && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
 271                    == FUNCTION_DECL)
 272                && (special_function_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
 273                                        0)
 274                    & ECF_MAY_BE_ALLOCA))
 275         return 1;
 276
 277       break;
 278
 279     case SAVE_EXPR:
 280       if (SAVE_EXPR_RTL (exp) != 0)
 281         return 0;
 282       if (value_member (exp, calls_function_save_exprs))
 283         return 0;
 284       calls_function_save_exprs = tree_cons (NULL_TREE, exp,
 285                                              calls_function_save_exprs);
 286       return (TREE_OPERAND (exp, 0) != 0
 287               && calls_function_1 (TREE_OPERAND (exp, 0), which));
 288
 289     case BLOCK:
 290       {
 291         register tree local;
 292         register tree subblock;
 293
 294         for (local = BLOCK_VARS (exp); local; local = TREE_CHAIN (local))
 295           if (DECL_INITIAL (local) != 0
 296               && calls_function_1 (DECL_INITIAL (local), which))
 297             return 1;
 298
 299         for (subblock = BLOCK_SUBBLOCKS (exp);
 300              subblock;
 301              subblock = TREE_CHAIN (subblock))
 302           if (calls_function_1 (subblock, which))
 303             return 1;
 304       }
 305       return 0;
 306
 307     case TREE_LIST:
 308       for (; exp != 0; exp = TREE_CHAIN (exp))
 309         if (calls_function_1 (TREE_VALUE (exp), which))
 310           return 1;
 311       return 0;
 312
 313     default:
 314       break;
 315     }
 316
 317   /* Only expressions, references, and blocks can contain calls.  */
 318   if (! IS_EXPR_CODE_CLASS (class) && class != 'r' && class != 'b')
 319     return 0;
 320
 321   for (i = 0; i < length; i++)
 322     if (TREE_OPERAND (exp, i) != 0
 323         && calls_function_1 (TREE_OPERAND (exp, i), which))
 324       return 1;
 325
 326   return 0;
 327 }
 328 \f
 329 /* Force FUNEXP into a form suitable for the address of a CALL,
 330    and return that as an rtx.  Also load the static chain register
 331    if FNDECL is a nested function.
 332
 333    CALL_FUSAGE points to a variable holding the prospective
 334    CALL_INSN_FUNCTION_USAGE information.  */
 335
 336 rtx
 337 prepare_call_address (funexp, fndecl, call_fusage, reg_parm_seen)
 338      rtx funexp;
 339      tree fndecl;
 340      rtx *call_fusage;
 341      int reg_parm_seen;
 342 {
 343   rtx static_chain_value = 0;
 344
 345   funexp = protect_from_queue (funexp, 0);
 346
 347   if (fndecl != 0)
 348     /* Get possible static chain value for nested function in C.  */
 349     static_chain_value = lookup_static_chain (fndecl);
 350
 351   /* Make a valid memory address and copy constants thru pseudo-regs,
 352      but not for a constant address if -fno-function-cse.  */
 353   if (GET_CODE (funexp) != SYMBOL_REF)
 354     /* If we are using registers for parameters, force the
 355        function address into a register now.  */
 356     funexp = ((SMALL_REGISTER_CLASSES && reg_parm_seen)
 357               ? force_not_mem (memory_address (FUNCTION_MODE, funexp))
 358               : memory_address (FUNCTION_MODE, funexp));
 359   else
 360     {
 361 #ifndef NO_FUNCTION_CSE
 362       if (optimize && ! flag_no_function_cse)
 363 #ifdef NO_RECURSIVE_FUNCTION_CSE
 364         if (fndecl != current_function_decl)
 365 #endif
 366           funexp = force_reg (Pmode, funexp);
 367 #endif
 368     }
 369
 370   if (static_chain_value != 0)
 371     {
 372       emit_move_insn (static_chain_rtx, static_chain_value);
 373
 374       if (GET_CODE (static_chain_rtx) == REG)
 375         use_reg (call_fusage, static_chain_rtx);
 376     }
 377
 378   return funexp;
 379 }
 380
 381 /* Generate instructions to call function FUNEXP,
 382    and optionally pop the results.
 383    The CALL_INSN is the first insn generated.
 384
 385    FNDECL is the declaration node of the function.  This is given to the
 386    macro RETURN_POPS_ARGS to determine whether this function pops its own args.
 387
 388    FUNTYPE is the data type of the function.  This is given to the macro
 389    RETURN_POPS_ARGS to determine whether this function pops its own args.
 390    We used to allow an identifier for library functions, but that doesn't
 391    work when the return type is an aggregate type and the calling convention
 392    says that the pointer to this aggregate is to be popped by the callee.
 393
 394    STACK_SIZE is the number of bytes of arguments on the stack,
 395    ROUNDED_STACK_SIZE is that number rounded up to
 396    PREFERRED_STACK_BOUNDARY; zero if the size is variable.  This is
 397    both to put into the call insn and to generate explicit popping
 398    code if necessary.
 399
 400    STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
 401    It is zero if this call doesn't want a structure value.
 402
 403    NEXT_ARG_REG is the rtx that results from executing
 404      FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1)
 405    just after all the args have had their registers assigned.
 406    This could be whatever you like, but normally it is the first
 407    arg-register beyond those used for args in this call,
 408    or 0 if all the arg-registers are used in this call.
 409    It is passed on to `gen_call' so you can put this info in the call insn.
 410
 411    VALREG is a hard register in which a value is returned,
 412    or 0 if the call does not return a value.
 413
 414    OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before
 415    the args to this call were processed.
 416    We restore `inhibit_defer_pop' to that value.
 417
 418    CALL_FUSAGE is either empty or an EXPR_LIST of USE expressions that
 419    denote registers used by the called function.  */
 420
 421 static void
 422 emit_call_1 (funexp, fndecl, funtype, stack_size, rounded_stack_size,
 423              struct_value_size, next_arg_reg, valreg, old_inhibit_defer_pop,
 424              call_fusage, ecf_flags)
 425      rtx funexp;
 426      tree fndecl ATTRIBUTE_UNUSED;
 427      tree funtype ATTRIBUTE_UNUSED;
 428      HOST_WIDE_INT stack_size ATTRIBUTE_UNUSED;
 429      HOST_WIDE_INT rounded_stack_size;
 430      HOST_WIDE_INT struct_value_size ATTRIBUTE_UNUSED;
 431      rtx next_arg_reg;
 432      rtx valreg;
 433      int old_inhibit_defer_pop;
 434      rtx call_fusage;
 435      int ecf_flags;
 436 {
 437   rtx rounded_stack_size_rtx = GEN_INT (rounded_stack_size);
 438   rtx call_insn;
 439   int already_popped = 0;
 440   HOST_WIDE_INT n_popped = RETURN_POPS_ARGS (fndecl, funtype, stack_size);
 441 #if defined (HAVE_call) && defined (HAVE_call_value)
 442   rtx struct_value_size_rtx;
 443   struct_value_size_rtx = GEN_INT (struct_value_size);
 444 #endif
 445
 446   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
 447      and we don't want to load it into a register as an optimization,
 448      because prepare_call_address already did it if it should be done.  */
 449   if (GET_CODE (funexp) != SYMBOL_REF)
 450     funexp = memory_address (FUNCTION_MODE, funexp);
 451
 452 #if defined (HAVE_sibcall_pop) && defined (HAVE_sibcall_value_pop)
 453   if ((ecf_flags & ECF_SIBCALL)
 454       && HAVE_sibcall_pop && HAVE_sibcall_value_pop
 455       && (RETURN_POPS_ARGS (fndecl, funtype, stack_size) > 0
 456           || stack_size == 0))
 457     {
 458       rtx n_pop = GEN_INT (RETURN_POPS_ARGS (fndecl, funtype, stack_size));
 459       rtx pat;
 460
 461       /* If this subroutine pops its own args, record that in the call insn
 462          if possible, for the sake of frame pointer elimination.  */
 463
 464       if (valreg)
 465         pat = GEN_SIBCALL_VALUE_POP (valreg,
 466                                      gen_rtx_MEM (FUNCTION_MODE, funexp),
 467                                      rounded_stack_size_rtx, next_arg_reg,
 468                                      n_pop);
 469       else
 470         pat = GEN_SIBCALL_POP (gen_rtx_MEM (FUNCTION_MODE, funexp),
 471                                rounded_stack_size_rtx, next_arg_reg, n_pop);
 472
 473       emit_call_insn (pat);
 474       already_popped = 1;
 475     }
 476   else
 477 #endif
 478
 479 #if defined (HAVE_call_pop) && defined (HAVE_call_value_pop)
 480 /* If the target has "call" or "call_value" insns, then prefer them
 481    if no arguments are actually popped.  If the target does not have
 482    "call" or "call_value" insns, then we must use the popping versions
 483    even if the call has no arguments to pop.  */
 484 #if defined (HAVE_call) && defined (HAVE_call_value)
 485   if (HAVE_call && HAVE_call_value && HAVE_call_pop && HAVE_call_value_pop
 486       && n_popped > 0)
 487 #else
 488   if (HAVE_call_pop && HAVE_call_value_pop)
 489 #endif
 490     {
 491       rtx n_pop = GEN_INT (n_popped);
 492       rtx pat;
 493
 494       /* If this subroutine pops its own args, record that in the call insn
 495          if possible, for the sake of frame pointer elimination.  */
 496
 497       if (valreg)
 498         pat = GEN_CALL_VALUE_POP (valreg,
 499                                   gen_rtx_MEM (FUNCTION_MODE, funexp),
 500                                   rounded_stack_size_rtx, next_arg_reg, n_pop);
 501       else
 502         pat = GEN_CALL_POP (gen_rtx_MEM (FUNCTION_MODE, funexp),
 503                             rounded_stack_size_rtx, next_arg_reg, n_pop);
 504
 505       emit_call_insn (pat);
 506       already_popped = 1;
 507     }
 508   else
 509 #endif
 510
 511 #if defined (HAVE_sibcall) && defined (HAVE_sibcall_value)
 512   if ((ecf_flags & ECF_SIBCALL)
 513       && HAVE_sibcall && HAVE_sibcall_value)
 514     {
 515       if (valreg)
 516         emit_call_insn (GEN_SIBCALL_VALUE (valreg,
 517                                            gen_rtx_MEM (FUNCTION_MODE, funexp),
 518                                            rounded_stack_size_rtx,
 519                                            next_arg_reg, NULL_RTX));
 520       else
 521         emit_call_insn (GEN_SIBCALL (gen_rtx_MEM (FUNCTION_MODE, funexp),
 522                                      rounded_stack_size_rtx, next_arg_reg,
 523                                      struct_value_size_rtx));
 524     }
 525   else
 526 #endif
 527
 528 #if defined (HAVE_call) && defined (HAVE_call_value)
 529   if (HAVE_call && HAVE_call_value)
 530     {
 531       if (valreg)
 532         emit_call_insn (GEN_CALL_VALUE (valreg,
 533                                         gen_rtx_MEM (FUNCTION_MODE, funexp),
 534                                         rounded_stack_size_rtx, next_arg_reg,
 535                                         NULL_RTX));
 536       else
 537         emit_call_insn (GEN_CALL (gen_rtx_MEM (FUNCTION_MODE, funexp),
 538                                   rounded_stack_size_rtx, next_arg_reg,
 539                                   struct_value_size_rtx));
 540     }
 541   else
 542 #endif
 543     abort ();
 544
 545   /* Find the CALL insn we just emitted.  */
 546   for (call_insn = get_last_insn ();
 547        call_insn && GET_CODE (call_insn) != CALL_INSN;
 548        call_insn = PREV_INSN (call_insn))
 549     ;
 550
 551   if (! call_insn)
 552     abort ();
 553
 554   /* Mark memory as used for "pure" function call.  */
 555   if (ecf_flags & ECF_PURE)
 556     {
 557       call_fusage =  gen_rtx_EXPR_LIST (VOIDmode,
 558         gen_rtx_USE (VOIDmode,
 559                      gen_rtx_MEM (BLKmode,
 560                                   gen_rtx_SCRATCH (VOIDmode))), call_fusage);
 561     }
 562
 563   /* Put the register usage information on the CALL.  If there is already
 564      some usage information, put ours at the end.  */
 565   if (CALL_INSN_FUNCTION_USAGE (call_insn))
 566     {
 567       rtx link;
 568
 569       for (link = CALL_INSN_FUNCTION_USAGE (call_insn); XEXP (link, 1) != 0;
 570            link = XEXP (link, 1))
 571         ;
 572
 573       XEXP (link, 1) = call_fusage;
 574     }
 575   else
 576     CALL_INSN_FUNCTION_USAGE (call_insn) = call_fusage;
 577
 578   /* If this is a const call, then set the insn's unchanging bit.  */
 579   if (ecf_flags & (ECF_CONST | ECF_PURE))
 580     CONST_CALL_P (call_insn) = 1;
 581
 582   /* If this call can't throw, attach a REG_EH_REGION reg note to that
 583      effect.  */
 584   if (ecf_flags & ECF_NOTHROW)
 585     REG_NOTES (call_insn) = gen_rtx_EXPR_LIST (REG_EH_REGION, const0_rtx,
 586                                                REG_NOTES (call_insn));
 587
 588   SIBLING_CALL_P (call_insn) = ((ecf_flags & ECF_SIBCALL) != 0);
 589
 590   /* Restore this now, so that we do defer pops for this call's args
 591      if the context of the call as a whole permits.  */
 592   inhibit_defer_pop = old_inhibit_defer_pop;
 593
 594   if (n_popped > 0)
 595     {
 596       if (!already_popped)
 597         CALL_INSN_FUNCTION_USAGE (call_insn)
 598           = gen_rtx_EXPR_LIST (VOIDmode,
 599                                gen_rtx_CLOBBER (VOIDmode, stack_pointer_rtx),
 600                                CALL_INSN_FUNCTION_USAGE (call_insn));
 601       rounded_stack_size -= n_popped;
 602       rounded_stack_size_rtx = GEN_INT (rounded_stack_size);
 603       stack_pointer_delta -= n_popped;
 604     }
 605
 606   if (!ACCUMULATE_OUTGOING_ARGS)
 607     {
 608       /* If returning from the subroutine does not automatically pop the args,
 609          we need an instruction to pop them sooner or later.
 610          Perhaps do it now; perhaps just record how much space to pop later.
 611
 612          If returning from the subroutine does pop the args, indicate that the
 613          stack pointer will be changed.  */
 614
 615       if (rounded_stack_size != 0)
 616         {
 617           if (flag_defer_pop && inhibit_defer_pop == 0
 618               && !(ecf_flags & (ECF_CONST | ECF_PURE)))
 619             pending_stack_adjust += rounded_stack_size;
 620           else
 621             adjust_stack (rounded_stack_size_rtx);
 622         }
 623     }
 624   /* When we accumulate outgoing args, we must avoid any stack manipulations.
 625      Restore the stack pointer to its original value now.  Usually
 626      ACCUMULATE_OUTGOING_ARGS targets don't get here, but there are exceptions.
 627      On  i386 ACCUMULATE_OUTGOING_ARGS can be enabled on demand, and
 628      popping variants of functions exist as well.
 629
 630      ??? We may optimize similar to defer_pop above, but it is
 631      probably not worthwhile.
 632
 633      ??? It will be worthwhile to enable combine_stack_adjustments even for
 634      such machines.  */
 635   else if (n_popped)
 636     anti_adjust_stack (GEN_INT (n_popped));
 637 }
 638
 639 /* Determine if the function identified by NAME and FNDECL is one with
 640    special properties we wish to know about.
 641
 642    For example, if the function might return more than one time (setjmp), then
 643    set RETURNS_TWICE to a nonzero value.
 644
 645    Similarly set LONGJMP for if the function is in the longjmp family.
 646
 647    Set MALLOC for any of the standard memory allocation functions which
 648    allocate from the heap.
 649
 650    Set MAY_BE_ALLOCA for any memory allocation function that might allocate
 651    space from the stack such as alloca.  */
 652
 653 static int
 654 special_function_p (fndecl, flags)
 655      tree fndecl;
 656      int flags;
 657 {
 658   if (! (flags & ECF_MALLOC)
 659       && fndecl && DECL_NAME (fndecl)
 660       && IDENTIFIER_LENGTH (DECL_NAME (fndecl)) <= 17
 661       /* Exclude functions not at the file scope, or not `extern',
 662          since they are not the magic functions we would otherwise
 663          think they are.  */
 664       && DECL_CONTEXT (fndecl) == NULL_TREE && TREE_PUBLIC (fndecl))
 665     {
 666       char *name = IDENTIFIER_POINTER (DECL_NAME (fndecl));
 667       char *tname = name;
 668
 669       /* We assume that alloca will always be called by name.  It
 670          makes no sense to pass it as a pointer-to-function to
 671          anything that does not understand its behavior.  */
 672       if (((IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 6
 673             && name[0] == 'a'
 674             && ! strcmp (name, "alloca"))
 675            || (IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 16
 676                && name[0] == '_'
 677                && ! strcmp (name, "__builtin_alloca"))))
 678         flags |= ECF_MAY_BE_ALLOCA;
 679
 680       /* Disregard prefix _, __ or __x.  */
 681       if (name[0] == '_')
 682         {
 683           if (name[1] == '_' && name[2] == 'x')
 684             tname += 3;
 685           else if (name[1] == '_')
 686             tname += 2;
 687           else
 688             tname += 1;
 689         }
 690
 691       if (tname[0] == 's')
 692         {
 693           if ((tname[1] == 'e'
 694                && (! strcmp (tname, "setjmp")
 695                    || ! strcmp (tname, "setjmp_syscall")))
 696               || (tname[1] == 'i'
 697                   && ! strcmp (tname, "sigsetjmp"))
 698               || (tname[1] == 'a'
 699                   && ! strcmp (tname, "savectx")))
 700             flags |= ECF_RETURNS_TWICE;
 701
 702           if (tname[1] == 'i'
 703               && ! strcmp (tname, "siglongjmp"))
 704             flags |= ECF_LONGJMP;
 705         }
 706       else if ((tname[0] == 'q' && tname[1] == 's'
 707                 && ! strcmp (tname, "qsetjmp"))
 708                || (tname[0] == 'v' && tname[1] == 'f'
 709                    && ! strcmp (tname, "vfork")))
 710         flags |= ECF_RETURNS_TWICE;
 711
 712       else if (tname[0] == 'l' && tname[1] == 'o'
 713                && ! strcmp (tname, "longjmp"))
 714         flags |= ECF_LONGJMP;
 715
 716       else if ((tname[0] == 'f' && tname[1] == 'o'
 717                 && ! strcmp (tname, "fork"))
 718                /* Linux specific: __clone.  check NAME to insist on the
 719                   leading underscores, to avoid polluting the ISO / POSIX
 720                   namespace.  */
 721                || (name[0] == '_' && name[1] == '_'
 722                    && ! strcmp (tname, "clone"))
 723                || (tname[0] == 'e' && tname[1] == 'x' && tname[2] == 'e'
 724                    && tname[3] == 'c' && (tname[4] == 'l' || tname[4] == 'v')
 725                    && (tname[5] == '\0'
 726                        || ((tname[5] == 'p' || tname[5] == 'e')
 727                            && tname[6] == '\0'))))
 728         flags |= ECF_FORK_OR_EXEC;
 729
 730       /* Do not add any more malloc-like functions to this list,
 731          instead mark them as malloc functions using the malloc attribute.
 732          Note, realloc is not suitable for attribute malloc since
 733          it may return the same address across multiple calls.
 734          C++ operator new is not suitable because it is not required
 735          to return a unique pointer; indeed, the standard placement new
 736          just returns its argument. */
 737       else if (TYPE_MODE (TREE_TYPE (TREE_TYPE (fndecl))) == Pmode
 738                && (! strcmp (tname, "malloc")
 739                    || ! strcmp (tname, "calloc")
 740                    || ! strcmp (tname, "strdup")))
 741         flags |= ECF_MALLOC;
 742     }
 743   return flags;
 744 }
 745
 746 /* Return nonzero when tree represent call to longjmp.  */
 747 int
 748 setjmp_call_p (fndecl)
 749      tree fndecl;
 750 {
 751   return special_function_p (fndecl, 0) & ECF_RETURNS_TWICE;
 752 }
 753
 754 /* Detect flags (function attributes) from the function type node.  */
 755 static int
 756 flags_from_decl_or_type (exp)
 757      tree exp;
 758 {
 759   int flags = 0;
 760   /* ??? We can't set IS_MALLOC for function types?  */
 761   if (DECL_P (exp))
 762     {
 763       /* The function exp may have the `malloc' attribute.  */
 764       if (DECL_P (exp) && DECL_IS_MALLOC (exp))
 765         flags |= ECF_MALLOC;
 766
 767       /* The function exp may have the `pure' attribute.  */
 768       if (DECL_P (exp) && DECL_IS_PURE (exp))
 769         flags |= ECF_PURE;
 770
 771       if (TREE_NOTHROW (exp))
 772         flags |= ECF_NOTHROW;
 773     }
 774
 775   if (TREE_READONLY (exp) && !TREE_THIS_VOLATILE (exp))
 776     flags |= ECF_CONST;
 777
 778   if (TREE_THIS_VOLATILE (exp))
 779     flags |= ECF_NORETURN;
 780
 781   return flags;
 782 }
 783
 784
 785 /* Precompute all register parameters as described by ARGS, storing values
 786    into fields within the ARGS array.
 787
 788    NUM_ACTUALS indicates the total number elements in the ARGS array.
 789
 790    Set REG_PARM_SEEN if we encounter a register parameter.  */
 791
 792 static void
 793 precompute_register_parameters (num_actuals, args, reg_parm_seen)
 794      int num_actuals;
 795      struct arg_data *args;
 796      int *reg_parm_seen;
 797 {
 798   int i;
 799
 800   *reg_parm_seen = 0;
 801
 802   for (i = 0; i < num_actuals; i++)
 803     if (args[i].reg != 0 && ! args[i].pass_on_stack)
 804       {
 805         *reg_parm_seen = 1;
 806
 807         if (args[i].value == 0)
 808           {
 809             push_temp_slots ();
 810             args[i].value = expand_expr (args[i].tree_value, NULL_RTX,
 811                                          VOIDmode, 0);
 812             preserve_temp_slots (args[i].value);
 813             pop_temp_slots ();
 814
 815             /* ANSI doesn't require a sequence point here,
 816                but PCC has one, so this will avoid some problems.  */
 817             emit_queue ();
 818           }
 819
 820         /* If we are to promote the function arg to a wider mode,
 821            do it now.  */
 822
 823         if (args[i].mode != TYPE_MODE (TREE_TYPE (args[i].tree_value)))
 824           args[i].value
 825             = convert_modes (args[i].mode,
 826                              TYPE_MODE (TREE_TYPE (args[i].tree_value)),
 827                              args[i].value, args[i].unsignedp);
 828
 829         /* If the value is expensive, and we are inside an appropriately
 830            short loop, put the value into a pseudo and then put the pseudo
 831            into the hard reg.
 832
 833            For small register classes, also do this if this call uses
 834            register parameters.  This is to avoid reload conflicts while
 835            loading the parameters registers.  */
 836
 837         if ((! (GET_CODE (args[i].value) == REG
 838                 || (GET_CODE (args[i].value) == SUBREG
 839                     && GET_CODE (SUBREG_REG (args[i].value)) == REG)))
 840             && args[i].mode != BLKmode
 841             && rtx_cost (args[i].value, SET) > 2
 842             && ((SMALL_REGISTER_CLASSES && *reg_parm_seen)
 843                 || preserve_subexpressions_p ()))
 844           args[i].value = copy_to_mode_reg (args[i].mode, args[i].value);
 845       }
 846 }
 847
 848 #ifdef REG_PARM_STACK_SPACE
 849
 850   /* The argument list is the property of the called routine and it
 851      may clobber it.  If the fixed area has been used for previous
 852      parameters, we must save and restore it.  */
 853
 854 static rtx
 855 save_fixed_argument_area (reg_parm_stack_space, argblock,
 856                           low_to_save, high_to_save)
 857      int reg_parm_stack_space;
 858      rtx argblock;
 859      int *low_to_save;
 860      int *high_to_save;
 861 {
 862   int i;
 863   rtx save_area = NULL_RTX;
 864
 865   /* Compute the boundary of the that needs to be saved, if any.  */
 866 #ifdef ARGS_GROW_DOWNWARD
 867   for (i = 0; i < reg_parm_stack_space + 1; i++)
 868 #else
 869   for (i = 0; i < reg_parm_stack_space; i++)
 870 #endif
 871     {
 872       if (i >= highest_outgoing_arg_in_use
 873           || stack_usage_map[i] == 0)
 874         continue;
 875
 876       if (*low_to_save == -1)
 877         *low_to_save = i;
 878
 879       *high_to_save = i;
 880     }
 881
 882   if (*low_to_save >= 0)
 883     {
 884       int num_to_save = *high_to_save - *low_to_save + 1;
 885       enum machine_mode save_mode
 886         = mode_for_size (num_to_save * BITS_PER_UNIT, MODE_INT, 1);
 887       rtx stack_area;
 888
 889       /* If we don't have the required alignment, must do this in BLKmode.  */
 890       if ((*low_to_save & (MIN (GET_MODE_SIZE (save_mode),
 891                                 BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1)))
 892         save_mode = BLKmode;
 893
 894 #ifdef ARGS_GROW_DOWNWARD
 895       stack_area
 896         = gen_rtx_MEM (save_mode,
 897                        memory_address (save_mode,
 898                                        plus_constant (argblock,
 899                                                       - *high_to_save)));
 900 #else
 901       stack_area = gen_rtx_MEM (save_mode,
 902                                 memory_address (save_mode,
 903                                                 plus_constant (argblock,
 904                                                                *low_to_save)));
 905 #endif
 906       if (save_mode == BLKmode)
 907         {
 908           save_area = assign_stack_temp (BLKmode, num_to_save, 0);
 909           /* Cannot use emit_block_move here because it can be done by a
 910              library call which in turn gets into this place again and deadly
 911              infinite recursion happens.  */
 912           move_by_pieces (validize_mem (save_area), stack_area, num_to_save,
 913                           PARM_BOUNDARY);
 914         }
 915       else
 916         {
 917           save_area = gen_reg_rtx (save_mode);
 918           emit_move_insn (save_area, stack_area);
 919         }
 920     }
 921   return save_area;
 922 }
 923
 924 static void
 925 restore_fixed_argument_area (save_area, argblock, high_to_save, low_to_save)
 926      rtx save_area;
 927      rtx argblock;
 928      int high_to_save;
 929      int low_to_save;
 930 {
 931   enum machine_mode save_mode = GET_MODE (save_area);
 932 #ifdef ARGS_GROW_DOWNWARD
 933   rtx stack_area
 934     = gen_rtx_MEM (save_mode,
 935                    memory_address (save_mode,
 936                                    plus_constant (argblock,
 937                                                   - high_to_save)));
 938 #else
 939   rtx stack_area
 940     = gen_rtx_MEM (save_mode,
 941                    memory_address (save_mode,
 942                                    plus_constant (argblock,
 943                                                   low_to_save)));
 944 #endif
 945
 946   if (save_mode != BLKmode)
 947     emit_move_insn (stack_area, save_area);
 948   else
 949     /* Cannot use emit_block_move here because it can be done by a library
 950        call which in turn gets into this place again and deadly infinite
 951        recursion happens.  */
 952     move_by_pieces (stack_area, validize_mem (save_area),
 953                     high_to_save - low_to_save + 1, PARM_BOUNDARY);
 954 }
 955 #endif
 956
 957 /* If any elements in ARGS refer to parameters that are to be passed in
 958    registers, but not in memory, and whose alignment does not permit a
 959    direct copy into registers.  Copy the values into a group of pseudos
 960    which we will later copy into the appropriate hard registers.
 961
 962    Pseudos for each unaligned argument will be stored into the array
 963    args[argnum].aligned_regs.  The caller is responsible for deallocating
 964    the aligned_regs array if it is nonzero.  */
 965
 966 static void
 967 store_unaligned_arguments_into_pseudos (args, num_actuals)
 968      struct arg_data *args;
 969      int num_actuals;
 970 {
 971   int i, j;
 972
 973   for (i = 0; i < num_actuals; i++)
 974     if (args[i].reg != 0 && ! args[i].pass_on_stack
 975         && args[i].mode == BLKmode
 976         && (TYPE_ALIGN (TREE_TYPE (args[i].tree_value))
 977             < (unsigned int) MIN (BIGGEST_ALIGNMENT, BITS_PER_WORD)))
 978       {
 979         int bytes = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
 980         int big_endian_correction = 0;
 981
 982         args[i].n_aligned_regs
 983           = args[i].partial ? args[i].partial
 984             : (bytes + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
 985
 986         args[i].aligned_regs = (rtx *) xmalloc (sizeof (rtx)
 987                                                 * args[i].n_aligned_regs);
 988
 989         /* Structures smaller than a word are aligned to the least
 990            significant byte (to the right).  On a BYTES_BIG_ENDIAN machine,
 991            this means we must skip the empty high order bytes when
 992            calculating the bit offset.  */
 993         if (BYTES_BIG_ENDIAN && bytes < UNITS_PER_WORD)
 994           big_endian_correction = (BITS_PER_WORD  - (bytes * BITS_PER_UNIT));
 995
 996         for (j = 0; j < args[i].n_aligned_regs; j++)
 997           {
 998             rtx reg = gen_reg_rtx (word_mode);
 999             rtx word = operand_subword_force (args[i].value, j, BLKmode);
1000             int bitsize = MIN (bytes * BITS_PER_UNIT, BITS_PER_WORD);
1001             int bitalign = TYPE_ALIGN (TREE_TYPE (args[i].tree_value));
1002
1003             args[i].aligned_regs[j] = reg;
1004
1005             /* There is no need to restrict this code to loading items
1006                in TYPE_ALIGN sized hunks.  The bitfield instructions can
1007                load up entire word sized registers efficiently.
1008
1009                ??? This may not be needed anymore.
1010                We use to emit a clobber here but that doesn't let later
1011                passes optimize the instructions we emit.  By storing 0 into
1012                the register later passes know the first AND to zero out the
1013                bitfield being set in the register is unnecessary.  The store
1014                of 0 will be deleted as will at least the first AND.  */
1015
1016             emit_move_insn (reg, const0_rtx);
1017
1018             bytes -= bitsize / BITS_PER_UNIT;
1019             store_bit_field (reg, bitsize, big_endian_correction, word_mode,
1020                              extract_bit_field (word, bitsize, 0, 1, NULL_RTX,
1021                                                 word_mode, word_mode, bitalign,
1022                                                 BITS_PER_WORD),
1023                              bitalign, BITS_PER_WORD);
1024           }
1025       }
1026 }
1027
1028 /* Fill in ARGS_SIZE and ARGS array based on the parameters found in
1029    ACTPARMS.
1030
1031    NUM_ACTUALS is the total number of parameters.
1032
1033    N_NAMED_ARGS is the total number of named arguments.
1034
1035    FNDECL is the tree code for the target of this call (if known)
1036
1037    ARGS_SO_FAR holds state needed by the target to know where to place
1038    the next argument.
1039
1040    REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
1041    for arguments which are passed in registers.
1042
1043    OLD_STACK_LEVEL is a pointer to an rtx which olds the old stack level
1044    and may be modified by this routine.
1045
1046    OLD_PENDING_ADJ, MUST_PREALLOCATE and FLAGS are pointers to integer
1047    flags which may may be modified by this routine.  */
1048
1049 static void
1050 initialize_argument_information (num_actuals, args, args_size, n_named_args,
1051                                  actparms, fndecl, args_so_far,
1052                                  reg_parm_stack_space, old_stack_level,
1053                                  old_pending_adj, must_preallocate,
1054                                  ecf_flags)
1055      int num_actuals ATTRIBUTE_UNUSED;
1056      struct arg_data *args;
1057      struct args_size *args_size;
1058      int n_named_args ATTRIBUTE_UNUSED;
1059      tree actparms;
1060      tree fndecl;
1061      CUMULATIVE_ARGS *args_so_far;
1062      int reg_parm_stack_space;
1063      rtx *old_stack_level;
1064      int *old_pending_adj;
1065      int *must_preallocate;
1066      int *ecf_flags;
1067 {
1068   /* 1 if scanning parms front to back, -1 if scanning back to front.  */
1069   int inc;
1070
1071   /* Count arg position in order args appear.  */
1072   int argpos;
1073
1074   struct args_size alignment_pad;
1075   int i;
1076   tree p;
1077
1078   args_size->constant = 0;
1079   args_size->var = 0;
1080
1081   /* In this loop, we consider args in the order they are written.
1082      We fill up ARGS from the front or from the back if necessary
1083      so that in any case the first arg to be pushed ends up at the front.  */
1084
1085   if (PUSH_ARGS_REVERSED)
1086     {
1087       i = num_actuals - 1, inc = -1;
1088       /* In this case, must reverse order of args
1089          so that we compute and push the last arg first.  */
1090     }
1091   else
1092     {
1093       i = 0, inc = 1;
1094     }
1095
1096   /* I counts args in order (to be) pushed; ARGPOS counts in order written.  */
1097   for (p = actparms, argpos = 0; p; p = TREE_CHAIN (p), i += inc, argpos++)
1098     {
1099       tree type = TREE_TYPE (TREE_VALUE (p));
1100       int unsignedp;
1101       enum machine_mode mode;
1102
1103       args[i].tree_value = TREE_VALUE (p);
1104
1105       /* Replace erroneous argument with constant zero.  */
1106       if (type == error_mark_node || !COMPLETE_TYPE_P (type))
1107         args[i].tree_value = integer_zero_node, type = integer_type_node;
1108
1109       /* If TYPE is a transparent union, pass things the way we would
1110          pass the first field of the union.  We have already verified that
1111          the modes are the same.  */
1112       if (TREE_CODE (type) == UNION_TYPE && TYPE_TRANSPARENT_UNION (type))
1113         type = TREE_TYPE (TYPE_FIELDS (type));
1114
1115       /* Decide where to pass this arg.
1116
1117          args[i].reg is nonzero if all or part is passed in registers.
1118
1119          args[i].partial is nonzero if part but not all is passed in registers,
1120          and the exact value says how many words are passed in registers.
1121
1122          args[i].pass_on_stack is nonzero if the argument must at least be
1123          computed on the stack.  It may then be loaded back into registers
1124          if args[i].reg is nonzero.
1125
1126          These decisions are driven by the FUNCTION_... macros and must agree
1127          with those made by function.c.  */
1128
1129       /* See if this argument should be passed by invisible reference.  */
1130       if ((TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST
1131            && contains_placeholder_p (TYPE_SIZE (type)))
1132           || TREE_ADDRESSABLE (type)
1133 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
1134           || FUNCTION_ARG_PASS_BY_REFERENCE (*args_so_far, TYPE_MODE (type),
1135                                              type, argpos < n_named_args)
1136 #endif
1137           )
1138         {
1139           /* If we're compiling a thunk, pass through invisible
1140              references instead of making a copy.  */
1141           if (current_function_is_thunk
1142 #ifdef FUNCTION_ARG_CALLEE_COPIES
1143               || (FUNCTION_ARG_CALLEE_COPIES (*args_so_far, TYPE_MODE (type),
1144                                              type, argpos < n_named_args)
1145                   /* If it's in a register, we must make a copy of it too.  */
1146                   /* ??? Is this a sufficient test?  Is there a better one? */
1147                   && !(TREE_CODE (args[i].tree_value) == VAR_DECL
1148                        && REG_P (DECL_RTL (args[i].tree_value)))
1149                   && ! TREE_ADDRESSABLE (type))
1150 #endif
1151               )
1152             {
1153               /* C++ uses a TARGET_EXPR to indicate that we want to make a
1154                  new object from the argument.  If we are passing by
1155                  invisible reference, the callee will do that for us, so we
1156                  can strip off the TARGET_EXPR.  This is not always safe,
1157                  but it is safe in the only case where this is a useful
1158                  optimization; namely, when the argument is a plain object.
1159                  In that case, the frontend is just asking the backend to
1160                  make a bitwise copy of the argument. */
1161
1162               if (TREE_CODE (args[i].tree_value) == TARGET_EXPR
1163                   && (DECL_P (TREE_OPERAND (args[i].tree_value, 1)))
1164                   && ! REG_P (DECL_RTL (TREE_OPERAND (args[i].tree_value, 1))))
1165                 args[i].tree_value = TREE_OPERAND (args[i].tree_value, 1);
1166
1167               args[i].tree_value = build1 (ADDR_EXPR,
1168                                            build_pointer_type (type),
1169                                            args[i].tree_value);
1170               type = build_pointer_type (type);
1171             }
1172           else
1173             {
1174               /* We make a copy of the object and pass the address to the
1175                  function being called.  */
1176               rtx copy;
1177
1178               if (!COMPLETE_TYPE_P (type)
1179                   || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST
1180                   || (flag_stack_check && ! STACK_CHECK_BUILTIN
1181                       && (0 < compare_tree_int (TYPE_SIZE_UNIT (type),
1182                                                 STACK_CHECK_MAX_VAR_SIZE))))
1183                 {
1184                   /* This is a variable-sized object.  Make space on the stack
1185                      for it.  */
1186                   rtx size_rtx = expr_size (TREE_VALUE (p));
1187
1188                   if (*old_stack_level == 0)
1189                     {
1190                       emit_stack_save (SAVE_BLOCK, old_stack_level, NULL_RTX);
1191                       *old_pending_adj = pending_stack_adjust;
1192                       pending_stack_adjust = 0;
1193                     }
1194
1195                   copy = gen_rtx_MEM (BLKmode,
1196                                       allocate_dynamic_stack_space
1197                                       (size_rtx, NULL_RTX, TYPE_ALIGN (type)));
1198                   set_mem_attributes (copy, type, 1);
1199                 }
1200               else
1201                 copy = assign_temp (type, 0, 1, 0);
1202
1203               store_expr (args[i].tree_value, copy, 0);
1204               *ecf_flags &= ~(ECF_CONST | ECF_PURE);
1205
1206               args[i].tree_value = build1 (ADDR_EXPR,
1207                                            build_pointer_type (type),
1208                                            make_tree (type, copy));
1209               type = build_pointer_type (type);
1210             }
1211         }
1212
1213       mode = TYPE_MODE (type);
1214       unsignedp = TREE_UNSIGNED (type);
1215
1216 #ifdef PROMOTE_FUNCTION_ARGS
1217       mode = promote_mode (type, mode, &unsignedp, 1);
1218 #endif
1219
1220       args[i].unsignedp = unsignedp;
1221       args[i].mode = mode;
1222
1223       args[i].reg = FUNCTION_ARG (*args_so_far, mode, type,
1224                                   argpos < n_named_args);
1225 #ifdef FUNCTION_INCOMING_ARG
1226       /* If this is a sibling call and the machine has register windows, the
1227          register window has to be unwinded before calling the routine, so
1228          arguments have to go into the incoming registers.  */
1229       args[i].tail_call_reg = FUNCTION_INCOMING_ARG (*args_so_far, mode, type,
1230                                              argpos < n_named_args);
1231 #else
1232       args[i].tail_call_reg = args[i].reg;
1233 #endif
1234
1235 #ifdef FUNCTION_ARG_PARTIAL_NREGS
1236       if (args[i].reg)
1237         args[i].partial
1238           = FUNCTION_ARG_PARTIAL_NREGS (*args_so_far, mode, type,
1239                                         argpos < n_named_args);
1240 #endif
1241
1242       args[i].pass_on_stack = MUST_PASS_IN_STACK (mode, type);
1243
1244       /* If FUNCTION_ARG returned a (parallel [(expr_list (nil) ...) ...]),
1245          it means that we are to pass this arg in the register(s) designated
1246          by the PARALLEL, but also to pass it in the stack.  */
1247       if (args[i].reg && GET_CODE (args[i].reg) == PARALLEL
1248           && XEXP (XVECEXP (args[i].reg, 0, 0), 0) == 0)
1249         args[i].pass_on_stack = 1;
1250
1251       /* If this is an addressable type, we must preallocate the stack
1252          since we must evaluate the object into its final location.
1253
1254          If this is to be passed in both registers and the stack, it is simpler
1255          to preallocate.  */
1256       if (TREE_ADDRESSABLE (type)
1257           || (args[i].pass_on_stack && args[i].reg != 0))
1258         *must_preallocate = 1;
1259
1260       /* If this is an addressable type, we cannot pre-evaluate it.  Thus,
1261          we cannot consider this function call constant.  */
1262       if (TREE_ADDRESSABLE (type))
1263         *ecf_flags &= ~(ECF_CONST | ECF_PURE);
1264
1265       /* Compute the stack-size of this argument.  */
1266       if (args[i].reg == 0 || args[i].partial != 0
1267           || reg_parm_stack_space > 0
1268           || args[i].pass_on_stack)
1269         locate_and_pad_parm (mode, type,
1270 #ifdef STACK_PARMS_IN_REG_PARM_AREA
1271                              1,
1272 #else
1273                              args[i].reg != 0,
1274 #endif
1275                              fndecl, args_size, &args[i].offset,
1276                              &args[i].size, &alignment_pad);
1277
1278 #ifndef ARGS_GROW_DOWNWARD
1279       args[i].slot_offset = *args_size;
1280 #endif
1281
1282       args[i].alignment_pad = alignment_pad;
1283
1284       /* If a part of the arg was put into registers,
1285          don't include that part in the amount pushed.  */
1286       if (reg_parm_stack_space == 0 && ! args[i].pass_on_stack)
1287         args[i].size.constant -= ((args[i].partial * UNITS_PER_WORD)
1288                                   / (PARM_BOUNDARY / BITS_PER_UNIT)
1289                                   * (PARM_BOUNDARY / BITS_PER_UNIT));
1290
1291       /* Update ARGS_SIZE, the total stack space for args so far.  */
1292
1293       args_size->constant += args[i].size.constant;
1294       if (args[i].size.var)
1295         {
1296           ADD_PARM_SIZE (*args_size, args[i].size.var);
1297         }
1298
1299       /* Since the slot offset points to the bottom of the slot,
1300          we must record it after incrementing if the args grow down.  */
1301 #ifdef ARGS_GROW_DOWNWARD
1302       args[i].slot_offset = *args_size;
1303
1304       args[i].slot_offset.constant = -args_size->constant;
1305       if (args_size->var)
1306         SUB_PARM_SIZE (args[i].slot_offset, args_size->var);
1307 #endif
1308
1309       /* Increment ARGS_SO_FAR, which has info about which arg-registers
1310          have been used, etc.  */
1311
1312       FUNCTION_ARG_ADVANCE (*args_so_far, TYPE_MODE (type), type,
1313                             argpos < n_named_args);
1314     }
1315 }
1316
1317 /* Update ARGS_SIZE to contain the total size for the argument block.
1318    Return the original constant component of the argument block's size.
1319
1320    REG_PARM_STACK_SPACE holds the number of bytes of stack space reserved
1321    for arguments passed in registers.  */
1322
1323 static int
1324 compute_argument_block_size (reg_parm_stack_space, args_size,
1325                              preferred_stack_boundary)
1326      int reg_parm_stack_space;
1327      struct args_size *args_size;
1328      int preferred_stack_boundary ATTRIBUTE_UNUSED;
1329 {
1330   int unadjusted_args_size = args_size->constant;
1331
1332   /* For accumulate outgoing args mode we don't need to align, since the frame
1333      will be already aligned.  Align to STACK_BOUNDARY in order to prevent
1334      backends from generating missaligned frame sizes.  */
1335 #ifdef STACK_BOUNDARY
1336   if (ACCUMULATE_OUTGOING_ARGS && preferred_stack_boundary > STACK_BOUNDARY)
1337     preferred_stack_boundary = STACK_BOUNDARY;
1338 #endif
1339
1340   /* Compute the actual size of the argument block required.  The variable
1341      and constant sizes must be combined, the size may have to be rounded,
1342      and there may be a minimum required size.  */
1343
1344   if (args_size->var)
1345     {
1346       args_size->var = ARGS_SIZE_TREE (*args_size);
1347       args_size->constant = 0;
1348
1349 #ifdef PREFERRED_STACK_BOUNDARY
1350       preferred_stack_boundary /= BITS_PER_UNIT;
1351       if (preferred_stack_boundary > 1)
1352         {
1353           /* We don't handle this case yet.  To handle it correctly we have
1354              to add the delta, round and substract the delta.
1355              Currently no machine description requires this support.  */
1356           if (stack_pointer_delta & (preferred_stack_boundary - 1))
1357             abort();
1358           args_size->var = round_up (args_size->var, preferred_stack_boundary);
1359         }
1360 #endif
1361
1362       if (reg_parm_stack_space > 0)
1363         {
1364           args_size->var
1365             = size_binop (MAX_EXPR, args_size->var,
1366                           ssize_int (reg_parm_stack_space));
1367
1368 #ifndef OUTGOING_REG_PARM_STACK_SPACE
1369           /* The area corresponding to register parameters is not to count in
1370              the size of the block we need.  So make the adjustment.  */
1371           args_size->var
1372             = size_binop (MINUS_EXPR, args_size->var,
1373                           ssize_int (reg_parm_stack_space));
1374 #endif
1375         }
1376     }
1377   else
1378     {
1379 #ifdef PREFERRED_STACK_BOUNDARY
1380       preferred_stack_boundary /= BITS_PER_UNIT;
1381       if (preferred_stack_boundary < 1)
1382         preferred_stack_boundary = 1;
1383       args_size->constant = (((args_size->constant
1384                                + stack_pointer_delta
1385                                + preferred_stack_boundary - 1)
1386                               / preferred_stack_boundary
1387                               * preferred_stack_boundary)
1388                              - stack_pointer_delta);
1389 #endif
1390
1391       args_size->constant = MAX (args_size->constant,
1392                                  reg_parm_stack_space);
1393
1394 #ifdef MAYBE_REG_PARM_STACK_SPACE
1395       if (reg_parm_stack_space == 0)
1396         args_size->constant = 0;
1397 #endif
1398
1399 #ifndef OUTGOING_REG_PARM_STACK_SPACE
1400       args_size->constant -= reg_parm_stack_space;
1401 #endif
1402     }
1403   return unadjusted_args_size;
1404 }
1405
1406 /* Precompute parameters as needed for a function call.
1407
1408    FLAGS is mask of ECF_* constants.
1409
1410    NUM_ACTUALS is the number of arguments.
1411
1412    ARGS is an array containing information for each argument; this routine
1413    fills in the INITIAL_VALUE and VALUE fields for each precomputed argument.
1414    */
1415
1416 static void
1417 precompute_arguments (flags, num_actuals, args)
1418      int flags;
1419      int num_actuals;
1420      struct arg_data *args;
1421 {
1422   int i;
1423
1424   /* If this function call is cse'able, precompute all the parameters.
1425      Note that if the parameter is constructed into a temporary, this will
1426      cause an additional copy because the parameter will be constructed
1427      into a temporary location and then copied into the outgoing arguments.
1428      If a parameter contains a call to alloca and this function uses the
1429      stack, precompute the parameter.  */
1430
1431   /* If we preallocated the stack space, and some arguments must be passed
1432      on the stack, then we must precompute any parameter which contains a
1433      function call which will store arguments on the stack.
1434      Otherwise, evaluating the parameter may clobber previous parameters
1435      which have already been stored into the stack.  (we have code to avoid
1436      such case by saving the ougoing stack arguments, but it results in
1437      worse code)  */
1438
1439   for (i = 0; i < num_actuals; i++)
1440     if ((flags & (ECF_CONST | ECF_PURE))
1441         || calls_function (args[i].tree_value, !ACCUMULATE_OUTGOING_ARGS))
1442       {
1443         /* If this is an addressable type, we cannot pre-evaluate it.  */
1444         if (TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value)))
1445           abort ();
1446
1447         push_temp_slots ();
1448
1449         args[i].value
1450           = expand_expr (args[i].tree_value, NULL_RTX, VOIDmode, 0);
1451
1452         preserve_temp_slots (args[i].value);
1453         pop_temp_slots ();
1454
1455         /* ANSI doesn't require a sequence point here,
1456            but PCC has one, so this will avoid some problems.  */
1457         emit_queue ();
1458
1459         args[i].initial_value = args[i].value
1460           = protect_from_queue (args[i].value, 0);
1461
1462         if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) != args[i].mode)
1463           {
1464             args[i].value
1465               = convert_modes (args[i].mode,
1466                                TYPE_MODE (TREE_TYPE (args[i].tree_value)),
1467                                args[i].value, args[i].unsignedp);
1468 #ifdef PROMOTE_FOR_CALL_ONLY
1469             /* CSE will replace this only if it contains args[i].value
1470                pseudo, so convert it down to the declared mode using
1471                a SUBREG.  */
1472             if (GET_CODE (args[i].value) == REG
1473                 && GET_MODE_CLASS (args[i].mode) == MODE_INT)
1474               {
1475                 args[i].initial_value
1476                   = gen_rtx_SUBREG (TYPE_MODE (TREE_TYPE (args[i].tree_value)),
1477                                     args[i].value, 0);
1478                 SUBREG_PROMOTED_VAR_P (args[i].initial_value) = 1;
1479                 SUBREG_PROMOTED_UNSIGNED_P (args[i].initial_value)
1480                   = args[i].unsignedp;
1481               }
1482 #endif
1483           }
1484       }
1485 }
1486
1487 /* Given the current state of MUST_PREALLOCATE and information about
1488    arguments to a function call in NUM_ACTUALS, ARGS and ARGS_SIZE,
1489    compute and return the final value for MUST_PREALLOCATE.  */
1490
1491 static int
1492 finalize_must_preallocate (must_preallocate, num_actuals, args, args_size)
1493      int must_preallocate;
1494      int num_actuals;
1495      struct arg_data *args;
1496      struct args_size *args_size;
1497 {
1498   /* See if we have or want to preallocate stack space.
1499
1500      If we would have to push a partially-in-regs parm
1501      before other stack parms, preallocate stack space instead.
1502
1503      If the size of some parm is not a multiple of the required stack
1504      alignment, we must preallocate.
1505
1506      If the total size of arguments that would otherwise create a copy in
1507      a temporary (such as a CALL) is more than half the total argument list
1508      size, preallocation is faster.
1509
1510      Another reason to preallocate is if we have a machine (like the m88k)
1511      where stack alignment is required to be maintained between every
1512      pair of insns, not just when the call is made.  However, we assume here
1513      that such machines either do not have push insns (and hence preallocation
1514      would occur anyway) or the problem is taken care of with
1515      PUSH_ROUNDING.  */
1516
1517   if (! must_preallocate)
1518     {
1519       int partial_seen = 0;
1520       int copy_to_evaluate_size = 0;
1521       int i;
1522
1523       for (i = 0; i < num_actuals && ! must_preallocate; i++)
1524         {
1525           if (args[i].partial > 0 && ! args[i].pass_on_stack)
1526             partial_seen = 1;
1527           else if (partial_seen && args[i].reg == 0)
1528             must_preallocate = 1;
1529
1530           if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
1531               && (TREE_CODE (args[i].tree_value) == CALL_EXPR
1532                   || TREE_CODE (args[i].tree_value) == TARGET_EXPR
1533                   || TREE_CODE (args[i].tree_value) == COND_EXPR
1534                   || TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value))))
1535             copy_to_evaluate_size
1536               += int_size_in_bytes (TREE_TYPE (args[i].tree_value));
1537         }
1538
1539       if (copy_to_evaluate_size * 2 >= args_size->constant
1540           && args_size->constant > 0)
1541         must_preallocate = 1;
1542     }
1543   return must_preallocate;
1544 }
1545
1546 /* If we preallocated stack space, compute the address of each argument
1547    and store it into the ARGS array.
1548
1549    We need not ensure it is a valid memory address here; it will be
1550    validized when it is used.
1551
1552    ARGBLOCK is an rtx for the address of the outgoing arguments.  */
1553
1554 static void
1555 compute_argument_addresses (args, argblock, num_actuals)
1556      struct arg_data *args;
1557      rtx argblock;
1558      int num_actuals;
1559 {
1560   if (argblock)
1561     {
1562       rtx arg_reg = argblock;
1563       int i, arg_offset = 0;
1564
1565       if (GET_CODE (argblock) == PLUS)
1566         arg_reg = XEXP (argblock, 0), arg_offset = INTVAL (XEXP (argblock, 1));
1567
1568       for (i = 0; i < num_actuals; i++)
1569         {
1570           rtx offset = ARGS_SIZE_RTX (args[i].offset);
1571           rtx slot_offset = ARGS_SIZE_RTX (args[i].slot_offset);
1572           rtx addr;
1573
1574           /* Skip this parm if it will not be passed on the stack.  */
1575           if (! args[i].pass_on_stack && args[i].reg != 0)
1576             continue;
1577
1578           if (GET_CODE (offset) == CONST_INT)
1579             addr = plus_constant (arg_reg, INTVAL (offset));
1580           else
1581             addr = gen_rtx_PLUS (Pmode, arg_reg, offset);
1582
1583           addr = plus_constant (addr, arg_offset);
1584           args[i].stack = gen_rtx_MEM (args[i].mode, addr);
1585           set_mem_attributes (args[i].stack,
1586                               TREE_TYPE (args[i].tree_value), 1);
1587
1588           if (GET_CODE (slot_offset) == CONST_INT)
1589             addr = plus_constant (arg_reg, INTVAL (slot_offset));
1590           else
1591             addr = gen_rtx_PLUS (Pmode, arg_reg, slot_offset);
1592
1593           addr = plus_constant (addr, arg_offset);
1594           args[i].stack_slot = gen_rtx_MEM (args[i].mode, addr);
1595           set_mem_attributes (args[i].stack_slot,
1596                               TREE_TYPE (args[i].tree_value), 1);
1597         }
1598     }
1599 }
1600
1601 /* Given a FNDECL and EXP, return an rtx suitable for use as a target address
1602    in a call instruction.
1603
1604    FNDECL is the tree node for the target function.  For an indirect call
1605    FNDECL will be NULL_TREE.
1606
1607    EXP is the CALL_EXPR for this call.  */
1608
1609 static rtx
1610 rtx_for_function_call (fndecl, exp)
1611      tree fndecl;
1612      tree exp;
1613 {
1614   rtx funexp;
1615
1616   /* Get the function to call, in the form of RTL.  */
1617   if (fndecl)
1618     {
1619       /* If this is the first use of the function, see if we need to
1620          make an external definition for it.  */
1621       if (! TREE_USED (fndecl))
1622         {
1623           assemble_external (fndecl);
1624           TREE_USED (fndecl) = 1;
1625         }
1626
1627       /* Get a SYMBOL_REF rtx for the function address.  */
1628       funexp = XEXP (DECL_RTL (fndecl), 0);
1629     }
1630   else
1631     /* Generate an rtx (probably a pseudo-register) for the address.  */
1632     {
1633       rtx funaddr;
1634       push_temp_slots ();
1635       funaddr = funexp =
1636           expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
1637       pop_temp_slots ();        /* FUNEXP can't be BLKmode */
1638
1639       /* Check the function is executable.  */
1640       if (current_function_check_memory_usage)
1641         {
1642 #ifdef POINTERS_EXTEND_UNSIGNED
1643           /* It might be OK to convert funexp in place, but there's
1644              a lot going on between here and when it happens naturally
1645              that this seems safer. */
1646           funaddr = convert_memory_address (Pmode, funexp);
1647 #endif
1648           emit_library_call (chkr_check_exec_libfunc, 1,
1649                              VOIDmode, 1,
1650                              funaddr, Pmode);
1651         }
1652       emit_queue ();
1653     }
1654   return funexp;
1655 }
1656
1657 /* Do the register loads required for any wholly-register parms or any
1658    parms which are passed both on the stack and in a register.  Their
1659    expressions were already evaluated.
1660
1661    Mark all register-parms as living through the call, putting these USE
1662    insns in the CALL_INSN_FUNCTION_USAGE field.  */
1663
1664 static void
1665 load_register_parameters (args, num_actuals, call_fusage, flags)
1666      struct arg_data *args;
1667      int num_actuals;
1668      rtx *call_fusage;
1669      int flags;
1670 {
1671   int i, j;
1672
1673 #ifdef LOAD_ARGS_REVERSED
1674   for (i = num_actuals - 1; i >= 0; i--)
1675 #else
1676   for (i = 0; i < num_actuals; i++)
1677 #endif
1678     {
1679       rtx reg = ((flags & ECF_SIBCALL)
1680                  ? args[i].tail_call_reg : args[i].reg);
1681       int partial = args[i].partial;
1682       int nregs;
1683
1684       if (reg)
1685         {
1686           /* Set to non-negative if must move a word at a time, even if just
1687              one word (e.g, partial == 1 && mode == DFmode).  Set to -1 if
1688              we just use a normal move insn.  This value can be zero if the
1689              argument is a zero size structure with no fields.  */
1690           nregs = (partial ? partial
1691                    : (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
1692                       ? ((int_size_in_bytes (TREE_TYPE (args[i].tree_value))
1693                           + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
1694                       : -1));
1695
1696           /* Handle calls that pass values in multiple non-contiguous
1697              locations.  The Irix 6 ABI has examples of this.  */
1698
1699           if (GET_CODE (reg) == PARALLEL)
1700             emit_group_load (reg, args[i].value,
1701                              int_size_in_bytes (TREE_TYPE (args[i].tree_value)),
1702                              TYPE_ALIGN (TREE_TYPE (args[i].tree_value)));
1703
1704           /* If simple case, just do move.  If normal partial, store_one_arg
1705              has already loaded the register for us.  In all other cases,
1706              load the register(s) from memory.  */
1707
1708           else if (nregs == -1)
1709             emit_move_insn (reg, args[i].value);
1710
1711           /* If we have pre-computed the values to put in the registers in
1712              the case of non-aligned structures, copy them in now.  */
1713
1714           else if (args[i].n_aligned_regs != 0)
1715             for (j = 0; j < args[i].n_aligned_regs; j++)
1716               emit_move_insn (gen_rtx_REG (word_mode, REGNO (reg) + j),
1717                               args[i].aligned_regs[j]);
1718
1719           else if (partial == 0 || args[i].pass_on_stack)
1720             move_block_to_reg (REGNO (reg),
1721                                validize_mem (args[i].value), nregs,
1722                                args[i].mode);
1723
1724           /* Handle calls that pass values in multiple non-contiguous
1725              locations.  The Irix 6 ABI has examples of this.  */
1726           if (GET_CODE (reg) == PARALLEL)
1727             use_group_regs (call_fusage, reg);
1728           else if (nregs == -1)
1729             use_reg (call_fusage, reg);
1730           else
1731             use_regs (call_fusage, REGNO (reg), nregs == 0 ? 1 : nregs);
1732         }
1733     }
1734 }
1735
1736 /* Try to integreate function.  See expand_inline_function for documentation
1737    about the parameters.  */
1738
1739 static rtx
1740 try_to_integrate (fndecl, actparms, target, ignore, type, structure_value_addr)
1741      tree fndecl;
1742      tree actparms;
1743      rtx target;
1744      int ignore;
1745      tree type;
1746      rtx structure_value_addr;
1747 {
1748   rtx temp;
1749   rtx before_call;
1750   int i;
1751   rtx old_stack_level = 0;
1752   int reg_parm_stack_space = 0;
1753
1754 #ifdef REG_PARM_STACK_SPACE
1755 #ifdef MAYBE_REG_PARM_STACK_SPACE
1756   reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
1757 #else
1758   reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
1759 #endif
1760 #endif
1761
1762   before_call = get_last_insn ();
1763
1764   temp = expand_inline_function (fndecl, actparms, target,
1765                                  ignore, type,
1766                                  structure_value_addr);
1767
1768   /* If inlining succeeded, return.  */
1769   if (temp != (rtx) (HOST_WIDE_INT) - 1)
1770     {
1771       if (ACCUMULATE_OUTGOING_ARGS)
1772         {
1773           /* If the outgoing argument list must be preserved, push
1774              the stack before executing the inlined function if it
1775              makes any calls.  */
1776
1777           for (i = reg_parm_stack_space - 1; i >= 0; i--)
1778             if (i < highest_outgoing_arg_in_use && stack_usage_map[i] != 0)
1779               break;
1780
1781           if (stack_arg_under_construction || i >= 0)
1782             {
1783               rtx first_insn
1784                 = before_call ? NEXT_INSN (before_call) : get_insns ();
1785               rtx insn = NULL_RTX, seq;
1786
1787               /* Look for a call in the inline function code.
1788                  If DECL_SAVED_INSNS (fndecl)->outgoing_args_size is
1789                  nonzero then there is a call and it is not necessary
1790                  to scan the insns.  */
1791
1792               if (DECL_SAVED_INSNS (fndecl)->outgoing_args_size == 0)
1793                 for (insn = first_insn; insn; insn = NEXT_INSN (insn))
1794                   if (GET_CODE (insn) == CALL_INSN)
1795                     break;
1796
1797               if (insn)
1798                 {
1799                   /* Reserve enough stack space so that the largest
1800                      argument list of any function call in the inline
1801                      function does not overlap the argument list being
1802                      evaluated.  This is usually an overestimate because
1803                      allocate_dynamic_stack_space reserves space for an
1804                      outgoing argument list in addition to the requested
1805                      space, but there is no way to ask for stack space such
1806                      that an argument list of a certain length can be
1807                      safely constructed.
1808
1809                      Add the stack space reserved for register arguments, if
1810                      any, in the inline function.  What is really needed is the
1811                      largest value of reg_parm_stack_space in the inline
1812                      function, but that is not available.  Using the current
1813                      value of reg_parm_stack_space is wrong, but gives
1814                      correct results on all supported machines.  */
1815
1816                   int adjust = (DECL_SAVED_INSNS (fndecl)->outgoing_args_size
1817                                 + reg_parm_stack_space);
1818
1819                   start_sequence ();
1820                   emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1821                   allocate_dynamic_stack_space (GEN_INT (adjust),
1822                                                 NULL_RTX, BITS_PER_UNIT);
1823                   seq = get_insns ();
1824                   end_sequence ();
1825                   emit_insns_before (seq, first_insn);
1826                   emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1827                 }
1828             }
1829         }
1830
1831       /* If the result is equivalent to TARGET, return TARGET to simplify
1832          checks in store_expr.  They can be equivalent but not equal in the
1833          case of a function that returns BLKmode.  */
1834       if (temp != target && rtx_equal_p (temp, target))
1835         return target;
1836       return temp;
1837     }
1838
1839   /* If inlining failed, mark FNDECL as needing to be compiled
1840      separately after all.  If function was declared inline,
1841      give a warning.  */
1842   if (DECL_INLINE (fndecl) && warn_inline && !flag_no_inline
1843       && optimize > 0 && !TREE_ADDRESSABLE (fndecl))
1844     {
1845       warning_with_decl (fndecl, "inlining failed in call to `%s'");
1846       warning ("called from here");
1847     }
1848   mark_addressable (fndecl);
1849   return (rtx) (HOST_WIDE_INT) - 1;
1850 }
1851
1852 /* We need to pop PENDING_STACK_ADJUST bytes.  But, if the arguments
1853    wouldn't fill up an even multiple of PREFERRED_UNIT_STACK_BOUNDARY
1854    bytes, then we would need to push some additional bytes to pad the
1855    arguments.  So, we compute an adjust to the stack pointer for an
1856    amount that will leave the stack under-aligned by UNADJUSTED_ARGS_SIZE
1857    bytes.  Then, when the arguments are pushed the stack will be perfectly
1858    aligned.  ARGS_SIZE->CONSTANT is set to the number of bytes that should
1859    be popped after the call.  Returns the adjustment.  */
1860
1861 static int
1862 combine_pending_stack_adjustment_and_call (unadjusted_args_size,
1863                                            args_size,
1864                                            preferred_unit_stack_boundary)
1865      int unadjusted_args_size;
1866      struct args_size *args_size;
1867      int preferred_unit_stack_boundary;
1868 {
1869   /* The number of bytes to pop so that the stack will be
1870      under-aligned by UNADJUSTED_ARGS_SIZE bytes.  */
1871   HOST_WIDE_INT adjustment;
1872   /* The alignment of the stack after the arguments are pushed, if we
1873      just pushed the arguments without adjust the stack here.  */
1874   HOST_WIDE_INT unadjusted_alignment;
1875
1876   unadjusted_alignment
1877     = ((stack_pointer_delta + unadjusted_args_size)
1878        % preferred_unit_stack_boundary);
1879
1880   /* We want to get rid of as many of the PENDING_STACK_ADJUST bytes
1881      as possible -- leaving just enough left to cancel out the
1882      UNADJUSTED_ALIGNMENT.  In other words, we want to ensure that the
1883      PENDING_STACK_ADJUST is non-negative, and congruent to
1884      -UNADJUSTED_ALIGNMENT modulo the PREFERRED_UNIT_STACK_BOUNDARY.  */
1885
1886   /* Begin by trying to pop all the bytes.  */
1887   unadjusted_alignment
1888     = (unadjusted_alignment
1889        - (pending_stack_adjust % preferred_unit_stack_boundary));
1890   adjustment = pending_stack_adjust;
1891   /* Push enough additional bytes that the stack will be aligned
1892      after the arguments are pushed.  */
1893   if (unadjusted_alignment >= 0)
1894     adjustment -= preferred_unit_stack_boundary - unadjusted_alignment;
1895   else
1896     adjustment += unadjusted_alignment;
1897
1898   /* Now, sets ARGS_SIZE->CONSTANT so that we pop the right number of
1899      bytes after the call.  The right number is the entire
1900      PENDING_STACK_ADJUST less our ADJUSTMENT plus the amount required
1901      by the arguments in the first place.  */
1902   args_size->constant
1903     = pending_stack_adjust - adjustment + unadjusted_args_size;
1904
1905   return adjustment;
1906 }
1907
1908 /* Generate all the code for a function call
1909    and return an rtx for its value.
1910    Store the value in TARGET (specified as an rtx) if convenient.
1911    If the value is stored in TARGET then TARGET is returned.
1912    If IGNORE is nonzero, then we ignore the value of the function call.  */
1913
1914 rtx
1915 expand_call (exp, target, ignore)
1916      tree exp;
1917      rtx target;
1918      int ignore;
1919 {
1920   /* Nonzero if we are currently expanding a call.  */
1921   static int currently_expanding_call = 0;
1922
1923   /* List of actual parameters.  */
1924   tree actparms = TREE_OPERAND (exp, 1);
1925   /* RTX for the function to be called.  */
1926   rtx funexp;
1927   /* Sequence of insns to perform a tail recursive "call".  */
1928   rtx tail_recursion_insns = NULL_RTX;
1929   /* Sequence of insns to perform a normal "call".  */
1930   rtx normal_call_insns = NULL_RTX;
1931   /* Sequence of insns to perform a tail recursive "call".  */
1932   rtx tail_call_insns = NULL_RTX;
1933   /* Data type of the function.  */
1934   tree funtype;
1935   /* Declaration of the function being called,
1936      or 0 if the function is computed (not known by name).  */
1937   tree fndecl = 0;
1938   char *name = 0;
1939   rtx insn;
1940   int try_tail_call = 1;
1941   int try_tail_recursion = 1;
1942   int pass;
1943
1944   /* Register in which non-BLKmode value will be returned,
1945      or 0 if no value or if value is BLKmode.  */
1946   rtx valreg;
1947   /* Address where we should return a BLKmode value;
1948      0 if value not BLKmode.  */
1949   rtx structure_value_addr = 0;
1950   /* Nonzero if that address is being passed by treating it as
1951      an extra, implicit first parameter.  Otherwise,
1952      it is passed by being copied directly into struct_value_rtx.  */
1953   int structure_value_addr_parm = 0;
1954   /* Size of aggregate value wanted, or zero if none wanted
1955      or if we are using the non-reentrant PCC calling convention
1956      or expecting the value in registers.  */
1957   HOST_WIDE_INT struct_value_size = 0;
1958   /* Nonzero if called function returns an aggregate in memory PCC style,
1959      by returning the address of where to find it.  */
1960   int pcc_struct_value = 0;
1961
1962   /* Number of actual parameters in this call, including struct value addr.  */
1963   int num_actuals;
1964   /* Number of named args.  Args after this are anonymous ones
1965      and they must all go on the stack.  */
1966   int n_named_args;
1967
1968   /* Vector of information about each argument.
1969      Arguments are numbered in the order they will be pushed,
1970      not the order they are written.  */
1971   struct arg_data *args;
1972
1973   /* Total size in bytes of all the stack-parms scanned so far.  */
1974   struct args_size args_size;
1975   struct args_size adjusted_args_size;
1976   /* Size of arguments before any adjustments (such as rounding).  */
1977   int unadjusted_args_size;
1978   /* Data on reg parms scanned so far.  */
1979   CUMULATIVE_ARGS args_so_far;
1980   /* Nonzero if a reg parm has been scanned.  */
1981   int reg_parm_seen;
1982   /* Nonzero if this is an indirect function call.  */
1983
1984   /* Nonzero if we must avoid push-insns in the args for this call.
1985      If stack space is allocated for register parameters, but not by the
1986      caller, then it is preallocated in the fixed part of the stack frame.
1987      So the entire argument block must then be preallocated (i.e., we
1988      ignore PUSH_ROUNDING in that case).  */
1989
1990   int must_preallocate = !PUSH_ARGS;
1991
1992   /* Size of the stack reserved for parameter registers.  */
1993   int reg_parm_stack_space = 0;
1994
1995   /* Address of space preallocated for stack parms
1996      (on machines that lack push insns), or 0 if space not preallocated.  */
1997   rtx argblock = 0;
1998
1999   /* Mask of ECF_ flags.  */
2000   int flags = 0;
2001   /* Nonzero if this is a call to an inline function.  */
2002   int is_integrable = 0;
2003 #ifdef REG_PARM_STACK_SPACE
2004   /* Define the boundary of the register parm stack space that needs to be
2005      save, if any.  */
2006   int low_to_save = -1, high_to_save;
2007   rtx save_area = 0;            /* Place that it is saved */
2008 #endif
2009
2010   int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
2011   char *initial_stack_usage_map = stack_usage_map;
2012   int old_stack_arg_under_construction = 0;
2013
2014   rtx old_stack_level = 0;
2015   int old_pending_adj = 0;
2016   int old_inhibit_defer_pop = inhibit_defer_pop;
2017   int old_stack_allocated;
2018   rtx call_fusage;
2019   register tree p;
2020   register int i;
2021   /* The alignment of the stack, in bits.  */
2022   HOST_WIDE_INT preferred_stack_boundary;
2023   /* The alignment of the stack, in bytes.  */
2024   HOST_WIDE_INT preferred_unit_stack_boundary;
2025
2026   /* The value of the function call can be put in a hard register.  But
2027      if -fcheck-memory-usage, code which invokes functions (and thus
2028      damages some hard registers) can be inserted before using the value.
2029      So, target is always a pseudo-register in that case.  */
2030   if (current_function_check_memory_usage)
2031     target = 0;
2032
2033   /* See if this is "nothrow" function call.  */
2034   if (TREE_NOTHROW (exp))
2035     flags |= ECF_NOTHROW;
2036
2037   /* See if we can find a DECL-node for the actual function.
2038      As a result, decide whether this is a call to an integrable function.  */
2039
2040   fndecl = get_callee_fndecl (exp);
2041   if (fndecl)
2042     {
2043       if (!flag_no_inline
2044           && fndecl != current_function_decl
2045           && DECL_INLINE (fndecl)
2046           && DECL_SAVED_INSNS (fndecl)
2047           && DECL_SAVED_INSNS (fndecl)->inlinable)
2048         is_integrable = 1;
2049       else if (! TREE_ADDRESSABLE (fndecl))
2050         {
2051           /* In case this function later becomes inlinable,
2052              record that there was already a non-inline call to it.
2053
2054              Use abstraction instead of setting TREE_ADDRESSABLE
2055              directly.  */
2056           if (DECL_INLINE (fndecl) && warn_inline && !flag_no_inline
2057               && optimize > 0)
2058             {
2059               warning_with_decl (fndecl, "can't inline call to `%s'");
2060               warning ("called from here");
2061             }
2062           mark_addressable (fndecl);
2063         }
2064
2065       flags |= flags_from_decl_or_type (fndecl);
2066     }
2067
2068   /* If we don't have specific function to call, see if we have a
2069      attributes set in the type.  */
2070   else
2071     {
2072       p = TREE_OPERAND (exp, 0);
2073       flags |= flags_from_decl_or_type (TREE_TYPE (TREE_TYPE (p)));
2074     }
2075
2076 #ifdef REG_PARM_STACK_SPACE
2077 #ifdef MAYBE_REG_PARM_STACK_SPACE
2078   reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
2079 #else
2080   reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
2081 #endif
2082 #endif
2083
2084 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2085   if (reg_parm_stack_space > 0 && PUSH_ARGS)
2086     must_preallocate = 1;
2087 #endif
2088
2089   /* Warn if this value is an aggregate type,
2090      regardless of which calling convention we are using for it.  */
2091   if (warn_aggregate_return && AGGREGATE_TYPE_P (TREE_TYPE (exp)))
2092     warning ("function call has aggregate value");
2093
2094   /* Set up a place to return a structure.  */
2095
2096   /* Cater to broken compilers.  */
2097   if (aggregate_value_p (exp))
2098     {
2099       /* This call returns a big structure.  */
2100       flags &= ~(ECF_CONST | ECF_PURE);
2101
2102 #ifdef PCC_STATIC_STRUCT_RETURN
2103       {
2104         pcc_struct_value = 1;
2105         /* Easier than making that case work right.  */
2106         if (is_integrable)
2107           {
2108             /* In case this is a static function, note that it has been
2109                used.  */
2110             if (! TREE_ADDRESSABLE (fndecl))
2111               mark_addressable (fndecl);
2112             is_integrable = 0;
2113           }
2114       }
2115 #else /* not PCC_STATIC_STRUCT_RETURN */
2116       {
2117         struct_value_size = int_size_in_bytes (TREE_TYPE (exp));
2118
2119         if (target && GET_CODE (target) == MEM)
2120           structure_value_addr = XEXP (target, 0);
2121         else
2122           {
2123             /* Assign a temporary to hold the value.  */
2124             tree d;
2125
2126             /* For variable-sized objects, we must be called with a target
2127                specified.  If we were to allocate space on the stack here,
2128                we would have no way of knowing when to free it.  */
2129
2130             if (struct_value_size < 0)
2131               abort ();
2132
2133             /* This DECL is just something to feed to mark_addressable;
2134                it doesn't get pushed.  */
2135             d = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (exp));
2136             DECL_RTL (d) = assign_temp (TREE_TYPE (exp), 1, 0, 1);
2137             mark_addressable (d);
2138             mark_temp_addr_taken (DECL_RTL (d));
2139             structure_value_addr = XEXP (DECL_RTL (d), 0);
2140             TREE_USED (d) = 1;
2141             target = 0;
2142           }
2143       }
2144 #endif /* not PCC_STATIC_STRUCT_RETURN */
2145     }
2146
2147   /* If called function is inline, try to integrate it.  */
2148
2149   if (is_integrable)
2150     {
2151       rtx temp = try_to_integrate (fndecl, actparms, target,
2152                                    ignore, TREE_TYPE (exp),
2153                                    structure_value_addr);
2154       if (temp != (rtx) (HOST_WIDE_INT) - 1)
2155         return temp;
2156     }
2157
2158   if (fndecl && DECL_NAME (fndecl))
2159     name = IDENTIFIER_POINTER (DECL_NAME (fndecl));
2160
2161   /* Figure out the amount to which the stack should be aligned.  */
2162 #ifdef PREFERRED_STACK_BOUNDARY
2163   preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
2164 #else
2165   preferred_stack_boundary = STACK_BOUNDARY;
2166 #endif
2167
2168   /* Operand 0 is a pointer-to-function; get the type of the function.  */
2169   funtype = TREE_TYPE (TREE_OPERAND (exp, 0));
2170   if (! POINTER_TYPE_P (funtype))
2171     abort ();
2172   funtype = TREE_TYPE (funtype);
2173
2174   /* See if this is a call to a function that can return more than once
2175      or a call to longjmp or malloc.  */
2176   flags |= special_function_p (fndecl, flags);
2177
2178   if (flags & ECF_MAY_BE_ALLOCA)
2179     current_function_calls_alloca = 1;
2180
2181   /* If struct_value_rtx is 0, it means pass the address
2182      as if it were an extra parameter.  */
2183   if (structure_value_addr && struct_value_rtx == 0)
2184     {
2185       /* If structure_value_addr is a REG other than
2186          virtual_outgoing_args_rtx, we can use always use it.  If it
2187          is not a REG, we must always copy it into a register.
2188          If it is virtual_outgoing_args_rtx, we must copy it to another
2189          register in some cases.  */
2190       rtx temp = (GET_CODE (structure_value_addr) != REG
2191                   || (ACCUMULATE_OUTGOING_ARGS
2192                       && stack_arg_under_construction
2193                       && structure_value_addr == virtual_outgoing_args_rtx)
2194                   ? copy_addr_to_reg (structure_value_addr)
2195                   : structure_value_addr);
2196
2197       actparms
2198         = tree_cons (error_mark_node,
2199                      make_tree (build_pointer_type (TREE_TYPE (funtype)),
2200                                 temp),
2201                      actparms);
2202       structure_value_addr_parm = 1;
2203     }
2204
2205   /* Count the arguments and set NUM_ACTUALS.  */
2206   for (p = actparms, num_actuals = 0; p; p = TREE_CHAIN (p))
2207     num_actuals++;
2208
2209   /* Compute number of named args.
2210      Normally, don't include the last named arg if anonymous args follow.
2211      We do include the last named arg if STRICT_ARGUMENT_NAMING is nonzero.
2212      (If no anonymous args follow, the result of list_length is actually
2213      one too large.  This is harmless.)
2214
2215      If PRETEND_OUTGOING_VARARGS_NAMED is set and STRICT_ARGUMENT_NAMING is
2216      zero, this machine will be able to place unnamed args that were
2217      passed in registers into the stack.  So treat all args as named.
2218      This allows the insns emitting for a specific argument list to be
2219      independent of the function declaration.
2220
2221      If PRETEND_OUTGOING_VARARGS_NAMED is not set, we do not have any
2222      reliable way to pass unnamed args in registers, so we must force
2223      them into memory.  */
2224
2225   if ((STRICT_ARGUMENT_NAMING
2226        || ! PRETEND_OUTGOING_VARARGS_NAMED)
2227       && TYPE_ARG_TYPES (funtype) != 0)
2228     n_named_args
2229       = (list_length (TYPE_ARG_TYPES (funtype))
2230          /* Don't include the last named arg.  */
2231          - (STRICT_ARGUMENT_NAMING ? 0 : 1)
2232          /* Count the struct value address, if it is passed as a parm.  */
2233          + structure_value_addr_parm);
2234   else
2235     /* If we know nothing, treat all args as named.  */
2236     n_named_args = num_actuals;
2237
2238   /* Start updating where the next arg would go.
2239
2240      On some machines (such as the PA) indirect calls have a different
2241      calling convention than normal calls.  The last argument in
2242      INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
2243      or not.  */
2244   INIT_CUMULATIVE_ARGS (args_so_far, funtype, NULL_RTX, (fndecl == 0));
2245
2246
2247   /* Make a vector to hold all the information about each arg.  */
2248   args = (struct arg_data *) alloca (num_actuals
2249                                      * sizeof (struct arg_data));
2250   bzero ((char *) args, num_actuals * sizeof (struct arg_data));
2251
2252   /* Build up entries inthe ARGS array, compute the size of the arguments
2253      into ARGS_SIZE, etc.  */
2254   initialize_argument_information (num_actuals, args, &args_size,
2255                                    n_named_args, actparms, fndecl,
2256                                    &args_so_far, reg_parm_stack_space,
2257                                    &old_stack_level, &old_pending_adj,
2258                                    &must_preallocate, &flags);
2259
2260   if (args_size.var)
2261     {
2262       /* If this function requires a variable-sized argument list, don't
2263          try to make a cse'able block for this call.  We may be able to
2264          do this eventually, but it is too complicated to keep track of
2265          what insns go in the cse'able block and which don't.   */
2266
2267       flags &= ~(ECF_CONST | ECF_PURE);
2268       must_preallocate = 1;
2269     }
2270
2271   /* Now make final decision about preallocating stack space.  */
2272   must_preallocate = finalize_must_preallocate (must_preallocate,
2273                                                 num_actuals, args,
2274                                                 &args_size);
2275
2276   /* If the structure value address will reference the stack pointer, we
2277      must stabilize it.  We don't need to do this if we know that we are
2278      not going to adjust the stack pointer in processing this call.  */
2279
2280   if (structure_value_addr
2281       && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
2282           || reg_mentioned_p (virtual_outgoing_args_rtx,
2283                               structure_value_addr))
2284       && (args_size.var
2285           || (!ACCUMULATE_OUTGOING_ARGS && args_size.constant)))
2286     structure_value_addr = copy_to_reg (structure_value_addr);
2287
2288   /* Tail calls can make things harder to debug, and we're traditionally
2289      pushed these optimizations into -O2.  Don't try if we're already
2290      expanding a call, as that means we're an argument.  Similarly, if
2291      there's pending loops or cleanups we know there's code to follow
2292      the call.
2293
2294      If rtx_equal_function_value_matters is false, that means we've
2295      finished with regular parsing.  Which means that some of the
2296      machinery we use to generate tail-calls is no longer in place.
2297      This is most often true of sjlj-exceptions, which we couldn't
2298      tail-call to anyway.  */
2299
2300   if (currently_expanding_call++ != 0
2301       || !flag_optimize_sibling_calls
2302       || !rtx_equal_function_value_matters
2303       || !stmt_loop_nest_empty ()
2304       || any_pending_cleanups (1)
2305       || args_size.var)
2306     try_tail_call = try_tail_recursion = 0;
2307
2308   /* Tail recursion fails, when we are not dealing with recursive calls.  */
2309   if (!try_tail_recursion
2310       || TREE_CODE (TREE_OPERAND (exp, 0)) != ADDR_EXPR
2311       || TREE_OPERAND (TREE_OPERAND (exp, 0), 0) != current_function_decl)
2312     try_tail_recursion = 0;
2313
2314   /*  Rest of purposes for tail call optimizations to fail.  */
2315   if (
2316 #ifdef HAVE_sibcall_epilogue
2317       !HAVE_sibcall_epilogue
2318 #else
2319       1
2320 #endif
2321       || !try_tail_call
2322       /* Doing sibling call optimization needs some work, since
2323          structure_value_addr can be allocated on the stack.
2324          It does not seem worth the effort since few optimizable
2325          sibling calls will return a structure.  */
2326       || structure_value_addr != NULL_RTX
2327       /* If the register holding the address is a callee saved
2328          register, then we lose.  We have no way to prevent that,
2329          so we only allow calls to named functions.  */
2330       /* ??? This could be done by having the insn constraints
2331          use a register class that is all call-clobbered.  Any
2332          reload insns generated to fix things up would appear
2333          before the sibcall_epilogue.  */
2334       || fndecl == NULL_TREE
2335       || (flags & (ECF_RETURNS_TWICE | ECF_LONGJMP))
2336       || !FUNCTION_OK_FOR_SIBCALL (fndecl)
2337       /* If this function requires more stack slots than the current
2338          function, we cannot change it into a sibling call.  */
2339       || args_size.constant > current_function_args_size
2340       /* If the callee pops its own arguments, then it must pop exactly
2341          the same number of arguments as the current function.  */
2342       || RETURN_POPS_ARGS (fndecl, funtype, args_size.constant)
2343          != RETURN_POPS_ARGS (current_function_decl,
2344                               TREE_TYPE (current_function_decl),
2345                               current_function_args_size))
2346   try_tail_call = 0;
2347
2348   if (try_tail_call || try_tail_recursion)
2349     {
2350       int end, inc;
2351       actparms = NULL_TREE;
2352       /* Ok, we're going to give the tail call the old college try.
2353          This means we're going to evaluate the function arguments
2354          up to three times.  There are two degrees of badness we can
2355          encounter, those that can be unsaved and those that can't.
2356          (See unsafe_for_reeval commentary for details.)
2357
2358          Generate a new argument list.  Pass safe arguments through
2359          unchanged.  For the easy badness wrap them in UNSAVE_EXPRs.
2360          For hard badness, evaluate them now and put their resulting
2361          rtx in a temporary VAR_DECL.
2362
2363          initialize_argument_information has ordered the array for the
2364          order to be pushed, and we must remember this when reconstructing
2365          the original argument orde.  */
2366
2367       if (PUSH_ARGS_REVERSED)
2368         {
2369           inc = 1;
2370           i = 0;
2371           end = num_actuals;
2372         }
2373       else
2374           {
2375           inc = -1;
2376           i = num_actuals - 1;
2377           end = -1;
2378         }
2379
2380       for (; i != end; i += inc)
2381         {
2382           switch (unsafe_for_reeval (args[i].tree_value))
2383             {
2384           case 0: /* Safe.  */
2385             break;
2386
2387           case 1: /* Mildly unsafe.  */
2388             args[i].tree_value = unsave_expr (args[i].tree_value);
2389             break;
2390
2391           case 2: /* Wildly unsafe.  */
2392             {
2393               tree var = build_decl (VAR_DECL, NULL_TREE,
2394                                        TREE_TYPE (args[i].tree_value));
2395                 DECL_RTL (var) = expand_expr (args[i].tree_value, NULL_RTX,
2396                                             VOIDmode, EXPAND_NORMAL);
2397                 args[i].tree_value = var;
2398             }
2399             break;
2400
2401           default:
2402             abort ();
2403           }
2404           /* We need to build actparms for optimize_tail_recursion.  We can
2405              safely trash away TREE_PURPOSE, since it is unused by this
2406              function.  */
2407           if (try_tail_recursion)
2408             actparms = tree_cons (NULL_TREE, args[i].tree_value, actparms);
2409         }
2410       /* Expanding one of those dangerous arguments could have added
2411          cleanups, but otherwise give it a whirl.  */
2412       if (any_pending_cleanups (1))
2413         try_tail_call = try_tail_recursion = 0;
2414     }
2415
2416   /* Generate a tail recursion sequence when calling ourselves.  */
2417
2418   if (try_tail_recursion)
2419     {
2420       /* We want to emit any pending stack adjustments before the tail
2421          recursion "call".  That way we know any adjustment after the tail
2422          recursion call can be ignored if we indeed use the tail recursion
2423          call expansion.  */
2424       int save_pending_stack_adjust = pending_stack_adjust;
2425       int save_stack_pointer_delta = stack_pointer_delta;
2426
2427       /* Use a new sequence to hold any RTL we generate.  We do not even
2428          know if we will use this RTL yet.  The final decision can not be
2429          made until after RTL generation for the entire function is
2430          complete.  */
2431       start_sequence ();
2432       /* If expanding any of the arguments creates cleanups, we can't
2433          do a tailcall.  So, we'll need to pop the pending cleanups
2434          list.  If, however, all goes well, and there are no cleanups
2435          then the call to expand_start_target_temps will have no
2436          effect.  */
2437       expand_start_target_temps ();
2438       if (optimize_tail_recursion (actparms, get_last_insn ()))
2439         {
2440           if (any_pending_cleanups (1))
2441             try_tail_call = try_tail_recursion = 0;
2442           else
2443             tail_recursion_insns = get_insns ();
2444         }
2445       expand_end_target_temps ();
2446       end_sequence ();
2447
2448       /* Restore the original pending stack adjustment for the sibling and
2449          normal call cases below.  */
2450       pending_stack_adjust = save_pending_stack_adjust;
2451       stack_pointer_delta = save_stack_pointer_delta;
2452     }
2453
2454   if (profile_arc_flag && (flags & ECF_FORK_OR_EXEC))
2455     {
2456       /* A fork duplicates the profile information, and an exec discards
2457          it.  We can't rely on fork/exec to be paired.  So write out the
2458          profile information we have gathered so far, and clear it.  */
2459       /* ??? When Linux's __clone is called with CLONE_VM set, profiling
2460          is subject to race conditions, just as with multithreaded
2461          programs.  */
2462
2463       emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__bb_fork_func"), 0,
2464                          VOIDmode, 0);
2465     }
2466
2467   /* Ensure current function's preferred stack boundary is at least
2468      what we need.  We don't have to increase alignment for recursive
2469      functions.  */
2470   if (cfun->preferred_stack_boundary < preferred_stack_boundary
2471       && fndecl != current_function_decl)
2472     cfun->preferred_stack_boundary = preferred_stack_boundary;
2473
2474   preferred_unit_stack_boundary = preferred_stack_boundary / BITS_PER_UNIT;
2475
2476   function_call_count++;
2477
2478   /* We want to make two insn chains; one for a sibling call, the other
2479      for a normal call.  We will select one of the two chains after
2480      initial RTL generation is complete.  */
2481   for (pass = 0; pass < 2; pass++)
2482     {
2483       int sibcall_failure = 0;
2484       /* We want to emit ay pending stack adjustments before the tail
2485          recursion "call".  That way we know any adjustment after the tail
2486          recursion call can be ignored if we indeed use the tail recursion
2487          call expansion.  */
2488       int save_pending_stack_adjust;
2489       int save_stack_pointer_delta;
2490       rtx insns;
2491       rtx before_call, next_arg_reg;
2492
2493       if (pass == 0)
2494         {
2495           if (! try_tail_call)
2496             continue;
2497
2498           /* Emit any queued insns now; otherwise they would end up in
2499              only one of the alternates.  */
2500           emit_queue ();
2501
2502           /* State variables we need to save and restore between
2503              iterations.  */
2504           save_pending_stack_adjust = pending_stack_adjust;
2505           save_stack_pointer_delta = stack_pointer_delta;
2506         }
2507       if (pass)
2508         flags &= ~ECF_SIBCALL;
2509       else
2510         flags |= ECF_SIBCALL;
2511
2512       /* Other state variables that we must reinitialize each time
2513          through the loop (that are not initialized by the loop itself).  */
2514       argblock = 0;
2515       call_fusage = 0;
2516
2517       /* Start a new sequence for the normal call case.
2518
2519          From this point on, if the sibling call fails, we want to set
2520          sibcall_failure instead of continuing the loop.  */
2521       start_sequence ();
2522
2523       if (pass == 0)
2524         {
2525           /* We know at this point that there are not currently any
2526              pending cleanups.  If, however, in the process of evaluating
2527              the arguments we were to create some, we'll need to be
2528              able to get rid of them.  */
2529           expand_start_target_temps ();
2530         }
2531
2532       /* When calling a const function, we must pop the stack args right away,
2533          so that the pop is deleted or moved with the call.  */
2534       if (flags & (ECF_CONST | ECF_PURE))
2535         NO_DEFER_POP;
2536
2537       /* Don't let pending stack adjusts add up to too much.
2538          Also, do all pending adjustments now if there is any chance
2539          this might be a call to alloca or if we are expanding a sibling
2540          call sequence.  */
2541       if (pending_stack_adjust >= 32
2542           || (pending_stack_adjust > 0 && (flags & ECF_MAY_BE_ALLOCA))
2543           || pass == 0)
2544         do_pending_stack_adjust ();
2545
2546       /* Push the temporary stack slot level so that we can free any
2547          temporaries we make.  */
2548       push_temp_slots ();
2549
2550
2551 #ifdef FINAL_REG_PARM_STACK_SPACE
2552       reg_parm_stack_space = FINAL_REG_PARM_STACK_SPACE (args_size.constant,
2553                                                          args_size.var);
2554 #endif
2555       /* Precompute any arguments as needed.  */
2556       if (pass)
2557         precompute_arguments (flags, num_actuals, args);
2558
2559       /* Now we are about to start emitting insns that can be deleted
2560          if a libcall is deleted.  */
2561       if (flags & (ECF_CONST | ECF_PURE | ECF_MALLOC))
2562         start_sequence ();
2563
2564       adjusted_args_size = args_size;
2565       /* Compute the actual size of the argument block required.  The variable
2566          and constant sizes must be combined, the size may have to be rounded,
2567          and there may be a minimum required size.  When generating a sibcall
2568          pattern, do not round up, since we'll be re-using whatever space our
2569          caller provided.  */
2570       unadjusted_args_size
2571         = compute_argument_block_size (reg_parm_stack_space, &adjusted_args_size,
2572                                        (pass == 0 ? 0
2573                                         : preferred_stack_boundary));
2574
2575       old_stack_allocated =  stack_pointer_delta - pending_stack_adjust;
2576
2577       /* The argument block when performing a sibling call is the
2578          incoming argument block.  */
2579       if (pass == 0)
2580         argblock = virtual_incoming_args_rtx;
2581
2582       /* If we have no actual push instructions, or shouldn't use them,
2583          make space for all args right now.  */
2584       else if (adjusted_args_size.var != 0)
2585         {
2586           if (old_stack_level == 0)
2587             {
2588               emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
2589               old_pending_adj = pending_stack_adjust;
2590               pending_stack_adjust = 0;
2591               /* stack_arg_under_construction says whether a stack arg is
2592                  being constructed at the old stack level.  Pushing the stack
2593                  gets a clean outgoing argument block.  */
2594               old_stack_arg_under_construction = stack_arg_under_construction;
2595               stack_arg_under_construction = 0;
2596             }
2597           argblock = push_block (ARGS_SIZE_RTX (adjusted_args_size), 0, 0);
2598         }
2599       else
2600         {
2601           /* Note that we must go through the motions of allocating an argument
2602              block even if the size is zero because we may be storing args
2603              in the area reserved for register arguments, which may be part of
2604              the stack frame.  */
2605
2606           int needed = adjusted_args_size.constant;
2607
2608           /* Store the maximum argument space used.  It will be pushed by
2609              the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
2610              checking).  */
2611
2612           if (needed > current_function_outgoing_args_size)
2613             current_function_outgoing_args_size = needed;
2614
2615           if (must_preallocate)
2616             {
2617               if (ACCUMULATE_OUTGOING_ARGS)
2618                 {
2619                   /* Since the stack pointer will never be pushed, it is
2620                      possible for the evaluation of a parm to clobber
2621                      something we have already written to the stack.
2622                      Since most function calls on RISC machines do not use
2623                      the stack, this is uncommon, but must work correctly.
2624
2625                      Therefore, we save any area of the stack that was already
2626                      written and that we are using.  Here we set up to do this
2627                      by making a new stack usage map from the old one.  The
2628                      actual save will be done by store_one_arg.
2629
2630                      Another approach might be to try to reorder the argument
2631                      evaluations to avoid this conflicting stack usage.  */
2632
2633 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2634                   /* Since we will be writing into the entire argument area,
2635                      the map must be allocated for its entire size, not just
2636                      the part that is the responsibility of the caller.  */
2637                   needed += reg_parm_stack_space;
2638 #endif
2639
2640 #ifdef ARGS_GROW_DOWNWARD
2641                   highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
2642                                                      needed + 1);
2643 #else
2644                   highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
2645                                                      needed);
2646 #endif
2647                   stack_usage_map
2648                     = (char *) alloca (highest_outgoing_arg_in_use);
2649
2650                   if (initial_highest_arg_in_use)
2651                     bcopy (initial_stack_usage_map, stack_usage_map,
2652                            initial_highest_arg_in_use);
2653
2654                   if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
2655                     bzero (&stack_usage_map[initial_highest_arg_in_use],
2656                            (highest_outgoing_arg_in_use
2657                             - initial_highest_arg_in_use));
2658                   needed = 0;
2659
2660                   /* The address of the outgoing argument list must not be
2661                      copied to a register here, because argblock would be left
2662                      pointing to the wrong place after the call to
2663                      allocate_dynamic_stack_space below. */
2664
2665                   argblock = virtual_outgoing_args_rtx;
2666                 }
2667               else
2668                 {
2669                   if (inhibit_defer_pop == 0)
2670                     {
2671                       /* Try to reuse some or all of the pending_stack_adjust
2672                          to get this space.  */
2673                       needed
2674                         = (combine_pending_stack_adjustment_and_call
2675                            (unadjusted_args_size,
2676                             &adjusted_args_size,
2677                             preferred_unit_stack_boundary));
2678
2679                       /* combine_pending_stack_adjustment_and_call computes
2680                          an adjustment before the arguments are allocated.
2681                          Account for them and see whether or not the stack
2682                          needs to go up or down.  */
2683                       needed = unadjusted_args_size - needed;
2684
2685                       if (needed < 0)
2686                         {
2687                           /* We're releasing stack space.  */
2688                           /* ??? We can avoid any adjustment at all if we're
2689                              already aligned.  FIXME.  */
2690                           pending_stack_adjust = -needed;
2691                           do_pending_stack_adjust ();
2692                           needed = 0;
2693                         }
2694                       else
2695                         /* We need to allocate space.  We'll do that in
2696                            push_block below.  */
2697                         pending_stack_adjust = 0;
2698                     }
2699
2700                   /* Special case this because overhead of `push_block' in
2701                      this case is non-trivial.  */
2702                   if (needed == 0)
2703                     argblock = virtual_outgoing_args_rtx;
2704                   else
2705                     argblock = push_block (GEN_INT (needed), 0, 0);
2706
2707                   /* We only really need to call `copy_to_reg' in the case
2708                      where push insns are going to be used to pass ARGBLOCK
2709                      to a function call in ARGS.  In that case, the stack
2710                      pointer changes value from the allocation point to the
2711                      call point, and hence the value of
2712                      VIRTUAL_OUTGOING_ARGS_RTX changes as well.  But might
2713                      as well always do it.  */
2714                   argblock = copy_to_reg (argblock);
2715
2716                   /* The save/restore code in store_one_arg handles all
2717                      cases except one: a constructor call (including a C
2718                      function returning a BLKmode struct) to initialize
2719                      an argument.  */
2720                   if (stack_arg_under_construction)
2721                     {
2722 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2723                       rtx push_size = GEN_INT (reg_parm_stack_space
2724                                                + adjusted_args_size.constant);
2725 #else
2726                       rtx push_size = GEN_INT (adjusted_args_size.constant);
2727 #endif
2728                       if (old_stack_level == 0)
2729                         {
2730                           emit_stack_save (SAVE_BLOCK, &old_stack_level,
2731                                            NULL_RTX);
2732                           old_pending_adj = pending_stack_adjust;
2733                           pending_stack_adjust = 0;
2734                           /* stack_arg_under_construction says whether a stack
2735                              arg is being constructed at the old stack level.
2736                              Pushing the stack gets a clean outgoing argument
2737                              block.  */
2738                           old_stack_arg_under_construction
2739                             = stack_arg_under_construction;
2740                           stack_arg_under_construction = 0;
2741                           /* Make a new map for the new argument list.  */
2742                           stack_usage_map = (char *)
2743                             alloca (highest_outgoing_arg_in_use);
2744                           bzero (stack_usage_map, highest_outgoing_arg_in_use);
2745                           highest_outgoing_arg_in_use = 0;
2746                         }
2747                       allocate_dynamic_stack_space (push_size, NULL_RTX,
2748                                                     BITS_PER_UNIT);
2749                     }
2750                   /* If argument evaluation might modify the stack pointer,
2751                      copy the address of the argument list to a register.  */
2752                   for (i = 0; i < num_actuals; i++)
2753                     if (args[i].pass_on_stack)
2754                       {
2755                         argblock = copy_addr_to_reg (argblock);
2756                         break;
2757                       }
2758                 }
2759             }
2760         }
2761
2762       compute_argument_addresses (args, argblock, num_actuals);
2763
2764 #ifdef PREFERRED_STACK_BOUNDARY
2765       /* If we push args individually in reverse order, perform stack alignment
2766          before the first push (the last arg).  */
2767       if (PUSH_ARGS_REVERSED && argblock == 0
2768           && adjusted_args_size.constant != unadjusted_args_size)
2769         {
2770           /* When the stack adjustment is pending, we get better code
2771              by combining the adjustments.  */
2772           if (pending_stack_adjust
2773               && ! (flags & (ECF_CONST | ECF_PURE))
2774               && ! inhibit_defer_pop)
2775             {
2776               pending_stack_adjust
2777                 = (combine_pending_stack_adjustment_and_call
2778                    (unadjusted_args_size,
2779                     &adjusted_args_size,
2780                     preferred_unit_stack_boundary));
2781               do_pending_stack_adjust ();
2782             }
2783           else if (argblock == 0)
2784             anti_adjust_stack (GEN_INT (adjusted_args_size.constant
2785                                         - unadjusted_args_size));
2786         }
2787       /* Now that the stack is properly aligned, pops can't safely
2788          be deferred during the evaluation of the arguments.  */
2789       NO_DEFER_POP;
2790 #endif
2791
2792       /* Don't try to defer pops if preallocating, not even from the first arg,
2793          since ARGBLOCK probably refers to the SP.  */
2794       if (argblock)
2795         NO_DEFER_POP;
2796
2797       funexp = rtx_for_function_call (fndecl, exp);
2798
2799       /* Figure out the register where the value, if any, will come back.  */
2800       valreg = 0;
2801       if (TYPE_MODE (TREE_TYPE (exp)) != VOIDmode
2802           && ! structure_value_addr)
2803         {
2804           if (pcc_struct_value)
2805             valreg = hard_function_value (build_pointer_type (TREE_TYPE (exp)),
2806                                           fndecl, (pass == 0));
2807           else
2808             valreg = hard_function_value (TREE_TYPE (exp), fndecl, (pass == 0));
2809         }
2810
2811       /* Precompute all register parameters.  It isn't safe to compute anything
2812          once we have started filling any specific hard regs.  */
2813       precompute_register_parameters (num_actuals, args, &reg_parm_seen);
2814
2815 #ifdef REG_PARM_STACK_SPACE
2816       /* Save the fixed argument area if it's part of the caller's frame and
2817          is clobbered by argument setup for this call.  */
2818       if (ACCUMULATE_OUTGOING_ARGS && pass)
2819         save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
2820                                               &low_to_save, &high_to_save);
2821 #endif
2822
2823       /* Now store (and compute if necessary) all non-register parms.
2824          These come before register parms, since they can require block-moves,
2825          which could clobber the registers used for register parms.
2826          Parms which have partial registers are not stored here,
2827          but we do preallocate space here if they want that.  */
2828
2829       for (i = 0; i < num_actuals; i++)
2830         if (args[i].reg == 0 || args[i].pass_on_stack)
2831           store_one_arg (&args[i], argblock, flags,
2832                          adjusted_args_size.var != 0, reg_parm_stack_space);
2833
2834       /* If we have a parm that is passed in registers but not in memory
2835          and whose alignment does not permit a direct copy into registers,
2836          make a group of pseudos that correspond to each register that we
2837          will later fill.  */
2838       if (STRICT_ALIGNMENT)
2839         store_unaligned_arguments_into_pseudos (args, num_actuals);
2840
2841       /* Now store any partially-in-registers parm.
2842          This is the last place a block-move can happen.  */
2843       if (reg_parm_seen)
2844         for (i = 0; i < num_actuals; i++)
2845           if (args[i].partial != 0 && ! args[i].pass_on_stack)
2846             store_one_arg (&args[i], argblock, flags,
2847                            adjusted_args_size.var != 0, reg_parm_stack_space);
2848
2849 #ifdef PREFERRED_STACK_BOUNDARY
2850       /* If we pushed args in forward order, perform stack alignment
2851          after pushing the last arg.  */
2852       if (!PUSH_ARGS_REVERSED && argblock == 0)
2853         anti_adjust_stack (GEN_INT (adjusted_args_size.constant
2854                                     - unadjusted_args_size));
2855 #endif
2856
2857       /* If register arguments require space on the stack and stack space
2858          was not preallocated, allocate stack space here for arguments
2859          passed in registers.  */
2860 #ifdef OUTGOING_REG_PARM_STACK_SPACE
2861       if (!ACCUMULATE_OUTGOING_ARGS
2862            && must_preallocate == 0 && reg_parm_stack_space > 0)
2863         anti_adjust_stack (GEN_INT (reg_parm_stack_space));
2864 #endif
2865
2866       /* Pass the function the address in which to return a
2867          structure value.  */
2868       if (pass != 0 && structure_value_addr && ! structure_value_addr_parm)
2869         {
2870           emit_move_insn (struct_value_rtx,
2871                           force_reg (Pmode,
2872                                      force_operand (structure_value_addr,
2873                                                     NULL_RTX)));
2874
2875           /* Mark the memory for the aggregate as write-only.  */
2876           if (current_function_check_memory_usage)
2877             emit_library_call (chkr_set_right_libfunc, 1,
2878                                VOIDmode, 3,
2879                                structure_value_addr, ptr_mode,
2880                                GEN_INT (struct_value_size),
2881                                TYPE_MODE (sizetype),
2882                                GEN_INT (MEMORY_USE_WO),
2883                                TYPE_MODE (integer_type_node));
2884
2885           if (GET_CODE (struct_value_rtx) == REG)
2886             use_reg (&call_fusage, struct_value_rtx);
2887         }
2888
2889       funexp = prepare_call_address (funexp, fndecl, &call_fusage,
2890                                      reg_parm_seen);
2891
2892       load_register_parameters (args, num_actuals, &call_fusage, flags);
2893
2894       /* Perform postincrements before actually calling the function.  */
2895       emit_queue ();
2896
2897       /* Save a pointer to the last insn before the call, so that we can
2898          later safely search backwards to find the CALL_INSN.  */
2899       before_call = get_last_insn ();
2900
2901       /* Set up next argument register.  For sibling calls on machines
2902          with register windows this should be the incoming register.  */
2903 #ifdef FUNCTION_INCOMING_ARG
2904       if (pass == 0)
2905         next_arg_reg = FUNCTION_INCOMING_ARG (args_so_far, VOIDmode,
2906                                               void_type_node, 1);
2907       else
2908 #endif
2909         next_arg_reg = FUNCTION_ARG (args_so_far, VOIDmode,
2910                                      void_type_node, 1);
2911
2912       /* All arguments and registers used for the call must be set up by
2913          now!  */
2914
2915 #ifdef PREFERRED_STACK_BOUNDARY
2916       /* Stack must be properly aligned now.  */
2917       if (pass && stack_pointer_delta % preferred_unit_stack_boundary)
2918         abort ();
2919 #endif
2920
2921       /* Generate the actual call instruction.  */
2922       emit_call_1 (funexp, fndecl, funtype, unadjusted_args_size,
2923                    adjusted_args_size.constant, struct_value_size,
2924                    next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
2925                    flags);
2926
2927       /* Verify that we've deallocated all the stack we used.  */
2928       if (pass
2929           && old_stack_allocated != stack_pointer_delta - pending_stack_adjust)
2930         abort();
2931
2932       /* If call is cse'able, make appropriate pair of reg-notes around it.
2933          Test valreg so we don't crash; may safely ignore `const'
2934          if return type is void.  Disable for PARALLEL return values, because
2935          we have no way to move such values into a pseudo register.  */
2936       if (pass
2937           && (flags & (ECF_CONST | ECF_PURE))
2938           && valreg != 0 && GET_CODE (valreg) != PARALLEL)
2939         {
2940           rtx note = 0;
2941           rtx temp = gen_reg_rtx (GET_MODE (valreg));
2942           rtx insns;
2943
2944           /* Mark the return value as a pointer if needed.  */
2945           if (TREE_CODE (TREE_TYPE (exp)) == POINTER_TYPE)
2946             mark_reg_pointer (temp, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp))));
2947
2948           /* Construct an "equal form" for the value which mentions all the
2949              arguments in order as well as the function name.  */
2950           for (i = 0; i < num_actuals; i++)
2951             note = gen_rtx_EXPR_LIST (VOIDmode, args[i].initial_value, note);
2952           note = gen_rtx_EXPR_LIST (VOIDmode, funexp, note);
2953
2954           insns = get_insns ();
2955           end_sequence ();
2956
2957           if (flags & ECF_PURE)
2958             note = gen_rtx_EXPR_LIST (VOIDmode,
2959                gen_rtx_USE (VOIDmode,
2960                             gen_rtx_MEM (BLKmode,
2961                                          gen_rtx_SCRATCH (VOIDmode))), note);
2962
2963           emit_libcall_block (insns, temp, valreg, note);
2964
2965           valreg = temp;
2966         }
2967       else if (flags & (ECF_CONST | ECF_PURE))
2968         {
2969           /* Otherwise, just write out the sequence without a note.  */
2970           rtx insns = get_insns ();
2971
2972           end_sequence ();
2973           emit_insns (insns);
2974         }
2975       else if (flags & ECF_MALLOC)
2976         {
2977           rtx temp = gen_reg_rtx (GET_MODE (valreg));
2978           rtx last, insns;
2979
2980           /* The return value from a malloc-like function is a pointer. */
2981           if (TREE_CODE (TREE_TYPE (exp)) == POINTER_TYPE)
2982             mark_reg_pointer (temp, BIGGEST_ALIGNMENT);
2983
2984           emit_move_insn (temp, valreg);
2985
2986           /* The return value from a malloc-like function can not alias
2987              anything else.  */
2988           last = get_last_insn ();
2989           REG_NOTES (last) =
2990             gen_rtx_EXPR_LIST (REG_NOALIAS, temp, REG_NOTES (last));
2991
2992           /* Write out the sequence.  */
2993           insns = get_insns ();
2994           end_sequence ();
2995           emit_insns (insns);
2996           valreg = temp;
2997         }
2998
2999       /* For calls to `setjmp', etc., inform flow.c it should complain
3000          if nonvolatile values are live.  For functions that cannot return,
3001          inform flow that control does not fall through.  */
3002
3003       if ((flags & (ECF_RETURNS_TWICE | ECF_NORETURN | ECF_LONGJMP)) || pass == 0)
3004         {
3005           /* The barrier or NOTE_INSN_SETJMP note must be emitted
3006              immediately after the CALL_INSN.  Some ports emit more
3007              than just a CALL_INSN above, so we must search for it here.  */
3008
3009           rtx last = get_last_insn ();
3010           while (GET_CODE (last) != CALL_INSN)
3011             {
3012               last = PREV_INSN (last);
3013               /* There was no CALL_INSN?  */
3014               if (last == before_call)
3015                 abort ();
3016             }
3017
3018           if (flags & ECF_RETURNS_TWICE)
3019             {
3020               emit_note_after (NOTE_INSN_SETJMP, last);
3021               current_function_calls_setjmp = 1;
3022             }
3023           else
3024             emit_barrier_after (last);
3025         }
3026
3027       if (flags & ECF_LONGJMP)
3028         current_function_calls_longjmp = 1;
3029
3030       /* If this function is returning into a memory location marked as
3031          readonly, it means it is initializing that location.  But we normally
3032          treat functions as not clobbering such locations, so we need to
3033          specify that this one does.  */
3034       if (target != 0 && GET_CODE (target) == MEM
3035           && structure_value_addr != 0 && RTX_UNCHANGING_P (target))
3036         emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
3037
3038       /* If value type not void, return an rtx for the value.  */
3039
3040       /* If there are cleanups to be called, don't use a hard reg as target.
3041          We need to double check this and see if it matters anymore.  */
3042       if (any_pending_cleanups (1))
3043         {
3044           if (target && REG_P (target)
3045               && REGNO (target) < FIRST_PSEUDO_REGISTER)
3046             target = 0;
3047           sibcall_failure = 1;
3048         }
3049
3050       if (TYPE_MODE (TREE_TYPE (exp)) == VOIDmode
3051           || ignore)
3052         {
3053           target = const0_rtx;
3054         }
3055       else if (structure_value_addr)
3056         {
3057           if (target == 0 || GET_CODE (target) != MEM)
3058             {
3059               target
3060                 = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
3061                                memory_address (TYPE_MODE (TREE_TYPE (exp)),
3062                                                structure_value_addr));
3063               set_mem_attributes (target, exp, 1);
3064             }
3065         }
3066       else if (pcc_struct_value)
3067         {
3068           /* This is the special C++ case where we need to
3069              know what the true target was.  We take care to
3070              never use this value more than once in one expression.  */
3071           target = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
3072                                 copy_to_reg (valreg));
3073           set_mem_attributes (target, exp, 1);
3074         }
3075       /* Handle calls that return values in multiple non-contiguous locations.
3076          The Irix 6 ABI has examples of this.  */
3077       else if (GET_CODE (valreg) == PARALLEL)
3078         {
3079           int bytes = int_size_in_bytes (TREE_TYPE (exp));
3080
3081           if (target == 0)
3082             {
3083               target = assign_stack_temp (TYPE_MODE (TREE_TYPE (exp)),
3084                                           bytes, 0);
3085               MEM_SET_IN_STRUCT_P (target, AGGREGATE_TYPE_P (TREE_TYPE (exp)));
3086               preserve_temp_slots (target);
3087             }
3088
3089           if (! rtx_equal_p (target, valreg))
3090             emit_group_store (target, valreg, bytes,
3091                               TYPE_ALIGN (TREE_TYPE (exp)));
3092
3093           /* We can not support sibling calls for this case.  */
3094           sibcall_failure = 1;
3095         }
3096       else if (target
3097                && GET_MODE (target) == TYPE_MODE (TREE_TYPE (exp))
3098                && GET_MODE (target) == GET_MODE (valreg))
3099         {
3100           /* TARGET and VALREG cannot be equal at this point because the
3101              latter would not have REG_FUNCTION_VALUE_P true, while the
3102              former would if it were referring to the same register.
3103
3104              If they refer to the same register, this move will be a no-op,
3105              except when function inlining is being done.  */
3106           emit_move_insn (target, valreg);
3107         }
3108       else if (TYPE_MODE (TREE_TYPE (exp)) == BLKmode)
3109         target = copy_blkmode_from_reg (target, valreg, TREE_TYPE (exp));
3110       else
3111         target = copy_to_reg (valreg);
3112
3113 #ifdef PROMOTE_FUNCTION_RETURN
3114       /* If we promoted this return value, make the proper SUBREG.  TARGET
3115          might be const0_rtx here, so be careful.  */
3116       if (GET_CODE (target) == REG
3117           && TYPE_MODE (TREE_TYPE (exp)) != BLKmode
3118           && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
3119         {
3120           tree type = TREE_TYPE (exp);
3121           int unsignedp = TREE_UNSIGNED (type);
3122
3123           /* If we don't promote as expected, something is wrong.  */
3124           if (GET_MODE (target)
3125               != promote_mode (type, TYPE_MODE (type), &unsignedp, 1))
3126             abort ();
3127
3128           target = gen_rtx_SUBREG (TYPE_MODE (type), target, 0);
3129           SUBREG_PROMOTED_VAR_P (target) = 1;
3130           SUBREG_PROMOTED_UNSIGNED_P (target) = unsignedp;
3131         }
3132 #endif
3133
3134       /* If size of args is variable or this was a constructor call for a stack
3135          argument, restore saved stack-pointer value.  */
3136
3137       if (old_stack_level)
3138         {
3139           emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
3140           pending_stack_adjust = old_pending_adj;
3141           stack_arg_under_construction = old_stack_arg_under_construction;
3142           highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3143           stack_usage_map = initial_stack_usage_map;
3144           sibcall_failure = 1;
3145         }
3146       else if (ACCUMULATE_OUTGOING_ARGS && pass)
3147         {
3148 #ifdef REG_PARM_STACK_SPACE
3149           if (save_area)
3150             {
3151               restore_fixed_argument_area (save_area, argblock,
3152                                            high_to_save, low_to_save);
3153             }
3154 #endif
3155
3156           /* If we saved any argument areas, restore them.  */
3157           for (i = 0; i < num_actuals; i++)
3158             if (args[i].save_area)
3159               {
3160                 enum machine_mode save_mode = GET_MODE (args[i].save_area);
3161                 rtx stack_area
3162                   = gen_rtx_MEM (save_mode,
3163                                  memory_address (save_mode,
3164                                                  XEXP (args[i].stack_slot, 0)));
3165
3166                 if (save_mode != BLKmode)
3167                   emit_move_insn (stack_area, args[i].save_area);
3168                 else
3169                   emit_block_move (stack_area,
3170                                    validize_mem (args[i].save_area),
3171                                    GEN_INT (args[i].size.constant),
3172                                    PARM_BOUNDARY);
3173               }
3174
3175           highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3176           stack_usage_map = initial_stack_usage_map;
3177         }
3178
3179       /* If this was alloca, record the new stack level for nonlocal gotos.
3180          Check for the handler slots since we might not have a save area
3181          for non-local gotos.  */
3182
3183       if ((flags & ECF_MAY_BE_ALLOCA) && nonlocal_goto_handler_slots != 0)
3184         emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
3185
3186       pop_temp_slots ();
3187
3188       /* Free up storage we no longer need.  */
3189       for (i = 0; i < num_actuals; ++i)
3190         if (args[i].aligned_regs)
3191           free (args[i].aligned_regs);
3192
3193       if (pass == 0)
3194         {
3195           /* Undo the fake expand_start_target_temps we did earlier.  If
3196              there had been any cleanups created, we've already set
3197              sibcall_failure.  */
3198           expand_end_target_temps ();
3199         }
3200
3201       insns = get_insns ();
3202       end_sequence ();
3203
3204       if (pass == 0)
3205         {
3206           tail_call_insns = insns;
3207
3208           /* If something prevents making this a sibling call,
3209              zero out the sequence.  */
3210           if (sibcall_failure)
3211             tail_call_insns = NULL_RTX;
3212           /* Restore the pending stack adjustment now that we have
3213              finished generating the sibling call sequence.  */
3214
3215           pending_stack_adjust = save_pending_stack_adjust;
3216           stack_pointer_delta = save_stack_pointer_delta;
3217
3218           /* Prepare arg structure for next iteration.  */
3219           for (i = 0 ; i < num_actuals ; i++)
3220             {
3221               args[i].value = 0;
3222               args[i].aligned_regs = 0;
3223               args[i].stack = 0;
3224             }
3225         }
3226       else
3227         normal_call_insns = insns;
3228     }
3229
3230   /* The function optimize_sibling_and_tail_recursive_calls doesn't
3231      handle CALL_PLACEHOLDERs inside other CALL_PLACEHOLDERs.  This
3232      can happen if the arguments to this function call an inline
3233      function who's expansion contains another CALL_PLACEHOLDER.
3234
3235      If there are any C_Ps in any of these sequences, replace them
3236      with their normal call. */
3237
3238   for (insn = normal_call_insns; insn; insn = NEXT_INSN (insn))
3239     if (GET_CODE (insn) == CALL_INSN
3240         && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
3241       replace_call_placeholder (insn, sibcall_use_normal);
3242
3243   for (insn = tail_call_insns; insn; insn = NEXT_INSN (insn))
3244     if (GET_CODE (insn) == CALL_INSN
3245         && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
3246       replace_call_placeholder (insn, sibcall_use_normal);
3247
3248   for (insn = tail_recursion_insns; insn; insn = NEXT_INSN (insn))
3249     if (GET_CODE (insn) == CALL_INSN
3250         && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
3251       replace_call_placeholder (insn, sibcall_use_normal);
3252
3253   /* If this was a potential tail recursion site, then emit a
3254      CALL_PLACEHOLDER with the normal and the tail recursion streams.
3255      One of them will be selected later.  */
3256   if (tail_recursion_insns || tail_call_insns)
3257     {
3258       /* The tail recursion label must be kept around.  We could expose
3259          its use in the CALL_PLACEHOLDER, but that creates unwanted edges
3260          and makes determining true tail recursion sites difficult.
3261
3262          So we set LABEL_PRESERVE_P here, then clear it when we select
3263          one of the call sequences after rtl generation is complete.  */
3264       if (tail_recursion_insns)
3265         LABEL_PRESERVE_P (tail_recursion_label) = 1;
3266       emit_call_insn (gen_rtx_CALL_PLACEHOLDER (VOIDmode, normal_call_insns,
3267                                                 tail_call_insns,
3268                                                 tail_recursion_insns,
3269                                                 tail_recursion_label));
3270     }
3271   else
3272     emit_insns (normal_call_insns);
3273
3274   currently_expanding_call--;
3275
3276   return target;
3277 }
3278 \f
3279 /* Returns nonzero if FUN is the symbol for a library function which can
3280    not throw.  */
3281
3282 static int
3283 libfunc_nothrow (fun)
3284      rtx fun;
3285 {
3286   if (fun == throw_libfunc
3287       || fun == rethrow_libfunc
3288       || fun == sjthrow_libfunc
3289       || fun == sjpopnthrow_libfunc)
3290     return 0;
3291
3292   return 1;
3293 }
3294 \f
3295 /* Output a library call to function FUN (a SYMBOL_REF rtx).
3296    The RETVAL parameter specifies whether return value needs to be saved, other
3297    parameters are documented in the emit_library_call function bellow.  */
3298 static rtx
3299 emit_library_call_value_1 (retval, orgfun, value, fn_type, outmode, nargs, p)
3300      int retval;
3301      rtx orgfun;
3302      rtx value;
3303      int fn_type;
3304      enum machine_mode outmode;
3305      int nargs;
3306      va_list p;
3307 {
3308   /* Total size in bytes of all the stack-parms scanned so far.  */
3309   struct args_size args_size;
3310   /* Size of arguments before any adjustments (such as rounding).  */
3311   struct args_size original_args_size;
3312   register int argnum;
3313   rtx fun;
3314   int inc;
3315   int count;
3316   struct args_size alignment_pad;
3317   rtx argblock = 0;
3318   CUMULATIVE_ARGS args_so_far;
3319   struct arg { rtx value; enum machine_mode mode; rtx reg; int partial;
3320                struct args_size offset; struct args_size size; rtx save_area; };
3321   struct arg *argvec;
3322   int old_inhibit_defer_pop = inhibit_defer_pop;
3323   rtx call_fusage = 0;
3324   rtx mem_value = 0;
3325   rtx valreg;
3326   int pcc_struct_value = 0;
3327   int struct_value_size = 0;
3328   int flags = 0;
3329   int reg_parm_stack_space = 0;
3330   int needed;
3331
3332 #ifdef REG_PARM_STACK_SPACE
3333   /* Define the boundary of the register parm stack space that needs to be
3334      save, if any.  */
3335   int low_to_save = -1, high_to_save = 0;
3336   rtx save_area = 0;            /* Place that it is saved */
3337 #endif
3338
3339   /* Size of the stack reserved for parameter registers.  */
3340   int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
3341   char *initial_stack_usage_map = stack_usage_map;
3342
3343 #ifdef REG_PARM_STACK_SPACE
3344 #ifdef MAYBE_REG_PARM_STACK_SPACE
3345   reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
3346 #else
3347   reg_parm_stack_space = REG_PARM_STACK_SPACE ((tree) 0);
3348 #endif
3349 #endif
3350
3351   if (fn_type == 1)
3352     flags |= ECF_CONST;
3353   else if (fn_type == 2)
3354     flags |= ECF_PURE;
3355   fun = orgfun;
3356
3357   if (libfunc_nothrow (fun))
3358     flags |= ECF_NOTHROW;
3359
3360 #ifdef PREFERRED_STACK_BOUNDARY
3361   /* Ensure current function's preferred stack boundary is at least
3362      what we need.  */
3363   if (cfun->preferred_stack_boundary < PREFERRED_STACK_BOUNDARY)
3364     cfun->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
3365 #endif
3366
3367   /* If this kind of value comes back in memory,
3368      decide where in memory it should come back.  */
3369   if (outmode != VOIDmode && aggregate_value_p (type_for_mode (outmode, 0)))
3370     {
3371 #ifdef PCC_STATIC_STRUCT_RETURN
3372       rtx pointer_reg
3373         = hard_function_value (build_pointer_type (type_for_mode (outmode, 0)),
3374                                0, 0);
3375       mem_value = gen_rtx_MEM (outmode, pointer_reg);
3376       pcc_struct_value = 1;
3377       if (value == 0)
3378         value = gen_reg_rtx (outmode);
3379 #else /* not PCC_STATIC_STRUCT_RETURN */
3380       struct_value_size = GET_MODE_SIZE (outmode);
3381       if (value != 0 && GET_CODE (value) == MEM)
3382         mem_value = value;
3383       else
3384         mem_value = assign_stack_temp (outmode, GET_MODE_SIZE (outmode), 0);
3385 #endif
3386
3387       /* This call returns a big structure.  */
3388       flags &= ~(ECF_CONST | ECF_PURE);
3389     }
3390
3391   /* ??? Unfinished: must pass the memory address as an argument.  */
3392
3393   /* Copy all the libcall-arguments out of the varargs data
3394      and into a vector ARGVEC.
3395
3396      Compute how to pass each argument.  We only support a very small subset
3397      of the full argument passing conventions to limit complexity here since
3398      library functions shouldn't have many args.  */
3399
3400   argvec = (struct arg *) alloca ((nargs + 1) * sizeof (struct arg));
3401   bzero ((char *) argvec, (nargs + 1) * sizeof (struct arg));
3402
3403   INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE, fun, 0);
3404
3405   args_size.constant = 0;
3406   args_size.var = 0;
3407
3408   count = 0;
3409
3410   /* Now we are about to start emitting insns that can be deleted
3411      if a libcall is deleted.  */
3412   if (flags & (ECF_CONST | ECF_PURE))
3413     start_sequence ();
3414
3415   push_temp_slots ();
3416
3417   /* If there's a structure value address to be passed,
3418      either pass it in the special place, or pass it as an extra argument.  */
3419   if (mem_value && struct_value_rtx == 0 && ! pcc_struct_value)
3420     {
3421       rtx addr = XEXP (mem_value, 0);
3422       nargs++;
3423
3424       /* Make sure it is a reasonable operand for a move or push insn.  */
3425       if (GET_CODE (addr) != REG && GET_CODE (addr) != MEM
3426           && ! (CONSTANT_P (addr) && LEGITIMATE_CONSTANT_P (addr)))
3427         addr = force_operand (addr, NULL_RTX);
3428
3429       argvec[count].value = addr;
3430       argvec[count].mode = Pmode;
3431       argvec[count].partial = 0;
3432
3433       argvec[count].reg = FUNCTION_ARG (args_so_far, Pmode, NULL_TREE, 1);
3434 #ifdef FUNCTION_ARG_PARTIAL_NREGS
3435       if (FUNCTION_ARG_PARTIAL_NREGS (args_so_far, Pmode, NULL_TREE, 1))
3436         abort ();
3437 #endif
3438
3439       locate_and_pad_parm (Pmode, NULL_TREE,
3440 #ifdef STACK_PARMS_IN_REG_PARM_AREA
3441                            1,
3442 #else
3443                            argvec[count].reg != 0,
3444 #endif
3445                            NULL_TREE, &args_size, &argvec[count].offset,
3446                            &argvec[count].size, &alignment_pad);
3447
3448
3449       if (argvec[count].reg == 0 || argvec[count].partial != 0
3450           || reg_parm_stack_space > 0)
3451         args_size.constant += argvec[count].size.constant;
3452
3453       FUNCTION_ARG_ADVANCE (args_so_far, Pmode, (tree) 0, 1);
3454
3455       count++;
3456     }
3457
3458   for (; count < nargs; count++)
3459     {
3460       rtx val = va_arg (p, rtx);
3461       enum machine_mode mode = va_arg (p, enum machine_mode);
3462
3463       /* We cannot convert the arg value to the mode the library wants here;
3464          must do it earlier where we know the signedness of the arg.  */
3465       if (mode == BLKmode
3466           || (GET_MODE (val) != mode && GET_MODE (val) != VOIDmode))
3467         abort ();
3468
3469       /* On some machines, there's no way to pass a float to a library fcn.
3470          Pass it as a double instead.  */
3471 #ifdef LIBGCC_NEEDS_DOUBLE
3472       if (LIBGCC_NEEDS_DOUBLE && mode == SFmode)
3473         val = convert_modes (DFmode, SFmode, val, 0), mode = DFmode;
3474 #endif
3475
3476       /* There's no need to call protect_from_queue, because
3477          either emit_move_insn or emit_push_insn will do that.  */
3478
3479       /* Make sure it is a reasonable operand for a move or push insn.  */
3480       if (GET_CODE (val) != REG && GET_CODE (val) != MEM
3481           && ! (CONSTANT_P (val) && LEGITIMATE_CONSTANT_P (val)))
3482         val = force_operand (val, NULL_RTX);
3483
3484 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
3485       if (FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, mode, NULL_TREE, 1))
3486         {
3487           /* We do not support FUNCTION_ARG_CALLEE_COPIES here since it can
3488              be viewed as just an efficiency improvement.  */
3489           rtx slot = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0);
3490           emit_move_insn (slot, val);
3491           val = force_operand (XEXP (slot, 0), NULL_RTX);
3492           mode = Pmode;
3493         }
3494 #endif
3495
3496       argvec[count].value = val;
3497       argvec[count].mode = mode;
3498
3499       argvec[count].reg = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1);
3500
3501 #ifdef FUNCTION_ARG_PARTIAL_NREGS
3502       argvec[count].partial
3503         = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, NULL_TREE, 1);
3504 #else
3505       argvec[count].partial = 0;
3506 #endif
3507
3508       locate_and_pad_parm (mode, NULL_TREE,
3509 #ifdef STACK_PARMS_IN_REG_PARM_AREA
3510                            1,
3511 #else
3512                            argvec[count].reg != 0,
3513 #endif
3514                            NULL_TREE, &args_size, &argvec[count].offset,
3515                            &argvec[count].size, &alignment_pad);
3516
3517       if (argvec[count].size.var)
3518         abort ();
3519
3520       if (reg_parm_stack_space == 0 && argvec[count].partial)
3521         argvec[count].size.constant -= argvec[count].partial * UNITS_PER_WORD;
3522
3523       if (argvec[count].reg == 0 || argvec[count].partial != 0
3524           || reg_parm_stack_space > 0)
3525         args_size.constant += argvec[count].size.constant;
3526
3527       FUNCTION_ARG_ADVANCE (args_so_far, mode, (tree) 0, 1);
3528     }
3529
3530 #ifdef FINAL_REG_PARM_STACK_SPACE
3531   reg_parm_stack_space = FINAL_REG_PARM_STACK_SPACE (args_size.constant,
3532                                                      args_size.var);
3533 #endif
3534   /* If this machine requires an external definition for library
3535      functions, write one out.  */
3536   assemble_external_libcall (fun);
3537
3538   original_args_size = args_size;
3539 #ifdef PREFERRED_STACK_BOUNDARY
3540   args_size.constant = (((args_size.constant
3541                           + stack_pointer_delta
3542                           + STACK_BYTES - 1)
3543                           / STACK_BYTES
3544                           * STACK_BYTES)
3545                          - stack_pointer_delta);
3546 #endif
3547
3548   args_size.constant = MAX (args_size.constant,
3549                             reg_parm_stack_space);
3550
3551 #ifndef OUTGOING_REG_PARM_STACK_SPACE
3552   args_size.constant -= reg_parm_stack_space;
3553 #endif
3554
3555   if (args_size.constant > current_function_outgoing_args_size)
3556     current_function_outgoing_args_size = args_size.constant;
3557
3558   if (ACCUMULATE_OUTGOING_ARGS)
3559     {
3560       /* Since the stack pointer will never be pushed, it is possible for
3561          the evaluation of a parm to clobber something we have already
3562          written to the stack.  Since most function calls on RISC machines
3563          do not use the stack, this is uncommon, but must work correctly.
3564
3565          Therefore, we save any area of the stack that was already written
3566          and that we are using.  Here we set up to do this by making a new
3567          stack usage map from the old one.
3568
3569          Another approach might be to try to reorder the argument
3570          evaluations to avoid this conflicting stack usage.  */
3571
3572       needed = args_size.constant;
3573
3574 #ifndef OUTGOING_REG_PARM_STACK_SPACE
3575       /* Since we will be writing into the entire argument area, the
3576          map must be allocated for its entire size, not just the part that
3577          is the responsibility of the caller.  */
3578       needed += reg_parm_stack_space;
3579 #endif
3580
3581 #ifdef ARGS_GROW_DOWNWARD
3582       highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
3583                                          needed + 1);
3584 #else
3585       highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
3586                                          needed);
3587 #endif
3588       stack_usage_map = (char *) alloca (highest_outgoing_arg_in_use);
3589
3590       if (initial_highest_arg_in_use)
3591         bcopy (initial_stack_usage_map, stack_usage_map,
3592                initial_highest_arg_in_use);
3593
3594       if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
3595         bzero (&stack_usage_map[initial_highest_arg_in_use],
3596                highest_outgoing_arg_in_use - initial_highest_arg_in_use);
3597       needed = 0;
3598
3599       /* The address of the outgoing argument list must not be copied to a
3600          register here, because argblock would be left pointing to the
3601          wrong place after the call to allocate_dynamic_stack_space below.
3602          */
3603
3604       argblock = virtual_outgoing_args_rtx;
3605     }
3606   else
3607     {
3608       if (!PUSH_ARGS)
3609         argblock = push_block (GEN_INT (args_size.constant), 0, 0);
3610     }
3611
3612 #ifdef PREFERRED_STACK_BOUNDARY
3613   /* If we push args individually in reverse order, perform stack alignment
3614      before the first push (the last arg).  */
3615   if (argblock == 0 && PUSH_ARGS_REVERSED)
3616     anti_adjust_stack (GEN_INT (args_size.constant
3617                                 - original_args_size.constant));
3618 #endif
3619
3620   if (PUSH_ARGS_REVERSED)
3621     {
3622       inc = -1;
3623       argnum = nargs - 1;
3624     }
3625   else
3626     {
3627       inc = 1;
3628       argnum = 0;
3629     }
3630
3631 #ifdef REG_PARM_STACK_SPACE
3632   if (ACCUMULATE_OUTGOING_ARGS)
3633     {
3634       /* The argument list is the property of the called routine and it
3635          may clobber it.  If the fixed area has been used for previous
3636          parameters, we must save and restore it.
3637
3638          Here we compute the boundary of the that needs to be saved, if any.  */
3639
3640 #ifdef ARGS_GROW_DOWNWARD
3641       for (count = 0; count < reg_parm_stack_space + 1; count++)
3642 #else
3643       for (count = 0; count < reg_parm_stack_space; count++)
3644 #endif
3645         {
3646           if (count >=  highest_outgoing_arg_in_use
3647               || stack_usage_map[count] == 0)
3648             continue;
3649
3650           if (low_to_save == -1)
3651             low_to_save = count;
3652
3653           high_to_save = count;
3654         }
3655
3656       if (low_to_save >= 0)
3657         {
3658           int num_to_save = high_to_save - low_to_save + 1;
3659           enum machine_mode save_mode
3660             = mode_for_size (num_to_save * BITS_PER_UNIT, MODE_INT, 1);
3661           rtx stack_area;
3662
3663           /* If we don't have the required alignment, must do this in BLKmode.  */
3664           if ((low_to_save & (MIN (GET_MODE_SIZE (save_mode),
3665                                    BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1)))
3666             save_mode = BLKmode;
3667
3668 #ifdef ARGS_GROW_DOWNWARD
3669           stack_area = gen_rtx_MEM (save_mode,
3670                                     memory_address (save_mode,
3671                                                     plus_constant (argblock,
3672                                                                    - high_to_save)));
3673 #else
3674           stack_area = gen_rtx_MEM (save_mode,
3675                                     memory_address (save_mode,
3676                                                     plus_constant (argblock,
3677                                                                    low_to_save)));
3678 #endif
3679           if (save_mode == BLKmode)
3680             {
3681               save_area = assign_stack_temp (BLKmode, num_to_save, 0);
3682               emit_block_move (validize_mem (save_area), stack_area,
3683                                GEN_INT (num_to_save), PARM_BOUNDARY);
3684             }
3685           else
3686             {
3687               save_area = gen_reg_rtx (save_mode);
3688               emit_move_insn (save_area, stack_area);
3689             }
3690         }
3691     }
3692 #endif
3693
3694   /* Push the args that need to be pushed.  */
3695
3696   /* ARGNUM indexes the ARGVEC array in the order in which the arguments
3697      are to be pushed.  */
3698   for (count = 0; count < nargs; count++, argnum += inc)
3699     {
3700       register enum machine_mode mode = argvec[argnum].mode;
3701       register rtx val = argvec[argnum].value;
3702       rtx reg = argvec[argnum].reg;
3703       int partial = argvec[argnum].partial;
3704       int lower_bound = 0, upper_bound = 0, i;
3705
3706       if (! (reg != 0 && partial == 0))
3707         {
3708           if (ACCUMULATE_OUTGOING_ARGS)
3709             {
3710               /* If this is being stored into a pre-allocated, fixed-size,
3711                  stack area, save any previous data at that location.  */
3712
3713 #ifdef ARGS_GROW_DOWNWARD
3714               /* stack_slot is negative, but we want to index stack_usage_map
3715                  with positive values.  */
3716               upper_bound = -argvec[argnum].offset.constant + 1;
3717               lower_bound = upper_bound - argvec[argnum].size.constant;
3718 #else
3719               lower_bound = argvec[argnum].offset.constant;
3720               upper_bound = lower_bound + argvec[argnum].size.constant;
3721 #endif
3722
3723               for (i = lower_bound; i < upper_bound; i++)
3724                 if (stack_usage_map[i]
3725                     /* Don't store things in the fixed argument area at this
3726                        point; it has already been saved.  */
3727                     && i > reg_parm_stack_space)
3728                   break;
3729
3730               if (i != upper_bound)
3731                 {
3732                   /* We need to make a save area.  See what mode we can make
3733                      it. */
3734                   enum machine_mode save_mode
3735                     = mode_for_size (argvec[argnum].size.constant
3736                                      * BITS_PER_UNIT,
3737                                      MODE_INT, 1);
3738                   rtx stack_area
3739                     = gen_rtx_MEM
3740                       (save_mode,
3741                        memory_address
3742                        (save_mode,
3743                         plus_constant (argblock,
3744                                        argvec[argnum].offset.constant)));
3745                   argvec[argnum].save_area = gen_reg_rtx (save_mode);
3746
3747                   emit_move_insn (argvec[argnum].save_area, stack_area);
3748                 }
3749             }
3750
3751           emit_push_insn (val, mode, NULL_TREE, NULL_RTX, 0, partial, reg, 0,
3752                           argblock, GEN_INT (argvec[argnum].offset.constant),
3753                           reg_parm_stack_space, ARGS_SIZE_RTX (alignment_pad));
3754
3755           /* Now mark the segment we just used.  */
3756           if (ACCUMULATE_OUTGOING_ARGS)
3757             for (i = lower_bound; i < upper_bound; i++)
3758               stack_usage_map[i] = 1;
3759
3760           NO_DEFER_POP;
3761         }
3762     }
3763
3764 #ifdef PREFERRED_STACK_BOUNDARY
3765   /* If we pushed args in forward order, perform stack alignment
3766      after pushing the last arg.  */
3767   if (argblock == 0 && !PUSH_ARGS_REVERSED)
3768     anti_adjust_stack (GEN_INT (args_size.constant
3769                                 - original_args_size.constant));
3770 #endif
3771
3772   if (PUSH_ARGS_REVERSED)
3773     argnum = nargs - 1;
3774   else
3775     argnum = 0;
3776
3777   fun = prepare_call_address (fun, NULL_TREE, &call_fusage, 0);
3778
3779   /* Now load any reg parms into their regs.  */
3780
3781   /* ARGNUM indexes the ARGVEC array in the order in which the arguments
3782      are to be pushed.  */
3783   for (count = 0; count < nargs; count++, argnum += inc)
3784     {
3785       register rtx val = argvec[argnum].value;
3786       rtx reg = argvec[argnum].reg;
3787       int partial = argvec[argnum].partial;
3788
3789       /* Handle calls that pass values in multiple non-contiguous
3790          locations.  The PA64 has examples of this for library calls.  */
3791       if (reg != 0 && GET_CODE (reg) == PARALLEL)
3792         emit_group_load (reg, val,
3793                          GET_MODE_SIZE (GET_MODE (val)),
3794                          GET_MODE_ALIGNMENT (GET_MODE (val)));
3795       else if (reg != 0 && partial == 0)
3796         emit_move_insn (reg, val);
3797
3798       NO_DEFER_POP;
3799     }
3800
3801   /* Any regs containing parms remain in use through the call.  */
3802   for (count = 0; count < nargs; count++)
3803     {
3804       rtx reg = argvec[count].reg;
3805       if (reg != 0 && GET_CODE (reg) == PARALLEL)
3806         use_group_regs (&call_fusage, reg);
3807       else if (reg != 0)
3808         use_reg (&call_fusage, reg);
3809     }
3810
3811   /* Pass the function the address in which to return a structure value.  */
3812   if (mem_value != 0 && struct_value_rtx != 0 && ! pcc_struct_value)
3813     {
3814       emit_move_insn (struct_value_rtx,
3815                       force_reg (Pmode,
3816                                  force_operand (XEXP (mem_value, 0),
3817                                                 NULL_RTX)));
3818       if (GET_CODE (struct_value_rtx) == REG)
3819           use_reg (&call_fusage, struct_value_rtx);
3820     }
3821
3822   /* Don't allow popping to be deferred, since then
3823      cse'ing of library calls could delete a call and leave the pop.  */
3824   NO_DEFER_POP;
3825   valreg = (mem_value == 0 && outmode != VOIDmode
3826             ? hard_libcall_value (outmode) : NULL_RTX);
3827
3828 #ifdef PREFERRED_STACK_BOUNDARY
3829   /* Stack must be properly aligned now.  */
3830   if (stack_pointer_delta & (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1))
3831     abort();
3832 #endif
3833
3834   /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
3835      will set inhibit_defer_pop to that value.  */
3836   /* The return type is needed to decide how many bytes the function pops.
3837      Signedness plays no role in that, so for simplicity, we pretend it's
3838      always signed.  We also assume that the list of arguments passed has
3839      no impact, so we pretend it is unknown.  */
3840
3841   emit_call_1 (fun,
3842                get_identifier (XSTR (orgfun, 0)),
3843                build_function_type (outmode == VOIDmode ? void_type_node
3844                                     : type_for_mode (outmode, 0), NULL_TREE),
3845                original_args_size.constant, args_size.constant,
3846                struct_value_size,
3847                FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
3848                valreg,
3849                old_inhibit_defer_pop + 1, call_fusage, flags);
3850
3851   /* Now restore inhibit_defer_pop to its actual original value.  */
3852   OK_DEFER_POP;
3853
3854   /* If call is cse'able, make appropriate pair of reg-notes around it.
3855      Test valreg so we don't crash; may safely ignore `const'
3856      if return type is void.  Disable for PARALLEL return values, because
3857      we have no way to move such values into a pseudo register.  */
3858   if ((flags & (ECF_CONST | ECF_PURE))
3859       && valreg != 0 && GET_CODE (valreg) != PARALLEL)
3860     {
3861       rtx note = 0;
3862       rtx temp = gen_reg_rtx (GET_MODE (valreg));
3863       rtx insns;
3864       int i;
3865
3866       /* Construct an "equal form" for the value which mentions all the
3867          arguments in order as well as the function name.  */
3868       for (i = 0; i < nargs; i++)
3869         note = gen_rtx_EXPR_LIST (VOIDmode, argvec[i].value, note);
3870       note = gen_rtx_EXPR_LIST (VOIDmode, fun, note);
3871
3872       insns = get_insns ();
3873       end_sequence ();
3874
3875       if (flags & ECF_PURE)
3876         note = gen_rtx_EXPR_LIST (VOIDmode,
3877            gen_rtx_USE (VOIDmode,
3878                         gen_rtx_MEM (BLKmode,
3879                                      gen_rtx_SCRATCH (VOIDmode))), note);
3880
3881       emit_libcall_block (insns, temp, valreg, note);
3882
3883       valreg = temp;
3884     }
3885   else if (flags & (ECF_CONST | ECF_PURE))
3886     {
3887       /* Otherwise, just write out the sequence without a note.  */
3888       rtx insns = get_insns ();
3889
3890       end_sequence ();
3891       emit_insns (insns);
3892     }
3893   pop_temp_slots ();
3894
3895   /* Copy the value to the right place.  */
3896   if (outmode != VOIDmode && retval)
3897     {
3898       if (mem_value)
3899         {
3900           if (value == 0)
3901             value = mem_value;
3902           if (value != mem_value)
3903             emit_move_insn (value, mem_value);
3904         }
3905       else if (value != 0)
3906         emit_move_insn (value, hard_libcall_value (outmode));
3907       else
3908         value = hard_libcall_value (outmode);
3909     }
3910
3911   if (ACCUMULATE_OUTGOING_ARGS)
3912     {
3913 #ifdef REG_PARM_STACK_SPACE
3914       if (save_area)
3915         {
3916           enum machine_mode save_mode = GET_MODE (save_area);
3917 #ifdef ARGS_GROW_DOWNWARD
3918           rtx stack_area
3919             = gen_rtx_MEM (save_mode,
3920                            memory_address (save_mode,
3921                                            plus_constant (argblock,
3922                                                           - high_to_save)));
3923 #else
3924           rtx stack_area
3925             = gen_rtx_MEM (save_mode,
3926                            memory_address (save_mode,
3927                                            plus_constant (argblock, low_to_save)));
3928 #endif
3929           if (save_mode != BLKmode)
3930             emit_move_insn (stack_area, save_area);
3931           else
3932             emit_block_move (stack_area, validize_mem (save_area),
3933                              GEN_INT (high_to_save - low_to_save + 1),
3934                              PARM_BOUNDARY);
3935         }
3936 #endif
3937
3938       /* If we saved any argument areas, restore them.  */
3939       for (count = 0; count < nargs; count++)
3940         if (argvec[count].save_area)
3941           {
3942             enum machine_mode save_mode = GET_MODE (argvec[count].save_area);
3943             rtx stack_area
3944               = gen_rtx_MEM (save_mode,
3945                              memory_address
3946                              (save_mode,
3947                               plus_constant (argblock,
3948                                              argvec[count].offset.constant)));
3949
3950             emit_move_insn (stack_area, argvec[count].save_area);
3951           }
3952
3953       highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3954       stack_usage_map = initial_stack_usage_map;
3955     }
3956
3957   return value;
3958
3959 }
3960 \f
3961 /* Output a library call to function FUN (a SYMBOL_REF rtx)
3962    (emitting the queue unless NO_QUEUE is nonzero),
3963    for a value of mode OUTMODE,
3964    with NARGS different arguments, passed as alternating rtx values
3965    and machine_modes to convert them to.
3966    The rtx values should have been passed through protect_from_queue already.
3967
3968    FN_TYPE will is zero for `normal' calls, one for `const' calls, wich
3969    which will be enclosed in REG_LIBCALL/REG_RETVAL notes and two for `pure'
3970    calls, that are handled like `const' calls with extra
3971    (use (memory (scratch)).  */
3972
3973 void
3974 emit_library_call VPARAMS((rtx orgfun, int fn_type, enum machine_mode outmode,
3975                            int nargs, ...))
3976 {
3977 #ifndef ANSI_PROTOTYPES
3978   rtx orgfun;
3979   int fn_type;
3980   enum machine_mode outmode;
3981   int nargs;
3982 #endif
3983   va_list p;
3984
3985   VA_START (p, nargs);
3986
3987 #ifndef ANSI_PROTOTYPES
3988   orgfun = va_arg (p, rtx);
3989   fn_type = va_arg (p, int);
3990   outmode = va_arg (p, enum machine_mode);
3991   nargs = va_arg (p, int);
3992 #endif
3993
3994   emit_library_call_value_1 (0, orgfun, NULL_RTX, fn_type, outmode, nargs, p);
3995
3996   va_end (p);
3997 }
3998 \f
3999 /* Like emit_library_call except that an extra argument, VALUE,
4000    comes second and says where to store the result.
4001    (If VALUE is zero, this function chooses a convenient way
4002    to return the value.
4003
4004    This function returns an rtx for where the value is to be found.
4005    If VALUE is nonzero, VALUE is returned.  */
4006
4007 rtx
4008 emit_library_call_value VPARAMS((rtx orgfun, rtx value, int fn_type,
4009                                  enum machine_mode outmode, int nargs, ...))
4010 {
4011 #ifndef ANSI_PROTOTYPES
4012   rtx orgfun;
4013   rtx value;
4014   int fn_type;
4015   enum machine_mode outmode;
4016   int nargs;
4017 #endif
4018   va_list p;
4019
4020   VA_START (p, nargs);
4021
4022 #ifndef ANSI_PROTOTYPES
4023   orgfun = va_arg (p, rtx);
4024   value = va_arg (p, rtx);
4025   fn_type = va_arg (p, int);
4026   outmode = va_arg (p, enum machine_mode);
4027   nargs = va_arg (p, int);
4028 #endif
4029
4030   value = emit_library_call_value_1 (1, orgfun, value, fn_type, outmode, nargs, p);
4031
4032   va_end (p);
4033
4034   return value;
4035 }
4036 \f
4037 #if 0
4038 /* Return an rtx which represents a suitable home on the stack
4039    given TYPE, the type of the argument looking for a home.
4040    This is called only for BLKmode arguments.
4041
4042    SIZE is the size needed for this target.
4043    ARGS_ADDR is the address of the bottom of the argument block for this call.
4044    OFFSET describes this parameter's offset into ARGS_ADDR.  It is meaningless
4045    if this machine uses push insns.  */
4046
4047 static rtx
4048 target_for_arg (type, size, args_addr, offset)
4049      tree type;
4050      rtx size;
4051      rtx args_addr;
4052      struct args_size offset;
4053 {
4054   rtx target;
4055   rtx offset_rtx = ARGS_SIZE_RTX (offset);
4056
4057   /* We do not call memory_address if possible,
4058      because we want to address as close to the stack
4059      as possible.  For non-variable sized arguments,
4060      this will be stack-pointer relative addressing.  */
4061   if (GET_CODE (offset_rtx) == CONST_INT)
4062     target = plus_constant (args_addr, INTVAL (offset_rtx));
4063   else
4064     {
4065       /* I have no idea how to guarantee that this
4066          will work in the presence of register parameters.  */
4067       target = gen_rtx_PLUS (Pmode, args_addr, offset_rtx);
4068       target = memory_address (QImode, target);
4069     }
4070
4071   return gen_rtx_MEM (BLKmode, target);
4072 }
4073 #endif
4074 \f
4075 /* Store a single argument for a function call
4076    into the register or memory area where it must be passed.
4077    *ARG describes the argument value and where to pass it.
4078
4079    ARGBLOCK is the address of the stack-block for all the arguments,
4080    or 0 on a machine where arguments are pushed individually.
4081
4082    MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
4083    so must be careful about how the stack is used.
4084
4085    VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
4086    argument stack.  This is used if ACCUMULATE_OUTGOING_ARGS to indicate
4087    that we need not worry about saving and restoring the stack.
4088
4089    FNDECL is the declaration of the function we are calling.  */
4090
4091 static void
4092 store_one_arg (arg, argblock, flags, variable_size,
4093                reg_parm_stack_space)
4094      struct arg_data *arg;
4095      rtx argblock;
4096      int flags;
4097      int variable_size ATTRIBUTE_UNUSED;
4098      int reg_parm_stack_space;
4099 {
4100   register tree pval = arg->tree_value;
4101   rtx reg = 0;
4102   int partial = 0;
4103   int used = 0;
4104   int i, lower_bound = 0, upper_bound = 0;
4105
4106   if (TREE_CODE (pval) == ERROR_MARK)
4107     return;
4108
4109   /* Push a new temporary level for any temporaries we make for
4110      this argument.  */
4111   push_temp_slots ();
4112
4113   if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL))
4114     {
4115       /* If this is being stored into a pre-allocated, fixed-size, stack area,
4116          save any previous data at that location.  */
4117       if (argblock && ! variable_size && arg->stack)
4118         {
4119 #ifdef ARGS_GROW_DOWNWARD
4120           /* stack_slot is negative, but we want to index stack_usage_map
4121              with positive values.  */
4122           if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
4123             upper_bound = -INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1)) + 1;
4124           else
4125             upper_bound = 0;
4126
4127           lower_bound = upper_bound - arg->size.constant;
4128 #else
4129           if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
4130             lower_bound = INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1));
4131           else
4132             lower_bound = 0;
4133
4134           upper_bound = lower_bound + arg->size.constant;
4135 #endif
4136
4137           for (i = lower_bound; i < upper_bound; i++)
4138             if (stack_usage_map[i]
4139                 /* Don't store things in the fixed argument area at this point;
4140                    it has already been saved.  */
4141                 && i > reg_parm_stack_space)
4142               break;
4143
4144           if (i != upper_bound)
4145             {
4146               /* We need to make a save area.  See what mode we can make it.  */
4147               enum machine_mode save_mode
4148                 = mode_for_size (arg->size.constant * BITS_PER_UNIT, MODE_INT, 1);
4149               rtx stack_area
4150                 = gen_rtx_MEM (save_mode,
4151                                memory_address (save_mode,
4152                                                XEXP (arg->stack_slot, 0)));
4153
4154               if (save_mode == BLKmode)
4155                 {
4156                   arg->save_area = assign_stack_temp (BLKmode,
4157                                                       arg->size.constant, 0);
4158                   MEM_SET_IN_STRUCT_P (arg->save_area,
4159                                        AGGREGATE_TYPE_P (TREE_TYPE
4160                                                          (arg->tree_value)));
4161                   preserve_temp_slots (arg->save_area);
4162                   emit_block_move (validize_mem (arg->save_area), stack_area,
4163                                    GEN_INT (arg->size.constant),
4164                                    PARM_BOUNDARY);
4165                 }
4166               else
4167                 {
4168                   arg->save_area = gen_reg_rtx (save_mode);
4169                   emit_move_insn (arg->save_area, stack_area);
4170                 }
4171             }
4172         }
4173       /* Now that we have saved any slots that will be overwritten by this
4174          store, mark all slots this store will use.  We must do this before
4175          we actually expand the argument since the expansion itself may
4176          trigger library calls which might need to use the same stack slot.  */
4177       if (argblock && ! variable_size && arg->stack)
4178         for (i = lower_bound; i < upper_bound; i++)
4179           stack_usage_map[i] = 1;
4180     }
4181
4182   /* If this isn't going to be placed on both the stack and in registers,
4183      set up the register and number of words.  */
4184   if (! arg->pass_on_stack)
4185     reg = arg->reg, partial = arg->partial;
4186
4187   if (reg != 0 && partial == 0)
4188     /* Being passed entirely in a register.  We shouldn't be called in
4189        this case.   */
4190     abort ();
4191
4192   /* If this arg needs special alignment, don't load the registers
4193      here.  */
4194   if (arg->n_aligned_regs != 0)
4195     reg = 0;
4196
4197   /* If this is being passed partially in a register, we can't evaluate
4198      it directly into its stack slot.  Otherwise, we can.  */
4199   if (arg->value == 0)
4200     {
4201       /* stack_arg_under_construction is nonzero if a function argument is
4202          being evaluated directly into the outgoing argument list and
4203          expand_call must take special action to preserve the argument list
4204          if it is called recursively.
4205
4206          For scalar function arguments stack_usage_map is sufficient to
4207          determine which stack slots must be saved and restored.  Scalar
4208          arguments in general have pass_on_stack == 0.
4209
4210          If this argument is initialized by a function which takes the
4211          address of the argument (a C++ constructor or a C function
4212          returning a BLKmode structure), then stack_usage_map is
4213          insufficient and expand_call must push the stack around the
4214          function call.  Such arguments have pass_on_stack == 1.
4215
4216          Note that it is always safe to set stack_arg_under_construction,
4217          but this generates suboptimal code if set when not needed.  */
4218
4219       if (arg->pass_on_stack)
4220         stack_arg_under_construction++;
4221
4222       arg->value = expand_expr (pval,
4223                                 (partial
4224                                  || TYPE_MODE (TREE_TYPE (pval)) != arg->mode)
4225                                 ? NULL_RTX : arg->stack,
4226                                 VOIDmode, 0);
4227
4228       /* If we are promoting object (or for any other reason) the mode
4229          doesn't agree, convert the mode.  */
4230
4231       if (arg->mode != TYPE_MODE (TREE_TYPE (pval)))
4232         arg->value = convert_modes (arg->mode, TYPE_MODE (TREE_TYPE (pval)),
4233                                     arg->value, arg->unsignedp);
4234
4235       if (arg->pass_on_stack)
4236         stack_arg_under_construction--;
4237     }
4238
4239   /* Don't allow anything left on stack from computation
4240      of argument to alloca.  */
4241   if (flags & ECF_MAY_BE_ALLOCA)
4242     do_pending_stack_adjust ();
4243
4244   if (arg->value == arg->stack)
4245     {
4246       /* If the value is already in the stack slot, we are done.  */
4247       if (current_function_check_memory_usage && GET_CODE (arg->stack) == MEM)
4248         {
4249           emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
4250                              XEXP (arg->stack, 0), Pmode,
4251                              ARGS_SIZE_RTX (arg->size),
4252                              TYPE_MODE (sizetype),
4253                              GEN_INT (MEMORY_USE_RW),
4254                              TYPE_MODE (integer_type_node));
4255         }
4256     }
4257   else if (arg->mode != BLKmode)
4258     {
4259       register int size;
4260
4261       /* Argument is a scalar, not entirely passed in registers.
4262          (If part is passed in registers, arg->partial says how much
4263          and emit_push_insn will take care of putting it there.)
4264
4265          Push it, and if its size is less than the
4266          amount of space allocated to it,
4267          also bump stack pointer by the additional space.
4268          Note that in C the default argument promotions
4269          will prevent such mismatches.  */
4270
4271       size = GET_MODE_SIZE (arg->mode);
4272       /* Compute how much space the push instruction will push.
4273          On many machines, pushing a byte will advance the stack
4274          pointer by a halfword.  */
4275 #ifdef PUSH_ROUNDING
4276       size = PUSH_ROUNDING (size);
4277 #endif
4278       used = size;
4279
4280       /* Compute how much space the argument should get:
4281          round up to a multiple of the alignment for arguments.  */
4282       if (none != FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)))
4283         used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1)
4284                  / (PARM_BOUNDARY / BITS_PER_UNIT))
4285                 * (PARM_BOUNDARY / BITS_PER_UNIT));
4286
4287       /* This isn't already where we want it on the stack, so put it there.
4288          This can either be done with push or copy insns.  */
4289       emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX, 0,
4290                       partial, reg, used - size, argblock,
4291                       ARGS_SIZE_RTX (arg->offset), reg_parm_stack_space,
4292                       ARGS_SIZE_RTX (arg->alignment_pad));
4293     }
4294   else
4295     {
4296       /* BLKmode, at least partly to be pushed.  */
4297
4298       register int excess;
4299       rtx size_rtx;
4300
4301       /* Pushing a nonscalar.
4302          If part is passed in registers, PARTIAL says how much
4303          and emit_push_insn will take care of putting it there.  */
4304
4305       /* Round its size up to a multiple
4306          of the allocation unit for arguments.  */
4307
4308       if (arg->size.var != 0)
4309         {
4310           excess = 0;
4311           size_rtx = ARGS_SIZE_RTX (arg->size);
4312         }
4313       else
4314         {
4315           /* PUSH_ROUNDING has no effect on us, because
4316              emit_push_insn for BLKmode is careful to avoid it.  */
4317           excess = (arg->size.constant - int_size_in_bytes (TREE_TYPE (pval))
4318                     + partial * UNITS_PER_WORD);
4319           size_rtx = expr_size (pval);
4320         }
4321
4322       emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
4323                       TYPE_ALIGN (TREE_TYPE (pval)), partial, reg, excess,
4324                       argblock, ARGS_SIZE_RTX (arg->offset),
4325                       reg_parm_stack_space,
4326                       ARGS_SIZE_RTX (arg->alignment_pad));
4327     }
4328
4329
4330   /* Unless this is a partially-in-register argument, the argument is now
4331      in the stack.
4332
4333      ??? Note that this can change arg->value from arg->stack to
4334      arg->stack_slot and it matters when they are not the same.
4335      It isn't totally clear that this is correct in all cases.  */
4336   if (partial == 0)
4337     arg->value = arg->stack_slot;
4338
4339   /* Once we have pushed something, pops can't safely
4340      be deferred during the rest of the arguments.  */
4341   NO_DEFER_POP;
4342
4343   /* ANSI doesn't require a sequence point here,
4344      but PCC has one, so this will avoid some problems.  */
4345   emit_queue ();
4346
4347   /* Free any temporary slots made in processing this argument.  Show
4348      that we might have taken the address of something and pushed that
4349      as an operand.  */
4350   preserve_temp_slots (NULL_RTX);
4351   free_temp_slots ();
4352   pop_temp_slots ();
4353 }