gcc/calls.c

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