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 *, 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                                  ecf_flags)
 985      int num_actuals ATTRIBUTE_UNUSED;
 986      struct arg_data *args;
 987      struct args_size *args_size;
 988      int n_named_args ATTRIBUTE_UNUSED;
 989      tree actparms;
 990      tree fndecl;
 991      CUMULATIVE_ARGS *args_so_far;
 992      int reg_parm_stack_space;
 993      rtx *old_stack_level;
 994      int *old_pending_adj;
 995      int *must_preallocate;
 996      int *is_const;
 997      int ecf_flags;
 998 {
 999   /* 1 if scanning parms front to back, -1 if scanning back to front.  */
1000   int inc;
1001
1002   /* Count arg position in order args appear.  */
1003   int argpos;
1004
1005   struct args_size alignment_pad;
1006   int i;
1007   tree p;
1008
1009   args_size->constant = 0;
1010   args_size->var = 0;
1011
1012   /* In this loop, we consider args in the order they are written.
1013      We fill up ARGS from the front or from the back if necessary
1014      so that in any case the first arg to be pushed ends up at the front.  */
1015
1016 #ifdef PUSH_ARGS_REVERSED
1017   i = num_actuals - 1, inc = -1;
1018   /* In this case, must reverse order of args
1019      so that we compute and push the last arg first.  */
1020 #else
1021   i = 0, inc = 1;
1022 #endif
1023
1024   /* I counts args in order (to be) pushed; ARGPOS counts in order written.  */
1025   for (p = actparms, argpos = 0; p; p = TREE_CHAIN (p), i += inc, argpos++)
1026     {
1027       tree type = TREE_TYPE (TREE_VALUE (p));
1028       int unsignedp;
1029       enum machine_mode mode;
1030
1031       args[i].tree_value = TREE_VALUE (p);
1032
1033       /* Replace erroneous argument with constant zero.  */
1034       if (type == error_mark_node || !COMPLETE_TYPE_P (type))
1035         args[i].tree_value = integer_zero_node, type = integer_type_node;
1036
1037       /* If TYPE is a transparent union, pass things the way we would
1038          pass the first field of the union.  We have already verified that
1039          the modes are the same.  */
1040       if (TYPE_TRANSPARENT_UNION (type))
1041         type = TREE_TYPE (TYPE_FIELDS (type));
1042
1043       /* Decide where to pass this arg.
1044
1045          args[i].reg is nonzero if all or part is passed in registers.
1046
1047          args[i].partial is nonzero if part but not all is passed in registers,
1048          and the exact value says how many words are passed in registers.
1049
1050          args[i].pass_on_stack is nonzero if the argument must at least be
1051          computed on the stack.  It may then be loaded back into registers
1052          if args[i].reg is nonzero.
1053
1054          These decisions are driven by the FUNCTION_... macros and must agree
1055          with those made by function.c.  */
1056
1057       /* See if this argument should be passed by invisible reference.  */
1058       if ((TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST
1059            && contains_placeholder_p (TYPE_SIZE (type)))
1060           || TREE_ADDRESSABLE (type)
1061 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
1062           || FUNCTION_ARG_PASS_BY_REFERENCE (*args_so_far, TYPE_MODE (type),
1063                                              type, argpos < n_named_args)
1064 #endif
1065           )
1066         {
1067           /* If we're compiling a thunk, pass through invisible
1068              references instead of making a copy.  */
1069           if (current_function_is_thunk
1070 #ifdef FUNCTION_ARG_CALLEE_COPIES
1071               || (FUNCTION_ARG_CALLEE_COPIES (*args_so_far, TYPE_MODE (type),
1072                                              type, argpos < n_named_args)
1073                   /* If it's in a register, we must make a copy of it too.  */
1074                   /* ??? Is this a sufficient test?  Is there a better one? */
1075                   && !(TREE_CODE (args[i].tree_value) == VAR_DECL
1076                        && REG_P (DECL_RTL (args[i].tree_value)))
1077                   && ! TREE_ADDRESSABLE (type))
1078 #endif
1079               )
1080             {
1081               /* C++ uses a TARGET_EXPR to indicate that we want to make a
1082                  new object from the argument.  If we are passing by
1083                  invisible reference, the callee will do that for us, so we
1084                  can strip off the TARGET_EXPR.  This is not always safe,
1085                  but it is safe in the only case where this is a useful
1086                  optimization; namely, when the argument is a plain object.
1087                  In that case, the frontend is just asking the backend to
1088                  make a bitwise copy of the argument. */
1089
1090               if (TREE_CODE (args[i].tree_value) == TARGET_EXPR
1091                   && (DECL_P (TREE_OPERAND (args[i].tree_value, 1)))
1092                   && ! REG_P (DECL_RTL (TREE_OPERAND (args[i].tree_value, 1))))
1093                 args[i].tree_value = TREE_OPERAND (args[i].tree_value, 1);
1094
1095               args[i].tree_value = build1 (ADDR_EXPR,
1096                                            build_pointer_type (type),
1097                                            args[i].tree_value);
1098               type = build_pointer_type (type);
1099             }
1100           else
1101             {
1102               /* We make a copy of the object and pass the address to the
1103                  function being called.  */
1104               rtx copy;
1105
1106               if (!COMPLETE_TYPE_P (type)
1107                   || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST
1108                   || (flag_stack_check && ! STACK_CHECK_BUILTIN
1109                       && (0 < compare_tree_int (TYPE_SIZE_UNIT (type),
1110                                                 STACK_CHECK_MAX_VAR_SIZE))))
1111                 {
1112                   /* This is a variable-sized object.  Make space on the stack
1113                      for it.  */
1114                   rtx size_rtx = expr_size (TREE_VALUE (p));
1115
1116                   if (*old_stack_level == 0)
1117                     {
1118                       emit_stack_save (SAVE_BLOCK, old_stack_level, NULL_RTX);
1119                       *old_pending_adj = pending_stack_adjust;
1120                       pending_stack_adjust = 0;
1121                     }
1122
1123                   copy = gen_rtx_MEM (BLKmode,
1124                                       allocate_dynamic_stack_space (size_rtx,
1125                                                                     NULL_RTX,
1126                                                                     TYPE_ALIGN (type)));
1127                 }
1128               else
1129                 {
1130                   int size = int_size_in_bytes (type);
1131                   copy = assign_stack_temp (TYPE_MODE (type), size, 0);
1132                 }
1133
1134               MEM_SET_IN_STRUCT_P (copy, AGGREGATE_TYPE_P (type));
1135
1136               store_expr (args[i].tree_value, copy, 0);
1137               *is_const = 0;
1138
1139               args[i].tree_value = build1 (ADDR_EXPR,
1140                                            build_pointer_type (type),
1141                                            make_tree (type, copy));
1142               type = build_pointer_type (type);
1143             }
1144         }
1145
1146       mode = TYPE_MODE (type);
1147       unsignedp = TREE_UNSIGNED (type);
1148
1149 #ifdef PROMOTE_FUNCTION_ARGS
1150       mode = promote_mode (type, mode, &unsignedp, 1);
1151 #endif
1152
1153       args[i].unsignedp = unsignedp;
1154       args[i].mode = mode;
1155
1156 #ifdef FUNCTION_INCOMING_ARG
1157       /* If this is a sibling call and the machine has register windows, the
1158          register window has to be unwinded before calling the routine, so
1159          arguments have to go into the incoming registers.  */
1160       if (ecf_flags & ECF_SIBCALL)
1161         args[i].reg = FUNCTION_INCOMING_ARG (*args_so_far, mode, type,
1162                                              argpos < n_named_args);
1163       else
1164 #endif
1165         args[i].reg = FUNCTION_ARG (*args_so_far, mode, type,
1166                                     argpos < n_named_args);
1167
1168 #ifdef FUNCTION_ARG_PARTIAL_NREGS
1169       if (args[i].reg)
1170         args[i].partial
1171           = FUNCTION_ARG_PARTIAL_NREGS (*args_so_far, mode, type,
1172                                         argpos < n_named_args);
1173 #endif
1174
1175       args[i].pass_on_stack = MUST_PASS_IN_STACK (mode, type);
1176
1177       /* If FUNCTION_ARG returned a (parallel [(expr_list (nil) ...) ...]),
1178          it means that we are to pass this arg in the register(s) designated
1179          by the PARALLEL, but also to pass it in the stack.  */
1180       if (args[i].reg && GET_CODE (args[i].reg) == PARALLEL
1181           && XEXP (XVECEXP (args[i].reg, 0, 0), 0) == 0)
1182         args[i].pass_on_stack = 1;
1183
1184       /* If this is an addressable type, we must preallocate the stack
1185          since we must evaluate the object into its final location.
1186
1187          If this is to be passed in both registers and the stack, it is simpler
1188          to preallocate.  */
1189       if (TREE_ADDRESSABLE (type)
1190           || (args[i].pass_on_stack && args[i].reg != 0))
1191         *must_preallocate = 1;
1192
1193       /* If this is an addressable type, we cannot pre-evaluate it.  Thus,
1194          we cannot consider this function call constant.  */
1195       if (TREE_ADDRESSABLE (type))
1196         *is_const = 0;
1197
1198       /* Compute the stack-size of this argument.  */
1199       if (args[i].reg == 0 || args[i].partial != 0
1200           || reg_parm_stack_space > 0
1201           || args[i].pass_on_stack)
1202         locate_and_pad_parm (mode, type,
1203 #ifdef STACK_PARMS_IN_REG_PARM_AREA
1204                              1,
1205 #else
1206                              args[i].reg != 0,
1207 #endif
1208                              fndecl, args_size, &args[i].offset,
1209                              &args[i].size, &alignment_pad);
1210
1211 #ifndef ARGS_GROW_DOWNWARD
1212       args[i].slot_offset = *args_size;
1213 #endif
1214
1215       args[i].alignment_pad = alignment_pad;
1216
1217       /* If a part of the arg was put into registers,
1218          don't include that part in the amount pushed.  */
1219       if (reg_parm_stack_space == 0 && ! args[i].pass_on_stack)
1220         args[i].size.constant -= ((args[i].partial * UNITS_PER_WORD)
1221                                   / (PARM_BOUNDARY / BITS_PER_UNIT)
1222                                   * (PARM_BOUNDARY / BITS_PER_UNIT));
1223
1224       /* Update ARGS_SIZE, the total stack space for args so far.  */
1225
1226       args_size->constant += args[i].size.constant;
1227       if (args[i].size.var)
1228         {
1229           ADD_PARM_SIZE (*args_size, args[i].size.var);
1230         }
1231
1232       /* Since the slot offset points to the bottom of the slot,
1233          we must record it after incrementing if the args grow down.  */
1234 #ifdef ARGS_GROW_DOWNWARD
1235       args[i].slot_offset = *args_size;
1236
1237       args[i].slot_offset.constant = -args_size->constant;
1238       if (args_size->var)
1239         SUB_PARM_SIZE (args[i].slot_offset, args_size->var);
1240 #endif
1241
1242       /* Increment ARGS_SO_FAR, which has info about which arg-registers
1243          have been used, etc.  */
1244
1245       FUNCTION_ARG_ADVANCE (*args_so_far, TYPE_MODE (type), type,
1246                             argpos < n_named_args);
1247     }
1248 }
1249
1250 /* Update ARGS_SIZE to contain the total size for the argument block.
1251    Return the original constant component of the argument block's size.
1252
1253    REG_PARM_STACK_SPACE holds the number of bytes of stack space reserved
1254    for arguments passed in registers.  */
1255
1256 static int
1257 compute_argument_block_size (reg_parm_stack_space, args_size,
1258                              preferred_stack_boundary)
1259      int reg_parm_stack_space;
1260      struct args_size *args_size;
1261      int preferred_stack_boundary ATTRIBUTE_UNUSED;
1262 {
1263   int unadjusted_args_size = args_size->constant;
1264
1265   /* Compute the actual size of the argument block required.  The variable
1266      and constant sizes must be combined, the size may have to be rounded,
1267      and there may be a minimum required size.  */
1268
1269   if (args_size->var)
1270     {
1271       args_size->var = ARGS_SIZE_TREE (*args_size);
1272       args_size->constant = 0;
1273
1274 #ifdef PREFERRED_STACK_BOUNDARY
1275       preferred_stack_boundary /= BITS_PER_UNIT;
1276       if (preferred_stack_boundary > 1)
1277         args_size->var = round_up (args_size->var, preferred_stack_boundary);
1278 #endif
1279
1280       if (reg_parm_stack_space > 0)
1281         {
1282           args_size->var
1283             = size_binop (MAX_EXPR, args_size->var,
1284                           ssize_int (reg_parm_stack_space));
1285
1286 #ifndef OUTGOING_REG_PARM_STACK_SPACE
1287           /* The area corresponding to register parameters is not to count in
1288              the size of the block we need.  So make the adjustment.  */
1289           args_size->var
1290             = size_binop (MINUS_EXPR, args_size->var,
1291                           ssize_int (reg_parm_stack_space));
1292 #endif
1293         }
1294     }
1295   else
1296     {
1297 #ifdef PREFERRED_STACK_BOUNDARY
1298       preferred_stack_boundary /= BITS_PER_UNIT;
1299       if (preferred_stack_boundary < 1)
1300         preferred_stack_boundary = 1;
1301       args_size->constant = (((args_size->constant
1302                                + arg_space_so_far
1303                                + pending_stack_adjust
1304                                + preferred_stack_boundary - 1)
1305                               / preferred_stack_boundary
1306                               * preferred_stack_boundary)
1307                              - arg_space_so_far
1308                              - pending_stack_adjust);
1309 #endif
1310
1311       args_size->constant = MAX (args_size->constant,
1312                                  reg_parm_stack_space);
1313
1314 #ifdef MAYBE_REG_PARM_STACK_SPACE
1315       if (reg_parm_stack_space == 0)
1316         args_size->constant = 0;
1317 #endif
1318
1319 #ifndef OUTGOING_REG_PARM_STACK_SPACE
1320       args_size->constant -= reg_parm_stack_space;
1321 #endif
1322     }
1323   return unadjusted_args_size;
1324 }
1325
1326 /* Precompute parameters as needed for a function call.
1327
1328    IS_CONST indicates the target function is a pure function.
1329
1330    MUST_PREALLOCATE indicates that we must preallocate stack space for
1331    any stack arguments.
1332
1333    NUM_ACTUALS is the number of arguments.
1334
1335    ARGS is an array containing information for each argument; this routine
1336    fills in the INITIAL_VALUE and VALUE fields for each precomputed argument.
1337
1338    ARGS_SIZE contains information about the size of the arg list.  */
1339
1340 static void
1341 precompute_arguments (is_const, must_preallocate, num_actuals, args, args_size)
1342      int is_const;
1343      int must_preallocate;
1344      int num_actuals;
1345      struct arg_data *args;
1346      struct args_size *args_size;
1347 {
1348   int i;
1349
1350   /* If this function call is cse'able, precompute all the parameters.
1351      Note that if the parameter is constructed into a temporary, this will
1352      cause an additional copy because the parameter will be constructed
1353      into a temporary location and then copied into the outgoing arguments.
1354      If a parameter contains a call to alloca and this function uses the
1355      stack, precompute the parameter.  */
1356
1357   /* If we preallocated the stack space, and some arguments must be passed
1358      on the stack, then we must precompute any parameter which contains a
1359      function call which will store arguments on the stack.
1360      Otherwise, evaluating the parameter may clobber previous parameters
1361      which have already been stored into the stack.  */
1362
1363   for (i = 0; i < num_actuals; i++)
1364     if (is_const
1365         || ((args_size->var != 0 || args_size->constant != 0)
1366             && calls_function (args[i].tree_value, 1))
1367         || (must_preallocate
1368             && (args_size->var != 0 || args_size->constant != 0)
1369             && calls_function (args[i].tree_value, 0)))
1370       {
1371         /* If this is an addressable type, we cannot pre-evaluate it.  */
1372         if (TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value)))
1373           abort ();
1374
1375         push_temp_slots ();
1376
1377         args[i].value
1378           = expand_expr (args[i].tree_value, NULL_RTX, VOIDmode, 0);
1379
1380         preserve_temp_slots (args[i].value);
1381         pop_temp_slots ();
1382
1383         /* ANSI doesn't require a sequence point here,
1384            but PCC has one, so this will avoid some problems.  */
1385         emit_queue ();
1386
1387         args[i].initial_value = args[i].value
1388           = protect_from_queue (args[i].value, 0);
1389
1390         if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) != args[i].mode)
1391           {
1392             args[i].value
1393               = convert_modes (args[i].mode,
1394                                TYPE_MODE (TREE_TYPE (args[i].tree_value)),
1395                                args[i].value, args[i].unsignedp);
1396 #ifdef PROMOTE_FOR_CALL_ONLY
1397             /* CSE will replace this only if it contains args[i].value
1398                pseudo, so convert it down to the declared mode using
1399                a SUBREG.  */
1400             if (GET_CODE (args[i].value) == REG
1401                 && GET_MODE_CLASS (args[i].mode) == MODE_INT)
1402               {
1403                 args[i].initial_value
1404                   = gen_rtx_SUBREG (TYPE_MODE (TREE_TYPE (args[i].tree_value)),
1405                                     args[i].value, 0);
1406                 SUBREG_PROMOTED_VAR_P (args[i].initial_value) = 1;
1407                 SUBREG_PROMOTED_UNSIGNED_P (args[i].initial_value)
1408                   = args[i].unsignedp;
1409               }
1410 #endif
1411           }
1412       }
1413 }
1414
1415 /* Given the current state of MUST_PREALLOCATE and information about
1416    arguments to a function call in NUM_ACTUALS, ARGS and ARGS_SIZE,
1417    compute and return the final value for MUST_PREALLOCATE.  */
1418
1419 static int
1420 finalize_must_preallocate (must_preallocate, num_actuals, args, args_size)
1421      int must_preallocate;
1422      int num_actuals;
1423      struct arg_data *args;
1424      struct args_size *args_size;
1425 {
1426   /* See if we have or want to preallocate stack space.
1427
1428      If we would have to push a partially-in-regs parm
1429      before other stack parms, preallocate stack space instead.
1430
1431      If the size of some parm is not a multiple of the required stack
1432      alignment, we must preallocate.
1433
1434      If the total size of arguments that would otherwise create a copy in
1435      a temporary (such as a CALL) is more than half the total argument list
1436      size, preallocation is faster.
1437
1438      Another reason to preallocate is if we have a machine (like the m88k)
1439      where stack alignment is required to be maintained between every
1440      pair of insns, not just when the call is made.  However, we assume here
1441      that such machines either do not have push insns (and hence preallocation
1442      would occur anyway) or the problem is taken care of with
1443      PUSH_ROUNDING.  */
1444
1445   if (! must_preallocate)
1446     {
1447       int partial_seen = 0;
1448       int copy_to_evaluate_size = 0;
1449       int i;
1450
1451       for (i = 0; i < num_actuals && ! must_preallocate; i++)
1452         {
1453           if (args[i].partial > 0 && ! args[i].pass_on_stack)
1454             partial_seen = 1;
1455           else if (partial_seen && args[i].reg == 0)
1456             must_preallocate = 1;
1457
1458           if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
1459               && (TREE_CODE (args[i].tree_value) == CALL_EXPR
1460                   || TREE_CODE (args[i].tree_value) == TARGET_EXPR
1461                   || TREE_CODE (args[i].tree_value) == COND_EXPR
1462                   || TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value))))
1463             copy_to_evaluate_size
1464               += int_size_in_bytes (TREE_TYPE (args[i].tree_value));
1465         }
1466
1467       if (copy_to_evaluate_size * 2 >= args_size->constant
1468           && args_size->constant > 0)
1469         must_preallocate = 1;
1470     }
1471   return must_preallocate;
1472 }
1473
1474 /* If we preallocated stack space, compute the address of each argument
1475    and store it into the ARGS array.
1476
1477    We need not ensure it is a valid memory address here; it will be
1478    validized when it is used.
1479
1480    ARGBLOCK is an rtx for the address of the outgoing arguments.  */
1481
1482 static void
1483 compute_argument_addresses (args, argblock, num_actuals)
1484      struct arg_data *args;
1485      rtx argblock;
1486      int num_actuals;
1487 {
1488   if (argblock)
1489     {
1490       rtx arg_reg = argblock;
1491       int i, arg_offset = 0;
1492
1493       if (GET_CODE (argblock) == PLUS)
1494         arg_reg = XEXP (argblock, 0), arg_offset = INTVAL (XEXP (argblock, 1));
1495
1496       for (i = 0; i < num_actuals; i++)
1497         {
1498           rtx offset = ARGS_SIZE_RTX (args[i].offset);
1499           rtx slot_offset = ARGS_SIZE_RTX (args[i].slot_offset);
1500           rtx addr;
1501
1502           /* Skip this parm if it will not be passed on the stack.  */
1503           if (! args[i].pass_on_stack && args[i].reg != 0)
1504             continue;
1505
1506           if (GET_CODE (offset) == CONST_INT)
1507             addr = plus_constant (arg_reg, INTVAL (offset));
1508           else
1509             addr = gen_rtx_PLUS (Pmode, arg_reg, offset);
1510
1511           addr = plus_constant (addr, arg_offset);
1512           args[i].stack = gen_rtx_MEM (args[i].mode, addr);
1513           MEM_SET_IN_STRUCT_P
1514             (args[i].stack,
1515              AGGREGATE_TYPE_P (TREE_TYPE (args[i].tree_value)));
1516
1517           if (GET_CODE (slot_offset) == CONST_INT)
1518             addr = plus_constant (arg_reg, INTVAL (slot_offset));
1519           else
1520             addr = gen_rtx_PLUS (Pmode, arg_reg, slot_offset);
1521
1522           addr = plus_constant (addr, arg_offset);
1523           args[i].stack_slot = gen_rtx_MEM (args[i].mode, addr);
1524         }
1525     }
1526 }
1527
1528 /* Given a FNDECL and EXP, return an rtx suitable for use as a target address
1529    in a call instruction.
1530
1531    FNDECL is the tree node for the target function.  For an indirect call
1532    FNDECL will be NULL_TREE.
1533
1534    EXP is the CALL_EXPR for this call.  */
1535
1536 static rtx
1537 rtx_for_function_call (fndecl, exp)
1538      tree fndecl;
1539      tree exp;
1540 {
1541   rtx funexp;
1542
1543   /* Get the function to call, in the form of RTL.  */
1544   if (fndecl)
1545     {
1546       /* If this is the first use of the function, see if we need to
1547          make an external definition for it.  */
1548       if (! TREE_USED (fndecl))
1549         {
1550           assemble_external (fndecl);
1551           TREE_USED (fndecl) = 1;
1552         }
1553
1554       /* Get a SYMBOL_REF rtx for the function address.  */
1555       funexp = XEXP (DECL_RTL (fndecl), 0);
1556     }
1557   else
1558     /* Generate an rtx (probably a pseudo-register) for the address.  */
1559     {
1560       rtx funaddr;
1561       push_temp_slots ();
1562       funaddr = funexp =
1563           expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
1564       pop_temp_slots ();        /* FUNEXP can't be BLKmode */
1565
1566       /* Check the function is executable.  */
1567       if (current_function_check_memory_usage)
1568         {
1569 #ifdef POINTERS_EXTEND_UNSIGNED
1570           /* It might be OK to convert funexp in place, but there's
1571              a lot going on between here and when it happens naturally
1572              that this seems safer. */
1573           funaddr = convert_memory_address (Pmode, funexp);
1574 #endif
1575           emit_library_call (chkr_check_exec_libfunc, 1,
1576                              VOIDmode, 1,
1577                              funaddr, Pmode);
1578         }
1579       emit_queue ();
1580     }
1581   return funexp;
1582 }
1583
1584 /* Do the register loads required for any wholly-register parms or any
1585    parms which are passed both on the stack and in a register.  Their
1586    expressions were already evaluated.
1587
1588    Mark all register-parms as living through the call, putting these USE
1589    insns in the CALL_INSN_FUNCTION_USAGE field.  */
1590
1591 static void
1592 load_register_parameters (args, num_actuals, call_fusage)
1593      struct arg_data *args;
1594      int num_actuals;
1595      rtx *call_fusage;
1596 {
1597   int i, j;
1598
1599 #ifdef LOAD_ARGS_REVERSED
1600   for (i = num_actuals - 1; i >= 0; i--)
1601 #else
1602   for (i = 0; i < num_actuals; i++)
1603 #endif
1604     {
1605       rtx reg = args[i].reg;
1606       int partial = args[i].partial;
1607       int nregs;
1608
1609       if (reg)
1610         {
1611           /* Set to non-negative if must move a word at a time, even if just
1612              one word (e.g, partial == 1 && mode == DFmode).  Set to -1 if
1613              we just use a normal move insn.  This value can be zero if the
1614              argument is a zero size structure with no fields.  */
1615           nregs = (partial ? partial
1616                    : (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
1617                       ? ((int_size_in_bytes (TREE_TYPE (args[i].tree_value))
1618                           + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
1619                       : -1));
1620
1621           /* Handle calls that pass values in multiple non-contiguous
1622              locations.  The Irix 6 ABI has examples of this.  */
1623
1624           if (GET_CODE (reg) == PARALLEL)
1625             {
1626               emit_group_load (reg, args[i].value,
1627                                int_size_in_bytes (TREE_TYPE (args[i].tree_value)),
1628                                (TYPE_ALIGN (TREE_TYPE (args[i].tree_value))
1629                                 / BITS_PER_UNIT));
1630             }
1631
1632           /* If simple case, just do move.  If normal partial, store_one_arg
1633              has already loaded the register for us.  In all other cases,
1634              load the register(s) from memory.  */
1635
1636           else if (nregs == -1)
1637             emit_move_insn (reg, args[i].value);
1638
1639           /* If we have pre-computed the values to put in the registers in
1640              the case of non-aligned structures, copy them in now.  */
1641
1642           else if (args[i].n_aligned_regs != 0)
1643             for (j = 0; j < args[i].n_aligned_regs; j++)
1644               emit_move_insn (gen_rtx_REG (word_mode, REGNO (reg) + j),
1645                               args[i].aligned_regs[j]);
1646
1647           else if (partial == 0 || args[i].pass_on_stack)
1648             move_block_to_reg (REGNO (reg),
1649                                validize_mem (args[i].value), nregs,
1650                                args[i].mode);
1651
1652           /* Handle calls that pass values in multiple non-contiguous
1653              locations.  The Irix 6 ABI has examples of this.  */
1654           if (GET_CODE (reg) == PARALLEL)
1655             use_group_regs (call_fusage, reg);
1656           else if (nregs == -1)
1657             use_reg (call_fusage, reg);
1658           else
1659             use_regs (call_fusage, REGNO (reg), nregs == 0 ? 1 : nregs);
1660         }
1661     }
1662 }
1663
1664 /* Generate all the code for a function call
1665    and return an rtx for its value.
1666    Store the value in TARGET (specified as an rtx) if convenient.
1667    If the value is stored in TARGET then TARGET is returned.
1668    If IGNORE is nonzero, then we ignore the value of the function call.  */
1669
1670 rtx
1671 expand_call (exp, target, ignore)
1672      tree exp;
1673      rtx target;
1674      int ignore;
1675 {
1676   /* Nonzero if we are currently expanding a call.  */
1677   static int currently_expanding_call = 0;
1678
1679   /* List of actual parameters.  */
1680   tree actparms = TREE_OPERAND (exp, 1);
1681   /* RTX for the function to be called.  */
1682   rtx funexp;
1683   /* Sequence of insns to perform a tail recursive "call".  */
1684   rtx tail_recursion_insns = NULL_RTX;
1685   /* Sequence of insns to perform a normal "call".  */
1686   rtx normal_call_insns = NULL_RTX;
1687   /* Sequence of insns to perform a tail recursive "call".  */
1688   rtx tail_call_insns = NULL_RTX;
1689   /* Data type of the function.  */
1690   tree funtype;
1691   /* Declaration of the function being called,
1692      or 0 if the function is computed (not known by name).  */
1693   tree fndecl = 0;
1694   char *name = 0;
1695 #ifdef ACCUMULATE_OUTGOING_ARGS
1696   rtx before_call;
1697 #endif
1698   rtx insn;
1699   int try_tail_call;
1700   int pass;
1701
1702   /* Register in which non-BLKmode value will be returned,
1703      or 0 if no value or if value is BLKmode.  */
1704   rtx valreg;
1705   /* Address where we should return a BLKmode value;
1706      0 if value not BLKmode.  */
1707   rtx structure_value_addr = 0;
1708   /* Nonzero if that address is being passed by treating it as
1709      an extra, implicit first parameter.  Otherwise,
1710      it is passed by being copied directly into struct_value_rtx.  */
1711   int structure_value_addr_parm = 0;
1712   /* Size of aggregate value wanted, or zero if none wanted
1713      or if we are using the non-reentrant PCC calling convention
1714      or expecting the value in registers.  */
1715   HOST_WIDE_INT struct_value_size = 0;
1716   /* Nonzero if called function returns an aggregate in memory PCC style,
1717      by returning the address of where to find it.  */
1718   int pcc_struct_value = 0;
1719
1720   /* Number of actual parameters in this call, including struct value addr.  */
1721   int num_actuals;
1722   /* Number of named args.  Args after this are anonymous ones
1723      and they must all go on the stack.  */
1724   int n_named_args;
1725
1726   /* Vector of information about each argument.
1727      Arguments are numbered in the order they will be pushed,
1728      not the order they are written.  */
1729   struct arg_data *args;
1730
1731   /* Total size in bytes of all the stack-parms scanned so far.  */
1732   struct args_size args_size;
1733   /* Size of arguments before any adjustments (such as rounding).  */
1734   int unadjusted_args_size;
1735   /* Data on reg parms scanned so far.  */
1736   CUMULATIVE_ARGS args_so_far;
1737   /* Nonzero if a reg parm has been scanned.  */
1738   int reg_parm_seen;
1739   /* Nonzero if this is an indirect function call.  */
1740
1741   /* Nonzero if we must avoid push-insns in the args for this call.
1742      If stack space is allocated for register parameters, but not by the
1743      caller, then it is preallocated in the fixed part of the stack frame.
1744      So the entire argument block must then be preallocated (i.e., we
1745      ignore PUSH_ROUNDING in that case).  */
1746
1747 #ifdef PUSH_ROUNDING
1748   int must_preallocate = 0;
1749 #else
1750   int must_preallocate = 1;
1751 #endif
1752
1753   /* Size of the stack reserved for parameter registers.  */
1754   int reg_parm_stack_space = 0;
1755
1756   /* Address of space preallocated for stack parms
1757      (on machines that lack push insns), or 0 if space not preallocated.  */
1758   rtx argblock = 0;
1759
1760   /* Nonzero if it is plausible that this is a call to alloca.  */
1761   int may_be_alloca;
1762   /* Nonzero if this is a call to malloc or a related function. */
1763   int is_malloc;
1764   /* Nonzero if this is a call to setjmp or a related function.  */
1765   int returns_twice;
1766   /* Nonzero if this is a call to `longjmp'.  */
1767   int is_longjmp;
1768   /* Nonzero if this is a syscall that makes a new process in the image of
1769      the current one.  */
1770   int fork_or_exec;
1771   /* Nonzero if this is a call to an inline function.  */
1772   int is_integrable = 0;
1773   /* Nonzero if this is a call to a `const' function.
1774      Note that only explicitly named functions are handled as `const' here.  */
1775   int is_const = 0;
1776   /* Nonzero if this is a call to a `volatile' function.  */
1777   int is_volatile = 0;
1778   /* Nonzero if this is a call to a function that won't throw an exception.  */
1779   int nothrow = TREE_NOTHROW (exp);
1780 #if defined(ACCUMULATE_OUTGOING_ARGS) && defined(REG_PARM_STACK_SPACE)
1781   /* Define the boundary of the register parm stack space that needs to be
1782      save, if any.  */
1783   int low_to_save = -1, high_to_save;
1784   rtx save_area = 0;            /* Place that it is saved */
1785 #endif
1786
1787 #ifdef ACCUMULATE_OUTGOING_ARGS
1788   int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
1789   char *initial_stack_usage_map = stack_usage_map;
1790   int old_stack_arg_under_construction = 0;
1791 #endif
1792
1793   rtx old_stack_level = 0;
1794   int old_pending_adj = 0;
1795   int old_inhibit_defer_pop = inhibit_defer_pop;
1796   rtx call_fusage;
1797   register tree p;
1798   register int i;
1799   int preferred_stack_boundary;
1800
1801   /* The value of the function call can be put in a hard register.  But
1802      if -fcheck-memory-usage, code which invokes functions (and thus
1803      damages some hard registers) can be inserted before using the value.
1804      So, target is always a pseudo-register in that case.  */
1805   if (current_function_check_memory_usage)
1806     target = 0;
1807
1808   /* See if we can find a DECL-node for the actual function.
1809      As a result, decide whether this is a call to an integrable function.  */
1810
1811   p = TREE_OPERAND (exp, 0);
1812   if (TREE_CODE (p) == ADDR_EXPR)
1813     {
1814       fndecl = TREE_OPERAND (p, 0);
1815       if (TREE_CODE (fndecl) != FUNCTION_DECL)
1816         fndecl = 0;
1817       else
1818         {
1819           if (!flag_no_inline
1820               && fndecl != current_function_decl
1821               && DECL_INLINE (fndecl)
1822               && DECL_SAVED_INSNS (fndecl)
1823               && DECL_SAVED_INSNS (fndecl)->inlinable)
1824             is_integrable = 1;
1825           else if (! TREE_ADDRESSABLE (fndecl))
1826             {
1827               /* In case this function later becomes inlinable,
1828                  record that there was already a non-inline call to it.
1829
1830                  Use abstraction instead of setting TREE_ADDRESSABLE
1831                  directly.  */
1832               if (DECL_INLINE (fndecl) && warn_inline && !flag_no_inline
1833                   && optimize > 0)
1834                 {
1835                   warning_with_decl (fndecl, "can't inline call to `%s'");
1836                   warning ("called from here");
1837                 }
1838               mark_addressable (fndecl);
1839             }
1840
1841           if (TREE_READONLY (fndecl) && ! TREE_THIS_VOLATILE (fndecl)
1842               && TYPE_MODE (TREE_TYPE (exp)) != VOIDmode)
1843             is_const = 1;
1844
1845           if (TREE_THIS_VOLATILE (fndecl))
1846             is_volatile = 1;
1847
1848           if (TREE_NOTHROW (fndecl))
1849             nothrow = 1;
1850         }
1851     }
1852
1853   /* If we don't have specific function to call, see if we have a
1854      constant or `noreturn' function from the type.  */
1855   if (fndecl == 0)
1856     {
1857       is_const = TREE_READONLY (TREE_TYPE (TREE_TYPE (p)));
1858       is_volatile = TREE_THIS_VOLATILE (TREE_TYPE (TREE_TYPE (p)));
1859     }
1860
1861 #ifdef REG_PARM_STACK_SPACE
1862 #ifdef MAYBE_REG_PARM_STACK_SPACE
1863   reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
1864 #else
1865   reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
1866 #endif
1867 #endif
1868
1869 #if defined(PUSH_ROUNDING) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
1870   if (reg_parm_stack_space > 0)
1871     must_preallocate = 1;
1872 #endif
1873
1874   /* Warn if this value is an aggregate type,
1875      regardless of which calling convention we are using for it.  */
1876   if (warn_aggregate_return && AGGREGATE_TYPE_P (TREE_TYPE (exp)))
1877     warning ("function call has aggregate value");
1878
1879   /* Set up a place to return a structure.  */
1880
1881   /* Cater to broken compilers.  */
1882   if (aggregate_value_p (exp))
1883     {
1884       /* This call returns a big structure.  */
1885       is_const = 0;
1886
1887 #ifdef PCC_STATIC_STRUCT_RETURN
1888       {
1889         pcc_struct_value = 1;
1890         /* Easier than making that case work right.  */
1891         if (is_integrable)
1892           {
1893             /* In case this is a static function, note that it has been
1894                used.  */
1895             if (! TREE_ADDRESSABLE (fndecl))
1896               mark_addressable (fndecl);
1897             is_integrable = 0;
1898           }
1899       }
1900 #else /* not PCC_STATIC_STRUCT_RETURN */
1901       {
1902         struct_value_size = int_size_in_bytes (TREE_TYPE (exp));
1903
1904         if (target && GET_CODE (target) == MEM)
1905           structure_value_addr = XEXP (target, 0);
1906         else
1907           {
1908             /* Assign a temporary to hold the value.  */
1909             tree d;
1910
1911             /* For variable-sized objects, we must be called with a target
1912                specified.  If we were to allocate space on the stack here,
1913                we would have no way of knowing when to free it.  */
1914
1915             if (struct_value_size < 0)
1916               abort ();
1917
1918             /* This DECL is just something to feed to mark_addressable;
1919                it doesn't get pushed.  */
1920             d = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (exp));
1921             DECL_RTL (d) = assign_temp (TREE_TYPE (exp), 1, 0, 1);
1922             mark_addressable (d);
1923             mark_temp_addr_taken (DECL_RTL (d));
1924             structure_value_addr = XEXP (DECL_RTL (d), 0);
1925             TREE_USED (d) = 1;
1926             target = 0;
1927           }
1928       }
1929 #endif /* not PCC_STATIC_STRUCT_RETURN */
1930     }
1931
1932   /* If called function is inline, try to integrate it.  */
1933
1934   if (is_integrable)
1935     {
1936       rtx temp;
1937
1938 #ifdef ACCUMULATE_OUTGOING_ARGS
1939       before_call = get_last_insn ();
1940 #endif
1941
1942       temp = expand_inline_function (fndecl, actparms, target,
1943                                      ignore, TREE_TYPE (exp),
1944                                      structure_value_addr);
1945
1946       /* If inlining succeeded, return.  */
1947       if (temp != (rtx) (HOST_WIDE_INT) -1)
1948         {
1949 #ifdef ACCUMULATE_OUTGOING_ARGS
1950           /* If the outgoing argument list must be preserved, push
1951              the stack before executing the inlined function if it
1952              makes any calls.  */
1953
1954           for (i = reg_parm_stack_space - 1; i >= 0; i--)
1955             if (i < highest_outgoing_arg_in_use && stack_usage_map[i] != 0)
1956               break;
1957
1958           if (stack_arg_under_construction || i >= 0)
1959             {
1960               rtx first_insn
1961                 = before_call ? NEXT_INSN (before_call) : get_insns ();
1962               rtx insn = NULL_RTX, seq;
1963
1964               /* Look for a call in the inline function code.
1965                  If DECL_SAVED_INSNS (fndecl)->outgoing_args_size is
1966                  nonzero then there is a call and it is not necessary
1967                  to scan the insns.  */
1968
1969               if (DECL_SAVED_INSNS (fndecl)->outgoing_args_size == 0)
1970                 for (insn = first_insn; insn; insn = NEXT_INSN (insn))
1971                   if (GET_CODE (insn) == CALL_INSN)
1972                     break;
1973
1974               if (insn)
1975                 {
1976                   /* Reserve enough stack space so that the largest
1977                      argument list of any function call in the inline
1978                      function does not overlap the argument list being
1979                      evaluated.  This is usually an overestimate because
1980                      allocate_dynamic_stack_space reserves space for an
1981                      outgoing argument list in addition to the requested
1982                      space, but there is no way to ask for stack space such
1983                      that an argument list of a certain length can be
1984                      safely constructed.
1985
1986                      Add the stack space reserved for register arguments, if
1987                      any, in the inline function.  What is really needed is the
1988                      largest value of reg_parm_stack_space in the inline
1989                      function, but that is not available.  Using the current
1990                      value of reg_parm_stack_space is wrong, but gives
1991                      correct results on all supported machines.  */
1992
1993                   int adjust = (DECL_SAVED_INSNS (fndecl)->outgoing_args_size
1994                                 + reg_parm_stack_space);
1995
1996                   start_sequence ();
1997                   emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1998                   allocate_dynamic_stack_space (GEN_INT (adjust),
1999                                                 NULL_RTX, BITS_PER_UNIT);
2000                   seq = get_insns ();
2001                   end_sequence ();
2002                   emit_insns_before (seq, first_insn);
2003                   emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
2004                 }
2005             }
2006 #endif
2007
2008           /* If the result is equivalent to TARGET, return TARGET to simplify
2009              checks in store_expr.  They can be equivalent but not equal in the
2010              case of a function that returns BLKmode.  */
2011           if (temp != target && rtx_equal_p (temp, target))
2012             return target;
2013           return temp;
2014         }
2015
2016       /* If inlining failed, mark FNDECL as needing to be compiled
2017          separately after all.  If function was declared inline,
2018          give a warning.  */
2019       if (DECL_INLINE (fndecl) && warn_inline && !flag_no_inline
2020           && optimize > 0 && ! TREE_ADDRESSABLE (fndecl))
2021         {
2022           warning_with_decl (fndecl, "inlining failed in call to `%s'");
2023           warning ("called from here");
2024         }
2025       mark_addressable (fndecl);
2026     }
2027
2028   currently_expanding_call++;
2029
2030   /* Tail calls can make things harder to debug, and we're traditionally
2031      pushed these optimizations into -O2.  Don't try if we're already
2032      expanding a call, as that means we're an argument.  Similarly, if
2033      there's pending loops or cleanups we know there's code to follow
2034      the call.  */
2035
2036   try_tail_call = 0;
2037   if (flag_optimize_sibling_calls
2038       && currently_expanding_call == 1
2039       && stmt_loop_nest_empty ()
2040       && ! any_pending_cleanups (1))
2041     {
2042       tree new_actparms = NULL_TREE;
2043
2044       /* Ok, we're going to give the tail call the old college try.
2045          This means we're going to evaluate the function arguments
2046          up to three times.  There are two degrees of badness we can
2047          encounter, those that can be unsaved and those that can't.
2048          (See unsafe_for_reeval commentary for details.)
2049
2050          Generate a new argument list.  Pass safe arguments through
2051          unchanged.  For the easy badness wrap them in UNSAVE_EXPRs.
2052          For hard badness, evaluate them now and put their resulting
2053          rtx in a temporary VAR_DECL.  */
2054
2055       for (p = actparms; p; p = TREE_CHAIN (p))
2056         switch (unsafe_for_reeval (TREE_VALUE (p)))
2057           {
2058           case 0: /* Safe.  */
2059             new_actparms = tree_cons (TREE_PURPOSE (p), TREE_VALUE (p),
2060                                       new_actparms);
2061             break;
2062
2063           case 1: /* Mildly unsafe.  */
2064             new_actparms = tree_cons (TREE_PURPOSE (p),
2065                                       unsave_expr (TREE_VALUE (p)),
2066                                       new_actparms);
2067             break;
2068
2069           case 2: /* Wildly unsafe.  */
2070             {
2071               tree var = build_decl (VAR_DECL, NULL_TREE,
2072                                      TREE_TYPE (TREE_VALUE (p)));
2073               DECL_RTL (var) = expand_expr (TREE_VALUE (p), NULL_RTX,
2074                                             VOIDmode, EXPAND_NORMAL);
2075               new_actparms = tree_cons (TREE_PURPOSE (p), var, new_actparms);
2076             }
2077             break;
2078
2079           default:
2080             abort ();
2081           }
2082
2083       /* We built the new argument chain backwards.  */
2084       actparms = nreverse (new_actparms);
2085
2086       /* Expanding one of those dangerous arguments could have added
2087          cleanups, but otherwise give it a whirl.  */
2088       try_tail_call = ! any_pending_cleanups (1);
2089     }
2090
2091   /* Generate a tail recursion sequence when calling ourselves.  */
2092
2093   if (try_tail_call
2094       && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
2095       && TREE_OPERAND (TREE_OPERAND (exp, 0), 0) == current_function_decl)
2096     {
2097       /* We want to emit any pending stack adjustments before the tail
2098          recursion "call".  That way we know any adjustment after the tail
2099          recursion call can be ignored if we indeed use the tail recursion
2100          call expansion.  */
2101       int save_pending_stack_adjust = pending_stack_adjust;
2102
2103       /* Use a new sequence to hold any RTL we generate.  We do not even
2104          know if we will use this RTL yet.  The final decision can not be
2105          made until after RTL generation for the entire function is
2106          complete.  */
2107       start_sequence ();
2108
2109       /* Emit the pending stack adjustments before we expand any arguments.  */
2110       do_pending_stack_adjust ();
2111
2112       if (optimize_tail_recursion (actparms, get_last_insn ()))
2113         tail_recursion_insns = get_insns ();
2114       end_sequence ();
2115
2116       /* Restore the original pending stack adjustment for the sibling and
2117          normal call cases below.  */
2118       pending_stack_adjust = save_pending_stack_adjust;
2119     }
2120
2121   function_call_count++;
2122
2123   if (fndecl && DECL_NAME (fndecl))
2124     name = IDENTIFIER_POINTER (DECL_NAME (fndecl));
2125
2126 #ifdef PREFERRED_STACK_BOUNDARY
2127   preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
2128 #else
2129   preferred_stack_boundary = STACK_BOUNDARY;
2130 #endif
2131
2132   /* Ensure current function's preferred stack boundary is at least
2133      what we need.  We don't have to increase alignment for recursive
2134      functions.  */
2135   if (cfun->preferred_stack_boundary < preferred_stack_boundary
2136       && fndecl != current_function_decl)
2137     cfun->preferred_stack_boundary = preferred_stack_boundary;
2138
2139   /* See if this is a call to a function that can return more than once
2140      or a call to longjmp or malloc.  */
2141   special_function_p (fndecl, &returns_twice, &is_longjmp, &fork_or_exec,
2142                       &is_malloc, &may_be_alloca);
2143
2144   if (may_be_alloca)
2145     current_function_calls_alloca = 1;
2146
2147   /* Operand 0 is a pointer-to-function; get the type of the function.  */
2148   funtype = TREE_TYPE (TREE_OPERAND (exp, 0));
2149   if (! POINTER_TYPE_P (funtype))
2150     abort ();
2151   funtype = TREE_TYPE (funtype);
2152
2153   /* We want to make two insn chains; one for a sibling call, the other
2154      for a normal call.  We will select one of the two chains after
2155      initial RTL generation is complete.  */
2156   for (pass = 0; pass < 2; pass++)
2157     {
2158       int sibcall_failure = 0;
2159       /* We want to emit ay pending stack adjustments before the tail
2160          recursion "call".  That way we know any adjustment after the tail
2161          recursion call can be ignored if we indeed use the tail recursion
2162          call expansion.  */
2163       int save_pending_stack_adjust;
2164       rtx insns;
2165       rtx before_call, next_arg_reg;
2166
2167       if (pass == 0)
2168         {
2169           /* Various reasons we can not use a sibling call.  */
2170           if (! try_tail_call
2171 #ifdef HAVE_sibcall_epilogue
2172               || ! HAVE_sibcall_epilogue
2173 #else
2174               || 1
2175 #endif
2176               /* The structure value address is used and modified in the
2177                  loop below.  It does not seem worth the effort to save and
2178                  restore it as a state variable since few optimizable
2179                  sibling calls will return a structure.  */
2180               || structure_value_addr != NULL_RTX
2181               /* If the register holding the address is a callee saved
2182                  register, then we lose.  We have no way to prevent that,
2183                  so we only allow calls to named functions.  */
2184               /* ??? This could be done by having the insn constraints
2185                  use a register class that is all call-clobbered.  Any
2186                  reload insns generated to fix things up would appear
2187                  before the sibcall_epilogue.  */
2188               || fndecl == NULL_TREE
2189               || ! FUNCTION_OK_FOR_SIBCALL (fndecl))
2190             continue;
2191
2192           /* We know at this point that there are not currently any
2193              pending cleanups.  If, however, in the process of evaluating
2194              the arguments we were to create some, we'll need to be
2195              able to get rid of them.  */
2196           expand_start_target_temps ();
2197
2198           /* State variables we need to save and restore between
2199              iterations.  */
2200           save_pending_stack_adjust = pending_stack_adjust;
2201         }
2202
2203       /* Other state variables that we must reinitialize each time
2204          through the loop (that are not initialized by the loop itself.  */
2205       argblock = 0;
2206       call_fusage = 0;
2207
2208       /* Start a new sequence for the normal call case.
2209
2210          From this point on, if the sibling call fails, we want to set
2211          sibcall_failure instead of continuing the loop.  */
2212       start_sequence ();
2213
2214       /* When calling a const function, we must pop the stack args right away,
2215          so that the pop is deleted or moved with the call.  */
2216       if (is_const)
2217         NO_DEFER_POP;
2218
2219       /* Don't let pending stack adjusts add up to too much.
2220          Also, do all pending adjustments now if there is any chance
2221          this might be a call to alloca or if we are expanding a sibling
2222          call sequence.  */
2223       if (pending_stack_adjust >= 32
2224           || (pending_stack_adjust > 0 && may_be_alloca)
2225           || pass == 0)
2226         do_pending_stack_adjust ();
2227
2228       if (profile_arc_flag && fork_or_exec)
2229         {
2230           /* A fork duplicates the profile information, and an exec discards
2231              it.  We can't rely on fork/exec to be paired.  So write out the
2232              profile information we have gathered so far, and clear it.  */
2233           /* ??? When Linux's __clone is called with CLONE_VM set, profiling
2234              is subject to race conditions, just as with multithreaded
2235              programs.  */
2236
2237           emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__bb_fork_func"), 0,
2238                              VOIDmode, 0);
2239         }
2240
2241       /* Push the temporary stack slot level so that we can free any
2242          temporaries we make.  */
2243       push_temp_slots ();
2244
2245       /* Start updating where the next arg would go.
2246
2247          On some machines (such as the PA) indirect calls have a different
2248          calling convention than normal calls.  The last argument in
2249          INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
2250          or not.  */
2251       INIT_CUMULATIVE_ARGS (args_so_far, funtype, NULL_RTX, (fndecl == 0));
2252
2253       /* If struct_value_rtx is 0, it means pass the address
2254          as if it were an extra parameter.  */
2255       if (structure_value_addr && struct_value_rtx == 0)
2256         {
2257           /* If structure_value_addr is a REG other than
2258              virtual_outgoing_args_rtx, we can use always use it.  If it
2259              is not a REG, we must always copy it into a register.
2260              If it is virtual_outgoing_args_rtx, we must copy it to another
2261              register in some cases.  */
2262           rtx temp = (GET_CODE (structure_value_addr) != REG
2263 #ifdef ACCUMULATE_OUTGOING_ARGS
2264                       || (stack_arg_under_construction
2265                           && structure_value_addr == virtual_outgoing_args_rtx)
2266 #endif
2267                       ? copy_addr_to_reg (structure_value_addr)
2268                       : structure_value_addr);
2269
2270           actparms
2271             = tree_cons (error_mark_node,
2272                          make_tree (build_pointer_type (TREE_TYPE (funtype)),
2273                                     temp),
2274                          actparms);
2275           structure_value_addr_parm = 1;
2276         }
2277
2278       /* Count the arguments and set NUM_ACTUALS.  */
2279       for (p = actparms, i = 0; p; p = TREE_CHAIN (p)) i++;
2280       num_actuals = i;
2281
2282       /* Compute number of named args.
2283          Normally, don't include the last named arg if anonymous args follow.
2284          We do include the last named arg if STRICT_ARGUMENT_NAMING is nonzero.
2285          (If no anonymous args follow, the result of list_length is actually
2286          one too large.  This is harmless.)
2287
2288          If PRETEND_OUTGOING_VARARGS_NAMED is set and STRICT_ARGUMENT_NAMING is
2289          zero, this machine will be able to place unnamed args that were
2290          passed in registers into the stack.  So treat all args as named.
2291          This allows the insns emitting for a specific argument list to be
2292          independent of the function declaration.
2293
2294          If PRETEND_OUTGOING_VARARGS_NAMED is not set, we do not have any
2295          reliable way to pass unnamed args in registers, so we must force
2296          them into memory.  */
2297
2298       if ((STRICT_ARGUMENT_NAMING
2299            || ! PRETEND_OUTGOING_VARARGS_NAMED)
2300           && TYPE_ARG_TYPES (funtype) != 0)
2301         n_named_args
2302           = (list_length (TYPE_ARG_TYPES (funtype))
2303              /* Don't include the last named arg.  */
2304              - (STRICT_ARGUMENT_NAMING ? 0 : 1)
2305              /* Count the struct value address, if it is passed as a parm.  */
2306              + structure_value_addr_parm);
2307       else
2308         /* If we know nothing, treat all args as named.  */
2309         n_named_args = num_actuals;
2310
2311       /* Make a vector to hold all the information about each arg.  */
2312       args = (struct arg_data *) alloca (num_actuals
2313                                          * sizeof (struct arg_data));
2314       bzero ((char *) args, num_actuals * sizeof (struct arg_data));
2315
2316       /* Build up entries inthe ARGS array, compute the size of the arguments
2317          into ARGS_SIZE, etc.  */
2318       initialize_argument_information (num_actuals, args, &args_size,
2319                                        n_named_args, actparms, fndecl,
2320                                        &args_so_far, reg_parm_stack_space,
2321                                        &old_stack_level, &old_pending_adj,
2322                                        &must_preallocate, &is_const,
2323                                        (pass == 0) ? ECF_SIBCALL : 0);
2324
2325 #ifdef FINAL_REG_PARM_STACK_SPACE
2326       reg_parm_stack_space = FINAL_REG_PARM_STACK_SPACE (args_size.constant,
2327                                                          args_size.var);
2328 #endif
2329
2330       if (args_size.var)
2331         {
2332           /* If this function requires a variable-sized argument list, don't
2333              try to make a cse'able block for this call.  We may be able to
2334              do this eventually, but it is too complicated to keep track of
2335              what insns go in the cse'able block and which don't.
2336
2337              Also do not make a sibling call.  */
2338
2339           is_const = 0;
2340           must_preallocate = 1;
2341           sibcall_failure = 1;
2342         }
2343
2344       if (args_size.constant > current_function_args_size)
2345         {
2346           /* If this function requires more stack slots than the current
2347              function, we cannot change it into a sibling call.  */
2348           sibcall_failure = 1;
2349         }
2350
2351       /* Compute the actual size of the argument block required.  The variable
2352          and constant sizes must be combined, the size may have to be rounded,
2353          and there may be a minimum required size.  When generating a sibcall
2354          pattern, do not round up, since we'll be re-using whatever space our
2355          caller provided.  */
2356       unadjusted_args_size
2357         = compute_argument_block_size (reg_parm_stack_space, &args_size,
2358                                        (pass == 0 ? 0
2359                                         : preferred_stack_boundary));
2360
2361       /* If the callee pops its own arguments, then it must pop exactly
2362          the same number of arguments as the current function.  */
2363       if (RETURN_POPS_ARGS (fndecl, funtype, unadjusted_args_size)
2364           != RETURN_POPS_ARGS (current_function_decl,
2365                                TREE_TYPE (current_function_decl),
2366                                current_function_args_size))
2367         sibcall_failure = 1;
2368
2369       /* Now make final decision about preallocating stack space.  */
2370       must_preallocate = finalize_must_preallocate (must_preallocate,
2371                                                     num_actuals, args,
2372                                                     &args_size);
2373
2374       /* If the structure value address will reference the stack pointer, we
2375          must stabilize it.  We don't need to do this if we know that we are
2376          not going to adjust the stack pointer in processing this call.  */
2377
2378       if (structure_value_addr
2379           && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
2380               || reg_mentioned_p (virtual_outgoing_args_rtx,
2381                                   structure_value_addr))
2382           && (args_size.var
2383 #ifndef ACCUMULATE_OUTGOING_ARGS
2384               || args_size.constant
2385 #endif
2386               ))
2387         structure_value_addr = copy_to_reg (structure_value_addr);
2388
2389       /* Precompute any arguments as needed.  */
2390       precompute_arguments (is_const, must_preallocate, num_actuals,
2391                             args, &args_size);
2392
2393       /* Now we are about to start emitting insns that can be deleted
2394          if a libcall is deleted.  */
2395       if (is_const || is_malloc)
2396         start_sequence ();
2397
2398       /* If we have no actual push instructions, or shouldn't use them,
2399          make space for all args right now.  */
2400
2401       if (args_size.var != 0)
2402         {
2403           if (old_stack_level == 0)
2404             {
2405               emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
2406               old_pending_adj = pending_stack_adjust;
2407               pending_stack_adjust = 0;
2408 #ifdef ACCUMULATE_OUTGOING_ARGS
2409               /* stack_arg_under_construction says whether a stack arg is
2410                  being constructed at the old stack level.  Pushing the stack
2411                  gets a clean outgoing argument block.  */
2412               old_stack_arg_under_construction = stack_arg_under_construction;
2413               stack_arg_under_construction = 0;
2414 #endif
2415             }
2416           argblock = push_block (ARGS_SIZE_RTX (args_size), 0, 0);
2417         }
2418       else
2419         {
2420           /* Note that we must go through the motions of allocating an argument
2421              block even if the size is zero because we may be storing args
2422              in the area reserved for register arguments, which may be part of
2423              the stack frame.  */
2424
2425           int needed = args_size.constant;
2426
2427           /* Store the maximum argument space used.  It will be pushed by
2428              the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
2429              checking).  */
2430
2431           if (needed > current_function_outgoing_args_size)
2432             current_function_outgoing_args_size = needed;
2433
2434           if (must_preallocate)
2435             {
2436 #ifdef ACCUMULATE_OUTGOING_ARGS
2437               /* Since the stack pointer will never be pushed, it is possible
2438                  for the evaluation of a parm to clobber something we have
2439                  already written to the stack.  Since most function calls on
2440                  RISC machines do not use the stack, this is uncommon, but
2441                  must work correctly.
2442
2443                  Therefore, we save any area of the stack that was already
2444                  written and that we are using.  Here we set up to do this by
2445                  making a new stack usage map from the old one.  The actual
2446                  save will be done by store_one_arg.
2447
2448                  Another approach might be to try to reorder the argument
2449                  evaluations to avoid this conflicting stack usage.  */
2450
2451 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2452               /* Since we will be writing into the entire argument area, the
2453                  map must be allocated for its entire size, not just the part
2454                  that is the responsibility of the caller.  */
2455               needed += reg_parm_stack_space;
2456 #endif
2457
2458 #ifdef ARGS_GROW_DOWNWARD
2459               highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
2460                                                  needed + 1);
2461 #else
2462               highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
2463                                                  needed);
2464 #endif
2465               stack_usage_map = (char *) alloca (highest_outgoing_arg_in_use);
2466
2467               if (initial_highest_arg_in_use)
2468                 bcopy (initial_stack_usage_map, stack_usage_map,
2469                        initial_highest_arg_in_use);
2470
2471               if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
2472                 bzero (&stack_usage_map[initial_highest_arg_in_use],
2473                        (highest_outgoing_arg_in_use
2474                         - initial_highest_arg_in_use));
2475               needed = 0;
2476
2477               /* The address of the outgoing argument list must not be copied
2478                  to a register here, because argblock would be left pointing
2479                  to the wrong place after the call to
2480                  allocate_dynamic_stack_space below. */
2481
2482               argblock = virtual_outgoing_args_rtx;
2483
2484 #else /* not ACCUMULATE_OUTGOING_ARGS */
2485               if (inhibit_defer_pop == 0)
2486                 {
2487                   /* Try to reuse some or all of the pending_stack_adjust
2488                      to get this space.  Maybe we can avoid any pushing.  */
2489                   if (needed > pending_stack_adjust)
2490                     {
2491                       needed -= pending_stack_adjust;
2492                       pending_stack_adjust = 0;
2493                     }
2494                   else
2495                     {
2496                       pending_stack_adjust -= needed;
2497                       needed = 0;
2498                     }
2499                 }
2500               /* Special case this because overhead of `push_block' in this
2501                  case is non-trivial.  */
2502               if (needed == 0)
2503                 argblock = virtual_outgoing_args_rtx;
2504               else
2505                 argblock = push_block (GEN_INT (needed), 0, 0);
2506
2507               /* We only really need to call `copy_to_reg' in the case where
2508                  push insns are going to be used to pass ARGBLOCK to a function
2509                  call in ARGS.  In that case, the stack pointer changes value
2510                  from the allocation point to the call point, and hence
2511                  the value of VIRTUAL_OUTGOING_ARGS_RTX changes as well.
2512                  But might as well always do it.  */
2513               argblock = copy_to_reg (argblock);
2514 #endif /* not ACCUMULATE_OUTGOING_ARGS */
2515             }
2516         }
2517
2518       /* The argument block when performing a sibling call is the
2519          incoming argument block.  */
2520       if (pass == 0)
2521         {
2522           rtx temp = plus_constant (arg_pointer_rtx,
2523                                     FIRST_PARM_OFFSET (current_function_decl));
2524           argblock = force_reg (Pmode, force_operand (temp, NULL_RTX));
2525         }
2526
2527 #ifdef ACCUMULATE_OUTGOING_ARGS
2528       /* The save/restore code in store_one_arg handles all cases except one:
2529          a constructor call (including a C function returning a BLKmode struct)
2530          to initialize an argument.  */
2531       if (stack_arg_under_construction)
2532         {
2533 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2534           rtx push_size = GEN_INT (reg_parm_stack_space + args_size.constant);
2535 #else
2536           rtx push_size = GEN_INT (args_size.constant);
2537 #endif
2538           if (old_stack_level == 0)
2539             {
2540               emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
2541               old_pending_adj = pending_stack_adjust;
2542               pending_stack_adjust = 0;
2543               /* stack_arg_under_construction says whether a stack arg is
2544                  being constructed at the old stack level.  Pushing the stack
2545                  gets a clean outgoing argument block.  */
2546               old_stack_arg_under_construction = stack_arg_under_construction;
2547               stack_arg_under_construction = 0;
2548               /* Make a new map for the new argument list.  */
2549               stack_usage_map = (char *)alloca (highest_outgoing_arg_in_use);
2550               bzero (stack_usage_map, highest_outgoing_arg_in_use);
2551               highest_outgoing_arg_in_use = 0;
2552             }
2553           allocate_dynamic_stack_space (push_size, NULL_RTX, BITS_PER_UNIT);
2554         }
2555       /* If argument evaluation might modify the stack pointer, copy the
2556          address of the argument list to a register.  */
2557       for (i = 0; i < num_actuals; i++)
2558         if (args[i].pass_on_stack)
2559           {
2560             argblock = copy_addr_to_reg (argblock);
2561             break;
2562           }
2563 #endif
2564
2565       compute_argument_addresses (args, argblock, num_actuals);
2566
2567 #ifdef PUSH_ARGS_REVERSED
2568 #ifdef PREFERRED_STACK_BOUNDARY
2569       /* If we push args individually in reverse order, perform stack alignment
2570          before the first push (the last arg).  */
2571       if (args_size.constant != unadjusted_args_size)
2572         {
2573           /* When the stack adjustment is pending, we get better code
2574              by combining the adjustments.  */
2575           if (pending_stack_adjust && ! is_const
2576               && ! inhibit_defer_pop)
2577             {
2578               args_size.constant = (unadjusted_args_size
2579                                     + ((pending_stack_adjust
2580                                         + args_size.constant
2581                                         + arg_space_so_far
2582                                         - unadjusted_args_size)
2583                                        % (preferred_stack_boundary
2584                                           / BITS_PER_UNIT)));
2585               pending_stack_adjust -= (args_size.constant
2586                                        - unadjusted_args_size);
2587               do_pending_stack_adjust ();
2588             }
2589           else if (argblock == 0)
2590             anti_adjust_stack (GEN_INT (args_size.constant
2591                                         - unadjusted_args_size));
2592           arg_space_so_far += args_size.constant - unadjusted_args_size;
2593
2594           /* Now that the stack is properly aligned, pops can't safely
2595              be deferred during the evaluation of the arguments.  */
2596           NO_DEFER_POP;
2597         }
2598 #endif
2599 #endif
2600
2601       /* Don't try to defer pops if preallocating, not even from the first arg,
2602          since ARGBLOCK probably refers to the SP.  */
2603       if (argblock)
2604         NO_DEFER_POP;
2605
2606       funexp = rtx_for_function_call (fndecl, exp);
2607
2608       /* Figure out the register where the value, if any, will come back.  */
2609       valreg = 0;
2610       if (TYPE_MODE (TREE_TYPE (exp)) != VOIDmode
2611           && ! structure_value_addr)
2612         {
2613           if (pcc_struct_value)
2614             valreg = hard_function_value (build_pointer_type (TREE_TYPE (exp)),
2615                                           fndecl, (pass == 0));
2616           else
2617             valreg = hard_function_value (TREE_TYPE (exp), fndecl, (pass == 0));
2618         }
2619
2620       /* Precompute all register parameters.  It isn't safe to compute anything
2621          once we have started filling any specific hard regs.  */
2622       precompute_register_parameters (num_actuals, args, &reg_parm_seen);
2623
2624 #if defined(ACCUMULATE_OUTGOING_ARGS) && defined(REG_PARM_STACK_SPACE)
2625       /* Save the fixed argument area if it's part of the caller's frame and
2626          is clobbered by argument setup for this call.  */
2627       save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
2628                                             &low_to_save, &high_to_save);
2629 #endif
2630
2631       /* Now store (and compute if necessary) all non-register parms.
2632          These come before register parms, since they can require block-moves,
2633          which could clobber the registers used for register parms.
2634          Parms which have partial registers are not stored here,
2635          but we do preallocate space here if they want that.  */
2636
2637       for (i = 0; i < num_actuals; i++)
2638         if (args[i].reg == 0 || args[i].pass_on_stack)
2639           store_one_arg (&args[i], argblock, may_be_alloca,
2640                          args_size.var != 0, reg_parm_stack_space);
2641
2642       /* If we have a parm that is passed in registers but not in memory
2643          and whose alignment does not permit a direct copy into registers,
2644          make a group of pseudos that correspond to each register that we
2645          will later fill.  */
2646       if (STRICT_ALIGNMENT)
2647         store_unaligned_arguments_into_pseudos (args, num_actuals);
2648
2649       /* Now store any partially-in-registers parm.
2650          This is the last place a block-move can happen.  */
2651       if (reg_parm_seen)
2652         for (i = 0; i < num_actuals; i++)
2653           if (args[i].partial != 0 && ! args[i].pass_on_stack)
2654             store_one_arg (&args[i], argblock, may_be_alloca,
2655                            args_size.var != 0, reg_parm_stack_space);
2656
2657 #ifndef PUSH_ARGS_REVERSED
2658 #ifdef PREFERRED_STACK_BOUNDARY
2659       /* If we pushed args in forward order, perform stack alignment
2660          after pushing the last arg.  */
2661       /* ??? Fix for arg_space_so_far.  */
2662       if (argblock == 0)
2663         anti_adjust_stack (GEN_INT (args_size.constant
2664                                     - unadjusted_args_size));
2665 #endif
2666 #endif
2667
2668       /* If register arguments require space on the stack and stack space
2669          was not preallocated, allocate stack space here for arguments
2670          passed in registers.  */
2671 #if ! defined(ACCUMULATE_OUTGOING_ARGS) && defined(OUTGOING_REG_PARM_STACK_SPACE)
2672       if (must_preallocate == 0 && reg_parm_stack_space > 0)
2673         anti_adjust_stack (GEN_INT (reg_parm_stack_space));
2674 #endif
2675
2676       /* Pass the function the address in which to return a
2677          structure value.  */
2678       if (pass != 0 && structure_value_addr && ! structure_value_addr_parm)
2679         {
2680           emit_move_insn (struct_value_rtx,
2681                           force_reg (Pmode,
2682                                      force_operand (structure_value_addr,
2683                                                     NULL_RTX)));
2684
2685           /* Mark the memory for the aggregate as write-only.  */
2686           if (current_function_check_memory_usage)
2687             emit_library_call (chkr_set_right_libfunc, 1,
2688                                VOIDmode, 3,
2689                                structure_value_addr, ptr_mode,
2690                                GEN_INT (struct_value_size),
2691                                TYPE_MODE (sizetype),
2692                                GEN_INT (MEMORY_USE_WO),
2693                                TYPE_MODE (integer_type_node));
2694
2695           if (GET_CODE (struct_value_rtx) == REG)
2696             use_reg (&call_fusage, struct_value_rtx);
2697         }
2698
2699       funexp = prepare_call_address (funexp, fndecl, &call_fusage,
2700                                      reg_parm_seen);
2701
2702       load_register_parameters (args, num_actuals, &call_fusage);
2703
2704       /* Perform postincrements before actually calling the function.  */
2705       emit_queue ();
2706
2707       /* Save a pointer to the last insn before the call, so that we can
2708          later safely search backwards to find the CALL_INSN.  */
2709       before_call = get_last_insn ();
2710
2711       /* Set up next argument register.  For sibling calls on machines
2712          with register windows this should be the incoming register.  */
2713 #ifdef FUNCTION_INCOMING_ARG
2714       if (pass == 0)
2715         next_arg_reg = FUNCTION_INCOMING_ARG (args_so_far, VOIDmode,
2716                                               void_type_node, 1);
2717       else
2718 #endif
2719         next_arg_reg = FUNCTION_ARG (args_so_far, VOIDmode,
2720                                      void_type_node, 1);
2721
2722       /* All arguments and registers used for the call must be set up by
2723          now!  */
2724
2725       /* Generate the actual call instruction.  */
2726       emit_call_1 (funexp, fndecl, funtype, unadjusted_args_size,
2727                    args_size.constant, struct_value_size,
2728                    next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
2729                    ((is_const ? ECF_IS_CONST : 0)
2730                     | (nothrow ? ECF_NOTHROW : 0)
2731                     | (pass == 0 ? ECF_SIBCALL : 0)));
2732
2733       /* If call is cse'able, make appropriate pair of reg-notes around it.
2734          Test valreg so we don't crash; may safely ignore `const'
2735          if return type is void.  Disable for PARALLEL return values, because
2736          we have no way to move such values into a pseudo register.  */
2737       if (is_const && valreg != 0 && GET_CODE (valreg) != PARALLEL)
2738         {
2739           rtx note = 0;
2740           rtx temp = gen_reg_rtx (GET_MODE (valreg));
2741           rtx insns;
2742
2743           /* Mark the return value as a pointer if needed.  */
2744           if (TREE_CODE (TREE_TYPE (exp)) == POINTER_TYPE)
2745             {
2746               tree pointed_to = TREE_TYPE (TREE_TYPE (exp));
2747               mark_reg_pointer (temp, TYPE_ALIGN (pointed_to) / BITS_PER_UNIT);
2748             }
2749
2750           /* Construct an "equal form" for the value which mentions all the
2751              arguments in order as well as the function name.  */
2752 #ifdef PUSH_ARGS_REVERSED
2753           for (i = 0; i < num_actuals; i++)
2754             note = gen_rtx_EXPR_LIST (VOIDmode, args[i].initial_value, note);
2755 #else
2756           for (i = num_actuals - 1; i >= 0; i--)
2757             note = gen_rtx_EXPR_LIST (VOIDmode, args[i].initial_value, note);
2758 #endif
2759           note = gen_rtx_EXPR_LIST (VOIDmode, funexp, note);
2760
2761           insns = get_insns ();
2762           end_sequence ();
2763
2764           emit_libcall_block (insns, temp, valreg, note);
2765
2766           valreg = temp;
2767         }
2768       else if (is_const)
2769         {
2770           /* Otherwise, just write out the sequence without a note.  */
2771           rtx insns = get_insns ();
2772
2773           end_sequence ();
2774           emit_insns (insns);
2775         }
2776       else if (is_malloc)
2777         {
2778           rtx temp = gen_reg_rtx (GET_MODE (valreg));
2779           rtx last, insns;
2780
2781           /* The return value from a malloc-like function is a pointer. */
2782           if (TREE_CODE (TREE_TYPE (exp)) == POINTER_TYPE)
2783             mark_reg_pointer (temp, BIGGEST_ALIGNMENT / BITS_PER_UNIT);
2784
2785           emit_move_insn (temp, valreg);
2786
2787           /* The return value from a malloc-like function can not alias
2788              anything else.  */
2789           last = get_last_insn ();
2790           REG_NOTES (last) =
2791             gen_rtx_EXPR_LIST (REG_NOALIAS, temp, REG_NOTES (last));
2792
2793           /* Write out the sequence.  */
2794           insns = get_insns ();
2795           end_sequence ();
2796           emit_insns (insns);
2797           valreg = temp;
2798         }
2799
2800       /* For calls to `setjmp', etc., inform flow.c it should complain
2801          if nonvolatile values are live.  For functions that cannot return,
2802          inform flow that control does not fall through.  */
2803
2804       if (returns_twice || is_volatile || is_longjmp || pass == 0)
2805         {
2806           /* The barrier or NOTE_INSN_SETJMP note must be emitted
2807              immediately after the CALL_INSN.  Some ports emit more
2808              than just a CALL_INSN above, so we must search for it here.  */
2809
2810           rtx last = get_last_insn ();
2811           while (GET_CODE (last) != CALL_INSN)
2812             {
2813               last = PREV_INSN (last);
2814               /* There was no CALL_INSN?  */
2815               if (last == before_call)
2816                 abort ();
2817             }
2818
2819           if (returns_twice)
2820             {
2821               emit_note_after (NOTE_INSN_SETJMP, last);
2822               current_function_calls_setjmp = 1;
2823               sibcall_failure = 1;
2824             }
2825           else
2826             emit_barrier_after (last);
2827         }
2828
2829       if (is_longjmp)
2830         current_function_calls_longjmp = 1, sibcall_failure = 1;
2831
2832       /* If this function is returning into a memory location marked as
2833          readonly, it means it is initializing that location.  But we normally
2834          treat functions as not clobbering such locations, so we need to
2835          specify that this one does.  */
2836       if (target != 0 && GET_CODE (target) == MEM
2837           && structure_value_addr != 0 && RTX_UNCHANGING_P (target))
2838         emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
2839
2840       /* If value type not void, return an rtx for the value.  */
2841
2842       /* If there are cleanups to be called, don't use a hard reg as target.
2843          We need to double check this and see if it matters anymore.  */
2844       if (any_pending_cleanups (1))
2845         {
2846           if (target && REG_P (target)
2847               && REGNO (target) < FIRST_PSEUDO_REGISTER)
2848             target = 0;
2849           sibcall_failure = 1;
2850         }
2851
2852       if (TYPE_MODE (TREE_TYPE (exp)) == VOIDmode
2853           || ignore)
2854         {
2855           target = const0_rtx;
2856         }
2857       else if (structure_value_addr)
2858         {
2859           if (target == 0 || GET_CODE (target) != MEM)
2860             {
2861               target = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
2862                                     memory_address (TYPE_MODE (TREE_TYPE (exp)),
2863                                                     structure_value_addr));
2864               MEM_SET_IN_STRUCT_P (target,
2865                                    AGGREGATE_TYPE_P (TREE_TYPE (exp)));
2866             }
2867         }
2868       else if (pcc_struct_value)
2869         {
2870           /* This is the special C++ case where we need to
2871              know what the true target was.  We take care to
2872              never use this value more than once in one expression.  */
2873           target = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
2874                                 copy_to_reg (valreg));
2875           MEM_SET_IN_STRUCT_P (target, AGGREGATE_TYPE_P (TREE_TYPE (exp)));
2876         }
2877       /* Handle calls that return values in multiple non-contiguous locations.
2878          The Irix 6 ABI has examples of this.  */
2879       else if (GET_CODE (valreg) == PARALLEL)
2880         {
2881           int bytes = int_size_in_bytes (TREE_TYPE (exp));
2882
2883           if (target == 0)
2884             {
2885               target = assign_stack_temp (TYPE_MODE (TREE_TYPE (exp)),
2886                                           bytes, 0);
2887               MEM_SET_IN_STRUCT_P (target, AGGREGATE_TYPE_P (TREE_TYPE (exp)));
2888               preserve_temp_slots (target);
2889             }
2890
2891           if (! rtx_equal_p (target, valreg))
2892             emit_group_store (target, valreg, bytes,
2893                               TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT);
2894           /* We can not support sibling calls for this case.  */
2895           sibcall_failure = 1;
2896         }
2897       else if (target
2898                && GET_MODE (target) == TYPE_MODE (TREE_TYPE (exp))
2899                && GET_MODE (target) == GET_MODE (valreg))
2900         {
2901           /* TARGET and VALREG cannot be equal at this point because the
2902              latter would not have REG_FUNCTION_VALUE_P true, while the
2903              former would if it were referring to the same register.
2904
2905              If they refer to the same register, this move will be a no-op,
2906              except when function inlining is being done.  */
2907           emit_move_insn (target, valreg);
2908         }
2909       else if (TYPE_MODE (TREE_TYPE (exp)) == BLKmode)
2910         target = copy_blkmode_from_reg (target, valreg, TREE_TYPE (exp));
2911       else
2912         target = copy_to_reg (valreg);
2913
2914 #ifdef PROMOTE_FUNCTION_RETURN
2915       /* If we promoted this return value, make the proper SUBREG.  TARGET
2916          might be const0_rtx here, so be careful.  */
2917       if (GET_CODE (target) == REG
2918           && TYPE_MODE (TREE_TYPE (exp)) != BLKmode
2919           && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
2920         {
2921           tree type = TREE_TYPE (exp);
2922           int unsignedp = TREE_UNSIGNED (type);
2923
2924           /* If we don't promote as expected, something is wrong.  */
2925           if (GET_MODE (target)
2926               != promote_mode (type, TYPE_MODE (type), &unsignedp, 1))
2927             abort ();
2928
2929           target = gen_rtx_SUBREG (TYPE_MODE (type), target, 0);
2930           SUBREG_PROMOTED_VAR_P (target) = 1;
2931           SUBREG_PROMOTED_UNSIGNED_P (target) = unsignedp;
2932         }
2933 #endif
2934
2935       /* If size of args is variable or this was a constructor call for a stack
2936          argument, restore saved stack-pointer value.  */
2937
2938       if (old_stack_level)
2939         {
2940           emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
2941           pending_stack_adjust = old_pending_adj;
2942 #ifdef ACCUMULATE_OUTGOING_ARGS
2943           stack_arg_under_construction = old_stack_arg_under_construction;
2944           highest_outgoing_arg_in_use = initial_highest_arg_in_use;
2945           stack_usage_map = initial_stack_usage_map;
2946 #endif
2947           sibcall_failure = 1;
2948         }
2949 #ifdef ACCUMULATE_OUTGOING_ARGS
2950       else
2951         {
2952 #ifdef REG_PARM_STACK_SPACE
2953           if (save_area)
2954             {
2955               restore_fixed_argument_area (save_area, argblock,
2956                                            high_to_save, low_to_save);
2957               sibcall_failure = 1;
2958             }
2959 #endif
2960
2961           /* If we saved any argument areas, restore them.  */
2962           for (i = 0; i < num_actuals; i++)
2963             if (args[i].save_area)
2964               {
2965                 enum machine_mode save_mode = GET_MODE (args[i].save_area);
2966                 rtx stack_area
2967                   = gen_rtx_MEM (save_mode,
2968                                  memory_address (save_mode,
2969                                                  XEXP (args[i].stack_slot, 0)));
2970
2971                 if (save_mode != BLKmode)
2972                   emit_move_insn (stack_area, args[i].save_area);
2973                 else
2974                   emit_block_move (stack_area,
2975                                    validize_mem (args[i].save_area),
2976                                    GEN_INT (args[i].size.constant),
2977                                    PARM_BOUNDARY / BITS_PER_UNIT);
2978                 sibcall_failure = 1;
2979               }
2980
2981           highest_outgoing_arg_in_use = initial_highest_arg_in_use;
2982           stack_usage_map = initial_stack_usage_map;
2983         }
2984 #endif
2985
2986       /* If this was alloca, record the new stack level for nonlocal gotos.
2987          Check for the handler slots since we might not have a save area
2988          for non-local gotos.  */
2989
2990       if (may_be_alloca && nonlocal_goto_handler_slots != 0)
2991         emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
2992
2993       pop_temp_slots ();
2994
2995       /* Free up storage we no longer need.  */
2996       for (i = 0; i < num_actuals; ++i)
2997         if (args[i].aligned_regs)
2998           free (args[i].aligned_regs);
2999
3000       if (pass == 0)
3001         {
3002           /* Undo the fake expand_start_target_temps we did earlier.  If
3003              there had been any cleanups created, we've already set
3004              sibcall_failure.  */
3005           expand_end_target_temps ();
3006         }
3007
3008       insns = get_insns ();
3009       end_sequence ();
3010
3011       if (pass == 0)
3012         {
3013           tail_call_insns = insns;
3014
3015           /* If something prevents making this a sibling call,
3016              zero out the sequence.  */
3017           if (sibcall_failure)
3018             tail_call_insns = NULL_RTX;
3019
3020           /* Restore the pending stack adjustment now that we have
3021              finished generating the sibling call sequence.  */
3022           pending_stack_adjust = save_pending_stack_adjust;
3023         }
3024       else
3025         normal_call_insns = insns;
3026     }
3027
3028   /* The function optimize_sibling_and_tail_recursive_calls doesn't
3029      handle CALL_PLACEHOLDERs inside other CALL_PLACEHOLDERs.  This
3030      can happen if the arguments to this function call an inline
3031      function who's expansion contains another CALL_PLACEHOLDER.
3032
3033      If there are any C_Ps in any of these sequences, replace them
3034      with their normal call. */
3035
3036   for (insn = normal_call_insns; insn; insn = NEXT_INSN (insn))
3037     if (GET_CODE (insn) == CALL_INSN
3038         && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
3039       replace_call_placeholder (insn, sibcall_use_normal);
3040
3041   for (insn = tail_call_insns; insn; insn = NEXT_INSN (insn))
3042     if (GET_CODE (insn) == CALL_INSN
3043         && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
3044       replace_call_placeholder (insn, sibcall_use_normal);
3045
3046   for (insn = tail_recursion_insns; insn; insn = NEXT_INSN (insn))
3047     if (GET_CODE (insn) == CALL_INSN
3048         && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
3049       replace_call_placeholder (insn, sibcall_use_normal);
3050
3051   /* If this was a potential tail recursion site, then emit a
3052      CALL_PLACEHOLDER with the normal and the tail recursion streams.
3053      One of them will be selected later.  */
3054   if (tail_recursion_insns || tail_call_insns)
3055     {
3056       /* The tail recursion label must be kept around.  We could expose
3057          its use in the CALL_PLACEHOLDER, but that creates unwanted edges
3058          and makes determining true tail recursion sites difficult.
3059
3060          So we set LABEL_PRESERVE_P here, then clear it when we select
3061          one of the call sequences after rtl generation is complete.  */
3062       if (tail_recursion_insns)
3063         LABEL_PRESERVE_P (tail_recursion_label) = 1;
3064       emit_call_insn (gen_rtx_CALL_PLACEHOLDER (VOIDmode, normal_call_insns,
3065                                                 tail_call_insns,
3066                                                 tail_recursion_insns,
3067                                                 tail_recursion_label));
3068     }
3069   else
3070     emit_insns (normal_call_insns);
3071
3072   currently_expanding_call--;
3073
3074   return target;
3075 }
3076 \f
3077 /* Returns nonzero if FUN is the symbol for a library function which can
3078    not throw.  */
3079
3080 static int
3081 libfunc_nothrow (fun)
3082      rtx fun;
3083 {
3084   if (fun == throw_libfunc
3085       || fun == rethrow_libfunc
3086       || fun == sjthrow_libfunc
3087       || fun == sjpopnthrow_libfunc)
3088     return 0;
3089
3090   return 1;
3091 }
3092 \f
3093 /* Output a library call to function FUN (a SYMBOL_REF rtx).
3094    The RETVAL parameter specifies whether return value needs to be saved, other
3095    parameters are documented in the emit_library_call function bellow.  */
3096 static rtx
3097 emit_library_call_value_1 (retval, orgfun, value, no_queue, outmode, nargs, p)
3098      int retval;
3099      rtx orgfun;
3100      rtx value;
3101      int no_queue;
3102      enum machine_mode outmode;
3103      int nargs;
3104      va_list p;
3105 {
3106   /* Total size in bytes of all the stack-parms scanned so far.  */
3107   struct args_size args_size;
3108   /* Size of arguments before any adjustments (such as rounding).  */
3109   struct args_size original_args_size;
3110   register int argnum;
3111   rtx fun;
3112   int inc;
3113   int count;
3114   struct args_size alignment_pad;
3115   rtx argblock = 0;
3116   CUMULATIVE_ARGS args_so_far;
3117   struct arg { rtx value; enum machine_mode mode; rtx reg; int partial;
3118                struct args_size offset; struct args_size size; rtx save_area; };
3119   struct arg *argvec;
3120   int old_inhibit_defer_pop = inhibit_defer_pop;
3121   rtx call_fusage = 0;
3122   rtx mem_value = 0;
3123   int pcc_struct_value = 0;
3124   int struct_value_size = 0;
3125   int is_const;
3126   int reg_parm_stack_space = 0;
3127   int nothrow;
3128 #ifdef ACCUMULATE_OUTGOING_ARGS
3129   int needed;
3130 #endif
3131
3132 #if defined(ACCUMULATE_OUTGOING_ARGS) && defined(REG_PARM_STACK_SPACE)
3133   /* Define the boundary of the register parm stack space that needs to be
3134      save, if any.  */
3135   int low_to_save = -1, high_to_save = 0;
3136   rtx save_area = 0;            /* Place that it is saved */
3137 #endif
3138
3139 #ifdef ACCUMULATE_OUTGOING_ARGS
3140   /* Size of the stack reserved for parameter registers.  */
3141   int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
3142   char *initial_stack_usage_map = stack_usage_map;
3143 #endif
3144
3145 #ifdef REG_PARM_STACK_SPACE
3146 #ifdef MAYBE_REG_PARM_STACK_SPACE
3147   reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
3148 #else
3149   reg_parm_stack_space = REG_PARM_STACK_SPACE ((tree) 0);
3150 #endif
3151 #endif
3152
3153   is_const = no_queue;
3154   fun = orgfun;
3155
3156   nothrow = libfunc_nothrow (fun);
3157
3158 #ifdef PREFERRED_STACK_BOUNDARY
3159   /* Ensure current function's preferred stack boundary is at least
3160      what we need.  */
3161   if (cfun->preferred_stack_boundary < PREFERRED_STACK_BOUNDARY)
3162     cfun->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
3163 #endif
3164
3165   /* If this kind of value comes back in memory,
3166      decide where in memory it should come back.  */
3167   if (outmode != VOIDmode && aggregate_value_p (type_for_mode (outmode, 0)))
3168     {
3169 #ifdef PCC_STATIC_STRUCT_RETURN
3170       rtx pointer_reg
3171         = hard_function_value (build_pointer_type (type_for_mode (outmode, 0)),
3172                                0, 0);
3173       mem_value = gen_rtx_MEM (outmode, pointer_reg);
3174       pcc_struct_value = 1;
3175       if (value == 0)
3176         value = gen_reg_rtx (outmode);
3177 #else /* not PCC_STATIC_STRUCT_RETURN */
3178       struct_value_size = GET_MODE_SIZE (outmode);
3179       if (value != 0 && GET_CODE (value) == MEM)
3180         mem_value = value;
3181       else
3182         mem_value = assign_stack_temp (outmode, GET_MODE_SIZE (outmode), 0);
3183 #endif
3184
3185       /* This call returns a big structure.  */
3186       is_const = 0;
3187     }
3188
3189   /* ??? Unfinished: must pass the memory address as an argument.  */
3190
3191   /* Copy all the libcall-arguments out of the varargs data
3192      and into a vector ARGVEC.
3193
3194      Compute how to pass each argument.  We only support a very small subset
3195      of the full argument passing conventions to limit complexity here since
3196      library functions shouldn't have many args.  */
3197
3198   argvec = (struct arg *) alloca ((nargs + 1) * sizeof (struct arg));
3199   bzero ((char *) argvec, (nargs + 1) * sizeof (struct arg));
3200
3201   INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE, fun, 0);
3202
3203   args_size.constant = 0;
3204   args_size.var = 0;
3205
3206   count = 0;
3207
3208   push_temp_slots ();
3209
3210   /* If there's a structure value address to be passed,
3211      either pass it in the special place, or pass it as an extra argument.  */
3212   if (mem_value && struct_value_rtx == 0 && ! pcc_struct_value)
3213     {
3214       rtx addr = XEXP (mem_value, 0);
3215       nargs++;
3216
3217       /* Make sure it is a reasonable operand for a move or push insn.  */
3218       if (GET_CODE (addr) != REG && GET_CODE (addr) != MEM
3219           && ! (CONSTANT_P (addr) && LEGITIMATE_CONSTANT_P (addr)))
3220         addr = force_operand (addr, NULL_RTX);
3221
3222       argvec[count].value = addr;
3223       argvec[count].mode = Pmode;
3224       argvec[count].partial = 0;
3225
3226       argvec[count].reg = FUNCTION_ARG (args_so_far, Pmode, NULL_TREE, 1);
3227 #ifdef FUNCTION_ARG_PARTIAL_NREGS
3228       if (FUNCTION_ARG_PARTIAL_NREGS (args_so_far, Pmode, NULL_TREE, 1))
3229         abort ();
3230 #endif
3231
3232       locate_and_pad_parm (Pmode, NULL_TREE,
3233                            argvec[count].reg && argvec[count].partial == 0,
3234                            NULL_TREE, &args_size, &argvec[count].offset,
3235                            &argvec[count].size, &alignment_pad);
3236
3237
3238       if (argvec[count].reg == 0 || argvec[count].partial != 0
3239           || reg_parm_stack_space > 0)
3240         args_size.constant += argvec[count].size.constant;
3241
3242       FUNCTION_ARG_ADVANCE (args_so_far, Pmode, (tree) 0, 1);
3243
3244       count++;
3245     }
3246
3247   for (; count < nargs; count++)
3248     {
3249       rtx val = va_arg (p, rtx);
3250       enum machine_mode mode = va_arg (p, enum machine_mode);
3251
3252       /* We cannot convert the arg value to the mode the library wants here;
3253          must do it earlier where we know the signedness of the arg.  */
3254       if (mode == BLKmode
3255           || (GET_MODE (val) != mode && GET_MODE (val) != VOIDmode))
3256         abort ();
3257
3258       /* On some machines, there's no way to pass a float to a library fcn.
3259          Pass it as a double instead.  */
3260 #ifdef LIBGCC_NEEDS_DOUBLE
3261       if (LIBGCC_NEEDS_DOUBLE && mode == SFmode)
3262         val = convert_modes (DFmode, SFmode, val, 0), mode = DFmode;
3263 #endif
3264
3265       /* There's no need to call protect_from_queue, because
3266          either emit_move_insn or emit_push_insn will do that.  */
3267
3268       /* Make sure it is a reasonable operand for a move or push insn.  */
3269       if (GET_CODE (val) != REG && GET_CODE (val) != MEM
3270           && ! (CONSTANT_P (val) && LEGITIMATE_CONSTANT_P (val)))
3271         val = force_operand (val, NULL_RTX);
3272
3273 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
3274       if (FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, mode, NULL_TREE, 1))
3275         {
3276           /* We do not support FUNCTION_ARG_CALLEE_COPIES here since it can
3277              be viewed as just an efficiency improvement.  */
3278           rtx slot = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0);
3279           emit_move_insn (slot, val);
3280           val = force_operand (XEXP (slot, 0), NULL_RTX);
3281           mode = Pmode;
3282         }
3283 #endif
3284
3285       argvec[count].value = val;
3286       argvec[count].mode = mode;
3287
3288       argvec[count].reg = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1);
3289
3290 #ifdef FUNCTION_ARG_PARTIAL_NREGS
3291       argvec[count].partial
3292         = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, NULL_TREE, 1);
3293 #else
3294       argvec[count].partial = 0;
3295 #endif
3296
3297       locate_and_pad_parm (mode, NULL_TREE,
3298                            argvec[count].reg && argvec[count].partial == 0,
3299                            NULL_TREE, &args_size, &argvec[count].offset,
3300                            &argvec[count].size, &alignment_pad);
3301
3302       if (argvec[count].size.var)
3303         abort ();
3304
3305       if (reg_parm_stack_space == 0 && argvec[count].partial)
3306         argvec[count].size.constant -= argvec[count].partial * UNITS_PER_WORD;
3307
3308       if (argvec[count].reg == 0 || argvec[count].partial != 0
3309           || reg_parm_stack_space > 0)
3310         args_size.constant += argvec[count].size.constant;
3311
3312       FUNCTION_ARG_ADVANCE (args_so_far, mode, (tree) 0, 1);
3313     }
3314
3315 #ifdef FINAL_REG_PARM_STACK_SPACE
3316   reg_parm_stack_space = FINAL_REG_PARM_STACK_SPACE (args_size.constant,
3317                                                      args_size.var);
3318 #endif
3319   /* If this machine requires an external definition for library
3320      functions, write one out.  */
3321   assemble_external_libcall (fun);
3322
3323   original_args_size = args_size;
3324 #ifdef PREFERRED_STACK_BOUNDARY
3325   args_size.constant = (((args_size.constant + (STACK_BYTES - 1))
3326                          / STACK_BYTES) * STACK_BYTES);
3327 #endif
3328
3329   args_size.constant = MAX (args_size.constant,
3330                             reg_parm_stack_space);
3331
3332 #ifndef OUTGOING_REG_PARM_STACK_SPACE
3333   args_size.constant -= reg_parm_stack_space;
3334 #endif
3335
3336   if (args_size.constant > current_function_outgoing_args_size)
3337     current_function_outgoing_args_size = args_size.constant;
3338
3339 #ifdef ACCUMULATE_OUTGOING_ARGS
3340   /* Since the stack pointer will never be pushed, it is possible for
3341      the evaluation of a parm to clobber something we have already
3342      written to the stack.  Since most function calls on RISC machines
3343      do not use the stack, this is uncommon, but must work correctly.
3344
3345      Therefore, we save any area of the stack that was already written
3346      and that we are using.  Here we set up to do this by making a new
3347      stack usage map from the old one.
3348
3349      Another approach might be to try to reorder the argument
3350      evaluations to avoid this conflicting stack usage.  */
3351
3352   needed = args_size.constant;
3353
3354 #ifndef OUTGOING_REG_PARM_STACK_SPACE
3355   /* Since we will be writing into the entire argument area, the
3356      map must be allocated for its entire size, not just the part that
3357      is the responsibility of the caller.  */
3358   needed += reg_parm_stack_space;
3359 #endif
3360
3361 #ifdef ARGS_GROW_DOWNWARD
3362   highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
3363                                      needed + 1);
3364 #else
3365   highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
3366                                      needed);
3367 #endif
3368   stack_usage_map = (char *) alloca (highest_outgoing_arg_in_use);
3369
3370   if (initial_highest_arg_in_use)
3371     bcopy (initial_stack_usage_map, stack_usage_map,
3372            initial_highest_arg_in_use);
3373
3374   if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
3375     bzero (&stack_usage_map[initial_highest_arg_in_use],
3376            highest_outgoing_arg_in_use - initial_highest_arg_in_use);
3377   needed = 0;
3378
3379   /* The address of the outgoing argument list must not be copied to a
3380      register here, because argblock would be left pointing to the
3381      wrong place after the call to allocate_dynamic_stack_space below.
3382      */
3383
3384   argblock = virtual_outgoing_args_rtx;
3385 #else /* not ACCUMULATE_OUTGOING_ARGS */
3386 #ifndef PUSH_ROUNDING
3387   argblock = push_block (GEN_INT (args_size.constant), 0, 0);
3388 #endif
3389 #endif
3390
3391 #ifdef PUSH_ARGS_REVERSED
3392 #ifdef PREFERRED_STACK_BOUNDARY
3393   /* If we push args individually in reverse order, perform stack alignment
3394      before the first push (the last arg).  */
3395   if (argblock == 0)
3396     anti_adjust_stack (GEN_INT (args_size.constant
3397                                 - original_args_size.constant));
3398 #endif
3399 #endif
3400
3401 #ifdef PUSH_ARGS_REVERSED
3402   inc = -1;
3403   argnum = nargs - 1;
3404 #else
3405   inc = 1;
3406   argnum = 0;
3407 #endif
3408
3409 #if defined(ACCUMULATE_OUTGOING_ARGS) && defined(REG_PARM_STACK_SPACE)
3410   /* The argument list is the property of the called routine and it
3411      may clobber it.  If the fixed area has been used for previous
3412      parameters, we must save and restore it.
3413
3414      Here we compute the boundary of the that needs to be saved, if any.  */
3415
3416 #ifdef ARGS_GROW_DOWNWARD
3417   for (count = 0; count < reg_parm_stack_space + 1; count++)
3418 #else
3419   for (count = 0; count < reg_parm_stack_space; count++)
3420 #endif
3421     {
3422       if (count >=  highest_outgoing_arg_in_use
3423           || stack_usage_map[count] == 0)
3424         continue;
3425
3426       if (low_to_save == -1)
3427         low_to_save = count;
3428
3429       high_to_save = count;
3430     }
3431
3432   if (low_to_save >= 0)
3433     {
3434       int num_to_save = high_to_save - low_to_save + 1;
3435       enum machine_mode save_mode
3436         = mode_for_size (num_to_save * BITS_PER_UNIT, MODE_INT, 1);
3437       rtx stack_area;
3438
3439       /* If we don't have the required alignment, must do this in BLKmode.  */
3440       if ((low_to_save & (MIN (GET_MODE_SIZE (save_mode),
3441                                BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1)))
3442         save_mode = BLKmode;
3443
3444 #ifdef ARGS_GROW_DOWNWARD
3445       stack_area = gen_rtx_MEM (save_mode,
3446                                 memory_address (save_mode,
3447                                                 plus_constant (argblock,
3448                                                                - high_to_save)));
3449 #else
3450       stack_area = gen_rtx_MEM (save_mode,
3451                                 memory_address (save_mode,
3452                                                 plus_constant (argblock,
3453                                                                low_to_save)));
3454 #endif
3455       if (save_mode == BLKmode)
3456         {
3457           save_area = assign_stack_temp (BLKmode, num_to_save, 0);
3458           emit_block_move (validize_mem (save_area), stack_area,
3459                            GEN_INT (num_to_save),
3460                            PARM_BOUNDARY / BITS_PER_UNIT);
3461         }
3462       else
3463         {
3464           save_area = gen_reg_rtx (save_mode);
3465           emit_move_insn (save_area, stack_area);
3466         }
3467     }
3468 #endif
3469
3470   /* Push the args that need to be pushed.  */
3471
3472   /* ARGNUM indexes the ARGVEC array in the order in which the arguments
3473      are to be pushed.  */
3474   for (count = 0; count < nargs; count++, argnum += inc)
3475     {
3476       register enum machine_mode mode = argvec[argnum].mode;
3477       register rtx val = argvec[argnum].value;
3478       rtx reg = argvec[argnum].reg;
3479       int partial = argvec[argnum].partial;
3480 #ifdef ACCUMULATE_OUTGOING_ARGS
3481       int lower_bound, upper_bound, i;
3482 #endif
3483
3484       if (! (reg != 0 && partial == 0))
3485         {
3486 #ifdef ACCUMULATE_OUTGOING_ARGS
3487           /* If this is being stored into a pre-allocated, fixed-size, stack
3488              area, save any previous data at that location.  */
3489
3490 #ifdef ARGS_GROW_DOWNWARD
3491           /* stack_slot is negative, but we want to index stack_usage_map
3492              with positive values.  */
3493           upper_bound = -argvec[argnum].offset.constant + 1;
3494           lower_bound = upper_bound - argvec[argnum].size.constant;
3495 #else
3496           lower_bound = argvec[argnum].offset.constant;
3497           upper_bound = lower_bound + argvec[argnum].size.constant;
3498 #endif
3499
3500           for (i = lower_bound; i < upper_bound; i++)
3501             if (stack_usage_map[i]
3502                 /* Don't store things in the fixed argument area at this point;
3503                    it has already been saved.  */
3504                 && i > reg_parm_stack_space)
3505               break;
3506
3507           if (i != upper_bound)
3508             {
3509               /* We need to make a save area.  See what mode we can make it. */
3510               enum machine_mode save_mode
3511                 = mode_for_size (argvec[argnum].size.constant * BITS_PER_UNIT,
3512                                  MODE_INT, 1);
3513               rtx stack_area
3514                 = gen_rtx_MEM
3515                   (save_mode,
3516                    memory_address
3517                    (save_mode,
3518                     plus_constant (argblock,
3519                                    argvec[argnum].offset.constant)));
3520               argvec[argnum].save_area = gen_reg_rtx (save_mode);
3521
3522               emit_move_insn (argvec[argnum].save_area, stack_area);
3523             }
3524 #endif
3525           emit_push_insn (val, mode, NULL_TREE, NULL_RTX, 0, partial, reg, 0,
3526                           argblock, GEN_INT (argvec[argnum].offset.constant),
3527                           reg_parm_stack_space, ARGS_SIZE_RTX (alignment_pad));
3528
3529 #ifdef ACCUMULATE_OUTGOING_ARGS
3530           /* Now mark the segment we just used.  */
3531           for (i = lower_bound; i < upper_bound; i++)
3532             stack_usage_map[i] = 1;
3533 #endif
3534
3535           NO_DEFER_POP;
3536         }
3537     }
3538
3539 #ifndef PUSH_ARGS_REVERSED
3540 #ifdef PREFERRED_STACK_BOUNDARY
3541   /* If we pushed args in forward order, perform stack alignment
3542      after pushing the last arg.  */
3543   if (argblock == 0)
3544     anti_adjust_stack (GEN_INT (args_size.constant
3545                                 - original_args_size.constant));
3546 #endif
3547 #endif
3548
3549 #ifdef PUSH_ARGS_REVERSED
3550   argnum = nargs - 1;
3551 #else
3552   argnum = 0;
3553 #endif
3554
3555   fun = prepare_call_address (fun, NULL_TREE, &call_fusage, 0);
3556
3557   /* Now load any reg parms into their regs.  */
3558
3559   /* ARGNUM indexes the ARGVEC array in the order in which the arguments
3560      are to be pushed.  */
3561   for (count = 0; count < nargs; count++, argnum += inc)
3562     {
3563       register rtx val = argvec[argnum].value;
3564       rtx reg = argvec[argnum].reg;
3565       int partial = argvec[argnum].partial;
3566
3567       /* Handle calls that pass values in multiple non-contiguous
3568          locations.  The PA64 has examples of this for library calls.  */
3569       if (reg != 0 && GET_CODE (reg) == PARALLEL)
3570         emit_group_load (reg, val,
3571                          GET_MODE_SIZE (GET_MODE (val)),
3572                          GET_MODE_ALIGNMENT (GET_MODE (val)));
3573       else if (reg != 0 && partial == 0)
3574         emit_move_insn (reg, val);
3575
3576       NO_DEFER_POP;
3577     }
3578
3579 #if 0
3580   /* For version 1.37, try deleting this entirely.  */
3581   if (! no_queue)
3582     emit_queue ();
3583 #endif
3584
3585   /* Any regs containing parms remain in use through the call.  */
3586   for (count = 0; count < nargs; count++)
3587     {
3588       rtx reg = argvec[count].reg;
3589       if (reg != 0 && GET_CODE (reg) == PARALLEL)
3590         use_group_regs (&call_fusage, reg);
3591       else if (reg != 0)
3592         use_reg (&call_fusage, reg);
3593     }
3594
3595   /* Pass the function the address in which to return a structure value.  */
3596   if (mem_value != 0 && struct_value_rtx != 0 && ! pcc_struct_value)
3597     {
3598       emit_move_insn (struct_value_rtx,
3599                       force_reg (Pmode,
3600                                  force_operand (XEXP (mem_value, 0),
3601                                                 NULL_RTX)));
3602       if (GET_CODE (struct_value_rtx) == REG)
3603           use_reg (&call_fusage, struct_value_rtx);
3604     }
3605
3606   /* Don't allow popping to be deferred, since then
3607      cse'ing of library calls could delete a call and leave the pop.  */
3608   NO_DEFER_POP;
3609
3610   /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
3611      will set inhibit_defer_pop to that value.  */
3612   /* The return type is needed to decide how many bytes the function pops.
3613      Signedness plays no role in that, so for simplicity, we pretend it's
3614      always signed.  We also assume that the list of arguments passed has
3615      no impact, so we pretend it is unknown.  */
3616
3617   emit_call_1 (fun,
3618                get_identifier (XSTR (orgfun, 0)),
3619                build_function_type (outmode == VOIDmode ? void_type_node
3620                                     : type_for_mode (outmode, 0), NULL_TREE),
3621                original_args_size.constant, args_size.constant,
3622                struct_value_size,
3623                FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
3624                mem_value == 0 && outmode != VOIDmode ? hard_libcall_value (outmode) : NULL_RTX,
3625                old_inhibit_defer_pop + 1, call_fusage,
3626                ((is_const ? ECF_IS_CONST : 0)
3627                 | (nothrow ? ECF_NOTHROW : 0)));
3628
3629   /* Now restore inhibit_defer_pop to its actual original value.  */
3630   OK_DEFER_POP;
3631
3632   pop_temp_slots ();
3633
3634   /* Copy the value to the right place.  */
3635   if (outmode != VOIDmode && retval)
3636     {
3637       if (mem_value)
3638         {
3639           if (value == 0)
3640             value = mem_value;
3641           if (value != mem_value)
3642             emit_move_insn (value, mem_value);
3643         }
3644       else if (value != 0)
3645         emit_move_insn (value, hard_libcall_value (outmode));
3646       else
3647         value = hard_libcall_value (outmode);
3648     }
3649
3650 #ifdef ACCUMULATE_OUTGOING_ARGS
3651 #ifdef REG_PARM_STACK_SPACE
3652   if (save_area)
3653     {
3654       enum machine_mode save_mode = GET_MODE (save_area);
3655 #ifdef ARGS_GROW_DOWNWARD
3656       rtx stack_area
3657         = gen_rtx_MEM (save_mode,
3658                        memory_address (save_mode,
3659                                        plus_constant (argblock,
3660                                                       - high_to_save)));
3661 #else
3662       rtx stack_area
3663         = gen_rtx_MEM (save_mode,
3664                        memory_address (save_mode,
3665                                        plus_constant (argblock, low_to_save)));
3666 #endif
3667       if (save_mode != BLKmode)
3668         emit_move_insn (stack_area, save_area);
3669       else
3670         emit_block_move (stack_area, validize_mem (save_area),
3671                          GEN_INT (high_to_save - low_to_save + 1),
3672                              PARM_BOUNDARY / BITS_PER_UNIT);
3673     }
3674 #endif
3675
3676   /* If we saved any argument areas, restore them.  */
3677   for (count = 0; count < nargs; count++)
3678     if (argvec[count].save_area)
3679       {
3680         enum machine_mode save_mode = GET_MODE (argvec[count].save_area);
3681         rtx stack_area
3682           = gen_rtx_MEM (save_mode,
3683                          memory_address
3684                          (save_mode,
3685                           plus_constant (argblock,
3686                                          argvec[count].offset.constant)));
3687
3688         emit_move_insn (stack_area, argvec[count].save_area);
3689       }
3690
3691   highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3692   stack_usage_map = initial_stack_usage_map;
3693 #endif
3694
3695   return value;
3696
3697 }
3698 \f
3699 /* Output a library call to function FUN (a SYMBOL_REF rtx)
3700    (emitting the queue unless NO_QUEUE is nonzero),
3701    for a value of mode OUTMODE,
3702    with NARGS different arguments, passed as alternating rtx values
3703    and machine_modes to convert them to.
3704    The rtx values should have been passed through protect_from_queue already.
3705
3706    NO_QUEUE will be true if and only if the library call is a `const' call
3707    which will be enclosed in REG_LIBCALL/REG_RETVAL notes; it is equivalent
3708    to the variable is_const in expand_call.
3709
3710    NO_QUEUE must be true for const calls, because if it isn't, then
3711    any pending increment will be emitted between REG_LIBCALL/REG_RETVAL notes,
3712    and will be lost if the libcall sequence is optimized away.
3713
3714    NO_QUEUE must be false for non-const calls, because if it isn't, the
3715    call insn will have its CONST_CALL_P bit set, and it will be incorrectly
3716    optimized.  For instance, the instruction scheduler may incorrectly
3717    move memory references across the non-const call.  */
3718
3719 void
3720 emit_library_call VPARAMS((rtx orgfun, int no_queue, enum machine_mode outmode,
3721                            int nargs, ...))
3722 {
3723 #ifndef ANSI_PROTOTYPES
3724   rtx orgfun;
3725   int no_queue;
3726   enum machine_mode outmode;
3727   int nargs;
3728 #endif
3729   va_list p;
3730
3731   VA_START (p, nargs);
3732
3733 #ifndef ANSI_PROTOTYPES
3734   orgfun = va_arg (p, rtx);
3735   no_queue = va_arg (p, int);
3736   outmode = va_arg (p, enum machine_mode);
3737   nargs = va_arg (p, int);
3738 #endif
3739
3740   emit_library_call_value_1 (0, orgfun, NULL_RTX, no_queue, outmode, nargs, p);
3741
3742   va_end (p);
3743 }
3744 \f
3745 /* Like emit_library_call except that an extra argument, VALUE,
3746    comes second and says where to store the result.
3747    (If VALUE is zero, this function chooses a convenient way
3748    to return the value.
3749
3750    This function returns an rtx for where the value is to be found.
3751    If VALUE is nonzero, VALUE is returned.  */
3752
3753 rtx
3754 emit_library_call_value VPARAMS((rtx orgfun, rtx value, int no_queue,
3755                                  enum machine_mode outmode, int nargs, ...))
3756 {
3757 #ifndef ANSI_PROTOTYPES
3758   rtx orgfun;
3759   rtx value;
3760   int no_queue;
3761   enum machine_mode outmode;
3762   int nargs;
3763 #endif
3764   va_list p;
3765
3766   VA_START (p, nargs);
3767
3768 #ifndef ANSI_PROTOTYPES
3769   orgfun = va_arg (p, rtx);
3770   value = va_arg (p, rtx);
3771   no_queue = va_arg (p, int);
3772   outmode = va_arg (p, enum machine_mode);
3773   nargs = va_arg (p, int);
3774 #endif
3775
3776   value = emit_library_call_value_1 (1, orgfun, value, no_queue, outmode, nargs, p);
3777
3778   va_end (p);
3779
3780   return value;
3781 }
3782 \f
3783 #if 0
3784 /* Return an rtx which represents a suitable home on the stack
3785    given TYPE, the type of the argument looking for a home.
3786    This is called only for BLKmode arguments.
3787
3788    SIZE is the size needed for this target.
3789    ARGS_ADDR is the address of the bottom of the argument block for this call.
3790    OFFSET describes this parameter's offset into ARGS_ADDR.  It is meaningless
3791    if this machine uses push insns.  */
3792
3793 static rtx
3794 target_for_arg (type, size, args_addr, offset)
3795      tree type;
3796      rtx size;
3797      rtx args_addr;
3798      struct args_size offset;
3799 {
3800   rtx target;
3801   rtx offset_rtx = ARGS_SIZE_RTX (offset);
3802
3803   /* We do not call memory_address if possible,
3804      because we want to address as close to the stack
3805      as possible.  For non-variable sized arguments,
3806      this will be stack-pointer relative addressing.  */
3807   if (GET_CODE (offset_rtx) == CONST_INT)
3808     target = plus_constant (args_addr, INTVAL (offset_rtx));
3809   else
3810     {
3811       /* I have no idea how to guarantee that this
3812          will work in the presence of register parameters.  */
3813       target = gen_rtx_PLUS (Pmode, args_addr, offset_rtx);
3814       target = memory_address (QImode, target);
3815     }
3816
3817   return gen_rtx_MEM (BLKmode, target);
3818 }
3819 #endif
3820 \f
3821 /* Store a single argument for a function call
3822    into the register or memory area where it must be passed.
3823    *ARG describes the argument value and where to pass it.
3824
3825    ARGBLOCK is the address of the stack-block for all the arguments,
3826    or 0 on a machine where arguments are pushed individually.
3827
3828    MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
3829    so must be careful about how the stack is used.
3830
3831    VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
3832    argument stack.  This is used if ACCUMULATE_OUTGOING_ARGS to indicate
3833    that we need not worry about saving and restoring the stack.
3834
3835    FNDECL is the declaration of the function we are calling.  */
3836
3837 static void
3838 store_one_arg (arg, argblock, may_be_alloca, variable_size,
3839                reg_parm_stack_space)
3840      struct arg_data *arg;
3841      rtx argblock;
3842      int may_be_alloca;
3843      int variable_size ATTRIBUTE_UNUSED;
3844      int reg_parm_stack_space;
3845 {
3846   register tree pval = arg->tree_value;
3847   rtx reg = 0;
3848   int partial = 0;
3849   int used = 0;
3850 #ifdef ACCUMULATE_OUTGOING_ARGS
3851   int i, lower_bound = 0, upper_bound = 0;
3852 #endif
3853
3854   if (TREE_CODE (pval) == ERROR_MARK)
3855     return;
3856
3857   /* Push a new temporary level for any temporaries we make for
3858      this argument.  */
3859   push_temp_slots ();
3860
3861 #ifdef ACCUMULATE_OUTGOING_ARGS
3862   /* If this is being stored into a pre-allocated, fixed-size, stack area,
3863      save any previous data at that location.  */
3864   if (argblock && ! variable_size && arg->stack)
3865     {
3866 #ifdef ARGS_GROW_DOWNWARD
3867       /* stack_slot is negative, but we want to index stack_usage_map
3868          with positive values.  */
3869       if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
3870         upper_bound = -INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1)) + 1;
3871       else
3872         upper_bound = 0;
3873
3874       lower_bound = upper_bound - arg->size.constant;
3875 #else
3876       if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
3877         lower_bound = INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1));
3878       else
3879         lower_bound = 0;
3880
3881       upper_bound = lower_bound + arg->size.constant;
3882 #endif
3883
3884       for (i = lower_bound; i < upper_bound; i++)
3885         if (stack_usage_map[i]
3886             /* Don't store things in the fixed argument area at this point;
3887                it has already been saved.  */
3888             && i > reg_parm_stack_space)
3889           break;
3890
3891       if (i != upper_bound)
3892         {
3893           /* We need to make a save area.  See what mode we can make it.  */
3894           enum machine_mode save_mode
3895             = mode_for_size (arg->size.constant * BITS_PER_UNIT, MODE_INT, 1);
3896           rtx stack_area
3897             = gen_rtx_MEM (save_mode,
3898                            memory_address (save_mode,
3899                                            XEXP (arg->stack_slot, 0)));
3900
3901           if (save_mode == BLKmode)
3902             {
3903               arg->save_area = assign_stack_temp (BLKmode,
3904                                                   arg->size.constant, 0);
3905               MEM_SET_IN_STRUCT_P (arg->save_area,
3906                                    AGGREGATE_TYPE_P (TREE_TYPE
3907                                                      (arg->tree_value)));
3908               preserve_temp_slots (arg->save_area);
3909               emit_block_move (validize_mem (arg->save_area), stack_area,
3910                                GEN_INT (arg->size.constant),
3911                                PARM_BOUNDARY / BITS_PER_UNIT);
3912             }
3913           else
3914             {
3915               arg->save_area = gen_reg_rtx (save_mode);
3916               emit_move_insn (arg->save_area, stack_area);
3917             }
3918         }
3919     }
3920
3921   /* Now that we have saved any slots that will be overwritten by this
3922      store, mark all slots this store will use.  We must do this before
3923      we actually expand the argument since the expansion itself may
3924      trigger library calls which might need to use the same stack slot.  */
3925   if (argblock && ! variable_size && arg->stack)
3926     for (i = lower_bound; i < upper_bound; i++)
3927       stack_usage_map[i] = 1;
3928 #endif
3929
3930   /* If this isn't going to be placed on both the stack and in registers,
3931      set up the register and number of words.  */
3932   if (! arg->pass_on_stack)
3933     reg = arg->reg, partial = arg->partial;
3934
3935   if (reg != 0 && partial == 0)
3936     /* Being passed entirely in a register.  We shouldn't be called in
3937        this case.   */
3938     abort ();
3939
3940   /* If this arg needs special alignment, don't load the registers
3941      here.  */
3942   if (arg->n_aligned_regs != 0)
3943     reg = 0;
3944
3945   /* If this is being passed partially in a register, we can't evaluate
3946      it directly into its stack slot.  Otherwise, we can.  */
3947   if (arg->value == 0)
3948     {
3949 #ifdef ACCUMULATE_OUTGOING_ARGS
3950       /* stack_arg_under_construction is nonzero if a function argument is
3951          being evaluated directly into the outgoing argument list and
3952          expand_call must take special action to preserve the argument list
3953          if it is called recursively.
3954
3955          For scalar function arguments stack_usage_map is sufficient to
3956          determine which stack slots must be saved and restored.  Scalar
3957          arguments in general have pass_on_stack == 0.
3958
3959          If this argument is initialized by a function which takes the
3960          address of the argument (a C++ constructor or a C function
3961          returning a BLKmode structure), then stack_usage_map is
3962          insufficient and expand_call must push the stack around the
3963          function call.  Such arguments have pass_on_stack == 1.
3964
3965          Note that it is always safe to set stack_arg_under_construction,
3966          but this generates suboptimal code if set when not needed.  */
3967
3968       if (arg->pass_on_stack)
3969         stack_arg_under_construction++;
3970 #endif
3971       arg->value = expand_expr (pval,
3972                                 (partial
3973                                  || TYPE_MODE (TREE_TYPE (pval)) != arg->mode)
3974                                 ? NULL_RTX : arg->stack,
3975                                 VOIDmode, 0);
3976
3977       /* If we are promoting object (or for any other reason) the mode
3978          doesn't agree, convert the mode.  */
3979
3980       if (arg->mode != TYPE_MODE (TREE_TYPE (pval)))
3981         arg->value = convert_modes (arg->mode, TYPE_MODE (TREE_TYPE (pval)),
3982                                     arg->value, arg->unsignedp);
3983
3984 #ifdef ACCUMULATE_OUTGOING_ARGS
3985       if (arg->pass_on_stack)
3986         stack_arg_under_construction--;
3987 #endif
3988     }
3989
3990   /* Don't allow anything left on stack from computation
3991      of argument to alloca.  */
3992   if (may_be_alloca)
3993     do_pending_stack_adjust ();
3994
3995   if (arg->value == arg->stack)
3996     {
3997       /* If the value is already in the stack slot, we are done.  */
3998       if (current_function_check_memory_usage && GET_CODE (arg->stack) == MEM)
3999         {
4000           emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
4001                              XEXP (arg->stack, 0), Pmode,
4002                              ARGS_SIZE_RTX (arg->size),
4003                              TYPE_MODE (sizetype),
4004                              GEN_INT (MEMORY_USE_RW),
4005                              TYPE_MODE (integer_type_node));
4006         }
4007     }
4008   else if (arg->mode != BLKmode)
4009     {
4010       register int size;
4011
4012       /* Argument is a scalar, not entirely passed in registers.
4013          (If part is passed in registers, arg->partial says how much
4014          and emit_push_insn will take care of putting it there.)
4015
4016          Push it, and if its size is less than the
4017          amount of space allocated to it,
4018          also bump stack pointer by the additional space.
4019          Note that in C the default argument promotions
4020          will prevent such mismatches.  */
4021
4022       size = GET_MODE_SIZE (arg->mode);
4023       /* Compute how much space the push instruction will push.
4024          On many machines, pushing a byte will advance the stack
4025          pointer by a halfword.  */
4026 #ifdef PUSH_ROUNDING
4027       size = PUSH_ROUNDING (size);
4028 #endif
4029       used = size;
4030
4031       /* Compute how much space the argument should get:
4032          round up to a multiple of the alignment for arguments.  */
4033       if (none != FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)))
4034         used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1)
4035                  / (PARM_BOUNDARY / BITS_PER_UNIT))
4036                 * (PARM_BOUNDARY / BITS_PER_UNIT));
4037
4038       /* This isn't already where we want it on the stack, so put it there.
4039          This can either be done with push or copy insns.  */
4040       emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX, 0,
4041                       partial, reg, used - size, argblock,
4042                       ARGS_SIZE_RTX (arg->offset), reg_parm_stack_space,
4043                       ARGS_SIZE_RTX (arg->alignment_pad));
4044
4045       arg_space_so_far += used;
4046     }
4047   else
4048     {
4049       /* BLKmode, at least partly to be pushed.  */
4050
4051       register int excess;
4052       rtx size_rtx;
4053
4054       /* Pushing a nonscalar.
4055          If part is passed in registers, PARTIAL says how much
4056          and emit_push_insn will take care of putting it there.  */
4057
4058       /* Round its size up to a multiple
4059          of the allocation unit for arguments.  */
4060
4061       if (arg->size.var != 0)
4062         {
4063           excess = 0;
4064           size_rtx = ARGS_SIZE_RTX (arg->size);
4065         }
4066       else
4067         {
4068           /* PUSH_ROUNDING has no effect on us, because
4069              emit_push_insn for BLKmode is careful to avoid it.  */
4070           excess = (arg->size.constant - int_size_in_bytes (TREE_TYPE (pval))
4071                     + partial * UNITS_PER_WORD);
4072           size_rtx = expr_size (pval);
4073           arg_space_so_far += excess + INTVAL (size_rtx);
4074         }
4075
4076       emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
4077                       TYPE_ALIGN (TREE_TYPE (pval)) / BITS_PER_UNIT, partial,
4078                       reg, excess, argblock, ARGS_SIZE_RTX (arg->offset),
4079                       reg_parm_stack_space,
4080                       ARGS_SIZE_RTX (arg->alignment_pad));
4081     }
4082
4083
4084   /* Unless this is a partially-in-register argument, the argument is now
4085      in the stack.
4086
4087      ??? Note that this can change arg->value from arg->stack to
4088      arg->stack_slot and it matters when they are not the same.
4089      It isn't totally clear that this is correct in all cases.  */
4090   if (partial == 0)
4091     arg->value = arg->stack_slot;
4092
4093   /* Once we have pushed something, pops can't safely
4094      be deferred during the rest of the arguments.  */
4095   NO_DEFER_POP;
4096
4097   /* ANSI doesn't require a sequence point here,
4098      but PCC has one, so this will avoid some problems.  */
4099   emit_queue ();
4100
4101   /* Free any temporary slots made in processing this argument.  Show
4102      that we might have taken the address of something and pushed that
4103      as an operand.  */
4104   preserve_temp_slots (NULL_RTX);
4105   free_temp_slots ();
4106   pop_temp_slots ();
4107 }