OSDN Git Service

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