home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 7 / FreshFishVol7.bin / bbs / gnu / gcc-2.3.3-src.lha / GNU / src / amiga / gcc-2.3.3 / calls.c < prev    next >
C/C++ Source or Header  |  1994-02-06  |  69KB  |  2,114 lines
  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.  
  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.  
  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_PTR);
  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.       int size = int_size_in_bytes (type);
  890.       rtx copy;
  891.  
  892.       if (size < 0)
  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.         copy = assign_stack_temp (TYPE_MODE (type), size, 1);
  912.  
  913.       store_expr (args[i].tree_value, copy, 0);
  914.  
  915.       args[i].tree_value = build1 (ADDR_EXPR, build_pointer_type (type),
  916.                        make_tree (type, copy));
  917.       type = build_pointer_type (type);
  918.     }
  919. #endif
  920.  
  921.       mode = TYPE_MODE (type);
  922.  
  923. #ifdef PROMOTE_FUNCTION_ARGS
  924.       /* Compute the mode in which the arg is actually to be extended to.  */
  925.       if (TREE_CODE (type) == INTEGER_TYPE || TREE_CODE (type) == ENUMERAL_TYPE
  926.       || TREE_CODE (type) == BOOLEAN_TYPE || TREE_CODE (type) == CHAR_TYPE
  927.       || TREE_CODE (type) == REAL_TYPE || TREE_CODE (type) == POINTER_TYPE
  928.       || TREE_CODE (type) == OFFSET_TYPE)
  929.     {
  930.       int unsignedp = TREE_UNSIGNED (type);
  931.       PROMOTE_MODE (mode, unsignedp, type);
  932.       args[i].unsignedp = unsignedp;
  933.     }
  934. #endif
  935.  
  936.       args[i].reg = FUNCTION_ARG (args_so_far, mode, type,
  937.                   argpos < n_named_args);
  938. #ifdef FUNCTION_ARG_PARTIAL_NREGS
  939.       if (args[i].reg)
  940.     args[i].partial
  941.       = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, type,
  942.                     argpos < n_named_args);
  943. #endif
  944.  
  945.       args[i].pass_on_stack = MUST_PASS_IN_STACK (mode, type);
  946.  
  947.       /* If FUNCTION_ARG returned an (expr_list (nil) FOO), it means that
  948.      we are to pass this arg in the register(s) designated by FOO, but
  949.      also to pass it in the stack.  */
  950.       if (args[i].reg && GET_CODE (args[i].reg) == EXPR_LIST
  951.       && XEXP (args[i].reg, 0) == 0)
  952.     args[i].pass_on_stack = 1, args[i].reg = XEXP (args[i].reg, 1);
  953.  
  954.       /* If this is an addressable type, we must preallocate the stack
  955.      since we must evaluate the object into its final location.
  956.  
  957.      If this is to be passed in both registers and the stack, it is simpler
  958.      to preallocate.  */
  959.       if (TREE_ADDRESSABLE (type)
  960.       || (args[i].pass_on_stack && args[i].reg != 0))
  961.     must_preallocate = 1;
  962.  
  963.       /* If this is an addressable type, we cannot pre-evaluate it.  Thus,
  964.      we cannot consider this function call constant.  */
  965.       if (TREE_ADDRESSABLE (type))
  966.     is_const = 0;
  967.  
  968.       /* Compute the stack-size of this argument.  */
  969.       if (args[i].reg == 0 || args[i].partial != 0
  970. #ifdef REG_PARM_STACK_SPACE
  971.       || reg_parm_stack_space > 0
  972. #endif
  973.       || args[i].pass_on_stack)
  974.     locate_and_pad_parm (TYPE_MODE (type), type,
  975. #ifdef STACK_PARMS_IN_REG_PARM_AREA
  976.                  1,
  977. #else
  978.                  args[i].reg != 0,
  979. #endif
  980.                  fndecl, &args_size, &args[i].offset,
  981.                  &args[i].size);
  982.  
  983. #ifndef ARGS_GROW_DOWNWARD
  984.       args[i].slot_offset = args_size;
  985. #endif
  986.  
  987. #ifndef REG_PARM_STACK_SPACE
  988.       /* If a part of the arg was put into registers,
  989.      don't include that part in the amount pushed.  */
  990.       if (! args[i].pass_on_stack)
  991.     args[i].size.constant -= ((args[i].partial * UNITS_PER_WORD)
  992.                   / (PARM_BOUNDARY / BITS_PER_UNIT)
  993.                   * (PARM_BOUNDARY / BITS_PER_UNIT));
  994. #endif
  995.       
  996.       /* Update ARGS_SIZE, the total stack space for args so far.  */
  997.  
  998.       args_size.constant += args[i].size.constant;
  999.       if (args[i].size.var)
  1000.     {
  1001.       ADD_PARM_SIZE (args_size, args[i].size.var);
  1002.     }
  1003.  
  1004.       /* Since the slot offset points to the bottom of the slot,
  1005.      we must record it after incrementing if the args grow down.  */
  1006. #ifdef ARGS_GROW_DOWNWARD
  1007.       args[i].slot_offset = args_size;
  1008.  
  1009.       args[i].slot_offset.constant = -args_size.constant;
  1010.       if (args_size.var)
  1011.     {
  1012.       SUB_PARM_SIZE (args[i].slot_offset, args_size.var);
  1013.     }
  1014. #endif
  1015.  
  1016.       /* Increment ARGS_SO_FAR, which has info about which arg-registers
  1017.      have been used, etc.  */
  1018.  
  1019.       FUNCTION_ARG_ADVANCE (args_so_far, TYPE_MODE (type), type,
  1020.                 argpos < n_named_args);
  1021.     }
  1022.  
  1023. #ifdef FINAL_REG_PARM_STACK_SPACE
  1024.   reg_parm_stack_space = FINAL_REG_PARM_STACK_SPACE (args_size.constant,
  1025.                              args_size.var);
  1026. #endif
  1027.       
  1028.   /* Compute the actual size of the argument block required.  The variable
  1029.      and constant sizes must be combined, the size may have to be rounded,
  1030.      and there may be a minimum required size.  */
  1031.  
  1032.   original_args_size = args_size;
  1033.   if (args_size.var)
  1034.     {
  1035.       /* If this function requires a variable-sized argument list, don't try to
  1036.      make a cse'able block for this call.  We may be able to do this
  1037.      eventually, but it is too complicated to keep track of what insns go
  1038.      in the cse'able block and which don't.  */
  1039.  
  1040.       is_const = 0;
  1041.       must_preallocate = 1;
  1042.  
  1043.       args_size.var = ARGS_SIZE_TREE (args_size);
  1044.       args_size.constant = 0;
  1045.  
  1046. #ifdef STACK_BOUNDARY
  1047.       if (STACK_BOUNDARY != BITS_PER_UNIT)
  1048.     args_size.var = round_up (args_size.var, STACK_BYTES);
  1049. #endif
  1050.  
  1051. #ifdef REG_PARM_STACK_SPACE
  1052.       if (reg_parm_stack_space > 0)
  1053.     {
  1054.       args_size.var
  1055.         = size_binop (MAX_EXPR, args_size.var,
  1056.               size_int (REG_PARM_STACK_SPACE (fndecl)));
  1057.  
  1058. #ifndef OUTGOING_REG_PARM_STACK_SPACE
  1059.       /* The area corresponding to register parameters is not to count in
  1060.          the size of the block we need.  So make the adjustment.  */
  1061.       args_size.var
  1062.         = size_binop (MINUS_EXPR, args_size.var,
  1063.               size_int (reg_parm_stack_space));
  1064. #endif
  1065.     }
  1066. #endif
  1067.     }
  1068.   else
  1069.     {
  1070. #ifdef STACK_BOUNDARY
  1071.       args_size.constant = (((args_size.constant + (STACK_BYTES - 1))
  1072.                  / STACK_BYTES) * STACK_BYTES);
  1073. #endif
  1074.  
  1075. #ifdef REG_PARM_STACK_SPACE
  1076.       args_size.constant = MAX (args_size.constant,
  1077.                 reg_parm_stack_space);
  1078. #ifndef OUTGOING_REG_PARM_STACK_SPACE
  1079.       args_size.constant -= reg_parm_stack_space;
  1080. #endif
  1081. #endif
  1082.     }
  1083.  
  1084.   /* See if we have or want to preallocate stack space.
  1085.  
  1086.      If we would have to push a partially-in-regs parm
  1087.      before other stack parms, preallocate stack space instead.
  1088.  
  1089.      If the size of some parm is not a multiple of the required stack
  1090.      alignment, we must preallocate.
  1091.  
  1092.      If the total size of arguments that would otherwise create a copy in
  1093.      a temporary (such as a CALL) is more than half the total argument list
  1094.      size, preallocation is faster.
  1095.  
  1096.      Another reason to preallocate is if we have a machine (like the m88k)
  1097.      where stack alignment is required to be maintained between every
  1098.      pair of insns, not just when the call is made.  However, we assume here
  1099.      that such machines either do not have push insns (and hence preallocation
  1100.      would occur anyway) or the problem is taken care of with
  1101.      PUSH_ROUNDING.  */
  1102.  
  1103.   if (! must_preallocate)
  1104.     {
  1105.       int partial_seen = 0;
  1106.       int copy_to_evaluate_size = 0;
  1107.  
  1108.       for (i = 0; i < num_actuals && ! must_preallocate; i++)
  1109.     {
  1110.       if (args[i].partial > 0 && ! args[i].pass_on_stack)
  1111.         partial_seen = 1;
  1112.       else if (partial_seen && args[i].reg == 0)
  1113.         must_preallocate = 1;
  1114.  
  1115.       if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
  1116.           && (TREE_CODE (args[i].tree_value) == CALL_EXPR
  1117.           || TREE_CODE (args[i].tree_value) == TARGET_EXPR
  1118.           || TREE_CODE (args[i].tree_value) == COND_EXPR
  1119.           || TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value))))
  1120.         copy_to_evaluate_size
  1121.           += int_size_in_bytes (TREE_TYPE (args[i].tree_value));
  1122.     }
  1123.  
  1124.       if (copy_to_evaluate_size * 2 >= args_size.constant
  1125.       && args_size.constant > 0)
  1126.     must_preallocate = 1;
  1127.     }
  1128.  
  1129.   /* If the structure value address will reference the stack pointer, we must
  1130.      stabilize it.  We don't need to do this if we know that we are not going
  1131.      to adjust the stack pointer in processing this call.  */
  1132.  
  1133.   if (structure_value_addr
  1134.       && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
  1135.        || reg_mentioned_p (virtual_outgoing_args_rtx, structure_value_addr))
  1136.       && (args_size.var
  1137. #ifndef ACCUMULATE_OUTGOING_ARGS
  1138.       || args_size.constant
  1139. #endif
  1140.       ))
  1141.     structure_value_addr = copy_to_reg (structure_value_addr);
  1142.  
  1143.   /* If this function call is cse'able, precompute all the parameters.
  1144.      Note that if the parameter is constructed into a temporary, this will
  1145.      cause an additional copy because the parameter will be constructed
  1146.      into a temporary location and then copied into the outgoing arguments.
  1147.      If a parameter contains a call to alloca and this function uses the
  1148.      stack, precompute the parameter.  */
  1149.  
  1150.   for (i = 0; i < num_actuals; i++)
  1151.     if (is_const
  1152.     || ((args_size.var != 0 || args_size.constant != 0)
  1153.         && calls_alloca (args[i].tree_value)))
  1154.       {
  1155.     args[i].initial_value = args[i].value
  1156.       = expand_expr (args[i].tree_value, NULL_RTX, VOIDmode, 0);
  1157.     preserve_temp_slots (args[i].value);
  1158.     free_temp_slots ();
  1159.  
  1160.     /* ANSI doesn't require a sequence point here,
  1161.        but PCC has one, so this will avoid some problems.  */
  1162.     emit_queue ();
  1163.       }
  1164.  
  1165.   /* Now we are about to start emitting insns that can be deleted
  1166.      if a libcall is deleted.  */
  1167.   if (is_const)
  1168.     start_sequence ();
  1169.  
  1170.   /* If we have no actual push instructions, or shouldn't use them,
  1171.      make space for all args right now.  */
  1172.  
  1173.   if (args_size.var != 0)
  1174.     {
  1175.       if (old_stack_level == 0)
  1176.     {
  1177.       emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
  1178.       old_pending_adj = pending_stack_adjust;
  1179.       pending_stack_adjust = 0;
  1180. #ifdef ACCUMULATE_OUTGOING_ARGS
  1181.       /* stack_arg_under_construction says whether a stack arg is
  1182.          being constructed at the old stack level.  Pushing the stack
  1183.          gets a clean outgoing argument block.  */
  1184.       old_stack_arg_under_construction = stack_arg_under_construction;
  1185.       stack_arg_under_construction = 0;
  1186. #endif
  1187.     }
  1188.       argblock = push_block (ARGS_SIZE_RTX (args_size), 0, 0);
  1189.     }
  1190.   else if (must_preallocate)
  1191.     {
  1192.       /* Note that we must go through the motions of allocating an argument
  1193.      block even if the size is zero because we may be storing args
  1194.      in the area reserved for register arguments, which may be part of
  1195.      the stack frame.  */
  1196.       int needed = args_size.constant;
  1197.  
  1198. #ifdef ACCUMULATE_OUTGOING_ARGS
  1199.       /* Store the maximum argument space used.  It will be pushed by the
  1200.      prologue.
  1201.  
  1202.      Since the stack pointer will never be pushed, it is possible for
  1203.      the evaluation of a parm to clobber something we have already
  1204.      written to the stack.  Since most function calls on RISC machines
  1205.      do not use the stack, this is uncommon, but must work correctly.
  1206.      
  1207.      Therefore, we save any area of the stack that was already written
  1208.      and that we are using.  Here we set up to do this by making a new
  1209.      stack usage map from the old one.  The actual save will be done
  1210.      by store_one_arg. 
  1211.  
  1212.      Another approach might be to try to reorder the argument
  1213.      evaluations to avoid this conflicting stack usage.  */
  1214.  
  1215.       if (needed > current_function_outgoing_args_size)
  1216.     current_function_outgoing_args_size = needed;
  1217.  
  1218. #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
  1219.       /* Since we will be writing into the entire argument area, the
  1220.      map must be allocated for its entire size, not just the part that
  1221.      is the responsibility of the caller.  */
  1222.       needed += reg_parm_stack_space;
  1223. #endif
  1224.  
  1225. #ifdef ARGS_GROW_DOWNWARD
  1226.       highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
  1227.                      needed + 1);
  1228. #else
  1229.       highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use, needed);
  1230. #endif
  1231.       stack_usage_map = (char *) alloca (highest_outgoing_arg_in_use);
  1232.  
  1233.       if (initial_highest_arg_in_use)
  1234.     bcopy (initial_stack_usage_map, stack_usage_map,
  1235.            initial_highest_arg_in_use);
  1236.  
  1237.       if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
  1238.     bzero (&stack_usage_map[initial_highest_arg_in_use],
  1239.            highest_outgoing_arg_in_use - initial_highest_arg_in_use);
  1240.       needed = 0;
  1241.  
  1242.       /* The address of the outgoing argument list must not be copied to a
  1243.      register here, because argblock would be left pointing to the
  1244.      wrong place after the call to allocate_dynamic_stack_space below. */
  1245.  
  1246.       argblock = virtual_outgoing_args_rtx;
  1247.  
  1248. #else /* not ACCUMULATE_OUTGOING_ARGS */
  1249.       if (inhibit_defer_pop == 0)
  1250.     {
  1251.       /* Try to reuse some or all of the pending_stack_adjust
  1252.          to get this space.  Maybe we can avoid any pushing.  */
  1253.       if (needed > pending_stack_adjust)
  1254.         {
  1255.           needed -= pending_stack_adjust;
  1256.           pending_stack_adjust = 0;
  1257.         }
  1258.       else
  1259.         {
  1260.           pending_stack_adjust -= needed;
  1261.           needed = 0;
  1262.         }
  1263.     }
  1264.       /* Special case this because overhead of `push_block' in this
  1265.      case is non-trivial.  */
  1266.       if (needed == 0)
  1267.     argblock = virtual_outgoing_args_rtx;
  1268.       else
  1269.     argblock = push_block (GEN_INT (needed), 0, 0);
  1270.  
  1271.       /* We only really need to call `copy_to_reg' in the case where push
  1272.      insns are going to be used to pass ARGBLOCK to a function
  1273.      call in ARGS.  In that case, the stack pointer changes value
  1274.      from the allocation point to the call point, and hence
  1275.      the value of VIRTUAL_OUTGOING_ARGS_RTX changes as well.
  1276.      But might as well always do it.  */
  1277.       argblock = copy_to_reg (argblock);
  1278. #endif /* not ACCUMULATE_OUTGOING_ARGS */
  1279.     }
  1280.  
  1281.  
  1282. #ifdef ACCUMULATE_OUTGOING_ARGS
  1283.   /* The save/restore code in store_one_arg handles all cases except one:
  1284.      a constructor call (including a C function returning a BLKmode struct)
  1285.      to initialize an argument.  */
  1286.   if (stack_arg_under_construction)
  1287.     {
  1288. #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
  1289.       rtx push_size = GEN_INT (reg_parm_stack_space + args_size.constant);
  1290. #else
  1291.       rtx push_size = GEN_INT (args_size.constant);
  1292. #endif
  1293.       if (old_stack_level == 0)
  1294.     {
  1295.       emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
  1296.       old_pending_adj = pending_stack_adjust;
  1297.       pending_stack_adjust = 0;
  1298.       /* stack_arg_under_construction says whether a stack arg is
  1299.          being constructed at the old stack level.  Pushing the stack
  1300.          gets a clean outgoing argument block.  */
  1301.       old_stack_arg_under_construction = stack_arg_under_construction;
  1302.       stack_arg_under_construction = 0;
  1303.       /* Make a new map for the new argument list.  */
  1304.       stack_usage_map = (char *)alloca (highest_outgoing_arg_in_use);
  1305.       bzero (stack_usage_map, highest_outgoing_arg_in_use);
  1306.       highest_outgoing_arg_in_use = 0;
  1307.     }
  1308.       allocate_dynamic_stack_space (push_size, NULL_RTX, BITS_PER_UNIT);
  1309.     }
  1310.   /* If argument evaluation might modify the stack pointer, copy the
  1311.      address of the argument list to a register.  */
  1312.   for (i = 0; i < num_actuals; i++)
  1313.     if (args[i].pass_on_stack)
  1314.       {
  1315.     argblock = copy_addr_to_reg (argblock);
  1316.     break;
  1317.       }
  1318. #endif
  1319.  
  1320.  
  1321.   /* If we preallocated stack space, compute the address of each argument.
  1322.      We need not ensure it is a valid memory address here; it will be 
  1323.      validized when it is used.  */
  1324.   if (argblock)
  1325.     {
  1326.       rtx arg_reg = argblock;
  1327.       int arg_offset = 0;
  1328.  
  1329.       if (GET_CODE (argblock) == PLUS)
  1330.     arg_reg = XEXP (argblock, 0), arg_offset = INTVAL (XEXP (argblock, 1));
  1331.  
  1332.       for (i = 0; i < num_actuals; i++)
  1333.     {
  1334.       rtx offset = ARGS_SIZE_RTX (args[i].offset);
  1335.       rtx slot_offset = ARGS_SIZE_RTX (args[i].slot_offset);
  1336.       rtx addr;
  1337.  
  1338.       /* Skip this parm if it will not be passed on the stack.  */
  1339.       if (! args[i].pass_on_stack && args[i].reg != 0)
  1340.         continue;
  1341.  
  1342.       if (GET_CODE (offset) == CONST_INT)
  1343.         addr = plus_constant (arg_reg, INTVAL (offset));
  1344.       else
  1345.         addr = gen_rtx (PLUS, Pmode, arg_reg, offset);
  1346.  
  1347.       addr = plus_constant (addr, arg_offset);
  1348.       args[i].stack
  1349.         = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (args[i].tree_value)), addr);
  1350.  
  1351.       if (GET_CODE (slot_offset) == CONST_INT)
  1352.         addr = plus_constant (arg_reg, INTVAL (slot_offset));
  1353.       else
  1354.         addr = gen_rtx (PLUS, Pmode, arg_reg, slot_offset);
  1355.  
  1356.       addr = plus_constant (addr, arg_offset);
  1357.       args[i].stack_slot
  1358.         = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (args[i].tree_value)), addr);
  1359.     }
  1360.     }
  1361.                            
  1362. #ifdef PUSH_ARGS_REVERSED
  1363. #ifdef STACK_BOUNDARY
  1364.   /* If we push args individually in reverse order, perform stack alignment
  1365.      before the first push (the last arg).  */
  1366.   if (argblock == 0)
  1367.     anti_adjust_stack (GEN_INT (args_size.constant
  1368.                 - original_args_size.constant));
  1369. #endif
  1370. #endif
  1371.  
  1372.   /* Don't try to defer pops if preallocating, not even from the first arg,
  1373.      since ARGBLOCK probably refers to the SP.  */
  1374.   if (argblock)
  1375.     NO_DEFER_POP;
  1376.  
  1377.   /* Get the function to call, in the form of RTL.  */
  1378.   if (fndecl)
  1379.     /* Get a SYMBOL_REF rtx for the function address.  */
  1380.     funexp = XEXP (DECL_RTL (fndecl), 0);
  1381.   else
  1382.     /* Generate an rtx (probably a pseudo-register) for the address.  */
  1383.     {
  1384.       funexp = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
  1385.       free_temp_slots ();    /* FUNEXP can't be BLKmode */
  1386.       emit_queue ();
  1387.     }
  1388.  
  1389.   /* Figure out the register where the value, if any, will come back.  */
  1390.   valreg = 0;
  1391.   if (TYPE_MODE (TREE_TYPE (exp)) != VOIDmode
  1392.       && ! structure_value_addr)
  1393.     {
  1394.       if (pcc_struct_value)
  1395.     valreg = hard_function_value (build_pointer_type (TREE_TYPE (exp)),
  1396.                       fndecl);
  1397.       else
  1398.     valreg = hard_function_value (TREE_TYPE (exp), fndecl);
  1399.     }
  1400.  
  1401.   /* Precompute all register parameters.  It isn't safe to compute anything
  1402.      once we have started filling any specific hard regs. */
  1403.   reg_parm_seen = 0;
  1404.   for (i = 0; i < num_actuals; i++)
  1405.     if (args[i].reg != 0 && ! args[i].pass_on_stack)
  1406.       {
  1407.     enum machine_mode mode;
  1408.  
  1409.     reg_parm_seen = 1;
  1410.  
  1411.     if (args[i].value == 0)
  1412.       {
  1413.         args[i].value = expand_expr (args[i].tree_value, NULL_RTX,
  1414.                      VOIDmode, 0);
  1415.         preserve_temp_slots (args[i].value);
  1416.         free_temp_slots ();
  1417.  
  1418.         /* ANSI doesn't require a sequence point here,
  1419.            but PCC has one, so this will avoid some problems.  */
  1420.         emit_queue ();
  1421.       }
  1422.  
  1423.     /* If we are to promote the function arg to a wider mode,
  1424.        do it now.  */
  1425.     mode = (GET_CODE (args[i].reg) == EXPR_LIST 
  1426.         ? GET_MODE (XEXP (args[i].reg, 0)) : GET_MODE (args[i].reg));
  1427.  
  1428.     if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) != mode)
  1429.       args[i].value = convert_to_mode (mode, args[i].value,
  1430.                        args[i].unsignedp);
  1431.       }
  1432.  
  1433. #if defined(ACCUMULATE_OUTGOING_ARGS) && defined(REG_PARM_STACK_SPACE)
  1434.   /* The argument list is the property of the called routine and it
  1435.      may clobber it.  If the fixed area has been used for previous
  1436.      parameters, we must save and restore it.
  1437.  
  1438.      Here we compute the boundary of the that needs to be saved, if any.  */
  1439.  
  1440. #ifdef ARGS_GROW_DOWNWARD
  1441.   for (i = 0; i < reg_parm_stack_space + 1; i++)
  1442. #else
  1443.   for (i = 0; i < reg_parm_stack_space; i++)
  1444. #endif
  1445.     {
  1446.       if (i >=  highest_outgoing_arg_in_use
  1447.       || stack_usage_map[i] == 0)
  1448.     continue;
  1449.  
  1450.       if (low_to_save == -1)
  1451.     low_to_save = i;
  1452.  
  1453.       high_to_save = i;
  1454.     }
  1455.  
  1456.   if (low_to_save >= 0)
  1457.     {
  1458.       int num_to_save = high_to_save - low_to_save + 1;
  1459.       enum machine_mode save_mode
  1460.     = mode_for_size (num_to_save * BITS_PER_UNIT, MODE_INT, 1);
  1461.       rtx stack_area;
  1462.  
  1463.       /* If we don't have the required alignment, must do this in BLKmode.  */
  1464.       if ((low_to_save & (MIN (GET_MODE_SIZE (save_mode),
  1465.                    BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1)))
  1466.     save_mode = BLKmode;
  1467.  
  1468.       stack_area = gen_rtx (MEM, save_mode,
  1469.                 memory_address (save_mode,
  1470.                         
  1471. #ifdef ARGS_GROW_DOWNWARD
  1472.                         plus_constant (argblock,
  1473.                                - high_to_save)
  1474. #else
  1475.                         plus_constant (argblock,
  1476.                                low_to_save)
  1477. #endif
  1478.                         ));
  1479.       if (save_mode == BLKmode)
  1480.     {
  1481.       save_area = assign_stack_temp (BLKmode, num_to_save, 1);
  1482.       emit_block_move (validize_mem (save_area), stack_area,
  1483.                GEN_INT (num_to_save),
  1484.                PARM_BOUNDARY / BITS_PER_UNIT);
  1485.     }
  1486.       else
  1487.     {
  1488.       save_area = gen_reg_rtx (save_mode);
  1489.       emit_move_insn (save_area, stack_area);
  1490.     }
  1491.     }
  1492. #endif
  1493.       
  1494.  
  1495.   /* Now store (and compute if necessary) all non-register parms.
  1496.      These come before register parms, since they can require block-moves,
  1497.      which could clobber the registers used for register parms.
  1498.      Parms which have partial registers are not stored here,
  1499.      but we do preallocate space here if they want that.  */
  1500.  
  1501.   for (i = 0; i < num_actuals; i++)
  1502.     if (args[i].reg == 0 || args[i].pass_on_stack)
  1503.       store_one_arg (&args[i], argblock, may_be_alloca,
  1504.              args_size.var != 0, fndecl, reg_parm_stack_space);
  1505.  
  1506.   /* Now store any partially-in-registers parm.
  1507.      This is the last place a block-move can happen.  */
  1508.   if (reg_parm_seen)
  1509.     for (i = 0; i < num_actuals; i++)
  1510.       if (args[i].partial != 0 && ! args[i].pass_on_stack)
  1511.     store_one_arg (&args[i], argblock, may_be_alloca,
  1512.                args_size.var != 0, fndecl, reg_parm_stack_space);
  1513.  
  1514. #ifndef PUSH_ARGS_REVERSED
  1515. #ifdef STACK_BOUNDARY
  1516.   /* If we pushed args in forward order, perform stack alignment
  1517.      after pushing the last arg.  */
  1518.   if (argblock == 0)
  1519.     anti_adjust_stack (GEN_INT (args_size.constant
  1520.                 - original_args_size.constant));
  1521. #endif
  1522. #endif
  1523.  
  1524.   /* If register arguments require space on the stack and stack space
  1525.      was not preallocated, allocate stack space here for arguments
  1526.      passed in registers.  */
  1527. #if ! defined(ALLOCATE_OUTGOING_ARGS) && defined(OUTGOING_REG_PARM_STACK_SPACE)
  1528.   if (must_preallocate == 0 && reg_parm_stack_space > 0)
  1529.     anti_adjust_stack (GEN_INT (reg_parm_stack_space));
  1530. #endif
  1531.  
  1532.   /* Pass the function the address in which to return a structure value.  */
  1533.   if (structure_value_addr && ! structure_value_addr_parm)
  1534.     {
  1535.       emit_move_insn (struct_value_rtx,
  1536.               force_reg (Pmode,
  1537.                  force_operand (structure_value_addr,
  1538.                         NULL_RTX)));
  1539.       if (GET_CODE (struct_value_rtx) == REG)
  1540.     {
  1541.       push_to_sequence (use_insns);
  1542.       emit_insn (gen_rtx (USE, VOIDmode, struct_value_rtx));
  1543.       use_insns = get_insns ();
  1544.       end_sequence ();
  1545.     }
  1546.     }
  1547.  
  1548.   /* Now do the register loads required for any wholly-register parms or any
  1549.      parms which are passed both on the stack and in a register.  Their
  1550.      expressions were already evaluated. 
  1551.  
  1552.      Mark all register-parms as living through the call, putting these USE
  1553.      insns in a list headed by USE_INSNS.  */
  1554.  
  1555.   for (i = 0; i < num_actuals; i++)
  1556.     {
  1557.       rtx list = args[i].reg;
  1558.       int partial = args[i].partial;
  1559.  
  1560.       while (list)
  1561.     {
  1562.       rtx reg;
  1563.       int nregs;
  1564.  
  1565.       /* Process each register that needs to get this arg.  */
  1566.       if (GET_CODE (list) == EXPR_LIST)
  1567.         reg = XEXP (list, 0), list = XEXP (list, 1);
  1568.       else
  1569.         reg = list, list = 0;
  1570.  
  1571.       /* Set to non-zero if must move a word at a time, even if just one
  1572.          word (e.g, partial == 1 && mode == DFmode).  Set to zero if
  1573.          we just use a normal move insn.  */
  1574.       nregs = (partial ? partial
  1575.            : (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
  1576.               ? ((int_size_in_bytes (TREE_TYPE (args[i].tree_value))
  1577.               + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
  1578.               : 0));
  1579.  
  1580.       /* If simple case, just do move.  If normal partial, store_one_arg
  1581.          has already loaded the register for us.  In all other cases,
  1582.          load the register(s) from memory.  */
  1583.  
  1584.       if (nregs == 0)
  1585.         emit_move_insn (reg, args[i].value);
  1586.       else if (args[i].partial == 0 || args[i].pass_on_stack)
  1587.         move_block_to_reg (REGNO (reg),
  1588.                    validize_mem (args[i].value), nregs,
  1589.                    TYPE_MODE (TREE_TYPE (args[i].tree_value)));
  1590.     
  1591.       push_to_sequence (use_insns);
  1592.       if (nregs == 0)
  1593.         emit_insn (gen_rtx (USE, VOIDmode, reg));
  1594.       else
  1595.         use_regs (REGNO (reg), nregs);
  1596.       use_insns = get_insns ();
  1597.       end_sequence ();
  1598.  
  1599.       /* PARTIAL referred only to the first register, so clear it for the
  1600.          next time.  */
  1601.       partial = 0;
  1602.     }
  1603.     }
  1604.  
  1605.   /* Perform postincrements before actually calling the function.  */
  1606.   emit_queue ();
  1607.  
  1608.   /* All arguments and registers used for the call must be set up by now!  */
  1609.  
  1610.   funexp = prepare_call_address (funexp, fndecl, &use_insns);
  1611.  
  1612.   /* Generate the actual call instruction.  */
  1613.   emit_call_1 (funexp, funtype, args_size.constant, struct_value_size,
  1614.            FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
  1615.            valreg, old_inhibit_defer_pop, use_insns, is_const);
  1616.  
  1617.   /* If call is cse'able, make appropriate pair of reg-notes around it.
  1618.      Test valreg so we don't crash; may safely ignore `const'
  1619.      if return type is void.  */
  1620.   if (is_const && valreg != 0)
  1621.     {
  1622.       rtx note = 0;
  1623.       rtx temp = gen_reg_rtx (GET_MODE (valreg));
  1624.       rtx insns;
  1625.  
  1626.       /* Construct an "equal form" for the value which mentions all the
  1627.      arguments in order as well as the function name.  */
  1628. #ifdef PUSH_ARGS_REVERSED
  1629.       for (i = 0; i < num_actuals; i++)
  1630.     note = gen_rtx (EXPR_LIST, VOIDmode, args[i].initial_value, note);
  1631. #else
  1632.       for (i = num_actuals - 1; i >= 0; i--)
  1633.     note = gen_rtx (EXPR_LIST, VOIDmode, args[i].initial_value, note);
  1634. #endif
  1635.       note = gen_rtx (EXPR_LIST, VOIDmode, funexp, note);
  1636.  
  1637.       insns = get_insns ();
  1638.       end_sequence ();
  1639.  
  1640.       emit_libcall_block (insns, temp, valreg, note);
  1641.  
  1642.       valreg = temp;
  1643.     }
  1644.  
  1645.   /* For calls to `setjmp', etc., inform flow.c it should complain
  1646.      if nonvolatile values are live.  */
  1647.  
  1648.   if (returns_twice)
  1649.     {
  1650.       emit_note (name, NOTE_INSN_SETJMP);
  1651.       current_function_calls_setjmp = 1;
  1652.     }
  1653.  
  1654.   if (is_longjmp)
  1655.     current_function_calls_longjmp = 1;
  1656.  
  1657.   /* Notice functions that cannot return.
  1658.      If optimizing, insns emitted below will be dead.
  1659.      If not optimizing, they will exist, which is useful
  1660.      if the user uses the `return' command in the debugger.  */
  1661.  
  1662.   if (is_volatile || is_longjmp)
  1663.     emit_barrier ();
  1664.  
  1665.   /* If value type not void, return an rtx for the value.  */
  1666.  
  1667.   /* If there are cleanups to be called, don't use a hard reg as target.  */
  1668.   if (cleanups_this_call != old_cleanups
  1669.       && target && REG_P (target)
  1670.       && REGNO (target) < FIRST_PSEUDO_REGISTER)
  1671.     target = 0;
  1672.  
  1673.   if (TYPE_MODE (TREE_TYPE (exp)) == VOIDmode
  1674.       || ignore)
  1675.     {
  1676.       target = const0_rtx;
  1677.     }
  1678.   else if (structure_value_addr)
  1679.     {
  1680.       if (target == 0 || GET_CODE (target) != MEM)
  1681.     {
  1682.       target = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)),
  1683.                 memory_address (TYPE_MODE (TREE_TYPE (exp)),
  1684.                         structure_value_addr));
  1685.       MEM_IN_STRUCT_P (target)
  1686.         = (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
  1687.            || TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
  1688.            || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE);
  1689.     }
  1690.     }
  1691.   else if (pcc_struct_value)
  1692.     {
  1693.       if (target == 0)
  1694.     {
  1695.       target = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)),
  1696.                 copy_to_reg (valreg));
  1697.       MEM_IN_STRUCT_P (target)
  1698.         = (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
  1699.            || TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
  1700.            || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE);
  1701.     }
  1702.       else if (TYPE_MODE (TREE_TYPE (exp)) != BLKmode)
  1703.     emit_move_insn (target, gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)),
  1704.                      copy_to_reg (valreg)));
  1705.       else
  1706.     emit_block_move (target, gen_rtx (MEM, BLKmode, copy_to_reg (valreg)),
  1707.              expr_size (exp),
  1708.              TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT);
  1709.     }
  1710.   else if (target && GET_MODE (target) == TYPE_MODE (TREE_TYPE (exp))
  1711.        && GET_MODE (target) == GET_MODE (valreg))
  1712.     /* TARGET and VALREG cannot be equal at this point because the latter
  1713.        would not have REG_FUNCTION_VALUE_P true, while the former would if
  1714.        it were referring to the same register.
  1715.  
  1716.        If they refer to the same register, this move will be a no-op, except
  1717.        when function inlining is being done.  */
  1718.     emit_move_insn (target, valreg);
  1719.   else
  1720.     target = copy_to_reg (valreg);
  1721.  
  1722. #ifdef PROMOTE_FUNCTION_RETURN
  1723.   /* If we promoted this return value, make the proper SUBREG.  */
  1724.   if (GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
  1725.     {
  1726.       enum machine_mode mode = GET_MODE (target);
  1727.       int unsignedp = TREE_UNSIGNED (TREE_TYPE (exp));
  1728.  
  1729.       if (TREE_CODE (TREE_TYPE (exp)) == INTEGER_TYPE
  1730.       || TREE_CODE (TREE_TYPE (exp)) == ENUMERAL_TYPE
  1731.       || TREE_CODE (TREE_TYPE (exp)) == BOOLEAN_TYPE
  1732.       || TREE_CODE (TREE_TYPE (exp)) == CHAR_TYPE
  1733.       || TREE_CODE (TREE_TYPE (exp)) == REAL_TYPE
  1734.       || TREE_CODE (TREE_TYPE (exp)) == POINTER_TYPE
  1735.       || TREE_CODE (TREE_TYPE (exp)) == OFFSET_TYPE)
  1736.     {
  1737.       PROMOTE_MODE (mode, unsignedp, TREE_TYPE (exp));
  1738.     }
  1739.  
  1740.       target = gen_rtx (SUBREG, TYPE_MODE (TREE_TYPE (exp)), target, 0);
  1741.       SUBREG_PROMOTED_VAR_P (target) = 1;
  1742.       SUBREG_PROMOTED_UNSIGNED_P (target) = unsignedp;
  1743.     }
  1744. #endif
  1745.  
  1746.   /* Perform all cleanups needed for the arguments of this call
  1747.      (i.e. destructors in C++).  */
  1748.   expand_cleanups_to (old_cleanups);
  1749.  
  1750.   /* If size of args is variable or this was a constructor call for a stack
  1751.      argument, restore saved stack-pointer value.  */
  1752.  
  1753.   if (old_stack_level)
  1754.     {
  1755.       emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
  1756.       pending_stack_adjust = old_pending_adj;
  1757. #ifdef ACCUMULATE_OUTGOING_ARGS
  1758.       stack_arg_under_construction = old_stack_arg_under_construction;
  1759.       highest_outgoing_arg_in_use = initial_highest_arg_in_use;
  1760.       stack_usage_map = initial_stack_usage_map;
  1761. #endif
  1762.     }
  1763. #ifdef ACCUMULATE_OUTGOING_ARGS
  1764.   else
  1765.     {
  1766. #ifdef REG_PARM_STACK_SPACE
  1767.       if (save_area)
  1768.     {
  1769.       enum machine_mode save_mode = GET_MODE (save_area);
  1770.       rtx stack_area
  1771.         = gen_rtx (MEM, save_mode,
  1772.                memory_address (save_mode,
  1773. #ifdef ARGS_GROW_DOWNWARD
  1774.                        plus_constant (argblock, - high_to_save)
  1775. #else
  1776.                        plus_constant (argblock, low_to_save)
  1777. #endif
  1778.                        ));
  1779.  
  1780.       if (save_mode != BLKmode)
  1781.         emit_move_insn (stack_area, save_area);
  1782.       else
  1783.         emit_block_move (stack_area, validize_mem (save_area),
  1784.                  GEN_INT (high_to_save - low_to_save + 1),
  1785.                  PARM_BOUNDARY / BITS_PER_UNIT);
  1786.     }
  1787. #endif
  1788.       
  1789.       /* If we saved any argument areas, restore them.  */
  1790.       for (i = 0; i < num_actuals; i++)
  1791.     if (args[i].save_area)
  1792.       {
  1793.         enum machine_mode save_mode = GET_MODE (args[i].save_area);
  1794.         rtx stack_area
  1795.           = gen_rtx (MEM, save_mode,
  1796.              memory_address (save_mode,
  1797.                      XEXP (args[i].stack_slot, 0)));
  1798.  
  1799.         if (save_mode != BLKmode)
  1800.           emit_move_insn (stack_area, args[i].save_area);
  1801.         else
  1802.           emit_block_move (stack_area, validize_mem (args[i].save_area),
  1803.                    GEN_INT (args[i].size.constant),
  1804.                    PARM_BOUNDARY / BITS_PER_UNIT);
  1805.       }
  1806.  
  1807.       highest_outgoing_arg_in_use = initial_highest_arg_in_use;
  1808.       stack_usage_map = initial_stack_usage_map;
  1809.     }
  1810. #endif
  1811.  
  1812.   /* If this was alloca, record the new stack level for nonlocal gotos.  
  1813.      Check for the handler slots since we might not have a save area
  1814.      for non-local gotos. */
  1815.  
  1816.   if (may_be_alloca && nonlocal_goto_handler_slot != 0)
  1817.     emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
  1818.  
  1819.   pop_temp_slots ();
  1820.  
  1821.   return target;
  1822. }
  1823.  
  1824. #if 0
  1825. /* Return an rtx which represents a suitable home on the stack
  1826.    given TYPE, the type of the argument looking for a home.
  1827.    This is called only for BLKmode arguments.
  1828.  
  1829.    SIZE is the size needed for this target.
  1830.    ARGS_ADDR is the address of the bottom of the argument block for this call.
  1831.    OFFSET describes this parameter's offset into ARGS_ADDR.  It is meaningless
  1832.    if this machine uses push insns.  */
  1833.  
  1834. static rtx
  1835. target_for_arg (type, size, args_addr, offset)
  1836.      tree type;
  1837.      rtx size;
  1838.      rtx args_addr;
  1839.      struct args_size offset;
  1840. {
  1841.   rtx target;
  1842.   rtx offset_rtx = ARGS_SIZE_RTX (offset);
  1843.  
  1844.   /* We do not call memory_address if possible,
  1845.      because we want to address as close to the stack
  1846.      as possible.  For non-variable sized arguments,
  1847.      this will be stack-pointer relative addressing.  */
  1848.   if (GET_CODE (offset_rtx) == CONST_INT)
  1849.     target = plus_constant (args_addr, INTVAL (offset_rtx));
  1850.   else
  1851.     {
  1852.       /* I have no idea how to guarantee that this
  1853.      will work in the presence of register parameters.  */
  1854.       target = gen_rtx (PLUS, Pmode, args_addr, offset_rtx);
  1855.       target = memory_address (QImode, target);
  1856.     }
  1857.  
  1858.   return gen_rtx (MEM, BLKmode, target);
  1859. }
  1860. #endif
  1861.  
  1862. /* Store a single argument for a function call
  1863.    into the register or memory area where it must be passed.
  1864.    *ARG describes the argument value and where to pass it.
  1865.  
  1866.    ARGBLOCK is the address of the stack-block for all the arguments,
  1867.    or 0 on a machine where arguments are pushed individually.
  1868.  
  1869.    MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
  1870.    so must be careful about how the stack is used. 
  1871.  
  1872.    VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
  1873.    argument stack.  This is used if ACCUMULATE_OUTGOING_ARGS to indicate
  1874.    that we need not worry about saving and restoring the stack.
  1875.  
  1876.    FNDECL is the declaration of the function we are calling.  */
  1877.  
  1878. static void
  1879. store_one_arg (arg, argblock, may_be_alloca, variable_size, fndecl,
  1880.            reg_parm_stack_space)
  1881.      struct arg_data *arg;
  1882.      rtx argblock;
  1883.      int may_be_alloca;
  1884.      int variable_size;
  1885.      tree fndecl;
  1886.      int reg_parm_stack_space;
  1887. {
  1888.   register tree pval = arg->tree_value;
  1889.   rtx reg = 0;
  1890.   int partial = 0;
  1891.   int used = 0;
  1892.   int i, lower_bound, upper_bound;
  1893.  
  1894.   if (TREE_CODE (pval) == ERROR_MARK)
  1895.     return;
  1896.  
  1897. #ifdef ACCUMULATE_OUTGOING_ARGS
  1898.   /* If this is being stored into a pre-allocated, fixed-size, stack area,
  1899.      save any previous data at that location.  */
  1900.   if (argblock && ! variable_size && arg->stack)
  1901.     {
  1902. #ifdef ARGS_GROW_DOWNWARD
  1903.       /* stack_slot is negative, but we want to index stack_usage_map */
  1904.       /* with positive values. */
  1905.       if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
  1906.     upper_bound = -INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1)) + 1;
  1907.       else
  1908.     abort ();
  1909.  
  1910.       lower_bound = upper_bound - arg->size.constant;
  1911. #else
  1912.       if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
  1913.     lower_bound = INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1));
  1914.       else
  1915.     lower_bound = 0;
  1916.  
  1917.       upper_bound = lower_bound + arg->size.constant;
  1918. #endif
  1919.  
  1920.       for (i = lower_bound; i < upper_bound; i++)
  1921.     if (stack_usage_map[i]
  1922. #ifdef REG_PARM_STACK_SPACE
  1923.         /* Don't store things in the fixed argument area at this point;
  1924.            it has already been saved.  */
  1925.         && i > reg_parm_stack_space
  1926. #endif
  1927.         )
  1928.       break;
  1929.  
  1930.       if (i != upper_bound)
  1931.     {
  1932.       /* We need to make a save area.  See what mode we can make it.  */
  1933.       enum machine_mode save_mode
  1934.         = mode_for_size (arg->size.constant * BITS_PER_UNIT, MODE_INT, 1);
  1935.       rtx stack_area
  1936.         = gen_rtx (MEM, save_mode,
  1937.                memory_address (save_mode, XEXP (arg->stack_slot, 0)));
  1938.  
  1939.       if (save_mode == BLKmode)
  1940.         {
  1941.           arg->save_area = assign_stack_temp (BLKmode,
  1942.                           arg->size.constant, 1);
  1943.           emit_block_move (validize_mem (arg->save_area), stack_area,
  1944.                    GEN_INT (arg->size.constant),
  1945.                    PARM_BOUNDARY / BITS_PER_UNIT);
  1946.         }
  1947.       else
  1948.         {
  1949.           arg->save_area = gen_reg_rtx (save_mode);
  1950.           emit_move_insn (arg->save_area, stack_area);
  1951.         }
  1952.     }
  1953.     }
  1954. #endif
  1955.  
  1956.   /* If this isn't going to be placed on both the stack and in registers,
  1957.      set up the register and number of words.  */
  1958.   if (! arg->pass_on_stack)
  1959.     reg = arg->reg, partial = arg->partial;
  1960.  
  1961.   if (reg != 0 && partial == 0)
  1962.     /* Being passed entirely in a register.  We shouldn't be called in
  1963.        this case.   */
  1964.     abort ();
  1965.  
  1966.   /* If this is being partially passed in a register, but multiple locations
  1967.      are specified, we assume that the one partially used is the one that is
  1968.      listed first.  */
  1969.   if (reg && GET_CODE (reg) == EXPR_LIST)
  1970.     reg = XEXP (reg, 0);
  1971.  
  1972.   /* If this is being passes partially in a register, we can't evaluate
  1973.      it directly into its stack slot.  Otherwise, we can.  */
  1974.   if (arg->value == 0)
  1975.     {
  1976. #ifdef ACCUMULATE_OUTGOING_ARGS
  1977.       /* stack_arg_under_construction is nonzero if a function argument is
  1978.      being evaluated directly into the outgoing argument list and
  1979.      expand_call must take special action to preserve the argument list
  1980.      if it is called recursively.
  1981.  
  1982.      For scalar function arguments stack_usage_map is sufficient to
  1983.      determine which stack slots must be saved and restored.  Scalar
  1984.      arguments in general have pass_on_stack == 0.
  1985.  
  1986.      If this argument is initialized by a function which takes the
  1987.      address of the argument (a C++ constructor or a C function
  1988.      returning a BLKmode structure), then stack_usage_map is
  1989.      insufficient and expand_call must push the stack around the
  1990.      function call.  Such arguments have pass_on_stack == 1.
  1991.  
  1992.      Note that it is always safe to set stack_arg_under_construction,
  1993.      but this generates suboptimal code if set when not needed.  */
  1994.  
  1995.       if (arg->pass_on_stack)
  1996.     stack_arg_under_construction++;
  1997. #endif
  1998.       arg->value = expand_expr (pval, partial ? NULL_RTX : arg->stack,
  1999.                 VOIDmode, 0);
  2000. #ifdef ACCUMULATE_OUTGOING_ARGS
  2001.       if (arg->pass_on_stack)
  2002.     stack_arg_under_construction--;
  2003. #endif
  2004.     }
  2005.  
  2006.   /* Don't allow anything left on stack from computation
  2007.      of argument to alloca.  */
  2008.   if (may_be_alloca)
  2009.     do_pending_stack_adjust ();
  2010.  
  2011.   if (arg->value == arg->stack)
  2012.     /* If the value is already in the stack slot, we are done.  */
  2013.     ;
  2014.   else if (TYPE_MODE (TREE_TYPE (pval)) != BLKmode)
  2015.     {
  2016.       register int size;
  2017.  
  2018.       /* Argument is a scalar, not entirely passed in registers.
  2019.      (If part is passed in registers, arg->partial says how much
  2020.      and emit_push_insn will take care of putting it there.)
  2021.      
  2022.      Push it, and if its size is less than the
  2023.      amount of space allocated to it,
  2024.      also bump stack pointer by the additional space.
  2025.      Note that in C the default argument promotions
  2026.      will prevent such mismatches.  */
  2027.  
  2028.       size = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (pval)));
  2029.       /* Compute how much space the push instruction will push.
  2030.      On many machines, pushing a byte will advance the stack
  2031.      pointer by a halfword.  */
  2032. #ifdef PUSH_ROUNDING
  2033.       size = PUSH_ROUNDING (size);
  2034. #endif
  2035.       used = size;
  2036.  
  2037.       /* Compute how much space the argument should get:
  2038.      round up to a multiple of the alignment for arguments.  */
  2039.       if (none != FUNCTION_ARG_PADDING (TYPE_MODE (TREE_TYPE (pval)),
  2040.                     TREE_TYPE (pval)))
  2041.     used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1)
  2042.          / (PARM_BOUNDARY / BITS_PER_UNIT))
  2043.         * (PARM_BOUNDARY / BITS_PER_UNIT));
  2044.  
  2045.       /* This isn't already where we want it on the stack, so put it there.
  2046.      This can either be done with push or copy insns.  */
  2047.       emit_push_insn (arg->value, TYPE_MODE (TREE_TYPE (pval)),
  2048.               TREE_TYPE (pval), 0, 0, partial, reg,
  2049.               used - size, argblock, ARGS_SIZE_RTX (arg->offset));
  2050.     }
  2051.   else
  2052.     {
  2053.       /* BLKmode, at least partly to be pushed.  */
  2054.  
  2055.       register int excess;
  2056.       rtx size_rtx;
  2057.  
  2058.       /* Pushing a nonscalar.
  2059.      If part is passed in registers, PARTIAL says how much
  2060.      and emit_push_insn will take care of putting it there.  */
  2061.  
  2062.       /* Round its size up to a multiple
  2063.      of the allocation unit for arguments.  */
  2064.  
  2065.       if (arg->size.var != 0)
  2066.     {
  2067.       excess = 0;
  2068.       size_rtx = ARGS_SIZE_RTX (arg->size);
  2069.     }
  2070.       else
  2071.     {
  2072.       register tree size = size_in_bytes (TREE_TYPE (pval));
  2073.       /* PUSH_ROUNDING has no effect on us, because
  2074.          emit_push_insn for BLKmode is careful to avoid it.  */
  2075.       excess = (arg->size.constant - TREE_INT_CST_LOW (size)
  2076.             + partial * UNITS_PER_WORD);
  2077.       size_rtx = expand_expr (size, NULL_RTX, VOIDmode, 0);
  2078.     }
  2079.  
  2080.       emit_push_insn (arg->value, TYPE_MODE (TREE_TYPE (pval)),
  2081.               TREE_TYPE (pval), size_rtx,
  2082.               TYPE_ALIGN (TREE_TYPE (pval)) / BITS_PER_UNIT, partial,
  2083.               reg, excess, argblock, ARGS_SIZE_RTX (arg->offset));
  2084.     }
  2085.  
  2086.  
  2087.   /* Unless this is a partially-in-register argument, the argument is now
  2088.      in the stack. 
  2089.  
  2090.      ??? Note that this can change arg->value from arg->stack to
  2091.      arg->stack_slot and it matters when they are not the same.
  2092.      It isn't totally clear that this is correct in all cases.  */
  2093.   if (partial == 0)
  2094.     arg->value = arg->stack_slot;
  2095.  
  2096.   /* Once we have pushed something, pops can't safely
  2097.      be deferred during the rest of the arguments.  */
  2098.   NO_DEFER_POP;
  2099.  
  2100.   /* ANSI doesn't require a sequence point here,
  2101.      but PCC has one, so this will avoid some problems.  */
  2102.   emit_queue ();
  2103.  
  2104.   /* Free any temporary slots made in processing this argument.  */
  2105.   free_temp_slots ();
  2106.  
  2107. #ifdef ACCUMULATE_OUTGOING_ARGS
  2108.   /* Now mark the segment we just used.  */
  2109.   if (argblock && ! variable_size && arg->stack)
  2110.     for (i = lower_bound; i < upper_bound; i++)
  2111.       stack_usage_map[i] = 1;
  2112. #endif
  2113. }
  2114.