OSDN Git Service

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