1 /* Convert function calls to rtl insns, for GNU C compiler.
2 Copyright (C) 1989-2018 Free Software Foundation, Inc.
4 This file is part of GCC.
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
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
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/>. */
22 #include "coretypes.h"
31 #include "stringpool.h"
36 #include "diagnostic-core.h"
37 #include "fold-const.h"
38 #include "stor-layout.h"
40 #include "internal-fn.h"
46 #include "langhooks.h"
50 #include "tree-chkp.h"
52 #include "tree-ssanames.h"
55 #include "stringpool.h"
58 #include "gimple-fold.h"
60 /* Like PREFERRED_STACK_BOUNDARY but in units of bytes, not bits. */
61 #define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)
63 /* Data structure and subroutines used within expand_call. */
67 /* Tree node for this argument. */
69 /* Mode for value; TYPE_MODE unless promoted. */
71 /* Current RTL value for argument, or 0 if it isn't precomputed. */
73 /* Initially-compute RTL value for argument; only for const functions. */
75 /* Register to pass this argument in, 0 if passed on stack, or an
76 PARALLEL if the arg is to be copied into multiple non-contiguous
79 /* Register to pass this argument in when generating tail call sequence.
80 This is not the same register as for normal calls on machines with
83 /* If REG is a PARALLEL, this is a copy of VALUE pulled into the correct
84 form for emit_group_move. */
86 /* If value is passed in neither reg nor stack, this field holds a number
87 of a special slot to be used. */
89 /* For pointer bounds hold an index of parm bounds are bound to. -1 if
90 there is no such pointer. */
92 /* If pointer_arg refers a structure, then pointer_offset holds an offset
93 of a pointer in this structure. */
95 /* If REG was promoted from the actual mode of the argument expression,
96 indicates whether the promotion is sign- or zero-extended. */
98 /* Number of bytes to put in registers. 0 means put the whole arg
99 in registers. Also 0 if not passed in registers. */
101 /* Nonzero if argument must be passed on stack.
102 Note that some arguments may be passed on the stack
103 even though pass_on_stack is zero, just because FUNCTION_ARG says so.
104 pass_on_stack identifies arguments that *cannot* go in registers. */
106 /* Some fields packaged up for locate_and_pad_parm. */
107 struct locate_and_pad_arg_data locate
;
108 /* Location on the stack at which parameter should be stored. The store
109 has already been done if STACK == VALUE. */
111 /* Location on the stack of the start of this argument slot. This can
112 differ from STACK if this arg pads downward. This location is known
113 to be aligned to TARGET_FUNCTION_ARG_BOUNDARY. */
115 /* Place that this stack area has been saved, if needed. */
117 /* If an argument's alignment does not permit direct copying into registers,
118 copy in smaller-sized pieces into pseudos. These are stored in a
119 block pointed to by this field. The next field says how many
120 word-sized pseudos we made. */
125 /* A vector of one char per byte of stack space. A byte if nonzero if
126 the corresponding stack location has been used.
127 This vector is used to prevent a function call within an argument from
128 clobbering any stack already set up. */
129 static char *stack_usage_map
;
131 /* Size of STACK_USAGE_MAP. */
132 static unsigned int highest_outgoing_arg_in_use
;
134 /* Assume that any stack location at this byte index is used,
135 without checking the contents of stack_usage_map. */
136 static unsigned HOST_WIDE_INT stack_usage_watermark
= HOST_WIDE_INT_M1U
;
138 /* A bitmap of virtual-incoming stack space. Bit is set if the corresponding
139 stack location's tail call argument has been already stored into the stack.
140 This bitmap is used to prevent sibling call optimization if function tries
141 to use parent's incoming argument slots when they have been already
142 overwritten with tail call arguments. */
143 static sbitmap stored_args_map
;
145 /* Assume that any virtual-incoming location at this byte index has been
146 stored, without checking the contents of stored_args_map. */
147 static unsigned HOST_WIDE_INT stored_args_watermark
;
149 /* stack_arg_under_construction is nonzero when an argument may be
150 initialized with a constructor call (including a C function that
151 returns a BLKmode struct) and expand_call must take special action
152 to make sure the object being constructed does not overlap the
153 argument list for the constructor call. */
154 static int stack_arg_under_construction
;
156 static void precompute_register_parameters (int, struct arg_data
*, int *);
157 static void store_bounds (struct arg_data
*, struct arg_data
*);
158 static int store_one_arg (struct arg_data
*, rtx
, int, int, int);
159 static void store_unaligned_arguments_into_pseudos (struct arg_data
*, int);
160 static int finalize_must_preallocate (int, int, struct arg_data
*,
162 static void precompute_arguments (int, struct arg_data
*);
163 static void compute_argument_addresses (struct arg_data
*, rtx
, int);
164 static rtx
rtx_for_function_call (tree
, tree
);
165 static void load_register_parameters (struct arg_data
*, int, rtx
*, int,
167 static int special_function_p (const_tree
, int);
168 static int check_sibcall_argument_overlap_1 (rtx
);
169 static int check_sibcall_argument_overlap (rtx_insn
*, struct arg_data
*, int);
171 static tree
split_complex_types (tree
);
173 #ifdef REG_PARM_STACK_SPACE
174 static rtx
save_fixed_argument_area (int, rtx
, int *, int *);
175 static void restore_fixed_argument_area (rtx
, rtx
, int, int);
178 /* Return true if bytes [LOWER_BOUND, UPPER_BOUND) of the outgoing
179 stack region might already be in use. */
182 stack_region_maybe_used_p (poly_uint64 lower_bound
, poly_uint64 upper_bound
,
183 unsigned int reg_parm_stack_space
)
185 unsigned HOST_WIDE_INT const_lower
, const_upper
;
186 const_lower
= constant_lower_bound (lower_bound
);
187 if (!upper_bound
.is_constant (&const_upper
))
188 const_upper
= HOST_WIDE_INT_M1U
;
190 if (const_upper
> stack_usage_watermark
)
193 /* Don't worry about things in the fixed argument area;
194 it has already been saved. */
195 const_lower
= MAX (const_lower
, reg_parm_stack_space
);
196 const_upper
= MIN (const_upper
, highest_outgoing_arg_in_use
);
197 for (unsigned HOST_WIDE_INT i
= const_lower
; i
< const_upper
; ++i
)
198 if (stack_usage_map
[i
])
203 /* Record that bytes [LOWER_BOUND, UPPER_BOUND) of the outgoing
204 stack region are now in use. */
207 mark_stack_region_used (poly_uint64 lower_bound
, poly_uint64 upper_bound
)
209 unsigned HOST_WIDE_INT const_lower
, const_upper
;
210 const_lower
= constant_lower_bound (lower_bound
);
211 if (upper_bound
.is_constant (&const_upper
))
212 for (unsigned HOST_WIDE_INT i
= const_lower
; i
< const_upper
; ++i
)
213 stack_usage_map
[i
] = 1;
215 stack_usage_watermark
= MIN (stack_usage_watermark
, const_lower
);
218 /* Force FUNEXP into a form suitable for the address of a CALL,
219 and return that as an rtx. Also load the static chain register
220 if FNDECL is a nested function.
222 CALL_FUSAGE points to a variable holding the prospective
223 CALL_INSN_FUNCTION_USAGE information. */
226 prepare_call_address (tree fndecl_or_type
, rtx funexp
, rtx static_chain_value
,
227 rtx
*call_fusage
, int reg_parm_seen
, int flags
)
229 /* Make a valid memory address and copy constants through pseudo-regs,
230 but not for a constant address if -fno-function-cse. */
231 if (GET_CODE (funexp
) != SYMBOL_REF
)
233 /* If it's an indirect call by descriptor, generate code to perform
234 runtime identification of the pointer and load the descriptor. */
235 if ((flags
& ECF_BY_DESCRIPTOR
) && !flag_trampolines
)
237 const int bit_val
= targetm
.calls
.custom_function_descriptors
;
238 rtx call_lab
= gen_label_rtx ();
240 gcc_assert (fndecl_or_type
&& TYPE_P (fndecl_or_type
));
242 = build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
, NULL_TREE
,
244 DECL_STATIC_CHAIN (fndecl_or_type
) = 1;
245 rtx chain
= targetm
.calls
.static_chain (fndecl_or_type
, false);
247 if (GET_MODE (funexp
) != Pmode
)
248 funexp
= convert_memory_address (Pmode
, funexp
);
250 /* Avoid long live ranges around function calls. */
251 funexp
= copy_to_mode_reg (Pmode
, funexp
);
254 emit_insn (gen_rtx_CLOBBER (VOIDmode
, chain
));
256 /* Emit the runtime identification pattern. */
257 rtx mask
= gen_rtx_AND (Pmode
, funexp
, GEN_INT (bit_val
));
258 emit_cmp_and_jump_insns (mask
, const0_rtx
, EQ
, NULL_RTX
, Pmode
, 1,
261 /* Statically predict the branch to very likely taken. */
262 rtx_insn
*insn
= get_last_insn ();
264 predict_insn_def (insn
, PRED_BUILTIN_EXPECT
, TAKEN
);
266 /* Load the descriptor. */
267 rtx mem
= gen_rtx_MEM (ptr_mode
,
268 plus_constant (Pmode
, funexp
, - bit_val
));
269 MEM_NOTRAP_P (mem
) = 1;
270 mem
= convert_memory_address (Pmode
, mem
);
271 emit_move_insn (chain
, mem
);
273 mem
= gen_rtx_MEM (ptr_mode
,
274 plus_constant (Pmode
, funexp
,
275 POINTER_SIZE
/ BITS_PER_UNIT
277 MEM_NOTRAP_P (mem
) = 1;
278 mem
= convert_memory_address (Pmode
, mem
);
279 emit_move_insn (funexp
, mem
);
281 emit_label (call_lab
);
285 use_reg (call_fusage
, chain
);
286 STATIC_CHAIN_REG_P (chain
) = 1;
289 /* Make sure we're not going to be overwritten below. */
290 gcc_assert (!static_chain_value
);
293 /* If we are using registers for parameters, force the
294 function address into a register now. */
295 funexp
= ((reg_parm_seen
296 && targetm
.small_register_classes_for_mode_p (FUNCTION_MODE
))
297 ? force_not_mem (memory_address (FUNCTION_MODE
, funexp
))
298 : memory_address (FUNCTION_MODE
, funexp
));
302 /* funexp could be a SYMBOL_REF represents a function pointer which is
303 of ptr_mode. In this case, it should be converted into address mode
304 to be a valid address for memory rtx pattern. See PR 64971. */
305 if (GET_MODE (funexp
) != Pmode
)
306 funexp
= convert_memory_address (Pmode
, funexp
);
308 if (!(flags
& ECF_SIBCALL
))
310 if (!NO_FUNCTION_CSE
&& optimize
&& ! flag_no_function_cse
)
311 funexp
= force_reg (Pmode
, funexp
);
315 if (static_chain_value
!= 0
316 && (TREE_CODE (fndecl_or_type
) != FUNCTION_DECL
317 || DECL_STATIC_CHAIN (fndecl_or_type
)))
321 chain
= targetm
.calls
.static_chain (fndecl_or_type
, false);
322 static_chain_value
= convert_memory_address (Pmode
, static_chain_value
);
324 emit_move_insn (chain
, static_chain_value
);
327 use_reg (call_fusage
, chain
);
328 STATIC_CHAIN_REG_P (chain
) = 1;
335 /* Generate instructions to call function FUNEXP,
336 and optionally pop the results.
337 The CALL_INSN is the first insn generated.
339 FNDECL is the declaration node of the function. This is given to the
340 hook TARGET_RETURN_POPS_ARGS to determine whether this function pops
343 FUNTYPE is the data type of the function. This is given to the hook
344 TARGET_RETURN_POPS_ARGS to determine whether this function pops its
345 own args. We used to allow an identifier for library functions, but
346 that doesn't work when the return type is an aggregate type and the
347 calling convention says that the pointer to this aggregate is to be
348 popped by the callee.
350 STACK_SIZE is the number of bytes of arguments on the stack,
351 ROUNDED_STACK_SIZE is that number rounded up to
352 PREFERRED_STACK_BOUNDARY; zero if the size is variable. This is
353 both to put into the call insn and to generate explicit popping
356 STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
357 It is zero if this call doesn't want a structure value.
359 NEXT_ARG_REG is the rtx that results from executing
360 targetm.calls.function_arg (&args_so_far, VOIDmode, void_type_node, true)
361 just after all the args have had their registers assigned.
362 This could be whatever you like, but normally it is the first
363 arg-register beyond those used for args in this call,
364 or 0 if all the arg-registers are used in this call.
365 It is passed on to `gen_call' so you can put this info in the call insn.
367 VALREG is a hard register in which a value is returned,
368 or 0 if the call does not return a value.
370 OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before
371 the args to this call were processed.
372 We restore `inhibit_defer_pop' to that value.
374 CALL_FUSAGE is either empty or an EXPR_LIST of USE expressions that
375 denote registers used by the called function. */
378 emit_call_1 (rtx funexp
, tree fntree ATTRIBUTE_UNUSED
, tree fndecl ATTRIBUTE_UNUSED
,
379 tree funtype ATTRIBUTE_UNUSED
,
380 poly_int64 stack_size ATTRIBUTE_UNUSED
,
381 poly_int64 rounded_stack_size
,
382 poly_int64 struct_value_size ATTRIBUTE_UNUSED
,
383 rtx next_arg_reg ATTRIBUTE_UNUSED
, rtx valreg
,
384 int old_inhibit_defer_pop
, rtx call_fusage
, int ecf_flags
,
385 cumulative_args_t args_so_far ATTRIBUTE_UNUSED
)
387 rtx rounded_stack_size_rtx
= gen_int_mode (rounded_stack_size
, Pmode
);
388 rtx call
, funmem
, pat
;
389 int already_popped
= 0;
390 poly_int64 n_popped
= 0;
392 /* Sibling call patterns never pop arguments (no sibcall(_value)_pop
393 patterns exist). Any popping that the callee does on return will
394 be from our caller's frame rather than ours. */
395 if (!(ecf_flags
& ECF_SIBCALL
))
397 n_popped
+= targetm
.calls
.return_pops_args (fndecl
, funtype
, stack_size
);
399 #ifdef CALL_POPS_ARGS
400 n_popped
+= CALL_POPS_ARGS (*get_cumulative_args (args_so_far
));
404 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
405 and we don't want to load it into a register as an optimization,
406 because prepare_call_address already did it if it should be done. */
407 if (GET_CODE (funexp
) != SYMBOL_REF
)
408 funexp
= memory_address (FUNCTION_MODE
, funexp
);
410 funmem
= gen_rtx_MEM (FUNCTION_MODE
, funexp
);
411 if (fndecl
&& TREE_CODE (fndecl
) == FUNCTION_DECL
)
415 /* Although a built-in FUNCTION_DECL and its non-__builtin
416 counterpart compare equal and get a shared mem_attrs, they
417 produce different dump output in compare-debug compilations,
418 if an entry gets garbage collected in one compilation, then
419 adds a different (but equivalent) entry, while the other
420 doesn't run the garbage collector at the same spot and then
421 shares the mem_attr with the equivalent entry. */
422 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
424 tree t2
= builtin_decl_explicit (DECL_FUNCTION_CODE (t
));
429 set_mem_expr (funmem
, t
);
432 set_mem_expr (funmem
, build_simple_mem_ref (CALL_EXPR_FN (fntree
)));
434 if (ecf_flags
& ECF_SIBCALL
)
437 pat
= targetm
.gen_sibcall_value (valreg
, funmem
,
438 rounded_stack_size_rtx
,
439 next_arg_reg
, NULL_RTX
);
441 pat
= targetm
.gen_sibcall (funmem
, rounded_stack_size_rtx
,
443 gen_int_mode (struct_value_size
, Pmode
));
445 /* If the target has "call" or "call_value" insns, then prefer them
446 if no arguments are actually popped. If the target does not have
447 "call" or "call_value" insns, then we must use the popping versions
448 even if the call has no arguments to pop. */
449 else if (maybe_ne (n_popped
, 0)
451 ? targetm
.have_call_value ()
452 : targetm
.have_call ()))
454 rtx n_pop
= gen_int_mode (n_popped
, Pmode
);
456 /* If this subroutine pops its own args, record that in the call insn
457 if possible, for the sake of frame pointer elimination. */
460 pat
= targetm
.gen_call_value_pop (valreg
, funmem
,
461 rounded_stack_size_rtx
,
462 next_arg_reg
, n_pop
);
464 pat
= targetm
.gen_call_pop (funmem
, rounded_stack_size_rtx
,
465 next_arg_reg
, n_pop
);
472 pat
= targetm
.gen_call_value (valreg
, funmem
, rounded_stack_size_rtx
,
473 next_arg_reg
, NULL_RTX
);
475 pat
= targetm
.gen_call (funmem
, rounded_stack_size_rtx
, next_arg_reg
,
476 gen_int_mode (struct_value_size
, Pmode
));
480 /* Find the call we just emitted. */
481 rtx_call_insn
*call_insn
= last_call_insn ();
483 /* Some target create a fresh MEM instead of reusing the one provided
484 above. Set its MEM_EXPR. */
485 call
= get_call_rtx_from (call_insn
);
487 && MEM_EXPR (XEXP (call
, 0)) == NULL_TREE
488 && MEM_EXPR (funmem
) != NULL_TREE
)
489 set_mem_expr (XEXP (call
, 0), MEM_EXPR (funmem
));
491 /* Mark instrumented calls. */
493 CALL_EXPR_WITH_BOUNDS_P (call
) = CALL_WITH_BOUNDS_P (fntree
);
495 /* Put the register usage information there. */
496 add_function_usage_to (call_insn
, call_fusage
);
498 /* If this is a const call, then set the insn's unchanging bit. */
499 if (ecf_flags
& ECF_CONST
)
500 RTL_CONST_CALL_P (call_insn
) = 1;
502 /* If this is a pure call, then set the insn's unchanging bit. */
503 if (ecf_flags
& ECF_PURE
)
504 RTL_PURE_CALL_P (call_insn
) = 1;
506 /* If this is a const call, then set the insn's unchanging bit. */
507 if (ecf_flags
& ECF_LOOPING_CONST_OR_PURE
)
508 RTL_LOOPING_CONST_OR_PURE_CALL_P (call_insn
) = 1;
510 /* Create a nothrow REG_EH_REGION note, if needed. */
511 make_reg_eh_region_note (call_insn
, ecf_flags
, 0);
513 if (ecf_flags
& ECF_NORETURN
)
514 add_reg_note (call_insn
, REG_NORETURN
, const0_rtx
);
516 if (ecf_flags
& ECF_RETURNS_TWICE
)
518 add_reg_note (call_insn
, REG_SETJMP
, const0_rtx
);
519 cfun
->calls_setjmp
= 1;
522 SIBLING_CALL_P (call_insn
) = ((ecf_flags
& ECF_SIBCALL
) != 0);
524 /* Restore this now, so that we do defer pops for this call's args
525 if the context of the call as a whole permits. */
526 inhibit_defer_pop
= old_inhibit_defer_pop
;
528 if (maybe_ne (n_popped
, 0))
531 CALL_INSN_FUNCTION_USAGE (call_insn
)
532 = gen_rtx_EXPR_LIST (VOIDmode
,
533 gen_rtx_CLOBBER (VOIDmode
, stack_pointer_rtx
),
534 CALL_INSN_FUNCTION_USAGE (call_insn
));
535 rounded_stack_size
-= n_popped
;
536 rounded_stack_size_rtx
= gen_int_mode (rounded_stack_size
, Pmode
);
537 stack_pointer_delta
-= n_popped
;
539 add_args_size_note (call_insn
, stack_pointer_delta
);
541 /* If popup is needed, stack realign must use DRAP */
542 if (SUPPORTS_STACK_ALIGNMENT
)
543 crtl
->need_drap
= true;
545 /* For noreturn calls when not accumulating outgoing args force
546 REG_ARGS_SIZE note to prevent crossjumping of calls with different
548 else if (!ACCUMULATE_OUTGOING_ARGS
&& (ecf_flags
& ECF_NORETURN
) != 0)
549 add_args_size_note (call_insn
, stack_pointer_delta
);
551 if (!ACCUMULATE_OUTGOING_ARGS
)
553 /* If returning from the subroutine does not automatically pop the args,
554 we need an instruction to pop them sooner or later.
555 Perhaps do it now; perhaps just record how much space to pop later.
557 If returning from the subroutine does pop the args, indicate that the
558 stack pointer will be changed. */
560 if (maybe_ne (rounded_stack_size
, 0))
562 if (ecf_flags
& ECF_NORETURN
)
563 /* Just pretend we did the pop. */
564 stack_pointer_delta
-= rounded_stack_size
;
565 else if (flag_defer_pop
&& inhibit_defer_pop
== 0
566 && ! (ecf_flags
& (ECF_CONST
| ECF_PURE
)))
567 pending_stack_adjust
+= rounded_stack_size
;
569 adjust_stack (rounded_stack_size_rtx
);
572 /* When we accumulate outgoing args, we must avoid any stack manipulations.
573 Restore the stack pointer to its original value now. Usually
574 ACCUMULATE_OUTGOING_ARGS targets don't get here, but there are exceptions.
575 On i386 ACCUMULATE_OUTGOING_ARGS can be enabled on demand, and
576 popping variants of functions exist as well.
578 ??? We may optimize similar to defer_pop above, but it is
579 probably not worthwhile.
581 ??? It will be worthwhile to enable combine_stack_adjustments even for
583 else if (maybe_ne (n_popped
, 0))
584 anti_adjust_stack (gen_int_mode (n_popped
, Pmode
));
587 /* Determine if the function identified by FNDECL is one with
588 special properties we wish to know about. Modify FLAGS accordingly.
590 For example, if the function might return more than one time (setjmp), then
591 set ECF_RETURNS_TWICE.
593 Set ECF_MAY_BE_ALLOCA for any memory allocation function that might allocate
594 space from the stack such as alloca. */
597 special_function_p (const_tree fndecl
, int flags
)
599 tree name_decl
= DECL_NAME (fndecl
);
601 /* For instrumentation clones we want to derive flags
602 from the original name. */
603 if (cgraph_node::get (fndecl
)
604 && cgraph_node::get (fndecl
)->instrumentation_clone
)
605 name_decl
= DECL_NAME (cgraph_node::get (fndecl
)->orig_decl
);
607 if (fndecl
&& name_decl
608 && IDENTIFIER_LENGTH (name_decl
) <= 11
609 /* Exclude functions not at the file scope, or not `extern',
610 since they are not the magic functions we would otherwise
612 FIXME: this should be handled with attributes, not with this
613 hacky imitation of DECL_ASSEMBLER_NAME. It's (also) wrong
614 because you can declare fork() inside a function if you
616 && (DECL_CONTEXT (fndecl
) == NULL_TREE
617 || TREE_CODE (DECL_CONTEXT (fndecl
)) == TRANSLATION_UNIT_DECL
)
618 && TREE_PUBLIC (fndecl
))
620 const char *name
= IDENTIFIER_POINTER (name_decl
);
621 const char *tname
= name
;
623 /* We assume that alloca will always be called by name. It
624 makes no sense to pass it as a pointer-to-function to
625 anything that does not understand its behavior. */
626 if (IDENTIFIER_LENGTH (name_decl
) == 6
628 && ! strcmp (name
, "alloca"))
629 flags
|= ECF_MAY_BE_ALLOCA
;
631 /* Disregard prefix _ or __. */
640 /* ECF_RETURNS_TWICE is safe even for -ffreestanding. */
641 if (! strcmp (tname
, "setjmp")
642 || ! strcmp (tname
, "sigsetjmp")
643 || ! strcmp (name
, "savectx")
644 || ! strcmp (name
, "vfork")
645 || ! strcmp (name
, "getcontext"))
646 flags
|= ECF_RETURNS_TWICE
;
649 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
650 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl
)))
651 flags
|= ECF_MAY_BE_ALLOCA
;
656 /* Similar to special_function_p; return a set of ERF_ flags for the
659 decl_return_flags (tree fndecl
)
662 tree type
= TREE_TYPE (fndecl
);
666 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
670 attr
= TREE_VALUE (TREE_VALUE (attr
));
671 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
674 switch (TREE_STRING_POINTER (attr
)[0])
680 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
691 /* Return nonzero when FNDECL represents a call to setjmp. */
694 setjmp_call_p (const_tree fndecl
)
696 if (DECL_IS_RETURNS_TWICE (fndecl
))
697 return ECF_RETURNS_TWICE
;
698 return special_function_p (fndecl
, 0) & ECF_RETURNS_TWICE
;
702 /* Return true if STMT may be an alloca call. */
705 gimple_maybe_alloca_call_p (const gimple
*stmt
)
709 if (!is_gimple_call (stmt
))
712 fndecl
= gimple_call_fndecl (stmt
);
713 if (fndecl
&& (special_function_p (fndecl
, 0) & ECF_MAY_BE_ALLOCA
))
719 /* Return true if STMT is a builtin alloca call. */
722 gimple_alloca_call_p (const gimple
*stmt
)
726 if (!is_gimple_call (stmt
))
729 fndecl
= gimple_call_fndecl (stmt
);
730 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
731 switch (DECL_FUNCTION_CODE (fndecl
))
733 CASE_BUILT_IN_ALLOCA
:
734 return gimple_call_num_args (stmt
) > 0;
742 /* Return true when exp contains a builtin alloca call. */
745 alloca_call_p (const_tree exp
)
748 if (TREE_CODE (exp
) == CALL_EXPR
749 && (fndecl
= get_callee_fndecl (exp
))
750 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
751 switch (DECL_FUNCTION_CODE (fndecl
))
753 CASE_BUILT_IN_ALLOCA
:
762 /* Return TRUE if FNDECL is either a TM builtin or a TM cloned
763 function. Return FALSE otherwise. */
766 is_tm_builtin (const_tree fndecl
)
771 if (decl_is_tm_clone (fndecl
))
774 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
776 switch (DECL_FUNCTION_CODE (fndecl
))
778 case BUILT_IN_TM_COMMIT
:
779 case BUILT_IN_TM_COMMIT_EH
:
780 case BUILT_IN_TM_ABORT
:
781 case BUILT_IN_TM_IRREVOCABLE
:
782 case BUILT_IN_TM_GETTMCLONE_IRR
:
783 case BUILT_IN_TM_MEMCPY
:
784 case BUILT_IN_TM_MEMMOVE
:
785 case BUILT_IN_TM_MEMSET
:
786 CASE_BUILT_IN_TM_STORE (1):
787 CASE_BUILT_IN_TM_STORE (2):
788 CASE_BUILT_IN_TM_STORE (4):
789 CASE_BUILT_IN_TM_STORE (8):
790 CASE_BUILT_IN_TM_STORE (FLOAT
):
791 CASE_BUILT_IN_TM_STORE (DOUBLE
):
792 CASE_BUILT_IN_TM_STORE (LDOUBLE
):
793 CASE_BUILT_IN_TM_STORE (M64
):
794 CASE_BUILT_IN_TM_STORE (M128
):
795 CASE_BUILT_IN_TM_STORE (M256
):
796 CASE_BUILT_IN_TM_LOAD (1):
797 CASE_BUILT_IN_TM_LOAD (2):
798 CASE_BUILT_IN_TM_LOAD (4):
799 CASE_BUILT_IN_TM_LOAD (8):
800 CASE_BUILT_IN_TM_LOAD (FLOAT
):
801 CASE_BUILT_IN_TM_LOAD (DOUBLE
):
802 CASE_BUILT_IN_TM_LOAD (LDOUBLE
):
803 CASE_BUILT_IN_TM_LOAD (M64
):
804 CASE_BUILT_IN_TM_LOAD (M128
):
805 CASE_BUILT_IN_TM_LOAD (M256
):
806 case BUILT_IN_TM_LOG
:
807 case BUILT_IN_TM_LOG_1
:
808 case BUILT_IN_TM_LOG_2
:
809 case BUILT_IN_TM_LOG_4
:
810 case BUILT_IN_TM_LOG_8
:
811 case BUILT_IN_TM_LOG_FLOAT
:
812 case BUILT_IN_TM_LOG_DOUBLE
:
813 case BUILT_IN_TM_LOG_LDOUBLE
:
814 case BUILT_IN_TM_LOG_M64
:
815 case BUILT_IN_TM_LOG_M128
:
816 case BUILT_IN_TM_LOG_M256
:
825 /* Detect flags (function attributes) from the function decl or type node. */
828 flags_from_decl_or_type (const_tree exp
)
834 /* The function exp may have the `malloc' attribute. */
835 if (DECL_IS_MALLOC (exp
))
838 /* The function exp may have the `returns_twice' attribute. */
839 if (DECL_IS_RETURNS_TWICE (exp
))
840 flags
|= ECF_RETURNS_TWICE
;
842 /* Process the pure and const attributes. */
843 if (TREE_READONLY (exp
))
845 if (DECL_PURE_P (exp
))
847 if (DECL_LOOPING_CONST_OR_PURE_P (exp
))
848 flags
|= ECF_LOOPING_CONST_OR_PURE
;
850 if (DECL_IS_NOVOPS (exp
))
852 if (lookup_attribute ("leaf", DECL_ATTRIBUTES (exp
)))
854 if (lookup_attribute ("cold", DECL_ATTRIBUTES (exp
)))
857 if (TREE_NOTHROW (exp
))
858 flags
|= ECF_NOTHROW
;
862 if (is_tm_builtin (exp
))
863 flags
|= ECF_TM_BUILTIN
;
864 else if ((flags
& (ECF_CONST
|ECF_NOVOPS
)) != 0
865 || lookup_attribute ("transaction_pure",
866 TYPE_ATTRIBUTES (TREE_TYPE (exp
))))
867 flags
|= ECF_TM_PURE
;
870 flags
= special_function_p (exp
, flags
);
872 else if (TYPE_P (exp
))
874 if (TYPE_READONLY (exp
))
878 && ((flags
& ECF_CONST
) != 0
879 || lookup_attribute ("transaction_pure", TYPE_ATTRIBUTES (exp
))))
880 flags
|= ECF_TM_PURE
;
885 if (TREE_THIS_VOLATILE (exp
))
887 flags
|= ECF_NORETURN
;
888 if (flags
& (ECF_CONST
|ECF_PURE
))
889 flags
|= ECF_LOOPING_CONST_OR_PURE
;
895 /* Detect flags from a CALL_EXPR. */
898 call_expr_flags (const_tree t
)
901 tree decl
= get_callee_fndecl (t
);
904 flags
= flags_from_decl_or_type (decl
);
905 else if (CALL_EXPR_FN (t
) == NULL_TREE
)
906 flags
= internal_fn_flags (CALL_EXPR_IFN (t
));
909 tree type
= TREE_TYPE (CALL_EXPR_FN (t
));
910 if (type
&& TREE_CODE (type
) == POINTER_TYPE
)
911 flags
= flags_from_decl_or_type (TREE_TYPE (type
));
914 if (CALL_EXPR_BY_DESCRIPTOR (t
))
915 flags
|= ECF_BY_DESCRIPTOR
;
921 /* Return true if TYPE should be passed by invisible reference. */
924 pass_by_reference (CUMULATIVE_ARGS
*ca
, machine_mode mode
,
925 tree type
, bool named_arg
)
929 /* If this type contains non-trivial constructors, then it is
930 forbidden for the middle-end to create any new copies. */
931 if (TREE_ADDRESSABLE (type
))
934 /* GCC post 3.4 passes *all* variable sized types by reference. */
935 if (!TYPE_SIZE (type
) || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
938 /* If a record type should be passed the same as its first (and only)
939 member, use the type and mode of that member. */
940 if (TREE_CODE (type
) == RECORD_TYPE
&& TYPE_TRANSPARENT_AGGR (type
))
942 type
= TREE_TYPE (first_field (type
));
943 mode
= TYPE_MODE (type
);
947 return targetm
.calls
.pass_by_reference (pack_cumulative_args (ca
), mode
,
951 /* Return true if TYPE, which is passed by reference, should be callee
952 copied instead of caller copied. */
955 reference_callee_copied (CUMULATIVE_ARGS
*ca
, machine_mode mode
,
956 tree type
, bool named_arg
)
958 if (type
&& TREE_ADDRESSABLE (type
))
960 return targetm
.calls
.callee_copies (pack_cumulative_args (ca
), mode
, type
,
965 /* Precompute all register parameters as described by ARGS, storing values
966 into fields within the ARGS array.
968 NUM_ACTUALS indicates the total number elements in the ARGS array.
970 Set REG_PARM_SEEN if we encounter a register parameter. */
973 precompute_register_parameters (int num_actuals
, struct arg_data
*args
,
980 for (i
= 0; i
< num_actuals
; i
++)
981 if (args
[i
].reg
!= 0 && ! args
[i
].pass_on_stack
)
985 if (args
[i
].value
== 0)
988 args
[i
].value
= expand_normal (args
[i
].tree_value
);
989 preserve_temp_slots (args
[i
].value
);
993 /* If we are to promote the function arg to a wider mode,
996 if (args
[i
].mode
!= TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)))
998 = convert_modes (args
[i
].mode
,
999 TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)),
1000 args
[i
].value
, args
[i
].unsignedp
);
1002 /* If the value is a non-legitimate constant, force it into a
1003 pseudo now. TLS symbols sometimes need a call to resolve. */
1004 if (CONSTANT_P (args
[i
].value
)
1005 && !targetm
.legitimate_constant_p (args
[i
].mode
, args
[i
].value
))
1006 args
[i
].value
= force_reg (args
[i
].mode
, args
[i
].value
);
1008 /* If we're going to have to load the value by parts, pull the
1009 parts into pseudos. The part extraction process can involve
1010 non-trivial computation. */
1011 if (GET_CODE (args
[i
].reg
) == PARALLEL
)
1013 tree type
= TREE_TYPE (args
[i
].tree_value
);
1014 args
[i
].parallel_value
1015 = emit_group_load_into_temps (args
[i
].reg
, args
[i
].value
,
1016 type
, int_size_in_bytes (type
));
1019 /* If the value is expensive, and we are inside an appropriately
1020 short loop, put the value into a pseudo and then put the pseudo
1023 For small register classes, also do this if this call uses
1024 register parameters. This is to avoid reload conflicts while
1025 loading the parameters registers. */
1027 else if ((! (REG_P (args
[i
].value
)
1028 || (GET_CODE (args
[i
].value
) == SUBREG
1029 && REG_P (SUBREG_REG (args
[i
].value
)))))
1030 && args
[i
].mode
!= BLKmode
1031 && (set_src_cost (args
[i
].value
, args
[i
].mode
,
1032 optimize_insn_for_speed_p ())
1033 > COSTS_N_INSNS (1))
1035 && targetm
.small_register_classes_for_mode_p (args
[i
].mode
))
1037 args
[i
].value
= copy_to_mode_reg (args
[i
].mode
, args
[i
].value
);
1041 #ifdef REG_PARM_STACK_SPACE
1043 /* The argument list is the property of the called routine and it
1044 may clobber it. If the fixed area has been used for previous
1045 parameters, we must save and restore it. */
1048 save_fixed_argument_area (int reg_parm_stack_space
, rtx argblock
, int *low_to_save
, int *high_to_save
)
1053 /* Compute the boundary of the area that needs to be saved, if any. */
1054 high
= reg_parm_stack_space
;
1055 if (ARGS_GROW_DOWNWARD
)
1058 if (high
> highest_outgoing_arg_in_use
)
1059 high
= highest_outgoing_arg_in_use
;
1061 for (low
= 0; low
< high
; low
++)
1062 if (stack_usage_map
[low
] != 0 || low
>= stack_usage_watermark
)
1065 machine_mode save_mode
;
1071 while (stack_usage_map
[--high
] == 0)
1075 *high_to_save
= high
;
1077 num_to_save
= high
- low
+ 1;
1079 /* If we don't have the required alignment, must do this
1081 scalar_int_mode imode
;
1082 if (int_mode_for_size (num_to_save
* BITS_PER_UNIT
, 1).exists (&imode
)
1083 && (low
& (MIN (GET_MODE_SIZE (imode
),
1084 BIGGEST_ALIGNMENT
/ UNITS_PER_WORD
) - 1)) == 0)
1087 save_mode
= BLKmode
;
1089 if (ARGS_GROW_DOWNWARD
)
1094 addr
= plus_constant (Pmode
, argblock
, delta
);
1095 stack_area
= gen_rtx_MEM (save_mode
, memory_address (save_mode
, addr
));
1097 set_mem_align (stack_area
, PARM_BOUNDARY
);
1098 if (save_mode
== BLKmode
)
1100 save_area
= assign_stack_temp (BLKmode
, num_to_save
);
1101 emit_block_move (validize_mem (save_area
), stack_area
,
1102 GEN_INT (num_to_save
), BLOCK_OP_CALL_PARM
);
1106 save_area
= gen_reg_rtx (save_mode
);
1107 emit_move_insn (save_area
, stack_area
);
1117 restore_fixed_argument_area (rtx save_area
, rtx argblock
, int high_to_save
, int low_to_save
)
1119 machine_mode save_mode
= GET_MODE (save_area
);
1121 rtx addr
, stack_area
;
1123 if (ARGS_GROW_DOWNWARD
)
1124 delta
= -high_to_save
;
1126 delta
= low_to_save
;
1128 addr
= plus_constant (Pmode
, argblock
, delta
);
1129 stack_area
= gen_rtx_MEM (save_mode
, memory_address (save_mode
, addr
));
1130 set_mem_align (stack_area
, PARM_BOUNDARY
);
1132 if (save_mode
!= BLKmode
)
1133 emit_move_insn (stack_area
, save_area
);
1135 emit_block_move (stack_area
, validize_mem (save_area
),
1136 GEN_INT (high_to_save
- low_to_save
+ 1),
1137 BLOCK_OP_CALL_PARM
);
1139 #endif /* REG_PARM_STACK_SPACE */
1141 /* If any elements in ARGS refer to parameters that are to be passed in
1142 registers, but not in memory, and whose alignment does not permit a
1143 direct copy into registers. Copy the values into a group of pseudos
1144 which we will later copy into the appropriate hard registers.
1146 Pseudos for each unaligned argument will be stored into the array
1147 args[argnum].aligned_regs. The caller is responsible for deallocating
1148 the aligned_regs array if it is nonzero. */
1151 store_unaligned_arguments_into_pseudos (struct arg_data
*args
, int num_actuals
)
1155 for (i
= 0; i
< num_actuals
; i
++)
1156 if (args
[i
].reg
!= 0 && ! args
[i
].pass_on_stack
1157 && GET_CODE (args
[i
].reg
) != PARALLEL
1158 && args
[i
].mode
== BLKmode
1159 && MEM_P (args
[i
].value
)
1160 && (MEM_ALIGN (args
[i
].value
)
1161 < (unsigned int) MIN (BIGGEST_ALIGNMENT
, BITS_PER_WORD
)))
1163 int bytes
= int_size_in_bytes (TREE_TYPE (args
[i
].tree_value
));
1164 int endian_correction
= 0;
1166 if (args
[i
].partial
)
1168 gcc_assert (args
[i
].partial
% UNITS_PER_WORD
== 0);
1169 args
[i
].n_aligned_regs
= args
[i
].partial
/ UNITS_PER_WORD
;
1173 args
[i
].n_aligned_regs
1174 = (bytes
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
1177 args
[i
].aligned_regs
= XNEWVEC (rtx
, args
[i
].n_aligned_regs
);
1179 /* Structures smaller than a word are normally aligned to the
1180 least significant byte. On a BYTES_BIG_ENDIAN machine,
1181 this means we must skip the empty high order bytes when
1182 calculating the bit offset. */
1183 if (bytes
< UNITS_PER_WORD
1184 #ifdef BLOCK_REG_PADDING
1185 && (BLOCK_REG_PADDING (args
[i
].mode
,
1186 TREE_TYPE (args
[i
].tree_value
), 1)
1192 endian_correction
= BITS_PER_WORD
- bytes
* BITS_PER_UNIT
;
1194 for (j
= 0; j
< args
[i
].n_aligned_regs
; j
++)
1196 rtx reg
= gen_reg_rtx (word_mode
);
1197 rtx word
= operand_subword_force (args
[i
].value
, j
, BLKmode
);
1198 int bitsize
= MIN (bytes
* BITS_PER_UNIT
, BITS_PER_WORD
);
1200 args
[i
].aligned_regs
[j
] = reg
;
1201 word
= extract_bit_field (word
, bitsize
, 0, 1, NULL_RTX
,
1202 word_mode
, word_mode
, false, NULL
);
1204 /* There is no need to restrict this code to loading items
1205 in TYPE_ALIGN sized hunks. The bitfield instructions can
1206 load up entire word sized registers efficiently.
1208 ??? This may not be needed anymore.
1209 We use to emit a clobber here but that doesn't let later
1210 passes optimize the instructions we emit. By storing 0 into
1211 the register later passes know the first AND to zero out the
1212 bitfield being set in the register is unnecessary. The store
1213 of 0 will be deleted as will at least the first AND. */
1215 emit_move_insn (reg
, const0_rtx
);
1217 bytes
-= bitsize
/ BITS_PER_UNIT
;
1218 store_bit_field (reg
, bitsize
, endian_correction
, 0, 0,
1219 word_mode
, word
, false);
1224 /* The limit set by -Walloc-larger-than=. */
1225 static GTY(()) tree alloc_object_size_limit
;
1227 /* Initialize ALLOC_OBJECT_SIZE_LIMIT based on the -Walloc-size-larger-than=
1228 setting if the option is specified, or to the maximum object size if it
1229 is not. Return the initialized value. */
1232 alloc_max_size (void)
1234 if (alloc_object_size_limit
)
1235 return alloc_object_size_limit
;
1237 alloc_object_size_limit
= max_object_size ();
1239 if (!warn_alloc_size_limit
)
1240 return alloc_object_size_limit
;
1242 const char *optname
= "-Walloc-size-larger-than=";
1246 unsigned HOST_WIDE_INT unit
= 1;
1247 unsigned HOST_WIDE_INT limit
1248 = strtoull (warn_alloc_size_limit
, &end
, 10);
1250 /* If the value is too large to be represented use the maximum
1251 representable value that strtoull sets limit to (setting
1252 errno to ERANGE). */
1256 /* Numeric option arguments are at most INT_MAX. Make it
1257 possible to specify a larger value by accepting common
1259 if (!strcmp (end
, "kB"))
1261 else if (!strcasecmp (end
, "KiB") || !strcmp (end
, "KB"))
1263 else if (!strcmp (end
, "MB"))
1264 unit
= HOST_WIDE_INT_UC (1000) * 1000;
1265 else if (!strcasecmp (end
, "MiB"))
1266 unit
= HOST_WIDE_INT_UC (1024) * 1024;
1267 else if (!strcasecmp (end
, "GB"))
1268 unit
= HOST_WIDE_INT_UC (1000) * 1000 * 1000;
1269 else if (!strcasecmp (end
, "GiB"))
1270 unit
= HOST_WIDE_INT_UC (1024) * 1024 * 1024;
1271 else if (!strcasecmp (end
, "TB"))
1272 unit
= HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000;
1273 else if (!strcasecmp (end
, "TiB"))
1274 unit
= HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024;
1275 else if (!strcasecmp (end
, "PB"))
1276 unit
= HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000 * 1000;
1277 else if (!strcasecmp (end
, "PiB"))
1278 unit
= HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024 * 1024;
1279 else if (!strcasecmp (end
, "EB"))
1280 unit
= HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000 * 1000
1282 else if (!strcasecmp (end
, "EiB"))
1283 unit
= HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024 * 1024
1287 /* This could mean an unknown suffix or a bad prefix, like
1289 warning_at (UNKNOWN_LOCATION
, 0,
1290 "invalid argument %qs to %qs",
1291 warn_alloc_size_limit
, optname
);
1293 /* Ignore the limit extracted by strtoull. */
1300 widest_int w
= wi::mul (limit
, unit
);
1301 if (w
< wi::to_widest (alloc_object_size_limit
))
1302 alloc_object_size_limit
1303 = wide_int_to_tree (ptrdiff_type_node
, w
);
1305 alloc_object_size_limit
= build_all_ones_cst (size_type_node
);
1309 return alloc_object_size_limit
;
1312 /* Return true when EXP's range can be determined and set RANGE[] to it
1313 after adjusting it if necessary to make EXP a represents a valid size
1314 of object, or a valid size argument to an allocation function declared
1315 with attribute alloc_size (whose argument may be signed), or to a string
1316 manipulation function like memset. When ALLOW_ZERO is true, allow
1317 returning a range of [0, 0] for a size in an anti-range [1, N] where
1318 N > PTRDIFF_MAX. A zero range is a (nearly) invalid argument to
1319 allocation functions like malloc but it is a valid argument to
1320 functions like memset. */
1323 get_size_range (tree exp
, tree range
[2], bool allow_zero
/* = false */)
1325 if (tree_fits_uhwi_p (exp
))
1327 /* EXP is a constant. */
1328 range
[0] = range
[1] = exp
;
1332 tree exptype
= TREE_TYPE (exp
);
1333 bool integral
= INTEGRAL_TYPE_P (exptype
);
1336 enum value_range_type range_type
;
1339 range_type
= determine_value_range (exp
, &min
, &max
);
1341 range_type
= VR_VARYING
;
1343 if (range_type
== VR_VARYING
)
1347 /* Use the full range of the type of the expression when
1348 no value range information is available. */
1349 range
[0] = TYPE_MIN_VALUE (exptype
);
1350 range
[1] = TYPE_MAX_VALUE (exptype
);
1354 range
[0] = NULL_TREE
;
1355 range
[1] = NULL_TREE
;
1359 unsigned expprec
= TYPE_PRECISION (exptype
);
1361 bool signed_p
= !TYPE_UNSIGNED (exptype
);
1363 if (range_type
== VR_ANTI_RANGE
)
1367 if (wi::les_p (max
, 0))
1369 /* EXP is not in a strictly negative range. That means
1370 it must be in some (not necessarily strictly) positive
1371 range which includes zero. Since in signed to unsigned
1372 conversions negative values end up converted to large
1373 positive values, and otherwise they are not valid sizes,
1374 the resulting range is in both cases [0, TYPE_MAX]. */
1375 min
= wi::zero (expprec
);
1376 max
= wi::to_wide (TYPE_MAX_VALUE (exptype
));
1378 else if (wi::les_p (min
- 1, 0))
1380 /* EXP is not in a negative-positive range. That means EXP
1381 is either negative, or greater than max. Since negative
1382 sizes are invalid make the range [MAX + 1, TYPE_MAX]. */
1384 max
= wi::to_wide (TYPE_MAX_VALUE (exptype
));
1389 min
= wi::zero (expprec
);
1392 else if (wi::eq_p (0, min
- 1))
1394 /* EXP is unsigned and not in the range [1, MAX]. That means
1395 it's either zero or greater than MAX. Even though 0 would
1396 normally be detected by -Walloc-zero, unless ALLOW_ZERO
1397 is true, set the range to [MAX, TYPE_MAX] so that when MAX
1398 is greater than the limit the whole range is diagnosed. */
1400 min
= max
= wi::zero (expprec
);
1404 max
= wi::to_wide (TYPE_MAX_VALUE (exptype
));
1410 min
= wi::zero (expprec
);
1414 range
[0] = wide_int_to_tree (exptype
, min
);
1415 range
[1] = wide_int_to_tree (exptype
, max
);
1420 /* Diagnose a call EXP to function FN decorated with attribute alloc_size
1421 whose argument numbers given by IDX with values given by ARGS exceed
1422 the maximum object size or cause an unsigned oveflow (wrapping) when
1423 multiplied. When ARGS[0] is null the function does nothing. ARGS[1]
1424 may be null for functions like malloc, and non-null for those like
1425 calloc that are decorated with a two-argument attribute alloc_size. */
1428 maybe_warn_alloc_args_overflow (tree fn
, tree exp
, tree args
[2], int idx
[2])
1430 /* The range each of the (up to) two arguments is known to be in. */
1431 tree argrange
[2][2] = { { NULL_TREE
, NULL_TREE
}, { NULL_TREE
, NULL_TREE
} };
1433 /* Maximum object size set by -Walloc-size-larger-than= or SIZE_MAX / 2. */
1434 tree maxobjsize
= alloc_max_size ();
1436 location_t loc
= EXPR_LOCATION (exp
);
1438 bool warned
= false;
1440 /* Validate each argument individually. */
1441 for (unsigned i
= 0; i
!= 2 && args
[i
]; ++i
)
1443 if (TREE_CODE (args
[i
]) == INTEGER_CST
)
1445 argrange
[i
][0] = args
[i
];
1446 argrange
[i
][1] = args
[i
];
1448 if (tree_int_cst_lt (args
[i
], integer_zero_node
))
1450 warned
= warning_at (loc
, OPT_Walloc_size_larger_than_
,
1451 "%Kargument %i value %qE is negative",
1452 exp
, idx
[i
] + 1, args
[i
]);
1454 else if (integer_zerop (args
[i
]))
1456 /* Avoid issuing -Walloc-zero for allocation functions other
1457 than __builtin_alloca that are declared with attribute
1458 returns_nonnull because there's no portability risk. This
1459 avoids warning for such calls to libiberty's xmalloc and
1461 Also avoid issuing the warning for calls to function named
1463 if ((DECL_FUNCTION_CODE (fn
) == BUILT_IN_ALLOCA
1464 && IDENTIFIER_LENGTH (DECL_NAME (fn
)) != 6)
1465 || (DECL_FUNCTION_CODE (fn
) != BUILT_IN_ALLOCA
1466 && !lookup_attribute ("returns_nonnull",
1467 TYPE_ATTRIBUTES (TREE_TYPE (fn
)))))
1468 warned
= warning_at (loc
, OPT_Walloc_zero
,
1469 "%Kargument %i value is zero",
1472 else if (tree_int_cst_lt (maxobjsize
, args
[i
]))
1474 /* G++ emits calls to ::operator new[](SIZE_MAX) in C++98
1475 mode and with -fno-exceptions as a way to indicate array
1476 size overflow. There's no good way to detect C++98 here
1477 so avoid diagnosing these calls for all C++ modes. */
1481 && DECL_IS_OPERATOR_NEW (fn
)
1482 && integer_all_onesp (args
[i
]))
1485 warned
= warning_at (loc
, OPT_Walloc_size_larger_than_
,
1486 "%Kargument %i value %qE exceeds "
1487 "maximum object size %E",
1488 exp
, idx
[i
] + 1, args
[i
], maxobjsize
);
1491 else if (TREE_CODE (args
[i
]) == SSA_NAME
1492 && get_size_range (args
[i
], argrange
[i
]))
1494 /* Verify that the argument's range is not negative (including
1495 upper bound of zero). */
1496 if (tree_int_cst_lt (argrange
[i
][0], integer_zero_node
)
1497 && tree_int_cst_le (argrange
[i
][1], integer_zero_node
))
1499 warned
= warning_at (loc
, OPT_Walloc_size_larger_than_
,
1500 "%Kargument %i range [%E, %E] is negative",
1502 argrange
[i
][0], argrange
[i
][1]);
1504 else if (tree_int_cst_lt (maxobjsize
, argrange
[i
][0]))
1506 warned
= warning_at (loc
, OPT_Walloc_size_larger_than_
,
1507 "%Kargument %i range [%E, %E] exceeds "
1508 "maximum object size %E",
1510 argrange
[i
][0], argrange
[i
][1],
1519 /* For a two-argument alloc_size, validate the product of the two
1520 arguments if both of their values or ranges are known. */
1521 if (!warned
&& tree_fits_uhwi_p (argrange
[0][0])
1522 && argrange
[1][0] && tree_fits_uhwi_p (argrange
[1][0])
1523 && !integer_onep (argrange
[0][0])
1524 && !integer_onep (argrange
[1][0]))
1526 /* Check for overflow in the product of a function decorated with
1527 attribute alloc_size (X, Y). */
1528 unsigned szprec
= TYPE_PRECISION (size_type_node
);
1529 wide_int x
= wi::to_wide (argrange
[0][0], szprec
);
1530 wide_int y
= wi::to_wide (argrange
[1][0], szprec
);
1533 wide_int prod
= wi::umul (x
, y
, &vflow
);
1536 warned
= warning_at (loc
, OPT_Walloc_size_larger_than_
,
1537 "%Kproduct %<%E * %E%> of arguments %i and %i "
1538 "exceeds %<SIZE_MAX%>",
1539 exp
, argrange
[0][0], argrange
[1][0],
1540 idx
[0] + 1, idx
[1] + 1);
1541 else if (wi::ltu_p (wi::to_wide (maxobjsize
, szprec
), prod
))
1542 warned
= warning_at (loc
, OPT_Walloc_size_larger_than_
,
1543 "%Kproduct %<%E * %E%> of arguments %i and %i "
1544 "exceeds maximum object size %E",
1545 exp
, argrange
[0][0], argrange
[1][0],
1546 idx
[0] + 1, idx
[1] + 1,
1551 /* Print the full range of each of the two arguments to make
1552 it clear when it is, in fact, in a range and not constant. */
1553 if (argrange
[0][0] != argrange
[0][1])
1554 inform (loc
, "argument %i in the range [%E, %E]",
1555 idx
[0] + 1, argrange
[0][0], argrange
[0][1]);
1556 if (argrange
[1][0] != argrange
[1][1])
1557 inform (loc
, "argument %i in the range [%E, %E]",
1558 idx
[1] + 1, argrange
[1][0], argrange
[1][1]);
1564 location_t fnloc
= DECL_SOURCE_LOCATION (fn
);
1566 if (DECL_IS_BUILTIN (fn
))
1568 "in a call to built-in allocation function %qD", fn
);
1571 "in a call to allocation function %qD declared here", fn
);
1575 /* If EXPR refers to a character array or pointer declared attribute
1576 nonstring return a decl for that array or pointer and set *REF to
1577 the referenced enclosing object or pointer. Otherwise returns
1581 get_attr_nonstring_decl (tree expr
, tree
*ref
)
1584 if (TREE_CODE (decl
) == SSA_NAME
)
1586 gimple
*def
= SSA_NAME_DEF_STMT (decl
);
1588 if (is_gimple_assign (def
))
1590 tree_code code
= gimple_assign_rhs_code (def
);
1591 if (code
== ADDR_EXPR
1592 || code
== COMPONENT_REF
1593 || code
== VAR_DECL
)
1594 decl
= gimple_assign_rhs1 (def
);
1596 else if (tree var
= SSA_NAME_VAR (decl
))
1600 if (TREE_CODE (decl
) == ADDR_EXPR
)
1601 decl
= TREE_OPERAND (decl
, 0);
1606 if (TREE_CODE (decl
) == ARRAY_REF
)
1607 decl
= TREE_OPERAND (decl
, 0);
1608 else if (TREE_CODE (decl
) == COMPONENT_REF
)
1609 decl
= TREE_OPERAND (decl
, 1);
1610 else if (TREE_CODE (decl
) == MEM_REF
)
1611 return get_attr_nonstring_decl (TREE_OPERAND (decl
, 0), ref
);
1614 && lookup_attribute ("nonstring", DECL_ATTRIBUTES (decl
)))
1620 /* Warn about passing a non-string array/pointer to a function that
1621 expects a nul-terminated string argument. */
1624 maybe_warn_nonstring_arg (tree fndecl
, tree exp
)
1626 if (!fndecl
|| DECL_BUILT_IN_CLASS (fndecl
) != BUILT_IN_NORMAL
)
1629 bool with_bounds
= CALL_WITH_BOUNDS_P (exp
);
1631 unsigned nargs
= call_expr_nargs (exp
);
1633 /* The bound argument to a bounded string function like strncpy. */
1634 tree bound
= NULL_TREE
;
1636 /* The range of lengths of a string argument to one of the comparison
1637 functions. If the length is less than the bound it is used instead. */
1638 tree lenrng
[2] = { NULL_TREE
, NULL_TREE
};
1640 /* It's safe to call "bounded" string functions with a non-string
1641 argument since the functions provide an explicit bound for this
1643 switch (DECL_FUNCTION_CODE (fndecl
))
1645 case BUILT_IN_STRCMP
:
1646 case BUILT_IN_STRNCMP
:
1647 case BUILT_IN_STRNCASECMP
:
1649 /* For these, if one argument refers to one or more of a set
1650 of string constants or arrays of known size, determine
1651 the range of their known or possible lengths and use it
1652 conservatively as the bound for the unbounded function,
1653 and to adjust the range of the bound of the bounded ones. */
1654 unsigned stride
= with_bounds
? 2 : 1;
1655 for (unsigned argno
= 0; argno
< nargs
&& !*lenrng
; argno
+= stride
)
1657 tree arg
= CALL_EXPR_ARG (exp
, argno
);
1658 if (!get_attr_nonstring_decl (arg
))
1659 get_range_strlen (arg
, lenrng
);
1664 case BUILT_IN_STPNCPY
:
1665 case BUILT_IN_STPNCPY_CHK
:
1666 case BUILT_IN_STRNCPY
:
1667 case BUILT_IN_STRNCPY_CHK
:
1669 unsigned argno
= with_bounds
? 4 : 2;
1671 bound
= CALL_EXPR_ARG (exp
, argno
);
1675 case BUILT_IN_STRNDUP
:
1677 unsigned argno
= with_bounds
? 2 : 1;
1679 bound
= CALL_EXPR_ARG (exp
, argno
);
1687 /* Determine the range of the bound argument (if specified). */
1688 tree bndrng
[2] = { NULL_TREE
, NULL_TREE
};
1692 get_size_range (bound
, bndrng
);
1697 /* Add one for the nul. */
1698 lenrng
[0] = const_binop (PLUS_EXPR
, TREE_TYPE (lenrng
[0]),
1699 lenrng
[0], size_one_node
);
1700 lenrng
[1] = const_binop (PLUS_EXPR
, TREE_TYPE (lenrng
[1]),
1701 lenrng
[1], size_one_node
);
1705 /* Conservatively use the upper bound of the lengths for
1706 both the lower and the upper bound of the operation. */
1707 bndrng
[0] = lenrng
[1];
1708 bndrng
[1] = lenrng
[1];
1709 bound
= void_type_node
;
1713 /* Replace the bound on the operation with the upper bound
1714 of the length of the string if the latter is smaller. */
1715 if (tree_int_cst_lt (lenrng
[1], bndrng
[0]))
1716 bndrng
[0] = lenrng
[1];
1717 else if (tree_int_cst_lt (lenrng
[1], bndrng
[1]))
1718 bndrng
[1] = lenrng
[1];
1722 /* Iterate over the built-in function's formal arguments and check
1723 each const char* against the actual argument. If the actual
1724 argument is declared attribute non-string issue a warning unless
1725 the argument's maximum length is bounded. */
1726 function_args_iterator it
;
1727 function_args_iter_init (&it
, TREE_TYPE (fndecl
));
1729 for (unsigned argno
= 0; ; ++argno
, function_args_iter_next (&it
))
1731 /* Avoid iterating past the declared argument in a call
1732 to function declared without a prototype. */
1736 tree argtype
= function_args_iter_cond (&it
);
1740 if (TREE_CODE (argtype
) != POINTER_TYPE
)
1743 argtype
= TREE_TYPE (argtype
);
1745 if (TREE_CODE (argtype
) != INTEGER_TYPE
1746 || !TYPE_READONLY (argtype
))
1749 argtype
= TYPE_MAIN_VARIANT (argtype
);
1750 if (argtype
!= char_type_node
)
1753 tree callarg
= CALL_EXPR_ARG (exp
, argno
);
1754 if (TREE_CODE (callarg
) == ADDR_EXPR
)
1755 callarg
= TREE_OPERAND (callarg
, 0);
1757 /* See if the destination is declared with attribute "nonstring". */
1758 tree decl
= get_attr_nonstring_decl (callarg
);
1762 tree type
= TREE_TYPE (decl
);
1764 /* The maximum number of array elements accessed. */
1765 offset_int wibnd
= 0;
1767 wibnd
= wi::to_offset (bndrng
[0]);
1769 /* Size of the array. */
1770 offset_int asize
= wibnd
;
1772 /* Determine the array size. For arrays of unknown bound and
1773 pointers reset BOUND to trigger the appropriate warning. */
1774 if (TREE_CODE (type
) == ARRAY_TYPE
)
1776 if (tree arrbnd
= TYPE_DOMAIN (type
))
1778 if ((arrbnd
= TYPE_MAX_VALUE (arrbnd
)))
1779 asize
= wi::to_offset (arrbnd
) + 1;
1781 else if (bound
== void_type_node
)
1784 else if (bound
== void_type_node
)
1787 location_t loc
= EXPR_LOCATION (exp
);
1789 bool warned
= false;
1791 if (wi::ltu_p (asize
, wibnd
))
1792 warned
= warning_at (loc
, OPT_Wstringop_overflow_
,
1793 "%qD argument %i declared attribute %<nonstring%> "
1794 "is smaller than the specified bound %E",
1795 fndecl
, argno
+ 1, bndrng
[0]);
1797 warned
= warning_at (loc
, OPT_Wstringop_overflow_
,
1798 "%qD argument %i declared attribute %<nonstring%>",
1802 inform (DECL_SOURCE_LOCATION (decl
),
1803 "argument %qD declared here", decl
);
1807 /* Issue an error if CALL_EXPR was flagged as requiring
1808 tall-call optimization. */
1811 maybe_complain_about_tail_call (tree call_expr
, const char *reason
)
1813 gcc_assert (TREE_CODE (call_expr
) == CALL_EXPR
);
1814 if (!CALL_EXPR_MUST_TAIL_CALL (call_expr
))
1817 error_at (EXPR_LOCATION (call_expr
), "cannot tail-call: %s", reason
);
1820 /* Fill in ARGS_SIZE and ARGS array based on the parameters found in
1823 NUM_ACTUALS is the total number of parameters.
1825 N_NAMED_ARGS is the total number of named arguments.
1827 STRUCT_VALUE_ADDR_VALUE is the implicit argument for a struct return
1830 FNDECL is the tree code for the target of this call (if known)
1832 ARGS_SO_FAR holds state needed by the target to know where to place
1835 REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
1836 for arguments which are passed in registers.
1838 OLD_STACK_LEVEL is a pointer to an rtx which olds the old stack level
1839 and may be modified by this routine.
1841 OLD_PENDING_ADJ, MUST_PREALLOCATE and FLAGS are pointers to integer
1842 flags which may be modified by this routine.
1844 MAY_TAILCALL is cleared if we encounter an invisible pass-by-reference
1845 that requires allocation of stack space.
1847 CALL_FROM_THUNK_P is true if this call is the jump from a thunk to
1848 the thunked-to function. */
1851 initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED
,
1852 struct arg_data
*args
,
1853 struct args_size
*args_size
,
1854 int n_named_args ATTRIBUTE_UNUSED
,
1855 tree exp
, tree struct_value_addr_value
,
1856 tree fndecl
, tree fntype
,
1857 cumulative_args_t args_so_far
,
1858 int reg_parm_stack_space
,
1859 rtx
*old_stack_level
,
1860 poly_int64_pod
*old_pending_adj
,
1861 int *must_preallocate
, int *ecf_flags
,
1862 bool *may_tailcall
, bool call_from_thunk_p
)
1864 CUMULATIVE_ARGS
*args_so_far_pnt
= get_cumulative_args (args_so_far
);
1865 location_t loc
= EXPR_LOCATION (exp
);
1867 /* Count arg position in order args appear. */
1872 args_size
->constant
= 0;
1875 bitmap_obstack_initialize (NULL
);
1877 /* In this loop, we consider args in the order they are written.
1878 We fill up ARGS from the back. */
1880 i
= num_actuals
- 1;
1882 int j
= i
, ptr_arg
= -1;
1883 call_expr_arg_iterator iter
;
1885 bitmap slots
= NULL
;
1887 if (struct_value_addr_value
)
1889 args
[j
].tree_value
= struct_value_addr_value
;
1892 /* If we pass structure address then we need to
1893 create bounds for it. Since created bounds is
1894 a call statement, we expand it right here to avoid
1895 fixing all other places where it may be expanded. */
1896 if (CALL_WITH_BOUNDS_P (exp
))
1898 args
[j
].value
= gen_reg_rtx (targetm
.chkp_bound_mode ());
1900 = chkp_make_bounds_for_struct_addr (struct_value_addr_value
);
1901 expand_expr_real (args
[j
].tree_value
, args
[j
].value
, VOIDmode
,
1902 EXPAND_NORMAL
, 0, false);
1903 args
[j
].pointer_arg
= j
+ 1;
1908 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
1910 tree argtype
= TREE_TYPE (arg
);
1912 /* Remember last param with pointer and associate it
1913 with following pointer bounds. */
1914 if (CALL_WITH_BOUNDS_P (exp
)
1915 && chkp_type_has_pointer (argtype
))
1918 BITMAP_FREE (slots
);
1920 if (!BOUNDED_TYPE_P (argtype
))
1922 slots
= BITMAP_ALLOC (NULL
);
1923 chkp_find_bound_slots (argtype
, slots
);
1926 else if (CALL_WITH_BOUNDS_P (exp
)
1927 && pass_by_reference (NULL
, TYPE_MODE (argtype
), argtype
,
1928 argpos
< n_named_args
))
1931 BITMAP_FREE (slots
);
1934 else if (POINTER_BOUNDS_TYPE_P (argtype
))
1936 /* We expect bounds in instrumented calls only.
1937 Otherwise it is a sign we lost flag due to some optimization
1938 and may emit call args incorrectly. */
1939 gcc_assert (CALL_WITH_BOUNDS_P (exp
));
1941 /* For structures look for the next available pointer. */
1942 if (ptr_arg
!= -1 && slots
)
1944 unsigned bnd_no
= bitmap_first_set_bit (slots
);
1945 args
[j
].pointer_offset
=
1946 bnd_no
* POINTER_SIZE
/ BITS_PER_UNIT
;
1948 bitmap_clear_bit (slots
, bnd_no
);
1950 /* Check we have no more pointers in the structure. */
1951 if (bitmap_empty_p (slots
))
1952 BITMAP_FREE (slots
);
1954 args
[j
].pointer_arg
= ptr_arg
;
1956 /* Check we covered all pointers in the previous
1964 if (targetm
.calls
.split_complex_arg
1966 && TREE_CODE (argtype
) == COMPLEX_TYPE
1967 && targetm
.calls
.split_complex_arg (argtype
))
1969 tree subtype
= TREE_TYPE (argtype
);
1970 args
[j
].tree_value
= build1 (REALPART_EXPR
, subtype
, arg
);
1972 args
[j
].tree_value
= build1 (IMAGPART_EXPR
, subtype
, arg
);
1975 args
[j
].tree_value
= arg
;
1981 BITMAP_FREE (slots
);
1984 bitmap_obstack_release (NULL
);
1986 /* Extract attribute alloc_size and if set, store the indices of
1987 the corresponding arguments in ALLOC_IDX, and then the actual
1988 argument(s) at those indices in ALLOC_ARGS. */
1989 int alloc_idx
[2] = { -1, -1 };
1991 = (fndecl
? lookup_attribute ("alloc_size",
1992 TYPE_ATTRIBUTES (TREE_TYPE (fndecl
)))
1995 tree args
= TREE_VALUE (alloc_size
);
1996 alloc_idx
[0] = TREE_INT_CST_LOW (TREE_VALUE (args
)) - 1;
1997 if (TREE_CHAIN (args
))
1998 alloc_idx
[1] = TREE_INT_CST_LOW (TREE_VALUE (TREE_CHAIN (args
))) - 1;
2001 /* Array for up to the two attribute alloc_size arguments. */
2002 tree alloc_args
[] = { NULL_TREE
, NULL_TREE
};
2004 /* I counts args in order (to be) pushed; ARGPOS counts in order written. */
2005 for (argpos
= 0; argpos
< num_actuals
; i
--, argpos
++)
2007 tree type
= TREE_TYPE (args
[i
].tree_value
);
2011 /* Replace erroneous argument with constant zero. */
2012 if (type
== error_mark_node
|| !COMPLETE_TYPE_P (type
))
2013 args
[i
].tree_value
= integer_zero_node
, type
= integer_type_node
;
2015 /* If TYPE is a transparent union or record, pass things the way
2016 we would pass the first field of the union or record. We have
2017 already verified that the modes are the same. */
2018 if ((TREE_CODE (type
) == UNION_TYPE
|| TREE_CODE (type
) == RECORD_TYPE
)
2019 && TYPE_TRANSPARENT_AGGR (type
))
2020 type
= TREE_TYPE (first_field (type
));
2022 /* Decide where to pass this arg.
2024 args[i].reg is nonzero if all or part is passed in registers.
2026 args[i].partial is nonzero if part but not all is passed in registers,
2027 and the exact value says how many bytes are passed in registers.
2029 args[i].pass_on_stack is nonzero if the argument must at least be
2030 computed on the stack. It may then be loaded back into registers
2031 if args[i].reg is nonzero.
2033 These decisions are driven by the FUNCTION_... macros and must agree
2034 with those made by function.c. */
2036 /* See if this argument should be passed by invisible reference. */
2037 if (pass_by_reference (args_so_far_pnt
, TYPE_MODE (type
),
2038 type
, argpos
< n_named_args
))
2041 tree base
= NULL_TREE
;
2044 = reference_callee_copied (args_so_far_pnt
, TYPE_MODE (type
),
2045 type
, argpos
< n_named_args
);
2047 /* If we're compiling a thunk, pass through invisible references
2048 instead of making a copy. */
2049 if (call_from_thunk_p
2051 && !TREE_ADDRESSABLE (type
)
2052 && (base
= get_base_address (args
[i
].tree_value
))
2053 && TREE_CODE (base
) != SSA_NAME
2054 && (!DECL_P (base
) || MEM_P (DECL_RTL (base
)))))
2056 /* We may have turned the parameter value into an SSA name.
2057 Go back to the original parameter so we can take the
2059 if (TREE_CODE (args
[i
].tree_value
) == SSA_NAME
)
2061 gcc_assert (SSA_NAME_IS_DEFAULT_DEF (args
[i
].tree_value
));
2062 args
[i
].tree_value
= SSA_NAME_VAR (args
[i
].tree_value
);
2063 gcc_assert (TREE_CODE (args
[i
].tree_value
) == PARM_DECL
);
2065 /* Argument setup code may have copied the value to register. We
2066 revert that optimization now because the tail call code must
2067 use the original location. */
2068 if (TREE_CODE (args
[i
].tree_value
) == PARM_DECL
2069 && !MEM_P (DECL_RTL (args
[i
].tree_value
))
2070 && DECL_INCOMING_RTL (args
[i
].tree_value
)
2071 && MEM_P (DECL_INCOMING_RTL (args
[i
].tree_value
)))
2072 set_decl_rtl (args
[i
].tree_value
,
2073 DECL_INCOMING_RTL (args
[i
].tree_value
));
2075 mark_addressable (args
[i
].tree_value
);
2077 /* We can't use sibcalls if a callee-copied argument is
2078 stored in the current function's frame. */
2079 if (!call_from_thunk_p
&& DECL_P (base
) && !TREE_STATIC (base
))
2081 *may_tailcall
= false;
2082 maybe_complain_about_tail_call (exp
,
2083 "a callee-copied argument is"
2084 " stored in the current"
2085 " function's frame");
2088 args
[i
].tree_value
= build_fold_addr_expr_loc (loc
,
2089 args
[i
].tree_value
);
2090 type
= TREE_TYPE (args
[i
].tree_value
);
2092 if (*ecf_flags
& ECF_CONST
)
2093 *ecf_flags
&= ~(ECF_CONST
| ECF_LOOPING_CONST_OR_PURE
);
2097 /* We make a copy of the object and pass the address to the
2098 function being called. */
2101 if (!COMPLETE_TYPE_P (type
)
2102 || TREE_CODE (TYPE_SIZE_UNIT (type
)) != INTEGER_CST
2103 || (flag_stack_check
== GENERIC_STACK_CHECK
2104 && compare_tree_int (TYPE_SIZE_UNIT (type
),
2105 STACK_CHECK_MAX_VAR_SIZE
) > 0))
2107 /* This is a variable-sized object. Make space on the stack
2109 rtx size_rtx
= expr_size (args
[i
].tree_value
);
2111 if (*old_stack_level
== 0)
2113 emit_stack_save (SAVE_BLOCK
, old_stack_level
);
2114 *old_pending_adj
= pending_stack_adjust
;
2115 pending_stack_adjust
= 0;
2118 /* We can pass TRUE as the 4th argument because we just
2119 saved the stack pointer and will restore it right after
2121 copy
= allocate_dynamic_stack_space (size_rtx
,
2124 max_int_size_in_bytes
2127 copy
= gen_rtx_MEM (BLKmode
, copy
);
2128 set_mem_attributes (copy
, type
, 1);
2131 copy
= assign_temp (type
, 1, 0);
2133 store_expr (args
[i
].tree_value
, copy
, 0, false, false);
2135 /* Just change the const function to pure and then let
2136 the next test clear the pure based on
2138 if (*ecf_flags
& ECF_CONST
)
2140 *ecf_flags
&= ~ECF_CONST
;
2141 *ecf_flags
|= ECF_PURE
;
2144 if (!callee_copies
&& *ecf_flags
& ECF_PURE
)
2145 *ecf_flags
&= ~(ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
);
2148 = build_fold_addr_expr_loc (loc
, make_tree (type
, copy
));
2149 type
= TREE_TYPE (args
[i
].tree_value
);
2150 *may_tailcall
= false;
2151 maybe_complain_about_tail_call (exp
,
2152 "argument must be passed"
2157 unsignedp
= TYPE_UNSIGNED (type
);
2158 mode
= promote_function_mode (type
, TYPE_MODE (type
), &unsignedp
,
2159 fndecl
? TREE_TYPE (fndecl
) : fntype
, 0);
2161 args
[i
].unsignedp
= unsignedp
;
2162 args
[i
].mode
= mode
;
2164 targetm
.calls
.warn_parameter_passing_abi (args_so_far
, type
);
2166 args
[i
].reg
= targetm
.calls
.function_arg (args_so_far
, mode
, type
,
2167 argpos
< n_named_args
);
2169 if (args
[i
].reg
&& CONST_INT_P (args
[i
].reg
))
2171 args
[i
].special_slot
= args
[i
].reg
;
2175 /* If this is a sibling call and the machine has register windows, the
2176 register window has to be unwinded before calling the routine, so
2177 arguments have to go into the incoming registers. */
2178 if (targetm
.calls
.function_incoming_arg
!= targetm
.calls
.function_arg
)
2179 args
[i
].tail_call_reg
2180 = targetm
.calls
.function_incoming_arg (args_so_far
, mode
, type
,
2181 argpos
< n_named_args
);
2183 args
[i
].tail_call_reg
= args
[i
].reg
;
2187 = targetm
.calls
.arg_partial_bytes (args_so_far
, mode
, type
,
2188 argpos
< n_named_args
);
2190 args
[i
].pass_on_stack
= targetm
.calls
.must_pass_in_stack (mode
, type
);
2192 /* If FUNCTION_ARG returned a (parallel [(expr_list (nil) ...) ...]),
2193 it means that we are to pass this arg in the register(s) designated
2194 by the PARALLEL, but also to pass it in the stack. */
2195 if (args
[i
].reg
&& GET_CODE (args
[i
].reg
) == PARALLEL
2196 && XEXP (XVECEXP (args
[i
].reg
, 0, 0), 0) == 0)
2197 args
[i
].pass_on_stack
= 1;
2199 /* If this is an addressable type, we must preallocate the stack
2200 since we must evaluate the object into its final location.
2202 If this is to be passed in both registers and the stack, it is simpler
2204 if (TREE_ADDRESSABLE (type
)
2205 || (args
[i
].pass_on_stack
&& args
[i
].reg
!= 0))
2206 *must_preallocate
= 1;
2208 /* No stack allocation and padding for bounds. */
2209 if (POINTER_BOUNDS_P (args
[i
].tree_value
))
2211 /* Compute the stack-size of this argument. */
2212 else if (args
[i
].reg
== 0 || args
[i
].partial
!= 0
2213 || reg_parm_stack_space
> 0
2214 || args
[i
].pass_on_stack
)
2215 locate_and_pad_parm (mode
, type
,
2216 #ifdef STACK_PARMS_IN_REG_PARM_AREA
2221 reg_parm_stack_space
,
2222 args
[i
].pass_on_stack
? 0 : args
[i
].partial
,
2223 fndecl
, args_size
, &args
[i
].locate
);
2224 #ifdef BLOCK_REG_PADDING
2226 /* The argument is passed entirely in registers. See at which
2227 end it should be padded. */
2228 args
[i
].locate
.where_pad
=
2229 BLOCK_REG_PADDING (mode
, type
,
2230 int_size_in_bytes (type
) <= UNITS_PER_WORD
);
2233 /* Update ARGS_SIZE, the total stack space for args so far. */
2235 args_size
->constant
+= args
[i
].locate
.size
.constant
;
2236 if (args
[i
].locate
.size
.var
)
2237 ADD_PARM_SIZE (*args_size
, args
[i
].locate
.size
.var
);
2239 /* Increment ARGS_SO_FAR, which has info about which arg-registers
2240 have been used, etc. */
2242 targetm
.calls
.function_arg_advance (args_so_far
, TYPE_MODE (type
),
2243 type
, argpos
< n_named_args
);
2245 /* Store argument values for functions decorated with attribute
2247 if (argpos
== alloc_idx
[0])
2248 alloc_args
[0] = args
[i
].tree_value
;
2249 else if (argpos
== alloc_idx
[1])
2250 alloc_args
[1] = args
[i
].tree_value
;
2255 /* Check the arguments of functions decorated with attribute
2257 maybe_warn_alloc_args_overflow (fndecl
, exp
, alloc_args
, alloc_idx
);
2260 /* Detect passing non-string arguments to functions expecting
2261 nul-terminated strings. */
2262 maybe_warn_nonstring_arg (fndecl
, exp
);
2265 /* Update ARGS_SIZE to contain the total size for the argument block.
2266 Return the original constant component of the argument block's size.
2268 REG_PARM_STACK_SPACE holds the number of bytes of stack space reserved
2269 for arguments passed in registers. */
2272 compute_argument_block_size (int reg_parm_stack_space
,
2273 struct args_size
*args_size
,
2274 tree fndecl ATTRIBUTE_UNUSED
,
2275 tree fntype ATTRIBUTE_UNUSED
,
2276 int preferred_stack_boundary ATTRIBUTE_UNUSED
)
2278 poly_int64 unadjusted_args_size
= args_size
->constant
;
2280 /* For accumulate outgoing args mode we don't need to align, since the frame
2281 will be already aligned. Align to STACK_BOUNDARY in order to prevent
2282 backends from generating misaligned frame sizes. */
2283 if (ACCUMULATE_OUTGOING_ARGS
&& preferred_stack_boundary
> STACK_BOUNDARY
)
2284 preferred_stack_boundary
= STACK_BOUNDARY
;
2286 /* Compute the actual size of the argument block required. The variable
2287 and constant sizes must be combined, the size may have to be rounded,
2288 and there may be a minimum required size. */
2292 args_size
->var
= ARGS_SIZE_TREE (*args_size
);
2293 args_size
->constant
= 0;
2295 preferred_stack_boundary
/= BITS_PER_UNIT
;
2296 if (preferred_stack_boundary
> 1)
2298 /* We don't handle this case yet. To handle it correctly we have
2299 to add the delta, round and subtract the delta.
2300 Currently no machine description requires this support. */
2301 gcc_assert (multiple_p (stack_pointer_delta
,
2302 preferred_stack_boundary
));
2303 args_size
->var
= round_up (args_size
->var
, preferred_stack_boundary
);
2306 if (reg_parm_stack_space
> 0)
2309 = size_binop (MAX_EXPR
, args_size
->var
,
2310 ssize_int (reg_parm_stack_space
));
2312 /* The area corresponding to register parameters is not to count in
2313 the size of the block we need. So make the adjustment. */
2314 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
2316 = size_binop (MINUS_EXPR
, args_size
->var
,
2317 ssize_int (reg_parm_stack_space
));
2322 preferred_stack_boundary
/= BITS_PER_UNIT
;
2323 if (preferred_stack_boundary
< 1)
2324 preferred_stack_boundary
= 1;
2325 args_size
->constant
= (aligned_upper_bound (args_size
->constant
2326 + stack_pointer_delta
,
2327 preferred_stack_boundary
)
2328 - stack_pointer_delta
);
2330 args_size
->constant
= upper_bound (args_size
->constant
,
2331 reg_parm_stack_space
);
2333 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
2334 args_size
->constant
-= reg_parm_stack_space
;
2336 return unadjusted_args_size
;
2339 /* Precompute parameters as needed for a function call.
2341 FLAGS is mask of ECF_* constants.
2343 NUM_ACTUALS is the number of arguments.
2345 ARGS is an array containing information for each argument; this
2346 routine fills in the INITIAL_VALUE and VALUE fields for each
2347 precomputed argument. */
2350 precompute_arguments (int num_actuals
, struct arg_data
*args
)
2354 /* If this is a libcall, then precompute all arguments so that we do not
2355 get extraneous instructions emitted as part of the libcall sequence. */
2357 /* If we preallocated the stack space, and some arguments must be passed
2358 on the stack, then we must precompute any parameter which contains a
2359 function call which will store arguments on the stack.
2360 Otherwise, evaluating the parameter may clobber previous parameters
2361 which have already been stored into the stack. (we have code to avoid
2362 such case by saving the outgoing stack arguments, but it results in
2364 if (!ACCUMULATE_OUTGOING_ARGS
)
2367 for (i
= 0; i
< num_actuals
; i
++)
2372 if (TREE_CODE (args
[i
].tree_value
) != CALL_EXPR
)
2375 /* If this is an addressable type, we cannot pre-evaluate it. */
2376 type
= TREE_TYPE (args
[i
].tree_value
);
2377 gcc_assert (!TREE_ADDRESSABLE (type
));
2379 args
[i
].initial_value
= args
[i
].value
2380 = expand_normal (args
[i
].tree_value
);
2382 mode
= TYPE_MODE (type
);
2383 if (mode
!= args
[i
].mode
)
2385 int unsignedp
= args
[i
].unsignedp
;
2387 = convert_modes (args
[i
].mode
, mode
,
2388 args
[i
].value
, args
[i
].unsignedp
);
2390 /* CSE will replace this only if it contains args[i].value
2391 pseudo, so convert it down to the declared mode using
2393 if (REG_P (args
[i
].value
)
2394 && GET_MODE_CLASS (args
[i
].mode
) == MODE_INT
2395 && promote_mode (type
, mode
, &unsignedp
) != args
[i
].mode
)
2397 args
[i
].initial_value
2398 = gen_lowpart_SUBREG (mode
, args
[i
].value
);
2399 SUBREG_PROMOTED_VAR_P (args
[i
].initial_value
) = 1;
2400 SUBREG_PROMOTED_SET (args
[i
].initial_value
, args
[i
].unsignedp
);
2406 /* Given the current state of MUST_PREALLOCATE and information about
2407 arguments to a function call in NUM_ACTUALS, ARGS and ARGS_SIZE,
2408 compute and return the final value for MUST_PREALLOCATE. */
2411 finalize_must_preallocate (int must_preallocate
, int num_actuals
,
2412 struct arg_data
*args
, struct args_size
*args_size
)
2414 /* See if we have or want to preallocate stack space.
2416 If we would have to push a partially-in-regs parm
2417 before other stack parms, preallocate stack space instead.
2419 If the size of some parm is not a multiple of the required stack
2420 alignment, we must preallocate.
2422 If the total size of arguments that would otherwise create a copy in
2423 a temporary (such as a CALL) is more than half the total argument list
2424 size, preallocation is faster.
2426 Another reason to preallocate is if we have a machine (like the m88k)
2427 where stack alignment is required to be maintained between every
2428 pair of insns, not just when the call is made. However, we assume here
2429 that such machines either do not have push insns (and hence preallocation
2430 would occur anyway) or the problem is taken care of with
2433 if (! must_preallocate
)
2435 int partial_seen
= 0;
2436 poly_int64 copy_to_evaluate_size
= 0;
2439 for (i
= 0; i
< num_actuals
&& ! must_preallocate
; i
++)
2441 if (args
[i
].partial
> 0 && ! args
[i
].pass_on_stack
)
2443 else if (partial_seen
&& args
[i
].reg
== 0)
2444 must_preallocate
= 1;
2445 /* We preallocate in case there are bounds passed
2446 in the bounds table to have precomputed address
2447 for bounds association. */
2448 else if (POINTER_BOUNDS_P (args
[i
].tree_value
)
2450 must_preallocate
= 1;
2452 if (TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)) == BLKmode
2453 && (TREE_CODE (args
[i
].tree_value
) == CALL_EXPR
2454 || TREE_CODE (args
[i
].tree_value
) == TARGET_EXPR
2455 || TREE_CODE (args
[i
].tree_value
) == COND_EXPR
2456 || TREE_ADDRESSABLE (TREE_TYPE (args
[i
].tree_value
))))
2457 copy_to_evaluate_size
2458 += int_size_in_bytes (TREE_TYPE (args
[i
].tree_value
));
2461 if (maybe_ne (args_size
->constant
, 0)
2462 && maybe_ge (copy_to_evaluate_size
* 2, args_size
->constant
))
2463 must_preallocate
= 1;
2465 return must_preallocate
;
2468 /* If we preallocated stack space, compute the address of each argument
2469 and store it into the ARGS array.
2471 We need not ensure it is a valid memory address here; it will be
2472 validized when it is used.
2474 ARGBLOCK is an rtx for the address of the outgoing arguments. */
2477 compute_argument_addresses (struct arg_data
*args
, rtx argblock
, int num_actuals
)
2481 rtx arg_reg
= argblock
;
2483 poly_int64 arg_offset
= 0;
2485 if (GET_CODE (argblock
) == PLUS
)
2487 arg_reg
= XEXP (argblock
, 0);
2488 arg_offset
= rtx_to_poly_int64 (XEXP (argblock
, 1));
2491 for (i
= 0; i
< num_actuals
; i
++)
2493 rtx offset
= ARGS_SIZE_RTX (args
[i
].locate
.offset
);
2494 rtx slot_offset
= ARGS_SIZE_RTX (args
[i
].locate
.slot_offset
);
2496 unsigned int align
, boundary
;
2497 poly_uint64 units_on_stack
= 0;
2498 machine_mode partial_mode
= VOIDmode
;
2500 /* Skip this parm if it will not be passed on the stack. */
2501 if (! args
[i
].pass_on_stack
2503 && args
[i
].partial
== 0)
2506 if (TYPE_EMPTY_P (TREE_TYPE (args
[i
].tree_value
)))
2509 /* Pointer Bounds are never passed on the stack. */
2510 if (POINTER_BOUNDS_P (args
[i
].tree_value
))
2513 addr
= simplify_gen_binary (PLUS
, Pmode
, arg_reg
, offset
);
2514 addr
= plus_constant (Pmode
, addr
, arg_offset
);
2516 if (args
[i
].partial
!= 0)
2518 /* Only part of the parameter is being passed on the stack.
2519 Generate a simple memory reference of the correct size. */
2520 units_on_stack
= args
[i
].locate
.size
.constant
;
2521 poly_uint64 bits_on_stack
= units_on_stack
* BITS_PER_UNIT
;
2522 partial_mode
= int_mode_for_size (bits_on_stack
, 1).else_blk ();
2523 args
[i
].stack
= gen_rtx_MEM (partial_mode
, addr
);
2524 set_mem_size (args
[i
].stack
, units_on_stack
);
2528 args
[i
].stack
= gen_rtx_MEM (args
[i
].mode
, addr
);
2529 set_mem_attributes (args
[i
].stack
,
2530 TREE_TYPE (args
[i
].tree_value
), 1);
2532 align
= BITS_PER_UNIT
;
2533 boundary
= args
[i
].locate
.boundary
;
2534 poly_int64 offset_val
;
2535 if (args
[i
].locate
.where_pad
!= PAD_DOWNWARD
)
2537 else if (poly_int_rtx_p (offset
, &offset_val
))
2539 align
= least_bit_hwi (boundary
);
2540 unsigned int offset_align
2541 = known_alignment (offset_val
) * BITS_PER_UNIT
;
2542 if (offset_align
!= 0)
2543 align
= MIN (align
, offset_align
);
2545 set_mem_align (args
[i
].stack
, align
);
2547 addr
= simplify_gen_binary (PLUS
, Pmode
, arg_reg
, slot_offset
);
2548 addr
= plus_constant (Pmode
, addr
, arg_offset
);
2550 if (args
[i
].partial
!= 0)
2552 /* Only part of the parameter is being passed on the stack.
2553 Generate a simple memory reference of the correct size.
2555 args
[i
].stack_slot
= gen_rtx_MEM (partial_mode
, addr
);
2556 set_mem_size (args
[i
].stack_slot
, units_on_stack
);
2560 args
[i
].stack_slot
= gen_rtx_MEM (args
[i
].mode
, addr
);
2561 set_mem_attributes (args
[i
].stack_slot
,
2562 TREE_TYPE (args
[i
].tree_value
), 1);
2564 set_mem_align (args
[i
].stack_slot
, args
[i
].locate
.boundary
);
2566 /* Function incoming arguments may overlap with sibling call
2567 outgoing arguments and we cannot allow reordering of reads
2568 from function arguments with stores to outgoing arguments
2569 of sibling calls. */
2570 set_mem_alias_set (args
[i
].stack
, 0);
2571 set_mem_alias_set (args
[i
].stack_slot
, 0);
2576 /* Given a FNDECL and EXP, return an rtx suitable for use as a target address
2577 in a call instruction.
2579 FNDECL is the tree node for the target function. For an indirect call
2580 FNDECL will be NULL_TREE.
2582 ADDR is the operand 0 of CALL_EXPR for this call. */
2585 rtx_for_function_call (tree fndecl
, tree addr
)
2589 /* Get the function to call, in the form of RTL. */
2592 if (!TREE_USED (fndecl
) && fndecl
!= current_function_decl
)
2593 TREE_USED (fndecl
) = 1;
2595 /* Get a SYMBOL_REF rtx for the function address. */
2596 funexp
= XEXP (DECL_RTL (fndecl
), 0);
2599 /* Generate an rtx (probably a pseudo-register) for the address. */
2602 funexp
= expand_normal (addr
);
2603 pop_temp_slots (); /* FUNEXP can't be BLKmode. */
2608 /* Return the static chain for this function, if any. */
2611 rtx_for_static_chain (const_tree fndecl_or_type
, bool incoming_p
)
2613 if (DECL_P (fndecl_or_type
) && !DECL_STATIC_CHAIN (fndecl_or_type
))
2616 return targetm
.calls
.static_chain (fndecl_or_type
, incoming_p
);
2619 /* Internal state for internal_arg_pointer_based_exp and its helpers. */
2622 /* Last insn that has been scanned by internal_arg_pointer_based_exp_scan,
2623 or NULL_RTX if none has been scanned yet. */
2624 rtx_insn
*scan_start
;
2625 /* Vector indexed by REGNO - FIRST_PSEUDO_REGISTER, recording if a pseudo is
2626 based on crtl->args.internal_arg_pointer. The element is NULL_RTX if the
2627 pseudo isn't based on it, a CONST_INT offset if the pseudo is based on it
2628 with fixed offset, or PC if this is with variable or unknown offset. */
2630 } internal_arg_pointer_exp_state
;
2632 static rtx
internal_arg_pointer_based_exp (const_rtx
, bool);
2634 /* Helper function for internal_arg_pointer_based_exp. Scan insns in
2635 the tail call sequence, starting with first insn that hasn't been
2636 scanned yet, and note for each pseudo on the LHS whether it is based
2637 on crtl->args.internal_arg_pointer or not, and what offset from that
2638 that pointer it has. */
2641 internal_arg_pointer_based_exp_scan (void)
2643 rtx_insn
*insn
, *scan_start
= internal_arg_pointer_exp_state
.scan_start
;
2645 if (scan_start
== NULL_RTX
)
2646 insn
= get_insns ();
2648 insn
= NEXT_INSN (scan_start
);
2652 rtx set
= single_set (insn
);
2653 if (set
&& REG_P (SET_DEST (set
)) && !HARD_REGISTER_P (SET_DEST (set
)))
2656 unsigned int idx
= REGNO (SET_DEST (set
)) - FIRST_PSEUDO_REGISTER
;
2657 /* Punt on pseudos set multiple times. */
2658 if (idx
< internal_arg_pointer_exp_state
.cache
.length ()
2659 && (internal_arg_pointer_exp_state
.cache
[idx
]
2663 val
= internal_arg_pointer_based_exp (SET_SRC (set
), false);
2664 if (val
!= NULL_RTX
)
2666 if (idx
>= internal_arg_pointer_exp_state
.cache
.length ())
2667 internal_arg_pointer_exp_state
.cache
2668 .safe_grow_cleared (idx
+ 1);
2669 internal_arg_pointer_exp_state
.cache
[idx
] = val
;
2672 if (NEXT_INSN (insn
) == NULL_RTX
)
2674 insn
= NEXT_INSN (insn
);
2677 internal_arg_pointer_exp_state
.scan_start
= scan_start
;
2680 /* Compute whether RTL is based on crtl->args.internal_arg_pointer. Return
2681 NULL_RTX if RTL isn't based on it, a CONST_INT offset if RTL is based on
2682 it with fixed offset, or PC if this is with variable or unknown offset.
2683 TOPLEVEL is true if the function is invoked at the topmost level. */
2686 internal_arg_pointer_based_exp (const_rtx rtl
, bool toplevel
)
2688 if (CONSTANT_P (rtl
))
2691 if (rtl
== crtl
->args
.internal_arg_pointer
)
2694 if (REG_P (rtl
) && HARD_REGISTER_P (rtl
))
2698 if (GET_CODE (rtl
) == PLUS
&& poly_int_rtx_p (XEXP (rtl
, 1), &offset
))
2700 rtx val
= internal_arg_pointer_based_exp (XEXP (rtl
, 0), toplevel
);
2701 if (val
== NULL_RTX
|| val
== pc_rtx
)
2703 return plus_constant (Pmode
, val
, offset
);
2706 /* When called at the topmost level, scan pseudo assignments in between the
2707 last scanned instruction in the tail call sequence and the latest insn
2708 in that sequence. */
2710 internal_arg_pointer_based_exp_scan ();
2714 unsigned int idx
= REGNO (rtl
) - FIRST_PSEUDO_REGISTER
;
2715 if (idx
< internal_arg_pointer_exp_state
.cache
.length ())
2716 return internal_arg_pointer_exp_state
.cache
[idx
];
2721 subrtx_iterator::array_type array
;
2722 FOR_EACH_SUBRTX (iter
, array
, rtl
, NONCONST
)
2724 const_rtx x
= *iter
;
2725 if (REG_P (x
) && internal_arg_pointer_based_exp (x
, false) != NULL_RTX
)
2728 iter
.skip_subrtxes ();
2734 /* Return true if SIZE bytes starting from address ADDR might overlap an
2735 already-clobbered argument area. This function is used to determine
2736 if we should give up a sibcall. */
2739 mem_might_overlap_already_clobbered_arg_p (rtx addr
, poly_uint64 size
)
2742 unsigned HOST_WIDE_INT start
, end
;
2745 if (bitmap_empty_p (stored_args_map
)
2746 && stored_args_watermark
== HOST_WIDE_INT_M1U
)
2748 val
= internal_arg_pointer_based_exp (addr
, true);
2749 if (val
== NULL_RTX
)
2751 else if (!poly_int_rtx_p (val
, &i
))
2754 if (known_eq (size
, 0U))
2757 if (STACK_GROWS_DOWNWARD
)
2758 i
-= crtl
->args
.pretend_args_size
;
2760 i
+= crtl
->args
.pretend_args_size
;
2762 if (ARGS_GROW_DOWNWARD
)
2765 /* We can ignore any references to the function's pretend args,
2766 which at this point would manifest as negative values of I. */
2767 if (known_le (i
, 0) && known_le (size
, poly_uint64 (-i
)))
2770 start
= maybe_lt (i
, 0) ? 0 : constant_lower_bound (i
);
2771 if (!(i
+ size
).is_constant (&end
))
2772 end
= HOST_WIDE_INT_M1U
;
2774 if (end
> stored_args_watermark
)
2777 end
= MIN (end
, SBITMAP_SIZE (stored_args_map
));
2778 for (unsigned HOST_WIDE_INT k
= start
; k
< end
; ++k
)
2779 if (bitmap_bit_p (stored_args_map
, k
))
2785 /* Do the register loads required for any wholly-register parms or any
2786 parms which are passed both on the stack and in a register. Their
2787 expressions were already evaluated.
2789 Mark all register-parms as living through the call, putting these USE
2790 insns in the CALL_INSN_FUNCTION_USAGE field.
2792 When IS_SIBCALL, perform the check_sibcall_argument_overlap
2793 checking, setting *SIBCALL_FAILURE if appropriate. */
2796 load_register_parameters (struct arg_data
*args
, int num_actuals
,
2797 rtx
*call_fusage
, int flags
, int is_sibcall
,
2798 int *sibcall_failure
)
2802 for (i
= 0; i
< num_actuals
; i
++)
2804 rtx reg
= ((flags
& ECF_SIBCALL
)
2805 ? args
[i
].tail_call_reg
: args
[i
].reg
);
2808 int partial
= args
[i
].partial
;
2810 poly_int64 size
= 0;
2811 HOST_WIDE_INT const_size
= 0;
2812 rtx_insn
*before_arg
= get_last_insn ();
2813 /* Set non-negative if we must move a word at a time, even if
2814 just one word (e.g, partial == 4 && mode == DFmode). Set
2815 to -1 if we just use a normal move insn. This value can be
2816 zero if the argument is a zero size structure. */
2818 if (GET_CODE (reg
) == PARALLEL
)
2822 gcc_assert (partial
% UNITS_PER_WORD
== 0);
2823 nregs
= partial
/ UNITS_PER_WORD
;
2825 else if (TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)) == BLKmode
)
2827 /* Variable-sized parameters should be described by a
2828 PARALLEL instead. */
2829 const_size
= int_size_in_bytes (TREE_TYPE (args
[i
].tree_value
));
2830 gcc_assert (const_size
>= 0);
2831 nregs
= (const_size
+ (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
;
2835 size
= GET_MODE_SIZE (args
[i
].mode
);
2837 /* Handle calls that pass values in multiple non-contiguous
2838 locations. The Irix 6 ABI has examples of this. */
2840 if (GET_CODE (reg
) == PARALLEL
)
2841 emit_group_move (reg
, args
[i
].parallel_value
);
2843 /* If simple case, just do move. If normal partial, store_one_arg
2844 has already loaded the register for us. In all other cases,
2845 load the register(s) from memory. */
2847 else if (nregs
== -1)
2849 emit_move_insn (reg
, args
[i
].value
);
2850 #ifdef BLOCK_REG_PADDING
2851 /* Handle case where we have a value that needs shifting
2852 up to the msb. eg. a QImode value and we're padding
2853 upward on a BYTES_BIG_ENDIAN machine. */
2854 if (args
[i
].locate
.where_pad
2855 == (BYTES_BIG_ENDIAN
? PAD_UPWARD
: PAD_DOWNWARD
))
2857 gcc_checking_assert (ordered_p (size
, UNITS_PER_WORD
));
2858 if (maybe_lt (size
, UNITS_PER_WORD
))
2862 = (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
2864 /* Assigning REG here rather than a temp makes
2865 CALL_FUSAGE report the whole reg as used.
2866 Strictly speaking, the call only uses SIZE
2867 bytes at the msb end, but it doesn't seem worth
2868 generating rtl to say that. */
2869 reg
= gen_rtx_REG (word_mode
, REGNO (reg
));
2870 x
= expand_shift (LSHIFT_EXPR
, word_mode
,
2871 reg
, shift
, reg
, 1);
2873 emit_move_insn (reg
, x
);
2879 /* If we have pre-computed the values to put in the registers in
2880 the case of non-aligned structures, copy them in now. */
2882 else if (args
[i
].n_aligned_regs
!= 0)
2883 for (j
= 0; j
< args
[i
].n_aligned_regs
; j
++)
2884 emit_move_insn (gen_rtx_REG (word_mode
, REGNO (reg
) + j
),
2885 args
[i
].aligned_regs
[j
]);
2887 else if (partial
== 0 || args
[i
].pass_on_stack
)
2889 /* SIZE and CONST_SIZE are 0 for partial arguments and
2890 the size of a BLKmode type otherwise. */
2891 gcc_checking_assert (known_eq (size
, const_size
));
2892 rtx mem
= validize_mem (copy_rtx (args
[i
].value
));
2894 /* Check for overlap with already clobbered argument area,
2895 providing that this has non-zero size. */
2898 && (mem_might_overlap_already_clobbered_arg_p
2899 (XEXP (args
[i
].value
, 0), const_size
)))
2900 *sibcall_failure
= 1;
2902 if (const_size
% UNITS_PER_WORD
== 0
2903 || MEM_ALIGN (mem
) % BITS_PER_WORD
== 0)
2904 move_block_to_reg (REGNO (reg
), mem
, nregs
, args
[i
].mode
);
2908 move_block_to_reg (REGNO (reg
), mem
, nregs
- 1,
2910 rtx dest
= gen_rtx_REG (word_mode
, REGNO (reg
) + nregs
- 1);
2911 unsigned int bitoff
= (nregs
- 1) * BITS_PER_WORD
;
2912 unsigned int bitsize
= const_size
* BITS_PER_UNIT
- bitoff
;
2913 rtx x
= extract_bit_field (mem
, bitsize
, bitoff
, 1, dest
,
2914 word_mode
, word_mode
, false,
2916 if (BYTES_BIG_ENDIAN
)
2917 x
= expand_shift (LSHIFT_EXPR
, word_mode
, x
,
2918 BITS_PER_WORD
- bitsize
, dest
, 1);
2920 emit_move_insn (dest
, x
);
2923 /* Handle a BLKmode that needs shifting. */
2924 if (nregs
== 1 && const_size
< UNITS_PER_WORD
2925 #ifdef BLOCK_REG_PADDING
2926 && args
[i
].locate
.where_pad
== PAD_DOWNWARD
2932 rtx dest
= gen_rtx_REG (word_mode
, REGNO (reg
));
2933 int shift
= (UNITS_PER_WORD
- const_size
) * BITS_PER_UNIT
;
2934 enum tree_code dir
= (BYTES_BIG_ENDIAN
2935 ? RSHIFT_EXPR
: LSHIFT_EXPR
);
2938 x
= expand_shift (dir
, word_mode
, dest
, shift
, dest
, 1);
2940 emit_move_insn (dest
, x
);
2944 /* When a parameter is a block, and perhaps in other cases, it is
2945 possible that it did a load from an argument slot that was
2946 already clobbered. */
2948 && check_sibcall_argument_overlap (before_arg
, &args
[i
], 0))
2949 *sibcall_failure
= 1;
2951 /* Handle calls that pass values in multiple non-contiguous
2952 locations. The Irix 6 ABI has examples of this. */
2953 if (GET_CODE (reg
) == PARALLEL
)
2954 use_group_regs (call_fusage
, reg
);
2955 else if (nregs
== -1)
2956 use_reg_mode (call_fusage
, reg
,
2957 TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)));
2959 use_regs (call_fusage
, REGNO (reg
), nregs
);
2964 /* We need to pop PENDING_STACK_ADJUST bytes. But, if the arguments
2965 wouldn't fill up an even multiple of PREFERRED_UNIT_STACK_BOUNDARY
2966 bytes, then we would need to push some additional bytes to pad the
2967 arguments. So, we try to compute an adjust to the stack pointer for an
2968 amount that will leave the stack under-aligned by UNADJUSTED_ARGS_SIZE
2969 bytes. Then, when the arguments are pushed the stack will be perfectly
2972 Return true if this optimization is possible, storing the adjustment
2973 in ADJUSTMENT_OUT and setting ARGS_SIZE->CONSTANT to the number of
2974 bytes that should be popped after the call. */
2977 combine_pending_stack_adjustment_and_call (poly_int64_pod
*adjustment_out
,
2978 poly_int64 unadjusted_args_size
,
2979 struct args_size
*args_size
,
2980 unsigned int preferred_unit_stack_boundary
)
2982 /* The number of bytes to pop so that the stack will be
2983 under-aligned by UNADJUSTED_ARGS_SIZE bytes. */
2984 poly_int64 adjustment
;
2985 /* The alignment of the stack after the arguments are pushed, if we
2986 just pushed the arguments without adjust the stack here. */
2987 unsigned HOST_WIDE_INT unadjusted_alignment
;
2989 if (!known_misalignment (stack_pointer_delta
+ unadjusted_args_size
,
2990 preferred_unit_stack_boundary
,
2991 &unadjusted_alignment
))
2994 /* We want to get rid of as many of the PENDING_STACK_ADJUST bytes
2995 as possible -- leaving just enough left to cancel out the
2996 UNADJUSTED_ALIGNMENT. In other words, we want to ensure that the
2997 PENDING_STACK_ADJUST is non-negative, and congruent to
2998 -UNADJUSTED_ALIGNMENT modulo the PREFERRED_UNIT_STACK_BOUNDARY. */
3000 /* Begin by trying to pop all the bytes. */
3001 unsigned HOST_WIDE_INT tmp_misalignment
;
3002 if (!known_misalignment (pending_stack_adjust
,
3003 preferred_unit_stack_boundary
,
3006 unadjusted_alignment
-= tmp_misalignment
;
3007 adjustment
= pending_stack_adjust
;
3008 /* Push enough additional bytes that the stack will be aligned
3009 after the arguments are pushed. */
3010 if (preferred_unit_stack_boundary
> 1 && unadjusted_alignment
)
3011 adjustment
-= preferred_unit_stack_boundary
- unadjusted_alignment
;
3013 /* We need to know whether the adjusted argument size
3014 (UNADJUSTED_ARGS_SIZE - ADJUSTMENT) constitutes an allocation
3015 or a deallocation. */
3016 if (!ordered_p (adjustment
, unadjusted_args_size
))
3019 /* Now, sets ARGS_SIZE->CONSTANT so that we pop the right number of
3020 bytes after the call. The right number is the entire
3021 PENDING_STACK_ADJUST less our ADJUSTMENT plus the amount required
3022 by the arguments in the first place. */
3024 = pending_stack_adjust
- adjustment
+ unadjusted_args_size
;
3026 *adjustment_out
= adjustment
;
3030 /* Scan X expression if it does not dereference any argument slots
3031 we already clobbered by tail call arguments (as noted in stored_args_map
3033 Return nonzero if X expression dereferences such argument slots,
3037 check_sibcall_argument_overlap_1 (rtx x
)
3046 code
= GET_CODE (x
);
3048 /* We need not check the operands of the CALL expression itself. */
3053 return (mem_might_overlap_already_clobbered_arg_p
3054 (XEXP (x
, 0), GET_MODE_SIZE (GET_MODE (x
))));
3056 /* Scan all subexpressions. */
3057 fmt
= GET_RTX_FORMAT (code
);
3058 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++, fmt
++)
3062 if (check_sibcall_argument_overlap_1 (XEXP (x
, i
)))
3065 else if (*fmt
== 'E')
3067 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3068 if (check_sibcall_argument_overlap_1 (XVECEXP (x
, i
, j
)))
3075 /* Scan sequence after INSN if it does not dereference any argument slots
3076 we already clobbered by tail call arguments (as noted in stored_args_map
3077 bitmap). If MARK_STORED_ARGS_MAP, add stack slots for ARG to
3078 stored_args_map bitmap afterwards (when ARG is a register MARK_STORED_ARGS_MAP
3079 should be 0). Return nonzero if sequence after INSN dereferences such argument
3080 slots, zero otherwise. */
3083 check_sibcall_argument_overlap (rtx_insn
*insn
, struct arg_data
*arg
,
3084 int mark_stored_args_map
)
3086 poly_uint64 low
, high
;
3087 unsigned HOST_WIDE_INT const_low
, const_high
;
3089 if (insn
== NULL_RTX
)
3090 insn
= get_insns ();
3092 insn
= NEXT_INSN (insn
);
3094 for (; insn
; insn
= NEXT_INSN (insn
))
3096 && check_sibcall_argument_overlap_1 (PATTERN (insn
)))
3099 if (mark_stored_args_map
)
3101 if (ARGS_GROW_DOWNWARD
)
3102 low
= -arg
->locate
.slot_offset
.constant
- arg
->locate
.size
.constant
;
3104 low
= arg
->locate
.slot_offset
.constant
;
3105 high
= low
+ arg
->locate
.size
.constant
;
3107 const_low
= constant_lower_bound (low
);
3108 if (high
.is_constant (&const_high
))
3109 for (unsigned HOST_WIDE_INT i
= const_low
; i
< const_high
; ++i
)
3110 bitmap_set_bit (stored_args_map
, i
);
3112 stored_args_watermark
= MIN (stored_args_watermark
, const_low
);
3114 return insn
!= NULL_RTX
;
3117 /* Given that a function returns a value of mode MODE at the most
3118 significant end of hard register VALUE, shift VALUE left or right
3119 as specified by LEFT_P. Return true if some action was needed. */
3122 shift_return_value (machine_mode mode
, bool left_p
, rtx value
)
3124 gcc_assert (REG_P (value
) && HARD_REGISTER_P (value
));
3125 machine_mode value_mode
= GET_MODE (value
);
3126 poly_int64 shift
= GET_MODE_BITSIZE (value_mode
) - GET_MODE_BITSIZE (mode
);
3128 if (known_eq (shift
, 0))
3131 /* Use ashr rather than lshr for right shifts. This is for the benefit
3132 of the MIPS port, which requires SImode values to be sign-extended
3133 when stored in 64-bit registers. */
3134 if (!force_expand_binop (value_mode
, left_p
? ashl_optab
: ashr_optab
,
3135 value
, gen_int_shift_amount (value_mode
, shift
),
3136 value
, 1, OPTAB_WIDEN
))
3141 /* If X is a likely-spilled register value, copy it to a pseudo
3142 register and return that register. Return X otherwise. */
3145 avoid_likely_spilled_reg (rtx x
)
3150 && HARD_REGISTER_P (x
)
3151 && targetm
.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (x
))))
3153 /* Make sure that we generate a REG rather than a CONCAT.
3154 Moves into CONCATs can need nontrivial instructions,
3155 and the whole point of this function is to avoid
3156 using the hard register directly in such a situation. */
3157 generating_concat_p
= 0;
3158 new_rtx
= gen_reg_rtx (GET_MODE (x
));
3159 generating_concat_p
= 1;
3160 emit_move_insn (new_rtx
, x
);
3166 /* Helper function for expand_call.
3167 Return false is EXP is not implementable as a sibling call. */
3170 can_implement_as_sibling_call_p (tree exp
,
3171 rtx structure_value_addr
,
3173 int reg_parm_stack_space ATTRIBUTE_UNUSED
,
3177 const args_size
&args_size
)
3179 if (!targetm
.have_sibcall_epilogue ())
3181 maybe_complain_about_tail_call
3183 "machine description does not have"
3184 " a sibcall_epilogue instruction pattern");
3188 /* Doing sibling call optimization needs some work, since
3189 structure_value_addr can be allocated on the stack.
3190 It does not seem worth the effort since few optimizable
3191 sibling calls will return a structure. */
3192 if (structure_value_addr
!= NULL_RTX
)
3194 maybe_complain_about_tail_call (exp
, "callee returns a structure");
3198 #ifdef REG_PARM_STACK_SPACE
3199 /* If outgoing reg parm stack space changes, we can not do sibcall. */
3200 if (OUTGOING_REG_PARM_STACK_SPACE (funtype
)
3201 != OUTGOING_REG_PARM_STACK_SPACE (TREE_TYPE (current_function_decl
))
3202 || (reg_parm_stack_space
!= REG_PARM_STACK_SPACE (current_function_decl
)))
3204 maybe_complain_about_tail_call (exp
,
3205 "inconsistent size of stack space"
3206 " allocated for arguments which are"
3207 " passed in registers");
3212 /* Check whether the target is able to optimize the call
3214 if (!targetm
.function_ok_for_sibcall (fndecl
, exp
))
3216 maybe_complain_about_tail_call (exp
,
3217 "target is not able to optimize the"
3218 " call into a sibling call");
3222 /* Functions that do not return exactly once may not be sibcall
3224 if (flags
& ECF_RETURNS_TWICE
)
3226 maybe_complain_about_tail_call (exp
, "callee returns twice");
3229 if (flags
& ECF_NORETURN
)
3231 maybe_complain_about_tail_call (exp
, "callee does not return");
3235 if (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (addr
))))
3237 maybe_complain_about_tail_call (exp
, "volatile function type");
3241 /* If the called function is nested in the current one, it might access
3242 some of the caller's arguments, but could clobber them beforehand if
3243 the argument areas are shared. */
3244 if (fndecl
&& decl_function_context (fndecl
) == current_function_decl
)
3246 maybe_complain_about_tail_call (exp
, "nested function");
3250 /* If this function requires more stack slots than the current
3251 function, we cannot change it into a sibling call.
3252 crtl->args.pretend_args_size is not part of the
3253 stack allocated by our caller. */
3254 if (maybe_gt (args_size
.constant
,
3255 crtl
->args
.size
- crtl
->args
.pretend_args_size
))
3257 maybe_complain_about_tail_call (exp
,
3258 "callee required more stack slots"
3259 " than the caller");
3263 /* If the callee pops its own arguments, then it must pop exactly
3264 the same number of arguments as the current function. */
3265 if (maybe_ne (targetm
.calls
.return_pops_args (fndecl
, funtype
,
3266 args_size
.constant
),
3267 targetm
.calls
.return_pops_args (current_function_decl
,
3269 (current_function_decl
),
3272 maybe_complain_about_tail_call (exp
,
3273 "inconsistent number of"
3274 " popped arguments");
3278 if (!lang_hooks
.decls
.ok_for_sibcall (fndecl
))
3280 maybe_complain_about_tail_call (exp
, "frontend does not support"
3285 /* All checks passed. */
3289 /* Generate all the code for a CALL_EXPR exp
3290 and return an rtx for its value.
3291 Store the value in TARGET (specified as an rtx) if convenient.
3292 If the value is stored in TARGET then TARGET is returned.
3293 If IGNORE is nonzero, then we ignore the value of the function call. */
3296 expand_call (tree exp
, rtx target
, int ignore
)
3298 /* Nonzero if we are currently expanding a call. */
3299 static int currently_expanding_call
= 0;
3301 /* RTX for the function to be called. */
3303 /* Sequence of insns to perform a normal "call". */
3304 rtx_insn
*normal_call_insns
= NULL
;
3305 /* Sequence of insns to perform a tail "call". */
3306 rtx_insn
*tail_call_insns
= NULL
;
3307 /* Data type of the function. */
3309 tree type_arg_types
;
3311 /* Declaration of the function being called,
3312 or 0 if the function is computed (not known by name). */
3314 /* The type of the function being called. */
3316 bool try_tail_call
= CALL_EXPR_TAILCALL (exp
);
3317 bool must_tail_call
= CALL_EXPR_MUST_TAIL_CALL (exp
);
3320 /* Register in which non-BLKmode value will be returned,
3321 or 0 if no value or if value is BLKmode. */
3323 /* Register(s) in which bounds are returned. */
3325 /* Address where we should return a BLKmode value;
3326 0 if value not BLKmode. */
3327 rtx structure_value_addr
= 0;
3328 /* Nonzero if that address is being passed by treating it as
3329 an extra, implicit first parameter. Otherwise,
3330 it is passed by being copied directly into struct_value_rtx. */
3331 int structure_value_addr_parm
= 0;
3332 /* Holds the value of implicit argument for the struct value. */
3333 tree structure_value_addr_value
= NULL_TREE
;
3334 /* Size of aggregate value wanted, or zero if none wanted
3335 or if we are using the non-reentrant PCC calling convention
3336 or expecting the value in registers. */
3337 poly_int64 struct_value_size
= 0;
3338 /* Nonzero if called function returns an aggregate in memory PCC style,
3339 by returning the address of where to find it. */
3340 int pcc_struct_value
= 0;
3341 rtx struct_value
= 0;
3343 /* Number of actual parameters in this call, including struct value addr. */
3345 /* Number of named args. Args after this are anonymous ones
3346 and they must all go on the stack. */
3348 /* Number of complex actual arguments that need to be split. */
3349 int num_complex_actuals
= 0;
3351 /* Vector of information about each argument.
3352 Arguments are numbered in the order they will be pushed,
3353 not the order they are written. */
3354 struct arg_data
*args
;
3356 /* Total size in bytes of all the stack-parms scanned so far. */
3357 struct args_size args_size
;
3358 struct args_size adjusted_args_size
;
3359 /* Size of arguments before any adjustments (such as rounding). */
3360 poly_int64 unadjusted_args_size
;
3361 /* Data on reg parms scanned so far. */
3362 CUMULATIVE_ARGS args_so_far_v
;
3363 cumulative_args_t args_so_far
;
3364 /* Nonzero if a reg parm has been scanned. */
3366 /* Nonzero if this is an indirect function call. */
3368 /* Nonzero if we must avoid push-insns in the args for this call.
3369 If stack space is allocated for register parameters, but not by the
3370 caller, then it is preallocated in the fixed part of the stack frame.
3371 So the entire argument block must then be preallocated (i.e., we
3372 ignore PUSH_ROUNDING in that case). */
3374 int must_preallocate
= !PUSH_ARGS
;
3376 /* Size of the stack reserved for parameter registers. */
3377 int reg_parm_stack_space
= 0;
3379 /* Address of space preallocated for stack parms
3380 (on machines that lack push insns), or 0 if space not preallocated. */
3383 /* Mask of ECF_ and ERF_ flags. */
3385 int return_flags
= 0;
3386 #ifdef REG_PARM_STACK_SPACE
3387 /* Define the boundary of the register parm stack space that needs to be
3389 int low_to_save
, high_to_save
;
3390 rtx save_area
= 0; /* Place that it is saved */
3393 unsigned int initial_highest_arg_in_use
= highest_outgoing_arg_in_use
;
3394 char *initial_stack_usage_map
= stack_usage_map
;
3395 unsigned HOST_WIDE_INT initial_stack_usage_watermark
= stack_usage_watermark
;
3396 char *stack_usage_map_buf
= NULL
;
3398 poly_int64 old_stack_allocated
;
3400 /* State variables to track stack modifications. */
3401 rtx old_stack_level
= 0;
3402 int old_stack_arg_under_construction
= 0;
3403 poly_int64 old_pending_adj
= 0;
3404 int old_inhibit_defer_pop
= inhibit_defer_pop
;
3406 /* Some stack pointer alterations we make are performed via
3407 allocate_dynamic_stack_space. This modifies the stack_pointer_delta,
3408 which we then also need to save/restore along the way. */
3409 poly_int64 old_stack_pointer_delta
= 0;
3412 tree addr
= CALL_EXPR_FN (exp
);
3414 /* The alignment of the stack, in bits. */
3415 unsigned HOST_WIDE_INT preferred_stack_boundary
;
3416 /* The alignment of the stack, in bytes. */
3417 unsigned HOST_WIDE_INT preferred_unit_stack_boundary
;
3418 /* The static chain value to use for this call. */
3419 rtx static_chain_value
;
3420 /* See if this is "nothrow" function call. */
3421 if (TREE_NOTHROW (exp
))
3422 flags
|= ECF_NOTHROW
;
3424 /* See if we can find a DECL-node for the actual function, and get the
3425 function attributes (flags) from the function decl or type node. */
3426 fndecl
= get_callee_fndecl (exp
);
3429 fntype
= TREE_TYPE (fndecl
);
3430 flags
|= flags_from_decl_or_type (fndecl
);
3431 return_flags
|= decl_return_flags (fndecl
);
3435 fntype
= TREE_TYPE (TREE_TYPE (addr
));
3436 flags
|= flags_from_decl_or_type (fntype
);
3437 if (CALL_EXPR_BY_DESCRIPTOR (exp
))
3438 flags
|= ECF_BY_DESCRIPTOR
;
3440 rettype
= TREE_TYPE (exp
);
3442 struct_value
= targetm
.calls
.struct_value_rtx (fntype
, 0);
3444 /* Warn if this value is an aggregate type,
3445 regardless of which calling convention we are using for it. */
3446 if (AGGREGATE_TYPE_P (rettype
))
3447 warning (OPT_Waggregate_return
, "function call has aggregate value");
3449 /* If the result of a non looping pure or const function call is
3450 ignored (or void), and none of its arguments are volatile, we can
3451 avoid expanding the call and just evaluate the arguments for
3453 if ((flags
& (ECF_CONST
| ECF_PURE
))
3454 && (!(flags
& ECF_LOOPING_CONST_OR_PURE
))
3455 && (ignore
|| target
== const0_rtx
3456 || TYPE_MODE (rettype
) == VOIDmode
))
3458 bool volatilep
= false;
3460 call_expr_arg_iterator iter
;
3462 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
3463 if (TREE_THIS_VOLATILE (arg
))
3471 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
3472 expand_expr (arg
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3477 #ifdef REG_PARM_STACK_SPACE
3478 reg_parm_stack_space
= REG_PARM_STACK_SPACE (!fndecl
? fntype
: fndecl
);
3481 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
)))
3482 && reg_parm_stack_space
> 0 && PUSH_ARGS
)
3483 must_preallocate
= 1;
3485 /* Set up a place to return a structure. */
3487 /* Cater to broken compilers. */
3488 if (aggregate_value_p (exp
, fntype
))
3490 /* This call returns a big structure. */
3491 flags
&= ~(ECF_CONST
| ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
);
3493 #ifdef PCC_STATIC_STRUCT_RETURN
3495 pcc_struct_value
= 1;
3497 #else /* not PCC_STATIC_STRUCT_RETURN */
3499 if (!poly_int_tree_p (TYPE_SIZE_UNIT (rettype
), &struct_value_size
))
3500 struct_value_size
= -1;
3502 /* Even if it is semantically safe to use the target as the return
3503 slot, it may be not sufficiently aligned for the return type. */
3504 if (CALL_EXPR_RETURN_SLOT_OPT (exp
)
3507 /* If rettype is addressable, we may not create a temporary.
3508 If target is properly aligned at runtime and the compiler
3509 just doesn't know about it, it will work fine, otherwise it
3511 && (TREE_ADDRESSABLE (rettype
)
3512 || !(MEM_ALIGN (target
) < TYPE_ALIGN (rettype
)
3513 && targetm
.slow_unaligned_access (TYPE_MODE (rettype
),
3514 MEM_ALIGN (target
)))))
3515 structure_value_addr
= XEXP (target
, 0);
3518 /* For variable-sized objects, we must be called with a target
3519 specified. If we were to allocate space on the stack here,
3520 we would have no way of knowing when to free it. */
3521 rtx d
= assign_temp (rettype
, 1, 1);
3522 structure_value_addr
= XEXP (d
, 0);
3526 #endif /* not PCC_STATIC_STRUCT_RETURN */
3529 /* Figure out the amount to which the stack should be aligned. */
3530 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
3533 struct cgraph_rtl_info
*i
= cgraph_node::rtl_info (fndecl
);
3534 /* Without automatic stack alignment, we can't increase preferred
3535 stack boundary. With automatic stack alignment, it is
3536 unnecessary since unless we can guarantee that all callers will
3537 align the outgoing stack properly, callee has to align its
3540 && i
->preferred_incoming_stack_boundary
3541 && i
->preferred_incoming_stack_boundary
< preferred_stack_boundary
)
3542 preferred_stack_boundary
= i
->preferred_incoming_stack_boundary
;
3545 /* Operand 0 is a pointer-to-function; get the type of the function. */
3546 funtype
= TREE_TYPE (addr
);
3547 gcc_assert (POINTER_TYPE_P (funtype
));
3548 funtype
= TREE_TYPE (funtype
);
3550 /* Count whether there are actual complex arguments that need to be split
3551 into their real and imaginary parts. Munge the type_arg_types
3552 appropriately here as well. */
3553 if (targetm
.calls
.split_complex_arg
)
3555 call_expr_arg_iterator iter
;
3557 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
3559 tree type
= TREE_TYPE (arg
);
3560 if (type
&& TREE_CODE (type
) == COMPLEX_TYPE
3561 && targetm
.calls
.split_complex_arg (type
))
3562 num_complex_actuals
++;
3564 type_arg_types
= split_complex_types (TYPE_ARG_TYPES (funtype
));
3567 type_arg_types
= TYPE_ARG_TYPES (funtype
);
3569 if (flags
& ECF_MAY_BE_ALLOCA
)
3570 cfun
->calls_alloca
= 1;
3572 /* If struct_value_rtx is 0, it means pass the address
3573 as if it were an extra parameter. Put the argument expression
3574 in structure_value_addr_value. */
3575 if (structure_value_addr
&& struct_value
== 0)
3577 /* If structure_value_addr is a REG other than
3578 virtual_outgoing_args_rtx, we can use always use it. If it
3579 is not a REG, we must always copy it into a register.
3580 If it is virtual_outgoing_args_rtx, we must copy it to another
3581 register in some cases. */
3582 rtx temp
= (!REG_P (structure_value_addr
)
3583 || (ACCUMULATE_OUTGOING_ARGS
3584 && stack_arg_under_construction
3585 && structure_value_addr
== virtual_outgoing_args_rtx
)
3586 ? copy_addr_to_reg (convert_memory_address
3587 (Pmode
, structure_value_addr
))
3588 : structure_value_addr
);
3590 structure_value_addr_value
=
3591 make_tree (build_pointer_type (TREE_TYPE (funtype
)), temp
);
3592 structure_value_addr_parm
= CALL_WITH_BOUNDS_P (exp
) ? 2 : 1;
3595 /* Count the arguments and set NUM_ACTUALS. */
3597 call_expr_nargs (exp
) + num_complex_actuals
+ structure_value_addr_parm
;
3599 /* Compute number of named args.
3600 First, do a raw count of the args for INIT_CUMULATIVE_ARGS. */
3602 if (type_arg_types
!= 0)
3604 = (list_length (type_arg_types
)
3605 /* Count the struct value address, if it is passed as a parm. */
3606 + structure_value_addr_parm
);
3608 /* If we know nothing, treat all args as named. */
3609 n_named_args
= num_actuals
;
3611 /* Start updating where the next arg would go.
3613 On some machines (such as the PA) indirect calls have a different
3614 calling convention than normal calls. The fourth argument in
3615 INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
3617 INIT_CUMULATIVE_ARGS (args_so_far_v
, funtype
, NULL_RTX
, fndecl
, n_named_args
);
3618 args_so_far
= pack_cumulative_args (&args_so_far_v
);
3620 /* Now possibly adjust the number of named args.
3621 Normally, don't include the last named arg if anonymous args follow.
3622 We do include the last named arg if
3623 targetm.calls.strict_argument_naming() returns nonzero.
3624 (If no anonymous args follow, the result of list_length is actually
3625 one too large. This is harmless.)
3627 If targetm.calls.pretend_outgoing_varargs_named() returns
3628 nonzero, and targetm.calls.strict_argument_naming() returns zero,
3629 this machine will be able to place unnamed args that were passed
3630 in registers into the stack. So treat all args as named. This
3631 allows the insns emitting for a specific argument list to be
3632 independent of the function declaration.
3634 If targetm.calls.pretend_outgoing_varargs_named() returns zero,
3635 we do not have any reliable way to pass unnamed args in
3636 registers, so we must force them into memory. */
3638 if (type_arg_types
!= 0
3639 && targetm
.calls
.strict_argument_naming (args_so_far
))
3641 else if (type_arg_types
!= 0
3642 && ! targetm
.calls
.pretend_outgoing_varargs_named (args_so_far
))
3643 /* Don't include the last named arg. */
3646 /* Treat all args as named. */
3647 n_named_args
= num_actuals
;
3649 /* Make a vector to hold all the information about each arg. */
3650 args
= XCNEWVEC (struct arg_data
, num_actuals
);
3652 /* Build up entries in the ARGS array, compute the size of the
3653 arguments into ARGS_SIZE, etc. */
3654 initialize_argument_information (num_actuals
, args
, &args_size
,
3656 structure_value_addr_value
, fndecl
, fntype
,
3657 args_so_far
, reg_parm_stack_space
,
3658 &old_stack_level
, &old_pending_adj
,
3659 &must_preallocate
, &flags
,
3660 &try_tail_call
, CALL_FROM_THUNK_P (exp
));
3663 must_preallocate
= 1;
3665 /* Now make final decision about preallocating stack space. */
3666 must_preallocate
= finalize_must_preallocate (must_preallocate
,
3670 /* If the structure value address will reference the stack pointer, we
3671 must stabilize it. We don't need to do this if we know that we are
3672 not going to adjust the stack pointer in processing this call. */
3674 if (structure_value_addr
3675 && (reg_mentioned_p (virtual_stack_dynamic_rtx
, structure_value_addr
)
3676 || reg_mentioned_p (virtual_outgoing_args_rtx
,
3677 structure_value_addr
))
3679 || (!ACCUMULATE_OUTGOING_ARGS
3680 && maybe_ne (args_size
.constant
, 0))))
3681 structure_value_addr
= copy_to_reg (structure_value_addr
);
3683 /* Tail calls can make things harder to debug, and we've traditionally
3684 pushed these optimizations into -O2. Don't try if we're already
3685 expanding a call, as that means we're an argument. Don't try if
3686 there's cleanups, as we know there's code to follow the call. */
3688 if (currently_expanding_call
++ != 0
3689 || !flag_optimize_sibling_calls
3691 || dbg_cnt (tail_call
) == false)
3694 /* If the user has marked the function as requiring tail-call
3695 optimization, attempt it. */
3699 /* Rest of purposes for tail call optimizations to fail. */
3701 try_tail_call
= can_implement_as_sibling_call_p (exp
,
3702 structure_value_addr
,
3704 reg_parm_stack_space
,
3706 flags
, addr
, args_size
);
3708 /* Check if caller and callee disagree in promotion of function
3712 machine_mode caller_mode
, caller_promoted_mode
;
3713 machine_mode callee_mode
, callee_promoted_mode
;
3714 int caller_unsignedp
, callee_unsignedp
;
3715 tree caller_res
= DECL_RESULT (current_function_decl
);
3717 caller_unsignedp
= TYPE_UNSIGNED (TREE_TYPE (caller_res
));
3718 caller_mode
= DECL_MODE (caller_res
);
3719 callee_unsignedp
= TYPE_UNSIGNED (TREE_TYPE (funtype
));
3720 callee_mode
= TYPE_MODE (TREE_TYPE (funtype
));
3721 caller_promoted_mode
3722 = promote_function_mode (TREE_TYPE (caller_res
), caller_mode
,
3724 TREE_TYPE (current_function_decl
), 1);
3725 callee_promoted_mode
3726 = promote_function_mode (TREE_TYPE (funtype
), callee_mode
,
3729 if (caller_mode
!= VOIDmode
3730 && (caller_promoted_mode
!= callee_promoted_mode
3731 || ((caller_mode
!= caller_promoted_mode
3732 || callee_mode
!= callee_promoted_mode
)
3733 && (caller_unsignedp
!= callee_unsignedp
3734 || partial_subreg_p (caller_mode
, callee_mode
)))))
3737 maybe_complain_about_tail_call (exp
,
3738 "caller and callee disagree in"
3739 " promotion of function"
3744 /* Ensure current function's preferred stack boundary is at least
3745 what we need. Stack alignment may also increase preferred stack
3747 if (crtl
->preferred_stack_boundary
< preferred_stack_boundary
)
3748 crtl
->preferred_stack_boundary
= preferred_stack_boundary
;
3750 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
3752 preferred_unit_stack_boundary
= preferred_stack_boundary
/ BITS_PER_UNIT
;
3754 /* We want to make two insn chains; one for a sibling call, the other
3755 for a normal call. We will select one of the two chains after
3756 initial RTL generation is complete. */
3757 for (pass
= try_tail_call
? 0 : 1; pass
< 2; pass
++)
3759 int sibcall_failure
= 0;
3760 /* We want to emit any pending stack adjustments before the tail
3761 recursion "call". That way we know any adjustment after the tail
3762 recursion call can be ignored if we indeed use the tail
3764 saved_pending_stack_adjust save
;
3765 rtx_insn
*insns
, *before_call
, *after_args
;
3770 /* State variables we need to save and restore between
3772 save_pending_stack_adjust (&save
);
3775 flags
&= ~ECF_SIBCALL
;
3777 flags
|= ECF_SIBCALL
;
3779 /* Other state variables that we must reinitialize each time
3780 through the loop (that are not initialized by the loop itself). */
3784 /* Start a new sequence for the normal call case.
3786 From this point on, if the sibling call fails, we want to set
3787 sibcall_failure instead of continuing the loop. */
3790 /* Don't let pending stack adjusts add up to too much.
3791 Also, do all pending adjustments now if there is any chance
3792 this might be a call to alloca or if we are expanding a sibling
3794 Also do the adjustments before a throwing call, otherwise
3795 exception handling can fail; PR 19225. */
3796 if (maybe_ge (pending_stack_adjust
, 32)
3797 || (maybe_ne (pending_stack_adjust
, 0)
3798 && (flags
& ECF_MAY_BE_ALLOCA
))
3799 || (maybe_ne (pending_stack_adjust
, 0)
3800 && flag_exceptions
&& !(flags
& ECF_NOTHROW
))
3802 do_pending_stack_adjust ();
3804 /* Precompute any arguments as needed. */
3806 precompute_arguments (num_actuals
, args
);
3808 /* Now we are about to start emitting insns that can be deleted
3809 if a libcall is deleted. */
3810 if (pass
&& (flags
& ECF_MALLOC
))
3814 && crtl
->stack_protect_guard
3815 && targetm
.stack_protect_runtime_enabled_p ())
3816 stack_protect_epilogue ();
3818 adjusted_args_size
= args_size
;
3819 /* Compute the actual size of the argument block required. The variable
3820 and constant sizes must be combined, the size may have to be rounded,
3821 and there may be a minimum required size. When generating a sibcall
3822 pattern, do not round up, since we'll be re-using whatever space our
3824 unadjusted_args_size
3825 = compute_argument_block_size (reg_parm_stack_space
,
3826 &adjusted_args_size
,
3829 : preferred_stack_boundary
));
3831 old_stack_allocated
= stack_pointer_delta
- pending_stack_adjust
;
3833 /* The argument block when performing a sibling call is the
3834 incoming argument block. */
3837 argblock
= crtl
->args
.internal_arg_pointer
;
3838 if (STACK_GROWS_DOWNWARD
)
3840 = plus_constant (Pmode
, argblock
, crtl
->args
.pretend_args_size
);
3843 = plus_constant (Pmode
, argblock
, -crtl
->args
.pretend_args_size
);
3845 HOST_WIDE_INT map_size
= constant_lower_bound (args_size
.constant
);
3846 stored_args_map
= sbitmap_alloc (map_size
);
3847 bitmap_clear (stored_args_map
);
3848 stored_args_watermark
= HOST_WIDE_INT_M1U
;
3851 /* If we have no actual push instructions, or shouldn't use them,
3852 make space for all args right now. */
3853 else if (adjusted_args_size
.var
!= 0)
3855 if (old_stack_level
== 0)
3857 emit_stack_save (SAVE_BLOCK
, &old_stack_level
);
3858 old_stack_pointer_delta
= stack_pointer_delta
;
3859 old_pending_adj
= pending_stack_adjust
;
3860 pending_stack_adjust
= 0;
3861 /* stack_arg_under_construction says whether a stack arg is
3862 being constructed at the old stack level. Pushing the stack
3863 gets a clean outgoing argument block. */
3864 old_stack_arg_under_construction
= stack_arg_under_construction
;
3865 stack_arg_under_construction
= 0;
3867 argblock
= push_block (ARGS_SIZE_RTX (adjusted_args_size
), 0, 0);
3868 if (flag_stack_usage_info
)
3869 current_function_has_unbounded_dynamic_stack_size
= 1;
3873 /* Note that we must go through the motions of allocating an argument
3874 block even if the size is zero because we may be storing args
3875 in the area reserved for register arguments, which may be part of
3878 poly_int64 needed
= adjusted_args_size
.constant
;
3880 /* Store the maximum argument space used. It will be pushed by
3881 the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
3884 crtl
->outgoing_args_size
= upper_bound (crtl
->outgoing_args_size
,
3887 if (must_preallocate
)
3889 if (ACCUMULATE_OUTGOING_ARGS
)
3891 /* Since the stack pointer will never be pushed, it is
3892 possible for the evaluation of a parm to clobber
3893 something we have already written to the stack.
3894 Since most function calls on RISC machines do not use
3895 the stack, this is uncommon, but must work correctly.
3897 Therefore, we save any area of the stack that was already
3898 written and that we are using. Here we set up to do this
3899 by making a new stack usage map from the old one. The
3900 actual save will be done by store_one_arg.
3902 Another approach might be to try to reorder the argument
3903 evaluations to avoid this conflicting stack usage. */
3905 /* Since we will be writing into the entire argument area,
3906 the map must be allocated for its entire size, not just
3907 the part that is the responsibility of the caller. */
3908 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
3909 needed
+= reg_parm_stack_space
;
3911 poly_int64 limit
= needed
;
3912 if (ARGS_GROW_DOWNWARD
)
3915 /* For polynomial sizes, this is the maximum possible
3916 size needed for arguments with a constant size
3918 HOST_WIDE_INT const_limit
= constant_lower_bound (limit
);
3919 highest_outgoing_arg_in_use
3920 = MAX (initial_highest_arg_in_use
, const_limit
);
3922 free (stack_usage_map_buf
);
3923 stack_usage_map_buf
= XNEWVEC (char, highest_outgoing_arg_in_use
);
3924 stack_usage_map
= stack_usage_map_buf
;
3926 if (initial_highest_arg_in_use
)
3927 memcpy (stack_usage_map
, initial_stack_usage_map
,
3928 initial_highest_arg_in_use
);
3930 if (initial_highest_arg_in_use
!= highest_outgoing_arg_in_use
)
3931 memset (&stack_usage_map
[initial_highest_arg_in_use
], 0,
3932 (highest_outgoing_arg_in_use
3933 - initial_highest_arg_in_use
));
3936 /* The address of the outgoing argument list must not be
3937 copied to a register here, because argblock would be left
3938 pointing to the wrong place after the call to
3939 allocate_dynamic_stack_space below. */
3941 argblock
= virtual_outgoing_args_rtx
;
3945 /* Try to reuse some or all of the pending_stack_adjust
3946 to get this space. */
3947 if (inhibit_defer_pop
== 0
3948 && (combine_pending_stack_adjustment_and_call
3950 unadjusted_args_size
,
3951 &adjusted_args_size
,
3952 preferred_unit_stack_boundary
)))
3954 /* combine_pending_stack_adjustment_and_call computes
3955 an adjustment before the arguments are allocated.
3956 Account for them and see whether or not the stack
3957 needs to go up or down. */
3958 needed
= unadjusted_args_size
- needed
;
3961 combine_pending_stack_adjustment_and_call. */
3962 gcc_checking_assert (ordered_p (needed
, 0));
3963 if (maybe_lt (needed
, 0))
3965 /* We're releasing stack space. */
3966 /* ??? We can avoid any adjustment at all if we're
3967 already aligned. FIXME. */
3968 pending_stack_adjust
= -needed
;
3969 do_pending_stack_adjust ();
3973 /* We need to allocate space. We'll do that in
3974 push_block below. */
3975 pending_stack_adjust
= 0;
3978 /* Special case this because overhead of `push_block' in
3979 this case is non-trivial. */
3980 if (known_eq (needed
, 0))
3981 argblock
= virtual_outgoing_args_rtx
;
3984 rtx needed_rtx
= gen_int_mode (needed
, Pmode
);
3985 argblock
= push_block (needed_rtx
, 0, 0);
3986 if (ARGS_GROW_DOWNWARD
)
3987 argblock
= plus_constant (Pmode
, argblock
, needed
);
3990 /* We only really need to call `copy_to_reg' in the case
3991 where push insns are going to be used to pass ARGBLOCK
3992 to a function call in ARGS. In that case, the stack
3993 pointer changes value from the allocation point to the
3994 call point, and hence the value of
3995 VIRTUAL_OUTGOING_ARGS_RTX changes as well. But might
3996 as well always do it. */
3997 argblock
= copy_to_reg (argblock
);
4002 if (ACCUMULATE_OUTGOING_ARGS
)
4004 /* The save/restore code in store_one_arg handles all
4005 cases except one: a constructor call (including a C
4006 function returning a BLKmode struct) to initialize
4008 if (stack_arg_under_construction
)
4012 (adjusted_args_size
.constant
4013 + (OUTGOING_REG_PARM_STACK_SPACE (!fndecl
? fntype
4014 : TREE_TYPE (fndecl
))
4015 ? 0 : reg_parm_stack_space
), Pmode
));
4016 if (old_stack_level
== 0)
4018 emit_stack_save (SAVE_BLOCK
, &old_stack_level
);
4019 old_stack_pointer_delta
= stack_pointer_delta
;
4020 old_pending_adj
= pending_stack_adjust
;
4021 pending_stack_adjust
= 0;
4022 /* stack_arg_under_construction says whether a stack
4023 arg is being constructed at the old stack level.
4024 Pushing the stack gets a clean outgoing argument
4026 old_stack_arg_under_construction
4027 = stack_arg_under_construction
;
4028 stack_arg_under_construction
= 0;
4029 /* Make a new map for the new argument list. */
4030 free (stack_usage_map_buf
);
4031 stack_usage_map_buf
= XCNEWVEC (char, highest_outgoing_arg_in_use
);
4032 stack_usage_map
= stack_usage_map_buf
;
4033 highest_outgoing_arg_in_use
= 0;
4034 stack_usage_watermark
= HOST_WIDE_INT_M1U
;
4036 /* We can pass TRUE as the 4th argument because we just
4037 saved the stack pointer and will restore it right after
4039 allocate_dynamic_stack_space (push_size
, 0, BIGGEST_ALIGNMENT
,
4043 /* If argument evaluation might modify the stack pointer,
4044 copy the address of the argument list to a register. */
4045 for (i
= 0; i
< num_actuals
; i
++)
4046 if (args
[i
].pass_on_stack
)
4048 argblock
= copy_addr_to_reg (argblock
);
4053 compute_argument_addresses (args
, argblock
, num_actuals
);
4055 /* Stack is properly aligned, pops can't safely be deferred during
4056 the evaluation of the arguments. */
4059 /* Precompute all register parameters. It isn't safe to compute
4060 anything once we have started filling any specific hard regs.
4061 TLS symbols sometimes need a call to resolve. Precompute
4062 register parameters before any stack pointer manipulation
4063 to avoid unaligned stack in the called function. */
4064 precompute_register_parameters (num_actuals
, args
, ®_parm_seen
);
4068 /* Perform stack alignment before the first push (the last arg). */
4070 && maybe_gt (adjusted_args_size
.constant
, reg_parm_stack_space
)
4071 && maybe_ne (adjusted_args_size
.constant
, unadjusted_args_size
))
4073 /* When the stack adjustment is pending, we get better code
4074 by combining the adjustments. */
4075 if (maybe_ne (pending_stack_adjust
, 0)
4076 && ! inhibit_defer_pop
4077 && (combine_pending_stack_adjustment_and_call
4078 (&pending_stack_adjust
,
4079 unadjusted_args_size
,
4080 &adjusted_args_size
,
4081 preferred_unit_stack_boundary
)))
4082 do_pending_stack_adjust ();
4083 else if (argblock
== 0)
4084 anti_adjust_stack (gen_int_mode (adjusted_args_size
.constant
4085 - unadjusted_args_size
,
4088 /* Now that the stack is properly aligned, pops can't safely
4089 be deferred during the evaluation of the arguments. */
4092 /* Record the maximum pushed stack space size. We need to delay
4093 doing it this far to take into account the optimization done
4094 by combine_pending_stack_adjustment_and_call. */
4095 if (flag_stack_usage_info
4096 && !ACCUMULATE_OUTGOING_ARGS
4098 && adjusted_args_size
.var
== 0)
4100 poly_int64 pushed
= (adjusted_args_size
.constant
4101 + pending_stack_adjust
);
4102 current_function_pushed_stack_size
4103 = upper_bound (current_function_pushed_stack_size
, pushed
);
4106 funexp
= rtx_for_function_call (fndecl
, addr
);
4108 if (CALL_EXPR_STATIC_CHAIN (exp
))
4109 static_chain_value
= expand_normal (CALL_EXPR_STATIC_CHAIN (exp
));
4111 static_chain_value
= 0;
4113 #ifdef REG_PARM_STACK_SPACE
4114 /* Save the fixed argument area if it's part of the caller's frame and
4115 is clobbered by argument setup for this call. */
4116 if (ACCUMULATE_OUTGOING_ARGS
&& pass
)
4117 save_area
= save_fixed_argument_area (reg_parm_stack_space
, argblock
,
4118 &low_to_save
, &high_to_save
);
4121 /* Now store (and compute if necessary) all non-register parms.
4122 These come before register parms, since they can require block-moves,
4123 which could clobber the registers used for register parms.
4124 Parms which have partial registers are not stored here,
4125 but we do preallocate space here if they want that. */
4127 for (i
= 0; i
< num_actuals
; i
++)
4129 /* Delay bounds until all other args are stored. */
4130 if (POINTER_BOUNDS_P (args
[i
].tree_value
))
4132 else if (args
[i
].reg
== 0 || args
[i
].pass_on_stack
)
4134 rtx_insn
*before_arg
= get_last_insn ();
4136 /* We don't allow passing huge (> 2^30 B) arguments
4137 by value. It would cause an overflow later on. */
4138 if (constant_lower_bound (adjusted_args_size
.constant
)
4139 >= (1 << (HOST_BITS_PER_INT
- 2)))
4141 sorry ("passing too large argument on stack");
4145 if (store_one_arg (&args
[i
], argblock
, flags
,
4146 adjusted_args_size
.var
!= 0,
4147 reg_parm_stack_space
)
4149 && check_sibcall_argument_overlap (before_arg
,
4151 sibcall_failure
= 1;
4156 = gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)),
4157 gen_rtx_USE (VOIDmode
, args
[i
].stack
),
4161 /* If we have a parm that is passed in registers but not in memory
4162 and whose alignment does not permit a direct copy into registers,
4163 make a group of pseudos that correspond to each register that we
4165 if (STRICT_ALIGNMENT
)
4166 store_unaligned_arguments_into_pseudos (args
, num_actuals
);
4168 /* Now store any partially-in-registers parm.
4169 This is the last place a block-move can happen. */
4171 for (i
= 0; i
< num_actuals
; i
++)
4172 if (args
[i
].partial
!= 0 && ! args
[i
].pass_on_stack
)
4174 rtx_insn
*before_arg
= get_last_insn ();
4176 /* On targets with weird calling conventions (e.g. PA) it's
4177 hard to ensure that all cases of argument overlap between
4178 stack and registers work. Play it safe and bail out. */
4179 if (ARGS_GROW_DOWNWARD
&& !STACK_GROWS_DOWNWARD
)
4181 sibcall_failure
= 1;
4185 if (store_one_arg (&args
[i
], argblock
, flags
,
4186 adjusted_args_size
.var
!= 0,
4187 reg_parm_stack_space
)
4189 && check_sibcall_argument_overlap (before_arg
,
4191 sibcall_failure
= 1;
4194 bool any_regs
= false;
4195 for (i
= 0; i
< num_actuals
; i
++)
4196 if (args
[i
].reg
!= NULL_RTX
)
4199 targetm
.calls
.call_args (args
[i
].reg
, funtype
);
4202 targetm
.calls
.call_args (pc_rtx
, funtype
);
4204 /* Figure out the register where the value, if any, will come back. */
4207 if (TYPE_MODE (rettype
) != VOIDmode
4208 && ! structure_value_addr
)
4210 if (pcc_struct_value
)
4212 valreg
= hard_function_value (build_pointer_type (rettype
),
4213 fndecl
, NULL
, (pass
== 0));
4214 if (CALL_WITH_BOUNDS_P (exp
))
4215 valbnd
= targetm
.calls
.
4216 chkp_function_value_bounds (build_pointer_type (rettype
),
4217 fndecl
, (pass
== 0));
4221 valreg
= hard_function_value (rettype
, fndecl
, fntype
,
4223 if (CALL_WITH_BOUNDS_P (exp
))
4224 valbnd
= targetm
.calls
.chkp_function_value_bounds (rettype
,
4229 /* If VALREG is a PARALLEL whose first member has a zero
4230 offset, use that. This is for targets such as m68k that
4231 return the same value in multiple places. */
4232 if (GET_CODE (valreg
) == PARALLEL
)
4234 rtx elem
= XVECEXP (valreg
, 0, 0);
4235 rtx where
= XEXP (elem
, 0);
4236 rtx offset
= XEXP (elem
, 1);
4237 if (offset
== const0_rtx
4238 && GET_MODE (where
) == GET_MODE (valreg
))
4243 /* Store all bounds not passed in registers. */
4244 for (i
= 0; i
< num_actuals
; i
++)
4246 if (POINTER_BOUNDS_P (args
[i
].tree_value
)
4248 store_bounds (&args
[i
],
4249 args
[i
].pointer_arg
== -1
4251 : &args
[args
[i
].pointer_arg
]);
4254 /* If register arguments require space on the stack and stack space
4255 was not preallocated, allocate stack space here for arguments
4256 passed in registers. */
4257 if (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
)))
4258 && !ACCUMULATE_OUTGOING_ARGS
4259 && must_preallocate
== 0 && reg_parm_stack_space
> 0)
4260 anti_adjust_stack (GEN_INT (reg_parm_stack_space
));
4262 /* Pass the function the address in which to return a
4264 if (pass
!= 0 && structure_value_addr
&& ! structure_value_addr_parm
)
4266 structure_value_addr
4267 = convert_memory_address (Pmode
, structure_value_addr
);
4268 emit_move_insn (struct_value
,
4270 force_operand (structure_value_addr
,
4273 if (REG_P (struct_value
))
4274 use_reg (&call_fusage
, struct_value
);
4277 after_args
= get_last_insn ();
4278 funexp
= prepare_call_address (fndecl
? fndecl
: fntype
, funexp
,
4279 static_chain_value
, &call_fusage
,
4280 reg_parm_seen
, flags
);
4282 load_register_parameters (args
, num_actuals
, &call_fusage
, flags
,
4283 pass
== 0, &sibcall_failure
);
4285 /* Save a pointer to the last insn before the call, so that we can
4286 later safely search backwards to find the CALL_INSN. */
4287 before_call
= get_last_insn ();
4289 /* Set up next argument register. For sibling calls on machines
4290 with register windows this should be the incoming register. */
4292 next_arg_reg
= targetm
.calls
.function_incoming_arg (args_so_far
,
4297 next_arg_reg
= targetm
.calls
.function_arg (args_so_far
,
4298 VOIDmode
, void_type_node
,
4301 if (pass
== 1 && (return_flags
& ERF_RETURNS_ARG
))
4303 int arg_nr
= return_flags
& ERF_RETURN_ARG_MASK
;
4304 arg_nr
= num_actuals
- arg_nr
- 1;
4306 && arg_nr
< num_actuals
4310 && GET_MODE (args
[arg_nr
].reg
) == GET_MODE (valreg
))
4312 = gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args
[arg_nr
].tree_value
)),
4313 gen_rtx_SET (valreg
, args
[arg_nr
].reg
),
4316 /* All arguments and registers used for the call must be set up by
4319 /* Stack must be properly aligned now. */
4321 || multiple_p (stack_pointer_delta
,
4322 preferred_unit_stack_boundary
));
4324 /* Generate the actual call instruction. */
4325 emit_call_1 (funexp
, exp
, fndecl
, funtype
, unadjusted_args_size
,
4326 adjusted_args_size
.constant
, struct_value_size
,
4327 next_arg_reg
, valreg
, old_inhibit_defer_pop
, call_fusage
,
4328 flags
, args_so_far
);
4332 rtx_call_insn
*last
;
4333 rtx datum
= NULL_RTX
;
4334 if (fndecl
!= NULL_TREE
)
4336 datum
= XEXP (DECL_RTL (fndecl
), 0);
4337 gcc_assert (datum
!= NULL_RTX
4338 && GET_CODE (datum
) == SYMBOL_REF
);
4340 last
= last_call_insn ();
4341 add_reg_note (last
, REG_CALL_DECL
, datum
);
4344 /* If the call setup or the call itself overlaps with anything
4345 of the argument setup we probably clobbered our call address.
4346 In that case we can't do sibcalls. */
4348 && check_sibcall_argument_overlap (after_args
, 0, 0))
4349 sibcall_failure
= 1;
4351 /* If a non-BLKmode value is returned at the most significant end
4352 of a register, shift the register right by the appropriate amount
4353 and update VALREG accordingly. BLKmode values are handled by the
4354 group load/store machinery below. */
4355 if (!structure_value_addr
4356 && !pcc_struct_value
4357 && TYPE_MODE (rettype
) != VOIDmode
4358 && TYPE_MODE (rettype
) != BLKmode
4360 && targetm
.calls
.return_in_msb (rettype
))
4362 if (shift_return_value (TYPE_MODE (rettype
), false, valreg
))
4363 sibcall_failure
= 1;
4364 valreg
= gen_rtx_REG (TYPE_MODE (rettype
), REGNO (valreg
));
4367 if (pass
&& (flags
& ECF_MALLOC
))
4369 rtx temp
= gen_reg_rtx (GET_MODE (valreg
));
4370 rtx_insn
*last
, *insns
;
4372 /* The return value from a malloc-like function is a pointer. */
4373 if (TREE_CODE (rettype
) == POINTER_TYPE
)
4374 mark_reg_pointer (temp
, MALLOC_ABI_ALIGNMENT
);
4376 emit_move_insn (temp
, valreg
);
4378 /* The return value from a malloc-like function can not alias
4380 last
= get_last_insn ();
4381 add_reg_note (last
, REG_NOALIAS
, temp
);
4383 /* Write out the sequence. */
4384 insns
= get_insns ();
4390 /* For calls to `setjmp', etc., inform
4391 function.c:setjmp_warnings that it should complain if
4392 nonvolatile values are live. For functions that cannot
4393 return, inform flow that control does not fall through. */
4395 if ((flags
& ECF_NORETURN
) || pass
== 0)
4397 /* The barrier must be emitted
4398 immediately after the CALL_INSN. Some ports emit more
4399 than just a CALL_INSN above, so we must search for it here. */
4401 rtx_insn
*last
= get_last_insn ();
4402 while (!CALL_P (last
))
4404 last
= PREV_INSN (last
);
4405 /* There was no CALL_INSN? */
4406 gcc_assert (last
!= before_call
);
4409 emit_barrier_after (last
);
4411 /* Stack adjustments after a noreturn call are dead code.
4412 However when NO_DEFER_POP is in effect, we must preserve
4413 stack_pointer_delta. */
4414 if (inhibit_defer_pop
== 0)
4416 stack_pointer_delta
= old_stack_allocated
;
4417 pending_stack_adjust
= 0;
4421 /* If value type not void, return an rtx for the value. */
4423 if (TYPE_MODE (rettype
) == VOIDmode
4425 target
= const0_rtx
;
4426 else if (structure_value_addr
)
4428 if (target
== 0 || !MEM_P (target
))
4431 = gen_rtx_MEM (TYPE_MODE (rettype
),
4432 memory_address (TYPE_MODE (rettype
),
4433 structure_value_addr
));
4434 set_mem_attributes (target
, rettype
, 1);
4437 else if (pcc_struct_value
)
4439 /* This is the special C++ case where we need to
4440 know what the true target was. We take care to
4441 never use this value more than once in one expression. */
4442 target
= gen_rtx_MEM (TYPE_MODE (rettype
),
4443 copy_to_reg (valreg
));
4444 set_mem_attributes (target
, rettype
, 1);
4446 /* Handle calls that return values in multiple non-contiguous locations.
4447 The Irix 6 ABI has examples of this. */
4448 else if (GET_CODE (valreg
) == PARALLEL
)
4451 target
= emit_group_move_into_temps (valreg
);
4452 else if (rtx_equal_p (target
, valreg
))
4454 else if (GET_CODE (target
) == PARALLEL
)
4455 /* Handle the result of a emit_group_move_into_temps
4456 call in the previous pass. */
4457 emit_group_move (target
, valreg
);
4459 emit_group_store (target
, valreg
, rettype
,
4460 int_size_in_bytes (rettype
));
4463 && GET_MODE (target
) == TYPE_MODE (rettype
)
4464 && GET_MODE (target
) == GET_MODE (valreg
))
4466 bool may_overlap
= false;
4468 /* We have to copy a return value in a CLASS_LIKELY_SPILLED hard
4469 reg to a plain register. */
4470 if (!REG_P (target
) || HARD_REGISTER_P (target
))
4471 valreg
= avoid_likely_spilled_reg (valreg
);
4473 /* If TARGET is a MEM in the argument area, and we have
4474 saved part of the argument area, then we can't store
4475 directly into TARGET as it may get overwritten when we
4476 restore the argument save area below. Don't work too
4477 hard though and simply force TARGET to a register if it
4478 is a MEM; the optimizer is quite likely to sort it out. */
4479 if (ACCUMULATE_OUTGOING_ARGS
&& pass
&& MEM_P (target
))
4480 for (i
= 0; i
< num_actuals
; i
++)
4481 if (args
[i
].save_area
)
4488 target
= copy_to_reg (valreg
);
4491 /* TARGET and VALREG cannot be equal at this point
4492 because the latter would not have
4493 REG_FUNCTION_VALUE_P true, while the former would if
4494 it were referring to the same register.
4496 If they refer to the same register, this move will be
4497 a no-op, except when function inlining is being
4499 emit_move_insn (target
, valreg
);
4501 /* If we are setting a MEM, this code must be executed.
4502 Since it is emitted after the call insn, sibcall
4503 optimization cannot be performed in that case. */
4505 sibcall_failure
= 1;
4509 target
= copy_to_reg (avoid_likely_spilled_reg (valreg
));
4511 /* If we promoted this return value, make the proper SUBREG.
4512 TARGET might be const0_rtx here, so be careful. */
4514 && TYPE_MODE (rettype
) != BLKmode
4515 && GET_MODE (target
) != TYPE_MODE (rettype
))
4517 tree type
= rettype
;
4518 int unsignedp
= TYPE_UNSIGNED (type
);
4521 /* Ensure we promote as expected, and get the new unsignedness. */
4522 pmode
= promote_function_mode (type
, TYPE_MODE (type
), &unsignedp
,
4524 gcc_assert (GET_MODE (target
) == pmode
);
4526 poly_uint64 offset
= subreg_lowpart_offset (TYPE_MODE (type
),
4528 target
= gen_rtx_SUBREG (TYPE_MODE (type
), target
, offset
);
4529 SUBREG_PROMOTED_VAR_P (target
) = 1;
4530 SUBREG_PROMOTED_SET (target
, unsignedp
);
4533 /* If size of args is variable or this was a constructor call for a stack
4534 argument, restore saved stack-pointer value. */
4536 if (old_stack_level
)
4538 rtx_insn
*prev
= get_last_insn ();
4540 emit_stack_restore (SAVE_BLOCK
, old_stack_level
);
4541 stack_pointer_delta
= old_stack_pointer_delta
;
4543 fixup_args_size_notes (prev
, get_last_insn (), stack_pointer_delta
);
4545 pending_stack_adjust
= old_pending_adj
;
4546 old_stack_allocated
= stack_pointer_delta
- pending_stack_adjust
;
4547 stack_arg_under_construction
= old_stack_arg_under_construction
;
4548 highest_outgoing_arg_in_use
= initial_highest_arg_in_use
;
4549 stack_usage_map
= initial_stack_usage_map
;
4550 stack_usage_watermark
= initial_stack_usage_watermark
;
4551 sibcall_failure
= 1;
4553 else if (ACCUMULATE_OUTGOING_ARGS
&& pass
)
4555 #ifdef REG_PARM_STACK_SPACE
4557 restore_fixed_argument_area (save_area
, argblock
,
4558 high_to_save
, low_to_save
);
4561 /* If we saved any argument areas, restore them. */
4562 for (i
= 0; i
< num_actuals
; i
++)
4563 if (args
[i
].save_area
)
4565 machine_mode save_mode
= GET_MODE (args
[i
].save_area
);
4567 = gen_rtx_MEM (save_mode
,
4568 memory_address (save_mode
,
4569 XEXP (args
[i
].stack_slot
, 0)));
4571 if (save_mode
!= BLKmode
)
4572 emit_move_insn (stack_area
, args
[i
].save_area
);
4574 emit_block_move (stack_area
, args
[i
].save_area
,
4576 (args
[i
].locate
.size
.constant
, Pmode
)),
4577 BLOCK_OP_CALL_PARM
);
4580 highest_outgoing_arg_in_use
= initial_highest_arg_in_use
;
4581 stack_usage_map
= initial_stack_usage_map
;
4582 stack_usage_watermark
= initial_stack_usage_watermark
;
4585 /* If this was alloca, record the new stack level. */
4586 if (flags
& ECF_MAY_BE_ALLOCA
)
4587 record_new_stack_level ();
4589 /* Free up storage we no longer need. */
4590 for (i
= 0; i
< num_actuals
; ++i
)
4591 free (args
[i
].aligned_regs
);
4593 targetm
.calls
.end_call_args ();
4595 insns
= get_insns ();
4600 tail_call_insns
= insns
;
4602 /* Restore the pending stack adjustment now that we have
4603 finished generating the sibling call sequence. */
4605 restore_pending_stack_adjust (&save
);
4607 /* Prepare arg structure for next iteration. */
4608 for (i
= 0; i
< num_actuals
; i
++)
4611 args
[i
].aligned_regs
= 0;
4615 sbitmap_free (stored_args_map
);
4616 internal_arg_pointer_exp_state
.scan_start
= NULL
;
4617 internal_arg_pointer_exp_state
.cache
.release ();
4621 normal_call_insns
= insns
;
4623 /* Verify that we've deallocated all the stack we used. */
4624 gcc_assert ((flags
& ECF_NORETURN
)
4625 || known_eq (old_stack_allocated
,
4627 - pending_stack_adjust
));
4630 /* If something prevents making this a sibling call,
4631 zero out the sequence. */
4632 if (sibcall_failure
)
4633 tail_call_insns
= NULL
;
4638 /* If tail call production succeeded, we need to remove REG_EQUIV notes on
4639 arguments too, as argument area is now clobbered by the call. */
4640 if (tail_call_insns
)
4642 emit_insn (tail_call_insns
);
4643 crtl
->tail_call_emit
= true;
4647 emit_insn (normal_call_insns
);
4649 /* Ideally we'd emit a message for all of the ways that it could
4651 maybe_complain_about_tail_call (exp
, "tail call production failed");
4654 currently_expanding_call
--;
4656 free (stack_usage_map_buf
);
4659 /* Join result with returned bounds so caller may use them if needed. */
4660 target
= chkp_join_splitted_slot (target
, valbnd
);
4665 /* A sibling call sequence invalidates any REG_EQUIV notes made for
4666 this function's incoming arguments.
4668 At the start of RTL generation we know the only REG_EQUIV notes
4669 in the rtl chain are those for incoming arguments, so we can look
4670 for REG_EQUIV notes between the start of the function and the
4671 NOTE_INSN_FUNCTION_BEG.
4673 This is (slight) overkill. We could keep track of the highest
4674 argument we clobber and be more selective in removing notes, but it
4675 does not seem to be worth the effort. */
4678 fixup_tail_calls (void)
4682 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
4686 /* There are never REG_EQUIV notes for the incoming arguments
4687 after the NOTE_INSN_FUNCTION_BEG note, so stop if we see it. */
4689 && NOTE_KIND (insn
) == NOTE_INSN_FUNCTION_BEG
)
4692 note
= find_reg_note (insn
, REG_EQUIV
, 0);
4694 remove_note (insn
, note
);
4695 note
= find_reg_note (insn
, REG_EQUIV
, 0);
4700 /* Traverse a list of TYPES and expand all complex types into their
4703 split_complex_types (tree types
)
4707 /* Before allocating memory, check for the common case of no complex. */
4708 for (p
= types
; p
; p
= TREE_CHAIN (p
))
4710 tree type
= TREE_VALUE (p
);
4711 if (TREE_CODE (type
) == COMPLEX_TYPE
4712 && targetm
.calls
.split_complex_arg (type
))
4718 types
= copy_list (types
);
4720 for (p
= types
; p
; p
= TREE_CHAIN (p
))
4722 tree complex_type
= TREE_VALUE (p
);
4724 if (TREE_CODE (complex_type
) == COMPLEX_TYPE
4725 && targetm
.calls
.split_complex_arg (complex_type
))
4729 /* Rewrite complex type with component type. */
4730 TREE_VALUE (p
) = TREE_TYPE (complex_type
);
4731 next
= TREE_CHAIN (p
);
4733 /* Add another component type for the imaginary part. */
4734 imag
= build_tree_list (NULL_TREE
, TREE_VALUE (p
));
4735 TREE_CHAIN (p
) = imag
;
4736 TREE_CHAIN (imag
) = next
;
4738 /* Skip the newly created node. */
4746 /* Output a library call to function ORGFUN (a SYMBOL_REF rtx)
4747 for a value of mode OUTMODE,
4748 with NARGS different arguments, passed as ARGS.
4749 Store the return value if RETVAL is nonzero: store it in VALUE if
4750 VALUE is nonnull, otherwise pick a convenient location. In either
4751 case return the location of the stored value.
4753 FN_TYPE should be LCT_NORMAL for `normal' calls, LCT_CONST for
4754 `const' calls, LCT_PURE for `pure' calls, or another LCT_ value for
4755 other types of library calls. */
4758 emit_library_call_value_1 (int retval
, rtx orgfun
, rtx value
,
4759 enum libcall_type fn_type
,
4760 machine_mode outmode
, int nargs
, rtx_mode_t
*args
)
4762 /* Total size in bytes of all the stack-parms scanned so far. */
4763 struct args_size args_size
;
4764 /* Size of arguments before any adjustments (such as rounding). */
4765 struct args_size original_args_size
;
4768 /* Todo, choose the correct decl type of orgfun. Sadly this information
4769 isn't present here, so we default to native calling abi here. */
4770 tree fndecl ATTRIBUTE_UNUSED
= NULL_TREE
; /* library calls default to host calling abi ? */
4771 tree fntype ATTRIBUTE_UNUSED
= NULL_TREE
; /* library calls default to host calling abi ? */
4774 CUMULATIVE_ARGS args_so_far_v
;
4775 cumulative_args_t args_so_far
;
4782 struct locate_and_pad_arg_data locate
;
4786 int old_inhibit_defer_pop
= inhibit_defer_pop
;
4787 rtx call_fusage
= 0;
4790 int pcc_struct_value
= 0;
4791 poly_int64 struct_value_size
= 0;
4793 int reg_parm_stack_space
= 0;
4795 rtx_insn
*before_call
;
4796 bool have_push_fusage
;
4797 tree tfom
; /* type_for_mode (outmode, 0) */
4799 #ifdef REG_PARM_STACK_SPACE
4800 /* Define the boundary of the register parm stack space that needs to be
4802 int low_to_save
= 0, high_to_save
= 0;
4803 rtx save_area
= 0; /* Place that it is saved. */
4806 /* Size of the stack reserved for parameter registers. */
4807 unsigned int initial_highest_arg_in_use
= highest_outgoing_arg_in_use
;
4808 char *initial_stack_usage_map
= stack_usage_map
;
4809 unsigned HOST_WIDE_INT initial_stack_usage_watermark
= stack_usage_watermark
;
4810 char *stack_usage_map_buf
= NULL
;
4812 rtx struct_value
= targetm
.calls
.struct_value_rtx (0, 0);
4814 #ifdef REG_PARM_STACK_SPACE
4815 reg_parm_stack_space
= REG_PARM_STACK_SPACE ((tree
) 0);
4818 /* By default, library functions cannot throw. */
4819 flags
= ECF_NOTHROW
;
4832 flags
|= ECF_NORETURN
;
4835 flags
&= ~ECF_NOTHROW
;
4837 case LCT_RETURNS_TWICE
:
4838 flags
= ECF_RETURNS_TWICE
;
4843 /* Ensure current function's preferred stack boundary is at least
4845 if (crtl
->preferred_stack_boundary
< PREFERRED_STACK_BOUNDARY
)
4846 crtl
->preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
4848 /* If this kind of value comes back in memory,
4849 decide where in memory it should come back. */
4850 if (outmode
!= VOIDmode
)
4852 tfom
= lang_hooks
.types
.type_for_mode (outmode
, 0);
4853 if (aggregate_value_p (tfom
, 0))
4855 #ifdef PCC_STATIC_STRUCT_RETURN
4857 = hard_function_value (build_pointer_type (tfom
), 0, 0, 0);
4858 mem_value
= gen_rtx_MEM (outmode
, pointer_reg
);
4859 pcc_struct_value
= 1;
4861 value
= gen_reg_rtx (outmode
);
4862 #else /* not PCC_STATIC_STRUCT_RETURN */
4863 struct_value_size
= GET_MODE_SIZE (outmode
);
4864 if (value
!= 0 && MEM_P (value
))
4867 mem_value
= assign_temp (tfom
, 1, 1);
4869 /* This call returns a big structure. */
4870 flags
&= ~(ECF_CONST
| ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
);
4874 tfom
= void_type_node
;
4876 /* ??? Unfinished: must pass the memory address as an argument. */
4878 /* Copy all the libcall-arguments out of the varargs data
4879 and into a vector ARGVEC.
4881 Compute how to pass each argument. We only support a very small subset
4882 of the full argument passing conventions to limit complexity here since
4883 library functions shouldn't have many args. */
4885 argvec
= XALLOCAVEC (struct arg
, nargs
+ 1);
4886 memset (argvec
, 0, (nargs
+ 1) * sizeof (struct arg
));
4888 #ifdef INIT_CUMULATIVE_LIBCALL_ARGS
4889 INIT_CUMULATIVE_LIBCALL_ARGS (args_so_far_v
, outmode
, fun
);
4891 INIT_CUMULATIVE_ARGS (args_so_far_v
, NULL_TREE
, fun
, 0, nargs
);
4893 args_so_far
= pack_cumulative_args (&args_so_far_v
);
4895 args_size
.constant
= 0;
4902 /* If there's a structure value address to be passed,
4903 either pass it in the special place, or pass it as an extra argument. */
4904 if (mem_value
&& struct_value
== 0 && ! pcc_struct_value
)
4906 rtx addr
= XEXP (mem_value
, 0);
4910 /* Make sure it is a reasonable operand for a move or push insn. */
4911 if (!REG_P (addr
) && !MEM_P (addr
)
4912 && !(CONSTANT_P (addr
)
4913 && targetm
.legitimate_constant_p (Pmode
, addr
)))
4914 addr
= force_operand (addr
, NULL_RTX
);
4916 argvec
[count
].value
= addr
;
4917 argvec
[count
].mode
= Pmode
;
4918 argvec
[count
].partial
= 0;
4920 argvec
[count
].reg
= targetm
.calls
.function_arg (args_so_far
,
4921 Pmode
, NULL_TREE
, true);
4922 gcc_assert (targetm
.calls
.arg_partial_bytes (args_so_far
, Pmode
,
4923 NULL_TREE
, 1) == 0);
4925 locate_and_pad_parm (Pmode
, NULL_TREE
,
4926 #ifdef STACK_PARMS_IN_REG_PARM_AREA
4929 argvec
[count
].reg
!= 0,
4931 reg_parm_stack_space
, 0,
4932 NULL_TREE
, &args_size
, &argvec
[count
].locate
);
4934 if (argvec
[count
].reg
== 0 || argvec
[count
].partial
!= 0
4935 || reg_parm_stack_space
> 0)
4936 args_size
.constant
+= argvec
[count
].locate
.size
.constant
;
4938 targetm
.calls
.function_arg_advance (args_so_far
, Pmode
, (tree
) 0, true);
4943 for (unsigned int i
= 0; count
< nargs
; i
++, count
++)
4945 rtx val
= args
[i
].first
;
4946 machine_mode mode
= args
[i
].second
;
4949 /* We cannot convert the arg value to the mode the library wants here;
4950 must do it earlier where we know the signedness of the arg. */
4951 gcc_assert (mode
!= BLKmode
4952 && (GET_MODE (val
) == mode
|| GET_MODE (val
) == VOIDmode
));
4954 /* Make sure it is a reasonable operand for a move or push insn. */
4955 if (!REG_P (val
) && !MEM_P (val
)
4956 && !(CONSTANT_P (val
) && targetm
.legitimate_constant_p (mode
, val
)))
4957 val
= force_operand (val
, NULL_RTX
);
4959 if (pass_by_reference (&args_so_far_v
, mode
, NULL_TREE
, 1))
4963 = !reference_callee_copied (&args_so_far_v
, mode
, NULL_TREE
, 1);
4965 /* If this was a CONST function, it is now PURE since it now
4967 if (flags
& ECF_CONST
)
4969 flags
&= ~ECF_CONST
;
4973 if (MEM_P (val
) && !must_copy
)
4975 tree val_expr
= MEM_EXPR (val
);
4977 mark_addressable (val_expr
);
4982 slot
= assign_temp (lang_hooks
.types
.type_for_mode (mode
, 0),
4984 emit_move_insn (slot
, val
);
4987 call_fusage
= gen_rtx_EXPR_LIST (VOIDmode
,
4988 gen_rtx_USE (VOIDmode
, slot
),
4991 call_fusage
= gen_rtx_EXPR_LIST (VOIDmode
,
4992 gen_rtx_CLOBBER (VOIDmode
,
4997 val
= force_operand (XEXP (slot
, 0), NULL_RTX
);
5000 mode
= promote_function_mode (NULL_TREE
, mode
, &unsigned_p
, NULL_TREE
, 0);
5001 argvec
[count
].mode
= mode
;
5002 argvec
[count
].value
= convert_modes (mode
, GET_MODE (val
), val
, unsigned_p
);
5003 argvec
[count
].reg
= targetm
.calls
.function_arg (args_so_far
, mode
,
5006 argvec
[count
].partial
5007 = targetm
.calls
.arg_partial_bytes (args_so_far
, mode
, NULL_TREE
, 1);
5009 if (argvec
[count
].reg
== 0
5010 || argvec
[count
].partial
!= 0
5011 || reg_parm_stack_space
> 0)
5013 locate_and_pad_parm (mode
, NULL_TREE
,
5014 #ifdef STACK_PARMS_IN_REG_PARM_AREA
5017 argvec
[count
].reg
!= 0,
5019 reg_parm_stack_space
, argvec
[count
].partial
,
5020 NULL_TREE
, &args_size
, &argvec
[count
].locate
);
5021 args_size
.constant
+= argvec
[count
].locate
.size
.constant
;
5022 gcc_assert (!argvec
[count
].locate
.size
.var
);
5024 #ifdef BLOCK_REG_PADDING
5026 /* The argument is passed entirely in registers. See at which
5027 end it should be padded. */
5028 argvec
[count
].locate
.where_pad
=
5029 BLOCK_REG_PADDING (mode
, NULL_TREE
,
5030 known_le (GET_MODE_SIZE (mode
), UNITS_PER_WORD
));
5033 targetm
.calls
.function_arg_advance (args_so_far
, mode
, (tree
) 0, true);
5036 /* If this machine requires an external definition for library
5037 functions, write one out. */
5038 assemble_external_libcall (fun
);
5040 original_args_size
= args_size
;
5041 args_size
.constant
= (aligned_upper_bound (args_size
.constant
5042 + stack_pointer_delta
,
5044 - stack_pointer_delta
);
5046 args_size
.constant
= upper_bound (args_size
.constant
,
5047 reg_parm_stack_space
);
5049 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
5050 args_size
.constant
-= reg_parm_stack_space
;
5052 crtl
->outgoing_args_size
= upper_bound (crtl
->outgoing_args_size
,
5053 args_size
.constant
);
5055 if (flag_stack_usage_info
&& !ACCUMULATE_OUTGOING_ARGS
)
5057 poly_int64 pushed
= args_size
.constant
+ pending_stack_adjust
;
5058 current_function_pushed_stack_size
5059 = upper_bound (current_function_pushed_stack_size
, pushed
);
5062 if (ACCUMULATE_OUTGOING_ARGS
)
5064 /* Since the stack pointer will never be pushed, it is possible for
5065 the evaluation of a parm to clobber something we have already
5066 written to the stack. Since most function calls on RISC machines
5067 do not use the stack, this is uncommon, but must work correctly.
5069 Therefore, we save any area of the stack that was already written
5070 and that we are using. Here we set up to do this by making a new
5071 stack usage map from the old one.
5073 Another approach might be to try to reorder the argument
5074 evaluations to avoid this conflicting stack usage. */
5076 needed
= args_size
.constant
;
5078 /* Since we will be writing into the entire argument area, the
5079 map must be allocated for its entire size, not just the part that
5080 is the responsibility of the caller. */
5081 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
5082 needed
+= reg_parm_stack_space
;
5084 poly_int64 limit
= needed
;
5085 if (ARGS_GROW_DOWNWARD
)
5088 /* For polynomial sizes, this is the maximum possible size needed
5089 for arguments with a constant size and offset. */
5090 HOST_WIDE_INT const_limit
= constant_lower_bound (limit
);
5091 highest_outgoing_arg_in_use
= MAX (initial_highest_arg_in_use
,
5094 stack_usage_map_buf
= XNEWVEC (char, highest_outgoing_arg_in_use
);
5095 stack_usage_map
= stack_usage_map_buf
;
5097 if (initial_highest_arg_in_use
)
5098 memcpy (stack_usage_map
, initial_stack_usage_map
,
5099 initial_highest_arg_in_use
);
5101 if (initial_highest_arg_in_use
!= highest_outgoing_arg_in_use
)
5102 memset (&stack_usage_map
[initial_highest_arg_in_use
], 0,
5103 highest_outgoing_arg_in_use
- initial_highest_arg_in_use
);
5106 /* We must be careful to use virtual regs before they're instantiated,
5107 and real regs afterwards. Loop optimization, for example, can create
5108 new libcalls after we've instantiated the virtual regs, and if we
5109 use virtuals anyway, they won't match the rtl patterns. */
5111 if (virtuals_instantiated
)
5112 argblock
= plus_constant (Pmode
, stack_pointer_rtx
,
5113 STACK_POINTER_OFFSET
);
5115 argblock
= virtual_outgoing_args_rtx
;
5120 argblock
= push_block (gen_int_mode (args_size
.constant
, Pmode
), 0, 0);
5123 /* We push args individually in reverse order, perform stack alignment
5124 before the first push (the last arg). */
5126 anti_adjust_stack (gen_int_mode (args_size
.constant
5127 - original_args_size
.constant
,
5132 #ifdef REG_PARM_STACK_SPACE
5133 if (ACCUMULATE_OUTGOING_ARGS
)
5135 /* The argument list is the property of the called routine and it
5136 may clobber it. If the fixed area has been used for previous
5137 parameters, we must save and restore it. */
5138 save_area
= save_fixed_argument_area (reg_parm_stack_space
, argblock
,
5139 &low_to_save
, &high_to_save
);
5143 /* When expanding a normal call, args are stored in push order,
5144 which is the reverse of what we have here. */
5145 bool any_regs
= false;
5146 for (int i
= nargs
; i
-- > 0; )
5147 if (argvec
[i
].reg
!= NULL_RTX
)
5149 targetm
.calls
.call_args (argvec
[i
].reg
, NULL_TREE
);
5153 targetm
.calls
.call_args (pc_rtx
, NULL_TREE
);
5155 /* Push the args that need to be pushed. */
5157 have_push_fusage
= false;
5159 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
5160 are to be pushed. */
5161 for (count
= 0; count
< nargs
; count
++, argnum
--)
5163 machine_mode mode
= argvec
[argnum
].mode
;
5164 rtx val
= argvec
[argnum
].value
;
5165 rtx reg
= argvec
[argnum
].reg
;
5166 int partial
= argvec
[argnum
].partial
;
5167 unsigned int parm_align
= argvec
[argnum
].locate
.boundary
;
5168 poly_int64 lower_bound
= 0, upper_bound
= 0;
5170 if (! (reg
!= 0 && partial
== 0))
5174 if (ACCUMULATE_OUTGOING_ARGS
)
5176 /* If this is being stored into a pre-allocated, fixed-size,
5177 stack area, save any previous data at that location. */
5179 if (ARGS_GROW_DOWNWARD
)
5181 /* stack_slot is negative, but we want to index stack_usage_map
5182 with positive values. */
5183 upper_bound
= -argvec
[argnum
].locate
.slot_offset
.constant
+ 1;
5184 lower_bound
= upper_bound
- argvec
[argnum
].locate
.size
.constant
;
5188 lower_bound
= argvec
[argnum
].locate
.slot_offset
.constant
;
5189 upper_bound
= lower_bound
+ argvec
[argnum
].locate
.size
.constant
;
5192 if (stack_region_maybe_used_p (lower_bound
, upper_bound
,
5193 reg_parm_stack_space
))
5195 /* We need to make a save area. */
5197 = argvec
[argnum
].locate
.size
.constant
* BITS_PER_UNIT
;
5198 machine_mode save_mode
5199 = int_mode_for_size (size
, 1).else_blk ();
5201 = plus_constant (Pmode
, argblock
,
5202 argvec
[argnum
].locate
.offset
.constant
);
5204 = gen_rtx_MEM (save_mode
, memory_address (save_mode
, adr
));
5206 if (save_mode
== BLKmode
)
5208 argvec
[argnum
].save_area
5209 = assign_stack_temp (BLKmode
,
5210 argvec
[argnum
].locate
.size
.constant
5213 emit_block_move (validize_mem
5214 (copy_rtx (argvec
[argnum
].save_area
)),
5217 (argvec
[argnum
].locate
.size
.constant
,
5219 BLOCK_OP_CALL_PARM
);
5223 argvec
[argnum
].save_area
= gen_reg_rtx (save_mode
);
5225 emit_move_insn (argvec
[argnum
].save_area
, stack_area
);
5230 emit_push_insn (val
, mode
, NULL_TREE
, NULL_RTX
, parm_align
,
5231 partial
, reg
, 0, argblock
,
5233 (argvec
[argnum
].locate
.offset
.constant
, Pmode
)),
5234 reg_parm_stack_space
,
5235 ARGS_SIZE_RTX (argvec
[argnum
].locate
.alignment_pad
), false);
5237 /* Now mark the segment we just used. */
5238 if (ACCUMULATE_OUTGOING_ARGS
)
5239 mark_stack_region_used (lower_bound
, upper_bound
);
5243 /* Indicate argument access so that alias.c knows that these
5246 use
= plus_constant (Pmode
, argblock
,
5247 argvec
[argnum
].locate
.offset
.constant
);
5248 else if (have_push_fusage
)
5252 /* When arguments are pushed, trying to tell alias.c where
5253 exactly this argument is won't work, because the
5254 auto-increment causes confusion. So we merely indicate
5255 that we access something with a known mode somewhere on
5257 use
= gen_rtx_PLUS (Pmode
, stack_pointer_rtx
,
5258 gen_rtx_SCRATCH (Pmode
));
5259 have_push_fusage
= true;
5261 use
= gen_rtx_MEM (argvec
[argnum
].mode
, use
);
5262 use
= gen_rtx_USE (VOIDmode
, use
);
5263 call_fusage
= gen_rtx_EXPR_LIST (VOIDmode
, use
, call_fusage
);
5269 fun
= prepare_call_address (NULL
, fun
, NULL
, &call_fusage
, 0, 0);
5271 /* Now load any reg parms into their regs. */
5273 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
5274 are to be pushed. */
5275 for (count
= 0; count
< nargs
; count
++, argnum
--)
5277 machine_mode mode
= argvec
[argnum
].mode
;
5278 rtx val
= argvec
[argnum
].value
;
5279 rtx reg
= argvec
[argnum
].reg
;
5280 int partial
= argvec
[argnum
].partial
;
5282 /* Handle calls that pass values in multiple non-contiguous
5283 locations. The PA64 has examples of this for library calls. */
5284 if (reg
!= 0 && GET_CODE (reg
) == PARALLEL
)
5285 emit_group_load (reg
, val
, NULL_TREE
, GET_MODE_SIZE (mode
));
5286 else if (reg
!= 0 && partial
== 0)
5288 emit_move_insn (reg
, val
);
5289 #ifdef BLOCK_REG_PADDING
5290 poly_int64 size
= GET_MODE_SIZE (argvec
[argnum
].mode
);
5292 /* Copied from load_register_parameters. */
5294 /* Handle case where we have a value that needs shifting
5295 up to the msb. eg. a QImode value and we're padding
5296 upward on a BYTES_BIG_ENDIAN machine. */
5297 if (known_lt (size
, UNITS_PER_WORD
)
5298 && (argvec
[argnum
].locate
.where_pad
5299 == (BYTES_BIG_ENDIAN
? PAD_UPWARD
: PAD_DOWNWARD
)))
5302 poly_int64 shift
= (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
5304 /* Assigning REG here rather than a temp makes CALL_FUSAGE
5305 report the whole reg as used. Strictly speaking, the
5306 call only uses SIZE bytes at the msb end, but it doesn't
5307 seem worth generating rtl to say that. */
5308 reg
= gen_rtx_REG (word_mode
, REGNO (reg
));
5309 x
= expand_shift (LSHIFT_EXPR
, word_mode
, reg
, shift
, reg
, 1);
5311 emit_move_insn (reg
, x
);
5319 /* Any regs containing parms remain in use through the call. */
5320 for (count
= 0; count
< nargs
; count
++)
5322 rtx reg
= argvec
[count
].reg
;
5323 if (reg
!= 0 && GET_CODE (reg
) == PARALLEL
)
5324 use_group_regs (&call_fusage
, reg
);
5327 int partial
= argvec
[count
].partial
;
5331 gcc_assert (partial
% UNITS_PER_WORD
== 0);
5332 nregs
= partial
/ UNITS_PER_WORD
;
5333 use_regs (&call_fusage
, REGNO (reg
), nregs
);
5336 use_reg (&call_fusage
, reg
);
5340 /* Pass the function the address in which to return a structure value. */
5341 if (mem_value
!= 0 && struct_value
!= 0 && ! pcc_struct_value
)
5343 emit_move_insn (struct_value
,
5345 force_operand (XEXP (mem_value
, 0),
5347 if (REG_P (struct_value
))
5348 use_reg (&call_fusage
, struct_value
);
5351 /* Don't allow popping to be deferred, since then
5352 cse'ing of library calls could delete a call and leave the pop. */
5354 valreg
= (mem_value
== 0 && outmode
!= VOIDmode
5355 ? hard_libcall_value (outmode
, orgfun
) : NULL_RTX
);
5357 /* Stack must be properly aligned now. */
5358 gcc_assert (multiple_p (stack_pointer_delta
,
5359 PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
));
5361 before_call
= get_last_insn ();
5363 /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
5364 will set inhibit_defer_pop to that value. */
5365 /* The return type is needed to decide how many bytes the function pops.
5366 Signedness plays no role in that, so for simplicity, we pretend it's
5367 always signed. We also assume that the list of arguments passed has
5368 no impact, so we pretend it is unknown. */
5370 emit_call_1 (fun
, NULL
,
5371 get_identifier (XSTR (orgfun
, 0)),
5372 build_function_type (tfom
, NULL_TREE
),
5373 original_args_size
.constant
, args_size
.constant
,
5375 targetm
.calls
.function_arg (args_so_far
,
5376 VOIDmode
, void_type_node
, true),
5378 old_inhibit_defer_pop
+ 1, call_fusage
, flags
, args_so_far
);
5383 gcc_assert (GET_CODE (datum
) == SYMBOL_REF
);
5384 rtx_call_insn
*last
= last_call_insn ();
5385 add_reg_note (last
, REG_CALL_DECL
, datum
);
5388 /* Right-shift returned value if necessary. */
5389 if (!pcc_struct_value
5390 && TYPE_MODE (tfom
) != BLKmode
5391 && targetm
.calls
.return_in_msb (tfom
))
5393 shift_return_value (TYPE_MODE (tfom
), false, valreg
);
5394 valreg
= gen_rtx_REG (TYPE_MODE (tfom
), REGNO (valreg
));
5397 targetm
.calls
.end_call_args ();
5399 /* For calls to `setjmp', etc., inform function.c:setjmp_warnings
5400 that it should complain if nonvolatile values are live. For
5401 functions that cannot return, inform flow that control does not
5403 if (flags
& ECF_NORETURN
)
5405 /* The barrier note must be emitted
5406 immediately after the CALL_INSN. Some ports emit more than
5407 just a CALL_INSN above, so we must search for it here. */
5408 rtx_insn
*last
= get_last_insn ();
5409 while (!CALL_P (last
))
5411 last
= PREV_INSN (last
);
5412 /* There was no CALL_INSN? */
5413 gcc_assert (last
!= before_call
);
5416 emit_barrier_after (last
);
5419 /* Consider that "regular" libcalls, i.e. all of them except for LCT_THROW
5420 and LCT_RETURNS_TWICE, cannot perform non-local gotos. */
5421 if (flags
& ECF_NOTHROW
)
5423 rtx_insn
*last
= get_last_insn ();
5424 while (!CALL_P (last
))
5426 last
= PREV_INSN (last
);
5427 /* There was no CALL_INSN? */
5428 gcc_assert (last
!= before_call
);
5431 make_reg_eh_region_note_nothrow_nononlocal (last
);
5434 /* Now restore inhibit_defer_pop to its actual original value. */
5439 /* Copy the value to the right place. */
5440 if (outmode
!= VOIDmode
&& retval
)
5446 if (value
!= mem_value
)
5447 emit_move_insn (value
, mem_value
);
5449 else if (GET_CODE (valreg
) == PARALLEL
)
5452 value
= gen_reg_rtx (outmode
);
5453 emit_group_store (value
, valreg
, NULL_TREE
, GET_MODE_SIZE (outmode
));
5457 /* Convert to the proper mode if a promotion has been active. */
5458 if (GET_MODE (valreg
) != outmode
)
5460 int unsignedp
= TYPE_UNSIGNED (tfom
);
5462 gcc_assert (promote_function_mode (tfom
, outmode
, &unsignedp
,
5463 fndecl
? TREE_TYPE (fndecl
) : fntype
, 1)
5464 == GET_MODE (valreg
));
5465 valreg
= convert_modes (outmode
, GET_MODE (valreg
), valreg
, 0);
5469 emit_move_insn (value
, valreg
);
5475 if (ACCUMULATE_OUTGOING_ARGS
)
5477 #ifdef REG_PARM_STACK_SPACE
5479 restore_fixed_argument_area (save_area
, argblock
,
5480 high_to_save
, low_to_save
);
5483 /* If we saved any argument areas, restore them. */
5484 for (count
= 0; count
< nargs
; count
++)
5485 if (argvec
[count
].save_area
)
5487 machine_mode save_mode
= GET_MODE (argvec
[count
].save_area
);
5488 rtx adr
= plus_constant (Pmode
, argblock
,
5489 argvec
[count
].locate
.offset
.constant
);
5490 rtx stack_area
= gen_rtx_MEM (save_mode
,
5491 memory_address (save_mode
, adr
));
5493 if (save_mode
== BLKmode
)
5494 emit_block_move (stack_area
,
5496 (copy_rtx (argvec
[count
].save_area
)),
5498 (argvec
[count
].locate
.size
.constant
, Pmode
)),
5499 BLOCK_OP_CALL_PARM
);
5501 emit_move_insn (stack_area
, argvec
[count
].save_area
);
5504 highest_outgoing_arg_in_use
= initial_highest_arg_in_use
;
5505 stack_usage_map
= initial_stack_usage_map
;
5506 stack_usage_watermark
= initial_stack_usage_watermark
;
5509 free (stack_usage_map_buf
);
5516 /* Store pointer bounds argument ARG into Bounds Table entry
5517 associated with PARM. */
5519 store_bounds (struct arg_data
*arg
, struct arg_data
*parm
)
5521 rtx slot
= NULL
, ptr
= NULL
, addr
= NULL
;
5523 /* We may pass bounds not associated with any pointer. */
5526 gcc_assert (arg
->special_slot
);
5527 slot
= arg
->special_slot
;
5530 /* Find pointer associated with bounds and where it is
5536 gcc_assert (!arg
->special_slot
);
5538 addr
= adjust_address (parm
->stack
, Pmode
, arg
->pointer_offset
);
5540 else if (REG_P (parm
->reg
))
5542 gcc_assert (arg
->special_slot
);
5543 slot
= arg
->special_slot
;
5545 if (MEM_P (parm
->value
))
5546 addr
= adjust_address (parm
->value
, Pmode
, arg
->pointer_offset
);
5547 else if (REG_P (parm
->value
))
5548 ptr
= gen_rtx_SUBREG (Pmode
, parm
->value
, arg
->pointer_offset
);
5551 gcc_assert (!arg
->pointer_offset
);
5557 gcc_assert (GET_CODE (parm
->reg
) == PARALLEL
);
5559 gcc_assert (arg
->special_slot
);
5560 slot
= arg
->special_slot
;
5562 if (parm
->parallel_value
)
5563 ptr
= chkp_get_value_with_offs (parm
->parallel_value
,
5564 GEN_INT (arg
->pointer_offset
));
5570 /* Expand bounds. */
5572 arg
->value
= expand_normal (arg
->tree_value
);
5574 targetm
.calls
.store_bounds_for_arg (ptr
, addr
, arg
->value
, slot
);
5577 /* Store a single argument for a function call
5578 into the register or memory area where it must be passed.
5579 *ARG describes the argument value and where to pass it.
5581 ARGBLOCK is the address of the stack-block for all the arguments,
5582 or 0 on a machine where arguments are pushed individually.
5584 MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
5585 so must be careful about how the stack is used.
5587 VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
5588 argument stack. This is used if ACCUMULATE_OUTGOING_ARGS to indicate
5589 that we need not worry about saving and restoring the stack.
5591 FNDECL is the declaration of the function we are calling.
5593 Return nonzero if this arg should cause sibcall failure,
5597 store_one_arg (struct arg_data
*arg
, rtx argblock
, int flags
,
5598 int variable_size ATTRIBUTE_UNUSED
, int reg_parm_stack_space
)
5600 tree pval
= arg
->tree_value
;
5603 poly_int64 used
= 0;
5604 poly_int64 lower_bound
= 0, upper_bound
= 0;
5605 int sibcall_failure
= 0;
5607 if (TREE_CODE (pval
) == ERROR_MARK
)
5610 /* Push a new temporary level for any temporaries we make for
5614 if (ACCUMULATE_OUTGOING_ARGS
&& !(flags
& ECF_SIBCALL
))
5616 /* If this is being stored into a pre-allocated, fixed-size, stack area,
5617 save any previous data at that location. */
5618 if (argblock
&& ! variable_size
&& arg
->stack
)
5620 if (ARGS_GROW_DOWNWARD
)
5622 /* stack_slot is negative, but we want to index stack_usage_map
5623 with positive values. */
5624 if (GET_CODE (XEXP (arg
->stack_slot
, 0)) == PLUS
)
5626 rtx offset
= XEXP (XEXP (arg
->stack_slot
, 0), 1);
5627 upper_bound
= -rtx_to_poly_int64 (offset
) + 1;
5632 lower_bound
= upper_bound
- arg
->locate
.size
.constant
;
5636 if (GET_CODE (XEXP (arg
->stack_slot
, 0)) == PLUS
)
5638 rtx offset
= XEXP (XEXP (arg
->stack_slot
, 0), 1);
5639 lower_bound
= rtx_to_poly_int64 (offset
);
5644 upper_bound
= lower_bound
+ arg
->locate
.size
.constant
;
5647 if (stack_region_maybe_used_p (lower_bound
, upper_bound
,
5648 reg_parm_stack_space
))
5650 /* We need to make a save area. */
5651 poly_uint64 size
= arg
->locate
.size
.constant
* BITS_PER_UNIT
;
5652 machine_mode save_mode
5653 = int_mode_for_size (size
, 1).else_blk ();
5654 rtx adr
= memory_address (save_mode
, XEXP (arg
->stack_slot
, 0));
5655 rtx stack_area
= gen_rtx_MEM (save_mode
, adr
);
5657 if (save_mode
== BLKmode
)
5660 = assign_temp (TREE_TYPE (arg
->tree_value
), 1, 1);
5661 preserve_temp_slots (arg
->save_area
);
5662 emit_block_move (validize_mem (copy_rtx (arg
->save_area
)),
5665 (arg
->locate
.size
.constant
, Pmode
)),
5666 BLOCK_OP_CALL_PARM
);
5670 arg
->save_area
= gen_reg_rtx (save_mode
);
5671 emit_move_insn (arg
->save_area
, stack_area
);
5677 /* If this isn't going to be placed on both the stack and in registers,
5678 set up the register and number of words. */
5679 if (! arg
->pass_on_stack
)
5681 if (flags
& ECF_SIBCALL
)
5682 reg
= arg
->tail_call_reg
;
5685 partial
= arg
->partial
;
5688 /* Being passed entirely in a register. We shouldn't be called in
5690 gcc_assert (reg
== 0 || partial
!= 0);
5692 /* If this arg needs special alignment, don't load the registers
5694 if (arg
->n_aligned_regs
!= 0)
5697 /* If this is being passed partially in a register, we can't evaluate
5698 it directly into its stack slot. Otherwise, we can. */
5699 if (arg
->value
== 0)
5701 /* stack_arg_under_construction is nonzero if a function argument is
5702 being evaluated directly into the outgoing argument list and
5703 expand_call must take special action to preserve the argument list
5704 if it is called recursively.
5706 For scalar function arguments stack_usage_map is sufficient to
5707 determine which stack slots must be saved and restored. Scalar
5708 arguments in general have pass_on_stack == 0.
5710 If this argument is initialized by a function which takes the
5711 address of the argument (a C++ constructor or a C function
5712 returning a BLKmode structure), then stack_usage_map is
5713 insufficient and expand_call must push the stack around the
5714 function call. Such arguments have pass_on_stack == 1.
5716 Note that it is always safe to set stack_arg_under_construction,
5717 but this generates suboptimal code if set when not needed. */
5719 if (arg
->pass_on_stack
)
5720 stack_arg_under_construction
++;
5722 arg
->value
= expand_expr (pval
,
5724 || TYPE_MODE (TREE_TYPE (pval
)) != arg
->mode
)
5725 ? NULL_RTX
: arg
->stack
,
5726 VOIDmode
, EXPAND_STACK_PARM
);
5728 /* If we are promoting object (or for any other reason) the mode
5729 doesn't agree, convert the mode. */
5731 if (arg
->mode
!= TYPE_MODE (TREE_TYPE (pval
)))
5732 arg
->value
= convert_modes (arg
->mode
, TYPE_MODE (TREE_TYPE (pval
)),
5733 arg
->value
, arg
->unsignedp
);
5735 if (arg
->pass_on_stack
)
5736 stack_arg_under_construction
--;
5739 /* Check for overlap with already clobbered argument area. */
5740 if ((flags
& ECF_SIBCALL
)
5741 && MEM_P (arg
->value
)
5742 && mem_might_overlap_already_clobbered_arg_p (XEXP (arg
->value
, 0),
5743 arg
->locate
.size
.constant
))
5744 sibcall_failure
= 1;
5746 /* Don't allow anything left on stack from computation
5747 of argument to alloca. */
5748 if (flags
& ECF_MAY_BE_ALLOCA
)
5749 do_pending_stack_adjust ();
5751 if (arg
->value
== arg
->stack
)
5752 /* If the value is already in the stack slot, we are done. */
5754 else if (arg
->mode
!= BLKmode
)
5756 unsigned int parm_align
;
5758 /* Argument is a scalar, not entirely passed in registers.
5759 (If part is passed in registers, arg->partial says how much
5760 and emit_push_insn will take care of putting it there.)
5762 Push it, and if its size is less than the
5763 amount of space allocated to it,
5764 also bump stack pointer by the additional space.
5765 Note that in C the default argument promotions
5766 will prevent such mismatches. */
5768 poly_int64 size
= (TYPE_EMPTY_P (TREE_TYPE (pval
))
5769 ? 0 : GET_MODE_SIZE (arg
->mode
));
5771 /* Compute how much space the push instruction will push.
5772 On many machines, pushing a byte will advance the stack
5773 pointer by a halfword. */
5774 #ifdef PUSH_ROUNDING
5775 size
= PUSH_ROUNDING (size
);
5779 /* Compute how much space the argument should get:
5780 round up to a multiple of the alignment for arguments. */
5781 if (targetm
.calls
.function_arg_padding (arg
->mode
, TREE_TYPE (pval
))
5783 /* At the moment we don't (need to) support ABIs for which the
5784 padding isn't known at compile time. In principle it should
5785 be easy to add though. */
5786 used
= force_align_up (size
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
5788 /* Compute the alignment of the pushed argument. */
5789 parm_align
= arg
->locate
.boundary
;
5790 if (targetm
.calls
.function_arg_padding (arg
->mode
, TREE_TYPE (pval
))
5793 poly_int64 pad
= used
- size
;
5794 unsigned int pad_align
= known_alignment (pad
) * BITS_PER_UNIT
;
5796 parm_align
= MIN (parm_align
, pad_align
);
5799 /* This isn't already where we want it on the stack, so put it there.
5800 This can either be done with push or copy insns. */
5801 if (maybe_ne (used
, 0)
5802 && !emit_push_insn (arg
->value
, arg
->mode
, TREE_TYPE (pval
),
5803 NULL_RTX
, parm_align
, partial
, reg
, used
- size
,
5804 argblock
, ARGS_SIZE_RTX (arg
->locate
.offset
),
5805 reg_parm_stack_space
,
5806 ARGS_SIZE_RTX (arg
->locate
.alignment_pad
), true))
5807 sibcall_failure
= 1;
5809 /* Unless this is a partially-in-register argument, the argument is now
5812 arg
->value
= arg
->stack
;
5816 /* BLKmode, at least partly to be pushed. */
5818 unsigned int parm_align
;
5822 /* Pushing a nonscalar.
5823 If part is passed in registers, PARTIAL says how much
5824 and emit_push_insn will take care of putting it there. */
5826 /* Round its size up to a multiple
5827 of the allocation unit for arguments. */
5829 if (arg
->locate
.size
.var
!= 0)
5832 size_rtx
= ARGS_SIZE_RTX (arg
->locate
.size
);
5836 /* PUSH_ROUNDING has no effect on us, because emit_push_insn
5837 for BLKmode is careful to avoid it. */
5838 excess
= (arg
->locate
.size
.constant
5839 - arg_int_size_in_bytes (TREE_TYPE (pval
))
5841 size_rtx
= expand_expr (arg_size_in_bytes (TREE_TYPE (pval
)),
5842 NULL_RTX
, TYPE_MODE (sizetype
),
5846 parm_align
= arg
->locate
.boundary
;
5848 /* When an argument is padded down, the block is aligned to
5849 PARM_BOUNDARY, but the actual argument isn't. */
5850 if (targetm
.calls
.function_arg_padding (arg
->mode
, TREE_TYPE (pval
))
5853 if (arg
->locate
.size
.var
)
5854 parm_align
= BITS_PER_UNIT
;
5857 unsigned int excess_align
5858 = known_alignment (excess
) * BITS_PER_UNIT
;
5859 if (excess_align
!= 0)
5860 parm_align
= MIN (parm_align
, excess_align
);
5864 if ((flags
& ECF_SIBCALL
) && MEM_P (arg
->value
))
5866 /* emit_push_insn might not work properly if arg->value and
5867 argblock + arg->locate.offset areas overlap. */
5871 if (XEXP (x
, 0) == crtl
->args
.internal_arg_pointer
5872 || (GET_CODE (XEXP (x
, 0)) == PLUS
5873 && XEXP (XEXP (x
, 0), 0) ==
5874 crtl
->args
.internal_arg_pointer
5875 && CONST_INT_P (XEXP (XEXP (x
, 0), 1))))
5877 if (XEXP (x
, 0) != crtl
->args
.internal_arg_pointer
)
5878 i
= rtx_to_poly_int64 (XEXP (XEXP (x
, 0), 1));
5880 /* arg.locate doesn't contain the pretend_args_size offset,
5881 it's part of argblock. Ensure we don't count it in I. */
5882 if (STACK_GROWS_DOWNWARD
)
5883 i
-= crtl
->args
.pretend_args_size
;
5885 i
+= crtl
->args
.pretend_args_size
;
5887 /* expand_call should ensure this. */
5888 gcc_assert (!arg
->locate
.offset
.var
5889 && arg
->locate
.size
.var
== 0);
5890 poly_int64 size_val
= rtx_to_poly_int64 (size_rtx
);
5892 if (known_eq (arg
->locate
.offset
.constant
, i
))
5894 /* Even though they appear to be at the same location,
5895 if part of the outgoing argument is in registers,
5896 they aren't really at the same location. Check for
5897 this by making sure that the incoming size is the
5898 same as the outgoing size. */
5899 if (maybe_ne (arg
->locate
.size
.constant
, size_val
))
5900 sibcall_failure
= 1;
5902 else if (maybe_in_range_p (arg
->locate
.offset
.constant
,
5904 sibcall_failure
= 1;
5905 /* Use arg->locate.size.constant instead of size_rtx
5906 because we only care about the part of the argument
5908 else if (maybe_in_range_p (i
, arg
->locate
.offset
.constant
,
5909 arg
->locate
.size
.constant
))
5910 sibcall_failure
= 1;
5914 if (!CONST_INT_P (size_rtx
) || INTVAL (size_rtx
) != 0)
5915 emit_push_insn (arg
->value
, arg
->mode
, TREE_TYPE (pval
), size_rtx
,
5916 parm_align
, partial
, reg
, excess
, argblock
,
5917 ARGS_SIZE_RTX (arg
->locate
.offset
),
5918 reg_parm_stack_space
,
5919 ARGS_SIZE_RTX (arg
->locate
.alignment_pad
), false);
5921 /* Unless this is a partially-in-register argument, the argument is now
5924 ??? Unlike the case above, in which we want the actual
5925 address of the data, so that we can load it directly into a
5926 register, here we want the address of the stack slot, so that
5927 it's properly aligned for word-by-word copying or something
5928 like that. It's not clear that this is always correct. */
5930 arg
->value
= arg
->stack_slot
;
5933 if (arg
->reg
&& GET_CODE (arg
->reg
) == PARALLEL
)
5935 tree type
= TREE_TYPE (arg
->tree_value
);
5937 = emit_group_load_into_temps (arg
->reg
, arg
->value
, type
,
5938 int_size_in_bytes (type
));
5941 /* Mark all slots this store used. */
5942 if (ACCUMULATE_OUTGOING_ARGS
&& !(flags
& ECF_SIBCALL
)
5943 && argblock
&& ! variable_size
&& arg
->stack
)
5944 mark_stack_region_used (lower_bound
, upper_bound
);
5946 /* Once we have pushed something, pops can't safely
5947 be deferred during the rest of the arguments. */
5950 /* Free any temporary slots made in processing this argument. */
5953 return sibcall_failure
;
5956 /* Nonzero if we do not know how to pass TYPE solely in registers. */
5959 must_pass_in_stack_var_size (machine_mode mode ATTRIBUTE_UNUSED
,
5965 /* If the type has variable size... */
5966 if (TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
5969 /* If the type is marked as addressable (it is required
5970 to be constructed into the stack)... */
5971 if (TREE_ADDRESSABLE (type
))
5977 /* Another version of the TARGET_MUST_PASS_IN_STACK hook. This one
5978 takes trailing padding of a structure into account. */
5979 /* ??? Should be able to merge these two by examining BLOCK_REG_PADDING. */
5982 must_pass_in_stack_var_size_or_pad (machine_mode mode
, const_tree type
)
5987 /* If the type has variable size... */
5988 if (TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
5991 /* If the type is marked as addressable (it is required
5992 to be constructed into the stack)... */
5993 if (TREE_ADDRESSABLE (type
))
5996 if (TYPE_EMPTY_P (type
))
5999 /* If the padding and mode of the type is such that a copy into
6000 a register would put it into the wrong part of the register. */
6002 && int_size_in_bytes (type
) % (PARM_BOUNDARY
/ BITS_PER_UNIT
)
6003 && (targetm
.calls
.function_arg_padding (mode
, type
)
6004 == (BYTES_BIG_ENDIAN
? PAD_UPWARD
: PAD_DOWNWARD
)))
6010 /* Tell the garbage collector about GTY markers in this source file. */
6011 #include "gt-calls.h"