gcc/calls.c

   1 /* Convert function calls to rtl insns, for GNU C compiler.
   2    Copyright (C) 1989, 1992 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "config.h"
  21 #include "rtl.h"
  22 #include "tree.h"
  23 #include "flags.h"
  24 #include "expr.h"
  25 #include "insn-flags.h"
  26
  27 /* Decide whether a function's arguments should be processed
  28    from first to last or from last to first.  */
  29
  30 #ifdef STACK_GROWS_DOWNWARD
  31 #ifdef PUSH_ROUNDING
  32 #define PUSH_ARGS_REVERSED      /* If it's last to first */
  33 #endif
  34 #endif
  35
  36 /* Like STACK_BOUNDARY but in units of bytes, not bits.  */
  37 #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
  38
  39 /* Data structure and subroutines used within expand_call.  */
  40
  41 struct arg_data
  42 {
  43   /* Tree node for this argument.  */
  44   tree tree_value;
  45   /* Current RTL value for argument, or 0 if it isn't precomputed.  */
  46   rtx value;
  47   /* Initially-compute RTL value for argument; only for const functions.  */
  48   rtx initial_value;
  49   /* Register to pass this argument in, 0 if passed on stack, or an
  50      EXPR_LIST if the arg is to be copied into multiple different
  51      registers.  */
  52   rtx reg;
  53   /* If REG was promoted from the actual mode of the argument expression,
  54      indicates whether the promotion is sign- or zero-extended.  */
  55   int unsignedp;
  56   /* Number of registers to use.  0 means put the whole arg in registers.
  57      Also 0 if not passed in registers.  */
  58   int partial;
  59   /* Non-zero if argument must be passed on stack.
  60      Note that some arguments may be passed on the stack
  61      even though pass_on_stack is zero, just because FUNCTION_ARG says so.
  62      pass_on_stack identifies arguments that *cannot* go in registers.  */
  63   int pass_on_stack;
  64   /* Offset of this argument from beginning of stack-args.  */
  65   struct args_size offset;
  66   /* Similar, but offset to the start of the stack slot.  Different from
  67      OFFSET if this arg pads downward.  */
  68   struct args_size slot_offset;
  69   /* Size of this argument on the stack, rounded up for any padding it gets,
  70      parts of the argument passed in registers do not count.
  71      If REG_PARM_STACK_SPACE is defined, then register parms
  72      are counted here as well.  */
  73   struct args_size size;
  74   /* Location on the stack at which parameter should be stored.  The store
  75      has already been done if STACK == VALUE.  */
  76   rtx stack;
  77   /* Location on the stack of the start of this argument slot.  This can
  78      differ from STACK if this arg pads downward.  This location is known
  79      to be aligned to FUNCTION_ARG_BOUNDARY.  */
  80   rtx stack_slot;
  81 #ifdef ACCUMULATE_OUTGOING_ARGS
  82   /* Place that this stack area has been saved, if needed.  */
  83   rtx save_area;
  84 #endif
  85 };
  86
  87 #ifdef ACCUMULATE_OUTGOING_ARGS
  88 /* A vector of one char per byte of stack space.  A byte if non-zero if
  89    the corresponding stack location has been used.
  90    This vector is used to prevent a function call within an argument from
  91    clobbering any stack already set up.  */
  92 static char *stack_usage_map;
  93
  94 /* Size of STACK_USAGE_MAP.  */
  95 static int highest_outgoing_arg_in_use;
  96
  97 /* stack_arg_under_construction is nonzero when an argument may be
  98    initialized with a constructor call (including a C function that
  99    returns a BLKmode struct) and expand_call must take special action
 100    to make sure the object being constructed does not overlap the
 101    argument list for the constructor call.  */
 102 int stack_arg_under_construction;
 103 #endif
 104
 105 static void store_one_arg ();
 106 extern enum machine_mode mode_for_size ();
 107 \f
 108 /* Return 1 if EXP contains a call to the built-in function `alloca'.  */
 109
 110 static int
 111 calls_alloca (exp)
 112      tree exp;
 113 {
 114   register int i;
 115   int type = TREE_CODE_CLASS (TREE_CODE (exp));
 116   int length = tree_code_length[(int) TREE_CODE (exp)];
 117
 118   /* Only expressions and references can contain calls.  */
 119
 120   if (type != 'e' && type != '<' && type != '1' && type != '2' && type != 'r'
 121       && type != 'b')
 122     return 0;
 123
 124   switch (TREE_CODE (exp))
 125     {
 126     case CALL_EXPR:
 127       if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
 128           && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
 129               == FUNCTION_DECL)
 130           && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
 131           && (DECL_FUNCTION_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
 132               == BUILT_IN_ALLOCA))
 133         return 1;
 134
 135       /* Third operand is RTL.  */
 136       length = 2;
 137       break;
 138
 139     case SAVE_EXPR:
 140       if (SAVE_EXPR_RTL (exp) != 0)
 141         return 0;
 142       break;
 143
 144     case BLOCK:
 145       {
 146         register tree local;
 147
 148         for (local = BLOCK_VARS (exp); local; local = TREE_CHAIN (local))
 149           if (DECL_INITIAL (local) != 0 && calls_alloca (DECL_INITIAL (local)))
 150             return 1;
 151       }
 152       {
 153         register tree subblock;
 154
 155         for (subblock = BLOCK_SUBBLOCKS (exp);
 156              subblock;
 157              subblock = TREE_CHAIN (subblock))
 158           if (calls_alloca (subblock))
 159             return 1;
 160       }
 161       return 0;
 162
 163     case METHOD_CALL_EXPR:
 164       length = 3;
 165       break;
 166
 167     case WITH_CLEANUP_EXPR:
 168       length = 1;
 169       break;
 170
 171     case RTL_EXPR:
 172       return 0;
 173     }
 174
 175   for (i = 0; i < length; i++)
 176     if (TREE_OPERAND (exp, i) != 0
 177         && calls_alloca (TREE_OPERAND (exp, i)))
 178       return 1;
 179
 180   return 0;
 181 }
 182 \f
 183 /* Force FUNEXP into a form suitable for the address of a CALL,
 184    and return that as an rtx.  Also load the static chain register
 185    if FNDECL is a nested function.
 186
 187    USE_INSNS points to a variable holding a chain of USE insns
 188    to which a USE of the static chain
 189    register should be added, if required.  */
 190
 191 rtx
 192 prepare_call_address (funexp, fndecl, use_insns)
 193      rtx funexp;
 194      tree fndecl;
 195      rtx *use_insns;
 196 {
 197   rtx static_chain_value = 0;
 198
 199   funexp = protect_from_queue (funexp, 0);
 200
 201   if (fndecl != 0)
 202     /* Get possible static chain value for nested function in C. */
 203     static_chain_value = lookup_static_chain (fndecl);
 204
 205   /* Make a valid memory address and copy constants thru pseudo-regs,
 206      but not for a constant address if -fno-function-cse.  */
 207   if (GET_CODE (funexp) != SYMBOL_REF)
 208     funexp = memory_address (FUNCTION_MODE, funexp);
 209   else
 210     {
 211 #ifndef NO_FUNCTION_CSE
 212       if (optimize && ! flag_no_function_cse)
 213 #ifdef NO_RECURSIVE_FUNCTION_CSE
 214         if (fndecl != current_function_decl)
 215 #endif
 216           funexp = force_reg (Pmode, funexp);
 217 #endif
 218     }
 219
 220   if (static_chain_value != 0)
 221     {
 222       emit_move_insn (static_chain_rtx, static_chain_value);
 223
 224       /* Put the USE insn in the chain we were passed.  It will later be
 225          output immediately in front of the CALL insn.  */
 226       push_to_sequence (*use_insns);
 227       emit_insn (gen_rtx (USE, VOIDmode, static_chain_rtx));
 228       *use_insns = get_insns ();
 229       end_sequence ();
 230     }
 231
 232   return funexp;
 233 }
 234
 235 /* Generate instructions to call function FUNEXP,
 236    and optionally pop the results.
 237    The CALL_INSN is the first insn generated.
 238
 239    FUNTYPE is the data type of the function, or, for a library call,
 240    the identifier for the name of the call.  This is given to the
 241    macro RETURN_POPS_ARGS to determine whether this function pops its own args.
 242
 243    STACK_SIZE is the number of bytes of arguments on the stack,
 244    rounded up to STACK_BOUNDARY; zero if the size is variable.
 245    This is both to put into the call insn and
 246    to generate explicit popping code if necessary.
 247
 248    STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
 249    It is zero if this call doesn't want a structure value.
 250
 251    NEXT_ARG_REG is the rtx that results from executing
 252      FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1)
 253    just after all the args have had their registers assigned.
 254    This could be whatever you like, but normally it is the first
 255    arg-register beyond those used for args in this call,
 256    or 0 if all the arg-registers are used in this call.
 257    It is passed on to `gen_call' so you can put this info in the call insn.
 258
 259    VALREG is a hard register in which a value is returned,
 260    or 0 if the call does not return a value.
 261
 262    OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before
 263    the args to this call were processed.
 264    We restore `inhibit_defer_pop' to that value.
 265
 266    USE_INSNS is a chain of USE insns to be emitted immediately before
 267    the actual CALL insn.
 268
 269    IS_CONST is true if this is a `const' call.  */
 270
 271 void
 272 emit_call_1 (funexp, funtype, stack_size, struct_value_size, next_arg_reg,
 273              valreg, old_inhibit_defer_pop, use_insns, is_const)
 274      rtx funexp;
 275      tree funtype;
 276      int stack_size;
 277      int struct_value_size;
 278      rtx next_arg_reg;
 279      rtx valreg;
 280      int old_inhibit_defer_pop;
 281      rtx use_insns;
 282      int is_const;
 283 {
 284   rtx stack_size_rtx = GEN_INT (stack_size);
 285   rtx struct_value_size_rtx = GEN_INT (struct_value_size);
 286   rtx call_insn;
 287   int already_popped = 0;
 288
 289   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
 290      and we don't want to load it into a register as an optimization,
 291      because prepare_call_address already did it if it should be done.  */
 292   if (GET_CODE (funexp) != SYMBOL_REF)
 293     funexp = memory_address (FUNCTION_MODE, funexp);
 294
 295 #ifndef ACCUMULATE_OUTGOING_ARGS
 296 #if defined (HAVE_call_pop) && defined (HAVE_call_value_pop)
 297   if (HAVE_call_pop && HAVE_call_value_pop
 298       && (RETURN_POPS_ARGS (funtype, stack_size) > 0 || stack_size == 0))
 299     {
 300       rtx n_pop = GEN_INT (RETURN_POPS_ARGS (funtype, stack_size));
 301       rtx pat;
 302
 303       /* If this subroutine pops its own args, record that in the call insn
 304          if possible, for the sake of frame pointer elimination.  */
 305       if (valreg)
 306         pat = gen_call_value_pop (valreg,
 307                                   gen_rtx (MEM, FUNCTION_MODE, funexp),
 308                                   stack_size_rtx, next_arg_reg, n_pop);
 309       else
 310         pat = gen_call_pop (gen_rtx (MEM, FUNCTION_MODE, funexp),
 311                             stack_size_rtx, next_arg_reg, n_pop);
 312
 313       emit_call_insn (pat);
 314       already_popped = 1;
 315     }
 316   else
 317 #endif
 318 #endif
 319
 320 #if defined (HAVE_call) && defined (HAVE_call_value)
 321   if (HAVE_call && HAVE_call_value)
 322     {
 323       if (valreg)
 324         emit_call_insn (gen_call_value (valreg,
 325                                         gen_rtx (MEM, FUNCTION_MODE, funexp),
 326                                         stack_size_rtx, next_arg_reg));
 327       else
 328         emit_call_insn (gen_call (gen_rtx (MEM, FUNCTION_MODE, funexp),
 329                                   stack_size_rtx, next_arg_reg,
 330                                   struct_value_size_rtx));
 331     }
 332   else
 333 #endif
 334     abort ();
 335
 336   /* Find the CALL insn we just emitted and write the USE insns before it.  */
 337   for (call_insn = get_last_insn ();
 338        call_insn && GET_CODE (call_insn) != CALL_INSN;
 339        call_insn = PREV_INSN (call_insn))
 340     ;
 341
 342   if (! call_insn)
 343     abort ();
 344
 345   /* Put the USE insns before the CALL.  */
 346   emit_insns_before (use_insns, call_insn);
 347
 348   /* If this is a const call, then set the insn's unchanging bit.  */
 349   if (is_const)
 350     CONST_CALL_P (call_insn) = 1;
 351
 352 #ifndef ACCUMULATE_OUTGOING_ARGS
 353   /* If returning from the subroutine does not automatically pop the args,
 354      we need an instruction to pop them sooner or later.
 355      Perhaps do it now; perhaps just record how much space to pop later.
 356
 357      If returning from the subroutine does pop the args, indicate that the
 358      stack pointer will be changed.  */
 359
 360   if (stack_size != 0 && RETURN_POPS_ARGS (funtype, stack_size) > 0)
 361     {
 362       if (!already_popped)
 363         emit_insn (gen_rtx (CLOBBER, VOIDmode, stack_pointer_rtx));
 364       stack_size -= RETURN_POPS_ARGS (funtype, stack_size);
 365       stack_size_rtx = GEN_INT (stack_size);
 366     }
 367
 368   if (stack_size != 0)
 369     {
 370       if (flag_defer_pop && inhibit_defer_pop == 0)
 371         pending_stack_adjust += stack_size;
 372       else
 373         adjust_stack (stack_size_rtx);
 374     }
 375 #endif
 376
 377   inhibit_defer_pop = old_inhibit_defer_pop;
 378 }
 379
 380 /* Generate all the code for a function call
 381    and return an rtx for its value.
 382    Store the value in TARGET (specified as an rtx) if convenient.
 383    If the value is stored in TARGET then TARGET is returned.
 384    If IGNORE is nonzero, then we ignore the value of the function call.  */
 385
 386 rtx
 387 expand_call (exp, target, ignore)
 388      tree exp;
 389      rtx target;
 390      int ignore;
 391 {
 392   /* List of actual parameters.  */
 393   tree actparms = TREE_OPERAND (exp, 1);
 394   /* RTX for the function to be called.  */
 395   rtx funexp;
 396   /* Tree node for the function to be called (not the address!).  */
 397   tree funtree;
 398   /* Data type of the function.  */
 399   tree funtype;
 400   /* Declaration of the function being called,
 401      or 0 if the function is computed (not known by name).  */
 402   tree fndecl = 0;
 403   char *name = 0;
 404
 405   /* Register in which non-BLKmode value will be returned,
 406      or 0 if no value or if value is BLKmode.  */
 407   rtx valreg;
 408   /* Address where we should return a BLKmode value;
 409      0 if value not BLKmode.  */
 410   rtx structure_value_addr = 0;
 411   /* Nonzero if that address is being passed by treating it as
 412      an extra, implicit first parameter.  Otherwise,
 413      it is passed by being copied directly into struct_value_rtx.  */
 414   int structure_value_addr_parm = 0;
 415   /* Size of aggregate value wanted, or zero if none wanted
 416      or if we are using the non-reentrant PCC calling convention
 417      or expecting the value in registers.  */
 418   int struct_value_size = 0;
 419   /* Nonzero if called function returns an aggregate in memory PCC style,
 420      by returning the address of where to find it.  */
 421   int pcc_struct_value = 0;
 422
 423   /* Number of actual parameters in this call, including struct value addr.  */
 424   int num_actuals;
 425   /* Number of named args.  Args after this are anonymous ones
 426      and they must all go on the stack.  */
 427   int n_named_args;
 428   /* Count arg position in order args appear.  */
 429   int argpos;
 430
 431   /* Vector of information about each argument.
 432      Arguments are numbered in the order they will be pushed,
 433      not the order they are written.  */
 434   struct arg_data *args;
 435
 436   /* Total size in bytes of all the stack-parms scanned so far.  */
 437   struct args_size args_size;
 438   /* Size of arguments before any adjustments (such as rounding).  */
 439   struct args_size original_args_size;
 440   /* Data on reg parms scanned so far.  */
 441   CUMULATIVE_ARGS args_so_far;
 442   /* Nonzero if a reg parm has been scanned.  */
 443   int reg_parm_seen;
 444
 445   /* Nonzero if we must avoid push-insns in the args for this call.
 446      If stack space is allocated for register parameters, but not by the
 447      caller, then it is preallocated in the fixed part of the stack frame.
 448      So the entire argument block must then be preallocated (i.e., we
 449      ignore PUSH_ROUNDING in that case).  */
 450
 451 #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
 452   int must_preallocate = 1;
 453 #else
 454 #ifdef PUSH_ROUNDING
 455   int must_preallocate = 0;
 456 #else
 457   int must_preallocate = 1;
 458 #endif
 459 #endif
 460
 461   /* Size of the stack reserved for parameter registers.  */
 462   int reg_parm_stack_space = 0;
 463
 464   /* 1 if scanning parms front to back, -1 if scanning back to front.  */
 465   int inc;
 466   /* Address of space preallocated for stack parms
 467      (on machines that lack push insns), or 0 if space not preallocated.  */
 468   rtx argblock = 0;
 469
 470   /* Nonzero if it is plausible that this is a call to alloca.  */
 471   int may_be_alloca;
 472   /* Nonzero if this is a call to setjmp or a related function.  */
 473   int returns_twice;
 474   /* Nonzero if this is a call to `longjmp'.  */
 475   int is_longjmp;
 476   /* Nonzero if this is a call to an inline function.  */
 477   int is_integrable = 0;
 478   /* Nonzero if this is a call to a `const' function.
 479      Note that only explicitly named functions are handled as `const' here.  */
 480   int is_const = 0;
 481   /* Nonzero if this is a call to a `volatile' function.  */
 482   int is_volatile = 0;
 483 #if defined(ACCUMULATE_OUTGOING_ARGS) && defined(REG_PARM_STACK_SPACE)
 484   /* Define the boundary of the register parm stack space that needs to be
 485      save, if any.  */
 486   int low_to_save = -1, high_to_save;
 487   rtx save_area = 0;            /* Place that it is saved */
 488 #endif
 489
 490 #ifdef ACCUMULATE_OUTGOING_ARGS
 491   int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
 492   char *initial_stack_usage_map = stack_usage_map;
 493 #endif
 494
 495   rtx old_stack_level = 0;
 496   int old_pending_adj;
 497   int old_stack_arg_under_construction;
 498   int old_inhibit_defer_pop = inhibit_defer_pop;
 499   tree old_cleanups = cleanups_this_call;
 500
 501   rtx use_insns = 0;
 502
 503   register tree p;
 504   register int i;
 505
 506   /* See if we can find a DECL-node for the actual function.
 507      As a result, decide whether this is a call to an integrable function.  */
 508
 509   p = TREE_OPERAND (exp, 0);
 510   if (TREE_CODE (p) == ADDR_EXPR)
 511     {
 512       fndecl = TREE_OPERAND (p, 0);
 513       if (TREE_CODE (fndecl) != FUNCTION_DECL)
 514         {
 515           /* May still be a `const' function if it is
 516              a call through a pointer-to-const.
 517              But we don't handle that.  */
 518           fndecl = 0;
 519         }
 520       else
 521         {
 522           if (!flag_no_inline
 523               && fndecl != current_function_decl
 524               && DECL_SAVED_INSNS (fndecl))
 525             is_integrable = 1;
 526           else if (! TREE_ADDRESSABLE (fndecl))
 527             {
 528               /* In case this function later becomes inlineable,
 529                  record that there was already a non-inline call to it.
 530
 531                  Use abstraction instead of setting TREE_ADDRESSABLE
 532                  directly.  */
 533               if (DECL_INLINE (fndecl) && extra_warnings && !flag_no_inline)
 534                 warning_with_decl (fndecl, "can't inline call to `%s' which was declared inline");
 535               mark_addressable (fndecl);
 536             }
 537
 538           if (TREE_READONLY (fndecl) && ! TREE_THIS_VOLATILE (fndecl)
 539               && TYPE_MODE (TREE_TYPE (exp)) != VOIDmode)
 540             is_const = 1;
 541         }
 542     }
 543
 544   is_volatile = TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (p)));
 545
 546 #ifdef REG_PARM_STACK_SPACE
 547 #ifdef MAYBE_REG_PARM_STACK_SPACE
 548   reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
 549 #else
 550   reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
 551 #endif
 552 #endif
 553
 554   /* Warn if this value is an aggregate type,
 555      regardless of which calling convention we are using for it.  */
 556   if (warn_aggregate_return
 557       && (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
 558           || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE
 559           || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE))
 560     warning ("function call has aggregate value");
 561
 562   /* Set up a place to return a structure.  */
 563
 564   /* Cater to broken compilers.  */
 565   if (aggregate_value_p (exp))
 566     {
 567       /* This call returns a big structure.  */
 568       is_const = 0;
 569
 570 #ifdef PCC_STATIC_STRUCT_RETURN
 571       if (flag_pcc_struct_return)
 572         {
 573           pcc_struct_value = 1;
 574           is_integrable = 0;  /* Easier than making that case work right.  */
 575         }
 576       else
 577 #endif
 578         {
 579           struct_value_size = int_size_in_bytes (TREE_TYPE (exp));
 580
 581           if (struct_value_size < 0)
 582             abort ();
 583
 584           if (target && GET_CODE (target) == MEM)
 585             structure_value_addr = XEXP (target, 0);
 586           else
 587             {
 588               /* Assign a temporary on the stack to hold the value.  */
 589
 590               /* For variable-sized objects, we must be called with a target
 591                  specified.  If we were to allocate space on the stack here,
 592                  we would have no way of knowing when to free it.  */
 593
 594               structure_value_addr
 595                 = XEXP (assign_stack_temp (BLKmode, struct_value_size, 1), 0);
 596               target = 0;
 597             }
 598         }
 599     }
 600
 601   /* If called function is inline, try to integrate it.  */
 602
 603   if (is_integrable)
 604     {
 605       rtx temp;
 606       rtx before_call = get_last_insn ();
 607
 608       temp = expand_inline_function (fndecl, actparms, target,
 609                                      ignore, TREE_TYPE (exp),
 610                                      structure_value_addr);
 611
 612       /* If inlining succeeded, return.  */
 613       if ((HOST_WIDE_INT) temp != -1)
 614         {
 615           int i;
 616
 617           /* Perform all cleanups needed for the arguments of this call
 618              (i.e. destructors in C++).  It is ok if these destructors
 619              clobber RETURN_VALUE_REG, because the only time we care about
 620              this is when TARGET is that register.  But in C++, we take
 621              care to never return that register directly.  */
 622           expand_cleanups_to (old_cleanups);
 623
 624 #ifdef ACCUMULATE_OUTGOING_ARGS
 625           /* If the outgoing argument list must be preserved, push
 626              the stack before executing the inlined function if it
 627              makes any calls.  */
 628
 629           for (i = reg_parm_stack_space - 1; i >= 0; i--)
 630             if (i < highest_outgoing_arg_in_use && stack_usage_map[i] != 0)
 631               break;
 632
 633           if (stack_arg_under_construction || i >= 0)
 634             {
 635               rtx insn = NEXT_INSN (before_call), seq;
 636
 637               /* Look for a call in the inline function code.
 638                  If OUTGOING_ARGS_SIZE (DECL_SAVED_INSNS (fndecl)) is
 639                  nonzero then there is a call and it is not necessary
 640                  to scan the insns.  */
 641
 642               if (OUTGOING_ARGS_SIZE (DECL_SAVED_INSNS (fndecl)) == 0)
 643                 for (; insn; insn = NEXT_INSN (insn))
 644                   if (GET_CODE (insn) == CALL_INSN)
 645                     break;
 646
 647               if (insn)
 648                 {
 649                   /* Reserve enough stack space so that the largest
 650                      argument list of any function call in the inline
 651                      function does not overlap the argument list being
 652                      evaluated.  This is usually an overestimate because
 653                      allocate_dynamic_stack_space reserves space for an
 654                      outgoing argument list in addition to the requested
 655                      space, but there is no way to ask for stack space such
 656                      that an argument list of a certain length can be
 657                      safely constructed.  */
 658
 659                   int adjust = OUTGOING_ARGS_SIZE (DECL_SAVED_INSNS (fndecl));
 660 #ifdef REG_PARM_STACK_SPACE
 661                   /* Add the stack space reserved for register arguments
 662                      in the inline function.  What is really needed is the
 663                      largest value of reg_parm_stack_space in the inline
 664                      function, but that is not available.  Using the current
 665                      value of reg_parm_stack_space is wrong, but gives
 666                      correct results on all supported machines.  */
 667                   adjust += reg_parm_stack_space;
 668 #endif
 669                   start_sequence ();
 670                   emit_stack_save (SAVE_BLOCK, &old_stack_level, 0);
 671                   allocate_dynamic_stack_space (GEN_INT (adjust),
 672                                                 NULL_RTX, BITS_PER_UNIT);
 673                   seq = get_insns ();
 674                   end_sequence ();
 675                   emit_insns_before (seq, NEXT_INSN (before_call));
 676                   emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
 677                 }
 678             }
 679 #endif
 680
 681           /* If the result is equivalent to TARGET, return TARGET to simplify
 682              checks in store_expr.  They can be equivalent but not equal in the
 683              case of a function that returns BLKmode.  */
 684           if (temp != target && rtx_equal_p (temp, target))
 685             return target;
 686           return temp;
 687         }
 688
 689       /* If inlining failed, mark FNDECL as needing to be compiled
 690          separately after all.  */
 691       mark_addressable (fndecl);
 692     }
 693
 694   /* When calling a const function, we must pop the stack args right away,
 695      so that the pop is deleted or moved with the call.  */
 696   if (is_const)
 697     NO_DEFER_POP;
 698
 699   function_call_count++;
 700
 701   if (fndecl && DECL_NAME (fndecl))
 702     name = IDENTIFIER_POINTER (DECL_NAME (fndecl));
 703
 704 #if 0
 705   /* Unless it's a call to a specific function that isn't alloca,
 706      if it has one argument, we must assume it might be alloca.  */
 707
 708   may_be_alloca =
 709     (!(fndecl != 0 && strcmp (name, "alloca"))
 710      && actparms != 0
 711      && TREE_CHAIN (actparms) == 0);
 712 #else
 713   /* We assume that alloca will always be called by name.  It
 714      makes no sense to pass it as a pointer-to-function to
 715      anything that does not understand its behavior.  */
 716   may_be_alloca =
 717     (name && ((IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 6
 718                  && name[0] == 'a'
 719                  && ! strcmp (name, "alloca"))
 720                 || (IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 16
 721                     && name[0] == '_'
 722                     && ! strcmp (name, "__builtin_alloca"))));
 723 #endif
 724
 725   /* See if this is a call to a function that can return more than once
 726      or a call to longjmp.  */
 727
 728   returns_twice = 0;
 729   is_longjmp = 0;
 730
 731   if (name != 0 && IDENTIFIER_LENGTH (DECL_NAME (fndecl)) <= 15)
 732     {
 733       char *tname = name;
 734
 735       if (name[0] == '_')
 736         tname += ((name[1] == '_' && name[2] == 'x') ? 3 : 1);
 737
 738       if (tname[0] == 's')
 739         {
 740           returns_twice
 741             = ((tname[1] == 'e'
 742                 && (! strcmp (tname, "setjmp")
 743                     || ! strcmp (tname, "setjmp_syscall")))
 744                || (tname[1] == 'i'
 745                    && ! strcmp (tname, "sigsetjmp"))
 746                || (tname[1] == 'a'
 747                    && ! strcmp (tname, "savectx")));
 748           if (tname[1] == 'i'
 749               && ! strcmp (tname, "siglongjmp"))
 750             is_longjmp = 1;
 751         }
 752       else if ((tname[0] == 'q' && tname[1] == 's'
 753                 && ! strcmp (tname, "qsetjmp"))
 754                || (tname[0] == 'v' && tname[1] == 'f'
 755                    && ! strcmp (tname, "vfork")))
 756         returns_twice = 1;
 757
 758       else if (tname[0] == 'l' && tname[1] == 'o'
 759                && ! strcmp (tname, "longjmp"))
 760         is_longjmp = 1;
 761     }
 762
 763   if (may_be_alloca)
 764     current_function_calls_alloca = 1;
 765
 766   /* Don't let pending stack adjusts add up to too much.
 767      Also, do all pending adjustments now
 768      if there is any chance this might be a call to alloca.  */
 769
 770   if (pending_stack_adjust >= 32
 771       || (pending_stack_adjust > 0 && may_be_alloca))
 772     do_pending_stack_adjust ();
 773
 774   /* Operand 0 is a pointer-to-function; get the type of the function.  */
 775   funtype = TREE_TYPE (TREE_OPERAND (exp, 0));
 776   if (TREE_CODE (funtype) != POINTER_TYPE)
 777     abort ();
 778   funtype = TREE_TYPE (funtype);
 779
 780   /* Push the temporary stack slot level so that we can free temporaries used
 781      by each of the arguments separately.  */
 782   push_temp_slots ();
 783
 784   /* Start updating where the next arg would go.  */
 785   INIT_CUMULATIVE_ARGS (args_so_far, funtype, NULL_RTX);
 786
 787   /* If struct_value_rtx is 0, it means pass the address
 788      as if it were an extra parameter.  */
 789   if (structure_value_addr && struct_value_rtx == 0)
 790     {
 791 #ifdef ACCUMULATE_OUTGOING_ARGS
 792       /* If the stack will be adjusted, make sure the structure address
 793          does not refer to virtual_outgoing_args_rtx.  */
 794       rtx temp = (stack_arg_under_construction
 795                   ? copy_addr_to_reg (structure_value_addr)
 796                   : force_reg (Pmode, structure_value_addr));
 797 #else
 798       rtx temp = force_reg (Pmode, structure_value_addr);
 799 #endif
 800
 801       actparms
 802         = tree_cons (error_mark_node,
 803                      make_tree (build_pointer_type (TREE_TYPE (funtype)),
 804                                 temp),
 805                      actparms);
 806       structure_value_addr_parm = 1;
 807     }
 808
 809   /* Count the arguments and set NUM_ACTUALS.  */
 810   for (p = actparms, i = 0; p; p = TREE_CHAIN (p)) i++;
 811   num_actuals = i;
 812
 813   /* Compute number of named args.
 814      Normally, don't include the last named arg if anonymous args follow.
 815      (If no anonymous args follow, the result of list_length
 816      is actually one too large.)
 817
 818      If SETUP_INCOMING_VARARGS is defined, this machine will be able to
 819      place unnamed args that were passed in registers into the stack.  So
 820      treat all args as named.  This allows the insns emitting for a specific
 821      argument list to be independent of the function declaration.
 822
 823      If SETUP_INCOMING_VARARGS is not defined, we do not have any reliable
 824      way to pass unnamed args in registers, so we must force them into
 825      memory.  */
 826 #ifndef SETUP_INCOMING_VARARGS
 827   if (TYPE_ARG_TYPES (funtype) != 0)
 828     n_named_args
 829       = list_length (TYPE_ARG_TYPES (funtype)) - 1
 830         /* Count the struct value address, if it is passed as a parm.  */
 831         + structure_value_addr_parm;
 832   else
 833 #endif
 834     /* If we know nothing, treat all args as named.  */
 835     n_named_args = num_actuals;
 836
 837   /* Make a vector to hold all the information about each arg.  */
 838   args = (struct arg_data *) alloca (num_actuals * sizeof (struct arg_data));
 839   bzero (args, num_actuals * sizeof (struct arg_data));
 840
 841   args_size.constant = 0;
 842   args_size.var = 0;
 843
 844   /* In this loop, we consider args in the order they are written.
 845      We fill up ARGS from the front of from the back if necessary
 846      so that in any case the first arg to be pushed ends up at the front.  */
 847
 848 #ifdef PUSH_ARGS_REVERSED
 849   i = num_actuals - 1, inc = -1;
 850   /* In this case, must reverse order of args
 851      so that we compute and push the last arg first.  */
 852 #else
 853   i = 0, inc = 1;
 854 #endif
 855
 856   /* I counts args in order (to be) pushed; ARGPOS counts in order written.  */
 857   for (p = actparms, argpos = 0; p; p = TREE_CHAIN (p), i += inc, argpos++)
 858     {
 859       tree type = TREE_TYPE (TREE_VALUE (p));
 860       enum machine_mode mode;
 861
 862       args[i].tree_value = TREE_VALUE (p);
 863
 864       /* Replace erroneous argument with constant zero.  */
 865       if (type == error_mark_node || TYPE_SIZE (type) == 0)
 866         args[i].tree_value = integer_zero_node, type = integer_type_node;
 867
 868       /* Decide where to pass this arg.
 869
 870          args[i].reg is nonzero if all or part is passed in registers.
 871
 872          args[i].partial is nonzero if part but not all is passed in registers,
 873          and the exact value says how many words are passed in registers.
 874
 875          args[i].pass_on_stack is nonzero if the argument must at least be
 876          computed on the stack.  It may then be loaded back into registers
 877          if args[i].reg is nonzero.
 878
 879          These decisions are driven by the FUNCTION_... macros and must agree
 880          with those made by function.c.  */
 881
 882 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
 883       /* See if this argument should be passed by invisible reference.  */
 884       if (FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, TYPE_MODE (type), type,
 885                                           argpos < n_named_args))
 886         {
 887           /* We make a copy of the object and pass the address to the function
 888              being called.  */
 889           rtx copy;
 890
 891           if (TYPE_SIZE (type) == 0
 892               || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
 893             {
 894               /* This is a variable-sized object.  Make space on the stack
 895                  for it.  */
 896               rtx size_rtx = expand_expr (size_in_bytes (type), NULL_RTX,
 897                                           VOIDmode, 0);
 898
 899               if (old_stack_level == 0)
 900                 {
 901                   emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
 902                   old_pending_adj = pending_stack_adjust;
 903                   pending_stack_adjust = 0;
 904                 }
 905
 906               copy = gen_rtx (MEM, BLKmode,
 907                               allocate_dynamic_stack_space (size_rtx, NULL_RTX,
 908                                                             TYPE_ALIGN (type)));
 909             }
 910           else
 911             {
 912               int size = int_size_in_bytes (type);
 913               copy = assign_stack_temp (TYPE_MODE (type), size, 1);
 914             }
 915
 916           store_expr (args[i].tree_value, copy, 0);
 917
 918           args[i].tree_value = build1 (ADDR_EXPR, build_pointer_type (type),
 919                                        make_tree (type, copy));
 920           type = build_pointer_type (type);
 921         }
 922 #endif
 923
 924       mode = TYPE_MODE (type);
 925
 926 #ifdef PROMOTE_FUNCTION_ARGS
 927       /* Compute the mode in which the arg is actually to be extended to.  */
 928       if (TREE_CODE (type) == INTEGER_TYPE || TREE_CODE (type) == ENUMERAL_TYPE
 929           || TREE_CODE (type) == BOOLEAN_TYPE || TREE_CODE (type) == CHAR_TYPE
 930           || TREE_CODE (type) == REAL_TYPE || TREE_CODE (type) == POINTER_TYPE
 931           || TREE_CODE (type) == OFFSET_TYPE)
 932         {
 933           int unsignedp = TREE_UNSIGNED (type);
 934           PROMOTE_MODE (mode, unsignedp, type);
 935           args[i].unsignedp = unsignedp;
 936         }
 937 #endif
 938
 939       args[i].reg = FUNCTION_ARG (args_so_far, mode, type,
 940                                   argpos < n_named_args);
 941 #ifdef FUNCTION_ARG_PARTIAL_NREGS
 942       if (args[i].reg)
 943         args[i].partial
 944           = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, type,
 945                                         argpos < n_named_args);
 946 #endif
 947
 948       args[i].pass_on_stack = MUST_PASS_IN_STACK (mode, type);
 949
 950       /* If FUNCTION_ARG returned an (expr_list (nil) FOO), it means that
 951          we are to pass this arg in the register(s) designated by FOO, but
 952          also to pass it in the stack.  */
 953       if (args[i].reg && GET_CODE (args[i].reg) == EXPR_LIST
 954           && XEXP (args[i].reg, 0) == 0)
 955         args[i].pass_on_stack = 1, args[i].reg = XEXP (args[i].reg, 1);
 956
 957       /* If this is an addressable type, we must preallocate the stack
 958          since we must evaluate the object into its final location.
 959
 960          If this is to be passed in both registers and the stack, it is simpler
 961          to preallocate.  */
 962       if (TREE_ADDRESSABLE (type)
 963           || (args[i].pass_on_stack && args[i].reg != 0))
 964         must_preallocate = 1;
 965
 966       /* If this is an addressable type, we cannot pre-evaluate it.  Thus,
 967          we cannot consider this function call constant.  */
 968       if (TREE_ADDRESSABLE (type))
 969         is_const = 0;
 970
 971       /* Compute the stack-size of this argument.  */
 972       if (args[i].reg == 0 || args[i].partial != 0
 973 #ifdef REG_PARM_STACK_SPACE
 974           || reg_parm_stack_space > 0
 975 #endif
 976           || args[i].pass_on_stack)
 977         locate_and_pad_parm (TYPE_MODE (type), type,
 978 #ifdef STACK_PARMS_IN_REG_PARM_AREA
 979                              1,
 980 #else
 981                              args[i].reg != 0,
 982 #endif
 983                              fndecl, &args_size, &args[i].offset,
 984                              &args[i].size);
 985
 986 #ifndef ARGS_GROW_DOWNWARD
 987       args[i].slot_offset = args_size;
 988 #endif
 989
 990 #ifndef REG_PARM_STACK_SPACE
 991       /* If a part of the arg was put into registers,
 992          don't include that part in the amount pushed.  */
 993       if (! args[i].pass_on_stack)
 994         args[i].size.constant -= ((args[i].partial * UNITS_PER_WORD)
 995                                   / (PARM_BOUNDARY / BITS_PER_UNIT)
 996                                   * (PARM_BOUNDARY / BITS_PER_UNIT));
 997 #endif
 998
 999       /* Update ARGS_SIZE, the total stack space for args so far.  */
