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