OSDN Git Service

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