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