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