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, ®_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