home *** CD-ROM | disk | FTP | other *** search
/ OpenStep (Enterprise) / OpenStepENTCD.toast / OEDEV / GNUSRC.Z / calls.c < prev    next >
C/C++ Source or Header  |  1996-01-31  |  109KB  |  3,355 lines
  1. /* Convert function calls to rtl insns, for GNU C compiler.
  2.    Copyright (C) 1989, 1992, 1993, 1994, 1995 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, 59 Temple Place - Suite 330,
  19. Boston, MA 02111-1307, USA.  */
  20.  
  21. #include "config.h"
  22. #include "rtl.h"
  23. #include "tree.h"
  24. #include "flags.h"
  25. #include "expr.h"
  26. #ifdef __STDC__
  27. #include <stdarg.h>
  28. #else
  29. #include <varargs.h>
  30. #endif
  31. #include "insn-flags.h"
  32.  
  33. /* Decide whether a function's arguments should be processed
  34.    from first to last or from last to first.
  35.  
  36.    They should if the stack and args grow in opposite directions, but
  37.    only if we have push insns.  */
  38.  
  39. #ifdef PUSH_ROUNDING
  40.  
  41. #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD)
  42. #define PUSH_ARGS_REVERSED    /* If it's last to first */
  43. #endif
  44.  
  45. #endif
  46.  
  47. /* Like STACK_BOUNDARY but in units of bytes, not bits.  */
  48. #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
  49.  
  50. /* Data structure and subroutines used within expand_call.  */
  51.  
  52. struct arg_data
  53. {
  54.   /* Tree node for this argument.  */
  55.   tree tree_value;
  56.   /* Mode for value; TYPE_MODE unless promoted.  */
  57.   enum machine_mode mode;
  58.   /* Current RTL value for argument, or 0 if it isn't precomputed.  */
  59.   rtx value;
  60.   /* Initially-compute RTL value for argument; only for const functions.  */
  61.   rtx initial_value;
  62.   /* Register to pass this argument in, 0 if passed on stack, or an
  63.      EXPR_LIST if the arg is to be copied into multiple different
  64.      registers.  */
  65.   rtx reg;
  66.   /* If REG was promoted from the actual mode of the argument expression,
  67.      indicates whether the promotion is sign- or zero-extended.  */
  68.   int unsignedp;
  69.   /* Number of registers to use.  0 means put the whole arg in registers.
  70.      Also 0 if not passed in registers.  */
  71.   int partial;
  72.   /* Non-zero if argument must be passed on stack.
  73.      Note that some arguments may be passed on the stack
  74.      even though pass_on_stack is zero, just because FUNCTION_ARG says so.
  75.      pass_on_stack identifies arguments that *cannot* go in registers.  */
  76.   int pass_on_stack;
  77.   /* Offset of this argument from beginning of stack-args.  */
  78.   struct args_size offset;
  79.   /* Similar, but offset to the start of the stack slot.  Different from
  80.      OFFSET if this arg pads downward.  */
  81.   struct args_size slot_offset;
  82.   /* Size of this argument on the stack, rounded up for any padding it gets,
  83.      parts of the argument passed in registers do not count.
  84.      If REG_PARM_STACK_SPACE is defined, then register parms
  85.      are counted here as well.  */
  86.   struct args_size size;
  87.   /* Location on the stack at which parameter should be stored.  The store
  88.      has already been done if STACK == VALUE.  */
  89.   rtx stack;
  90.   /* Location on the stack of the start of this argument slot.  This can
  91.      differ from STACK if this arg pads downward.  This location is known
  92.      to be aligned to FUNCTION_ARG_BOUNDARY.  */
  93.   rtx stack_slot;
  94. #ifdef ACCUMULATE_OUTGOING_ARGS
  95.   /* Place that this stack area has been saved, if needed.  */
  96.   rtx save_area;
  97. #endif
  98. #ifdef STRICT_ALIGNMENT
  99.   /* If an argument's alignment does not permit direct copying into registers,
  100.      copy in smaller-sized pieces into pseudos.  These are stored in a
  101.      block pointed to by this field.  The next field says how many
  102.      word-sized pseudos we made.  */
  103.   rtx *aligned_regs;
  104.   int n_aligned_regs;
  105. #endif
  106. };
  107.  
  108. #ifdef ACCUMULATE_OUTGOING_ARGS
  109. /* A vector of one char per byte of stack space.  A byte if non-zero if
  110.    the corresponding stack location has been used.
  111.    This vector is used to prevent a function call within an argument from
  112.    clobbering any stack already set up.  */
  113. static char *stack_usage_map;
  114.  
  115. /* Size of STACK_USAGE_MAP.  */
  116. static int highest_outgoing_arg_in_use;
  117.  
  118. /* stack_arg_under_construction is nonzero when an argument may be
  119.    initialized with a constructor call (including a C function that
  120.    returns a BLKmode struct) and expand_call must take special action
  121.    to make sure the object being constructed does not overlap the
  122.    argument list for the constructor call.  */
  123. int stack_arg_under_construction;
  124. #endif
  125.  
  126. static int calls_function    PROTO((tree, int));
  127. static int calls_function_1    PROTO((tree, int));
  128. static void emit_call_1        PROTO((rtx, tree, tree, int, int, rtx, rtx,
  129.                        int, rtx, int));
  130. static void store_one_arg    PROTO ((struct arg_data *, rtx, int, int,
  131.                     tree, int));
  132.  
  133. /* If WHICH is 1, return 1 if EXP contains a call to the built-in function
  134.    `alloca'.
  135.  
  136.    If WHICH is 0, return 1 if EXP contains a call to any function.
  137.    Actually, we only need return 1 if evaluating EXP would require pushing
  138.    arguments on the stack, but that is too difficult to compute, so we just
  139.    assume any function call might require the stack.  */
  140.  
  141. static tree calls_function_save_exprs;
  142.  
  143. static int
  144. calls_function (exp, which)
  145.      tree exp;
  146.      int which;
  147. {
  148.   int val;
  149.   calls_function_save_exprs = 0;
  150.   val = calls_function_1 (exp, which);
  151.   calls_function_save_exprs = 0;
  152.   return val;
  153. }
  154.  
  155. static int
  156. calls_function_1 (exp, which)
  157.      tree exp;
  158.      int which;
  159. {
  160.   register int i;
  161.   enum tree_code code = TREE_CODE (exp);
  162.   int type = TREE_CODE_CLASS (code);
  163.   int length = tree_code_length[(int) code];
  164.  
  165.   /* If this code is language-specific, we don't know what it will do.  */
  166.   if ((int) code >= NUM_TREE_CODES)
  167.     return 1;
  168.  
  169.   /* Only expressions and references can contain calls.  */
  170.   if (type != 'e' && type != '<' && type != '1' && type != '2' && type != 'r'
  171.       && type != 'b')
  172.     return 0;
  173.  
  174.   switch (code)
  175.     {
  176.     case CALL_EXPR:
  177.       if (which == 0)
  178.     return 1;
  179.       else if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
  180.            && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
  181.            == FUNCTION_DECL))
  182.     {
  183.       tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
  184.  
  185.       if ((DECL_BUILT_IN (fndecl)
  186.            && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_ALLOCA)
  187.           || (DECL_SAVED_INSNS (fndecl)
  188.           && (FUNCTION_FLAGS (DECL_SAVED_INSNS (fndecl))
  189.               & FUNCTION_FLAGS_CALLS_ALLOCA)))
  190.         return 1;
  191.     }
  192.  
  193.       /* Third operand is RTL.  */
  194.       length = 2;
  195.       break;
  196.  
  197.     case SAVE_EXPR:
  198.       if (SAVE_EXPR_RTL (exp) != 0)
  199.     return 0;
  200.       if (value_member (exp, calls_function_save_exprs))
  201.     return 0;
  202.       calls_function_save_exprs = tree_cons (NULL_TREE, exp,
  203.                          calls_function_save_exprs);
  204.       return (TREE_OPERAND (exp, 0) != 0
  205.           && calls_function_1 (TREE_OPERAND (exp, 0), which));
  206.  
  207.     case BLOCK:
  208.       {
  209.     register tree local;
  210.  
  211.     for (local = BLOCK_VARS (exp); local; local = TREE_CHAIN (local))
  212.       if (DECL_INITIAL (local) != 0
  213.           && calls_function_1 (DECL_INITIAL (local), which))
  214.         return 1;
  215.       }
  216.       {
  217.     register tree subblock;
  218.  
  219.     for (subblock = BLOCK_SUBBLOCKS (exp);
  220.          subblock;
  221.          subblock = TREE_CHAIN (subblock))
  222.       if (calls_function_1 (subblock, which))
  223.         return 1;
  224.       }
  225.       return 0;
  226.  
  227.     case METHOD_CALL_EXPR:
  228.       length = 3;
  229.       break;
  230.  
  231.     case WITH_CLEANUP_EXPR:
  232.       length = 1;
  233.       break;
  234.  
  235.     case RTL_EXPR:
  236.       return 0;
  237.     }
  238.  
  239.   for (i = 0; i < length; i++)
  240.     if (TREE_OPERAND (exp, i) != 0
  241.     && calls_function_1 (TREE_OPERAND (exp, i), which))
  242.       return 1;
  243.  
  244.   return 0;
  245. }
  246.  
  247. /* Force FUNEXP into a form suitable for the address of a CALL,
  248.    and return that as an rtx.  Also load the static chain register
  249.    if FNDECL is a nested function.
  250.  
  251.    CALL_FUSAGE points to a variable holding the prospective
  252.    CALL_INSN_FUNCTION_USAGE information.  */
  253.  
  254. rtx
  255. prepare_call_address (funexp, fndecl, call_fusage, reg_parm_seen)
  256.      rtx funexp;
  257.      tree fndecl;
  258.      rtx *call_fusage;
  259.      int reg_parm_seen;
  260. {
  261.   rtx static_chain_value = 0;
  262.  
  263.   funexp = protect_from_queue (funexp, 0);
  264.  
  265.   if (fndecl != 0)
  266.     /* Get possible static chain value for nested function in C. */
  267.     static_chain_value = lookup_static_chain (fndecl);
  268.  
  269.   /* Make a valid memory address and copy constants thru pseudo-regs,
  270.      but not for a constant address if -fno-function-cse.  */
  271.   if (GET_CODE (funexp) != SYMBOL_REF)
  272.     funexp =
  273. #ifdef SMALL_REGISTER_CLASSES
  274.     /* If we are using registers for parameters, force the
  275.      function address into a register now.  */
  276.       reg_parm_seen ? force_not_mem (memory_address (FUNCTION_MODE, funexp))
  277.             :
  278. #endif
  279.               memory_address (FUNCTION_MODE, funexp);
  280.   else
  281.     {
  282. #ifndef NO_FUNCTION_CSE
  283.       if (optimize && ! flag_no_function_cse)
  284. #ifdef NO_RECURSIVE_FUNCTION_CSE
  285.     if (fndecl != current_function_decl)
  286. #endif
  287.       funexp = force_reg (Pmode, funexp);
  288. #endif
  289.     }
  290.  
  291.   if (static_chain_value != 0)
  292.     {
  293.       emit_move_insn (static_chain_rtx, static_chain_value);
  294.  
  295.       if (GET_CODE (static_chain_rtx) == REG)
  296.     use_reg (call_fusage, static_chain_rtx);
  297.     }
  298.  
  299.   return funexp;
  300. }
  301.  
  302. /* Generate instructions to call function FUNEXP,
  303.    and optionally pop the results.
  304.    The CALL_INSN is the first insn generated.
  305.  
  306.    FNDECL is the declaration node of the function.  This is given ot the
  307.    macro RETURN_POPS_ARGS to determine whether this function pops its own args.
  308.  
  309.    FUNTYPE is the data type of the function, or, for a library call,
  310.    the identifier for the name of the call.  This is given to the
  311.    macro RETURN_POPS_ARGS to determine whether this function pops its own args.
  312.  
  313.    STACK_SIZE is the number of bytes of arguments on the stack,
  314.    rounded up to STACK_BOUNDARY; zero if the size is variable.
  315.    This is both to put into the call insn and
  316.    to generate explicit popping code if necessary.
  317.  
  318.    STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
  319.    It is zero if this call doesn't want a structure value.
  320.  
  321.    NEXT_ARG_REG is the rtx that results from executing
  322.      FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1)
  323.    just after all the args have had their registers assigned.
  324.    This could be whatever you like, but normally it is the first
  325.    arg-register beyond those used for args in this call,
  326.    or 0 if all the arg-registers are used in this call.
  327.    It is passed on to `gen_call' so you can put this info in the call insn.
  328.  
  329.    VALREG is a hard register in which a value is returned,
  330.    or 0 if the call does not return a value.
  331.  
  332.    OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before
  333.    the args to this call were processed.
  334.    We restore `inhibit_defer_pop' to that value.
  335.  
  336.    CALL_FUSAGE is either empty or an EXPR_LIST of USE expressions that
  337.    denote registers used by the called function.
  338.  
  339.    IS_CONST is true if this is a `const' call.  */
  340.  
  341. static void
  342. emit_call_1 (funexp, fndecl, funtype, stack_size, struct_value_size, 
  343.              next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
  344.          is_const)
  345.      rtx funexp;
  346.      tree fndecl;
  347.      tree funtype;
  348.      int stack_size;
  349.      int struct_value_size;
  350.      rtx next_arg_reg;
  351.      rtx valreg;
  352.      int old_inhibit_defer_pop;
  353.      rtx call_fusage;
  354.      int is_const;
  355. {
  356.   rtx stack_size_rtx = GEN_INT (stack_size);
  357.   rtx struct_value_size_rtx = GEN_INT (struct_value_size);
  358.   rtx call_insn;
  359.   int already_popped = 0;
  360.  
  361.   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
  362.      and we don't want to load it into a register as an optimization,
  363.      because prepare_call_address already did it if it should be done.  */
  364.   if (GET_CODE (funexp) != SYMBOL_REF)
  365.     funexp = memory_address (FUNCTION_MODE, funexp);
  366.  
  367. #ifndef ACCUMULATE_OUTGOING_ARGS
  368. #if defined (HAVE_call_pop) && defined (HAVE_call_value_pop)
  369.   if (HAVE_call_pop && HAVE_call_value_pop
  370.       && (RETURN_POPS_ARGS (fndecl, funtype, stack_size) > 0 
  371.           || stack_size == 0))
  372.     {
  373.       rtx n_pop = GEN_INT (RETURN_POPS_ARGS (fndecl, funtype, stack_size));
  374.       rtx pat;
  375.  
  376.       /* If this subroutine pops its own args, record that in the call insn
  377.      if possible, for the sake of frame pointer elimination.  */
  378.  
  379.       if (valreg)
  380.     pat = gen_call_value_pop (valreg,
  381.                   gen_rtx (MEM, FUNCTION_MODE, funexp),
  382.                   stack_size_rtx, next_arg_reg, n_pop);
  383.       else
  384.     pat = gen_call_pop (gen_rtx (MEM, FUNCTION_MODE, funexp),
  385.                 stack_size_rtx, next_arg_reg, n_pop);
  386.  
  387.       emit_call_insn (pat);
  388.       already_popped = 1;
  389.     }
  390.   else
  391. #endif
  392. #endif
  393.  
  394. #if defined (HAVE_call) && defined (HAVE_call_value)
  395.   if (HAVE_call && HAVE_call_value)
  396.     {
  397.       if (valreg)
  398.     emit_call_insn (gen_call_value (valreg,
  399.                     gen_rtx (MEM, FUNCTION_MODE, funexp),
  400.                     stack_size_rtx, next_arg_reg,
  401.                     NULL_RTX));
  402.       else
  403.     emit_call_insn (gen_call (gen_rtx (MEM, FUNCTION_MODE, funexp),
  404.                   stack_size_rtx, next_arg_reg,
  405.                   struct_value_size_rtx));
  406.     }
  407.   else
  408. #endif
  409.     abort ();
  410.  
  411.   /* Find the CALL insn we just emitted.  */
  412.   for (call_insn = get_last_insn ();
  413.        call_insn && GET_CODE (call_insn) != CALL_INSN;
  414.        call_insn = PREV_INSN (call_insn))
  415.     ;
  416.  
  417.   if (! call_insn)
  418.     abort ();
  419.  
  420.   /* Put the register usage information on the CALL.  If there is already
  421.      some usage information, put ours at the end.  */
  422.   if (CALL_INSN_FUNCTION_USAGE (call_insn))
  423.     {
  424.       rtx link;
  425.  
  426.       for (link = CALL_INSN_FUNCTION_USAGE (call_insn); XEXP (link, 1) != 0;
  427.        link = XEXP (link, 1))
  428.     ;
  429.  
  430.       XEXP (link, 1) = call_fusage;
  431.     }
  432.   else
  433.     CALL_INSN_FUNCTION_USAGE (call_insn) = call_fusage;
  434.  
  435.   /* If this is a const call, then set the insn's unchanging bit.  */
  436.   if (is_const)
  437.     CONST_CALL_P (call_insn) = 1;
  438.  
  439.   /* Restore this now, so that we do defer pops for this call's args
  440.      if the context of the call as a whole permits.  */
  441.   inhibit_defer_pop = old_inhibit_defer_pop;
  442.  
  443. #ifndef ACCUMULATE_OUTGOING_ARGS
  444.   /* If returning from the subroutine does not automatically pop the args,
  445.      we need an instruction to pop them sooner or later.
  446.      Perhaps do it now; perhaps just record how much space to pop later.
  447.  
  448.      If returning from the subroutine does pop the args, indicate that the
  449.      stack pointer will be changed.  */
  450.  
  451. #ifdef _WIN32
  452. {
  453.   int blah = 0;
  454.   if (TREE_CODE(funtype) == IDENTIFIER_NODE)
  455.     /* do nothing */;
  456.   else if (TYPE_STDCALL(funtype))
  457.     blah = stack_size;
  458.   else if ((TARGET_RTD
  459.         && (TYPE_ARG_TYPES (funtype) == 0
  460.         || (TREE_VALUE (tree_last (TYPE_ARG_TYPES (funtype)))
  461.             == void_type_node))))
  462.     blah = stack_size;
  463.   if (stack_size != 0 && blah > 0)
  464. #else
  465.   if (stack_size != 0 && RETURN_POPS_ARGS (fndecl, funtype, stack_size) > 0)
  466. #endif /* _WIN32 */
  467.     {
  468.       if (!already_popped)
  469.     CALL_INSN_FUNCTION_USAGE (call_insn) =
  470.        gen_rtx (EXPR_LIST, VOIDmode,
  471.             gen_rtx (CLOBBER, VOIDmode, stack_pointer_rtx),
  472.             CALL_INSN_FUNCTION_USAGE (call_insn));
  473.       stack_size -= RETURN_POPS_ARGS (fndecl, funtype, stack_size);
  474.       stack_size_rtx = GEN_INT (stack_size);
  475.     }
  476. #ifdef _WIN32
  477. }
  478. #endif /* _WIN32 */
  479.  
  480.   if (stack_size != 0)
  481.     {
  482.       if (flag_defer_pop && inhibit_defer_pop == 0 && !is_const)
  483.     pending_stack_adjust += stack_size;
  484.       else
  485.     adjust_stack (stack_size_rtx);
  486.     }
  487. #endif
  488. }
  489.  
  490. #if defined (_WIN32) && defined (NEXT_PDO)
  491.   /* This flag indicates whether the call returns a struct or not */
  492.   unsigned int _function_returns_struct = 0;
  493.  
  494.   /* This flag indicates when the last parameter is being pushed on the 
  495.      stack.  When we're doing a struct return with a struct > 8 bytes the
  496.      last parameter on the stack will be a "hidden" parameter which is 
  497.      the address of the struct to return to.  When we're making a call
  498.      to objc_msgSend, we want to OR the high bit on right before we push
  499.      the parameter onto the stack so that the messenger will know that
  500.      we're doing a struct return.  */
  501.   unsigned int _last_argument_being_pushed = 0;
  502. #endif /* _WIN32 */
  503.  
  504. /* Generate all the code for a function call
  505.    and return an rtx for its value.
  506.    Store the value in TARGET (specified as an rtx) if convenient.
  507.    If the value is stored in TARGET then TARGET is returned.
  508.    If IGNORE is nonzero, then we ignore the value of the function call.  */
  509.  
  510. rtx
  511. expand_call (exp, target, ignore)
  512.      tree exp;
  513.      rtx target;
  514.      int ignore;
  515. {
  516.   /* List of actual parameters.  */
  517.   tree actparms = TREE_OPERAND (exp, 1);
  518.   /* RTX for the function to be called.  */
  519.   rtx funexp;
  520.   /* Tree node for the function to be called (not the address!).  */
  521.   tree funtree;
  522.   /* Data type of the function.  */
  523.   tree funtype;
  524.   /* Declaration of the function being called,
  525.      or 0 if the function is computed (not known by name).  */
  526.   tree fndecl = 0;
  527.   char *name = 0;
  528.  
  529. #if defined (_WIN32) && defined (NEXT_PDO)
  530.   /* Under NT, struct returns are handled with a hidden parameter that
  531.      is passed on the stack.  This flag will let us indicate to gen_call
  532.      and gen_call_value that it needs to set a flag in one of the 
  533.      registers so that objc_msgSend knows that self is actually the 
  534.      2nd parameter on the stack and that sel is the 3rd.  */
  535.      int _function_returns_struct_local = 0;
  536. #endif /* _WIN32 */
  537.  
  538.   /* Register in which non-BLKmode value will be returned,
  539.      or 0 if no value or if value is BLKmode.  */
  540.   rtx valreg;
  541.   /* Address where we should return a BLKmode value;
  542.      0 if value not BLKmode.  */
  543.   rtx structure_value_addr = 0;
  544.   /* Nonzero if that address is being passed by treating it as
  545.      an extra, implicit first parameter.  Otherwise,
  546.      it is passed by being copied directly into struct_value_rtx.  */
  547.   int structure_value_addr_parm = 0;
  548.   /* Size of aggregate value wanted, or zero if none wanted
  549.      or if we are using the non-reentrant PCC calling convention
  550.      or expecting the value in registers.  */
  551.   int struct_value_size = 0;
  552.   /* Nonzero if called function returns an aggregate in memory PCC style,
  553.      by returning the address of where to find it.  */
  554.   int pcc_struct_value = 0;
  555.  
  556.   /* Number of actual parameters in this call, including struct value addr.  */
  557.   int num_actuals;
  558.   /* Number of named args.  Args after this are anonymous ones
  559.      and they must all go on the stack.  */
  560.   int n_named_args;
  561.   /* Count arg position in order args appear.  */
  562.   int argpos;
  563.  
  564.   /* Vector of information about each argument.
  565.      Arguments are numbered in the order they will be pushed,
  566.      not the order they are written.  */
  567.   struct arg_data *args;
  568.  
  569.   /* Total size in bytes of all the stack-parms scanned so far.  */
  570.   struct args_size args_size;
  571.   /* Size of arguments before any adjustments (such as rounding).  */
  572.   struct args_size original_args_size;
  573.   /* Data on reg parms scanned so far.  */
  574.   CUMULATIVE_ARGS args_so_far;
  575.   /* Nonzero if a reg parm has been scanned.  */
  576.   int reg_parm_seen;
  577.   /* Nonzero if this is an indirect function call.  */
  578.   int current_call_is_indirect = 0;
  579.  
  580.   /* Nonzero if we must avoid push-insns in the args for this call. 
  581.      If stack space is allocated for register parameters, but not by the
  582.      caller, then it is preallocated in the fixed part of the stack frame.
  583.      So the entire argument block must then be preallocated (i.e., we
  584.      ignore PUSH_ROUNDING in that case).  */
  585.  
  586. #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
  587.   int must_preallocate = 1;
  588. #else
  589. #ifdef PUSH_ROUNDING
  590.   int must_preallocate = 0;
  591. #else
  592.   int must_preallocate = 1;
  593. #endif
  594. #endif
  595.  
  596.   /* Size of the stack reserved for parameter registers.  */
  597.   int reg_parm_stack_space = 0;
  598.  
  599.   /* 1 if scanning parms front to back, -1 if scanning back to front.  */
  600.   int inc;
  601.   /* Address of space preallocated for stack parms
  602.      (on machines that lack push insns), or 0 if space not preallocated.  */
  603.   rtx argblock = 0;
  604.  
  605.   /* Nonzero if it is plausible that this is a call to alloca.  */
  606.   int may_be_alloca;
  607.   /* Nonzero if this is a call to setjmp or a related function.  */
  608.   int returns_twice;
  609.   /* Nonzero if this is a call to `longjmp'.  */
  610.   int is_longjmp;
  611.   /* Nonzero if this is a call to an inline function.  */
  612.   int is_integrable = 0;
  613.   /* Nonzero if this is a call to a `const' function.
  614.      Note that only explicitly named functions are handled as `const' here.  */
  615.   int is_const = 0;
  616. #ifdef _WIN32
  617.   int is_stdcall = 0;
  618. #endif /* _WIN32 */
  619.   /* Nonzero if this is a call to a `volatile' function.  */
  620.   int is_volatile = 0;
  621. #if defined(ACCUMULATE_OUTGOING_ARGS) && defined(REG_PARM_STACK_SPACE)
  622.   /* Define the boundary of the register parm stack space that needs to be
  623.      save, if any.  */
  624.   int low_to_save = -1, high_to_save;
  625.   rtx save_area = 0;        /* Place that it is saved */
  626. #endif
  627.  
  628. #ifdef ACCUMULATE_OUTGOING_ARGS
  629.   int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
  630.   char *initial_stack_usage_map = stack_usage_map;
  631. #endif
  632.  
  633.   rtx old_stack_level = 0;
  634.   int old_pending_adj = 0;
  635.   int old_stack_arg_under_construction;
  636.   int old_inhibit_defer_pop = inhibit_defer_pop;
  637.   tree old_cleanups = cleanups_this_call;
  638.   rtx call_fusage = 0;
  639.   register tree p;
  640.   register int i, j;
  641.  
  642.   /* See if we can find a DECL-node for the actual function.
  643.      As a result, decide whether this is a call to an integrable function.  */
  644.  
  645.   p = TREE_OPERAND (exp, 0);
  646.   if (TREE_CODE (p) == ADDR_EXPR)
  647.     {
  648.       fndecl = TREE_OPERAND (p, 0);
  649.       if (TREE_CODE (fndecl) != FUNCTION_DECL)
  650.     fndecl = 0;
  651.       else
  652.     {
  653.       if (!flag_no_inline
  654.           && fndecl != current_function_decl
  655.           && DECL_INLINE (fndecl)
  656.           && DECL_SAVED_INSNS (fndecl))
  657.         is_integrable = 1;
  658.       else if (! TREE_ADDRESSABLE (fndecl))
  659.         {
  660.           /* In case this function later becomes inlinable,
  661.          record that there was already a non-inline call to it.
  662.  
  663.          Use abstraction instead of setting TREE_ADDRESSABLE
  664.          directly.  */
  665.           if (DECL_INLINE (fndecl) && warn_inline && !flag_no_inline)
  666.         {
  667.           warning_with_decl (fndecl, "can't inline call to `%s'");
  668.           warning ("called from here");
  669.         }
  670.           mark_addressable (fndecl);
  671.         }
  672.  
  673.       if (TREE_READONLY (fndecl) && ! TREE_THIS_VOLATILE (fndecl)
  674.           && TYPE_MODE (TREE_TYPE (exp)) != VOIDmode)
  675.         is_const = 1;
  676.  
  677.       if (TREE_THIS_VOLATILE (fndecl))
  678.         is_volatile = 1;
  679.     }
  680.     }
  681.  
  682.   /* If we don't have specific function to call, see if we have a 
  683.      constant or `noreturn' function from the type.  */
  684.   if (fndecl == 0)
  685.     {
  686.       is_const = TREE_READONLY (TREE_TYPE (TREE_TYPE (p)));
  687.       is_volatile = TREE_THIS_VOLATILE (TREE_TYPE (TREE_TYPE (p)));
  688. #ifdef _WIN32 
  689.       is_stdcall = TYPE_STDCALL (TREE_TYPE (p));
  690. #endif /* _WIN32 */
  691.     }
  692.  
  693. #ifdef REG_PARM_STACK_SPACE
  694. #ifdef MAYBE_REG_PARM_STACK_SPACE
  695.   reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
  696. #else
  697.   reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
  698. #endif
  699. #endif
  700.  
  701.   /* Warn if this value is an aggregate type,
  702.      regardless of which calling convention we are using for it.  */
  703.   if (warn_aggregate_return && AGGREGATE_TYPE_P (TREE_TYPE (exp)))
  704.     warning ("function call has aggregate value");
  705.  
  706.   /* Set up a place to return a structure.  */
  707.  
  708.   /* Cater to broken compilers.  */
  709.   if (aggregate_value_p (exp))
  710.     {
  711.       /* This call returns a big structure.  */
  712.       is_const = 0;
  713.  
  714. #ifdef PCC_STATIC_STRUCT_RETURN
  715.       {
  716.     pcc_struct_value = 1;
  717.     /* Easier than making that case work right.  */
  718.     if (is_integrable)
  719.       {
  720.         /* In case this is a static function, note that it has been
  721.            used.  */
  722.         if (! TREE_ADDRESSABLE (fndecl))
  723.           mark_addressable (fndecl);
  724.         is_integrable = 0;
  725.       }
  726.       }
  727. #else /* not PCC_STATIC_STRUCT_RETURN */
  728.       {
  729.     struct_value_size = int_size_in_bytes (TREE_TYPE (exp));
  730.  
  731.     if (target && GET_CODE (target) == MEM)
  732.       structure_value_addr = XEXP (target, 0);
  733.     else
  734.       {
  735.         /* Assign a temporary on the stack to hold the value.  */
  736.  
  737.         /* For variable-sized objects, we must be called with a target
  738.            specified.  If we were to allocate space on the stack here,
  739.            we would have no way of knowing when to free it.  */
  740.  
  741.         if (struct_value_size < 0)
  742.           abort ();
  743.  
  744.         structure_value_addr
  745.           = XEXP (assign_stack_temp (BLKmode, struct_value_size, 1), 0);
  746.         MEM_IN_STRUCT_P (structure_value_addr)
  747.           = AGGREGATE_TYPE_P (TREE_TYPE (exp));
  748.         target = 0;
  749.       }
  750.       }
  751. #endif /* not PCC_STATIC_STRUCT_RETURN */
  752.     }
  753.  
  754.   /* If called function is inline, try to integrate it.  */
  755.  
  756.   if (is_integrable)
  757.     {
  758.       rtx temp;
  759.       rtx before_call = get_last_insn ();
  760.  
  761.       temp = expand_inline_function (fndecl, actparms, target,
  762.                      ignore, TREE_TYPE (exp),
  763.                      structure_value_addr);
  764.  
  765.       /* If inlining succeeded, return.  */
  766.       if ((HOST_WIDE_INT) temp != -1)
  767.     {
  768.       if (flag_short_temps)
  769.         {
  770.           /* Perform all cleanups needed for the arguments of this
  771.          call (i.e. destructors in C++).  It is ok if these
  772.          destructors clobber RETURN_VALUE_REG, because the
  773.          only time we care about this is when TARGET is that
  774.          register.  But in C++, we take care to never return
  775.          that register directly.  */
  776.           expand_cleanups_to (old_cleanups);
  777.         }
  778.  
  779. #ifdef ACCUMULATE_OUTGOING_ARGS
  780.       /* If the outgoing argument list must be preserved, push
  781.          the stack before executing the inlined function if it
  782.          makes any calls.  */
  783.  
  784.       for (i = reg_parm_stack_space - 1; i >= 0; i--)
  785.         if (i < highest_outgoing_arg_in_use && stack_usage_map[i] != 0)
  786.           break;
  787.  
  788.       if (stack_arg_under_construction || i >= 0)
  789.         {
  790.           rtx insn = NEXT_INSN (before_call), seq;
  791.  
  792.           /* Look for a call in the inline function code.
  793.          If OUTGOING_ARGS_SIZE (DECL_SAVED_INSNS (fndecl)) is
  794.          nonzero then there is a call and it is not necessary
  795.          to scan the insns.  */
  796.  
  797.           if (OUTGOING_ARGS_SIZE (DECL_SAVED_INSNS (fndecl)) == 0)
  798.         for (; insn; insn = NEXT_INSN (insn))
  799.           if (GET_CODE (insn) == CALL_INSN)
  800.             break;
  801.  
  802.           if (insn)
  803.         {
  804.           /* Reserve enough stack space so that the largest
  805.              argument list of any function call in the inline
  806.              function does not overlap the argument list being
  807.              evaluated.  This is usually an overestimate because
  808.              allocate_dynamic_stack_space reserves space for an
  809.              outgoing argument list in addition to the requested
  810.              space, but there is no way to ask for stack space such
  811.              that an argument list of a certain length can be
  812.              safely constructed.  */
  813.  
  814.           int adjust = OUTGOING_ARGS_SIZE (DECL_SAVED_INSNS (fndecl));
  815. #ifdef REG_PARM_STACK_SPACE
  816.           /* Add the stack space reserved for register arguments
  817.              in the inline function.  What is really needed is the
  818.              largest value of reg_parm_stack_space in the inline
  819.              function, but that is not available.  Using the current
  820.              value of reg_parm_stack_space is wrong, but gives
  821.              correct results on all supported machines.  */
  822.           adjust += reg_parm_stack_space;
  823. #endif
  824.           start_sequence ();
  825.           emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
  826.           allocate_dynamic_stack_space (GEN_INT (adjust),
  827.                         NULL_RTX, BITS_PER_UNIT);
  828.           seq = get_insns ();
  829.           end_sequence ();
  830.           emit_insns_before (seq, NEXT_INSN (before_call));
  831.           emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
  832.         }
  833.         }
  834. #endif
  835.  
  836.       /* If the result is equivalent to TARGET, return TARGET to simplify
  837.          checks in store_expr.  They can be equivalent but not equal in the
  838.          case of a function that returns BLKmode.  */
  839.       if (temp != target && rtx_equal_p (temp, target))
  840.         return target;
  841.       return temp;
  842.     }
  843.  
  844.       /* If inlining failed, mark FNDECL as needing to be compiled
  845.      separately after all.  If function was declared inline,
  846.      give a warning.  */
  847.       if (DECL_INLINE (fndecl) && warn_inline && !flag_no_inline
  848.       && ! TREE_ADDRESSABLE (fndecl))
  849.     {
  850.       warning_with_decl (fndecl, "inlining failed in call to `%s'");
  851.       warning ("called from here");
  852.     }
  853.       mark_addressable (fndecl);
  854.     }
  855.  
  856.   /* When calling a const function, we must pop the stack args right away,
  857.      so that the pop is deleted or moved with the call.  */
  858.   if (is_const)
  859.     NO_DEFER_POP;
  860.  
  861.   function_call_count++;
  862.  
  863.   if (fndecl && DECL_NAME (fndecl))
  864.     name = IDENTIFIER_POINTER (DECL_NAME (fndecl));
  865.  
  866.   /* On some machines (such as the PA) indirect calls have a different
  867.      calling convention than normal calls.  FUNCTION_ARG in the target
  868.      description can look at current_call_is_indirect to determine which
  869.      calling convention to use.  */
  870.   current_call_is_indirect = (fndecl == 0);
  871. #if 0
  872.     = TREE_CODE (TREE_OPERAND (exp, 0)) == NON_LVALUE_EXPR ? 1 : 0;
  873. #endif
  874.  
  875. #if 0
  876.   /* Unless it's a call to a specific function that isn't alloca,
  877.      if it has one argument, we must assume it might be alloca.  */
  878.  
  879.   may_be_alloca =
  880.     (!(fndecl != 0 && strcmp (name, "alloca"))
  881.      && actparms != 0
  882.      && TREE_CHAIN (actparms) == 0);
  883. #else
  884.   /* We assume that alloca will always be called by name.  It
  885.      makes no sense to pass it as a pointer-to-function to
  886.      anything that does not understand its behavior.  */
  887.   may_be_alloca =
  888.     (name && ((IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 6
  889.          && name[0] == 'a'
  890.          && ! strcmp (name, "alloca"))
  891.         || (IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 16
  892.             && name[0] == '_'
  893.             && ! strcmp (name, "__builtin_alloca"))));
  894. #endif
  895.  
  896.   /* See if this is a call to a function that can return more than once
  897.      or a call to longjmp.  */
  898.  
  899.   returns_twice = 0;
  900.   is_longjmp = 0;
  901.  
  902.   if (name != 0 && IDENTIFIER_LENGTH (DECL_NAME (fndecl)) <= 15)
  903.     {
  904.       char *tname = name;
  905.  
  906.       /* Disregard prefix _, __ or __x.  */
  907.       if (name[0] == '_')
  908.     {
  909.       if (name[1] == '_' && name[2] == 'x')
  910.         tname += 3;
  911.       else if (name[1] == '_')
  912.         tname += 2;
  913.       else
  914.         tname += 1;
  915.     }
  916.  
  917.       if (tname[0] == 's')
  918.     {
  919.       returns_twice
  920.         = ((tname[1] == 'e'
  921.         && (! strcmp (tname, "setjmp")
  922.             || ! strcmp (tname, "setjmp_syscall")))
  923.            || (tname[1] == 'i'
  924.            && ! strcmp (tname, "sigsetjmp"))
  925.            || (tname[1] == 'a'
  926.            && ! strcmp (tname, "savectx")));
  927.       if (tname[1] == 'i'
  928.           && ! strcmp (tname, "siglongjmp"))
  929.         is_longjmp = 1;
  930.     }
  931.       else if ((tname[0] == 'q' && tname[1] == 's'
  932.         && ! strcmp (tname, "qsetjmp"))
  933.            || (tname[0] == 'v' && tname[1] == 'f'
  934.            && ! strcmp (tname, "vfork")))
  935.     returns_twice = 1;
  936.  
  937.       else if (tname[0] == 'l' && tname[1] == 'o'
  938.            && ! strcmp (tname, "longjmp"))
  939.     is_longjmp = 1;
  940.     }
  941.  
  942.   if (may_be_alloca)
  943.     current_function_calls_alloca = 1;
  944.  
  945.   /* Don't let pending stack adjusts add up to too much.
  946.      Also, do all pending adjustments now
  947.      if there is any chance this might be a call to alloca.  */
  948.  
  949.   if (pending_stack_adjust >= 32
  950.       || (pending_stack_adjust > 0 && may_be_alloca))
  951.     do_pending_stack_adjust ();
  952.  
  953.   /* Operand 0 is a pointer-to-function; get the type of the function.  */
  954.   funtype = TREE_TYPE (TREE_OPERAND (exp, 0));
  955.   if (TREE_CODE (funtype) != POINTER_TYPE)
  956.     abort ();
  957.   funtype = TREE_TYPE (funtype);
  958.  
  959.   /* Push the temporary stack slot level so that we can free any temporaries
  960.      we make.  */
  961.   push_temp_slots ();
  962.  
  963.   /* Start updating where the next arg would go.  */
  964.   INIT_CUMULATIVE_ARGS (args_so_far, funtype, NULL_RTX);
  965.  
  966. #if defined (_WIN32) && defined (NEXT_PDO)
  967.   /* If this function returns a struct, AND we're calling either objc_msgSend or
  968.      objc_msgSendSuper, then set our local flag so that when the function call
  969.      is emitted, it will OR the high bit of the parameter pushed on the stack
  970.      so that the messenger knows that it's doing a struct return method and 
  971.      that self and sel are one parameter further on the stack than they thought. */
  972.   if (structure_value_addr && struct_value_rtx == 0)
  973.     if (name && ((!strcmp (name, "objc_msgSend"))
  974.          || (!strcmp (name, "objc_msgSendSuper"))))
  975.       _function_returns_struct_local = 1;
  976.     else
  977.       _function_returns_struct_local = 0;
  978.   else
  979.     _function_returns_struct_local = 0;
  980. #endif /* _WIN32 */
  981.  
  982.   /* If struct_value_rtx is 0, it means pass the address
  983.      as if it were an extra parameter.  */
  984.   if (structure_value_addr && struct_value_rtx == 0)
  985.     {
  986.       /* If structure_value_addr is a REG other than
  987.      virtual_outgoing_args_rtx, we can use always use it.  If it
  988.      is not a REG, we must always copy it into a register.
  989.      If it is virtual_outgoing_args_rtx, we must copy it to another
  990.      register in some cases.  */
  991.       rtx temp = (GET_CODE (structure_value_addr) != REG
  992. #ifdef ACCUMULATE_OUTGOING_ARGS
  993.           || (stack_arg_under_construction
  994.               && structure_value_addr == virtual_outgoing_args_rtx)
  995. #endif
  996.           ? copy_addr_to_reg (structure_value_addr)
  997.           : structure_value_addr);
  998.  
  999.       actparms
  1000.     = tree_cons (error_mark_node,
  1001.              make_tree (build_pointer_type (TREE_TYPE (funtype)),
  1002.                 temp),
  1003.              actparms);
  1004.       structure_value_addr_parm = 1;
  1005.     }
  1006.  
  1007.   /* Count the arguments and set NUM_ACTUALS.  */
  1008.   for (p = actparms, i = 0; p; p = TREE_CHAIN (p)) i++;
  1009.   num_actuals = i;
  1010.  
  1011.   /* Compute number of named args.
  1012.      Normally, don't include the last named arg if anonymous args follow.
  1013.      We do include the last named arg if STRICT_ARGUMENT_NAMING is defined.
  1014.      (If no anonymous args follow, the result of list_length is actually
  1015.      one too large.  This is harmless.)
  1016.  
  1017.      If SETUP_INCOMING_VARARGS is defined and STRICT_ARGUMENT_NAMING is not,
  1018.      this machine will be able to place unnamed args that were passed in
  1019.      registers into the stack.  So treat all args as named.  This allows the
  1020.      insns emitting for a specific argument list to be independent of the
  1021.      function declaration.
  1022.  
  1023.      If SETUP_INCOMING_VARARGS is not defined, we do not have any reliable
  1024.      way to pass unnamed args in registers, so we must force them into
  1025.      memory.  */
  1026. #if !defined(SETUP_INCOMING_VARARGS) || defined(STRICT_ARGUMENT_NAMING)
  1027.   if (TYPE_ARG_TYPES (funtype) != 0)
  1028.     n_named_args
  1029.       = (list_length (TYPE_ARG_TYPES (funtype))
  1030. #ifndef STRICT_ARGUMENT_NAMING
  1031.      /* Don't include the last named arg.  */
  1032.      - 1
  1033. #endif
  1034.      /* Count the struct value address, if it is passed as a parm.  */
  1035.      + structure_value_addr_parm);
  1036.   else
  1037. #endif
  1038.     /* If we know nothing, treat all args as named.  */
  1039.     n_named_args = num_actuals;
  1040.  
  1041.   /* Make a vector to hold all the information about each arg.  */
  1042.   args = (struct arg_data *) alloca (num_actuals * sizeof (struct arg_data));
  1043.   bzero ((char *) args, num_actuals * sizeof (struct arg_data));
  1044.  
  1045.   args_size.constant = 0;
  1046.   args_size.var = 0;
  1047.  
  1048.   /* In this loop, we consider args in the order they are written.
  1049.      We fill up ARGS from the front or from the back if necessary
  1050.      so that in any case the first arg to be pushed ends up at the front.  */
  1051.  
  1052. #ifdef PUSH_ARGS_REVERSED
  1053.   i = num_actuals - 1, inc = -1;
  1054.   /* In this case, must reverse order of args
  1055.      so that we compute and push the last arg first.  */
  1056. #else
  1057.   i = 0, inc = 1;
  1058. #endif
  1059.  
  1060.   /* I counts args in order (to be) pushed; ARGPOS counts in order written.  */
  1061.   for (p = actparms, argpos = 0; p; p = TREE_CHAIN (p), i += inc, argpos++)
  1062.     {
  1063.       tree type = TREE_TYPE (TREE_VALUE (p));
  1064.       int unsignedp;
  1065.       enum machine_mode mode;
  1066.  
  1067.       args[i].tree_value = TREE_VALUE (p);
  1068.  
  1069.       /* Replace erroneous argument with constant zero.  */
  1070.       if (type == error_mark_node || TYPE_SIZE (type) == 0)
  1071.     args[i].tree_value = integer_zero_node, type = integer_type_node;
  1072.  
  1073.       /* If TYPE is a transparent union, pass things the way we would
  1074.      pass the first field of the union.  We have already verified that
  1075.      the modes are the same.  */
  1076.       if (TYPE_TRANSPARENT_UNION (type))
  1077.     type = TREE_TYPE (TYPE_FIELDS (type));
  1078.  
  1079.       /* Decide where to pass this arg.
  1080.  
  1081.      args[i].reg is nonzero if all or part is passed in registers.
  1082.  
  1083.      args[i].partial is nonzero if part but not all is passed in registers,
  1084.      and the exact value says how many words are passed in registers.
  1085.  
  1086.      args[i].pass_on_stack is nonzero if the argument must at least be
  1087.      computed on the stack.  It may then be loaded back into registers
  1088.      if args[i].reg is nonzero.
  1089.  
  1090.      These decisions are driven by the FUNCTION_... macros and must agree
  1091.      with those made by function.c.  */
  1092.  
  1093.       /* See if this argument should be passed by invisible reference.  */
  1094.       if ((TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST
  1095.        && contains_placeholder_p (TYPE_SIZE (type)))
  1096.       || TREE_ADDRESSABLE (type)
  1097. #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
  1098.       || FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, TYPE_MODE (type),
  1099.                          type, argpos < n_named_args)
  1100. #endif
  1101.       )
  1102.     {
  1103. #ifdef FUNCTION_ARG_CALLEE_COPIES
  1104.       if (FUNCTION_ARG_CALLEE_COPIES (args_so_far, TYPE_MODE (type), type,
  1105.                       argpos < n_named_args)
  1106.           /* If it's in a register, we must make a copy of it too.  */
  1107.           /* ??? Is this a sufficient test?  Is there a better one? */
  1108.           && !(TREE_CODE (args[i].tree_value) == VAR_DECL
  1109.            && REG_P (DECL_RTL (args[i].tree_value)))
  1110.           && ! TREE_ADDRESSABLE (type))
  1111.         {
  1112.           args[i].tree_value = build1 (ADDR_EXPR,
  1113.                        build_pointer_type (type),
  1114.                        args[i].tree_value);
  1115.           type = build_pointer_type (type);
  1116.         }
  1117.       else
  1118. #endif
  1119.         {
  1120.           /* We make a copy of the object and pass the address to the
  1121.          function being called.  */
  1122.           rtx copy;
  1123.  
  1124.           if (TYPE_SIZE (type) == 0
  1125.           || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
  1126.         {
  1127.           /* This is a variable-sized object.  Make space on the stack
  1128.              for it.  */
  1129.           rtx size_rtx = expr_size (TREE_VALUE (p));
  1130.  
  1131.           if (old_stack_level == 0)
  1132.             {
  1133.               emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
  1134.               old_pending_adj = pending_stack_adjust;
  1135.               pending_stack_adjust = 0;
  1136.             }
  1137.  
  1138.           copy = gen_rtx (MEM, BLKmode,
  1139.                   allocate_dynamic_stack_space (size_rtx,
  1140.                                 NULL_RTX,
  1141.                                 TYPE_ALIGN (type)));
  1142.         }
  1143.           else
  1144.         {
  1145.           int size = int_size_in_bytes (type);
  1146.           copy = assign_stack_temp (TYPE_MODE (type), size, 0);
  1147.         }
  1148.  
  1149.           MEM_IN_STRUCT_P (copy) = AGGREGATE_TYPE_P (type);
  1150.  
  1151.           store_expr (args[i].tree_value, copy, 0);
  1152.  
  1153.           args[i].tree_value = build1 (ADDR_EXPR,
  1154.                        build_pointer_type (type),
  1155.                        make_tree (type, copy));
  1156.           type = build_pointer_type (type);
  1157.         }
  1158.     }
  1159.  
  1160.       mode = TYPE_MODE (type);
  1161.       unsignedp = TREE_UNSIGNED (type);
  1162.  
  1163. #ifdef PROMOTE_FUNCTION_ARGS
  1164.       mode = promote_mode (type, mode, &unsignedp, 1);
  1165. #endif
  1166.  
  1167.       args[i].unsignedp = unsignedp;
  1168.       args[i].mode = mode;
  1169.       args[i].reg = FUNCTION_ARG (args_so_far, mode, type,
  1170.                   argpos < n_named_args);
  1171. #ifdef FUNCTION_ARG_PARTIAL_NREGS
  1172.       if (args[i].reg)
  1173.     args[i].partial
  1174.       = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, type,
  1175.                     argpos < n_named_args);
  1176. #endif
  1177.  
  1178.       args[i].pass_on_stack = MUST_PASS_IN_STACK (mode, type);
  1179.  
  1180.       /* If FUNCTION_ARG returned an (expr_list (nil) FOO), it means that
  1181.      we are to pass this arg in the register(s) designated by FOO, but
  1182.      also to pass it in the stack.  */
  1183.       if (args[i].reg && GET_CODE (args[i].reg) == EXPR_LIST
  1184.       && XEXP (args[i].reg, 0) == 0)
  1185.     args[i].pass_on_stack = 1, args[i].reg = XEXP (args[i].reg, 1);
  1186.  
  1187.       /* If this is an addressable type, we must preallocate the stack
  1188.      since we must evaluate the object into its final location.
  1189.  
  1190.      If this is to be passed in both registers and the stack, it is simpler
  1191.      to preallocate.  */
  1192.       if (TREE_ADDRESSABLE (type)
  1193.       || (args[i].pass_on_stack && args[i].reg != 0))
  1194.     must_preallocate = 1;
  1195.  
  1196.       /* If this is an addressable type, we cannot pre-evaluate it.  Thus,
  1197.      we cannot consider this function call constant.  */
  1198.       if (TREE_ADDRESSABLE (type))
  1199.     is_const = 0;
  1200.  
  1201.       /* Compute the stack-size of this argument.  */
  1202.       if (args[i].reg == 0 || args[i].partial != 0
  1203. #ifdef REG_PARM_STACK_SPACE
  1204.       || reg_parm_stack_space > 0
  1205. #endif
  1206.       || args[i].pass_on_stack)
  1207.     locate_and_pad_parm (mode, type,
  1208. #ifdef STACK_PARMS_IN_REG_PARM_AREA
  1209.                  1,
  1210. #else
  1211.                  args[i].reg != 0,
  1212. #endif
  1213.                  fndecl, &args_size, &args[i].offset,
  1214.                  &args[i].size);
  1215.  
  1216. #ifndef ARGS_GROW_DOWNWARD
  1217.       args[i].slot_offset = args_size;
  1218. #endif
  1219.  
  1220. #ifndef REG_PARM_STACK_SPACE
  1221.       /* If a part of the arg was put into registers,
  1222.      don't include that part in the amount pushed.  */
  1223.       if (! args[i].pass_on_stack)
  1224.     args[i].size.constant -= ((args[i].partial * UNITS_PER_WORD)
  1225.                   / (PARM_BOUNDARY / BITS_PER_UNIT)
  1226.                   * (PARM_BOUNDARY / BITS_PER_UNIT));
  1227. #endif
  1228.       
  1229.       /* Update ARGS_SIZE, the total stack space for args so far.  */
  1230.  
  1231.       args_size.constant += args[i].size.constant;
  1232.       if (args[i].size.var)
  1233.     {
  1234.       ADD_PARM_SIZE (args_size, args[i].size.var);
  1235.     }
  1236.  
  1237.       /* Since the slot offset points to the bottom of the slot,
  1238.      we must record it after incrementing if the args grow down.  */
  1239. #ifdef ARGS_GROW_DOWNWARD
  1240.       args[i].slot_offset = args_size;
  1241.  
  1242.       args[i].slot_offset.constant = -args_size.constant;
  1243.       if (args_size.var)
  1244.     {
  1245.       SUB_PARM_SIZE (args[i].slot_offset, args_size.var);
  1246.     }
  1247. #endif
  1248.  
  1249.       /* Increment ARGS_SO_FAR, which has info about which arg-registers
  1250.      have been used, etc.  */
  1251.  
  1252.       FUNCTION_ARG_ADVANCE (args_so_far, TYPE_MODE (type), type,
  1253.                 argpos < n_named_args);
  1254.     }
  1255.  
  1256. #ifdef FINAL_REG_PARM_STACK_SPACE
  1257.   reg_parm_stack_space = FINAL_REG_PARM_STACK_SPACE (args_size.constant,
  1258.                              args_size.var);
  1259. #endif
  1260.       
  1261.   /* Compute the actual size of the argument block required.  The variable
  1262.      and constant sizes must be combined, the size may have to be rounded,
  1263.      and there may be a minimum required size.  */
  1264.  
  1265.   original_args_size = args_size;
  1266.   if (args_size.var)
  1267.     {
  1268.       /* If this function requires a variable-sized argument list, don't try to
  1269.      make a cse'able block for this call.  We may be able to do this
  1270.      eventually, but it is too complicated to keep track of what insns go
  1271.      in the cse'able block and which don't.  */
  1272.  
  1273.       is_const = 0;
  1274.       must_preallocate = 1;
  1275.  
  1276.       args_size.var = ARGS_SIZE_TREE (args_size);
  1277.       args_size.constant = 0;
  1278.  
  1279. #ifdef STACK_BOUNDARY
  1280.       if (STACK_BOUNDARY != BITS_PER_UNIT)
  1281.     args_size.var = round_up (args_size.var, STACK_BYTES);
  1282. #endif
  1283.  
  1284. #ifdef REG_PARM_STACK_SPACE
  1285.       if (reg_parm_stack_space > 0)
  1286.     {
  1287.       args_size.var
  1288.         = size_binop (MAX_EXPR, args_size.var,
  1289.               size_int (REG_PARM_STACK_SPACE (fndecl)));
  1290.  
  1291. #ifndef OUTGOING_REG_PARM_STACK_SPACE
  1292.       /* The area corresponding to register parameters is not to count in
  1293.          the size of the block we need.  So make the adjustment.  */
  1294.       args_size.var
  1295.         = size_binop (MINUS_EXPR, args_size.var,
  1296.               size_int (reg_parm_stack_space));
  1297. #endif
  1298.     }
  1299. #endif
  1300.     }
  1301.   else
  1302.     {
  1303. #ifdef STACK_BOUNDARY
  1304.       args_size.constant = (((args_size.constant + (STACK_BYTES - 1))
  1305.                  / STACK_BYTES) * STACK_BYTES);
  1306. #endif
  1307.  
  1308. #ifdef REG_PARM_STACK_SPACE
  1309.       args_size.constant = MAX (args_size.constant,
  1310.                 reg_parm_stack_space);
  1311. #ifdef MAYBE_REG_PARM_STACK_SPACE
  1312.       if (reg_parm_stack_space == 0)
  1313.     args_size.constant = 0;
  1314. #endif
  1315. #ifndef OUTGOING_REG_PARM_STACK_SPACE
  1316.       args_size.constant -= reg_parm_stack_space;
  1317. #endif
  1318. #endif
  1319.     }
  1320.  
  1321.   /* See if we have or want to preallocate stack space.
  1322.  
  1323.      If we would have to push a partially-in-regs parm
  1324.      before other stack parms, preallocate stack space instead.
  1325.  
  1326.      If the size of some parm is not a multiple of the required stack
  1327.      alignment, we must preallocate.
  1328.  
  1329.      If the total size of arguments that would otherwise create a copy in
  1330.      a temporary (such as a CALL) is more than half the total argument list
  1331.      size, preallocation is faster.
  1332.  
  1333.      Another reason to preallocate is if we have a machine (like the m88k)
  1334.      where stack alignment is required to be maintained between every
  1335.      pair of insns, not just when the call is made.  However, we assume here
  1336.      that such machines either do not have push insns (and hence preallocation
  1337.      would occur anyway) or the problem is taken care of with
  1338.      PUSH_ROUNDING.  */
  1339.  
  1340.   if (! must_preallocate)
  1341.     {
  1342.       int partial_seen = 0;
  1343.       int copy_to_evaluate_size = 0;
  1344.  
  1345.       for (i = 0; i < num_actuals && ! must_preallocate; i++)
  1346.     {
  1347.       if (args[i].partial > 0 && ! args[i].pass_on_stack)
  1348.         partial_seen = 1;
  1349.       else if (partial_seen && args[i].reg == 0)
  1350.         must_preallocate = 1;
  1351.  
  1352.       if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
  1353.           && (TREE_CODE (args[i].tree_value) == CALL_EXPR
  1354.           || TREE_CODE (args[i].tree_value) == TARGET_EXPR
  1355.           || TREE_CODE (args[i].tree_value) == COND_EXPR
  1356.           || TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value))))
  1357.         copy_to_evaluate_size
  1358.           += int_size_in_bytes (TREE_TYPE (args[i].tree_value));
  1359.     }
  1360.  
  1361.       if (copy_to_evaluate_size * 2 >= args_size.constant
  1362.       && args_size.constant > 0)
  1363.     must_preallocate = 1;
  1364.     }
  1365.  
  1366.   /* If the structure value address will reference the stack pointer, we must
  1367.      stabilize it.  We don't need to do this if we know that we are not going
  1368.      to adjust the stack pointer in processing this call.  */
  1369.  
  1370.   if (structure_value_addr
  1371.       && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
  1372.        || reg_mentioned_p (virtual_outgoing_args_rtx, structure_value_addr))
  1373.       && (args_size.var
  1374. #ifndef ACCUMULATE_OUTGOING_ARGS
  1375.       || args_size.constant
  1376. #endif
  1377.       ))
  1378.     structure_value_addr = copy_to_reg (structure_value_addr);
  1379.  
  1380.   /* If this function call is cse'able, precompute all the parameters.
  1381.      Note that if the parameter is constructed into a temporary, this will
  1382.      cause an additional copy because the parameter will be constructed
  1383.      into a temporary location and then copied into the outgoing arguments.
  1384.      If a parameter contains a call to alloca and this function uses the
  1385.      stack, precompute the parameter.  */
  1386.  
  1387.   /* If we preallocated the stack space, and some arguments must be passed
  1388.      on the stack, then we must precompute any parameter which contains a
  1389.      function call which will store arguments on the stack.
  1390.      Otherwise, evaluating the parameter may clobber previous parameters
  1391.      which have already been stored into the stack.  */
  1392.  
  1393.   for (i = 0; i < num_actuals; i++)
  1394.     if (is_const
  1395.     || ((args_size.var != 0 || args_size.constant != 0)
  1396.         && calls_function (args[i].tree_value, 1))
  1397.     || (must_preallocate && (args_size.var != 0 || args_size.constant != 0)
  1398.         && calls_function (args[i].tree_value, 0)))
  1399.       {
  1400.     /* If this is an addressable type, we cannot pre-evaluate it.  */
  1401.     if (TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value)))
  1402.       abort ();
  1403.  
  1404.     push_temp_slots ();
  1405.  
  1406.     args[i].initial_value = args[i].value
  1407.       = expand_expr (args[i].tree_value, NULL_RTX, VOIDmode, 0);
  1408.  
  1409.     preserve_temp_slots (args[i].value);
  1410.     pop_temp_slots ();
  1411.  
  1412.     /* ANSI doesn't require a sequence point here,
  1413.        but PCC has one, so this will avoid some problems.  */
  1414.     emit_queue ();
  1415.  
  1416.     args[i].initial_value = args[i].value
  1417.       = protect_from_queue (args[i].initial_value, 0);
  1418.  
  1419.     if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) != args[i].mode)
  1420.       args[i].value
  1421.         = convert_modes (args[i].mode, 
  1422.                  TYPE_MODE (TREE_TYPE (args[i].tree_value)),
  1423.                  args[i].value, args[i].unsignedp);
  1424.       }
  1425.  
  1426.   /* Now we are about to start emitting insns that can be deleted
  1427.      if a libcall is deleted.  */
  1428.   if (is_const)
  1429.     start_sequence ();
  1430.  
  1431.   /* If we have no actual push instructions, or shouldn't use them,
  1432.      make space for all args right now.  */
  1433.  
  1434.   if (args_size.var != 0)
  1435.     {
  1436.       if (old_stack_level == 0)
  1437.     {
  1438.       emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
  1439.       old_pending_adj = pending_stack_adjust;
  1440.       pending_stack_adjust = 0;
  1441. #ifdef ACCUMULATE_OUTGOING_ARGS
  1442.       /* stack_arg_under_construction says whether a stack arg is
  1443.          being constructed at the old stack level.  Pushing the stack
  1444.          gets a clean outgoing argument block.  */
  1445.       old_stack_arg_under_construction = stack_arg_under_construction;
  1446.       stack_arg_under_construction = 0;
  1447. #endif
  1448.     }
  1449.       argblock = push_block (ARGS_SIZE_RTX (args_size), 0, 0);
  1450.     }
  1451.   else
  1452.     {
  1453.       /* Note that we must go through the motions of allocating an argument
  1454.      block even if the size is zero because we may be storing args
  1455.      in the area reserved for register arguments, which may be part of
  1456.      the stack frame.  */
  1457.  
  1458.       int needed = args_size.constant;
  1459.  
  1460.       /* Store the maximum argument space used.  It will be pushed by the
  1461.      prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow checking). */
  1462.  
  1463.       if (needed > current_function_outgoing_args_size)
  1464.     current_function_outgoing_args_size = needed;
  1465.  
  1466.       if (must_preallocate)
  1467.     {
  1468. #ifdef ACCUMULATE_OUTGOING_ARGS
  1469.       /* Since the stack pointer will never be pushed, it is possible for
  1470.          the evaluation of a parm to clobber something we have already
  1471.          written to the stack.  Since most function calls on RISC machines
  1472.          do not use the stack, this is uncommon, but must work correctly.
  1473.  
  1474.          Therefore, we save any area of the stack that was already written
  1475.          and that we are using.  Here we set up to do this by making a new
  1476.          stack usage map from the old one.  The actual save will be done
  1477.          by store_one_arg. 
  1478.  
  1479.          Another approach might be to try to reorder the argument
  1480.          evaluations to avoid this conflicting stack usage.  */
  1481.  
  1482. #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
  1483.       /* Since we will be writing into the entire argument area, the
  1484.          map must be allocated for its entire size, not just the part that
  1485.          is the responsibility of the caller.  */
  1486.       needed += reg_parm_stack_space;
  1487. #endif
  1488.  
  1489. #ifdef ARGS_GROW_DOWNWARD
  1490.       highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
  1491.                          needed + 1);
  1492. #else
  1493.       highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
  1494.                          needed);
  1495. #endif
  1496.       stack_usage_map = (char *) alloca (highest_outgoing_arg_in_use);
  1497.  
  1498.       if (initial_highest_arg_in_use)
  1499.         bcopy (initial_stack_usage_map, stack_usage_map,
  1500.            initial_highest_arg_in_use);
  1501.  
  1502.       if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
  1503.         bzero (&stack_usage_map[initial_highest_arg_in_use],
  1504.            highest_outgoing_arg_in_use - initial_highest_arg_in_use);
  1505.       needed = 0;
  1506.  
  1507.       /* The address of the outgoing argument list must not be copied to a
  1508.          register here, because argblock would be left pointing to the
  1509.          wrong place after the call to allocate_dynamic_stack_space below.
  1510.          */
  1511.  
  1512.       argblock = virtual_outgoing_args_rtx;
  1513.  
  1514. #else /* not ACCUMULATE_OUTGOING_ARGS */
  1515.       if (inhibit_defer_pop == 0)
  1516.         {
  1517.           /* Try to reuse some or all of the pending_stack_adjust
  1518.          to get this space.  Maybe we can avoid any pushing.  */
  1519.           if (needed > pending_stack_adjust)
  1520.         {
  1521.           needed -= pending_stack_adjust;
  1522.           pending_stack_adjust = 0;
  1523.         }
  1524.           else
  1525.         {
  1526.           pending_stack_adjust -= needed;
  1527.           needed = 0;
  1528.         }
  1529.         }
  1530.       /* Special case this because overhead of `push_block' in this
  1531.          case is non-trivial.  */
  1532.       if (needed == 0)
  1533.         argblock = virtual_outgoing_args_rtx;
  1534.       else
  1535.         argblock = push_block (GEN_INT (needed), 0, 0);
  1536.  
  1537.       /* We only really need to call `copy_to_reg' in the case where push
  1538.          insns are going to be used to pass ARGBLOCK to a function
  1539.          call in ARGS.  In that case, the stack pointer changes value
  1540.          from the allocation point to the call point, and hence
  1541.          the value of VIRTUAL_OUTGOING_ARGS_RTX changes as well.
  1542.          But might as well always do it.  */
  1543.       argblock = copy_to_reg (argblock);
  1544. #endif /* not ACCUMULATE_OUTGOING_ARGS */
  1545.     }
  1546.     }
  1547.  
  1548. #ifdef ACCUMULATE_OUTGOING_ARGS
  1549.   /* The save/restore code in store_one_arg handles all cases except one:
  1550.      a constructor call (including a C function returning a BLKmode struct)
  1551.      to initialize an argument.  */
  1552.   if (stack_arg_under_construction)
  1553.     {
  1554. #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
  1555.       rtx push_size = GEN_INT (reg_parm_stack_space + args_size.constant);
  1556. #else
  1557.       rtx push_size = GEN_INT (args_size.constant);
  1558. #endif
  1559.       if (old_stack_level == 0)
  1560.     {
  1561.       emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
  1562.       old_pending_adj = pending_stack_adjust;
  1563.       pending_stack_adjust = 0;
  1564.       /* stack_arg_under_construction says whether a stack arg is
  1565.          being constructed at the old stack level.  Pushing the stack
  1566.          gets a clean outgoing argument block.  */
  1567.       old_stack_arg_under_construction = stack_arg_under_construction;
  1568.       stack_arg_under_construction = 0;
  1569.       /* Make a new map for the new argument list.  */
  1570.       stack_usage_map = (char *)alloca (highest_outgoing_arg_in_use);
  1571.       bzero (stack_usage_map, highest_outgoing_arg_in_use);
  1572.       highest_outgoing_arg_in_use = 0;
  1573.     }
  1574.       allocate_dynamic_stack_space (push_size, NULL_RTX, BITS_PER_UNIT);
  1575.     }
  1576.   /* If argument evaluation might modify the stack pointer, copy the
  1577.      address of the argument list to a register.  */
  1578.   for (i = 0; i < num_actuals; i++)
  1579.     if (args[i].pass_on_stack)
  1580.       {
  1581.     argblock = copy_addr_to_reg (argblock);
  1582.     break;
  1583.       }
  1584. #endif
  1585.  
  1586.  
  1587.   /* If we preallocated stack space, compute the address of each argument.
  1588.      We need not ensure it is a valid memory address here; it will be 
  1589.      validized when it is used.  */
  1590.   if (argblock)
  1591.     {
  1592.       rtx arg_reg = argblock;
  1593.       int arg_offset = 0;
  1594.  
  1595.       if (GET_CODE (argblock) == PLUS)
  1596.     arg_reg = XEXP (argblock, 0), arg_offset = INTVAL (XEXP (argblock, 1));
  1597.  
  1598.       for (i = 0; i < num_actuals; i++)
  1599.     {
  1600.       rtx offset = ARGS_SIZE_RTX (args[i].offset);
  1601.       rtx slot_offset = ARGS_SIZE_RTX (args[i].slot_offset);
  1602.       rtx addr;
  1603.  
  1604.       /* Skip this parm if it will not be passed on the stack.  */
  1605.       if (! args[i].pass_on_stack && args[i].reg != 0)
  1606.         continue;
  1607.  
  1608.       if (GET_CODE (offset) == CONST_INT)
  1609.         addr = plus_constant (arg_reg, INTVAL (offset));
  1610.       else
  1611.         addr = gen_rtx (PLUS, Pmode, arg_reg, offset);
  1612.  
  1613.       addr = plus_constant (addr, arg_offset);
  1614.       args[i].stack = gen_rtx (MEM, args[i].mode, addr);
  1615.       MEM_IN_STRUCT_P (args[i].stack)
  1616.         = AGGREGATE_TYPE_P (TREE_TYPE (args[i].tree_value));
  1617.  
  1618.       if (GET_CODE (slot_offset) == CONST_INT)
  1619.         addr = plus_constant (arg_reg, INTVAL (slot_offset));
  1620.       else
  1621.         addr = gen_rtx (PLUS, Pmode, arg_reg, slot_offset);
  1622.  
  1623.       addr = plus_constant (addr, arg_offset);
  1624.       args[i].stack_slot = gen_rtx (MEM, args[i].mode, addr);
  1625.     }
  1626.     }
  1627.                            
  1628. #ifdef PUSH_ARGS_REVERSED
  1629. #ifdef STACK_BOUNDARY
  1630.   /* If we push args individually in reverse order, perform stack alignment
  1631.      before the first push (the last arg).  */
  1632.   if (argblock == 0)
  1633.     anti_adjust_stack (GEN_INT (args_size.constant
  1634.                 - original_args_size.constant));
  1635. #endif
  1636. #endif
  1637.  
  1638.   /* Don't try to defer pops if preallocating, not even from the first arg,
  1639.      since ARGBLOCK probably refers to the SP.  */
  1640.   if (argblock)
  1641.     NO_DEFER_POP;
  1642.  
  1643.   /* Get the function to call, in the form of RTL.  */
  1644.   if (fndecl)
  1645.     {
  1646.       /* If this is the first use of the function, see if we need to
  1647.      make an external definition for it.  */
  1648.       if (! TREE_USED (fndecl))
  1649.     {
  1650.       assemble_external (fndecl);
  1651.       TREE_USED (fndecl) = 1;
  1652.     }
  1653. #ifdef _WIN32
  1654.     /* If the tree is marked as stdcall, then append @ and the size of 
  1655.        the parameters to the end of the assembler_name identifier. */
  1656.     if( DECL_STDCALL(fndecl) )
  1657.     {
  1658.         char* newName;
  1659.         char parm_size[255];
  1660.  
  1661.         _ltoa( args_size.constant, parm_size, 10 );
  1662.  
  1663.         // to allow for '@' and \0
  1664.         newName = (char*)malloc( strlen( IDENTIFIER_POINTER(DECL_NAME(fndecl)) ) 
  1665.             + strlen( parm_size ) + 2 ); 
  1666.  
  1667.         sprintf( newName, "%s@%s", IDENTIFIER_POINTER(DECL_NAME(fndecl)), parm_size );
  1668.         DECL_ASSEMBLER_NAME(fndecl) = get_identifier( newName );
  1669.         free( newName );
  1670.         XSTR( XEXP(DECL_RTL(fndecl), 0), 0 ) = IDENTIFIER_POINTER(DECL_ASSEMBLER_NAME(fndecl));
  1671.  
  1672.         DECL_DLLIMPORT(fndecl) = 0;
  1673.     }
  1674.  
  1675.       /* Get a SYMBOL_REF rtx for the function address.  */
  1676.         if (DECL_DLLIMPORT (fndecl))
  1677.       {
  1678.         rtx loc = XEXP( DECL_RTL (fndecl), 0 );
  1679.           if (DECL_DLLIMPORT (fndecl))
  1680.         {
  1681.             rtx addr = copy_rtx (loc);
  1682.             PUT_MODE (addr, Pmode);
  1683.  
  1684.             funexp = gen_rtx (MEM, GET_MODE (loc), force_reg (Pmode, addr));
  1685.           }
  1686.         }
  1687.       else
  1688. #endif /* _WIN32 */
  1689.  
  1690.       /* Get a SYMBOL_REF rtx for the function address.  */
  1691.       funexp = XEXP (DECL_RTL (fndecl), 0);
  1692.     }
  1693.   else
  1694.     /* Generate an rtx (probably a pseudo-register) for the address.  */
  1695.     {
  1696.       push_temp_slots ();
  1697.       funexp = expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
  1698.       pop_temp_slots ();    /* FUNEXP can't be BLKmode */
  1699.       emit_queue ();
  1700.     }
  1701.  
  1702.   /* Figure out the register where the value, if any, will come back.  */
  1703.   valreg = 0;
  1704.   if (TYPE_MODE (TREE_TYPE (exp)) != VOIDmode
  1705.       && ! structure_value_addr)
  1706.     {
  1707.       if (pcc_struct_value)
  1708.     valreg = hard_function_value (build_pointer_type (TREE_TYPE (exp)),
  1709.                       fndecl);
  1710.       else
  1711.     valreg = hard_function_value (TREE_TYPE (exp), fndecl);
  1712.     }
  1713.  
  1714.   /* Precompute all register parameters.  It isn't safe to compute anything
  1715.      once we have started filling any specific hard regs. */
  1716.   reg_parm_seen = 0;
  1717.   for (i = 0; i < num_actuals; i++)
  1718.     if (args[i].reg != 0 && ! args[i].pass_on_stack)
  1719.       {
  1720.     reg_parm_seen = 1;
  1721.  
  1722.     if (args[i].value == 0)
  1723.       {
  1724.         push_temp_slots ();
  1725.         args[i].value = expand_expr (args[i].tree_value, NULL_RTX,
  1726.                      VOIDmode, 0);
  1727.         preserve_temp_slots (args[i].value);
  1728.         pop_temp_slots ();
  1729.  
  1730.         /* ANSI doesn't require a sequence point here,
  1731.            but PCC has one, so this will avoid some problems.  */
  1732.         emit_queue ();
  1733.       }
  1734.  
  1735.     /* If we are to promote the function arg to a wider mode,
  1736.        do it now.  */
  1737.  
  1738.     if (args[i].mode != TYPE_MODE (TREE_TYPE (args[i].tree_value)))
  1739.       args[i].value
  1740.         = convert_modes (args[i].mode,
  1741.                  TYPE_MODE (TREE_TYPE (args[i].tree_value)),
  1742.                  args[i].value, args[i].unsignedp);
  1743.  
  1744.     /* If the value is expensive, and we are inside an appropriately 
  1745.        short loop, put the value into a pseudo and then put the pseudo
  1746.        into the hard reg.
  1747.  
  1748.        For small register classes, also do this if this call uses
  1749.        register parameters.  This is to avoid reload conflicts while
  1750.        loading the parameters registers.  */
  1751.  
  1752.     if ((! (GET_CODE (args[i].value) == REG
  1753.         || (GET_CODE (args[i].value) == SUBREG
  1754.             && GET_CODE (SUBREG_REG (args[i].value)) == REG)))
  1755.         && args[i].mode != BLKmode
  1756.         && rtx_cost (args[i].value, SET) > 2
  1757. #ifdef SMALL_REGISTER_CLASSES
  1758.         && (reg_parm_seen || preserve_subexpressions_p ())
  1759. #else
  1760.         && preserve_subexpressions_p ()
  1761. #endif
  1762.         )
  1763.       args[i].value = copy_to_mode_reg (args[i].mode, args[i].value);
  1764.       }
  1765.  
  1766. #if defined(ACCUMULATE_OUTGOING_ARGS) && defined(REG_PARM_STACK_SPACE)
  1767.   /* The argument list is the property of the called routine and it
  1768.      may clobber it.  If the fixed area has been used for previous
  1769.      parameters, we must save and restore it.
  1770.  
  1771.      Here we compute the boundary of the that needs to be saved, if any.  */
  1772.  
  1773. #ifdef ARGS_GROW_DOWNWARD
  1774.   for (i = 0; i < reg_parm_stack_space + 1; i++)
  1775. #else
  1776.   for (i = 0; i < reg_parm_stack_space; i++)
  1777. #endif
  1778.     {
  1779.       if (i >=  highest_outgoing_arg_in_use
  1780.       || stack_usage_map[i] == 0)
  1781.     continue;
  1782.  
  1783.       if (low_to_save == -1)
  1784.     low_to_save = i;
  1785.  
  1786.       high_to_save = i;
  1787.     }
  1788.  
  1789.   if (low_to_save >= 0)
  1790.     {
  1791.       int num_to_save = high_to_save - low_to_save + 1;
  1792.       enum machine_mode save_mode
  1793.     = mode_for_size (num_to_save * BITS_PER_UNIT, MODE_INT, 1);
  1794.       rtx stack_area;
  1795.  
  1796.       /* If we don't have the required alignment, must do this in BLKmode.  */
  1797.       if ((low_to_save & (MIN (GET_MODE_SIZE (save_mode),
  1798.                    BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1)))
  1799.     save_mode = BLKmode;
  1800.  
  1801.       stack_area = gen_rtx (MEM, save_mode,
  1802.                 memory_address (save_mode,
  1803.                         
  1804. #ifdef ARGS_GROW_DOWNWARD
  1805.                         plus_constant (argblock,
  1806.                                - high_to_save)
  1807. #else
  1808.                         plus_constant (argblock,
  1809.                                low_to_save)
  1810. #endif
  1811.                         ));
  1812.       if (save_mode == BLKmode)
  1813.     {
  1814.       save_area = assign_stack_temp (BLKmode, num_to_save, 0);
  1815.       MEM_IN_STRUCT_P (save_area) = 0;
  1816.       emit_block_move (validize_mem (save_area), stack_area,
  1817.                GEN_INT (num_to_save),
  1818.                PARM_BOUNDARY / BITS_PER_UNIT);
  1819.     }
  1820.       else
  1821.     {
  1822.       save_area = gen_reg_rtx (save_mode);
  1823.       emit_move_insn (save_area, stack_area);
  1824.     }
  1825.     }
  1826. #endif
  1827.       
  1828.  
  1829. #if defined (_WIN32) && defined (NEXT_PDO)
  1830.   /* Fill in the global flag with our local definition.  This let's us
  1831.      handle recursive calls.*/
  1832.   _function_returns_struct = _function_returns_struct_local;
  1833. #endif /* _WIN32 */
  1834.  
  1835.   /* Now store (and compute if necessary) all non-register parms.
  1836.      These come before register parms, since they can require block-moves,
  1837.      which could clobber the registers used for register parms.
  1838.      Parms which have partial registers are not stored here,
  1839.      but we do preallocate space here if they want that.  */
  1840.  
  1841.   for (i = 0; i < num_actuals; i++)
  1842. #if defined (_WIN32) && defined (NEXT_PDO)
  1843.   {
  1844.     if (i == num_actuals - 1 && _function_returns_struct_local)
  1845.       /* This indicates that we're working on the last parameter and that
  1846.      this function is returning a struct so we need to indicate to 
  1847.      the store_one_arg function that just before pushing this parameter
  1848.      on the stack, it should OR the high bit on.*/
  1849.       _last_argument_being_pushed = 1;
  1850. #endif /* _WIN32 */
  1851.     if (args[i].reg == 0 || args[i].pass_on_stack)
  1852.       store_one_arg (&args[i], argblock, may_be_alloca,
  1853.              args_size.var != 0, fndecl, reg_parm_stack_space);
  1854. #if defined (_WIN32) && defined (NEXT_PDO)
  1855.   }
  1856. #endif
  1857.  
  1858. #ifdef STRICT_ALIGNMENT
  1859.   /* If we have a parm that is passed in registers but not in memory
  1860.      and whose alignment does not permit a direct copy into registers,
  1861.      make a group of pseudos that correspond to each register that we
  1862.      will later fill.  */
  1863.  
  1864.   for (i = 0; i < num_actuals; i++)
  1865.     if (args[i].reg != 0 && ! args[i].pass_on_stack
  1866.     && args[i].mode == BLKmode
  1867.     && (TYPE_ALIGN (TREE_TYPE (args[i].tree_value))
  1868.         < MIN (BIGGEST_ALIGNMENT, BITS_PER_WORD)))
  1869.       {
  1870.     int bytes = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
  1871.     int big_endian_correction = 0;
  1872.  
  1873.     args[i].n_aligned_regs
  1874.       = args[i].partial ? args[i].partial
  1875.         : (bytes + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
  1876.  
  1877.     args[i].aligned_regs = (rtx *) alloca (sizeof (rtx)
  1878.                            * args[i].n_aligned_regs);
  1879.  
  1880.     /* Structures smaller than a word are aligned to the least significant
  1881.        byte (to the right).  On a BYTES_BIG_ENDIAN machine, this means we
  1882.        must skip the empty high order bytes when calculating the bit
  1883.        offset.  */
  1884.     if (BYTES_BIG_ENDIAN && bytes < UNITS_PER_WORD)
  1885.       big_endian_correction = (BITS_PER_WORD  - (bytes * BITS_PER_UNIT));
  1886.  
  1887.     for (j = 0; j < args[i].n_aligned_regs; j++)
  1888.       {
  1889.         rtx reg = gen_reg_rtx (word_mode);
  1890.         rtx word = operand_subword_force (args[i].value, j, BLKmode);
  1891.         int bitsize = TYPE_ALIGN (TREE_TYPE (args[i].tree_value));
  1892.         int bitpos;
  1893.  
  1894.         args[i].aligned_regs[j] = reg;
  1895.  
  1896.         /* Clobber REG and move each partword into it.  Ensure we don't
  1897.            go past the end of the structure.  Note that the loop below
  1898.            works because we've already verified that padding
  1899.            and endianness are compatible.  */
  1900.  
  1901.         emit_insn (gen_rtx (CLOBBER, VOIDmode, reg));
  1902.  
  1903.         for (bitpos = 0;
  1904.          bitpos < BITS_PER_WORD && bytes > 0;
  1905.          bitpos += bitsize, bytes -= bitsize / BITS_PER_UNIT)
  1906.           {
  1907.         int xbitpos = bitpos + big_endian_correction;
  1908.  
  1909.         store_bit_field (reg, bitsize, xbitpos, word_mode,
  1910.                  extract_bit_field (word, bitsize, bitpos, 1,
  1911.                             NULL_RTX, word_mode,
  1912.                             word_mode,
  1913.                             bitsize / BITS_PER_UNIT,
  1914.                             BITS_PER_WORD),
  1915.                  bitsize / BITS_PER_UNIT, BITS_PER_WORD);
  1916.           }
  1917.       }
  1918.       }
  1919. #endif
  1920.  
  1921.   /* Now store any partially-in-registers parm.
  1922.      This is the last place a block-move can happen.  */
  1923.   if (reg_parm_seen)
  1924.     for (i = 0; i < num_actuals; i++)
  1925.       if (args[i].partial != 0 && ! args[i].pass_on_stack)
  1926.     store_one_arg (&args[i], argblock, may_be_alloca,
  1927.                args_size.var != 0, fndecl, reg_parm_stack_space);
  1928.  
  1929. #ifndef PUSH_ARGS_REVERSED
  1930. #ifdef STACK_BOUNDARY
  1931.   /* If we pushed args in forward order, perform stack alignment
  1932.      after pushing the last arg.  */
  1933.   if (argblock == 0)
  1934.     anti_adjust_stack (GEN_INT (args_size.constant
  1935.                 - original_args_size.constant));
  1936. #endif
  1937. #endif
  1938.  
  1939.   /* If register arguments require space on the stack and stack space
  1940.      was not preallocated, allocate stack space here for arguments
  1941.      passed in registers.  */
  1942. #if ! defined(ACCUMULATE_OUTGOING_ARGS) && defined(OUTGOING_REG_PARM_STACK_SPACE)
  1943.   if (must_preallocate == 0 && reg_parm_stack_space > 0)
  1944.     anti_adjust_stack (GEN_INT (reg_parm_stack_space));
  1945. #endif
  1946.  
  1947.   /* Pass the function the address in which to return a structure value.  */
  1948.   if (structure_value_addr && ! structure_value_addr_parm)
  1949.     {
  1950.       emit_move_insn (struct_value_rtx,
  1951.               force_reg (Pmode,
  1952.                  force_operand (structure_value_addr,
  1953.                         NULL_RTX)));
  1954.       if (GET_CODE (struct_value_rtx) == REG)
  1955.       use_reg (&call_fusage, struct_value_rtx);
  1956.     }
  1957.  
  1958.   funexp = prepare_call_address (funexp, fndecl, &call_fusage, reg_parm_seen);
  1959.  
  1960.   /* Now do the register loads required for any wholly-register parms or any
  1961.      parms which are passed both on the stack and in a register.  Their
  1962.      expressions were already evaluated. 
  1963.  
  1964.      Mark all register-parms as living through the call, putting these USE
  1965.      insns in the CALL_INSN_FUNCTION_USAGE field.  */
  1966.  
  1967.   for (i = 0; i < num_actuals; i++)
  1968.     {
  1969.       rtx list = args[i].reg;
  1970.       int partial = args[i].partial;
  1971.  
  1972.       while (list)
  1973.     {
  1974.       rtx reg;
  1975.       int nregs;
  1976.  
  1977.       /* Process each register that needs to get this arg.  */
  1978.       if (GET_CODE (list) == EXPR_LIST)
  1979.         reg = XEXP (list, 0), list = XEXP (list, 1);
  1980.       else
  1981.         reg = list, list = 0;
  1982.  
  1983.       /* Set to non-negative if must move a word at a time, even if just
  1984.          one word (e.g, partial == 1 && mode == DFmode).  Set to -1 if
  1985.          we just use a normal move insn.  This value can be zero if the
  1986.          argument is a zero size structure with no fields.  */
  1987.       nregs = (partial ? partial
  1988.            : (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
  1989.               ? ((int_size_in_bytes (TREE_TYPE (args[i].tree_value))
  1990.               + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
  1991.               : -1));
  1992.  
  1993.       /* If simple case, just do move.  If normal partial, store_one_arg
  1994.          has already loaded the register for us.  In all other cases,
  1995.          load the register(s) from memory.  */
  1996.  
  1997.       if (nregs == -1)
  1998.         emit_move_insn (reg, args[i].value);
  1999.  
  2000. #ifdef STRICT_ALIGNMENT
  2001.       /* If we have pre-computed the values to put in the registers in
  2002.          the case of non-aligned structures, copy them in now.  */
  2003.  
  2004.       else if (args[i].n_aligned_regs != 0)
  2005.         for (j = 0; j < args[i].n_aligned_regs; j++)
  2006.           emit_move_insn (gen_rtx (REG, word_mode, REGNO (reg) + j),
  2007.                   args[i].aligned_regs[j]);
  2008. #endif
  2009.  
  2010.       else if (args[i].partial == 0 || args[i].pass_on_stack)
  2011.         move_block_to_reg (REGNO (reg),
  2012.                    validize_mem (args[i].value), nregs,
  2013.                    args[i].mode);
  2014.  
  2015.       if (nregs == -1)
  2016.         use_reg (&call_fusage, reg);
  2017.       else
  2018.         use_regs (&call_fusage, REGNO (reg), nregs == 0 ? 1 : nregs);
  2019.  
  2020.       /* PARTIAL referred only to the first register, so clear it for the
  2021.          next time.  */
  2022.       partial = 0;
  2023.     }
  2024.     }
  2025.  
  2026.   /* Perform postincrements before actually calling the function.  */
  2027.   emit_queue ();
  2028.  
  2029. #ifdef _WIN32
  2030.   if (is_stdcall)
  2031.     TYPE_STDCALL (TREE_TYPE (funtype)) = 1;
  2032. #endif /* _WIN32 */
  2033.  
  2034.   /* All arguments and registers used for the call must be set up by now!  */
  2035.  
  2036.   /* Generate the actual call instruction.  */
  2037.   emit_call_1 (funexp, fndecl, funtype, args_size.constant, struct_value_size,
  2038.            FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
  2039.            valreg, old_inhibit_defer_pop, call_fusage, is_const);
  2040.  
  2041.   /* If call is cse'able, make appropriate pair of reg-notes around it.
  2042.      Test valreg so we don't crash; may safely ignore `const'
  2043.      if return type is void.  */
  2044.   if (is_const && valreg != 0)
  2045.     {
  2046.       rtx note = 0;
  2047.       rtx temp = gen_reg_rtx (GET_MODE (valreg));
  2048.       rtx insns;
  2049.  
  2050.       /* Construct an "equal form" for the value which mentions all the
  2051.      arguments in order as well as the function name.  */
  2052. #ifdef PUSH_ARGS_REVERSED
  2053.       for (i = 0; i < num_actuals; i++)
  2054.     note = gen_rtx (EXPR_LIST, VOIDmode, args[i].initial_value, note);
  2055. #else
  2056.       for (i = num_actuals - 1; i >= 0; i--)
  2057.     note = gen_rtx (EXPR_LIST, VOIDmode, args[i].initial_value, note);
  2058. #endif
  2059.       note = gen_rtx (EXPR_LIST, VOIDmode, funexp, note);
  2060.  
  2061.       insns = get_insns ();
  2062.       end_sequence ();
  2063.  
  2064.       emit_libcall_block (insns, temp, valreg, note);
  2065.  
  2066.       valreg = temp;
  2067.     }
  2068. #if !defined (_WIN32) || !defined (NEXT_PDO)
  2069.   else if (is_const)
  2070.     {
  2071.       /* Otherwise, just write out the sequence without a note.  */
  2072.       rtx insns = get_insns ();
  2073.  
  2074.       end_sequence ();
  2075.       emit_insns (insns);
  2076.     }
  2077. #endif
  2078.  
  2079.   /* For calls to `setjmp', etc., inform flow.c it should complain
  2080.      if nonvolatile values are live.  */
  2081.  
  2082.   if (returns_twice)
  2083.     {
  2084.       emit_note (name, NOTE_INSN_SETJMP);
  2085.       current_function_calls_setjmp = 1;
  2086.     }
  2087.  
  2088.   if (is_longjmp)
  2089.     current_function_calls_longjmp = 1;
  2090.  
  2091.   /* Notice functions that cannot return.
  2092.      If optimizing, insns emitted below will be dead.
  2093.      If not optimizing, they will exist, which is useful
  2094.      if the user uses the `return' command in the debugger.  */
  2095.  
  2096.   if (is_volatile || is_longjmp)
  2097.     emit_barrier ();
  2098.  
  2099.   /* If value type not void, return an rtx for the value.  */
  2100.  
  2101.   /* If there are cleanups to be called, don't use a hard reg as target.  */
  2102.   if (cleanups_this_call != old_cleanups
  2103.       && target && REG_P (target)
  2104.       && REGNO (target) < FIRST_PSEUDO_REGISTER)
  2105.     target = 0;
  2106.  
  2107.   if (TYPE_MODE (TREE_TYPE (exp)) == VOIDmode
  2108.       || ignore)
  2109.     {
  2110.       target = const0_rtx;
  2111.     }
  2112.   else if (structure_value_addr)
  2113.     {
  2114.       if (target == 0 || GET_CODE (target) != MEM)
  2115.     {
  2116.       target = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)),
  2117.                 memory_address (TYPE_MODE (TREE_TYPE (exp)),
  2118.                         structure_value_addr));
  2119.       MEM_IN_STRUCT_P (target) = AGGREGATE_TYPE_P (TREE_TYPE (exp));
  2120.     }
  2121.     }
  2122.   else if (pcc_struct_value)
  2123.     {
  2124.       if (target == 0)
  2125.     {
  2126.       /* We used leave the value in the location that it is
  2127.          returned in, but that causes problems if it is used more
  2128.          than once in one expression.  Rather than trying to track
  2129.          when a copy is required, we always copy when TARGET is
  2130.          not specified.  This calling sequence is only used on
  2131.          a few machines and TARGET is usually nonzero.  */
  2132.       if (TYPE_MODE (TREE_TYPE (exp)) == BLKmode)
  2133.         {
  2134.           target = assign_stack_temp (BLKmode,
  2135.                       int_size_in_bytes (TREE_TYPE (exp)),
  2136.                       0);
  2137.  
  2138.           MEM_IN_STRUCT_P (target) = AGGREGATE_TYPE_P (TREE_TYPE (exp));
  2139.  
  2140.           /* Save this temp slot around the pop below.  */
  2141.           preserve_temp_slots (target);
  2142.         }
  2143.       else
  2144.         target = gen_reg_rtx (TYPE_MODE (TREE_TYPE (exp)));
  2145.     }
  2146.  
  2147.       if (TYPE_MODE (TREE_TYPE (exp)) != BLKmode)
  2148.     emit_move_insn (target, gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)),
  2149.                      copy_to_reg (valreg)));
  2150.       else
  2151.     emit_block_move (target, gen_rtx (MEM, BLKmode, copy_to_reg (valreg)),
  2152.              expr_size (exp),
  2153.              TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT);
  2154.     }
  2155.   else if (target && GET_MODE (target) == TYPE_MODE (TREE_TYPE (exp))
  2156.        && GET_MODE (target) == GET_MODE (valreg))
  2157.     /* TARGET and VALREG cannot be equal at this point because the latter
  2158.        would not have REG_FUNCTION_VALUE_P true, while the former would if
  2159.        it were referring to the same register.
  2160.  
  2161.        If they refer to the same register, this move will be a no-op, except
  2162.        when function inlining is being done.  */
  2163.     emit_move_insn (target, valreg);
  2164.   else if (TYPE_MODE (TREE_TYPE (exp)) == BLKmode)
  2165.     {
  2166.       /* Some machines (the PA for example) want to return all small
  2167.      structures in registers regardless of the structure's alignment.
  2168.      
  2169.      Deal with them explicitly by copying from the return registers
  2170.      into the target MEM locations.  */
  2171.       int bytes = int_size_in_bytes (TREE_TYPE (exp));
  2172.       int n_regs = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
  2173.       int i;
  2174.       enum machine_mode tmpmode;
  2175.       rtx src, dst;
  2176.       int bitsize = MIN (TYPE_ALIGN (TREE_TYPE (exp)), BITS_PER_WORD);
  2177.       int bitpos, xbitpos, big_endian_correction = 0;
  2178.       
  2179.       if (target == 0)
  2180.     {
  2181.       target = assign_stack_temp (BLKmode, bytes, 0);
  2182.       MEM_IN_STRUCT_P (target) = AGGREGATE_TYPE_P (TREE_TYPE (exp));
  2183.       preserve_temp_slots (target);
  2184.     }
  2185.  
  2186.       /* This code assumes valreg is at least a full word.  If it isn't,
  2187.      copy it into a new pseudo which is a full word.  */
  2188.       if (GET_MODE (valreg) != BLKmode
  2189.       && GET_MODE_SIZE (GET_MODE (valreg)) < UNITS_PER_WORD)
  2190.     valreg = convert_to_mode (SImode, valreg,
  2191.                   TREE_UNSIGNED (TREE_TYPE (exp)));
  2192.  
  2193.       /* Structures whose size is not a multiple of a word are aligned
  2194.      to the least significant byte (to the right).  On a BYTES_BIG_ENDIAN
  2195.      machine, this means we must skip the empty high order bytes when
  2196.      calculating the bit offset.  */
  2197.       if (BYTES_BIG_ENDIAN && bytes % UNITS_PER_WORD)
  2198.     big_endian_correction = (BITS_PER_WORD - ((bytes % UNITS_PER_WORD)
  2199.                           * BITS_PER_UNIT));
  2200.  
  2201.       /* Copy the structure BITSIZE bites at a time.
  2202.  
  2203.      We could probably emit more efficient code for machines
  2204.      which do not use strict alignment, but it doesn't seem
  2205.      worth the effort at the current time.  */
  2206.       for (bitpos = 0, xbitpos = big_endian_correction;
  2207.        bitpos < bytes * BITS_PER_UNIT;
  2208.        bitpos += bitsize, xbitpos += bitsize)
  2209.     {
  2210.  
  2211.       /* We need a new source operand each time xbitpos is on a 
  2212.          word boundary and when xbitpos == big_endian_correction
  2213.          (the first time through).  */
  2214.       if (xbitpos % BITS_PER_WORD == 0
  2215.           || xbitpos == big_endian_correction)
  2216.         src = operand_subword_force (valreg,
  2217.                      xbitpos / BITS_PER_WORD, 
  2218.                      BLKmode);
  2219.  
  2220.       /* We need a new destination operand each time bitpos is on
  2221.          a word boundary.  */
  2222.       if (bitpos % BITS_PER_WORD == 0)
  2223.         dst = operand_subword (target, bitpos / BITS_PER_WORD, 1, BLKmode);
  2224.           
  2225.       /* Use xbitpos for the source extraction (right justified) and
  2226.          xbitpos for the destination store (left justified).  */
  2227.       store_bit_field (dst, bitsize, bitpos % BITS_PER_WORD, word_mode,
  2228.                extract_bit_field (src, bitsize,
  2229.                           xbitpos % BITS_PER_WORD, 1,
  2230.                           NULL_RTX, word_mode,
  2231.                           word_mode,
  2232.                           bitsize / BITS_PER_UNIT,
  2233.                           BITS_PER_WORD),
  2234.                bitsize / BITS_PER_UNIT, BITS_PER_WORD);
  2235.     }
  2236.     }
  2237.   else
  2238.     target = copy_to_reg (valreg);
  2239.  
  2240. #ifdef PROMOTE_FUNCTION_RETURN
  2241.   /* If we promoted this return value, make the proper SUBREG.  TARGET
  2242.      might be const0_rtx here, so be careful.  */
  2243.   if (GET_CODE (target) == REG
  2244.       && TYPE_MODE (TREE_TYPE (exp)) != BLKmode
  2245.       && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
  2246.     {
  2247.       tree type = TREE_TYPE (exp);
  2248.       int unsignedp = TREE_UNSIGNED (type);
  2249.  
  2250.       /* If we don't promote as expected, something is wrong.  */
  2251.       if (GET_MODE (target)
  2252.       != promote_mode (type, TYPE_MODE (type), &unsignedp, 1))
  2253.     abort ();
  2254.  
  2255.       target = gen_rtx (SUBREG, TYPE_MODE (type), target, 0);
  2256.       SUBREG_PROMOTED_VAR_P (target) = 1;
  2257.       SUBREG_PROMOTED_UNSIGNED_P (target) = unsignedp;
  2258.     }
  2259. #endif
  2260.  
  2261.   if (flag_short_temps)
  2262.     {
  2263.       /* Perform all cleanups needed for the arguments of this call
  2264.      (i.e. destructors in C++).  */
  2265.       expand_cleanups_to (old_cleanups);
  2266.     }
  2267.  
  2268.   /* If size of args is variable or this was a constructor call for a stack
  2269.      argument, restore saved stack-pointer value.  */
  2270.  
  2271.   if (old_stack_level)
  2272.     {
  2273.       emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
  2274.       pending_stack_adjust = old_pending_adj;
  2275. #ifdef ACCUMULATE_OUTGOING_ARGS
  2276.       stack_arg_under_construction = old_stack_arg_under_construction;
  2277.       highest_outgoing_arg_in_use = initial_highest_arg_in_use;
  2278.       stack_usage_map = initial_stack_usage_map;
  2279. #endif
  2280.     }
  2281. #ifdef ACCUMULATE_OUTGOING_ARGS
  2282.   else
  2283.     {
  2284. #ifdef REG_PARM_STACK_SPACE
  2285.       if (save_area)
  2286.     {
  2287.       enum machine_mode save_mode = GET_MODE (save_area);
  2288.       rtx stack_area
  2289.         = gen_rtx (MEM, save_mode,
  2290.                memory_address (save_mode,
  2291. #ifdef ARGS_GROW_DOWNWARD
  2292.                        plus_constant (argblock, - high_to_save)
  2293. #else
  2294.                        plus_constant (argblock, low_to_save)
  2295. #endif
  2296.                        ));
  2297.  
  2298.       if (save_mode != BLKmode)
  2299.         emit_move_insn (stack_area, save_area);
  2300.       else
  2301.         emit_block_move (stack_area, validize_mem (save_area),
  2302.                  GEN_INT (high_to_save - low_to_save + 1),
  2303.                  PARM_BOUNDARY / BITS_PER_UNIT);
  2304.     }
  2305. #endif
  2306.       
  2307.       /* If we saved any argument areas, restore them.  */
  2308.       for (i = 0; i < num_actuals; i++)
  2309.     if (args[i].save_area)
  2310.       {
  2311.         enum machine_mode save_mode = GET_MODE (args[i].save_area);
  2312.         rtx stack_area
  2313.           = gen_rtx (MEM, save_mode,
  2314.              memory_address (save_mode,
  2315.                      XEXP (args[i].stack_slot, 0)));
  2316.  
  2317.         if (save_mode != BLKmode)
  2318.           emit_move_insn (stack_area, args[i].save_area);
  2319.         else
  2320.           emit_block_move (stack_area, validize_mem (args[i].save_area),
  2321.                    GEN_INT (args[i].size.constant),
  2322.                    PARM_BOUNDARY / BITS_PER_UNIT);
  2323.       }
  2324.  
  2325.       highest_outgoing_arg_in_use = initial_highest_arg_in_use;
  2326.       stack_usage_map = initial_stack_usage_map;
  2327.     }
  2328. #endif
  2329.  
  2330.   /* If this was alloca, record the new stack level for nonlocal gotos.  
  2331.      Check for the handler slots since we might not have a save area
  2332.      for non-local gotos. */
  2333.  
  2334.   if (may_be_alloca && nonlocal_goto_handler_slot != 0)
  2335.     emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
  2336.  
  2337.   pop_temp_slots ();
  2338.  
  2339.   return target;
  2340. }
  2341.  
  2342. /* Output a library call to function FUN (a SYMBOL_REF rtx)
  2343.    (emitting the queue unless NO_QUEUE is nonzero),
  2344.    for a value of mode OUTMODE,
  2345.    with NARGS different arguments, passed as alternating rtx values
  2346.    and machine_modes to convert them to.
  2347.    The rtx values should have been passed through protect_from_queue already.
  2348.  
  2349.    NO_QUEUE will be true if and only if the library call is a `const' call
  2350.    which will be enclosed in REG_LIBCALL/REG_RETVAL notes; it is equivalent
  2351.    to the variable is_const in expand_call.
  2352.  
  2353.    NO_QUEUE must be true for const calls, because if it isn't, then
  2354.    any pending increment will be emitted between REG_LIBCALL/REG_RETVAL notes,
  2355.    and will be lost if the libcall sequence is optimized away.
  2356.  
  2357.    NO_QUEUE must be false for non-const calls, because if it isn't, the
  2358.    call insn will have its CONST_CALL_P bit set, and it will be incorrectly
  2359.    optimized.  For instance, the instruction scheduler may incorrectly
  2360.    move memory references across the non-const call.  */
  2361.  
  2362. void
  2363. emit_library_call VPROTO((rtx orgfun, int no_queue, enum machine_mode outmode,
  2364.               int nargs, ...))
  2365. {
  2366. #ifndef __STDC__
  2367.   rtx orgfun;
  2368.   int no_queue;
  2369.   enum machine_mode outmode;
  2370.   int nargs;
  2371. #endif
  2372.   va_list p;
  2373.   /* Total size in bytes of all the stack-parms scanned so far.  */
  2374.   struct args_size args_size;
  2375.   /* Size of arguments before any adjustments (such as rounding).  */
  2376.   struct args_size original_args_size;
  2377.   register int argnum;
  2378.   rtx fun;
  2379.   int inc;
  2380.   int count;
  2381.   rtx argblock = 0;
  2382.   CUMULATIVE_ARGS args_so_far;
  2383.   struct arg { rtx value; enum machine_mode mode; rtx reg; int partial;
  2384.            struct args_size offset; struct args_size size; };
  2385.   struct arg *argvec;
  2386.   int old_inhibit_defer_pop = inhibit_defer_pop;
  2387.   rtx call_fusage = 0;
  2388.   /* library calls are never indirect calls.  */
  2389.   int current_call_is_indirect = 0;
  2390.  
  2391.   VA_START (p, nargs);
  2392.  
  2393. #ifndef __STDC__
  2394.   orgfun = va_arg (p, rtx);
  2395.   no_queue = va_arg (p, int);
  2396.   outmode = va_arg (p, enum machine_mode);
  2397.   nargs = va_arg (p, int);
  2398. #endif
  2399.  
  2400.   fun = orgfun;
  2401.  
  2402.   /* Copy all the libcall-arguments out of the varargs data
  2403.      and into a vector ARGVEC.
  2404.  
  2405.      Compute how to pass each argument.  We only support a very small subset
  2406.      of the full argument passing conventions to limit complexity here since
  2407.      library functions shouldn't have many args.  */
  2408.  
  2409.   argvec = (struct arg *) alloca (nargs * sizeof (struct arg));
  2410.  
  2411.   INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE, fun);
  2412.  
  2413.   args_size.constant = 0;
  2414.   args_size.var = 0;
  2415.  
  2416.   push_temp_slots ();
  2417.  
  2418.   for (count = 0; count < nargs; count++)
  2419.     {
  2420.       rtx val = va_arg (p, rtx);
  2421.       enum machine_mode mode = va_arg (p, enum machine_mode);
  2422.  
  2423.       /* We cannot convert the arg value to the mode the library wants here;
  2424.      must do it earlier where we know the signedness of the arg.  */
  2425.       if (mode == BLKmode
  2426.       || (GET_MODE (val) != mode && GET_MODE (val) != VOIDmode))
  2427.     abort ();
  2428.  
  2429.       /* On some machines, there's no way to pass a float to a library fcn.
  2430.      Pass it as a double instead.  */
  2431. #ifdef LIBGCC_NEEDS_DOUBLE
  2432.       if (LIBGCC_NEEDS_DOUBLE && mode == SFmode)
  2433.     val = convert_modes (DFmode, SFmode, val, 0), mode = DFmode;
  2434. #endif
  2435.  
  2436.       /* There's no need to call protect_from_queue, because
  2437.      either emit_move_insn or emit_push_insn will do that.  */
  2438.  
  2439.       /* Make sure it is a reasonable operand for a move or push insn.  */
  2440.       if (GET_CODE (val) != REG && GET_CODE (val) != MEM
  2441.       && ! (CONSTANT_P (val) && LEGITIMATE_CONSTANT_P (val)))
  2442.     val = force_operand (val, NULL_RTX);
  2443.  
  2444. #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
  2445.       if (FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, mode, NULL_TREE, 1))
  2446.     {
  2447.       /* We do not support FUNCTION_ARG_CALLEE_COPIES here since it can
  2448.          be viewed as just an efficiency improvement.  */
  2449.       rtx slot = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0);
  2450.       emit_move_insn (slot, val);
  2451.       val = force_operand (XEXP (slot, 0), NULL_RTX);
  2452.       mode = Pmode;
  2453.     }
  2454. #endif
  2455.  
  2456.       argvec[count].value = val;
  2457.       argvec[count].mode = mode;
  2458.  
  2459.       argvec[count].reg = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1);
  2460.       if (argvec[count].reg && GET_CODE (argvec[count].reg) == EXPR_LIST)
  2461.     abort ();
  2462. #ifdef FUNCTION_ARG_PARTIAL_NREGS
  2463.       argvec[count].partial
  2464.     = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, NULL_TREE, 1);
  2465. #else
  2466.       argvec[count].partial = 0;
  2467. #endif
  2468.  
  2469.       locate_and_pad_parm (mode, NULL_TREE,
  2470.                argvec[count].reg && argvec[count].partial == 0,
  2471.                NULL_TREE, &args_size, &argvec[count].offset,
  2472.                &argvec[count].size);
  2473.  
  2474.       if (argvec[count].size.var)
  2475.     abort ();
  2476.  
  2477. #ifndef REG_PARM_STACK_SPACE
  2478.       if (argvec[count].partial)
  2479.     argvec[count].size.constant -= argvec[count].partial * UNITS_PER_WORD;
  2480. #endif
  2481.  
  2482.       if (argvec[count].reg == 0 || argvec[count].partial != 0
  2483. #ifdef REG_PARM_STACK_SPACE
  2484.       || 1
  2485. #endif
  2486.       )
  2487.     args_size.constant += argvec[count].size.constant;
  2488.  
  2489. #ifdef ACCUMULATE_OUTGOING_ARGS
  2490.       /* If this arg is actually passed on the stack, it might be
  2491.      clobbering something we already put there (this library call might
  2492.      be inside the evaluation of an argument to a function whose call
  2493.      requires the stack).  This will only occur when the library call
  2494.      has sufficient args to run out of argument registers.  Abort in
  2495.      this case; if this ever occurs, code must be added to save and
  2496.      restore the arg slot.  */
  2497.  
  2498.       if (argvec[count].reg == 0 || argvec[count].partial != 0)
  2499.     abort ();
  2500. #endif
  2501.  
  2502.       FUNCTION_ARG_ADVANCE (args_so_far, mode, (tree)0, 1);
  2503.     }
  2504.   va_end (p);
  2505.  
  2506.   /* If this machine requires an external definition for library
  2507.      functions, write one out.  */
  2508.   assemble_external_libcall (fun);
  2509.  
  2510.   original_args_size = args_size;
  2511. #ifdef STACK_BOUNDARY
  2512.   args_size.constant = (((args_size.constant + (STACK_BYTES - 1))
  2513.              / STACK_BYTES) * STACK_BYTES);
  2514. #endif
  2515.  
  2516. #ifdef REG_PARM_STACK_SPACE
  2517.   args_size.constant = MAX (args_size.constant,
  2518.                 REG_PARM_STACK_SPACE (NULL_TREE));
  2519. #ifndef OUTGOING_REG_PARM_STACK_SPACE
  2520.   args_size.constant -= REG_PARM_STACK_SPACE (NULL_TREE);
  2521. #endif
  2522. #endif
  2523.  
  2524.   if (args_size.constant > current_function_outgoing_args_size)
  2525.     current_function_outgoing_args_size = args_size.constant;
  2526.  
  2527. #ifdef ACCUMULATE_OUTGOING_ARGS
  2528.   args_size.constant = 0;
  2529. #endif
  2530.  
  2531. #ifndef PUSH_ROUNDING
  2532.   argblock = push_block (GEN_INT (args_size.constant), 0, 0);
  2533. #endif
  2534.  
  2535. #ifdef PUSH_ARGS_REVERSED
  2536. #ifdef STACK_BOUNDARY
  2537.   /* If we push args individually in reverse order, perform stack alignment
  2538.      before the first push (the last arg).  */
  2539.   if (argblock == 0)
  2540.     anti_adjust_stack (GEN_INT (args_size.constant
  2541.                 - original_args_size.constant));
  2542. #endif
  2543. #endif
  2544.  
  2545. #ifdef PUSH_ARGS_REVERSED
  2546.   inc = -1;
  2547.   argnum = nargs - 1;
  2548. #else
  2549.   inc = 1;
  2550.   argnum = 0;
  2551. #endif
  2552.  
  2553.   /* Push the args that need to be pushed.  */
  2554.  
  2555.   for (count = 0; count < nargs; count++, argnum += inc)
  2556.     {
  2557.       register enum machine_mode mode = argvec[argnum].mode;
  2558.       register rtx val = argvec[argnum].value;
  2559.       rtx reg = argvec[argnum].reg;
  2560.       int partial = argvec[argnum].partial;
  2561.  
  2562.       if (! (reg != 0 && partial == 0))
  2563.     emit_push_insn (val, mode, NULL_TREE, NULL_RTX, 0, partial, reg, 0,
  2564.             argblock, GEN_INT (argvec[count].offset.constant));
  2565.       NO_DEFER_POP;
  2566.     }
  2567.  
  2568. #ifndef PUSH_ARGS_REVERSED
  2569. #ifdef STACK_BOUNDARY
  2570.   /* If we pushed args in forward order, perform stack alignment
  2571.      after pushing the last arg.  */
  2572.   if (argblock == 0)
  2573.     anti_adjust_stack (GEN_INT (args_size.constant
  2574.                 - original_args_size.constant));
  2575. #endif
  2576. #endif
  2577.  
  2578. #ifdef PUSH_ARGS_REVERSED
  2579.   argnum = nargs - 1;
  2580. #else
  2581.   argnum = 0;
  2582. #endif
  2583.  
  2584.   fun = prepare_call_address (fun, NULL_TREE, &call_fusage, 0);
  2585.  
  2586.   /* Now load any reg parms into their regs.  */
  2587.  
  2588.   for (count = 0; count < nargs; count++, argnum += inc)
  2589.     {
  2590.       register enum machine_mode mode = argvec[argnum].mode;
  2591.       register rtx val = argvec[argnum].value;
  2592.       rtx reg = argvec[argnum].reg;
  2593.       int partial = argvec[argnum].partial;
  2594.  
  2595.       if (reg != 0 && partial == 0)
  2596.     emit_move_insn (reg, val);
  2597.       NO_DEFER_POP;
  2598.     }
  2599.  
  2600.   /* For version 1.37, try deleting this entirely.  */
  2601.   if (! no_queue)
  2602.     emit_queue ();
  2603.  
  2604.   /* Any regs containing parms remain in use through the call.  */
  2605.   for (count = 0; count < nargs; count++)
  2606.     if (argvec[count].reg != 0)
  2607.        use_reg (&call_fusage, argvec[count].reg);
  2608.  
  2609.   /* Don't allow popping to be deferred, since then
  2610.      cse'ing of library calls could delete a call and leave the pop.  */
  2611.   NO_DEFER_POP;
  2612.  
  2613.   /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
  2614.      will set inhibit_defer_pop to that value.  */
  2615.  
  2616.   emit_call_1 (fun, 
  2617.                get_identifier (XSTR (orgfun, 0)), 
  2618.                get_identifier (XSTR (orgfun, 0)), args_size.constant, 0,
  2619.            FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
  2620.            outmode != VOIDmode ? hard_libcall_value (outmode) : NULL_RTX,
  2621.            old_inhibit_defer_pop + 1, call_fusage, no_queue);
  2622.  
  2623.   pop_temp_slots ();
  2624.  
  2625.   /* Now restore inhibit_defer_pop to its actual original value.  */
  2626.   OK_DEFER_POP;
  2627. }
  2628.  
  2629. /* Like emit_library_call except that an extra argument, VALUE,
  2630.    comes second and says where to store the result.
  2631.    (If VALUE is zero, this function chooses a convenient way
  2632.    to return the value.
  2633.  
  2634.    This function returns an rtx for where the value is to be found.
  2635.    If VALUE is nonzero, VALUE is returned.  */
  2636.  
  2637. rtx
  2638. emit_library_call_value VPROTO((rtx orgfun, rtx value, int no_queue,
  2639.                 enum machine_mode outmode, int nargs, ...))
  2640. {
  2641. #ifndef __STDC__
  2642.   rtx orgfun;
  2643.   rtx value;
  2644.   int no_queue;
  2645.   enum machine_mode outmode;
  2646.   int nargs;
  2647. #endif
  2648.   va_list p;
  2649.   /* Total size in bytes of all the stack-parms scanned so far.  */
  2650.   struct args_size args_size;
  2651.   /* Size of arguments before any adjustments (such as rounding).  */
  2652.   struct args_size original_args_size;
  2653.   register int argnum;
  2654.   rtx fun;
  2655.   int inc;
  2656.   int count;
  2657.   rtx argblock = 0;
  2658.   CUMULATIVE_ARGS args_so_far;
  2659.   struct arg { rtx value; enum machine_mode mode; rtx reg; int partial;
  2660.            struct args_size offset; struct args_size size; };
  2661.   struct arg *argvec;
  2662.   int old_inhibit_defer_pop = inhibit_defer_pop;
  2663.   rtx call_fusage = 0;
  2664.   rtx mem_value = 0;
  2665.   int pcc_struct_value = 0;
  2666.   int struct_value_size = 0;
  2667.   /* library calls are never indirect calls.  */
  2668.   int current_call_is_indirect = 0;
  2669.   int is_const;
  2670.  
  2671.   VA_START (p, nargs);
  2672.  
  2673. #ifndef __STDC__
  2674.   orgfun = va_arg (p, rtx);
  2675.   value = va_arg (p, rtx);
  2676.   no_queue = va_arg (p, int);
  2677.   outmode = va_arg (p, enum machine_mode);
  2678.   nargs = va_arg (p, int);
  2679. #endif
  2680.  
  2681.   is_const = no_queue;
  2682.   fun = orgfun;
  2683.  
  2684.   /* If this kind of value comes back in memory,
  2685.      decide where in memory it should come back.  */
  2686.   if (aggregate_value_p (type_for_mode (outmode, 0)))
  2687.     {
  2688. #ifdef PCC_STATIC_STRUCT_RETURN
  2689.       rtx pointer_reg
  2690.     = hard_function_value (build_pointer_type (type_for_mode (outmode, 0)),
  2691.                    0);
  2692.       mem_value = gen_rtx (MEM, outmode, pointer_reg);
  2693.       pcc_struct_value = 1;
  2694.       if (value == 0)
  2695.     value = gen_reg_rtx (outmode);
  2696. #else /* not PCC_STATIC_STRUCT_RETURN */
  2697.       struct_value_size = GET_MODE_SIZE (outmode);
  2698.       if (value != 0 && GET_CODE (value) == MEM)
  2699.     mem_value = value;
  2700.       else
  2701.     mem_value = assign_stack_temp (outmode, GET_MODE_SIZE (outmode), 0);
  2702. #endif
  2703.  
  2704.       /* This call returns a big structure.  */
  2705.       is_const = 0;
  2706.     }
  2707.  
  2708.   /* ??? Unfinished: must pass the memory address as an argument.  */
  2709.  
  2710.   /* Copy all the libcall-arguments out of the varargs data
  2711.      and into a vector ARGVEC.
  2712.  
  2713.      Compute how to pass each argument.  We only support a very small subset
  2714.      of the full argument passing conventions to limit complexity here since
  2715.      library functions shouldn't have many args.  */
  2716.  
  2717.   argvec = (struct arg *) alloca ((nargs + 1) * sizeof (struct arg));
  2718.  
  2719.   INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE, fun);
  2720.  
  2721.   args_size.constant = 0;
  2722.   args_size.var = 0;
  2723.  
  2724.   count = 0;
  2725.  
  2726.   push_temp_slots ();
  2727.  
  2728.   /* If there's a structure value address to be passed,
  2729.      either pass it in the special place, or pass it as an extra argument.  */
  2730.   if (mem_value && struct_value_rtx == 0 && ! pcc_struct_value)
  2731.     {
  2732.       rtx addr = XEXP (mem_value, 0);
  2733.       nargs++;
  2734.  
  2735.       /* Make sure it is a reasonable operand for a move or push insn.  */
  2736.       if (GET_CODE (addr) != REG && GET_CODE (addr) != MEM
  2737.       && ! (CONSTANT_P (addr) && LEGITIMATE_CONSTANT_P (addr)))
  2738.     addr = force_operand (addr, NULL_RTX);
  2739.  
  2740.       argvec[count].value = addr;
  2741.       argvec[count].mode = Pmode;
  2742.       argvec[count].partial = 0;
  2743.  
  2744.       argvec[count].reg = FUNCTION_ARG (args_so_far, Pmode, NULL_TREE, 1);
  2745. #ifdef FUNCTION_ARG_PARTIAL_NREGS
  2746.       if (FUNCTION_ARG_PARTIAL_NREGS (args_so_far, Pmode, NULL_TREE, 1))
  2747.     abort ();
  2748. #endif
  2749.  
  2750.       locate_and_pad_parm (Pmode, NULL_TREE,
  2751.                argvec[count].reg && argvec[count].partial == 0,
  2752.                NULL_TREE, &args_size, &argvec[count].offset,
  2753.                &argvec[count].size);
  2754.  
  2755.  
  2756.       if (argvec[count].reg == 0 || argvec[count].partial != 0
  2757. #ifdef REG_PARM_STACK_SPACE
  2758.       || 1
  2759. #endif
  2760.       )
  2761.     args_size.constant += argvec[count].size.constant;
  2762.  
  2763.       FUNCTION_ARG_ADVANCE (args_so_far, Pmode, (tree)0, 1);
  2764.  
  2765.       count++;
  2766.     }
  2767.  
  2768.   for (; count < nargs; count++)
  2769.     {
  2770.       rtx val = va_arg (p, rtx);
  2771.       enum machine_mode mode = va_arg (p, enum machine_mode);
  2772.  
  2773.       /* We cannot convert the arg value to the mode the library wants here;
  2774.      must do it earlier where we know the signedness of the arg.  */
  2775.       if (mode == BLKmode
  2776.       || (GET_MODE (val) != mode && GET_MODE (val) != VOIDmode))
  2777.     abort ();
  2778.  
  2779.       /* On some machines, there's no way to pass a float to a library fcn.
  2780.      Pass it as a double instead.  */
  2781. #ifdef LIBGCC_NEEDS_DOUBLE
  2782.       if (LIBGCC_NEEDS_DOUBLE && mode == SFmode)
  2783.     val = convert_modes (DFmode, SFmode, val, 0), mode = DFmode;
  2784. #endif
  2785.  
  2786.       /* There's no need to call protect_from_queue, because
  2787.      either emit_move_insn or emit_push_insn will do that.  */
  2788.  
  2789.       /* Make sure it is a reasonable operand for a move or push insn.  */
  2790.       if (GET_CODE (val) != REG && GET_CODE (val) != MEM
  2791.       && ! (CONSTANT_P (val) && LEGITIMATE_CONSTANT_P (val)))
  2792.     val = force_operand (val, NULL_RTX);
  2793.  
  2794. #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
  2795.       if (FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, mode, NULL_TREE, 1))
  2796.     {
  2797.       /* We do not support FUNCTION_ARG_CALLEE_COPIES here since it can
  2798.          be viewed as just an efficiency improvement.  */
  2799.       rtx slot = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0);
  2800.       emit_move_insn (slot, val);
  2801.       val = XEXP (slot, 0);
  2802.       mode = Pmode;
  2803.     }
  2804. #endif
  2805.  
  2806.       argvec[count].value = val;
  2807.       argvec[count].mode = mode;
  2808.  
  2809.       argvec[count].reg = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1);
  2810.       if (argvec[count].reg && GET_CODE (argvec[count].reg) == EXPR_LIST)
  2811.     abort ();
  2812. #ifdef FUNCTION_ARG_PARTIAL_NREGS
  2813.       argvec[count].partial
  2814.     = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, NULL_TREE, 1);
  2815. #else
  2816.       argvec[count].partial = 0;
  2817. #endif
  2818.  
  2819.       locate_and_pad_parm (mode, NULL_TREE,
  2820.                argvec[count].reg && argvec[count].partial == 0,
  2821.                NULL_TREE, &args_size, &argvec[count].offset,
  2822.                &argvec[count].size);
  2823.  
  2824.       if (argvec[count].size.var)
  2825.     abort ();
  2826.  
  2827. #ifndef REG_PARM_STACK_SPACE
  2828.       if (argvec[count].partial)
  2829.     argvec[count].size.constant -= argvec[count].partial * UNITS_PER_WORD;
  2830. #endif
  2831.  
  2832.       if (argvec[count].reg == 0 || argvec[count].partial != 0
  2833. #ifdef REG_PARM_STACK_SPACE
  2834.       || 1
  2835. #endif
  2836.       )
  2837.     args_size.constant += argvec[count].size.constant;
  2838.  
  2839. #ifdef ACCUMULATE_OUTGOING_ARGS
  2840.       /* If this arg is actually passed on the stack, it might be
  2841.      clobbering something we already put there (this library call might
  2842.      be inside the evaluation of an argument to a function whose call
  2843.      requires the stack).  This will only occur when the library call
  2844.      has sufficient args to run out of argument registers.  Abort in
  2845.      this case; if this ever occurs, code must be added to save and
  2846.      restore the arg slot.  */
  2847.  
  2848.       if (argvec[count].reg == 0 || argvec[count].partial != 0)
  2849.     abort ();
  2850. #endif
  2851.  
  2852.       FUNCTION_ARG_ADVANCE (args_so_far, mode, (tree)0, 1);
  2853.     }
  2854.   va_end (p);
  2855.  
  2856.   /* If this machine requires an external definition for library
  2857.      functions, write one out.  */
  2858.   assemble_external_libcall (fun);
  2859.  
  2860.   original_args_size = args_size;
  2861. #ifdef STACK_BOUNDARY
  2862.   args_size.constant = (((args_size.constant + (STACK_BYTES - 1))
  2863.              / STACK_BYTES) * STACK_BYTES);
  2864. #endif
  2865.  
  2866. #ifdef REG_PARM_STACK_SPACE
  2867.   args_size.constant = MAX (args_size.constant,
  2868.                 REG_PARM_STACK_SPACE (NULL_TREE));
  2869. #ifndef OUTGOING_REG_PARM_STACK_SPACE
  2870.   args_size.constant -= REG_PARM_STACK_SPACE (NULL_TREE);
  2871. #endif
  2872. #endif
  2873.  
  2874.   if (args_size.constant > current_function_outgoing_args_size)
  2875.     current_function_outgoing_args_size = args_size.constant;
  2876.  
  2877. #ifdef ACCUMULATE_OUTGOING_ARGS
  2878.   args_size.constant = 0;
  2879. #endif
  2880.  
  2881. #ifndef PUSH_ROUNDING
  2882.   argblock = push_block (GEN_INT (args_size.constant), 0, 0);
  2883. #endif
  2884.  
  2885. #ifdef PUSH_ARGS_REVERSED
  2886. #ifdef STACK_BOUNDARY
  2887.   /* If we push args individually in reverse order, perform stack alignment
  2888.      before the first push (the last arg).  */
  2889.   if (argblock == 0)
  2890.     anti_adjust_stack (GEN_INT (args_size.constant
  2891.                 - original_args_size.constant));
  2892. #endif
  2893. #endif
  2894.  
  2895. #ifdef PUSH_ARGS_REVERSED
  2896.   inc = -1;
  2897.   argnum = nargs - 1;
  2898. #else
  2899.   inc = 1;
  2900.   argnum = 0;
  2901. #endif
  2902.  
  2903.   /* Push the args that need to be pushed.  */
  2904.  
  2905.   for (count = 0; count < nargs; count++, argnum += inc)
  2906.     {
  2907.       register enum machine_mode mode = argvec[argnum].mode;
  2908.       register rtx val = argvec[argnum].value;
  2909.       rtx reg = argvec[argnum].reg;
  2910.       int partial = argvec[argnum].partial;
  2911.  
  2912.       if (! (reg != 0 && partial == 0))
  2913.     emit_push_insn (val, mode, NULL_TREE, NULL_RTX, 0, partial, reg, 0,
  2914.             argblock, GEN_INT (argvec[count].offset.constant));
  2915.       NO_DEFER_POP;
  2916.     }
  2917.  
  2918. #ifndef PUSH_ARGS_REVERSED
  2919. #ifdef STACK_BOUNDARY
  2920.   /* If we pushed args in forward order, perform stack alignment
  2921.      after pushing the last arg.  */
  2922.   if (argblock == 0)
  2923.     anti_adjust_stack (GEN_INT (args_size.constant
  2924.                 - original_args_size.constant));
  2925. #endif
  2926. #endif
  2927.  
  2928. #ifdef PUSH_ARGS_REVERSED
  2929.   argnum = nargs - 1;
  2930. #else
  2931.   argnum = 0;
  2932. #endif
  2933.  
  2934.   fun = prepare_call_address (fun, NULL_TREE, &call_fusage, 0);
  2935.  
  2936.   /* Now load any reg parms into their regs.  */
  2937.  
  2938.   for (count = 0; count < nargs; count++, argnum += inc)
  2939.     {
  2940.       register enum machine_mode mode = argvec[argnum].mode;
  2941.       register rtx val = argvec[argnum].value;
  2942.       rtx reg = argvec[argnum].reg;
  2943.       int partial = argvec[argnum].partial;
  2944.  
  2945.       if (reg != 0 && partial == 0)
  2946.     emit_move_insn (reg, val);
  2947.       NO_DEFER_POP;
  2948.     }
  2949.  
  2950. #if 0
  2951.   /* For version 1.37, try deleting this entirely.  */
  2952.   if (! no_queue)
  2953.     emit_queue ();
  2954. #endif
  2955.  
  2956.   /* Any regs containing parms remain in use through the call.  */
  2957.   for (count = 0; count < nargs; count++)
  2958.     if (argvec[count].reg != 0)
  2959.        use_reg (&call_fusage, argvec[count].reg);
  2960.  
  2961.   /* Pass the function the address in which to return a structure value.  */
  2962.   if (mem_value != 0 && struct_value_rtx != 0 && ! pcc_struct_value)
  2963.     {
  2964.       emit_move_insn (struct_value_rtx,
  2965.               force_reg (Pmode,
  2966.                  force_operand (XEXP (mem_value, 0),
  2967.                         NULL_RTX)));
  2968.       if (GET_CODE (struct_value_rtx) == REG)
  2969.       use_reg (&call_fusage, struct_value_rtx);
  2970.     }
  2971.  
  2972.   /* Don't allow popping to be deferred, since then
  2973.      cse'ing of library calls could delete a call and leave the pop.  */
  2974.   NO_DEFER_POP;
  2975.  
  2976.   /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
  2977.      will set inhibit_defer_pop to that value.  */
  2978.  
  2979.   emit_call_1 (fun, 
  2980.                get_identifier (XSTR (orgfun, 0)),
  2981.                get_identifier (XSTR (orgfun, 0)), args_size.constant,
  2982.            struct_value_size,
  2983.            FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
  2984.            (outmode != VOIDmode && mem_value == 0
  2985.         ? hard_libcall_value (outmode) : NULL_RTX),
  2986.            old_inhibit_defer_pop + 1, call_fusage, is_const);
  2987.  
  2988.   /* Now restore inhibit_defer_pop to its actual original value.  */
  2989.   OK_DEFER_POP;
  2990.  
  2991.   pop_temp_slots ();
  2992.  
  2993.   /* Copy the value to the right place.  */
  2994.   if (outmode != VOIDmode)
  2995.     {
  2996.       if (mem_value)
  2997.     {
  2998.       if (value == 0)
  2999.         value = mem_value;
  3000.       if (value != mem_value)
  3001.         emit_move_insn (value, mem_value);
  3002.     }
  3003.       else if (value != 0)
  3004.     emit_move_insn (value, hard_libcall_value (outmode));
  3005.       else
  3006.     value = hard_libcall_value (outmode);
  3007.     }
  3008.  
  3009.   return value;
  3010. }
  3011.  
  3012. #if 0
  3013. /* Return an rtx which represents a suitable home on the stack
  3014.    given TYPE, the type of the argument looking for a home.
  3015.    This is called only for BLKmode arguments.
  3016.  
  3017.    SIZE is the size needed for this target.
  3018.    ARGS_ADDR is the address of the bottom of the argument block for this call.
  3019.    OFFSET describes this parameter's offset into ARGS_ADDR.  It is meaningless
  3020.    if this machine uses push insns.  */
  3021.  
  3022. static rtx
  3023. target_for_arg (type, size, args_addr, offset)
  3024.      tree type;
  3025.      rtx size;
  3026.      rtx args_addr;
  3027.      struct args_size offset;
  3028. {
  3029.   rtx target;
  3030.   rtx offset_rtx = ARGS_SIZE_RTX (offset);
  3031.  
  3032.   /* We do not call memory_address if possible,
  3033.      because we want to address as close to the stack
  3034.      as possible.  For non-variable sized arguments,
  3035.      this will be stack-pointer relative addressing.  */
  3036.   if (GET_CODE (offset_rtx) == CONST_INT)
  3037.     target = plus_constant (args_addr, INTVAL (offset_rtx));
  3038.   else
  3039.     {
  3040.       /* I have no idea how to guarantee that this
  3041.      will work in the presence of register parameters.  */
  3042.       target = gen_rtx (PLUS, Pmode, args_addr, offset_rtx);
  3043.       target = memory_address (QImode, target);
  3044.     }
  3045.  
  3046.   return gen_rtx (MEM, BLKmode, target);
  3047. }
  3048. #endif
  3049.  
  3050. /* Store a single argument for a function call
  3051.    into the register or memory area where it must be passed.
  3052.    *ARG describes the argument value and where to pass it.
  3053.  
  3054.    ARGBLOCK is the address of the stack-block for all the arguments,
  3055.    or 0 on a machine where arguments are pushed individually.
  3056.  
  3057.    MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
  3058.    so must be careful about how the stack is used. 
  3059.  
  3060.    VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
  3061.    argument stack.  This is used if ACCUMULATE_OUTGOING_ARGS to indicate
  3062.    that we need not worry about saving and restoring the stack.
  3063.  
  3064.    FNDECL is the declaration of the function we are calling.  */
  3065.  
  3066. static void
  3067. store_one_arg (arg, argblock, may_be_alloca, variable_size, fndecl,
  3068.            reg_parm_stack_space)
  3069.      struct arg_data *arg;
  3070.      rtx argblock;
  3071.      int may_be_alloca;
  3072.      int variable_size;
  3073.      tree fndecl;
  3074.      int reg_parm_stack_space;
  3075. {
  3076.   register tree pval = arg->tree_value;
  3077.   rtx reg = 0;
  3078.   int partial = 0;
  3079.   int used = 0;
  3080.   int i, lower_bound, upper_bound;
  3081.  
  3082.   if (TREE_CODE (pval) == ERROR_MARK)
  3083.     return;
  3084.  
  3085.   /* Push a new temporary level for any temporaries we make for
  3086.      this argument.  */
  3087.   push_temp_slots ();
  3088.  
  3089. #ifdef ACCUMULATE_OUTGOING_ARGS
  3090.   /* If this is being stored into a pre-allocated, fixed-size, stack area,
  3091.      save any previous data at that location.  */
  3092.   if (argblock && ! variable_size && arg->stack)
  3093.     {
  3094. #ifdef ARGS_GROW_DOWNWARD
  3095.       /* stack_slot is negative, but we want to index stack_usage_map */
  3096.       /* with positive values. */
  3097.       if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
  3098.     upper_bound = -INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1)) + 1;
  3099.       else
  3100.     abort ();
  3101.  
  3102.       lower_bound = upper_bound - arg->size.constant;
  3103. #else
  3104.       if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
  3105.     lower_bound = INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1));
  3106.       else
  3107.     lower_bound = 0;
  3108.  
  3109.       upper_bound = lower_bound + arg->size.constant;
  3110. #endif
  3111.  
  3112.       for (i = lower_bound; i < upper_bound; i++)
  3113.     if (stack_usage_map[i]
  3114. #ifdef REG_PARM_STACK_SPACE
  3115.         /* Don't store things in the fixed argument area at this point;
  3116.            it has already been saved.  */
  3117.         && i > reg_parm_stack_space
  3118. #endif
  3119.         )
  3120.       break;
  3121.  
  3122.       if (i != upper_bound)
  3123.     {
  3124.       /* We need to make a save area.  See what mode we can make it.  */
  3125.       enum machine_mode save_mode
  3126.         = mode_for_size (arg->size.constant * BITS_PER_UNIT, MODE_INT, 1);
  3127.       rtx stack_area
  3128.         = gen_rtx (MEM, save_mode,
  3129.                memory_address (save_mode, XEXP (arg->stack_slot, 0)));
  3130.  
  3131.       if (save_mode == BLKmode)
  3132.         {
  3133.           arg->save_area = assign_stack_temp (BLKmode,
  3134.                           arg->size.constant, 0);
  3135.           MEM_IN_STRUCT_P (arg->save_area)
  3136.         = AGGREGATE_TYPE_P (TREE_TYPE (arg->tree_value));
  3137.           preserve_temp_slots (arg->save_area);
  3138.           emit_block_move (validize_mem (arg->save_area), stack_area,
  3139.                    GEN_INT (arg->size.constant),
  3140.                    PARM_BOUNDARY / BITS_PER_UNIT);
  3141.         }
  3142.       else
  3143.         {
  3144.           arg->save_area = gen_reg_rtx (save_mode);
  3145.           emit_move_insn (arg->save_area, stack_area);
  3146.         }
  3147.     }
  3148.     }
  3149. #endif
  3150.  
  3151.   /* If this isn't going to be placed on both the stack and in registers,
  3152.      set up the register and number of words.  */
  3153.   if (! arg->pass_on_stack)
  3154.     reg = arg->reg, partial = arg->partial;
  3155.  
  3156.   if (reg != 0 && partial == 0)
  3157.     /* Being passed entirely in a register.  We shouldn't be called in
  3158.        this case.   */
  3159.     abort ();
  3160.  
  3161. #ifdef STRICT_ALIGNMENT
  3162.   /* If this arg needs special alignment, don't load the registers
  3163.      here.  */
  3164.   if (arg->n_aligned_regs != 0)
  3165.     reg = 0;
  3166. #endif
  3167.   
  3168.   /* If this is being partially passed in a register, but multiple locations
  3169.      are specified, we assume that the one partially used is the one that is
  3170.      listed first.  */
  3171.   if (reg && GET_CODE (reg) == EXPR_LIST)
  3172.     reg = XEXP (reg, 0);
  3173.  
  3174.   /* If this is being passed partially in a register, we can't evaluate
  3175.      it directly into its stack slot.  Otherwise, we can.  */
  3176.   if (arg->value == 0)
  3177.     {
  3178. #ifdef ACCUMULATE_OUTGOING_ARGS
  3179.       /* stack_arg_under_construction is nonzero if a function argument is
  3180.      being evaluated directly into the outgoing argument list and
  3181.      expand_call must take special action to preserve the argument list
  3182.      if it is called recursively.
  3183.  
  3184.      For scalar function arguments stack_usage_map is sufficient to
  3185.      determine which stack slots must be saved and restored.  Scalar
  3186.      arguments in general have pass_on_stack == 0.
  3187.  
  3188.      If this argument is initialized by a function which takes the
  3189.      address of the argument (a C++ constructor or a C function
  3190.      returning a BLKmode structure), then stack_usage_map is
  3191.      insufficient and expand_call must push the stack around the
  3192.      function call.  Such arguments have pass_on_stack == 1.
  3193.  
  3194.      Note that it is always safe to set stack_arg_under_construction,
  3195.      but this generates suboptimal code if set when not needed.  */
  3196.  
  3197.       if (arg->pass_on_stack)
  3198.     stack_arg_under_construction++;
  3199. #endif
  3200.       arg->value = expand_expr (pval,
  3201.                 (partial
  3202.                  || TYPE_MODE (TREE_TYPE (pval)) != arg->mode)
  3203.                 ? NULL_RTX : arg->stack,
  3204.                 VOIDmode, 0);
  3205.  
  3206.       /* If we are promoting object (or for any other reason) the mode
  3207.      doesn't agree, convert the mode.  */
  3208.  
  3209.       if (arg->mode != TYPE_MODE (TREE_TYPE (pval)))
  3210.     arg->value = convert_modes (arg->mode, TYPE_MODE (TREE_TYPE (pval)),
  3211.                     arg->value, arg->unsignedp);
  3212.  
  3213. #ifdef ACCUMULATE_OUTGOING_ARGS
  3214.       if (arg->pass_on_stack)
  3215.     stack_arg_under_construction--;
  3216. #endif
  3217.     }
  3218.  
  3219.   /* Don't allow anything left on stack from computation
  3220.      of argument to alloca.  */
  3221.   if (may_be_alloca)
  3222.     do_pending_stack_adjust ();
  3223.  
  3224.   if (arg->value == arg->stack)
  3225.     /* If the value is already in the stack slot, we are done.  */
  3226.     ;
  3227.   else if (arg->mode != BLKmode)
  3228.     {
  3229.       register int size;
  3230.  
  3231.       /* Argument is a scalar, not entirely passed in registers.
  3232.      (If part is passed in registers, arg->partial says how much
  3233.      and emit_push_insn will take care of putting it there.)
  3234.      
  3235.      Push it, and if its size is less than the
  3236.      amount of space allocated to it,
  3237.      also bump stack pointer by the additional space.
  3238.      Note that in C the default argument promotions
  3239.      will prevent such mismatches.  */
  3240.  
  3241.       size = GET_MODE_SIZE (arg->mode);
  3242.       /* Compute how much space the push instruction will push.
  3243.      On many machines, pushing a byte will advance the stack
  3244.      pointer by a halfword.  */
  3245. #ifdef PUSH_ROUNDING
  3246.       size = PUSH_ROUNDING (size);
  3247. #endif
  3248.       used = size;
  3249.  
  3250.       /* Compute how much space the argument should get:
  3251.      round up to a multiple of the alignment for arguments.  */
  3252.       if (none != FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)))
  3253.     used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1)
  3254.          / (PARM_BOUNDARY / BITS_PER_UNIT))
  3255.         * (PARM_BOUNDARY / BITS_PER_UNIT));
  3256.  
  3257. #if defined (_WIN32) && defined (NEXT_PDO)
  3258.     /* If _last_argument_being_pushed is true, then we are returning a 
  3259.        struct > 8 bytes and are calling objc_msgSend or objc_msgSendSuper.
  3260.        In this event, we're going to OR on the high bit of the parameter
  3261.        before pushing it on the stack so that the messenger knows that 
  3262.        self and sel are one parameter further down the stack than usual.*/
  3263.     if( _last_argument_being_pushed )
  3264.     {
  3265.         rtx ior;
  3266.  
  3267.         /* Reset the flag */
  3268.          _last_argument_being_pushed = 0;
  3269.  
  3270.         /* Make sure to not affect any outer calls so unset the indicator */        
  3271.         _function_returns_struct = 0;
  3272.  
  3273.         /* Expand the ior optab on the arg rtx */
  3274.         ior = expand_binop( arg->mode, ior_optab, arg->value, 
  3275.             GEN_INT ((HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (arg->mode) - 1)), arg->value,
  3276.             1, OPTAB_LIB_WIDEN );
  3277.         if( ior && ior != arg->value )
  3278.             emit_move_insn( arg->value, ior );
  3279.     }
  3280. #endif /* _WIN32 */
  3281.  
  3282.       /* This isn't already where we want it on the stack, so put it there.
  3283.      This can either be done with push or copy insns.  */
  3284.       emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX,
  3285.               0, partial, reg, used - size,
  3286.               argblock, ARGS_SIZE_RTX (arg->offset));
  3287.     }
  3288.   else
  3289.     {
  3290.       /* BLKmode, at least partly to be pushed.  */
  3291.  
  3292.       register int excess;
  3293.       rtx size_rtx;
  3294.  
  3295.       /* Pushing a nonscalar.
  3296.      If part is passed in registers, PARTIAL says how much
  3297.      and emit_push_insn will take care of putting it there.  */
  3298.  
  3299.       /* Round its size up to a multiple
  3300.      of the allocation unit for arguments.  */
  3301.  
  3302.       if (arg->size.var != 0)
  3303.     {
  3304.       excess = 0;
  3305.       size_rtx = ARGS_SIZE_RTX (arg->size);
  3306.     }
  3307.       else
  3308.     {
  3309.       /* PUSH_ROUNDING has no effect on us, because
  3310.          emit_push_insn for BLKmode is careful to avoid it.  */
  3311.       excess = (arg->size.constant - int_size_in_bytes (TREE_TYPE (pval))
  3312.             + partial * UNITS_PER_WORD);
  3313.       size_rtx = expr_size (pval);
  3314.     }
  3315.  
  3316.       emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
  3317.               TYPE_ALIGN (TREE_TYPE (pval)) / BITS_PER_UNIT, partial,
  3318.               reg, excess, argblock, ARGS_SIZE_RTX (arg->offset));
  3319.     }
  3320.  
  3321.  
  3322.   /* Unless this is a partially-in-register argument, the argument is now
  3323.      in the stack. 
  3324.  
  3325.      ??? Note that this can change arg->value from arg->stack to
  3326.      arg->stack_slot and it matters when they are not the same.
  3327.      It isn't totally clear that this is correct in all cases.  */
  3328.   if (partial == 0)
  3329.     arg->value = arg->stack_slot;
  3330.  
  3331.   /* Once we have pushed something, pops can't safely
  3332.      be deferred during the rest of the arguments.  */
  3333.   NO_DEFER_POP;
  3334.  
  3335.   /* ANSI doesn't require a sequence point here,
  3336.      but PCC has one, so this will avoid some problems.  */
  3337.   emit_queue ();
  3338.  
  3339.   /* Free any temporary slots made in processing this argument.  Show
  3340.      that we might have taken the address of something and pushed that
  3341.      as an operand.  */
  3342. #if !defined (_WIN32) || !defined (NEXT_PDO)
  3343.   preserve_temp_slots (NULL_RTX);
  3344. #endif
  3345.   free_temp_slots ();
  3346.   pop_temp_slots ();
  3347.  
  3348. #ifdef ACCUMULATE_OUTGOING_ARGS
  3349.   /* Now mark the segment we just used.  */
  3350.   if (argblock && ! variable_size && arg->stack)
  3351.     for (i = lower_bound; i < upper_bound; i++)
  3352.       stack_usage_map[i] = 1;
  3353. #endif
  3354. }
  3355.