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