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