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 (RECORD_OR_UNION_TYPE_P (type) && TYPE_TRANSPARENT_AGGR (type))
2082 type = TREE_TYPE (first_field (type));
2083
2084 /* Decide where to pass this arg.
2085
2086 args[i].reg is nonzero if all or part is passed in registers.
2087
2088 args[i].partial is nonzero if part but not all is passed in registers,
2089 and the exact value says how many bytes are passed in registers.
2090
2091 args[i].pass_on_stack is nonzero if the argument must at least be
2092 computed on the stack. It may then be loaded back into registers
2093 if args[i].reg is nonzero.
2094
2095 These decisions are driven by the FUNCTION_... macros and must agree
2096 with those made by function.c. */
2097
2098 /* See if this argument should be passed by invisible reference. */
2099 if (pass_by_reference (args_so_far_pnt, TYPE_MODE (type),
2100 type, argpos < n_named_args))
2101 {
2102 bool callee_copies;
2103 tree base = NULL_TREE;
2104
2105 callee_copies
2106 = reference_callee_copied (args_so_far_pnt, TYPE_MODE (type),
2107 type, argpos < n_named_args);
2108
2109 /* If we're compiling a thunk, pass through invisible references
2110 instead of making a copy. */
2111 if (call_from_thunk_p
2112 || (callee_copies
2113 && !TREE_ADDRESSABLE (type)
2114 && (base = get_base_address (args[i].tree_value))
2115 && TREE_CODE (base) != SSA_NAME
2116 && (!DECL_P (base) || MEM_P (DECL_RTL (base)))))
2117 {
2118 /* We may have turned the parameter value into an SSA name.
2119 Go back to the original parameter so we can take the
2120 address. */
2121 if (TREE_CODE (args[i].tree_value) == SSA_NAME)
2122 {
2123 gcc_assert (SSA_NAME_IS_DEFAULT_DEF (args[i].tree_value));
2124 args[i].tree_value = SSA_NAME_VAR (args[i].tree_value);
2125 gcc_assert (TREE_CODE (args[i].tree_value) == PARM_DECL);
2126 }
2127 /* Argument setup code may have copied the value to register. We
2128 revert that optimization now because the tail call code must
2129 use the original location. */
2130 if (TREE_CODE (args[i].tree_value) == PARM_DECL
2131 && !MEM_P (DECL_RTL (args[i].tree_value))
2132 && DECL_INCOMING_RTL (args[i].tree_value)
2133 && MEM_P (DECL_INCOMING_RTL (args[i].tree_value)))
2134 set_decl_rtl (args[i].tree_value,
2135 DECL_INCOMING_RTL (args[i].tree_value));
2136
2137 mark_addressable (args[i].tree_value);
2138
2139 /* We can't use sibcalls if a callee-copied argument is
2140 stored in the current function's frame. */
2141 if (!call_from_thunk_p && DECL_P (base) && !TREE_STATIC (base))
2142 {
2143 *may_tailcall = false;
2144 maybe_complain_about_tail_call (exp,
2145 "a callee-copied argument is"
2146 " stored in the current"
2147 " function's frame");
2148 }
2149
2150 args[i].tree_value = build_fold_addr_expr_loc (loc,
2151 args[i].tree_value);
2152 type = TREE_TYPE (args[i].tree_value);
2153
2154 if (*ecf_flags & ECF_CONST)
2155 *ecf_flags &= ~(ECF_CONST | ECF_LOOPING_CONST_OR_PURE);
2156 }
2157 else
2158 {
2159 /* We make a copy of the object and pass the address to the
2160 function being called. */
2161 rtx copy;
2162
2163 if (!COMPLETE_TYPE_P (type)
2164 || TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST
2165 || (flag_stack_check == GENERIC_STACK_CHECK
2166 && compare_tree_int (TYPE_SIZE_UNIT (type),
2167 STACK_CHECK_MAX_VAR_SIZE) > 0))
2168 {
2169 /* This is a variable-sized object. Make space on the stack
2170 for it. */
2171 rtx size_rtx = expr_size (args[i].tree_value);
2172
2173 if (*old_stack_level == 0)
2174 {
2175 emit_stack_save (SAVE_BLOCK, old_stack_level);
2176 *old_pending_adj = pending_stack_adjust;
2177 pending_stack_adjust = 0;
2178 }
2179
2180 /* We can pass TRUE as the 4th argument because we just
2181 saved the stack pointer and will restore it right after
2182 the call. */
2183 copy = allocate_dynamic_stack_space (size_rtx,
2184 TYPE_ALIGN (type),
2185 TYPE_ALIGN (type),
2186 max_int_size_in_bytes
2187 (type),
2188 true);
2189 copy = gen_rtx_MEM (BLKmode, copy);
2190 set_mem_attributes (copy, type, 1);
2191 }
2192 else
2193 copy = assign_temp (type, 1, 0);
2194
2195 store_expr (args[i].tree_value, copy, 0, false, false);
2196
2197 /* Just change the const function to pure and then let
2198 the next test clear the pure based on
2199 callee_copies. */
2200 if (*ecf_flags & ECF_CONST)
2201 {
2202 *ecf_flags &= ~ECF_CONST;
2203 *ecf_flags |= ECF_PURE;
2204 }
2205
2206 if (!callee_copies && *ecf_flags & ECF_PURE)
2207 *ecf_flags &= ~(ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
2208
2209 args[i].tree_value
2210 = build_fold_addr_expr_loc (loc, make_tree (type, copy));
2211 type = TREE_TYPE (args[i].tree_value);
2212 *may_tailcall = false;
2213 maybe_complain_about_tail_call (exp,
2214 "argument must be passed"
2215 " by copying");
2216 }
2217 }
2218
2219 unsignedp = TYPE_UNSIGNED (type);
2220 mode = promote_function_mode (type, TYPE_MODE (type), &unsignedp,
2221 fndecl ? TREE_TYPE (fndecl) : fntype, 0);
2222
2223 args[i].unsignedp = unsignedp;
2224 args[i].mode = mode;
2225
2226 targetm.calls.warn_parameter_passing_abi (args_so_far, type);
2227
2228 args[i].reg = targetm.calls.function_arg (args_so_far, mode, type,
2229 argpos < n_named_args);
2230
2231 if (args[i].reg && CONST_INT_P (args[i].reg))
2232 {
2233 args[i].special_slot = args[i].reg;
2234 args[i].reg = NULL;
2235 }
2236
2237 /* If this is a sibling call and the machine has register windows, the
2238 register window has to be unwinded before calling the routine, so
2239 arguments have to go into the incoming registers. */
2240 if (targetm.calls.function_incoming_arg != targetm.calls.function_arg)
2241 args[i].tail_call_reg
2242 = targetm.calls.function_incoming_arg (args_so_far, mode, type,
2243 argpos < n_named_args);
2244 else
2245 args[i].tail_call_reg = args[i].reg;
2246
2247 if (args[i].reg)
2248 args[i].partial
2249 = targetm.calls.arg_partial_bytes (args_so_far, mode, type,
2250 argpos < n_named_args);
2251
2252 args[i].pass_on_stack = targetm.calls.must_pass_in_stack (mode, type);
2253
2254 /* If FUNCTION_ARG returned a (parallel [(expr_list (nil) ...) ...]),
2255 it means that we are to pass this arg in the register(s) designated
2256 by the PARALLEL, but also to pass it in the stack. */
2257 if (args[i].reg && GET_CODE (args[i].reg) == PARALLEL
2258 && XEXP (XVECEXP (args[i].reg, 0, 0), 0) == 0)
2259 args[i].pass_on_stack = 1;
2260
2261 /* If this is an addressable type, we must preallocate the stack
2262 since we must evaluate the object into its final location.
2263
2264 If this is to be passed in both registers and the stack, it is simpler
2265 to preallocate. */
2266 if (TREE_ADDRESSABLE (type)
2267 || (args[i].pass_on_stack && args[i].reg != 0))
2268 *must_preallocate = 1;
2269
2270 /* No stack allocation and padding for bounds. */
2271 if (POINTER_BOUNDS_P (args[i].tree_value))
2272 ;
2273 /* Compute the stack-size of this argument. */
2274 else if (args[i].reg == 0 || args[i].partial != 0
2275 || reg_parm_stack_space > 0
2276 || args[i].pass_on_stack)
2277 locate_and_pad_parm (mode, type,
2278 #ifdef STACK_PARMS_IN_REG_PARM_AREA
2279 1,
2280 #else
2281 args[i].reg != 0,
2282 #endif
2283 reg_parm_stack_space,
2284 args[i].pass_on_stack ? 0 : args[i].partial,
2285 fndecl, args_size, &args[i].locate);
2286 #ifdef BLOCK_REG_PADDING
2287 else
2288 /* The argument is passed entirely in registers. See at which
2289 end it should be padded. */
2290 args[i].locate.where_pad =
2291 BLOCK_REG_PADDING (mode, type,
2292 int_size_in_bytes (type) <= UNITS_PER_WORD);
2293 #endif
2294
2295 /* Update ARGS_SIZE, the total stack space for args so far. */
2296
2297 args_size->constant += args[i].locate.size.constant;
2298 if (args[i].locate.size.var)
2299 ADD_PARM_SIZE (*args_size, args[i].locate.size.var);
2300
2301 /* Increment ARGS_SO_FAR, which has info about which arg-registers
2302 have been used, etc. */
2303
2304 targetm.calls.function_arg_advance (args_so_far, TYPE_MODE (type),
2305 type, argpos < n_named_args);
2306
2307 /* Store argument values for functions decorated with attribute
2308 alloc_size. */
2309 if (argpos == alloc_idx[0])
2310 alloc_args[0] = args[i].tree_value;
2311 else if (argpos == alloc_idx[1])
2312 alloc_args[1] = args[i].tree_value;
2313 }
2314
2315 if (alloc_args[0])
2316 {
2317 /* Check the arguments of functions decorated with attribute
2318 alloc_size. */
2319 maybe_warn_alloc_args_overflow (fndecl, exp, alloc_args, alloc_idx);
2320 }
2321
2322 /* Detect passing non-string arguments to functions expecting
2323 nul-terminated strings. */
2324 maybe_warn_nonstring_arg (fndecl, exp);
2325 }
2326
2327 /* Update ARGS_SIZE to contain the total size for the argument block.
2328 Return the original constant component of the argument block's size.
2329
2330 REG_PARM_STACK_SPACE holds the number of bytes of stack space reserved
2331 for arguments passed in registers. */
2332
2333 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)2334 compute_argument_block_size (int reg_parm_stack_space,
2335 struct args_size *args_size,
2336 tree fndecl ATTRIBUTE_UNUSED,
2337 tree fntype ATTRIBUTE_UNUSED,
2338 int preferred_stack_boundary ATTRIBUTE_UNUSED)
2339 {
2340 poly_int64 unadjusted_args_size = args_size->constant;
2341
2342 /* For accumulate outgoing args mode we don't need to align, since the frame
2343 will be already aligned. Align to STACK_BOUNDARY in order to prevent
2344 backends from generating misaligned frame sizes. */
2345 if (ACCUMULATE_OUTGOING_ARGS && preferred_stack_boundary > STACK_BOUNDARY)
2346 preferred_stack_boundary = STACK_BOUNDARY;
2347
2348 /* Compute the actual size of the argument block required. The variable
2349 and constant sizes must be combined, the size may have to be rounded,
2350 and there may be a minimum required size. */
2351
2352 if (args_size->var)
2353 {
2354 args_size->var = ARGS_SIZE_TREE (*args_size);
2355 args_size->constant = 0;
2356
2357 preferred_stack_boundary /= BITS_PER_UNIT;
2358 if (preferred_stack_boundary > 1)
2359 {
2360 /* We don't handle this case yet. To handle it correctly we have
2361 to add the delta, round and subtract the delta.
2362 Currently no machine description requires this support. */
2363 gcc_assert (multiple_p (stack_pointer_delta,
2364 preferred_stack_boundary));
2365 args_size->var = round_up (args_size->var, preferred_stack_boundary);
2366 }
2367
2368 if (reg_parm_stack_space > 0)
2369 {
2370 args_size->var
2371 = size_binop (MAX_EXPR, args_size->var,
2372 ssize_int (reg_parm_stack_space));
2373
2374 /* The area corresponding to register parameters is not to count in
2375 the size of the block we need. So make the adjustment. */
2376 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
2377 args_size->var
2378 = size_binop (MINUS_EXPR, args_size->var,
2379 ssize_int (reg_parm_stack_space));
2380 }
2381 }
2382 else
2383 {
2384 preferred_stack_boundary /= BITS_PER_UNIT;
2385 if (preferred_stack_boundary < 1)
2386 preferred_stack_boundary = 1;
2387 args_size->constant = (aligned_upper_bound (args_size->constant
2388 + stack_pointer_delta,
2389 preferred_stack_boundary)
2390 - stack_pointer_delta);
2391
2392 args_size->constant = upper_bound (args_size->constant,
2393 reg_parm_stack_space);
2394
2395 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
2396 args_size->constant -= reg_parm_stack_space;
2397 }
2398 return unadjusted_args_size;
2399 }
2400
2401 /* Precompute parameters as needed for a function call.
2402
2403 FLAGS is mask of ECF_* constants.
2404
2405 NUM_ACTUALS is the number of arguments.
2406
2407 ARGS is an array containing information for each argument; this
2408 routine fills in the INITIAL_VALUE and VALUE fields for each
2409 precomputed argument. */
2410
2411 static void
precompute_arguments(int num_actuals,struct arg_data * args)2412 precompute_arguments (int num_actuals, struct arg_data *args)
2413 {
2414 int i;
2415
2416 /* If this is a libcall, then precompute all arguments so that we do not
2417 get extraneous instructions emitted as part of the libcall sequence. */
2418
2419 /* If we preallocated the stack space, and some arguments must be passed
2420 on the stack, then we must precompute any parameter which contains a
2421 function call which will store arguments on the stack.
2422 Otherwise, evaluating the parameter may clobber previous parameters
2423 which have already been stored into the stack. (we have code to avoid
2424 such case by saving the outgoing stack arguments, but it results in
2425 worse code) */
2426 if (!ACCUMULATE_OUTGOING_ARGS)
2427 return;
2428
2429 for (i = 0; i < num_actuals; i++)
2430 {
2431 tree type;
2432 machine_mode mode;
2433
2434 if (TREE_CODE (args[i].tree_value) != CALL_EXPR)
2435 continue;
2436
2437 /* If this is an addressable type, we cannot pre-evaluate it. */
2438 type = TREE_TYPE (args[i].tree_value);
2439 gcc_assert (!TREE_ADDRESSABLE (type));
2440
2441 args[i].initial_value = args[i].value
2442 = expand_normal (args[i].tree_value);
2443
2444 mode = TYPE_MODE (type);
2445 if (mode != args[i].mode)
2446 {
2447 int unsignedp = args[i].unsignedp;
2448 args[i].value
2449 = convert_modes (args[i].mode, mode,
2450 args[i].value, args[i].unsignedp);
2451
2452 /* CSE will replace this only if it contains args[i].value
2453 pseudo, so convert it down to the declared mode using
2454 a SUBREG. */
2455 if (REG_P (args[i].value)
2456 && GET_MODE_CLASS (args[i].mode) == MODE_INT
2457 && promote_mode (type, mode, &unsignedp) != args[i].mode)
2458 {
2459 args[i].initial_value
2460 = gen_lowpart_SUBREG (mode, args[i].value);
2461 SUBREG_PROMOTED_VAR_P (args[i].initial_value) = 1;
2462 SUBREG_PROMOTED_SET (args[i].initial_value, args[i].unsignedp);
2463 }
2464 }
2465 }
2466 }
2467
2468 /* Given the current state of MUST_PREALLOCATE and information about
2469 arguments to a function call in NUM_ACTUALS, ARGS and ARGS_SIZE,
2470 compute and return the final value for MUST_PREALLOCATE. */
2471
2472 static int
finalize_must_preallocate(int must_preallocate,int num_actuals,struct arg_data * args,struct args_size * args_size)2473 finalize_must_preallocate (int must_preallocate, int num_actuals,
2474 struct arg_data *args, struct args_size *args_size)
2475 {
2476 /* See if we have or want to preallocate stack space.
2477
2478 If we would have to push a partially-in-regs parm
2479 before other stack parms, preallocate stack space instead.
2480
2481 If the size of some parm is not a multiple of the required stack
2482 alignment, we must preallocate.
2483
2484 If the total size of arguments that would otherwise create a copy in
2485 a temporary (such as a CALL) is more than half the total argument list
2486 size, preallocation is faster.
2487
2488 Another reason to preallocate is if we have a machine (like the m88k)
2489 where stack alignment is required to be maintained between every
2490 pair of insns, not just when the call is made. However, we assume here
2491 that such machines either do not have push insns (and hence preallocation
2492 would occur anyway) or the problem is taken care of with
2493 PUSH_ROUNDING. */
2494
2495 if (! must_preallocate)
2496 {
2497 int partial_seen = 0;
2498 poly_int64 copy_to_evaluate_size = 0;
2499 int i;
2500
2501 for (i = 0; i < num_actuals && ! must_preallocate; i++)
2502 {
2503 if (args[i].partial > 0 && ! args[i].pass_on_stack)
2504 partial_seen = 1;
2505 else if (partial_seen && args[i].reg == 0)
2506 must_preallocate = 1;
2507 /* We preallocate in case there are bounds passed
2508 in the bounds table to have precomputed address
2509 for bounds association. */
2510 else if (POINTER_BOUNDS_P (args[i].tree_value)
2511 && !args[i].reg)
2512 must_preallocate = 1;
2513
2514 if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
2515 && (TREE_CODE (args[i].tree_value) == CALL_EXPR
2516 || TREE_CODE (args[i].tree_value) == TARGET_EXPR
2517 || TREE_CODE (args[i].tree_value) == COND_EXPR
2518 || TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value))))
2519 copy_to_evaluate_size
2520 += int_size_in_bytes (TREE_TYPE (args[i].tree_value));
2521 }
2522
2523 if (maybe_ne (args_size->constant, 0)
2524 && maybe_ge (copy_to_evaluate_size * 2, args_size->constant))
2525 must_preallocate = 1;
2526 }
2527 return must_preallocate;
2528 }
2529
2530 /* If we preallocated stack space, compute the address of each argument
2531 and store it into the ARGS array.
2532
2533 We need not ensure it is a valid memory address here; it will be
2534 validized when it is used.
2535
2536 ARGBLOCK is an rtx for the address of the outgoing arguments. */
2537
2538 static void
compute_argument_addresses(struct arg_data * args,rtx argblock,int num_actuals)2539 compute_argument_addresses (struct arg_data *args, rtx argblock, int num_actuals)
2540 {
2541 if (argblock)
2542 {
2543 rtx arg_reg = argblock;
2544 int i;
2545 poly_int64 arg_offset = 0;
2546
2547 if (GET_CODE (argblock) == PLUS)
2548 {
2549 arg_reg = XEXP (argblock, 0);
2550 arg_offset = rtx_to_poly_int64 (XEXP (argblock, 1));
2551 }
2552
2553 for (i = 0; i < num_actuals; i++)
2554 {
2555 rtx offset = ARGS_SIZE_RTX (args[i].locate.offset);
2556 rtx slot_offset = ARGS_SIZE_RTX (args[i].locate.slot_offset);
2557 rtx addr;
2558 unsigned int align, boundary;
2559 poly_uint64 units_on_stack = 0;
2560 machine_mode partial_mode = VOIDmode;
2561
2562 /* Skip this parm if it will not be passed on the stack. */
2563 if (! args[i].pass_on_stack
2564 && args[i].reg != 0
2565 && args[i].partial == 0)
2566 continue;
2567
2568 if (TYPE_EMPTY_P (TREE_TYPE (args[i].tree_value)))
2569 continue;
2570
2571 /* Pointer Bounds are never passed on the stack. */
2572 if (POINTER_BOUNDS_P (args[i].tree_value))
2573 continue;
2574
2575 addr = simplify_gen_binary (PLUS, Pmode, arg_reg, offset);
2576 addr = plus_constant (Pmode, addr, arg_offset);
2577
2578 if (args[i].partial != 0)
2579 {
2580 /* Only part of the parameter is being passed on the stack.
2581 Generate a simple memory reference of the correct size. */
2582 units_on_stack = args[i].locate.size.constant;
2583 poly_uint64 bits_on_stack = units_on_stack * BITS_PER_UNIT;
2584 partial_mode = int_mode_for_size (bits_on_stack, 1).else_blk ();
2585 args[i].stack = gen_rtx_MEM (partial_mode, addr);
2586 set_mem_size (args[i].stack, units_on_stack);
2587 }
2588 else
2589 {
2590 args[i].stack = gen_rtx_MEM (args[i].mode, addr);
2591 set_mem_attributes (args[i].stack,
2592 TREE_TYPE (args[i].tree_value), 1);
2593 }
2594 align = BITS_PER_UNIT;
2595 boundary = args[i].locate.boundary;
2596 poly_int64 offset_val;
2597 if (args[i].locate.where_pad != PAD_DOWNWARD)
2598 align = boundary;
2599 else if (poly_int_rtx_p (offset, &offset_val))
2600 {
2601 align = least_bit_hwi (boundary);
2602 unsigned int offset_align
2603 = known_alignment (offset_val) * BITS_PER_UNIT;
2604 if (offset_align != 0)
2605 align = MIN (align, offset_align);
2606 }
2607 set_mem_align (args[i].stack, align);
2608
2609 addr = simplify_gen_binary (PLUS, Pmode, arg_reg, slot_offset);
2610 addr = plus_constant (Pmode, addr, arg_offset);
2611
2612 if (args[i].partial != 0)
2613 {
2614 /* Only part of the parameter is being passed on the stack.
2615 Generate a simple memory reference of the correct size.
2616 */
2617 args[i].stack_slot = gen_rtx_MEM (partial_mode, addr);
2618 set_mem_size (args[i].stack_slot, units_on_stack);
2619 }
2620 else
2621 {
2622 args[i].stack_slot = gen_rtx_MEM (args[i].mode, addr);
2623 set_mem_attributes (args[i].stack_slot,
2624 TREE_TYPE (args[i].tree_value), 1);
2625 }
2626 set_mem_align (args[i].stack_slot, args[i].locate.boundary);
2627
2628 /* Function incoming arguments may overlap with sibling call
2629 outgoing arguments and we cannot allow reordering of reads
2630 from function arguments with stores to outgoing arguments
2631 of sibling calls. */
2632 set_mem_alias_set (args[i].stack, 0);
2633 set_mem_alias_set (args[i].stack_slot, 0);
2634 }
2635 }
2636 }
2637
2638 /* Given a FNDECL and EXP, return an rtx suitable for use as a target address
2639 in a call instruction.
2640
2641 FNDECL is the tree node for the target function. For an indirect call
2642 FNDECL will be NULL_TREE.
2643
2644 ADDR is the operand 0 of CALL_EXPR for this call. */
2645
2646 static rtx
rtx_for_function_call(tree fndecl,tree addr)2647 rtx_for_function_call (tree fndecl, tree addr)
2648 {
2649 rtx funexp;
2650
2651 /* Get the function to call, in the form of RTL. */
2652 if (fndecl)
2653 {
2654 if (!TREE_USED (fndecl) && fndecl != current_function_decl)
2655 TREE_USED (fndecl) = 1;
2656
2657 /* Get a SYMBOL_REF rtx for the function address. */
2658 funexp = XEXP (DECL_RTL (fndecl), 0);
2659 }
2660 else
2661 /* Generate an rtx (probably a pseudo-register) for the address. */
2662 {
2663 push_temp_slots ();
2664 funexp = expand_normal (addr);
2665 pop_temp_slots (); /* FUNEXP can't be BLKmode. */
2666 }
2667 return funexp;
2668 }
2669
2670 /* Return the static chain for this function, if any. */
2671
2672 rtx
rtx_for_static_chain(const_tree fndecl_or_type,bool incoming_p)2673 rtx_for_static_chain (const_tree fndecl_or_type, bool incoming_p)
2674 {
2675 if (DECL_P (fndecl_or_type) && !DECL_STATIC_CHAIN (fndecl_or_type))
2676 return NULL;
2677
2678 return targetm.calls.static_chain (fndecl_or_type, incoming_p);
2679 }
2680
2681 /* Internal state for internal_arg_pointer_based_exp and its helpers. */
2682 static struct
2683 {
2684 /* Last insn that has been scanned by internal_arg_pointer_based_exp_scan,
2685 or NULL_RTX if none has been scanned yet. */
2686 rtx_insn *scan_start;
2687 /* Vector indexed by REGNO - FIRST_PSEUDO_REGISTER, recording if a pseudo is
2688 based on crtl->args.internal_arg_pointer. The element is NULL_RTX if the
2689 pseudo isn't based on it, a CONST_INT offset if the pseudo is based on it
2690 with fixed offset, or PC if this is with variable or unknown offset. */
2691 vec<rtx> cache;
2692 } internal_arg_pointer_exp_state;
2693
2694 static rtx internal_arg_pointer_based_exp (const_rtx, bool);
2695
2696 /* Helper function for internal_arg_pointer_based_exp. Scan insns in
2697 the tail call sequence, starting with first insn that hasn't been
2698 scanned yet, and note for each pseudo on the LHS whether it is based
2699 on crtl->args.internal_arg_pointer or not, and what offset from that
2700 that pointer it has. */
2701
2702 static void
internal_arg_pointer_based_exp_scan(void)2703 internal_arg_pointer_based_exp_scan (void)
2704 {
2705 rtx_insn *insn, *scan_start = internal_arg_pointer_exp_state.scan_start;
2706
2707 if (scan_start == NULL_RTX)
2708 insn = get_insns ();
2709 else
2710 insn = NEXT_INSN (scan_start);
2711
2712 while (insn)
2713 {
2714 rtx set = single_set (insn);
2715 if (set && REG_P (SET_DEST (set)) && !HARD_REGISTER_P (SET_DEST (set)))
2716 {
2717 rtx val = NULL_RTX;
2718 unsigned int idx = REGNO (SET_DEST (set)) - FIRST_PSEUDO_REGISTER;
2719 /* Punt on pseudos set multiple times. */
2720 if (idx < internal_arg_pointer_exp_state.cache.length ()
2721 && (internal_arg_pointer_exp_state.cache[idx]
2722 != NULL_RTX))
2723 val = pc_rtx;
2724 else
2725 val = internal_arg_pointer_based_exp (SET_SRC (set), false);
2726 if (val != NULL_RTX)
2727 {
2728 if (idx >= internal_arg_pointer_exp_state.cache.length ())
2729 internal_arg_pointer_exp_state.cache
2730 .safe_grow_cleared (idx + 1);
2731 internal_arg_pointer_exp_state.cache[idx] = val;
2732 }
2733 }
2734 if (NEXT_INSN (insn) == NULL_RTX)
2735 scan_start = insn;
2736 insn = NEXT_INSN (insn);
2737 }
2738
2739 internal_arg_pointer_exp_state.scan_start = scan_start;
2740 }
2741
2742 /* Compute whether RTL is based on crtl->args.internal_arg_pointer. Return
2743 NULL_RTX if RTL isn't based on it, a CONST_INT offset if RTL is based on
2744 it with fixed offset, or PC if this is with variable or unknown offset.
2745 TOPLEVEL is true if the function is invoked at the topmost level. */
2746
2747 static rtx
internal_arg_pointer_based_exp(const_rtx rtl,bool toplevel)2748 internal_arg_pointer_based_exp (const_rtx rtl, bool toplevel)
2749 {
2750 if (CONSTANT_P (rtl))
2751 return NULL_RTX;
2752
2753 if (rtl == crtl->args.internal_arg_pointer)
2754 return const0_rtx;
2755
2756 if (REG_P (rtl) && HARD_REGISTER_P (rtl))
2757 return NULL_RTX;
2758
2759 poly_int64 offset;
2760 if (GET_CODE (rtl) == PLUS && poly_int_rtx_p (XEXP (rtl, 1), &offset))
2761 {
2762 rtx val = internal_arg_pointer_based_exp (XEXP (rtl, 0), toplevel);
2763 if (val == NULL_RTX || val == pc_rtx)
2764 return val;
2765 return plus_constant (Pmode, val, offset);
2766 }
2767
2768 /* When called at the topmost level, scan pseudo assignments in between the
2769 last scanned instruction in the tail call sequence and the latest insn
2770 in that sequence. */
2771 if (toplevel)
2772 internal_arg_pointer_based_exp_scan ();
2773
2774 if (REG_P (rtl))
2775 {
2776 unsigned int idx = REGNO (rtl) - FIRST_PSEUDO_REGISTER;
2777 if (idx < internal_arg_pointer_exp_state.cache.length ())
2778 return internal_arg_pointer_exp_state.cache[idx];
2779
2780 return NULL_RTX;
2781 }
2782
2783 subrtx_iterator::array_type array;
2784 FOR_EACH_SUBRTX (iter, array, rtl, NONCONST)
2785 {
2786 const_rtx x = *iter;
2787 if (REG_P (x) && internal_arg_pointer_based_exp (x, false) != NULL_RTX)
2788 return pc_rtx;
2789 if (MEM_P (x))
2790 iter.skip_subrtxes ();
2791 }
2792
2793 return NULL_RTX;
2794 }
2795
2796 /* Return true if SIZE bytes starting from address ADDR might overlap an
2797 already-clobbered argument area. This function is used to determine
2798 if we should give up a sibcall. */
2799
2800 static bool
mem_might_overlap_already_clobbered_arg_p(rtx addr,poly_uint64 size)2801 mem_might_overlap_already_clobbered_arg_p (rtx addr, poly_uint64 size)
2802 {
2803 poly_int64 i;
2804 unsigned HOST_WIDE_INT start, end;
2805 rtx val;
2806
2807 if (bitmap_empty_p (stored_args_map)
2808 && stored_args_watermark == HOST_WIDE_INT_M1U)
2809 return false;
2810 val = internal_arg_pointer_based_exp (addr, true);
2811 if (val == NULL_RTX)
2812 return false;
2813 else if (!poly_int_rtx_p (val, &i))
2814 return true;
2815
2816 if (known_eq (size, 0U))
2817 return false;
2818
2819 if (STACK_GROWS_DOWNWARD)
2820 i -= crtl->args.pretend_args_size;
2821 else
2822 i += crtl->args.pretend_args_size;
2823
2824 if (ARGS_GROW_DOWNWARD)
2825 i = -i - size;
2826
2827 /* We can ignore any references to the function's pretend args,
2828 which at this point would manifest as negative values of I. */
2829 if (known_le (i, 0) && known_le (size, poly_uint64 (-i)))
2830 return false;
2831
2832 start = maybe_lt (i, 0) ? 0 : constant_lower_bound (i);
2833 if (!(i + size).is_constant (&end))
2834 end = HOST_WIDE_INT_M1U;
2835
2836 if (end > stored_args_watermark)
2837 return true;
2838
2839 end = MIN (end, SBITMAP_SIZE (stored_args_map));
2840 for (unsigned HOST_WIDE_INT k = start; k < end; ++k)
2841 if (bitmap_bit_p (stored_args_map, k))
2842 return true;
2843
2844 return false;
2845 }
2846
2847 /* Do the register loads required for any wholly-register parms or any
2848 parms which are passed both on the stack and in a register. Their
2849 expressions were already evaluated.
2850
2851 Mark all register-parms as living through the call, putting these USE
2852 insns in the CALL_INSN_FUNCTION_USAGE field.
2853
2854 When IS_SIBCALL, perform the check_sibcall_argument_overlap
2855 checking, setting *SIBCALL_FAILURE if appropriate. */
2856
2857 static void
load_register_parameters(struct arg_data * args,int num_actuals,rtx * call_fusage,int flags,int is_sibcall,int * sibcall_failure)2858 load_register_parameters (struct arg_data *args, int num_actuals,
2859 rtx *call_fusage, int flags, int is_sibcall,
2860 int *sibcall_failure)
2861 {
2862 int i, j;
2863
2864 for (i = 0; i < num_actuals; i++)
2865 {
2866 rtx reg = ((flags & ECF_SIBCALL)
2867 ? args[i].tail_call_reg : args[i].reg);
2868 if (reg)
2869 {
2870 int partial = args[i].partial;
2871 int nregs;
2872 poly_int64 size = 0;
2873 HOST_WIDE_INT const_size = 0;
2874 rtx_insn *before_arg = get_last_insn ();
2875 tree type = TREE_TYPE (args[i].tree_value);
2876 if (RECORD_OR_UNION_TYPE_P (type) && TYPE_TRANSPARENT_AGGR (type))
2877 type = TREE_TYPE (first_field (type));
2878 /* Set non-negative if we must move a word at a time, even if
2879 just one word (e.g, partial == 4 && mode == DFmode). Set
2880 to -1 if we just use a normal move insn. This value can be
2881 zero if the argument is a zero size structure. */
2882 nregs = -1;
2883 if (GET_CODE (reg) == PARALLEL)
2884 ;
2885 else if (partial)
2886 {
2887 gcc_assert (partial % UNITS_PER_WORD == 0);
2888 nregs = partial / UNITS_PER_WORD;
2889 }
2890 else if (TYPE_MODE (type) == BLKmode)
2891 {
2892 /* Variable-sized parameters should be described by a
2893 PARALLEL instead. */
2894 const_size = int_size_in_bytes (type);
2895 gcc_assert (const_size >= 0);
2896 nregs = (const_size + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
2897 size = const_size;
2898 }
2899 else
2900 size = GET_MODE_SIZE (args[i].mode);
2901
2902 /* Handle calls that pass values in multiple non-contiguous
2903 locations. The Irix 6 ABI has examples of this. */
2904
2905 if (GET_CODE (reg) == PARALLEL)
2906 emit_group_move (reg, args[i].parallel_value);
2907
2908 /* If simple case, just do move. If normal partial, store_one_arg
2909 has already loaded the register for us. In all other cases,
2910 load the register(s) from memory. */
2911
2912 else if (nregs == -1)
2913 {
2914 emit_move_insn (reg, args[i].value);
2915 #ifdef BLOCK_REG_PADDING
2916 /* Handle case where we have a value that needs shifting
2917 up to the msb. eg. a QImode value and we're padding
2918 upward on a BYTES_BIG_ENDIAN machine. */
2919 if (args[i].locate.where_pad
2920 == (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD))
2921 {
2922 gcc_checking_assert (ordered_p (size, UNITS_PER_WORD));
2923 if (maybe_lt (size, UNITS_PER_WORD))
2924 {
2925 rtx x;
2926 poly_int64 shift
2927 = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
2928
2929 /* Assigning REG here rather than a temp makes
2930 CALL_FUSAGE report the whole reg as used.
2931 Strictly speaking, the call only uses SIZE
2932 bytes at the msb end, but it doesn't seem worth
2933 generating rtl to say that. */
2934 reg = gen_rtx_REG (word_mode, REGNO (reg));
2935 x = expand_shift (LSHIFT_EXPR, word_mode,
2936 reg, shift, reg, 1);
2937 if (x != reg)
2938 emit_move_insn (reg, x);
2939 }
2940 }
2941 #endif
2942 }
2943
2944 /* If we have pre-computed the values to put in the registers in
2945 the case of non-aligned structures, copy them in now. */
2946
2947 else if (args[i].n_aligned_regs != 0)
2948 for (j = 0; j < args[i].n_aligned_regs; j++)
2949 emit_move_insn (gen_rtx_REG (word_mode, REGNO (reg) + j),
2950 args[i].aligned_regs[j]);
2951
2952 else if (partial == 0 || args[i].pass_on_stack)
2953 {
2954 /* SIZE and CONST_SIZE are 0 for partial arguments and
2955 the size of a BLKmode type otherwise. */
2956 gcc_checking_assert (known_eq (size, const_size));
2957 rtx mem = validize_mem (copy_rtx (args[i].value));
2958
2959 /* Check for overlap with already clobbered argument area,
2960 providing that this has non-zero size. */
2961 if (is_sibcall
2962 && const_size != 0
2963 && (mem_might_overlap_already_clobbered_arg_p
2964 (XEXP (args[i].value, 0), const_size)))
2965 *sibcall_failure = 1;
2966
2967 if (const_size % UNITS_PER_WORD == 0
2968 || MEM_ALIGN (mem) % BITS_PER_WORD == 0)
2969 move_block_to_reg (REGNO (reg), mem, nregs, args[i].mode);
2970 else
2971 {
2972 if (nregs > 1)
2973 move_block_to_reg (REGNO (reg), mem, nregs - 1,
2974 args[i].mode);
2975 rtx dest = gen_rtx_REG (word_mode, REGNO (reg) + nregs - 1);
2976 unsigned int bitoff = (nregs - 1) * BITS_PER_WORD;
2977 unsigned int bitsize = const_size * BITS_PER_UNIT - bitoff;
2978 rtx x = extract_bit_field (mem, bitsize, bitoff, 1, dest,
2979 word_mode, word_mode, false,
2980 NULL);
2981 if (BYTES_BIG_ENDIAN)
2982 x = expand_shift (LSHIFT_EXPR, word_mode, x,
2983 BITS_PER_WORD - bitsize, dest, 1);
2984 if (x != dest)
2985 emit_move_insn (dest, x);
2986 }
2987
2988 /* Handle a BLKmode that needs shifting. */
2989 if (nregs == 1 && const_size < UNITS_PER_WORD
2990 #ifdef BLOCK_REG_PADDING
2991 && args[i].locate.where_pad == PAD_DOWNWARD
2992 #else
2993 && BYTES_BIG_ENDIAN
2994 #endif
2995 )
2996 {
2997 rtx dest = gen_rtx_REG (word_mode, REGNO (reg));
2998 int shift = (UNITS_PER_WORD - const_size) * BITS_PER_UNIT;
2999 enum tree_code dir = (BYTES_BIG_ENDIAN
3000 ? RSHIFT_EXPR : LSHIFT_EXPR);
3001 rtx x;
3002
3003 x = expand_shift (dir, word_mode, dest, shift, dest, 1);
3004 if (x != dest)
3005 emit_move_insn (dest, x);
3006 }
3007 }
3008
3009 /* When a parameter is a block, and perhaps in other cases, it is
3010 possible that it did a load from an argument slot that was
3011 already clobbered. */
3012 if (is_sibcall
3013 && check_sibcall_argument_overlap (before_arg, &args[i], 0))
3014 *sibcall_failure = 1;
3015
3016 /* Handle calls that pass values in multiple non-contiguous
3017 locations. The Irix 6 ABI has examples of this. */
3018 if (GET_CODE (reg) == PARALLEL)
3019 use_group_regs (call_fusage, reg);
3020 else if (nregs == -1)
3021 use_reg_mode (call_fusage, reg, TYPE_MODE (type));
3022 else if (nregs > 0)
3023 use_regs (call_fusage, REGNO (reg), nregs);
3024 }
3025 }
3026 }
3027
3028 /* We need to pop PENDING_STACK_ADJUST bytes. But, if the arguments
3029 wouldn't fill up an even multiple of PREFERRED_UNIT_STACK_BOUNDARY
3030 bytes, then we would need to push some additional bytes to pad the
3031 arguments. So, we try to compute an adjust to the stack pointer for an
3032 amount that will leave the stack under-aligned by UNADJUSTED_ARGS_SIZE
3033 bytes. Then, when the arguments are pushed the stack will be perfectly
3034 aligned.
3035
3036 Return true if this optimization is possible, storing the adjustment
3037 in ADJUSTMENT_OUT and setting ARGS_SIZE->CONSTANT to the number of
3038 bytes that should be popped after the call. */
3039
3040 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)3041 combine_pending_stack_adjustment_and_call (poly_int64_pod *adjustment_out,
3042 poly_int64 unadjusted_args_size,
3043 struct args_size *args_size,
3044 unsigned int preferred_unit_stack_boundary)
3045 {
3046 /* The number of bytes to pop so that the stack will be
3047 under-aligned by UNADJUSTED_ARGS_SIZE bytes. */
3048 poly_int64 adjustment;
3049 /* The alignment of the stack after the arguments are pushed, if we
3050 just pushed the arguments without adjust the stack here. */
3051 unsigned HOST_WIDE_INT unadjusted_alignment;
3052
3053 if (!known_misalignment (stack_pointer_delta + unadjusted_args_size,
3054 preferred_unit_stack_boundary,
3055 &unadjusted_alignment))
3056 return false;
3057
3058 /* We want to get rid of as many of the PENDING_STACK_ADJUST bytes
3059 as possible -- leaving just enough left to cancel out the
3060 UNADJUSTED_ALIGNMENT. In other words, we want to ensure that the
3061 PENDING_STACK_ADJUST is non-negative, and congruent to
3062 -UNADJUSTED_ALIGNMENT modulo the PREFERRED_UNIT_STACK_BOUNDARY. */
3063
3064 /* Begin by trying to pop all the bytes. */
3065 unsigned HOST_WIDE_INT tmp_misalignment;
3066 if (!known_misalignment (pending_stack_adjust,
3067 preferred_unit_stack_boundary,
3068 &tmp_misalignment))
3069 return false;
3070 unadjusted_alignment -= tmp_misalignment;
3071 adjustment = pending_stack_adjust;
3072 /* Push enough additional bytes that the stack will be aligned
3073 after the arguments are pushed. */
3074 if (preferred_unit_stack_boundary > 1 && unadjusted_alignment)
3075 adjustment -= preferred_unit_stack_boundary - unadjusted_alignment;
3076
3077 /* We need to know whether the adjusted argument size
3078 (UNADJUSTED_ARGS_SIZE - ADJUSTMENT) constitutes an allocation
3079 or a deallocation. */
3080 if (!ordered_p (adjustment, unadjusted_args_size))
3081 return false;
3082
3083 /* Now, sets ARGS_SIZE->CONSTANT so that we pop the right number of
3084 bytes after the call. The right number is the entire
3085 PENDING_STACK_ADJUST less our ADJUSTMENT plus the amount required
3086 by the arguments in the first place. */
3087 args_size->constant
3088 = pending_stack_adjust - adjustment + unadjusted_args_size;
3089
3090 *adjustment_out = adjustment;
3091 return true;
3092 }
3093
3094 /* Scan X expression if it does not dereference any argument slots
3095 we already clobbered by tail call arguments (as noted in stored_args_map
3096 bitmap).
3097 Return nonzero if X expression dereferences such argument slots,
3098 zero otherwise. */
3099
3100 static int
check_sibcall_argument_overlap_1(rtx x)3101 check_sibcall_argument_overlap_1 (rtx x)
3102 {
3103 RTX_CODE code;
3104 int i, j;
3105 const char *fmt;
3106
3107 if (x == NULL_RTX)
3108 return 0;
3109
3110 code = GET_CODE (x);
3111
3112 /* We need not check the operands of the CALL expression itself. */
3113 if (code == CALL)
3114 return 0;
3115
3116 if (code == MEM)
3117 return (mem_might_overlap_already_clobbered_arg_p
3118 (XEXP (x, 0), GET_MODE_SIZE (GET_MODE (x))));
3119
3120 /* Scan all subexpressions. */
3121 fmt = GET_RTX_FORMAT (code);
3122 for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
3123 {
3124 if (*fmt == 'e')
3125 {
3126 if (check_sibcall_argument_overlap_1 (XEXP (x, i)))
3127 return 1;
3128 }
3129 else if (*fmt == 'E')
3130 {
3131 for (j = 0; j < XVECLEN (x, i); j++)
3132 if (check_sibcall_argument_overlap_1 (XVECEXP (x, i, j)))
3133 return 1;
3134 }
3135 }
3136 return 0;
3137 }
3138
3139 /* Scan sequence after INSN if it does not dereference any argument slots
3140 we already clobbered by tail call arguments (as noted in stored_args_map
3141 bitmap). If MARK_STORED_ARGS_MAP, add stack slots for ARG to
3142 stored_args_map bitmap afterwards (when ARG is a register MARK_STORED_ARGS_MAP
3143 should be 0). Return nonzero if sequence after INSN dereferences such argument
3144 slots, zero otherwise. */
3145
3146 static int
check_sibcall_argument_overlap(rtx_insn * insn,struct arg_data * arg,int mark_stored_args_map)3147 check_sibcall_argument_overlap (rtx_insn *insn, struct arg_data *arg,
3148 int mark_stored_args_map)
3149 {
3150 poly_uint64 low, high;
3151 unsigned HOST_WIDE_INT const_low, const_high;
3152
3153 if (insn == NULL_RTX)
3154 insn = get_insns ();
3155 else
3156 insn = NEXT_INSN (insn);
3157
3158 for (; insn; insn = NEXT_INSN (insn))
3159 if (INSN_P (insn)
3160 && check_sibcall_argument_overlap_1 (PATTERN (insn)))
3161 break;
3162
3163 if (mark_stored_args_map)
3164 {
3165 if (ARGS_GROW_DOWNWARD)
3166 low = -arg->locate.slot_offset.constant - arg->locate.size.constant;
3167 else
3168 low = arg->locate.slot_offset.constant;
3169 high = low + arg->locate.size.constant;
3170
3171 const_low = constant_lower_bound (low);
3172 if (high.is_constant (&const_high))
3173 for (unsigned HOST_WIDE_INT i = const_low; i < const_high; ++i)
3174 bitmap_set_bit (stored_args_map, i);
3175 else
3176 stored_args_watermark = MIN (stored_args_watermark, const_low);
3177 }
3178 return insn != NULL_RTX;
3179 }
3180
3181 /* Given that a function returns a value of mode MODE at the most
3182 significant end of hard register VALUE, shift VALUE left or right
3183 as specified by LEFT_P. Return true if some action was needed. */
3184
3185 bool
shift_return_value(machine_mode mode,bool left_p,rtx value)3186 shift_return_value (machine_mode mode, bool left_p, rtx value)
3187 {
3188 gcc_assert (REG_P (value) && HARD_REGISTER_P (value));
3189 machine_mode value_mode = GET_MODE (value);
3190 poly_int64 shift = GET_MODE_BITSIZE (value_mode) - GET_MODE_BITSIZE (mode);
3191
3192 if (known_eq (shift, 0))
3193 return false;
3194
3195 /* Use ashr rather than lshr for right shifts. This is for the benefit
3196 of the MIPS port, which requires SImode values to be sign-extended
3197 when stored in 64-bit registers. */
3198 if (!force_expand_binop (value_mode, left_p ? ashl_optab : ashr_optab,
3199 value, gen_int_shift_amount (value_mode, shift),
3200 value, 1, OPTAB_WIDEN))
3201 gcc_unreachable ();
3202 return true;
3203 }
3204
3205 /* If X is a likely-spilled register value, copy it to a pseudo
3206 register and return that register. Return X otherwise. */
3207
3208 static rtx
avoid_likely_spilled_reg(rtx x)3209 avoid_likely_spilled_reg (rtx x)
3210 {
3211 rtx new_rtx;
3212
3213 if (REG_P (x)
3214 && HARD_REGISTER_P (x)
3215 && targetm.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (x))))
3216 {
3217 /* Make sure that we generate a REG rather than a CONCAT.
3218 Moves into CONCATs can need nontrivial instructions,
3219 and the whole point of this function is to avoid
3220 using the hard register directly in such a situation. */
3221 generating_concat_p = 0;
3222 new_rtx = gen_reg_rtx (GET_MODE (x));
3223 generating_concat_p = 1;
3224 emit_move_insn (new_rtx, x);
3225 return new_rtx;
3226 }
3227 return x;
3228 }
3229
3230 /* Helper function for expand_call.
3231 Return false is EXP is not implementable as a sibling call. */
3232
3233 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)3234 can_implement_as_sibling_call_p (tree exp,
3235 rtx structure_value_addr,
3236 tree funtype,
3237 int reg_parm_stack_space ATTRIBUTE_UNUSED,
3238 tree fndecl,
3239 int flags,
3240 tree addr,
3241 const args_size &args_size)
3242 {
3243 if (!targetm.have_sibcall_epilogue ())
3244 {
3245 maybe_complain_about_tail_call
3246 (exp,
3247 "machine description does not have"
3248 " a sibcall_epilogue instruction pattern");
3249 return false;
3250 }
3251
3252 /* Doing sibling call optimization needs some work, since
3253 structure_value_addr can be allocated on the stack.
3254 It does not seem worth the effort since few optimizable
3255 sibling calls will return a structure. */
3256 if (structure_value_addr != NULL_RTX)
3257 {
3258 maybe_complain_about_tail_call (exp, "callee returns a structure");
3259 return false;
3260 }
3261
3262 #ifdef REG_PARM_STACK_SPACE
3263 /* If outgoing reg parm stack space changes, we can not do sibcall. */
3264 if (OUTGOING_REG_PARM_STACK_SPACE (funtype)
3265 != OUTGOING_REG_PARM_STACK_SPACE (TREE_TYPE (current_function_decl))
3266 || (reg_parm_stack_space != REG_PARM_STACK_SPACE (current_function_decl)))
3267 {
3268 maybe_complain_about_tail_call (exp,
3269 "inconsistent size of stack space"
3270 " allocated for arguments which are"
3271 " passed in registers");
3272 return false;
3273 }
3274 #endif
3275
3276 /* Check whether the target is able to optimize the call
3277 into a sibcall. */
3278 if (!targetm.function_ok_for_sibcall (fndecl, exp))
3279 {
3280 maybe_complain_about_tail_call (exp,
3281 "target is not able to optimize the"
3282 " call into a sibling call");
3283 return false;
3284 }
3285
3286 /* Functions that do not return exactly once may not be sibcall
3287 optimized. */
3288 if (flags & ECF_RETURNS_TWICE)
3289 {
3290 maybe_complain_about_tail_call (exp, "callee returns twice");
3291 return false;
3292 }
3293 if (flags & ECF_NORETURN)
3294 {
3295 maybe_complain_about_tail_call (exp, "callee does not return");
3296 return false;
3297 }
3298
3299 if (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (addr))))
3300 {
3301 maybe_complain_about_tail_call (exp, "volatile function type");
3302 return false;
3303 }
3304
3305 /* If the called function is nested in the current one, it might access
3306 some of the caller's arguments, but could clobber them beforehand if
3307 the argument areas are shared. */
3308 if (fndecl && decl_function_context (fndecl) == current_function_decl)
3309 {
3310 maybe_complain_about_tail_call (exp, "nested function");
3311 return false;
3312 }
3313
3314 /* If this function requires more stack slots than the current
3315 function, we cannot change it into a sibling call.
3316 crtl->args.pretend_args_size is not part of the
3317 stack allocated by our caller. */
3318 if (maybe_gt (args_size.constant,
3319 crtl->args.size - crtl->args.pretend_args_size))
3320 {
3321 maybe_complain_about_tail_call (exp,
3322 "callee required more stack slots"
3323 " than the caller");
3324 return false;
3325 }
3326
3327 /* If the callee pops its own arguments, then it must pop exactly
3328 the same number of arguments as the current function. */
3329 if (maybe_ne (targetm.calls.return_pops_args (fndecl, funtype,
3330 args_size.constant),
3331 targetm.calls.return_pops_args (current_function_decl,
3332 TREE_TYPE
3333 (current_function_decl),
3334 crtl->args.size)))
3335 {
3336 maybe_complain_about_tail_call (exp,
3337 "inconsistent number of"
3338 " popped arguments");
3339 return false;
3340 }
3341
3342 if (!lang_hooks.decls.ok_for_sibcall (fndecl))
3343 {
3344 maybe_complain_about_tail_call (exp, "frontend does not support"
3345 " sibling call");
3346 return false;
3347 }
3348
3349 /* All checks passed. */
3350 return true;
3351 }
3352
3353 /* Generate all the code for a CALL_EXPR exp
3354 and return an rtx for its value.
3355 Store the value in TARGET (specified as an rtx) if convenient.
3356 If the value is stored in TARGET then TARGET is returned.
3357 If IGNORE is nonzero, then we ignore the value of the function call. */
3358
3359 rtx
expand_call(tree exp,rtx target,int ignore)3360 expand_call (tree exp, rtx target, int ignore)
3361 {
3362 /* Nonzero if we are currently expanding a call. */
3363 static int currently_expanding_call = 0;
3364
3365 /* RTX for the function to be called. */
3366 rtx funexp;
3367 /* Sequence of insns to perform a normal "call". */
3368 rtx_insn *normal_call_insns = NULL;
3369 /* Sequence of insns to perform a tail "call". */
3370 rtx_insn *tail_call_insns = NULL;
3371 /* Data type of the function. */
3372 tree funtype;
3373 tree type_arg_types;
3374 tree rettype;
3375 /* Declaration of the function being called,
3376 or 0 if the function is computed (not known by name). */
3377 tree fndecl = 0;
3378 /* The type of the function being called. */
3379 tree fntype;
3380 bool try_tail_call = CALL_EXPR_TAILCALL (exp);
3381 bool must_tail_call = CALL_EXPR_MUST_TAIL_CALL (exp);
3382 int pass;
3383
3384 /* Register in which non-BLKmode value will be returned,
3385 or 0 if no value or if value is BLKmode. */
3386 rtx valreg;
3387 /* Register(s) in which bounds are returned. */
3388 rtx valbnd = NULL;
3389 /* Address where we should return a BLKmode value;
3390 0 if value not BLKmode. */
3391 rtx structure_value_addr = 0;
3392 /* Nonzero if that address is being passed by treating it as
3393 an extra, implicit first parameter. Otherwise,
3394 it is passed by being copied directly into struct_value_rtx. */
3395 int structure_value_addr_parm = 0;
3396 /* Holds the value of implicit argument for the struct value. */
3397 tree structure_value_addr_value = NULL_TREE;
3398 /* Size of aggregate value wanted, or zero if none wanted
3399 or if we are using the non-reentrant PCC calling convention
3400 or expecting the value in registers. */
3401 poly_int64 struct_value_size = 0;
3402 /* Nonzero if called function returns an aggregate in memory PCC style,
3403 by returning the address of where to find it. */
3404 int pcc_struct_value = 0;
3405 rtx struct_value = 0;
3406
3407 /* Number of actual parameters in this call, including struct value addr. */
3408 int num_actuals;
3409 /* Number of named args. Args after this are anonymous ones
3410 and they must all go on the stack. */
3411 int n_named_args;
3412 /* Number of complex actual arguments that need to be split. */
3413 int num_complex_actuals = 0;
3414
3415 /* Vector of information about each argument.
3416 Arguments are numbered in the order they will be pushed,
3417 not the order they are written. */
3418 struct arg_data *args;
3419
3420 /* Total size in bytes of all the stack-parms scanned so far. */
3421 struct args_size args_size;
3422 struct args_size adjusted_args_size;
3423 /* Size of arguments before any adjustments (such as rounding). */
3424 poly_int64 unadjusted_args_size;
3425 /* Data on reg parms scanned so far. */
3426 CUMULATIVE_ARGS args_so_far_v;
3427 cumulative_args_t args_so_far;
3428 /* Nonzero if a reg parm has been scanned. */
3429 int reg_parm_seen;
3430 /* Nonzero if this is an indirect function call. */
3431
3432 /* Nonzero if we must avoid push-insns in the args for this call.
3433 If stack space is allocated for register parameters, but not by the
3434 caller, then it is preallocated in the fixed part of the stack frame.
3435 So the entire argument block must then be preallocated (i.e., we
3436 ignore PUSH_ROUNDING in that case). */
3437
3438 int must_preallocate = !PUSH_ARGS;
3439
3440 /* Size of the stack reserved for parameter registers. */
3441 int reg_parm_stack_space = 0;
3442
3443 /* Address of space preallocated for stack parms
3444 (on machines that lack push insns), or 0 if space not preallocated. */
3445 rtx argblock = 0;
3446
3447 /* Mask of ECF_ and ERF_ flags. */
3448 int flags = 0;
3449 int return_flags = 0;
3450 #ifdef REG_PARM_STACK_SPACE
3451 /* Define the boundary of the register parm stack space that needs to be
3452 saved, if any. */
3453 int low_to_save, high_to_save;
3454 rtx save_area = 0; /* Place that it is saved */
3455 #endif
3456
3457 unsigned int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
3458 char *initial_stack_usage_map = stack_usage_map;
3459 unsigned HOST_WIDE_INT initial_stack_usage_watermark = stack_usage_watermark;
3460 char *stack_usage_map_buf = NULL;
3461
3462 poly_int64 old_stack_allocated;
3463
3464 /* State variables to track stack modifications. */
3465 rtx old_stack_level = 0;
3466 int old_stack_arg_under_construction = 0;
3467 poly_int64 old_pending_adj = 0;
3468 int old_inhibit_defer_pop = inhibit_defer_pop;
3469
3470 /* Some stack pointer alterations we make are performed via
3471 allocate_dynamic_stack_space. This modifies the stack_pointer_delta,
3472 which we then also need to save/restore along the way. */
3473 poly_int64 old_stack_pointer_delta = 0;
3474
3475 rtx call_fusage;
3476 tree addr = CALL_EXPR_FN (exp);
3477 int i;
3478 /* The alignment of the stack, in bits. */
3479 unsigned HOST_WIDE_INT preferred_stack_boundary;
3480 /* The alignment of the stack, in bytes. */
3481 unsigned HOST_WIDE_INT preferred_unit_stack_boundary;
3482 /* The static chain value to use for this call. */
3483 rtx static_chain_value;
3484 /* See if this is "nothrow" function call. */
3485 if (TREE_NOTHROW (exp))
3486 flags |= ECF_NOTHROW;
3487
3488 /* See if we can find a DECL-node for the actual function, and get the
3489 function attributes (flags) from the function decl or type node. */
3490 fndecl = get_callee_fndecl (exp);
3491 if (fndecl)
3492 {
3493 fntype = TREE_TYPE (fndecl);
3494 flags |= flags_from_decl_or_type (fndecl);
3495 return_flags |= decl_return_flags (fndecl);
3496 }
3497 else
3498 {
3499 fntype = TREE_TYPE (TREE_TYPE (addr));
3500 flags |= flags_from_decl_or_type (fntype);
3501 if (CALL_EXPR_BY_DESCRIPTOR (exp))
3502 flags |= ECF_BY_DESCRIPTOR;
3503 }
3504 rettype = TREE_TYPE (exp);
3505
3506 struct_value = targetm.calls.struct_value_rtx (fntype, 0);
3507
3508 /* Warn if this value is an aggregate type,
3509 regardless of which calling convention we are using for it. */
3510 if (AGGREGATE_TYPE_P (rettype))
3511 warning (OPT_Waggregate_return, "function call has aggregate value");
3512
3513 /* If the result of a non looping pure or const function call is
3514 ignored (or void), and none of its arguments are volatile, we can
3515 avoid expanding the call and just evaluate the arguments for
3516 side-effects. */
3517 if ((flags & (ECF_CONST | ECF_PURE))
3518 && (!(flags & ECF_LOOPING_CONST_OR_PURE))
3519 && (ignore || target == const0_rtx
3520 || TYPE_MODE (rettype) == VOIDmode))
3521 {
3522 bool volatilep = false;
3523 tree arg;
3524 call_expr_arg_iterator iter;
3525
3526 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
3527 if (TREE_THIS_VOLATILE (arg))
3528 {
3529 volatilep = true;
3530 break;
3531 }
3532
3533 if (! volatilep)
3534 {
3535 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
3536 expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
3537 return const0_rtx;
3538 }
3539 }
3540
3541 #ifdef REG_PARM_STACK_SPACE
3542 reg_parm_stack_space = REG_PARM_STACK_SPACE (!fndecl ? fntype : fndecl);
3543 #endif
3544
3545 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))
3546 && reg_parm_stack_space > 0 && PUSH_ARGS)
3547 must_preallocate = 1;
3548
3549 /* Set up a place to return a structure. */
3550
3551 /* Cater to broken compilers. */
3552 if (aggregate_value_p (exp, fntype))
3553 {
3554 /* This call returns a big structure. */
3555 flags &= ~(ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
3556
3557 #ifdef PCC_STATIC_STRUCT_RETURN
3558 {
3559 pcc_struct_value = 1;
3560 }
3561 #else /* not PCC_STATIC_STRUCT_RETURN */
3562 {
3563 if (!poly_int_tree_p (TYPE_SIZE_UNIT (rettype), &struct_value_size))
3564 struct_value_size = -1;
3565
3566 /* Even if it is semantically safe to use the target as the return
3567 slot, it may be not sufficiently aligned for the return type. */
3568 if (CALL_EXPR_RETURN_SLOT_OPT (exp)
3569 && target
3570 && MEM_P (target)
3571 /* If rettype is addressable, we may not create a temporary.
3572 If target is properly aligned at runtime and the compiler
3573 just doesn't know about it, it will work fine, otherwise it
3574 will be UB. */
3575 && (TREE_ADDRESSABLE (rettype)
3576 || !(MEM_ALIGN (target) < TYPE_ALIGN (rettype)
3577 && targetm.slow_unaligned_access (TYPE_MODE (rettype),
3578 MEM_ALIGN (target)))))
3579 structure_value_addr = XEXP (target, 0);
3580 else
3581 {
3582 /* For variable-sized objects, we must be called with a target
3583 specified. If we were to allocate space on the stack here,
3584 we would have no way of knowing when to free it. */
3585 rtx d = assign_temp (rettype, 1, 1);
3586 structure_value_addr = XEXP (d, 0);
3587 target = 0;
3588 }
3589 }
3590 #endif /* not PCC_STATIC_STRUCT_RETURN */
3591 }
3592
3593 /* Figure out the amount to which the stack should be aligned. */
3594 preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
3595 if (fndecl)
3596 {
3597 struct cgraph_rtl_info *i = cgraph_node::rtl_info (fndecl);
3598 /* Without automatic stack alignment, we can't increase preferred
3599 stack boundary. With automatic stack alignment, it is
3600 unnecessary since unless we can guarantee that all callers will
3601 align the outgoing stack properly, callee has to align its
3602 stack anyway. */
3603 if (i
3604 && i->preferred_incoming_stack_boundary
3605 && i->preferred_incoming_stack_boundary < preferred_stack_boundary)
3606 preferred_stack_boundary = i->preferred_incoming_stack_boundary;
3607 }
3608
3609 /* Operand 0 is a pointer-to-function; get the type of the function. */
3610 funtype = TREE_TYPE (addr);
3611 gcc_assert (POINTER_TYPE_P (funtype));
3612 funtype = TREE_TYPE (funtype);
3613
3614 /* Count whether there are actual complex arguments that need to be split
3615 into their real and imaginary parts. Munge the type_arg_types
3616 appropriately here as well. */
3617 if (targetm.calls.split_complex_arg)
3618 {
3619 call_expr_arg_iterator iter;
3620 tree arg;
3621 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
3622 {
3623 tree type = TREE_TYPE (arg);
3624 if (type && TREE_CODE (type) == COMPLEX_TYPE
3625 && targetm.calls.split_complex_arg (type))
3626 num_complex_actuals++;
3627 }
3628 type_arg_types = split_complex_types (TYPE_ARG_TYPES (funtype));
3629 }
3630 else
3631 type_arg_types = TYPE_ARG_TYPES (funtype);
3632
3633 if (flags & ECF_MAY_BE_ALLOCA)
3634 cfun->calls_alloca = 1;
3635
3636 /* If struct_value_rtx is 0, it means pass the address
3637 as if it were an extra parameter. Put the argument expression
3638 in structure_value_addr_value. */
3639 if (structure_value_addr && struct_value == 0)
3640 {
3641 /* If structure_value_addr is a REG other than
3642 virtual_outgoing_args_rtx, we can use always use it. If it
3643 is not a REG, we must always copy it into a register.
3644 If it is virtual_outgoing_args_rtx, we must copy it to another
3645 register in some cases. */
3646 rtx temp = (!REG_P (structure_value_addr)
3647 || (ACCUMULATE_OUTGOING_ARGS
3648 && stack_arg_under_construction
3649 && structure_value_addr == virtual_outgoing_args_rtx)
3650 ? copy_addr_to_reg (convert_memory_address
3651 (Pmode, structure_value_addr))
3652 : structure_value_addr);
3653
3654 structure_value_addr_value =
3655 make_tree (build_pointer_type (TREE_TYPE (funtype)), temp);
3656 structure_value_addr_parm = CALL_WITH_BOUNDS_P (exp) ? 2 : 1;
3657 }
3658
3659 /* Count the arguments and set NUM_ACTUALS. */
3660 num_actuals =
3661 call_expr_nargs (exp) + num_complex_actuals + structure_value_addr_parm;
3662
3663 /* Compute number of named args.
3664 First, do a raw count of the args for INIT_CUMULATIVE_ARGS. */
3665
3666 if (type_arg_types != 0)
3667 n_named_args
3668 = (list_length (type_arg_types)
3669 /* Count the struct value address, if it is passed as a parm. */
3670 + structure_value_addr_parm);
3671 else
3672 /* If we know nothing, treat all args as named. */
3673 n_named_args = num_actuals;
3674
3675 /* Start updating where the next arg would go.
3676
3677 On some machines (such as the PA) indirect calls have a different
3678 calling convention than normal calls. The fourth argument in
3679 INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
3680 or not. */
3681 INIT_CUMULATIVE_ARGS (args_so_far_v, funtype, NULL_RTX, fndecl, n_named_args);
3682 args_so_far = pack_cumulative_args (&args_so_far_v);
3683
3684 /* Now possibly adjust the number of named args.
3685 Normally, don't include the last named arg if anonymous args follow.
3686 We do include the last named arg if
3687 targetm.calls.strict_argument_naming() returns nonzero.
3688 (If no anonymous args follow, the result of list_length is actually
3689 one too large. This is harmless.)
3690
3691 If targetm.calls.pretend_outgoing_varargs_named() returns
3692 nonzero, and targetm.calls.strict_argument_naming() returns zero,
3693 this machine will be able to place unnamed args that were passed
3694 in registers into the stack. So treat all args as named. This
3695 allows the insns emitting for a specific argument list to be
3696 independent of the function declaration.
3697
3698 If targetm.calls.pretend_outgoing_varargs_named() returns zero,
3699 we do not have any reliable way to pass unnamed args in
3700 registers, so we must force them into memory. */
3701
3702 if (type_arg_types != 0
3703 && targetm.calls.strict_argument_naming (args_so_far))
3704 ;
3705 else if (type_arg_types != 0
3706 && ! targetm.calls.pretend_outgoing_varargs_named (args_so_far))
3707 /* Don't include the last named arg. */
3708 --n_named_args;
3709 else
3710 /* Treat all args as named. */
3711 n_named_args = num_actuals;
3712
3713 /* Make a vector to hold all the information about each arg. */
3714 args = XCNEWVEC (struct arg_data, num_actuals);
3715
3716 /* Build up entries in the ARGS array, compute the size of the
3717 arguments into ARGS_SIZE, etc. */
3718 initialize_argument_information (num_actuals, args, &args_size,
3719 n_named_args, exp,
3720 structure_value_addr_value, fndecl, fntype,
3721 args_so_far, reg_parm_stack_space,
3722 &old_stack_level, &old_pending_adj,
3723 &must_preallocate, &flags,
3724 &try_tail_call, CALL_FROM_THUNK_P (exp));
3725
3726 if (args_size.var)
3727 must_preallocate = 1;
3728
3729 /* Now make final decision about preallocating stack space. */
3730 must_preallocate = finalize_must_preallocate (must_preallocate,
3731 num_actuals, args,
3732 &args_size);
3733
3734 /* If the structure value address will reference the stack pointer, we
3735 must stabilize it. We don't need to do this if we know that we are
3736 not going to adjust the stack pointer in processing this call. */
3737
3738 if (structure_value_addr
3739 && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
3740 || reg_mentioned_p (virtual_outgoing_args_rtx,
3741 structure_value_addr))
3742 && (args_size.var
3743 || (!ACCUMULATE_OUTGOING_ARGS
3744 && maybe_ne (args_size.constant, 0))))
3745 structure_value_addr = copy_to_reg (structure_value_addr);
3746
3747 /* Tail calls can make things harder to debug, and we've traditionally
3748 pushed these optimizations into -O2. Don't try if we're already
3749 expanding a call, as that means we're an argument. Don't try if
3750 there's cleanups, as we know there's code to follow the call. */
3751
3752 if (currently_expanding_call++ != 0
3753 || !flag_optimize_sibling_calls
3754 || args_size.var
3755 || dbg_cnt (tail_call) == false)
3756 try_tail_call = 0;
3757
3758 /* Workaround buggy C/C++ wrappers around Fortran routines with
3759 character(len=constant) arguments if the hidden string length arguments
3760 are passed on the stack; if the callers forget to pass those arguments,
3761 attempting to tail call in such routines leads to stack corruption.
3762 Avoid tail calls in functions where at least one such hidden string
3763 length argument is passed (partially or fully) on the stack in the
3764 caller and the callee needs to pass any arguments on the stack.
3765 See PR90329. */
3766 if (try_tail_call && maybe_ne (args_size.constant, 0))
3767 for (tree arg = DECL_ARGUMENTS (current_function_decl);
3768 arg; arg = DECL_CHAIN (arg))
3769 if (DECL_HIDDEN_STRING_LENGTH (arg) && DECL_INCOMING_RTL (arg))
3770 {
3771 subrtx_iterator::array_type array;
3772 FOR_EACH_SUBRTX (iter, array, DECL_INCOMING_RTL (arg), NONCONST)
3773 if (MEM_P (*iter))
3774 {
3775 try_tail_call = 0;
3776 break;
3777 }
3778 }
3779
3780 /* If the user has marked the function as requiring tail-call
3781 optimization, attempt it. */
3782 if (must_tail_call)
3783 try_tail_call = 1;
3784
3785 /* Rest of purposes for tail call optimizations to fail. */
3786 if (try_tail_call)
3787 try_tail_call = can_implement_as_sibling_call_p (exp,
3788 structure_value_addr,
3789 funtype,
3790 reg_parm_stack_space,
3791 fndecl,
3792 flags, addr, args_size);
3793
3794 /* Check if caller and callee disagree in promotion of function
3795 return value. */
3796 if (try_tail_call)
3797 {
3798 machine_mode caller_mode, caller_promoted_mode;
3799 machine_mode callee_mode, callee_promoted_mode;
3800 int caller_unsignedp, callee_unsignedp;
3801 tree caller_res = DECL_RESULT (current_function_decl);
3802
3803 caller_unsignedp = TYPE_UNSIGNED (TREE_TYPE (caller_res));
3804 caller_mode = DECL_MODE (caller_res);
3805 callee_unsignedp = TYPE_UNSIGNED (TREE_TYPE (funtype));
3806 callee_mode = TYPE_MODE (TREE_TYPE (funtype));
3807 caller_promoted_mode
3808 = promote_function_mode (TREE_TYPE (caller_res), caller_mode,
3809 &caller_unsignedp,
3810 TREE_TYPE (current_function_decl), 1);
3811 callee_promoted_mode
3812 = promote_function_mode (TREE_TYPE (funtype), callee_mode,
3813 &callee_unsignedp,
3814 funtype, 1);
3815 if (caller_mode != VOIDmode
3816 && (caller_promoted_mode != callee_promoted_mode
3817 || ((caller_mode != caller_promoted_mode
3818 || callee_mode != callee_promoted_mode)
3819 && (caller_unsignedp != callee_unsignedp
3820 || partial_subreg_p (caller_mode, callee_mode)))))
3821 {
3822 try_tail_call = 0;
3823 maybe_complain_about_tail_call (exp,
3824 "caller and callee disagree in"
3825 " promotion of function"
3826 " return value");
3827 }
3828 }
3829
3830 /* Ensure current function's preferred stack boundary is at least
3831 what we need. Stack alignment may also increase preferred stack
3832 boundary. */
3833 if (crtl->preferred_stack_boundary < preferred_stack_boundary)
3834 crtl->preferred_stack_boundary = preferred_stack_boundary;
3835 else
3836 preferred_stack_boundary = crtl->preferred_stack_boundary;
3837
3838 preferred_unit_stack_boundary = preferred_stack_boundary / BITS_PER_UNIT;
3839
3840 /* We want to make two insn chains; one for a sibling call, the other
3841 for a normal call. We will select one of the two chains after
3842 initial RTL generation is complete. */
3843 for (pass = try_tail_call ? 0 : 1; pass < 2; pass++)
3844 {
3845 int sibcall_failure = 0;
3846 /* We want to emit any pending stack adjustments before the tail
3847 recursion "call". That way we know any adjustment after the tail
3848 recursion call can be ignored if we indeed use the tail
3849 call expansion. */
3850 saved_pending_stack_adjust save;
3851 rtx_insn *insns, *before_call, *after_args;
3852 rtx next_arg_reg;
3853
3854 if (pass == 0)
3855 {
3856 /* State variables we need to save and restore between
3857 iterations. */
3858 save_pending_stack_adjust (&save);
3859 }
3860 if (pass)
3861 flags &= ~ECF_SIBCALL;
3862 else
3863 flags |= ECF_SIBCALL;
3864
3865 /* Other state variables that we must reinitialize each time
3866 through the loop (that are not initialized by the loop itself). */
3867 argblock = 0;
3868 call_fusage = 0;
3869
3870 /* Start a new sequence for the normal call case.
3871
3872 From this point on, if the sibling call fails, we want to set
3873 sibcall_failure instead of continuing the loop. */
3874 start_sequence ();
3875
3876 /* Don't let pending stack adjusts add up to too much.
3877 Also, do all pending adjustments now if there is any chance
3878 this might be a call to alloca or if we are expanding a sibling
3879 call sequence.
3880 Also do the adjustments before a throwing call, otherwise
3881 exception handling can fail; PR 19225. */
3882 if (maybe_ge (pending_stack_adjust, 32)
3883 || (maybe_ne (pending_stack_adjust, 0)
3884 && (flags & ECF_MAY_BE_ALLOCA))
3885 || (maybe_ne (pending_stack_adjust, 0)
3886 && flag_exceptions && !(flags & ECF_NOTHROW))
3887 || pass == 0)
3888 do_pending_stack_adjust ();
3889
3890 /* Precompute any arguments as needed. */
3891 if (pass)
3892 precompute_arguments (num_actuals, args);
3893
3894 /* Now we are about to start emitting insns that can be deleted
3895 if a libcall is deleted. */
3896 if (pass && (flags & ECF_MALLOC))
3897 start_sequence ();
3898
3899 if (pass == 0
3900 && crtl->stack_protect_guard
3901 && targetm.stack_protect_runtime_enabled_p ())
3902 stack_protect_epilogue ();
3903
3904 adjusted_args_size = args_size;
3905 /* Compute the actual size of the argument block required. The variable
3906 and constant sizes must be combined, the size may have to be rounded,
3907 and there may be a minimum required size. When generating a sibcall
3908 pattern, do not round up, since we'll be re-using whatever space our
3909 caller provided. */
3910 unadjusted_args_size
3911 = compute_argument_block_size (reg_parm_stack_space,
3912 &adjusted_args_size,
3913 fndecl, fntype,
3914 (pass == 0 ? 0
3915 : preferred_stack_boundary));
3916
3917 old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
3918
3919 /* The argument block when performing a sibling call is the
3920 incoming argument block. */
3921 if (pass == 0)
3922 {
3923 argblock = crtl->args.internal_arg_pointer;
3924 if (STACK_GROWS_DOWNWARD)
3925 argblock
3926 = plus_constant (Pmode, argblock, crtl->args.pretend_args_size);
3927 else
3928 argblock
3929 = plus_constant (Pmode, argblock, -crtl->args.pretend_args_size);
3930
3931 HOST_WIDE_INT map_size = constant_lower_bound (args_size.constant);
3932 stored_args_map = sbitmap_alloc (map_size);
3933 bitmap_clear (stored_args_map);
3934 stored_args_watermark = HOST_WIDE_INT_M1U;
3935 }
3936
3937 /* If we have no actual push instructions, or shouldn't use them,
3938 make space for all args right now. */
3939 else if (adjusted_args_size.var != 0)
3940 {
3941 if (old_stack_level == 0)
3942 {
3943 emit_stack_save (SAVE_BLOCK, &old_stack_level);
3944 old_stack_pointer_delta = stack_pointer_delta;
3945 old_pending_adj = pending_stack_adjust;
3946 pending_stack_adjust = 0;
3947 /* stack_arg_under_construction says whether a stack arg is
3948 being constructed at the old stack level. Pushing the stack
3949 gets a clean outgoing argument block. */
3950 old_stack_arg_under_construction = stack_arg_under_construction;
3951 stack_arg_under_construction = 0;
3952 }
3953 argblock = push_block (ARGS_SIZE_RTX (adjusted_args_size), 0, 0);
3954 if (flag_stack_usage_info)
3955 current_function_has_unbounded_dynamic_stack_size = 1;
3956 }
3957 else
3958 {
3959 /* Note that we must go through the motions of allocating an argument
3960 block even if the size is zero because we may be storing args
3961 in the area reserved for register arguments, which may be part of
3962 the stack frame. */
3963
3964 poly_int64 needed = adjusted_args_size.constant;
3965
3966 /* Store the maximum argument space used. It will be pushed by
3967 the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
3968 checking). */
3969
3970 crtl->outgoing_args_size = upper_bound (crtl->outgoing_args_size,
3971 needed);
3972
3973 if (must_preallocate)
3974 {
3975 if (ACCUMULATE_OUTGOING_ARGS)
3976 {
3977 /* Since the stack pointer will never be pushed, it is
3978 possible for the evaluation of a parm to clobber
3979 something we have already written to the stack.
3980 Since most function calls on RISC machines do not use
3981 the stack, this is uncommon, but must work correctly.
3982
3983 Therefore, we save any area of the stack that was already
3984 written and that we are using. Here we set up to do this
3985 by making a new stack usage map from the old one. The
3986 actual save will be done by store_one_arg.
3987
3988 Another approach might be to try to reorder the argument
3989 evaluations to avoid this conflicting stack usage. */
3990
3991 /* Since we will be writing into the entire argument area,
3992 the map must be allocated for its entire size, not just
3993 the part that is the responsibility of the caller. */
3994 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
3995 needed += reg_parm_stack_space;
3996
3997 poly_int64 limit = needed;
3998 if (ARGS_GROW_DOWNWARD)
3999 limit += 1;
4000
4001 /* For polynomial sizes, this is the maximum possible
4002 size needed for arguments with a constant size
4003 and offset. */
4004 HOST_WIDE_INT const_limit = constant_lower_bound (limit);
4005 highest_outgoing_arg_in_use
4006 = MAX (initial_highest_arg_in_use, const_limit);
4007
4008 free (stack_usage_map_buf);
4009 stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
4010 stack_usage_map = stack_usage_map_buf;
4011
4012 if (initial_highest_arg_in_use)
4013 memcpy (stack_usage_map, initial_stack_usage_map,
4014 initial_highest_arg_in_use);
4015
4016 if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
4017 memset (&stack_usage_map[initial_highest_arg_in_use], 0,
4018 (highest_outgoing_arg_in_use
4019 - initial_highest_arg_in_use));
4020 needed = 0;
4021
4022 /* The address of the outgoing argument list must not be
4023 copied to a register here, because argblock would be left
4024 pointing to the wrong place after the call to
4025 allocate_dynamic_stack_space below. */
4026
4027 argblock = virtual_outgoing_args_rtx;
4028 }
4029 else
4030 {
4031 /* Try to reuse some or all of the pending_stack_adjust
4032 to get this space. */
4033 if (inhibit_defer_pop == 0
4034 && (combine_pending_stack_adjustment_and_call
4035 (&needed,
4036 unadjusted_args_size,
4037 &adjusted_args_size,
4038 preferred_unit_stack_boundary)))
4039 {
4040 /* combine_pending_stack_adjustment_and_call computes
4041 an adjustment before the arguments are allocated.
4042 Account for them and see whether or not the stack
4043 needs to go up or down. */
4044 needed = unadjusted_args_size - needed;
4045
4046 /* Checked by
4047 combine_pending_stack_adjustment_and_call. */
4048 gcc_checking_assert (ordered_p (needed, 0));
4049 if (maybe_lt (needed, 0))
4050 {
4051 /* We're releasing stack space. */
4052 /* ??? We can avoid any adjustment at all if we're
4053 already aligned. FIXME. */
4054 pending_stack_adjust = -needed;
4055 do_pending_stack_adjust ();
4056 needed = 0;
4057 }
4058 else
4059 /* We need to allocate space. We'll do that in
4060 push_block below. */
4061 pending_stack_adjust = 0;
4062 }
4063
4064 /* Special case this because overhead of `push_block' in
4065 this case is non-trivial. */
4066 if (known_eq (needed, 0))
4067 argblock = virtual_outgoing_args_rtx;
4068 else
4069 {
4070 rtx needed_rtx = gen_int_mode (needed, Pmode);
4071 argblock = push_block (needed_rtx, 0, 0);
4072 if (ARGS_GROW_DOWNWARD)
4073 argblock = plus_constant (Pmode, argblock, needed);
4074 }
4075
4076 /* We only really need to call `copy_to_reg' in the case
4077 where push insns are going to be used to pass ARGBLOCK
4078 to a function call in ARGS. In that case, the stack
4079 pointer changes value from the allocation point to the
4080 call point, and hence the value of
4081 VIRTUAL_OUTGOING_ARGS_RTX changes as well. But might
4082 as well always do it. */
4083 argblock = copy_to_reg (argblock);
4084 }
4085 }
4086 }
4087
4088 if (ACCUMULATE_OUTGOING_ARGS)
4089 {
4090 /* The save/restore code in store_one_arg handles all
4091 cases except one: a constructor call (including a C
4092 function returning a BLKmode struct) to initialize
4093 an argument. */
4094 if (stack_arg_under_construction)
4095 {
4096 rtx push_size
4097 = (gen_int_mode
4098 (adjusted_args_size.constant
4099 + (OUTGOING_REG_PARM_STACK_SPACE (!fndecl ? fntype
4100 : TREE_TYPE (fndecl))
4101 ? 0 : reg_parm_stack_space), Pmode));
4102 if (old_stack_level == 0)
4103 {
4104 emit_stack_save (SAVE_BLOCK, &old_stack_level);
4105 old_stack_pointer_delta = stack_pointer_delta;
4106 old_pending_adj = pending_stack_adjust;
4107 pending_stack_adjust = 0;
4108 /* stack_arg_under_construction says whether a stack
4109 arg is being constructed at the old stack level.
4110 Pushing the stack gets a clean outgoing argument
4111 block. */
4112 old_stack_arg_under_construction
4113 = stack_arg_under_construction;
4114 stack_arg_under_construction = 0;
4115 /* Make a new map for the new argument list. */
4116 free (stack_usage_map_buf);
4117 stack_usage_map_buf = XCNEWVEC (char, highest_outgoing_arg_in_use);
4118 stack_usage_map = stack_usage_map_buf;
4119 highest_outgoing_arg_in_use = 0;
4120 stack_usage_watermark = HOST_WIDE_INT_M1U;
4121 }
4122 /* We can pass TRUE as the 4th argument because we just
4123 saved the stack pointer and will restore it right after
4124 the call. */
4125 allocate_dynamic_stack_space (push_size, 0, BIGGEST_ALIGNMENT,
4126 -1, true);
4127 }
4128
4129 /* If argument evaluation might modify the stack pointer,
4130 copy the address of the argument list to a register. */
4131 for (i = 0; i < num_actuals; i++)
4132 if (args[i].pass_on_stack)
4133 {
4134 argblock = copy_addr_to_reg (argblock);
4135 break;
4136 }
4137 }
4138
4139 compute_argument_addresses (args, argblock, num_actuals);
4140
4141 /* Stack is properly aligned, pops can't safely be deferred during
4142 the evaluation of the arguments. */
4143 NO_DEFER_POP;
4144
4145 /* Precompute all register parameters. It isn't safe to compute
4146 anything once we have started filling any specific hard regs.
4147 TLS symbols sometimes need a call to resolve. Precompute
4148 register parameters before any stack pointer manipulation
4149 to avoid unaligned stack in the called function. */
4150 precompute_register_parameters (num_actuals, args, ®_parm_seen);
4151
4152 OK_DEFER_POP;
4153
4154 /* Perform stack alignment before the first push (the last arg). */
4155 if (argblock == 0
4156 && maybe_gt (adjusted_args_size.constant, reg_parm_stack_space)
4157 && maybe_ne (adjusted_args_size.constant, unadjusted_args_size))
4158 {
4159 /* When the stack adjustment is pending, we get better code
4160 by combining the adjustments. */
4161 if (maybe_ne (pending_stack_adjust, 0)
4162 && ! inhibit_defer_pop
4163 && (combine_pending_stack_adjustment_and_call
4164 (&pending_stack_adjust,
4165 unadjusted_args_size,
4166 &adjusted_args_size,
4167 preferred_unit_stack_boundary)))
4168 do_pending_stack_adjust ();
4169 else if (argblock == 0)
4170 anti_adjust_stack (gen_int_mode (adjusted_args_size.constant
4171 - unadjusted_args_size,
4172 Pmode));
4173 }
4174 /* Now that the stack is properly aligned, pops can't safely
4175 be deferred during the evaluation of the arguments. */
4176 NO_DEFER_POP;
4177
4178 /* Record the maximum pushed stack space size. We need to delay
4179 doing it this far to take into account the optimization done
4180 by combine_pending_stack_adjustment_and_call. */
4181 if (flag_stack_usage_info
4182 && !ACCUMULATE_OUTGOING_ARGS
4183 && pass
4184 && adjusted_args_size.var == 0)
4185 {
4186 poly_int64 pushed = (adjusted_args_size.constant
4187 + pending_stack_adjust);
4188 current_function_pushed_stack_size
4189 = upper_bound (current_function_pushed_stack_size, pushed);
4190 }
4191
4192 funexp = rtx_for_function_call (fndecl, addr);
4193
4194 if (CALL_EXPR_STATIC_CHAIN (exp))
4195 static_chain_value = expand_normal (CALL_EXPR_STATIC_CHAIN (exp));
4196 else
4197 static_chain_value = 0;
4198
4199 #ifdef REG_PARM_STACK_SPACE
4200 /* Save the fixed argument area if it's part of the caller's frame and
4201 is clobbered by argument setup for this call. */
4202 if (ACCUMULATE_OUTGOING_ARGS && pass)
4203 save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
4204 &low_to_save, &high_to_save);
4205 #endif
4206
4207 /* Now store (and compute if necessary) all non-register parms.
4208 These come before register parms, since they can require block-moves,
4209 which could clobber the registers used for register parms.
4210 Parms which have partial registers are not stored here,
4211 but we do preallocate space here if they want that. */
4212
4213 for (i = 0; i < num_actuals; i++)
4214 {
4215 /* Delay bounds until all other args are stored. */
4216 if (POINTER_BOUNDS_P (args[i].tree_value))
4217 continue;
4218 else if (args[i].reg == 0 || args[i].pass_on_stack)
4219 {
4220 rtx_insn *before_arg = get_last_insn ();
4221
4222 /* We don't allow passing huge (> 2^30 B) arguments
4223 by value. It would cause an overflow later on. */
4224 if (constant_lower_bound (adjusted_args_size.constant)
4225 >= (1 << (HOST_BITS_PER_INT - 2)))
4226 {
4227 sorry ("passing too large argument on stack");
4228 continue;
4229 }
4230
4231 if (store_one_arg (&args[i], argblock, flags,
4232 adjusted_args_size.var != 0,
4233 reg_parm_stack_space)
4234 || (pass == 0
4235 && check_sibcall_argument_overlap (before_arg,
4236 &args[i], 1)))
4237 sibcall_failure = 1;
4238 }
4239
4240 if (args[i].stack)
4241 call_fusage
4242 = gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args[i].tree_value)),
4243 gen_rtx_USE (VOIDmode, args[i].stack),
4244 call_fusage);
4245 }
4246
4247 /* If we have a parm that is passed in registers but not in memory
4248 and whose alignment does not permit a direct copy into registers,
4249 make a group of pseudos that correspond to each register that we
4250 will later fill. */
4251 if (STRICT_ALIGNMENT)
4252 store_unaligned_arguments_into_pseudos (args, num_actuals);
4253
4254 /* Now store any partially-in-registers parm.
4255 This is the last place a block-move can happen. */
4256 if (reg_parm_seen)
4257 for (i = 0; i < num_actuals; i++)
4258 if (args[i].partial != 0 && ! args[i].pass_on_stack)
4259 {
4260 rtx_insn *before_arg = get_last_insn ();
4261
4262 /* On targets with weird calling conventions (e.g. PA) it's
4263 hard to ensure that all cases of argument overlap between
4264 stack and registers work. Play it safe and bail out. */
4265 if (ARGS_GROW_DOWNWARD && !STACK_GROWS_DOWNWARD)
4266 {
4267 sibcall_failure = 1;
4268 break;
4269 }
4270
4271 if (store_one_arg (&args[i], argblock, flags,
4272 adjusted_args_size.var != 0,
4273 reg_parm_stack_space)
4274 || (pass == 0
4275 && check_sibcall_argument_overlap (before_arg,
4276 &args[i], 1)))
4277 sibcall_failure = 1;
4278 }
4279
4280 bool any_regs = false;
4281 for (i = 0; i < num_actuals; i++)
4282 if (args[i].reg != NULL_RTX)
4283 {
4284 any_regs = true;
4285 targetm.calls.call_args (args[i].reg, funtype);
4286 }
4287 if (!any_regs)
4288 targetm.calls.call_args (pc_rtx, funtype);
4289
4290 /* Figure out the register where the value, if any, will come back. */
4291 valreg = 0;
4292 valbnd = 0;
4293 if (TYPE_MODE (rettype) != VOIDmode
4294 && ! structure_value_addr)
4295 {
4296 if (pcc_struct_value)
4297 {
4298 valreg = hard_function_value (build_pointer_type (rettype),
4299 fndecl, NULL, (pass == 0));
4300 if (CALL_WITH_BOUNDS_P (exp))
4301 valbnd = targetm.calls.
4302 chkp_function_value_bounds (build_pointer_type (rettype),
4303 fndecl, (pass == 0));
4304 }
4305 else
4306 {
4307 valreg = hard_function_value (rettype, fndecl, fntype,
4308 (pass == 0));
4309 if (CALL_WITH_BOUNDS_P (exp))
4310 valbnd = targetm.calls.chkp_function_value_bounds (rettype,
4311 fndecl,
4312 (pass == 0));
4313 }
4314
4315 /* If VALREG is a PARALLEL whose first member has a zero
4316 offset, use that. This is for targets such as m68k that
4317 return the same value in multiple places. */
4318 if (GET_CODE (valreg) == PARALLEL)
4319 {
4320 rtx elem = XVECEXP (valreg, 0, 0);
4321 rtx where = XEXP (elem, 0);
4322 rtx offset = XEXP (elem, 1);
4323 if (offset == const0_rtx
4324 && GET_MODE (where) == GET_MODE (valreg))
4325 valreg = where;
4326 }
4327 }
4328
4329 /* Store all bounds not passed in registers. */
4330 for (i = 0; i < num_actuals; i++)
4331 {
4332 if (POINTER_BOUNDS_P (args[i].tree_value)
4333 && !args[i].reg)
4334 store_bounds (&args[i],
4335 args[i].pointer_arg == -1
4336 ? NULL
4337 : &args[args[i].pointer_arg]);
4338 }
4339
4340 /* If register arguments require space on the stack and stack space
4341 was not preallocated, allocate stack space here for arguments
4342 passed in registers. */
4343 if (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))
4344 && !ACCUMULATE_OUTGOING_ARGS
4345 && must_preallocate == 0 && reg_parm_stack_space > 0)
4346 anti_adjust_stack (GEN_INT (reg_parm_stack_space));
4347
4348 /* Pass the function the address in which to return a
4349 structure value. */
4350 if (pass != 0 && structure_value_addr && ! structure_value_addr_parm)
4351 {
4352 structure_value_addr
4353 = convert_memory_address (Pmode, structure_value_addr);
4354 emit_move_insn (struct_value,
4355 force_reg (Pmode,
4356 force_operand (structure_value_addr,
4357 NULL_RTX)));
4358
4359 if (REG_P (struct_value))
4360 use_reg (&call_fusage, struct_value);
4361 }
4362
4363 after_args = get_last_insn ();
4364 funexp = prepare_call_address (fndecl ? fndecl : fntype, funexp,
4365 static_chain_value, &call_fusage,
4366 reg_parm_seen, flags);
4367
4368 load_register_parameters (args, num_actuals, &call_fusage, flags,
4369 pass == 0, &sibcall_failure);
4370
4371 /* Save a pointer to the last insn before the call, so that we can
4372 later safely search backwards to find the CALL_INSN. */
4373 before_call = get_last_insn ();
4374
4375 /* Set up next argument register. For sibling calls on machines
4376 with register windows this should be the incoming register. */
4377 if (pass == 0)
4378 next_arg_reg = targetm.calls.function_incoming_arg (args_so_far,
4379 VOIDmode,
4380 void_type_node,
4381 true);
4382 else
4383 next_arg_reg = targetm.calls.function_arg (args_so_far,
4384 VOIDmode, void_type_node,
4385 true);
4386
4387 if (pass == 1 && (return_flags & ERF_RETURNS_ARG))
4388 {
4389 int arg_nr = return_flags & ERF_RETURN_ARG_MASK;
4390 arg_nr = num_actuals - arg_nr - 1;
4391 if (arg_nr >= 0
4392 && arg_nr < num_actuals
4393 && args[arg_nr].reg
4394 && valreg
4395 && REG_P (valreg)
4396 && GET_MODE (args[arg_nr].reg) == GET_MODE (valreg))
4397 call_fusage
4398 = gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args[arg_nr].tree_value)),
4399 gen_rtx_SET (valreg, args[arg_nr].reg),
4400 call_fusage);
4401 }
4402 /* All arguments and registers used for the call must be set up by
4403 now! */
4404
4405 /* Stack must be properly aligned now. */
4406 gcc_assert (!pass
4407 || multiple_p (stack_pointer_delta,
4408 preferred_unit_stack_boundary));
4409
4410 /* Generate the actual call instruction. */
4411 emit_call_1 (funexp, exp, fndecl, funtype, unadjusted_args_size,
4412 adjusted_args_size.constant, struct_value_size,
4413 next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
4414 flags, args_so_far);
4415
4416 if (flag_ipa_ra)
4417 {
4418 rtx_call_insn *last;
4419 rtx datum = NULL_RTX;
4420 if (fndecl != NULL_TREE)
4421 {
4422 datum = XEXP (DECL_RTL (fndecl), 0);
4423 gcc_assert (datum != NULL_RTX
4424 && GET_CODE (datum) == SYMBOL_REF);
4425 }
4426 last = last_call_insn ();
4427 add_reg_note (last, REG_CALL_DECL, datum);
4428 }
4429
4430 /* If the call setup or the call itself overlaps with anything
4431 of the argument setup we probably clobbered our call address.
4432 In that case we can't do sibcalls. */
4433 if (pass == 0
4434 && check_sibcall_argument_overlap (after_args, 0, 0))
4435 sibcall_failure = 1;
4436
4437 /* If a non-BLKmode value is returned at the most significant end
4438 of a register, shift the register right by the appropriate amount
4439 and update VALREG accordingly. BLKmode values are handled by the
4440 group load/store machinery below. */
4441 if (!structure_value_addr
4442 && !pcc_struct_value
4443 && TYPE_MODE (rettype) != VOIDmode
4444 && TYPE_MODE (rettype) != BLKmode
4445 && REG_P (valreg)
4446 && targetm.calls.return_in_msb (rettype))
4447 {
4448 if (shift_return_value (TYPE_MODE (rettype), false, valreg))
4449 sibcall_failure = 1;
4450 valreg = gen_rtx_REG (TYPE_MODE (rettype), REGNO (valreg));
4451 }
4452
4453 if (pass && (flags & ECF_MALLOC))
4454 {
4455 rtx temp = gen_reg_rtx (GET_MODE (valreg));
4456 rtx_insn *last, *insns;
4457
4458 /* The return value from a malloc-like function is a pointer. */
4459 if (TREE_CODE (rettype) == POINTER_TYPE)
4460 mark_reg_pointer (temp, MALLOC_ABI_ALIGNMENT);
4461
4462 emit_move_insn (temp, valreg);
4463
4464 /* The return value from a malloc-like function can not alias
4465 anything else. */
4466 last = get_last_insn ();
4467 add_reg_note (last, REG_NOALIAS, temp);
4468
4469 /* Write out the sequence. */
4470 insns = get_insns ();
4471 end_sequence ();
4472 emit_insn (insns);
4473 valreg = temp;
4474 }
4475
4476 /* For calls to `setjmp', etc., inform
4477 function.c:setjmp_warnings that it should complain if
4478 nonvolatile values are live. For functions that cannot
4479 return, inform flow that control does not fall through. */
4480
4481 if ((flags & ECF_NORETURN) || pass == 0)
4482 {
4483 /* The barrier must be emitted
4484 immediately after the CALL_INSN. Some ports emit more
4485 than just a CALL_INSN above, so we must search for it here. */
4486
4487 rtx_insn *last = get_last_insn ();
4488 while (!CALL_P (last))
4489 {
4490 last = PREV_INSN (last);
4491 /* There was no CALL_INSN? */
4492 gcc_assert (last != before_call);
4493 }
4494
4495 emit_barrier_after (last);
4496
4497 /* Stack adjustments after a noreturn call are dead code.
4498 However when NO_DEFER_POP is in effect, we must preserve
4499 stack_pointer_delta. */
4500 if (inhibit_defer_pop == 0)
4501 {
4502 stack_pointer_delta = old_stack_allocated;
4503 pending_stack_adjust = 0;
4504 }
4505 }
4506
4507 /* If value type not void, return an rtx for the value. */
4508
4509 if (TYPE_MODE (rettype) == VOIDmode
4510 || ignore)
4511 target = const0_rtx;
4512 else if (structure_value_addr)
4513 {
4514 if (target == 0 || !MEM_P (target))
4515 {
4516 target
4517 = gen_rtx_MEM (TYPE_MODE (rettype),
4518 memory_address (TYPE_MODE (rettype),
4519 structure_value_addr));
4520 set_mem_attributes (target, rettype, 1);
4521 }
4522 }
4523 else if (pcc_struct_value)
4524 {
4525 /* This is the special C++ case where we need to
4526 know what the true target was. We take care to
4527 never use this value more than once in one expression. */
4528 target = gen_rtx_MEM (TYPE_MODE (rettype),
4529 copy_to_reg (valreg));
4530 set_mem_attributes (target, rettype, 1);
4531 }
4532 /* Handle calls that return values in multiple non-contiguous locations.
4533 The Irix 6 ABI has examples of this. */
4534 else if (GET_CODE (valreg) == PARALLEL)
4535 {
4536 if (target == 0)
4537 target = emit_group_move_into_temps (valreg);
4538 else if (rtx_equal_p (target, valreg))
4539 ;
4540 else if (GET_CODE (target) == PARALLEL)
4541 /* Handle the result of a emit_group_move_into_temps
4542 call in the previous pass. */
4543 emit_group_move (target, valreg);
4544 else
4545 emit_group_store (target, valreg, rettype,
4546 int_size_in_bytes (rettype));
4547 }
4548 else if (target
4549 && GET_MODE (target) == TYPE_MODE (rettype)
4550 && GET_MODE (target) == GET_MODE (valreg))
4551 {
4552 bool may_overlap = false;
4553
4554 /* We have to copy a return value in a CLASS_LIKELY_SPILLED hard
4555 reg to a plain register. */
4556 if (!REG_P (target) || HARD_REGISTER_P (target))
4557 valreg = avoid_likely_spilled_reg (valreg);
4558
4559 /* If TARGET is a MEM in the argument area, and we have
4560 saved part of the argument area, then we can't store
4561 directly into TARGET as it may get overwritten when we
4562 restore the argument save area below. Don't work too
4563 hard though and simply force TARGET to a register if it
4564 is a MEM; the optimizer is quite likely to sort it out. */
4565 if (ACCUMULATE_OUTGOING_ARGS && pass && MEM_P (target))
4566 for (i = 0; i < num_actuals; i++)
4567 if (args[i].save_area)
4568 {
4569 may_overlap = true;
4570 break;
4571 }
4572
4573 if (may_overlap)
4574 target = copy_to_reg (valreg);
4575 else
4576 {
4577 /* TARGET and VALREG cannot be equal at this point
4578 because the latter would not have
4579 REG_FUNCTION_VALUE_P true, while the former would if
4580 it were referring to the same register.
4581
4582 If they refer to the same register, this move will be
4583 a no-op, except when function inlining is being
4584 done. */
4585 emit_move_insn (target, valreg);
4586
4587 /* If we are setting a MEM, this code must be executed.
4588 Since it is emitted after the call insn, sibcall
4589 optimization cannot be performed in that case. */
4590 if (MEM_P (target))
4591 sibcall_failure = 1;
4592 }
4593 }
4594 else
4595 target = copy_to_reg (avoid_likely_spilled_reg (valreg));
4596
4597 /* If we promoted this return value, make the proper SUBREG.
4598 TARGET might be const0_rtx here, so be careful. */
4599 if (REG_P (target)
4600 && TYPE_MODE (rettype) != BLKmode
4601 && GET_MODE (target) != TYPE_MODE (rettype))
4602 {
4603 tree type = rettype;
4604 int unsignedp = TYPE_UNSIGNED (type);
4605 machine_mode pmode;
4606
4607 /* Ensure we promote as expected, and get the new unsignedness. */
4608 pmode = promote_function_mode (type, TYPE_MODE (type), &unsignedp,
4609 funtype, 1);
4610 gcc_assert (GET_MODE (target) == pmode);
4611
4612 poly_uint64 offset = subreg_lowpart_offset (TYPE_MODE (type),
4613 GET_MODE (target));
4614 target = gen_rtx_SUBREG (TYPE_MODE (type), target, offset);
4615 SUBREG_PROMOTED_VAR_P (target) = 1;
4616 SUBREG_PROMOTED_SET (target, unsignedp);
4617 }
4618
4619 /* If size of args is variable or this was a constructor call for a stack
4620 argument, restore saved stack-pointer value. */
4621
4622 if (old_stack_level)
4623 {
4624 rtx_insn *prev = get_last_insn ();
4625
4626 emit_stack_restore (SAVE_BLOCK, old_stack_level);
4627 stack_pointer_delta = old_stack_pointer_delta;
4628
4629 fixup_args_size_notes (prev, get_last_insn (), stack_pointer_delta);
4630
4631 pending_stack_adjust = old_pending_adj;
4632 old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
4633 stack_arg_under_construction = old_stack_arg_under_construction;
4634 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
4635 stack_usage_map = initial_stack_usage_map;
4636 stack_usage_watermark = initial_stack_usage_watermark;
4637 sibcall_failure = 1;
4638 }
4639 else if (ACCUMULATE_OUTGOING_ARGS && pass)
4640 {
4641 #ifdef REG_PARM_STACK_SPACE
4642 if (save_area)
4643 restore_fixed_argument_area (save_area, argblock,
4644 high_to_save, low_to_save);
4645 #endif
4646
4647 /* If we saved any argument areas, restore them. */
4648 for (i = 0; i < num_actuals; i++)
4649 if (args[i].save_area)
4650 {
4651 machine_mode save_mode = GET_MODE (args[i].save_area);
4652 rtx stack_area
4653 = gen_rtx_MEM (save_mode,
4654 memory_address (save_mode,
4655 XEXP (args[i].stack_slot, 0)));
4656
4657 if (save_mode != BLKmode)
4658 emit_move_insn (stack_area, args[i].save_area);
4659 else
4660 emit_block_move (stack_area, args[i].save_area,
4661 (gen_int_mode
4662 (args[i].locate.size.constant, Pmode)),
4663 BLOCK_OP_CALL_PARM);
4664 }
4665
4666 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
4667 stack_usage_map = initial_stack_usage_map;
4668 stack_usage_watermark = initial_stack_usage_watermark;
4669 }
4670
4671 /* If this was alloca, record the new stack level. */
4672 if (flags & ECF_MAY_BE_ALLOCA)
4673 record_new_stack_level ();
4674
4675 /* Free up storage we no longer need. */
4676 for (i = 0; i < num_actuals; ++i)
4677 free (args[i].aligned_regs);
4678
4679 targetm.calls.end_call_args ();
4680
4681 insns = get_insns ();
4682 end_sequence ();
4683
4684 if (pass == 0)
4685 {
4686 tail_call_insns = insns;
4687
4688 /* Restore the pending stack adjustment now that we have
4689 finished generating the sibling call sequence. */
4690
4691 restore_pending_stack_adjust (&save);
4692
4693 /* Prepare arg structure for next iteration. */
4694 for (i = 0; i < num_actuals; i++)
4695 {
4696 args[i].value = 0;
4697 args[i].aligned_regs = 0;
4698 args[i].stack = 0;
4699 }
4700
4701 sbitmap_free (stored_args_map);
4702 internal_arg_pointer_exp_state.scan_start = NULL;
4703 internal_arg_pointer_exp_state.cache.release ();
4704 }
4705 else
4706 {
4707 normal_call_insns = insns;
4708
4709 /* Verify that we've deallocated all the stack we used. */
4710 gcc_assert ((flags & ECF_NORETURN)
4711 || known_eq (old_stack_allocated,
4712 stack_pointer_delta
4713 - pending_stack_adjust));
4714 }
4715
4716 /* If something prevents making this a sibling call,
4717 zero out the sequence. */
4718 if (sibcall_failure)
4719 tail_call_insns = NULL;
4720 else
4721 break;
4722 }
4723
4724 /* If tail call production succeeded, we need to remove REG_EQUIV notes on
4725 arguments too, as argument area is now clobbered by the call. */
4726 if (tail_call_insns)
4727 {
4728 emit_insn (tail_call_insns);
4729 crtl->tail_call_emit = true;
4730 }
4731 else
4732 {
4733 emit_insn (normal_call_insns);
4734 if (try_tail_call)
4735 /* Ideally we'd emit a message for all of the ways that it could
4736 have failed. */
4737 maybe_complain_about_tail_call (exp, "tail call production failed");
4738 }
4739
4740 currently_expanding_call--;
4741
4742 free (stack_usage_map_buf);
4743 free (args);
4744
4745 /* Join result with returned bounds so caller may use them if needed. */
4746 target = chkp_join_splitted_slot (target, valbnd);
4747
4748 return target;
4749 }
4750
4751 /* A sibling call sequence invalidates any REG_EQUIV notes made for
4752 this function's incoming arguments.
4753
4754 At the start of RTL generation we know the only REG_EQUIV notes
4755 in the rtl chain are those for incoming arguments, so we can look
4756 for REG_EQUIV notes between the start of the function and the
4757 NOTE_INSN_FUNCTION_BEG.
4758
4759 This is (slight) overkill. We could keep track of the highest
4760 argument we clobber and be more selective in removing notes, but it
4761 does not seem to be worth the effort. */
4762
4763 void
fixup_tail_calls(void)4764 fixup_tail_calls (void)
4765 {
4766 rtx_insn *insn;
4767
4768 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4769 {
4770 rtx note;
4771
4772 /* There are never REG_EQUIV notes for the incoming arguments
4773 after the NOTE_INSN_FUNCTION_BEG note, so stop if we see it. */
4774 if (NOTE_P (insn)
4775 && NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG)
4776 break;
4777
4778 note = find_reg_note (insn, REG_EQUIV, 0);
4779 if (note)
4780 remove_note (insn, note);
4781 note = find_reg_note (insn, REG_EQUIV, 0);
4782 gcc_assert (!note);
4783 }
4784 }
4785
4786 /* Traverse a list of TYPES and expand all complex types into their
4787 components. */
4788 static tree
split_complex_types(tree types)4789 split_complex_types (tree types)
4790 {
4791 tree p;
4792
4793 /* Before allocating memory, check for the common case of no complex. */
4794 for (p = types; p; p = TREE_CHAIN (p))
4795 {
4796 tree type = TREE_VALUE (p);
4797 if (TREE_CODE (type) == COMPLEX_TYPE
4798 && targetm.calls.split_complex_arg (type))
4799 goto found;
4800 }
4801 return types;
4802
4803 found:
4804 types = copy_list (types);
4805
4806 for (p = types; p; p = TREE_CHAIN (p))
4807 {
4808 tree complex_type = TREE_VALUE (p);
4809
4810 if (TREE_CODE (complex_type) == COMPLEX_TYPE
4811 && targetm.calls.split_complex_arg (complex_type))
4812 {
4813 tree next, imag;
4814
4815 /* Rewrite complex type with component type. */
4816 TREE_VALUE (p) = TREE_TYPE (complex_type);
4817 next = TREE_CHAIN (p);
4818
4819 /* Add another component type for the imaginary part. */
4820 imag = build_tree_list (NULL_TREE, TREE_VALUE (p));
4821 TREE_CHAIN (p) = imag;
4822 TREE_CHAIN (imag) = next;
4823
4824 /* Skip the newly created node. */
4825 p = TREE_CHAIN (p);
4826 }
4827 }
4828
4829 return types;
4830 }
4831
4832 /* Output a library call to function ORGFUN (a SYMBOL_REF rtx)
4833 for a value of mode OUTMODE,
4834 with NARGS different arguments, passed as ARGS.
4835 Store the return value if RETVAL is nonzero: store it in VALUE if
4836 VALUE is nonnull, otherwise pick a convenient location. In either
4837 case return the location of the stored value.
4838
4839 FN_TYPE should be LCT_NORMAL for `normal' calls, LCT_CONST for
4840 `const' calls, LCT_PURE for `pure' calls, or another LCT_ value for
4841 other types of library calls. */
4842
4843 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)4844 emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
4845 enum libcall_type fn_type,
4846 machine_mode outmode, int nargs, rtx_mode_t *args)
4847 {
4848 /* Total size in bytes of all the stack-parms scanned so far. */
4849 struct args_size args_size;
4850 /* Size of arguments before any adjustments (such as rounding). */
4851 struct args_size original_args_size;
4852 int argnum;
4853 rtx fun;
4854 /* Todo, choose the correct decl type of orgfun. Sadly this information
4855 isn't present here, so we default to native calling abi here. */
4856 tree fndecl ATTRIBUTE_UNUSED = NULL_TREE; /* library calls default to host calling abi ? */
4857 tree fntype ATTRIBUTE_UNUSED = NULL_TREE; /* library calls default to host calling abi ? */
4858 int count;
4859 rtx argblock = 0;
4860 CUMULATIVE_ARGS args_so_far_v;
4861 cumulative_args_t args_so_far;
4862 struct arg
4863 {
4864 rtx value;
4865 machine_mode mode;
4866 rtx reg;
4867 int partial;
4868 struct locate_and_pad_arg_data locate;
4869 rtx save_area;
4870 };
4871 struct arg *argvec;
4872 int old_inhibit_defer_pop = inhibit_defer_pop;
4873 rtx call_fusage = 0;
4874 rtx mem_value = 0;
4875 rtx valreg;
4876 int pcc_struct_value = 0;
4877 poly_int64 struct_value_size = 0;
4878 int flags;
4879 int reg_parm_stack_space = 0;
4880 poly_int64 needed;
4881 rtx_insn *before_call;
4882 bool have_push_fusage;
4883 tree tfom; /* type_for_mode (outmode, 0) */
4884
4885 #ifdef REG_PARM_STACK_SPACE
4886 /* Define the boundary of the register parm stack space that needs to be
4887 save, if any. */
4888 int low_to_save = 0, high_to_save = 0;
4889 rtx save_area = 0; /* Place that it is saved. */
4890 #endif
4891
4892 /* Size of the stack reserved for parameter registers. */
4893 unsigned int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
4894 char *initial_stack_usage_map = stack_usage_map;
4895 unsigned HOST_WIDE_INT initial_stack_usage_watermark = stack_usage_watermark;
4896 char *stack_usage_map_buf = NULL;
4897
4898 rtx struct_value = targetm.calls.struct_value_rtx (0, 0);
4899
4900 #ifdef REG_PARM_STACK_SPACE
4901 reg_parm_stack_space = REG_PARM_STACK_SPACE ((tree) 0);
4902 #endif
4903
4904 /* By default, library functions cannot throw. */
4905 flags = ECF_NOTHROW;
4906
4907 switch (fn_type)
4908 {
4909 case LCT_NORMAL:
4910 break;
4911 case LCT_CONST:
4912 flags |= ECF_CONST;
4913 break;
4914 case LCT_PURE:
4915 flags |= ECF_PURE;
4916 break;
4917 case LCT_NORETURN:
4918 flags |= ECF_NORETURN;
4919 break;
4920 case LCT_THROW:
4921 flags &= ~ECF_NOTHROW;
4922 break;
4923 case LCT_RETURNS_TWICE:
4924 flags = ECF_RETURNS_TWICE;
4925 break;
4926 }
4927 fun = orgfun;
4928
4929 /* Ensure current function's preferred stack boundary is at least
4930 what we need. */
4931 if (crtl->preferred_stack_boundary < PREFERRED_STACK_BOUNDARY)
4932 crtl->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
4933
4934 /* If this kind of value comes back in memory,
4935 decide where in memory it should come back. */
4936 if (outmode != VOIDmode)
4937 {
4938 tfom = lang_hooks.types.type_for_mode (outmode, 0);
4939 if (aggregate_value_p (tfom, 0))
4940 {
4941 #ifdef PCC_STATIC_STRUCT_RETURN
4942 rtx pointer_reg
4943 = hard_function_value (build_pointer_type (tfom), 0, 0, 0);
4944 mem_value = gen_rtx_MEM (outmode, pointer_reg);
4945 pcc_struct_value = 1;
4946 if (value == 0)
4947 value = gen_reg_rtx (outmode);
4948 #else /* not PCC_STATIC_STRUCT_RETURN */
4949 struct_value_size = GET_MODE_SIZE (outmode);
4950 if (value != 0 && MEM_P (value))
4951 mem_value = value;
4952 else
4953 mem_value = assign_temp (tfom, 1, 1);
4954 #endif
4955 /* This call returns a big structure. */
4956 flags &= ~(ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
4957 }
4958 }
4959 else
4960 tfom = void_type_node;
4961
4962 /* ??? Unfinished: must pass the memory address as an argument. */
4963
4964 /* Copy all the libcall-arguments out of the varargs data
4965 and into a vector ARGVEC.
4966
4967 Compute how to pass each argument. We only support a very small subset
4968 of the full argument passing conventions to limit complexity here since
4969 library functions shouldn't have many args. */
4970
4971 argvec = XALLOCAVEC (struct arg, nargs + 1);
4972 memset (argvec, 0, (nargs + 1) * sizeof (struct arg));
4973
4974 #ifdef INIT_CUMULATIVE_LIBCALL_ARGS
4975 INIT_CUMULATIVE_LIBCALL_ARGS (args_so_far_v, outmode, fun);
4976 #else
4977 INIT_CUMULATIVE_ARGS (args_so_far_v, NULL_TREE, fun, 0, nargs);
4978 #endif
4979 args_so_far = pack_cumulative_args (&args_so_far_v);
4980
4981 args_size.constant = 0;
4982 args_size.var = 0;
4983
4984 count = 0;
4985
4986 push_temp_slots ();
4987
4988 /* If there's a structure value address to be passed,
4989 either pass it in the special place, or pass it as an extra argument. */
4990 if (mem_value && struct_value == 0 && ! pcc_struct_value)
4991 {
4992 rtx addr = XEXP (mem_value, 0);
4993
4994 nargs++;
4995
4996 /* Make sure it is a reasonable operand for a move or push insn. */
4997 if (!REG_P (addr) && !MEM_P (addr)
4998 && !(CONSTANT_P (addr)
4999 && targetm.legitimate_constant_p (Pmode, addr)))
5000 addr = force_operand (addr, NULL_RTX);
5001
5002 argvec[count].value = addr;
5003 argvec[count].mode = Pmode;
5004 argvec[count].partial = 0;
5005
5006 argvec[count].reg = targetm.calls.function_arg (args_so_far,
5007 Pmode, NULL_TREE, true);
5008 gcc_assert (targetm.calls.arg_partial_bytes (args_so_far, Pmode,
5009 NULL_TREE, 1) == 0);
5010
5011 locate_and_pad_parm (Pmode, NULL_TREE,
5012 #ifdef STACK_PARMS_IN_REG_PARM_AREA
5013 1,
5014 #else
5015 argvec[count].reg != 0,
5016 #endif
5017 reg_parm_stack_space, 0,
5018 NULL_TREE, &args_size, &argvec[count].locate);
5019
5020 if (argvec[count].reg == 0 || argvec[count].partial != 0
5021 || reg_parm_stack_space > 0)
5022 args_size.constant += argvec[count].locate.size.constant;
5023
5024 targetm.calls.function_arg_advance (args_so_far, Pmode, (tree) 0, true);
5025
5026 count++;
5027 }
5028
5029 for (unsigned int i = 0; count < nargs; i++, count++)
5030 {
5031 rtx val = args[i].first;
5032 machine_mode mode = args[i].second;
5033 int unsigned_p = 0;
5034
5035 /* We cannot convert the arg value to the mode the library wants here;
5036 must do it earlier where we know the signedness of the arg. */
5037 gcc_assert (mode != BLKmode
5038 && (GET_MODE (val) == mode || GET_MODE (val) == VOIDmode));
5039
5040 /* Make sure it is a reasonable operand for a move or push insn. */
5041 if (!REG_P (val) && !MEM_P (val)
5042 && !(CONSTANT_P (val) && targetm.legitimate_constant_p (mode, val)))
5043 val = force_operand (val, NULL_RTX);
5044
5045 if (pass_by_reference (&args_so_far_v, mode, NULL_TREE, 1))
5046 {
5047 rtx slot;
5048 int must_copy
5049 = !reference_callee_copied (&args_so_far_v, mode, NULL_TREE, 1);
5050
5051 /* If this was a CONST function, it is now PURE since it now
5052 reads memory. */
5053 if (flags & ECF_CONST)
5054 {
5055 flags &= ~ECF_CONST;
5056 flags |= ECF_PURE;
5057 }
5058
5059 if (MEM_P (val) && !must_copy)
5060 {
5061 tree val_expr = MEM_EXPR (val);
5062 if (val_expr)
5063 mark_addressable (val_expr);
5064 slot = val;
5065 }
5066 else
5067 {
5068 slot = assign_temp (lang_hooks.types.type_for_mode (mode, 0),
5069 1, 1);
5070 emit_move_insn (slot, val);
5071 }
5072
5073 call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
5074 gen_rtx_USE (VOIDmode, slot),
5075 call_fusage);
5076 if (must_copy)
5077 call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
5078 gen_rtx_CLOBBER (VOIDmode,
5079 slot),
5080 call_fusage);
5081
5082 mode = Pmode;
5083 val = force_operand (XEXP (slot, 0), NULL_RTX);
5084 }
5085
5086 mode = promote_function_mode (NULL_TREE, mode, &unsigned_p, NULL_TREE, 0);
5087 argvec[count].mode = mode;
5088 argvec[count].value = convert_modes (mode, GET_MODE (val), val, unsigned_p);
5089 argvec[count].reg = targetm.calls.function_arg (args_so_far, mode,
5090 NULL_TREE, true);
5091
5092 argvec[count].partial
5093 = targetm.calls.arg_partial_bytes (args_so_far, mode, NULL_TREE, 1);
5094
5095 if (argvec[count].reg == 0
5096 || argvec[count].partial != 0
5097 || reg_parm_stack_space > 0)
5098 {
5099 locate_and_pad_parm (mode, NULL_TREE,
5100 #ifdef STACK_PARMS_IN_REG_PARM_AREA
5101 1,
5102 #else
5103 argvec[count].reg != 0,
5104 #endif
5105 reg_parm_stack_space, argvec[count].partial,
5106 NULL_TREE, &args_size, &argvec[count].locate);
5107 args_size.constant += argvec[count].locate.size.constant;
5108 gcc_assert (!argvec[count].locate.size.var);
5109 }
5110 #ifdef BLOCK_REG_PADDING
5111 else
5112 /* The argument is passed entirely in registers. See at which
5113 end it should be padded. */
5114 argvec[count].locate.where_pad =
5115 BLOCK_REG_PADDING (mode, NULL_TREE,
5116 known_le (GET_MODE_SIZE (mode), UNITS_PER_WORD));
5117 #endif
5118
5119 targetm.calls.function_arg_advance (args_so_far, mode, (tree) 0, true);
5120 }
5121
5122 /* If this machine requires an external definition for library
5123 functions, write one out. */
5124 assemble_external_libcall (fun);
5125
5126 original_args_size = args_size;
5127 args_size.constant = (aligned_upper_bound (args_size.constant
5128 + stack_pointer_delta,
5129 STACK_BYTES)
5130 - stack_pointer_delta);
5131
5132 args_size.constant = upper_bound (args_size.constant,
5133 reg_parm_stack_space);
5134
5135 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
5136 args_size.constant -= reg_parm_stack_space;
5137
5138 crtl->outgoing_args_size = upper_bound (crtl->outgoing_args_size,
5139 args_size.constant);
5140
5141 if (flag_stack_usage_info && !ACCUMULATE_OUTGOING_ARGS)
5142 {
5143 poly_int64 pushed = args_size.constant + pending_stack_adjust;
5144 current_function_pushed_stack_size
5145 = upper_bound (current_function_pushed_stack_size, pushed);
5146 }
5147
5148 if (ACCUMULATE_OUTGOING_ARGS)
5149 {
5150 /* Since the stack pointer will never be pushed, it is possible for
5151 the evaluation of a parm to clobber something we have already
5152 written to the stack. Since most function calls on RISC machines
5153 do not use the stack, this is uncommon, but must work correctly.
5154
5155 Therefore, we save any area of the stack that was already written
5156 and that we are using. Here we set up to do this by making a new
5157 stack usage map from the old one.
5158
5159 Another approach might be to try to reorder the argument
5160 evaluations to avoid this conflicting stack usage. */
5161
5162 needed = args_size.constant;
5163
5164 /* Since we will be writing into the entire argument area, the
5165 map must be allocated for its entire size, not just the part that
5166 is the responsibility of the caller. */
5167 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
5168 needed += reg_parm_stack_space;
5169
5170 poly_int64 limit = needed;
5171 if (ARGS_GROW_DOWNWARD)
5172 limit += 1;
5173
5174 /* For polynomial sizes, this is the maximum possible size needed
5175 for arguments with a constant size and offset. */
5176 HOST_WIDE_INT const_limit = constant_lower_bound (limit);
5177 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
5178 const_limit);
5179
5180 stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
5181 stack_usage_map = stack_usage_map_buf;
5182
5183 if (initial_highest_arg_in_use)
5184 memcpy (stack_usage_map, initial_stack_usage_map,
5185 initial_highest_arg_in_use);
5186
5187 if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
5188 memset (&stack_usage_map[initial_highest_arg_in_use], 0,
5189 highest_outgoing_arg_in_use - initial_highest_arg_in_use);
5190 needed = 0;
5191
5192 /* We must be careful to use virtual regs before they're instantiated,
5193 and real regs afterwards. Loop optimization, for example, can create
5194 new libcalls after we've instantiated the virtual regs, and if we
5195 use virtuals anyway, they won't match the rtl patterns. */
5196
5197 if (virtuals_instantiated)
5198 argblock = plus_constant (Pmode, stack_pointer_rtx,
5199 STACK_POINTER_OFFSET);
5200 else
5201 argblock = virtual_outgoing_args_rtx;
5202 }
5203 else
5204 {
5205 if (!PUSH_ARGS)
5206 argblock = push_block (gen_int_mode (args_size.constant, Pmode), 0, 0);
5207 }
5208
5209 /* We push args individually in reverse order, perform stack alignment
5210 before the first push (the last arg). */
5211 if (argblock == 0)
5212 anti_adjust_stack (gen_int_mode (args_size.constant
5213 - original_args_size.constant,
5214 Pmode));
5215
5216 argnum = nargs - 1;
5217
5218 #ifdef REG_PARM_STACK_SPACE
5219 if (ACCUMULATE_OUTGOING_ARGS)
5220 {
5221 /* The argument list is the property of the called routine and it
5222 may clobber it. If the fixed area has been used for previous
5223 parameters, we must save and restore it. */
5224 save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
5225 &low_to_save, &high_to_save);
5226 }
5227 #endif
5228
5229 /* When expanding a normal call, args are stored in push order,
5230 which is the reverse of what we have here. */
5231 bool any_regs = false;
5232 for (int i = nargs; i-- > 0; )
5233 if (argvec[i].reg != NULL_RTX)
5234 {
5235 targetm.calls.call_args (argvec[i].reg, NULL_TREE);
5236 any_regs = true;
5237 }
5238 if (!any_regs)
5239 targetm.calls.call_args (pc_rtx, NULL_TREE);
5240
5241 /* Push the args that need to be pushed. */
5242
5243 have_push_fusage = false;
5244
5245 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
5246 are to be pushed. */
5247 for (count = 0; count < nargs; count++, argnum--)
5248 {
5249 machine_mode mode = argvec[argnum].mode;
5250 rtx val = argvec[argnum].value;
5251 rtx reg = argvec[argnum].reg;
5252 int partial = argvec[argnum].partial;
5253 unsigned int parm_align = argvec[argnum].locate.boundary;
5254 poly_int64 lower_bound = 0, upper_bound = 0;
5255
5256 if (! (reg != 0 && partial == 0))
5257 {
5258 rtx use;
5259
5260 if (ACCUMULATE_OUTGOING_ARGS)
5261 {
5262 /* If this is being stored into a pre-allocated, fixed-size,
5263 stack area, save any previous data at that location. */
5264
5265 if (ARGS_GROW_DOWNWARD)
5266 {
5267 /* stack_slot is negative, but we want to index stack_usage_map
5268 with positive values. */
5269 upper_bound = -argvec[argnum].locate.slot_offset.constant + 1;
5270 lower_bound = upper_bound - argvec[argnum].locate.size.constant;
5271 }
5272 else
5273 {
5274 lower_bound = argvec[argnum].locate.slot_offset.constant;
5275 upper_bound = lower_bound + argvec[argnum].locate.size.constant;
5276 }
5277
5278 if (stack_region_maybe_used_p (lower_bound, upper_bound,
5279 reg_parm_stack_space))
5280 {
5281 /* We need to make a save area. */
5282 poly_uint64 size
5283 = argvec[argnum].locate.size.constant * BITS_PER_UNIT;
5284 machine_mode save_mode
5285 = int_mode_for_size (size, 1).else_blk ();
5286 rtx adr
5287 = plus_constant (Pmode, argblock,
5288 argvec[argnum].locate.offset.constant);
5289 rtx stack_area
5290 = gen_rtx_MEM (save_mode, memory_address (save_mode, adr));
5291
5292 if (save_mode == BLKmode)
5293 {
5294 argvec[argnum].save_area
5295 = assign_stack_temp (BLKmode,
5296 argvec[argnum].locate.size.constant
5297 );
5298
5299 emit_block_move (validize_mem
5300 (copy_rtx (argvec[argnum].save_area)),
5301 stack_area,
5302 (gen_int_mode
5303 (argvec[argnum].locate.size.constant,
5304 Pmode)),
5305 BLOCK_OP_CALL_PARM);
5306 }
5307 else
5308 {
5309 argvec[argnum].save_area = gen_reg_rtx (save_mode);
5310
5311 emit_move_insn (argvec[argnum].save_area, stack_area);
5312 }
5313 }
5314 }
5315
5316 emit_push_insn (val, mode, NULL_TREE, NULL_RTX, parm_align,
5317 partial, reg, 0, argblock,
5318 (gen_int_mode
5319 (argvec[argnum].locate.offset.constant, Pmode)),
5320 reg_parm_stack_space,
5321 ARGS_SIZE_RTX (argvec[argnum].locate.alignment_pad), false);
5322
5323 /* Now mark the segment we just used. */
5324 if (ACCUMULATE_OUTGOING_ARGS)
5325 mark_stack_region_used (lower_bound, upper_bound);
5326
5327 NO_DEFER_POP;
5328
5329 /* Indicate argument access so that alias.c knows that these
5330 values are live. */
5331 if (argblock)
5332 use = plus_constant (Pmode, argblock,
5333 argvec[argnum].locate.offset.constant);
5334 else if (have_push_fusage)
5335 continue;
5336 else
5337 {
5338 /* When arguments are pushed, trying to tell alias.c where
5339 exactly this argument is won't work, because the
5340 auto-increment causes confusion. So we merely indicate
5341 that we access something with a known mode somewhere on
5342 the stack. */
5343 use = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
5344 gen_rtx_SCRATCH (Pmode));
5345 have_push_fusage = true;
5346 }
5347 use = gen_rtx_MEM (argvec[argnum].mode, use);
5348 use = gen_rtx_USE (VOIDmode, use);
5349 call_fusage = gen_rtx_EXPR_LIST (VOIDmode, use, call_fusage);
5350 }
5351 }
5352
5353 argnum = nargs - 1;
5354
5355 fun = prepare_call_address (NULL, fun, NULL, &call_fusage, 0, 0);
5356
5357 /* Now load any reg parms into their regs. */
5358
5359 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
5360 are to be pushed. */
5361 for (count = 0; count < nargs; count++, argnum--)
5362 {
5363 machine_mode mode = argvec[argnum].mode;
5364 rtx val = argvec[argnum].value;
5365 rtx reg = argvec[argnum].reg;
5366 int partial = argvec[argnum].partial;
5367
5368 /* Handle calls that pass values in multiple non-contiguous
5369 locations. The PA64 has examples of this for library calls. */
5370 if (reg != 0 && GET_CODE (reg) == PARALLEL)
5371 emit_group_load (reg, val, NULL_TREE, GET_MODE_SIZE (mode));
5372 else if (reg != 0 && partial == 0)
5373 {
5374 emit_move_insn (reg, val);
5375 #ifdef BLOCK_REG_PADDING
5376 poly_int64 size = GET_MODE_SIZE (argvec[argnum].mode);
5377
5378 /* Copied from load_register_parameters. */
5379
5380 /* Handle case where we have a value that needs shifting
5381 up to the msb. eg. a QImode value and we're padding
5382 upward on a BYTES_BIG_ENDIAN machine. */
5383 if (known_lt (size, UNITS_PER_WORD)
5384 && (argvec[argnum].locate.where_pad
5385 == (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD)))
5386 {
5387 rtx x;
5388 poly_int64 shift = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
5389
5390 /* Assigning REG here rather than a temp makes CALL_FUSAGE
5391 report the whole reg as used. Strictly speaking, the
5392 call only uses SIZE bytes at the msb end, but it doesn't
5393 seem worth generating rtl to say that. */
5394 reg = gen_rtx_REG (word_mode, REGNO (reg));
5395 x = expand_shift (LSHIFT_EXPR, word_mode, reg, shift, reg, 1);
5396 if (x != reg)
5397 emit_move_insn (reg, x);
5398 }
5399 #endif
5400 }
5401
5402 NO_DEFER_POP;
5403 }
5404
5405 /* Any regs containing parms remain in use through the call. */
5406 for (count = 0; count < nargs; count++)
5407 {
5408 rtx reg = argvec[count].reg;
5409 if (reg != 0 && GET_CODE (reg) == PARALLEL)
5410 use_group_regs (&call_fusage, reg);
5411 else if (reg != 0)
5412 {
5413 int partial = argvec[count].partial;
5414 if (partial)
5415 {
5416 int nregs;
5417 gcc_assert (partial % UNITS_PER_WORD == 0);
5418 nregs = partial / UNITS_PER_WORD;
5419 use_regs (&call_fusage, REGNO (reg), nregs);
5420 }
5421 else
5422 use_reg (&call_fusage, reg);
5423 }
5424 }
5425
5426 /* Pass the function the address in which to return a structure value. */
5427 if (mem_value != 0 && struct_value != 0 && ! pcc_struct_value)
5428 {
5429 emit_move_insn (struct_value,
5430 force_reg (Pmode,
5431 force_operand (XEXP (mem_value, 0),
5432 NULL_RTX)));
5433 if (REG_P (struct_value))
5434 use_reg (&call_fusage, struct_value);
5435 }
5436
5437 /* Don't allow popping to be deferred, since then
5438 cse'ing of library calls could delete a call and leave the pop. */
5439 NO_DEFER_POP;
5440 valreg = (mem_value == 0 && outmode != VOIDmode
5441 ? hard_libcall_value (outmode, orgfun) : NULL_RTX);
5442
5443 /* Stack must be properly aligned now. */
5444 gcc_assert (multiple_p (stack_pointer_delta,
5445 PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT));
5446
5447 before_call = get_last_insn ();
5448
5449 /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
5450 will set inhibit_defer_pop to that value. */
5451 /* The return type is needed to decide how many bytes the function pops.
5452 Signedness plays no role in that, so for simplicity, we pretend it's
5453 always signed. We also assume that the list of arguments passed has
5454 no impact, so we pretend it is unknown. */
5455
5456 emit_call_1 (fun, NULL,
5457 get_identifier (XSTR (orgfun, 0)),
5458 build_function_type (tfom, NULL_TREE),
5459 original_args_size.constant, args_size.constant,
5460 struct_value_size,
5461 targetm.calls.function_arg (args_so_far,
5462 VOIDmode, void_type_node, true),
5463 valreg,
5464 old_inhibit_defer_pop + 1, call_fusage, flags, args_so_far);
5465
5466 if (flag_ipa_ra)
5467 {
5468 rtx datum = orgfun;
5469 gcc_assert (GET_CODE (datum) == SYMBOL_REF);
5470 rtx_call_insn *last = last_call_insn ();
5471 add_reg_note (last, REG_CALL_DECL, datum);
5472 }
5473
5474 /* Right-shift returned value if necessary. */
5475 if (!pcc_struct_value
5476 && TYPE_MODE (tfom) != BLKmode
5477 && targetm.calls.return_in_msb (tfom))
5478 {
5479 shift_return_value (TYPE_MODE (tfom), false, valreg);
5480 valreg = gen_rtx_REG (TYPE_MODE (tfom), REGNO (valreg));
5481 }
5482
5483 targetm.calls.end_call_args ();
5484
5485 /* For calls to `setjmp', etc., inform function.c:setjmp_warnings
5486 that it should complain if nonvolatile values are live. For
5487 functions that cannot return, inform flow that control does not
5488 fall through. */
5489 if (flags & ECF_NORETURN)
5490 {
5491 /* The barrier note must be emitted
5492 immediately after the CALL_INSN. Some ports emit more than
5493 just a CALL_INSN above, so we must search for it here. */
5494 rtx_insn *last = get_last_insn ();
5495 while (!CALL_P (last))
5496 {
5497 last = PREV_INSN (last);
5498 /* There was no CALL_INSN? */
5499 gcc_assert (last != before_call);
5500 }
5501
5502 emit_barrier_after (last);
5503 }
5504
5505 /* Consider that "regular" libcalls, i.e. all of them except for LCT_THROW
5506 and LCT_RETURNS_TWICE, cannot perform non-local gotos. */
5507 if (flags & ECF_NOTHROW)
5508 {
5509 rtx_insn *last = get_last_insn ();
5510 while (!CALL_P (last))
5511 {
5512 last = PREV_INSN (last);
5513 /* There was no CALL_INSN? */
5514 gcc_assert (last != before_call);
5515 }
5516
5517 make_reg_eh_region_note_nothrow_nononlocal (last);
5518 }
5519
5520 /* Now restore inhibit_defer_pop to its actual original value. */
5521 OK_DEFER_POP;
5522
5523 pop_temp_slots ();
5524
5525 /* Copy the value to the right place. */
5526 if (outmode != VOIDmode && retval)
5527 {
5528 if (mem_value)
5529 {
5530 if (value == 0)
5531 value = mem_value;
5532 if (value != mem_value)
5533 emit_move_insn (value, mem_value);
5534 }
5535 else if (GET_CODE (valreg) == PARALLEL)
5536 {
5537 if (value == 0)
5538 value = gen_reg_rtx (outmode);
5539 emit_group_store (value, valreg, NULL_TREE, GET_MODE_SIZE (outmode));
5540 }
5541 else
5542 {
5543 /* Convert to the proper mode if a promotion has been active. */
5544 if (GET_MODE (valreg) != outmode)
5545 {
5546 int unsignedp = TYPE_UNSIGNED (tfom);
5547
5548 gcc_assert (promote_function_mode (tfom, outmode, &unsignedp,
5549 fndecl ? TREE_TYPE (fndecl) : fntype, 1)
5550 == GET_MODE (valreg));
5551 valreg = convert_modes (outmode, GET_MODE (valreg), valreg, 0);
5552 }
5553
5554 if (value != 0)
5555 emit_move_insn (value, valreg);
5556 else
5557 value = valreg;
5558 }
5559 }
5560
5561 if (ACCUMULATE_OUTGOING_ARGS)
5562 {
5563 #ifdef REG_PARM_STACK_SPACE
5564 if (save_area)
5565 restore_fixed_argument_area (save_area, argblock,
5566 high_to_save, low_to_save);
5567 #endif
5568
5569 /* If we saved any argument areas, restore them. */
5570 for (count = 0; count < nargs; count++)
5571 if (argvec[count].save_area)
5572 {
5573 machine_mode save_mode = GET_MODE (argvec[count].save_area);
5574 rtx adr = plus_constant (Pmode, argblock,
5575 argvec[count].locate.offset.constant);
5576 rtx stack_area = gen_rtx_MEM (save_mode,
5577 memory_address (save_mode, adr));
5578
5579 if (save_mode == BLKmode)
5580 emit_block_move (stack_area,
5581 validize_mem
5582 (copy_rtx (argvec[count].save_area)),
5583 (gen_int_mode
5584 (argvec[count].locate.size.constant, Pmode)),
5585 BLOCK_OP_CALL_PARM);
5586 else
5587 emit_move_insn (stack_area, argvec[count].save_area);
5588 }
5589
5590 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
5591 stack_usage_map = initial_stack_usage_map;
5592 stack_usage_watermark = initial_stack_usage_watermark;
5593 }
5594
5595 free (stack_usage_map_buf);
5596
5597 return value;
5598
5599 }
5600
5601
5602 /* Store pointer bounds argument ARG into Bounds Table entry
5603 associated with PARM. */
5604 static void
store_bounds(struct arg_data * arg,struct arg_data * parm)5605 store_bounds (struct arg_data *arg, struct arg_data *parm)
5606 {
5607 rtx slot = NULL, ptr = NULL, addr = NULL;
5608
5609 /* We may pass bounds not associated with any pointer. */
5610 if (!parm)
5611 {
5612 gcc_assert (arg->special_slot);
5613 slot = arg->special_slot;
5614 ptr = const0_rtx;
5615 }
5616 /* Find pointer associated with bounds and where it is
5617 passed. */
5618 else
5619 {
5620 if (!parm->reg)
5621 {
5622 gcc_assert (!arg->special_slot);
5623
5624 addr = adjust_address (parm->stack, Pmode, arg->pointer_offset);
5625 }
5626 else if (REG_P (parm->reg))
5627 {
5628 gcc_assert (arg->special_slot);
5629 slot = arg->special_slot;
5630
5631 if (MEM_P (parm->value))
5632 addr = adjust_address (parm->value, Pmode, arg->pointer_offset);
5633 else if (REG_P (parm->value))
5634 ptr = gen_rtx_SUBREG (Pmode, parm->value, arg->pointer_offset);
5635 else
5636 {
5637 gcc_assert (!arg->pointer_offset);
5638 ptr = parm->value;
5639 }
5640 }
5641 else
5642 {
5643 gcc_assert (GET_CODE (parm->reg) == PARALLEL);
5644
5645 gcc_assert (arg->special_slot);
5646 slot = arg->special_slot;
5647
5648 if (parm->parallel_value)
5649 ptr = chkp_get_value_with_offs (parm->parallel_value,
5650 GEN_INT (arg->pointer_offset));
5651 else
5652 gcc_unreachable ();
5653 }
5654 }
5655
5656 /* Expand bounds. */
5657 if (!arg->value)
5658 arg->value = expand_normal (arg->tree_value);
5659
5660 targetm.calls.store_bounds_for_arg (ptr, addr, arg->value, slot);
5661 }
5662
5663 /* Store a single argument for a function call
5664 into the register or memory area where it must be passed.
5665 *ARG describes the argument value and where to pass it.
5666
5667 ARGBLOCK is the address of the stack-block for all the arguments,
5668 or 0 on a machine where arguments are pushed individually.
5669
5670 MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
5671 so must be careful about how the stack is used.
5672
5673 VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
5674 argument stack. This is used if ACCUMULATE_OUTGOING_ARGS to indicate
5675 that we need not worry about saving and restoring the stack.
5676
5677 FNDECL is the declaration of the function we are calling.
5678
5679 Return nonzero if this arg should cause sibcall failure,
5680 zero otherwise. */
5681
5682 static int
store_one_arg(struct arg_data * arg,rtx argblock,int flags,int variable_size ATTRIBUTE_UNUSED,int reg_parm_stack_space)5683 store_one_arg (struct arg_data *arg, rtx argblock, int flags,
5684 int variable_size ATTRIBUTE_UNUSED, int reg_parm_stack_space)
5685 {
5686 tree pval = arg->tree_value;
5687 rtx reg = 0;
5688 int partial = 0;
5689 poly_int64 used = 0;
5690 poly_int64 lower_bound = 0, upper_bound = 0;
5691 int sibcall_failure = 0;
5692
5693 if (TREE_CODE (pval) == ERROR_MARK)
5694 return 1;
5695
5696 /* Push a new temporary level for any temporaries we make for
5697 this argument. */
5698 push_temp_slots ();
5699
5700 if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL))
5701 {
5702 /* If this is being stored into a pre-allocated, fixed-size, stack area,
5703 save any previous data at that location. */
5704 if (argblock && ! variable_size && arg->stack)
5705 {
5706 if (ARGS_GROW_DOWNWARD)
5707 {
5708 /* stack_slot is negative, but we want to index stack_usage_map
5709 with positive values. */
5710 if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
5711 {
5712 rtx offset = XEXP (XEXP (arg->stack_slot, 0), 1);
5713 upper_bound = -rtx_to_poly_int64 (offset) + 1;
5714 }
5715 else
5716 upper_bound = 0;
5717
5718 lower_bound = upper_bound - arg->locate.size.constant;
5719 }
5720 else
5721 {
5722 if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
5723 {
5724 rtx offset = XEXP (XEXP (arg->stack_slot, 0), 1);
5725 lower_bound = rtx_to_poly_int64 (offset);
5726 }
5727 else
5728 lower_bound = 0;
5729
5730 upper_bound = lower_bound + arg->locate.size.constant;
5731 }
5732
5733 if (stack_region_maybe_used_p (lower_bound, upper_bound,
5734 reg_parm_stack_space))
5735 {
5736 /* We need to make a save area. */
5737 poly_uint64 size = arg->locate.size.constant * BITS_PER_UNIT;
5738 machine_mode save_mode
5739 = int_mode_for_size (size, 1).else_blk ();
5740 rtx adr = memory_address (save_mode, XEXP (arg->stack_slot, 0));
5741 rtx stack_area = gen_rtx_MEM (save_mode, adr);
5742
5743 if (save_mode == BLKmode)
5744 {
5745 arg->save_area
5746 = assign_temp (TREE_TYPE (arg->tree_value), 1, 1);
5747 preserve_temp_slots (arg->save_area);
5748 emit_block_move (validize_mem (copy_rtx (arg->save_area)),
5749 stack_area,
5750 (gen_int_mode
5751 (arg->locate.size.constant, Pmode)),
5752 BLOCK_OP_CALL_PARM);
5753 }
5754 else
5755 {
5756 arg->save_area = gen_reg_rtx (save_mode);
5757 emit_move_insn (arg->save_area, stack_area);
5758 }
5759 }
5760 }
5761 }
5762
5763 /* If this isn't going to be placed on both the stack and in registers,
5764 set up the register and number of words. */
5765 if (! arg->pass_on_stack)
5766 {
5767 if (flags & ECF_SIBCALL)
5768 reg = arg->tail_call_reg;
5769 else
5770 reg = arg->reg;
5771 partial = arg->partial;
5772 }
5773
5774 /* Being passed entirely in a register. We shouldn't be called in
5775 this case. */
5776 gcc_assert (reg == 0 || partial != 0);
5777
5778 /* If this arg needs special alignment, don't load the registers
5779 here. */
5780 if (arg->n_aligned_regs != 0)
5781 reg = 0;
5782
5783 /* If this is being passed partially in a register, we can't evaluate
5784 it directly into its stack slot. Otherwise, we can. */
5785 if (arg->value == 0)
5786 {
5787 /* stack_arg_under_construction is nonzero if a function argument is
5788 being evaluated directly into the outgoing argument list and
5789 expand_call must take special action to preserve the argument list
5790 if it is called recursively.
5791
5792 For scalar function arguments stack_usage_map is sufficient to
5793 determine which stack slots must be saved and restored. Scalar
5794 arguments in general have pass_on_stack == 0.
5795
5796 If this argument is initialized by a function which takes the
5797 address of the argument (a C++ constructor or a C function
5798 returning a BLKmode structure), then stack_usage_map is
5799 insufficient and expand_call must push the stack around the
5800 function call. Such arguments have pass_on_stack == 1.
5801
5802 Note that it is always safe to set stack_arg_under_construction,
5803 but this generates suboptimal code if set when not needed. */
5804
5805 if (arg->pass_on_stack)
5806 stack_arg_under_construction++;
5807
5808 arg->value = expand_expr (pval,
5809 (partial
5810 || TYPE_MODE (TREE_TYPE (pval)) != arg->mode)
5811 ? NULL_RTX : arg->stack,
5812 VOIDmode, EXPAND_STACK_PARM);
5813
5814 /* If we are promoting object (or for any other reason) the mode
5815 doesn't agree, convert the mode. */
5816
5817 if (arg->mode != TYPE_MODE (TREE_TYPE (pval)))
5818 arg->value = convert_modes (arg->mode, TYPE_MODE (TREE_TYPE (pval)),
5819 arg->value, arg->unsignedp);
5820
5821 if (arg->pass_on_stack)
5822 stack_arg_under_construction--;
5823 }
5824
5825 /* Check for overlap with already clobbered argument area. */
5826 if ((flags & ECF_SIBCALL)
5827 && MEM_P (arg->value)
5828 && mem_might_overlap_already_clobbered_arg_p (XEXP (arg->value, 0),
5829 arg->locate.size.constant))
5830 sibcall_failure = 1;
5831
5832 /* Don't allow anything left on stack from computation
5833 of argument to alloca. */
5834 if (flags & ECF_MAY_BE_ALLOCA)
5835 do_pending_stack_adjust ();
5836
5837 if (arg->value == arg->stack)
5838 /* If the value is already in the stack slot, we are done. */
5839 ;
5840 else if (arg->mode != BLKmode)
5841 {
5842 unsigned int parm_align;
5843
5844 /* Argument is a scalar, not entirely passed in registers.
5845 (If part is passed in registers, arg->partial says how much
5846 and emit_push_insn will take care of putting it there.)
5847
5848 Push it, and if its size is less than the
5849 amount of space allocated to it,
5850 also bump stack pointer by the additional space.
5851 Note that in C the default argument promotions
5852 will prevent such mismatches. */
5853
5854 poly_int64 size = (TYPE_EMPTY_P (TREE_TYPE (pval))
5855 ? 0 : GET_MODE_SIZE (arg->mode));
5856
5857 /* Compute how much space the push instruction will push.
5858 On many machines, pushing a byte will advance the stack
5859 pointer by a halfword. */
5860 #ifdef PUSH_ROUNDING
5861 size = PUSH_ROUNDING (size);
5862 #endif
5863 used = size;
5864
5865 /* Compute how much space the argument should get:
5866 round up to a multiple of the alignment for arguments. */
5867 if (targetm.calls.function_arg_padding (arg->mode, TREE_TYPE (pval))
5868 != PAD_NONE)
5869 /* At the moment we don't (need to) support ABIs for which the
5870 padding isn't known at compile time. In principle it should
5871 be easy to add though. */
5872 used = force_align_up (size, PARM_BOUNDARY / BITS_PER_UNIT);
5873
5874 /* Compute the alignment of the pushed argument. */
5875 parm_align = arg->locate.boundary;
5876 if (targetm.calls.function_arg_padding (arg->mode, TREE_TYPE (pval))
5877 == PAD_DOWNWARD)
5878 {
5879 poly_int64 pad = used - size;
5880 unsigned int pad_align = known_alignment (pad) * BITS_PER_UNIT;
5881 if (pad_align != 0)
5882 parm_align = MIN (parm_align, pad_align);
5883 }
5884
5885 /* This isn't already where we want it on the stack, so put it there.
5886 This can either be done with push or copy insns. */
5887 if (maybe_ne (used, 0)
5888 && !emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval),
5889 NULL_RTX, parm_align, partial, reg, used - size,
5890 argblock, ARGS_SIZE_RTX (arg->locate.offset),
5891 reg_parm_stack_space,
5892 ARGS_SIZE_RTX (arg->locate.alignment_pad), true))
5893 sibcall_failure = 1;
5894
5895 /* Unless this is a partially-in-register argument, the argument is now
5896 in the stack. */
5897 if (partial == 0)
5898 arg->value = arg->stack;
5899 }
5900 else
5901 {
5902 /* BLKmode, at least partly to be pushed. */
5903
5904 unsigned int parm_align;
5905 poly_int64 excess;
5906 rtx size_rtx;
5907
5908 /* Pushing a nonscalar.
5909 If part is passed in registers, PARTIAL says how much
5910 and emit_push_insn will take care of putting it there. */
5911
5912 /* Round its size up to a multiple
5913 of the allocation unit for arguments. */
5914
5915 if (arg->locate.size.var != 0)
5916 {
5917 excess = 0;
5918 size_rtx = ARGS_SIZE_RTX (arg->locate.size);
5919 }
5920 else
5921 {
5922 /* PUSH_ROUNDING has no effect on us, because emit_push_insn
5923 for BLKmode is careful to avoid it. */
5924 excess = (arg->locate.size.constant
5925 - arg_int_size_in_bytes (TREE_TYPE (pval))
5926 + partial);
5927 size_rtx = expand_expr (arg_size_in_bytes (TREE_TYPE (pval)),
5928 NULL_RTX, TYPE_MODE (sizetype),
5929 EXPAND_NORMAL);
5930 }
5931
5932 parm_align = arg->locate.boundary;
5933
5934 /* When an argument is padded down, the block is aligned to
5935 PARM_BOUNDARY, but the actual argument isn't. */
5936 if (targetm.calls.function_arg_padding (arg->mode, TREE_TYPE (pval))
5937 == PAD_DOWNWARD)
5938 {
5939 if (arg->locate.size.var)
5940 parm_align = BITS_PER_UNIT;
5941 else
5942 {
5943 unsigned int excess_align
5944 = known_alignment (excess) * BITS_PER_UNIT;
5945 if (excess_align != 0)
5946 parm_align = MIN (parm_align, excess_align);
5947 }
5948 }
5949
5950 if ((flags & ECF_SIBCALL) && MEM_P (arg->value))
5951 {
5952 /* emit_push_insn might not work properly if arg->value and
5953 argblock + arg->locate.offset areas overlap. */
5954 rtx x = arg->value;
5955 poly_int64 i = 0;
5956
5957 if (XEXP (x, 0) == crtl->args.internal_arg_pointer
5958 || (GET_CODE (XEXP (x, 0)) == PLUS
5959 && XEXP (XEXP (x, 0), 0) ==
5960 crtl->args.internal_arg_pointer
5961 && CONST_INT_P (XEXP (XEXP (x, 0), 1))))
5962 {
5963 if (XEXP (x, 0) != crtl->args.internal_arg_pointer)
5964 i = rtx_to_poly_int64 (XEXP (XEXP (x, 0), 1));
5965
5966 /* arg.locate doesn't contain the pretend_args_size offset,
5967 it's part of argblock. Ensure we don't count it in I. */
5968 if (STACK_GROWS_DOWNWARD)
5969 i -= crtl->args.pretend_args_size;
5970 else
5971 i += crtl->args.pretend_args_size;
5972
5973 /* expand_call should ensure this. */
5974 gcc_assert (!arg->locate.offset.var
5975 && arg->locate.size.var == 0);
5976 poly_int64 size_val = rtx_to_poly_int64 (size_rtx);
5977
5978 if (known_eq (arg->locate.offset.constant, i))
5979 {
5980 /* Even though they appear to be at the same location,
5981 if part of the outgoing argument is in registers,
5982 they aren't really at the same location. Check for
5983 this by making sure that the incoming size is the
5984 same as the outgoing size. */
5985 if (maybe_ne (arg->locate.size.constant, size_val))
5986 sibcall_failure = 1;
5987 }
5988 else if (maybe_in_range_p (arg->locate.offset.constant,
5989 i, size_val))
5990 sibcall_failure = 1;
5991 /* Use arg->locate.size.constant instead of size_rtx
5992 because we only care about the part of the argument
5993 on the stack. */
5994 else if (maybe_in_range_p (i, arg->locate.offset.constant,
5995 arg->locate.size.constant))
5996 sibcall_failure = 1;
5997 }
5998 }
5999
6000 if (!CONST_INT_P (size_rtx) || INTVAL (size_rtx) != 0)
6001 emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
6002 parm_align, partial, reg, excess, argblock,
6003 ARGS_SIZE_RTX (arg->locate.offset),
6004 reg_parm_stack_space,
6005 ARGS_SIZE_RTX (arg->locate.alignment_pad), false);
6006
6007 /* Unless this is a partially-in-register argument, the argument is now
6008 in the stack.
6009
6010 ??? Unlike the case above, in which we want the actual
6011 address of the data, so that we can load it directly into a
6012 register, here we want the address of the stack slot, so that
6013 it's properly aligned for word-by-word copying or something
6014 like that. It's not clear that this is always correct. */
6015 if (partial == 0)
6016 arg->value = arg->stack_slot;
6017 }
6018
6019 if (arg->reg && GET_CODE (arg->reg) == PARALLEL)
6020 {
6021 tree type = TREE_TYPE (arg->tree_value);
6022 arg->parallel_value
6023 = emit_group_load_into_temps (arg->reg, arg->value, type,
6024 int_size_in_bytes (type));
6025 }
6026
6027 /* Mark all slots this store used. */
6028 if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL)
6029 && argblock && ! variable_size && arg->stack)
6030 mark_stack_region_used (lower_bound, upper_bound);
6031
6032 /* Once we have pushed something, pops can't safely
6033 be deferred during the rest of the arguments. */
6034 NO_DEFER_POP;
6035
6036 /* Free any temporary slots made in processing this argument. */
6037 pop_temp_slots ();
6038
6039 return sibcall_failure;
6040 }
6041
6042 /* Nonzero if we do not know how to pass TYPE solely in registers. */
6043
6044 bool
must_pass_in_stack_var_size(machine_mode mode ATTRIBUTE_UNUSED,const_tree type)6045 must_pass_in_stack_var_size (machine_mode mode ATTRIBUTE_UNUSED,
6046 const_tree type)
6047 {
6048 if (!type)
6049 return false;
6050
6051 /* If the type has variable size... */
6052 if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
6053 return true;
6054
6055 /* If the type is marked as addressable (it is required
6056 to be constructed into the stack)... */
6057 if (TREE_ADDRESSABLE (type))
6058 return true;
6059
6060 return false;
6061 }
6062
6063 /* Another version of the TARGET_MUST_PASS_IN_STACK hook. This one
6064 takes trailing padding of a structure into account. */
6065 /* ??? Should be able to merge these two by examining BLOCK_REG_PADDING. */
6066
6067 bool
must_pass_in_stack_var_size_or_pad(machine_mode mode,const_tree type)6068 must_pass_in_stack_var_size_or_pad (machine_mode mode, const_tree type)
6069 {
6070 if (!type)
6071 return false;
6072
6073 /* If the type has variable size... */
6074 if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
6075 return true;
6076
6077 /* If the type is marked as addressable (it is required
6078 to be constructed into the stack)... */
6079 if (TREE_ADDRESSABLE (type))
6080 return true;
6081
6082 if (TYPE_EMPTY_P (type))
6083 return false;
6084
6085 /* If the padding and mode of the type is such that a copy into
6086 a register would put it into the wrong part of the register. */
6087 if (mode == BLKmode
6088 && int_size_in_bytes (type) % (PARM_BOUNDARY / BITS_PER_UNIT)
6089 && (targetm.calls.function_arg_padding (mode, type)
6090 == (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD)))
6091 return true;
6092
6093 return false;
6094 }
6095
6096 /* Tell the garbage collector about GTY markers in this source file. */
6097 #include "gt-calls.h"
6098