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 && GET_CODE (target) == MEM)
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   function_call_count++;
2492
2493   /* We want to make two insn chains; one for a sibling call, the other
2494      for a normal call.  We will select one of the two chains after
2495      initial RTL generation is complete.  */
2496   for (pass = try_tail_call ? 0 : 1; pass < 2; pass++)
2497     {
2498       int sibcall_failure = 0;
2499       /* We want to emit any pending stack adjustments before the tail
2500          recursion "call".  That way we know any adjustment after the tail
2501          recursion call can be ignored if we indeed use the tail
2502          call expansion.  */
2503       int save_pending_stack_adjust = 0;
2504       int save_stack_pointer_delta = 0;
2505       rtx insns;
2506       rtx before_call, next_arg_reg;
2507
2508       if (pass == 0)
2509         {
2510           /* Emit any queued insns now; otherwise they would end up in
2511              only one of the alternates.  */
2512           emit_queue ();
2513
2514           /* State variables we need to save and restore between
2515              iterations.  */
2516           save_pending_stack_adjust = pending_stack_adjust;
2517           save_stack_pointer_delta = stack_pointer_delta;
2518         }
2519       if (pass)
2520         flags &= ~ECF_SIBCALL;
2521       else
2522         flags |= ECF_SIBCALL;
2523
2524       /* Other state variables that we must reinitialize each time
2525          through the loop (that are not initialized by the loop itself).  */
2526       argblock = 0;
2527       call_fusage = 0;
2528
2529       /* Start a new sequence for the normal call case.
2530
2531          From this point on, if the sibling call fails, we want to set
2532          sibcall_failure instead of continuing the loop.  */
2533       start_sequence ();
2534
2535       if (pass == 0)
2536         {
2537           /* We know at this point that there are not currently any
2538              pending cleanups.  If, however, in the process of evaluating
2539              the arguments we were to create some, we'll need to be
2540              able to get rid of them.  */
2541           expand_start_target_temps ();
2542         }
2543
2544       /* Don't let pending stack adjusts add up to too much.
2545          Also, do all pending adjustments now if there is any chance
2546          this might be a call to alloca or if we are expanding a sibling
2547          call sequence or if we are calling a function that is to return
2548          with stack pointer depressed.  */
2549       if (pending_stack_adjust >= 32
2550           || (pending_stack_adjust > 0
2551               && (flags & (ECF_MAY_BE_ALLOCA | ECF_SP_DEPRESSED)))
2552           || pass == 0)
2553         do_pending_stack_adjust ();
2554
2555       /* When calling a const function, we must pop the stack args right away,
2556          so that the pop is deleted or moved with the call.  */
2557       if (pass && (flags & ECF_LIBCALL_BLOCK))
2558         NO_DEFER_POP;
2559
2560       /* Precompute any arguments as needed.  */
2561       if (pass)
2562         precompute_arguments (flags, num_actuals, args);
2563
2564       /* Now we are about to start emitting insns that can be deleted
2565          if a libcall is deleted.  */
2566       if (pass && (flags & (ECF_LIBCALL_BLOCK | ECF_MALLOC)))
2567         start_sequence ();
2568
2569       adjusted_args_size = args_size;
2570       /* Compute the actual size of the argument block required.  The variable
2571          and constant sizes must be combined, the size may have to be rounded,
2572          and there may be a minimum required size.  When generating a sibcall
2573          pattern, do not round up, since we'll be re-using whatever space our
2574          caller provided.  */
2575       unadjusted_args_size
2576         = compute_argument_block_size (reg_parm_stack_space,
2577                                        &adjusted_args_size,
2578                                        (pass == 0 ? 0
2579                                         : preferred_stack_boundary));
2580
2581       old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
2582
2583       /* The argument block when performing a sibling call is the
2584          incoming argument block.  */
2585       if (pass == 0)
2586         {
2587           argblock = virtual_incoming_args_rtx;
2588           argblock
2589 #ifdef STACK_GROWS_DOWNWARD
2590             = plus_constant (argblock, current_function_pretend_args_size);
2591 #else
2592             = plus_constant (argblock, -current_function_pretend_args_size);
2593 #endif
2594           stored_args_map = sbitmap_alloc (args_size.constant);
2595           sbitmap_zero (stored_args_map);
2596         }
2597
2598       /* If we have no actual push instructions, or shouldn't use them,
2599          make space for all args right now.  */
2600       else if (adjusted_args_size.var != 0)
2601         {
2602           if (old_stack_level == 0)
2603             {
2604               emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
2605               old_stack_pointer_delta = stack_pointer_delta;
2606               old_pending_adj = pending_stack_adjust;
2607               pending_stack_adjust = 0;
2608               /* stack_arg_under_construction says whether a stack arg is
2609                  being constructed at the old stack level.  Pushing the stack
2610                  gets a clean outgoing argument block.  */
2611               old_stack_arg_under_construction = stack_arg_under_construction;
2612               stack_arg_under_construction = 0;
2613             }
2614           argblock = push_block (ARGS_SIZE_RTX (adjusted_args_size), 0, 0);
2615         }
2616       else
2617         {
2618           /* Note that we must go through the motions of allocating an argument
2619              block even if the size is zero because we may be storing args
2620              in the area reserved for register arguments, which may be part of
2621              the stack frame.  */
2622
2623           int needed = adjusted_args_size.constant;
2624
2625           /* Store the maximum argument space used.  It will be pushed by
2626              the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
2627              checking).  */
2628
2629           if (needed > current_function_outgoing_args_size)
2630             current_function_outgoing_args_size = needed;
2631
2632           if (must_preallocate)
2633             {
2634               if (ACCUMULATE_OUTGOING_ARGS)
2635                 {
2636                   /* Since the stack pointer will never be pushed, it is
2637                      possible for the evaluation of a parm to clobber
2638                      something we have already written to the stack.
2639                      Since most function calls on RISC machines do not use
2640                      the stack, this is uncommon, but must work correctly.
2641
2642                      Therefore, we save any area of the stack that was already
2643                      written and that we are using.  Here we set up to do this
2644                      by making a new stack usage map from the old one.  The
2645                      actual save will be done by store_one_arg.
2646
2647                      Another approach might be to try to reorder the argument
2648                      evaluations to avoid this conflicting stack usage.  */
2649
2650 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2651                   /* Since we will be writing into the entire argument area,
2652                      the map must be allocated for its entire size, not just
2653                      the part that is the responsibility of the caller.  */
2654                   needed += reg_parm_stack_space;
2655 #endif
2656
2657 #ifdef ARGS_GROW_DOWNWARD
2658                   highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
2659                                                      needed + 1);
2660 #else
2661                   highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
2662                                                      needed);
2663 #endif
2664                   stack_usage_map = alloca (highest_outgoing_arg_in_use);
2665
2666                   if (initial_highest_arg_in_use)
2667                     memcpy (stack_usage_map, initial_stack_usage_map,
2668                             initial_highest_arg_in_use);
2669
2670                   if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
2671                     memset (&stack_usage_map[initial_highest_arg_in_use], 0,
2672                            (highest_outgoing_arg_in_use
2673                             - initial_highest_arg_in_use));
2674                   needed = 0;
2675
2676                   /* The address of the outgoing argument list must not be
2677                      copied to a register here, because argblock would be left
2678                      pointing to the wrong place after the call to
2679                      allocate_dynamic_stack_space below.  */
2680
2681                   argblock = virtual_outgoing_args_rtx;
2682                 }
2683               else
2684                 {
2685                   if (inhibit_defer_pop == 0)
2686                     {
2687                       /* Try to reuse some or all of the pending_stack_adjust
2688                          to get this space.  */
2689                       needed
2690                         = (combine_pending_stack_adjustment_and_call
2691                            (unadjusted_args_size,
2692                             &adjusted_args_size,
2693                             preferred_unit_stack_boundary));
2694
2695                       /* combine_pending_stack_adjustment_and_call computes
2696                          an adjustment before the arguments are allocated.
2697                          Account for them and see whether or not the stack
2698                          needs to go up or down.  */
2699                       needed = unadjusted_args_size - needed;
2700
2701                       if (needed < 0)
2702                         {
2703                           /* We're releasing stack space.  */
2704                           /* ??? We can avoid any adjustment at all if we're
2705                              already aligned.  FIXME.  */
2706                           pending_stack_adjust = -needed;
2707                           do_pending_stack_adjust ();
2708                           needed = 0;
2709                         }
2710                       else
2711                         /* We need to allocate space.  We'll do that in
2712                            push_block below.  */
2713                         pending_stack_adjust = 0;
2714                     }
2715
2716                   /* Special case this because overhead of `push_block' in
2717                      this case is non-trivial.  */
2718                   if (needed == 0)
2719                     argblock = virtual_outgoing_args_rtx;
2720                   else
2721                     {
2722                       argblock = push_block (GEN_INT (needed), 0, 0);
2723 #ifdef ARGS_GROW_DOWNWARD
2724                       argblock = plus_constant (argblock, needed);
2725 #endif
2726                     }
2727
2728                   /* We only really need to call `copy_to_reg' in the case
2729                      where push insns are going to be used to pass ARGBLOCK
2730                      to a function call in ARGS.  In that case, the stack
2731                      pointer changes value from the allocation point to the
2732                      call point, and hence the value of
2733                      VIRTUAL_OUTGOING_ARGS_RTX changes as well.  But might
2734                      as well always do it.  */
2735                   argblock = copy_to_reg (argblock);
2736                 }
2737             }
2738         }
2739
2740       if (ACCUMULATE_OUTGOING_ARGS)
2741         {
2742           /* The save/restore code in store_one_arg handles all
2743              cases except one: a constructor call (including a C
2744              function returning a BLKmode struct) to initialize
2745              an argument.  */
2746           if (stack_arg_under_construction)
2747             {
2748 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2749               rtx push_size = GEN_INT (reg_parm_stack_space
2750                                        + adjusted_args_size.constant);
2751 #else
2752               rtx push_size = GEN_INT (adjusted_args_size.constant);
2753 #endif
2754               if (old_stack_level == 0)
2755                 {
2756                   emit_stack_save (SAVE_BLOCK, &old_stack_level,
2757                                    NULL_RTX);
2758                   old_stack_pointer_delta = stack_pointer_delta;
2759                   old_pending_adj = pending_stack_adjust;
2760                   pending_stack_adjust = 0;
2761                   /* stack_arg_under_construction says whether a stack
2762                      arg is being constructed at the old stack level.
2763                      Pushing the stack gets a clean outgoing argument
2764                      block.  */
2765                   old_stack_arg_under_construction
2766                     = stack_arg_under_construction;
2767                   stack_arg_under_construction = 0;
2768                   /* Make a new map for the new argument list.  */
2769                   stack_usage_map = alloca (highest_outgoing_arg_in_use);
2770                   memset (stack_usage_map, 0, highest_outgoing_arg_in_use);
2771                   highest_outgoing_arg_in_use = 0;
2772                 }
2773               allocate_dynamic_stack_space (push_size, NULL_RTX,
2774                                             BITS_PER_UNIT);
2775             }
2776
2777           /* If argument evaluation might modify the stack pointer,
2778              copy the address of the argument list to a register.  */
2779           for (i = 0; i < num_actuals; i++)
2780             if (args[i].pass_on_stack)
2781               {
2782                 argblock = copy_addr_to_reg (argblock);
2783                 break;
2784               }
2785         }
2786
2787       compute_argument_addresses (args, argblock, num_actuals);
2788
2789       /* If we push args individually in reverse order, perform stack alignment
2790          before the first push (the last arg).  */
2791       if (PUSH_ARGS_REVERSED && argblock == 0
2792           && adjusted_args_size.constant != unadjusted_args_size)
2793         {
2794           /* When the stack adjustment is pending, we get better code
2795              by combining the adjustments.  */
2796           if (pending_stack_adjust
2797               && ! (flags & ECF_LIBCALL_BLOCK)
2798               && ! inhibit_defer_pop)
2799             {
2800               pending_stack_adjust
2801                 = (combine_pending_stack_adjustment_and_call
2802                    (unadjusted_args_size,
2803                     &adjusted_args_size,
2804                     preferred_unit_stack_boundary));
2805               do_pending_stack_adjust ();
2806             }
2807           else if (argblock == 0)
2808             anti_adjust_stack (GEN_INT (adjusted_args_size.constant
2809                                         - unadjusted_args_size));
2810         }
2811       /* Now that the stack is properly aligned, pops can't safely
2812          be deferred during the evaluation of the arguments.  */
2813       NO_DEFER_POP;
2814
2815       funexp = rtx_for_function_call (fndecl, addr);
2816
2817       /* Figure out the register where the value, if any, will come back.  */
2818       valreg = 0;
2819       if (TYPE_MODE (TREE_TYPE (exp)) != VOIDmode
2820           && ! structure_value_addr)
2821         {
2822           if (pcc_struct_value)
2823             valreg = hard_function_value (build_pointer_type (TREE_TYPE (exp)),
2824                                           fndecl, (pass == 0));
2825           else
2826             valreg = hard_function_value (TREE_TYPE (exp), fndecl, (pass == 0));
2827         }
2828
2829       /* Precompute all register parameters.  It isn't safe to compute anything
2830          once we have started filling any specific hard regs.  */
2831       precompute_register_parameters (num_actuals, args, &reg_parm_seen);
2832
2833       if (TREE_OPERAND (exp, 2))
2834         static_chain_value = expand_expr (TREE_OPERAND (exp, 2),
2835                                           NULL_RTX, VOIDmode, 0);
2836       else
2837         static_chain_value = 0;
2838
2839 #ifdef REG_PARM_STACK_SPACE
2840       /* Save the fixed argument area if it's part of the caller's frame and
2841          is clobbered by argument setup for this call.  */
2842       if (ACCUMULATE_OUTGOING_ARGS && pass)
2843         save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
2844                                               &low_to_save, &high_to_save);
2845 #endif
2846
2847       /* Now store (and compute if necessary) all non-register parms.
2848          These come before register parms, since they can require block-moves,
2849          which could clobber the registers used for register parms.
2850          Parms which have partial registers are not stored here,
2851          but we do preallocate space here if they want that.  */
2852
2853       for (i = 0; i < num_actuals; i++)
2854         if (args[i].reg == 0 || args[i].pass_on_stack)
2855           {
2856             rtx before_arg = get_last_insn ();
2857
2858             if (store_one_arg (&args[i], argblock, flags,
2859                                adjusted_args_size.var != 0,
2860                                reg_parm_stack_space)
2861                 || (pass == 0
2862                     && check_sibcall_argument_overlap (before_arg,
2863                                                        &args[i], 1)))
2864               sibcall_failure = 1;
2865
2866             if (flags & ECF_CONST
2867                 && args[i].stack
2868                 && args[i].value == args[i].stack)
2869               call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
2870                                                gen_rtx_USE (VOIDmode,
2871                                                             args[i].value),
2872                                                call_fusage);
2873           }
2874
2875       /* If we have a parm that is passed in registers but not in memory
2876          and whose alignment does not permit a direct copy into registers,
2877          make a group of pseudos that correspond to each register that we
2878          will later fill.  */
2879       if (STRICT_ALIGNMENT)
2880         store_unaligned_arguments_into_pseudos (args, num_actuals);
2881
2882       /* Now store any partially-in-registers parm.
2883          This is the last place a block-move can happen.  */
2884       if (reg_parm_seen)
2885         for (i = 0; i < num_actuals; i++)
2886           if (args[i].partial != 0 && ! args[i].pass_on_stack)
2887             {
2888               rtx before_arg = get_last_insn ();
2889
2890               if (store_one_arg (&args[i], argblock, flags,
2891                                  adjusted_args_size.var != 0,
2892                                  reg_parm_stack_space)
2893                   || (pass == 0
2894                       && check_sibcall_argument_overlap (before_arg,
2895                                                          &args[i], 1)))
2896                 sibcall_failure = 1;
2897             }
2898
2899       /* If we pushed args in forward order, perform stack alignment
2900          after pushing the last arg.  */
2901       if (!PUSH_ARGS_REVERSED && argblock == 0)
2902         anti_adjust_stack (GEN_INT (adjusted_args_size.constant
2903                                     - unadjusted_args_size));
2904
2905       /* If register arguments require space on the stack and stack space
2906          was not preallocated, allocate stack space here for arguments
2907          passed in registers.  */
2908 #ifdef OUTGOING_REG_PARM_STACK_SPACE
2909       if (!ACCUMULATE_OUTGOING_ARGS
2910           && must_preallocate == 0 && reg_parm_stack_space > 0)
2911         anti_adjust_stack (GEN_INT (reg_parm_stack_space));
2912 #endif
2913
2914       /* Pass the function the address in which to return a
2915          structure value.  */
2916       if (pass != 0 && structure_value_addr && ! structure_value_addr_parm)
2917         {
2918           structure_value_addr
2919             = convert_memory_address (Pmode, structure_value_addr);
2920           emit_move_insn (struct_value,
2921                           force_reg (Pmode,
2922                                      force_operand (structure_value_addr,
2923                                                     NULL_RTX)));
2924
2925           if (REG_P (struct_value))
2926             use_reg (&call_fusage, struct_value);
2927         }
2928
2929       funexp = prepare_call_address (funexp, static_chain_value,
2930                                      &call_fusage, reg_parm_seen, pass == 0);
2931
2932       load_register_parameters (args, num_actuals, &call_fusage, flags,
2933                                 pass == 0, &sibcall_failure);
2934
2935       /* Perform postincrements before actually calling the function.  */
2936       emit_queue ();
2937
2938       /* Save a pointer to the last insn before the call, so that we can
2939          later safely search backwards to find the CALL_INSN.  */
2940       before_call = get_last_insn ();
2941
2942       /* Set up next argument register.  For sibling calls on machines
2943          with register windows this should be the incoming register.  */
2944 #ifdef FUNCTION_INCOMING_ARG
2945       if (pass == 0)
2946         next_arg_reg = FUNCTION_INCOMING_ARG (args_so_far, VOIDmode,
2947                                               void_type_node, 1);
2948       else
2949 #endif
2950         next_arg_reg = FUNCTION_ARG (args_so_far, VOIDmode,
2951                                      void_type_node, 1);
2952
2953       /* All arguments and registers used for the call must be set up by
2954          now!  */
2955
2956       /* Stack must be properly aligned now.  */
2957       if (pass && stack_pointer_delta % preferred_unit_stack_boundary)
2958         abort ();
2959
2960       /* Generate the actual call instruction.  */
2961       emit_call_1 (funexp, exp, fndecl, funtype, unadjusted_args_size,
2962                    adjusted_args_size.constant, struct_value_size,
2963                    next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
2964                    flags, & args_so_far);
2965
2966       /* If call is cse'able, make appropriate pair of reg-notes around it.
2967          Test valreg so we don't crash; may safely ignore `const'
2968          if return type is void.  Disable for PARALLEL return values, because
2969          we have no way to move such values into a pseudo register.  */
2970       if (pass && (flags & ECF_LIBCALL_BLOCK))
2971         {
2972           rtx insns;
2973           rtx insn;
2974           bool failed = valreg == 0 || GET_CODE (valreg) == PARALLEL;
2975
2976           insns = get_insns ();
2977
2978           /* Expansion of block moves possibly introduced a loop that may
2979              not appear inside libcall block.  */
2980           for (insn = insns; insn; insn = NEXT_INSN (insn))
2981             if (GET_CODE (insn) == JUMP_INSN)
2982               failed = true;
2983
2984           if (failed)
2985             {
2986               end_sequence ();
2987               emit_insn (insns);
2988             }
2989           else
2990             {
2991               rtx note = 0;
2992               rtx temp = gen_reg_rtx (GET_MODE (valreg));
2993
2994               /* Mark the return value as a pointer if needed.  */
2995               if (TREE_CODE (TREE_TYPE (exp)) == POINTER_TYPE)
2996                 mark_reg_pointer (temp,
2997                                   TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp))));
2998
2999               end_sequence ();
3000               if (flag_unsafe_math_optimizations
3001                   && fndecl
3002                   && DECL_BUILT_IN (fndecl)
3003                   && (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_SQRT
3004                       || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_SQRTF
3005                       || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_SQRTL))
3006                 note = gen_rtx_fmt_e (SQRT,
3007                                       GET_MODE (temp),
3008                                       args[0].initial_value);
3009               else
3010                 {
3011                   /* Construct an "equal form" for the value which
3012                      mentions all the arguments in order as well as
3013                      the function name.  */
3014                   for (i = 0; i < num_actuals; i++)
3015                     note = gen_rtx_EXPR_LIST (VOIDmode,
3016                                               args[i].initial_value, note);
3017                   note = gen_rtx_EXPR_LIST (VOIDmode, funexp, note);
3018
3019                   if (flags & ECF_PURE)
3020                     note = gen_rtx_EXPR_LIST (VOIDmode,
3021                         gen_rtx_USE (VOIDmode,
3022                                      gen_rtx_MEM (BLKmode,
3023                                                   gen_rtx_SCRATCH (VOIDmode))),
3024                         note);
3025                 }
3026               emit_libcall_block (insns, temp, valreg, note);
3027
3028               valreg = temp;
3029             }
3030         }
3031       else if (pass && (flags & ECF_MALLOC))
3032         {
3033           rtx temp = gen_reg_rtx (GET_MODE (valreg));
3034           rtx last, insns;
3035
3036           /* The return value from a malloc-like function is a pointer.  */
3037           if (TREE_CODE (TREE_TYPE (exp)) == POINTER_TYPE)
3038             mark_reg_pointer (temp, BIGGEST_ALIGNMENT);
3039
3040           emit_move_insn (temp, valreg);
3041
3042           /* The return value from a malloc-like function can not alias
3043              anything else.  */
3044           last = get_last_insn ();
3045           REG_NOTES (last) =
3046             gen_rtx_EXPR_LIST (REG_NOALIAS, temp, REG_NOTES (last));
3047
3048           /* Write out the sequence.  */
3049           insns = get_insns ();
3050           end_sequence ();
3051           emit_insn (insns);
3052           valreg = temp;
3053         }
3054
3055       /* For calls to `setjmp', etc., inform flow.c it should complain
3056          if nonvolatile values are live.  For functions that cannot return,
3057          inform flow that control does not fall through.  */
3058
3059       if ((flags & (ECF_NORETURN | ECF_LONGJMP)) || pass == 0)
3060         {
3061           /* The barrier must be emitted
3062              immediately after the CALL_INSN.  Some ports emit more
3063              than just a CALL_INSN above, so we must search for it here.  */
3064
3065           rtx last = get_last_insn ();
3066           while (GET_CODE (last) != CALL_INSN)
3067             {
3068               last = PREV_INSN (last);
3069               /* There was no CALL_INSN?  */
3070               if (last == before_call)
3071                 abort ();
3072             }
3073
3074           emit_barrier_after (last);
3075
3076           /* Stack adjustments after a noreturn call are dead code.
3077              However when NO_DEFER_POP is in effect, we must preserve
3078              stack_pointer_delta.  */
3079           if (inhibit_defer_pop == 0)
3080             {
3081               stack_pointer_delta = old_stack_allocated;
3082               pending_stack_adjust = 0;
3083             }
3084         }
3085
3086       if (flags & ECF_LONGJMP)
3087         current_function_calls_longjmp = 1;
3088
3089       /* If value type not void, return an rtx for the value.  */
3090
3091       /* If there are cleanups to be called, don't use a hard reg as target.
3092          We need to double check this and see if it matters anymore.  */
3093       if (any_pending_cleanups ())
3094         {
3095           if (target && REG_P (target)
3096               && REGNO (target) < FIRST_PSEUDO_REGISTER)
3097             target = 0;
3098           sibcall_failure = 1;
3099         }
3100
3101       if (TYPE_MODE (TREE_TYPE (exp)) == VOIDmode
3102           || ignore)
3103         target = const0_rtx;
3104       else if (structure_value_addr)
3105         {
3106           if (target == 0 || GET_CODE (target) != MEM)
3107             {
3108               target
3109                 = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
3110                                memory_address (TYPE_MODE (TREE_TYPE (exp)),
3111                                                structure_value_addr));
3112               set_mem_attributes (target, exp, 1);
3113             }
3114         }
3115       else if (pcc_struct_value)
3116         {
3117           /* This is the special C++ case where we need to
3118              know what the true target was.  We take care to
3119              never use this value more than once in one expression.  */
3120           target = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
3121                                 copy_to_reg (valreg));
3122           set_mem_attributes (target, exp, 1);
3123         }
3124       /* Handle calls that return values in multiple non-contiguous locations.
3125          The Irix 6 ABI has examples of this.  */
3126       else if (GET_CODE (valreg) == PARALLEL)
3127         {
3128           if (target == 0)
3129             {
3130               /* This will only be assigned once, so it can be readonly.  */
3131               tree nt = build_qualified_type (TREE_TYPE (exp),
3132                                               (TYPE_QUALS (TREE_TYPE (exp))
3133                                                | TYPE_QUAL_CONST));
3134
3135               target = assign_temp (nt, 0, 1, 1);
3136               preserve_temp_slots (target);
3137             }
3138
3139           if (! rtx_equal_p (target, valreg))
3140             emit_group_store (target, valreg, TREE_TYPE (exp),
3141                               int_size_in_bytes (TREE_TYPE (exp)));
3142
3143           /* We can not support sibling calls for this case.  */
3144           sibcall_failure = 1;
3145         }
3146       else if (target
3147                && GET_MODE (target) == TYPE_MODE (TREE_TYPE (exp))
3148                && GET_MODE (target) == GET_MODE (valreg))
3149         {
3150           /* TARGET and VALREG cannot be equal at this point because the
3151              latter would not have REG_FUNCTION_VALUE_P true, while the
3152              former would if it were referring to the same register.
3153
3154              If they refer to the same register, this move will be a no-op,
3155              except when function inlining is being done.  */
3156           emit_move_insn (target, valreg);
3157
3158           /* If we are setting a MEM, this code must be executed.  Since it is
3159              emitted after the call insn, sibcall optimization cannot be
3160              performed in that case.  */
3161           if (GET_CODE (target) == MEM)
3162             sibcall_failure = 1;
3163         }
3164       else if (TYPE_MODE (TREE_TYPE (exp)) == BLKmode)
3165         {
3166           target = copy_blkmode_from_reg (target, valreg, TREE_TYPE (exp));
3167
3168           /* We can not support sibling calls for this case.  */
3169           sibcall_failure = 1;
3170         }
3171       else
3172         {
3173           if (shift_returned_value (TREE_TYPE (exp), &valreg))
3174             sibcall_failure = 1;
3175
3176           target = copy_to_reg (valreg);
3177         }
3178
3179       if (targetm.calls.promote_function_return(funtype))
3180         {
3181       /* If we promoted this return value, make the proper SUBREG.  TARGET
3182          might be const0_rtx here, so be careful.  */
3183       if (REG_P (target)
3184           && TYPE_MODE (TREE_TYPE (exp)) != BLKmode
3185           && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
3186         {
3187           tree type = TREE_TYPE (exp);
3188           int unsignedp = TYPE_UNSIGNED (type);
3189           int offset = 0;
3190
3191           /* If we don't promote as expected, something is wrong.  */
3192           if (GET_MODE (target)
3193               != promote_mode (type, TYPE_MODE (type), &unsignedp, 1))
3194             abort ();
3195
3196         if ((WORDS_BIG_ENDIAN || BYTES_BIG_ENDIAN)
3197             && GET_MODE_SIZE (GET_MODE (target))
3198                > GET_MODE_SIZE (TYPE_MODE (type)))
3199           {
3200             offset = GET_MODE_SIZE (GET_MODE (target))
3201                      - GET_MODE_SIZE (TYPE_MODE (type));
3202             if (! BYTES_BIG_ENDIAN)
3203               offset = (offset / UNITS_PER_WORD) * UNITS_PER_WORD;
3204             else if (! WORDS_BIG_ENDIAN)
3205               offset %= UNITS_PER_WORD;
3206           }
3207           target = gen_rtx_SUBREG (TYPE_MODE (type), target, offset);
3208           SUBREG_PROMOTED_VAR_P (target) = 1;
3209           SUBREG_PROMOTED_UNSIGNED_SET (target, unsignedp);
3210         }
3211         }
3212
3213       /* If size of args is variable or this was a constructor call for a stack
3214          argument, restore saved stack-pointer value.  */
3215
3216       if (old_stack_level && ! (flags & ECF_SP_DEPRESSED))
3217         {
3218           emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
3219           stack_pointer_delta = old_stack_pointer_delta;
3220           pending_stack_adjust = old_pending_adj;
3221           stack_arg_under_construction = old_stack_arg_under_construction;
3222           highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3223           stack_usage_map = initial_stack_usage_map;
3224           sibcall_failure = 1;
3225         }
3226       else if (ACCUMULATE_OUTGOING_ARGS && pass)
3227         {
3228 #ifdef REG_PARM_STACK_SPACE
3229           if (save_area)
3230             restore_fixed_argument_area (save_area, argblock,
3231                                          high_to_save, low_to_save);
3232 #endif
3233
3234           /* If we saved any argument areas, restore them.  */
3235           for (i = 0; i < num_actuals; i++)
3236             if (args[i].save_area)
3237               {
3238                 enum machine_mode save_mode = GET_MODE (args[i].save_area);
3239                 rtx stack_area
3240                   = gen_rtx_MEM (save_mode,
3241                                  memory_address (save_mode,
3242                                                  XEXP (args[i].stack_slot, 0)));
3243
3244                 if (save_mode != BLKmode)
3245                   emit_move_insn (stack_area, args[i].save_area);
3246                 else
3247                   emit_block_move (stack_area, args[i].save_area,
3248                                    GEN_INT (args[i].locate.size.constant),
3249                                    BLOCK_OP_CALL_PARM);
3250               }
3251
3252           highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3253           stack_usage_map = initial_stack_usage_map;
3254         }
3255
3256       /* If this was alloca, record the new stack level for nonlocal gotos.
3257          Check for the handler slots since we might not have a save area
3258          for non-local gotos.  */
3259
3260       if ((flags & ECF_MAY_BE_ALLOCA) && cfun->nonlocal_goto_save_area != 0)
3261         update_nonlocal_goto_save_area ();
3262
3263       /* Free up storage we no longer need.  */
3264       for (i = 0; i < num_actuals; ++i)
3265         if (args[i].aligned_regs)
3266           free (args[i].aligned_regs);
3267
3268       if (pass == 0)
3269         {
3270           /* Undo the fake expand_start_target_temps we did earlier.  If
3271              there had been any cleanups created, we've already set
3272              sibcall_failure.  */
3273           expand_end_target_temps ();
3274         }
3275
3276       /* If this function is returning into a memory location marked as
3277          readonly, it means it is initializing that location. We normally treat
3278          functions as not clobbering such locations, so we need to specify that
3279          this one does. We do this by adding the appropriate CLOBBER to the
3280          CALL_INSN function usage list.  This cannot be done by emitting a
3281          standalone CLOBBER after the call because the latter would be ignored
3282          by at least the delay slot scheduling pass. We do this now instead of
3283          adding to call_fusage before the call to emit_call_1 because TARGET
3284          may be modified in the meantime.  */
3285       if (structure_value_addr != 0 && target != 0
3286           && GET_CODE (target) == MEM && RTX_UNCHANGING_P (target))
3287         add_function_usage_to
3288           (last_call_insn (),
3289            gen_rtx_EXPR_LIST (VOIDmode, gen_rtx_CLOBBER (VOIDmode, target),
3290                               NULL_RTX));
3291
3292       insns = get_insns ();
3293       end_sequence ();
3294
3295       if (pass == 0)
3296         {
3297           tail_call_insns = insns;
3298
3299           /* Restore the pending stack adjustment now that we have
3300              finished generating the sibling call sequence.  */
3301
3302           pending_stack_adjust = save_pending_stack_adjust;
3303           stack_pointer_delta = save_stack_pointer_delta;
3304
3305           /* Prepare arg structure for next iteration.  */
3306           for (i = 0; i < num_actuals; i++)
3307             {
3308               args[i].value = 0;
3309               args[i].aligned_regs = 0;
3310               args[i].stack = 0;
3311             }
3312
3313           sbitmap_free (stored_args_map);
3314         }
3315       else
3316         {
3317           normal_call_insns = insns;
3318
3319           /* Verify that we've deallocated all the stack we used.  */
3320           if (! (flags & (ECF_NORETURN | ECF_LONGJMP))
3321               && old_stack_allocated != stack_pointer_delta
3322                                         - pending_stack_adjust)
3323             abort ();
3324         }
3325
3326       /* If something prevents making this a sibling call,
3327          zero out the sequence.  */
3328       if (sibcall_failure)
3329         tail_call_insns = NULL_RTX;
3330       else
3331         break;
3332     }
3333
3334   /* If tail call production succeeded, we need to remove REG_EQUIV notes on
3335      arguments too, as argument area is now clobbered by the call.  */
3336   if (tail_call_insns)
3337     {
3338       emit_insn (tail_call_insns);
3339       cfun->tail_call_emit = true;
3340     }
3341   else
3342     emit_insn (normal_call_insns);
3343
3344   currently_expanding_call--;
3345
3346   /* If this function returns with the stack pointer depressed, ensure
3347      this block saves and restores the stack pointer, show it was
3348      changed, and adjust for any outgoing arg space.  */
3349   if (flags & ECF_SP_DEPRESSED)
3350     {
3351       clear_pending_stack_adjust ();
3352       emit_insn (gen_rtx_CLOBBER (VOIDmode, stack_pointer_rtx));
3353       emit_move_insn (virtual_stack_dynamic_rtx, stack_pointer_rtx);
3354       save_stack_pointer ();
3355     }
3356
3357   return target;
3358 }
3359
3360 /* A sibling call sequence invalidates any REG_EQUIV notes made for
3361    this function's incoming arguments.
3362
3363    At the start of RTL generation we know the only REG_EQUIV notes
3364    in the rtl chain are those for incoming arguments, so we can safely
3365    flush any REG_EQUIV note.
3366
3367    This is (slight) overkill.  We could keep track of the highest
3368    argument we clobber and be more selective in removing notes, but it
3369    does not seem to be worth the effort.  */
3370 void
3371 fixup_tail_calls (void)
3372 {
3373   rtx insn;
3374   tree arg;
3375
3376   purge_reg_equiv_notes ();
3377
3378   /* A sibling call sequence also may invalidate RTX_UNCHANGING_P
3379      flag of some incoming arguments MEM RTLs, because it can write into
3380      those slots.  We clear all those bits now.
3381
3382      This is (slight) overkill, we could keep track of which arguments
3383      we actually write into.  */
3384   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3385     {
3386       if (INSN_P (insn))
3387         purge_mem_unchanging_flag (PATTERN (insn));
3388     }
3389
3390   /* Similarly, invalidate RTX_UNCHANGING_P for any incoming
3391      arguments passed in registers.  */
3392   for (arg = DECL_ARGUMENTS (current_function_decl);
3393        arg;
3394        arg = TREE_CHAIN (arg))
3395     {
3396       if (REG_P (DECL_RTL (arg)))
3397         RTX_UNCHANGING_P (DECL_RTL (arg)) = false;
3398     }
3399 }
3400
3401 /* Traverse an argument list in VALUES and expand all complex
3402    arguments into their components.  */
3403 tree
3404 split_complex_values (tree values)
3405 {
3406   tree p;
3407
3408   /* Before allocating memory, check for the common case of no complex.  */
3409   for (p = values; p; p = TREE_CHAIN (p))
3410     {
3411       tree type = TREE_TYPE (TREE_VALUE (p));
3412       if (type && TREE_CODE (type) == COMPLEX_TYPE
3413           && targetm.calls.split_complex_arg (type))
3414         goto found;
3415     }
3416   return values;
3417
3418  found:
3419   values = copy_list (values);
3420
3421   for (p = values; p; p = TREE_CHAIN (p))
3422     {
3423       tree complex_value = TREE_VALUE (p);
3424       tree complex_type;
3425
3426       complex_type = TREE_TYPE (complex_value);
3427       if (!complex_type)
3428         continue;
3429
3430       if (TREE_CODE (complex_type) == COMPLEX_TYPE
3431           && targetm.calls.split_complex_arg (complex_type))
3432         {
3433           tree subtype;
3434           tree real, imag, next;
3435
3436           subtype = TREE_TYPE (complex_type);
3437           complex_value = save_expr (complex_value);
3438           real = build1 (REALPART_EXPR, subtype, complex_value);
3439           imag = build1 (IMAGPART_EXPR, subtype, complex_value);
3440
3441           TREE_VALUE (p) = real;
3442           next = TREE_CHAIN (p);
3443           imag = build_tree_list (NULL_TREE, imag);
3444           TREE_CHAIN (p) = imag;
3445           TREE_CHAIN (imag) = next;
3446
3447           /* Skip the newly created node.  */
3448           p = TREE_CHAIN (p);
3449         }
3450     }
3451
3452   return values;
3453 }
3454
3455 /* Traverse a list of TYPES and expand all complex types into their
3456    components.  */
3457 tree
3458 split_complex_types (tree types)
3459 {
3460   tree p;
3461
3462   /* Before allocating memory, check for the common case of no complex.  */
3463   for (p = types; p; p = TREE_CHAIN (p))
3464     {
3465       tree type = TREE_VALUE (p);
3466       if (TREE_CODE (type) == COMPLEX_TYPE
3467           && targetm.calls.split_complex_arg (type))
3468         goto found;
3469     }
3470   return types;
3471
3472  found:
3473   types = copy_list (types);
3474
3475   for (p = types; p; p = TREE_CHAIN (p))
3476     {
3477       tree complex_type = TREE_VALUE (p);
3478
3479       if (TREE_CODE (complex_type) == COMPLEX_TYPE
3480           && targetm.calls.split_complex_arg (complex_type))
3481         {
3482           tree next, imag;
3483
3484           /* Rewrite complex type with component type.  */
3485           TREE_VALUE (p) = TREE_TYPE (complex_type);
3486           next = TREE_CHAIN (p);
3487
3488           /* Add another component type for the imaginary part.  */
3489           imag = build_tree_list (NULL_TREE, TREE_VALUE (p));
3490           TREE_CHAIN (p) = imag;
3491           TREE_CHAIN (imag) = next;
3492
3493           /* Skip the newly created node.  */
3494           p = TREE_CHAIN (p);
3495         }
3496     }
3497
3498   return types;
3499 }
3500 \f
3501 /* Output a library call to function FUN (a SYMBOL_REF rtx).
3502    The RETVAL parameter specifies whether return value needs to be saved, other
3503    parameters are documented in the emit_library_call function below.  */
3504
3505 static rtx
3506 emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
3507                            enum libcall_type fn_type,
3508                            enum machine_mode outmode, int nargs, va_list p)
3509 {
3510   /* Total size in bytes of all the stack-parms scanned so far.  */
3511   struct args_size args_size;
3512   /* Size of arguments before any adjustments (such as rounding).  */
3513   struct args_size original_args_size;
3514   int argnum;
3515   rtx fun;
3516   int inc;
3517   int count;
3518   rtx argblock = 0;
3519   CUMULATIVE_ARGS args_so_far;
3520   struct arg
3521   {
3522     rtx value;
3523     enum machine_mode mode;
3524     rtx reg;
3525     int partial;
3526     struct locate_and_pad_arg_data locate;
3527     rtx save_area;
3528   };
3529   struct arg *argvec;
3530   int old_inhibit_defer_pop = inhibit_defer_pop;
3531   rtx call_fusage = 0;
3532   rtx mem_value = 0;
3533   rtx valreg;
3534   int pcc_struct_value = 0;
3535   int struct_value_size = 0;
3536   int flags;
3537   int reg_parm_stack_space = 0;
3538   int needed;
3539   rtx before_call;
3540   tree tfom;                    /* type_for_mode (outmode, 0) */
3541
3542 #ifdef REG_PARM_STACK_SPACE
3543   /* Define the boundary of the register parm stack space that needs to be
3544      save, if any.  */
3545   int low_to_save, high_to_save;
3546   rtx save_area = 0;            /* Place that it is saved.  */
3547 #endif
3548
3549   /* Size of the stack reserved for parameter registers.  */
3550   int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
3551   char *initial_stack_usage_map = stack_usage_map;
3552
3553   rtx struct_value = targetm.calls.struct_value_rtx (0, 0);
3554
3555 #ifdef REG_PARM_STACK_SPACE
3556   reg_parm_stack_space = REG_PARM_STACK_SPACE ((tree) 0);
3557 #endif
3558
3559   /* By default, library functions can not throw.  */
3560   flags = ECF_NOTHROW;
3561
3562   switch (fn_type)
3563     {
3564     case LCT_NORMAL:
3565       break;
3566     case LCT_CONST:
3567       flags |= ECF_CONST;
3568       break;
3569     case LCT_PURE:
3570       flags |= ECF_PURE;
3571       break;
3572     case LCT_CONST_MAKE_BLOCK:
3573       flags |= ECF_CONST | ECF_LIBCALL_BLOCK;
3574       break;
3575     case LCT_PURE_MAKE_BLOCK:
3576       flags |= ECF_PURE | ECF_LIBCALL_BLOCK;
3577       break;
3578     case LCT_NORETURN:
3579       flags |= ECF_NORETURN;
3580       break;
3581     case LCT_THROW:
3582       flags = ECF_NORETURN;
3583       break;
3584     case LCT_ALWAYS_RETURN:
3585       flags = ECF_ALWAYS_RETURN;
3586       break;
3587     case LCT_RETURNS_TWICE:
3588       flags = ECF_RETURNS_TWICE;
3589       break;
3590     }
3591   fun = orgfun;
3592
3593   /* Ensure current function's preferred stack boundary is at least
3594      what we need.  */
3595   if (cfun->preferred_stack_boundary < PREFERRED_STACK_BOUNDARY)
3596     cfun->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
3597
3598   /* If this kind of value comes back in memory,
3599      decide where in memory it should come back.  */
3600   if (outmode != VOIDmode)
3601     {
3602       tfom = lang_hooks.types.type_for_mode (outmode, 0);
3603       if (aggregate_value_p (tfom, 0))
3604         {
3605 #ifdef PCC_STATIC_STRUCT_RETURN
3606           rtx pointer_reg
3607             = hard_function_value (build_pointer_type (tfom), 0, 0);
3608           mem_value = gen_rtx_MEM (outmode, pointer_reg);
3609           pcc_struct_value = 1;
3610           if (value == 0)
3611             value = gen_reg_rtx (outmode);
3612 #else /* not PCC_STATIC_STRUCT_RETURN */
3613           struct_value_size = GET_MODE_SIZE (outmode);
3614           if (value != 0 && GET_CODE (value) == MEM)
3615             mem_value = value;
3616           else
3617             mem_value = assign_temp (tfom, 0, 1, 1);
3618 #endif
3619           /* This call returns a big structure.  */
3620           flags &= ~(ECF_CONST | ECF_PURE | ECF_LIBCALL_BLOCK);
3621         }
3622     }
3623   else
3624     tfom = void_type_node;
3625
3626   /* ??? Unfinished: must pass the memory address as an argument.  */
3627
3628   /* Copy all the libcall-arguments out of the varargs data
3629      and into a vector ARGVEC.
3630
3631      Compute how to pass each argument.  We only support a very small subset
3632      of the full argument passing conventions to limit complexity here since
3633      library functions shouldn't have many args.  */
3634
3635   argvec = alloca ((nargs + 1) * sizeof (struct arg));
3636   memset (argvec, 0, (nargs + 1) * sizeof (struct arg));
3637
3638 #ifdef INIT_CUMULATIVE_LIBCALL_ARGS
3639   INIT_CUMULATIVE_LIBCALL_ARGS (args_so_far, outmode, fun);
3640 #else
3641   INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE, fun, 0, nargs);
3642 #endif
3643
3644   args_size.constant = 0;
3645   args_size.var = 0;
3646
3647   count = 0;
3648
3649   /* Now we are about to start emitting insns that can be deleted
3650      if a libcall is deleted.  */
3651   if (flags & ECF_LIBCALL_BLOCK)
3652     start_sequence ();
3653
3654   push_temp_slots ();
3655
3656   /* If there's a structure value address to be passed,
3657      either pass it in the special place, or pass it as an extra argument.  */
3658   if (mem_value && struct_value == 0 && ! pcc_struct_value)
3659     {
3660       rtx addr = XEXP (mem_value, 0);
3661       nargs++;
3662
3663       /* Make sure it is a reasonable operand for a move or push insn.  */
3664       if (!REG_P (addr) && GET_CODE (addr) != MEM
3665           && ! (CONSTANT_P (addr) && LEGITIMATE_CONSTANT_P (addr)))
3666         addr = force_operand (addr, NULL_RTX);
3667
3668       argvec[count].value = addr;
3669       argvec[count].mode = Pmode;
3670       argvec[count].partial = 0;
3671
3672       argvec[count].reg = FUNCTION_ARG (args_so_far, Pmode, NULL_TREE, 1);
3673 #ifdef FUNCTION_ARG_PARTIAL_NREGS
3674       if (FUNCTION_ARG_PARTIAL_NREGS (args_so_far, Pmode, NULL_TREE, 1))
3675         abort ();
3676 #endif
3677
3678       locate_and_pad_parm (Pmode, NULL_TREE,
3679 #ifdef STACK_PARMS_IN_REG_PARM_AREA
3680                            1,
3681 #else
3682                            argvec[count].reg != 0,
3683 #endif
3684                            0, NULL_TREE, &args_size, &argvec[count].locate);
3685
3686       if (argvec[count].reg == 0 || argvec[count].partial != 0
3687           || reg_parm_stack_space > 0)
3688         args_size.constant += argvec[count].locate.size.constant;
3689
3690       FUNCTION_ARG_ADVANCE (args_so_far, Pmode, (tree) 0, 1);
3691
3692       count++;
3693     }
3694
3695   for (; count < nargs; count++)
3696     {
3697       rtx val = va_arg (p, rtx);
3698       enum machine_mode mode = va_arg (p, enum machine_mode);
3699
3700       /* We cannot convert the arg value to the mode the library wants here;
3701          must do it earlier where we know the signedness of the arg.  */
3702       if (mode == BLKmode
3703           || (GET_MODE (val) != mode && GET_MODE (val) != VOIDmode))
3704         abort ();
3705
3706       /* There's no need to call protect_from_queue, because
3707          either emit_move_insn or emit_push_insn will do that.  */
3708
3709       /* Make sure it is a reasonable operand for a move or push insn.  */
3710       if (!REG_P (val) && GET_CODE (val) != MEM
3711           && ! (CONSTANT_P (val) && LEGITIMATE_CONSTANT_P (val)))
3712         val = force_operand (val, NULL_RTX);
3713
3714 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
3715       if (FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, mode, NULL_TREE, 1))
3716         {
3717           rtx slot;
3718           int must_copy = 1
3719 #ifdef FUNCTION_ARG_CALLEE_COPIES
3720             && ! FUNCTION_ARG_CALLEE_COPIES (args_so_far, mode,
3721                                              NULL_TREE, 1)
3722 #endif
3723             ;
3724
3725           /* loop.c won't look at CALL_INSN_FUNCTION_USAGE of const/pure
3726              functions, so we have to pretend this isn't such a function.  */
3727           if (flags & ECF_LIBCALL_BLOCK)
3728             {
3729               rtx insns = get_insns ();
3730               end_sequence ();
3731               emit_insn (insns);
3732             }
3733           flags &= ~(ECF_CONST | ECF_PURE | ECF_LIBCALL_BLOCK);
3734
3735           /* If this was a CONST function, it is now PURE since
3736              it now reads memory.  */
3737           if (flags & ECF_CONST)
3738             {
3739               flags &= ~ECF_CONST;
3740               flags |= ECF_PURE;
3741             }
3742
3743           if (GET_MODE (val) == MEM && ! must_copy)
3744             slot = val;
3745           else if (must_copy)
3746             {
3747               slot = assign_temp (lang_hooks.types.type_for_mode (mode, 0),
3748                                   0, 1, 1);
3749               emit_move_insn (slot, val);
3750             }
3751           else
3752             {
3753               tree type = lang_hooks.types.type_for_mode (mode, 0);
3754
3755               slot
3756                 = gen_rtx_MEM (mode,
3757                                expand_expr (build1 (ADDR_EXPR,
3758                                                     build_pointer_type (type),
3759                                                     make_tree (type, val)),
3760                                             NULL_RTX, VOIDmode, 0));
3761             }
3762
3763           call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
3764                                            gen_rtx_USE (VOIDmode, slot),
3765                                            call_fusage);
3766           if (must_copy)
3767             call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
3768                                              gen_rtx_CLOBBER (VOIDmode,
3769                                                               slot),
3770                                              call_fusage);
3771
3772           mode = Pmode;
3773           val = force_operand (XEXP (slot, 0), NULL_RTX);
3774         }
3775 #endif
3776
3777       argvec[count].value = val;
3778       argvec[count].mode = mode;
3779
3780       argvec[count].reg = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1);
3781
3782 #ifdef FUNCTION_ARG_PARTIAL_NREGS
3783       argvec[count].partial
3784         = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, NULL_TREE, 1);
3785 #else
3786       argvec[count].partial = 0;
3787 #endif
3788
3789       locate_and_pad_parm (mode, NULL_TREE,
3790 #ifdef STACK_PARMS_IN_REG_PARM_AREA
3791                            1,
3792 #else
3793                            argvec[count].reg != 0,
3794 #endif
3795                            argvec[count].partial,
3796                            NULL_TREE, &args_size, &argvec[count].locate);
3797
3798       if (argvec[count].locate.size.var)
3799         abort ();
3800
3801       if (argvec[count].reg == 0 || argvec[count].partial != 0
3802           || reg_parm_stack_space > 0)
3803         args_size.constant += argvec[count].locate.size.constant;
3804
3805       FUNCTION_ARG_ADVANCE (args_so_far, mode, (tree) 0, 1);
3806     }
3807
3808   /* If this machine requires an external definition for library
3809      functions, write one out.  */
3810   assemble_external_libcall (fun);
3811
3812   original_args_size = args_size;
3813   args_size.constant = (((args_size.constant
3814                           + stack_pointer_delta
3815                           + STACK_BYTES - 1)
3816                           / STACK_BYTES
3817                           * STACK_BYTES)
3818                          - stack_pointer_delta);
3819
3820   args_size.constant = MAX (args_size.constant,
3821                             reg_parm_stack_space);
3822
3823 #ifndef OUTGOING_REG_PARM_STACK_SPACE
3824   args_size.constant -= reg_parm_stack_space;
3825 #endif
3826
3827   if (args_size.constant > current_function_outgoing_args_size)
3828     current_function_outgoing_args_size = args_size.constant;
3829
3830   if (ACCUMULATE_OUTGOING_ARGS)
3831     {
3832       /* Since the stack pointer will never be pushed, it is possible for
3833          the evaluation of a parm to clobber something we have already
3834          written to the stack.  Since most function calls on RISC machines
3835          do not use the stack, this is uncommon, but must work correctly.
3836
3837          Therefore, we save any area of the stack that was already written
3838          and that we are using.  Here we set up to do this by making a new
3839          stack usage map from the old one.
3840
3841          Another approach might be to try to reorder the argument
3842          evaluations to avoid this conflicting stack usage.  */
3843
3844       needed = args_size.constant;
3845
3846 #ifndef OUTGOING_REG_PARM_STACK_SPACE
3847       /* Since we will be writing into the entire argument area, the
3848          map must be allocated for its entire size, not just the part that
3849          is the responsibility of the caller.  */
3850       needed += reg_parm_stack_space;
3851 #endif
3852
3853 #ifdef ARGS_GROW_DOWNWARD
3854       highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
3855                                          needed + 1);
3856 #else
3857       highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
3858                                          needed);
3859 #endif
3860       stack_usage_map = alloca (highest_outgoing_arg_in_use);
3861
3862       if (initial_highest_arg_in_use)
3863         memcpy (stack_usage_map, initial_stack_usage_map,
3864                 initial_highest_arg_in_use);
3865
3866       if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
3867         memset (&stack_usage_map[initial_highest_arg_in_use], 0,
3868                highest_outgoing_arg_in_use - initial_highest_arg_in_use);
3869       needed = 0;
3870
3871       /* We must be careful to use virtual regs before they're instantiated,
3872          and real regs afterwards.  Loop optimization, for example, can create
3873          new libcalls after we've instantiated the virtual regs, and if we
3874          use virtuals anyway, they won't match the rtl patterns.  */
3875
3876       if (virtuals_instantiated)
3877         argblock = plus_constant (stack_pointer_rtx, STACK_POINTER_OFFSET);
3878       else
3879         argblock = virtual_outgoing_args_rtx;
3880     }
3881   else
3882     {
3883       if (!PUSH_ARGS)
3884         argblock = push_block (GEN_INT (args_size.constant), 0, 0);
3885     }
3886
3887   /* If we push args individually in reverse order, perform stack alignment
3888      before the first push (the last arg).  */
3889   if (argblock == 0 && PUSH_ARGS_REVERSED)
3890     anti_adjust_stack (GEN_INT (args_size.constant
3891                                 - original_args_size.constant));
3892
3893   if (PUSH_ARGS_REVERSED)
3894     {
3895       inc = -1;
3896       argnum = nargs - 1;
3897     }
3898   else
3899     {
3900       inc = 1;
3901       argnum = 0;
3902     }
3903
3904 #ifdef REG_PARM_STACK_SPACE
3905   if (ACCUMULATE_OUTGOING_ARGS)
3906     {
3907       /* The argument list is the property of the called routine and it
3908          may clobber it.  If the fixed area has been used for previous
3909          parameters, we must save and restore it.  */
3910       save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
3911                                             &low_to_save, &high_to_save);
3912     }
3913 #endif
3914
3915   /* Push the args that need to be pushed.  */
3916
3917   /* ARGNUM indexes the ARGVEC array in the order in which the arguments
3918      are to be pushed.  */
3919   for (count = 0; count < nargs; count++, argnum += inc)
3920     {
3921       enum machine_mode mode = argvec[argnum].mode;
3922       rtx val = argvec[argnum].value;
3923       rtx reg = argvec[argnum].reg;
3924       int partial = argvec[argnum].partial;
3925       int lower_bound = 0, upper_bound = 0, i;
3926
3927       if (! (reg != 0 && partial == 0))
3928         {
3929           if (ACCUMULATE_OUTGOING_ARGS)
3930             {
3931               /* If this is being stored into a pre-allocated, fixed-size,
3932                  stack area, save any previous data at that location.  */
3933
3934 #ifdef ARGS_GROW_DOWNWARD
3935               /* stack_slot is negative, but we want to index stack_usage_map
3936                  with positive values.  */
3937               upper_bound = -argvec[argnum].locate.offset.constant + 1;
3938               lower_bound = upper_bound - argvec[argnum].locate.size.constant;
3939 #else
3940               lower_bound = argvec[argnum].locate.offset.constant;
3941               upper_bound = lower_bound + argvec[argnum].locate.size.constant;
3942 #endif
3943
3944               i = lower_bound;
3945               /* Don't worry about things in the fixed argument area;
3946                  it has already been saved.  */
3947               if (i < reg_parm_stack_space)
3948                 i = reg_parm_stack_space;
3949               while (i < upper_bound && stack_usage_map[i] == 0)
3950                 i++;
3951
3952               if (i < upper_bound)
3953                 {
3954                   /* We need to make a save area.  */
3955                   unsigned int size
3956                     = argvec[argnum].locate.size.constant * BITS_PER_UNIT;
3957                   enum machine_mode save_mode
3958                     = mode_for_size (size, MODE_INT, 1);
3959                   rtx adr
3960                     = plus_constant (argblock,
3961                                      argvec[argnum].locate.offset.constant);
3962                   rtx stack_area
3963                     = gen_rtx_MEM (save_mode, memory_address (save_mode, adr));
3964
3965                   if (save_mode == BLKmode)
3966                     {
3967                       argvec[argnum].save_area
3968                         = assign_stack_temp (BLKmode,
3969                                              argvec[argnum].locate.size.constant,
3970                                              0);
3971
3972                       emit_block_move (validize_mem (argvec[argnum].save_area),
3973                                        stack_area,
3974                                        GEN_INT (argvec[argnum].locate.size.constant),
3975                                        BLOCK_OP_CALL_PARM);
3976                     }
3977                   else
3978                     {
3979                       argvec[argnum].save_area = gen_reg_rtx (save_mode);
3980
3981                       emit_move_insn (argvec[argnum].save_area, stack_area);
3982                     }
3983                 }
3984             }
3985
3986           emit_push_insn (val, mode, NULL_TREE, NULL_RTX, PARM_BOUNDARY,
3987                           partial, reg, 0, argblock,
3988                           GEN_INT (argvec[argnum].locate.offset.constant),
3989                           reg_parm_stack_space,
3990                           ARGS_SIZE_RTX (argvec[argnum].locate.alignment_pad));
3991
3992           /* Now mark the segment we just used.  */
3993           if (ACCUMULATE_OUTGOING_ARGS)
3994             for (i = lower_bound; i < upper_bound; i++)
3995               stack_usage_map[i] = 1;
3996
3997           NO_DEFER_POP;
3998         }
3999     }
4000
4001   /* If we pushed args in forward order, perform stack alignment
4002      after pushing the last arg.  */
4003   if (argblock == 0 && !PUSH_ARGS_REVERSED)
4004     anti_adjust_stack (GEN_INT (args_size.constant
4005                                 - original_args_size.constant));
4006
4007   if (PUSH_ARGS_REVERSED)
4008     argnum = nargs - 1;
4009   else
4010     argnum = 0;
4011
4012   fun = prepare_call_address (fun, NULL, &call_fusage, 0, 0);
4013
4014   /* Now load any reg parms into their regs.  */
4015
4016   /* ARGNUM indexes the ARGVEC array in the order in which the arguments
4017      are to be pushed.  */
4018   for (count = 0; count < nargs; count++, argnum += inc)
4019     {
4020       rtx val = argvec[argnum].value;
4021       rtx reg = argvec[argnum].reg;
4022       int partial = argvec[argnum].partial;
4023
4024       /* Handle calls that pass values in multiple non-contiguous
4025          locations.  The PA64 has examples of this for library calls.  */
4026       if (reg != 0 && GET_CODE (reg) == PARALLEL)
4027         emit_group_load (reg, val, NULL_TREE, GET_MODE_SIZE (GET_MODE (val)));
4028       else if (reg != 0 && partial == 0)
4029         emit_move_insn (reg, val);
4030
4031       NO_DEFER_POP;
4032     }
4033
4034   /* Any regs containing parms remain in use through the call.  */
4035   for (count = 0; count < nargs; count++)
4036     {
4037       rtx reg = argvec[count].reg;
4038       if (reg != 0 && GET_CODE (reg) == PARALLEL)
4039         use_group_regs (&call_fusage, reg);
4040       else if (reg != 0)
4041         use_reg (&call_fusage, reg);
4042     }
4043
4044   /* Pass the function the address in which to return a structure value.  */
4045   if (mem_value != 0 && struct_value != 0 && ! pcc_struct_value)
4046     {
4047       emit_move_insn (struct_value,
4048                       force_reg (Pmode,
4049                                  force_operand (XEXP (mem_value, 0),
4050                                                 NULL_RTX)));
4051       if (REG_P (struct_value))
4052         use_reg (&call_fusage, struct_value);
4053     }
4054
4055   /* Don't allow popping to be deferred, since then
4056      cse'ing of library calls could delete a call and leave the pop.  */
4057   NO_DEFER_POP;
4058   valreg = (mem_value == 0 && outmode != VOIDmode
4059             ? hard_libcall_value (outmode) : NULL_RTX);
4060
4061   /* Stack must be properly aligned now.  */
4062   if (stack_pointer_delta & (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1))
4063     abort ();
4064
4065   before_call = get_last_insn ();
4066
4067   /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
4068      will set inhibit_defer_pop to that value.  */
4069   /* The return type is needed to decide how many bytes the function pops.
4070      Signedness plays no role in that, so for simplicity, we pretend it's
4071      always signed.  We also assume that the list of arguments passed has
4072      no impact, so we pretend it is unknown.  */
4073
4074   emit_call_1 (fun, NULL,
4075                get_identifier (XSTR (orgfun, 0)),
4076                build_function_type (tfom, NULL_TREE),
4077                original_args_size.constant, args_size.constant,
4078                struct_value_size,
4079                FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
4080                valreg,
4081                old_inhibit_defer_pop + 1, call_fusage, flags, & args_so_far);
4082
4083   /* For calls to `setjmp', etc., inform flow.c it should complain
4084      if nonvolatile values are live.  For functions that cannot return,
4085      inform flow that control does not fall through.  */
4086
4087   if (flags & (ECF_NORETURN | ECF_LONGJMP))
4088     {
4089       /* The barrier note must be emitted
4090          immediately after the CALL_INSN.  Some ports emit more than
4091          just a CALL_INSN above, so we must search for it here.  */
4092
4093       rtx last = get_last_insn ();
4094       while (GET_CODE (last) != CALL_INSN)
4095         {
4096           last = PREV_INSN (last);
4097           /* There was no CALL_INSN?  */
4098           if (last == before_call)
4099             abort ();
4100         }
4101
4102       emit_barrier_after (last);
4103     }
4104
4105   /* Now restore inhibit_defer_pop to its actual original value.  */
4106   OK_DEFER_POP;
4107
4108   /* If call is cse'able, make appropriate pair of reg-notes around it.
4109      Test valreg so we don't crash; may safely ignore `const'
4110      if return type is void.  Disable for PARALLEL return values, because
4111      we have no way to move such values into a pseudo register.  */
4112   if (flags & ECF_LIBCALL_BLOCK)
4113     {
4114       rtx insns;
4115
4116       if (valreg == 0)
4117         {
4118           insns = get_insns ();
4119           end_sequence ();
4120           emit_insn (insns);
4121         }
4122       else
4123         {
4124           rtx note = 0;
4125           rtx temp;
4126           int i;
4127
4128           if (GET_CODE (valreg) == PARALLEL)
4129             {
4130               temp = gen_reg_rtx (outmode);
4131               emit_group_store (temp, valreg, NULL_TREE,
4132                                 GET_MODE_SIZE (outmode));
4133               valreg = temp;
4134             }
4135
4136           temp = gen_reg_rtx (GET_MODE (valreg));
4137
4138           /* Construct an "equal form" for the value which mentions all the
4139              arguments in order as well as the function name.  */
4140           for (i = 0; i < nargs; i++)
4141             note = gen_rtx_EXPR_LIST (VOIDmode, argvec[i].value, note);
4142           note = gen_rtx_EXPR_LIST (VOIDmode, fun, note);
4143
4144           insns = get_insns ();
4145           end_sequence ();
4146
4147           if (flags & ECF_PURE)
4148             note = gen_rtx_EXPR_LIST (VOIDmode,
4149                         gen_rtx_USE (VOIDmode,
4150                                      gen_rtx_MEM (BLKmode,
4151                                                   gen_rtx_SCRATCH (VOIDmode))),
4152                         note);
4153
4154           emit_libcall_block (insns, temp, valreg, note);
4155
4156           valreg = temp;
4157         }
4158     }
4159   pop_temp_slots ();
4160
4161   /* Copy the value to the right place.  */
4162   if (outmode != VOIDmode && retval)
4163     {
4164       if (mem_value)
4165         {
4166           if (value == 0)
4167             value = mem_value;
4168           if (value != mem_value)
4169             emit_move_insn (value, mem_value);
4170         }
4171       else if (GET_CODE (valreg) == PARALLEL)
4172         {
4173           if (value == 0)
4174             value = gen_reg_rtx (outmode);
4175           emit_group_store (value, valreg, NULL_TREE, GET_MODE_SIZE (outmode));
4176         }
4177       else if (value != 0)
4178         emit_move_insn (value, valreg);
4179       else
4180         value = valreg;
4181     }
4182
4183   if (ACCUMULATE_OUTGOING_ARGS)
4184     {
4185 #ifdef REG_PARM_STACK_SPACE
4186       if (save_area)
4187         restore_fixed_argument_area (save_area, argblock,
4188                                      high_to_save, low_to_save);
4189 #endif
4190
4191       /* If we saved any argument areas, restore them.  */
4192       for (count = 0; count < nargs; count++)
4193         if (argvec[count].save_area)
4194           {
4195             enum machine_mode save_mode = GET_MODE (argvec[count].save_area);
4196             rtx adr = plus_constant (argblock,
4197                                      argvec[count].locate.offset.constant);
4198             rtx stack_area = gen_rtx_MEM (save_mode,
4199                                           memory_address (save_mode, adr));
4200
4201             if (save_mode == BLKmode)
4202               emit_block_move (stack_area,
4203                                validize_mem (argvec[count].save_area),
4204                                GEN_INT (argvec[count].locate.size.constant),
4205                                BLOCK_OP_CALL_PARM);
4206             else
4207               emit_move_insn (stack_area, argvec[count].save_area);
4208           }
4209
4210       highest_outgoing_arg_in_use = initial_highest_arg_in_use;
4211       stack_usage_map = initial_stack_usage_map;
4212     }
4213
4214   return value;
4215
4216 }
4217 \f
4218 /* Output a library call to function FUN (a SYMBOL_REF rtx)
4219    (emitting the queue unless NO_QUEUE is nonzero),
4220    for a value of mode OUTMODE,
4221    with NARGS different arguments, passed as alternating rtx values
4222    and machine_modes to convert them to.
4223    The rtx values should have been passed through protect_from_queue already.
4224
4225    FN_TYPE should be LCT_NORMAL for `normal' calls, LCT_CONST for `const'
4226    calls, LCT_PURE for `pure' calls, LCT_CONST_MAKE_BLOCK for `const' calls
4227    which should be enclosed in REG_LIBCALL/REG_RETVAL notes,
4228    LCT_PURE_MAKE_BLOCK for `purep' calls which should be enclosed in
4229    REG_LIBCALL/REG_RETVAL notes with extra (use (memory (scratch)),
4230    or other LCT_ value for other types of library calls.  */
4231
4232 void
4233 emit_library_call (rtx orgfun, enum libcall_type fn_type,
4234                    enum machine_mode outmode, int nargs, ...)
4235 {
4236   va_list p;
4237
4238   va_start (p, nargs);
4239   emit_library_call_value_1 (0, orgfun, NULL_RTX, fn_type, outmode, nargs, p);
4240   va_end (p);
4241 }
4242 \f
4243 /* Like emit_library_call except that an extra argument, VALUE,
4244    comes second and says where to store the result.
4245    (If VALUE is zero, this function chooses a convenient way
4246    to return the value.
4247
4248    This function returns an rtx for where the value is to be found.
4249    If VALUE is nonzero, VALUE is returned.  */
4250
4251 rtx
4252 emit_library_call_value (rtx orgfun, rtx value,
4253                          enum libcall_type fn_type,
4254                          enum machine_mode outmode, int nargs, ...)
4255 {
4256   rtx result;
4257   va_list p;
4258
4259   va_start (p, nargs);
4260   result = emit_library_call_value_1 (1, orgfun, value, fn_type, outmode,
4261                                       nargs, p);
4262   va_end (p);
4263
4264   return result;
4265 }
4266 \f
4267 /* Store a single argument for a function call
4268    into the register or memory area where it must be passed.
4269    *ARG describes the argument value and where to pass it.
4270
4271    ARGBLOCK is the address of the stack-block for all the arguments,
4272    or 0 on a machine where arguments are pushed individually.
4273
4274    MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
4275    so must be careful about how the stack is used.
4276
4277    VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
4278    argument stack.  This is used if ACCUMULATE_OUTGOING_ARGS to indicate
4279    that we need not worry about saving and restoring the stack.
4280
4281    FNDECL is the declaration of the function we are calling.
4282
4283    Return nonzero if this arg should cause sibcall failure,
4284    zero otherwise.  */
4285
4286 static int
4287 store_one_arg (struct arg_data *arg, rtx argblock, int flags,
4288                int variable_size ATTRIBUTE_UNUSED, int reg_parm_stack_space)
4289 {
4290   tree pval = arg->tree_value;
4291   rtx reg = 0;
4292   int partial = 0;
4293   int used = 0;
4294   int i, lower_bound = 0, upper_bound = 0;
4295   int sibcall_failure = 0;
4296
4297   if (TREE_CODE (pval) == ERROR_MARK)
4298     return 1;
4299
4300   /* Push a new temporary level for any temporaries we make for
4301      this argument.  */
4302   push_temp_slots ();
4303
4304   if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL))
4305     {
4306       /* If this is being stored into a pre-allocated, fixed-size, stack area,
4307          save any previous data at that location.  */
4308       if (argblock && ! variable_size && arg->stack)
4309         {
4310 #ifdef ARGS_GROW_DOWNWARD
4311           /* stack_slot is negative, but we want to index stack_usage_map
4312              with positive values.  */
4313           if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
4314             upper_bound = -INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1)) + 1;
4315           else
4316             upper_bound = 0;
4317
4318           lower_bound = upper_bound - arg->locate.size.constant;
4319 #else
4320           if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
4321             lower_bound = INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1));
4322           else
4323             lower_bound = 0;
4324
4325           upper_bound = lower_bound + arg->locate.size.constant;
4326 #endif
4327
4328           i = lower_bound;
4329           /* Don't worry about things in the fixed argument area;
4330              it has already been saved.  */
4331           if (i < reg_parm_stack_space)
4332             i = reg_parm_stack_space;
4333           while (i < upper_bound && stack_usage_map[i] == 0)
4334             i++;
4335
4336           if (i < upper_bound)
4337             {
4338               /* We need to make a save area.  */
4339               unsigned int size = arg->locate.size.constant * BITS_PER_UNIT;
4340               enum machine_mode save_mode = mode_for_size (size, MODE_INT, 1);
4341               rtx adr = memory_address (save_mode, XEXP (arg->stack_slot, 0));
4342               rtx stack_area = gen_rtx_MEM (save_mode, adr);
4343
4344               if (save_mode == BLKmode)
4345                 {
4346                   tree ot = TREE_TYPE (arg->tree_value);
4347                   tree nt = build_qualified_type (ot, (TYPE_QUALS (ot)
4348                                                        | TYPE_QUAL_CONST));
4349
4350                   arg->save_area = assign_temp (nt, 0, 1, 1);
4351                   preserve_temp_slots (arg->save_area);
4352                   emit_block_move (validize_mem (arg->save_area), stack_area,
4353                                    expr_size (arg->tree_value),
4354                                    BLOCK_OP_CALL_PARM);
4355                 }
4356               else
4357                 {
4358                   arg->save_area = gen_reg_rtx (save_mode);
4359                   emit_move_insn (arg->save_area, stack_area);
4360                 }
4361             }
4362         }
4363     }
4364
4365   /* If this isn't going to be placed on both the stack and in registers,
4366      set up the register and number of words.  */
4367   if (! arg->pass_on_stack)
4368     {
4369       if (flags & ECF_SIBCALL)
4370         reg = arg->tail_call_reg;
4371       else
4372         reg = arg->reg;
4373       partial = arg->partial;
4374     }
4375
4376   if (reg != 0 && partial == 0)
4377     /* Being passed entirely in a register.  We shouldn't be called in
4378        this case.  */
4379     abort ();
4380
4381   /* If this arg needs special alignment, don't load the registers
4382      here.  */
4383   if (arg->n_aligned_regs != 0)
4384     reg = 0;
4385
4386   /* If this is being passed partially in a register, we can't evaluate
4387      it directly into its stack slot.  Otherwise, we can.  */
4388   if (arg->value == 0)
4389     {
4390       /* stack_arg_under_construction is nonzero if a function argument is
4391          being evaluated directly into the outgoing argument list and
4392          expand_call must take special action to preserve the argument list
4393          if it is called recursively.
4394
4395          For scalar function arguments stack_usage_map is sufficient to
4396          determine which stack slots must be saved and restored.  Scalar
4397          arguments in general have pass_on_stack == 0.
4398
4399          If this argument is initialized by a function which takes the
4400          address of the argument (a C++ constructor or a C function
4401          returning a BLKmode structure), then stack_usage_map is
4402          insufficient and expand_call must push the stack around the
4403          function call.  Such arguments have pass_on_stack == 1.
4404
4405          Note that it is always safe to set stack_arg_under_construction,
4406          but this generates suboptimal code if set when not needed.  */
4407
4408       if (arg->pass_on_stack)
4409         stack_arg_under_construction++;
4410
4411       arg->value = expand_expr (pval,
4412                                 (partial
4413                                  || TYPE_MODE (TREE_TYPE (pval)) != arg->mode)
4414                                 ? NULL_RTX : arg->stack,
4415                                 VOIDmode, EXPAND_STACK_PARM);
4416
4417       /* If we are promoting object (or for any other reason) the mode
4418          doesn't agree, convert the mode.  */
4419
4420       if (arg->mode != TYPE_MODE (TREE_TYPE (pval)))
4421         arg->value = convert_modes (arg->mode, TYPE_MODE (TREE_TYPE (pval)),
4422                                     arg->value, arg->unsignedp);
4423
4424       if (arg->pass_on_stack)
4425         stack_arg_under_construction--;
4426     }
4427
4428   /* Don't allow anything left on stack from computation
4429      of argument to alloca.  */
4430   if (flags & ECF_MAY_BE_ALLOCA)
4431     do_pending_stack_adjust ();
4432
4433   if (arg->value == arg->stack)
4434     /* If the value is already in the stack slot, we are done.  */
4435     ;
4436   else if (arg->mode != BLKmode)
4437     {
4438       int size;
4439
4440       /* Argument is a scalar, not entirely passed in registers.
4441          (If part is passed in registers, arg->partial says how much
4442          and emit_push_insn will take care of putting it there.)
4443
4444          Push it, and if its size is less than the
4445          amount of space allocated to it,
4446          also bump stack pointer by the additional space.
4447          Note that in C the default argument promotions
4448          will prevent such mismatches.  */
4449
4450       size = GET_MODE_SIZE (arg->mode);
4451       /* Compute how much space the push instruction will push.
4452          On many machines, pushing a byte will advance the stack
4453          pointer by a halfword.  */
4454 #ifdef PUSH_ROUNDING
4455       size = PUSH_ROUNDING (size);
4456 #endif
4457       used = size;
4458
4459       /* Compute how much space the argument should get:
4460          round up to a multiple of the alignment for arguments.  */
4461       if (none != FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)))
4462         used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1)
4463                  / (PARM_BOUNDARY / BITS_PER_UNIT))
4464                 * (PARM_BOUNDARY / BITS_PER_UNIT));
4465
4466       /* This isn't already where we want it on the stack, so put it there.
4467          This can either be done with push or copy insns.  */
4468       emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX,
4469                       PARM_BOUNDARY, partial, reg, used - size, argblock,
4470                       ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
4471                       ARGS_SIZE_RTX (arg->locate.alignment_pad));
4472
4473       /* Unless this is a partially-in-register argument, the argument is now
4474          in the stack.  */
4475       if (partial == 0)
4476         arg->value = arg->stack;
4477     }
4478   else
4479     {
4480       /* BLKmode, at least partly to be pushed.  */
4481
4482       unsigned int parm_align;
4483       int excess;
4484       rtx size_rtx;
4485
4486       /* Pushing a nonscalar.
4487          If part is passed in registers, PARTIAL says how much
4488          and emit_push_insn will take care of putting it there.  */
4489
4490       /* Round its size up to a multiple
4491          of the allocation unit for arguments.  */
4492
4493       if (arg->locate.size.var != 0)
4494         {
4495           excess = 0;
4496           size_rtx = ARGS_SIZE_RTX (arg->locate.size);
4497         }
4498       else
4499         {
4500           /* PUSH_ROUNDING has no effect on us, because
4501              emit_push_insn for BLKmode is careful to avoid it.  */
4502           if (reg && GET_CODE (reg) == PARALLEL)
4503           {
4504             /* Use the size of the elt to compute excess.  */
4505             rtx elt = XEXP (XVECEXP (reg, 0, 0), 0);
4506             excess = (arg->locate.size.constant
4507                       - int_size_in_bytes (TREE_TYPE (pval))
4508                       + partial * GET_MODE_SIZE (GET_MODE (elt)));
4509           }
4510           else
4511             excess = (arg->locate.size.constant
4512                       - int_size_in_bytes (TREE_TYPE (pval))
4513                       + partial * UNITS_PER_WORD);
4514           size_rtx = expand_expr (size_in_bytes (TREE_TYPE (pval)),
4515                                   NULL_RTX, TYPE_MODE (sizetype), 0);
4516         }
4517
4518       /* Some types will require stricter alignment, which will be
4519          provided for elsewhere in argument layout.  */
4520       parm_align = MAX (PARM_BOUNDARY, TYPE_ALIGN (TREE_TYPE (pval)));
4521
4522       /* When an argument is padded down, the block is aligned to
4523          PARM_BOUNDARY, but the actual argument isn't.  */
4524       if (FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)) == downward)
4525         {
4526           if (arg->locate.size.var)
4527             parm_align = BITS_PER_UNIT;
4528           else if (excess)
4529             {
4530               unsigned int excess_align = (excess & -excess) * BITS_PER_UNIT;
4531               parm_align = MIN (parm_align, excess_align);
4532             }
4533         }
4534
4535       if ((flags & ECF_SIBCALL) && GET_CODE (arg->value) == MEM)
4536         {
4537           /* emit_push_insn might not work properly if arg->value and
4538              argblock + arg->locate.offset areas overlap.  */
4539           rtx x = arg->value;
4540           int i = 0;
4541
4542           if (XEXP (x, 0) == current_function_internal_arg_pointer
4543               || (GET_CODE (XEXP (x, 0)) == PLUS
4544                   && XEXP (XEXP (x, 0), 0) ==
4545                      current_function_internal_arg_pointer
4546                   && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT))
4547             {
4548               if (XEXP (x, 0) != current_function_internal_arg_pointer)
4549                 i = INTVAL (XEXP (XEXP (x, 0), 1));
4550
4551               /* expand_call should ensure this.  */
4552               if (arg->locate.offset.var || GET_CODE (size_rtx) != CONST_INT)
4553                 abort ();
4554
4555               if (arg->locate.offset.constant > i)
4556                 {
4557                   if (arg->locate.offset.constant < i + INTVAL (size_rtx))
4558                     sibcall_failure = 1;
4559                 }
4560               else if (arg->locate.offset.constant < i)
4561                 {
4562                   if (i < arg->locate.offset.constant + INTVAL (size_rtx))
4563                     sibcall_failure = 1;
4564                 }
4565             }
4566         }
4567
4568       emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
4569                       parm_align, partial, reg, excess, argblock,
4570                       ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
4571                       ARGS_SIZE_RTX (arg->locate.alignment_pad));
4572
4573       /* Unless this is a partially-in-register argument, the argument is now
4574          in the stack.
4575
4576          ??? Unlike the case above, in which we want the actual
4577          address of the data, so that we can load it directly into a
4578          register, here we want the address of the stack slot, so that
4579          it's properly aligned for word-by-word copying or something
4580          like that.  It's not clear that this is always correct.  */
4581       if (partial == 0)
4582         arg->value = arg->stack_slot;
4583     }
4584
4585   /* Mark all slots this store used.  */
4586   if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL)
4587       && argblock && ! variable_size && arg->stack)
4588     for (i = lower_bound; i < upper_bound; i++)
4589       stack_usage_map[i] = 1;
4590
4591   /* Once we have pushed something, pops can't safely
4592      be deferred during the rest of the arguments.  */
4593   NO_DEFER_POP;
4594
4595   /* ANSI doesn't require a sequence point here,
4596      but PCC has one, so this will avoid some problems.  */
4597   emit_queue ();
4598
4599   /* Free any temporary slots made in processing this argument.  Show
4600      that we might have taken the address of something and pushed that
4601      as an operand.  */
4602   preserve_temp_slots (NULL_RTX);
4603   free_temp_slots ();
4604   pop_temp_slots ();
4605
4606   return sibcall_failure;
4607 }
4608
4609 /* Nonzero if we do not know how to pass TYPE solely in registers.
4610    We cannot do so in the following cases:
4611
4612    - if the type has variable size
4613    - if the type is marked as addressable (it is required to be constructed
4614      into the stack)
4615    - if the padding and mode of the type is such that a copy into a register
4616      would put it into the wrong part of the register.
4617
4618    Which padding can't be supported depends on the byte endianness.
4619
4620    A value in a register is implicitly padded at the most significant end.
4621    On a big-endian machine, that is the lower end in memory.
4622    So a value padded in memory at the upper end can't go in a register.
4623    For a little-endian machine, the reverse is true.  */
4624
4625 bool
4626 default_must_pass_in_stack (enum machine_mode mode, tree type)
4627 {
4628   if (!type)
4629     return false;
4630
4631   /* If the type has variable size...  */
4632   if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4633     return true;
4634
4635   /* If the type is marked as addressable (it is required
4636      to be constructed into the stack)...  */
4637   if (TREE_ADDRESSABLE (type))
4638     return true;
4639
4640   /* If the padding and mode of the type is such that a copy into
4641      a register would put it into the wrong part of the register.  */
4642   if (mode == BLKmode
4643       && int_size_in_bytes (type) % (PARM_BOUNDARY / BITS_PER_UNIT)
4644       && (FUNCTION_ARG_PADDING (mode, type)
4645           == (BYTES_BIG_ENDIAN ? upward : downward)))
4646     return true;
4647
4648   return false;
4649 }