OSDN Git Service

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