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