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