gcc/calls.c

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