gcc/calls.c

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