gcc/calls.c

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