xref: /dragonfly/contrib/gcc-8.0/gcc/calls.c (revision 58e805e6)
1 /* Convert function calls to rtl insns, for GNU C compiler.
2    Copyright (C) 1989-2018 Free Software Foundation, Inc.
3 
4 This file is part of GCC.
5 
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
10 
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 for more details.
15 
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3.  If not see
18 <http://www.gnu.org/licenses/>.  */
19 
20 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "backend.h"
24 #include "target.h"
25 #include "rtl.h"
26 #include "tree.h"
27 #include "gimple.h"
28 #include "predict.h"
29 #include "memmodel.h"
30 #include "tm_p.h"
31 #include "stringpool.h"
32 #include "expmed.h"
33 #include "optabs.h"
34 #include "emit-rtl.h"
35 #include "cgraph.h"
36 #include "diagnostic-core.h"
37 #include "fold-const.h"
38 #include "stor-layout.h"
39 #include "varasm.h"
40 #include "internal-fn.h"
41 #include "dojump.h"
42 #include "explow.h"
43 #include "calls.h"
44 #include "expr.h"
45 #include "output.h"
46 #include "langhooks.h"
47 #include "except.h"
48 #include "dbgcnt.h"
49 #include "rtl-iter.h"
50 #include "tree-chkp.h"
51 #include "tree-vrp.h"
52 #include "tree-ssanames.h"
53 #include "tree-ssa-strlen.h"
54 #include "rtl-chkp.h"
55 #include "intl.h"
56 #include "stringpool.h"
57 #include "attribs.h"
58 #include "builtins.h"
59 #include "gimple-fold.h"
60 
61 /* Like PREFERRED_STACK_BOUNDARY but in units of bytes, not bits.  */
62 #define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)
63 
64 /* Data structure and subroutines used within expand_call.  */
65 
66 struct arg_data
67 {
68   /* Tree node for this argument.  */
69   tree tree_value;
70   /* Mode for value; TYPE_MODE unless promoted.  */
71   machine_mode mode;
72   /* Current RTL value for argument, or 0 if it isn't precomputed.  */
73   rtx value;
74   /* Initially-compute RTL value for argument; only for const functions.  */
75   rtx initial_value;
76   /* Register to pass this argument in, 0 if passed on stack, or an
77      PARALLEL if the arg is to be copied into multiple non-contiguous
78      registers.  */
79   rtx reg;
80   /* Register to pass this argument in when generating tail call sequence.
81      This is not the same register as for normal calls on machines with
82      register windows.  */
83   rtx tail_call_reg;
84   /* If REG is a PARALLEL, this is a copy of VALUE pulled into the correct
85      form for emit_group_move.  */
86   rtx parallel_value;
87   /* If value is passed in neither reg nor stack, this field holds a number
88      of a special slot to be used.  */
89   rtx special_slot;
90   /* For pointer bounds hold an index of parm bounds are bound to.  -1 if
91      there is no such pointer.  */
92   int pointer_arg;
93   /* If pointer_arg refers a structure, then pointer_offset holds an offset
94      of a pointer in this structure.  */
95   int pointer_offset;
96   /* If REG was promoted from the actual mode of the argument expression,
97      indicates whether the promotion is sign- or zero-extended.  */
98   int unsignedp;
99   /* Number of bytes to put in registers.  0 means put the whole arg
100      in registers.  Also 0 if not passed in registers.  */
101   int partial;
102   /* Nonzero if argument must be passed on stack.
103      Note that some arguments may be passed on the stack
104      even though pass_on_stack is zero, just because FUNCTION_ARG says so.
105      pass_on_stack identifies arguments that *cannot* go in registers.  */
106   int pass_on_stack;
107   /* Some fields packaged up for locate_and_pad_parm.  */
108   struct locate_and_pad_arg_data locate;
109   /* Location on the stack at which parameter should be stored.  The store
110      has already been done if STACK == VALUE.  */
111   rtx stack;
112   /* Location on the stack of the start of this argument slot.  This can
113      differ from STACK if this arg pads downward.  This location is known
114      to be aligned to TARGET_FUNCTION_ARG_BOUNDARY.  */
115   rtx stack_slot;
116   /* Place that this stack area has been saved, if needed.  */
117   rtx save_area;
118   /* If an argument's alignment does not permit direct copying into registers,
119      copy in smaller-sized pieces into pseudos.  These are stored in a
120      block pointed to by this field.  The next field says how many
121      word-sized pseudos we made.  */
122   rtx *aligned_regs;
123   int n_aligned_regs;
124 };
125 
126 /* A vector of one char per byte of stack space.  A byte if nonzero if
127    the corresponding stack location has been used.
128    This vector is used to prevent a function call within an argument from
129    clobbering any stack already set up.  */
130 static char *stack_usage_map;
131 
132 /* Size of STACK_USAGE_MAP.  */
133 static unsigned int highest_outgoing_arg_in_use;
134 
135 /* Assume that any stack location at this byte index is used,
136    without checking the contents of stack_usage_map.  */
137 static unsigned HOST_WIDE_INT stack_usage_watermark = HOST_WIDE_INT_M1U;
138 
139 /* A bitmap of virtual-incoming stack space.  Bit is set if the corresponding
140    stack location's tail call argument has been already stored into the stack.
141    This bitmap is used to prevent sibling call optimization if function tries
142    to use parent's incoming argument slots when they have been already
143    overwritten with tail call arguments.  */
144 static sbitmap stored_args_map;
145 
146 /* Assume that any virtual-incoming location at this byte index has been
147    stored, without checking the contents of stored_args_map.  */
148 static unsigned HOST_WIDE_INT stored_args_watermark;
149 
150 /* stack_arg_under_construction is nonzero when an argument may be
151    initialized with a constructor call (including a C function that
152    returns a BLKmode struct) and expand_call must take special action
153    to make sure the object being constructed does not overlap the
154    argument list for the constructor call.  */
155 static int stack_arg_under_construction;
156 
157 static void precompute_register_parameters (int, struct arg_data *, int *);
158 static void store_bounds (struct arg_data *, struct arg_data *);
159 static int store_one_arg (struct arg_data *, rtx, int, int, int);
160 static void store_unaligned_arguments_into_pseudos (struct arg_data *, int);
161 static int finalize_must_preallocate (int, int, struct arg_data *,
162 				      struct args_size *);
163 static void precompute_arguments (int, struct arg_data *);
164 static void compute_argument_addresses (struct arg_data *, rtx, int);
165 static rtx rtx_for_function_call (tree, tree);
166 static void load_register_parameters (struct arg_data *, int, rtx *, int,
167 				      int, int *);
168 static int special_function_p (const_tree, int);
169 static int check_sibcall_argument_overlap_1 (rtx);
170 static int check_sibcall_argument_overlap (rtx_insn *, struct arg_data *, int);
171 
172 static tree split_complex_types (tree);
173 
174 #ifdef REG_PARM_STACK_SPACE
175 static rtx save_fixed_argument_area (int, rtx, int *, int *);
176 static void restore_fixed_argument_area (rtx, rtx, int, int);
177 #endif
178 
179 /* Return true if bytes [LOWER_BOUND, UPPER_BOUND) of the outgoing
180    stack region might already be in use.  */
181 
182 static bool
stack_region_maybe_used_p(poly_uint64 lower_bound,poly_uint64 upper_bound,unsigned int reg_parm_stack_space)183 stack_region_maybe_used_p (poly_uint64 lower_bound, poly_uint64 upper_bound,
184 			   unsigned int reg_parm_stack_space)
185 {
186   unsigned HOST_WIDE_INT const_lower, const_upper;
187   const_lower = constant_lower_bound (lower_bound);
188   if (!upper_bound.is_constant (&const_upper))
189     const_upper = HOST_WIDE_INT_M1U;
190 
191   if (const_upper > stack_usage_watermark)
192     return true;
193 
194   /* Don't worry about things in the fixed argument area;
195      it has already been saved.  */
196   const_lower = MAX (const_lower, reg_parm_stack_space);
197   const_upper = MIN (const_upper, highest_outgoing_arg_in_use);
198   for (unsigned HOST_WIDE_INT i = const_lower; i < const_upper; ++i)
199     if (stack_usage_map[i])
200       return true;
201   return false;
202 }
203 
204 /* Record that bytes [LOWER_BOUND, UPPER_BOUND) of the outgoing
205    stack region are now in use.  */
206 
207 static void
mark_stack_region_used(poly_uint64 lower_bound,poly_uint64 upper_bound)208 mark_stack_region_used (poly_uint64 lower_bound, poly_uint64 upper_bound)
209 {
210   unsigned HOST_WIDE_INT const_lower, const_upper;
211   const_lower = constant_lower_bound (lower_bound);
212   if (upper_bound.is_constant (&const_upper))
213     for (unsigned HOST_WIDE_INT i = const_lower; i < const_upper; ++i)
214       stack_usage_map[i] = 1;
215   else
216     stack_usage_watermark = MIN (stack_usage_watermark, const_lower);
217 }
218 
219 /* Force FUNEXP into a form suitable for the address of a CALL,
220    and return that as an rtx.  Also load the static chain register
221    if FNDECL is a nested function.
222 
223    CALL_FUSAGE points to a variable holding the prospective
224    CALL_INSN_FUNCTION_USAGE information.  */
225 
226 rtx
prepare_call_address(tree fndecl_or_type,rtx funexp,rtx static_chain_value,rtx * call_fusage,int reg_parm_seen,int flags)227 prepare_call_address (tree fndecl_or_type, rtx funexp, rtx static_chain_value,
228 		      rtx *call_fusage, int reg_parm_seen, int flags)
229 {
230   /* Make a valid memory address and copy constants through pseudo-regs,
231      but not for a constant address if -fno-function-cse.  */
232   if (GET_CODE (funexp) != SYMBOL_REF)
233     {
234       /* If it's an indirect call by descriptor, generate code to perform
235 	 runtime identification of the pointer and load the descriptor.  */
236       if ((flags & ECF_BY_DESCRIPTOR) && !flag_trampolines)
237 	{
238 	  const int bit_val = targetm.calls.custom_function_descriptors;
239 	  rtx call_lab = gen_label_rtx ();
240 
241 	  gcc_assert (fndecl_or_type && TYPE_P (fndecl_or_type));
242 	  fndecl_or_type
243 	    = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL, NULL_TREE,
244 			  fndecl_or_type);
245 	  DECL_STATIC_CHAIN (fndecl_or_type) = 1;
246 	  rtx chain = targetm.calls.static_chain (fndecl_or_type, false);
247 
248 	  if (GET_MODE (funexp) != Pmode)
249 	    funexp = convert_memory_address (Pmode, funexp);
250 
251 	  /* Avoid long live ranges around function calls.  */
252 	  funexp = copy_to_mode_reg (Pmode, funexp);
253 
254 	  if (REG_P (chain))
255 	    emit_insn (gen_rtx_CLOBBER (VOIDmode, chain));
256 
257 	  /* Emit the runtime identification pattern.  */
258 	  rtx mask = gen_rtx_AND (Pmode, funexp, GEN_INT (bit_val));
259 	  emit_cmp_and_jump_insns (mask, const0_rtx, EQ, NULL_RTX, Pmode, 1,
260 				   call_lab);
261 
262 	  /* Statically predict the branch to very likely taken.  */
263 	  rtx_insn *insn = get_last_insn ();
264 	  if (JUMP_P (insn))
265 	    predict_insn_def (insn, PRED_BUILTIN_EXPECT, TAKEN);
266 
267 	  /* Load the descriptor.  */
268 	  rtx mem = gen_rtx_MEM (ptr_mode,
269 				 plus_constant (Pmode, funexp, - bit_val));
270 	  MEM_NOTRAP_P (mem) = 1;
271 	  mem = convert_memory_address (Pmode, mem);
272 	  emit_move_insn (chain, mem);
273 
274 	  mem = gen_rtx_MEM (ptr_mode,
275 			     plus_constant (Pmode, funexp,
276 					    POINTER_SIZE / BITS_PER_UNIT
277 					      - bit_val));
278 	  MEM_NOTRAP_P (mem) = 1;
279 	  mem = convert_memory_address (Pmode, mem);
280 	  emit_move_insn (funexp, mem);
281 
282 	  emit_label (call_lab);
283 
284 	  if (REG_P (chain))
285 	    {
286 	      use_reg (call_fusage, chain);
287 	      STATIC_CHAIN_REG_P (chain) = 1;
288 	    }
289 
290 	  /* Make sure we're not going to be overwritten below.  */
291 	  gcc_assert (!static_chain_value);
292 	}
293 
294       /* If we are using registers for parameters, force the
295 	 function address into a register now.  */
296       funexp = ((reg_parm_seen
297 		 && targetm.small_register_classes_for_mode_p (FUNCTION_MODE))
298 		 ? force_not_mem (memory_address (FUNCTION_MODE, funexp))
299 		 : memory_address (FUNCTION_MODE, funexp));
300     }
301   else
302     {
303       /* funexp could be a SYMBOL_REF represents a function pointer which is
304 	 of ptr_mode.  In this case, it should be converted into address mode
305 	 to be a valid address for memory rtx pattern.  See PR 64971.  */
306       if (GET_MODE (funexp) != Pmode)
307 	funexp = convert_memory_address (Pmode, funexp);
308 
309       if (!(flags & ECF_SIBCALL))
310 	{
311 	  if (!NO_FUNCTION_CSE && optimize && ! flag_no_function_cse)
312 	    funexp = force_reg (Pmode, funexp);
313 	}
314     }
315 
316   if (static_chain_value != 0
317       && (TREE_CODE (fndecl_or_type) != FUNCTION_DECL
318 	  || DECL_STATIC_CHAIN (fndecl_or_type)))
319     {
320       rtx chain;
321 
322       chain = targetm.calls.static_chain (fndecl_or_type, false);
323       static_chain_value = convert_memory_address (Pmode, static_chain_value);
324 
325       emit_move_insn (chain, static_chain_value);
326       if (REG_P (chain))
327 	{
328 	  use_reg (call_fusage, chain);
329 	  STATIC_CHAIN_REG_P (chain) = 1;
330 	}
331     }
332 
333   return funexp;
334 }
335 
336 /* Generate instructions to call function FUNEXP,
337    and optionally pop the results.
338    The CALL_INSN is the first insn generated.
339 
340    FNDECL is the declaration node of the function.  This is given to the
341    hook TARGET_RETURN_POPS_ARGS to determine whether this function pops
342    its own args.
343 
344    FUNTYPE is the data type of the function.  This is given to the hook
345    TARGET_RETURN_POPS_ARGS to determine whether this function pops its
346    own args.  We used to allow an identifier for library functions, but
347    that doesn't work when the return type is an aggregate type and the
348    calling convention says that the pointer to this aggregate is to be
349    popped by the callee.
350 
351    STACK_SIZE is the number of bytes of arguments on the stack,
352    ROUNDED_STACK_SIZE is that number rounded up to
353    PREFERRED_STACK_BOUNDARY; zero if the size is variable.  This is
354    both to put into the call insn and to generate explicit popping
355    code if necessary.
356 
357    STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
358    It is zero if this call doesn't want a structure value.
359 
360    NEXT_ARG_REG is the rtx that results from executing
361      targetm.calls.function_arg (&args_so_far, VOIDmode, void_type_node, true)
362    just after all the args have had their registers assigned.
363    This could be whatever you like, but normally it is the first
364    arg-register beyond those used for args in this call,
365    or 0 if all the arg-registers are used in this call.
366    It is passed on to `gen_call' so you can put this info in the call insn.
367 
368    VALREG is a hard register in which a value is returned,
369    or 0 if the call does not return a value.
370 
371    OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before
372    the args to this call were processed.
373    We restore `inhibit_defer_pop' to that value.
374 
375    CALL_FUSAGE is either empty or an EXPR_LIST of USE expressions that
376    denote registers used by the called function.  */
377 
378 static void
emit_call_1(rtx funexp,tree fntree ATTRIBUTE_UNUSED,tree fndecl ATTRIBUTE_UNUSED,tree funtype ATTRIBUTE_UNUSED,poly_int64 stack_size ATTRIBUTE_UNUSED,poly_int64 rounded_stack_size,poly_int64 struct_value_size ATTRIBUTE_UNUSED,rtx next_arg_reg ATTRIBUTE_UNUSED,rtx valreg,int old_inhibit_defer_pop,rtx call_fusage,int ecf_flags,cumulative_args_t args_so_far ATTRIBUTE_UNUSED)379 emit_call_1 (rtx funexp, tree fntree ATTRIBUTE_UNUSED, tree fndecl ATTRIBUTE_UNUSED,
380 	     tree funtype ATTRIBUTE_UNUSED,
381 	     poly_int64 stack_size ATTRIBUTE_UNUSED,
382 	     poly_int64 rounded_stack_size,
383 	     poly_int64 struct_value_size ATTRIBUTE_UNUSED,
384 	     rtx next_arg_reg ATTRIBUTE_UNUSED, rtx valreg,
385 	     int old_inhibit_defer_pop, rtx call_fusage, int ecf_flags,
386 	     cumulative_args_t args_so_far ATTRIBUTE_UNUSED)
387 {
388   rtx rounded_stack_size_rtx = gen_int_mode (rounded_stack_size, Pmode);
389   rtx call, funmem, pat;
390   int already_popped = 0;
391   poly_int64 n_popped = 0;
392 
393   /* Sibling call patterns never pop arguments (no sibcall(_value)_pop
394      patterns exist).  Any popping that the callee does on return will
395      be from our caller's frame rather than ours.  */
396   if (!(ecf_flags & ECF_SIBCALL))
397     {
398       n_popped += targetm.calls.return_pops_args (fndecl, funtype, stack_size);
399 
400 #ifdef CALL_POPS_ARGS
401       n_popped += CALL_POPS_ARGS (*get_cumulative_args (args_so_far));
402 #endif
403     }
404 
405   /* Ensure address is valid.  SYMBOL_REF is already valid, so no need,
406      and we don't want to load it into a register as an optimization,
407      because prepare_call_address already did it if it should be done.  */
408   if (GET_CODE (funexp) != SYMBOL_REF)
409     funexp = memory_address (FUNCTION_MODE, funexp);
410 
411   funmem = gen_rtx_MEM (FUNCTION_MODE, funexp);
412   if (fndecl && TREE_CODE (fndecl) == FUNCTION_DECL)
413     {
414       tree t = fndecl;
415 
416       /* Although a built-in FUNCTION_DECL and its non-__builtin
417 	 counterpart compare equal and get a shared mem_attrs, they
418 	 produce different dump output in compare-debug compilations,
419 	 if an entry gets garbage collected in one compilation, then
420 	 adds a different (but equivalent) entry, while the other
421 	 doesn't run the garbage collector at the same spot and then
422 	 shares the mem_attr with the equivalent entry. */
423       if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL)
424 	{
425 	  tree t2 = builtin_decl_explicit (DECL_FUNCTION_CODE (t));
426 	  if (t2)
427 	    t = t2;
428 	}
429 
430 	set_mem_expr (funmem, t);
431     }
432   else if (fntree)
433     set_mem_expr (funmem, build_simple_mem_ref (CALL_EXPR_FN (fntree)));
434 
435   if (ecf_flags & ECF_SIBCALL)
436     {
437       if (valreg)
438 	pat = targetm.gen_sibcall_value (valreg, funmem,
439 					 rounded_stack_size_rtx,
440 					 next_arg_reg, NULL_RTX);
441       else
442 	pat = targetm.gen_sibcall (funmem, rounded_stack_size_rtx,
443 				   next_arg_reg,
444 				   gen_int_mode (struct_value_size, Pmode));
445     }
446   /* If the target has "call" or "call_value" insns, then prefer them
447      if no arguments are actually popped.  If the target does not have
448      "call" or "call_value" insns, then we must use the popping versions
449      even if the call has no arguments to pop.  */
450   else if (maybe_ne (n_popped, 0)
451 	   || !(valreg
452 		? targetm.have_call_value ()
453 		: targetm.have_call ()))
454     {
455       rtx n_pop = gen_int_mode (n_popped, Pmode);
456 
457       /* If this subroutine pops its own args, record that in the call insn
458 	 if possible, for the sake of frame pointer elimination.  */
459 
460       if (valreg)
461 	pat = targetm.gen_call_value_pop (valreg, funmem,
462 					  rounded_stack_size_rtx,
463 					  next_arg_reg, n_pop);
464       else
465 	pat = targetm.gen_call_pop (funmem, rounded_stack_size_rtx,
466 				    next_arg_reg, n_pop);
467 
468       already_popped = 1;
469     }
470   else
471     {
472       if (valreg)
473 	pat = targetm.gen_call_value (valreg, funmem, rounded_stack_size_rtx,
474 				      next_arg_reg, NULL_RTX);
475       else
476 	pat = targetm.gen_call (funmem, rounded_stack_size_rtx, next_arg_reg,
477 				gen_int_mode (struct_value_size, Pmode));
478     }
479   emit_insn (pat);
480 
481   /* Find the call we just emitted.  */
482   rtx_call_insn *call_insn = last_call_insn ();
483 
484   /* Some target create a fresh MEM instead of reusing the one provided
485      above.  Set its MEM_EXPR.  */
486   call = get_call_rtx_from (call_insn);
487   if (call
488       && MEM_EXPR (XEXP (call, 0)) == NULL_TREE
489       && MEM_EXPR (funmem) != NULL_TREE)
490     set_mem_expr (XEXP (call, 0), MEM_EXPR (funmem));
491 
492   /* Mark instrumented calls.  */
493   if (call && fntree)
494     CALL_EXPR_WITH_BOUNDS_P (call) = CALL_WITH_BOUNDS_P (fntree);
495 
496   /* Put the register usage information there.  */
497   add_function_usage_to (call_insn, call_fusage);
498 
499   /* If this is a const call, then set the insn's unchanging bit.  */
500   if (ecf_flags & ECF_CONST)
501     RTL_CONST_CALL_P (call_insn) = 1;
502 
503   /* If this is a pure call, then set the insn's unchanging bit.  */
504   if (ecf_flags & ECF_PURE)
505     RTL_PURE_CALL_P (call_insn) = 1;
506 
507   /* If this is a const call, then set the insn's unchanging bit.  */
508   if (ecf_flags & ECF_LOOPING_CONST_OR_PURE)
509     RTL_LOOPING_CONST_OR_PURE_CALL_P (call_insn) = 1;
510 
511   /* Create a nothrow REG_EH_REGION note, if needed.  */
512   make_reg_eh_region_note (call_insn, ecf_flags, 0);
513 
514   if (ecf_flags & ECF_NORETURN)
515     add_reg_note (call_insn, REG_NORETURN, const0_rtx);
516 
517   if (ecf_flags & ECF_RETURNS_TWICE)
518     {
519       add_reg_note (call_insn, REG_SETJMP, const0_rtx);
520       cfun->calls_setjmp = 1;
521     }
522 
523   SIBLING_CALL_P (call_insn) = ((ecf_flags & ECF_SIBCALL) != 0);
524 
525   /* Restore this now, so that we do defer pops for this call's args
526      if the context of the call as a whole permits.  */
527   inhibit_defer_pop = old_inhibit_defer_pop;
528 
529   if (maybe_ne (n_popped, 0))
530     {
531       if (!already_popped)
532 	CALL_INSN_FUNCTION_USAGE (call_insn)
533 	  = gen_rtx_EXPR_LIST (VOIDmode,
534 			       gen_rtx_CLOBBER (VOIDmode, stack_pointer_rtx),
535 			       CALL_INSN_FUNCTION_USAGE (call_insn));
536       rounded_stack_size -= n_popped;
537       rounded_stack_size_rtx = gen_int_mode (rounded_stack_size, Pmode);
538       stack_pointer_delta -= n_popped;
539 
540       add_args_size_note (call_insn, stack_pointer_delta);
541 
542       /* If popup is needed, stack realign must use DRAP  */
543       if (SUPPORTS_STACK_ALIGNMENT)
544         crtl->need_drap = true;
545     }
546   /* For noreturn calls when not accumulating outgoing args force
547      REG_ARGS_SIZE note to prevent crossjumping of calls with different
548      args sizes.  */
549   else if (!ACCUMULATE_OUTGOING_ARGS && (ecf_flags & ECF_NORETURN) != 0)
550     add_args_size_note (call_insn, stack_pointer_delta);
551 
552   if (!ACCUMULATE_OUTGOING_ARGS)
553     {
554       /* If returning from the subroutine does not automatically pop the args,
555 	 we need an instruction to pop them sooner or later.
556 	 Perhaps do it now; perhaps just record how much space to pop later.
557 
558 	 If returning from the subroutine does pop the args, indicate that the
559 	 stack pointer will be changed.  */
560 
561       if (maybe_ne (rounded_stack_size, 0))
562 	{
563 	  if (ecf_flags & ECF_NORETURN)
564 	    /* Just pretend we did the pop.  */
565 	    stack_pointer_delta -= rounded_stack_size;
566 	  else if (flag_defer_pop && inhibit_defer_pop == 0
567 	      && ! (ecf_flags & (ECF_CONST | ECF_PURE)))
568 	    pending_stack_adjust += rounded_stack_size;
569 	  else
570 	    adjust_stack (rounded_stack_size_rtx);
571 	}
572     }
573   /* When we accumulate outgoing args, we must avoid any stack manipulations.
574      Restore the stack pointer to its original value now.  Usually
575      ACCUMULATE_OUTGOING_ARGS targets don't get here, but there are exceptions.
576      On  i386 ACCUMULATE_OUTGOING_ARGS can be enabled on demand, and
577      popping variants of functions exist as well.
578 
579      ??? We may optimize similar to defer_pop above, but it is
580      probably not worthwhile.
581 
582      ??? It will be worthwhile to enable combine_stack_adjustments even for
583      such machines.  */
584   else if (maybe_ne (n_popped, 0))
585     anti_adjust_stack (gen_int_mode (n_popped, Pmode));
586 }
587 
588 /* Determine if the function identified by FNDECL is one with
589    special properties we wish to know about.  Modify FLAGS accordingly.
590 
591    For example, if the function might return more than one time (setjmp), then
592    set ECF_RETURNS_TWICE.
593 
594    Set ECF_MAY_BE_ALLOCA for any memory allocation function that might allocate
595    space from the stack such as alloca.  */
596 
597 static int
special_function_p(const_tree fndecl,int flags)598 special_function_p (const_tree fndecl, int flags)
599 {
600   tree name_decl = DECL_NAME (fndecl);
601 
602   /* For instrumentation clones we want to derive flags
603      from the original name.  */
604   if (cgraph_node::get (fndecl)
605       && cgraph_node::get (fndecl)->instrumentation_clone)
606     name_decl = DECL_NAME (cgraph_node::get (fndecl)->orig_decl);
607 
608   if (fndecl && name_decl
609       && IDENTIFIER_LENGTH (name_decl) <= 11
610       /* Exclude functions not at the file scope, or not `extern',
611 	 since they are not the magic functions we would otherwise
612 	 think they are.
613 	 FIXME: this should be handled with attributes, not with this
614 	 hacky imitation of DECL_ASSEMBLER_NAME.  It's (also) wrong
615 	 because you can declare fork() inside a function if you
616 	 wish.  */
617       && (DECL_CONTEXT (fndecl) == NULL_TREE
618 	  || TREE_CODE (DECL_CONTEXT (fndecl)) == TRANSLATION_UNIT_DECL)
619       && TREE_PUBLIC (fndecl))
620     {
621       const char *name = IDENTIFIER_POINTER (name_decl);
622       const char *tname = name;
623 
624       /* We assume that alloca will always be called by name.  It
625 	 makes no sense to pass it as a pointer-to-function to
626 	 anything that does not understand its behavior.  */
627       if (IDENTIFIER_LENGTH (name_decl) == 6
628 	  && name[0] == 'a'
629 	  && ! strcmp (name, "alloca"))
630 	flags |= ECF_MAY_BE_ALLOCA;
631 
632       /* Disregard prefix _ or __.  */
633       if (name[0] == '_')
634 	{
635 	  if (name[1] == '_')
636 	    tname += 2;
637 	  else
638 	    tname += 1;
639 	}
640 
641       /* ECF_RETURNS_TWICE is safe even for -ffreestanding.  */
642       if (! strcmp (tname, "setjmp")
643 	  || ! strcmp (tname, "sigsetjmp")
644 	  || ! strcmp (name, "savectx")
645 	  || ! strcmp (name, "vfork")
646 	  || ! strcmp (name, "getcontext"))
647 	flags |= ECF_RETURNS_TWICE;
648     }
649 
650   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
651       && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl)))
652     flags |= ECF_MAY_BE_ALLOCA;
653 
654   return flags;
655 }
656 
657 /* Similar to special_function_p; return a set of ERF_ flags for the
658    function FNDECL.  */
659 static int
decl_return_flags(tree fndecl)660 decl_return_flags (tree fndecl)
661 {
662   tree attr;
663   tree type = TREE_TYPE (fndecl);
664   if (!type)
665     return 0;
666 
667   attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
668   if (!attr)
669     return 0;
670 
671   attr = TREE_VALUE (TREE_VALUE (attr));
672   if (!attr || TREE_STRING_LENGTH (attr) < 1)
673     return 0;
674 
675   switch (TREE_STRING_POINTER (attr)[0])
676     {
677     case '1':
678     case '2':
679     case '3':
680     case '4':
681       return ERF_RETURNS_ARG | (TREE_STRING_POINTER (attr)[0] - '1');
682 
683     case 'm':
684       return ERF_NOALIAS;
685 
686     case '.':
687     default:
688       return 0;
689     }
690 }
691 
692 /* Return nonzero when FNDECL represents a call to setjmp.  */
693 
694 int
setjmp_call_p(const_tree fndecl)695 setjmp_call_p (const_tree fndecl)
696 {
697   if (DECL_IS_RETURNS_TWICE (fndecl))
698     return ECF_RETURNS_TWICE;
699   return special_function_p (fndecl, 0) & ECF_RETURNS_TWICE;
700 }
701 
702 
703 /* Return true if STMT may be an alloca call.  */
704 
705 bool
gimple_maybe_alloca_call_p(const gimple * stmt)706 gimple_maybe_alloca_call_p (const gimple *stmt)
707 {
708   tree fndecl;
709 
710   if (!is_gimple_call (stmt))
711     return false;
712 
713   fndecl = gimple_call_fndecl (stmt);
714   if (fndecl && (special_function_p (fndecl, 0) & ECF_MAY_BE_ALLOCA))
715     return true;
716 
717   return false;
718 }
719 
720 /* Return true if STMT is a builtin alloca call.  */
721 
722 bool
gimple_alloca_call_p(const gimple * stmt)723 gimple_alloca_call_p (const gimple *stmt)
724 {
725   tree fndecl;
726 
727   if (!is_gimple_call (stmt))
728     return false;
729 
730   fndecl = gimple_call_fndecl (stmt);
731   if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
732     switch (DECL_FUNCTION_CODE (fndecl))
733       {
734       CASE_BUILT_IN_ALLOCA:
735 	return gimple_call_num_args (stmt) > 0;
736       default:
737 	break;
738       }
739 
740   return false;
741 }
742 
743 /* Return true when exp contains a builtin alloca call.  */
744 
745 bool
alloca_call_p(const_tree exp)746 alloca_call_p (const_tree exp)
747 {
748   tree fndecl;
749   if (TREE_CODE (exp) == CALL_EXPR
750       && (fndecl = get_callee_fndecl (exp))
751       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
752     switch (DECL_FUNCTION_CODE (fndecl))
753       {
754       CASE_BUILT_IN_ALLOCA:
755         return true;
756       default:
757 	break;
758       }
759 
760   return false;
761 }
762 
763 /* Return TRUE if FNDECL is either a TM builtin or a TM cloned
764    function.  Return FALSE otherwise.  */
765 
766 static bool
is_tm_builtin(const_tree fndecl)767 is_tm_builtin (const_tree fndecl)
768 {
769   if (fndecl == NULL)
770     return false;
771 
772   if (decl_is_tm_clone (fndecl))
773     return true;
774 
775   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
776     {
777       switch (DECL_FUNCTION_CODE (fndecl))
778 	{
779 	case BUILT_IN_TM_COMMIT:
780 	case BUILT_IN_TM_COMMIT_EH:
781 	case BUILT_IN_TM_ABORT:
782 	case BUILT_IN_TM_IRREVOCABLE:
783 	case BUILT_IN_TM_GETTMCLONE_IRR:
784 	case BUILT_IN_TM_MEMCPY:
785 	case BUILT_IN_TM_MEMMOVE:
786 	case BUILT_IN_TM_MEMSET:
787 	CASE_BUILT_IN_TM_STORE (1):
788 	CASE_BUILT_IN_TM_STORE (2):
789 	CASE_BUILT_IN_TM_STORE (4):
790 	CASE_BUILT_IN_TM_STORE (8):
791 	CASE_BUILT_IN_TM_STORE (FLOAT):
792 	CASE_BUILT_IN_TM_STORE (DOUBLE):
793 	CASE_BUILT_IN_TM_STORE (LDOUBLE):
794 	CASE_BUILT_IN_TM_STORE (M64):
795 	CASE_BUILT_IN_TM_STORE (M128):
796 	CASE_BUILT_IN_TM_STORE (M256):
797 	CASE_BUILT_IN_TM_LOAD (1):
798 	CASE_BUILT_IN_TM_LOAD (2):
799 	CASE_BUILT_IN_TM_LOAD (4):
800 	CASE_BUILT_IN_TM_LOAD (8):
801 	CASE_BUILT_IN_TM_LOAD (FLOAT):
802 	CASE_BUILT_IN_TM_LOAD (DOUBLE):
803 	CASE_BUILT_IN_TM_LOAD (LDOUBLE):
804 	CASE_BUILT_IN_TM_LOAD (M64):
805 	CASE_BUILT_IN_TM_LOAD (M128):
806 	CASE_BUILT_IN_TM_LOAD (M256):
807 	case BUILT_IN_TM_LOG:
808 	case BUILT_IN_TM_LOG_1:
809 	case BUILT_IN_TM_LOG_2:
810 	case BUILT_IN_TM_LOG_4:
811 	case BUILT_IN_TM_LOG_8:
812 	case BUILT_IN_TM_LOG_FLOAT:
813 	case BUILT_IN_TM_LOG_DOUBLE:
814 	case BUILT_IN_TM_LOG_LDOUBLE:
815 	case BUILT_IN_TM_LOG_M64:
816 	case BUILT_IN_TM_LOG_M128:
817 	case BUILT_IN_TM_LOG_M256:
818 	  return true;
819 	default:
820 	  break;
821 	}
822     }
823   return false;
824 }
825 
826 /* Detect flags (function attributes) from the function decl or type node.  */
827 
828 int
flags_from_decl_or_type(const_tree exp)829 flags_from_decl_or_type (const_tree exp)
830 {
831   int flags = 0;
832 
833   if (DECL_P (exp))
834     {
835       /* The function exp may have the `malloc' attribute.  */
836       if (DECL_IS_MALLOC (exp))
837 	flags |= ECF_MALLOC;
838 
839       /* The function exp may have the `returns_twice' attribute.  */
840       if (DECL_IS_RETURNS_TWICE (exp))
841 	flags |= ECF_RETURNS_TWICE;
842 
843       /* Process the pure and const attributes.  */
844       if (TREE_READONLY (exp))
845 	flags |= ECF_CONST;
846       if (DECL_PURE_P (exp))
847 	flags |= ECF_PURE;
848       if (DECL_LOOPING_CONST_OR_PURE_P (exp))
849 	flags |= ECF_LOOPING_CONST_OR_PURE;
850 
851       if (DECL_IS_NOVOPS (exp))
852 	flags |= ECF_NOVOPS;
853       if (lookup_attribute ("leaf", DECL_ATTRIBUTES (exp)))
854 	flags |= ECF_LEAF;
855       if (lookup_attribute ("cold", DECL_ATTRIBUTES (exp)))
856 	flags |= ECF_COLD;
857 
858       if (TREE_NOTHROW (exp))
859 	flags |= ECF_NOTHROW;
860 
861       if (flag_tm)
862 	{
863 	  if (is_tm_builtin (exp))
864 	    flags |= ECF_TM_BUILTIN;
865 	  else if ((flags & (ECF_CONST|ECF_NOVOPS)) != 0
866 		   || lookup_attribute ("transaction_pure",
867 					TYPE_ATTRIBUTES (TREE_TYPE (exp))))
868 	    flags |= ECF_TM_PURE;
869 	}
870 
871       flags = special_function_p (exp, flags);
872     }
873   else if (TYPE_P (exp))
874     {
875       if (TYPE_READONLY (exp))
876 	flags |= ECF_CONST;
877 
878       if (flag_tm
879 	  && ((flags & ECF_CONST) != 0
880 	      || lookup_attribute ("transaction_pure", TYPE_ATTRIBUTES (exp))))
881 	flags |= ECF_TM_PURE;
882     }
883   else
884     gcc_unreachable ();
885 
886   if (TREE_THIS_VOLATILE (exp))
887     {
888       flags |= ECF_NORETURN;
889       if (flags & (ECF_CONST|ECF_PURE))
890 	flags |= ECF_LOOPING_CONST_OR_PURE;
891     }
892 
893   return flags;
894 }
895 
896 /* Detect flags from a CALL_EXPR.  */
897 
898 int
call_expr_flags(const_tree t)899 call_expr_flags (const_tree t)
900 {
901   int flags;
902   tree decl = get_callee_fndecl (t);
903 
904   if (decl)
905     flags = flags_from_decl_or_type (decl);
906   else if (CALL_EXPR_FN (t) == NULL_TREE)
907     flags = internal_fn_flags (CALL_EXPR_IFN (t));
908   else
909     {
910       tree type = TREE_TYPE (CALL_EXPR_FN (t));
911       if (type && TREE_CODE (type) == POINTER_TYPE)
912 	flags = flags_from_decl_or_type (TREE_TYPE (type));
913       else
914 	flags = 0;
915       if (CALL_EXPR_BY_DESCRIPTOR (t))
916 	flags |= ECF_BY_DESCRIPTOR;
917     }
918 
919   return flags;
920 }
921 
922 /* Return true if TYPE should be passed by invisible reference.  */
923 
924 bool
pass_by_reference(CUMULATIVE_ARGS * ca,machine_mode mode,tree type,bool named_arg)925 pass_by_reference (CUMULATIVE_ARGS *ca, machine_mode mode,
926 		   tree type, bool named_arg)
927 {
928   if (type)
929     {
930       /* If this type contains non-trivial constructors, then it is
931 	 forbidden for the middle-end to create any new copies.  */
932       if (TREE_ADDRESSABLE (type))
933 	return true;
934 
935       /* GCC post 3.4 passes *all* variable sized types by reference.  */
936       if (!TYPE_SIZE (type) || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
937 	return true;
938 
939       /* If a record type should be passed the same as its first (and only)
940 	 member, use the type and mode of that member.  */
941       if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type))
942 	{
943 	  type = TREE_TYPE (first_field (type));
944 	  mode = TYPE_MODE (type);
945 	}
946     }
947 
948   return targetm.calls.pass_by_reference (pack_cumulative_args (ca), mode,
949 					  type, named_arg);
950 }
951 
952 /* Return true if TYPE, which is passed by reference, should be callee
953    copied instead of caller copied.  */
954 
955 bool
reference_callee_copied(CUMULATIVE_ARGS * ca,machine_mode mode,tree type,bool named_arg)956 reference_callee_copied (CUMULATIVE_ARGS *ca, machine_mode mode,
957 			 tree type, bool named_arg)
958 {
959   if (type && TREE_ADDRESSABLE (type))
960     return false;
961   return targetm.calls.callee_copies (pack_cumulative_args (ca), mode, type,
962 				      named_arg);
963 }
964 
965 
966 /* Precompute all register parameters as described by ARGS, storing values
967    into fields within the ARGS array.
968 
969    NUM_ACTUALS indicates the total number elements in the ARGS array.
970 
971    Set REG_PARM_SEEN if we encounter a register parameter.  */
972 
973 static void
precompute_register_parameters(int num_actuals,struct arg_data * args,int * reg_parm_seen)974 precompute_register_parameters (int num_actuals, struct arg_data *args,
975 				int *reg_parm_seen)
976 {
977   int i;
978 
979   *reg_parm_seen = 0;
980 
981   for (i = 0; i < num_actuals; i++)
982     if (args[i].reg != 0 && ! args[i].pass_on_stack)
983       {
984 	*reg_parm_seen = 1;
985 
986 	if (args[i].value == 0)
987 	  {
988 	    push_temp_slots ();
989 	    args[i].value = expand_normal (args[i].tree_value);
990 	    preserve_temp_slots (args[i].value);
991 	    pop_temp_slots ();
992 	  }
993 
994 	/* If we are to promote the function arg to a wider mode,
995 	   do it now.  */
996 
997 	if (args[i].mode != TYPE_MODE (TREE_TYPE (args[i].tree_value)))
998 	  args[i].value
999 	    = convert_modes (args[i].mode,
1000 			     TYPE_MODE (TREE_TYPE (args[i].tree_value)),
1001 			     args[i].value, args[i].unsignedp);
1002 
1003 	/* If the value is a non-legitimate constant, force it into a
1004 	   pseudo now.  TLS symbols sometimes need a call to resolve.  */
1005 	if (CONSTANT_P (args[i].value)
1006 	    && !targetm.legitimate_constant_p (args[i].mode, args[i].value))
1007 	  args[i].value = force_reg (args[i].mode, args[i].value);
1008 
1009 	/* If we're going to have to load the value by parts, pull the
1010 	   parts into pseudos.  The part extraction process can involve
1011 	   non-trivial computation.  */
1012 	if (GET_CODE (args[i].reg) == PARALLEL)
1013 	  {
1014 	    tree type = TREE_TYPE (args[i].tree_value);
1015 	    args[i].parallel_value
1016 	      = emit_group_load_into_temps (args[i].reg, args[i].value,
1017 					    type, int_size_in_bytes (type));
1018 	  }
1019 
1020 	/* If the value is expensive, and we are inside an appropriately
1021 	   short loop, put the value into a pseudo and then put the pseudo
1022 	   into the hard reg.
1023 
1024 	   For small register classes, also do this if this call uses
1025 	   register parameters.  This is to avoid reload conflicts while
1026 	   loading the parameters registers.  */
1027 
1028 	else if ((! (REG_P (args[i].value)
1029 		     || (GET_CODE (args[i].value) == SUBREG
1030 			 && REG_P (SUBREG_REG (args[i].value)))))
1031 		 && args[i].mode != BLKmode
1032 		 && (set_src_cost (args[i].value, args[i].mode,
1033 				   optimize_insn_for_speed_p ())
1034 		     > COSTS_N_INSNS (1))
1035 		 && ((*reg_parm_seen
1036 		      && targetm.small_register_classes_for_mode_p (args[i].mode))
1037 		     || optimize))
1038 	  args[i].value = copy_to_mode_reg (args[i].mode, args[i].value);
1039       }
1040 }
1041 
1042 #ifdef REG_PARM_STACK_SPACE
1043 
1044   /* The argument list is the property of the called routine and it
1045      may clobber it.  If the fixed area has been used for previous
1046      parameters, we must save and restore it.  */
1047 
1048 static rtx
save_fixed_argument_area(int reg_parm_stack_space,rtx argblock,int * low_to_save,int * high_to_save)1049 save_fixed_argument_area (int reg_parm_stack_space, rtx argblock, int *low_to_save, int *high_to_save)
1050 {
1051   unsigned int low;
1052   unsigned int high;
1053 
1054   /* Compute the boundary of the area that needs to be saved, if any.  */
1055   high = reg_parm_stack_space;
1056   if (ARGS_GROW_DOWNWARD)
1057     high += 1;
1058 
1059   if (high > highest_outgoing_arg_in_use)
1060     high = highest_outgoing_arg_in_use;
1061 
1062   for (low = 0; low < high; low++)
1063     if (stack_usage_map[low] != 0 || low >= stack_usage_watermark)
1064       {
1065 	int num_to_save;
1066 	machine_mode save_mode;
1067 	int delta;
1068 	rtx addr;
1069 	rtx stack_area;
1070 	rtx save_area;
1071 
1072 	while (stack_usage_map[--high] == 0)
1073 	  ;
1074 
1075 	*low_to_save = low;
1076 	*high_to_save = high;
1077 
1078 	num_to_save = high - low + 1;
1079 
1080 	/* If we don't have the required alignment, must do this
1081 	   in BLKmode.  */
1082 	scalar_int_mode imode;
1083 	if (int_mode_for_size (num_to_save * BITS_PER_UNIT, 1).exists (&imode)
1084 	    && (low & (MIN (GET_MODE_SIZE (imode),
1085 			    BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1)) == 0)
1086 	  save_mode = imode;
1087 	else
1088 	  save_mode = BLKmode;
1089 
1090 	if (ARGS_GROW_DOWNWARD)
1091 	  delta = -high;
1092 	else
1093 	  delta = low;
1094 
1095 	addr = plus_constant (Pmode, argblock, delta);
1096 	stack_area = gen_rtx_MEM (save_mode, memory_address (save_mode, addr));
1097 
1098 	set_mem_align (stack_area, PARM_BOUNDARY);
1099 	if (save_mode == BLKmode)
1100 	  {
1101 	    save_area = assign_stack_temp (BLKmode, num_to_save);
1102 	    emit_block_move (validize_mem (save_area), stack_area,
1103 			     GEN_INT (num_to_save), BLOCK_OP_CALL_PARM);
1104 	  }
1105 	else
1106 	  {
1107 	    save_area = gen_reg_rtx (save_mode);
1108 	    emit_move_insn (save_area, stack_area);
1109 	  }
1110 
1111 	return save_area;
1112       }
1113 
1114   return NULL_RTX;
1115 }
1116 
1117 static void
restore_fixed_argument_area(rtx save_area,rtx argblock,int high_to_save,int low_to_save)1118 restore_fixed_argument_area (rtx save_area, rtx argblock, int high_to_save, int low_to_save)
1119 {
1120   machine_mode save_mode = GET_MODE (save_area);
1121   int delta;
1122   rtx addr, stack_area;
1123 
1124   if (ARGS_GROW_DOWNWARD)
1125     delta = -high_to_save;
1126   else
1127     delta = low_to_save;
1128 
1129   addr = plus_constant (Pmode, argblock, delta);
1130   stack_area = gen_rtx_MEM (save_mode, memory_address (save_mode, addr));
1131   set_mem_align (stack_area, PARM_BOUNDARY);
1132 
1133   if (save_mode != BLKmode)
1134     emit_move_insn (stack_area, save_area);
1135   else
1136     emit_block_move (stack_area, validize_mem (save_area),
1137 		     GEN_INT (high_to_save - low_to_save + 1),
1138 		     BLOCK_OP_CALL_PARM);
1139 }
1140 #endif /* REG_PARM_STACK_SPACE */
1141 
1142 /* If any elements in ARGS refer to parameters that are to be passed in
1143    registers, but not in memory, and whose alignment does not permit a
1144    direct copy into registers.  Copy the values into a group of pseudos
1145    which we will later copy into the appropriate hard registers.
1146 
1147    Pseudos for each unaligned argument will be stored into the array
1148    args[argnum].aligned_regs.  The caller is responsible for deallocating
1149    the aligned_regs array if it is nonzero.  */
1150 
1151 static void
store_unaligned_arguments_into_pseudos(struct arg_data * args,int num_actuals)1152 store_unaligned_arguments_into_pseudos (struct arg_data *args, int num_actuals)
1153 {
1154   int i, j;
1155 
1156   for (i = 0; i < num_actuals; i++)
1157     if (args[i].reg != 0 && ! args[i].pass_on_stack
1158 	&& GET_CODE (args[i].reg) != PARALLEL
1159 	&& args[i].mode == BLKmode
1160 	&& MEM_P (args[i].value)
1161 	&& (MEM_ALIGN (args[i].value)
1162 	    < (unsigned int) MIN (BIGGEST_ALIGNMENT, BITS_PER_WORD)))
1163       {
1164 	int bytes = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
1165 	int endian_correction = 0;
1166 
1167 	if (args[i].partial)
1168 	  {
1169 	    gcc_assert (args[i].partial % UNITS_PER_WORD == 0);
1170 	    args[i].n_aligned_regs = args[i].partial / UNITS_PER_WORD;
1171 	  }
1172 	else
1173 	  {
1174 	    args[i].n_aligned_regs
1175 	      = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
1176 	  }
1177 
1178 	args[i].aligned_regs = XNEWVEC (rtx, args[i].n_aligned_regs);
1179 
1180 	/* Structures smaller than a word are normally aligned to the
1181 	   least significant byte.  On a BYTES_BIG_ENDIAN machine,
1182 	   this means we must skip the empty high order bytes when
1183 	   calculating the bit offset.  */
1184 	if (bytes < UNITS_PER_WORD
1185 #ifdef BLOCK_REG_PADDING
1186 	    && (BLOCK_REG_PADDING (args[i].mode,
1187 				   TREE_TYPE (args[i].tree_value), 1)
1188 		== PAD_DOWNWARD)
1189 #else
1190 	    && BYTES_BIG_ENDIAN
1191 #endif
1192 	    )
1193 	  endian_correction = BITS_PER_WORD - bytes * BITS_PER_UNIT;
1194 
1195 	for (j = 0; j < args[i].n_aligned_regs; j++)
1196 	  {
1197 	    rtx reg = gen_reg_rtx (word_mode);
1198 	    rtx word = operand_subword_force (args[i].value, j, BLKmode);
1199 	    int bitsize = MIN (bytes * BITS_PER_UNIT, BITS_PER_WORD);
1200 
1201 	    args[i].aligned_regs[j] = reg;
1202 	    word = extract_bit_field (word, bitsize, 0, 1, NULL_RTX,
1203 				      word_mode, word_mode, false, NULL);
1204 
1205 	    /* There is no need to restrict this code to loading items
1206 	       in TYPE_ALIGN sized hunks.  The bitfield instructions can
1207 	       load up entire word sized registers efficiently.
1208 
1209 	       ??? This may not be needed anymore.
1210 	       We use to emit a clobber here but that doesn't let later
1211 	       passes optimize the instructions we emit.  By storing 0 into
1212 	       the register later passes know the first AND to zero out the
1213 	       bitfield being set in the register is unnecessary.  The store
1214 	       of 0 will be deleted as will at least the first AND.  */
1215 
1216 	    emit_move_insn (reg, const0_rtx);
1217 
1218 	    bytes -= bitsize / BITS_PER_UNIT;
1219 	    store_bit_field (reg, bitsize, endian_correction, 0, 0,
1220 			     word_mode, word, false);
1221 	  }
1222       }
1223 }
1224 
1225 /* The limit set by -Walloc-larger-than=.  */
1226 static GTY(()) tree alloc_object_size_limit;
1227 
1228 /* Initialize ALLOC_OBJECT_SIZE_LIMIT based on the -Walloc-size-larger-than=
1229    setting if the option is specified, or to the maximum object size if it
1230    is not.  Return the initialized value.  */
1231 
1232 static tree
alloc_max_size(void)1233 alloc_max_size (void)
1234 {
1235   if (alloc_object_size_limit)
1236     return alloc_object_size_limit;
1237 
1238   alloc_object_size_limit = max_object_size ();
1239 
1240   if (!warn_alloc_size_limit)
1241     return alloc_object_size_limit;
1242 
1243   const char *optname = "-Walloc-size-larger-than=";
1244 
1245   char *end = NULL;
1246   errno = 0;
1247   unsigned HOST_WIDE_INT unit = 1;
1248   unsigned HOST_WIDE_INT limit
1249     = strtoull (warn_alloc_size_limit, &end, 10);
1250 
1251   /* If the value is too large to be represented use the maximum
1252      representable value that strtoull sets limit to (setting
1253      errno to ERANGE).  */
1254 
1255   if (end && *end)
1256     {
1257       /* Numeric option arguments are at most INT_MAX.  Make it
1258 	 possible to specify a larger value by accepting common
1259 	 suffixes.  */
1260       if (!strcmp (end, "kB"))
1261 	unit = 1000;
1262       else if (!strcasecmp (end, "KiB") || !strcmp (end, "KB"))
1263 	unit = 1024;
1264       else if (!strcmp (end, "MB"))
1265 	unit = HOST_WIDE_INT_UC (1000) * 1000;
1266       else if (!strcasecmp (end, "MiB"))
1267 	unit = HOST_WIDE_INT_UC (1024) * 1024;
1268       else if (!strcasecmp (end, "GB"))
1269 	unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000;
1270       else if (!strcasecmp (end, "GiB"))
1271 	unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024;
1272       else if (!strcasecmp (end, "TB"))
1273 	unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000;
1274       else if (!strcasecmp (end, "TiB"))
1275 	unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024;
1276       else if (!strcasecmp (end, "PB"))
1277 	unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000 * 1000;
1278       else if (!strcasecmp (end, "PiB"))
1279 	unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024 * 1024;
1280       else if (!strcasecmp (end, "EB"))
1281 	unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000 * 1000
1282 	  * 1000;
1283       else if (!strcasecmp (end, "EiB"))
1284 	unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024 * 1024
1285 	  * 1024;
1286       else
1287 	{
1288 	  /* This could mean an unknown suffix or a bad prefix, like
1289 	     "+-1".  */
1290 	  warning_at (UNKNOWN_LOCATION, 0,
1291 		      "invalid argument %qs to %qs",
1292 		      warn_alloc_size_limit, optname);
1293 
1294 	  /* Ignore the limit extracted by strtoull.  */
1295 	  unit = 0;
1296 	}
1297     }
1298 
1299   if (unit)
1300     {
1301       widest_int w = wi::mul (limit, unit);
1302       if (w < wi::to_widest (alloc_object_size_limit))
1303 	alloc_object_size_limit
1304 	  = wide_int_to_tree (ptrdiff_type_node, w);
1305       else
1306 	alloc_object_size_limit = build_all_ones_cst (size_type_node);
1307     }
1308 
1309 
1310   return alloc_object_size_limit;
1311 }
1312 
1313 /* Return true when EXP's range can be determined and set RANGE[] to it
1314    after adjusting it if necessary to make EXP a represents a valid size
1315    of object, or a valid size argument to an allocation function declared
1316    with attribute alloc_size (whose argument may be signed), or to a string
1317    manipulation function like memset.  When ALLOW_ZERO is true, allow
1318    returning a range of [0, 0] for a size in an anti-range [1, N] where
1319    N > PTRDIFF_MAX.  A zero range is a (nearly) invalid argument to
1320    allocation functions like malloc but it is a valid argument to
1321    functions like memset.  */
1322 
1323 bool
get_size_range(tree exp,tree range[2],bool allow_zero)1324 get_size_range (tree exp, tree range[2], bool allow_zero /* = false */)
1325 {
1326   if (tree_fits_uhwi_p (exp))
1327     {
1328       /* EXP is a constant.  */
1329       range[0] = range[1] = exp;
1330       return true;
1331     }
1332 
1333   tree exptype = TREE_TYPE (exp);
1334   bool integral = INTEGRAL_TYPE_P (exptype);
1335 
1336   wide_int min, max;
1337   enum value_range_type range_type;
1338 
1339   if (TREE_CODE (exp) == SSA_NAME && integral)
1340     range_type = get_range_info (exp, &min, &max);
1341   else
1342     range_type = VR_VARYING;
1343 
1344   if (range_type == VR_VARYING)
1345     {
1346       if (integral)
1347 	{
1348 	  /* Use the full range of the type of the expression when
1349 	     no value range information is available.  */
1350 	  range[0] = TYPE_MIN_VALUE (exptype);
1351 	  range[1] = TYPE_MAX_VALUE (exptype);
1352 	  return true;
1353 	}
1354 
1355       range[0] = NULL_TREE;
1356       range[1] = NULL_TREE;
1357       return false;
1358     }
1359 
1360   unsigned expprec = TYPE_PRECISION (exptype);
1361 
1362   bool signed_p = !TYPE_UNSIGNED (exptype);
1363 
1364   if (range_type == VR_ANTI_RANGE)
1365     {
1366       if (signed_p)
1367 	{
1368 	  if (wi::les_p (max, 0))
1369 	    {
1370 	      /* EXP is not in a strictly negative range.  That means
1371 		 it must be in some (not necessarily strictly) positive
1372 		 range which includes zero.  Since in signed to unsigned
1373 		 conversions negative values end up converted to large
1374 		 positive values, and otherwise they are not valid sizes,
1375 		 the resulting range is in both cases [0, TYPE_MAX].  */
1376 	      min = wi::zero (expprec);
1377 	      max = wi::to_wide (TYPE_MAX_VALUE (exptype));
1378 	    }
1379 	  else if (wi::les_p (min - 1, 0))
1380 	    {
1381 	      /* EXP is not in a negative-positive range.  That means EXP
1382 		 is either negative, or greater than max.  Since negative
1383 		 sizes are invalid make the range [MAX + 1, TYPE_MAX].  */
1384 	      min = max + 1;
1385 	      max = wi::to_wide (TYPE_MAX_VALUE (exptype));
1386 	    }
1387 	  else
1388 	    {
1389 	      max = min - 1;
1390 	      min = wi::zero (expprec);
1391 	    }
1392 	}
1393       else if (wi::eq_p (0, min - 1))
1394 	{
1395 	  /* EXP is unsigned and not in the range [1, MAX].  That means
1396 	     it's either zero or greater than MAX.  Even though 0 would
1397 	     normally be detected by -Walloc-zero, unless ALLOW_ZERO
1398 	     is true, set the range to [MAX, TYPE_MAX] so that when MAX
1399 	     is greater than the limit the whole range is diagnosed.  */
1400 	  if (allow_zero)
1401 	    min = max = wi::zero (expprec);
1402 	  else
1403 	    {
1404 	      min = max + 1;
1405 	      max = wi::to_wide (TYPE_MAX_VALUE (exptype));
1406 	    }
1407 	}
1408       else
1409 	{
1410 	  max = min - 1;
1411 	  min = wi::zero (expprec);
1412 	}
1413     }
1414 
1415   range[0] = wide_int_to_tree (exptype, min);
1416   range[1] = wide_int_to_tree (exptype, max);
1417 
1418   return true;
1419 }
1420 
1421 /* Diagnose a call EXP to function FN decorated with attribute alloc_size
1422    whose argument numbers given by IDX with values given by ARGS exceed
1423    the maximum object size or cause an unsigned oveflow (wrapping) when
1424    multiplied.  When ARGS[0] is null the function does nothing.  ARGS[1]
1425    may be null for functions like malloc, and non-null for those like
1426    calloc that are decorated with a two-argument attribute alloc_size.  */
1427 
1428 void
maybe_warn_alloc_args_overflow(tree fn,tree exp,tree args[2],int idx[2])1429 maybe_warn_alloc_args_overflow (tree fn, tree exp, tree args[2], int idx[2])
1430 {
1431   /* The range each of the (up to) two arguments is known to be in.  */
1432   tree argrange[2][2] = { { NULL_TREE, NULL_TREE }, { NULL_TREE, NULL_TREE } };
1433 
1434   /* Maximum object size set by -Walloc-size-larger-than= or SIZE_MAX / 2.  */
1435   tree maxobjsize = alloc_max_size ();
1436 
1437   location_t loc = EXPR_LOCATION (exp);
1438 
1439   bool warned = false;
1440 
1441   /* Validate each argument individually.  */
1442   for (unsigned i = 0; i != 2 && args[i]; ++i)
1443     {
1444       if (TREE_CODE (args[i]) == INTEGER_CST)
1445 	{
1446 	  argrange[i][0] = args[i];
1447 	  argrange[i][1] = args[i];
1448 
1449 	  if (tree_int_cst_lt (args[i], integer_zero_node))
1450 	    {
1451 	      warned = warning_at (loc, OPT_Walloc_size_larger_than_,
1452 				   "%Kargument %i value %qE is negative",
1453 				   exp, idx[i] + 1, args[i]);
1454 	    }
1455 	  else if (integer_zerop (args[i]))
1456 	    {
1457 	      /* Avoid issuing -Walloc-zero for allocation functions other
1458 		 than __builtin_alloca that are declared with attribute
1459 		 returns_nonnull because there's no portability risk.  This
1460 		 avoids warning for such calls to libiberty's xmalloc and
1461 		 friends.
1462 		 Also avoid issuing the warning for calls to function named
1463 		 "alloca".  */
1464 	      if ((DECL_FUNCTION_CODE (fn) == BUILT_IN_ALLOCA
1465 		   && IDENTIFIER_LENGTH (DECL_NAME (fn)) != 6)
1466 		  || (DECL_FUNCTION_CODE (fn) != BUILT_IN_ALLOCA
1467 		      && !lookup_attribute ("returns_nonnull",
1468 					    TYPE_ATTRIBUTES (TREE_TYPE (fn)))))
1469 		warned = warning_at (loc, OPT_Walloc_zero,
1470 				     "%Kargument %i value is zero",
1471 				     exp, idx[i] + 1);
1472 	    }
1473 	  else if (tree_int_cst_lt (maxobjsize, args[i]))
1474 	    {
1475 	      /* G++ emits calls to ::operator new[](SIZE_MAX) in C++98
1476 		 mode and with -fno-exceptions as a way to indicate array
1477 		 size overflow.  There's no good way to detect C++98 here
1478 		 so avoid diagnosing these calls for all C++ modes.  */
1479 	      if (i == 0
1480 		  && !args[1]
1481 		  && lang_GNU_CXX ()
1482 		  && DECL_IS_OPERATOR_NEW (fn)
1483 		  && integer_all_onesp (args[i]))
1484 		continue;
1485 
1486 	      warned = warning_at (loc, OPT_Walloc_size_larger_than_,
1487 				   "%Kargument %i value %qE exceeds "
1488 				   "maximum object size %E",
1489 				   exp, idx[i] + 1, args[i], maxobjsize);
1490 	    }
1491 	}
1492       else if (TREE_CODE (args[i]) == SSA_NAME
1493 	       && get_size_range (args[i], argrange[i]))
1494 	{
1495 	  /* Verify that the argument's range is not negative (including
1496 	     upper bound of zero).  */
1497 	  if (tree_int_cst_lt (argrange[i][0], integer_zero_node)
1498 	      && tree_int_cst_le (argrange[i][1], integer_zero_node))
1499 	    {
1500 	      warned = warning_at (loc, OPT_Walloc_size_larger_than_,
1501 				   "%Kargument %i range [%E, %E] is negative",
1502 				   exp, idx[i] + 1,
1503 				   argrange[i][0], argrange[i][1]);
1504 	    }
1505 	  else if (tree_int_cst_lt (maxobjsize, argrange[i][0]))
1506 	    {
1507 	      warned = warning_at (loc, OPT_Walloc_size_larger_than_,
1508 				   "%Kargument %i range [%E, %E] exceeds "
1509 				   "maximum object size %E",
1510 				   exp, idx[i] + 1,
1511 				   argrange[i][0], argrange[i][1],
1512 				   maxobjsize);
1513 	    }
1514 	}
1515     }
1516 
1517   if (!argrange[0])
1518     return;
1519 
1520   /* For a two-argument alloc_size, validate the product of the two
1521      arguments if both of their values or ranges are known.  */
1522   if (!warned && tree_fits_uhwi_p (argrange[0][0])
1523       && argrange[1][0] && tree_fits_uhwi_p (argrange[1][0])
1524       && !integer_onep (argrange[0][0])
1525       && !integer_onep (argrange[1][0]))
1526     {
1527       /* Check for overflow in the product of a function decorated with
1528 	 attribute alloc_size (X, Y).  */
1529       unsigned szprec = TYPE_PRECISION (size_type_node);
1530       wide_int x = wi::to_wide (argrange[0][0], szprec);
1531       wide_int y = wi::to_wide (argrange[1][0], szprec);
1532 
1533       bool vflow;
1534       wide_int prod = wi::umul (x, y, &vflow);
1535 
1536       if (vflow)
1537 	warned = warning_at (loc, OPT_Walloc_size_larger_than_,
1538 			     "%Kproduct %<%E * %E%> of arguments %i and %i "
1539 			     "exceeds %<SIZE_MAX%>",
1540 			     exp, argrange[0][0], argrange[1][0],
1541 			     idx[0] + 1, idx[1] + 1);
1542       else if (wi::ltu_p (wi::to_wide (maxobjsize, szprec), prod))
1543 	warned = warning_at (loc, OPT_Walloc_size_larger_than_,
1544 			     "%Kproduct %<%E * %E%> of arguments %i and %i "
1545 			     "exceeds maximum object size %E",
1546 			     exp, argrange[0][0], argrange[1][0],
1547 			     idx[0] + 1, idx[1] + 1,
1548 			     maxobjsize);
1549 
1550       if (warned)
1551 	{
1552 	  /* Print the full range of each of the two arguments to make
1553 	     it clear when it is, in fact, in a range and not constant.  */
1554 	  if (argrange[0][0] != argrange [0][1])
1555 	    inform (loc, "argument %i in the range [%E, %E]",
1556 		    idx[0] + 1, argrange[0][0], argrange[0][1]);
1557 	  if (argrange[1][0] != argrange [1][1])
1558 	    inform (loc, "argument %i in the range [%E, %E]",
1559 		    idx[1] + 1, argrange[1][0], argrange[1][1]);
1560 	}
1561     }
1562 
1563   if (warned)
1564     {
1565       location_t fnloc = DECL_SOURCE_LOCATION (fn);
1566 
1567       if (DECL_IS_BUILTIN (fn))
1568 	inform (loc,
1569 		"in a call to built-in allocation function %qD", fn);
1570       else
1571 	inform (fnloc,
1572 		"in a call to allocation function %qD declared here", fn);
1573     }
1574 }
1575 
1576 /* If EXPR refers to a character array or pointer declared attribute
1577    nonstring return a decl for that array or pointer and set *REF to
1578    the referenced enclosing object or pointer.  Otherwise returns
1579    null.  */
1580 
1581 tree
get_attr_nonstring_decl(tree expr,tree * ref)1582 get_attr_nonstring_decl (tree expr, tree *ref)
1583 {
1584   tree decl = expr;
1585   if (TREE_CODE (decl) == SSA_NAME)
1586     {
1587       gimple *def = SSA_NAME_DEF_STMT (decl);
1588 
1589       if (is_gimple_assign (def))
1590 	{
1591 	  tree_code code = gimple_assign_rhs_code (def);
1592 	  if (code == ADDR_EXPR
1593 	      || code == COMPONENT_REF
1594 	      || code == VAR_DECL)
1595 	    decl = gimple_assign_rhs1 (def);
1596 	}
1597       else if (tree var = SSA_NAME_VAR (decl))
1598 	decl = var;
1599     }
1600 
1601   if (TREE_CODE (decl) == ADDR_EXPR)
1602     decl = TREE_OPERAND (decl, 0);
1603 
1604   if (ref)
1605     *ref = decl;
1606 
1607   if (TREE_CODE (decl) == ARRAY_REF)
1608     decl = TREE_OPERAND (decl, 0);
1609   else if (TREE_CODE (decl) == COMPONENT_REF)
1610     decl = TREE_OPERAND (decl, 1);
1611   else if (TREE_CODE (decl) == MEM_REF)
1612     return get_attr_nonstring_decl (TREE_OPERAND (decl, 0), ref);
1613 
1614   if (DECL_P (decl)
1615       && lookup_attribute ("nonstring", DECL_ATTRIBUTES (decl)))
1616     return decl;
1617 
1618   return NULL_TREE;
1619 }
1620 
1621 /* Warn about passing a non-string array/pointer to a function that
1622    expects a nul-terminated string argument.  */
1623 
1624 void
maybe_warn_nonstring_arg(tree fndecl,tree exp)1625 maybe_warn_nonstring_arg (tree fndecl, tree exp)
1626 {
1627   if (!fndecl || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
1628     return;
1629 
1630   if (!warn_stringop_overflow)
1631     return;
1632 
1633   bool with_bounds = CALL_WITH_BOUNDS_P (exp);
1634 
1635   unsigned nargs = call_expr_nargs (exp);
1636 
1637   /* The bound argument to a bounded string function like strncpy.  */
1638   tree bound = NULL_TREE;
1639 
1640   /* The range of lengths of a string argument to one of the comparison
1641      functions.  If the length is less than the bound it is used instead.  */
1642   tree lenrng[2] = { NULL_TREE, NULL_TREE };
1643 
1644   /* It's safe to call "bounded" string functions with a non-string
1645      argument since the functions provide an explicit bound for this
1646      purpose.  The exception is strncat where the bound may refer to
1647      either the destination or the source.  */
1648   int fncode = DECL_FUNCTION_CODE (fndecl);
1649   switch (fncode)
1650     {
1651     case BUILT_IN_STRCMP:
1652     case BUILT_IN_STRNCMP:
1653     case BUILT_IN_STRNCASECMP:
1654       {
1655 	/* For these, if one argument refers to one or more of a set
1656 	   of string constants or arrays of known size, determine
1657 	   the range of their known or possible lengths and use it
1658 	   conservatively as the bound for the unbounded function,
1659 	   and to adjust the range of the bound of the bounded ones.  */
1660 	unsigned stride = with_bounds ? 2 : 1;
1661 	for (unsigned argno = 0;
1662 	     argno < MIN (nargs, 2 * stride)
1663 	     && !(lenrng[1] && TREE_CODE (lenrng[1]) == INTEGER_CST);
1664 	     argno += stride)
1665 	  {
1666 	    tree arg = CALL_EXPR_ARG (exp, argno);
1667 	    if (!get_attr_nonstring_decl (arg))
1668 	      get_range_strlen (arg, lenrng);
1669 	  }
1670       }
1671       /* Fall through.  */
1672 
1673     case BUILT_IN_STRNCAT:
1674     case BUILT_IN_STPNCPY:
1675     case BUILT_IN_STPNCPY_CHK:
1676     case BUILT_IN_STRNCPY:
1677     case BUILT_IN_STRNCPY_CHK:
1678       {
1679 	unsigned argno = with_bounds ? 4 : 2;
1680 	if (argno < nargs)
1681 	  bound = CALL_EXPR_ARG (exp, argno);
1682 	break;
1683       }
1684 
1685     case BUILT_IN_STRNDUP:
1686       {
1687 	unsigned argno = with_bounds ? 2 : 1;
1688 	if (argno < nargs)
1689 	  bound = CALL_EXPR_ARG (exp, argno);
1690 	break;
1691       }
1692 
1693     default:
1694       break;
1695     }
1696 
1697   /* Determine the range of the bound argument (if specified).  */
1698   tree bndrng[2] = { NULL_TREE, NULL_TREE };
1699   if (bound)
1700     get_size_range (bound, bndrng);
1701 
1702   if (lenrng[1] && TREE_CODE (lenrng[1]) == INTEGER_CST)
1703     {
1704       /* Add one for the nul.  */
1705       lenrng[1] = const_binop (PLUS_EXPR, TREE_TYPE (lenrng[1]),
1706 			       lenrng[1], size_one_node);
1707 
1708       if (!bndrng[0])
1709 	{
1710 	  /* Conservatively use the upper bound of the lengths for
1711 	     both the lower and the upper bound of the operation.  */
1712 	  bndrng[0] = lenrng[1];
1713 	  bndrng[1] = lenrng[1];
1714 	  bound = void_type_node;
1715 	}
1716       else
1717 	{
1718 	  /* Replace the bound on the oparation with the upper bound
1719 	     of the length of the string if the latter is smaller.  */
1720 	  if (tree_int_cst_lt (lenrng[1], bndrng[0]))
1721 	    bndrng[0] = lenrng[1];
1722 	  else if (tree_int_cst_lt (lenrng[1], bndrng[1]))
1723 	    bndrng[1] = lenrng[1];
1724 	}
1725     }
1726 
1727   /* Iterate over the built-in function's formal arguments and check
1728      each const char* against the actual argument.  If the actual
1729      argument is declared attribute non-string issue a warning unless
1730      the argument's maximum length is bounded.  */
1731   function_args_iterator it;
1732   function_args_iter_init (&it, TREE_TYPE (fndecl));
1733 
1734   for (unsigned argno = 0; ; ++argno, function_args_iter_next (&it))
1735     {
1736       /* Avoid iterating past the declared argument in a call
1737 	 to function declared without a prototype.  */
1738       if (argno >= nargs)
1739 	break;
1740 
1741       tree argtype = function_args_iter_cond (&it);
1742       if (!argtype)
1743 	break;
1744 
1745       if (TREE_CODE (argtype) != POINTER_TYPE)
1746 	continue;
1747 
1748       argtype = TREE_TYPE (argtype);
1749 
1750       if (TREE_CODE (argtype) != INTEGER_TYPE
1751 	  || !TYPE_READONLY (argtype))
1752 	continue;
1753 
1754       argtype = TYPE_MAIN_VARIANT (argtype);
1755       if (argtype != char_type_node)
1756 	continue;
1757 
1758       tree callarg = CALL_EXPR_ARG (exp, argno);
1759       if (TREE_CODE (callarg) == ADDR_EXPR)
1760 	callarg = TREE_OPERAND (callarg, 0);
1761 
1762       /* See if the destination is declared with attribute "nonstring".  */
1763       tree decl = get_attr_nonstring_decl (callarg);
1764       if (!decl)
1765 	continue;
1766 
1767       /* The maximum number of array elements accessed.  */
1768       offset_int wibnd = 0;
1769 
1770       if (argno && fncode == BUILT_IN_STRNCAT)
1771 	{
1772 	  /* See if the bound in strncat is derived from the length
1773 	     of the strlen of the destination (as it's expected to be).
1774 	     If so, reset BOUND and FNCODE to trigger a warning.  */
1775 	  tree dstarg = CALL_EXPR_ARG (exp, 0);
1776 	  if (is_strlen_related_p (dstarg, bound))
1777 	    {
1778 	      /* The bound applies to the destination, not to the source,
1779 		 so reset these to trigger a warning without mentioning
1780 		 the bound.  */
1781 	      bound = NULL;
1782 	      fncode = 0;
1783 	    }
1784 	  else if (bndrng[1])
1785 	    /* Use the upper bound of the range for strncat.  */
1786 	    wibnd = wi::to_offset (bndrng[1]);
1787 	}
1788       else if (bndrng[0])
1789 	/* Use the lower bound of the range for functions other than
1790 	   strncat.  */
1791 	wibnd = wi::to_offset (bndrng[0]);
1792 
1793       /* Determine the size of the argument array if it is one.  */
1794       offset_int asize = wibnd;
1795       bool known_size = false;
1796       tree type = TREE_TYPE (decl);
1797 
1798       /* Determine the array size.  For arrays of unknown bound and
1799 	 pointers reset BOUND to trigger the appropriate warning.  */
1800       if (TREE_CODE (type) == ARRAY_TYPE)
1801 	{
1802 	  if (tree arrbnd = TYPE_DOMAIN (type))
1803 	    {
1804 	      if ((arrbnd = TYPE_MAX_VALUE (arrbnd)))
1805 		{
1806 		  asize = wi::to_offset (arrbnd) + 1;
1807 		  known_size = true;
1808 		}
1809 	    }
1810 	  else if (bound == void_type_node)
1811 	    bound = NULL_TREE;
1812 	}
1813       else if (bound == void_type_node)
1814 	bound = NULL_TREE;
1815 
1816       location_t loc = EXPR_LOCATION (exp);
1817 
1818       /* In a call to strncat with a bound in a range whose lower but
1819 	 not upper bound is less than the array size, reset ASIZE to
1820 	 be the same as the bound and the other variable to trigger
1821 	 the apprpriate warning below.  */
1822       if (fncode == BUILT_IN_STRNCAT
1823 	  && bndrng[0] != bndrng[1]
1824 	  && wi::ltu_p (wi::to_offset (bndrng[0]), asize)
1825 	  && (!known_size
1826 	      || wi::ltu_p (asize, wibnd)))
1827 	{
1828 	  asize = wibnd;
1829 	  bound = NULL_TREE;
1830 	  fncode = 0;
1831 	}
1832 
1833       bool warned = false;
1834 
1835       if (wi::ltu_p (asize, wibnd))
1836 	{
1837 	  if (bndrng[0] == bndrng[1])
1838 	    warned = warning_at (loc, OPT_Wstringop_overflow_,
1839 				 "%qD argument %i declared attribute "
1840 				 "%<nonstring%> is smaller than the specified "
1841 				 "bound %wu",
1842 				 fndecl, argno + 1, wibnd.to_uhwi ());
1843 	  else if (wi::ltu_p (asize, wi::to_offset (bndrng[0])))
1844 	    warned = warning_at (loc, OPT_Wstringop_overflow_,
1845 				 "%qD argument %i declared attribute "
1846 				 "%<nonstring%> is smaller than "
1847 				 "the specified bound [%E, %E]",
1848 				 fndecl, argno + 1, bndrng[0], bndrng[1]);
1849 	  else
1850 	    warned = warning_at (loc, OPT_Wstringop_overflow_,
1851 				 "%qD argument %i declared attribute "
1852 				 "%<nonstring%> may be smaller than "
1853 				 "the specified bound [%E, %E]",
1854 				 fndecl, argno + 1, bndrng[0], bndrng[1]);
1855 	}
1856       else if (fncode == BUILT_IN_STRNCAT)
1857 	; /* Avoid warning for calls to strncat() when the bound
1858 	     is equal to the size of the non-string argument.  */
1859       else if (!bound)
1860 	warned = warning_at (loc, OPT_Wstringop_overflow_,
1861 			     "%qD argument %i declared attribute %<nonstring%>",
1862 			     fndecl, argno + 1);
1863 
1864       if (warned)
1865 	inform (DECL_SOURCE_LOCATION (decl),
1866 		"argument %qD declared here", decl);
1867     }
1868 }
1869 
1870 /* Issue an error if CALL_EXPR was flagged as requiring
1871    tall-call optimization.  */
1872 
1873 static void
maybe_complain_about_tail_call(tree call_expr,const char * reason)1874 maybe_complain_about_tail_call (tree call_expr, const char *reason)
1875 {
1876   gcc_assert (TREE_CODE (call_expr) == CALL_EXPR);
1877   if (!CALL_EXPR_MUST_TAIL_CALL (call_expr))
1878     return;
1879 
1880   error_at (EXPR_LOCATION (call_expr), "cannot tail-call: %s", reason);
1881 }
1882 
1883 /* Fill in ARGS_SIZE and ARGS array based on the parameters found in
1884    CALL_EXPR EXP.
1885 
1886    NUM_ACTUALS is the total number of parameters.
1887 
1888    N_NAMED_ARGS is the total number of named arguments.
1889 
1890    STRUCT_VALUE_ADDR_VALUE is the implicit argument for a struct return
1891    value, or null.
1892 
1893    FNDECL is the tree code for the target of this call (if known)
1894 
1895    ARGS_SO_FAR holds state needed by the target to know where to place
1896    the next argument.
1897 
1898    REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
1899    for arguments which are passed in registers.
1900 
1901    OLD_STACK_LEVEL is a pointer to an rtx which olds the old stack level
1902    and may be modified by this routine.
1903 
1904    OLD_PENDING_ADJ, MUST_PREALLOCATE and FLAGS are pointers to integer
1905    flags which may be modified by this routine.
1906 
1907    MAY_TAILCALL is cleared if we encounter an invisible pass-by-reference
1908    that requires allocation of stack space.
1909 
1910    CALL_FROM_THUNK_P is true if this call is the jump from a thunk to
1911    the thunked-to function.  */
1912 
1913 static void
initialize_argument_information(int num_actuals ATTRIBUTE_UNUSED,struct arg_data * args,struct args_size * args_size,int n_named_args ATTRIBUTE_UNUSED,tree exp,tree struct_value_addr_value,tree fndecl,tree fntype,cumulative_args_t args_so_far,int reg_parm_stack_space,rtx * old_stack_level,poly_int64_pod * old_pending_adj,int * must_preallocate,int * ecf_flags,bool * may_tailcall,bool call_from_thunk_p)1914 initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
1915 				 struct arg_data *args,
1916 				 struct args_size *args_size,
1917 				 int n_named_args ATTRIBUTE_UNUSED,
1918 				 tree exp, tree struct_value_addr_value,
1919 				 tree fndecl, tree fntype,
1920 				 cumulative_args_t args_so_far,
1921 				 int reg_parm_stack_space,
1922 				 rtx *old_stack_level,
1923 				 poly_int64_pod *old_pending_adj,
1924 				 int *must_preallocate, int *ecf_flags,
1925 				 bool *may_tailcall, bool call_from_thunk_p)
1926 {
1927   CUMULATIVE_ARGS *args_so_far_pnt = get_cumulative_args (args_so_far);
1928   location_t loc = EXPR_LOCATION (exp);
1929 
1930   /* Count arg position in order args appear.  */
1931   int argpos;
1932 
1933   int i;
1934 
1935   args_size->constant = 0;
1936   args_size->var = 0;
1937 
1938   bitmap_obstack_initialize (NULL);
1939 
1940   /* In this loop, we consider args in the order they are written.
1941      We fill up ARGS from the back.  */
1942 
1943   i = num_actuals - 1;
1944   {
1945     int j = i, ptr_arg = -1;
1946     call_expr_arg_iterator iter;
1947     tree arg;
1948     bitmap slots = NULL;
1949 
1950     if (struct_value_addr_value)
1951       {
1952 	args[j].tree_value = struct_value_addr_value;
1953 	j--;
1954 
1955 	/* If we pass structure address then we need to
1956 	   create bounds for it.  Since created bounds is
1957 	   a call statement, we expand it right here to avoid
1958 	   fixing all other places where it may be expanded.  */
1959 	if (CALL_WITH_BOUNDS_P (exp))
1960 	  {
1961 	    args[j].value = gen_reg_rtx (targetm.chkp_bound_mode ());
1962 	    args[j].tree_value
1963 	      = chkp_make_bounds_for_struct_addr (struct_value_addr_value);
1964 	    expand_expr_real (args[j].tree_value, args[j].value, VOIDmode,
1965 			      EXPAND_NORMAL, 0, false);
1966 	    args[j].pointer_arg = j + 1;
1967 	    j--;
1968 	  }
1969       }
1970     argpos = 0;
1971     FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
1972       {
1973 	tree argtype = TREE_TYPE (arg);
1974 
1975 	/* Remember last param with pointer and associate it
1976 	   with following pointer bounds.  */
1977 	if (CALL_WITH_BOUNDS_P (exp)
1978 	    && chkp_type_has_pointer (argtype))
1979 	  {
1980 	    if (slots)
1981 	      BITMAP_FREE (slots);
1982 	    ptr_arg = j;
1983 	    if (!BOUNDED_TYPE_P (argtype))
1984 	      {
1985 		slots = BITMAP_ALLOC (NULL);
1986 		chkp_find_bound_slots (argtype, slots);
1987 	      }
1988 	  }
1989 	else if (CALL_WITH_BOUNDS_P (exp)
1990 		 && pass_by_reference (NULL, TYPE_MODE (argtype), argtype,
1991 				       argpos < n_named_args))
1992 	  {
1993 	    if (slots)
1994 	      BITMAP_FREE (slots);
1995 	    ptr_arg = j;
1996 	  }
1997 	else if (POINTER_BOUNDS_TYPE_P (argtype))
1998 	  {
1999 	    /* We expect bounds in instrumented calls only.
2000 	       Otherwise it is a sign we lost flag due to some optimization
2001 	       and may emit call args incorrectly.  */
2002 	    gcc_assert (CALL_WITH_BOUNDS_P (exp));
2003 
2004 	    /* For structures look for the next available pointer.  */
2005 	    if (ptr_arg != -1 && slots)
2006 	      {
2007 		unsigned bnd_no = bitmap_first_set_bit (slots);
2008 		args[j].pointer_offset =
2009 		  bnd_no * POINTER_SIZE / BITS_PER_UNIT;
2010 
2011 		bitmap_clear_bit (slots, bnd_no);
2012 
2013 		/* Check we have no more pointers in the structure.  */
2014 		if (bitmap_empty_p (slots))
2015 		  BITMAP_FREE (slots);
2016 	      }
2017 	    args[j].pointer_arg = ptr_arg;
2018 
2019 	    /* Check we covered all pointers in the previous
2020 	       non bounds arg.  */
2021 	    if (!slots)
2022 	      ptr_arg = -1;
2023 	  }
2024 	else
2025 	  ptr_arg = -1;
2026 
2027 	if (targetm.calls.split_complex_arg
2028 	    && argtype
2029 	    && TREE_CODE (argtype) == COMPLEX_TYPE
2030 	    && targetm.calls.split_complex_arg (argtype))
2031 	  {
2032 	    tree subtype = TREE_TYPE (argtype);
2033 	    args[j].tree_value = build1 (REALPART_EXPR, subtype, arg);
2034 	    j--;
2035 	    args[j].tree_value = build1 (IMAGPART_EXPR, subtype, arg);
2036 	  }
2037 	else
2038 	  args[j].tree_value = arg;
2039 	j--;
2040 	argpos++;
2041       }
2042 
2043     if (slots)
2044       BITMAP_FREE (slots);
2045   }
2046 
2047   bitmap_obstack_release (NULL);
2048 
2049   /* Extract attribute alloc_size and if set, store the indices of
2050      the corresponding arguments in ALLOC_IDX, and then the actual
2051      argument(s) at those indices in ALLOC_ARGS.  */
2052   int alloc_idx[2] = { -1, -1 };
2053   if (tree alloc_size
2054       = (fndecl ? lookup_attribute ("alloc_size",
2055 				    TYPE_ATTRIBUTES (TREE_TYPE (fndecl)))
2056 	 : NULL_TREE))
2057     {
2058       tree args = TREE_VALUE (alloc_size);
2059       alloc_idx[0] = TREE_INT_CST_LOW (TREE_VALUE (args)) - 1;
2060       if (TREE_CHAIN (args))
2061 	alloc_idx[1] = TREE_INT_CST_LOW (TREE_VALUE (TREE_CHAIN (args))) - 1;
2062     }
2063 
2064   /* Array for up to the two attribute alloc_size arguments.  */
2065   tree alloc_args[] = { NULL_TREE, NULL_TREE };
2066 
2067   /* I counts args in order (to be) pushed; ARGPOS counts in order written.  */
2068   for (argpos = 0; argpos < num_actuals; i--, argpos++)
2069     {
2070       tree type = TREE_TYPE (args[i].tree_value);
2071       int unsignedp;
2072       machine_mode mode;
2073 
2074       /* Replace erroneous argument with constant zero.  */
2075       if (type == error_mark_node || !COMPLETE_TYPE_P (type))
2076 	args[i].tree_value = integer_zero_node, type = integer_type_node;
2077 
2078       /* If TYPE is a transparent union or record, pass things the way
2079 	 we would pass the first field of the union or record.  We have
2080 	 already verified that the modes are the same.  */
2081       if ((TREE_CODE (type) == UNION_TYPE || TREE_CODE (type) == RECORD_TYPE)
2082 	   && TYPE_TRANSPARENT_AGGR (type))
2083 	type = TREE_TYPE (first_field (type));
2084 
2085       /* Decide where to pass this arg.
2086 
2087 	 args[i].reg is nonzero if all or part is passed in registers.
2088 
2089 	 args[i].partial is nonzero if part but not all is passed in registers,
2090 	 and the exact value says how many bytes are passed in registers.
2091 
2092 	 args[i].pass_on_stack is nonzero if the argument must at least be
2093 	 computed on the stack.  It may then be loaded back into registers
2094 	 if args[i].reg is nonzero.
2095 
2096 	 These decisions are driven by the FUNCTION_... macros and must agree
2097 	 with those made by function.c.  */
2098 
2099       /* See if this argument should be passed by invisible reference.  */
2100       if (pass_by_reference (args_so_far_pnt, TYPE_MODE (type),
2101 			     type, argpos < n_named_args))
2102 	{
2103 	  bool callee_copies;
2104 	  tree base = NULL_TREE;
2105 
2106 	  callee_copies
2107 	    = reference_callee_copied (args_so_far_pnt, TYPE_MODE (type),
2108 				       type, argpos < n_named_args);
2109 
2110 	  /* If we're compiling a thunk, pass through invisible references
2111 	     instead of making a copy.  */
2112 	  if (call_from_thunk_p
2113 	      || (callee_copies
2114 		  && !TREE_ADDRESSABLE (type)
2115 		  && (base = get_base_address (args[i].tree_value))
2116 		  && TREE_CODE (base) != SSA_NAME
2117 		  && (!DECL_P (base) || MEM_P (DECL_RTL (base)))))
2118 	    {
2119 	      /* We may have turned the parameter value into an SSA name.
2120 		 Go back to the original parameter so we can take the
2121 		 address.  */
2122 	      if (TREE_CODE (args[i].tree_value) == SSA_NAME)
2123 		{
2124 		  gcc_assert (SSA_NAME_IS_DEFAULT_DEF (args[i].tree_value));
2125 		  args[i].tree_value = SSA_NAME_VAR (args[i].tree_value);
2126 		  gcc_assert (TREE_CODE (args[i].tree_value) == PARM_DECL);
2127 		}
2128 	      /* Argument setup code may have copied the value to register.  We
2129 		 revert that optimization now because the tail call code must
2130 		 use the original location.  */
2131 	      if (TREE_CODE (args[i].tree_value) == PARM_DECL
2132 		  && !MEM_P (DECL_RTL (args[i].tree_value))
2133 		  && DECL_INCOMING_RTL (args[i].tree_value)
2134 		  && MEM_P (DECL_INCOMING_RTL (args[i].tree_value)))
2135 		set_decl_rtl (args[i].tree_value,
2136 			      DECL_INCOMING_RTL (args[i].tree_value));
2137 
2138 	      mark_addressable (args[i].tree_value);
2139 
2140 	      /* We can't use sibcalls if a callee-copied argument is
2141 		 stored in the current function's frame.  */
2142 	      if (!call_from_thunk_p && DECL_P (base) && !TREE_STATIC (base))
2143 		{
2144 		  *may_tailcall = false;
2145 		  maybe_complain_about_tail_call (exp,
2146 						  "a callee-copied argument is"
2147 						  " stored in the current"
2148 						  " function's frame");
2149 		}
2150 
2151 	      args[i].tree_value = build_fold_addr_expr_loc (loc,
2152 							 args[i].tree_value);
2153 	      type = TREE_TYPE (args[i].tree_value);
2154 
2155 	      if (*ecf_flags & ECF_CONST)
2156 		*ecf_flags &= ~(ECF_CONST | ECF_LOOPING_CONST_OR_PURE);
2157 	    }
2158 	  else
2159 	    {
2160 	      /* We make a copy of the object and pass the address to the
2161 		 function being called.  */
2162 	      rtx copy;
2163 
2164 	      if (!COMPLETE_TYPE_P (type)
2165 		  || TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST
2166 		  || (flag_stack_check == GENERIC_STACK_CHECK
2167 		      && compare_tree_int (TYPE_SIZE_UNIT (type),
2168 					   STACK_CHECK_MAX_VAR_SIZE) > 0))
2169 		{
2170 		  /* This is a variable-sized object.  Make space on the stack
2171 		     for it.  */
2172 		  rtx size_rtx = expr_size (args[i].tree_value);
2173 
2174 		  if (*old_stack_level == 0)
2175 		    {
2176 		      emit_stack_save (SAVE_BLOCK, old_stack_level);
2177 		      *old_pending_adj = pending_stack_adjust;
2178 		      pending_stack_adjust = 0;
2179 		    }
2180 
2181 		  /* We can pass TRUE as the 4th argument because we just
2182 		     saved the stack pointer and will restore it right after
2183 		     the call.  */
2184 		  copy = allocate_dynamic_stack_space (size_rtx,
2185 						       TYPE_ALIGN (type),
2186 						       TYPE_ALIGN (type),
2187 						       max_int_size_in_bytes
2188 						       (type),
2189 						       true);
2190 		  copy = gen_rtx_MEM (BLKmode, copy);
2191 		  set_mem_attributes (copy, type, 1);
2192 		}
2193 	      else
2194 		copy = assign_temp (type, 1, 0);
2195 
2196 	      store_expr (args[i].tree_value, copy, 0, false, false);
2197 
2198 	      /* Just change the const function to pure and then let
2199 		 the next test clear the pure based on
2200 		 callee_copies.  */
2201 	      if (*ecf_flags & ECF_CONST)
2202 		{
2203 		  *ecf_flags &= ~ECF_CONST;
2204 		  *ecf_flags |= ECF_PURE;
2205 		}
2206 
2207 	      if (!callee_copies && *ecf_flags & ECF_PURE)
2208 		*ecf_flags &= ~(ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
2209 
2210 	      args[i].tree_value
2211 		= build_fold_addr_expr_loc (loc, make_tree (type, copy));
2212 	      type = TREE_TYPE (args[i].tree_value);
2213 	      *may_tailcall = false;
2214 	      maybe_complain_about_tail_call (exp,
2215 					      "argument must be passed"
2216 					      " by copying");
2217 	    }
2218 	}
2219 
2220       unsignedp = TYPE_UNSIGNED (type);
2221       mode = promote_function_mode (type, TYPE_MODE (type), &unsignedp,
2222 				    fndecl ? TREE_TYPE (fndecl) : fntype, 0);
2223 
2224       args[i].unsignedp = unsignedp;
2225       args[i].mode = mode;
2226 
2227       targetm.calls.warn_parameter_passing_abi (args_so_far, type);
2228 
2229       args[i].reg = targetm.calls.function_arg (args_so_far, mode, type,
2230 						argpos < n_named_args);
2231 
2232       if (args[i].reg && CONST_INT_P (args[i].reg))
2233 	{
2234 	  args[i].special_slot = args[i].reg;
2235 	  args[i].reg = NULL;
2236 	}
2237 
2238       /* If this is a sibling call and the machine has register windows, the
2239 	 register window has to be unwinded before calling the routine, so
2240 	 arguments have to go into the incoming registers.  */
2241       if (targetm.calls.function_incoming_arg != targetm.calls.function_arg)
2242 	args[i].tail_call_reg
2243 	  = targetm.calls.function_incoming_arg (args_so_far, mode, type,
2244 						 argpos < n_named_args);
2245       else
2246 	args[i].tail_call_reg = args[i].reg;
2247 
2248       if (args[i].reg)
2249 	args[i].partial
2250 	  = targetm.calls.arg_partial_bytes (args_so_far, mode, type,
2251 					     argpos < n_named_args);
2252 
2253       args[i].pass_on_stack = targetm.calls.must_pass_in_stack (mode, type);
2254 
2255       /* If FUNCTION_ARG returned a (parallel [(expr_list (nil) ...) ...]),
2256 	 it means that we are to pass this arg in the register(s) designated
2257 	 by the PARALLEL, but also to pass it in the stack.  */
2258       if (args[i].reg && GET_CODE (args[i].reg) == PARALLEL
2259 	  && XEXP (XVECEXP (args[i].reg, 0, 0), 0) == 0)
2260 	args[i].pass_on_stack = 1;
2261 
2262       /* If this is an addressable type, we must preallocate the stack
2263 	 since we must evaluate the object into its final location.
2264 
2265 	 If this is to be passed in both registers and the stack, it is simpler
2266 	 to preallocate.  */
2267       if (TREE_ADDRESSABLE (type)
2268 	  || (args[i].pass_on_stack && args[i].reg != 0))
2269 	*must_preallocate = 1;
2270 
2271       /* No stack allocation and padding for bounds.  */
2272       if (POINTER_BOUNDS_P (args[i].tree_value))
2273 	;
2274       /* Compute the stack-size of this argument.  */
2275       else if (args[i].reg == 0 || args[i].partial != 0
2276 	       || reg_parm_stack_space > 0
2277 	       || args[i].pass_on_stack)
2278 	locate_and_pad_parm (mode, type,
2279 #ifdef STACK_PARMS_IN_REG_PARM_AREA
2280 			     1,
2281 #else
2282 			     args[i].reg != 0,
2283 #endif
2284 			     reg_parm_stack_space,
2285 			     args[i].pass_on_stack ? 0 : args[i].partial,
2286 			     fndecl, args_size, &args[i].locate);
2287 #ifdef BLOCK_REG_PADDING
2288       else
2289 	/* The argument is passed entirely in registers.  See at which
2290 	   end it should be padded.  */
2291 	args[i].locate.where_pad =
2292 	  BLOCK_REG_PADDING (mode, type,
2293 			     int_size_in_bytes (type) <= UNITS_PER_WORD);
2294 #endif
2295 
2296       /* Update ARGS_SIZE, the total stack space for args so far.  */
2297 
2298       args_size->constant += args[i].locate.size.constant;
2299       if (args[i].locate.size.var)
2300 	ADD_PARM_SIZE (*args_size, args[i].locate.size.var);
2301 
2302       /* Increment ARGS_SO_FAR, which has info about which arg-registers
2303 	 have been used, etc.  */
2304 
2305       targetm.calls.function_arg_advance (args_so_far, TYPE_MODE (type),
2306 					  type, argpos < n_named_args);
2307 
2308       /* Store argument values for functions decorated with attribute
2309 	 alloc_size.  */
2310       if (argpos == alloc_idx[0])
2311 	alloc_args[0] = args[i].tree_value;
2312       else if (argpos == alloc_idx[1])
2313 	alloc_args[1] = args[i].tree_value;
2314     }
2315 
2316   if (alloc_args[0])
2317     {
2318       /* Check the arguments of functions decorated with attribute
2319 	 alloc_size.  */
2320       maybe_warn_alloc_args_overflow (fndecl, exp, alloc_args, alloc_idx);
2321     }
2322 
2323   /* Detect passing non-string arguments to functions expecting
2324      nul-terminated strings.  */
2325   maybe_warn_nonstring_arg (fndecl, exp);
2326 }
2327 
2328 /* Update ARGS_SIZE to contain the total size for the argument block.
2329    Return the original constant component of the argument block's size.
2330 
2331    REG_PARM_STACK_SPACE holds the number of bytes of stack space reserved
2332    for arguments passed in registers.  */
2333 
2334 static poly_int64
compute_argument_block_size(int reg_parm_stack_space,struct args_size * args_size,tree fndecl ATTRIBUTE_UNUSED,tree fntype ATTRIBUTE_UNUSED,int preferred_stack_boundary ATTRIBUTE_UNUSED)2335 compute_argument_block_size (int reg_parm_stack_space,
2336 			     struct args_size *args_size,
2337 			     tree fndecl ATTRIBUTE_UNUSED,
2338 			     tree fntype ATTRIBUTE_UNUSED,
2339 			     int preferred_stack_boundary ATTRIBUTE_UNUSED)
2340 {
2341   poly_int64 unadjusted_args_size = args_size->constant;
2342 
2343   /* For accumulate outgoing args mode we don't need to align, since the frame
2344      will be already aligned.  Align to STACK_BOUNDARY in order to prevent
2345      backends from generating misaligned frame sizes.  */
2346   if (ACCUMULATE_OUTGOING_ARGS && preferred_stack_boundary > STACK_BOUNDARY)
2347     preferred_stack_boundary = STACK_BOUNDARY;
2348 
2349   /* Compute the actual size of the argument block required.  The variable
2350      and constant sizes must be combined, the size may have to be rounded,
2351      and there may be a minimum required size.  */
2352 
2353   if (args_size->var)
2354     {
2355       args_size->var = ARGS_SIZE_TREE (*args_size);
2356       args_size->constant = 0;
2357 
2358       preferred_stack_boundary /= BITS_PER_UNIT;
2359       if (preferred_stack_boundary > 1)
2360 	{
2361 	  /* We don't handle this case yet.  To handle it correctly we have
2362 	     to add the delta, round and subtract the delta.
2363 	     Currently no machine description requires this support.  */
2364 	  gcc_assert (multiple_p (stack_pointer_delta,
2365 				  preferred_stack_boundary));
2366 	  args_size->var = round_up (args_size->var, preferred_stack_boundary);
2367 	}
2368 
2369       if (reg_parm_stack_space > 0)
2370 	{
2371 	  args_size->var
2372 	    = size_binop (MAX_EXPR, args_size->var,
2373 			  ssize_int (reg_parm_stack_space));
2374 
2375 	  /* The area corresponding to register parameters is not to count in
2376 	     the size of the block we need.  So make the adjustment.  */
2377 	  if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
2378 	    args_size->var
2379 	      = size_binop (MINUS_EXPR, args_size->var,
2380 			    ssize_int (reg_parm_stack_space));
2381 	}
2382     }
2383   else
2384     {
2385       preferred_stack_boundary /= BITS_PER_UNIT;
2386       if (preferred_stack_boundary < 1)
2387 	preferred_stack_boundary = 1;
2388       args_size->constant = (aligned_upper_bound (args_size->constant
2389 						  + stack_pointer_delta,
2390 						  preferred_stack_boundary)
2391 			     - stack_pointer_delta);
2392 
2393       args_size->constant = upper_bound (args_size->constant,
2394 					 reg_parm_stack_space);
2395 
2396       if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
2397 	args_size->constant -= reg_parm_stack_space;
2398     }
2399   return unadjusted_args_size;
2400 }
2401 
2402 /* Precompute parameters as needed for a function call.
2403 
2404    FLAGS is mask of ECF_* constants.
2405 
2406    NUM_ACTUALS is the number of arguments.
2407 
2408    ARGS is an array containing information for each argument; this
2409    routine fills in the INITIAL_VALUE and VALUE fields for each
2410    precomputed argument.  */
2411 
2412 static void
precompute_arguments(int num_actuals,struct arg_data * args)2413 precompute_arguments (int num_actuals, struct arg_data *args)
2414 {
2415   int i;
2416 
2417   /* If this is a libcall, then precompute all arguments so that we do not
2418      get extraneous instructions emitted as part of the libcall sequence.  */
2419 
2420   /* If we preallocated the stack space, and some arguments must be passed
2421      on the stack, then we must precompute any parameter which contains a
2422      function call which will store arguments on the stack.
2423      Otherwise, evaluating the parameter may clobber previous parameters
2424      which have already been stored into the stack.  (we have code to avoid
2425      such case by saving the outgoing stack arguments, but it results in
2426      worse code)  */
2427   if (!ACCUMULATE_OUTGOING_ARGS)
2428     return;
2429 
2430   for (i = 0; i < num_actuals; i++)
2431     {
2432       tree type;
2433       machine_mode mode;
2434 
2435       if (TREE_CODE (args[i].tree_value) != CALL_EXPR)
2436 	continue;
2437 
2438       /* If this is an addressable type, we cannot pre-evaluate it.  */
2439       type = TREE_TYPE (args[i].tree_value);
2440       gcc_assert (!TREE_ADDRESSABLE (type));
2441 
2442       args[i].initial_value = args[i].value
2443 	= expand_normal (args[i].tree_value);
2444 
2445       mode = TYPE_MODE (type);
2446       if (mode != args[i].mode)
2447 	{
2448 	  int unsignedp = args[i].unsignedp;
2449 	  args[i].value
2450 	    = convert_modes (args[i].mode, mode,
2451 			     args[i].value, args[i].unsignedp);
2452 
2453 	  /* CSE will replace this only if it contains args[i].value
2454 	     pseudo, so convert it down to the declared mode using
2455 	     a SUBREG.  */
2456 	  if (REG_P (args[i].value)
2457 	      && GET_MODE_CLASS (args[i].mode) == MODE_INT
2458 	      && promote_mode (type, mode, &unsignedp) != args[i].mode)
2459 	    {
2460 	      args[i].initial_value
2461 		= gen_lowpart_SUBREG (mode, args[i].value);
2462 	      SUBREG_PROMOTED_VAR_P (args[i].initial_value) = 1;
2463 	      SUBREG_PROMOTED_SET (args[i].initial_value, args[i].unsignedp);
2464 	    }
2465 	}
2466     }
2467 }
2468 
2469 /* Given the current state of MUST_PREALLOCATE and information about
2470    arguments to a function call in NUM_ACTUALS, ARGS and ARGS_SIZE,
2471    compute and return the final value for MUST_PREALLOCATE.  */
2472 
2473 static int
finalize_must_preallocate(int must_preallocate,int num_actuals,struct arg_data * args,struct args_size * args_size)2474 finalize_must_preallocate (int must_preallocate, int num_actuals,
2475 			   struct arg_data *args, struct args_size *args_size)
2476 {
2477   /* See if we have or want to preallocate stack space.
2478 
2479      If we would have to push a partially-in-regs parm
2480      before other stack parms, preallocate stack space instead.
2481 
2482      If the size of some parm is not a multiple of the required stack
2483      alignment, we must preallocate.
2484 
2485      If the total size of arguments that would otherwise create a copy in
2486      a temporary (such as a CALL) is more than half the total argument list
2487      size, preallocation is faster.
2488 
2489      Another reason to preallocate is if we have a machine (like the m88k)
2490      where stack alignment is required to be maintained between every
2491      pair of insns, not just when the call is made.  However, we assume here
2492      that such machines either do not have push insns (and hence preallocation
2493      would occur anyway) or the problem is taken care of with
2494      PUSH_ROUNDING.  */
2495 
2496   if (! must_preallocate)
2497     {
2498       int partial_seen = 0;
2499       poly_int64 copy_to_evaluate_size = 0;
2500       int i;
2501 
2502       for (i = 0; i < num_actuals && ! must_preallocate; i++)
2503 	{
2504 	  if (args[i].partial > 0 && ! args[i].pass_on_stack)
2505 	    partial_seen = 1;
2506 	  else if (partial_seen && args[i].reg == 0)
2507 	    must_preallocate = 1;
2508 	  /* We preallocate in case there are bounds passed
2509 	     in the bounds table to have precomputed address
2510 	     for bounds association.  */
2511 	  else if (POINTER_BOUNDS_P (args[i].tree_value)
2512 		   && !args[i].reg)
2513 	    must_preallocate = 1;
2514 
2515 	  if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
2516 	      && (TREE_CODE (args[i].tree_value) == CALL_EXPR
2517 		  || TREE_CODE (args[i].tree_value) == TARGET_EXPR
2518 		  || TREE_CODE (args[i].tree_value) == COND_EXPR
2519 		  || TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value))))
2520 	    copy_to_evaluate_size
2521 	      += int_size_in_bytes (TREE_TYPE (args[i].tree_value));
2522 	}
2523 
2524       if (maybe_ne (args_size->constant, 0)
2525 	  && maybe_ge (copy_to_evaluate_size * 2, args_size->constant))
2526 	must_preallocate = 1;
2527     }
2528   return must_preallocate;
2529 }
2530 
2531 /* If we preallocated stack space, compute the address of each argument
2532    and store it into the ARGS array.
2533 
2534    We need not ensure it is a valid memory address here; it will be
2535    validized when it is used.
2536 
2537    ARGBLOCK is an rtx for the address of the outgoing arguments.  */
2538 
2539 static void
compute_argument_addresses(struct arg_data * args,rtx argblock,int num_actuals)2540 compute_argument_addresses (struct arg_data *args, rtx argblock, int num_actuals)
2541 {
2542   if (argblock)
2543     {
2544       rtx arg_reg = argblock;
2545       int i;
2546       poly_int64 arg_offset = 0;
2547 
2548       if (GET_CODE (argblock) == PLUS)
2549 	{
2550 	  arg_reg = XEXP (argblock, 0);
2551 	  arg_offset = rtx_to_poly_int64 (XEXP (argblock, 1));
2552 	}
2553 
2554       for (i = 0; i < num_actuals; i++)
2555 	{
2556 	  rtx offset = ARGS_SIZE_RTX (args[i].locate.offset);
2557 	  rtx slot_offset = ARGS_SIZE_RTX (args[i].locate.slot_offset);
2558 	  rtx addr;
2559 	  unsigned int align, boundary;
2560 	  poly_uint64 units_on_stack = 0;
2561 	  machine_mode partial_mode = VOIDmode;
2562 
2563 	  /* Skip this parm if it will not be passed on the stack.  */
2564 	  if (! args[i].pass_on_stack
2565 	      && args[i].reg != 0
2566 	      && args[i].partial == 0)
2567 	    continue;
2568 
2569 	  if (TYPE_EMPTY_P (TREE_TYPE (args[i].tree_value)))
2570 	    continue;
2571 
2572 	  /* Pointer Bounds are never passed on the stack.  */
2573 	  if (POINTER_BOUNDS_P (args[i].tree_value))
2574 	    continue;
2575 
2576 	  addr = simplify_gen_binary (PLUS, Pmode, arg_reg, offset);
2577 	  addr = plus_constant (Pmode, addr, arg_offset);
2578 
2579 	  if (args[i].partial != 0)
2580 	    {
2581 	      /* Only part of the parameter is being passed on the stack.
2582 		 Generate a simple memory reference of the correct size.  */
2583 	      units_on_stack = args[i].locate.size.constant;
2584 	      poly_uint64 bits_on_stack = units_on_stack * BITS_PER_UNIT;
2585 	      partial_mode = int_mode_for_size (bits_on_stack, 1).else_blk ();
2586 	      args[i].stack = gen_rtx_MEM (partial_mode, addr);
2587 	      set_mem_size (args[i].stack, units_on_stack);
2588 	    }
2589 	  else
2590 	    {
2591 	      args[i].stack = gen_rtx_MEM (args[i].mode, addr);
2592 	      set_mem_attributes (args[i].stack,
2593 				  TREE_TYPE (args[i].tree_value), 1);
2594 	    }
2595 	  align = BITS_PER_UNIT;
2596 	  boundary = args[i].locate.boundary;
2597 	  poly_int64 offset_val;
2598 	  if (args[i].locate.where_pad != PAD_DOWNWARD)
2599 	    align = boundary;
2600 	  else if (poly_int_rtx_p (offset, &offset_val))
2601 	    {
2602 	      align = least_bit_hwi (boundary);
2603 	      unsigned int offset_align
2604 		= known_alignment (offset_val) * BITS_PER_UNIT;
2605 	      if (offset_align != 0)
2606 		align = MIN (align, offset_align);
2607 	    }
2608 	  set_mem_align (args[i].stack, align);
2609 
2610 	  addr = simplify_gen_binary (PLUS, Pmode, arg_reg, slot_offset);
2611 	  addr = plus_constant (Pmode, addr, arg_offset);
2612 
2613 	  if (args[i].partial != 0)
2614 	    {
2615 	      /* Only part of the parameter is being passed on the stack.
2616 		 Generate a simple memory reference of the correct size.
2617 	       */
2618 	      args[i].stack_slot = gen_rtx_MEM (partial_mode, addr);
2619 	      set_mem_size (args[i].stack_slot, units_on_stack);
2620 	    }
2621 	  else
2622 	    {
2623 	      args[i].stack_slot = gen_rtx_MEM (args[i].mode, addr);
2624 	      set_mem_attributes (args[i].stack_slot,
2625 				  TREE_TYPE (args[i].tree_value), 1);
2626 	    }
2627 	  set_mem_align (args[i].stack_slot, args[i].locate.boundary);
2628 
2629 	  /* Function incoming arguments may overlap with sibling call
2630 	     outgoing arguments and we cannot allow reordering of reads
2631 	     from function arguments with stores to outgoing arguments
2632 	     of sibling calls.  */
2633 	  set_mem_alias_set (args[i].stack, 0);
2634 	  set_mem_alias_set (args[i].stack_slot, 0);
2635 	}
2636     }
2637 }
2638 
2639 /* Given a FNDECL and EXP, return an rtx suitable for use as a target address
2640    in a call instruction.
2641 
2642    FNDECL is the tree node for the target function.  For an indirect call
2643    FNDECL will be NULL_TREE.
2644 
2645    ADDR is the operand 0 of CALL_EXPR for this call.  */
2646 
2647 static rtx
rtx_for_function_call(tree fndecl,tree addr)2648 rtx_for_function_call (tree fndecl, tree addr)
2649 {
2650   rtx funexp;
2651 
2652   /* Get the function to call, in the form of RTL.  */
2653   if (fndecl)
2654     {
2655       if (!TREE_USED (fndecl) && fndecl != current_function_decl)
2656 	TREE_USED (fndecl) = 1;
2657 
2658       /* Get a SYMBOL_REF rtx for the function address.  */
2659       funexp = XEXP (DECL_RTL (fndecl), 0);
2660     }
2661   else
2662     /* Generate an rtx (probably a pseudo-register) for the address.  */
2663     {
2664       push_temp_slots ();
2665       funexp = expand_normal (addr);
2666       pop_temp_slots ();	/* FUNEXP can't be BLKmode.  */
2667     }
2668   return funexp;
2669 }
2670 
2671 /* Return the static chain for this function, if any.  */
2672 
2673 rtx
rtx_for_static_chain(const_tree fndecl_or_type,bool incoming_p)2674 rtx_for_static_chain (const_tree fndecl_or_type, bool incoming_p)
2675 {
2676   if (DECL_P (fndecl_or_type) && !DECL_STATIC_CHAIN (fndecl_or_type))
2677     return NULL;
2678 
2679   return targetm.calls.static_chain (fndecl_or_type, incoming_p);
2680 }
2681 
2682 /* Internal state for internal_arg_pointer_based_exp and its helpers.  */
2683 static struct
2684 {
2685   /* Last insn that has been scanned by internal_arg_pointer_based_exp_scan,
2686      or NULL_RTX if none has been scanned yet.  */
2687   rtx_insn *scan_start;
2688   /* Vector indexed by REGNO - FIRST_PSEUDO_REGISTER, recording if a pseudo is
2689      based on crtl->args.internal_arg_pointer.  The element is NULL_RTX if the
2690      pseudo isn't based on it, a CONST_INT offset if the pseudo is based on it
2691      with fixed offset, or PC if this is with variable or unknown offset.  */
2692   vec<rtx> cache;
2693 } internal_arg_pointer_exp_state;
2694 
2695 static rtx internal_arg_pointer_based_exp (const_rtx, bool);
2696 
2697 /* Helper function for internal_arg_pointer_based_exp.  Scan insns in
2698    the tail call sequence, starting with first insn that hasn't been
2699    scanned yet, and note for each pseudo on the LHS whether it is based
2700    on crtl->args.internal_arg_pointer or not, and what offset from that
2701    that pointer it has.  */
2702 
2703 static void
internal_arg_pointer_based_exp_scan(void)2704 internal_arg_pointer_based_exp_scan (void)
2705 {
2706   rtx_insn *insn, *scan_start = internal_arg_pointer_exp_state.scan_start;
2707 
2708   if (scan_start == NULL_RTX)
2709     insn = get_insns ();
2710   else
2711     insn = NEXT_INSN (scan_start);
2712 
2713   while (insn)
2714     {
2715       rtx set = single_set (insn);
2716       if (set && REG_P (SET_DEST (set)) && !HARD_REGISTER_P (SET_DEST (set)))
2717 	{
2718 	  rtx val = NULL_RTX;
2719 	  unsigned int idx = REGNO (SET_DEST (set)) - FIRST_PSEUDO_REGISTER;
2720 	  /* Punt on pseudos set multiple times.  */
2721 	  if (idx < internal_arg_pointer_exp_state.cache.length ()
2722 	      && (internal_arg_pointer_exp_state.cache[idx]
2723 		  != NULL_RTX))
2724 	    val = pc_rtx;
2725 	  else
2726 	    val = internal_arg_pointer_based_exp (SET_SRC (set), false);
2727 	  if (val != NULL_RTX)
2728 	    {
2729 	      if (idx >= internal_arg_pointer_exp_state.cache.length ())
2730 		internal_arg_pointer_exp_state.cache
2731 		  .safe_grow_cleared (idx + 1);
2732 	      internal_arg_pointer_exp_state.cache[idx] = val;
2733 	    }
2734 	}
2735       if (NEXT_INSN (insn) == NULL_RTX)
2736 	scan_start = insn;
2737       insn = NEXT_INSN (insn);
2738     }
2739 
2740   internal_arg_pointer_exp_state.scan_start = scan_start;
2741 }
2742 
2743 /* Compute whether RTL is based on crtl->args.internal_arg_pointer.  Return
2744    NULL_RTX if RTL isn't based on it, a CONST_INT offset if RTL is based on
2745    it with fixed offset, or PC if this is with variable or unknown offset.
2746    TOPLEVEL is true if the function is invoked at the topmost level.  */
2747 
2748 static rtx
internal_arg_pointer_based_exp(const_rtx rtl,bool toplevel)2749 internal_arg_pointer_based_exp (const_rtx rtl, bool toplevel)
2750 {
2751   if (CONSTANT_P (rtl))
2752     return NULL_RTX;
2753 
2754   if (rtl == crtl->args.internal_arg_pointer)
2755     return const0_rtx;
2756 
2757   if (REG_P (rtl) && HARD_REGISTER_P (rtl))
2758     return NULL_RTX;
2759 
2760   poly_int64 offset;
2761   if (GET_CODE (rtl) == PLUS && poly_int_rtx_p (XEXP (rtl, 1), &offset))
2762     {
2763       rtx val = internal_arg_pointer_based_exp (XEXP (rtl, 0), toplevel);
2764       if (val == NULL_RTX || val == pc_rtx)
2765 	return val;
2766       return plus_constant (Pmode, val, offset);
2767     }
2768 
2769   /* When called at the topmost level, scan pseudo assignments in between the
2770      last scanned instruction in the tail call sequence and the latest insn
2771      in that sequence.  */
2772   if (toplevel)
2773     internal_arg_pointer_based_exp_scan ();
2774 
2775   if (REG_P (rtl))
2776     {
2777       unsigned int idx = REGNO (rtl) - FIRST_PSEUDO_REGISTER;
2778       if (idx < internal_arg_pointer_exp_state.cache.length ())
2779 	return internal_arg_pointer_exp_state.cache[idx];
2780 
2781       return NULL_RTX;
2782     }
2783 
2784   subrtx_iterator::array_type array;
2785   FOR_EACH_SUBRTX (iter, array, rtl, NONCONST)
2786     {
2787       const_rtx x = *iter;
2788       if (REG_P (x) && internal_arg_pointer_based_exp (x, false) != NULL_RTX)
2789 	return pc_rtx;
2790       if (MEM_P (x))
2791 	iter.skip_subrtxes ();
2792     }
2793 
2794   return NULL_RTX;
2795 }
2796 
2797 /* Return true if SIZE bytes starting from address ADDR might overlap an
2798    already-clobbered argument area.  This function is used to determine
2799    if we should give up a sibcall.  */
2800 
2801 static bool
mem_might_overlap_already_clobbered_arg_p(rtx addr,poly_uint64 size)2802 mem_might_overlap_already_clobbered_arg_p (rtx addr, poly_uint64 size)
2803 {
2804   poly_int64 i;
2805   unsigned HOST_WIDE_INT start, end;
2806   rtx val;
2807 
2808   if (bitmap_empty_p (stored_args_map)
2809       && stored_args_watermark == HOST_WIDE_INT_M1U)
2810     return false;
2811   val = internal_arg_pointer_based_exp (addr, true);
2812   if (val == NULL_RTX)
2813     return false;
2814   else if (!poly_int_rtx_p (val, &i))
2815     return true;
2816 
2817   if (known_eq (size, 0U))
2818     return false;
2819 
2820   if (STACK_GROWS_DOWNWARD)
2821     i -= crtl->args.pretend_args_size;
2822   else
2823     i += crtl->args.pretend_args_size;
2824 
2825   if (ARGS_GROW_DOWNWARD)
2826     i = -i - size;
2827 
2828   /* We can ignore any references to the function's pretend args,
2829      which at this point would manifest as negative values of I.  */
2830   if (known_le (i, 0) && known_le (size, poly_uint64 (-i)))
2831     return false;
2832 
2833   start = maybe_lt (i, 0) ? 0 : constant_lower_bound (i);
2834   if (!(i + size).is_constant (&end))
2835     end = HOST_WIDE_INT_M1U;
2836 
2837   if (end > stored_args_watermark)
2838     return true;
2839 
2840   end = MIN (end, SBITMAP_SIZE (stored_args_map));
2841   for (unsigned HOST_WIDE_INT k = start; k < end; ++k)
2842     if (bitmap_bit_p (stored_args_map, k))
2843       return true;
2844 
2845   return false;
2846 }
2847 
2848 /* Do the register loads required for any wholly-register parms or any
2849    parms which are passed both on the stack and in a register.  Their
2850    expressions were already evaluated.
2851 
2852    Mark all register-parms as living through the call, putting these USE
2853    insns in the CALL_INSN_FUNCTION_USAGE field.
2854 
2855    When IS_SIBCALL, perform the check_sibcall_argument_overlap
2856    checking, setting *SIBCALL_FAILURE if appropriate.  */
2857 
2858 static void
load_register_parameters(struct arg_data * args,int num_actuals,rtx * call_fusage,int flags,int is_sibcall,int * sibcall_failure)2859 load_register_parameters (struct arg_data *args, int num_actuals,
2860 			  rtx *call_fusage, int flags, int is_sibcall,
2861 			  int *sibcall_failure)
2862 {
2863   int i, j;
2864 
2865   for (i = 0; i < num_actuals; i++)
2866     {
2867       rtx reg = ((flags & ECF_SIBCALL)
2868 		 ? args[i].tail_call_reg : args[i].reg);
2869       if (reg)
2870 	{
2871 	  int partial = args[i].partial;
2872 	  int nregs;
2873 	  poly_int64 size = 0;
2874 	  HOST_WIDE_INT const_size = 0;
2875 	  rtx_insn *before_arg = get_last_insn ();
2876 	  /* Set non-negative if we must move a word at a time, even if
2877 	     just one word (e.g, partial == 4 && mode == DFmode).  Set
2878 	     to -1 if we just use a normal move insn.  This value can be
2879 	     zero if the argument is a zero size structure.  */
2880 	  nregs = -1;
2881 	  if (GET_CODE (reg) == PARALLEL)
2882 	    ;
2883 	  else if (partial)
2884 	    {
2885 	      gcc_assert (partial % UNITS_PER_WORD == 0);
2886 	      nregs = partial / UNITS_PER_WORD;
2887 	    }
2888 	  else if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode)
2889 	    {
2890 	      /* Variable-sized parameters should be described by a
2891 		 PARALLEL instead.  */
2892 	      const_size = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
2893 	      gcc_assert (const_size >= 0);
2894 	      nregs = (const_size + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
2895 	      size = const_size;
2896 	    }
2897 	  else
2898 	    size = GET_MODE_SIZE (args[i].mode);
2899 
2900 	  /* Handle calls that pass values in multiple non-contiguous
2901 	     locations.  The Irix 6 ABI has examples of this.  */
2902 
2903 	  if (GET_CODE (reg) == PARALLEL)
2904 	    emit_group_move (reg, args[i].parallel_value);
2905 
2906 	  /* If simple case, just do move.  If normal partial, store_one_arg
2907 	     has already loaded the register for us.  In all other cases,
2908 	     load the register(s) from memory.  */
2909 
2910 	  else if (nregs == -1)
2911 	    {
2912 	      emit_move_insn (reg, args[i].value);
2913 #ifdef BLOCK_REG_PADDING
2914 	      /* Handle case where we have a value that needs shifting
2915 		 up to the msb.  eg. a QImode value and we're padding
2916 		 upward on a BYTES_BIG_ENDIAN machine.  */
2917 	      if (args[i].locate.where_pad
2918 		  == (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD))
2919 		{
2920 		  gcc_checking_assert (ordered_p (size, UNITS_PER_WORD));
2921 		  if (maybe_lt (size, UNITS_PER_WORD))
2922 		    {
2923 		      rtx x;
2924 		      poly_int64 shift
2925 			= (UNITS_PER_WORD - size) * BITS_PER_UNIT;
2926 
2927 		      /* Assigning REG here rather than a temp makes
2928 			 CALL_FUSAGE report the whole reg as used.
2929 			 Strictly speaking, the call only uses SIZE
2930 			 bytes at the msb end, but it doesn't seem worth
2931 			 generating rtl to say that.  */
2932 		      reg = gen_rtx_REG (word_mode, REGNO (reg));
2933 		      x = expand_shift (LSHIFT_EXPR, word_mode,
2934 					reg, shift, reg, 1);
2935 		      if (x != reg)
2936 			emit_move_insn (reg, x);
2937 		    }
2938 		}
2939 #endif
2940 	    }
2941 
2942 	  /* If we have pre-computed the values to put in the registers in
2943 	     the case of non-aligned structures, copy them in now.  */
2944 
2945 	  else if (args[i].n_aligned_regs != 0)
2946 	    for (j = 0; j < args[i].n_aligned_regs; j++)
2947 	      emit_move_insn (gen_rtx_REG (word_mode, REGNO (reg) + j),
2948 			      args[i].aligned_regs[j]);
2949 
2950 	  else if (partial == 0 || args[i].pass_on_stack)
2951 	    {
2952 	      /* SIZE and CONST_SIZE are 0 for partial arguments and
2953 		 the size of a BLKmode type otherwise.  */
2954 	      gcc_checking_assert (known_eq (size, const_size));
2955 	      rtx mem = validize_mem (copy_rtx (args[i].value));
2956 
2957 	      /* Check for overlap with already clobbered argument area,
2958 	         providing that this has non-zero size.  */
2959 	      if (is_sibcall
2960 		  && const_size != 0
2961 		  && (mem_might_overlap_already_clobbered_arg_p
2962 		      (XEXP (args[i].value, 0), const_size)))
2963 		*sibcall_failure = 1;
2964 
2965 	      if (const_size % UNITS_PER_WORD == 0
2966 		  || MEM_ALIGN (mem) % BITS_PER_WORD == 0)
2967 		move_block_to_reg (REGNO (reg), mem, nregs, args[i].mode);
2968 	      else
2969 		{
2970 		  if (nregs > 1)
2971 		    move_block_to_reg (REGNO (reg), mem, nregs - 1,
2972 				       args[i].mode);
2973 		  rtx dest = gen_rtx_REG (word_mode, REGNO (reg) + nregs - 1);
2974 		  unsigned int bitoff = (nregs - 1) * BITS_PER_WORD;
2975 		  unsigned int bitsize = const_size * BITS_PER_UNIT - bitoff;
2976 		  rtx x = extract_bit_field (mem, bitsize, bitoff, 1, dest,
2977 					     word_mode, word_mode, false,
2978 					     NULL);
2979 		  if (BYTES_BIG_ENDIAN)
2980 		    x = expand_shift (LSHIFT_EXPR, word_mode, x,
2981 				      BITS_PER_WORD - bitsize, dest, 1);
2982 		  if (x != dest)
2983 		    emit_move_insn (dest, x);
2984 		}
2985 
2986 	      /* Handle a BLKmode that needs shifting.  */
2987 	      if (nregs == 1 && const_size < UNITS_PER_WORD
2988 #ifdef BLOCK_REG_PADDING
2989 		  && args[i].locate.where_pad == PAD_DOWNWARD
2990 #else
2991 		  && BYTES_BIG_ENDIAN
2992 #endif
2993 		  )
2994 		{
2995 		  rtx dest = gen_rtx_REG (word_mode, REGNO (reg));
2996 		  int shift = (UNITS_PER_WORD - const_size) * BITS_PER_UNIT;
2997 		  enum tree_code dir = (BYTES_BIG_ENDIAN
2998 					? RSHIFT_EXPR : LSHIFT_EXPR);
2999 		  rtx x;
3000 
3001 		  x = expand_shift (dir, word_mode, dest, shift, dest, 1);
3002 		  if (x != dest)
3003 		    emit_move_insn (dest, x);
3004 		}
3005 	    }
3006 
3007 	  /* When a parameter is a block, and perhaps in other cases, it is
3008 	     possible that it did a load from an argument slot that was
3009 	     already clobbered.  */
3010 	  if (is_sibcall
3011 	      && check_sibcall_argument_overlap (before_arg, &args[i], 0))
3012 	    *sibcall_failure = 1;
3013 
3014 	  /* Handle calls that pass values in multiple non-contiguous
3015 	     locations.  The Irix 6 ABI has examples of this.  */
3016 	  if (GET_CODE (reg) == PARALLEL)
3017 	    use_group_regs (call_fusage, reg);
3018 	  else if (nregs == -1)
3019 	    use_reg_mode (call_fusage, reg,
3020 			  TYPE_MODE (TREE_TYPE (args[i].tree_value)));
3021 	  else if (nregs > 0)
3022 	    use_regs (call_fusage, REGNO (reg), nregs);
3023 	}
3024     }
3025 }
3026 
3027 /* We need to pop PENDING_STACK_ADJUST bytes.  But, if the arguments
3028    wouldn't fill up an even multiple of PREFERRED_UNIT_STACK_BOUNDARY
3029    bytes, then we would need to push some additional bytes to pad the
3030    arguments.  So, we try to compute an adjust to the stack pointer for an
3031    amount that will leave the stack under-aligned by UNADJUSTED_ARGS_SIZE
3032    bytes.  Then, when the arguments are pushed the stack will be perfectly
3033    aligned.
3034 
3035    Return true if this optimization is possible, storing the adjustment
3036    in ADJUSTMENT_OUT and setting ARGS_SIZE->CONSTANT to the number of
3037    bytes that should be popped after the call.  */
3038 
3039 static bool
combine_pending_stack_adjustment_and_call(poly_int64_pod * adjustment_out,poly_int64 unadjusted_args_size,struct args_size * args_size,unsigned int preferred_unit_stack_boundary)3040 combine_pending_stack_adjustment_and_call (poly_int64_pod *adjustment_out,
3041 					   poly_int64 unadjusted_args_size,
3042 					   struct args_size *args_size,
3043 					   unsigned int preferred_unit_stack_boundary)
3044 {
3045   /* The number of bytes to pop so that the stack will be
3046      under-aligned by UNADJUSTED_ARGS_SIZE bytes.  */
3047   poly_int64 adjustment;
3048   /* The alignment of the stack after the arguments are pushed, if we
3049      just pushed the arguments without adjust the stack here.  */
3050   unsigned HOST_WIDE_INT unadjusted_alignment;
3051 
3052   if (!known_misalignment (stack_pointer_delta + unadjusted_args_size,
3053 			   preferred_unit_stack_boundary,
3054 			   &unadjusted_alignment))
3055     return false;
3056 
3057   /* We want to get rid of as many of the PENDING_STACK_ADJUST bytes
3058      as possible -- leaving just enough left to cancel out the
3059      UNADJUSTED_ALIGNMENT.  In other words, we want to ensure that the
3060      PENDING_STACK_ADJUST is non-negative, and congruent to
3061      -UNADJUSTED_ALIGNMENT modulo the PREFERRED_UNIT_STACK_BOUNDARY.  */
3062 
3063   /* Begin by trying to pop all the bytes.  */
3064   unsigned HOST_WIDE_INT tmp_misalignment;
3065   if (!known_misalignment (pending_stack_adjust,
3066 			   preferred_unit_stack_boundary,
3067 			   &tmp_misalignment))
3068     return false;
3069   unadjusted_alignment -= tmp_misalignment;
3070   adjustment = pending_stack_adjust;
3071   /* Push enough additional bytes that the stack will be aligned
3072      after the arguments are pushed.  */
3073   if (preferred_unit_stack_boundary > 1 && unadjusted_alignment)
3074     adjustment -= preferred_unit_stack_boundary - unadjusted_alignment;
3075 
3076   /* We need to know whether the adjusted argument size
3077      (UNADJUSTED_ARGS_SIZE - ADJUSTMENT) constitutes an allocation
3078      or a deallocation.  */
3079   if (!ordered_p (adjustment, unadjusted_args_size))
3080     return false;
3081 
3082   /* Now, sets ARGS_SIZE->CONSTANT so that we pop the right number of
3083      bytes after the call.  The right number is the entire
3084      PENDING_STACK_ADJUST less our ADJUSTMENT plus the amount required
3085      by the arguments in the first place.  */
3086   args_size->constant
3087     = pending_stack_adjust - adjustment + unadjusted_args_size;
3088 
3089   *adjustment_out = adjustment;
3090   return true;
3091 }
3092 
3093 /* Scan X expression if it does not dereference any argument slots
3094    we already clobbered by tail call arguments (as noted in stored_args_map
3095    bitmap).
3096    Return nonzero if X expression dereferences such argument slots,
3097    zero otherwise.  */
3098 
3099 static int
check_sibcall_argument_overlap_1(rtx x)3100 check_sibcall_argument_overlap_1 (rtx x)
3101 {
3102   RTX_CODE code;
3103   int i, j;
3104   const char *fmt;
3105 
3106   if (x == NULL_RTX)
3107     return 0;
3108 
3109   code = GET_CODE (x);
3110 
3111   /* We need not check the operands of the CALL expression itself.  */
3112   if (code == CALL)
3113     return 0;
3114 
3115   if (code == MEM)
3116     return (mem_might_overlap_already_clobbered_arg_p
3117 	    (XEXP (x, 0), GET_MODE_SIZE (GET_MODE (x))));
3118 
3119   /* Scan all subexpressions.  */
3120   fmt = GET_RTX_FORMAT (code);
3121   for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
3122     {
3123       if (*fmt == 'e')
3124 	{
3125 	  if (check_sibcall_argument_overlap_1 (XEXP (x, i)))
3126 	    return 1;
3127 	}
3128       else if (*fmt == 'E')
3129 	{
3130 	  for (j = 0; j < XVECLEN (x, i); j++)
3131 	    if (check_sibcall_argument_overlap_1 (XVECEXP (x, i, j)))
3132 	      return 1;
3133 	}
3134     }
3135   return 0;
3136 }
3137 
3138 /* Scan sequence after INSN if it does not dereference any argument slots
3139    we already clobbered by tail call arguments (as noted in stored_args_map
3140    bitmap).  If MARK_STORED_ARGS_MAP, add stack slots for ARG to
3141    stored_args_map bitmap afterwards (when ARG is a register MARK_STORED_ARGS_MAP
3142    should be 0).  Return nonzero if sequence after INSN dereferences such argument
3143    slots, zero otherwise.  */
3144 
3145 static int
check_sibcall_argument_overlap(rtx_insn * insn,struct arg_data * arg,int mark_stored_args_map)3146 check_sibcall_argument_overlap (rtx_insn *insn, struct arg_data *arg,
3147 				int mark_stored_args_map)
3148 {
3149   poly_uint64 low, high;
3150   unsigned HOST_WIDE_INT const_low, const_high;
3151 
3152   if (insn == NULL_RTX)
3153     insn = get_insns ();
3154   else
3155     insn = NEXT_INSN (insn);
3156 
3157   for (; insn; insn = NEXT_INSN (insn))
3158     if (INSN_P (insn)
3159 	&& check_sibcall_argument_overlap_1 (PATTERN (insn)))
3160       break;
3161 
3162   if (mark_stored_args_map)
3163     {
3164       if (ARGS_GROW_DOWNWARD)
3165 	low = -arg->locate.slot_offset.constant - arg->locate.size.constant;
3166       else
3167 	low = arg->locate.slot_offset.constant;
3168       high = low + arg->locate.size.constant;
3169 
3170       const_low = constant_lower_bound (low);
3171       if (high.is_constant (&const_high))
3172 	for (unsigned HOST_WIDE_INT i = const_low; i < const_high; ++i)
3173 	  bitmap_set_bit (stored_args_map, i);
3174       else
3175 	stored_args_watermark = MIN (stored_args_watermark, const_low);
3176     }
3177   return insn != NULL_RTX;
3178 }
3179 
3180 /* Given that a function returns a value of mode MODE at the most
3181    significant end of hard register VALUE, shift VALUE left or right
3182    as specified by LEFT_P.  Return true if some action was needed.  */
3183 
3184 bool
shift_return_value(machine_mode mode,bool left_p,rtx value)3185 shift_return_value (machine_mode mode, bool left_p, rtx value)
3186 {
3187   gcc_assert (REG_P (value) && HARD_REGISTER_P (value));
3188   machine_mode value_mode = GET_MODE (value);
3189   poly_int64 shift = GET_MODE_BITSIZE (value_mode) - GET_MODE_BITSIZE (mode);
3190 
3191   if (known_eq (shift, 0))
3192     return false;
3193 
3194   /* Use ashr rather than lshr for right shifts.  This is for the benefit
3195      of the MIPS port, which requires SImode values to be sign-extended
3196      when stored in 64-bit registers.  */
3197   if (!force_expand_binop (value_mode, left_p ? ashl_optab : ashr_optab,
3198 			   value, gen_int_shift_amount (value_mode, shift),
3199 			   value, 1, OPTAB_WIDEN))
3200     gcc_unreachable ();
3201   return true;
3202 }
3203 
3204 /* If X is a likely-spilled register value, copy it to a pseudo
3205    register and return that register.  Return X otherwise.  */
3206 
3207 static rtx
avoid_likely_spilled_reg(rtx x)3208 avoid_likely_spilled_reg (rtx x)
3209 {
3210   rtx new_rtx;
3211 
3212   if (REG_P (x)
3213       && HARD_REGISTER_P (x)
3214       && targetm.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (x))))
3215     {
3216       /* Make sure that we generate a REG rather than a CONCAT.
3217 	 Moves into CONCATs can need nontrivial instructions,
3218 	 and the whole point of this function is to avoid
3219 	 using the hard register directly in such a situation.  */
3220       generating_concat_p = 0;
3221       new_rtx = gen_reg_rtx (GET_MODE (x));
3222       generating_concat_p = 1;
3223       emit_move_insn (new_rtx, x);
3224       return new_rtx;
3225     }
3226   return x;
3227 }
3228 
3229 /* Helper function for expand_call.
3230    Return false is EXP is not implementable as a sibling call.  */
3231 
3232 static bool
can_implement_as_sibling_call_p(tree exp,rtx structure_value_addr,tree funtype,int reg_parm_stack_space ATTRIBUTE_UNUSED,tree fndecl,int flags,tree addr,const args_size & args_size)3233 can_implement_as_sibling_call_p (tree exp,
3234 				 rtx structure_value_addr,
3235 				 tree funtype,
3236 				 int reg_parm_stack_space ATTRIBUTE_UNUSED,
3237 				 tree fndecl,
3238 				 int flags,
3239 				 tree addr,
3240 				 const args_size &args_size)
3241 {
3242   if (!targetm.have_sibcall_epilogue ())
3243     {
3244       maybe_complain_about_tail_call
3245 	(exp,
3246 	 "machine description does not have"
3247 	 " a sibcall_epilogue instruction pattern");
3248       return false;
3249     }
3250 
3251   /* Doing sibling call optimization needs some work, since
3252      structure_value_addr can be allocated on the stack.
3253      It does not seem worth the effort since few optimizable
3254      sibling calls will return a structure.  */
3255   if (structure_value_addr != NULL_RTX)
3256     {
3257       maybe_complain_about_tail_call (exp, "callee returns a structure");
3258       return false;
3259     }
3260 
3261 #ifdef REG_PARM_STACK_SPACE
3262   /* If outgoing reg parm stack space changes, we can not do sibcall.  */
3263   if (OUTGOING_REG_PARM_STACK_SPACE (funtype)
3264       != OUTGOING_REG_PARM_STACK_SPACE (TREE_TYPE (current_function_decl))
3265       || (reg_parm_stack_space != REG_PARM_STACK_SPACE (current_function_decl)))
3266     {
3267       maybe_complain_about_tail_call (exp,
3268 				      "inconsistent size of stack space"
3269 				      " allocated for arguments which are"
3270 				      " passed in registers");
3271       return false;
3272     }
3273 #endif
3274 
3275   /* Check whether the target is able to optimize the call
3276      into a sibcall.  */
3277   if (!targetm.function_ok_for_sibcall (fndecl, exp))
3278     {
3279       maybe_complain_about_tail_call (exp,
3280 				      "target is not able to optimize the"
3281 				      " call into a sibling call");
3282       return false;
3283     }
3284 
3285   /* Functions that do not return exactly once may not be sibcall
3286      optimized.  */
3287   if (flags & ECF_RETURNS_TWICE)
3288     {
3289       maybe_complain_about_tail_call (exp, "callee returns twice");
3290       return false;
3291     }
3292   if (flags & ECF_NORETURN)
3293     {
3294       maybe_complain_about_tail_call (exp, "callee does not return");
3295       return false;
3296     }
3297 
3298   if (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (addr))))
3299     {
3300       maybe_complain_about_tail_call (exp, "volatile function type");
3301       return false;
3302     }
3303 
3304   /* If the called function is nested in the current one, it might access
3305      some of the caller's arguments, but could clobber them beforehand if
3306      the argument areas are shared.  */
3307   if (fndecl && decl_function_context (fndecl) == current_function_decl)
3308     {
3309       maybe_complain_about_tail_call (exp, "nested function");
3310       return false;
3311     }
3312 
3313   /* If this function requires more stack slots than the current
3314      function, we cannot change it into a sibling call.
3315      crtl->args.pretend_args_size is not part of the
3316      stack allocated by our caller.  */
3317   if (maybe_gt (args_size.constant,
3318 		crtl->args.size - crtl->args.pretend_args_size))
3319     {
3320       maybe_complain_about_tail_call (exp,
3321 				      "callee required more stack slots"
3322 				      " than the caller");
3323       return false;
3324     }
3325 
3326   /* If the callee pops its own arguments, then it must pop exactly
3327      the same number of arguments as the current function.  */
3328   if (maybe_ne (targetm.calls.return_pops_args (fndecl, funtype,
3329 						args_size.constant),
3330 		targetm.calls.return_pops_args (current_function_decl,
3331 						TREE_TYPE
3332 						(current_function_decl),
3333 						crtl->args.size)))
3334     {
3335       maybe_complain_about_tail_call (exp,
3336 				      "inconsistent number of"
3337 				      " popped arguments");
3338       return false;
3339     }
3340 
3341   if (!lang_hooks.decls.ok_for_sibcall (fndecl))
3342     {
3343       maybe_complain_about_tail_call (exp, "frontend does not support"
3344 					    " sibling call");
3345       return false;
3346     }
3347 
3348   /* All checks passed.  */
3349   return true;
3350 }
3351 
3352 /* Generate all the code for a CALL_EXPR exp
3353    and return an rtx for its value.
3354    Store the value in TARGET (specified as an rtx) if convenient.
3355    If the value is stored in TARGET then TARGET is returned.
3356    If IGNORE is nonzero, then we ignore the value of the function call.  */
3357 
3358 rtx
expand_call(tree exp,rtx target,int ignore)3359 expand_call (tree exp, rtx target, int ignore)
3360 {
3361   /* Nonzero if we are currently expanding a call.  */
3362   static int currently_expanding_call = 0;
3363 
3364   /* RTX for the function to be called.  */
3365   rtx funexp;
3366   /* Sequence of insns to perform a normal "call".  */
3367   rtx_insn *normal_call_insns = NULL;
3368   /* Sequence of insns to perform a tail "call".  */
3369   rtx_insn *tail_call_insns = NULL;
3370   /* Data type of the function.  */
3371   tree funtype;
3372   tree type_arg_types;
3373   tree rettype;
3374   /* Declaration of the function being called,
3375      or 0 if the function is computed (not known by name).  */
3376   tree fndecl = 0;
3377   /* The type of the function being called.  */
3378   tree fntype;
3379   bool try_tail_call = CALL_EXPR_TAILCALL (exp);
3380   bool must_tail_call = CALL_EXPR_MUST_TAIL_CALL (exp);
3381   int pass;
3382 
3383   /* Register in which non-BLKmode value will be returned,
3384      or 0 if no value or if value is BLKmode.  */
3385   rtx valreg;
3386   /* Register(s) in which bounds are returned.  */
3387   rtx valbnd = NULL;
3388   /* Address where we should return a BLKmode value;
3389      0 if value not BLKmode.  */
3390   rtx structure_value_addr = 0;
3391   /* Nonzero if that address is being passed by treating it as
3392      an extra, implicit first parameter.  Otherwise,
3393      it is passed by being copied directly into struct_value_rtx.  */
3394   int structure_value_addr_parm = 0;
3395   /* Holds the value of implicit argument for the struct value.  */
3396   tree structure_value_addr_value = NULL_TREE;
3397   /* Size of aggregate value wanted, or zero if none wanted
3398      or if we are using the non-reentrant PCC calling convention
3399      or expecting the value in registers.  */
3400   poly_int64 struct_value_size = 0;
3401   /* Nonzero if called function returns an aggregate in memory PCC style,
3402      by returning the address of where to find it.  */
3403   int pcc_struct_value = 0;
3404   rtx struct_value = 0;
3405 
3406   /* Number of actual parameters in this call, including struct value addr.  */
3407   int num_actuals;
3408   /* Number of named args.  Args after this are anonymous ones
3409      and they must all go on the stack.  */
3410   int n_named_args;
3411   /* Number of complex actual arguments that need to be split.  */
3412   int num_complex_actuals = 0;
3413 
3414   /* Vector of information about each argument.
3415      Arguments are numbered in the order they will be pushed,
3416      not the order they are written.  */
3417   struct arg_data *args;
3418 
3419   /* Total size in bytes of all the stack-parms scanned so far.  */
3420   struct args_size args_size;
3421   struct args_size adjusted_args_size;
3422   /* Size of arguments before any adjustments (such as rounding).  */
3423   poly_int64 unadjusted_args_size;
3424   /* Data on reg parms scanned so far.  */
3425   CUMULATIVE_ARGS args_so_far_v;
3426   cumulative_args_t args_so_far;
3427   /* Nonzero if a reg parm has been scanned.  */
3428   int reg_parm_seen;
3429   /* Nonzero if this is an indirect function call.  */
3430 
3431   /* Nonzero if we must avoid push-insns in the args for this call.
3432      If stack space is allocated for register parameters, but not by the
3433      caller, then it is preallocated in the fixed part of the stack frame.
3434      So the entire argument block must then be preallocated (i.e., we
3435      ignore PUSH_ROUNDING in that case).  */
3436 
3437   int must_preallocate = !PUSH_ARGS;
3438 
3439   /* Size of the stack reserved for parameter registers.  */
3440   int reg_parm_stack_space = 0;
3441 
3442   /* Address of space preallocated for stack parms
3443      (on machines that lack push insns), or 0 if space not preallocated.  */
3444   rtx argblock = 0;
3445 
3446   /* Mask of ECF_ and ERF_ flags.  */
3447   int flags = 0;
3448   int return_flags = 0;
3449 #ifdef REG_PARM_STACK_SPACE
3450   /* Define the boundary of the register parm stack space that needs to be
3451      saved, if any.  */
3452   int low_to_save, high_to_save;
3453   rtx save_area = 0;		/* Place that it is saved */
3454 #endif
3455 
3456   unsigned int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
3457   char *initial_stack_usage_map = stack_usage_map;
3458   unsigned HOST_WIDE_INT initial_stack_usage_watermark = stack_usage_watermark;
3459   char *stack_usage_map_buf = NULL;
3460 
3461   poly_int64 old_stack_allocated;
3462 
3463   /* State variables to track stack modifications.  */
3464   rtx old_stack_level = 0;
3465   int old_stack_arg_under_construction = 0;
3466   poly_int64 old_pending_adj = 0;
3467   int old_inhibit_defer_pop = inhibit_defer_pop;
3468 
3469   /* Some stack pointer alterations we make are performed via
3470      allocate_dynamic_stack_space. This modifies the stack_pointer_delta,
3471      which we then also need to save/restore along the way.  */
3472   poly_int64 old_stack_pointer_delta = 0;
3473 
3474   rtx call_fusage;
3475   tree addr = CALL_EXPR_FN (exp);
3476   int i;
3477   /* The alignment of the stack, in bits.  */
3478   unsigned HOST_WIDE_INT preferred_stack_boundary;
3479   /* The alignment of the stack, in bytes.  */
3480   unsigned HOST_WIDE_INT preferred_unit_stack_boundary;
3481   /* The static chain value to use for this call.  */
3482   rtx static_chain_value;
3483   /* See if this is "nothrow" function call.  */
3484   if (TREE_NOTHROW (exp))
3485     flags |= ECF_NOTHROW;
3486 
3487   /* See if we can find a DECL-node for the actual function, and get the
3488      function attributes (flags) from the function decl or type node.  */
3489   fndecl = get_callee_fndecl (exp);
3490   if (fndecl)
3491     {
3492       fntype = TREE_TYPE (fndecl);
3493       flags |= flags_from_decl_or_type (fndecl);
3494       return_flags |= decl_return_flags (fndecl);
3495     }
3496   else
3497     {
3498       fntype = TREE_TYPE (TREE_TYPE (addr));
3499       flags |= flags_from_decl_or_type (fntype);
3500       if (CALL_EXPR_BY_DESCRIPTOR (exp))
3501 	flags |= ECF_BY_DESCRIPTOR;
3502     }
3503   rettype = TREE_TYPE (exp);
3504 
3505   struct_value = targetm.calls.struct_value_rtx (fntype, 0);
3506 
3507   /* Warn if this value is an aggregate type,
3508      regardless of which calling convention we are using for it.  */
3509   if (AGGREGATE_TYPE_P (rettype))
3510     warning (OPT_Waggregate_return, "function call has aggregate value");
3511 
3512   /* If the result of a non looping pure or const function call is
3513      ignored (or void), and none of its arguments are volatile, we can
3514      avoid expanding the call and just evaluate the arguments for
3515      side-effects.  */
3516   if ((flags & (ECF_CONST | ECF_PURE))
3517       && (!(flags & ECF_LOOPING_CONST_OR_PURE))
3518       && (ignore || target == const0_rtx
3519 	  || TYPE_MODE (rettype) == VOIDmode))
3520     {
3521       bool volatilep = false;
3522       tree arg;
3523       call_expr_arg_iterator iter;
3524 
3525       FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
3526 	if (TREE_THIS_VOLATILE (arg))
3527 	  {
3528 	    volatilep = true;
3529 	    break;
3530 	  }
3531 
3532       if (! volatilep)
3533 	{
3534 	  FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
3535 	    expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
3536 	  return const0_rtx;
3537 	}
3538     }
3539 
3540 #ifdef REG_PARM_STACK_SPACE
3541   reg_parm_stack_space = REG_PARM_STACK_SPACE (!fndecl ? fntype : fndecl);
3542 #endif
3543 
3544   if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))
3545       && reg_parm_stack_space > 0 && PUSH_ARGS)
3546     must_preallocate = 1;
3547 
3548   /* Set up a place to return a structure.  */
3549 
3550   /* Cater to broken compilers.  */
3551   if (aggregate_value_p (exp, fntype))
3552     {
3553       /* This call returns a big structure.  */
3554       flags &= ~(ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
3555 
3556 #ifdef PCC_STATIC_STRUCT_RETURN
3557       {
3558 	pcc_struct_value = 1;
3559       }
3560 #else /* not PCC_STATIC_STRUCT_RETURN */
3561       {
3562 	if (!poly_int_tree_p (TYPE_SIZE_UNIT (rettype), &struct_value_size))
3563 	  struct_value_size = -1;
3564 
3565 	/* Even if it is semantically safe to use the target as the return
3566 	   slot, it may be not sufficiently aligned for the return type.  */
3567 	if (CALL_EXPR_RETURN_SLOT_OPT (exp)
3568 	    && target
3569 	    && MEM_P (target)
3570 	    /* If rettype is addressable, we may not create a temporary.
3571 	       If target is properly aligned at runtime and the compiler
3572 	       just doesn't know about it, it will work fine, otherwise it
3573 	       will be UB.  */
3574 	    && (TREE_ADDRESSABLE (rettype)
3575 		|| !(MEM_ALIGN (target) < TYPE_ALIGN (rettype)
3576 		     && targetm.slow_unaligned_access (TYPE_MODE (rettype),
3577 						       MEM_ALIGN (target)))))
3578 	  structure_value_addr = XEXP (target, 0);
3579 	else
3580 	  {
3581 	    /* For variable-sized objects, we must be called with a target
3582 	       specified.  If we were to allocate space on the stack here,
3583 	       we would have no way of knowing when to free it.  */
3584 	    rtx d = assign_temp (rettype, 1, 1);
3585 	    structure_value_addr = XEXP (d, 0);
3586 	    target = 0;
3587 	  }
3588       }
3589 #endif /* not PCC_STATIC_STRUCT_RETURN */
3590     }
3591 
3592   /* Figure out the amount to which the stack should be aligned.  */
3593   preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
3594   if (fndecl)
3595     {
3596       struct cgraph_rtl_info *i = cgraph_node::rtl_info (fndecl);
3597       /* Without automatic stack alignment, we can't increase preferred
3598 	 stack boundary.  With automatic stack alignment, it is
3599 	 unnecessary since unless we can guarantee that all callers will
3600 	 align the outgoing stack properly, callee has to align its
3601 	 stack anyway.  */
3602       if (i
3603 	  && i->preferred_incoming_stack_boundary
3604 	  && i->preferred_incoming_stack_boundary < preferred_stack_boundary)
3605 	preferred_stack_boundary = i->preferred_incoming_stack_boundary;
3606     }
3607 
3608   /* Operand 0 is a pointer-to-function; get the type of the function.  */
3609   funtype = TREE_TYPE (addr);
3610   gcc_assert (POINTER_TYPE_P (funtype));
3611   funtype = TREE_TYPE (funtype);
3612 
3613   /* Count whether there are actual complex arguments that need to be split
3614      into their real and imaginary parts.  Munge the type_arg_types
3615      appropriately here as well.  */
3616   if (targetm.calls.split_complex_arg)
3617     {
3618       call_expr_arg_iterator iter;
3619       tree arg;
3620       FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
3621 	{
3622 	  tree type = TREE_TYPE (arg);
3623 	  if (type && TREE_CODE (type) == COMPLEX_TYPE
3624 	      && targetm.calls.split_complex_arg (type))
3625 	    num_complex_actuals++;
3626 	}
3627       type_arg_types = split_complex_types (TYPE_ARG_TYPES (funtype));
3628     }
3629   else
3630     type_arg_types = TYPE_ARG_TYPES (funtype);
3631 
3632   if (flags & ECF_MAY_BE_ALLOCA)
3633     cfun->calls_alloca = 1;
3634 
3635   /* If struct_value_rtx is 0, it means pass the address
3636      as if it were an extra parameter.  Put the argument expression
3637      in structure_value_addr_value.  */
3638   if (structure_value_addr && struct_value == 0)
3639     {
3640       /* If structure_value_addr is a REG other than
3641 	 virtual_outgoing_args_rtx, we can use always use it.  If it
3642 	 is not a REG, we must always copy it into a register.
3643 	 If it is virtual_outgoing_args_rtx, we must copy it to another
3644 	 register in some cases.  */
3645       rtx temp = (!REG_P (structure_value_addr)
3646 		  || (ACCUMULATE_OUTGOING_ARGS
3647 		      && stack_arg_under_construction
3648 		      && structure_value_addr == virtual_outgoing_args_rtx)
3649 		  ? copy_addr_to_reg (convert_memory_address
3650 				      (Pmode, structure_value_addr))
3651 		  : structure_value_addr);
3652 
3653       structure_value_addr_value =
3654 	make_tree (build_pointer_type (TREE_TYPE (funtype)), temp);
3655       structure_value_addr_parm = CALL_WITH_BOUNDS_P (exp) ? 2 : 1;
3656     }
3657 
3658   /* Count the arguments and set NUM_ACTUALS.  */
3659   num_actuals =
3660     call_expr_nargs (exp) + num_complex_actuals + structure_value_addr_parm;
3661 
3662   /* Compute number of named args.
3663      First, do a raw count of the args for INIT_CUMULATIVE_ARGS.  */
3664 
3665   if (type_arg_types != 0)
3666     n_named_args
3667       = (list_length (type_arg_types)
3668 	 /* Count the struct value address, if it is passed as a parm.  */
3669 	 + structure_value_addr_parm);
3670   else
3671     /* If we know nothing, treat all args as named.  */
3672     n_named_args = num_actuals;
3673 
3674   /* Start updating where the next arg would go.
3675 
3676      On some machines (such as the PA) indirect calls have a different
3677      calling convention than normal calls.  The fourth argument in
3678      INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
3679      or not.  */
3680   INIT_CUMULATIVE_ARGS (args_so_far_v, funtype, NULL_RTX, fndecl, n_named_args);
3681   args_so_far = pack_cumulative_args (&args_so_far_v);
3682 
3683   /* Now possibly adjust the number of named args.
3684      Normally, don't include the last named arg if anonymous args follow.
3685      We do include the last named arg if
3686      targetm.calls.strict_argument_naming() returns nonzero.
3687      (If no anonymous args follow, the result of list_length is actually
3688      one too large.  This is harmless.)
3689 
3690      If targetm.calls.pretend_outgoing_varargs_named() returns
3691      nonzero, and targetm.calls.strict_argument_naming() returns zero,
3692      this machine will be able to place unnamed args that were passed
3693      in registers into the stack.  So treat all args as named.  This
3694      allows the insns emitting for a specific argument list to be
3695      independent of the function declaration.
3696 
3697      If targetm.calls.pretend_outgoing_varargs_named() returns zero,
3698      we do not have any reliable way to pass unnamed args in
3699      registers, so we must force them into memory.  */
3700 
3701   if (type_arg_types != 0
3702       && targetm.calls.strict_argument_naming (args_so_far))
3703     ;
3704   else if (type_arg_types != 0
3705 	   && ! targetm.calls.pretend_outgoing_varargs_named (args_so_far))
3706     /* Don't include the last named arg.  */
3707     --n_named_args;
3708   else
3709     /* Treat all args as named.  */
3710     n_named_args = num_actuals;
3711 
3712   /* Make a vector to hold all the information about each arg.  */
3713   args = XCNEWVEC (struct arg_data, num_actuals);
3714 
3715   /* Build up entries in the ARGS array, compute the size of the
3716      arguments into ARGS_SIZE, etc.  */
3717   initialize_argument_information (num_actuals, args, &args_size,
3718 				   n_named_args, exp,
3719 				   structure_value_addr_value, fndecl, fntype,
3720 				   args_so_far, reg_parm_stack_space,
3721 				   &old_stack_level, &old_pending_adj,
3722 				   &must_preallocate, &flags,
3723 				   &try_tail_call, CALL_FROM_THUNK_P (exp));
3724 
3725   if (args_size.var)
3726     must_preallocate = 1;
3727 
3728   /* Now make final decision about preallocating stack space.  */
3729   must_preallocate = finalize_must_preallocate (must_preallocate,
3730 						num_actuals, args,
3731 						&args_size);
3732 
3733   /* If the structure value address will reference the stack pointer, we
3734      must stabilize it.  We don't need to do this if we know that we are
3735      not going to adjust the stack pointer in processing this call.  */
3736 
3737   if (structure_value_addr
3738       && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
3739 	  || reg_mentioned_p (virtual_outgoing_args_rtx,
3740 			      structure_value_addr))
3741       && (args_size.var
3742 	  || (!ACCUMULATE_OUTGOING_ARGS
3743 	      && maybe_ne (args_size.constant, 0))))
3744     structure_value_addr = copy_to_reg (structure_value_addr);
3745 
3746   /* Tail calls can make things harder to debug, and we've traditionally
3747      pushed these optimizations into -O2.  Don't try if we're already
3748      expanding a call, as that means we're an argument.  Don't try if
3749      there's cleanups, as we know there's code to follow the call.  */
3750 
3751   if (currently_expanding_call++ != 0
3752       || !flag_optimize_sibling_calls
3753       || args_size.var
3754       || dbg_cnt (tail_call) == false)
3755     try_tail_call = 0;
3756 
3757   /* If the user has marked the function as requiring tail-call
3758      optimization, attempt it.  */
3759   if (must_tail_call)
3760     try_tail_call = 1;
3761 
3762   /*  Rest of purposes for tail call optimizations to fail.  */
3763   if (try_tail_call)
3764     try_tail_call = can_implement_as_sibling_call_p (exp,
3765 						     structure_value_addr,
3766 						     funtype,
3767 						     reg_parm_stack_space,
3768 						     fndecl,
3769 						     flags, addr, args_size);
3770 
3771   /* Check if caller and callee disagree in promotion of function
3772      return value.  */
3773   if (try_tail_call)
3774     {
3775       machine_mode caller_mode, caller_promoted_mode;
3776       machine_mode callee_mode, callee_promoted_mode;
3777       int caller_unsignedp, callee_unsignedp;
3778       tree caller_res = DECL_RESULT (current_function_decl);
3779 
3780       caller_unsignedp = TYPE_UNSIGNED (TREE_TYPE (caller_res));
3781       caller_mode = DECL_MODE (caller_res);
3782       callee_unsignedp = TYPE_UNSIGNED (TREE_TYPE (funtype));
3783       callee_mode = TYPE_MODE (TREE_TYPE (funtype));
3784       caller_promoted_mode
3785 	= promote_function_mode (TREE_TYPE (caller_res), caller_mode,
3786 				 &caller_unsignedp,
3787 				 TREE_TYPE (current_function_decl), 1);
3788       callee_promoted_mode
3789 	= promote_function_mode (TREE_TYPE (funtype), callee_mode,
3790 				 &callee_unsignedp,
3791 				 funtype, 1);
3792       if (caller_mode != VOIDmode
3793 	  && (caller_promoted_mode != callee_promoted_mode
3794 	      || ((caller_mode != caller_promoted_mode
3795 		   || callee_mode != callee_promoted_mode)
3796 		  && (caller_unsignedp != callee_unsignedp
3797 		      || partial_subreg_p (caller_mode, callee_mode)))))
3798 	{
3799 	  try_tail_call = 0;
3800 	  maybe_complain_about_tail_call (exp,
3801 					  "caller and callee disagree in"
3802 					  " promotion of function"
3803 					  " return value");
3804 	}
3805     }
3806 
3807   /* Ensure current function's preferred stack boundary is at least
3808      what we need.  Stack alignment may also increase preferred stack
3809      boundary.  */
3810   if (crtl->preferred_stack_boundary < preferred_stack_boundary)
3811     crtl->preferred_stack_boundary = preferred_stack_boundary;
3812   else
3813     preferred_stack_boundary = crtl->preferred_stack_boundary;
3814 
3815   preferred_unit_stack_boundary = preferred_stack_boundary / BITS_PER_UNIT;
3816 
3817   /* We want to make two insn chains; one for a sibling call, the other
3818      for a normal call.  We will select one of the two chains after
3819      initial RTL generation is complete.  */
3820   for (pass = try_tail_call ? 0 : 1; pass < 2; pass++)
3821     {
3822       int sibcall_failure = 0;
3823       /* We want to emit any pending stack adjustments before the tail
3824 	 recursion "call".  That way we know any adjustment after the tail
3825 	 recursion call can be ignored if we indeed use the tail
3826 	 call expansion.  */
3827       saved_pending_stack_adjust save;
3828       rtx_insn *insns, *before_call, *after_args;
3829       rtx next_arg_reg;
3830 
3831       if (pass == 0)
3832 	{
3833 	  /* State variables we need to save and restore between
3834 	     iterations.  */
3835 	  save_pending_stack_adjust (&save);
3836 	}
3837       if (pass)
3838 	flags &= ~ECF_SIBCALL;
3839       else
3840 	flags |= ECF_SIBCALL;
3841 
3842       /* Other state variables that we must reinitialize each time
3843 	 through the loop (that are not initialized by the loop itself).  */
3844       argblock = 0;
3845       call_fusage = 0;
3846 
3847       /* Start a new sequence for the normal call case.
3848 
3849 	 From this point on, if the sibling call fails, we want to set
3850 	 sibcall_failure instead of continuing the loop.  */
3851       start_sequence ();
3852 
3853       /* Don't let pending stack adjusts add up to too much.
3854 	 Also, do all pending adjustments now if there is any chance
3855 	 this might be a call to alloca or if we are expanding a sibling
3856 	 call sequence.
3857 	 Also do the adjustments before a throwing call, otherwise
3858 	 exception handling can fail; PR 19225. */
3859       if (maybe_ge (pending_stack_adjust, 32)
3860 	  || (maybe_ne (pending_stack_adjust, 0)
3861 	      && (flags & ECF_MAY_BE_ALLOCA))
3862 	  || (maybe_ne (pending_stack_adjust, 0)
3863 	      && flag_exceptions && !(flags & ECF_NOTHROW))
3864 	  || pass == 0)
3865 	do_pending_stack_adjust ();
3866 
3867       /* Precompute any arguments as needed.  */
3868       if (pass)
3869 	precompute_arguments (num_actuals, args);
3870 
3871       /* Now we are about to start emitting insns that can be deleted
3872 	 if a libcall is deleted.  */
3873       if (pass && (flags & ECF_MALLOC))
3874 	start_sequence ();
3875 
3876       if (pass == 0
3877 	  && crtl->stack_protect_guard
3878 	  && targetm.stack_protect_runtime_enabled_p ())
3879 	stack_protect_epilogue ();
3880 
3881       adjusted_args_size = args_size;
3882       /* Compute the actual size of the argument block required.  The variable
3883 	 and constant sizes must be combined, the size may have to be rounded,
3884 	 and there may be a minimum required size.  When generating a sibcall
3885 	 pattern, do not round up, since we'll be re-using whatever space our
3886 	 caller provided.  */
3887       unadjusted_args_size
3888 	= compute_argument_block_size (reg_parm_stack_space,
3889 				       &adjusted_args_size,
3890 				       fndecl, fntype,
3891 				       (pass == 0 ? 0
3892 					: preferred_stack_boundary));
3893 
3894       old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
3895 
3896       /* The argument block when performing a sibling call is the
3897 	 incoming argument block.  */
3898       if (pass == 0)
3899 	{
3900 	  argblock = crtl->args.internal_arg_pointer;
3901 	  if (STACK_GROWS_DOWNWARD)
3902 	    argblock
3903 	      = plus_constant (Pmode, argblock, crtl->args.pretend_args_size);
3904 	  else
3905 	    argblock
3906 	      = plus_constant (Pmode, argblock, -crtl->args.pretend_args_size);
3907 
3908 	  HOST_WIDE_INT map_size = constant_lower_bound (args_size.constant);
3909 	  stored_args_map = sbitmap_alloc (map_size);
3910 	  bitmap_clear (stored_args_map);
3911 	  stored_args_watermark = HOST_WIDE_INT_M1U;
3912 	}
3913 
3914       /* If we have no actual push instructions, or shouldn't use them,
3915 	 make space for all args right now.  */
3916       else if (adjusted_args_size.var != 0)
3917 	{
3918 	  if (old_stack_level == 0)
3919 	    {
3920 	      emit_stack_save (SAVE_BLOCK, &old_stack_level);
3921 	      old_stack_pointer_delta = stack_pointer_delta;
3922 	      old_pending_adj = pending_stack_adjust;
3923 	      pending_stack_adjust = 0;
3924 	      /* stack_arg_under_construction says whether a stack arg is
3925 		 being constructed at the old stack level.  Pushing the stack
3926 		 gets a clean outgoing argument block.  */
3927 	      old_stack_arg_under_construction = stack_arg_under_construction;
3928 	      stack_arg_under_construction = 0;
3929 	    }
3930 	  argblock = push_block (ARGS_SIZE_RTX (adjusted_args_size), 0, 0);
3931 	  if (flag_stack_usage_info)
3932 	    current_function_has_unbounded_dynamic_stack_size = 1;
3933 	}
3934       else
3935 	{
3936 	  /* Note that we must go through the motions of allocating an argument
3937 	     block even if the size is zero because we may be storing args
3938 	     in the area reserved for register arguments, which may be part of
3939 	     the stack frame.  */
3940 
3941 	  poly_int64 needed = adjusted_args_size.constant;
3942 
3943 	  /* Store the maximum argument space used.  It will be pushed by
3944 	     the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
3945 	     checking).  */
3946 
3947 	  crtl->outgoing_args_size = upper_bound (crtl->outgoing_args_size,
3948 						  needed);
3949 
3950 	  if (must_preallocate)
3951 	    {
3952 	      if (ACCUMULATE_OUTGOING_ARGS)
3953 		{
3954 		  /* Since the stack pointer will never be pushed, it is
3955 		     possible for the evaluation of a parm to clobber
3956 		     something we have already written to the stack.
3957 		     Since most function calls on RISC machines do not use
3958 		     the stack, this is uncommon, but must work correctly.
3959 
3960 		     Therefore, we save any area of the stack that was already
3961 		     written and that we are using.  Here we set up to do this
3962 		     by making a new stack usage map from the old one.  The
3963 		     actual save will be done by store_one_arg.
3964 
3965 		     Another approach might be to try to reorder the argument
3966 		     evaluations to avoid this conflicting stack usage.  */
3967 
3968 		  /* Since we will be writing into the entire argument area,
3969 		     the map must be allocated for its entire size, not just
3970 		     the part that is the responsibility of the caller.  */
3971 		  if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
3972 		    needed += reg_parm_stack_space;
3973 
3974 		  poly_int64 limit = needed;
3975 		  if (ARGS_GROW_DOWNWARD)
3976 		    limit += 1;
3977 
3978 		  /* For polynomial sizes, this is the maximum possible
3979 		     size needed for arguments with a constant size
3980 		     and offset.  */
3981 		  HOST_WIDE_INT const_limit = constant_lower_bound (limit);
3982 		  highest_outgoing_arg_in_use
3983 		    = MAX (initial_highest_arg_in_use, const_limit);
3984 
3985 		  free (stack_usage_map_buf);
3986 		  stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
3987 		  stack_usage_map = stack_usage_map_buf;
3988 
3989 		  if (initial_highest_arg_in_use)
3990 		    memcpy (stack_usage_map, initial_stack_usage_map,
3991 			    initial_highest_arg_in_use);
3992 
3993 		  if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
3994 		    memset (&stack_usage_map[initial_highest_arg_in_use], 0,
3995 			   (highest_outgoing_arg_in_use
3996 			    - initial_highest_arg_in_use));
3997 		  needed = 0;
3998 
3999 		  /* The address of the outgoing argument list must not be
4000 		     copied to a register here, because argblock would be left
4001 		     pointing to the wrong place after the call to
4002 		     allocate_dynamic_stack_space below.  */
4003 
4004 		  argblock = virtual_outgoing_args_rtx;
4005 		}
4006 	      else
4007 		{
4008 		  /* Try to reuse some or all of the pending_stack_adjust
4009 		     to get this space.  */
4010 		  if (inhibit_defer_pop == 0
4011 		      && (combine_pending_stack_adjustment_and_call
4012 			  (&needed,
4013 			   unadjusted_args_size,
4014 			   &adjusted_args_size,
4015 			   preferred_unit_stack_boundary)))
4016 		    {
4017 		      /* combine_pending_stack_adjustment_and_call computes
4018 			 an adjustment before the arguments are allocated.
4019 			 Account for them and see whether or not the stack
4020 			 needs to go up or down.  */
4021 		      needed = unadjusted_args_size - needed;
4022 
4023 		      /* Checked by
4024 			 combine_pending_stack_adjustment_and_call.  */
4025 		      gcc_checking_assert (ordered_p (needed, 0));
4026 		      if (maybe_lt (needed, 0))
4027 			{
4028 			  /* We're releasing stack space.  */
4029 			  /* ??? We can avoid any adjustment at all if we're
4030 			     already aligned.  FIXME.  */
4031 			  pending_stack_adjust = -needed;
4032 			  do_pending_stack_adjust ();
4033 			  needed = 0;
4034 			}
4035 		      else
4036 			/* We need to allocate space.  We'll do that in
4037 			   push_block below.  */
4038 			pending_stack_adjust = 0;
4039 		    }
4040 
4041 		  /* Special case this because overhead of `push_block' in
4042 		     this case is non-trivial.  */
4043 		  if (known_eq (needed, 0))
4044 		    argblock = virtual_outgoing_args_rtx;
4045 		  else
4046 		    {
4047 		      rtx needed_rtx = gen_int_mode (needed, Pmode);
4048 		      argblock = push_block (needed_rtx, 0, 0);
4049 		      if (ARGS_GROW_DOWNWARD)
4050 			argblock = plus_constant (Pmode, argblock, needed);
4051 		    }
4052 
4053 		  /* We only really need to call `copy_to_reg' in the case
4054 		     where push insns are going to be used to pass ARGBLOCK
4055 		     to a function call in ARGS.  In that case, the stack
4056 		     pointer changes value from the allocation point to the
4057 		     call point, and hence the value of
4058 		     VIRTUAL_OUTGOING_ARGS_RTX changes as well.  But might
4059 		     as well always do it.  */
4060 		  argblock = copy_to_reg (argblock);
4061 		}
4062 	    }
4063 	}
4064 
4065       if (ACCUMULATE_OUTGOING_ARGS)
4066 	{
4067 	  /* The save/restore code in store_one_arg handles all
4068 	     cases except one: a constructor call (including a C
4069 	     function returning a BLKmode struct) to initialize
4070 	     an argument.  */
4071 	  if (stack_arg_under_construction)
4072 	    {
4073 	      rtx push_size
4074 		= (gen_int_mode
4075 		   (adjusted_args_size.constant
4076 		    + (OUTGOING_REG_PARM_STACK_SPACE (!fndecl ? fntype
4077 						      : TREE_TYPE (fndecl))
4078 		       ? 0 : reg_parm_stack_space), Pmode));
4079 	      if (old_stack_level == 0)
4080 		{
4081 		  emit_stack_save (SAVE_BLOCK, &old_stack_level);
4082 		  old_stack_pointer_delta = stack_pointer_delta;
4083 		  old_pending_adj = pending_stack_adjust;
4084 		  pending_stack_adjust = 0;
4085 		  /* stack_arg_under_construction says whether a stack
4086 		     arg is being constructed at the old stack level.
4087 		     Pushing the stack gets a clean outgoing argument
4088 		     block.  */
4089 		  old_stack_arg_under_construction
4090 		    = stack_arg_under_construction;
4091 		  stack_arg_under_construction = 0;
4092 		  /* Make a new map for the new argument list.  */
4093 		  free (stack_usage_map_buf);
4094 		  stack_usage_map_buf = XCNEWVEC (char, highest_outgoing_arg_in_use);
4095 		  stack_usage_map = stack_usage_map_buf;
4096 		  highest_outgoing_arg_in_use = 0;
4097 		  stack_usage_watermark = HOST_WIDE_INT_M1U;
4098 		}
4099 	      /* We can pass TRUE as the 4th argument because we just
4100 		 saved the stack pointer and will restore it right after
4101 		 the call.  */
4102 	      allocate_dynamic_stack_space (push_size, 0, BIGGEST_ALIGNMENT,
4103 					    -1, true);
4104 	    }
4105 
4106 	  /* If argument evaluation might modify the stack pointer,
4107 	     copy the address of the argument list to a register.  */
4108 	  for (i = 0; i < num_actuals; i++)
4109 	    if (args[i].pass_on_stack)
4110 	      {
4111 		argblock = copy_addr_to_reg (argblock);
4112 		break;
4113 	      }
4114 	}
4115 
4116       compute_argument_addresses (args, argblock, num_actuals);
4117 
4118       /* Stack is properly aligned, pops can't safely be deferred during
4119 	 the evaluation of the arguments.  */
4120       NO_DEFER_POP;
4121 
4122       /* Precompute all register parameters.  It isn't safe to compute
4123 	 anything once we have started filling any specific hard regs.
4124 	 TLS symbols sometimes need a call to resolve.  Precompute
4125 	 register parameters before any stack pointer manipulation
4126 	 to avoid unaligned stack in the called function.  */
4127       precompute_register_parameters (num_actuals, args, &reg_parm_seen);
4128 
4129       OK_DEFER_POP;
4130 
4131       /* Perform stack alignment before the first push (the last arg).  */
4132       if (argblock == 0
4133 	  && maybe_gt (adjusted_args_size.constant, reg_parm_stack_space)
4134 	  && maybe_ne (adjusted_args_size.constant, unadjusted_args_size))
4135 	{
4136 	  /* When the stack adjustment is pending, we get better code
4137 	     by combining the adjustments.  */
4138 	  if (maybe_ne (pending_stack_adjust, 0)
4139 	      && ! inhibit_defer_pop
4140 	      && (combine_pending_stack_adjustment_and_call
4141 		  (&pending_stack_adjust,
4142 		   unadjusted_args_size,
4143 		   &adjusted_args_size,
4144 		   preferred_unit_stack_boundary)))
4145 	    do_pending_stack_adjust ();
4146 	  else if (argblock == 0)
4147 	    anti_adjust_stack (gen_int_mode (adjusted_args_size.constant
4148 					     - unadjusted_args_size,
4149 					     Pmode));
4150 	}
4151       /* Now that the stack is properly aligned, pops can't safely
4152 	 be deferred during the evaluation of the arguments.  */
4153       NO_DEFER_POP;
4154 
4155       /* Record the maximum pushed stack space size.  We need to delay
4156 	 doing it this far to take into account the optimization done
4157 	 by combine_pending_stack_adjustment_and_call.  */
4158       if (flag_stack_usage_info
4159 	  && !ACCUMULATE_OUTGOING_ARGS
4160 	  && pass
4161 	  && adjusted_args_size.var == 0)
4162 	{
4163 	  poly_int64 pushed = (adjusted_args_size.constant
4164 			       + pending_stack_adjust);
4165 	  current_function_pushed_stack_size
4166 	    = upper_bound (current_function_pushed_stack_size, pushed);
4167 	}
4168 
4169       funexp = rtx_for_function_call (fndecl, addr);
4170 
4171       if (CALL_EXPR_STATIC_CHAIN (exp))
4172 	static_chain_value = expand_normal (CALL_EXPR_STATIC_CHAIN (exp));
4173       else
4174 	static_chain_value = 0;
4175 
4176 #ifdef REG_PARM_STACK_SPACE
4177       /* Save the fixed argument area if it's part of the caller's frame and
4178 	 is clobbered by argument setup for this call.  */
4179       if (ACCUMULATE_OUTGOING_ARGS && pass)
4180 	save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
4181 					      &low_to_save, &high_to_save);
4182 #endif
4183 
4184       /* Now store (and compute if necessary) all non-register parms.
4185 	 These come before register parms, since they can require block-moves,
4186 	 which could clobber the registers used for register parms.
4187 	 Parms which have partial registers are not stored here,
4188 	 but we do preallocate space here if they want that.  */
4189 
4190       for (i = 0; i < num_actuals; i++)
4191 	{
4192 	  /* Delay bounds until all other args are stored.  */
4193 	  if (POINTER_BOUNDS_P (args[i].tree_value))
4194 	    continue;
4195 	  else if (args[i].reg == 0 || args[i].pass_on_stack)
4196 	    {
4197 	      rtx_insn *before_arg = get_last_insn ();
4198 
4199 	      /* We don't allow passing huge (> 2^30 B) arguments
4200 	         by value.  It would cause an overflow later on.  */
4201 	      if (constant_lower_bound (adjusted_args_size.constant)
4202 		  >= (1 << (HOST_BITS_PER_INT - 2)))
4203 	        {
4204 	          sorry ("passing too large argument on stack");
4205 		  continue;
4206 		}
4207 
4208 	      if (store_one_arg (&args[i], argblock, flags,
4209 				 adjusted_args_size.var != 0,
4210 				 reg_parm_stack_space)
4211 		  || (pass == 0
4212 		      && check_sibcall_argument_overlap (before_arg,
4213 							 &args[i], 1)))
4214 		sibcall_failure = 1;
4215 	      }
4216 
4217 	  if (args[i].stack)
4218 	    call_fusage
4219 	      = gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args[i].tree_value)),
4220 				   gen_rtx_USE (VOIDmode, args[i].stack),
4221 				   call_fusage);
4222 	}
4223 
4224       /* If we have a parm that is passed in registers but not in memory
4225 	 and whose alignment does not permit a direct copy into registers,
4226 	 make a group of pseudos that correspond to each register that we
4227 	 will later fill.  */
4228       if (STRICT_ALIGNMENT)
4229 	store_unaligned_arguments_into_pseudos (args, num_actuals);
4230 
4231       /* Now store any partially-in-registers parm.
4232 	 This is the last place a block-move can happen.  */
4233       if (reg_parm_seen)
4234 	for (i = 0; i < num_actuals; i++)
4235 	  if (args[i].partial != 0 && ! args[i].pass_on_stack)
4236 	    {
4237 	      rtx_insn *before_arg = get_last_insn ();
4238 
4239 	     /* On targets with weird calling conventions (e.g. PA) it's
4240 		hard to ensure that all cases of argument overlap between
4241 		stack and registers work.  Play it safe and bail out.  */
4242 	      if (ARGS_GROW_DOWNWARD && !STACK_GROWS_DOWNWARD)
4243 		{
4244 		  sibcall_failure = 1;
4245 		  break;
4246 		}
4247 
4248 	      if (store_one_arg (&args[i], argblock, flags,
4249 				 adjusted_args_size.var != 0,
4250 				 reg_parm_stack_space)
4251 		  || (pass == 0
4252 		      && check_sibcall_argument_overlap (before_arg,
4253 							 &args[i], 1)))
4254 		sibcall_failure = 1;
4255 	    }
4256 
4257       bool any_regs = false;
4258       for (i = 0; i < num_actuals; i++)
4259 	if (args[i].reg != NULL_RTX)
4260 	  {
4261 	    any_regs = true;
4262 	    targetm.calls.call_args (args[i].reg, funtype);
4263 	  }
4264       if (!any_regs)
4265 	targetm.calls.call_args (pc_rtx, funtype);
4266 
4267       /* Figure out the register where the value, if any, will come back.  */
4268       valreg = 0;
4269       valbnd = 0;
4270       if (TYPE_MODE (rettype) != VOIDmode
4271 	  && ! structure_value_addr)
4272 	{
4273 	  if (pcc_struct_value)
4274 	    {
4275 	      valreg = hard_function_value (build_pointer_type (rettype),
4276 					    fndecl, NULL, (pass == 0));
4277 	      if (CALL_WITH_BOUNDS_P (exp))
4278 		valbnd = targetm.calls.
4279 		  chkp_function_value_bounds (build_pointer_type (rettype),
4280 					      fndecl, (pass == 0));
4281 	    }
4282 	  else
4283 	    {
4284 	      valreg = hard_function_value (rettype, fndecl, fntype,
4285 					    (pass == 0));
4286 	      if (CALL_WITH_BOUNDS_P (exp))
4287 		valbnd = targetm.calls.chkp_function_value_bounds (rettype,
4288 								   fndecl,
4289 								   (pass == 0));
4290 	    }
4291 
4292 	  /* If VALREG is a PARALLEL whose first member has a zero
4293 	     offset, use that.  This is for targets such as m68k that
4294 	     return the same value in multiple places.  */
4295 	  if (GET_CODE (valreg) == PARALLEL)
4296 	    {
4297 	      rtx elem = XVECEXP (valreg, 0, 0);
4298 	      rtx where = XEXP (elem, 0);
4299 	      rtx offset = XEXP (elem, 1);
4300 	      if (offset == const0_rtx
4301 		  && GET_MODE (where) == GET_MODE (valreg))
4302 		valreg = where;
4303 	    }
4304 	}
4305 
4306       /* Store all bounds not passed in registers.  */
4307       for (i = 0; i < num_actuals; i++)
4308 	{
4309 	  if (POINTER_BOUNDS_P (args[i].tree_value)
4310 	      && !args[i].reg)
4311 	    store_bounds (&args[i],
4312 			  args[i].pointer_arg == -1
4313 			  ? NULL
4314 			  : &args[args[i].pointer_arg]);
4315 	}
4316 
4317       /* If register arguments require space on the stack and stack space
4318 	 was not preallocated, allocate stack space here for arguments
4319 	 passed in registers.  */
4320       if (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))
4321           && !ACCUMULATE_OUTGOING_ARGS
4322 	  && must_preallocate == 0 && reg_parm_stack_space > 0)
4323 	anti_adjust_stack (GEN_INT (reg_parm_stack_space));
4324 
4325       /* Pass the function the address in which to return a
4326 	 structure value.  */
4327       if (pass != 0 && structure_value_addr && ! structure_value_addr_parm)
4328 	{
4329 	  structure_value_addr
4330 	    = convert_memory_address (Pmode, structure_value_addr);
4331 	  emit_move_insn (struct_value,
4332 			  force_reg (Pmode,
4333 				     force_operand (structure_value_addr,
4334 						    NULL_RTX)));
4335 
4336 	  if (REG_P (struct_value))
4337 	    use_reg (&call_fusage, struct_value);
4338 	}
4339 
4340       after_args = get_last_insn ();
4341       funexp = prepare_call_address (fndecl ? fndecl : fntype, funexp,
4342 				     static_chain_value, &call_fusage,
4343 				     reg_parm_seen, flags);
4344 
4345       load_register_parameters (args, num_actuals, &call_fusage, flags,
4346 				pass == 0, &sibcall_failure);
4347 
4348       /* Save a pointer to the last insn before the call, so that we can
4349 	 later safely search backwards to find the CALL_INSN.  */
4350       before_call = get_last_insn ();
4351 
4352       /* Set up next argument register.  For sibling calls on machines
4353 	 with register windows this should be the incoming register.  */
4354       if (pass == 0)
4355 	next_arg_reg = targetm.calls.function_incoming_arg (args_so_far,
4356 							    VOIDmode,
4357 							    void_type_node,
4358 							    true);
4359       else
4360 	next_arg_reg = targetm.calls.function_arg (args_so_far,
4361 						   VOIDmode, void_type_node,
4362 						   true);
4363 
4364       if (pass == 1 && (return_flags & ERF_RETURNS_ARG))
4365 	{
4366 	  int arg_nr = return_flags & ERF_RETURN_ARG_MASK;
4367 	  arg_nr = num_actuals - arg_nr - 1;
4368 	  if (arg_nr >= 0
4369 	      && arg_nr < num_actuals
4370 	      && args[arg_nr].reg
4371 	      && valreg
4372 	      && REG_P (valreg)
4373 	      && GET_MODE (args[arg_nr].reg) == GET_MODE (valreg))
4374 	  call_fusage
4375 	    = gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args[arg_nr].tree_value)),
4376 				 gen_rtx_SET (valreg, args[arg_nr].reg),
4377 				 call_fusage);
4378 	}
4379       /* All arguments and registers used for the call must be set up by
4380 	 now!  */
4381 
4382       /* Stack must be properly aligned now.  */
4383       gcc_assert (!pass
4384 		  || multiple_p (stack_pointer_delta,
4385 				 preferred_unit_stack_boundary));
4386 
4387       /* Generate the actual call instruction.  */
4388       emit_call_1 (funexp, exp, fndecl, funtype, unadjusted_args_size,
4389 		   adjusted_args_size.constant, struct_value_size,
4390 		   next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
4391 		   flags, args_so_far);
4392 
4393       if (flag_ipa_ra)
4394 	{
4395 	  rtx_call_insn *last;
4396 	  rtx datum = NULL_RTX;
4397 	  if (fndecl != NULL_TREE)
4398 	    {
4399 	      datum = XEXP (DECL_RTL (fndecl), 0);
4400 	      gcc_assert (datum != NULL_RTX
4401 			  && GET_CODE (datum) == SYMBOL_REF);
4402 	    }
4403 	  last = last_call_insn ();
4404 	  add_reg_note (last, REG_CALL_DECL, datum);
4405 	}
4406 
4407       /* If the call setup or the call itself overlaps with anything
4408 	 of the argument setup we probably clobbered our call address.
4409 	 In that case we can't do sibcalls.  */
4410       if (pass == 0
4411 	  && check_sibcall_argument_overlap (after_args, 0, 0))
4412 	sibcall_failure = 1;
4413 
4414       /* If a non-BLKmode value is returned at the most significant end
4415 	 of a register, shift the register right by the appropriate amount
4416 	 and update VALREG accordingly.  BLKmode values are handled by the
4417 	 group load/store machinery below.  */
4418       if (!structure_value_addr
4419 	  && !pcc_struct_value
4420 	  && TYPE_MODE (rettype) != VOIDmode
4421 	  && TYPE_MODE (rettype) != BLKmode
4422 	  && REG_P (valreg)
4423 	  && targetm.calls.return_in_msb (rettype))
4424 	{
4425 	  if (shift_return_value (TYPE_MODE (rettype), false, valreg))
4426 	    sibcall_failure = 1;
4427 	  valreg = gen_rtx_REG (TYPE_MODE (rettype), REGNO (valreg));
4428 	}
4429 
4430       if (pass && (flags & ECF_MALLOC))
4431 	{
4432 	  rtx temp = gen_reg_rtx (GET_MODE (valreg));
4433 	  rtx_insn *last, *insns;
4434 
4435 	  /* The return value from a malloc-like function is a pointer.  */
4436 	  if (TREE_CODE (rettype) == POINTER_TYPE)
4437 	    mark_reg_pointer (temp, MALLOC_ABI_ALIGNMENT);
4438 
4439 	  emit_move_insn (temp, valreg);
4440 
4441 	  /* The return value from a malloc-like function can not alias
4442 	     anything else.  */
4443 	  last = get_last_insn ();
4444 	  add_reg_note (last, REG_NOALIAS, temp);
4445 
4446 	  /* Write out the sequence.  */
4447 	  insns = get_insns ();
4448 	  end_sequence ();
4449 	  emit_insn (insns);
4450 	  valreg = temp;
4451 	}
4452 
4453       /* For calls to `setjmp', etc., inform
4454 	 function.c:setjmp_warnings that it should complain if
4455 	 nonvolatile values are live.  For functions that cannot
4456 	 return, inform flow that control does not fall through.  */
4457 
4458       if ((flags & ECF_NORETURN) || pass == 0)
4459 	{
4460 	  /* The barrier must be emitted
4461 	     immediately after the CALL_INSN.  Some ports emit more
4462 	     than just a CALL_INSN above, so we must search for it here.  */
4463 
4464 	  rtx_insn *last = get_last_insn ();
4465 	  while (!CALL_P (last))
4466 	    {
4467 	      last = PREV_INSN (last);
4468 	      /* There was no CALL_INSN?  */
4469 	      gcc_assert (last != before_call);
4470 	    }
4471 
4472 	  emit_barrier_after (last);
4473 
4474 	  /* Stack adjustments after a noreturn call are dead code.
4475 	     However when NO_DEFER_POP is in effect, we must preserve
4476 	     stack_pointer_delta.  */
4477 	  if (inhibit_defer_pop == 0)
4478 	    {
4479 	      stack_pointer_delta = old_stack_allocated;
4480 	      pending_stack_adjust = 0;
4481 	    }
4482 	}
4483 
4484       /* If value type not void, return an rtx for the value.  */
4485 
4486       if (TYPE_MODE (rettype) == VOIDmode
4487 	  || ignore)
4488 	target = const0_rtx;
4489       else if (structure_value_addr)
4490 	{
4491 	  if (target == 0 || !MEM_P (target))
4492 	    {
4493 	      target
4494 		= gen_rtx_MEM (TYPE_MODE (rettype),
4495 			       memory_address (TYPE_MODE (rettype),
4496 					       structure_value_addr));
4497 	      set_mem_attributes (target, rettype, 1);
4498 	    }
4499 	}
4500       else if (pcc_struct_value)
4501 	{
4502 	  /* This is the special C++ case where we need to
4503 	     know what the true target was.  We take care to
4504 	     never use this value more than once in one expression.  */
4505 	  target = gen_rtx_MEM (TYPE_MODE (rettype),
4506 				copy_to_reg (valreg));
4507 	  set_mem_attributes (target, rettype, 1);
4508 	}
4509       /* Handle calls that return values in multiple non-contiguous locations.
4510 	 The Irix 6 ABI has examples of this.  */
4511       else if (GET_CODE (valreg) == PARALLEL)
4512 	{
4513 	  if (target == 0)
4514 	    target = emit_group_move_into_temps (valreg);
4515 	  else if (rtx_equal_p (target, valreg))
4516 	    ;
4517 	  else if (GET_CODE (target) == PARALLEL)
4518 	    /* Handle the result of a emit_group_move_into_temps
4519 	       call in the previous pass.  */
4520 	    emit_group_move (target, valreg);
4521 	  else
4522 	    emit_group_store (target, valreg, rettype,
4523 			      int_size_in_bytes (rettype));
4524 	}
4525       else if (target
4526 	       && GET_MODE (target) == TYPE_MODE (rettype)
4527 	       && GET_MODE (target) == GET_MODE (valreg))
4528 	{
4529 	  bool may_overlap = false;
4530 
4531 	  /* We have to copy a return value in a CLASS_LIKELY_SPILLED hard
4532 	     reg to a plain register.  */
4533 	  if (!REG_P (target) || HARD_REGISTER_P (target))
4534 	    valreg = avoid_likely_spilled_reg (valreg);
4535 
4536 	  /* If TARGET is a MEM in the argument area, and we have
4537 	     saved part of the argument area, then we can't store
4538 	     directly into TARGET as it may get overwritten when we
4539 	     restore the argument save area below.  Don't work too
4540 	     hard though and simply force TARGET to a register if it
4541 	     is a MEM; the optimizer is quite likely to sort it out.  */
4542 	  if (ACCUMULATE_OUTGOING_ARGS && pass && MEM_P (target))
4543 	    for (i = 0; i < num_actuals; i++)
4544 	      if (args[i].save_area)
4545 		{
4546 		  may_overlap = true;
4547 		  break;
4548 		}
4549 
4550 	  if (may_overlap)
4551 	    target = copy_to_reg (valreg);
4552 	  else
4553 	    {
4554 	      /* TARGET and VALREG cannot be equal at this point
4555 		 because the latter would not have
4556 		 REG_FUNCTION_VALUE_P true, while the former would if
4557 		 it were referring to the same register.
4558 
4559 		 If they refer to the same register, this move will be
4560 		 a no-op, except when function inlining is being
4561 		 done.  */
4562 	      emit_move_insn (target, valreg);
4563 
4564 	      /* If we are setting a MEM, this code must be executed.
4565 		 Since it is emitted after the call insn, sibcall
4566 		 optimization cannot be performed in that case.  */
4567 	      if (MEM_P (target))
4568 		sibcall_failure = 1;
4569 	    }
4570 	}
4571       else
4572 	target = copy_to_reg (avoid_likely_spilled_reg (valreg));
4573 
4574       /* If we promoted this return value, make the proper SUBREG.
4575          TARGET might be const0_rtx here, so be careful.  */
4576       if (REG_P (target)
4577 	  && TYPE_MODE (rettype) != BLKmode
4578 	  && GET_MODE (target) != TYPE_MODE (rettype))
4579 	{
4580 	  tree type = rettype;
4581 	  int unsignedp = TYPE_UNSIGNED (type);
4582 	  machine_mode pmode;
4583 
4584 	  /* Ensure we promote as expected, and get the new unsignedness.  */
4585 	  pmode = promote_function_mode (type, TYPE_MODE (type), &unsignedp,
4586 					 funtype, 1);
4587 	  gcc_assert (GET_MODE (target) == pmode);
4588 
4589 	  poly_uint64 offset = subreg_lowpart_offset (TYPE_MODE (type),
4590 						      GET_MODE (target));
4591 	  target = gen_rtx_SUBREG (TYPE_MODE (type), target, offset);
4592 	  SUBREG_PROMOTED_VAR_P (target) = 1;
4593 	  SUBREG_PROMOTED_SET (target, unsignedp);
4594 	}
4595 
4596       /* If size of args is variable or this was a constructor call for a stack
4597 	 argument, restore saved stack-pointer value.  */
4598 
4599       if (old_stack_level)
4600 	{
4601 	  rtx_insn *prev = get_last_insn ();
4602 
4603 	  emit_stack_restore (SAVE_BLOCK, old_stack_level);
4604 	  stack_pointer_delta = old_stack_pointer_delta;
4605 
4606 	  fixup_args_size_notes (prev, get_last_insn (), stack_pointer_delta);
4607 
4608 	  pending_stack_adjust = old_pending_adj;
4609 	  old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
4610 	  stack_arg_under_construction = old_stack_arg_under_construction;
4611 	  highest_outgoing_arg_in_use = initial_highest_arg_in_use;
4612 	  stack_usage_map = initial_stack_usage_map;
4613 	  stack_usage_watermark = initial_stack_usage_watermark;
4614 	  sibcall_failure = 1;
4615 	}
4616       else if (ACCUMULATE_OUTGOING_ARGS && pass)
4617 	{
4618 #ifdef REG_PARM_STACK_SPACE
4619 	  if (save_area)
4620 	    restore_fixed_argument_area (save_area, argblock,
4621 					 high_to_save, low_to_save);
4622 #endif
4623 
4624 	  /* If we saved any argument areas, restore them.  */
4625 	  for (i = 0; i < num_actuals; i++)
4626 	    if (args[i].save_area)
4627 	      {
4628 		machine_mode save_mode = GET_MODE (args[i].save_area);
4629 		rtx stack_area
4630 		  = gen_rtx_MEM (save_mode,
4631 				 memory_address (save_mode,
4632 						 XEXP (args[i].stack_slot, 0)));
4633 
4634 		if (save_mode != BLKmode)
4635 		  emit_move_insn (stack_area, args[i].save_area);
4636 		else
4637 		  emit_block_move (stack_area, args[i].save_area,
4638 				   (gen_int_mode
4639 				    (args[i].locate.size.constant, Pmode)),
4640 				   BLOCK_OP_CALL_PARM);
4641 	      }
4642 
4643 	  highest_outgoing_arg_in_use = initial_highest_arg_in_use;
4644 	  stack_usage_map = initial_stack_usage_map;
4645 	  stack_usage_watermark = initial_stack_usage_watermark;
4646 	}
4647 
4648       /* If this was alloca, record the new stack level.  */
4649       if (flags & ECF_MAY_BE_ALLOCA)
4650 	record_new_stack_level ();
4651 
4652       /* Free up storage we no longer need.  */
4653       for (i = 0; i < num_actuals; ++i)
4654 	free (args[i].aligned_regs);
4655 
4656       targetm.calls.end_call_args ();
4657 
4658       insns = get_insns ();
4659       end_sequence ();
4660 
4661       if (pass == 0)
4662 	{
4663 	  tail_call_insns = insns;
4664 
4665 	  /* Restore the pending stack adjustment now that we have
4666 	     finished generating the sibling call sequence.  */
4667 
4668 	  restore_pending_stack_adjust (&save);
4669 
4670 	  /* Prepare arg structure for next iteration.  */
4671 	  for (i = 0; i < num_actuals; i++)
4672 	    {
4673 	      args[i].value = 0;
4674 	      args[i].aligned_regs = 0;
4675 	      args[i].stack = 0;
4676 	    }
4677 
4678 	  sbitmap_free (stored_args_map);
4679 	  internal_arg_pointer_exp_state.scan_start = NULL;
4680 	  internal_arg_pointer_exp_state.cache.release ();
4681 	}
4682       else
4683 	{
4684 	  normal_call_insns = insns;
4685 
4686 	  /* Verify that we've deallocated all the stack we used.  */
4687 	  gcc_assert ((flags & ECF_NORETURN)
4688 		      || known_eq (old_stack_allocated,
4689 				   stack_pointer_delta
4690 				   - pending_stack_adjust));
4691 	}
4692 
4693       /* If something prevents making this a sibling call,
4694 	 zero out the sequence.  */
4695       if (sibcall_failure)
4696 	tail_call_insns = NULL;
4697       else
4698 	break;
4699     }
4700 
4701   /* If tail call production succeeded, we need to remove REG_EQUIV notes on
4702      arguments too, as argument area is now clobbered by the call.  */
4703   if (tail_call_insns)
4704     {
4705       emit_insn (tail_call_insns);
4706       crtl->tail_call_emit = true;
4707     }
4708   else
4709     {
4710       emit_insn (normal_call_insns);
4711       if (try_tail_call)
4712 	/* Ideally we'd emit a message for all of the ways that it could
4713 	   have failed.  */
4714 	maybe_complain_about_tail_call (exp, "tail call production failed");
4715     }
4716 
4717   currently_expanding_call--;
4718 
4719   free (stack_usage_map_buf);
4720   free (args);
4721 
4722   /* Join result with returned bounds so caller may use them if needed.  */
4723   target = chkp_join_splitted_slot (target, valbnd);
4724 
4725   return target;
4726 }
4727 
4728 /* A sibling call sequence invalidates any REG_EQUIV notes made for
4729    this function's incoming arguments.
4730 
4731    At the start of RTL generation we know the only REG_EQUIV notes
4732    in the rtl chain are those for incoming arguments, so we can look
4733    for REG_EQUIV notes between the start of the function and the
4734    NOTE_INSN_FUNCTION_BEG.
4735 
4736    This is (slight) overkill.  We could keep track of the highest
4737    argument we clobber and be more selective in removing notes, but it
4738    does not seem to be worth the effort.  */
4739 
4740 void
fixup_tail_calls(void)4741 fixup_tail_calls (void)
4742 {
4743   rtx_insn *insn;
4744 
4745   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4746     {
4747       rtx note;
4748 
4749       /* There are never REG_EQUIV notes for the incoming arguments
4750 	 after the NOTE_INSN_FUNCTION_BEG note, so stop if we see it.  */
4751       if (NOTE_P (insn)
4752 	  && NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG)
4753 	break;
4754 
4755       note = find_reg_note (insn, REG_EQUIV, 0);
4756       if (note)
4757 	remove_note (insn, note);
4758       note = find_reg_note (insn, REG_EQUIV, 0);
4759       gcc_assert (!note);
4760     }
4761 }
4762 
4763 /* Traverse a list of TYPES and expand all complex types into their
4764    components.  */
4765 static tree
split_complex_types(tree types)4766 split_complex_types (tree types)
4767 {
4768   tree p;
4769 
4770   /* Before allocating memory, check for the common case of no complex.  */
4771   for (p = types; p; p = TREE_CHAIN (p))
4772     {
4773       tree type = TREE_VALUE (p);
4774       if (TREE_CODE (type) == COMPLEX_TYPE
4775 	  && targetm.calls.split_complex_arg (type))
4776 	goto found;
4777     }
4778   return types;
4779 
4780  found:
4781   types = copy_list (types);
4782 
4783   for (p = types; p; p = TREE_CHAIN (p))
4784     {
4785       tree complex_type = TREE_VALUE (p);
4786 
4787       if (TREE_CODE (complex_type) == COMPLEX_TYPE
4788 	  && targetm.calls.split_complex_arg (complex_type))
4789 	{
4790 	  tree next, imag;
4791 
4792 	  /* Rewrite complex type with component type.  */
4793 	  TREE_VALUE (p) = TREE_TYPE (complex_type);
4794 	  next = TREE_CHAIN (p);
4795 
4796 	  /* Add another component type for the imaginary part.  */
4797 	  imag = build_tree_list (NULL_TREE, TREE_VALUE (p));
4798 	  TREE_CHAIN (p) = imag;
4799 	  TREE_CHAIN (imag) = next;
4800 
4801 	  /* Skip the newly created node.  */
4802 	  p = TREE_CHAIN (p);
4803 	}
4804     }
4805 
4806   return types;
4807 }
4808 
4809 /* Output a library call to function ORGFUN (a SYMBOL_REF rtx)
4810    for a value of mode OUTMODE,
4811    with NARGS different arguments, passed as ARGS.
4812    Store the return value if RETVAL is nonzero: store it in VALUE if
4813    VALUE is nonnull, otherwise pick a convenient location.  In either
4814    case return the location of the stored value.
4815 
4816    FN_TYPE should be LCT_NORMAL for `normal' calls, LCT_CONST for
4817    `const' calls, LCT_PURE for `pure' calls, or another LCT_ value for
4818    other types of library calls.  */
4819 
4820 rtx
emit_library_call_value_1(int retval,rtx orgfun,rtx value,enum libcall_type fn_type,machine_mode outmode,int nargs,rtx_mode_t * args)4821 emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
4822 			   enum libcall_type fn_type,
4823 			   machine_mode outmode, int nargs, rtx_mode_t *args)
4824 {
4825   /* Total size in bytes of all the stack-parms scanned so far.  */
4826   struct args_size args_size;
4827   /* Size of arguments before any adjustments (such as rounding).  */
4828   struct args_size original_args_size;
4829   int argnum;
4830   rtx fun;
4831   /* Todo, choose the correct decl type of orgfun. Sadly this information
4832      isn't present here, so we default to native calling abi here.  */
4833   tree fndecl ATTRIBUTE_UNUSED = NULL_TREE; /* library calls default to host calling abi ? */
4834   tree fntype ATTRIBUTE_UNUSED = NULL_TREE; /* library calls default to host calling abi ? */
4835   int count;
4836   rtx argblock = 0;
4837   CUMULATIVE_ARGS args_so_far_v;
4838   cumulative_args_t args_so_far;
4839   struct arg
4840   {
4841     rtx value;
4842     machine_mode mode;
4843     rtx reg;
4844     int partial;
4845     struct locate_and_pad_arg_data locate;
4846     rtx save_area;
4847   };
4848   struct arg *argvec;
4849   int old_inhibit_defer_pop = inhibit_defer_pop;
4850   rtx call_fusage = 0;
4851   rtx mem_value = 0;
4852   rtx valreg;
4853   int pcc_struct_value = 0;
4854   poly_int64 struct_value_size = 0;
4855   int flags;
4856   int reg_parm_stack_space = 0;
4857   poly_int64 needed;
4858   rtx_insn *before_call;
4859   bool have_push_fusage;
4860   tree tfom;			/* type_for_mode (outmode, 0) */
4861 
4862 #ifdef REG_PARM_STACK_SPACE
4863   /* Define the boundary of the register parm stack space that needs to be
4864      save, if any.  */
4865   int low_to_save = 0, high_to_save = 0;
4866   rtx save_area = 0;            /* Place that it is saved.  */
4867 #endif
4868 
4869   /* Size of the stack reserved for parameter registers.  */
4870   unsigned int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
4871   char *initial_stack_usage_map = stack_usage_map;
4872   unsigned HOST_WIDE_INT initial_stack_usage_watermark = stack_usage_watermark;
4873   char *stack_usage_map_buf = NULL;
4874 
4875   rtx struct_value = targetm.calls.struct_value_rtx (0, 0);
4876 
4877 #ifdef REG_PARM_STACK_SPACE
4878   reg_parm_stack_space = REG_PARM_STACK_SPACE ((tree) 0);
4879 #endif
4880 
4881   /* By default, library functions cannot throw.  */
4882   flags = ECF_NOTHROW;
4883 
4884   switch (fn_type)
4885     {
4886     case LCT_NORMAL:
4887       break;
4888     case LCT_CONST:
4889       flags |= ECF_CONST;
4890       break;
4891     case LCT_PURE:
4892       flags |= ECF_PURE;
4893       break;
4894     case LCT_NORETURN:
4895       flags |= ECF_NORETURN;
4896       break;
4897     case LCT_THROW:
4898       flags &= ~ECF_NOTHROW;
4899       break;
4900     case LCT_RETURNS_TWICE:
4901       flags = ECF_RETURNS_TWICE;
4902       break;
4903     }
4904   fun = orgfun;
4905 
4906   /* Ensure current function's preferred stack boundary is at least
4907      what we need.  */
4908   if (crtl->preferred_stack_boundary < PREFERRED_STACK_BOUNDARY)
4909     crtl->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
4910 
4911   /* If this kind of value comes back in memory,
4912      decide where in memory it should come back.  */
4913   if (outmode != VOIDmode)
4914     {
4915       tfom = lang_hooks.types.type_for_mode (outmode, 0);
4916       if (aggregate_value_p (tfom, 0))
4917 	{
4918 #ifdef PCC_STATIC_STRUCT_RETURN
4919 	  rtx pointer_reg
4920 	    = hard_function_value (build_pointer_type (tfom), 0, 0, 0);
4921 	  mem_value = gen_rtx_MEM (outmode, pointer_reg);
4922 	  pcc_struct_value = 1;
4923 	  if (value == 0)
4924 	    value = gen_reg_rtx (outmode);
4925 #else /* not PCC_STATIC_STRUCT_RETURN */
4926 	  struct_value_size = GET_MODE_SIZE (outmode);
4927 	  if (value != 0 && MEM_P (value))
4928 	    mem_value = value;
4929 	  else
4930 	    mem_value = assign_temp (tfom, 1, 1);
4931 #endif
4932 	  /* This call returns a big structure.  */
4933 	  flags &= ~(ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
4934 	}
4935     }
4936   else
4937     tfom = void_type_node;
4938 
4939   /* ??? Unfinished: must pass the memory address as an argument.  */
4940 
4941   /* Copy all the libcall-arguments out of the varargs data
4942      and into a vector ARGVEC.
4943 
4944      Compute how to pass each argument.  We only support a very small subset
4945      of the full argument passing conventions to limit complexity here since
4946      library functions shouldn't have many args.  */
4947 
4948   argvec = XALLOCAVEC (struct arg, nargs + 1);
4949   memset (argvec, 0, (nargs + 1) * sizeof (struct arg));
4950 
4951 #ifdef INIT_CUMULATIVE_LIBCALL_ARGS
4952   INIT_CUMULATIVE_LIBCALL_ARGS (args_so_far_v, outmode, fun);
4953 #else
4954   INIT_CUMULATIVE_ARGS (args_so_far_v, NULL_TREE, fun, 0, nargs);
4955 #endif
4956   args_so_far = pack_cumulative_args (&args_so_far_v);
4957 
4958   args_size.constant = 0;
4959   args_size.var = 0;
4960 
4961   count = 0;
4962 
4963   push_temp_slots ();
4964 
4965   /* If there's a structure value address to be passed,
4966      either pass it in the special place, or pass it as an extra argument.  */
4967   if (mem_value && struct_value == 0 && ! pcc_struct_value)
4968     {
4969       rtx addr = XEXP (mem_value, 0);
4970 
4971       nargs++;
4972 
4973       /* Make sure it is a reasonable operand for a move or push insn.  */
4974       if (!REG_P (addr) && !MEM_P (addr)
4975 	  && !(CONSTANT_P (addr)
4976 	       && targetm.legitimate_constant_p (Pmode, addr)))
4977 	addr = force_operand (addr, NULL_RTX);
4978 
4979       argvec[count].value = addr;
4980       argvec[count].mode = Pmode;
4981       argvec[count].partial = 0;
4982 
4983       argvec[count].reg = targetm.calls.function_arg (args_so_far,
4984 						      Pmode, NULL_TREE, true);
4985       gcc_assert (targetm.calls.arg_partial_bytes (args_so_far, Pmode,
4986 						   NULL_TREE, 1) == 0);
4987 
4988       locate_and_pad_parm (Pmode, NULL_TREE,
4989 #ifdef STACK_PARMS_IN_REG_PARM_AREA
4990 			   1,
4991 #else
4992 			   argvec[count].reg != 0,
4993 #endif
4994 			   reg_parm_stack_space, 0,
4995 			   NULL_TREE, &args_size, &argvec[count].locate);
4996 
4997       if (argvec[count].reg == 0 || argvec[count].partial != 0
4998 	  || reg_parm_stack_space > 0)
4999 	args_size.constant += argvec[count].locate.size.constant;
5000 
5001       targetm.calls.function_arg_advance (args_so_far, Pmode, (tree) 0, true);
5002 
5003       count++;
5004     }
5005 
5006   for (unsigned int i = 0; count < nargs; i++, count++)
5007     {
5008       rtx val = args[i].first;
5009       machine_mode mode = args[i].second;
5010       int unsigned_p = 0;
5011 
5012       /* We cannot convert the arg value to the mode the library wants here;
5013 	 must do it earlier where we know the signedness of the arg.  */
5014       gcc_assert (mode != BLKmode
5015 		  && (GET_MODE (val) == mode || GET_MODE (val) == VOIDmode));
5016 
5017       /* Make sure it is a reasonable operand for a move or push insn.  */
5018       if (!REG_P (val) && !MEM_P (val)
5019 	  && !(CONSTANT_P (val) && targetm.legitimate_constant_p (mode, val)))
5020 	val = force_operand (val, NULL_RTX);
5021 
5022       if (pass_by_reference (&args_so_far_v, mode, NULL_TREE, 1))
5023 	{
5024 	  rtx slot;
5025 	  int must_copy
5026 	    = !reference_callee_copied (&args_so_far_v, mode, NULL_TREE, 1);
5027 
5028 	  /* If this was a CONST function, it is now PURE since it now
5029 	     reads memory.  */
5030 	  if (flags & ECF_CONST)
5031 	    {
5032 	      flags &= ~ECF_CONST;
5033 	      flags |= ECF_PURE;
5034 	    }
5035 
5036 	  if (MEM_P (val) && !must_copy)
5037 	    {
5038 	      tree val_expr = MEM_EXPR (val);
5039 	      if (val_expr)
5040 		mark_addressable (val_expr);
5041 	      slot = val;
5042 	    }
5043 	  else
5044 	    {
5045 	      slot = assign_temp (lang_hooks.types.type_for_mode (mode, 0),
5046 				  1, 1);
5047 	      emit_move_insn (slot, val);
5048 	    }
5049 
5050 	  call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
5051 					   gen_rtx_USE (VOIDmode, slot),
5052 					   call_fusage);
5053 	  if (must_copy)
5054 	    call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
5055 					     gen_rtx_CLOBBER (VOIDmode,
5056 							      slot),
5057 					     call_fusage);
5058 
5059 	  mode = Pmode;
5060 	  val = force_operand (XEXP (slot, 0), NULL_RTX);
5061 	}
5062 
5063       mode = promote_function_mode (NULL_TREE, mode, &unsigned_p, NULL_TREE, 0);
5064       argvec[count].mode = mode;
5065       argvec[count].value = convert_modes (mode, GET_MODE (val), val, unsigned_p);
5066       argvec[count].reg = targetm.calls.function_arg (args_so_far, mode,
5067 						      NULL_TREE, true);
5068 
5069       argvec[count].partial
5070 	= targetm.calls.arg_partial_bytes (args_so_far, mode, NULL_TREE, 1);
5071 
5072       if (argvec[count].reg == 0
5073 	  || argvec[count].partial != 0
5074 	  || reg_parm_stack_space > 0)
5075 	{
5076 	  locate_and_pad_parm (mode, NULL_TREE,
5077 #ifdef STACK_PARMS_IN_REG_PARM_AREA
5078 			       1,
5079 #else
5080 			       argvec[count].reg != 0,
5081 #endif
5082 			       reg_parm_stack_space, argvec[count].partial,
5083 			       NULL_TREE, &args_size, &argvec[count].locate);
5084 	  args_size.constant += argvec[count].locate.size.constant;
5085 	  gcc_assert (!argvec[count].locate.size.var);
5086 	}
5087 #ifdef BLOCK_REG_PADDING
5088       else
5089 	/* The argument is passed entirely in registers.  See at which
5090 	   end it should be padded.  */
5091 	argvec[count].locate.where_pad =
5092 	  BLOCK_REG_PADDING (mode, NULL_TREE,
5093 			     known_le (GET_MODE_SIZE (mode), UNITS_PER_WORD));
5094 #endif
5095 
5096       targetm.calls.function_arg_advance (args_so_far, mode, (tree) 0, true);
5097     }
5098 
5099   /* If this machine requires an external definition for library
5100      functions, write one out.  */
5101   assemble_external_libcall (fun);
5102 
5103   original_args_size = args_size;
5104   args_size.constant = (aligned_upper_bound (args_size.constant
5105 					     + stack_pointer_delta,
5106 					     STACK_BYTES)
5107 			- stack_pointer_delta);
5108 
5109   args_size.constant = upper_bound (args_size.constant,
5110 				    reg_parm_stack_space);
5111 
5112   if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
5113     args_size.constant -= reg_parm_stack_space;
5114 
5115   crtl->outgoing_args_size = upper_bound (crtl->outgoing_args_size,
5116 					  args_size.constant);
5117 
5118   if (flag_stack_usage_info && !ACCUMULATE_OUTGOING_ARGS)
5119     {
5120       poly_int64 pushed = args_size.constant + pending_stack_adjust;
5121       current_function_pushed_stack_size
5122 	= upper_bound (current_function_pushed_stack_size, pushed);
5123     }
5124 
5125   if (ACCUMULATE_OUTGOING_ARGS)
5126     {
5127       /* Since the stack pointer will never be pushed, it is possible for
5128 	 the evaluation of a parm to clobber something we have already
5129 	 written to the stack.  Since most function calls on RISC machines
5130 	 do not use the stack, this is uncommon, but must work correctly.
5131 
5132 	 Therefore, we save any area of the stack that was already written
5133 	 and that we are using.  Here we set up to do this by making a new
5134 	 stack usage map from the old one.
5135 
5136 	 Another approach might be to try to reorder the argument
5137 	 evaluations to avoid this conflicting stack usage.  */
5138 
5139       needed = args_size.constant;
5140 
5141       /* Since we will be writing into the entire argument area, the
5142 	 map must be allocated for its entire size, not just the part that
5143 	 is the responsibility of the caller.  */
5144       if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
5145 	needed += reg_parm_stack_space;
5146 
5147       poly_int64 limit = needed;
5148       if (ARGS_GROW_DOWNWARD)
5149 	limit += 1;
5150 
5151       /* For polynomial sizes, this is the maximum possible size needed
5152 	 for arguments with a constant size and offset.  */
5153       HOST_WIDE_INT const_limit = constant_lower_bound (limit);
5154       highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
5155 					 const_limit);
5156 
5157       stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
5158       stack_usage_map = stack_usage_map_buf;
5159 
5160       if (initial_highest_arg_in_use)
5161 	memcpy (stack_usage_map, initial_stack_usage_map,
5162 		initial_highest_arg_in_use);
5163 
5164       if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
5165 	memset (&stack_usage_map[initial_highest_arg_in_use], 0,
5166 	       highest_outgoing_arg_in_use - initial_highest_arg_in_use);
5167       needed = 0;
5168 
5169       /* We must be careful to use virtual regs before they're instantiated,
5170 	 and real regs afterwards.  Loop optimization, for example, can create
5171 	 new libcalls after we've instantiated the virtual regs, and if we
5172 	 use virtuals anyway, they won't match the rtl patterns.  */
5173 
5174       if (virtuals_instantiated)
5175 	argblock = plus_constant (Pmode, stack_pointer_rtx,
5176 				  STACK_POINTER_OFFSET);
5177       else
5178 	argblock = virtual_outgoing_args_rtx;
5179     }
5180   else
5181     {
5182       if (!PUSH_ARGS)
5183 	argblock = push_block (gen_int_mode (args_size.constant, Pmode), 0, 0);
5184     }
5185 
5186   /* We push args individually in reverse order, perform stack alignment
5187      before the first push (the last arg).  */
5188   if (argblock == 0)
5189     anti_adjust_stack (gen_int_mode (args_size.constant
5190 				     - original_args_size.constant,
5191 				     Pmode));
5192 
5193   argnum = nargs - 1;
5194 
5195 #ifdef REG_PARM_STACK_SPACE
5196   if (ACCUMULATE_OUTGOING_ARGS)
5197     {
5198       /* The argument list is the property of the called routine and it
5199 	 may clobber it.  If the fixed area has been used for previous
5200 	 parameters, we must save and restore it.  */
5201       save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
5202 					    &low_to_save, &high_to_save);
5203     }
5204 #endif
5205 
5206   /* When expanding a normal call, args are stored in push order,
5207      which is the reverse of what we have here.  */
5208   bool any_regs = false;
5209   for (int i = nargs; i-- > 0; )
5210     if (argvec[i].reg != NULL_RTX)
5211       {
5212 	targetm.calls.call_args (argvec[i].reg, NULL_TREE);
5213 	any_regs = true;
5214       }
5215   if (!any_regs)
5216     targetm.calls.call_args (pc_rtx, NULL_TREE);
5217 
5218   /* Push the args that need to be pushed.  */
5219 
5220   have_push_fusage = false;
5221 
5222   /* ARGNUM indexes the ARGVEC array in the order in which the arguments
5223      are to be pushed.  */
5224   for (count = 0; count < nargs; count++, argnum--)
5225     {
5226       machine_mode mode = argvec[argnum].mode;
5227       rtx val = argvec[argnum].value;
5228       rtx reg = argvec[argnum].reg;
5229       int partial = argvec[argnum].partial;
5230       unsigned int parm_align = argvec[argnum].locate.boundary;
5231       poly_int64 lower_bound = 0, upper_bound = 0;
5232 
5233       if (! (reg != 0 && partial == 0))
5234 	{
5235 	  rtx use;
5236 
5237 	  if (ACCUMULATE_OUTGOING_ARGS)
5238 	    {
5239 	      /* If this is being stored into a pre-allocated, fixed-size,
5240 		 stack area, save any previous data at that location.  */
5241 
5242 	      if (ARGS_GROW_DOWNWARD)
5243 		{
5244 		  /* stack_slot is negative, but we want to index stack_usage_map
5245 		     with positive values.  */
5246 		  upper_bound = -argvec[argnum].locate.slot_offset.constant + 1;
5247 		  lower_bound = upper_bound - argvec[argnum].locate.size.constant;
5248 		}
5249 	      else
5250 		{
5251 		  lower_bound = argvec[argnum].locate.slot_offset.constant;
5252 		  upper_bound = lower_bound + argvec[argnum].locate.size.constant;
5253 		}
5254 
5255 	      if (stack_region_maybe_used_p (lower_bound, upper_bound,
5256 					     reg_parm_stack_space))
5257 		{
5258 		  /* We need to make a save area.  */
5259 		  poly_uint64 size
5260 		    = argvec[argnum].locate.size.constant * BITS_PER_UNIT;
5261 		  machine_mode save_mode
5262 		    = int_mode_for_size (size, 1).else_blk ();
5263 		  rtx adr
5264 		    = plus_constant (Pmode, argblock,
5265 				     argvec[argnum].locate.offset.constant);
5266 		  rtx stack_area
5267 		    = gen_rtx_MEM (save_mode, memory_address (save_mode, adr));
5268 
5269 		  if (save_mode == BLKmode)
5270 		    {
5271 		      argvec[argnum].save_area
5272 			= assign_stack_temp (BLKmode,
5273 					     argvec[argnum].locate.size.constant
5274 					     );
5275 
5276 		      emit_block_move (validize_mem
5277 				         (copy_rtx (argvec[argnum].save_area)),
5278 				       stack_area,
5279 				       (gen_int_mode
5280 					(argvec[argnum].locate.size.constant,
5281 					 Pmode)),
5282 				       BLOCK_OP_CALL_PARM);
5283 		    }
5284 		  else
5285 		    {
5286 		      argvec[argnum].save_area = gen_reg_rtx (save_mode);
5287 
5288 		      emit_move_insn (argvec[argnum].save_area, stack_area);
5289 		    }
5290 		}
5291 	    }
5292 
5293 	  emit_push_insn (val, mode, NULL_TREE, NULL_RTX, parm_align,
5294 			  partial, reg, 0, argblock,
5295 			  (gen_int_mode
5296 			   (argvec[argnum].locate.offset.constant, Pmode)),
5297 			  reg_parm_stack_space,
5298 			  ARGS_SIZE_RTX (argvec[argnum].locate.alignment_pad), false);
5299 
5300 	  /* Now mark the segment we just used.  */
5301 	  if (ACCUMULATE_OUTGOING_ARGS)
5302 	    mark_stack_region_used (lower_bound, upper_bound);
5303 
5304 	  NO_DEFER_POP;
5305 
5306 	  /* Indicate argument access so that alias.c knows that these
5307 	     values are live.  */
5308 	  if (argblock)
5309 	    use = plus_constant (Pmode, argblock,
5310 				 argvec[argnum].locate.offset.constant);
5311 	  else if (have_push_fusage)
5312 	    continue;
5313 	  else
5314 	    {
5315 	      /* When arguments are pushed, trying to tell alias.c where
5316 		 exactly this argument is won't work, because the
5317 		 auto-increment causes confusion.  So we merely indicate
5318 		 that we access something with a known mode somewhere on
5319 		 the stack.  */
5320 	      use = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
5321 				  gen_rtx_SCRATCH (Pmode));
5322 	      have_push_fusage = true;
5323 	    }
5324 	  use = gen_rtx_MEM (argvec[argnum].mode, use);
5325 	  use = gen_rtx_USE (VOIDmode, use);
5326 	  call_fusage = gen_rtx_EXPR_LIST (VOIDmode, use, call_fusage);
5327 	}
5328     }
5329 
5330   argnum = nargs - 1;
5331 
5332   fun = prepare_call_address (NULL, fun, NULL, &call_fusage, 0, 0);
5333 
5334   /* Now load any reg parms into their regs.  */
5335 
5336   /* ARGNUM indexes the ARGVEC array in the order in which the arguments
5337      are to be pushed.  */
5338   for (count = 0; count < nargs; count++, argnum--)
5339     {
5340       machine_mode mode = argvec[argnum].mode;
5341       rtx val = argvec[argnum].value;
5342       rtx reg = argvec[argnum].reg;
5343       int partial = argvec[argnum].partial;
5344 
5345       /* Handle calls that pass values in multiple non-contiguous
5346 	 locations.  The PA64 has examples of this for library calls.  */
5347       if (reg != 0 && GET_CODE (reg) == PARALLEL)
5348 	emit_group_load (reg, val, NULL_TREE, GET_MODE_SIZE (mode));
5349       else if (reg != 0 && partial == 0)
5350         {
5351 	  emit_move_insn (reg, val);
5352 #ifdef BLOCK_REG_PADDING
5353 	  poly_int64 size = GET_MODE_SIZE (argvec[argnum].mode);
5354 
5355 	  /* Copied from load_register_parameters.  */
5356 
5357 	  /* Handle case where we have a value that needs shifting
5358 	     up to the msb.  eg. a QImode value and we're padding
5359 	     upward on a BYTES_BIG_ENDIAN machine.  */
5360 	  if (known_lt (size, UNITS_PER_WORD)
5361 	      && (argvec[argnum].locate.where_pad
5362 		  == (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD)))
5363 	    {
5364 	      rtx x;
5365 	      poly_int64 shift = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
5366 
5367 	      /* Assigning REG here rather than a temp makes CALL_FUSAGE
5368 		 report the whole reg as used.  Strictly speaking, the
5369 		 call only uses SIZE bytes at the msb end, but it doesn't
5370 		 seem worth generating rtl to say that.  */
5371 	      reg = gen_rtx_REG (word_mode, REGNO (reg));
5372 	      x = expand_shift (LSHIFT_EXPR, word_mode, reg, shift, reg, 1);
5373 	      if (x != reg)
5374 		emit_move_insn (reg, x);
5375 	    }
5376 #endif
5377 	}
5378 
5379       NO_DEFER_POP;
5380     }
5381 
5382   /* Any regs containing parms remain in use through the call.  */
5383   for (count = 0; count < nargs; count++)
5384     {
5385       rtx reg = argvec[count].reg;
5386       if (reg != 0 && GET_CODE (reg) == PARALLEL)
5387 	use_group_regs (&call_fusage, reg);
5388       else if (reg != 0)
5389         {
5390 	  int partial = argvec[count].partial;
5391 	  if (partial)
5392 	    {
5393 	      int nregs;
5394               gcc_assert (partial % UNITS_PER_WORD == 0);
5395 	      nregs = partial / UNITS_PER_WORD;
5396 	      use_regs (&call_fusage, REGNO (reg), nregs);
5397 	    }
5398 	  else
5399 	    use_reg (&call_fusage, reg);
5400 	}
5401     }
5402 
5403   /* Pass the function the address in which to return a structure value.  */
5404   if (mem_value != 0 && struct_value != 0 && ! pcc_struct_value)
5405     {
5406       emit_move_insn (struct_value,
5407 		      force_reg (Pmode,
5408 				 force_operand (XEXP (mem_value, 0),
5409 						NULL_RTX)));
5410       if (REG_P (struct_value))
5411 	use_reg (&call_fusage, struct_value);
5412     }
5413 
5414   /* Don't allow popping to be deferred, since then
5415      cse'ing of library calls could delete a call and leave the pop.  */
5416   NO_DEFER_POP;
5417   valreg = (mem_value == 0 && outmode != VOIDmode
5418 	    ? hard_libcall_value (outmode, orgfun) : NULL_RTX);
5419 
5420   /* Stack must be properly aligned now.  */
5421   gcc_assert (multiple_p (stack_pointer_delta,
5422 			  PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT));
5423 
5424   before_call = get_last_insn ();
5425 
5426   /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
5427      will set inhibit_defer_pop to that value.  */
5428   /* The return type is needed to decide how many bytes the function pops.
5429      Signedness plays no role in that, so for simplicity, we pretend it's
5430      always signed.  We also assume that the list of arguments passed has
5431      no impact, so we pretend it is unknown.  */
5432 
5433   emit_call_1 (fun, NULL,
5434 	       get_identifier (XSTR (orgfun, 0)),
5435 	       build_function_type (tfom, NULL_TREE),
5436 	       original_args_size.constant, args_size.constant,
5437 	       struct_value_size,
5438 	       targetm.calls.function_arg (args_so_far,
5439 					   VOIDmode, void_type_node, true),
5440 	       valreg,
5441 	       old_inhibit_defer_pop + 1, call_fusage, flags, args_so_far);
5442 
5443   if (flag_ipa_ra)
5444     {
5445       rtx datum = orgfun;
5446       gcc_assert (GET_CODE (datum) == SYMBOL_REF);
5447       rtx_call_insn *last = last_call_insn ();
5448       add_reg_note (last, REG_CALL_DECL, datum);
5449     }
5450 
5451   /* Right-shift returned value if necessary.  */
5452   if (!pcc_struct_value
5453       && TYPE_MODE (tfom) != BLKmode
5454       && targetm.calls.return_in_msb (tfom))
5455     {
5456       shift_return_value (TYPE_MODE (tfom), false, valreg);
5457       valreg = gen_rtx_REG (TYPE_MODE (tfom), REGNO (valreg));
5458     }
5459 
5460   targetm.calls.end_call_args ();
5461 
5462   /* For calls to `setjmp', etc., inform function.c:setjmp_warnings
5463      that it should complain if nonvolatile values are live.  For
5464      functions that cannot return, inform flow that control does not
5465      fall through.  */
5466   if (flags & ECF_NORETURN)
5467     {
5468       /* The barrier note must be emitted
5469 	 immediately after the CALL_INSN.  Some ports emit more than
5470 	 just a CALL_INSN above, so we must search for it here.  */
5471       rtx_insn *last = get_last_insn ();
5472       while (!CALL_P (last))
5473 	{
5474 	  last = PREV_INSN (last);
5475 	  /* There was no CALL_INSN?  */
5476 	  gcc_assert (last != before_call);
5477 	}
5478 
5479       emit_barrier_after (last);
5480     }
5481 
5482   /* Consider that "regular" libcalls, i.e. all of them except for LCT_THROW
5483      and LCT_RETURNS_TWICE, cannot perform non-local gotos.  */
5484   if (flags & ECF_NOTHROW)
5485     {
5486       rtx_insn *last = get_last_insn ();
5487       while (!CALL_P (last))
5488 	{
5489 	  last = PREV_INSN (last);
5490 	  /* There was no CALL_INSN?  */
5491 	  gcc_assert (last != before_call);
5492 	}
5493 
5494       make_reg_eh_region_note_nothrow_nononlocal (last);
5495     }
5496 
5497   /* Now restore inhibit_defer_pop to its actual original value.  */
5498   OK_DEFER_POP;
5499 
5500   pop_temp_slots ();
5501 
5502   /* Copy the value to the right place.  */
5503   if (outmode != VOIDmode && retval)
5504     {
5505       if (mem_value)
5506 	{
5507 	  if (value == 0)
5508 	    value = mem_value;
5509 	  if (value != mem_value)
5510 	    emit_move_insn (value, mem_value);
5511 	}
5512       else if (GET_CODE (valreg) == PARALLEL)
5513 	{
5514 	  if (value == 0)
5515 	    value = gen_reg_rtx (outmode);
5516 	  emit_group_store (value, valreg, NULL_TREE, GET_MODE_SIZE (outmode));
5517 	}
5518       else
5519 	{
5520 	  /* Convert to the proper mode if a promotion has been active.  */
5521 	  if (GET_MODE (valreg) != outmode)
5522 	    {
5523 	      int unsignedp = TYPE_UNSIGNED (tfom);
5524 
5525 	      gcc_assert (promote_function_mode (tfom, outmode, &unsignedp,
5526 						 fndecl ? TREE_TYPE (fndecl) : fntype, 1)
5527 			  == GET_MODE (valreg));
5528 	      valreg = convert_modes (outmode, GET_MODE (valreg), valreg, 0);
5529 	    }
5530 
5531 	  if (value != 0)
5532 	    emit_move_insn (value, valreg);
5533 	  else
5534 	    value = valreg;
5535 	}
5536     }
5537 
5538   if (ACCUMULATE_OUTGOING_ARGS)
5539     {
5540 #ifdef REG_PARM_STACK_SPACE
5541       if (save_area)
5542 	restore_fixed_argument_area (save_area, argblock,
5543 				     high_to_save, low_to_save);
5544 #endif
5545 
5546       /* If we saved any argument areas, restore them.  */
5547       for (count = 0; count < nargs; count++)
5548 	if (argvec[count].save_area)
5549 	  {
5550 	    machine_mode save_mode = GET_MODE (argvec[count].save_area);
5551 	    rtx adr = plus_constant (Pmode, argblock,
5552 				     argvec[count].locate.offset.constant);
5553 	    rtx stack_area = gen_rtx_MEM (save_mode,
5554 					  memory_address (save_mode, adr));
5555 
5556 	    if (save_mode == BLKmode)
5557 	      emit_block_move (stack_area,
5558 			       validize_mem
5559 			         (copy_rtx (argvec[count].save_area)),
5560 			       (gen_int_mode
5561 				(argvec[count].locate.size.constant, Pmode)),
5562 			       BLOCK_OP_CALL_PARM);
5563 	    else
5564 	      emit_move_insn (stack_area, argvec[count].save_area);
5565 	  }
5566 
5567       highest_outgoing_arg_in_use = initial_highest_arg_in_use;
5568       stack_usage_map = initial_stack_usage_map;
5569       stack_usage_watermark = initial_stack_usage_watermark;
5570     }
5571 
5572   free (stack_usage_map_buf);
5573 
5574   return value;
5575 
5576 }
5577 
5578 
5579 /* Store pointer bounds argument ARG  into Bounds Table entry
5580    associated with PARM.  */
5581 static void
store_bounds(struct arg_data * arg,struct arg_data * parm)5582 store_bounds (struct arg_data *arg, struct arg_data *parm)
5583 {
5584   rtx slot = NULL, ptr = NULL, addr = NULL;
5585 
5586   /* We may pass bounds not associated with any pointer.  */
5587   if (!parm)
5588     {
5589       gcc_assert (arg->special_slot);
5590       slot = arg->special_slot;
5591       ptr = const0_rtx;
5592     }
5593   /* Find pointer associated with bounds and where it is
5594      passed.  */
5595   else
5596     {
5597       if (!parm->reg)
5598 	{
5599 	  gcc_assert (!arg->special_slot);
5600 
5601 	  addr = adjust_address (parm->stack, Pmode, arg->pointer_offset);
5602 	}
5603       else if (REG_P (parm->reg))
5604 	{
5605 	  gcc_assert (arg->special_slot);
5606 	  slot = arg->special_slot;
5607 
5608 	  if (MEM_P (parm->value))
5609 	    addr = adjust_address (parm->value, Pmode, arg->pointer_offset);
5610 	  else if (REG_P (parm->value))
5611 	    ptr = gen_rtx_SUBREG (Pmode, parm->value, arg->pointer_offset);
5612 	  else
5613 	    {
5614 	      gcc_assert (!arg->pointer_offset);
5615 	      ptr = parm->value;
5616 	    }
5617 	}
5618       else
5619 	{
5620 	  gcc_assert (GET_CODE (parm->reg) == PARALLEL);
5621 
5622 	  gcc_assert (arg->special_slot);
5623 	  slot = arg->special_slot;
5624 
5625 	  if (parm->parallel_value)
5626 	    ptr = chkp_get_value_with_offs (parm->parallel_value,
5627 					    GEN_INT (arg->pointer_offset));
5628 	  else
5629 	    gcc_unreachable ();
5630 	}
5631     }
5632 
5633   /* Expand bounds.  */
5634   if (!arg->value)
5635     arg->value = expand_normal (arg->tree_value);
5636 
5637   targetm.calls.store_bounds_for_arg (ptr, addr, arg->value, slot);
5638 }
5639 
5640 /* Store a single argument for a function call
5641    into the register or memory area where it must be passed.
5642    *ARG describes the argument value and where to pass it.
5643 
5644    ARGBLOCK is the address of the stack-block for all the arguments,
5645    or 0 on a machine where arguments are pushed individually.
5646 
5647    MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
5648    so must be careful about how the stack is used.
5649 
5650    VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
5651    argument stack.  This is used if ACCUMULATE_OUTGOING_ARGS to indicate
5652    that we need not worry about saving and restoring the stack.
5653 
5654    FNDECL is the declaration of the function we are calling.
5655 
5656    Return nonzero if this arg should cause sibcall failure,
5657    zero otherwise.  */
5658 
5659 static int
store_one_arg(struct arg_data * arg,rtx argblock,int flags,int variable_size ATTRIBUTE_UNUSED,int reg_parm_stack_space)5660 store_one_arg (struct arg_data *arg, rtx argblock, int flags,
5661 	       int variable_size ATTRIBUTE_UNUSED, int reg_parm_stack_space)
5662 {
5663   tree pval = arg->tree_value;
5664   rtx reg = 0;
5665   int partial = 0;
5666   poly_int64 used = 0;
5667   poly_int64 lower_bound = 0, upper_bound = 0;
5668   int sibcall_failure = 0;
5669 
5670   if (TREE_CODE (pval) == ERROR_MARK)
5671     return 1;
5672 
5673   /* Push a new temporary level for any temporaries we make for
5674      this argument.  */
5675   push_temp_slots ();
5676 
5677   if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL))
5678     {
5679       /* If this is being stored into a pre-allocated, fixed-size, stack area,
5680 	 save any previous data at that location.  */
5681       if (argblock && ! variable_size && arg->stack)
5682 	{
5683 	  if (ARGS_GROW_DOWNWARD)
5684 	    {
5685 	      /* stack_slot is negative, but we want to index stack_usage_map
5686 		 with positive values.  */
5687 	      if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
5688 		{
5689 		  rtx offset = XEXP (XEXP (arg->stack_slot, 0), 1);
5690 		  upper_bound = -rtx_to_poly_int64 (offset) + 1;
5691 		}
5692 	      else
5693 		upper_bound = 0;
5694 
5695 	      lower_bound = upper_bound - arg->locate.size.constant;
5696 	    }
5697 	  else
5698 	    {
5699 	      if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
5700 		{
5701 		  rtx offset = XEXP (XEXP (arg->stack_slot, 0), 1);
5702 		  lower_bound = rtx_to_poly_int64 (offset);
5703 		}
5704 	      else
5705 		lower_bound = 0;
5706 
5707 	      upper_bound = lower_bound + arg->locate.size.constant;
5708 	    }
5709 
5710 	  if (stack_region_maybe_used_p (lower_bound, upper_bound,
5711 					 reg_parm_stack_space))
5712 	    {
5713 	      /* We need to make a save area.  */
5714 	      poly_uint64 size = arg->locate.size.constant * BITS_PER_UNIT;
5715 	      machine_mode save_mode
5716 		= int_mode_for_size (size, 1).else_blk ();
5717 	      rtx adr = memory_address (save_mode, XEXP (arg->stack_slot, 0));
5718 	      rtx stack_area = gen_rtx_MEM (save_mode, adr);
5719 
5720 	      if (save_mode == BLKmode)
5721 		{
5722 		  arg->save_area
5723 		    = assign_temp (TREE_TYPE (arg->tree_value), 1, 1);
5724 		  preserve_temp_slots (arg->save_area);
5725 		  emit_block_move (validize_mem (copy_rtx (arg->save_area)),
5726 				   stack_area,
5727 				   (gen_int_mode
5728 				    (arg->locate.size.constant, Pmode)),
5729 				   BLOCK_OP_CALL_PARM);
5730 		}
5731 	      else
5732 		{
5733 		  arg->save_area = gen_reg_rtx (save_mode);
5734 		  emit_move_insn (arg->save_area, stack_area);
5735 		}
5736 	    }
5737 	}
5738     }
5739 
5740   /* If this isn't going to be placed on both the stack and in registers,
5741      set up the register and number of words.  */
5742   if (! arg->pass_on_stack)
5743     {
5744       if (flags & ECF_SIBCALL)
5745 	reg = arg->tail_call_reg;
5746       else
5747 	reg = arg->reg;
5748       partial = arg->partial;
5749     }
5750 
5751   /* Being passed entirely in a register.  We shouldn't be called in
5752      this case.  */
5753   gcc_assert (reg == 0 || partial != 0);
5754 
5755   /* If this arg needs special alignment, don't load the registers
5756      here.  */
5757   if (arg->n_aligned_regs != 0)
5758     reg = 0;
5759 
5760   /* If this is being passed partially in a register, we can't evaluate
5761      it directly into its stack slot.  Otherwise, we can.  */
5762   if (arg->value == 0)
5763     {
5764       /* stack_arg_under_construction is nonzero if a function argument is
5765 	 being evaluated directly into the outgoing argument list and
5766 	 expand_call must take special action to preserve the argument list
5767 	 if it is called recursively.
5768 
5769 	 For scalar function arguments stack_usage_map is sufficient to
5770 	 determine which stack slots must be saved and restored.  Scalar
5771 	 arguments in general have pass_on_stack == 0.
5772 
5773 	 If this argument is initialized by a function which takes the
5774 	 address of the argument (a C++ constructor or a C function
5775 	 returning a BLKmode structure), then stack_usage_map is
5776 	 insufficient and expand_call must push the stack around the
5777 	 function call.  Such arguments have pass_on_stack == 1.
5778 
5779 	 Note that it is always safe to set stack_arg_under_construction,
5780 	 but this generates suboptimal code if set when not needed.  */
5781 
5782       if (arg->pass_on_stack)
5783 	stack_arg_under_construction++;
5784 
5785       arg->value = expand_expr (pval,
5786 				(partial
5787 				 || TYPE_MODE (TREE_TYPE (pval)) != arg->mode)
5788 				? NULL_RTX : arg->stack,
5789 				VOIDmode, EXPAND_STACK_PARM);
5790 
5791       /* If we are promoting object (or for any other reason) the mode
5792 	 doesn't agree, convert the mode.  */
5793 
5794       if (arg->mode != TYPE_MODE (TREE_TYPE (pval)))
5795 	arg->value = convert_modes (arg->mode, TYPE_MODE (TREE_TYPE (pval)),
5796 				    arg->value, arg->unsignedp);
5797 
5798       if (arg->pass_on_stack)
5799 	stack_arg_under_construction--;
5800     }
5801 
5802   /* Check for overlap with already clobbered argument area.  */
5803   if ((flags & ECF_SIBCALL)
5804       && MEM_P (arg->value)
5805       && mem_might_overlap_already_clobbered_arg_p (XEXP (arg->value, 0),
5806 						    arg->locate.size.constant))
5807     sibcall_failure = 1;
5808 
5809   /* Don't allow anything left on stack from computation
5810      of argument to alloca.  */
5811   if (flags & ECF_MAY_BE_ALLOCA)
5812     do_pending_stack_adjust ();
5813 
5814   if (arg->value == arg->stack)
5815     /* If the value is already in the stack slot, we are done.  */
5816     ;
5817   else if (arg->mode != BLKmode)
5818     {
5819       unsigned int parm_align;
5820 
5821       /* Argument is a scalar, not entirely passed in registers.
5822 	 (If part is passed in registers, arg->partial says how much
5823 	 and emit_push_insn will take care of putting it there.)
5824 
5825 	 Push it, and if its size is less than the
5826 	 amount of space allocated to it,
5827 	 also bump stack pointer by the additional space.
5828 	 Note that in C the default argument promotions
5829 	 will prevent such mismatches.  */
5830 
5831       poly_int64 size = (TYPE_EMPTY_P (TREE_TYPE (pval))
5832 			 ? 0 : GET_MODE_SIZE (arg->mode));
5833 
5834       /* Compute how much space the push instruction will push.
5835 	 On many machines, pushing a byte will advance the stack
5836 	 pointer by a halfword.  */
5837 #ifdef PUSH_ROUNDING
5838       size = PUSH_ROUNDING (size);
5839 #endif
5840       used = size;
5841 
5842       /* Compute how much space the argument should get:
5843 	 round up to a multiple of the alignment for arguments.  */
5844       if (targetm.calls.function_arg_padding (arg->mode, TREE_TYPE (pval))
5845 	  != PAD_NONE)
5846 	/* At the moment we don't (need to) support ABIs for which the
5847 	   padding isn't known at compile time.  In principle it should
5848 	   be easy to add though.  */
5849 	used = force_align_up (size, PARM_BOUNDARY / BITS_PER_UNIT);
5850 
5851       /* Compute the alignment of the pushed argument.  */
5852       parm_align = arg->locate.boundary;
5853       if (targetm.calls.function_arg_padding (arg->mode, TREE_TYPE (pval))
5854 	  == PAD_DOWNWARD)
5855 	{
5856 	  poly_int64 pad = used - size;
5857 	  unsigned int pad_align = known_alignment (pad) * BITS_PER_UNIT;
5858 	  if (pad_align != 0)
5859 	    parm_align = MIN (parm_align, pad_align);
5860 	}
5861 
5862       /* This isn't already where we want it on the stack, so put it there.
5863 	 This can either be done with push or copy insns.  */
5864       if (maybe_ne (used, 0)
5865 	  && !emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval),
5866 			      NULL_RTX, parm_align, partial, reg, used - size,
5867 			      argblock, ARGS_SIZE_RTX (arg->locate.offset),
5868 			      reg_parm_stack_space,
5869 			      ARGS_SIZE_RTX (arg->locate.alignment_pad), true))
5870 	sibcall_failure = 1;
5871 
5872       /* Unless this is a partially-in-register argument, the argument is now
5873 	 in the stack.  */
5874       if (partial == 0)
5875 	arg->value = arg->stack;
5876     }
5877   else
5878     {
5879       /* BLKmode, at least partly to be pushed.  */
5880 
5881       unsigned int parm_align;
5882       poly_int64 excess;
5883       rtx size_rtx;
5884 
5885       /* Pushing a nonscalar.
5886 	 If part is passed in registers, PARTIAL says how much
5887 	 and emit_push_insn will take care of putting it there.  */
5888 
5889       /* Round its size up to a multiple
5890 	 of the allocation unit for arguments.  */
5891 
5892       if (arg->locate.size.var != 0)
5893 	{
5894 	  excess = 0;
5895 	  size_rtx = ARGS_SIZE_RTX (arg->locate.size);
5896 	}
5897       else
5898 	{
5899 	  /* PUSH_ROUNDING has no effect on us, because emit_push_insn
5900 	     for BLKmode is careful to avoid it.  */
5901 	  excess = (arg->locate.size.constant
5902 		    - arg_int_size_in_bytes (TREE_TYPE (pval))
5903 		    + partial);
5904 	  size_rtx = expand_expr (arg_size_in_bytes (TREE_TYPE (pval)),
5905 				  NULL_RTX, TYPE_MODE (sizetype),
5906 				  EXPAND_NORMAL);
5907 	}
5908 
5909       parm_align = arg->locate.boundary;
5910 
5911       /* When an argument is padded down, the block is aligned to
5912 	 PARM_BOUNDARY, but the actual argument isn't.  */
5913       if (targetm.calls.function_arg_padding (arg->mode, TREE_TYPE (pval))
5914 	  == PAD_DOWNWARD)
5915 	{
5916 	  if (arg->locate.size.var)
5917 	    parm_align = BITS_PER_UNIT;
5918 	  else
5919 	    {
5920 	      unsigned int excess_align
5921 		= known_alignment (excess) * BITS_PER_UNIT;
5922 	      if (excess_align != 0)
5923 		parm_align = MIN (parm_align, excess_align);
5924 	    }
5925 	}
5926 
5927       if ((flags & ECF_SIBCALL) && MEM_P (arg->value))
5928 	{
5929 	  /* emit_push_insn might not work properly if arg->value and
5930 	     argblock + arg->locate.offset areas overlap.  */
5931 	  rtx x = arg->value;
5932 	  poly_int64 i = 0;
5933 
5934 	  if (XEXP (x, 0) == crtl->args.internal_arg_pointer
5935 	      || (GET_CODE (XEXP (x, 0)) == PLUS
5936 		  && XEXP (XEXP (x, 0), 0) ==
5937 		     crtl->args.internal_arg_pointer
5938 		  && CONST_INT_P (XEXP (XEXP (x, 0), 1))))
5939 	    {
5940 	      if (XEXP (x, 0) != crtl->args.internal_arg_pointer)
5941 		i = rtx_to_poly_int64 (XEXP (XEXP (x, 0), 1));
5942 
5943 	      /* arg.locate doesn't contain the pretend_args_size offset,
5944 		 it's part of argblock.  Ensure we don't count it in I.  */
5945 	      if (STACK_GROWS_DOWNWARD)
5946 		i -= crtl->args.pretend_args_size;
5947 	      else
5948 		i += crtl->args.pretend_args_size;
5949 
5950 	      /* expand_call should ensure this.  */
5951 	      gcc_assert (!arg->locate.offset.var
5952 			  && arg->locate.size.var == 0);
5953 	      poly_int64 size_val = rtx_to_poly_int64 (size_rtx);
5954 
5955 	      if (known_eq (arg->locate.offset.constant, i))
5956 		{
5957 		  /* Even though they appear to be at the same location,
5958 		     if part of the outgoing argument is in registers,
5959 		     they aren't really at the same location.  Check for
5960 		     this by making sure that the incoming size is the
5961 		     same as the outgoing size.  */
5962 		  if (maybe_ne (arg->locate.size.constant, size_val))
5963 		    sibcall_failure = 1;
5964 		}
5965 	      else if (maybe_in_range_p (arg->locate.offset.constant,
5966 					 i, size_val))
5967 		sibcall_failure = 1;
5968 	      /* Use arg->locate.size.constant instead of size_rtx
5969 		 because we only care about the part of the argument
5970 		 on the stack.  */
5971 	      else if (maybe_in_range_p (i, arg->locate.offset.constant,
5972 					 arg->locate.size.constant))
5973 		sibcall_failure = 1;
5974 	    }
5975 	}
5976 
5977       if (!CONST_INT_P (size_rtx) || INTVAL (size_rtx) != 0)
5978 	emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
5979 			parm_align, partial, reg, excess, argblock,
5980 			ARGS_SIZE_RTX (arg->locate.offset),
5981 			reg_parm_stack_space,
5982 			ARGS_SIZE_RTX (arg->locate.alignment_pad), false);
5983 
5984       /* Unless this is a partially-in-register argument, the argument is now
5985 	 in the stack.
5986 
5987 	 ??? Unlike the case above, in which we want the actual
5988 	 address of the data, so that we can load it directly into a
5989 	 register, here we want the address of the stack slot, so that
5990 	 it's properly aligned for word-by-word copying or something
5991 	 like that.  It's not clear that this is always correct.  */
5992       if (partial == 0)
5993 	arg->value = arg->stack_slot;
5994     }
5995 
5996   if (arg->reg && GET_CODE (arg->reg) == PARALLEL)
5997     {
5998       tree type = TREE_TYPE (arg->tree_value);
5999       arg->parallel_value
6000 	= emit_group_load_into_temps (arg->reg, arg->value, type,
6001 				      int_size_in_bytes (type));
6002     }
6003 
6004   /* Mark all slots this store used.  */
6005   if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL)
6006       && argblock && ! variable_size && arg->stack)
6007     mark_stack_region_used (lower_bound, upper_bound);
6008 
6009   /* Once we have pushed something, pops can't safely
6010      be deferred during the rest of the arguments.  */
6011   NO_DEFER_POP;
6012 
6013   /* Free any temporary slots made in processing this argument.  */
6014   pop_temp_slots ();
6015 
6016   return sibcall_failure;
6017 }
6018 
6019 /* Nonzero if we do not know how to pass TYPE solely in registers.  */
6020 
6021 bool
must_pass_in_stack_var_size(machine_mode mode ATTRIBUTE_UNUSED,const_tree type)6022 must_pass_in_stack_var_size (machine_mode mode ATTRIBUTE_UNUSED,
6023 			     const_tree type)
6024 {
6025   if (!type)
6026     return false;
6027 
6028   /* If the type has variable size...  */
6029   if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
6030     return true;
6031 
6032   /* If the type is marked as addressable (it is required
6033      to be constructed into the stack)...  */
6034   if (TREE_ADDRESSABLE (type))
6035     return true;
6036 
6037   return false;
6038 }
6039 
6040 /* Another version of the TARGET_MUST_PASS_IN_STACK hook.  This one
6041    takes trailing padding of a structure into account.  */
6042 /* ??? Should be able to merge these two by examining BLOCK_REG_PADDING.  */
6043 
6044 bool
must_pass_in_stack_var_size_or_pad(machine_mode mode,const_tree type)6045 must_pass_in_stack_var_size_or_pad (machine_mode mode, const_tree type)
6046 {
6047   if (!type)
6048     return false;
6049 
6050   /* If the type has variable size...  */
6051   if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
6052     return true;
6053 
6054   /* If the type is marked as addressable (it is required
6055      to be constructed into the stack)...  */
6056   if (TREE_ADDRESSABLE (type))
6057     return true;
6058 
6059   if (TYPE_EMPTY_P (type))
6060     return false;
6061 
6062   /* If the padding and mode of the type is such that a copy into
6063      a register would put it into the wrong part of the register.  */
6064   if (mode == BLKmode
6065       && int_size_in_bytes (type) % (PARM_BOUNDARY / BITS_PER_UNIT)
6066       && (targetm.calls.function_arg_padding (mode, type)
6067 	  == (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD)))
6068     return true;
6069 
6070   return false;
6071 }
6072 
6073 /* Tell the garbage collector about GTY markers in this source file.  */
6074 #include "gt-calls.h"
6075