gcc/calls.c

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