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