1000
1001       args_size.constant += args[i].size.constant;
1002       if (args[i].size.var)
1003         {
1004           ADD_PARM_SIZE (args_size, args[i].size.var);
1005         }
1006
1007       /* Since the slot offset points to the bottom of the slot,
1008          we must record it after incrementing if the args grow down.  */
1009 #ifdef ARGS_GROW_DOWNWARD
1010       args[i].slot_offset = args_size;
1011
1012       args[i].slot_offset.constant = -args_size.constant;
1013       if (args_size.var)
1014         {
1015           SUB_PARM_SIZE (args[i].slot_offset, args_size.var);
1016         }
1017 #endif
1018
1019       /* Increment ARGS_SO_FAR, which has info about which arg-registers
1020          have been used, etc.  */
1021
1022       FUNCTION_ARG_ADVANCE (args_so_far, TYPE_MODE (type), type,
1023                             argpos < n_named_args);
1024     }
1025
1026 #ifdef FINAL_REG_PARM_STACK_SPACE
1027   reg_parm_stack_space = FINAL_REG_PARM_STACK_SPACE (args_size.constant,
1028                                                      args_size.var);
1029 #endif
1030
1031   /* Compute the actual size of the argument block required.  The variable
1032      and constant sizes must be combined, the size may have to be rounded,
1033      and there may be a minimum required size.  */
1034
1035   original_args_size = args_size;
1036   if (args_size.var)
1037     {
1038       /* If this function requires a variable-sized argument list, don't try to
1039          make a cse'able block for this call.  We may be able to do this
1040          eventually, but it is too complicated to keep track of what insns go
1041          in the cse'able block and which don't.  */
1042
1043       is_const = 0;
1044       must_preallocate = 1;
1045
1046       args_size.var = ARGS_SIZE_TREE (args_size);
1047       args_size.constant = 0;
1048
1049 #ifdef STACK_BOUNDARY
1050       if (STACK_BOUNDARY != BITS_PER_UNIT)
1051         args_size.var = round_up (args_size.var, STACK_BYTES);
1052 #endif
1053
1054 #ifdef REG_PARM_STACK_SPACE
1055       if (reg_parm_stack_space > 0)
1056         {
1057           args_size.var
1058             = size_binop (MAX_EXPR, args_size.var,
1059                           size_int (REG_PARM_STACK_SPACE (fndecl)));
1060
1061 #ifndef OUTGOING_REG_PARM_STACK_SPACE
1062           /* The area corresponding to register parameters is not to count in
1063              the size of the block we need.  So make the adjustment.  */
1064           args_size.var
1065             = size_binop (MINUS_EXPR, args_size.var,
1066                           size_int (reg_parm_stack_space));
1067 #endif
1068         }
1069 #endif
1070     }
1071   else
1072     {
1073 #ifdef STACK_BOUNDARY
1074       args_size.constant = (((args_size.constant + (STACK_BYTES - 1))
1075                              / STACK_BYTES) * STACK_BYTES);
1076 #endif
1077
1078 #ifdef REG_PARM_STACK_SPACE
1079       args_size.constant = MAX (args_size.constant,
1080                                 reg_parm_stack_space);
1081 #ifndef OUTGOING_REG_PARM_STACK_SPACE
1082       args_size.constant -= reg_parm_stack_space;
1083 #endif
1084 #endif
1085     }
1086
1087   /* See if we have or want to preallocate stack space.
1088
1089      If we would have to push a partially-in-regs parm
1090      before other stack parms, preallocate stack space instead.
1091
1092      If the size of some parm is not a multiple of the required stack
1093      alignment, we must preallocate.
1094
1095      If the total size of arguments that would otherwise create a copy in
1096      a temporary (such as a CALL) is more than half the total argument list
1097      size, preallocation is faster.
1098
1099      Another reason to preallocate is if we have a machine (like the m88k)
1100      where stack alignment is required to be maintained between every
1101      pair of insns, not just when the call is made.  However, we assume here
1102      that such machines either do not have push insns (and hence preallocation
1103      would occur anyway) or the problem is taken care of with
1104      PUSH_ROUNDING.  */
1105
1106   if (! must_preallocate)
1107     {
1108       int partial_seen = 0;
1109       int copy_to_evaluate_size = 0;
1110
1111       for (i = 0; i < num_actuals && ! must_preallocate; i++)
1112         {
1113           if (args[i].partial > 0 && ! args[i].pass_on_stack)
1114             partial_seen = 1;
1115           else if (partial_seen && args[i].reg == 0)
1116             must_preallocate = 1;
1117
1118           if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
1119               && (TREE_CODE (args[i].tree_value) == CALL_EXPR
1120                   || TREE_CODE (args[i].tree_value) == TARGET_EXPR
1121                   || TREE_CODE (args[i].tree_value) == COND_EXPR
1122                   || TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value))))
1123             copy_to_evaluate_size
1124               += int_size_in_bytes (TREE_TYPE (args[i].tree_value));
1125         }
1126
1127       if (copy_to_evaluate_size * 2 >= args_size.constant
1128           && args_size.constant > 0)
1129         must_preallocate = 1;
1130     }
1131
1132   /* If the structure value address will reference the stack pointer, we must
1133      stabilize it.  We don't need to do this if we know that we are not going
1134      to adjust the stack pointer in processing this call.  */
1135
1136   if (structure_value_addr
1137       && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
1138        || reg_mentioned_p (virtual_outgoing_args_rtx, structure_value_addr))
1139       && (args_size.var
1140 #ifndef ACCUMULATE_OUTGOING_ARGS
1141           || args_size.constant
1142 #endif
1143           ))
1144     structure_value_addr = copy_to_reg (structure_value_addr);
1145
1146   /* If this function call is cse'able, precompute all the parameters.
1147      Note that if the parameter is constructed into a temporary, this will
1148      cause an additional copy because the parameter will be constructed
1149      into a temporary location and then copied into the outgoing arguments.
1150      If a parameter contains a call to alloca and this function uses the
1151      stack, precompute the parameter.  */
1152
1153   for (i = 0; i < num_actuals; i++)
1154     if (is_const
1155         || ((args_size.var != 0 || args_size.constant != 0)
1156             && calls_alloca (args[i].tree_value)))
1157       {
1158         args[i].initial_value = args[i].value
1159           = expand_expr (args[i].tree_value, NULL_RTX, VOIDmode, 0);
1160         preserve_temp_slots (args[i].value);
1161         free_temp_slots ();
1162
1163         /* ANSI doesn't require a sequence point here,
1164            but PCC has one, so this will avoid some problems.  */
1165         emit_queue ();
1166       }
1167
1168   /* Now we are about to start emitting insns that can be deleted
1169      if a libcall is deleted.  */
1170   if (is_const)
1171     start_sequence ();
1172
1173   /* If we have no actual push instructions, or shouldn't use them,
1174      make space for all args right now.  */
1175
1176   if (args_size.var != 0)
1177     {
1178       if (old_stack_level == 0)
1179         {
1180           emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1181           old_pending_adj = pending_stack_adjust;
1182           pending_stack_adjust = 0;
1183 #ifdef ACCUMULATE_OUTGOING_ARGS
1184           /* stack_arg_under_construction says whether a stack arg is
1185              being constructed at the old stack level.  Pushing the stack
1186              gets a clean outgoing argument block.  */
1187           old_stack_arg_under_construction = stack_arg_under_construction;
1188           stack_arg_under_construction = 0;
1189 #endif
1190         }
1191       argblock = push_block (ARGS_SIZE_RTX (args_size), 0, 0);
1192     }
1193   else if (must_preallocate)
1194     {
1195       /* Note that we must go through the motions of allocating an argument
1196          block even if the size is zero because we may be storing args
1197          in the area reserved for register arguments, which may be part of
1198          the stack frame.  */
1199       int needed = args_size.constant;
1200
1201 #ifdef ACCUMULATE_OUTGOING_ARGS
1202       /* Store the maximum argument space used.  It will be pushed by the
1203          prologue.
1204
1205          Since the stack pointer will never be pushed, it is possible for
1206          the evaluation of a parm to clobber something we have already
1207          written to the stack.  Since most function calls on RISC machines
1208          do not use the stack, this is uncommon, but must work correctly.
1209
1210          Therefore, we save any area of the stack that was already written
1211          and that we are using.  Here we set up to do this by making a new
1212          stack usage map from the old one.  The actual save will be done
1213          by store_one_arg.
1214
1215          Another approach might be to try to reorder the argument
1216          evaluations to avoid this conflicting stack usage.  */
1217
1218       if (needed > current_function_outgoing_args_size)
1219         current_function_outgoing_args_size = needed;
1220
1221 #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
1222       /* Since we will be writing into the entire argument area, the
1223          map must be allocated for its entire size, not just the part that
1224          is the responsibility of the caller.  */
1225       needed += reg_parm_stack_space;
1226 #endif
1227
1228 #ifdef ARGS_GROW_DOWNWARD
1229       highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
1230                                          needed + 1);
1231 #else
1232       highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use, needed);
1233 #endif
1234       stack_usage_map = (char *) alloca (highest_outgoing_arg_in_use);
1235
1236       if (initial_highest_arg_in_use)
1237         bcopy (initial_stack_usage_map, stack_usage_map,
1238                initial_highest_arg_in_use);
1239
1240       if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
1241         bzero (&stack_usage_map[initial_highest_arg_in_use],
1242                highest_outgoing_arg_in_use - initial_highest_arg_in_use);
1243       needed = 0;
1244
1245       /* The address of the outgoing argument list must not be copied to a
1246          register here, because argblock would be left pointing to the
1247          wrong place after the call to allocate_dynamic_stack_space below. */
1248
1249       argblock = virtual_outgoing_args_rtx;
1250
1251 #else /* not ACCUMULATE_OUTGOING_ARGS */
1252       if (inhibit_defer_pop == 0)
1253         {
1254           /* Try to reuse some or all of the pending_stack_adjust
1255              to get this space.  Maybe we can avoid any pushing.  */
1256           if (needed > pending_stack_adjust)
1257             {
1258               needed -= pending_stack_adjust;
1259               pending_stack_adjust = 0;
1260             }
1261           else
1262             {
1263               pending_stack_adjust -= needed;
1264               needed = 0;
1265             }
1266         }
1267       /* Special case this because overhead of `push_block' in this
1268          case is non-trivial.  */
1269       if (needed == 0)
1270         argblock = virtual_outgoing_args_rtx;
1271       else
1272         argblock = push_block (GEN_INT (needed), 0, 0);
1273
1274       /* We only really need to call `copy_to_reg' in the case where push
1275          insns are going to be used to pass ARGBLOCK to a function
1276          call in ARGS.  In that case, the stack pointer changes value
1277          from the allocation point to the call point, and hence
1278          the value of VIRTUAL_OUTGOING_ARGS_RTX changes as well.
1279          But might as well always do it.  */
1280       argblock = copy_to_reg (argblock);
1281 #endif /* not ACCUMULATE_OUTGOING_ARGS */
1282     }
1283
1284
1285 #ifdef ACCUMULATE_OUTGOING_ARGS
1286   /* The save/restore code in store_one_arg handles all cases except one:
1287      a constructor call (including a C function returning a BLKmode struct)
1288      to initialize an argument.  */
1289   if (stack_arg_under_construction)
1290     {
1291 #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
1292       rtx push_size = GEN_INT (reg_parm_stack_space + args_size.constant);
1293 #else
1294       rtx push_size = GEN_INT (args_size.constant);
1295 #endif
1296       if (old_stack_level == 0)
1297         {
1298           emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1299           old_pending_adj = pending_stack_adjust;
1300           pending_stack_adjust = 0;
1301           /* stack_arg_under_construction says whether a stack arg is
1302              being constructed at the old stack level.  Pushing the stack
1303              gets a clean outgoing argument block.  */
1304           old_stack_arg_under_construction = stack_arg_under_construction;
1305           stack_arg_under_construction = 0;
1306           /* Make a new map for the new argument list.  */
1307           stack_usage_map = (char *)alloca (highest_outgoing_arg_in_use);
1308           bzero (stack_usage_map, highest_outgoing_arg_in_use);
1309           highest_outgoing_arg_in_use = 0;
1310         }
1311       allocate_dynamic_stack_space (push_size, NULL_RTX, BITS_PER_UNIT);
1312     }
1313   /* If argument evaluation might modify the stack pointer, copy the
1314      address of the argument list to a register.  */
1315   for (i = 0; i < num_actuals; i++)
1316     if (args[i].pass_on_stack)
1317       {
1318         argblock = copy_addr_to_reg (argblock);
1319         break;
1320       }
1321 #endif
1322
1323
1324   /* If we preallocated stack space, compute the address of each argument.
1325      We need not ensure it is a valid memory address here; it will be
1326      validized when it is used.  */
1327   if (argblock)
1328     {
1329       rtx arg_reg = argblock;
1330       int arg_offset = 0;
1331
1332       if (GET_CODE (argblock) == PLUS)
1333         arg_reg = XEXP (argblock, 0), arg_offset = INTVAL (XEXP (argblock, 1));
1334
1335       for (i = 0; i < num_actuals; i++)
1336         {
1337           rtx offset = ARGS_SIZE_RTX (args[i].offset);
1338           rtx slot_offset = ARGS_SIZE_RTX (args[i].slot_offset);
1339           rtx addr;
1340
1341           /* Skip this parm if it will not be passed on the stack.  */
1342           if (! args[i].pass_on_stack && args[i].reg != 0)
1343             continue;
1344
1345           if (GET_CODE (offset) == CONST_INT)
1346             addr = plus_constant (arg_reg, INTVAL (offset));
1347           else
1348             addr = gen_rtx (PLUS, Pmode, arg_reg, offset);
1349
1350           addr = plus_constant (addr, arg_offset);
1351           args[i].stack
1352             = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (args[i].tree_value)), addr);
1353
1354           if (GET_CODE (slot_offset) == CONST_INT)
1355             addr = plus_constant (arg_reg, INTVAL (slot_offset));
1356           else
1357             addr = gen_rtx (PLUS, Pmode, arg_reg, slot_offset);
1358
1359           addr = plus_constant (addr, arg_offset);
1360           args[i].stack_slot
1361             = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (args[i].tree_value)), addr);
1362         }
1363     }
1364
1365 #ifdef PUSH_ARGS_REVERSED
1366 #ifdef STACK_BOUNDARY
1367   /* If we push args individually in reverse order, perform stack alignment
1368      before the first push (the last arg).  */
1369   if (argblock == 0)
1370     anti_adjust_stack (GEN_INT (args_size.constant
1371                                 - original_args_size.constant));
1372 #endif
1373 #endif
1374
1375   /* Don't try to defer pops if preallocating, not even from the first arg,
1376      since ARGBLOCK probably refers to the SP.  */
1377   if (argblock)
1378     NO_DEFER_POP;
1379
1380   /* Get the function to call, in the form of RTL.  */
1381   if (fndecl)
1382     /* Get a SYMBOL_REF rtx for the function address.  */
1383     funexp = XEXP (DECL_RTL (fndecl), 0);
1384   else
1385     /* Generate an rtx (probably a pseudo-register) for the address.  */
1386     {
1387       funexp = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
1388       free_temp_slots ();       /* FUNEXP can't be BLKmode */
1389       emit_queue ();
1390     }
1391
1392   /* Figure out the register where the value, if any, will come back.  */
1393   valreg = 0;
1394   if (TYPE_MODE (TREE_TYPE (exp)) != VOIDmode
1395       && ! structure_value_addr)
1396     {
1397       if (pcc_struct_value)
1398         valreg = hard_function_value (build_pointer_type (TREE_TYPE (exp)),
1399                                       fndecl);
1400       else
1401         valreg = hard_function_value (TREE_TYPE (exp), fndecl);
1402     }
1403
1404   /* Precompute all register parameters.  It isn't safe to compute anything
1405      once we have started filling any specific hard regs. */
1406   reg_parm_seen = 0;
1407   for (i = 0; i < num_actuals; i++)
1408     if (args[i].reg != 0 && ! args[i].pass_on_stack)
1409       {
1410         enum machine_mode mode;
1411
1412         reg_parm_seen = 1;
1413
1414         if (args[i].value == 0)
1415           {
1416             args[i].value = expand_expr (args[i].tree_value, NULL_RTX,
1417                                          VOIDmode, 0);
1418             preserve_temp_slots (args[i].value);
1419             free_temp_slots ();
1420
1421             /* ANSI doesn't require a sequence point here,
1422                but PCC has one, so this will avoid some problems.  */
1423             emit_queue ();
1424           }
1425
1426         /* If we are to promote the function arg to a wider mode,
1427            do it now.  */
1428         mode = (GET_CODE (args[i].reg) == EXPR_LIST
1429                 ? GET_MODE (XEXP (args[i].reg, 0)) : GET_MODE (args[i].reg));
1430
1431         if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) != mode)
1432           args[i].value = convert_to_mode (mode, args[i].value,
1433                                            args[i].unsignedp);
1434       }
1435
1436 #if defined(ACCUMULATE_OUTGOING_ARGS) && defined(REG_PARM_STACK_SPACE)
1437   /* The argument list is the property of the called routine and it
1438      may clobber it.  If the fixed area has been used for previous
1439      parameters, we must save and restore it.
1440
1441      Here we compute the boundary of the that needs to be saved, if any.  */
1442
1443 #ifdef ARGS_GROW_DOWNWARD
1444   for (i = 0; i < reg_parm_stack_space + 1; i++)
1445 #else
1446   for (i = 0; i < reg_parm_stack_space; i++)
1447 #endif
1448     {
1449       if (i >=  highest_outgoing_arg_in_use
1450           || stack_usage_map[i] == 0)
1451         continue;
1452
1453       if (low_to_save == -1)
1454         low_to_save = i;
1455
1456       high_to_save = i;
1457     }
1458
1459   if (low_to_save >= 0)
1460     {
1461       int num_to_save = high_to_save - low_to_save + 1;
1462       enum machine_mode save_mode
1463         = mode_for_size (num_to_save * BITS_PER_UNIT, MODE_INT, 1);
1464       rtx stack_area;
1465
1466       /* If we don't have the required alignment, must do this in BLKmode.  */
1467       if ((low_to_save & (MIN (GET_MODE_SIZE (save_mode),
1468                                BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1)))
1469         save_mode = BLKmode;
1470
1471       stack_area = gen_rtx (MEM, save_mode,
1472                             memory_address (save_mode,
1473
1474 #ifdef ARGS_GROW_DOWNWARD
1475                                             plus_constant (argblock,
1476                                                            - high_to_save)
1477 #else
1478                                             plus_constant (argblock,
1479                                                            low_to_save)
1480 #endif
1481                                             ));
1482       if (save_mode == BLKmode)
1483         {
1484           save_area = assign_stack_temp (BLKmode, num_to_save, 1);
1485           emit_block_move (validize_mem (save_area), stack_area,
1486                            GEN_INT (num_to_save),
1487                            PARM_BOUNDARY / BITS_PER_UNIT);
1488         }
1489       else
1490         {
1491           save_area = gen_reg_rtx (save_mode);
1492           emit_move_insn (save_area, stack_area);
1493         }
1494     }
1495 #endif
1496
1497
1498   /* Now store (and compute if necessary) all non-register parms.
1499      These come before register parms, since they can require block-moves,
1500      which could clobber the registers used for register parms.
1501      Parms which have partial registers are not stored here,
1502      but we do preallocate space here if they want that.  */
1503
1504   for (i = 0; i < num_actuals; i++)
1505     if (args[i].reg == 0 || args[i].pass_on_stack)
1506       store_one_arg (&args[i], argblock, may_be_alloca,
1507                      args_size.var != 0, fndecl, reg_parm_stack_space);
1508
1509   /* Now store any partially-in-registers parm.
1510      This is the last place a block-move can happen.  */
1511   if (reg_parm_seen)
1512     for (i = 0; i < num_actuals; i++)
1513       if (args[i].partial != 0 && ! args[i].pass_on_stack)
1514         store_one_arg (&args[i], argblock, may_be_alloca,
1515                        args_size.var != 0, fndecl, reg_parm_stack_space);
1516
1517 #ifndef PUSH_ARGS_REVERSED
1518 #ifdef STACK_BOUNDARY
1519   /* If we pushed args in forward order, perform stack alignment
1520      after pushing the last arg.  */
1521   if (argblock == 0)
1522     anti_adjust_stack (GEN_INT (args_size.constant
1523                                 - original_args_size.constant));
1524 #endif
1525 #endif
1526
1527   /* If register arguments require space on the stack and stack space
1528      was not preallocated, allocate stack space here for arguments
1529      passed in registers.  */
1530 #if ! defined(ALLOCATE_OUTGOING_ARGS) && defined(OUTGOING_REG_PARM_STACK_SPACE)
1531   if (must_preallocate == 0 && reg_parm_stack_space > 0)
1532     anti_adjust_stack (GEN_INT (reg_parm_stack_space));
1533 #endif
1534
1535   /* Pass the function the address in which to return a structure value.  */
1536   if (structure_value_addr && ! structure_value_addr_parm)
1537     {
1538       emit_move_insn (struct_value_rtx,
1539                       force_reg (Pmode,
1540                                  force_operand (structure_value_addr,
1541                                                 NULL_RTX)));
1542       if (GET_CODE (struct_value_rtx) == REG)
1543         {
1544           push_to_sequence (use_insns);
1545           emit_insn (gen_rtx (USE, VOIDmode, struct_value_rtx));
1546           use_insns = get_insns ();
1547           end_sequence ();
1548         }
1549     }
1550
1551   /* Now do the register loads required for any wholly-register parms or any
1552      parms which are passed both on the stack and in a register.  Their
1553      expressions were already evaluated.
1554
1555      Mark all register-parms as living through the call, putting these USE
1556      insns in a list headed by USE_INSNS.  */
1557
1558   for (i = 0; i < num_actuals; i++)
1559     {
1560       rtx list = args[i].reg;
1561       int partial = args[i].partial;
1562
1563       while (list)
1564         {
1565           rtx reg;
1566           int nregs;
1567
1568           /* Process each register that needs to get this arg.  */
1569           if (GET_CODE (list) == EXPR_LIST)
1570             reg = XEXP (list, 0), list = XEXP (list, 1);
1571           else
1572             reg = list, list = 0;
1573
1574           /* Set to non-zero if must move a word at a time, even if just one
1575              word (e.g, partial == 1 && mode == DFmode).  Set to zero if
1576              we just use a normal move insn.  */
1577           nregs = (partial ? partial
1578                    : (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
1579                       ? ((int_size_in_bytes (TREE_TYPE (args[i].tree_value))
1580                           + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
1581                       : 0));
1582
1583           /* If simple case, just do move.  If normal partial, store_one_arg
1584              has already loaded the register for us.  In all other cases,
1585              load the register(s) from memory.  */
1586
1587           if (nregs == 0)
1588             emit_move_insn (reg, args[i].value);
1589           else if (args[i].partial == 0 || args[i].pass_on_stack)
1590             move_block_to_reg (REGNO (reg),
1591                                validize_mem (args[i].value), nregs,
1592                                TYPE_MODE (TREE_TYPE (args[i].tree_value)));
1593
1594           push_to_sequence (use_insns);
1595           if (nregs == 0)
1596             emit_insn (gen_rtx (USE, VOIDmode, reg));
1597           else
1598             use_regs (REGNO (reg), nregs);
1599           use_insns = get_insns ();
1600           end_sequence ();
1601
1602           /* PARTIAL referred only to the first register, so clear it for the
1603              next time.  */
1604           partial = 0;
1605         }
1606     }
1607
1608   /* Perform postincrements before actually calling the function.  */
1609   emit_queue ();
1610
1611   /* All arguments and registers used for the call must be set up by now!  */
1612
1613   funexp = prepare_call_address (funexp, fndecl, &use_insns);
1614
1615   /* Generate the actual call instruction.  */
1616   emit_call_1 (funexp, funtype, args_size.constant, struct_value_size,
1617                FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
1618                valreg, old_inhibit_defer_pop, use_insns, is_const);
1619
1620   /* If call is cse'able, make appropriate pair of reg-notes around it.
1621      Test valreg so we don't crash; may safely ignore `const'
1622      if return type is void.  */
1623   if (is_const && valreg != 0)
1624     {
1625       rtx note = 0;
1626       rtx temp = gen_reg_rtx (GET_MODE (valreg));
1627       rtx insns;
1628
1629       /* Construct an "equal form" for the value which mentions all the
1630          arguments in order as well as the function name.  */
1631 #ifdef PUSH_ARGS_REVERSED
1632       for (i = 0; i < num_actuals; i++)
1633         note = gen_rtx (EXPR_LIST, VOIDmode, args[i].initial_value, note);
1634 #else
1635       for (i = num_actuals - 1; i >= 0; i--)
1636         note = gen_rtx (EXPR_LIST, VOIDmode, args[i].initial_value, note);
1637 #endif
1638       note = gen_rtx (EXPR_LIST, VOIDmode, funexp, note);
1639
1640       insns = get_insns ();
1641       end_sequence ();
1642
1643       emit_libcall_block (insns, temp, valreg, note);
1644
1645       valreg = temp;
1646     }
1647
1648   /* For calls to `setjmp', etc., inform flow.c it should complain
1649      if nonvolatile values are live.  */
1650
1651   if (returns_twice)
1652     {
1653       emit_note (name, NOTE_INSN_SETJMP);
1654       current_function_calls_setjmp = 1;
1655     }
1656
1657   if (is_longjmp)
1658     current_function_calls_longjmp = 1;
1659
1660   /* Notice functions that cannot return.
1661      If optimizing, insns emitted below will be dead.
1662      If not optimizing, they will exist, which is useful
1663      if the user uses the `return' command in the debugger.  */
1664
1665   if (is_volatile || is_longjmp)
1666     emit_barrier ();
1667
1668   /* If value type not void, return an rtx for the value.  */
1669
1670   /* If there are cleanups to be called, don't use a hard reg as target.  */
1671   if (cleanups_this_call != old_cleanups
1672       && target && REG_P (target)
1673       && REGNO (target) < FIRST_PSEUDO_REGISTER)
1674     target = 0;
1675
1676   if (TYPE_MODE (TREE_TYPE (exp)) == VOIDmode
1677       || ignore)
1678     {
1679       target = const0_rtx;
1680     }
1681   else if (structure_value_addr)
1682     {
1683       if (target == 0 || GET_CODE (target) != MEM)
1684         {
1685           target = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)),
1686                             memory_address (TYPE_MODE (TREE_TYPE (exp)),
1687                                             structure_value_addr));
1688           MEM_IN_STRUCT_P (target)
1689             = (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
1690                || TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
1691                || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE);
1692         }
1693     }
1694   else if (pcc_struct_value)
1695     {
1696       if (target == 0)
1697         {
1698           target = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)),
1699                             copy_to_reg (valreg));
1700           MEM_IN_STRUCT_P (target)
1701             = (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
1702                || TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
1703                || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE);
1704         }
1705       else if (TYPE_MODE (TREE_TYPE (exp)) != BLKmode)
1706         emit_move_insn (target, gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)),
1707                                          copy_to_reg (valreg)));
1708       else
1709         emit_block_move (target, gen_rtx (MEM, BLKmode, copy_to_reg (valreg)),
1710                          expr_size (exp),
1711                          TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT);
1712     }
1713   else if (target && GET_MODE (target) == TYPE_MODE (TREE_TYPE (exp))
1714            && GET_MODE (target) == GET_MODE (valreg))
1715     /* TARGET and VALREG cannot be equal at this point because the latter
1716        would not have REG_FUNCTION_VALUE_P true, while the former would if
1717        it were referring to the same register.
1718
1719        If they refer to the same register, this move will be a no-op, except
1720        when function inlining is being done.  */
1721     emit_move_insn (target, valreg);
1722   else
1723     target = copy_to_reg (valreg);
1724
1725 #ifdef PROMOTE_FUNCTION_RETURN
1726   /* If we promoted this return value, make the proper SUBREG.  */
1727   if (GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
1728     {
1729       enum machine_mode mode = GET_MODE (target);
1730       int unsignedp = TREE_UNSIGNED (TREE_TYPE (exp));
1731
1732       if (TREE_CODE (TREE_TYPE (exp)) == INTEGER_TYPE
1733           || TREE_CODE (TREE_TYPE (exp)) == ENUMERAL_TYPE
1734           || TREE_CODE (TREE_TYPE (exp)) == BOOLEAN_TYPE
1735           || TREE_CODE (TREE_TYPE (exp)) == CHAR_TYPE
1736           || TREE_CODE (TREE_TYPE (exp)) == REAL_TYPE
1737           || TREE_CODE (TREE_TYPE (exp)) == POINTER_TYPE
1738           || TREE_CODE (TREE_TYPE (exp)) == OFFSET_TYPE)
1739         {
1740           PROMOTE_MODE (mode, unsignedp, TREE_TYPE (exp));
1741         }
1742
1743       target = gen_rtx (SUBREG, TYPE_MODE (TREE_TYPE (exp)), target, 0);
1744       SUBREG_PROMOTED_VAR_P (target) = 1;
1745       SUBREG_PROMOTED_UNSIGNED_P (target) = unsignedp;
1746     }
1747 #endif
1748
1749   /* Perform all cleanups needed for the arguments of this call
1750      (i.e. destructors in C++).  */
1751   expand_cleanups_to (old_cleanups);
1752
1753   /* If size of args is variable or this was a constructor call for a stack
1754      argument, restore saved stack-pointer value.  */
1755
1756   if (old_stack_level)
1757     {
1758       emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1759       pending_stack_adjust = old_pending_adj;
1760 #ifdef ACCUMULATE_OUTGOING_ARGS
1761       stack_arg_under_construction = old_stack_arg_under_construction;
1762       highest_outgoing_arg_in_use = initial_highest_arg_in_use;
1763       stack_usage_map = initial_stack_usage_map;
1764 #endif
1765     }
1766 #ifdef ACCUMULATE_OUTGOING_ARGS
1767   else
1768     {
1769 #ifdef REG_PARM_STACK_SPACE
1770       if (save_area)
1771         {
1772           enum machine_mode save_mode = GET_MODE (save_area);
1773           rtx stack_area
1774             = gen_rtx (MEM, save_mode,
1775                        memory_address (save_mode,
1776 #ifdef ARGS_GROW_DOWNWARD
1777                                        plus_constant (argblock, - high_to_save)
1778 #else
1779                                        plus_constant (argblock, low_to_save)
1780 #endif
1781                                        ));
1782
1783           if (save_mode != BLKmode)
1784             emit_move_insn (stack_area, save_area);
1785           else
1786             emit_block_move (stack_area, validize_mem (save_area),
1787                              GEN_INT (high_to_save - low_to_save + 1),
1788                              PARM_BOUNDARY / BITS_PER_UNIT);
1789         }
1790 #endif
1791
1792       /* If we saved any argument areas, restore them.  */
1793       for (i = 0; i < num_actuals; i++)
1794         if (args[i].save_area)
1795           {
1796             enum machine_mode save_mode = GET_MODE (args[i].save_area);
1797             rtx stack_area
1798               = gen_rtx (MEM, save_mode,
1799                          memory_address (save_mode,
1800                                          XEXP (args[i].stack_slot, 0)));
1801
1802             if (save_mode != BLKmode)
1803               emit_move_insn (stack_area, args[i].save_area);
1804             else
1805               emit_block_move (stack_area, validize_mem (args[i].save_area),
1806                                GEN_INT (args[i].size.constant),
1807                                PARM_BOUNDARY / BITS_PER_UNIT);
1808           }
1809
1810       highest_outgoing_arg_in_use = initial_highest_arg_in_use;
1811       stack_usage_map = initial_stack_usage_map;
1812     }
1813 #endif
1814
1815   /* If this was alloca, record the new stack level for nonlocal gotos.
1816      Check for the handler slots since we might not have a save area
1817      for non-local gotos. */
1818
1819   if (may_be_alloca && nonlocal_goto_handler_slot != 0)
1820     emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
1821
1822   pop_temp_slots ();
1823
1824   return target;
1825 }
1826 \f
1827 #if 0
1828 /* Return an rtx which represents a suitable home on the stack
1829    given TYPE, the type of the argument looking for a home.
1830    This is called only for BLKmode arguments.
1831
1832    SIZE is the size needed for this target.
1833    ARGS_ADDR is the address of the bottom of the argument block for this call.
1834    OFFSET describes this parameter's offset into ARGS_ADDR.  It is meaningless
1835    if this machine uses push insns.  */
1836
1837 static rtx
1838 target_for_arg (type, size, args_addr, offset)
1839      tree type;
1840      rtx size;
1841      rtx args_addr;
1842      struct args_size offset;
1843 {
1844   rtx target;
1845   rtx offset_rtx = ARGS_SIZE_RTX (offset);
1846
1847   /* We do not call memory_address if possible,
1848      because we want to address as close to the stack
1849      as possible.  For non-variable sized arguments,
1850      this will be stack-pointer relative addressing.  */
1851   if (GET_CODE (offset_rtx) == CONST_INT)
1852     target = plus_constant (args_addr, INTVAL (offset_rtx));
1853   else
1854     {
1855       /* I have no idea how to guarantee that this
1856          will work in the presence of register parameters.  */
1857       target = gen_rtx (PLUS, Pmode, args_addr, offset_rtx);
1858       target = memory_address (QImode, target);
1859     }
1860
1861   return gen_rtx (MEM, BLKmode, target);
1862 }
1863 #endif
1864 \f
1865 /* Store a single argument for a function call
1866    into the register or memory area where it must be passed.
1867    *ARG describes the argument value and where to pass it.
1868
1869    ARGBLOCK is the address of the stack-block for all the arguments,
1870    or 0 on a machine where arguments are pushed individually.
1871
1872    MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
1873    so must be careful about how the stack is used.
1874
1875    VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
1876    argument stack.  This is used if ACCUMULATE_OUTGOING_ARGS to indicate
1877    that we need not worry about saving and restoring the stack.
1878
1879    FNDECL is the declaration of the function we are calling.  */
1880
1881 static void
1882 store_one_arg (arg, argblock, may_be_alloca, variable_size, fndecl,
1883                reg_parm_stack_space)
1884      struct arg_data *arg;
1885      rtx argblock;
1886      int may_be_alloca;
1887      int variable_size;
1888      tree fndecl;
1889      int reg_parm_stack_space;
1890 {
1891   register tree pval = arg->tree_value;
1892   rtx reg = 0;
1893   int partial = 0;
1894   int used = 0;
1895   int i, lower_bound, upper_bound;
1896
1897   if (TREE_CODE (pval) == ERROR_MARK)
1898     return;
1899
1900 #ifdef ACCUMULATE_OUTGOING_ARGS
1901   /* If this is being stored into a pre-allocated, fixed-size, stack area,
1902      save any previous data at that location.  */
1903   if (argblock && ! variable_size && arg->stack)
1904     {
1905 #ifdef ARGS_GROW_DOWNWARD
1906       /* stack_slot is negative, but we want to index stack_usage_map */
1907       /* with positive values. */
1908       if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
1909         upper_bound = -INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1)) + 1;
1910       else
1911         abort ();
1912
1913       lower_bound = upper_bound - arg->size.constant;
1914 #else
1915       if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
1916         lower_bound = INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1));
1917       else
1918         lower_bound = 0;
1919
1920       upper_bound = lower_bound + arg->size.constant;
1921 #endif
1922
1923       for (i = lower_bound; i < upper_bound; i++)
1924         if (stack_usage_map[i]
1925 #ifdef REG_PARM_STACK_SPACE
1926             /* Don't store things in the fixed argument area at this point;
1927                it has already been saved.  */
1928             && i > reg_parm_stack_space
1929 #endif
1930             )
1931           break;
1932
1933       if (i != upper_bound)
1934         {
1935           /* We need to make a save area.  See what mode we can make it.  */
1936           enum machine_mode save_mode
1937             = mode_for_size (arg->size.constant * BITS_PER_UNIT, MODE_INT, 1);
1938           rtx stack_area
1939             = gen_rtx (MEM, save_mode,
1940                        memory_address (save_mode, XEXP (arg->stack_slot, 0)));
1941
1942           if (save_mode == BLKmode)
1943             {
1944               arg->save_area = assign_stack_temp (BLKmode,
1945                                                   arg->size.constant, 1);
1946               emit_block_move (validize_mem (arg->save_area), stack_area,
1947                                GEN_INT (arg->size.constant),
1948                                PARM_BOUNDARY / BITS_PER_UNIT);
1949             }
1950           else
1951             {
1952               arg->save_area = gen_reg_rtx (save_mode);
1953               emit_move_insn (arg->save_area, stack_area);
1954             }
1955         }
1956     }
1957 #endif
1958
1959   /* If this isn't going to be placed on both the stack and in registers,
1960      set up the register and number of words.  */
1961   if (! arg->pass_on_stack)
1962     reg = arg->reg, partial = arg->partial;
1963
1964   if (reg != 0 && partial == 0)
1965     /* Being passed entirely in a register.  We shouldn't be called in
1966        this case.   */
1967     abort ();
1968
1969   /* If this is being partially passed in a register, but multiple locations
1970      are specified, we assume that the one partially used is the one that is
1971      listed first.  */
1972   if (reg && GET_CODE (reg) == EXPR_LIST)
1973     reg = XEXP (reg, 0);
1974
1975   /* If this is being passes partially in a register, we can't evaluate
1976      it directly into its stack slot.  Otherwise, we can.  */
1977   if (arg->value == 0)
1978     {
1979 #ifdef ACCUMULATE_OUTGOING_ARGS
1980       /* stack_arg_under_construction is nonzero if a function argument is
1981          being evaluated directly into the outgoing argument list and
1982          expand_call must take special action to preserve the argument list
1983          if it is called recursively.
1984
1985          For scalar function arguments stack_usage_map is sufficient to
1986          determine which stack slots must be saved and restored.  Scalar
1987          arguments in general have pass_on_stack == 0.
1988
1989          If this argument is initialized by a function which takes the
1990          address of the argument (a C++ constructor or a C function
1991          returning a BLKmode structure), then stack_usage_map is
1992          insufficient and expand_call must push the stack around the
1993          function call.  Such arguments have pass_on_stack == 1.
1994
1995          Note that it is always safe to set stack_arg_under_construction,
1996          but this generates suboptimal code if set when not needed.  */
1997
1998       if (arg->pass_on_stack)
1999         stack_arg_under_construction++;
2000 #endif
2001       arg->value = expand_expr (pval, partial ? NULL_RTX : arg->stack,
2002                                 VOIDmode, 0);
2003 #ifdef ACCUMULATE_OUTGOING_ARGS
2004       if (arg->pass_on_stack)
2005         stack_arg_under_construction--;
2006 #endif
2007     }
2008
2009   /* Don't allow anything left on stack from computation
2010      of argument to alloca.  */
2011   if (may_be_alloca)
2012     do_pending_stack_adjust ();
2013
2014   if (arg->value == arg->stack)
2015     /* If the value is already in the stack slot, we are done.  */
2016     ;
2017   else if (TYPE_MODE (TREE_TYPE (pval)) != BLKmode)
2018     {
2019       register int size;
2020
2021       /* Argument is a scalar, not entirely passed in registers.
2022          (If part is passed in registers, arg->partial says how much
2023          and emit_push_insn will take care of putting it there.)
2024
2025          Push it, and if its size is less than the
2026          amount of space allocated to it,
2027          also bump stack pointer by the additional space.
2028          Note that in C the default argument promotions
2029          will prevent such mismatches.  */
2030
2031       size = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (pval)));
2032       /* Compute how much space the push instruction will push.
2033          On many machines, pushing a byte will advance the stack
2034          pointer by a halfword.  */
2035 #ifdef PUSH_ROUNDING
2036       size = PUSH_ROUNDING (size);
2037 #endif
2038       used = size;
2039
2040       /* Compute how much space the argument should get:
2041          round up to a multiple of the alignment for arguments.  */
2042       if (none != FUNCTION_ARG_PADDING (TYPE_MODE (TREE_TYPE (pval)),
2043                                         TREE_TYPE (pval)))
2044         used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1)
2045                  / (PARM_BOUNDARY / BITS_PER_UNIT))
2046                 * (PARM_BOUNDARY / BITS_PER_UNIT));
2047
2048       /* This isn't already where we want it on the stack, so put it there.
2049          This can either be done with push or copy insns.  */
2050       emit_push_insn (arg->value, TYPE_MODE (TREE_TYPE (pval)),
2051                       TREE_TYPE (pval), 0, 0, partial, reg,
2052                       used - size, argblock, ARGS_SIZE_RTX (arg->offset));
2053     }
2054   else
2055     {
2056       /* BLKmode, at least partly to be pushed.  */
2057
2058       register int excess;
2059       rtx size_rtx;
2060
2061       /* Pushing a nonscalar.
2062          If part is passed in registers, PARTIAL says how much
2063          and emit_push_insn will take care of putting it there.  */
2064
2065       /* Round its size up to a multiple
2066          of the allocation unit for arguments.  */
2067
2068       if (arg->size.var != 0)
2069         {
2070           excess = 0;
2071           size_rtx = ARGS_SIZE_RTX (arg->size);
2072         }
2073       else
2074         {
2075           register tree size = size_in_bytes (TREE_TYPE (pval));
2076           /* PUSH_ROUNDING has no effect on us, because
2077              emit_push_insn for BLKmode is careful to avoid it.  */
2078           excess = (arg->size.constant - TREE_INT_CST_LOW (size)
2079                     + partial * UNITS_PER_WORD);
2080           size_rtx = expand_expr (size, NULL_RTX, VOIDmode, 0);
2081         }
2082
2083       emit_push_insn (arg->value, TYPE_MODE (TREE_TYPE (pval)),
2084                       TREE_TYPE (pval), size_rtx,
2085                       TYPE_ALIGN (TREE_TYPE (pval)) / BITS_PER_UNIT, partial,
2086                       reg, excess, argblock, ARGS_SIZE_RTX (arg->offset));
2087     }
2088
2089
2090   /* Unless this is a partially-in-register argument, the argument is now
2091      in the stack.
2092
2093      ??? Note that this can change arg->value from arg->stack to
2094      arg->stack_slot and it matters when they are not the same.
2095      It isn't totally clear that this is correct in all cases.  */
2096   if (partial == 0)
2097     arg->value = arg->stack_slot;
2098
2099   /* Once we have pushed something, pops can't safely
2100      be deferred during the rest of the arguments.  */
2101   NO_DEFER_POP;
2102
2103   /* ANSI doesn't require a sequence point here,
2104      but PCC has one, so this will avoid some problems.  */
2105   emit_queue ();
2106
2107   /* Free any temporary slots made in processing this argument.  */
2108   free_temp_slots ();
2109
2110 #ifdef ACCUMULATE_OUTGOING_ARGS
2111   /* Now mark the segment we just used.  */
2112   if (argblock && ! variable_size && arg->stack)
2113     for (i = lower_bound; i < upper_bound; i++)
2114       stack_usage_map[i] = 1;
2115 #endif
2116 }