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