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