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_STRUCT_FUNCTION (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_STRUCT_FUNCTION (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 =
1810                         (DECL_STRUCT_FUNCTION (fndecl)->outgoing_args_size
1811                          + reg_parm_stack_space);
1812
1813                   start_sequence ();
1814                   emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1815                   allocate_dynamic_stack_space (GEN_INT (adjust),
1816                                                 NULL_RTX, BITS_PER_UNIT);
1817                   seq = get_insns ();
1818                   end_sequence ();
1819                   emit_insn_before (seq, first_insn);
1820                   emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1821                 }
1822             }
1823         }
1824
1825       /* If the result is equivalent to TARGET, return TARGET to simplify
1826          checks in store_expr.  They can be equivalent but not equal in the
1827          case of a function that returns BLKmode.  */
1828       if (temp != target && rtx_equal_p (temp, target))
1829         return target;
1830       return temp;
1831     }
1832
1833   /* If inlining failed, mark FNDECL as needing to be compiled
1834      separately after all.  If function was declared inline,
1835      give a warning.  */
1836   if (DECL_INLINE (fndecl) && warn_inline && !flag_no_inline
1837       && optimize > 0 && !TREE_ADDRESSABLE (fndecl))
1838     {
1839       warning ("%Jinlining failed in call to '%F'", fndecl, fndecl);
1840       warning ("called from here");
1841     }
1842   (*lang_hooks.mark_addressable) (fndecl);
1843   return (rtx) (size_t) - 1;
1844 }
1845
1846 /* We need to pop PENDING_STACK_ADJUST bytes.  But, if the arguments
1847    wouldn't fill up an even multiple of PREFERRED_UNIT_STACK_BOUNDARY
1848    bytes, then we would need to push some additional bytes to pad the
1849    arguments.  So, we compute an adjust to the stack pointer for an
1850    amount that will leave the stack under-aligned by UNADJUSTED_ARGS_SIZE
1851    bytes.  Then, when the arguments are pushed the stack will be perfectly
1852    aligned.  ARGS_SIZE->CONSTANT is set to the number of bytes that should
1853    be popped after the call.  Returns the adjustment.  */
1854
1855 static int
1856 combine_pending_stack_adjustment_and_call (int unadjusted_args_size,
1857                                            struct args_size *args_size,
1858                                            int preferred_unit_stack_boundary)
1859 {
1860   /* The number of bytes to pop so that the stack will be
1861      under-aligned by UNADJUSTED_ARGS_SIZE bytes.  */
1862   HOST_WIDE_INT adjustment;
1863   /* The alignment of the stack after the arguments are pushed, if we
1864      just pushed the arguments without adjust the stack here.  */
1865   HOST_WIDE_INT unadjusted_alignment;
1866
1867   unadjusted_alignment
1868     = ((stack_pointer_delta + unadjusted_args_size)
1869        % preferred_unit_stack_boundary);
1870
1871   /* We want to get rid of as many of the PENDING_STACK_ADJUST bytes
1872      as possible -- leaving just enough left to cancel out the
1873      UNADJUSTED_ALIGNMENT.  In other words, we want to ensure that the
1874      PENDING_STACK_ADJUST is non-negative, and congruent to
1875      -UNADJUSTED_ALIGNMENT modulo the PREFERRED_UNIT_STACK_BOUNDARY.  */
1876
1877   /* Begin by trying to pop all the bytes.  */
1878   unadjusted_alignment
1879     = (unadjusted_alignment
1880        - (pending_stack_adjust % preferred_unit_stack_boundary));
1881   adjustment = pending_stack_adjust;
1882   /* Push enough additional bytes that the stack will be aligned
1883      after the arguments are pushed.  */
1884   if (preferred_unit_stack_boundary > 1)
1885     {
1886       if (unadjusted_alignment > 0)
1887         adjustment -= preferred_unit_stack_boundary - unadjusted_alignment;
1888       else
1889         adjustment += unadjusted_alignment;
1890     }
1891
1892   /* Now, sets ARGS_SIZE->CONSTANT so that we pop the right number of
1893      bytes after the call.  The right number is the entire
1894      PENDING_STACK_ADJUST less our ADJUSTMENT plus the amount required
1895      by the arguments in the first place.  */
1896   args_size->constant
1897     = pending_stack_adjust - adjustment + unadjusted_args_size;
1898
1899   return adjustment;
1900 }
1901
1902 /* Scan X expression if it does not dereference any argument slots
1903    we already clobbered by tail call arguments (as noted in stored_args_map
1904    bitmap).
1905    Return nonzero if X expression dereferences such argument slots,
1906    zero otherwise.  */
1907
1908 static int
1909 check_sibcall_argument_overlap_1 (rtx x)
1910 {
1911   RTX_CODE code;
1912   int i, j;
1913   unsigned int k;
1914   const char *fmt;
1915
1916   if (x == NULL_RTX)
1917     return 0;
1918
1919   code = GET_CODE (x);
1920
1921   if (code == MEM)
1922     {
1923       if (XEXP (x, 0) == current_function_internal_arg_pointer)
1924         i = 0;
1925       else if (GET_CODE (XEXP (x, 0)) == PLUS
1926                && XEXP (XEXP (x, 0), 0) ==
1927                   current_function_internal_arg_pointer
1928                && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
1929         i = INTVAL (XEXP (XEXP (x, 0), 1));
1930       else
1931         return 0;
1932
1933 #ifdef ARGS_GROW_DOWNWARD
1934       i = -i - GET_MODE_SIZE (GET_MODE (x));
1935 #endif
1936
1937       for (k = 0; k < GET_MODE_SIZE (GET_MODE (x)); k++)
1938         if (i + k < stored_args_map->n_bits
1939             && TEST_BIT (stored_args_map, i + k))
1940           return 1;
1941
1942       return 0;
1943     }
1944
1945   /* Scan all subexpressions.  */
1946   fmt = GET_RTX_FORMAT (code);
1947   for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
1948     {
1949       if (*fmt == 'e')
1950         {
1951           if (check_sibcall_argument_overlap_1 (XEXP (x, i)))
1952             return 1;
1953         }
1954       else if (*fmt == 'E')
1955         {
1956           for (j = 0; j < XVECLEN (x, i); j++)
1957             if (check_sibcall_argument_overlap_1 (XVECEXP (x, i, j)))
1958               return 1;
1959         }
1960     }
1961   return 0;
1962 }
1963
1964 /* Scan sequence after INSN if it does not dereference any argument slots
1965    we already clobbered by tail call arguments (as noted in stored_args_map
1966    bitmap).  If MARK_STORED_ARGS_MAP, add stack slots for ARG to
1967    stored_args_map bitmap afterwards (when ARG is a register MARK_STORED_ARGS_MAP
1968    should be 0).  Return nonzero if sequence after INSN dereferences such argument
1969    slots, zero otherwise.  */
1970
1971 static int
1972 check_sibcall_argument_overlap (rtx insn, struct arg_data *arg, int mark_stored_args_map)
1973 {
1974   int low, high;
1975
1976   if (insn == NULL_RTX)
1977     insn = get_insns ();
1978   else
1979     insn = NEXT_INSN (insn);
1980
1981   for (; insn; insn = NEXT_INSN (insn))
1982     if (INSN_P (insn)
1983         && check_sibcall_argument_overlap_1 (PATTERN (insn)))
1984       break;
1985
1986   if (mark_stored_args_map)
1987     {
1988 #ifdef ARGS_GROW_DOWNWARD
1989       low = -arg->locate.slot_offset.constant - arg->locate.size.constant;
1990 #else
1991       low = arg->locate.slot_offset.constant;
1992 #endif
1993
1994       for (high = low + arg->locate.size.constant; low < high; low++)
1995         SET_BIT (stored_args_map, low);
1996     }
1997   return insn != NULL_RTX;
1998 }
1999
2000 static tree
2001 fix_unsafe_tree (tree t)
2002 {
2003   switch (unsafe_for_reeval (t))
2004     {
2005     case 0: /* Safe.  */
2006       break;
2007
2008     case 1: /* Mildly unsafe.  */
2009       t = unsave_expr (t);
2010       break;
2011
2012     case 2: /* Wildly unsafe.  */
2013       {
2014         tree var = build_decl (VAR_DECL, NULL_TREE,
2015                                TREE_TYPE (t));
2016         SET_DECL_RTL (var,
2017                       expand_expr (t, NULL_RTX, VOIDmode, EXPAND_NORMAL));
2018         t = var;
2019       }
2020       break;
2021
2022     default:
2023       abort ();
2024     }
2025   return t;
2026 }
2027
2028
2029 /* If function value *VALUE was returned at the most significant end of a
2030    register, shift it towards the least significant end and convert it to
2031    TYPE's mode.  Return true and update *VALUE if some action was needed.
2032
2033    TYPE is the type of the function's return value, which is known not
2034    to have mode BLKmode.  */
2035
2036 static bool
2037 shift_returned_value (tree type, rtx *value)
2038 {
2039   if (targetm.calls.return_in_msb (type))
2040     {
2041       HOST_WIDE_INT shift;
2042
2043       shift = (GET_MODE_BITSIZE (GET_MODE (*value))
2044                - BITS_PER_UNIT * int_size_in_bytes (type));
2045       if (shift > 0)
2046         {
2047           *value = expand_binop (GET_MODE (*value), lshr_optab, *value,
2048                                  GEN_INT (shift), 0, 1, OPTAB_WIDEN);
2049           *value = convert_to_mode (TYPE_MODE (type), *value, 0);
2050           return true;
2051         }
2052     }
2053   return false;
2054 }
2055
2056 /* Generate all the code for a function call
2057    and return an rtx for its value.
2058    Store the value in TARGET (specified as an rtx) if convenient.
2059    If the value is stored in TARGET then TARGET is returned.
2060    If IGNORE is nonzero, then we ignore the value of the function call.  */
2061
2062 rtx
2063 expand_call (tree exp, rtx target, int ignore)
2064 {
2065   /* Nonzero if we are currently expanding a call.  */
2066   static int currently_expanding_call = 0;
2067
2068   /* List of actual parameters.  */
2069   tree actparms = TREE_OPERAND (exp, 1);
2070   /* RTX for the function to be called.  */
2071   rtx funexp;
2072   /* Sequence of insns to perform a tail recursive "call".  */
2073   rtx tail_recursion_insns = NULL_RTX;
2074   /* Sequence of insns to perform a normal "call".  */
2075   rtx normal_call_insns = NULL_RTX;
2076   /* Sequence of insns to perform a tail recursive "call".  */
2077   rtx tail_call_insns = NULL_RTX;
2078   /* Data type of the function.  */
2079   tree funtype;
2080   tree type_arg_types;
2081   /* Declaration of the function being called,
2082      or 0 if the function is computed (not known by name).  */
2083   tree fndecl = 0;
2084   /* The type of the function being called.  */
2085   tree fntype;
2086   rtx insn;
2087   int try_tail_call = 1;
2088   int try_tail_recursion = 1;
2089   int pass;
2090
2091   /* Register in which non-BLKmode value will be returned,
2092      or 0 if no value or if value is BLKmode.  */
2093   rtx valreg;
2094   /* Address where we should return a BLKmode value;
2095      0 if value not BLKmode.  */
2096   rtx structure_value_addr = 0;
2097   /* Nonzero if that address is being passed by treating it as
2098      an extra, implicit first parameter.  Otherwise,
2099      it is passed by being copied directly into struct_value_rtx.  */
2100   int structure_value_addr_parm = 0;
2101   /* Size of aggregate value wanted, or zero if none wanted
2102      or if we are using the non-reentrant PCC calling convention
2103      or expecting the value in registers.  */
2104   HOST_WIDE_INT struct_value_size = 0;
2105   /* Nonzero if called function returns an aggregate in memory PCC style,
2106      by returning the address of where to find it.  */
2107   int pcc_struct_value = 0;
2108   rtx struct_value = 0;
2109
2110   /* Number of actual parameters in this call, including struct value addr.  */
2111   int num_actuals;
2112   /* Number of named args.  Args after this are anonymous ones
2113      and they must all go on the stack.  */
2114   int n_named_args;
2115
2116   /* Vector of information about each argument.
2117      Arguments are numbered in the order they will be pushed,
2118      not the order they are written.  */
2119   struct arg_data *args;
2120
2121   /* Total size in bytes of all the stack-parms scanned so far.  */
2122   struct args_size args_size;
2123   struct args_size adjusted_args_size;
2124   /* Size of arguments before any adjustments (such as rounding).  */
2125   int unadjusted_args_size;
2126   /* Data on reg parms scanned so far.  */
2127   CUMULATIVE_ARGS args_so_far;
2128   /* Nonzero if a reg parm has been scanned.  */
2129   int reg_parm_seen;
2130   /* Nonzero if this is an indirect function call.  */
2131
2132   /* Nonzero if we must avoid push-insns in the args for this call.
2133      If stack space is allocated for register parameters, but not by the
2134      caller, then it is preallocated in the fixed part of the stack frame.
2135      So the entire argument block must then be preallocated (i.e., we
2136      ignore PUSH_ROUNDING in that case).  */
2137
2138   int must_preallocate = !PUSH_ARGS;
2139
2140   /* Size of the stack reserved for parameter registers.  */
2141   int reg_parm_stack_space = 0;
2142
2143   /* Address of space preallocated for stack parms
2144      (on machines that lack push insns), or 0 if space not preallocated.  */
2145   rtx argblock = 0;
2146
2147   /* Mask of ECF_ flags.  */
2148   int flags = 0;
2149   /* Nonzero if this is a call to an inline function.  */
2150   int is_integrable = 0;
2151 #ifdef REG_PARM_STACK_SPACE
2152   /* Define the boundary of the register parm stack space that needs to be
2153      saved, if any.  */
2154   int low_to_save, high_to_save;
2155   rtx save_area = 0;            /* Place that it is saved */
2156 #endif
2157
2158   int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
2159   rtx temp_target = 0;
2160   char *initial_stack_usage_map = stack_usage_map;
2161
2162   int old_stack_allocated;
2163
2164   /* State variables to track stack modifications.  */
2165   rtx old_stack_level = 0;
2166   int old_stack_arg_under_construction = 0;
2167   int old_pending_adj = 0;
2168   int old_inhibit_defer_pop = inhibit_defer_pop;
2169
2170   /* Some stack pointer alterations we make are performed via
2171      allocate_dynamic_stack_space. This modifies the stack_pointer_delta,
2172      which we then also need to save/restore along the way.  */
2173   int old_stack_pointer_delta = 0;
2174
2175   rtx call_fusage;
2176   tree p = TREE_OPERAND (exp, 0);
2177   tree addr = TREE_OPERAND (exp, 0);
2178   int i;
2179   /* The alignment of the stack, in bits.  */
2180   HOST_WIDE_INT preferred_stack_boundary;
2181   /* The alignment of the stack, in bytes.  */
2182   HOST_WIDE_INT preferred_unit_stack_boundary;
2183
2184   /* See if this is "nothrow" function call.  */
2185   if (TREE_NOTHROW (exp))
2186     flags |= ECF_NOTHROW;
2187
2188   /* See if we can find a DECL-node for the actual function.
2189      As a result, decide whether this is a call to an integrable function.  */
2190
2191   fndecl = get_callee_fndecl (exp);
2192   if (fndecl)
2193     {
2194       fntype = TREE_TYPE (fndecl);
2195       if (!flag_no_inline
2196           && fndecl != current_function_decl
2197           && DECL_INLINE (fndecl)
2198           && DECL_STRUCT_FUNCTION (fndecl)
2199           && DECL_STRUCT_FUNCTION (fndecl)->inlinable)
2200         is_integrable = 1;
2201       else if (! TREE_ADDRESSABLE (fndecl))
2202         {
2203           /* In case this function later becomes inlinable,
2204              record that there was already a non-inline call to it.
2205
2206              Use abstraction instead of setting TREE_ADDRESSABLE
2207              directly.  */
2208           if (DECL_INLINE (fndecl) && warn_inline && !flag_no_inline
2209               && optimize > 0)
2210             {
2211               warning ("%Jcan't inline call to '%F'", fndecl, fndecl);
2212               warning ("called from here");
2213             }
2214           (*lang_hooks.mark_addressable) (fndecl);
2215         }
2216
2217       if (ignore
2218           && lookup_attribute ("warn_unused_result",
2219                                TYPE_ATTRIBUTES (TREE_TYPE (fndecl))))
2220         warning ("ignoring return value of `%D', "
2221                  "declared with attribute warn_unused_result", fndecl);
2222
2223       flags |= flags_from_decl_or_type (fndecl);
2224     }
2225
2226   /* If we don't have specific function to call, see if we have a
2227      attributes set in the type.  */
2228   else
2229     {
2230       fntype = TREE_TYPE (TREE_TYPE (p));
2231       if (ignore
2232           && lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (fntype)))
2233         warning ("ignoring return value of function "
2234                  "declared with attribute warn_unused_result");
2235       flags |= flags_from_decl_or_type (fntype);
2236     }
2237
2238   struct_value = targetm.calls.struct_value_rtx (fntype, 0);
2239
2240   /* Warn if this value is an aggregate type,
2241      regardless of which calling convention we are using for it.  */
2242   if (warn_aggregate_return && AGGREGATE_TYPE_P (TREE_TYPE (exp)))
2243     warning ("function call has aggregate value");
2244
2245   /* If the result of a pure or const function call is ignored (or void),
2246      and none of its arguments are volatile, we can avoid expanding the
2247      call and just evaluate the arguments for side-effects.  */
2248   if ((flags & (ECF_CONST | ECF_PURE))
2249       && (ignore || target == const0_rtx
2250           || TYPE_MODE (TREE_TYPE (exp)) == VOIDmode))
2251     {
2252       bool volatilep = false;
2253       tree arg;
2254
2255       for (arg = actparms; arg; arg = TREE_CHAIN (arg))
2256         if (TREE_THIS_VOLATILE (TREE_VALUE (arg)))
2257           {
2258             volatilep = true;
2259             break;
2260           }
2261
2262       if (! volatilep)
2263         {
2264           for (arg = actparms; arg; arg = TREE_CHAIN (arg))
2265             expand_expr (TREE_VALUE (arg), const0_rtx,
2266                          VOIDmode, EXPAND_NORMAL);
2267           return const0_rtx;
2268         }
2269     }
2270
2271 #ifdef REG_PARM_STACK_SPACE
2272 #ifdef MAYBE_REG_PARM_STACK_SPACE
2273   reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
2274 #else
2275   reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
2276 #endif
2277 #endif
2278
2279 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2280   if (reg_parm_stack_space > 0 && PUSH_ARGS)
2281     must_preallocate = 1;
2282 #endif
2283
2284   /* Set up a place to return a structure.  */
2285
2286   /* Cater to broken compilers.  */
2287   if (aggregate_value_p (exp, fndecl))
2288     {
2289       /* This call returns a big structure.  */
2290       flags &= ~(ECF_CONST | ECF_PURE | ECF_LIBCALL_BLOCK);
2291
2292 #ifdef PCC_STATIC_STRUCT_RETURN
2293       {
2294         pcc_struct_value = 1;
2295         /* Easier than making that case work right.  */
2296         if (is_integrable)
2297           {
2298             /* In case this is a static function, note that it has been
2299                used.  */
2300             if (! TREE_ADDRESSABLE (fndecl))
2301               (*lang_hooks.mark_addressable) (fndecl);
2302             is_integrable = 0;
2303           }
2304       }
2305 #else /* not PCC_STATIC_STRUCT_RETURN */
2306       {
2307         struct_value_size = int_size_in_bytes (TREE_TYPE (exp));
2308
2309         if (CALL_EXPR_HAS_RETURN_SLOT_ADDR (exp))
2310           {
2311             /* The structure value address arg is already in actparms.
2312                Pull it out.  It might be nice to just leave it there, but
2313                we need to set structure_value_addr.  */
2314             tree return_arg = TREE_VALUE (actparms);
2315             actparms = TREE_CHAIN (actparms);
2316             structure_value_addr = expand_expr (return_arg, NULL_RTX,
2317                                                 VOIDmode, EXPAND_NORMAL);
2318           }
2319         else if (target && GET_CODE (target) == MEM)
2320           structure_value_addr = XEXP (target, 0);
2321         else
2322           {
2323             /* For variable-sized objects, we must be called with a target
2324                specified.  If we were to allocate space on the stack here,
2325                we would have no way of knowing when to free it.  */
2326             rtx d = assign_temp (TREE_TYPE (exp), 1, 1, 1);
2327
2328             mark_temp_addr_taken (d);
2329             structure_value_addr = XEXP (d, 0);
2330             target = 0;
2331           }
2332       }
2333 #endif /* not PCC_STATIC_STRUCT_RETURN */
2334     }
2335
2336   /* If called function is inline, try to integrate it.  */
2337
2338   if (is_integrable)
2339     {
2340       rtx temp = try_to_integrate (fndecl, actparms, target,
2341                                    ignore, TREE_TYPE (exp),
2342                                    structure_value_addr);
2343       if (temp != (rtx) (size_t) - 1)
2344         return temp;
2345     }
2346
2347   /* Figure out the amount to which the stack should be aligned.  */
2348   preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
2349   if (fndecl)
2350     {
2351       struct cgraph_rtl_info *i = cgraph_rtl_info (fndecl);
2352       if (i && i->preferred_incoming_stack_boundary)
2353         preferred_stack_boundary = i->preferred_incoming_stack_boundary;
2354     }
2355
2356   /* Operand 0 is a pointer-to-function; get the type of the function.  */
2357   funtype = TREE_TYPE (addr);
2358   if (! POINTER_TYPE_P (funtype))
2359     abort ();
2360   funtype = TREE_TYPE (funtype);
2361
2362   /* Munge the tree to split complex arguments into their imaginary
2363      and real parts.  */
2364   if (SPLIT_COMPLEX_ARGS)
2365     {
2366       type_arg_types = split_complex_types (TYPE_ARG_TYPES (funtype));
2367       actparms = split_complex_values (actparms);
2368     }
2369   else
2370     type_arg_types = TYPE_ARG_TYPES (funtype);
2371
2372   /* See if this is a call to a function that can return more than once
2373      or a call to longjmp or malloc.  */
2374   flags |= special_function_p (fndecl, flags);
2375
2376   if (flags & ECF_MAY_BE_ALLOCA)
2377     current_function_calls_alloca = 1;
2378
2379   /* If struct_value_rtx is 0, it means pass the address
2380      as if it were an extra parameter.  */
2381   if (structure_value_addr && struct_value == 0)
2382     {
2383       /* If structure_value_addr is a REG other than
2384          virtual_outgoing_args_rtx, we can use always use it.  If it
2385          is not a REG, we must always copy it into a register.
2386          If it is virtual_outgoing_args_rtx, we must copy it to another
2387          register in some cases.  */
2388       rtx temp = (GET_CODE (structure_value_addr) != REG
2389                   || (ACCUMULATE_OUTGOING_ARGS
2390                       && stack_arg_under_construction
2391                       && structure_value_addr == virtual_outgoing_args_rtx)
2392                   ? copy_addr_to_reg (convert_memory_address
2393                                       (Pmode, structure_value_addr))
2394                   : structure_value_addr);
2395
2396       actparms
2397         = tree_cons (error_mark_node,
2398                      make_tree (build_pointer_type (TREE_TYPE (funtype)),
2399                                 temp),
2400                      actparms);
2401       structure_value_addr_parm = 1;
2402     }
2403
2404   /* Count the arguments and set NUM_ACTUALS.  */
2405   for (p = actparms, num_actuals = 0; p; p = TREE_CHAIN (p))
2406     num_actuals++;
2407
2408   /* Compute number of named args.
2409      Normally, don't include the last named arg if anonymous args follow.
2410      We do include the last named arg if
2411      targetm.calls.strict_argument_naming() returns nonzero.
2412      (If no anonymous args follow, the result of list_length is actually
2413      one too large.  This is harmless.)
2414
2415      If targetm.calls.pretend_outgoing_varargs_named() returns
2416      nonzero, and targetm.calls.strict_argument_naming() returns zero,
2417      this machine will be able to place unnamed args that were passed
2418      in registers into the stack.  So treat all args as named.  This
2419      allows the insns emitting for a specific argument list to be
2420      independent of the function declaration.
2421
2422      If targetm.calls.pretend_outgoing_varargs_named() returns zero,
2423      we do not have any reliable way to pass unnamed args in
2424      registers, so we must force them into memory.  */
2425
2426   if ((targetm.calls.strict_argument_naming (&args_so_far)
2427        || ! targetm.calls.pretend_outgoing_varargs_named (&args_so_far))
2428       && type_arg_types != 0)
2429     n_named_args
2430       = (list_length (type_arg_types)
2431          /* Don't include the last named arg.  */
2432          - (targetm.calls.strict_argument_naming (&args_so_far) ? 0 : 1)
2433          /* Count the struct value address, if it is passed as a parm.  */
2434          + structure_value_addr_parm);
2435   else
2436     /* If we know nothing, treat all args as named.  */
2437     n_named_args = num_actuals;
2438
2439   /* Start updating where the next arg would go.
2440
2441      On some machines (such as the PA) indirect calls have a different
2442      calling convention than normal calls.  The fourth argument in
2443      INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
2444      or not.  */
2445   INIT_CUMULATIVE_ARGS (args_so_far, funtype, NULL_RTX, fndecl, n_named_args);
2446
2447   /* Make a vector to hold all the information about each arg.  */
2448   args = alloca (num_actuals * sizeof (struct arg_data));
2449   memset (args, 0, num_actuals * sizeof (struct arg_data));
2450
2451   /* Build up entries in the ARGS array, compute the size of the
2452      arguments into ARGS_SIZE, etc.  */
2453   initialize_argument_information (num_actuals, args, &args_size,
2454                                    n_named_args, actparms, fndecl,
2455                                    &args_so_far, reg_parm_stack_space,
2456                                    &old_stack_level, &old_pending_adj,
2457                                    &must_preallocate, &flags,
2458                                    CALL_FROM_THUNK_P (exp));
2459
2460   if (args_size.var)
2461     {
2462       /* If this function requires a variable-sized argument list, don't
2463          try to make a cse'able block for this call.  We may be able to
2464          do this eventually, but it is too complicated to keep track of
2465          what insns go in the cse'able block and which don't.  */
2466
2467       flags &= ~ECF_LIBCALL_BLOCK;
2468       must_preallocate = 1;
2469     }
2470
2471   /* Now make final decision about preallocating stack space.  */
2472   must_preallocate = finalize_must_preallocate (must_preallocate,
2473                                                 num_actuals, args,
2474                                                 &args_size);
2475
2476   /* If the structure value address will reference the stack pointer, we
2477      must stabilize it.  We don't need to do this if we know that we are
2478      not going to adjust the stack pointer in processing this call.  */
2479
2480   if (structure_value_addr
2481       && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
2482           || reg_mentioned_p (virtual_outgoing_args_rtx,
2483                               structure_value_addr))
2484       && (args_size.var
2485           || (!ACCUMULATE_OUTGOING_ARGS && args_size.constant)))
2486     structure_value_addr = copy_to_reg (structure_value_addr);
2487
2488   /* Tail calls can make things harder to debug, and we're traditionally
2489      pushed these optimizations into -O2.  Don't try if we're already
2490      expanding a call, as that means we're an argument.  Don't try if
2491      there's cleanups, as we know there's code to follow the call.
2492
2493      If rtx_equal_function_value_matters is false, that means we've
2494      finished with regular parsing.  Which means that some of the
2495      machinery we use to generate tail-calls is no longer in place.
2496      This is most often true of sjlj-exceptions, which we couldn't
2497      tail-call to anyway.
2498
2499      If current_nesting_level () == 0, we're being called after
2500      the function body has been expanded.  This can happen when
2501      setting up trampolines in expand_function_end.  */
2502   if (currently_expanding_call++ != 0
2503       || !flag_optimize_sibling_calls
2504       || !rtx_equal_function_value_matters
2505       || current_nesting_level () == 0
2506       || any_pending_cleanups ()
2507       || args_size.var)
2508     try_tail_call = try_tail_recursion = 0;
2509
2510   /* Tail recursion fails, when we are not dealing with recursive calls.  */
2511   if (!try_tail_recursion
2512       || TREE_CODE (addr) != ADDR_EXPR
2513       || TREE_OPERAND (addr, 0) != current_function_decl)
2514     try_tail_recursion = 0;
2515
2516   /*  Rest of purposes for tail call optimizations to fail.  */
2517   if (
2518 #ifdef HAVE_sibcall_epilogue
2519       !HAVE_sibcall_epilogue
2520 #else
2521       1
2522 #endif
2523       || !try_tail_call
2524       /* Doing sibling call optimization needs some work, since
2525          structure_value_addr can be allocated on the stack.
2526          It does not seem worth the effort since few optimizable
2527          sibling calls will return a structure.  */
2528       || structure_value_addr != NULL_RTX
2529       /* Check whether the target is able to optimize the call
2530          into a sibcall.  */
2531       || !(*targetm.function_ok_for_sibcall) (fndecl, exp)
2532       /* Functions that do not return exactly once may not be sibcall
2533          optimized.  */
2534       || (flags & (ECF_RETURNS_TWICE | ECF_LONGJMP | ECF_NORETURN))
2535       || TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (addr)))
2536       /* If the called function is nested in the current one, it might access
2537          some of the caller's arguments, but could clobber them beforehand if
2538          the argument areas are shared.  */
2539       || (fndecl && decl_function_context (fndecl) == current_function_decl)
2540       /* If this function requires more stack slots than the current
2541          function, we cannot change it into a sibling call.  */
2542       || args_size.constant > current_function_args_size
2543       /* If the callee pops its own arguments, then it must pop exactly
2544          the same number of arguments as the current function.  */
2545       || (RETURN_POPS_ARGS (fndecl, funtype, args_size.constant)
2546           != RETURN_POPS_ARGS (current_function_decl,
2547                                TREE_TYPE (current_function_decl),
2548                                current_function_args_size))
2549       || !(*lang_hooks.decls.ok_for_sibcall) (fndecl))
2550     try_tail_call = 0;
2551
2552   if (try_tail_call || try_tail_recursion)
2553     {
2554       int end, inc;
2555       actparms = NULL_TREE;
2556       /* Ok, we're going to give the tail call the old college try.
2557          This means we're going to evaluate the function arguments
2558          up to three times.  There are two degrees of badness we can
2559          encounter, those that can be unsaved and those that can't.
2560          (See unsafe_for_reeval commentary for details.)
2561
2562          Generate a new argument list.  Pass safe arguments through
2563          unchanged.  For the easy badness wrap them in UNSAVE_EXPRs.
2564          For hard badness, evaluate them now and put their resulting
2565          rtx in a temporary VAR_DECL.
2566
2567          initialize_argument_information has ordered the array for the
2568          order to be pushed, and we must remember this when reconstructing
2569          the original argument order.  */
2570
2571       if (PUSH_ARGS_REVERSED)
2572         {
2573           inc = 1;
2574           i = 0;
2575           end = num_actuals;
2576         }
2577       else
2578         {
2579           inc = -1;
2580           i = num_actuals - 1;
2581           end = -1;
2582         }
2583
2584       for (; i != end; i += inc)
2585         {
2586           args[i].tree_value = fix_unsafe_tree (args[i].tree_value);
2587           /* We need to build actparms for optimize_tail_recursion.  We can
2588              safely trash away TREE_PURPOSE, since it is unused by this
2589              function.  */
2590           if (try_tail_recursion)
2591             actparms = tree_cons (NULL_TREE, args[i].tree_value, actparms);
2592         }
2593       /* Do the same for the function address if it is an expression.  */
2594       if (!fndecl)
2595         addr = fix_unsafe_tree (addr);
2596       /* Expanding one of those dangerous arguments could have added
2597          cleanups, but otherwise give it a whirl.  */
2598       if (any_pending_cleanups ())
2599         try_tail_call = try_tail_recursion = 0;
2600     }
2601
2602   /* Generate a tail recursion sequence when calling ourselves.  */
2603
2604   if (try_tail_recursion)
2605     {
2606       /* We want to emit any pending stack adjustments before the tail
2607          recursion "call".  That way we know any adjustment after the tail
2608          recursion call can be ignored if we indeed use the tail recursion
2609          call expansion.  */
2610       int save_pending_stack_adjust = pending_stack_adjust;
2611       int save_stack_pointer_delta = stack_pointer_delta;
2612
2613       /* Emit any queued insns now; otherwise they would end up in
2614          only one of the alternates.  */
2615       emit_queue ();
2616
2617       /* Use a new sequence to hold any RTL we generate.  We do not even
2618          know if we will use this RTL yet.  The final decision can not be
2619          made until after RTL generation for the entire function is
2620          complete.  */
2621       start_sequence ();
2622       /* If expanding any of the arguments creates cleanups, we can't
2623          do a tailcall.  So, we'll need to pop the pending cleanups
2624          list.  If, however, all goes well, and there are no cleanups
2625          then the call to expand_start_target_temps will have no
2626          effect.  */
2627       expand_start_target_temps ();
2628       if (optimize_tail_recursion (actparms, get_last_insn ()))
2629         {
2630           if (any_pending_cleanups ())
2631             try_tail_call = try_tail_recursion = 0;
2632           else
2633             tail_recursion_insns = get_insns ();
2634         }
2635       expand_end_target_temps ();
2636       end_sequence ();
2637
2638       /* Restore the original pending stack adjustment for the sibling and
2639          normal call cases below.  */
2640       pending_stack_adjust = save_pending_stack_adjust;
2641       stack_pointer_delta = save_stack_pointer_delta;
2642     }
2643
2644   if (profile_arc_flag && (flags & ECF_FORK_OR_EXEC))
2645     {
2646       /* A fork duplicates the profile information, and an exec discards
2647          it.  We can't rely on fork/exec to be paired.  So write out the
2648          profile information we have gathered so far, and clear it.  */
2649       /* ??? When Linux's __clone is called with CLONE_VM set, profiling
2650          is subject to race conditions, just as with multithreaded
2651          programs.  */
2652
2653       emit_library_call (gcov_flush_libfunc, LCT_ALWAYS_RETURN, VOIDmode, 0);
2654     }
2655
2656   /* Ensure current function's preferred stack boundary is at least
2657      what we need.  We don't have to increase alignment for recursive
2658      functions.  */
2659   if (cfun->preferred_stack_boundary < preferred_stack_boundary
2660       && fndecl != current_function_decl)
2661     cfun->preferred_stack_boundary = preferred_stack_boundary;
2662   if (fndecl == current_function_decl)
2663     cfun->recursive_call_emit = true;
2664
2665   preferred_unit_stack_boundary = preferred_stack_boundary / BITS_PER_UNIT;
2666
2667   function_call_count++;
2668
2669   /* We want to make two insn chains; one for a sibling call, the other
2670      for a normal call.  We will select one of the two chains after
2671      initial RTL generation is complete.  */
2672   for (pass = try_tail_call ? 0 : 1; pass < 2; pass++)
2673     {
2674       int sibcall_failure = 0;
2675       /* We want to emit any pending stack adjustments before the tail
2676          recursion "call".  That way we know any adjustment after the tail
2677          recursion call can be ignored if we indeed use the tail recursion
2678          call expansion.  */
2679       int save_pending_stack_adjust = 0;
2680       int save_stack_pointer_delta = 0;
2681       rtx insns;
2682       rtx before_call, next_arg_reg;
2683
2684       if (pass == 0)
2685         {
2686           /* Emit any queued insns now; otherwise they would end up in
2687              only one of the alternates.  */
2688           emit_queue ();
2689
2690           /* State variables we need to save and restore between
2691              iterations.  */
2692           save_pending_stack_adjust = pending_stack_adjust;
2693           save_stack_pointer_delta = stack_pointer_delta;
2694         }
2695       if (pass)
2696         flags &= ~ECF_SIBCALL;
2697       else
2698         flags |= ECF_SIBCALL;
2699
2700       /* Other state variables that we must reinitialize each time
2701          through the loop (that are not initialized by the loop itself).  */
2702       argblock = 0;
2703       call_fusage = 0;
2704
2705       /* Start a new sequence for the normal call case.
2706
2707          From this point on, if the sibling call fails, we want to set
2708          sibcall_failure instead of continuing the loop.  */
2709       start_sequence ();
2710
2711       if (pass == 0)
2712         {
2713           /* We know at this point that there are not currently any
2714              pending cleanups.  If, however, in the process of evaluating
2715              the arguments we were to create some, we'll need to be
2716              able to get rid of them.  */
2717           expand_start_target_temps ();
2718         }
2719
2720       /* Don't let pending stack adjusts add up to too much.
2721          Also, do all pending adjustments now if there is any chance
2722          this might be a call to alloca or if we are expanding a sibling
2723          call sequence or if we are calling a function that is to return
2724          with stack pointer depressed.  */
2725       if (pending_stack_adjust >= 32
2726           || (pending_stack_adjust > 0
2727               && (flags & (ECF_MAY_BE_ALLOCA | ECF_SP_DEPRESSED)))
2728           || pass == 0)
2729         do_pending_stack_adjust ();
2730
2731       /* When calling a const function, we must pop the stack args right away,
2732          so that the pop is deleted or moved with the call.  */
2733       if (pass && (flags & ECF_LIBCALL_BLOCK))
2734         NO_DEFER_POP;
2735
2736 #ifdef FINAL_REG_PARM_STACK_SPACE
2737       reg_parm_stack_space = FINAL_REG_PARM_STACK_SPACE (args_size.constant,
2738                                                          args_size.var);
2739 #endif
2740       /* Precompute any arguments as needed.  */
2741       if (pass)
2742         precompute_arguments (flags, num_actuals, args);
2743
2744       /* Now we are about to start emitting insns that can be deleted
2745          if a libcall is deleted.  */
2746       if (pass && (flags & (ECF_LIBCALL_BLOCK | ECF_MALLOC)))
2747         start_sequence ();
2748
2749       adjusted_args_size = args_size;
2750       /* Compute the actual size of the argument block required.  The variable
2751          and constant sizes must be combined, the size may have to be rounded,
2752          and there may be a minimum required size.  When generating a sibcall
2753          pattern, do not round up, since we'll be re-using whatever space our
2754          caller provided.  */
2755       unadjusted_args_size
2756         = compute_argument_block_size (reg_parm_stack_space,
2757                                        &adjusted_args_size,
2758                                        (pass == 0 ? 0
2759                                         : preferred_stack_boundary));
2760
2761       old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
2762
2763       /* The argument block when performing a sibling call is the
2764          incoming argument block.  */
2765       if (pass == 0)
2766         {
2767           argblock = virtual_incoming_args_rtx;
2768           argblock
2769 #ifdef STACK_GROWS_DOWNWARD
2770             = plus_constant (argblock, current_function_pretend_args_size);
2771 #else
2772             = plus_constant (argblock, -current_function_pretend_args_size);
2773 #endif
2774           stored_args_map = sbitmap_alloc (args_size.constant);
2775           sbitmap_zero (stored_args_map);
2776         }
2777
2778       /* If we have no actual push instructions, or shouldn't use them,
2779          make space for all args right now.  */
2780       else if (adjusted_args_size.var != 0)
2781         {
2782           if (old_stack_level == 0)
2783             {
2784               emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
2785               old_stack_pointer_delta = stack_pointer_delta;
2786               old_pending_adj = pending_stack_adjust;
2787               pending_stack_adjust = 0;
2788               /* stack_arg_under_construction says whether a stack arg is
2789                  being constructed at the old stack level.  Pushing the stack
2790                  gets a clean outgoing argument block.  */
2791               old_stack_arg_under_construction = stack_arg_under_construction;
2792               stack_arg_under_construction = 0;
2793             }
2794           argblock = push_block (ARGS_SIZE_RTX (adjusted_args_size), 0, 0);
2795         }
2796       else
2797         {
2798           /* Note that we must go through the motions of allocating an argument
2799              block even if the size is zero because we may be storing args
2800              in the area reserved for register arguments, which may be part of
2801              the stack frame.  */
2802
2803           int needed = adjusted_args_size.constant;
2804
2805           /* Store the maximum argument space used.  It will be pushed by
2806              the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
2807              checking).  */
2808
2809           if (needed > current_function_outgoing_args_size)
2810             current_function_outgoing_args_size = needed;
2811
2812           if (must_preallocate)
2813             {
2814               if (ACCUMULATE_OUTGOING_ARGS)
2815                 {
2816                   /* Since the stack pointer will never be pushed, it is
2817                      possible for the evaluation of a parm to clobber
2818                      something we have already written to the stack.
2819                      Since most function calls on RISC machines do not use
2820                      the stack, this is uncommon, but must work correctly.
2821
2822                      Therefore, we save any area of the stack that was already
2823                      written and that we are using.  Here we set up to do this
2824                      by making a new stack usage map from the old one.  The
2825                      actual save will be done by store_one_arg.
2826
2827                      Another approach might be to try to reorder the argument
2828                      evaluations to avoid this conflicting stack usage.  */
2829
2830 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2831                   /* Since we will be writing into the entire argument area,
2832                      the map must be allocated for its entire size, not just
2833                      the part that is the responsibility of the caller.  */
2834                   needed += reg_parm_stack_space;
2835 #endif
2836
2837 #ifdef ARGS_GROW_DOWNWARD
2838                   highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
2839                                                      needed + 1);
2840 #else
2841                   highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
2842                                                      needed);
2843 #endif
2844                   stack_usage_map = alloca (highest_outgoing_arg_in_use);
2845
2846                   if (initial_highest_arg_in_use)
2847                     memcpy (stack_usage_map, initial_stack_usage_map,
2848                             initial_highest_arg_in_use);
2849
2850                   if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
2851                     memset (&stack_usage_map[initial_highest_arg_in_use], 0,
2852                            (highest_outgoing_arg_in_use
2853                             - initial_highest_arg_in_use));
2854                   needed = 0;
2855
2856                   /* The address of the outgoing argument list must not be
2857                      copied to a register here, because argblock would be left
2858                      pointing to the wrong place after the call to
2859                      allocate_dynamic_stack_space below.  */
2860
2861                   argblock = virtual_outgoing_args_rtx;
2862                 }
2863               else
2864                 {
2865                   if (inhibit_defer_pop == 0)
2866                     {
2867                       /* Try to reuse some or all of the pending_stack_adjust
2868                          to get this space.  */
2869                       needed
2870                         = (combine_pending_stack_adjustment_and_call
2871                            (unadjusted_args_size,
2872                             &adjusted_args_size,
2873                             preferred_unit_stack_boundary));
2874
2875                       /* combine_pending_stack_adjustment_and_call computes
2876                          an adjustment before the arguments are allocated.
2877                          Account for them and see whether or not the stack
2878                          needs to go up or down.  */
2879                       needed = unadjusted_args_size - needed;
2880
2881                       if (needed < 0)
2882                         {
2883                           /* We're releasing stack space.  */
2884                           /* ??? We can avoid any adjustment at all if we're
2885                              already aligned.  FIXME.  */
2886                           pending_stack_adjust = -needed;
2887                           do_pending_stack_adjust ();
2888                           needed = 0;
2889                         }
2890                       else
2891                         /* We need to allocate space.  We'll do that in
2892                            push_block below.  */
2893                         pending_stack_adjust = 0;
2894                     }
2895
2896                   /* Special case this because overhead of `push_block' in
2897                      this case is non-trivial.  */
2898                   if (needed == 0)
2899                     argblock = virtual_outgoing_args_rtx;
2900                   else
2901                     {
2902                       argblock = push_block (GEN_INT (needed), 0, 0);
2903 #ifdef ARGS_GROW_DOWNWARD
2904                       argblock = plus_constant (argblock, needed);
2905 #endif
2906                     }
2907
2908                   /* We only really need to call `copy_to_reg' in the case
2909                      where push insns are going to be used to pass ARGBLOCK
2910                      to a function call in ARGS.  In that case, the stack
2911                      pointer changes value from the allocation point to the
2912                      call point, and hence the value of
2913                      VIRTUAL_OUTGOING_ARGS_RTX changes as well.  But might
2914                      as well always do it.  */
2915                   argblock = copy_to_reg (argblock);
2916                 }
2917             }
2918         }
2919
2920       if (ACCUMULATE_OUTGOING_ARGS)
2921         {
2922           /* The save/restore code in store_one_arg handles all
2923              cases except one: a constructor call (including a C
2924              function returning a BLKmode struct) to initialize
2925              an argument.  */
2926           if (stack_arg_under_construction)
2927             {
2928 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2929               rtx push_size = GEN_INT (reg_parm_stack_space
2930                                        + adjusted_args_size.constant);
2931 #else
2932               rtx push_size = GEN_INT (adjusted_args_size.constant);
2933 #endif
2934               if (old_stack_level == 0)
2935                 {
2936                   emit_stack_save (SAVE_BLOCK, &old_stack_level,
2937                                    NULL_RTX);
2938                   old_stack_pointer_delta = stack_pointer_delta;
2939                   old_pending_adj = pending_stack_adjust;
2940                   pending_stack_adjust = 0;
2941                   /* stack_arg_under_construction says whether a stack
2942                      arg is being constructed at the old stack level.
2943                      Pushing the stack gets a clean outgoing argument
2944                      block.  */
2945                   old_stack_arg_under_construction
2946                     = stack_arg_under_construction;
2947                   stack_arg_under_construction = 0;
2948                   /* Make a new map for the new argument list.  */
2949                   stack_usage_map = alloca (highest_outgoing_arg_in_use);
2950                   memset (stack_usage_map, 0, highest_outgoing_arg_in_use);
2951                   highest_outgoing_arg_in_use = 0;
2952                 }
2953               allocate_dynamic_stack_space (push_size, NULL_RTX,
2954                                             BITS_PER_UNIT);
2955             }
2956
2957           /* If argument evaluation might modify the stack pointer,
2958              copy the address of the argument list to a register.  */
2959           for (i = 0; i < num_actuals; i++)
2960             if (args[i].pass_on_stack)
2961               {
2962                 argblock = copy_addr_to_reg (argblock);
2963                 break;
2964               }
2965         }
2966
2967       compute_argument_addresses (args, argblock, num_actuals);
2968
2969       /* If we push args individually in reverse order, perform stack alignment
2970          before the first push (the last arg).  */
2971       if (PUSH_ARGS_REVERSED && argblock == 0
2972           && adjusted_args_size.constant != unadjusted_args_size)
2973         {
2974           /* When the stack adjustment is pending, we get better code
2975              by combining the adjustments.  */
2976           if (pending_stack_adjust
2977               && ! (flags & ECF_LIBCALL_BLOCK)
2978               && ! inhibit_defer_pop)
2979             {
2980               pending_stack_adjust
2981                 = (combine_pending_stack_adjustment_and_call
2982                    (unadjusted_args_size,
2983                     &adjusted_args_size,
2984                     preferred_unit_stack_boundary));
2985               do_pending_stack_adjust ();
2986             }
2987           else if (argblock == 0)
2988             anti_adjust_stack (GEN_INT (adjusted_args_size.constant
2989                                         - unadjusted_args_size));
2990         }
2991       /* Now that the stack is properly aligned, pops can't safely
2992          be deferred during the evaluation of the arguments.  */
2993       NO_DEFER_POP;
2994
2995       funexp = rtx_for_function_call (fndecl, addr);
2996
2997       /* Figure out the register where the value, if any, will come back.  */
2998       valreg = 0;
2999       if (TYPE_MODE (TREE_TYPE (exp)) != VOIDmode
3000           && ! structure_value_addr)
3001         {
3002           if (pcc_struct_value)
3003             valreg = hard_function_value (build_pointer_type (TREE_TYPE (exp)),
3004                                           fndecl, (pass == 0));
3005           else
3006             valreg = hard_function_value (TREE_TYPE (exp), fndecl, (pass == 0));
3007         }
3008
3009       /* Precompute all register parameters.  It isn't safe to compute anything
3010          once we have started filling any specific hard regs.  */
3011       precompute_register_parameters (num_actuals, args, &reg_parm_seen);
3012
3013 #ifdef REG_PARM_STACK_SPACE
3014       /* Save the fixed argument area if it's part of the caller's frame and
3015          is clobbered by argument setup for this call.  */
3016       if (ACCUMULATE_OUTGOING_ARGS && pass)
3017         save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
3018                                               &low_to_save, &high_to_save);
3019 #endif
3020
3021       /* Now store (and compute if necessary) all non-register parms.
3022          These come before register parms, since they can require block-moves,
3023          which could clobber the registers used for register parms.
3024          Parms which have partial registers are not stored here,
3025          but we do preallocate space here if they want that.  */
3026
3027       for (i = 0; i < num_actuals; i++)
3028         if (args[i].reg == 0 || args[i].pass_on_stack)
3029           {
3030             rtx before_arg = get_last_insn ();
3031
3032             if (store_one_arg (&args[i], argblock, flags,
3033                                adjusted_args_size.var != 0,
3034                                reg_parm_stack_space)
3035                 || (pass == 0
3036                     && check_sibcall_argument_overlap (before_arg,
3037                                                        &args[i], 1)))
3038               sibcall_failure = 1;
3039
3040             if (flags & ECF_CONST
3041                 && args[i].stack
3042                 && args[i].value == args[i].stack)
3043               call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
3044                                                gen_rtx_USE (VOIDmode,
3045                                                             args[i].value),
3046                                                call_fusage);
3047           }
3048
3049       /* If we have a parm that is passed in registers but not in memory
3050          and whose alignment does not permit a direct copy into registers,
3051          make a group of pseudos that correspond to each register that we
3052          will later fill.  */
3053       if (STRICT_ALIGNMENT)
3054         store_unaligned_arguments_into_pseudos (args, num_actuals);
3055
3056       /* Now store any partially-in-registers parm.
3057          This is the last place a block-move can happen.  */
3058       if (reg_parm_seen)
3059         for (i = 0; i < num_actuals; i++)
3060           if (args[i].partial != 0 && ! args[i].pass_on_stack)
3061             {
3062               rtx before_arg = get_last_insn ();
3063
3064               if (store_one_arg (&args[i], argblock, flags,
3065                                  adjusted_args_size.var != 0,
3066                                  reg_parm_stack_space)
3067                   || (pass == 0
3068                       && check_sibcall_argument_overlap (before_arg,
3069                                                          &args[i], 1)))
3070                 sibcall_failure = 1;
3071             }
3072
3073       /* If we pushed args in forward order, perform stack alignment
3074          after pushing the last arg.  */
3075       if (!PUSH_ARGS_REVERSED && argblock == 0)
3076         anti_adjust_stack (GEN_INT (adjusted_args_size.constant
3077                                     - unadjusted_args_size));
3078
3079       /* If register arguments require space on the stack and stack space
3080          was not preallocated, allocate stack space here for arguments
3081          passed in registers.  */
3082 #ifdef OUTGOING_REG_PARM_STACK_SPACE
3083       if (!ACCUMULATE_OUTGOING_ARGS
3084           && must_preallocate == 0 && reg_parm_stack_space > 0)
3085         anti_adjust_stack (GEN_INT (reg_parm_stack_space));
3086 #endif
3087
3088       /* Pass the function the address in which to return a
3089          structure value.  */
3090       if (pass != 0 && structure_value_addr && ! structure_value_addr_parm)
3091         {
3092           structure_value_addr
3093             = convert_memory_address (Pmode, structure_value_addr);
3094           emit_move_insn (struct_value,
3095                           force_reg (Pmode,
3096                                      force_operand (structure_value_addr,
3097                                                     NULL_RTX)));
3098
3099           if (GET_CODE (struct_value) == REG)
3100             use_reg (&call_fusage, struct_value);
3101         }
3102
3103       funexp = prepare_call_address (funexp, fndecl, &call_fusage,
3104                                      reg_parm_seen, pass == 0);
3105
3106       load_register_parameters (args, num_actuals, &call_fusage, flags,
3107                                 pass == 0, &sibcall_failure);
3108
3109       /* Perform postincrements before actually calling the function.  */
3110       emit_queue ();
3111
3112       /* Save a pointer to the last insn before the call, so that we can
3113          later safely search backwards to find the CALL_INSN.  */
3114       before_call = get_last_insn ();
3115
3116       /* Set up next argument register.  For sibling calls on machines
3117          with register windows this should be the incoming register.  */
3118 #ifdef FUNCTION_INCOMING_ARG
3119       if (pass == 0)
3120         next_arg_reg = FUNCTION_INCOMING_ARG (args_so_far, VOIDmode,
3121                                               void_type_node, 1);
3122       else
3123 #endif
3124         next_arg_reg = FUNCTION_ARG (args_so_far, VOIDmode,
3125                                      void_type_node, 1);
3126
3127       /* All arguments and registers used for the call must be set up by
3128          now!  */
3129
3130       /* Stack must be properly aligned now.  */
3131       if (pass && stack_pointer_delta % preferred_unit_stack_boundary)
3132         abort ();
3133
3134       /* Generate the actual call instruction.  */
3135       emit_call_1 (funexp, fndecl, funtype, unadjusted_args_size,
3136                    adjusted_args_size.constant, struct_value_size,
3137                    next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
3138                    flags, & args_so_far);
3139
3140       /* If call is cse'able, make appropriate pair of reg-notes around it.
3141          Test valreg so we don't crash; may safely ignore `const'
3142          if return type is void.  Disable for PARALLEL return values, because
3143          we have no way to move such values into a pseudo register.  */
3144       if (pass && (flags & ECF_LIBCALL_BLOCK))
3145         {
3146           rtx insns;
3147           rtx insn;
3148           bool failed = valreg == 0 || GET_CODE (valreg) == PARALLEL;
3149
3150           insns = get_insns ();
3151
3152           /* Expansion of block moves possibly introduced a loop that may
3153              not appear inside libcall block.  */
3154           for (insn = insns; insn; insn = NEXT_INSN (insn))
3155             if (GET_CODE (insn) == JUMP_INSN)
3156               failed = true;
3157
3158           if (failed)
3159             {
3160               end_sequence ();
3161               emit_insn (insns);
3162             }
3163           else
3164             {
3165               rtx note = 0;
3166               rtx temp = gen_reg_rtx (GET_MODE (valreg));
3167
3168               /* Mark the return value as a pointer if needed.  */
3169               if (TREE_CODE (TREE_TYPE (exp)) == POINTER_TYPE)
3170                 mark_reg_pointer (temp,
3171                                   TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp))));
3172
3173               end_sequence ();
3174               if (flag_unsafe_math_optimizations
3175                   && fndecl
3176                   && DECL_BUILT_IN (fndecl)
3177                   && (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_SQRT
3178                       || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_SQRTF
3179                       || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_SQRTL))
3180                 note = gen_rtx_fmt_e (SQRT,
3181                                       GET_MODE (temp),
3182                                       args[0].initial_value);
3183               else
3184                 {
3185                   /* Construct an "equal form" for the value which
3186                      mentions all the arguments in order as well as
3187                      the function name.  */
3188                   for (i = 0; i < num_actuals; i++)
3189                     note = gen_rtx_EXPR_LIST (VOIDmode,
3190                                               args[i].initial_value, note);
3191                   note = gen_rtx_EXPR_LIST (VOIDmode, funexp, note);
3192
3193                   if (flags & ECF_PURE)
3194                     note = gen_rtx_EXPR_LIST (VOIDmode,
3195                         gen_rtx_USE (VOIDmode,
3196                                      gen_rtx_MEM (BLKmode,
3197                                                   gen_rtx_SCRATCH (VOIDmode))),
3198                         note);
3199                 }
3200               emit_libcall_block (insns, temp, valreg, note);
3201
3202               valreg = temp;
3203             }
3204         }
3205       else if (pass && (flags & ECF_MALLOC))
3206         {
3207           rtx temp = gen_reg_rtx (GET_MODE (valreg));
3208           rtx last, insns;
3209
3210           /* The return value from a malloc-like function is a pointer.  */
3211           if (TREE_CODE (TREE_TYPE (exp)) == POINTER_TYPE)
3212             mark_reg_pointer (temp, BIGGEST_ALIGNMENT);
3213
3214           emit_move_insn (temp, valreg);
3215
3216           /* The return value from a malloc-like function can not alias
3217              anything else.  */
3218           last = get_last_insn ();
3219           REG_NOTES (last) =
3220             gen_rtx_EXPR_LIST (REG_NOALIAS, temp, REG_NOTES (last));
3221
3222           /* Write out the sequence.  */
3223           insns = get_insns ();
3224           end_sequence ();
3225           emit_insn (insns);
3226           valreg = temp;
3227         }
3228
3229       /* For calls to `setjmp', etc., inform flow.c it should complain
3230          if nonvolatile values are live.  For functions that cannot return,
3231          inform flow that control does not fall through.  */
3232
3233       if ((flags & (ECF_NORETURN | ECF_LONGJMP)) || pass == 0)
3234         {
3235           /* The barrier must be emitted
3236              immediately after the CALL_INSN.  Some ports emit more
3237              than just a CALL_INSN above, so we must search for it here.  */
3238
3239           rtx last = get_last_insn ();
3240           while (GET_CODE (last) != CALL_INSN)
3241             {
3242               last = PREV_INSN (last);
3243               /* There was no CALL_INSN?  */
3244               if (last == before_call)
3245                 abort ();
3246             }
3247
3248           emit_barrier_after (last);
3249
3250           /* Stack adjustments after a noreturn call are dead code.
3251              However when NO_DEFER_POP is in effect, we must preserve
3252              stack_pointer_delta.  */
3253           if (inhibit_defer_pop == 0)
3254             {
3255               stack_pointer_delta = old_stack_allocated;
3256               pending_stack_adjust = 0;
3257             }
3258         }
3259
3260       if (flags & ECF_LONGJMP)
3261         current_function_calls_longjmp = 1;
3262
3263       /* If value type not void, return an rtx for the value.  */
3264
3265       /* If there are cleanups to be called, don't use a hard reg as target.
3266          We need to double check this and see if it matters anymore.  */
3267       if (any_pending_cleanups ())
3268         {
3269           if (target && REG_P (target)
3270               && REGNO (target) < FIRST_PSEUDO_REGISTER)
3271             target = 0;
3272           sibcall_failure = 1;
3273         }
3274
3275       if (TYPE_MODE (TREE_TYPE (exp)) == VOIDmode
3276           || ignore)
3277         target = const0_rtx;
3278       else if (structure_value_addr)
3279         {
3280           if (target == 0 || GET_CODE (target) != MEM)
3281             {
3282               target
3283                 = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
3284                                memory_address (TYPE_MODE (TREE_TYPE (exp)),
3285                                                structure_value_addr));
3286               set_mem_attributes (target, exp, 1);
3287             }
3288         }
3289       else if (pcc_struct_value)
3290         {
3291           /* This is the special C++ case where we need to
3292              know what the true target was.  We take care to
3293              never use this value more than once in one expression.  */
3294           target = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
3295                                 copy_to_reg (valreg));
3296           set_mem_attributes (target, exp, 1);
3297         }
3298       /* Handle calls that return values in multiple non-contiguous locations.
3299          The Irix 6 ABI has examples of this.  */
3300       else if (GET_CODE (valreg) == PARALLEL)
3301         {
3302           /* Second condition is added because "target" is freed at the
3303              the end of "pass0" for -O2 when call is made to
3304              expand_end_target_temps ().  Its "in_use" flag has been set
3305              to false, so allocate a new temp.  */
3306           if (target == 0 || (pass == 1 && target == temp_target))
3307             {
3308               /* This will only be assigned once, so it can be readonly.  */
3309               tree nt = build_qualified_type (TREE_TYPE (exp),
3310                                               (TYPE_QUALS (TREE_TYPE (exp))
3311                                                | TYPE_QUAL_CONST));
3312
3313               target = assign_temp (nt, 0, 1, 1);
3314               temp_target = target;
3315               preserve_temp_slots (target);
3316             }
3317
3318           if (! rtx_equal_p (target, valreg))
3319             emit_group_store (target, valreg, TREE_TYPE (exp),
3320                               int_size_in_bytes (TREE_TYPE (exp)));
3321
3322           /* We can not support sibling calls for this case.  */
3323           sibcall_failure = 1;
3324         }
3325       else if (target
3326                && GET_MODE (target) == TYPE_MODE (TREE_TYPE (exp))
3327                && GET_MODE (target) == GET_MODE (valreg))
3328         {
3329           /* TARGET and VALREG cannot be equal at this point because the
3330              latter would not have REG_FUNCTION_VALUE_P true, while the
3331              former would if it were referring to the same register.
3332
3333              If they refer to the same register, this move will be a no-op,
3334              except when function inlining is being done.  */
3335           emit_move_insn (target, valreg);
3336
3337           /* If we are setting a MEM, this code must be executed.  Since it is
3338              emitted after the call insn, sibcall optimization cannot be
3339              performed in that case.  */
3340           if (GET_CODE (target) == MEM)
3341             sibcall_failure = 1;
3342         }
3343       else if (TYPE_MODE (TREE_TYPE (exp)) == BLKmode)
3344         {
3345           target = copy_blkmode_from_reg (target, valreg, TREE_TYPE (exp));
3346
3347           /* We can not support sibling calls for this case.  */
3348           sibcall_failure = 1;
3349         }
3350       else
3351         {
3352           if (shift_returned_value (TREE_TYPE (exp), &valreg))
3353             sibcall_failure = 1;
3354
3355           target = copy_to_reg (valreg);
3356         }
3357
3358       if (targetm.calls.promote_function_return(funtype))
3359         {
3360       /* If we promoted this return value, make the proper SUBREG.  TARGET
3361          might be const0_rtx here, so be careful.  */
3362       if (GET_CODE (target) == REG
3363           && TYPE_MODE (TREE_TYPE (exp)) != BLKmode
3364           && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
3365         {
3366           tree type = TREE_TYPE (exp);
3367           int unsignedp = TREE_UNSIGNED (type);
3368           int offset = 0;
3369
3370           /* If we don't promote as expected, something is wrong.  */
3371           if (GET_MODE (target)
3372               != promote_mode (type, TYPE_MODE (type), &unsignedp, 1))
3373             abort ();
3374
3375         if ((WORDS_BIG_ENDIAN || BYTES_BIG_ENDIAN)
3376             && GET_MODE_SIZE (GET_MODE (target))
3377                > GET_MODE_SIZE (TYPE_MODE (type)))
3378           {
3379             offset = GET_MODE_SIZE (GET_MODE (target))
3380                      - GET_MODE_SIZE (TYPE_MODE (type));
3381             if (! BYTES_BIG_ENDIAN)
3382               offset = (offset / UNITS_PER_WORD) * UNITS_PER_WORD;
3383             else if (! WORDS_BIG_ENDIAN)
3384               offset %= UNITS_PER_WORD;
3385           }
3386           target = gen_rtx_SUBREG (TYPE_MODE (type), target, offset);
3387           SUBREG_PROMOTED_VAR_P (target) = 1;
3388           SUBREG_PROMOTED_UNSIGNED_SET (target, unsignedp);
3389         }
3390         }
3391
3392       /* If size of args is variable or this was a constructor call for a stack
3393          argument, restore saved stack-pointer value.  */
3394
3395       if (old_stack_level && ! (flags & ECF_SP_DEPRESSED))
3396         {
3397           emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
3398           stack_pointer_delta = old_stack_pointer_delta;
3399           pending_stack_adjust = old_pending_adj;
3400           stack_arg_under_construction = old_stack_arg_under_construction;
3401           highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3402           stack_usage_map = initial_stack_usage_map;
3403           sibcall_failure = 1;
3404         }
3405       else if (ACCUMULATE_OUTGOING_ARGS && pass)
3406         {
3407 #ifdef REG_PARM_STACK_SPACE
3408           if (save_area)
3409             restore_fixed_argument_area (save_area, argblock,
3410                                          high_to_save, low_to_save);
3411 #endif
3412
3413           /* If we saved any argument areas, restore them.  */
3414           for (i = 0; i < num_actuals; i++)
3415             if (args[i].save_area)
3416               {
3417                 enum machine_mode save_mode = GET_MODE (args[i].save_area);
3418                 rtx stack_area
3419                   = gen_rtx_MEM (save_mode,
3420                                  memory_address (save_mode,
3421                                                  XEXP (args[i].stack_slot, 0)));
3422
3423                 if (save_mode != BLKmode)
3424                   emit_move_insn (stack_area, args[i].save_area);
3425                 else
3426                   emit_block_move (stack_area, args[i].save_area,
3427                                    GEN_INT (args[i].locate.size.constant),
3428                                    BLOCK_OP_CALL_PARM);
3429               }
3430
3431           highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3432           stack_usage_map = initial_stack_usage_map;
3433         }
3434
3435       /* If this was alloca, record the new stack level for nonlocal gotos.
3436          Check for the handler slots since we might not have a save area
3437          for non-local gotos.  */
3438
3439       if ((flags & ECF_MAY_BE_ALLOCA) && nonlocal_goto_handler_slots != 0)
3440         emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
3441
3442       /* Free up storage we no longer need.  */
3443       for (i = 0; i < num_actuals; ++i)
3444         if (args[i].aligned_regs)
3445           free (args[i].aligned_regs);
3446
3447       if (pass == 0)
3448         {
3449           /* Undo the fake expand_start_target_temps we did earlier.  If
3450              there had been any cleanups created, we've already set
3451              sibcall_failure.  */
3452           expand_end_target_temps ();
3453         }
3454
3455       /* If this function is returning into a memory location marked as
3456          readonly, it means it is initializing that location. We normally treat
3457          functions as not clobbering such locations, so we need to specify that
3458          this one does. We do this by adding the appropriate CLOBBER to the
3459          CALL_INSN function usage list.  This cannot be done by emitting a
3460          standalone CLOBBER after the call because the latter would be ignored
3461          by at least the delay slot scheduling pass. We do this now instead of
3462          adding to call_fusage before the call to emit_call_1 because TARGET
3463          may be modified in the meantime.  */
3464       if (structure_value_addr != 0 && target != 0
3465           && GET_CODE (target) == MEM && RTX_UNCHANGING_P (target))
3466         add_function_usage_to
3467           (last_call_insn (),
3468            gen_rtx_EXPR_LIST (VOIDmode, gen_rtx_CLOBBER (VOIDmode, target),
3469                               NULL_RTX));
3470
3471       insns = get_insns ();
3472       end_sequence ();
3473
3474       if (pass == 0)
3475         {
3476           tail_call_insns = insns;
3477
3478           /* Restore the pending stack adjustment now that we have
3479              finished generating the sibling call sequence.  */
3480
3481           pending_stack_adjust = save_pending_stack_adjust;
3482           stack_pointer_delta = save_stack_pointer_delta;
3483
3484           /* Prepare arg structure for next iteration.  */
3485           for (i = 0; i < num_actuals; i++)
3486             {
3487               args[i].value = 0;
3488               args[i].aligned_regs = 0;
3489               args[i].stack = 0;
3490             }
3491
3492           sbitmap_free (stored_args_map);
3493         }
3494       else
3495         {
3496           normal_call_insns = insns;
3497
3498           /* Verify that we've deallocated all the stack we used.  */
3499           if (! (flags & (ECF_NORETURN | ECF_LONGJMP))
3500               && old_stack_allocated != stack_pointer_delta
3501                                         - pending_stack_adjust)
3502             abort ();
3503         }
3504
3505       /* If something prevents making this a sibling call,
3506          zero out the sequence.  */
3507       if (sibcall_failure)
3508         tail_call_insns = NULL_RTX;
3509     }
3510
3511   /* The function optimize_sibling_and_tail_recursive_calls doesn't
3512      handle CALL_PLACEHOLDERs inside other CALL_PLACEHOLDERs.  This
3513      can happen if the arguments to this function call an inline
3514      function who's expansion contains another CALL_PLACEHOLDER.
3515
3516      If there are any C_Ps in any of these sequences, replace them
3517      with their normal call.  */
3518
3519   for (insn = normal_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_call_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   for (insn = tail_recursion_insns; insn; insn = NEXT_INSN (insn))
3530     if (GET_CODE (insn) == CALL_INSN
3531         && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
3532       replace_call_placeholder (insn, sibcall_use_normal);
3533
3534   /* If this was a potential tail recursion site, then emit a
3535      CALL_PLACEHOLDER with the normal and the tail recursion streams.
3536      One of them will be selected later.  */
3537   if (tail_recursion_insns || tail_call_insns)
3538     {
3539       /* The tail recursion label must be kept around.  We could expose
3540          its use in the CALL_PLACEHOLDER, but that creates unwanted edges
3541          and makes determining true tail recursion sites difficult.
3542
3543          So we set LABEL_PRESERVE_P here, then clear it when we select
3544          one of the call sequences after rtl generation is complete.  */
3545       if (tail_recursion_insns)
3546         LABEL_PRESERVE_P (tail_recursion_label) = 1;
3547       emit_call_insn (gen_rtx_CALL_PLACEHOLDER (VOIDmode, normal_call_insns,
3548                                                 tail_call_insns,
3549                                                 tail_recursion_insns,
3550                                                 tail_recursion_label));
3551     }
3552   else
3553     emit_insn (normal_call_insns);
3554
3555   currently_expanding_call--;
3556
3557   /* If this function returns with the stack pointer depressed, ensure
3558      this block saves and restores the stack pointer, show it was
3559      changed, and adjust for any outgoing arg space.  */
3560   if (flags & ECF_SP_DEPRESSED)
3561     {
3562       clear_pending_stack_adjust ();
3563       emit_insn (gen_rtx_CLOBBER (VOIDmode, stack_pointer_rtx));
3564       emit_move_insn (virtual_stack_dynamic_rtx, stack_pointer_rtx);
3565       save_stack_pointer ();
3566     }
3567
3568   return target;
3569 }
3570
3571 /* Traverse an argument list in VALUES and expand all complex
3572    arguments into their components.  */
3573 tree
3574 split_complex_values (tree values)
3575 {
3576   tree p;
3577
3578   values = copy_list (values);
3579
3580   for (p = values; p; p = TREE_CHAIN (p))
3581     {
3582       tree complex_value = TREE_VALUE (p);
3583       tree complex_type;
3584
3585       complex_type = TREE_TYPE (complex_value);
3586       if (!complex_type)
3587         continue;
3588
3589       if (TREE_CODE (complex_type) == COMPLEX_TYPE)
3590         {
3591           tree subtype;
3592           tree real, imag, next;
3593
3594           subtype = TREE_TYPE (complex_type);
3595           complex_value = save_expr (complex_value);
3596           real = build1 (REALPART_EXPR, subtype, complex_value);
3597           imag = build1 (IMAGPART_EXPR, subtype, complex_value);
3598
3599           TREE_VALUE (p) = real;
3600           next = TREE_CHAIN (p);
3601           imag = build_tree_list (NULL_TREE, imag);
3602           TREE_CHAIN (p) = imag;
3603           TREE_CHAIN (imag) = next;
3604
3605           /* Skip the newly created node.  */
3606           p = TREE_CHAIN (p);
3607         }
3608     }
3609
3610   return values;
3611 }
3612
3613 /* Traverse a list of TYPES and expand all complex types into their
3614    components.  */
3615 tree
3616 split_complex_types (tree types)
3617 {
3618   tree p;
3619
3620   types = copy_list (types);
3621
3622   for (p = types; p; p = TREE_CHAIN (p))
3623     {
3624       tree complex_type = TREE_VALUE (p);
3625
3626       if (TREE_CODE (complex_type) == COMPLEX_TYPE)
3627         {
3628           tree next, imag;
3629
3630           /* Rewrite complex type with component type.  */
3631           TREE_VALUE (p) = TREE_TYPE (complex_type);
3632           next = TREE_CHAIN (p);
3633
3634           /* Add another component type for the imaginary part.  */
3635           imag = build_tree_list (NULL_TREE, TREE_VALUE (p));
3636           TREE_CHAIN (p) = imag;
3637           TREE_CHAIN (imag) = next;
3638
3639           /* Skip the newly created node.  */
3640           p = TREE_CHAIN (p);
3641         }
3642     }
3643
3644   return types;
3645 }
3646 \f
3647 /* Output a library call to function FUN (a SYMBOL_REF rtx).
3648    The RETVAL parameter specifies whether return value needs to be saved, other
3649    parameters are documented in the emit_library_call function below.  */
3650
3651 static rtx
3652 emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
3653                            enum libcall_type fn_type,
3654                            enum machine_mode outmode, int nargs, va_list p)
3655 {
3656   /* Total size in bytes of all the stack-parms scanned so far.  */
3657   struct args_size args_size;
3658   /* Size of arguments before any adjustments (such as rounding).  */
3659   struct args_size original_args_size;
3660   int argnum;
3661   rtx fun;
3662   int inc;
3663   int count;
3664   rtx argblock = 0;
3665   CUMULATIVE_ARGS args_so_far;
3666   struct arg
3667   {
3668     rtx value;
3669     enum machine_mode mode;
3670     rtx reg;
3671     int partial;
3672     struct locate_and_pad_arg_data locate;
3673     rtx save_area;
3674   };
3675   struct arg *argvec;
3676   int old_inhibit_defer_pop = inhibit_defer_pop;
3677   rtx call_fusage = 0;
3678   rtx mem_value = 0;
3679   rtx valreg;
3680   int pcc_struct_value = 0;
3681   int struct_value_size = 0;
3682   int flags;
3683   int reg_parm_stack_space = 0;
3684   int needed;
3685   rtx before_call;
3686   tree tfom;                    /* type_for_mode (outmode, 0) */
3687
3688 #ifdef REG_PARM_STACK_SPACE
3689   /* Define the boundary of the register parm stack space that needs to be
3690      save, if any.  */
3691   int low_to_save, high_to_save;
3692   rtx save_area = 0;            /* Place that it is saved.  */
3693 #endif
3694
3695   /* Size of the stack reserved for parameter registers.  */
3696   int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
3697   char *initial_stack_usage_map = stack_usage_map;
3698
3699   rtx struct_value = targetm.calls.struct_value_rtx (0, 0);
3700
3701 #ifdef REG_PARM_STACK_SPACE
3702 #ifdef MAYBE_REG_PARM_STACK_SPACE
3703   reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
3704 #else
3705   reg_parm_stack_space = REG_PARM_STACK_SPACE ((tree) 0);
3706 #endif
3707 #endif
3708
3709   /* By default, library functions can not throw.  */
3710   flags = ECF_NOTHROW;
3711
3712   switch (fn_type)
3713     {
3714     case LCT_NORMAL:
3715       break;
3716     case LCT_CONST:
3717       flags |= ECF_CONST;
3718       break;
3719     case LCT_PURE:
3720       flags |= ECF_PURE;
3721       break;
3722     case LCT_CONST_MAKE_BLOCK:
3723       flags |= ECF_CONST | ECF_LIBCALL_BLOCK;
3724       break;
3725     case LCT_PURE_MAKE_BLOCK:
3726       flags |= ECF_PURE | ECF_LIBCALL_BLOCK;
3727       break;
3728     case LCT_NORETURN:
3729       flags |= ECF_NORETURN;
3730       break;
3731     case LCT_THROW:
3732       flags = ECF_NORETURN;
3733       break;
3734     case LCT_ALWAYS_RETURN:
3735       flags = ECF_ALWAYS_RETURN;
3736       break;
3737     case LCT_RETURNS_TWICE:
3738       flags = ECF_RETURNS_TWICE;
3739       break;
3740     }
3741   fun = orgfun;
3742
3743   /* Ensure current function's preferred stack boundary is at least
3744      what we need.  */
3745   if (cfun->preferred_stack_boundary < PREFERRED_STACK_BOUNDARY)
3746     cfun->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
3747
3748   /* If this kind of value comes back in memory,
3749      decide where in memory it should come back.  */
3750   if (outmode != VOIDmode)
3751     {
3752       tfom = (*lang_hooks.types.type_for_mode) (outmode, 0);
3753       if (aggregate_value_p (tfom, 0))
3754         {
3755 #ifdef PCC_STATIC_STRUCT_RETURN
3756           rtx pointer_reg
3757             = hard_function_value (build_pointer_type (tfom), 0, 0);
3758           mem_value = gen_rtx_MEM (outmode, pointer_reg);
3759           pcc_struct_value = 1;
3760           if (value == 0)
3761             value = gen_reg_rtx (outmode);
3762 #else /* not PCC_STATIC_STRUCT_RETURN */
3763           struct_value_size = GET_MODE_SIZE (outmode);
3764           if (value != 0 && GET_CODE (value) == MEM)
3765             mem_value = value;
3766           else
3767             mem_value = assign_temp (tfom, 0, 1, 1);
3768 #endif
3769           /* This call returns a big structure.  */
3770           flags &= ~(ECF_CONST | ECF_PURE | ECF_LIBCALL_BLOCK);
3771         }
3772     }
3773   else
3774     tfom = void_type_node;
3775
3776   /* ??? Unfinished: must pass the memory address as an argument.  */
3777
3778   /* Copy all the libcall-arguments out of the varargs data
3779      and into a vector ARGVEC.
3780
3781      Compute how to pass each argument.  We only support a very small subset
3782      of the full argument passing conventions to limit complexity here since
3783      library functions shouldn't have many args.  */
3784
3785   argvec = alloca ((nargs + 1) * sizeof (struct arg));
3786   memset (argvec, 0, (nargs + 1) * sizeof (struct arg));
3787
3788 #ifdef INIT_CUMULATIVE_LIBCALL_ARGS
3789   INIT_CUMULATIVE_LIBCALL_ARGS (args_so_far, outmode, fun);
3790 #else
3791   INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE, fun, 0, nargs);
3792 #endif
3793
3794   args_size.constant = 0;
3795   args_size.var = 0;
3796
3797   count = 0;
3798
3799   /* Now we are about to start emitting insns that can be deleted
3800      if a libcall is deleted.  */
3801   if (flags & ECF_LIBCALL_BLOCK)
3802     start_sequence ();
3803
3804   push_temp_slots ();
3805
3806   /* If there's a structure value address to be passed,
3807      either pass it in the special place, or pass it as an extra argument.  */
3808   if (mem_value && struct_value == 0 && ! pcc_struct_value)
3809     {
3810       rtx addr = XEXP (mem_value, 0);
3811       nargs++;
3812
3813       /* Make sure it is a reasonable operand for a move or push insn.  */
3814       if (GET_CODE (addr) != REG && GET_CODE (addr) != MEM
3815           && ! (CONSTANT_P (addr) && LEGITIMATE_CONSTANT_P (addr)))
3816         addr = force_operand (addr, NULL_RTX);
3817
3818       argvec[count].value = addr;
3819       argvec[count].mode = Pmode;
3820       argvec[count].partial = 0;
3821
3822       argvec[count].reg = FUNCTION_ARG (args_so_far, Pmode, NULL_TREE, 1);
3823 #ifdef FUNCTION_ARG_PARTIAL_NREGS
3824       if (FUNCTION_ARG_PARTIAL_NREGS (args_so_far, Pmode, NULL_TREE, 1))
3825         abort ();
3826 #endif
3827
3828       locate_and_pad_parm (Pmode, NULL_TREE,
3829 #ifdef STACK_PARMS_IN_REG_PARM_AREA
3830                            1,
3831 #else
3832                            argvec[count].reg != 0,
3833 #endif
3834                            0, NULL_TREE, &args_size, &argvec[count].locate);
3835
3836       if (argvec[count].reg == 0 || argvec[count].partial != 0
3837           || reg_parm_stack_space > 0)
3838         args_size.constant += argvec[count].locate.size.constant;
3839
3840       FUNCTION_ARG_ADVANCE (args_so_far, Pmode, (tree) 0, 1);
3841
3842       count++;
3843     }
3844
3845   for (; count < nargs; count++)
3846     {
3847       rtx val = va_arg (p, rtx);
3848       enum machine_mode mode = va_arg (p, enum machine_mode);
3849
3850       /* We cannot convert the arg value to the mode the library wants here;
3851          must do it earlier where we know the signedness of the arg.  */
3852       if (mode == BLKmode
3853           || (GET_MODE (val) != mode && GET_MODE (val) != VOIDmode))
3854         abort ();
3855
3856       /* There's no need to call protect_from_queue, because
3857          either emit_move_insn or emit_push_insn will do that.  */
3858
3859       /* Make sure it is a reasonable operand for a move or push insn.  */
3860       if (GET_CODE (val) != REG && GET_CODE (val) != MEM
3861           && ! (CONSTANT_P (val) && LEGITIMATE_CONSTANT_P (val)))
3862         val = force_operand (val, NULL_RTX);
3863
3864 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
3865       if (FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, mode, NULL_TREE, 1))
3866         {
3867           rtx slot;
3868           int must_copy = 1
3869 #ifdef FUNCTION_ARG_CALLEE_COPIES
3870             && ! FUNCTION_ARG_CALLEE_COPIES (args_so_far, mode,
3871                                              NULL_TREE, 1)
3872 #endif
3873             ;
3874
3875           /* loop.c won't look at CALL_INSN_FUNCTION_USAGE of const/pure
3876              functions, so we have to pretend this isn't such a function.  */
3877           if (flags & ECF_LIBCALL_BLOCK)
3878             {
3879               rtx insns = get_insns ();
3880               end_sequence ();
3881               emit_insn (insns);
3882             }
3883           flags &= ~(ECF_CONST | ECF_PURE | ECF_LIBCALL_BLOCK);
3884
3885           /* If this was a CONST function, it is now PURE since
3886              it now reads memory.  */
3887           if (flags & ECF_CONST)
3888             {
3889               flags &= ~ECF_CONST;
3890               flags |= ECF_PURE;
3891             }
3892
3893           if (GET_MODE (val) == MEM && ! must_copy)
3894             slot = val;
3895           else if (must_copy)
3896             {
3897               slot = assign_temp ((*lang_hooks.types.type_for_mode) (mode, 0),
3898                                   0, 1, 1);
3899               emit_move_insn (slot, val);
3900             }
3901           else
3902             {
3903               tree type = (*lang_hooks.types.type_for_mode) (mode, 0);
3904
3905               slot
3906                 = gen_rtx_MEM (mode,
3907                                expand_expr (build1 (ADDR_EXPR,
3908                                                     build_pointer_type (type),
3909                                                     make_tree (type, val)),
3910                                             NULL_RTX, VOIDmode, 0));
3911             }
3912
3913           call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
3914                                            gen_rtx_USE (VOIDmode, slot),
3915                                            call_fusage);
3916           if (must_copy)
3917             call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
3918                                              gen_rtx_CLOBBER (VOIDmode,
3919                                                               slot),
3920                                              call_fusage);
3921
3922           mode = Pmode;
3923           val = force_operand (XEXP (slot, 0), NULL_RTX);
3924         }
3925 #endif
3926
3927       argvec[count].value = val;
3928       argvec[count].mode = mode;
3929
3930       argvec[count].reg = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1);
3931
3932 #ifdef FUNCTION_ARG_PARTIAL_NREGS
3933       argvec[count].partial
3934         = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, NULL_TREE, 1);
3935 #else
3936       argvec[count].partial = 0;
3937 #endif
3938
3939       locate_and_pad_parm (mode, NULL_TREE,
3940 #ifdef STACK_PARMS_IN_REG_PARM_AREA
3941                            1,
3942 #else
3943                            argvec[count].reg != 0,
3944 #endif
3945                            argvec[count].partial,
3946                            NULL_TREE, &args_size, &argvec[count].locate);
3947
3948       if (argvec[count].locate.size.var)
3949         abort ();
3950
3951       if (argvec[count].reg == 0 || argvec[count].partial != 0
3952           || reg_parm_stack_space > 0)
3953         args_size.constant += argvec[count].locate.size.constant;
3954
3955       FUNCTION_ARG_ADVANCE (args_so_far, mode, (tree) 0, 1);
3956     }
3957
3958 #ifdef FINAL_REG_PARM_STACK_SPACE
3959   reg_parm_stack_space = FINAL_REG_PARM_STACK_SPACE (args_size.constant,
3960                                                      args_size.var);
3961 #endif
3962   /* If this machine requires an external definition for library
3963      functions, write one out.  */
3964   assemble_external_libcall (fun);
3965
3966   original_args_size = args_size;
3967   args_size.constant = (((args_size.constant
3968                           + stack_pointer_delta
3969                           + STACK_BYTES - 1)
3970                           / STACK_BYTES
3971                           * STACK_BYTES)
3972                          - stack_pointer_delta);
3973
3974   args_size.constant = MAX (args_size.constant,
3975                             reg_parm_stack_space);
3976
3977 #ifndef OUTGOING_REG_PARM_STACK_SPACE
3978   args_size.constant -= reg_parm_stack_space;
3979 #endif
3980
3981   if (args_size.constant > current_function_outgoing_args_size)
3982     current_function_outgoing_args_size = args_size.constant;
3983
3984   if (ACCUMULATE_OUTGOING_ARGS)
3985     {
3986       /* Since the stack pointer will never be pushed, it is possible for
3987          the evaluation of a parm to clobber something we have already
3988          written to the stack.  Since most function calls on RISC machines
3989          do not use the stack, this is uncommon, but must work correctly.
3990
3991          Therefore, we save any area of the stack that was already written
3992          and that we are using.  Here we set up to do this by making a new
3993          stack usage map from the old one.
3994
3995          Another approach might be to try to reorder the argument
3996          evaluations to avoid this conflicting stack usage.  */
3997
3998       needed = args_size.constant;
3999
4000 #ifndef OUTGOING_REG_PARM_STACK_SPACE
4001       /* Since we will be writing into the entire argument area, the
4002          map must be allocated for its entire size, not just the part that
4003          is the responsibility of the caller.  */
4004       needed += reg_parm_stack_space;
4005 #endif
4006
4007 #ifdef ARGS_GROW_DOWNWARD
4008       highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
4009                                          needed + 1);
4010 #else
4011       highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
4012                                          needed);
4013 #endif
4014       stack_usage_map = alloca (highest_outgoing_arg_in_use);
4015
4016       if (initial_highest_arg_in_use)
4017         memcpy (stack_usage_map, initial_stack_usage_map,
4018                 initial_highest_arg_in_use);
4019
4020       if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
4021         memset (&stack_usage_map[initial_highest_arg_in_use], 0,
4022                highest_outgoing_arg_in_use - initial_highest_arg_in_use);
4023       needed = 0;
4024
4025       /* We must be careful to use virtual regs before they're instantiated,
4026          and real regs afterwards.  Loop optimization, for example, can create
4027          new libcalls after we've instantiated the virtual regs, and if we
4028          use virtuals anyway, they won't match the rtl patterns.  */
4029
4030       if (virtuals_instantiated)
4031         argblock = plus_constant (stack_pointer_rtx, STACK_POINTER_OFFSET);
4032       else
4033         argblock = virtual_outgoing_args_rtx;
4034     }
4035   else
4036     {
4037       if (!PUSH_ARGS)
4038         argblock = push_block (GEN_INT (args_size.constant), 0, 0);
4039     }
4040
4041   /* If we push args individually in reverse order, perform stack alignment
4042      before the first push (the last arg).  */
4043   if (argblock == 0 && PUSH_ARGS_REVERSED)
4044     anti_adjust_stack (GEN_INT (args_size.constant
4045                                 - original_args_size.constant));
4046
4047   if (PUSH_ARGS_REVERSED)
4048     {
4049       inc = -1;
4050       argnum = nargs - 1;
4051     }
4052   else
4053     {
4054       inc = 1;
4055       argnum = 0;
4056     }
4057
4058 #ifdef REG_PARM_STACK_SPACE
4059   if (ACCUMULATE_OUTGOING_ARGS)
4060     {
4061       /* The argument list is the property of the called routine and it
4062          may clobber it.  If the fixed area has been used for previous
4063          parameters, we must save and restore it.  */
4064       save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
4065                                             &low_to_save, &high_to_save);
4066     }
4067 #endif
4068
4069   /* Push the args that need to be pushed.  */
4070
4071   /* ARGNUM indexes the ARGVEC array in the order in which the arguments
4072      are to be pushed.  */
4073   for (count = 0; count < nargs; count++, argnum += inc)
4074     {
4075       enum machine_mode mode = argvec[argnum].mode;
4076       rtx val = argvec[argnum].value;
4077       rtx reg = argvec[argnum].reg;
4078       int partial = argvec[argnum].partial;
4079       int lower_bound = 0, upper_bound = 0, i;
4080
4081       if (! (reg != 0 && partial == 0))
4082         {
4083           if (ACCUMULATE_OUTGOING_ARGS)
4084             {
4085               /* If this is being stored into a pre-allocated, fixed-size,
4086                  stack area, save any previous data at that location.  */
4087
4088 #ifdef ARGS_GROW_DOWNWARD
4089               /* stack_slot is negative, but we want to index stack_usage_map
4090                  with positive values.  */
4091               upper_bound = -argvec[argnum].locate.offset.constant + 1;
4092               lower_bound = upper_bound - argvec[argnum].locate.size.constant;
4093 #else
4094               lower_bound = argvec[argnum].locate.offset.constant;
4095               upper_bound = lower_bound + argvec[argnum].locate.size.constant;
4096 #endif
4097
4098               i = lower_bound;
4099               /* Don't worry about things in the fixed argument area;
4100                  it has already been saved.  */
4101               if (i < reg_parm_stack_space)
4102                 i = reg_parm_stack_space;
4103               while (i < upper_bound && stack_usage_map[i] == 0)
4104                 i++;
4105
4106               if (i < upper_bound)
4107                 {
4108                   /* We need to make a save area.  */
4109                   unsigned int size
4110                     = argvec[argnum].locate.size.constant * BITS_PER_UNIT;
4111                   enum machine_mode save_mode
4112                     = mode_for_size (size, MODE_INT, 1);
4113                   rtx adr
4114                     = plus_constant (argblock,
4115                                      argvec[argnum].locate.offset.constant);
4116                   rtx stack_area
4117                     = gen_rtx_MEM (save_mode, memory_address (save_mode, adr));
4118
4119                   if (save_mode == BLKmode)
4120                     {
4121                       argvec[argnum].save_area
4122                         = assign_stack_temp (BLKmode,
4123                                              argvec[argnum].locate.size.constant,
4124                                              0);
4125
4126                       emit_block_move (validize_mem (argvec[argnum].save_area),
4127                                        stack_area,
4128                                        GEN_INT (argvec[argnum].locate.size.constant),
4129                                        BLOCK_OP_CALL_PARM);
4130                     }
4131                   else
4132                     {
4133                       argvec[argnum].save_area = gen_reg_rtx (save_mode);
4134
4135                       emit_move_insn (argvec[argnum].save_area, stack_area);
4136                     }
4137                 }
4138             }
4139
4140           emit_push_insn (val, mode, NULL_TREE, NULL_RTX, PARM_BOUNDARY,
4141                           partial, reg, 0, argblock,
4142                           GEN_INT (argvec[argnum].locate.offset.constant),
4143                           reg_parm_stack_space,
4144                           ARGS_SIZE_RTX (argvec[argnum].locate.alignment_pad));
4145
4146           /* Now mark the segment we just used.  */
4147           if (ACCUMULATE_OUTGOING_ARGS)
4148             for (i = lower_bound; i < upper_bound; i++)
4149               stack_usage_map[i] = 1;
4150
4151           NO_DEFER_POP;
4152         }
4153     }
4154
4155   /* If we pushed args in forward order, perform stack alignment
4156      after pushing the last arg.  */
4157   if (argblock == 0 && !PUSH_ARGS_REVERSED)
4158     anti_adjust_stack (GEN_INT (args_size.constant
4159                                 - original_args_size.constant));
4160
4161   if (PUSH_ARGS_REVERSED)
4162     argnum = nargs - 1;
4163   else
4164     argnum = 0;
4165
4166   fun = prepare_call_address (fun, NULL_TREE, &call_fusage, 0, 0);
4167
4168   /* Now load any reg parms into their regs.  */
4169
4170   /* ARGNUM indexes the ARGVEC array in the order in which the arguments
4171      are to be pushed.  */
4172   for (count = 0; count < nargs; count++, argnum += inc)
4173     {
4174       rtx val = argvec[argnum].value;
4175       rtx reg = argvec[argnum].reg;
4176       int partial = argvec[argnum].partial;
4177
4178       /* Handle calls that pass values in multiple non-contiguous
4179          locations.  The PA64 has examples of this for library calls.  */
4180       if (reg != 0 && GET_CODE (reg) == PARALLEL)
4181         emit_group_load (reg, val, NULL_TREE, GET_MODE_SIZE (GET_MODE (val)));
4182       else if (reg != 0 && partial == 0)
4183         emit_move_insn (reg, val);
4184
4185       NO_DEFER_POP;
4186     }
4187
4188   /* Any regs containing parms remain in use through the call.  */
4189   for (count = 0; count < nargs; count++)
4190     {
4191       rtx reg = argvec[count].reg;
4192       if (reg != 0 && GET_CODE (reg) == PARALLEL)
4193         use_group_regs (&call_fusage, reg);
4194       else if (reg != 0)
4195         use_reg (&call_fusage, reg);
4196     }
4197
4198   /* Pass the function the address in which to return a structure value.  */
4199   if (mem_value != 0 && struct_value != 0 && ! pcc_struct_value)
4200     {
4201       emit_move_insn (struct_value,
4202                       force_reg (Pmode,
4203                                  force_operand (XEXP (mem_value, 0),
4204                                                 NULL_RTX)));
4205       if (GET_CODE (struct_value) == REG)
4206         use_reg (&call_fusage, struct_value);
4207     }
4208
4209   /* Don't allow popping to be deferred, since then
4210      cse'ing of library calls could delete a call and leave the pop.  */
4211   NO_DEFER_POP;
4212   valreg = (mem_value == 0 && outmode != VOIDmode
4213             ? hard_libcall_value (outmode) : NULL_RTX);
4214
4215   /* Stack must be properly aligned now.  */
4216   if (stack_pointer_delta & (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1))
4217     abort ();
4218
4219   before_call = get_last_insn ();
4220
4221   /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
4222      will set inhibit_defer_pop to that value.  */
4223   /* The return type is needed to decide how many bytes the function pops.
4224      Signedness plays no role in that, so for simplicity, we pretend it's
4225      always signed.  We also assume that the list of arguments passed has
4226      no impact, so we pretend it is unknown.  */
4227
4228   emit_call_1 (fun,
4229                get_identifier (XSTR (orgfun, 0)),
4230                build_function_type (tfom, NULL_TREE),
4231                original_args_size.constant, args_size.constant,
4232                struct_value_size,
4233                FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
4234                valreg,
4235                old_inhibit_defer_pop + 1, call_fusage, flags, & args_so_far);
4236
4237   /* For calls to `setjmp', etc., inform flow.c it should complain
4238      if nonvolatile values are live.  For functions that cannot return,
4239      inform flow that control does not fall through.  */
4240
4241   if (flags & (ECF_NORETURN | ECF_LONGJMP))
4242     {
4243       /* The barrier note must be emitted
4244          immediately after the CALL_INSN.  Some ports emit more than
4245          just a CALL_INSN above, so we must search for it here.  */
4246
4247       rtx last = get_last_insn ();
4248       while (GET_CODE (last) != CALL_INSN)
4249         {
4250           last = PREV_INSN (last);
4251           /* There was no CALL_INSN?  */
4252           if (last == before_call)
4253             abort ();
4254         }
4255
4256       emit_barrier_after (last);
4257     }
4258
4259   /* Now restore inhibit_defer_pop to its actual original value.  */
4260   OK_DEFER_POP;
4261
4262   /* If call is cse'able, make appropriate pair of reg-notes around it.
4263      Test valreg so we don't crash; may safely ignore `const'
4264      if return type is void.  Disable for PARALLEL return values, because
4265      we have no way to move such values into a pseudo register.  */
4266   if (flags & ECF_LIBCALL_BLOCK)
4267     {
4268       rtx insns;
4269
4270       if (valreg == 0)
4271         {
4272           insns = get_insns ();
4273           end_sequence ();
4274           emit_insn (insns);
4275         }
4276       else
4277         {
4278           rtx note = 0;
4279           rtx temp;
4280           int i;
4281
4282           if (GET_CODE (valreg) == PARALLEL)
4283             {
4284               temp = gen_reg_rtx (outmode);
4285               emit_group_store (temp, valreg, NULL_TREE,
4286                                 GET_MODE_SIZE (outmode));
4287               valreg = temp;
4288             }
4289
4290           temp = gen_reg_rtx (GET_MODE (valreg));
4291
4292           /* Construct an "equal form" for the value which mentions all the
4293              arguments in order as well as the function name.  */
4294           for (i = 0; i < nargs; i++)
4295             note = gen_rtx_EXPR_LIST (VOIDmode, argvec[i].value, note);
4296           note = gen_rtx_EXPR_LIST (VOIDmode, fun, note);
4297
4298           insns = get_insns ();
4299           end_sequence ();
4300
4301           if (flags & ECF_PURE)
4302             note = gen_rtx_EXPR_LIST (VOIDmode,
4303                         gen_rtx_USE (VOIDmode,
4304                                      gen_rtx_MEM (BLKmode,
4305                                                   gen_rtx_SCRATCH (VOIDmode))),
4306                         note);
4307
4308           emit_libcall_block (insns, temp, valreg, note);
4309
4310           valreg = temp;
4311         }
4312     }
4313   pop_temp_slots ();
4314
4315   /* Copy the value to the right place.  */
4316   if (outmode != VOIDmode && retval)
4317     {
4318       if (mem_value)
4319         {
4320           if (value == 0)
4321             value = mem_value;
4322           if (value != mem_value)
4323             emit_move_insn (value, mem_value);
4324         }
4325       else if (GET_CODE (valreg) == PARALLEL)
4326         {
4327           if (value == 0)
4328             value = gen_reg_rtx (outmode);
4329           emit_group_store (value, valreg, NULL_TREE, GET_MODE_SIZE (outmode));
4330         }
4331       else if (value != 0)
4332         emit_move_insn (value, valreg);
4333       else
4334         value = valreg;
4335     }
4336
4337   if (ACCUMULATE_OUTGOING_ARGS)
4338     {
4339 #ifdef REG_PARM_STACK_SPACE
4340       if (save_area)
4341         restore_fixed_argument_area (save_area, argblock,
4342                                      high_to_save, low_to_save);
4343 #endif
4344
4345       /* If we saved any argument areas, restore them.  */
4346       for (count = 0; count < nargs; count++)
4347         if (argvec[count].save_area)
4348           {
4349             enum machine_mode save_mode = GET_MODE (argvec[count].save_area);
4350             rtx adr = plus_constant (argblock,
4351                                      argvec[count].locate.offset.constant);
4352             rtx stack_area = gen_rtx_MEM (save_mode,
4353                                           memory_address (save_mode, adr));
4354
4355             if (save_mode == BLKmode)
4356               emit_block_move (stack_area,
4357                                validize_mem (argvec[count].save_area),
4358                                GEN_INT (argvec[count].locate.size.constant),
4359                                BLOCK_OP_CALL_PARM);
4360             else
4361               emit_move_insn (stack_area, argvec[count].save_area);
4362           }
4363
4364       highest_outgoing_arg_in_use = initial_highest_arg_in_use;
4365       stack_usage_map = initial_stack_usage_map;
4366     }
4367
4368   return value;
4369
4370 }
4371 \f
4372 /* Output a library call to function FUN (a SYMBOL_REF rtx)
4373    (emitting the queue unless NO_QUEUE is nonzero),
4374    for a value of mode OUTMODE,
4375    with NARGS different arguments, passed as alternating rtx values
4376    and machine_modes to convert them to.
4377    The rtx values should have been passed through protect_from_queue already.
4378
4379    FN_TYPE should be LCT_NORMAL for `normal' calls, LCT_CONST for `const'
4380    calls, LCT_PURE for `pure' calls, LCT_CONST_MAKE_BLOCK for `const' calls
4381    which should be enclosed in REG_LIBCALL/REG_RETVAL notes,
4382    LCT_PURE_MAKE_BLOCK for `purep' calls which should be enclosed in
4383    REG_LIBCALL/REG_RETVAL notes with extra (use (memory (scratch)),
4384    or other LCT_ value for other types of library calls.  */
4385
4386 void
4387 emit_library_call (rtx orgfun, enum libcall_type fn_type,
4388                    enum machine_mode outmode, int nargs, ...)
4389 {
4390   va_list p;
4391
4392   va_start (p, nargs);
4393   emit_library_call_value_1 (0, orgfun, NULL_RTX, fn_type, outmode, nargs, p);
4394   va_end (p);
4395 }
4396 \f
4397 /* Like emit_library_call except that an extra argument, VALUE,
4398    comes second and says where to store the result.
4399    (If VALUE is zero, this function chooses a convenient way
4400    to return the value.
4401
4402    This function returns an rtx for where the value is to be found.
4403    If VALUE is nonzero, VALUE is returned.  */
4404
4405 rtx
4406 emit_library_call_value (rtx orgfun, rtx value,
4407                          enum libcall_type fn_type,
4408                          enum machine_mode outmode, int nargs, ...)
4409 {
4410   rtx result;
4411   va_list p;
4412
4413   va_start (p, nargs);
4414   result = emit_library_call_value_1 (1, orgfun, value, fn_type, outmode,
4415                                       nargs, p);
4416   va_end (p);
4417
4418   return result;
4419 }
4420 \f
4421 /* Store a single argument for a function call
4422    into the register or memory area where it must be passed.
4423    *ARG describes the argument value and where to pass it.
4424
4425    ARGBLOCK is the address of the stack-block for all the arguments,
4426    or 0 on a machine where arguments are pushed individually.
4427
4428    MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
4429    so must be careful about how the stack is used.
4430
4431    VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
4432    argument stack.  This is used if ACCUMULATE_OUTGOING_ARGS to indicate
4433    that we need not worry about saving and restoring the stack.
4434
4435    FNDECL is the declaration of the function we are calling.
4436
4437    Return nonzero if this arg should cause sibcall failure,
4438    zero otherwise.  */
4439
4440 static int
4441 store_one_arg (struct arg_data *arg, rtx argblock, int flags,
4442                int variable_size ATTRIBUTE_UNUSED, int reg_parm_stack_space)
4443 {
4444   tree pval = arg->tree_value;
4445   rtx reg = 0;
4446   int partial = 0;
4447   int used = 0;
4448   int i, lower_bound = 0, upper_bound = 0;
4449   int sibcall_failure = 0;
4450
4451   if (TREE_CODE (pval) == ERROR_MARK)
4452     return 1;
4453
4454   /* Push a new temporary level for any temporaries we make for
4455      this argument.  */
4456   push_temp_slots ();
4457
4458   if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL))
4459     {
4460       /* If this is being stored into a pre-allocated, fixed-size, stack area,
4461          save any previous data at that location.  */
4462       if (argblock && ! variable_size && arg->stack)
4463         {
4464 #ifdef ARGS_GROW_DOWNWARD
4465           /* stack_slot is negative, but we want to index stack_usage_map
4466              with positive values.  */
4467           if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
4468             upper_bound = -INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1)) + 1;
4469           else
4470             upper_bound = 0;
4471
4472           lower_bound = upper_bound - arg->locate.size.constant;
4473 #else
4474           if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
4475             lower_bound = INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1));
4476           else
4477             lower_bound = 0;
4478
4479           upper_bound = lower_bound + arg->locate.size.constant;
4480 #endif
4481
4482           i = lower_bound;
4483           /* Don't worry about things in the fixed argument area;
4484              it has already been saved.  */
4485           if (i < reg_parm_stack_space)
4486             i = reg_parm_stack_space;
4487           while (i < upper_bound && stack_usage_map[i] == 0)
4488             i++;
4489
4490           if (i < upper_bound)
4491             {
4492               /* We need to make a save area.  */
4493               unsigned int size = arg->locate.size.constant * BITS_PER_UNIT;
4494               enum machine_mode save_mode = mode_for_size (size, MODE_INT, 1);
4495               rtx adr = memory_address (save_mode, XEXP (arg->stack_slot, 0));
4496               rtx stack_area = gen_rtx_MEM (save_mode, adr);
4497
4498               if (save_mode == BLKmode)
4499                 {
4500                   tree ot = TREE_TYPE (arg->tree_value);
4501                   tree nt = build_qualified_type (ot, (TYPE_QUALS (ot)
4502                                                        | TYPE_QUAL_CONST));
4503
4504                   arg->save_area = assign_temp (nt, 0, 1, 1);
4505                   preserve_temp_slots (arg->save_area);
4506                   emit_block_move (validize_mem (arg->save_area), stack_area,
4507                                    expr_size (arg->tree_value),
4508                                    BLOCK_OP_CALL_PARM);
4509                 }
4510               else
4511                 {
4512                   arg->save_area = gen_reg_rtx (save_mode);
4513                   emit_move_insn (arg->save_area, stack_area);
4514                 }
4515             }
4516         }
4517     }
4518
4519   /* If this isn't going to be placed on both the stack and in registers,
4520      set up the register and number of words.  */
4521   if (! arg->pass_on_stack)
4522     {
4523       if (flags & ECF_SIBCALL)
4524         reg = arg->tail_call_reg;
4525       else
4526         reg = arg->reg;
4527       partial = arg->partial;
4528     }
4529
4530   if (reg != 0 && partial == 0)
4531     /* Being passed entirely in a register.  We shouldn't be called in
4532        this case.  */
4533     abort ();
4534
4535   /* If this arg needs special alignment, don't load the registers
4536      here.  */
4537   if (arg->n_aligned_regs != 0)
4538     reg = 0;
4539
4540   /* If this is being passed partially in a register, we can't evaluate
4541      it directly into its stack slot.  Otherwise, we can.  */
4542   if (arg->value == 0)
4543     {
4544       /* stack_arg_under_construction is nonzero if a function argument is
4545          being evaluated directly into the outgoing argument list and
4546          expand_call must take special action to preserve the argument list
4547          if it is called recursively.
4548
4549          For scalar function arguments stack_usage_map is sufficient to
4550          determine which stack slots must be saved and restored.  Scalar
4551          arguments in general have pass_on_stack == 0.
4552
4553          If this argument is initialized by a function which takes the
4554          address of the argument (a C++ constructor or a C function
4555          returning a BLKmode structure), then stack_usage_map is
4556          insufficient and expand_call must push the stack around the
4557          function call.  Such arguments have pass_on_stack == 1.
4558
4559          Note that it is always safe to set stack_arg_under_construction,
4560          but this generates suboptimal code if set when not needed.  */
4561
4562       if (arg->pass_on_stack)
4563         stack_arg_under_construction++;
4564
4565       arg->value = expand_expr (pval,
4566                                 (partial
4567                                  || TYPE_MODE (TREE_TYPE (pval)) != arg->mode)
4568                                 ? NULL_RTX : arg->stack,
4569                                 VOIDmode, EXPAND_STACK_PARM);
4570
4571       /* If we are promoting object (or for any other reason) the mode
4572          doesn't agree, convert the mode.  */
4573
4574       if (arg->mode != TYPE_MODE (TREE_TYPE (pval)))
4575         arg->value = convert_modes (arg->mode, TYPE_MODE (TREE_TYPE (pval)),
4576                                     arg->value, arg->unsignedp);
4577
4578       if (arg->pass_on_stack)
4579         stack_arg_under_construction--;
4580     }
4581
4582   /* Don't allow anything left on stack from computation
4583      of argument to alloca.  */
4584   if (flags & ECF_MAY_BE_ALLOCA)
4585     do_pending_stack_adjust ();
4586
4587   if (arg->value == arg->stack)
4588     /* If the value is already in the stack slot, we are done.  */
4589     ;
4590   else if (arg->mode != BLKmode)
4591     {
4592       int size;
4593
4594       /* Argument is a scalar, not entirely passed in registers.
4595          (If part is passed in registers, arg->partial says how much
4596          and emit_push_insn will take care of putting it there.)
4597
4598          Push it, and if its size is less than the
4599          amount of space allocated to it,
4600          also bump stack pointer by the additional space.
4601          Note that in C the default argument promotions
4602          will prevent such mismatches.  */
4603
4604       size = GET_MODE_SIZE (arg->mode);
4605       /* Compute how much space the push instruction will push.
4606          On many machines, pushing a byte will advance the stack
4607          pointer by a halfword.  */
4608 #ifdef PUSH_ROUNDING
4609       size = PUSH_ROUNDING (size);
4610 #endif
4611       used = size;
4612
4613       /* Compute how much space the argument should get:
4614          round up to a multiple of the alignment for arguments.  */
4615       if (none != FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)))
4616         used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1)
4617                  / (PARM_BOUNDARY / BITS_PER_UNIT))
4618                 * (PARM_BOUNDARY / BITS_PER_UNIT));
4619
4620       /* This isn't already where we want it on the stack, so put it there.
4621          This can either be done with push or copy insns.  */
4622       emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX,
4623                       PARM_BOUNDARY, partial, reg, used - size, argblock,
4624                       ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
4625                       ARGS_SIZE_RTX (arg->locate.alignment_pad));
4626
4627       /* Unless this is a partially-in-register argument, the argument is now
4628          in the stack.  */
4629       if (partial == 0)
4630         arg->value = arg->stack;
4631     }
4632   else
4633     {
4634       /* BLKmode, at least partly to be pushed.  */
4635
4636       unsigned int parm_align;
4637       int excess;
4638       rtx size_rtx;
4639
4640       /* Pushing a nonscalar.
4641          If part is passed in registers, PARTIAL says how much
4642          and emit_push_insn will take care of putting it there.  */
4643
4644       /* Round its size up to a multiple
4645          of the allocation unit for arguments.  */
4646
4647       if (arg->locate.size.var != 0)
4648         {
4649           excess = 0;
4650           size_rtx = ARGS_SIZE_RTX (arg->locate.size);
4651         }
4652       else
4653         {
4654           /* PUSH_ROUNDING has no effect on us, because
4655              emit_push_insn for BLKmode is careful to avoid it.  */
4656           if (reg && GET_CODE (reg) == PARALLEL)
4657           {
4658             /* Use the size of the elt to compute excess.  */
4659             rtx elt = XEXP (XVECEXP (reg, 0, 0), 0);
4660             excess = (arg->locate.size.constant
4661                       - int_size_in_bytes (TREE_TYPE (pval))
4662                       + partial * GET_MODE_SIZE (GET_MODE (elt)));
4663           }
4664           else
4665             excess = (arg->locate.size.constant
4666                       - int_size_in_bytes (TREE_TYPE (pval))
4667                       + partial * UNITS_PER_WORD);
4668           size_rtx = expand_expr (size_in_bytes (TREE_TYPE (pval)),
4669                                   NULL_RTX, TYPE_MODE (sizetype), 0);
4670         }
4671
4672       /* Some types will require stricter alignment, which will be
4673          provided for elsewhere in argument layout.  */
4674       parm_align = MAX (PARM_BOUNDARY, TYPE_ALIGN (TREE_TYPE (pval)));
4675
4676       /* When an argument is padded down, the block is aligned to
4677          PARM_BOUNDARY, but the actual argument isn't.  */
4678       if (FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)) == downward)
4679         {
4680           if (arg->locate.size.var)
4681             parm_align = BITS_PER_UNIT;
4682           else if (excess)
4683             {
4684               unsigned int excess_align = (excess & -excess) * BITS_PER_UNIT;
4685               parm_align = MIN (parm_align, excess_align);
4686             }
4687         }
4688
4689       if ((flags & ECF_SIBCALL) && GET_CODE (arg->value) == MEM)
4690         {
4691           /* emit_push_insn might not work properly if arg->value and
4692              argblock + arg->locate.offset areas overlap.  */
4693           rtx x = arg->value;
4694           int i = 0;
4695
4696           if (XEXP (x, 0) == current_function_internal_arg_pointer
4697               || (GET_CODE (XEXP (x, 0)) == PLUS
4698                   && XEXP (XEXP (x, 0), 0) ==
4699                      current_function_internal_arg_pointer
4700                   && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT))
4701             {
4702               if (XEXP (x, 0) != current_function_internal_arg_pointer)
4703                 i = INTVAL (XEXP (XEXP (x, 0), 1));
4704
4705               /* expand_call should ensure this.  */
4706               if (arg->locate.offset.var || GET_CODE (size_rtx) != CONST_INT)
4707                 abort ();
4708
4709               if (arg->locate.offset.constant > i)
4710                 {
4711                   if (arg->locate.offset.constant < i + INTVAL (size_rtx))
4712                     sibcall_failure = 1;
4713                 }
4714               else if (arg->locate.offset.constant < i)
4715                 {
4716                   if (i < arg->locate.offset.constant + INTVAL (size_rtx))
4717                     sibcall_failure = 1;
4718                 }
4719             }
4720         }
4721
4722       emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
4723                       parm_align, partial, reg, excess, argblock,
4724                       ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
4725                       ARGS_SIZE_RTX (arg->locate.alignment_pad));
4726
4727       /* Unless this is a partially-in-register argument, the argument is now
4728          in the stack.
4729
4730          ??? Unlike the case above, in which we want the actual
4731          address of the data, so that we can load it directly into a
4732          register, here we want the address of the stack slot, so that
4733          it's properly aligned for word-by-word copying or something
4734          like that.  It's not clear that this is always correct.  */
4735       if (partial == 0)
4736         arg->value = arg->stack_slot;
4737     }
4738
4739   /* Mark all slots this store used.  */
4740   if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL)
4741       && argblock && ! variable_size && arg->stack)
4742     for (i = lower_bound; i < upper_bound; i++)
4743       stack_usage_map[i] = 1;
4744
4745   /* Once we have pushed something, pops can't safely
4746      be deferred during the rest of the arguments.  */
4747   NO_DEFER_POP;
4748
4749   /* ANSI doesn't require a sequence point here,
4750      but PCC has one, so this will avoid some problems.  */
4751   emit_queue ();
4752
4753   /* Free any temporary slots made in processing this argument.  Show
4754      that we might have taken the address of something and pushed that
4755      as an operand.  */
4756   preserve_temp_slots (NULL_RTX);
4757   free_temp_slots ();
4758   pop_temp_slots ();
4759
4760   return sibcall_failure;
4761 }
4762
4763 /* Nonzero if we do not know how to pass TYPE solely in registers.
4764    We cannot do so in the following cases:
4765
4766    - if the type has variable size
4767    - if the type is marked as addressable (it is required to be constructed
4768      into the stack)
4769    - if the padding and mode of the type is such that a copy into a register
4770      would put it into the wrong part of the register.
4771
4772    Which padding can't be supported depends on the byte endianness.
4773
4774    A value in a register is implicitly padded at the most significant end.
4775    On a big-endian machine, that is the lower end in memory.
4776    So a value padded in memory at the upper end can't go in a register.
4777    For a little-endian machine, the reverse is true.  */
4778
4779 bool
4780 default_must_pass_in_stack (enum machine_mode mode, tree type)
4781 {
4782   if (!type)
4783     return false;
4784
4785   /* If the type has variable size...  */
4786   if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4787     return true;
4788
4789   /* If the type is marked as addressable (it is required
4790      to be constructed into the stack)...  */
4791   if (TREE_ADDRESSABLE (type))
4792     return true;
4793
4794   /* If the padding and mode of the type is such that a copy into
4795      a register would put it into the wrong part of the register.  */
4796   if (mode == BLKmode
4797       && int_size_in_bytes (type) % (PARM_BOUNDARY / BITS_PER_UNIT)
4798       && (FUNCTION_ARG_PADDING (mode, type)
4799           == (BYTES_BIG_ENDIAN ? upward : downward)))
4800     return true;
4801
4802   return false;
4803 }