1 /* Convert function calls to rtl insns, for GNU C compiler.
2 Copyright (C) 1989-2017 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"
59 /* Like PREFERRED_STACK_BOUNDARY but in units of bytes, not bits. */
60 #define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)
62 /* Data structure and subroutines used within expand_call. */
66 /* Tree node for this argument. */
68 /* Mode for value; TYPE_MODE unless promoted. */
70 /* Current RTL value for argument, or 0 if it isn't precomputed. */
72 /* Initially-compute RTL value for argument; only for const functions. */
74 /* Register to pass this argument in, 0 if passed on stack, or an
75 PARALLEL if the arg is to be copied into multiple non-contiguous
78 /* Register to pass this argument in when generating tail call sequence.
79 This is not the same register as for normal calls on machines with
82 /* If REG is a PARALLEL, this is a copy of VALUE pulled into the correct
83 form for emit_group_move. */
85 /* If value is passed in neither reg nor stack, this field holds a number
86 of a special slot to be used. */
88 /* For pointer bounds hold an index of parm bounds are bound to. -1 if
89 there is no such pointer. */
91 /* If pointer_arg refers a structure, then pointer_offset holds an offset
92 of a pointer in this structure. */
94 /* If REG was promoted from the actual mode of the argument expression,
95 indicates whether the promotion is sign- or zero-extended. */
97 /* Number of bytes to put in registers. 0 means put the whole arg
98 in registers. Also 0 if not passed in registers. */
100 /* Nonzero if argument must be passed on stack.
101 Note that some arguments may be passed on the stack
102 even though pass_on_stack is zero, just because FUNCTION_ARG says so.
103 pass_on_stack identifies arguments that *cannot* go in registers. */
105 /* Some fields packaged up for locate_and_pad_parm. */
106 struct locate_and_pad_arg_data locate
;
107 /* Location on the stack at which parameter should be stored. The store
108 has already been done if STACK == VALUE. */
110 /* Location on the stack of the start of this argument slot. This can
111 differ from STACK if this arg pads downward. This location is known
112 to be aligned to TARGET_FUNCTION_ARG_BOUNDARY. */
114 /* Place that this stack area has been saved, if needed. */
116 /* If an argument's alignment does not permit direct copying into registers,
117 copy in smaller-sized pieces into pseudos. These are stored in a
118 block pointed to by this field. The next field says how many
119 word-sized pseudos we made. */
124 /* A vector of one char per byte of stack space. A byte if nonzero if
125 the corresponding stack location has been used.
126 This vector is used to prevent a function call within an argument from
127 clobbering any stack already set up. */
128 static char *stack_usage_map
;
130 /* Size of STACK_USAGE_MAP. */
131 static unsigned int highest_outgoing_arg_in_use
;
133 /* Assume that any stack location at this byte index is used,
134 without checking the contents of stack_usage_map. */
135 static unsigned HOST_WIDE_INT stack_usage_watermark
= HOST_WIDE_INT_M1U
;
137 /* A bitmap of virtual-incoming stack space. Bit is set if the corresponding
138 stack location's tail call argument has been already stored into the stack.
139 This bitmap is used to prevent sibling call optimization if function tries
140 to use parent's incoming argument slots when they have been already
141 overwritten with tail call arguments. */
142 static sbitmap stored_args_map
;
144 /* Assume that any virtual-incoming location at this byte index has been
145 stored, without checking the contents of stored_args_map. */
146 static unsigned HOST_WIDE_INT stored_args_watermark
;
148 /* stack_arg_under_construction is nonzero when an argument may be
149 initialized with a constructor call (including a C function that
150 returns a BLKmode struct) and expand_call must take special action
151 to make sure the object being constructed does not overlap the
152 argument list for the constructor call. */
153 static int stack_arg_under_construction
;
155 static void precompute_register_parameters (int, struct arg_data
*, int *);
156 static void store_bounds (struct arg_data
*, struct arg_data
*);
157 static int store_one_arg (struct arg_data
*, rtx
, int, int, int);
158 static void store_unaligned_arguments_into_pseudos (struct arg_data
*, int);
159 static int finalize_must_preallocate (int, int, struct arg_data
*,
161 static void precompute_arguments (int, struct arg_data
*);
162 static void compute_argument_addresses (struct arg_data
*, rtx
, int);
163 static rtx
rtx_for_function_call (tree
, tree
);
164 static void load_register_parameters (struct arg_data
*, int, rtx
*, int,
166 static int special_function_p (const_tree
, int);
167 static int check_sibcall_argument_overlap_1 (rtx
);
168 static int check_sibcall_argument_overlap (rtx_insn
*, struct arg_data
*, int);
170 static tree
split_complex_types (tree
);
172 #ifdef REG_PARM_STACK_SPACE
173 static rtx
save_fixed_argument_area (int, rtx
, int *, int *);
174 static void restore_fixed_argument_area (rtx
, rtx
, int, int);
177 /* Return true if bytes [LOWER_BOUND, UPPER_BOUND) of the outgoing
178 stack region might already be in use. */
181 stack_region_maybe_used_p (poly_uint64 lower_bound
, poly_uint64 upper_bound
,
182 unsigned int reg_parm_stack_space
)
184 unsigned HOST_WIDE_INT const_lower
, const_upper
;
185 const_lower
= constant_lower_bound (lower_bound
);
186 if (!upper_bound
.is_constant (&const_upper
))
187 const_upper
= HOST_WIDE_INT_M1U
;
189 if (const_upper
> stack_usage_watermark
)
192 /* Don't worry about things in the fixed argument area;
193 it has already been saved. */
194 const_lower
= MAX (const_lower
, reg_parm_stack_space
);
195 const_upper
= MIN (const_upper
, highest_outgoing_arg_in_use
);
196 for (unsigned HOST_WIDE_INT i
= const_lower
; i
< const_upper
; ++i
)
197 if (stack_usage_map
[i
])
202 /* Record that bytes [LOWER_BOUND, UPPER_BOUND) of the outgoing
203 stack region are now in use. */
206 mark_stack_region_used (poly_uint64 lower_bound
, poly_uint64 upper_bound
)
208 unsigned HOST_WIDE_INT const_lower
, const_upper
;
209 const_lower
= constant_lower_bound (lower_bound
);
210 if (upper_bound
.is_constant (&const_upper
))
211 for (unsigned HOST_WIDE_INT i
= const_lower
; i
< const_upper
; ++i
)
212 stack_usage_map
[i
] = 1;
214 stack_usage_watermark
= MIN (stack_usage_watermark
, const_lower
);
217 /* Force FUNEXP into a form suitable for the address of a CALL,
218 and return that as an rtx. Also load the static chain register
219 if FNDECL is a nested function.
221 CALL_FUSAGE points to a variable holding the prospective
222 CALL_INSN_FUNCTION_USAGE information. */
225 prepare_call_address (tree fndecl_or_type
, rtx funexp
, rtx static_chain_value
,
226 rtx
*call_fusage
, int reg_parm_seen
, int flags
)
228 /* Make a valid memory address and copy constants through pseudo-regs,
229 but not for a constant address if -fno-function-cse. */
230 if (GET_CODE (funexp
) != SYMBOL_REF
)
232 /* If it's an indirect call by descriptor, generate code to perform
233 runtime identification of the pointer and load the descriptor. */
234 if ((flags
& ECF_BY_DESCRIPTOR
) && !flag_trampolines
)
236 const int bit_val
= targetm
.calls
.custom_function_descriptors
;
237 rtx call_lab
= gen_label_rtx ();
239 gcc_assert (fndecl_or_type
&& TYPE_P (fndecl_or_type
));
241 = build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
, NULL_TREE
,
243 DECL_STATIC_CHAIN (fndecl_or_type
) = 1;
244 rtx chain
= targetm
.calls
.static_chain (fndecl_or_type
, false);
246 if (GET_MODE (funexp
) != Pmode
)
247 funexp
= convert_memory_address (Pmode
, funexp
);
249 /* Avoid long live ranges around function calls. */
250 funexp
= copy_to_mode_reg (Pmode
, funexp
);
253 emit_insn (gen_rtx_CLOBBER (VOIDmode
, chain
));
255 /* Emit the runtime identification pattern. */
256 rtx mask
= gen_rtx_AND (Pmode
, funexp
, GEN_INT (bit_val
));
257 emit_cmp_and_jump_insns (mask
, const0_rtx
, EQ
, NULL_RTX
, Pmode
, 1,
260 /* Statically predict the branch to very likely taken. */
261 rtx_insn
*insn
= get_last_insn ();
263 predict_insn_def (insn
, PRED_BUILTIN_EXPECT
, TAKEN
);
265 /* Load the descriptor. */
266 rtx mem
= gen_rtx_MEM (ptr_mode
,
267 plus_constant (Pmode
, funexp
, - bit_val
));
268 MEM_NOTRAP_P (mem
) = 1;
269 mem
= convert_memory_address (Pmode
, mem
);
270 emit_move_insn (chain
, mem
);
272 mem
= gen_rtx_MEM (ptr_mode
,
273 plus_constant (Pmode
, funexp
,
274 POINTER_SIZE
/ BITS_PER_UNIT
276 MEM_NOTRAP_P (mem
) = 1;
277 mem
= convert_memory_address (Pmode
, mem
);
278 emit_move_insn (funexp
, mem
);
280 emit_label (call_lab
);
284 use_reg (call_fusage
, chain
);
285 STATIC_CHAIN_REG_P (chain
) = 1;
288 /* Make sure we're not going to be overwritten below. */
289 gcc_assert (!static_chain_value
);
292 /* If we are using registers for parameters, force the
293 function address into a register now. */
294 funexp
= ((reg_parm_seen
295 && targetm
.small_register_classes_for_mode_p (FUNCTION_MODE
))
296 ? force_not_mem (memory_address (FUNCTION_MODE
, funexp
))
297 : memory_address (FUNCTION_MODE
, funexp
));
301 /* funexp could be a SYMBOL_REF represents a function pointer which is
302 of ptr_mode. In this case, it should be converted into address mode
303 to be a valid address for memory rtx pattern. See PR 64971. */
304 if (GET_MODE (funexp
) != Pmode
)
305 funexp
= convert_memory_address (Pmode
, funexp
);
307 if (!(flags
& ECF_SIBCALL
))
309 if (!NO_FUNCTION_CSE
&& optimize
&& ! flag_no_function_cse
)
310 funexp
= force_reg (Pmode
, funexp
);
314 if (static_chain_value
!= 0
315 && (TREE_CODE (fndecl_or_type
) != FUNCTION_DECL
316 || DECL_STATIC_CHAIN (fndecl_or_type
)))
320 chain
= targetm
.calls
.static_chain (fndecl_or_type
, false);
321 static_chain_value
= convert_memory_address (Pmode
, static_chain_value
);
323 emit_move_insn (chain
, static_chain_value
);
326 use_reg (call_fusage
, chain
);
327 STATIC_CHAIN_REG_P (chain
) = 1;
334 /* Generate instructions to call function FUNEXP,
335 and optionally pop the results.
336 The CALL_INSN is the first insn generated.
338 FNDECL is the declaration node of the function. This is given to the
339 hook TARGET_RETURN_POPS_ARGS to determine whether this function pops
342 FUNTYPE is the data type of the function. This is given to the hook
343 TARGET_RETURN_POPS_ARGS to determine whether this function pops its
344 own args. We used to allow an identifier for library functions, but
345 that doesn't work when the return type is an aggregate type and the
346 calling convention says that the pointer to this aggregate is to be
347 popped by the callee.
349 STACK_SIZE is the number of bytes of arguments on the stack,
350 ROUNDED_STACK_SIZE is that number rounded up to
351 PREFERRED_STACK_BOUNDARY; zero if the size is variable. This is
352 both to put into the call insn and to generate explicit popping
355 STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
356 It is zero if this call doesn't want a structure value.
358 NEXT_ARG_REG is the rtx that results from executing
359 targetm.calls.function_arg (&args_so_far, VOIDmode, void_type_node, true)
360 just after all the args have had their registers assigned.
361 This could be whatever you like, but normally it is the first
362 arg-register beyond those used for args in this call,
363 or 0 if all the arg-registers are used in this call.
364 It is passed on to `gen_call' so you can put this info in the call insn.
366 VALREG is a hard register in which a value is returned,
367 or 0 if the call does not return a value.
369 OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before
370 the args to this call were processed.
371 We restore `inhibit_defer_pop' to that value.
373 CALL_FUSAGE is either empty or an EXPR_LIST of USE expressions that
374 denote registers used by the called function. */
377 emit_call_1 (rtx funexp
, tree fntree ATTRIBUTE_UNUSED
, tree fndecl ATTRIBUTE_UNUSED
,
378 tree funtype ATTRIBUTE_UNUSED
,
379 poly_int64 stack_size ATTRIBUTE_UNUSED
,
380 poly_int64 rounded_stack_size
,
381 HOST_WIDE_INT struct_value_size ATTRIBUTE_UNUSED
,
382 rtx next_arg_reg ATTRIBUTE_UNUSED
, rtx valreg
,
383 int old_inhibit_defer_pop
, rtx call_fusage
, int ecf_flags
,
384 cumulative_args_t args_so_far ATTRIBUTE_UNUSED
)
386 rtx rounded_stack_size_rtx
= gen_int_mode (rounded_stack_size
, Pmode
);
387 rtx call
, funmem
, pat
;
388 int already_popped
= 0;
389 poly_int64 n_popped
= 0;
391 /* Sibling call patterns never pop arguments (no sibcall(_value)_pop
392 patterns exist). Any popping that the callee does on return will
393 be from our caller's frame rather than ours. */
394 if (!(ecf_flags
& ECF_SIBCALL
))
396 n_popped
+= targetm
.calls
.return_pops_args (fndecl
, funtype
, stack_size
);
398 #ifdef CALL_POPS_ARGS
399 n_popped
+= CALL_POPS_ARGS (*get_cumulative_args (args_so_far
));
403 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
404 and we don't want to load it into a register as an optimization,
405 because prepare_call_address already did it if it should be done. */
406 if (GET_CODE (funexp
) != SYMBOL_REF
)
407 funexp
= memory_address (FUNCTION_MODE
, funexp
);
409 funmem
= gen_rtx_MEM (FUNCTION_MODE
, funexp
);
410 if (fndecl
&& TREE_CODE (fndecl
) == FUNCTION_DECL
)
414 /* Although a built-in FUNCTION_DECL and its non-__builtin
415 counterpart compare equal and get a shared mem_attrs, they
416 produce different dump output in compare-debug compilations,
417 if an entry gets garbage collected in one compilation, then
418 adds a different (but equivalent) entry, while the other
419 doesn't run the garbage collector at the same spot and then
420 shares the mem_attr with the equivalent entry. */
421 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
423 tree t2
= builtin_decl_explicit (DECL_FUNCTION_CODE (t
));
428 set_mem_expr (funmem
, t
);
431 set_mem_expr (funmem
, build_simple_mem_ref (CALL_EXPR_FN (fntree
)));
433 if (ecf_flags
& ECF_SIBCALL
)
436 pat
= targetm
.gen_sibcall_value (valreg
, funmem
,
437 rounded_stack_size_rtx
,
438 next_arg_reg
, NULL_RTX
);
440 pat
= targetm
.gen_sibcall (funmem
, rounded_stack_size_rtx
,
441 next_arg_reg
, GEN_INT (struct_value_size
));
443 /* If the target has "call" or "call_value" insns, then prefer them
444 if no arguments are actually popped. If the target does not have
445 "call" or "call_value" insns, then we must use the popping versions
446 even if the call has no arguments to pop. */
447 else if (maybe_ne (n_popped
, 0)
449 ? targetm
.have_call_value ()
450 : targetm
.have_call ()))
452 rtx n_pop
= gen_int_mode (n_popped
, Pmode
);
454 /* If this subroutine pops its own args, record that in the call insn
455 if possible, for the sake of frame pointer elimination. */
458 pat
= targetm
.gen_call_value_pop (valreg
, funmem
,
459 rounded_stack_size_rtx
,
460 next_arg_reg
, n_pop
);
462 pat
= targetm
.gen_call_pop (funmem
, rounded_stack_size_rtx
,
463 next_arg_reg
, n_pop
);
470 pat
= targetm
.gen_call_value (valreg
, funmem
, rounded_stack_size_rtx
,
471 next_arg_reg
, NULL_RTX
);
473 pat
= targetm
.gen_call (funmem
, rounded_stack_size_rtx
, next_arg_reg
,
474 GEN_INT (struct_value_size
));
478 /* Find the call we just emitted. */
479 rtx_call_insn
*call_insn
= last_call_insn ();
481 /* Some target create a fresh MEM instead of reusing the one provided
482 above. Set its MEM_EXPR. */
483 call
= get_call_rtx_from (call_insn
);
485 && MEM_EXPR (XEXP (call
, 0)) == NULL_TREE
486 && MEM_EXPR (funmem
) != NULL_TREE
)
487 set_mem_expr (XEXP (call
, 0), MEM_EXPR (funmem
));
489 /* Mark instrumented calls. */
491 CALL_EXPR_WITH_BOUNDS_P (call
) = CALL_WITH_BOUNDS_P (fntree
);
493 /* Put the register usage information there. */
494 add_function_usage_to (call_insn
, call_fusage
);
496 /* If this is a const call, then set the insn's unchanging bit. */
497 if (ecf_flags
& ECF_CONST
)
498 RTL_CONST_CALL_P (call_insn
) = 1;
500 /* If this is a pure call, then set the insn's unchanging bit. */
501 if (ecf_flags
& ECF_PURE
)
502 RTL_PURE_CALL_P (call_insn
) = 1;
504 /* If this is a const call, then set the insn's unchanging bit. */
505 if (ecf_flags
& ECF_LOOPING_CONST_OR_PURE
)
506 RTL_LOOPING_CONST_OR_PURE_CALL_P (call_insn
) = 1;
508 /* Create a nothrow REG_EH_REGION note, if needed. */
509 make_reg_eh_region_note (call_insn
, ecf_flags
, 0);
511 if (ecf_flags
& ECF_NORETURN
)
512 add_reg_note (call_insn
, REG_NORETURN
, const0_rtx
);
514 if (ecf_flags
& ECF_RETURNS_TWICE
)
516 add_reg_note (call_insn
, REG_SETJMP
, const0_rtx
);
517 cfun
->calls_setjmp
= 1;
520 SIBLING_CALL_P (call_insn
) = ((ecf_flags
& ECF_SIBCALL
) != 0);
522 /* Restore this now, so that we do defer pops for this call's args
523 if the context of the call as a whole permits. */
524 inhibit_defer_pop
= old_inhibit_defer_pop
;
526 if (maybe_ne (n_popped
, 0))
529 CALL_INSN_FUNCTION_USAGE (call_insn
)
530 = gen_rtx_EXPR_LIST (VOIDmode
,
531 gen_rtx_CLOBBER (VOIDmode
, stack_pointer_rtx
),
532 CALL_INSN_FUNCTION_USAGE (call_insn
));
533 rounded_stack_size
-= n_popped
;
534 rounded_stack_size_rtx
= gen_int_mode (rounded_stack_size
, Pmode
);
535 stack_pointer_delta
-= n_popped
;
537 add_args_size_note (call_insn
, stack_pointer_delta
);
539 /* If popup is needed, stack realign must use DRAP */
540 if (SUPPORTS_STACK_ALIGNMENT
)
541 crtl
->need_drap
= true;
543 /* For noreturn calls when not accumulating outgoing args force
544 REG_ARGS_SIZE note to prevent crossjumping of calls with different
546 else if (!ACCUMULATE_OUTGOING_ARGS
&& (ecf_flags
& ECF_NORETURN
) != 0)
547 add_args_size_note (call_insn
, stack_pointer_delta
);
549 if (!ACCUMULATE_OUTGOING_ARGS
)
551 /* If returning from the subroutine does not automatically pop the args,
552 we need an instruction to pop them sooner or later.
553 Perhaps do it now; perhaps just record how much space to pop later.
555 If returning from the subroutine does pop the args, indicate that the
556 stack pointer will be changed. */
558 if (maybe_ne (rounded_stack_size
, 0))
560 if (ecf_flags
& ECF_NORETURN
)
561 /* Just pretend we did the pop. */
562 stack_pointer_delta
-= rounded_stack_size
;
563 else if (flag_defer_pop
&& inhibit_defer_pop
== 0
564 && ! (ecf_flags
& (ECF_CONST
| ECF_PURE
)))
565 pending_stack_adjust
+= rounded_stack_size
;
567 adjust_stack (rounded_stack_size_rtx
);
570 /* When we accumulate outgoing args, we must avoid any stack manipulations.
571 Restore the stack pointer to its original value now. Usually
572 ACCUMULATE_OUTGOING_ARGS targets don't get here, but there are exceptions.
573 On i386 ACCUMULATE_OUTGOING_ARGS can be enabled on demand, and
574 popping variants of functions exist as well.
576 ??? We may optimize similar to defer_pop above, but it is
577 probably not worthwhile.
579 ??? It will be worthwhile to enable combine_stack_adjustments even for
581 else if (maybe_ne (n_popped
, 0))
582 anti_adjust_stack (gen_int_mode (n_popped
, Pmode
));
585 /* Determine if the function identified by FNDECL is one with
586 special properties we wish to know about. Modify FLAGS accordingly.
588 For example, if the function might return more than one time (setjmp), then
589 set ECF_RETURNS_TWICE.
591 Set ECF_MAY_BE_ALLOCA for any memory allocation function that might allocate
592 space from the stack such as alloca. */
595 special_function_p (const_tree fndecl
, int flags
)
597 tree name_decl
= DECL_NAME (fndecl
);
599 /* For instrumentation clones we want to derive flags
600 from the original name. */
601 if (cgraph_node::get (fndecl
)
602 && cgraph_node::get (fndecl
)->instrumentation_clone
)
603 name_decl
= DECL_NAME (cgraph_node::get (fndecl
)->orig_decl
);
605 if (fndecl
&& name_decl
606 && IDENTIFIER_LENGTH (name_decl
) <= 11
607 /* Exclude functions not at the file scope, or not `extern',
608 since they are not the magic functions we would otherwise
610 FIXME: this should be handled with attributes, not with this
611 hacky imitation of DECL_ASSEMBLER_NAME. It's (also) wrong
612 because you can declare fork() inside a function if you
614 && (DECL_CONTEXT (fndecl
) == NULL_TREE
615 || TREE_CODE (DECL_CONTEXT (fndecl
)) == TRANSLATION_UNIT_DECL
)
616 && TREE_PUBLIC (fndecl
))
618 const char *name
= IDENTIFIER_POINTER (name_decl
);
619 const char *tname
= name
;
621 /* We assume that alloca will always be called by name. It
622 makes no sense to pass it as a pointer-to-function to
623 anything that does not understand its behavior. */
624 if (IDENTIFIER_LENGTH (name_decl
) == 6
626 && ! strcmp (name
, "alloca"))
627 flags
|= ECF_MAY_BE_ALLOCA
;
629 /* Disregard prefix _ or __. */
638 /* ECF_RETURNS_TWICE is safe even for -ffreestanding. */
639 if (! strcmp (tname
, "setjmp")
640 || ! strcmp (tname
, "sigsetjmp")
641 || ! strcmp (name
, "savectx")
642 || ! strcmp (name
, "vfork")
643 || ! strcmp (name
, "getcontext"))
644 flags
|= ECF_RETURNS_TWICE
;
647 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
648 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl
)))
649 flags
|= ECF_MAY_BE_ALLOCA
;
654 /* Similar to special_function_p; return a set of ERF_ flags for the
657 decl_return_flags (tree fndecl
)
660 tree type
= TREE_TYPE (fndecl
);
664 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
668 attr
= TREE_VALUE (TREE_VALUE (attr
));
669 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
672 switch (TREE_STRING_POINTER (attr
)[0])
678 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
689 /* Return nonzero when FNDECL represents a call to setjmp. */
692 setjmp_call_p (const_tree fndecl
)
694 if (DECL_IS_RETURNS_TWICE (fndecl
))
695 return ECF_RETURNS_TWICE
;
696 return special_function_p (fndecl
, 0) & ECF_RETURNS_TWICE
;
700 /* Return true if STMT may be an alloca call. */
703 gimple_maybe_alloca_call_p (const gimple
*stmt
)
707 if (!is_gimple_call (stmt
))
710 fndecl
= gimple_call_fndecl (stmt
);
711 if (fndecl
&& (special_function_p (fndecl
, 0) & ECF_MAY_BE_ALLOCA
))
717 /* Return true if STMT is a builtin alloca call. */
720 gimple_alloca_call_p (const gimple
*stmt
)
724 if (!is_gimple_call (stmt
))
727 fndecl
= gimple_call_fndecl (stmt
);
728 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
729 switch (DECL_FUNCTION_CODE (fndecl
))
731 CASE_BUILT_IN_ALLOCA
:
740 /* Return true when exp contains a builtin alloca call. */
743 alloca_call_p (const_tree exp
)
746 if (TREE_CODE (exp
) == CALL_EXPR
747 && (fndecl
= get_callee_fndecl (exp
))
748 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
749 switch (DECL_FUNCTION_CODE (fndecl
))
751 CASE_BUILT_IN_ALLOCA
:
760 /* Return TRUE if FNDECL is either a TM builtin or a TM cloned
761 function. Return FALSE otherwise. */
764 is_tm_builtin (const_tree fndecl
)
769 if (decl_is_tm_clone (fndecl
))
772 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
774 switch (DECL_FUNCTION_CODE (fndecl
))
776 case BUILT_IN_TM_COMMIT
:
777 case BUILT_IN_TM_COMMIT_EH
:
778 case BUILT_IN_TM_ABORT
:
779 case BUILT_IN_TM_IRREVOCABLE
:
780 case BUILT_IN_TM_GETTMCLONE_IRR
:
781 case BUILT_IN_TM_MEMCPY
:
782 case BUILT_IN_TM_MEMMOVE
:
783 case BUILT_IN_TM_MEMSET
:
784 CASE_BUILT_IN_TM_STORE (1):
785 CASE_BUILT_IN_TM_STORE (2):
786 CASE_BUILT_IN_TM_STORE (4):
787 CASE_BUILT_IN_TM_STORE (8):
788 CASE_BUILT_IN_TM_STORE (FLOAT
):
789 CASE_BUILT_IN_TM_STORE (DOUBLE
):
790 CASE_BUILT_IN_TM_STORE (LDOUBLE
):
791 CASE_BUILT_IN_TM_STORE (M64
):
792 CASE_BUILT_IN_TM_STORE (M128
):
793 CASE_BUILT_IN_TM_STORE (M256
):
794 CASE_BUILT_IN_TM_LOAD (1):
795 CASE_BUILT_IN_TM_LOAD (2):
796 CASE_BUILT_IN_TM_LOAD (4):
797 CASE_BUILT_IN_TM_LOAD (8):
798 CASE_BUILT_IN_TM_LOAD (FLOAT
):
799 CASE_BUILT_IN_TM_LOAD (DOUBLE
):
800 CASE_BUILT_IN_TM_LOAD (LDOUBLE
):
801 CASE_BUILT_IN_TM_LOAD (M64
):
802 CASE_BUILT_IN_TM_LOAD (M128
):
803 CASE_BUILT_IN_TM_LOAD (M256
):
804 case BUILT_IN_TM_LOG
:
805 case BUILT_IN_TM_LOG_1
:
806 case BUILT_IN_TM_LOG_2
:
807 case BUILT_IN_TM_LOG_4
:
808 case BUILT_IN_TM_LOG_8
:
809 case BUILT_IN_TM_LOG_FLOAT
:
810 case BUILT_IN_TM_LOG_DOUBLE
:
811 case BUILT_IN_TM_LOG_LDOUBLE
:
812 case BUILT_IN_TM_LOG_M64
:
813 case BUILT_IN_TM_LOG_M128
:
814 case BUILT_IN_TM_LOG_M256
:
823 /* Detect flags (function attributes) from the function decl or type node. */
826 flags_from_decl_or_type (const_tree exp
)
832 /* The function exp may have the `malloc' attribute. */
833 if (DECL_IS_MALLOC (exp
))
836 /* The function exp may have the `returns_twice' attribute. */
837 if (DECL_IS_RETURNS_TWICE (exp
))
838 flags
|= ECF_RETURNS_TWICE
;
840 /* Process the pure and const attributes. */
841 if (TREE_READONLY (exp
))
843 if (DECL_PURE_P (exp
))
845 if (DECL_LOOPING_CONST_OR_PURE_P (exp
))
846 flags
|= ECF_LOOPING_CONST_OR_PURE
;
848 if (DECL_IS_NOVOPS (exp
))
850 if (lookup_attribute ("leaf", DECL_ATTRIBUTES (exp
)))
852 if (lookup_attribute ("cold", DECL_ATTRIBUTES (exp
)))
855 if (TREE_NOTHROW (exp
))
856 flags
|= ECF_NOTHROW
;
860 if (is_tm_builtin (exp
))
861 flags
|= ECF_TM_BUILTIN
;
862 else if ((flags
& (ECF_CONST
|ECF_NOVOPS
)) != 0
863 || lookup_attribute ("transaction_pure",
864 TYPE_ATTRIBUTES (TREE_TYPE (exp
))))
865 flags
|= ECF_TM_PURE
;
868 flags
= special_function_p (exp
, flags
);
870 else if (TYPE_P (exp
))
872 if (TYPE_READONLY (exp
))
876 && ((flags
& ECF_CONST
) != 0
877 || lookup_attribute ("transaction_pure", TYPE_ATTRIBUTES (exp
))))
878 flags
|= ECF_TM_PURE
;
883 if (TREE_THIS_VOLATILE (exp
))
885 flags
|= ECF_NORETURN
;
886 if (flags
& (ECF_CONST
|ECF_PURE
))
887 flags
|= ECF_LOOPING_CONST_OR_PURE
;
893 /* Detect flags from a CALL_EXPR. */
896 call_expr_flags (const_tree t
)
899 tree decl
= get_callee_fndecl (t
);
902 flags
= flags_from_decl_or_type (decl
);
903 else if (CALL_EXPR_FN (t
) == NULL_TREE
)
904 flags
= internal_fn_flags (CALL_EXPR_IFN (t
));
907 tree type
= TREE_TYPE (CALL_EXPR_FN (t
));
908 if (type
&& TREE_CODE (type
) == POINTER_TYPE
)
909 flags
= flags_from_decl_or_type (TREE_TYPE (type
));
912 if (CALL_EXPR_BY_DESCRIPTOR (t
))
913 flags
|= ECF_BY_DESCRIPTOR
;
919 /* Return true if TYPE should be passed by invisible reference. */
922 pass_by_reference (CUMULATIVE_ARGS
*ca
, machine_mode mode
,
923 tree type
, bool named_arg
)
927 /* If this type contains non-trivial constructors, then it is
928 forbidden for the middle-end to create any new copies. */
929 if (TREE_ADDRESSABLE (type
))
932 /* GCC post 3.4 passes *all* variable sized types by reference. */
933 if (!TYPE_SIZE (type
) || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
936 /* If a record type should be passed the same as its first (and only)
937 member, use the type and mode of that member. */
938 if (TREE_CODE (type
) == RECORD_TYPE
&& TYPE_TRANSPARENT_AGGR (type
))
940 type
= TREE_TYPE (first_field (type
));
941 mode
= TYPE_MODE (type
);
945 return targetm
.calls
.pass_by_reference (pack_cumulative_args (ca
), mode
,
949 /* Return true if TYPE, which is passed by reference, should be callee
950 copied instead of caller copied. */
953 reference_callee_copied (CUMULATIVE_ARGS
*ca
, machine_mode mode
,
954 tree type
, bool named_arg
)
956 if (type
&& TREE_ADDRESSABLE (type
))
958 return targetm
.calls
.callee_copies (pack_cumulative_args (ca
), mode
, type
,
963 /* Precompute all register parameters as described by ARGS, storing values
964 into fields within the ARGS array.
966 NUM_ACTUALS indicates the total number elements in the ARGS array.
968 Set REG_PARM_SEEN if we encounter a register parameter. */
971 precompute_register_parameters (int num_actuals
, struct arg_data
*args
,
978 for (i
= 0; i
< num_actuals
; i
++)
979 if (args
[i
].reg
!= 0 && ! args
[i
].pass_on_stack
)
983 if (args
[i
].value
== 0)
986 args
[i
].value
= expand_normal (args
[i
].tree_value
);
987 preserve_temp_slots (args
[i
].value
);
991 /* If we are to promote the function arg to a wider mode,
994 if (args
[i
].mode
!= TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)))
996 = convert_modes (args
[i
].mode
,
997 TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)),
998 args
[i
].value
, args
[i
].unsignedp
);
1000 /* If the value is a non-legitimate constant, force it into a
1001 pseudo now. TLS symbols sometimes need a call to resolve. */
1002 if (CONSTANT_P (args
[i
].value
)
1003 && !targetm
.legitimate_constant_p (args
[i
].mode
, args
[i
].value
))
1004 args
[i
].value
= force_reg (args
[i
].mode
, args
[i
].value
);
1006 /* If we're going to have to load the value by parts, pull the
1007 parts into pseudos. The part extraction process can involve
1008 non-trivial computation. */
1009 if (GET_CODE (args
[i
].reg
) == PARALLEL
)
1011 tree type
= TREE_TYPE (args
[i
].tree_value
);
1012 args
[i
].parallel_value
1013 = emit_group_load_into_temps (args
[i
].reg
, args
[i
].value
,
1014 type
, int_size_in_bytes (type
));
1017 /* If the value is expensive, and we are inside an appropriately
1018 short loop, put the value into a pseudo and then put the pseudo
1021 For small register classes, also do this if this call uses
1022 register parameters. This is to avoid reload conflicts while
1023 loading the parameters registers. */
1025 else if ((! (REG_P (args
[i
].value
)
1026 || (GET_CODE (args
[i
].value
) == SUBREG
1027 && REG_P (SUBREG_REG (args
[i
].value
)))))
1028 && args
[i
].mode
!= BLKmode
1029 && (set_src_cost (args
[i
].value
, args
[i
].mode
,
1030 optimize_insn_for_speed_p ())
1031 > COSTS_N_INSNS (1))
1033 && targetm
.small_register_classes_for_mode_p (args
[i
].mode
))
1035 args
[i
].value
= copy_to_mode_reg (args
[i
].mode
, args
[i
].value
);
1039 #ifdef REG_PARM_STACK_SPACE
1041 /* The argument list is the property of the called routine and it
1042 may clobber it. If the fixed area has been used for previous
1043 parameters, we must save and restore it. */
1046 save_fixed_argument_area (int reg_parm_stack_space
, rtx argblock
, int *low_to_save
, int *high_to_save
)
1051 /* Compute the boundary of the area that needs to be saved, if any. */
1052 high
= reg_parm_stack_space
;
1053 if (ARGS_GROW_DOWNWARD
)
1056 if (high
> highest_outgoing_arg_in_use
)
1057 high
= highest_outgoing_arg_in_use
;
1059 for (low
= 0; low
< high
; low
++)
1060 if (stack_usage_map
[low
] != 0 || low
>= stack_usage_watermark
)
1063 machine_mode save_mode
;
1069 while (stack_usage_map
[--high
] == 0)
1073 *high_to_save
= high
;
1075 num_to_save
= high
- low
+ 1;
1077 /* If we don't have the required alignment, must do this
1079 scalar_int_mode imode
;
1080 if (int_mode_for_size (num_to_save
* BITS_PER_UNIT
, 1).exists (&imode
)
1081 && (low
& (MIN (GET_MODE_SIZE (imode
),
1082 BIGGEST_ALIGNMENT
/ UNITS_PER_WORD
) - 1)) == 0)
1085 save_mode
= BLKmode
;
1087 if (ARGS_GROW_DOWNWARD
)
1092 addr
= plus_constant (Pmode
, argblock
, delta
);
1093 stack_area
= gen_rtx_MEM (save_mode
, memory_address (save_mode
, addr
));
1095 set_mem_align (stack_area
, PARM_BOUNDARY
);
1096 if (save_mode
== BLKmode
)
1098 save_area
= assign_stack_temp (BLKmode
, num_to_save
);
1099 emit_block_move (validize_mem (save_area
), stack_area
,
1100 GEN_INT (num_to_save
), BLOCK_OP_CALL_PARM
);
1104 save_area
= gen_reg_rtx (save_mode
);
1105 emit_move_insn (save_area
, stack_area
);
1115 restore_fixed_argument_area (rtx save_area
, rtx argblock
, int high_to_save
, int low_to_save
)
1117 machine_mode save_mode
= GET_MODE (save_area
);
1119 rtx addr
, stack_area
;
1121 if (ARGS_GROW_DOWNWARD
)
1122 delta
= -high_to_save
;
1124 delta
= low_to_save
;
1126 addr
= plus_constant (Pmode
, argblock
, delta
);
1127 stack_area
= gen_rtx_MEM (save_mode
, memory_address (save_mode
, addr
));
1128 set_mem_align (stack_area
, PARM_BOUNDARY
);
1130 if (save_mode
!= BLKmode
)
1131 emit_move_insn (stack_area
, save_area
);
1133 emit_block_move (stack_area
, validize_mem (save_area
),
1134 GEN_INT (high_to_save
- low_to_save
+ 1),
1135 BLOCK_OP_CALL_PARM
);
1137 #endif /* REG_PARM_STACK_SPACE */
1139 /* If any elements in ARGS refer to parameters that are to be passed in
1140 registers, but not in memory, and whose alignment does not permit a
1141 direct copy into registers. Copy the values into a group of pseudos
1142 which we will later copy into the appropriate hard registers.
1144 Pseudos for each unaligned argument will be stored into the array
1145 args[argnum].aligned_regs. The caller is responsible for deallocating
1146 the aligned_regs array if it is nonzero. */
1149 store_unaligned_arguments_into_pseudos (struct arg_data
*args
, int num_actuals
)
1153 for (i
= 0; i
< num_actuals
; i
++)
1154 if (args
[i
].reg
!= 0 && ! args
[i
].pass_on_stack
1155 && GET_CODE (args
[i
].reg
) != PARALLEL
1156 && args
[i
].mode
== BLKmode
1157 && MEM_P (args
[i
].value
)
1158 && (MEM_ALIGN (args
[i
].value
)
1159 < (unsigned int) MIN (BIGGEST_ALIGNMENT
, BITS_PER_WORD
)))
1161 int bytes
= int_size_in_bytes (TREE_TYPE (args
[i
].tree_value
));
1162 int endian_correction
= 0;
1164 if (args
[i
].partial
)
1166 gcc_assert (args
[i
].partial
% UNITS_PER_WORD
== 0);
1167 args
[i
].n_aligned_regs
= args
[i
].partial
/ UNITS_PER_WORD
;
1171 args
[i
].n_aligned_regs
1172 = (bytes
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
1175 args
[i
].aligned_regs
= XNEWVEC (rtx
, args
[i
].n_aligned_regs
);
1177 /* Structures smaller than a word are normally aligned to the
1178 least significant byte. On a BYTES_BIG_ENDIAN machine,
1179 this means we must skip the empty high order bytes when
1180 calculating the bit offset. */
1181 if (bytes
< UNITS_PER_WORD
1182 #ifdef BLOCK_REG_PADDING
1183 && (BLOCK_REG_PADDING (args
[i
].mode
,
1184 TREE_TYPE (args
[i
].tree_value
), 1)
1190 endian_correction
= BITS_PER_WORD
- bytes
* BITS_PER_UNIT
;
1192 for (j
= 0; j
< args
[i
].n_aligned_regs
; j
++)
1194 rtx reg
= gen_reg_rtx (word_mode
);
1195 rtx word
= operand_subword_force (args
[i
].value
, j
, BLKmode
);
1196 int bitsize
= MIN (bytes
* BITS_PER_UNIT
, BITS_PER_WORD
);
1198 args
[i
].aligned_regs
[j
] = reg
;
1199 word
= extract_bit_field (word
, bitsize
, 0, 1, NULL_RTX
,
1200 word_mode
, word_mode
, false, NULL
);
1202 /* There is no need to restrict this code to loading items
1203 in TYPE_ALIGN sized hunks. The bitfield instructions can
1204 load up entire word sized registers efficiently.
1206 ??? This may not be needed anymore.
1207 We use to emit a clobber here but that doesn't let later
1208 passes optimize the instructions we emit. By storing 0 into
1209 the register later passes know the first AND to zero out the
1210 bitfield being set in the register is unnecessary. The store
1211 of 0 will be deleted as will at least the first AND. */
1213 emit_move_insn (reg
, const0_rtx
);
1215 bytes
-= bitsize
/ BITS_PER_UNIT
;
1216 store_bit_field (reg
, bitsize
, endian_correction
, 0, 0,
1217 word_mode
, word
, false);
1222 /* The limit set by -Walloc-larger-than=. */
1223 static GTY(()) tree alloc_object_size_limit
;
1225 /* Initialize ALLOC_OBJECT_SIZE_LIMIT based on the -Walloc-size-larger-than=
1226 setting if the option is specified, or to the maximum object size if it
1227 is not. Return the initialized value. */
1230 alloc_max_size (void)
1232 if (!alloc_object_size_limit
)
1234 alloc_object_size_limit
= max_object_size ();
1236 if (warn_alloc_size_limit
)
1240 unsigned HOST_WIDE_INT unit
= 1;
1241 unsigned HOST_WIDE_INT limit
1242 = strtoull (warn_alloc_size_limit
, &end
, 10);
1248 /* Numeric option arguments are at most INT_MAX. Make it
1249 possible to specify a larger value by accepting common
1251 if (!strcmp (end
, "kB"))
1253 else if (!strcasecmp (end
, "KiB") || strcmp (end
, "KB"))
1255 else if (!strcmp (end
, "MB"))
1256 unit
= HOST_WIDE_INT_UC (1000) * 1000;
1257 else if (!strcasecmp (end
, "MiB"))
1258 unit
= HOST_WIDE_INT_UC (1024) * 1024;
1259 else if (!strcasecmp (end
, "GB"))
1260 unit
= HOST_WIDE_INT_UC (1000) * 1000 * 1000;
1261 else if (!strcasecmp (end
, "GiB"))
1262 unit
= HOST_WIDE_INT_UC (1024) * 1024 * 1024;
1263 else if (!strcasecmp (end
, "TB"))
1264 unit
= HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000;
1265 else if (!strcasecmp (end
, "TiB"))
1266 unit
= HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024;
1267 else if (!strcasecmp (end
, "PB"))
1268 unit
= HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000 * 1000;
1269 else if (!strcasecmp (end
, "PiB"))
1270 unit
= HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024 * 1024;
1271 else if (!strcasecmp (end
, "EB"))
1272 unit
= HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000 * 1000
1274 else if (!strcasecmp (end
, "EiB"))
1275 unit
= HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024 * 1024
1283 widest_int w
= wi::mul (limit
, unit
);
1284 if (w
< wi::to_widest (alloc_object_size_limit
))
1285 alloc_object_size_limit
1286 = wide_int_to_tree (ptrdiff_type_node
, w
);
1291 return alloc_object_size_limit
;
1294 /* Return true when EXP's range can be determined and set RANGE[] to it
1295 after adjusting it if necessary to make EXP a represents a valid size
1296 of object, or a valid size argument to an allocation function declared
1297 with attribute alloc_size (whose argument may be signed), or to a string
1298 manipulation function like memset. When ALLOW_ZERO is true, allow
1299 returning a range of [0, 0] for a size in an anti-range [1, N] where
1300 N > PTRDIFF_MAX. A zero range is a (nearly) invalid argument to
1301 allocation functions like malloc but it is a valid argument to
1302 functions like memset. */
1305 get_size_range (tree exp
, tree range
[2], bool allow_zero
/* = false */)
1307 if (tree_fits_uhwi_p (exp
))
1309 /* EXP is a constant. */
1310 range
[0] = range
[1] = exp
;
1314 tree exptype
= TREE_TYPE (exp
);
1315 bool integral
= INTEGRAL_TYPE_P (exptype
);
1318 enum value_range_type range_type
;
1320 if (TREE_CODE (exp
) == SSA_NAME
&& integral
)
1321 range_type
= get_range_info (exp
, &min
, &max
);
1323 range_type
= VR_VARYING
;
1325 if (range_type
== VR_VARYING
)
1329 /* Use the full range of the type of the expression when
1330 no value range information is available. */
1331 range
[0] = TYPE_MIN_VALUE (exptype
);
1332 range
[1] = TYPE_MAX_VALUE (exptype
);
1336 range
[0] = NULL_TREE
;
1337 range
[1] = NULL_TREE
;
1341 unsigned expprec
= TYPE_PRECISION (exptype
);
1343 bool signed_p
= !TYPE_UNSIGNED (exptype
);
1345 if (range_type
== VR_ANTI_RANGE
)
1349 if (wi::les_p (max
, 0))
1351 /* EXP is not in a strictly negative range. That means
1352 it must be in some (not necessarily strictly) positive
1353 range which includes zero. Since in signed to unsigned
1354 conversions negative values end up converted to large
1355 positive values, and otherwise they are not valid sizes,
1356 the resulting range is in both cases [0, TYPE_MAX]. */
1357 min
= wi::zero (expprec
);
1358 max
= wi::to_wide (TYPE_MAX_VALUE (exptype
));
1360 else if (wi::les_p (min
- 1, 0))
1362 /* EXP is not in a negative-positive range. That means EXP
1363 is either negative, or greater than max. Since negative
1364 sizes are invalid make the range [MAX + 1, TYPE_MAX]. */
1366 max
= wi::to_wide (TYPE_MAX_VALUE (exptype
));
1371 min
= wi::zero (expprec
);
1374 else if (wi::eq_p (0, min
- 1))
1376 /* EXP is unsigned and not in the range [1, MAX]. That means
1377 it's either zero or greater than MAX. Even though 0 would
1378 normally be detected by -Walloc-zero, unless ALLOW_ZERO
1379 is true, set the range to [MAX, TYPE_MAX] so that when MAX
1380 is greater than the limit the whole range is diagnosed. */
1382 min
= max
= wi::zero (expprec
);
1386 max
= wi::to_wide (TYPE_MAX_VALUE (exptype
));
1392 min
= wi::zero (expprec
);
1396 range
[0] = wide_int_to_tree (exptype
, min
);
1397 range
[1] = wide_int_to_tree (exptype
, max
);
1402 /* Diagnose a call EXP to function FN decorated with attribute alloc_size
1403 whose argument numbers given by IDX with values given by ARGS exceed
1404 the maximum object size or cause an unsigned oveflow (wrapping) when
1405 multiplied. When ARGS[0] is null the function does nothing. ARGS[1]
1406 may be null for functions like malloc, and non-null for those like
1407 calloc that are decorated with a two-argument attribute alloc_size. */
1410 maybe_warn_alloc_args_overflow (tree fn
, tree exp
, tree args
[2], int idx
[2])
1412 /* The range each of the (up to) two arguments is known to be in. */
1413 tree argrange
[2][2] = { { NULL_TREE
, NULL_TREE
}, { NULL_TREE
, NULL_TREE
} };
1415 /* Maximum object size set by -Walloc-size-larger-than= or SIZE_MAX / 2. */
1416 tree maxobjsize
= alloc_max_size ();
1418 location_t loc
= EXPR_LOCATION (exp
);
1420 bool warned
= false;
1422 /* Validate each argument individually. */
1423 for (unsigned i
= 0; i
!= 2 && args
[i
]; ++i
)
1425 if (TREE_CODE (args
[i
]) == INTEGER_CST
)
1427 argrange
[i
][0] = args
[i
];
1428 argrange
[i
][1] = args
[i
];
1430 if (tree_int_cst_lt (args
[i
], integer_zero_node
))
1432 warned
= warning_at (loc
, OPT_Walloc_size_larger_than_
,
1433 "%Kargument %i value %qE is negative",
1434 exp
, idx
[i
] + 1, args
[i
]);
1436 else if (integer_zerop (args
[i
]))
1438 /* Avoid issuing -Walloc-zero for allocation functions other
1439 than __builtin_alloca that are declared with attribute
1440 returns_nonnull because there's no portability risk. This
1441 avoids warning for such calls to libiberty's xmalloc and
1443 Also avoid issuing the warning for calls to function named
1445 if ((DECL_FUNCTION_CODE (fn
) == BUILT_IN_ALLOCA
1446 && IDENTIFIER_LENGTH (DECL_NAME (fn
)) != 6)
1447 || (DECL_FUNCTION_CODE (fn
) != BUILT_IN_ALLOCA
1448 && !lookup_attribute ("returns_nonnull",
1449 TYPE_ATTRIBUTES (TREE_TYPE (fn
)))))
1450 warned
= warning_at (loc
, OPT_Walloc_zero
,
1451 "%Kargument %i value is zero",
1454 else if (tree_int_cst_lt (maxobjsize
, args
[i
]))
1456 /* G++ emits calls to ::operator new[](SIZE_MAX) in C++98
1457 mode and with -fno-exceptions as a way to indicate array
1458 size overflow. There's no good way to detect C++98 here
1459 so avoid diagnosing these calls for all C++ modes. */
1463 && DECL_IS_OPERATOR_NEW (fn
)
1464 && integer_all_onesp (args
[i
]))
1467 warned
= warning_at (loc
, OPT_Walloc_size_larger_than_
,
1468 "%Kargument %i value %qE exceeds "
1469 "maximum object size %E",
1470 exp
, idx
[i
] + 1, args
[i
], maxobjsize
);
1473 else if (TREE_CODE (args
[i
]) == SSA_NAME
1474 && get_size_range (args
[i
], argrange
[i
]))
1476 /* Verify that the argument's range is not negative (including
1477 upper bound of zero). */
1478 if (tree_int_cst_lt (argrange
[i
][0], integer_zero_node
)
1479 && tree_int_cst_le (argrange
[i
][1], integer_zero_node
))
1481 warned
= warning_at (loc
, OPT_Walloc_size_larger_than_
,
1482 "%Kargument %i range [%E, %E] is negative",
1484 argrange
[i
][0], argrange
[i
][1]);
1486 else if (tree_int_cst_lt (maxobjsize
, argrange
[i
][0]))
1488 warned
= warning_at (loc
, OPT_Walloc_size_larger_than_
,
1489 "%Kargument %i range [%E, %E] exceeds "
1490 "maximum object size %E",
1492 argrange
[i
][0], argrange
[i
][1],
1501 /* For a two-argument alloc_size, validate the product of the two
1502 arguments if both of their values or ranges are known. */
1503 if (!warned
&& tree_fits_uhwi_p (argrange
[0][0])
1504 && argrange
[1][0] && tree_fits_uhwi_p (argrange
[1][0])
1505 && !integer_onep (argrange
[0][0])
1506 && !integer_onep (argrange
[1][0]))
1508 /* Check for overflow in the product of a function decorated with
1509 attribute alloc_size (X, Y). */
1510 unsigned szprec
= TYPE_PRECISION (size_type_node
);
1511 wide_int x
= wi::to_wide (argrange
[0][0], szprec
);
1512 wide_int y
= wi::to_wide (argrange
[1][0], szprec
);
1515 wide_int prod
= wi::umul (x
, y
, &vflow
);
1518 warned
= warning_at (loc
, OPT_Walloc_size_larger_than_
,
1519 "%Kproduct %<%E * %E%> of arguments %i and %i "
1520 "exceeds %<SIZE_MAX%>",
1521 exp
, argrange
[0][0], argrange
[1][0],
1522 idx
[0] + 1, idx
[1] + 1);
1523 else if (wi::ltu_p (wi::to_wide (maxobjsize
, szprec
), prod
))
1524 warned
= warning_at (loc
, OPT_Walloc_size_larger_than_
,
1525 "%Kproduct %<%E * %E%> of arguments %i and %i "
1526 "exceeds maximum object size %E",
1527 exp
, argrange
[0][0], argrange
[1][0],
1528 idx
[0] + 1, idx
[1] + 1,
1533 /* Print the full range of each of the two arguments to make
1534 it clear when it is, in fact, in a range and not constant. */
1535 if (argrange
[0][0] != argrange
[0][1])
1536 inform (loc
, "argument %i in the range [%E, %E]",
1537 idx
[0] + 1, argrange
[0][0], argrange
[0][1]);
1538 if (argrange
[1][0] != argrange
[1][1])
1539 inform (loc
, "argument %i in the range [%E, %E]",
1540 idx
[1] + 1, argrange
[1][0], argrange
[1][1]);
1546 location_t fnloc
= DECL_SOURCE_LOCATION (fn
);
1548 if (DECL_IS_BUILTIN (fn
))
1550 "in a call to built-in allocation function %qD", fn
);
1553 "in a call to allocation function %qD declared here", fn
);
1557 /* If EXPR refers to a character array or pointer declared attribute
1558 nonstring return a decl for that array or pointer and set *REF to
1559 the referenced enclosing object or pointer. Otherwise returns
1563 get_attr_nonstring_decl (tree expr
, tree
*ref
)
1566 if (TREE_CODE (decl
) == SSA_NAME
)
1568 gimple
*def
= SSA_NAME_DEF_STMT (decl
);
1570 if (is_gimple_assign (def
))
1572 tree_code code
= gimple_assign_rhs_code (def
);
1573 if (code
== ADDR_EXPR
1574 || code
== COMPONENT_REF
1575 || code
== VAR_DECL
)
1576 decl
= gimple_assign_rhs1 (def
);
1578 else if (tree var
= SSA_NAME_VAR (decl
))
1582 if (TREE_CODE (decl
) == ADDR_EXPR
)
1583 decl
= TREE_OPERAND (decl
, 0);
1588 if (TREE_CODE (decl
) == COMPONENT_REF
)
1589 decl
= TREE_OPERAND (decl
, 1);
1592 && lookup_attribute ("nonstring", DECL_ATTRIBUTES (decl
)))
1598 /* Warn about passing a non-string array/pointer to a function that
1599 expects a nul-terminated string argument. */
1602 maybe_warn_nonstring_arg (tree fndecl
, tree exp
)
1604 if (!fndecl
|| DECL_BUILT_IN_CLASS (fndecl
) != BUILT_IN_NORMAL
)
1607 bool with_bounds
= CALL_WITH_BOUNDS_P (exp
);
1609 /* The bound argument to a bounded string function like strncpy. */
1610 tree bound
= NULL_TREE
;
1612 /* It's safe to call "bounded" string functions with a non-string
1613 argument since the functions provide an explicit bound for this
1615 switch (DECL_FUNCTION_CODE (fndecl
))
1617 case BUILT_IN_STPNCPY
:
1618 case BUILT_IN_STPNCPY_CHK
:
1619 case BUILT_IN_STRNCMP
:
1620 case BUILT_IN_STRNCASECMP
:
1621 case BUILT_IN_STRNCPY
:
1622 case BUILT_IN_STRNCPY_CHK
:
1623 bound
= CALL_EXPR_ARG (exp
, with_bounds
? 4 : 2);
1626 case BUILT_IN_STRNDUP
:
1627 bound
= CALL_EXPR_ARG (exp
, with_bounds
? 2 : 1);
1634 /* Determine the range of the bound argument (if specified). */
1635 tree bndrng
[2] = { NULL_TREE
, NULL_TREE
};
1637 get_size_range (bound
, bndrng
);
1639 /* Iterate over the built-in function's formal arguments and check
1640 each const char* against the actual argument. If the actual
1641 argument is declared attribute non-string issue a warning unless
1642 the argument's maximum length is bounded. */
1643 function_args_iterator it
;
1644 function_args_iter_init (&it
, TREE_TYPE (fndecl
));
1646 for (unsigned argno
= 0; ; ++argno
, function_args_iter_next (&it
))
1648 tree argtype
= function_args_iter_cond (&it
);
1652 if (TREE_CODE (argtype
) != POINTER_TYPE
)
1655 argtype
= TREE_TYPE (argtype
);
1657 if (TREE_CODE (argtype
) != INTEGER_TYPE
1658 || !TYPE_READONLY (argtype
))
1661 argtype
= TYPE_MAIN_VARIANT (argtype
);
1662 if (argtype
!= char_type_node
)
1665 tree callarg
= CALL_EXPR_ARG (exp
, argno
);
1666 if (TREE_CODE (callarg
) == ADDR_EXPR
)
1667 callarg
= TREE_OPERAND (callarg
, 0);
1669 /* See if the destination is declared with attribute "nonstring". */
1670 tree decl
= get_attr_nonstring_decl (callarg
);
1674 tree type
= TREE_TYPE (decl
);
1676 offset_int wibnd
= 0;
1678 wibnd
= wi::to_offset (bndrng
[0]);
1680 offset_int asize
= wibnd
;
1682 if (TREE_CODE (type
) == ARRAY_TYPE
)
1683 if (tree arrbnd
= TYPE_DOMAIN (type
))
1685 if ((arrbnd
= TYPE_MAX_VALUE (arrbnd
)))
1686 asize
= wi::to_offset (arrbnd
) + 1;
1689 location_t loc
= EXPR_LOCATION (exp
);
1691 bool warned
= false;
1693 if (wi::ltu_p (asize
, wibnd
))
1694 warned
= warning_at (loc
, OPT_Wstringop_overflow_
,
1695 "%qD argument %i declared attribute %<nonstring%> "
1696 "is smaller than the specified bound %E",
1697 fndecl
, argno
+ 1, bndrng
[0]);
1699 warned
= warning_at (loc
, OPT_Wstringop_overflow_
,
1700 "%qD argument %i declared attribute %<nonstring%>",
1704 inform (DECL_SOURCE_LOCATION (decl
),
1705 "argument %qD declared here", decl
);
1709 /* Issue an error if CALL_EXPR was flagged as requiring
1710 tall-call optimization. */
1713 maybe_complain_about_tail_call (tree call_expr
, const char *reason
)
1715 gcc_assert (TREE_CODE (call_expr
) == CALL_EXPR
);
1716 if (!CALL_EXPR_MUST_TAIL_CALL (call_expr
))
1719 error_at (EXPR_LOCATION (call_expr
), "cannot tail-call: %s", reason
);
1722 /* Fill in ARGS_SIZE and ARGS array based on the parameters found in
1725 NUM_ACTUALS is the total number of parameters.
1727 N_NAMED_ARGS is the total number of named arguments.
1729 STRUCT_VALUE_ADDR_VALUE is the implicit argument for a struct return
1732 FNDECL is the tree code for the target of this call (if known)
1734 ARGS_SO_FAR holds state needed by the target to know where to place
1737 REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
1738 for arguments which are passed in registers.
1740 OLD_STACK_LEVEL is a pointer to an rtx which olds the old stack level
1741 and may be modified by this routine.
1743 OLD_PENDING_ADJ, MUST_PREALLOCATE and FLAGS are pointers to integer
1744 flags which may be modified by this routine.
1746 MAY_TAILCALL is cleared if we encounter an invisible pass-by-reference
1747 that requires allocation of stack space.
1749 CALL_FROM_THUNK_P is true if this call is the jump from a thunk to
1750 the thunked-to function. */
1753 initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED
,
1754 struct arg_data
*args
,
1755 struct args_size
*args_size
,
1756 int n_named_args ATTRIBUTE_UNUSED
,
1757 tree exp
, tree struct_value_addr_value
,
1758 tree fndecl
, tree fntype
,
1759 cumulative_args_t args_so_far
,
1760 int reg_parm_stack_space
,
1761 rtx
*old_stack_level
,
1762 poly_int64_pod
*old_pending_adj
,
1763 int *must_preallocate
, int *ecf_flags
,
1764 bool *may_tailcall
, bool call_from_thunk_p
)
1766 CUMULATIVE_ARGS
*args_so_far_pnt
= get_cumulative_args (args_so_far
);
1767 location_t loc
= EXPR_LOCATION (exp
);
1769 /* Count arg position in order args appear. */
1774 args_size
->constant
= 0;
1777 bitmap_obstack_initialize (NULL
);
1779 /* In this loop, we consider args in the order they are written.
1780 We fill up ARGS from the back. */
1782 i
= num_actuals
- 1;
1784 int j
= i
, ptr_arg
= -1;
1785 call_expr_arg_iterator iter
;
1787 bitmap slots
= NULL
;
1789 if (struct_value_addr_value
)
1791 args
[j
].tree_value
= struct_value_addr_value
;
1794 /* If we pass structure address then we need to
1795 create bounds for it. Since created bounds is
1796 a call statement, we expand it right here to avoid
1797 fixing all other places where it may be expanded. */
1798 if (CALL_WITH_BOUNDS_P (exp
))
1800 args
[j
].value
= gen_reg_rtx (targetm
.chkp_bound_mode ());
1802 = chkp_make_bounds_for_struct_addr (struct_value_addr_value
);
1803 expand_expr_real (args
[j
].tree_value
, args
[j
].value
, VOIDmode
,
1804 EXPAND_NORMAL
, 0, false);
1805 args
[j
].pointer_arg
= j
+ 1;
1810 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
1812 tree argtype
= TREE_TYPE (arg
);
1814 /* Remember last param with pointer and associate it
1815 with following pointer bounds. */
1816 if (CALL_WITH_BOUNDS_P (exp
)
1817 && chkp_type_has_pointer (argtype
))
1820 BITMAP_FREE (slots
);
1822 if (!BOUNDED_TYPE_P (argtype
))
1824 slots
= BITMAP_ALLOC (NULL
);
1825 chkp_find_bound_slots (argtype
, slots
);
1828 else if (CALL_WITH_BOUNDS_P (exp
)
1829 && pass_by_reference (NULL
, TYPE_MODE (argtype
), argtype
,
1830 argpos
< n_named_args
))
1833 BITMAP_FREE (slots
);
1836 else if (POINTER_BOUNDS_TYPE_P (argtype
))
1838 /* We expect bounds in instrumented calls only.
1839 Otherwise it is a sign we lost flag due to some optimization
1840 and may emit call args incorrectly. */
1841 gcc_assert (CALL_WITH_BOUNDS_P (exp
));
1843 /* For structures look for the next available pointer. */
1844 if (ptr_arg
!= -1 && slots
)
1846 unsigned bnd_no
= bitmap_first_set_bit (slots
);
1847 args
[j
].pointer_offset
=
1848 bnd_no
* POINTER_SIZE
/ BITS_PER_UNIT
;
1850 bitmap_clear_bit (slots
, bnd_no
);
1852 /* Check we have no more pointers in the structure. */
1853 if (bitmap_empty_p (slots
))
1854 BITMAP_FREE (slots
);
1856 args
[j
].pointer_arg
= ptr_arg
;
1858 /* Check we covered all pointers in the previous
1866 if (targetm
.calls
.split_complex_arg
1868 && TREE_CODE (argtype
) == COMPLEX_TYPE
1869 && targetm
.calls
.split_complex_arg (argtype
))
1871 tree subtype
= TREE_TYPE (argtype
);
1872 args
[j
].tree_value
= build1 (REALPART_EXPR
, subtype
, arg
);
1874 args
[j
].tree_value
= build1 (IMAGPART_EXPR
, subtype
, arg
);
1877 args
[j
].tree_value
= arg
;
1883 BITMAP_FREE (slots
);
1886 bitmap_obstack_release (NULL
);
1888 /* Extract attribute alloc_size and if set, store the indices of
1889 the corresponding arguments in ALLOC_IDX, and then the actual
1890 argument(s) at those indices in ALLOC_ARGS. */
1891 int alloc_idx
[2] = { -1, -1 };
1893 = (fndecl
? lookup_attribute ("alloc_size",
1894 TYPE_ATTRIBUTES (TREE_TYPE (fndecl
)))
1897 tree args
= TREE_VALUE (alloc_size
);
1898 alloc_idx
[0] = TREE_INT_CST_LOW (TREE_VALUE (args
)) - 1;
1899 if (TREE_CHAIN (args
))
1900 alloc_idx
[1] = TREE_INT_CST_LOW (TREE_VALUE (TREE_CHAIN (args
))) - 1;
1903 /* Array for up to the two attribute alloc_size arguments. */
1904 tree alloc_args
[] = { NULL_TREE
, NULL_TREE
};
1906 /* I counts args in order (to be) pushed; ARGPOS counts in order written. */
1907 for (argpos
= 0; argpos
< num_actuals
; i
--, argpos
++)
1909 tree type
= TREE_TYPE (args
[i
].tree_value
);
1913 /* Replace erroneous argument with constant zero. */
1914 if (type
== error_mark_node
|| !COMPLETE_TYPE_P (type
))
1915 args
[i
].tree_value
= integer_zero_node
, type
= integer_type_node
;
1917 /* If TYPE is a transparent union or record, pass things the way
1918 we would pass the first field of the union or record. We have
1919 already verified that the modes are the same. */
1920 if ((TREE_CODE (type
) == UNION_TYPE
|| TREE_CODE (type
) == RECORD_TYPE
)
1921 && TYPE_TRANSPARENT_AGGR (type
))
1922 type
= TREE_TYPE (first_field (type
));
1924 /* Decide where to pass this arg.
1926 args[i].reg is nonzero if all or part is passed in registers.
1928 args[i].partial is nonzero if part but not all is passed in registers,
1929 and the exact value says how many bytes are passed in registers.
1931 args[i].pass_on_stack is nonzero if the argument must at least be
1932 computed on the stack. It may then be loaded back into registers
1933 if args[i].reg is nonzero.
1935 These decisions are driven by the FUNCTION_... macros and must agree
1936 with those made by function.c. */
1938 /* See if this argument should be passed by invisible reference. */
1939 if (pass_by_reference (args_so_far_pnt
, TYPE_MODE (type
),
1940 type
, argpos
< n_named_args
))
1943 tree base
= NULL_TREE
;
1946 = reference_callee_copied (args_so_far_pnt
, TYPE_MODE (type
),
1947 type
, argpos
< n_named_args
);
1949 /* If we're compiling a thunk, pass through invisible references
1950 instead of making a copy. */
1951 if (call_from_thunk_p
1953 && !TREE_ADDRESSABLE (type
)
1954 && (base
= get_base_address (args
[i
].tree_value
))
1955 && TREE_CODE (base
) != SSA_NAME
1956 && (!DECL_P (base
) || MEM_P (DECL_RTL (base
)))))
1958 /* We may have turned the parameter value into an SSA name.
1959 Go back to the original parameter so we can take the
1961 if (TREE_CODE (args
[i
].tree_value
) == SSA_NAME
)
1963 gcc_assert (SSA_NAME_IS_DEFAULT_DEF (args
[i
].tree_value
));
1964 args
[i
].tree_value
= SSA_NAME_VAR (args
[i
].tree_value
);
1965 gcc_assert (TREE_CODE (args
[i
].tree_value
) == PARM_DECL
);
1967 /* Argument setup code may have copied the value to register. We
1968 revert that optimization now because the tail call code must
1969 use the original location. */
1970 if (TREE_CODE (args
[i
].tree_value
) == PARM_DECL
1971 && !MEM_P (DECL_RTL (args
[i
].tree_value
))
1972 && DECL_INCOMING_RTL (args
[i
].tree_value
)
1973 && MEM_P (DECL_INCOMING_RTL (args
[i
].tree_value
)))
1974 set_decl_rtl (args
[i
].tree_value
,
1975 DECL_INCOMING_RTL (args
[i
].tree_value
));
1977 mark_addressable (args
[i
].tree_value
);
1979 /* We can't use sibcalls if a callee-copied argument is
1980 stored in the current function's frame. */
1981 if (!call_from_thunk_p
&& DECL_P (base
) && !TREE_STATIC (base
))
1983 *may_tailcall
= false;
1984 maybe_complain_about_tail_call (exp
,
1985 "a callee-copied argument is"
1986 " stored in the current "
1987 " function's frame");
1990 args
[i
].tree_value
= build_fold_addr_expr_loc (loc
,
1991 args
[i
].tree_value
);
1992 type
= TREE_TYPE (args
[i
].tree_value
);
1994 if (*ecf_flags
& ECF_CONST
)
1995 *ecf_flags
&= ~(ECF_CONST
| ECF_LOOPING_CONST_OR_PURE
);
1999 /* We make a copy of the object and pass the address to the
2000 function being called. */
2003 if (!COMPLETE_TYPE_P (type
)
2004 || TREE_CODE (TYPE_SIZE_UNIT (type
)) != INTEGER_CST
2005 || (flag_stack_check
== GENERIC_STACK_CHECK
2006 && compare_tree_int (TYPE_SIZE_UNIT (type
),
2007 STACK_CHECK_MAX_VAR_SIZE
) > 0))
2009 /* This is a variable-sized object. Make space on the stack
2011 rtx size_rtx
= expr_size (args
[i
].tree_value
);
2013 if (*old_stack_level
== 0)
2015 emit_stack_save (SAVE_BLOCK
, old_stack_level
);
2016 *old_pending_adj
= pending_stack_adjust
;
2017 pending_stack_adjust
= 0;
2020 /* We can pass TRUE as the 4th argument because we just
2021 saved the stack pointer and will restore it right after
2023 copy
= allocate_dynamic_stack_space (size_rtx
,
2026 max_int_size_in_bytes
2029 copy
= gen_rtx_MEM (BLKmode
, copy
);
2030 set_mem_attributes (copy
, type
, 1);
2033 copy
= assign_temp (type
, 1, 0);
2035 store_expr (args
[i
].tree_value
, copy
, 0, false, false);
2037 /* Just change the const function to pure and then let
2038 the next test clear the pure based on
2040 if (*ecf_flags
& ECF_CONST
)
2042 *ecf_flags
&= ~ECF_CONST
;
2043 *ecf_flags
|= ECF_PURE
;
2046 if (!callee_copies
&& *ecf_flags
& ECF_PURE
)
2047 *ecf_flags
&= ~(ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
);
2050 = build_fold_addr_expr_loc (loc
, make_tree (type
, copy
));
2051 type
= TREE_TYPE (args
[i
].tree_value
);
2052 *may_tailcall
= false;
2053 maybe_complain_about_tail_call (exp
,
2054 "argument must be passed"
2059 unsignedp
= TYPE_UNSIGNED (type
);
2060 mode
= promote_function_mode (type
, TYPE_MODE (type
), &unsignedp
,
2061 fndecl
? TREE_TYPE (fndecl
) : fntype
, 0);
2063 args
[i
].unsignedp
= unsignedp
;
2064 args
[i
].mode
= mode
;
2066 targetm
.calls
.warn_parameter_passing_abi (args_so_far
, type
);
2068 args
[i
].reg
= targetm
.calls
.function_arg (args_so_far
, mode
, type
,
2069 argpos
< n_named_args
);
2071 if (args
[i
].reg
&& CONST_INT_P (args
[i
].reg
))
2073 args
[i
].special_slot
= args
[i
].reg
;
2077 /* If this is a sibling call and the machine has register windows, the
2078 register window has to be unwinded before calling the routine, so
2079 arguments have to go into the incoming registers. */
2080 if (targetm
.calls
.function_incoming_arg
!= targetm
.calls
.function_arg
)
2081 args
[i
].tail_call_reg
2082 = targetm
.calls
.function_incoming_arg (args_so_far
, mode
, type
,
2083 argpos
< n_named_args
);
2085 args
[i
].tail_call_reg
= args
[i
].reg
;
2089 = targetm
.calls
.arg_partial_bytes (args_so_far
, mode
, type
,
2090 argpos
< n_named_args
);
2092 args
[i
].pass_on_stack
= targetm
.calls
.must_pass_in_stack (mode
, type
);
2094 /* If FUNCTION_ARG returned a (parallel [(expr_list (nil) ...) ...]),
2095 it means that we are to pass this arg in the register(s) designated
2096 by the PARALLEL, but also to pass it in the stack. */
2097 if (args
[i
].reg
&& GET_CODE (args
[i
].reg
) == PARALLEL
2098 && XEXP (XVECEXP (args
[i
].reg
, 0, 0), 0) == 0)
2099 args
[i
].pass_on_stack
= 1;
2101 /* If this is an addressable type, we must preallocate the stack
2102 since we must evaluate the object into its final location.
2104 If this is to be passed in both registers and the stack, it is simpler
2106 if (TREE_ADDRESSABLE (type
)
2107 || (args
[i
].pass_on_stack
&& args
[i
].reg
!= 0))
2108 *must_preallocate
= 1;
2110 /* No stack allocation and padding for bounds. */
2111 if (POINTER_BOUNDS_P (args
[i
].tree_value
))
2113 /* Compute the stack-size of this argument. */
2114 else if (args
[i
].reg
== 0 || args
[i
].partial
!= 0
2115 || reg_parm_stack_space
> 0
2116 || args
[i
].pass_on_stack
)
2117 locate_and_pad_parm (mode
, type
,
2118 #ifdef STACK_PARMS_IN_REG_PARM_AREA
2123 reg_parm_stack_space
,
2124 args
[i
].pass_on_stack
? 0 : args
[i
].partial
,
2125 fndecl
, args_size
, &args
[i
].locate
);
2126 #ifdef BLOCK_REG_PADDING
2128 /* The argument is passed entirely in registers. See at which
2129 end it should be padded. */
2130 args
[i
].locate
.where_pad
=
2131 BLOCK_REG_PADDING (mode
, type
,
2132 int_size_in_bytes (type
) <= UNITS_PER_WORD
);
2135 /* Update ARGS_SIZE, the total stack space for args so far. */
2137 args_size
->constant
+= args
[i
].locate
.size
.constant
;
2138 if (args
[i
].locate
.size
.var
)
2139 ADD_PARM_SIZE (*args_size
, args
[i
].locate
.size
.var
);
2141 /* Increment ARGS_SO_FAR, which has info about which arg-registers
2142 have been used, etc. */
2144 targetm
.calls
.function_arg_advance (args_so_far
, TYPE_MODE (type
),
2145 type
, argpos
< n_named_args
);
2147 /* Store argument values for functions decorated with attribute
2149 if (argpos
== alloc_idx
[0])
2150 alloc_args
[0] = args
[i
].tree_value
;
2151 else if (argpos
== alloc_idx
[1])
2152 alloc_args
[1] = args
[i
].tree_value
;
2157 /* Check the arguments of functions decorated with attribute
2159 maybe_warn_alloc_args_overflow (fndecl
, exp
, alloc_args
, alloc_idx
);
2162 /* Detect passing non-string arguments to functions expecting
2163 nul-terminated strings. */
2164 maybe_warn_nonstring_arg (fndecl
, exp
);
2167 /* Update ARGS_SIZE to contain the total size for the argument block.
2168 Return the original constant component of the argument block's size.
2170 REG_PARM_STACK_SPACE holds the number of bytes of stack space reserved
2171 for arguments passed in registers. */
2174 compute_argument_block_size (int reg_parm_stack_space
,
2175 struct args_size
*args_size
,
2176 tree fndecl ATTRIBUTE_UNUSED
,
2177 tree fntype ATTRIBUTE_UNUSED
,
2178 int preferred_stack_boundary ATTRIBUTE_UNUSED
)
2180 poly_int64 unadjusted_args_size
= args_size
->constant
;
2182 /* For accumulate outgoing args mode we don't need to align, since the frame
2183 will be already aligned. Align to STACK_BOUNDARY in order to prevent
2184 backends from generating misaligned frame sizes. */
2185 if (ACCUMULATE_OUTGOING_ARGS
&& preferred_stack_boundary
> STACK_BOUNDARY
)
2186 preferred_stack_boundary
= STACK_BOUNDARY
;
2188 /* Compute the actual size of the argument block required. The variable
2189 and constant sizes must be combined, the size may have to be rounded,
2190 and there may be a minimum required size. */
2194 args_size
->var
= ARGS_SIZE_TREE (*args_size
);
2195 args_size
->constant
= 0;
2197 preferred_stack_boundary
/= BITS_PER_UNIT
;
2198 if (preferred_stack_boundary
> 1)
2200 /* We don't handle this case yet. To handle it correctly we have
2201 to add the delta, round and subtract the delta.
2202 Currently no machine description requires this support. */
2203 gcc_assert (multiple_p (stack_pointer_delta
,
2204 preferred_stack_boundary
));
2205 args_size
->var
= round_up (args_size
->var
, preferred_stack_boundary
);
2208 if (reg_parm_stack_space
> 0)
2211 = size_binop (MAX_EXPR
, args_size
->var
,
2212 ssize_int (reg_parm_stack_space
));
2214 /* The area corresponding to register parameters is not to count in
2215 the size of the block we need. So make the adjustment. */
2216 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
2218 = size_binop (MINUS_EXPR
, args_size
->var
,
2219 ssize_int (reg_parm_stack_space
));
2224 preferred_stack_boundary
/= BITS_PER_UNIT
;
2225 if (preferred_stack_boundary
< 1)
2226 preferred_stack_boundary
= 1;
2227 args_size
->constant
= (aligned_upper_bound (args_size
->constant
2228 + stack_pointer_delta
,
2229 preferred_stack_boundary
)
2230 - stack_pointer_delta
);
2232 args_size
->constant
= upper_bound (args_size
->constant
,
2233 reg_parm_stack_space
);
2235 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
2236 args_size
->constant
-= reg_parm_stack_space
;
2238 return unadjusted_args_size
;
2241 /* Precompute parameters as needed for a function call.
2243 FLAGS is mask of ECF_* constants.
2245 NUM_ACTUALS is the number of arguments.
2247 ARGS is an array containing information for each argument; this
2248 routine fills in the INITIAL_VALUE and VALUE fields for each
2249 precomputed argument. */
2252 precompute_arguments (int num_actuals
, struct arg_data
*args
)
2256 /* If this is a libcall, then precompute all arguments so that we do not
2257 get extraneous instructions emitted as part of the libcall sequence. */
2259 /* If we preallocated the stack space, and some arguments must be passed
2260 on the stack, then we must precompute any parameter which contains a
2261 function call which will store arguments on the stack.
2262 Otherwise, evaluating the parameter may clobber previous parameters
2263 which have already been stored into the stack. (we have code to avoid
2264 such case by saving the outgoing stack arguments, but it results in
2266 if (!ACCUMULATE_OUTGOING_ARGS
)
2269 for (i
= 0; i
< num_actuals
; i
++)
2274 if (TREE_CODE (args
[i
].tree_value
) != CALL_EXPR
)
2277 /* If this is an addressable type, we cannot pre-evaluate it. */
2278 type
= TREE_TYPE (args
[i
].tree_value
);
2279 gcc_assert (!TREE_ADDRESSABLE (type
));
2281 args
[i
].initial_value
= args
[i
].value
2282 = expand_normal (args
[i
].tree_value
);
2284 mode
= TYPE_MODE (type
);
2285 if (mode
!= args
[i
].mode
)
2287 int unsignedp
= args
[i
].unsignedp
;
2289 = convert_modes (args
[i
].mode
, mode
,
2290 args
[i
].value
, args
[i
].unsignedp
);
2292 /* CSE will replace this only if it contains args[i].value
2293 pseudo, so convert it down to the declared mode using
2295 if (REG_P (args
[i
].value
)
2296 && GET_MODE_CLASS (args
[i
].mode
) == MODE_INT
2297 && promote_mode (type
, mode
, &unsignedp
) != args
[i
].mode
)
2299 args
[i
].initial_value
2300 = gen_lowpart_SUBREG (mode
, args
[i
].value
);
2301 SUBREG_PROMOTED_VAR_P (args
[i
].initial_value
) = 1;
2302 SUBREG_PROMOTED_SET (args
[i
].initial_value
, args
[i
].unsignedp
);
2308 /* Given the current state of MUST_PREALLOCATE and information about
2309 arguments to a function call in NUM_ACTUALS, ARGS and ARGS_SIZE,
2310 compute and return the final value for MUST_PREALLOCATE. */
2313 finalize_must_preallocate (int must_preallocate
, int num_actuals
,
2314 struct arg_data
*args
, struct args_size
*args_size
)
2316 /* See if we have or want to preallocate stack space.
2318 If we would have to push a partially-in-regs parm
2319 before other stack parms, preallocate stack space instead.
2321 If the size of some parm is not a multiple of the required stack
2322 alignment, we must preallocate.
2324 If the total size of arguments that would otherwise create a copy in
2325 a temporary (such as a CALL) is more than half the total argument list
2326 size, preallocation is faster.
2328 Another reason to preallocate is if we have a machine (like the m88k)
2329 where stack alignment is required to be maintained between every
2330 pair of insns, not just when the call is made. However, we assume here
2331 that such machines either do not have push insns (and hence preallocation
2332 would occur anyway) or the problem is taken care of with
2335 if (! must_preallocate
)
2337 int partial_seen
= 0;
2338 poly_int64 copy_to_evaluate_size
= 0;
2341 for (i
= 0; i
< num_actuals
&& ! must_preallocate
; i
++)
2343 if (args
[i
].partial
> 0 && ! args
[i
].pass_on_stack
)
2345 else if (partial_seen
&& args
[i
].reg
== 0)
2346 must_preallocate
= 1;
2347 /* We preallocate in case there are bounds passed
2348 in the bounds table to have precomputed address
2349 for bounds association. */
2350 else if (POINTER_BOUNDS_P (args
[i
].tree_value
)
2352 must_preallocate
= 1;
2354 if (TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)) == BLKmode
2355 && (TREE_CODE (args
[i
].tree_value
) == CALL_EXPR
2356 || TREE_CODE (args
[i
].tree_value
) == TARGET_EXPR
2357 || TREE_CODE (args
[i
].tree_value
) == COND_EXPR
2358 || TREE_ADDRESSABLE (TREE_TYPE (args
[i
].tree_value
))))
2359 copy_to_evaluate_size
2360 += int_size_in_bytes (TREE_TYPE (args
[i
].tree_value
));
2363 if (maybe_ne (args_size
->constant
, 0)
2364 && maybe_ge (copy_to_evaluate_size
* 2, args_size
->constant
))
2365 must_preallocate
= 1;
2367 return must_preallocate
;
2370 /* If we preallocated stack space, compute the address of each argument
2371 and store it into the ARGS array.
2373 We need not ensure it is a valid memory address here; it will be
2374 validized when it is used.
2376 ARGBLOCK is an rtx for the address of the outgoing arguments. */
2379 compute_argument_addresses (struct arg_data
*args
, rtx argblock
, int num_actuals
)
2383 rtx arg_reg
= argblock
;
2385 poly_int64 arg_offset
= 0;
2387 if (GET_CODE (argblock
) == PLUS
)
2389 arg_reg
= XEXP (argblock
, 0);
2390 arg_offset
= rtx_to_poly_int64 (XEXP (argblock
, 1));
2393 for (i
= 0; i
< num_actuals
; i
++)
2395 rtx offset
= ARGS_SIZE_RTX (args
[i
].locate
.offset
);
2396 rtx slot_offset
= ARGS_SIZE_RTX (args
[i
].locate
.slot_offset
);
2398 unsigned int align
, boundary
;
2399 poly_uint64 units_on_stack
= 0;
2400 machine_mode partial_mode
= VOIDmode
;
2402 /* Skip this parm if it will not be passed on the stack. */
2403 if (! args
[i
].pass_on_stack
2405 && args
[i
].partial
== 0)
2408 if (TYPE_EMPTY_P (TREE_TYPE (args
[i
].tree_value
)))
2411 /* Pointer Bounds are never passed on the stack. */
2412 if (POINTER_BOUNDS_P (args
[i
].tree_value
))
2415 addr
= simplify_gen_binary (PLUS
, Pmode
, arg_reg
, offset
);
2416 addr
= plus_constant (Pmode
, addr
, arg_offset
);
2418 if (args
[i
].partial
!= 0)
2420 /* Only part of the parameter is being passed on the stack.
2421 Generate a simple memory reference of the correct size. */
2422 units_on_stack
= args
[i
].locate
.size
.constant
;
2423 poly_uint64 bits_on_stack
= units_on_stack
* BITS_PER_UNIT
;
2424 partial_mode
= int_mode_for_size (bits_on_stack
, 1).else_blk ();
2425 args
[i
].stack
= gen_rtx_MEM (partial_mode
, addr
);
2426 set_mem_size (args
[i
].stack
, units_on_stack
);
2430 args
[i
].stack
= gen_rtx_MEM (args
[i
].mode
, addr
);
2431 set_mem_attributes (args
[i
].stack
,
2432 TREE_TYPE (args
[i
].tree_value
), 1);
2434 align
= BITS_PER_UNIT
;
2435 boundary
= args
[i
].locate
.boundary
;
2436 poly_int64 offset_val
;
2437 if (args
[i
].locate
.where_pad
!= PAD_DOWNWARD
)
2439 else if (poly_int_rtx_p (offset
, &offset_val
))
2441 align
= least_bit_hwi (boundary
);
2442 unsigned int offset_align
2443 = known_alignment (offset_val
) * BITS_PER_UNIT
;
2444 if (offset_align
!= 0)
2445 align
= MIN (align
, offset_align
);
2447 set_mem_align (args
[i
].stack
, align
);
2449 addr
= simplify_gen_binary (PLUS
, Pmode
, arg_reg
, slot_offset
);
2450 addr
= plus_constant (Pmode
, addr
, arg_offset
);
2452 if (args
[i
].partial
!= 0)
2454 /* Only part of the parameter is being passed on the stack.
2455 Generate a simple memory reference of the correct size.
2457 args
[i
].stack_slot
= gen_rtx_MEM (partial_mode
, addr
);
2458 set_mem_size (args
[i
].stack_slot
, units_on_stack
);
2462 args
[i
].stack_slot
= gen_rtx_MEM (args
[i
].mode
, addr
);
2463 set_mem_attributes (args
[i
].stack_slot
,
2464 TREE_TYPE (args
[i
].tree_value
), 1);
2466 set_mem_align (args
[i
].stack_slot
, args
[i
].locate
.boundary
);
2468 /* Function incoming arguments may overlap with sibling call
2469 outgoing arguments and we cannot allow reordering of reads
2470 from function arguments with stores to outgoing arguments
2471 of sibling calls. */
2472 set_mem_alias_set (args
[i
].stack
, 0);
2473 set_mem_alias_set (args
[i
].stack_slot
, 0);
2478 /* Given a FNDECL and EXP, return an rtx suitable for use as a target address
2479 in a call instruction.
2481 FNDECL is the tree node for the target function. For an indirect call
2482 FNDECL will be NULL_TREE.
2484 ADDR is the operand 0 of CALL_EXPR for this call. */
2487 rtx_for_function_call (tree fndecl
, tree addr
)
2491 /* Get the function to call, in the form of RTL. */
2494 if (!TREE_USED (fndecl
) && fndecl
!= current_function_decl
)
2495 TREE_USED (fndecl
) = 1;
2497 /* Get a SYMBOL_REF rtx for the function address. */
2498 funexp
= XEXP (DECL_RTL (fndecl
), 0);
2501 /* Generate an rtx (probably a pseudo-register) for the address. */
2504 funexp
= expand_normal (addr
);
2505 pop_temp_slots (); /* FUNEXP can't be BLKmode. */
2510 /* Return the static chain for this function, if any. */
2513 rtx_for_static_chain (const_tree fndecl_or_type
, bool incoming_p
)
2515 if (DECL_P (fndecl_or_type
) && !DECL_STATIC_CHAIN (fndecl_or_type
))
2518 return targetm
.calls
.static_chain (fndecl_or_type
, incoming_p
);
2521 /* Internal state for internal_arg_pointer_based_exp and its helpers. */
2524 /* Last insn that has been scanned by internal_arg_pointer_based_exp_scan,
2525 or NULL_RTX if none has been scanned yet. */
2526 rtx_insn
*scan_start
;
2527 /* Vector indexed by REGNO - FIRST_PSEUDO_REGISTER, recording if a pseudo is
2528 based on crtl->args.internal_arg_pointer. The element is NULL_RTX if the
2529 pseudo isn't based on it, a CONST_INT offset if the pseudo is based on it
2530 with fixed offset, or PC if this is with variable or unknown offset. */
2532 } internal_arg_pointer_exp_state
;
2534 static rtx
internal_arg_pointer_based_exp (const_rtx
, bool);
2536 /* Helper function for internal_arg_pointer_based_exp. Scan insns in
2537 the tail call sequence, starting with first insn that hasn't been
2538 scanned yet, and note for each pseudo on the LHS whether it is based
2539 on crtl->args.internal_arg_pointer or not, and what offset from that
2540 that pointer it has. */
2543 internal_arg_pointer_based_exp_scan (void)
2545 rtx_insn
*insn
, *scan_start
= internal_arg_pointer_exp_state
.scan_start
;
2547 if (scan_start
== NULL_RTX
)
2548 insn
= get_insns ();
2550 insn
= NEXT_INSN (scan_start
);
2554 rtx set
= single_set (insn
);
2555 if (set
&& REG_P (SET_DEST (set
)) && !HARD_REGISTER_P (SET_DEST (set
)))
2558 unsigned int idx
= REGNO (SET_DEST (set
)) - FIRST_PSEUDO_REGISTER
;
2559 /* Punt on pseudos set multiple times. */
2560 if (idx
< internal_arg_pointer_exp_state
.cache
.length ()
2561 && (internal_arg_pointer_exp_state
.cache
[idx
]
2565 val
= internal_arg_pointer_based_exp (SET_SRC (set
), false);
2566 if (val
!= NULL_RTX
)
2568 if (idx
>= internal_arg_pointer_exp_state
.cache
.length ())
2569 internal_arg_pointer_exp_state
.cache
2570 .safe_grow_cleared (idx
+ 1);
2571 internal_arg_pointer_exp_state
.cache
[idx
] = val
;
2574 if (NEXT_INSN (insn
) == NULL_RTX
)
2576 insn
= NEXT_INSN (insn
);
2579 internal_arg_pointer_exp_state
.scan_start
= scan_start
;
2582 /* Compute whether RTL is based on crtl->args.internal_arg_pointer. Return
2583 NULL_RTX if RTL isn't based on it, a CONST_INT offset if RTL is based on
2584 it with fixed offset, or PC if this is with variable or unknown offset.
2585 TOPLEVEL is true if the function is invoked at the topmost level. */
2588 internal_arg_pointer_based_exp (const_rtx rtl
, bool toplevel
)
2590 if (CONSTANT_P (rtl
))
2593 if (rtl
== crtl
->args
.internal_arg_pointer
)
2596 if (REG_P (rtl
) && HARD_REGISTER_P (rtl
))
2600 if (GET_CODE (rtl
) == PLUS
&& poly_int_rtx_p (XEXP (rtl
, 1), &offset
))
2602 rtx val
= internal_arg_pointer_based_exp (XEXP (rtl
, 0), toplevel
);
2603 if (val
== NULL_RTX
|| val
== pc_rtx
)
2605 return plus_constant (Pmode
, val
, offset
);
2608 /* When called at the topmost level, scan pseudo assignments in between the
2609 last scanned instruction in the tail call sequence and the latest insn
2610 in that sequence. */
2612 internal_arg_pointer_based_exp_scan ();
2616 unsigned int idx
= REGNO (rtl
) - FIRST_PSEUDO_REGISTER
;
2617 if (idx
< internal_arg_pointer_exp_state
.cache
.length ())
2618 return internal_arg_pointer_exp_state
.cache
[idx
];
2623 subrtx_iterator::array_type array
;
2624 FOR_EACH_SUBRTX (iter
, array
, rtl
, NONCONST
)
2626 const_rtx x
= *iter
;
2627 if (REG_P (x
) && internal_arg_pointer_based_exp (x
, false) != NULL_RTX
)
2630 iter
.skip_subrtxes ();
2636 /* Return true if SIZE bytes starting from address ADDR might overlap an
2637 already-clobbered argument area. This function is used to determine
2638 if we should give up a sibcall. */
2641 mem_might_overlap_already_clobbered_arg_p (rtx addr
, poly_uint64 size
)
2644 unsigned HOST_WIDE_INT start
, end
;
2647 if (bitmap_empty_p (stored_args_map
)
2648 && stored_args_watermark
== HOST_WIDE_INT_M1U
)
2650 val
= internal_arg_pointer_based_exp (addr
, true);
2651 if (val
== NULL_RTX
)
2653 else if (!poly_int_rtx_p (val
, &i
))
2656 if (known_eq (size
, 0U))
2659 if (STACK_GROWS_DOWNWARD
)
2660 i
-= crtl
->args
.pretend_args_size
;
2662 i
+= crtl
->args
.pretend_args_size
;
2664 if (ARGS_GROW_DOWNWARD
)
2667 /* We can ignore any references to the function's pretend args,
2668 which at this point would manifest as negative values of I. */
2669 if (known_le (i
, 0) && known_le (size
, poly_uint64 (-i
)))
2672 start
= maybe_lt (i
, 0) ? 0 : constant_lower_bound (i
);
2673 if (!(i
+ size
).is_constant (&end
))
2674 end
= HOST_WIDE_INT_M1U
;
2676 if (end
> stored_args_watermark
)
2679 end
= MIN (end
, SBITMAP_SIZE (stored_args_map
));
2680 for (unsigned HOST_WIDE_INT k
= start
; k
< end
; ++k
)
2681 if (bitmap_bit_p (stored_args_map
, k
))
2687 /* Do the register loads required for any wholly-register parms or any
2688 parms which are passed both on the stack and in a register. Their
2689 expressions were already evaluated.
2691 Mark all register-parms as living through the call, putting these USE
2692 insns in the CALL_INSN_FUNCTION_USAGE field.
2694 When IS_SIBCALL, perform the check_sibcall_argument_overlap
2695 checking, setting *SIBCALL_FAILURE if appropriate. */
2698 load_register_parameters (struct arg_data
*args
, int num_actuals
,
2699 rtx
*call_fusage
, int flags
, int is_sibcall
,
2700 int *sibcall_failure
)
2704 for (i
= 0; i
< num_actuals
; i
++)
2706 rtx reg
= ((flags
& ECF_SIBCALL
)
2707 ? args
[i
].tail_call_reg
: args
[i
].reg
);
2710 int partial
= args
[i
].partial
;
2712 poly_int64 size
= 0;
2713 HOST_WIDE_INT const_size
= 0;
2714 rtx_insn
*before_arg
= get_last_insn ();
2715 /* Set non-negative if we must move a word at a time, even if
2716 just one word (e.g, partial == 4 && mode == DFmode). Set
2717 to -1 if we just use a normal move insn. This value can be
2718 zero if the argument is a zero size structure. */
2720 if (GET_CODE (reg
) == PARALLEL
)
2724 gcc_assert (partial
% UNITS_PER_WORD
== 0);
2725 nregs
= partial
/ UNITS_PER_WORD
;
2727 else if (TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)) == BLKmode
)
2729 /* Variable-sized parameters should be described by a
2730 PARALLEL instead. */
2731 const_size
= int_size_in_bytes (TREE_TYPE (args
[i
].tree_value
));
2732 gcc_assert (const_size
>= 0);
2733 nregs
= (const_size
+ (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
;
2737 size
= GET_MODE_SIZE (args
[i
].mode
);
2739 /* Handle calls that pass values in multiple non-contiguous
2740 locations. The Irix 6 ABI has examples of this. */
2742 if (GET_CODE (reg
) == PARALLEL
)
2743 emit_group_move (reg
, args
[i
].parallel_value
);
2745 /* If simple case, just do move. If normal partial, store_one_arg
2746 has already loaded the register for us. In all other cases,
2747 load the register(s) from memory. */
2749 else if (nregs
== -1)
2751 emit_move_insn (reg
, args
[i
].value
);
2752 #ifdef BLOCK_REG_PADDING
2753 /* Handle case where we have a value that needs shifting
2754 up to the msb. eg. a QImode value and we're padding
2755 upward on a BYTES_BIG_ENDIAN machine. */
2756 if (args
[i
].locate
.where_pad
2757 == (BYTES_BIG_ENDIAN
? PAD_UPWARD
: PAD_DOWNWARD
))
2759 gcc_checking_assert (ordered_p (size
, UNITS_PER_WORD
));
2760 if (maybe_lt (size
, UNITS_PER_WORD
))
2764 = (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
2766 /* Assigning REG here rather than a temp makes
2767 CALL_FUSAGE report the whole reg as used.
2768 Strictly speaking, the call only uses SIZE
2769 bytes at the msb end, but it doesn't seem worth
2770 generating rtl to say that. */
2771 reg
= gen_rtx_REG (word_mode
, REGNO (reg
));
2772 x
= expand_shift (LSHIFT_EXPR
, word_mode
,
2773 reg
, shift
, reg
, 1);
2775 emit_move_insn (reg
, x
);
2781 /* If we have pre-computed the values to put in the registers in
2782 the case of non-aligned structures, copy them in now. */
2784 else if (args
[i
].n_aligned_regs
!= 0)
2785 for (j
= 0; j
< args
[i
].n_aligned_regs
; j
++)
2786 emit_move_insn (gen_rtx_REG (word_mode
, REGNO (reg
) + j
),
2787 args
[i
].aligned_regs
[j
]);
2789 else if (partial
== 0 || args
[i
].pass_on_stack
)
2791 /* SIZE and CONST_SIZE are 0 for partial arguments and
2792 the size of a BLKmode type otherwise. */
2793 gcc_checking_assert (known_eq (size
, const_size
));
2794 rtx mem
= validize_mem (copy_rtx (args
[i
].value
));
2796 /* Check for overlap with already clobbered argument area,
2797 providing that this has non-zero size. */
2800 && (mem_might_overlap_already_clobbered_arg_p
2801 (XEXP (args
[i
].value
, 0), const_size
)))
2802 *sibcall_failure
= 1;
2804 if (const_size
% UNITS_PER_WORD
== 0
2805 || MEM_ALIGN (mem
) % BITS_PER_WORD
== 0)
2806 move_block_to_reg (REGNO (reg
), mem
, nregs
, args
[i
].mode
);
2810 move_block_to_reg (REGNO (reg
), mem
, nregs
- 1,
2812 rtx dest
= gen_rtx_REG (word_mode
, REGNO (reg
) + nregs
- 1);
2813 unsigned int bitoff
= (nregs
- 1) * BITS_PER_WORD
;
2814 unsigned int bitsize
= const_size
* BITS_PER_UNIT
- bitoff
;
2815 rtx x
= extract_bit_field (mem
, bitsize
, bitoff
, 1, dest
,
2816 word_mode
, word_mode
, false,
2818 if (BYTES_BIG_ENDIAN
)
2819 x
= expand_shift (LSHIFT_EXPR
, word_mode
, x
,
2820 BITS_PER_WORD
- bitsize
, dest
, 1);
2822 emit_move_insn (dest
, x
);
2825 /* Handle a BLKmode that needs shifting. */
2826 if (nregs
== 1 && const_size
< UNITS_PER_WORD
2827 #ifdef BLOCK_REG_PADDING
2828 && args
[i
].locate
.where_pad
== PAD_DOWNWARD
2834 rtx dest
= gen_rtx_REG (word_mode
, REGNO (reg
));
2835 int shift
= (UNITS_PER_WORD
- const_size
) * BITS_PER_UNIT
;
2836 enum tree_code dir
= (BYTES_BIG_ENDIAN
2837 ? RSHIFT_EXPR
: LSHIFT_EXPR
);
2840 x
= expand_shift (dir
, word_mode
, dest
, shift
, dest
, 1);
2842 emit_move_insn (dest
, x
);
2846 /* When a parameter is a block, and perhaps in other cases, it is
2847 possible that it did a load from an argument slot that was
2848 already clobbered. */
2850 && check_sibcall_argument_overlap (before_arg
, &args
[i
], 0))
2851 *sibcall_failure
= 1;
2853 /* Handle calls that pass values in multiple non-contiguous
2854 locations. The Irix 6 ABI has examples of this. */
2855 if (GET_CODE (reg
) == PARALLEL
)
2856 use_group_regs (call_fusage
, reg
);
2857 else if (nregs
== -1)
2858 use_reg_mode (call_fusage
, reg
,
2859 TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)));
2861 use_regs (call_fusage
, REGNO (reg
), nregs
);
2866 /* We need to pop PENDING_STACK_ADJUST bytes. But, if the arguments
2867 wouldn't fill up an even multiple of PREFERRED_UNIT_STACK_BOUNDARY
2868 bytes, then we would need to push some additional bytes to pad the
2869 arguments. So, we try to compute an adjust to the stack pointer for an
2870 amount that will leave the stack under-aligned by UNADJUSTED_ARGS_SIZE
2871 bytes. Then, when the arguments are pushed the stack will be perfectly
2874 Return true if this optimization is possible, storing the adjustment
2875 in ADJUSTMENT_OUT and setting ARGS_SIZE->CONSTANT to the number of
2876 bytes that should be popped after the call. */
2879 combine_pending_stack_adjustment_and_call (poly_int64_pod
*adjustment_out
,
2880 poly_int64 unadjusted_args_size
,
2881 struct args_size
*args_size
,
2882 unsigned int preferred_unit_stack_boundary
)
2884 /* The number of bytes to pop so that the stack will be
2885 under-aligned by UNADJUSTED_ARGS_SIZE bytes. */
2886 poly_int64 adjustment
;
2887 /* The alignment of the stack after the arguments are pushed, if we
2888 just pushed the arguments without adjust the stack here. */
2889 unsigned HOST_WIDE_INT unadjusted_alignment
;
2891 if (!known_misalignment (stack_pointer_delta
+ unadjusted_args_size
,
2892 preferred_unit_stack_boundary
,
2893 &unadjusted_alignment
))
2896 /* We want to get rid of as many of the PENDING_STACK_ADJUST bytes
2897 as possible -- leaving just enough left to cancel out the
2898 UNADJUSTED_ALIGNMENT. In other words, we want to ensure that the
2899 PENDING_STACK_ADJUST is non-negative, and congruent to
2900 -UNADJUSTED_ALIGNMENT modulo the PREFERRED_UNIT_STACK_BOUNDARY. */
2902 /* Begin by trying to pop all the bytes. */
2903 unsigned HOST_WIDE_INT tmp_misalignment
;
2904 if (!known_misalignment (pending_stack_adjust
,
2905 preferred_unit_stack_boundary
,
2908 unadjusted_alignment
-= tmp_misalignment
;
2909 adjustment
= pending_stack_adjust
;
2910 /* Push enough additional bytes that the stack will be aligned
2911 after the arguments are pushed. */
2912 if (preferred_unit_stack_boundary
> 1 && unadjusted_alignment
)
2913 adjustment
-= preferred_unit_stack_boundary
- unadjusted_alignment
;
2915 /* We need to know whether the adjusted argument size
2916 (UNADJUSTED_ARGS_SIZE - ADJUSTMENT) constitutes an allocation
2917 or a deallocation. */
2918 if (!ordered_p (adjustment
, unadjusted_args_size
))
2921 /* Now, sets ARGS_SIZE->CONSTANT so that we pop the right number of
2922 bytes after the call. The right number is the entire
2923 PENDING_STACK_ADJUST less our ADJUSTMENT plus the amount required
2924 by the arguments in the first place. */
2926 = pending_stack_adjust
- adjustment
+ unadjusted_args_size
;
2928 *adjustment_out
= adjustment
;
2932 /* Scan X expression if it does not dereference any argument slots
2933 we already clobbered by tail call arguments (as noted in stored_args_map
2935 Return nonzero if X expression dereferences such argument slots,
2939 check_sibcall_argument_overlap_1 (rtx x
)
2948 code
= GET_CODE (x
);
2950 /* We need not check the operands of the CALL expression itself. */
2955 return (mem_might_overlap_already_clobbered_arg_p
2956 (XEXP (x
, 0), GET_MODE_SIZE (GET_MODE (x
))));
2958 /* Scan all subexpressions. */
2959 fmt
= GET_RTX_FORMAT (code
);
2960 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++, fmt
++)
2964 if (check_sibcall_argument_overlap_1 (XEXP (x
, i
)))
2967 else if (*fmt
== 'E')
2969 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
2970 if (check_sibcall_argument_overlap_1 (XVECEXP (x
, i
, j
)))
2977 /* Scan sequence after INSN if it does not dereference any argument slots
2978 we already clobbered by tail call arguments (as noted in stored_args_map
2979 bitmap). If MARK_STORED_ARGS_MAP, add stack slots for ARG to
2980 stored_args_map bitmap afterwards (when ARG is a register MARK_STORED_ARGS_MAP
2981 should be 0). Return nonzero if sequence after INSN dereferences such argument
2982 slots, zero otherwise. */
2985 check_sibcall_argument_overlap (rtx_insn
*insn
, struct arg_data
*arg
,
2986 int mark_stored_args_map
)
2988 poly_uint64 low
, high
;
2989 unsigned HOST_WIDE_INT const_low
, const_high
;
2991 if (insn
== NULL_RTX
)
2992 insn
= get_insns ();
2994 insn
= NEXT_INSN (insn
);
2996 for (; insn
; insn
= NEXT_INSN (insn
))
2998 && check_sibcall_argument_overlap_1 (PATTERN (insn
)))
3001 if (mark_stored_args_map
)
3003 if (ARGS_GROW_DOWNWARD
)
3004 low
= -arg
->locate
.slot_offset
.constant
- arg
->locate
.size
.constant
;
3006 low
= arg
->locate
.slot_offset
.constant
;
3007 high
= low
+ arg
->locate
.size
.constant
;
3009 const_low
= constant_lower_bound (low
);
3010 if (high
.is_constant (&const_high
))
3011 for (unsigned HOST_WIDE_INT i
= const_low
; i
< const_high
; ++i
)
3012 bitmap_set_bit (stored_args_map
, i
);
3014 stored_args_watermark
= MIN (stored_args_watermark
, const_low
);
3016 return insn
!= NULL_RTX
;
3019 /* Given that a function returns a value of mode MODE at the most
3020 significant end of hard register VALUE, shift VALUE left or right
3021 as specified by LEFT_P. Return true if some action was needed. */
3024 shift_return_value (machine_mode mode
, bool left_p
, rtx value
)
3026 HOST_WIDE_INT shift
;
3028 gcc_assert (REG_P (value
) && HARD_REGISTER_P (value
));
3029 machine_mode value_mode
= GET_MODE (value
);
3030 shift
= GET_MODE_BITSIZE (value_mode
) - GET_MODE_BITSIZE (mode
);
3034 /* Use ashr rather than lshr for right shifts. This is for the benefit
3035 of the MIPS port, which requires SImode values to be sign-extended
3036 when stored in 64-bit registers. */
3037 if (!force_expand_binop (value_mode
, left_p
? ashl_optab
: ashr_optab
,
3038 value
, gen_int_shift_amount (value_mode
, shift
),
3039 value
, 1, OPTAB_WIDEN
))
3044 /* If X is a likely-spilled register value, copy it to a pseudo
3045 register and return that register. Return X otherwise. */
3048 avoid_likely_spilled_reg (rtx x
)
3053 && HARD_REGISTER_P (x
)
3054 && targetm
.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (x
))))
3056 /* Make sure that we generate a REG rather than a CONCAT.
3057 Moves into CONCATs can need nontrivial instructions,
3058 and the whole point of this function is to avoid
3059 using the hard register directly in such a situation. */
3060 generating_concat_p
= 0;
3061 new_rtx
= gen_reg_rtx (GET_MODE (x
));
3062 generating_concat_p
= 1;
3063 emit_move_insn (new_rtx
, x
);
3069 /* Helper function for expand_call.
3070 Return false is EXP is not implementable as a sibling call. */
3073 can_implement_as_sibling_call_p (tree exp
,
3074 rtx structure_value_addr
,
3076 int reg_parm_stack_space ATTRIBUTE_UNUSED
,
3080 const args_size
&args_size
)
3082 if (!targetm
.have_sibcall_epilogue ())
3084 maybe_complain_about_tail_call
3086 "machine description does not have"
3087 " a sibcall_epilogue instruction pattern");
3091 /* Doing sibling call optimization needs some work, since
3092 structure_value_addr can be allocated on the stack.
3093 It does not seem worth the effort since few optimizable
3094 sibling calls will return a structure. */
3095 if (structure_value_addr
!= NULL_RTX
)
3097 maybe_complain_about_tail_call (exp
, "callee returns a structure");
3101 #ifdef REG_PARM_STACK_SPACE
3102 /* If outgoing reg parm stack space changes, we can not do sibcall. */
3103 if (OUTGOING_REG_PARM_STACK_SPACE (funtype
)
3104 != OUTGOING_REG_PARM_STACK_SPACE (TREE_TYPE (current_function_decl
))
3105 || (reg_parm_stack_space
!= REG_PARM_STACK_SPACE (current_function_decl
)))
3107 maybe_complain_about_tail_call (exp
,
3108 "inconsistent size of stack space"
3109 " allocated for arguments which are"
3110 " passed in registers");
3115 /* Check whether the target is able to optimize the call
3117 if (!targetm
.function_ok_for_sibcall (fndecl
, exp
))
3119 maybe_complain_about_tail_call (exp
,
3120 "target is not able to optimize the"
3121 " call into a sibling call");
3125 /* Functions that do not return exactly once may not be sibcall
3127 if (flags
& ECF_RETURNS_TWICE
)
3129 maybe_complain_about_tail_call (exp
, "callee returns twice");
3132 if (flags
& ECF_NORETURN
)
3134 maybe_complain_about_tail_call (exp
, "callee does not return");
3138 if (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (addr
))))
3140 maybe_complain_about_tail_call (exp
, "volatile function type");
3144 /* If the called function is nested in the current one, it might access
3145 some of the caller's arguments, but could clobber them beforehand if
3146 the argument areas are shared. */
3147 if (fndecl
&& decl_function_context (fndecl
) == current_function_decl
)
3149 maybe_complain_about_tail_call (exp
, "nested function");
3153 /* If this function requires more stack slots than the current
3154 function, we cannot change it into a sibling call.
3155 crtl->args.pretend_args_size is not part of the
3156 stack allocated by our caller. */
3157 if (maybe_gt (args_size
.constant
,
3158 crtl
->args
.size
- crtl
->args
.pretend_args_size
))
3160 maybe_complain_about_tail_call (exp
,
3161 "callee required more stack slots"
3162 " than the caller");
3166 /* If the callee pops its own arguments, then it must pop exactly
3167 the same number of arguments as the current function. */
3168 if (maybe_ne (targetm
.calls
.return_pops_args (fndecl
, funtype
,
3169 args_size
.constant
),
3170 targetm
.calls
.return_pops_args (current_function_decl
,
3172 (current_function_decl
),
3175 maybe_complain_about_tail_call (exp
,
3176 "inconsistent number of"
3177 " popped arguments");
3181 if (!lang_hooks
.decls
.ok_for_sibcall (fndecl
))
3183 maybe_complain_about_tail_call (exp
, "frontend does not support"
3188 /* All checks passed. */
3192 /* Generate all the code for a CALL_EXPR exp
3193 and return an rtx for its value.
3194 Store the value in TARGET (specified as an rtx) if convenient.
3195 If the value is stored in TARGET then TARGET is returned.
3196 If IGNORE is nonzero, then we ignore the value of the function call. */
3199 expand_call (tree exp
, rtx target
, int ignore
)
3201 /* Nonzero if we are currently expanding a call. */
3202 static int currently_expanding_call
= 0;
3204 /* RTX for the function to be called. */
3206 /* Sequence of insns to perform a normal "call". */
3207 rtx_insn
*normal_call_insns
= NULL
;
3208 /* Sequence of insns to perform a tail "call". */
3209 rtx_insn
*tail_call_insns
= NULL
;
3210 /* Data type of the function. */
3212 tree type_arg_types
;
3214 /* Declaration of the function being called,
3215 or 0 if the function is computed (not known by name). */
3217 /* The type of the function being called. */
3219 bool try_tail_call
= CALL_EXPR_TAILCALL (exp
);
3220 bool must_tail_call
= CALL_EXPR_MUST_TAIL_CALL (exp
);
3223 /* Register in which non-BLKmode value will be returned,
3224 or 0 if no value or if value is BLKmode. */
3226 /* Register(s) in which bounds are returned. */
3228 /* Address where we should return a BLKmode value;
3229 0 if value not BLKmode. */
3230 rtx structure_value_addr
= 0;
3231 /* Nonzero if that address is being passed by treating it as
3232 an extra, implicit first parameter. Otherwise,
3233 it is passed by being copied directly into struct_value_rtx. */
3234 int structure_value_addr_parm
= 0;
3235 /* Holds the value of implicit argument for the struct value. */
3236 tree structure_value_addr_value
= NULL_TREE
;
3237 /* Size of aggregate value wanted, or zero if none wanted
3238 or if we are using the non-reentrant PCC calling convention
3239 or expecting the value in registers. */
3240 HOST_WIDE_INT struct_value_size
= 0;
3241 /* Nonzero if called function returns an aggregate in memory PCC style,
3242 by returning the address of where to find it. */
3243 int pcc_struct_value
= 0;
3244 rtx struct_value
= 0;
3246 /* Number of actual parameters in this call, including struct value addr. */
3248 /* Number of named args. Args after this are anonymous ones
3249 and they must all go on the stack. */
3251 /* Number of complex actual arguments that need to be split. */
3252 int num_complex_actuals
= 0;
3254 /* Vector of information about each argument.
3255 Arguments are numbered in the order they will be pushed,
3256 not the order they are written. */
3257 struct arg_data
*args
;
3259 /* Total size in bytes of all the stack-parms scanned so far. */
3260 struct args_size args_size
;
3261 struct args_size adjusted_args_size
;
3262 /* Size of arguments before any adjustments (such as rounding). */
3263 poly_int64 unadjusted_args_size
;
3264 /* Data on reg parms scanned so far. */
3265 CUMULATIVE_ARGS args_so_far_v
;
3266 cumulative_args_t args_so_far
;
3267 /* Nonzero if a reg parm has been scanned. */
3269 /* Nonzero if this is an indirect function call. */
3271 /* Nonzero if we must avoid push-insns in the args for this call.
3272 If stack space is allocated for register parameters, but not by the
3273 caller, then it is preallocated in the fixed part of the stack frame.
3274 So the entire argument block must then be preallocated (i.e., we
3275 ignore PUSH_ROUNDING in that case). */
3277 int must_preallocate
= !PUSH_ARGS
;
3279 /* Size of the stack reserved for parameter registers. */
3280 int reg_parm_stack_space
= 0;
3282 /* Address of space preallocated for stack parms
3283 (on machines that lack push insns), or 0 if space not preallocated. */
3286 /* Mask of ECF_ and ERF_ flags. */
3288 int return_flags
= 0;
3289 #ifdef REG_PARM_STACK_SPACE
3290 /* Define the boundary of the register parm stack space that needs to be
3292 int low_to_save
, high_to_save
;
3293 rtx save_area
= 0; /* Place that it is saved */
3296 unsigned int initial_highest_arg_in_use
= highest_outgoing_arg_in_use
;
3297 char *initial_stack_usage_map
= stack_usage_map
;
3298 unsigned HOST_WIDE_INT initial_stack_usage_watermark
= stack_usage_watermark
;
3299 char *stack_usage_map_buf
= NULL
;
3301 poly_int64 old_stack_allocated
;
3303 /* State variables to track stack modifications. */
3304 rtx old_stack_level
= 0;
3305 int old_stack_arg_under_construction
= 0;
3306 poly_int64 old_pending_adj
= 0;
3307 int old_inhibit_defer_pop
= inhibit_defer_pop
;
3309 /* Some stack pointer alterations we make are performed via
3310 allocate_dynamic_stack_space. This modifies the stack_pointer_delta,
3311 which we then also need to save/restore along the way. */
3312 poly_int64 old_stack_pointer_delta
= 0;
3315 tree addr
= CALL_EXPR_FN (exp
);
3317 /* The alignment of the stack, in bits. */
3318 unsigned HOST_WIDE_INT preferred_stack_boundary
;
3319 /* The alignment of the stack, in bytes. */
3320 unsigned HOST_WIDE_INT preferred_unit_stack_boundary
;
3321 /* The static chain value to use for this call. */
3322 rtx static_chain_value
;
3323 /* See if this is "nothrow" function call. */
3324 if (TREE_NOTHROW (exp
))
3325 flags
|= ECF_NOTHROW
;
3327 /* See if we can find a DECL-node for the actual function, and get the
3328 function attributes (flags) from the function decl or type node. */
3329 fndecl
= get_callee_fndecl (exp
);
3332 fntype
= TREE_TYPE (fndecl
);
3333 flags
|= flags_from_decl_or_type (fndecl
);
3334 return_flags
|= decl_return_flags (fndecl
);
3338 fntype
= TREE_TYPE (TREE_TYPE (addr
));
3339 flags
|= flags_from_decl_or_type (fntype
);
3340 if (CALL_EXPR_BY_DESCRIPTOR (exp
))
3341 flags
|= ECF_BY_DESCRIPTOR
;
3343 rettype
= TREE_TYPE (exp
);
3345 struct_value
= targetm
.calls
.struct_value_rtx (fntype
, 0);
3347 /* Warn if this value is an aggregate type,
3348 regardless of which calling convention we are using for it. */
3349 if (AGGREGATE_TYPE_P (rettype
))
3350 warning (OPT_Waggregate_return
, "function call has aggregate value");
3352 /* If the result of a non looping pure or const function call is
3353 ignored (or void), and none of its arguments are volatile, we can
3354 avoid expanding the call and just evaluate the arguments for
3356 if ((flags
& (ECF_CONST
| ECF_PURE
))
3357 && (!(flags
& ECF_LOOPING_CONST_OR_PURE
))
3358 && (ignore
|| target
== const0_rtx
3359 || TYPE_MODE (rettype
) == VOIDmode
))
3361 bool volatilep
= false;
3363 call_expr_arg_iterator iter
;
3365 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
3366 if (TREE_THIS_VOLATILE (arg
))
3374 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
3375 expand_expr (arg
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3380 #ifdef REG_PARM_STACK_SPACE
3381 reg_parm_stack_space
= REG_PARM_STACK_SPACE (!fndecl
? fntype
: fndecl
);
3384 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
)))
3385 && reg_parm_stack_space
> 0 && PUSH_ARGS
)
3386 must_preallocate
= 1;
3388 /* Set up a place to return a structure. */
3390 /* Cater to broken compilers. */
3391 if (aggregate_value_p (exp
, fntype
))
3393 /* This call returns a big structure. */
3394 flags
&= ~(ECF_CONST
| ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
);
3396 #ifdef PCC_STATIC_STRUCT_RETURN
3398 pcc_struct_value
= 1;
3400 #else /* not PCC_STATIC_STRUCT_RETURN */
3402 struct_value_size
= int_size_in_bytes (rettype
);
3404 /* Even if it is semantically safe to use the target as the return
3405 slot, it may be not sufficiently aligned for the return type. */
3406 if (CALL_EXPR_RETURN_SLOT_OPT (exp
)
3409 && !(MEM_ALIGN (target
) < TYPE_ALIGN (rettype
)
3410 && targetm
.slow_unaligned_access (TYPE_MODE (rettype
),
3411 MEM_ALIGN (target
))))
3412 structure_value_addr
= XEXP (target
, 0);
3415 /* For variable-sized objects, we must be called with a target
3416 specified. If we were to allocate space on the stack here,
3417 we would have no way of knowing when to free it. */
3418 rtx d
= assign_temp (rettype
, 1, 1);
3419 structure_value_addr
= XEXP (d
, 0);
3423 #endif /* not PCC_STATIC_STRUCT_RETURN */
3426 /* Figure out the amount to which the stack should be aligned. */
3427 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
3430 struct cgraph_rtl_info
*i
= cgraph_node::rtl_info (fndecl
);
3431 /* Without automatic stack alignment, we can't increase preferred
3432 stack boundary. With automatic stack alignment, it is
3433 unnecessary since unless we can guarantee that all callers will
3434 align the outgoing stack properly, callee has to align its
3437 && i
->preferred_incoming_stack_boundary
3438 && i
->preferred_incoming_stack_boundary
< preferred_stack_boundary
)
3439 preferred_stack_boundary
= i
->preferred_incoming_stack_boundary
;
3442 /* Operand 0 is a pointer-to-function; get the type of the function. */
3443 funtype
= TREE_TYPE (addr
);
3444 gcc_assert (POINTER_TYPE_P (funtype
));
3445 funtype
= TREE_TYPE (funtype
);
3447 /* Count whether there are actual complex arguments that need to be split
3448 into their real and imaginary parts. Munge the type_arg_types
3449 appropriately here as well. */
3450 if (targetm
.calls
.split_complex_arg
)
3452 call_expr_arg_iterator iter
;
3454 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
3456 tree type
= TREE_TYPE (arg
);
3457 if (type
&& TREE_CODE (type
) == COMPLEX_TYPE
3458 && targetm
.calls
.split_complex_arg (type
))
3459 num_complex_actuals
++;
3461 type_arg_types
= split_complex_types (TYPE_ARG_TYPES (funtype
));
3464 type_arg_types
= TYPE_ARG_TYPES (funtype
);
3466 if (flags
& ECF_MAY_BE_ALLOCA
)
3467 cfun
->calls_alloca
= 1;
3469 /* If struct_value_rtx is 0, it means pass the address
3470 as if it were an extra parameter. Put the argument expression
3471 in structure_value_addr_value. */
3472 if (structure_value_addr
&& struct_value
== 0)
3474 /* If structure_value_addr is a REG other than
3475 virtual_outgoing_args_rtx, we can use always use it. If it
3476 is not a REG, we must always copy it into a register.
3477 If it is virtual_outgoing_args_rtx, we must copy it to another
3478 register in some cases. */
3479 rtx temp
= (!REG_P (structure_value_addr
)
3480 || (ACCUMULATE_OUTGOING_ARGS
3481 && stack_arg_under_construction
3482 && structure_value_addr
== virtual_outgoing_args_rtx
)
3483 ? copy_addr_to_reg (convert_memory_address
3484 (Pmode
, structure_value_addr
))
3485 : structure_value_addr
);
3487 structure_value_addr_value
=
3488 make_tree (build_pointer_type (TREE_TYPE (funtype
)), temp
);
3489 structure_value_addr_parm
= CALL_WITH_BOUNDS_P (exp
) ? 2 : 1;
3492 /* Count the arguments and set NUM_ACTUALS. */
3494 call_expr_nargs (exp
) + num_complex_actuals
+ structure_value_addr_parm
;
3496 /* Compute number of named args.
3497 First, do a raw count of the args for INIT_CUMULATIVE_ARGS. */
3499 if (type_arg_types
!= 0)
3501 = (list_length (type_arg_types
)
3502 /* Count the struct value address, if it is passed as a parm. */
3503 + structure_value_addr_parm
);
3505 /* If we know nothing, treat all args as named. */
3506 n_named_args
= num_actuals
;
3508 /* Start updating where the next arg would go.
3510 On some machines (such as the PA) indirect calls have a different
3511 calling convention than normal calls. The fourth argument in
3512 INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
3514 INIT_CUMULATIVE_ARGS (args_so_far_v
, funtype
, NULL_RTX
, fndecl
, n_named_args
);
3515 args_so_far
= pack_cumulative_args (&args_so_far_v
);
3517 /* Now possibly adjust the number of named args.
3518 Normally, don't include the last named arg if anonymous args follow.
3519 We do include the last named arg if
3520 targetm.calls.strict_argument_naming() returns nonzero.
3521 (If no anonymous args follow, the result of list_length is actually
3522 one too large. This is harmless.)
3524 If targetm.calls.pretend_outgoing_varargs_named() returns
3525 nonzero, and targetm.calls.strict_argument_naming() returns zero,
3526 this machine will be able to place unnamed args that were passed
3527 in registers into the stack. So treat all args as named. This
3528 allows the insns emitting for a specific argument list to be
3529 independent of the function declaration.
3531 If targetm.calls.pretend_outgoing_varargs_named() returns zero,
3532 we do not have any reliable way to pass unnamed args in
3533 registers, so we must force them into memory. */
3535 if (type_arg_types
!= 0
3536 && targetm
.calls
.strict_argument_naming (args_so_far
))
3538 else if (type_arg_types
!= 0
3539 && ! targetm
.calls
.pretend_outgoing_varargs_named (args_so_far
))
3540 /* Don't include the last named arg. */
3543 /* Treat all args as named. */
3544 n_named_args
= num_actuals
;
3546 /* Make a vector to hold all the information about each arg. */
3547 args
= XCNEWVEC (struct arg_data
, num_actuals
);
3549 /* Build up entries in the ARGS array, compute the size of the
3550 arguments into ARGS_SIZE, etc. */
3551 initialize_argument_information (num_actuals
, args
, &args_size
,
3553 structure_value_addr_value
, fndecl
, fntype
,
3554 args_so_far
, reg_parm_stack_space
,
3555 &old_stack_level
, &old_pending_adj
,
3556 &must_preallocate
, &flags
,
3557 &try_tail_call
, CALL_FROM_THUNK_P (exp
));
3560 must_preallocate
= 1;
3562 /* Now make final decision about preallocating stack space. */
3563 must_preallocate
= finalize_must_preallocate (must_preallocate
,
3567 /* If the structure value address will reference the stack pointer, we
3568 must stabilize it. We don't need to do this if we know that we are
3569 not going to adjust the stack pointer in processing this call. */
3571 if (structure_value_addr
3572 && (reg_mentioned_p (virtual_stack_dynamic_rtx
, structure_value_addr
)
3573 || reg_mentioned_p (virtual_outgoing_args_rtx
,
3574 structure_value_addr
))
3576 || (!ACCUMULATE_OUTGOING_ARGS
3577 && maybe_ne (args_size
.constant
, 0))))
3578 structure_value_addr
= copy_to_reg (structure_value_addr
);
3580 /* Tail calls can make things harder to debug, and we've traditionally
3581 pushed these optimizations into -O2. Don't try if we're already
3582 expanding a call, as that means we're an argument. Don't try if
3583 there's cleanups, as we know there's code to follow the call. */
3585 if (currently_expanding_call
++ != 0
3586 || !flag_optimize_sibling_calls
3588 || dbg_cnt (tail_call
) == false)
3591 /* If the user has marked the function as requiring tail-call
3592 optimization, attempt it. */
3596 /* Rest of purposes for tail call optimizations to fail. */
3598 try_tail_call
= can_implement_as_sibling_call_p (exp
,
3599 structure_value_addr
,
3601 reg_parm_stack_space
,
3603 flags
, addr
, args_size
);
3605 /* Check if caller and callee disagree in promotion of function
3609 machine_mode caller_mode
, caller_promoted_mode
;
3610 machine_mode callee_mode
, callee_promoted_mode
;
3611 int caller_unsignedp
, callee_unsignedp
;
3612 tree caller_res
= DECL_RESULT (current_function_decl
);
3614 caller_unsignedp
= TYPE_UNSIGNED (TREE_TYPE (caller_res
));
3615 caller_mode
= DECL_MODE (caller_res
);
3616 callee_unsignedp
= TYPE_UNSIGNED (TREE_TYPE (funtype
));
3617 callee_mode
= TYPE_MODE (TREE_TYPE (funtype
));
3618 caller_promoted_mode
3619 = promote_function_mode (TREE_TYPE (caller_res
), caller_mode
,
3621 TREE_TYPE (current_function_decl
), 1);
3622 callee_promoted_mode
3623 = promote_function_mode (TREE_TYPE (funtype
), callee_mode
,
3626 if (caller_mode
!= VOIDmode
3627 && (caller_promoted_mode
!= callee_promoted_mode
3628 || ((caller_mode
!= caller_promoted_mode
3629 || callee_mode
!= callee_promoted_mode
)
3630 && (caller_unsignedp
!= callee_unsignedp
3631 || partial_subreg_p (caller_mode
, callee_mode
)))))
3634 maybe_complain_about_tail_call (exp
,
3635 "caller and callee disagree in"
3636 " promotion of function"
3641 /* Ensure current function's preferred stack boundary is at least
3642 what we need. Stack alignment may also increase preferred stack
3644 if (crtl
->preferred_stack_boundary
< preferred_stack_boundary
)
3645 crtl
->preferred_stack_boundary
= preferred_stack_boundary
;
3647 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
3649 preferred_unit_stack_boundary
= preferred_stack_boundary
/ BITS_PER_UNIT
;
3651 /* We want to make two insn chains; one for a sibling call, the other
3652 for a normal call. We will select one of the two chains after
3653 initial RTL generation is complete. */
3654 for (pass
= try_tail_call
? 0 : 1; pass
< 2; pass
++)
3656 int sibcall_failure
= 0;
3657 /* We want to emit any pending stack adjustments before the tail
3658 recursion "call". That way we know any adjustment after the tail
3659 recursion call can be ignored if we indeed use the tail
3661 saved_pending_stack_adjust save
;
3662 rtx_insn
*insns
, *before_call
, *after_args
;
3667 /* State variables we need to save and restore between
3669 save_pending_stack_adjust (&save
);
3672 flags
&= ~ECF_SIBCALL
;
3674 flags
|= ECF_SIBCALL
;
3676 /* Other state variables that we must reinitialize each time
3677 through the loop (that are not initialized by the loop itself). */
3681 /* Start a new sequence for the normal call case.
3683 From this point on, if the sibling call fails, we want to set
3684 sibcall_failure instead of continuing the loop. */
3687 /* Don't let pending stack adjusts add up to too much.
3688 Also, do all pending adjustments now if there is any chance
3689 this might be a call to alloca or if we are expanding a sibling
3691 Also do the adjustments before a throwing call, otherwise
3692 exception handling can fail; PR 19225. */
3693 if (maybe_ge (pending_stack_adjust
, 32)
3694 || (maybe_ne (pending_stack_adjust
, 0)
3695 && (flags
& ECF_MAY_BE_ALLOCA
))
3696 || (maybe_ne (pending_stack_adjust
, 0)
3697 && flag_exceptions
&& !(flags
& ECF_NOTHROW
))
3699 do_pending_stack_adjust ();
3701 /* Precompute any arguments as needed. */
3703 precompute_arguments (num_actuals
, args
);
3705 /* Now we are about to start emitting insns that can be deleted
3706 if a libcall is deleted. */
3707 if (pass
&& (flags
& ECF_MALLOC
))
3711 && crtl
->stack_protect_guard
3712 && targetm
.stack_protect_runtime_enabled_p ())
3713 stack_protect_epilogue ();
3715 adjusted_args_size
= args_size
;
3716 /* Compute the actual size of the argument block required. The variable
3717 and constant sizes must be combined, the size may have to be rounded,
3718 and there may be a minimum required size. When generating a sibcall
3719 pattern, do not round up, since we'll be re-using whatever space our
3721 unadjusted_args_size
3722 = compute_argument_block_size (reg_parm_stack_space
,
3723 &adjusted_args_size
,
3726 : preferred_stack_boundary
));
3728 old_stack_allocated
= stack_pointer_delta
- pending_stack_adjust
;
3730 /* The argument block when performing a sibling call is the
3731 incoming argument block. */
3734 argblock
= crtl
->args
.internal_arg_pointer
;
3735 if (STACK_GROWS_DOWNWARD
)
3737 = plus_constant (Pmode
, argblock
, crtl
->args
.pretend_args_size
);
3740 = plus_constant (Pmode
, argblock
, -crtl
->args
.pretend_args_size
);
3742 HOST_WIDE_INT map_size
= constant_lower_bound (args_size
.constant
);
3743 stored_args_map
= sbitmap_alloc (map_size
);
3744 bitmap_clear (stored_args_map
);
3745 stored_args_watermark
= HOST_WIDE_INT_M1U
;
3748 /* If we have no actual push instructions, or shouldn't use them,
3749 make space for all args right now. */
3750 else if (adjusted_args_size
.var
!= 0)
3752 if (old_stack_level
== 0)
3754 emit_stack_save (SAVE_BLOCK
, &old_stack_level
);
3755 old_stack_pointer_delta
= stack_pointer_delta
;
3756 old_pending_adj
= pending_stack_adjust
;
3757 pending_stack_adjust
= 0;
3758 /* stack_arg_under_construction says whether a stack arg is
3759 being constructed at the old stack level. Pushing the stack
3760 gets a clean outgoing argument block. */
3761 old_stack_arg_under_construction
= stack_arg_under_construction
;
3762 stack_arg_under_construction
= 0;
3764 argblock
= push_block (ARGS_SIZE_RTX (adjusted_args_size
), 0, 0);
3765 if (flag_stack_usage_info
)
3766 current_function_has_unbounded_dynamic_stack_size
= 1;
3770 /* Note that we must go through the motions of allocating an argument
3771 block even if the size is zero because we may be storing args
3772 in the area reserved for register arguments, which may be part of
3775 poly_int64 needed
= adjusted_args_size
.constant
;
3777 /* Store the maximum argument space used. It will be pushed by
3778 the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
3781 crtl
->outgoing_args_size
= upper_bound (crtl
->outgoing_args_size
,
3784 if (must_preallocate
)
3786 if (ACCUMULATE_OUTGOING_ARGS
)
3788 /* Since the stack pointer will never be pushed, it is
3789 possible for the evaluation of a parm to clobber
3790 something we have already written to the stack.
3791 Since most function calls on RISC machines do not use
3792 the stack, this is uncommon, but must work correctly.
3794 Therefore, we save any area of the stack that was already
3795 written and that we are using. Here we set up to do this
3796 by making a new stack usage map from the old one. The
3797 actual save will be done by store_one_arg.
3799 Another approach might be to try to reorder the argument
3800 evaluations to avoid this conflicting stack usage. */
3802 /* Since we will be writing into the entire argument area,
3803 the map must be allocated for its entire size, not just
3804 the part that is the responsibility of the caller. */
3805 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
3806 needed
+= reg_parm_stack_space
;
3808 poly_int64 limit
= needed
;
3809 if (ARGS_GROW_DOWNWARD
)
3812 /* For polynomial sizes, this is the maximum possible
3813 size needed for arguments with a constant size
3815 HOST_WIDE_INT const_limit
= constant_lower_bound (limit
);
3816 highest_outgoing_arg_in_use
3817 = MAX (initial_highest_arg_in_use
, const_limit
);
3819 free (stack_usage_map_buf
);
3820 stack_usage_map_buf
= XNEWVEC (char, highest_outgoing_arg_in_use
);
3821 stack_usage_map
= stack_usage_map_buf
;
3823 if (initial_highest_arg_in_use
)
3824 memcpy (stack_usage_map
, initial_stack_usage_map
,
3825 initial_highest_arg_in_use
);
3827 if (initial_highest_arg_in_use
!= highest_outgoing_arg_in_use
)
3828 memset (&stack_usage_map
[initial_highest_arg_in_use
], 0,
3829 (highest_outgoing_arg_in_use
3830 - initial_highest_arg_in_use
));
3833 /* The address of the outgoing argument list must not be
3834 copied to a register here, because argblock would be left
3835 pointing to the wrong place after the call to
3836 allocate_dynamic_stack_space below. */
3838 argblock
= virtual_outgoing_args_rtx
;
3842 /* Try to reuse some or all of the pending_stack_adjust
3843 to get this space. */
3844 if (inhibit_defer_pop
== 0
3845 && (combine_pending_stack_adjustment_and_call
3847 unadjusted_args_size
,
3848 &adjusted_args_size
,
3849 preferred_unit_stack_boundary
)))
3851 /* combine_pending_stack_adjustment_and_call computes
3852 an adjustment before the arguments are allocated.
3853 Account for them and see whether or not the stack
3854 needs to go up or down. */
3855 needed
= unadjusted_args_size
- needed
;
3858 combine_pending_stack_adjustment_and_call. */
3859 gcc_checking_assert (ordered_p (needed
, 0));
3860 if (maybe_lt (needed
, 0))
3862 /* We're releasing stack space. */
3863 /* ??? We can avoid any adjustment at all if we're
3864 already aligned. FIXME. */
3865 pending_stack_adjust
= -needed
;
3866 do_pending_stack_adjust ();
3870 /* We need to allocate space. We'll do that in
3871 push_block below. */
3872 pending_stack_adjust
= 0;
3875 /* Special case this because overhead of `push_block' in
3876 this case is non-trivial. */
3877 if (known_eq (needed
, 0))
3878 argblock
= virtual_outgoing_args_rtx
;
3881 rtx needed_rtx
= gen_int_mode (needed
, Pmode
);
3882 argblock
= push_block (needed_rtx
, 0, 0);
3883 if (ARGS_GROW_DOWNWARD
)
3884 argblock
= plus_constant (Pmode
, argblock
, needed
);
3887 /* We only really need to call `copy_to_reg' in the case
3888 where push insns are going to be used to pass ARGBLOCK
3889 to a function call in ARGS. In that case, the stack
3890 pointer changes value from the allocation point to the
3891 call point, and hence the value of
3892 VIRTUAL_OUTGOING_ARGS_RTX changes as well. But might
3893 as well always do it. */
3894 argblock
= copy_to_reg (argblock
);
3899 if (ACCUMULATE_OUTGOING_ARGS
)
3901 /* The save/restore code in store_one_arg handles all
3902 cases except one: a constructor call (including a C
3903 function returning a BLKmode struct) to initialize
3905 if (stack_arg_under_construction
)
3909 (adjusted_args_size
.constant
3910 + (OUTGOING_REG_PARM_STACK_SPACE (!fndecl
? fntype
3911 : TREE_TYPE (fndecl
))
3912 ? 0 : reg_parm_stack_space
), Pmode
));
3913 if (old_stack_level
== 0)
3915 emit_stack_save (SAVE_BLOCK
, &old_stack_level
);
3916 old_stack_pointer_delta
= stack_pointer_delta
;
3917 old_pending_adj
= pending_stack_adjust
;
3918 pending_stack_adjust
= 0;
3919 /* stack_arg_under_construction says whether a stack
3920 arg is being constructed at the old stack level.
3921 Pushing the stack gets a clean outgoing argument
3923 old_stack_arg_under_construction
3924 = stack_arg_under_construction
;
3925 stack_arg_under_construction
= 0;
3926 /* Make a new map for the new argument list. */
3927 free (stack_usage_map_buf
);
3928 stack_usage_map_buf
= XCNEWVEC (char, highest_outgoing_arg_in_use
);
3929 stack_usage_map
= stack_usage_map_buf
;
3930 highest_outgoing_arg_in_use
= 0;
3931 stack_usage_watermark
= HOST_WIDE_INT_M1U
;
3933 /* We can pass TRUE as the 4th argument because we just
3934 saved the stack pointer and will restore it right after
3936 allocate_dynamic_stack_space (push_size
, 0, BIGGEST_ALIGNMENT
,
3940 /* If argument evaluation might modify the stack pointer,
3941 copy the address of the argument list to a register. */
3942 for (i
= 0; i
< num_actuals
; i
++)
3943 if (args
[i
].pass_on_stack
)
3945 argblock
= copy_addr_to_reg (argblock
);
3950 compute_argument_addresses (args
, argblock
, num_actuals
);
3952 /* Stack is properly aligned, pops can't safely be deferred during
3953 the evaluation of the arguments. */
3956 /* Precompute all register parameters. It isn't safe to compute
3957 anything once we have started filling any specific hard regs.
3958 TLS symbols sometimes need a call to resolve. Precompute
3959 register parameters before any stack pointer manipulation
3960 to avoid unaligned stack in the called function. */
3961 precompute_register_parameters (num_actuals
, args
, ®_parm_seen
);
3965 /* Perform stack alignment before the first push (the last arg). */
3967 && maybe_gt (adjusted_args_size
.constant
, reg_parm_stack_space
)
3968 && maybe_ne (adjusted_args_size
.constant
, unadjusted_args_size
))
3970 /* When the stack adjustment is pending, we get better code
3971 by combining the adjustments. */
3972 if (maybe_ne (pending_stack_adjust
, 0)
3973 && ! inhibit_defer_pop
3974 && (combine_pending_stack_adjustment_and_call
3975 (&pending_stack_adjust
,
3976 unadjusted_args_size
,
3977 &adjusted_args_size
,
3978 preferred_unit_stack_boundary
)))
3979 do_pending_stack_adjust ();
3980 else if (argblock
== 0)
3981 anti_adjust_stack (gen_int_mode (adjusted_args_size
.constant
3982 - unadjusted_args_size
,
3985 /* Now that the stack is properly aligned, pops can't safely
3986 be deferred during the evaluation of the arguments. */
3989 /* Record the maximum pushed stack space size. We need to delay
3990 doing it this far to take into account the optimization done
3991 by combine_pending_stack_adjustment_and_call. */
3992 if (flag_stack_usage_info
3993 && !ACCUMULATE_OUTGOING_ARGS
3995 && adjusted_args_size
.var
== 0)
3997 poly_int64 pushed
= (adjusted_args_size
.constant
3998 + pending_stack_adjust
);
3999 current_function_pushed_stack_size
4000 = upper_bound (current_function_pushed_stack_size
, pushed
);
4003 funexp
= rtx_for_function_call (fndecl
, addr
);
4005 if (CALL_EXPR_STATIC_CHAIN (exp
))
4006 static_chain_value
= expand_normal (CALL_EXPR_STATIC_CHAIN (exp
));
4008 static_chain_value
= 0;
4010 #ifdef REG_PARM_STACK_SPACE
4011 /* Save the fixed argument area if it's part of the caller's frame and
4012 is clobbered by argument setup for this call. */
4013 if (ACCUMULATE_OUTGOING_ARGS
&& pass
)
4014 save_area
= save_fixed_argument_area (reg_parm_stack_space
, argblock
,
4015 &low_to_save
, &high_to_save
);
4018 /* Now store (and compute if necessary) all non-register parms.
4019 These come before register parms, since they can require block-moves,
4020 which could clobber the registers used for register parms.
4021 Parms which have partial registers are not stored here,
4022 but we do preallocate space here if they want that. */
4024 for (i
= 0; i
< num_actuals
; i
++)
4026 /* Delay bounds until all other args are stored. */
4027 if (POINTER_BOUNDS_P (args
[i
].tree_value
))
4029 else if (args
[i
].reg
== 0 || args
[i
].pass_on_stack
)
4031 rtx_insn
*before_arg
= get_last_insn ();
4033 /* We don't allow passing huge (> 2^30 B) arguments
4034 by value. It would cause an overflow later on. */
4035 if (constant_lower_bound (adjusted_args_size
.constant
)
4036 >= (1 << (HOST_BITS_PER_INT
- 2)))
4038 sorry ("passing too large argument on stack");
4042 if (store_one_arg (&args
[i
], argblock
, flags
,
4043 adjusted_args_size
.var
!= 0,
4044 reg_parm_stack_space
)
4046 && check_sibcall_argument_overlap (before_arg
,
4048 sibcall_failure
= 1;
4053 = gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)),
4054 gen_rtx_USE (VOIDmode
, args
[i
].stack
),
4058 /* If we have a parm that is passed in registers but not in memory
4059 and whose alignment does not permit a direct copy into registers,
4060 make a group of pseudos that correspond to each register that we
4062 if (STRICT_ALIGNMENT
)
4063 store_unaligned_arguments_into_pseudos (args
, num_actuals
);
4065 /* Now store any partially-in-registers parm.
4066 This is the last place a block-move can happen. */
4068 for (i
= 0; i
< num_actuals
; i
++)
4069 if (args
[i
].partial
!= 0 && ! args
[i
].pass_on_stack
)
4071 rtx_insn
*before_arg
= get_last_insn ();
4073 /* On targets with weird calling conventions (e.g. PA) it's
4074 hard to ensure that all cases of argument overlap between
4075 stack and registers work. Play it safe and bail out. */
4076 if (ARGS_GROW_DOWNWARD
&& !STACK_GROWS_DOWNWARD
)
4078 sibcall_failure
= 1;
4082 if (store_one_arg (&args
[i
], argblock
, flags
,
4083 adjusted_args_size
.var
!= 0,
4084 reg_parm_stack_space
)
4086 && check_sibcall_argument_overlap (before_arg
,
4088 sibcall_failure
= 1;
4091 bool any_regs
= false;
4092 for (i
= 0; i
< num_actuals
; i
++)
4093 if (args
[i
].reg
!= NULL_RTX
)
4096 targetm
.calls
.call_args (args
[i
].reg
, funtype
);
4099 targetm
.calls
.call_args (pc_rtx
, funtype
);
4101 /* Figure out the register where the value, if any, will come back. */
4104 if (TYPE_MODE (rettype
) != VOIDmode
4105 && ! structure_value_addr
)
4107 if (pcc_struct_value
)
4109 valreg
= hard_function_value (build_pointer_type (rettype
),
4110 fndecl
, NULL
, (pass
== 0));
4111 if (CALL_WITH_BOUNDS_P (exp
))
4112 valbnd
= targetm
.calls
.
4113 chkp_function_value_bounds (build_pointer_type (rettype
),
4114 fndecl
, (pass
== 0));
4118 valreg
= hard_function_value (rettype
, fndecl
, fntype
,
4120 if (CALL_WITH_BOUNDS_P (exp
))
4121 valbnd
= targetm
.calls
.chkp_function_value_bounds (rettype
,
4126 /* If VALREG is a PARALLEL whose first member has a zero
4127 offset, use that. This is for targets such as m68k that
4128 return the same value in multiple places. */
4129 if (GET_CODE (valreg
) == PARALLEL
)
4131 rtx elem
= XVECEXP (valreg
, 0, 0);
4132 rtx where
= XEXP (elem
, 0);
4133 rtx offset
= XEXP (elem
, 1);
4134 if (offset
== const0_rtx
4135 && GET_MODE (where
) == GET_MODE (valreg
))
4140 /* Store all bounds not passed in registers. */
4141 for (i
= 0; i
< num_actuals
; i
++)
4143 if (POINTER_BOUNDS_P (args
[i
].tree_value
)
4145 store_bounds (&args
[i
],
4146 args
[i
].pointer_arg
== -1
4148 : &args
[args
[i
].pointer_arg
]);
4151 /* If register arguments require space on the stack and stack space
4152 was not preallocated, allocate stack space here for arguments
4153 passed in registers. */
4154 if (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
)))
4155 && !ACCUMULATE_OUTGOING_ARGS
4156 && must_preallocate
== 0 && reg_parm_stack_space
> 0)
4157 anti_adjust_stack (GEN_INT (reg_parm_stack_space
));
4159 /* Pass the function the address in which to return a
4161 if (pass
!= 0 && structure_value_addr
&& ! structure_value_addr_parm
)
4163 structure_value_addr
4164 = convert_memory_address (Pmode
, structure_value_addr
);
4165 emit_move_insn (struct_value
,
4167 force_operand (structure_value_addr
,
4170 if (REG_P (struct_value
))
4171 use_reg (&call_fusage
, struct_value
);
4174 after_args
= get_last_insn ();
4175 funexp
= prepare_call_address (fndecl
? fndecl
: fntype
, funexp
,
4176 static_chain_value
, &call_fusage
,
4177 reg_parm_seen
, flags
);
4179 load_register_parameters (args
, num_actuals
, &call_fusage
, flags
,
4180 pass
== 0, &sibcall_failure
);
4182 /* Save a pointer to the last insn before the call, so that we can
4183 later safely search backwards to find the CALL_INSN. */
4184 before_call
= get_last_insn ();
4186 /* Set up next argument register. For sibling calls on machines
4187 with register windows this should be the incoming register. */
4189 next_arg_reg
= targetm
.calls
.function_incoming_arg (args_so_far
,
4194 next_arg_reg
= targetm
.calls
.function_arg (args_so_far
,
4195 VOIDmode
, void_type_node
,
4198 if (pass
== 1 && (return_flags
& ERF_RETURNS_ARG
))
4200 int arg_nr
= return_flags
& ERF_RETURN_ARG_MASK
;
4201 arg_nr
= num_actuals
- arg_nr
- 1;
4203 && arg_nr
< num_actuals
4207 && GET_MODE (args
[arg_nr
].reg
) == GET_MODE (valreg
))
4209 = gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args
[arg_nr
].tree_value
)),
4210 gen_rtx_SET (valreg
, args
[arg_nr
].reg
),
4213 /* All arguments and registers used for the call must be set up by
4216 /* Stack must be properly aligned now. */
4218 || multiple_p (stack_pointer_delta
,
4219 preferred_unit_stack_boundary
));
4221 /* Generate the actual call instruction. */
4222 emit_call_1 (funexp
, exp
, fndecl
, funtype
, unadjusted_args_size
,
4223 adjusted_args_size
.constant
, struct_value_size
,
4224 next_arg_reg
, valreg
, old_inhibit_defer_pop
, call_fusage
,
4225 flags
, args_so_far
);
4229 rtx_call_insn
*last
;
4230 rtx datum
= NULL_RTX
;
4231 if (fndecl
!= NULL_TREE
)
4233 datum
= XEXP (DECL_RTL (fndecl
), 0);
4234 gcc_assert (datum
!= NULL_RTX
4235 && GET_CODE (datum
) == SYMBOL_REF
);
4237 last
= last_call_insn ();
4238 add_reg_note (last
, REG_CALL_DECL
, datum
);
4241 /* If the call setup or the call itself overlaps with anything
4242 of the argument setup we probably clobbered our call address.
4243 In that case we can't do sibcalls. */
4245 && check_sibcall_argument_overlap (after_args
, 0, 0))
4246 sibcall_failure
= 1;
4248 /* If a non-BLKmode value is returned at the most significant end
4249 of a register, shift the register right by the appropriate amount
4250 and update VALREG accordingly. BLKmode values are handled by the
4251 group load/store machinery below. */
4252 if (!structure_value_addr
4253 && !pcc_struct_value
4254 && TYPE_MODE (rettype
) != VOIDmode
4255 && TYPE_MODE (rettype
) != BLKmode
4257 && targetm
.calls
.return_in_msb (rettype
))
4259 if (shift_return_value (TYPE_MODE (rettype
), false, valreg
))
4260 sibcall_failure
= 1;
4261 valreg
= gen_rtx_REG (TYPE_MODE (rettype
), REGNO (valreg
));
4264 if (pass
&& (flags
& ECF_MALLOC
))
4266 rtx temp
= gen_reg_rtx (GET_MODE (valreg
));
4267 rtx_insn
*last
, *insns
;
4269 /* The return value from a malloc-like function is a pointer. */
4270 if (TREE_CODE (rettype
) == POINTER_TYPE
)
4271 mark_reg_pointer (temp
, MALLOC_ABI_ALIGNMENT
);
4273 emit_move_insn (temp
, valreg
);
4275 /* The return value from a malloc-like function can not alias
4277 last
= get_last_insn ();
4278 add_reg_note (last
, REG_NOALIAS
, temp
);
4280 /* Write out the sequence. */
4281 insns
= get_insns ();
4287 /* For calls to `setjmp', etc., inform
4288 function.c:setjmp_warnings that it should complain if
4289 nonvolatile values are live. For functions that cannot
4290 return, inform flow that control does not fall through. */
4292 if ((flags
& ECF_NORETURN
) || pass
== 0)
4294 /* The barrier must be emitted
4295 immediately after the CALL_INSN. Some ports emit more
4296 than just a CALL_INSN above, so we must search for it here. */
4298 rtx_insn
*last
= get_last_insn ();
4299 while (!CALL_P (last
))
4301 last
= PREV_INSN (last
);
4302 /* There was no CALL_INSN? */
4303 gcc_assert (last
!= before_call
);
4306 emit_barrier_after (last
);
4308 /* Stack adjustments after a noreturn call are dead code.
4309 However when NO_DEFER_POP is in effect, we must preserve
4310 stack_pointer_delta. */
4311 if (inhibit_defer_pop
== 0)
4313 stack_pointer_delta
= old_stack_allocated
;
4314 pending_stack_adjust
= 0;
4318 /* If value type not void, return an rtx for the value. */
4320 if (TYPE_MODE (rettype
) == VOIDmode
4322 target
= const0_rtx
;
4323 else if (structure_value_addr
)
4325 if (target
== 0 || !MEM_P (target
))
4328 = gen_rtx_MEM (TYPE_MODE (rettype
),
4329 memory_address (TYPE_MODE (rettype
),
4330 structure_value_addr
));
4331 set_mem_attributes (target
, rettype
, 1);
4334 else if (pcc_struct_value
)
4336 /* This is the special C++ case where we need to
4337 know what the true target was. We take care to
4338 never use this value more than once in one expression. */
4339 target
= gen_rtx_MEM (TYPE_MODE (rettype
),
4340 copy_to_reg (valreg
));
4341 set_mem_attributes (target
, rettype
, 1);
4343 /* Handle calls that return values in multiple non-contiguous locations.
4344 The Irix 6 ABI has examples of this. */
4345 else if (GET_CODE (valreg
) == PARALLEL
)
4348 target
= emit_group_move_into_temps (valreg
);
4349 else if (rtx_equal_p (target
, valreg
))
4351 else if (GET_CODE (target
) == PARALLEL
)
4352 /* Handle the result of a emit_group_move_into_temps
4353 call in the previous pass. */
4354 emit_group_move (target
, valreg
);
4356 emit_group_store (target
, valreg
, rettype
,
4357 int_size_in_bytes (rettype
));
4360 && GET_MODE (target
) == TYPE_MODE (rettype
)
4361 && GET_MODE (target
) == GET_MODE (valreg
))
4363 bool may_overlap
= false;
4365 /* We have to copy a return value in a CLASS_LIKELY_SPILLED hard
4366 reg to a plain register. */
4367 if (!REG_P (target
) || HARD_REGISTER_P (target
))
4368 valreg
= avoid_likely_spilled_reg (valreg
);
4370 /* If TARGET is a MEM in the argument area, and we have
4371 saved part of the argument area, then we can't store
4372 directly into TARGET as it may get overwritten when we
4373 restore the argument save area below. Don't work too
4374 hard though and simply force TARGET to a register if it
4375 is a MEM; the optimizer is quite likely to sort it out. */
4376 if (ACCUMULATE_OUTGOING_ARGS
&& pass
&& MEM_P (target
))
4377 for (i
= 0; i
< num_actuals
; i
++)
4378 if (args
[i
].save_area
)
4385 target
= copy_to_reg (valreg
);
4388 /* TARGET and VALREG cannot be equal at this point
4389 because the latter would not have
4390 REG_FUNCTION_VALUE_P true, while the former would if
4391 it were referring to the same register.
4393 If they refer to the same register, this move will be
4394 a no-op, except when function inlining is being
4396 emit_move_insn (target
, valreg
);
4398 /* If we are setting a MEM, this code must be executed.
4399 Since it is emitted after the call insn, sibcall
4400 optimization cannot be performed in that case. */
4402 sibcall_failure
= 1;
4406 target
= copy_to_reg (avoid_likely_spilled_reg (valreg
));
4408 /* If we promoted this return value, make the proper SUBREG.
4409 TARGET might be const0_rtx here, so be careful. */
4411 && TYPE_MODE (rettype
) != BLKmode
4412 && GET_MODE (target
) != TYPE_MODE (rettype
))
4414 tree type
= rettype
;
4415 int unsignedp
= TYPE_UNSIGNED (type
);
4418 /* Ensure we promote as expected, and get the new unsignedness. */
4419 pmode
= promote_function_mode (type
, TYPE_MODE (type
), &unsignedp
,
4421 gcc_assert (GET_MODE (target
) == pmode
);
4423 poly_uint64 offset
= subreg_lowpart_offset (TYPE_MODE (type
),
4425 target
= gen_rtx_SUBREG (TYPE_MODE (type
), target
, offset
);
4426 SUBREG_PROMOTED_VAR_P (target
) = 1;
4427 SUBREG_PROMOTED_SET (target
, unsignedp
);
4430 /* If size of args is variable or this was a constructor call for a stack
4431 argument, restore saved stack-pointer value. */
4433 if (old_stack_level
)
4435 rtx_insn
*prev
= get_last_insn ();
4437 emit_stack_restore (SAVE_BLOCK
, old_stack_level
);
4438 stack_pointer_delta
= old_stack_pointer_delta
;
4440 fixup_args_size_notes (prev
, get_last_insn (), stack_pointer_delta
);
4442 pending_stack_adjust
= old_pending_adj
;
4443 old_stack_allocated
= stack_pointer_delta
- pending_stack_adjust
;
4444 stack_arg_under_construction
= old_stack_arg_under_construction
;
4445 highest_outgoing_arg_in_use
= initial_highest_arg_in_use
;
4446 stack_usage_map
= initial_stack_usage_map
;
4447 stack_usage_watermark
= initial_stack_usage_watermark
;
4448 sibcall_failure
= 1;
4450 else if (ACCUMULATE_OUTGOING_ARGS
&& pass
)
4452 #ifdef REG_PARM_STACK_SPACE
4454 restore_fixed_argument_area (save_area
, argblock
,
4455 high_to_save
, low_to_save
);
4458 /* If we saved any argument areas, restore them. */
4459 for (i
= 0; i
< num_actuals
; i
++)
4460 if (args
[i
].save_area
)
4462 machine_mode save_mode
= GET_MODE (args
[i
].save_area
);
4464 = gen_rtx_MEM (save_mode
,
4465 memory_address (save_mode
,
4466 XEXP (args
[i
].stack_slot
, 0)));
4468 if (save_mode
!= BLKmode
)
4469 emit_move_insn (stack_area
, args
[i
].save_area
);
4471 emit_block_move (stack_area
, args
[i
].save_area
,
4473 (args
[i
].locate
.size
.constant
, Pmode
)),
4474 BLOCK_OP_CALL_PARM
);
4477 highest_outgoing_arg_in_use
= initial_highest_arg_in_use
;
4478 stack_usage_map
= initial_stack_usage_map
;
4479 stack_usage_watermark
= initial_stack_usage_watermark
;
4482 /* If this was alloca, record the new stack level. */
4483 if (flags
& ECF_MAY_BE_ALLOCA
)
4484 record_new_stack_level ();
4486 /* Free up storage we no longer need. */
4487 for (i
= 0; i
< num_actuals
; ++i
)
4488 free (args
[i
].aligned_regs
);
4490 targetm
.calls
.end_call_args ();
4492 insns
= get_insns ();
4497 tail_call_insns
= insns
;
4499 /* Restore the pending stack adjustment now that we have
4500 finished generating the sibling call sequence. */
4502 restore_pending_stack_adjust (&save
);
4504 /* Prepare arg structure for next iteration. */
4505 for (i
= 0; i
< num_actuals
; i
++)
4508 args
[i
].aligned_regs
= 0;
4512 sbitmap_free (stored_args_map
);
4513 internal_arg_pointer_exp_state
.scan_start
= NULL
;
4514 internal_arg_pointer_exp_state
.cache
.release ();
4518 normal_call_insns
= insns
;
4520 /* Verify that we've deallocated all the stack we used. */
4521 gcc_assert ((flags
& ECF_NORETURN
)
4522 || known_eq (old_stack_allocated
,
4524 - pending_stack_adjust
));
4527 /* If something prevents making this a sibling call,
4528 zero out the sequence. */
4529 if (sibcall_failure
)
4530 tail_call_insns
= NULL
;
4535 /* If tail call production succeeded, we need to remove REG_EQUIV notes on
4536 arguments too, as argument area is now clobbered by the call. */
4537 if (tail_call_insns
)
4539 emit_insn (tail_call_insns
);
4540 crtl
->tail_call_emit
= true;
4544 emit_insn (normal_call_insns
);
4546 /* Ideally we'd emit a message for all of the ways that it could
4548 maybe_complain_about_tail_call (exp
, "tail call production failed");
4551 currently_expanding_call
--;
4553 free (stack_usage_map_buf
);
4556 /* Join result with returned bounds so caller may use them if needed. */
4557 target
= chkp_join_splitted_slot (target
, valbnd
);
4562 /* A sibling call sequence invalidates any REG_EQUIV notes made for
4563 this function's incoming arguments.
4565 At the start of RTL generation we know the only REG_EQUIV notes
4566 in the rtl chain are those for incoming arguments, so we can look
4567 for REG_EQUIV notes between the start of the function and the
4568 NOTE_INSN_FUNCTION_BEG.
4570 This is (slight) overkill. We could keep track of the highest
4571 argument we clobber and be more selective in removing notes, but it
4572 does not seem to be worth the effort. */
4575 fixup_tail_calls (void)
4579 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
4583 /* There are never REG_EQUIV notes for the incoming arguments
4584 after the NOTE_INSN_FUNCTION_BEG note, so stop if we see it. */
4586 && NOTE_KIND (insn
) == NOTE_INSN_FUNCTION_BEG
)
4589 note
= find_reg_note (insn
, REG_EQUIV
, 0);
4591 remove_note (insn
, note
);
4592 note
= find_reg_note (insn
, REG_EQUIV
, 0);
4597 /* Traverse a list of TYPES and expand all complex types into their
4600 split_complex_types (tree types
)
4604 /* Before allocating memory, check for the common case of no complex. */
4605 for (p
= types
; p
; p
= TREE_CHAIN (p
))
4607 tree type
= TREE_VALUE (p
);
4608 if (TREE_CODE (type
) == COMPLEX_TYPE
4609 && targetm
.calls
.split_complex_arg (type
))
4615 types
= copy_list (types
);
4617 for (p
= types
; p
; p
= TREE_CHAIN (p
))
4619 tree complex_type
= TREE_VALUE (p
);
4621 if (TREE_CODE (complex_type
) == COMPLEX_TYPE
4622 && targetm
.calls
.split_complex_arg (complex_type
))
4626 /* Rewrite complex type with component type. */
4627 TREE_VALUE (p
) = TREE_TYPE (complex_type
);
4628 next
= TREE_CHAIN (p
);
4630 /* Add another component type for the imaginary part. */
4631 imag
= build_tree_list (NULL_TREE
, TREE_VALUE (p
));
4632 TREE_CHAIN (p
) = imag
;
4633 TREE_CHAIN (imag
) = next
;
4635 /* Skip the newly created node. */
4643 /* Output a library call to function ORGFUN (a SYMBOL_REF rtx)
4644 for a value of mode OUTMODE,
4645 with NARGS different arguments, passed as ARGS.
4646 Store the return value if RETVAL is nonzero: store it in VALUE if
4647 VALUE is nonnull, otherwise pick a convenient location. In either
4648 case return the location of the stored value.
4650 FN_TYPE should be LCT_NORMAL for `normal' calls, LCT_CONST for
4651 `const' calls, LCT_PURE for `pure' calls, or another LCT_ value for
4652 other types of library calls. */
4655 emit_library_call_value_1 (int retval
, rtx orgfun
, rtx value
,
4656 enum libcall_type fn_type
,
4657 machine_mode outmode
, int nargs
, rtx_mode_t
*args
)
4659 /* Total size in bytes of all the stack-parms scanned so far. */
4660 struct args_size args_size
;
4661 /* Size of arguments before any adjustments (such as rounding). */
4662 struct args_size original_args_size
;
4665 /* Todo, choose the correct decl type of orgfun. Sadly this information
4666 isn't present here, so we default to native calling abi here. */
4667 tree fndecl ATTRIBUTE_UNUSED
= NULL_TREE
; /* library calls default to host calling abi ? */
4668 tree fntype ATTRIBUTE_UNUSED
= NULL_TREE
; /* library calls default to host calling abi ? */
4671 CUMULATIVE_ARGS args_so_far_v
;
4672 cumulative_args_t args_so_far
;
4679 struct locate_and_pad_arg_data locate
;
4683 int old_inhibit_defer_pop
= inhibit_defer_pop
;
4684 rtx call_fusage
= 0;
4687 int pcc_struct_value
= 0;
4688 int struct_value_size
= 0;
4690 int reg_parm_stack_space
= 0;
4692 rtx_insn
*before_call
;
4693 bool have_push_fusage
;
4694 tree tfom
; /* type_for_mode (outmode, 0) */
4696 #ifdef REG_PARM_STACK_SPACE
4697 /* Define the boundary of the register parm stack space that needs to be
4699 int low_to_save
= 0, high_to_save
= 0;
4700 rtx save_area
= 0; /* Place that it is saved. */
4703 /* Size of the stack reserved for parameter registers. */
4704 unsigned int initial_highest_arg_in_use
= highest_outgoing_arg_in_use
;
4705 char *initial_stack_usage_map
= stack_usage_map
;
4706 unsigned HOST_WIDE_INT initial_stack_usage_watermark
= stack_usage_watermark
;
4707 char *stack_usage_map_buf
= NULL
;
4709 rtx struct_value
= targetm
.calls
.struct_value_rtx (0, 0);
4711 #ifdef REG_PARM_STACK_SPACE
4712 reg_parm_stack_space
= REG_PARM_STACK_SPACE ((tree
) 0);
4715 /* By default, library functions cannot throw. */
4716 flags
= ECF_NOTHROW
;
4729 flags
|= ECF_NORETURN
;
4732 flags
&= ~ECF_NOTHROW
;
4734 case LCT_RETURNS_TWICE
:
4735 flags
= ECF_RETURNS_TWICE
;
4740 /* Ensure current function's preferred stack boundary is at least
4742 if (crtl
->preferred_stack_boundary
< PREFERRED_STACK_BOUNDARY
)
4743 crtl
->preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
4745 /* If this kind of value comes back in memory,
4746 decide where in memory it should come back. */
4747 if (outmode
!= VOIDmode
)
4749 tfom
= lang_hooks
.types
.type_for_mode (outmode
, 0);
4750 if (aggregate_value_p (tfom
, 0))
4752 #ifdef PCC_STATIC_STRUCT_RETURN
4754 = hard_function_value (build_pointer_type (tfom
), 0, 0, 0);
4755 mem_value
= gen_rtx_MEM (outmode
, pointer_reg
);
4756 pcc_struct_value
= 1;
4758 value
= gen_reg_rtx (outmode
);
4759 #else /* not PCC_STATIC_STRUCT_RETURN */
4760 struct_value_size
= GET_MODE_SIZE (outmode
);
4761 if (value
!= 0 && MEM_P (value
))
4764 mem_value
= assign_temp (tfom
, 1, 1);
4766 /* This call returns a big structure. */
4767 flags
&= ~(ECF_CONST
| ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
);
4771 tfom
= void_type_node
;
4773 /* ??? Unfinished: must pass the memory address as an argument. */
4775 /* Copy all the libcall-arguments out of the varargs data
4776 and into a vector ARGVEC.
4778 Compute how to pass each argument. We only support a very small subset
4779 of the full argument passing conventions to limit complexity here since
4780 library functions shouldn't have many args. */
4782 argvec
= XALLOCAVEC (struct arg
, nargs
+ 1);
4783 memset (argvec
, 0, (nargs
+ 1) * sizeof (struct arg
));
4785 #ifdef INIT_CUMULATIVE_LIBCALL_ARGS
4786 INIT_CUMULATIVE_LIBCALL_ARGS (args_so_far_v
, outmode
, fun
);
4788 INIT_CUMULATIVE_ARGS (args_so_far_v
, NULL_TREE
, fun
, 0, nargs
);
4790 args_so_far
= pack_cumulative_args (&args_so_far_v
);
4792 args_size
.constant
= 0;
4799 /* If there's a structure value address to be passed,
4800 either pass it in the special place, or pass it as an extra argument. */
4801 if (mem_value
&& struct_value
== 0 && ! pcc_struct_value
)
4803 rtx addr
= XEXP (mem_value
, 0);
4807 /* Make sure it is a reasonable operand for a move or push insn. */
4808 if (!REG_P (addr
) && !MEM_P (addr
)
4809 && !(CONSTANT_P (addr
)
4810 && targetm
.legitimate_constant_p (Pmode
, addr
)))
4811 addr
= force_operand (addr
, NULL_RTX
);
4813 argvec
[count
].value
= addr
;
4814 argvec
[count
].mode
= Pmode
;
4815 argvec
[count
].partial
= 0;
4817 argvec
[count
].reg
= targetm
.calls
.function_arg (args_so_far
,
4818 Pmode
, NULL_TREE
, true);
4819 gcc_assert (targetm
.calls
.arg_partial_bytes (args_so_far
, Pmode
,
4820 NULL_TREE
, 1) == 0);
4822 locate_and_pad_parm (Pmode
, NULL_TREE
,
4823 #ifdef STACK_PARMS_IN_REG_PARM_AREA
4826 argvec
[count
].reg
!= 0,
4828 reg_parm_stack_space
, 0,
4829 NULL_TREE
, &args_size
, &argvec
[count
].locate
);
4831 if (argvec
[count
].reg
== 0 || argvec
[count
].partial
!= 0
4832 || reg_parm_stack_space
> 0)
4833 args_size
.constant
+= argvec
[count
].locate
.size
.constant
;
4835 targetm
.calls
.function_arg_advance (args_so_far
, Pmode
, (tree
) 0, true);
4840 for (unsigned int i
= 0; count
< nargs
; i
++, count
++)
4842 rtx val
= args
[i
].first
;
4843 machine_mode mode
= args
[i
].second
;
4846 /* We cannot convert the arg value to the mode the library wants here;
4847 must do it earlier where we know the signedness of the arg. */
4848 gcc_assert (mode
!= BLKmode
4849 && (GET_MODE (val
) == mode
|| GET_MODE (val
) == VOIDmode
));
4851 /* Make sure it is a reasonable operand for a move or push insn. */
4852 if (!REG_P (val
) && !MEM_P (val
)
4853 && !(CONSTANT_P (val
) && targetm
.legitimate_constant_p (mode
, val
)))
4854 val
= force_operand (val
, NULL_RTX
);
4856 if (pass_by_reference (&args_so_far_v
, mode
, NULL_TREE
, 1))
4860 = !reference_callee_copied (&args_so_far_v
, mode
, NULL_TREE
, 1);
4862 /* If this was a CONST function, it is now PURE since it now
4864 if (flags
& ECF_CONST
)
4866 flags
&= ~ECF_CONST
;
4870 if (MEM_P (val
) && !must_copy
)
4872 tree val_expr
= MEM_EXPR (val
);
4874 mark_addressable (val_expr
);
4879 slot
= assign_temp (lang_hooks
.types
.type_for_mode (mode
, 0),
4881 emit_move_insn (slot
, val
);
4884 call_fusage
= gen_rtx_EXPR_LIST (VOIDmode
,
4885 gen_rtx_USE (VOIDmode
, slot
),
4888 call_fusage
= gen_rtx_EXPR_LIST (VOIDmode
,
4889 gen_rtx_CLOBBER (VOIDmode
,
4894 val
= force_operand (XEXP (slot
, 0), NULL_RTX
);
4897 mode
= promote_function_mode (NULL_TREE
, mode
, &unsigned_p
, NULL_TREE
, 0);
4898 argvec
[count
].mode
= mode
;
4899 argvec
[count
].value
= convert_modes (mode
, GET_MODE (val
), val
, unsigned_p
);
4900 argvec
[count
].reg
= targetm
.calls
.function_arg (args_so_far
, mode
,
4903 argvec
[count
].partial
4904 = targetm
.calls
.arg_partial_bytes (args_so_far
, mode
, NULL_TREE
, 1);
4906 if (argvec
[count
].reg
== 0
4907 || argvec
[count
].partial
!= 0
4908 || reg_parm_stack_space
> 0)
4910 locate_and_pad_parm (mode
, NULL_TREE
,
4911 #ifdef STACK_PARMS_IN_REG_PARM_AREA
4914 argvec
[count
].reg
!= 0,
4916 reg_parm_stack_space
, argvec
[count
].partial
,
4917 NULL_TREE
, &args_size
, &argvec
[count
].locate
);
4918 args_size
.constant
+= argvec
[count
].locate
.size
.constant
;
4919 gcc_assert (!argvec
[count
].locate
.size
.var
);
4921 #ifdef BLOCK_REG_PADDING
4923 /* The argument is passed entirely in registers. See at which
4924 end it should be padded. */
4925 argvec
[count
].locate
.where_pad
=
4926 BLOCK_REG_PADDING (mode
, NULL_TREE
,
4927 GET_MODE_SIZE (mode
) <= UNITS_PER_WORD
);
4930 targetm
.calls
.function_arg_advance (args_so_far
, mode
, (tree
) 0, true);
4933 /* If this machine requires an external definition for library
4934 functions, write one out. */
4935 assemble_external_libcall (fun
);
4937 original_args_size
= args_size
;
4938 args_size
.constant
= (aligned_upper_bound (args_size
.constant
4939 + stack_pointer_delta
,
4941 - stack_pointer_delta
);
4943 args_size
.constant
= upper_bound (args_size
.constant
,
4944 reg_parm_stack_space
);
4946 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
4947 args_size
.constant
-= reg_parm_stack_space
;
4949 crtl
->outgoing_args_size
= upper_bound (crtl
->outgoing_args_size
,
4950 args_size
.constant
);
4952 if (flag_stack_usage_info
&& !ACCUMULATE_OUTGOING_ARGS
)
4954 poly_int64 pushed
= args_size
.constant
+ pending_stack_adjust
;
4955 current_function_pushed_stack_size
4956 = upper_bound (current_function_pushed_stack_size
, pushed
);
4959 if (ACCUMULATE_OUTGOING_ARGS
)
4961 /* Since the stack pointer will never be pushed, it is possible for
4962 the evaluation of a parm to clobber something we have already
4963 written to the stack. Since most function calls on RISC machines
4964 do not use the stack, this is uncommon, but must work correctly.
4966 Therefore, we save any area of the stack that was already written
4967 and that we are using. Here we set up to do this by making a new
4968 stack usage map from the old one.
4970 Another approach might be to try to reorder the argument
4971 evaluations to avoid this conflicting stack usage. */
4973 needed
= args_size
.constant
;
4975 /* Since we will be writing into the entire argument area, the
4976 map must be allocated for its entire size, not just the part that
4977 is the responsibility of the caller. */
4978 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
4979 needed
+= reg_parm_stack_space
;
4981 poly_int64 limit
= needed
;
4982 if (ARGS_GROW_DOWNWARD
)
4985 /* For polynomial sizes, this is the maximum possible size needed
4986 for arguments with a constant size and offset. */
4987 HOST_WIDE_INT const_limit
= constant_lower_bound (limit
);
4988 highest_outgoing_arg_in_use
= MAX (initial_highest_arg_in_use
,
4991 stack_usage_map_buf
= XNEWVEC (char, highest_outgoing_arg_in_use
);
4992 stack_usage_map
= stack_usage_map_buf
;
4994 if (initial_highest_arg_in_use
)
4995 memcpy (stack_usage_map
, initial_stack_usage_map
,
4996 initial_highest_arg_in_use
);
4998 if (initial_highest_arg_in_use
!= highest_outgoing_arg_in_use
)
4999 memset (&stack_usage_map
[initial_highest_arg_in_use
], 0,
5000 highest_outgoing_arg_in_use
- initial_highest_arg_in_use
);
5003 /* We must be careful to use virtual regs before they're instantiated,
5004 and real regs afterwards. Loop optimization, for example, can create
5005 new libcalls after we've instantiated the virtual regs, and if we
5006 use virtuals anyway, they won't match the rtl patterns. */
5008 if (virtuals_instantiated
)
5009 argblock
= plus_constant (Pmode
, stack_pointer_rtx
,
5010 STACK_POINTER_OFFSET
);
5012 argblock
= virtual_outgoing_args_rtx
;
5017 argblock
= push_block (gen_int_mode (args_size
.constant
, Pmode
), 0, 0);
5020 /* We push args individually in reverse order, perform stack alignment
5021 before the first push (the last arg). */
5023 anti_adjust_stack (gen_int_mode (args_size
.constant
5024 - original_args_size
.constant
,
5029 #ifdef REG_PARM_STACK_SPACE
5030 if (ACCUMULATE_OUTGOING_ARGS
)
5032 /* The argument list is the property of the called routine and it
5033 may clobber it. If the fixed area has been used for previous
5034 parameters, we must save and restore it. */
5035 save_area
= save_fixed_argument_area (reg_parm_stack_space
, argblock
,
5036 &low_to_save
, &high_to_save
);
5040 /* When expanding a normal call, args are stored in push order,
5041 which is the reverse of what we have here. */
5042 bool any_regs
= false;
5043 for (int i
= nargs
; i
-- > 0; )
5044 if (argvec
[i
].reg
!= NULL_RTX
)
5046 targetm
.calls
.call_args (argvec
[i
].reg
, NULL_TREE
);
5050 targetm
.calls
.call_args (pc_rtx
, NULL_TREE
);
5052 /* Push the args that need to be pushed. */
5054 have_push_fusage
= false;
5056 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
5057 are to be pushed. */
5058 for (count
= 0; count
< nargs
; count
++, argnum
--)
5060 machine_mode mode
= argvec
[argnum
].mode
;
5061 rtx val
= argvec
[argnum
].value
;
5062 rtx reg
= argvec
[argnum
].reg
;
5063 int partial
= argvec
[argnum
].partial
;
5064 unsigned int parm_align
= argvec
[argnum
].locate
.boundary
;
5065 poly_int64 lower_bound
= 0, upper_bound
= 0;
5067 if (! (reg
!= 0 && partial
== 0))
5071 if (ACCUMULATE_OUTGOING_ARGS
)
5073 /* If this is being stored into a pre-allocated, fixed-size,
5074 stack area, save any previous data at that location. */
5076 if (ARGS_GROW_DOWNWARD
)
5078 /* stack_slot is negative, but we want to index stack_usage_map
5079 with positive values. */
5080 upper_bound
= -argvec
[argnum
].locate
.slot_offset
.constant
+ 1;
5081 lower_bound
= upper_bound
- argvec
[argnum
].locate
.size
.constant
;
5085 lower_bound
= argvec
[argnum
].locate
.slot_offset
.constant
;
5086 upper_bound
= lower_bound
+ argvec
[argnum
].locate
.size
.constant
;
5089 if (stack_region_maybe_used_p (lower_bound
, upper_bound
,
5090 reg_parm_stack_space
))
5092 /* We need to make a save area. */
5094 = argvec
[argnum
].locate
.size
.constant
* BITS_PER_UNIT
;
5095 machine_mode save_mode
5096 = int_mode_for_size (size
, 1).else_blk ();
5098 = plus_constant (Pmode
, argblock
,
5099 argvec
[argnum
].locate
.offset
.constant
);
5101 = gen_rtx_MEM (save_mode
, memory_address (save_mode
, adr
));
5103 if (save_mode
== BLKmode
)
5105 argvec
[argnum
].save_area
5106 = assign_stack_temp (BLKmode
,
5107 argvec
[argnum
].locate
.size
.constant
5110 emit_block_move (validize_mem
5111 (copy_rtx (argvec
[argnum
].save_area
)),
5114 (argvec
[argnum
].locate
.size
.constant
,
5116 BLOCK_OP_CALL_PARM
);
5120 argvec
[argnum
].save_area
= gen_reg_rtx (save_mode
);
5122 emit_move_insn (argvec
[argnum
].save_area
, stack_area
);
5127 emit_push_insn (val
, mode
, NULL_TREE
, NULL_RTX
, parm_align
,
5128 partial
, reg
, 0, argblock
,
5130 (argvec
[argnum
].locate
.offset
.constant
, Pmode
)),
5131 reg_parm_stack_space
,
5132 ARGS_SIZE_RTX (argvec
[argnum
].locate
.alignment_pad
), false);
5134 /* Now mark the segment we just used. */
5135 if (ACCUMULATE_OUTGOING_ARGS
)
5136 mark_stack_region_used (lower_bound
, upper_bound
);
5140 /* Indicate argument access so that alias.c knows that these
5143 use
= plus_constant (Pmode
, argblock
,
5144 argvec
[argnum
].locate
.offset
.constant
);
5145 else if (have_push_fusage
)
5149 /* When arguments are pushed, trying to tell alias.c where
5150 exactly this argument is won't work, because the
5151 auto-increment causes confusion. So we merely indicate
5152 that we access something with a known mode somewhere on
5154 use
= gen_rtx_PLUS (Pmode
, stack_pointer_rtx
,
5155 gen_rtx_SCRATCH (Pmode
));
5156 have_push_fusage
= true;
5158 use
= gen_rtx_MEM (argvec
[argnum
].mode
, use
);
5159 use
= gen_rtx_USE (VOIDmode
, use
);
5160 call_fusage
= gen_rtx_EXPR_LIST (VOIDmode
, use
, call_fusage
);
5166 fun
= prepare_call_address (NULL
, fun
, NULL
, &call_fusage
, 0, 0);
5168 /* Now load any reg parms into their regs. */
5170 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
5171 are to be pushed. */
5172 for (count
= 0; count
< nargs
; count
++, argnum
--)
5174 machine_mode mode
= argvec
[argnum
].mode
;
5175 rtx val
= argvec
[argnum
].value
;
5176 rtx reg
= argvec
[argnum
].reg
;
5177 int partial
= argvec
[argnum
].partial
;
5178 #ifdef BLOCK_REG_PADDING
5182 /* Handle calls that pass values in multiple non-contiguous
5183 locations. The PA64 has examples of this for library calls. */
5184 if (reg
!= 0 && GET_CODE (reg
) == PARALLEL
)
5185 emit_group_load (reg
, val
, NULL_TREE
, GET_MODE_SIZE (mode
));
5186 else if (reg
!= 0 && partial
== 0)
5188 emit_move_insn (reg
, val
);
5189 #ifdef BLOCK_REG_PADDING
5190 size
= GET_MODE_SIZE (argvec
[argnum
].mode
);
5192 /* Copied from load_register_parameters. */
5194 /* Handle case where we have a value that needs shifting
5195 up to the msb. eg. a QImode value and we're padding
5196 upward on a BYTES_BIG_ENDIAN machine. */
5197 if (size
< UNITS_PER_WORD
5198 && (argvec
[argnum
].locate
.where_pad
5199 == (BYTES_BIG_ENDIAN
? PAD_UPWARD
: PAD_DOWNWARD
)))
5202 int shift
= (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
5204 /* Assigning REG here rather than a temp makes CALL_FUSAGE
5205 report the whole reg as used. Strictly speaking, the
5206 call only uses SIZE bytes at the msb end, but it doesn't
5207 seem worth generating rtl to say that. */
5208 reg
= gen_rtx_REG (word_mode
, REGNO (reg
));
5209 x
= expand_shift (LSHIFT_EXPR
, word_mode
, reg
, shift
, reg
, 1);
5211 emit_move_insn (reg
, x
);
5219 /* Any regs containing parms remain in use through the call. */
5220 for (count
= 0; count
< nargs
; count
++)
5222 rtx reg
= argvec
[count
].reg
;
5223 if (reg
!= 0 && GET_CODE (reg
) == PARALLEL
)
5224 use_group_regs (&call_fusage
, reg
);
5227 int partial
= argvec
[count
].partial
;
5231 gcc_assert (partial
% UNITS_PER_WORD
== 0);
5232 nregs
= partial
/ UNITS_PER_WORD
;
5233 use_regs (&call_fusage
, REGNO (reg
), nregs
);
5236 use_reg (&call_fusage
, reg
);
5240 /* Pass the function the address in which to return a structure value. */
5241 if (mem_value
!= 0 && struct_value
!= 0 && ! pcc_struct_value
)
5243 emit_move_insn (struct_value
,
5245 force_operand (XEXP (mem_value
, 0),
5247 if (REG_P (struct_value
))
5248 use_reg (&call_fusage
, struct_value
);
5251 /* Don't allow popping to be deferred, since then
5252 cse'ing of library calls could delete a call and leave the pop. */
5254 valreg
= (mem_value
== 0 && outmode
!= VOIDmode
5255 ? hard_libcall_value (outmode
, orgfun
) : NULL_RTX
);
5257 /* Stack must be properly aligned now. */
5258 gcc_assert (multiple_p (stack_pointer_delta
,
5259 PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
));
5261 before_call
= get_last_insn ();
5263 /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
5264 will set inhibit_defer_pop to that value. */
5265 /* The return type is needed to decide how many bytes the function pops.
5266 Signedness plays no role in that, so for simplicity, we pretend it's
5267 always signed. We also assume that the list of arguments passed has
5268 no impact, so we pretend it is unknown. */
5270 emit_call_1 (fun
, NULL
,
5271 get_identifier (XSTR (orgfun
, 0)),
5272 build_function_type (tfom
, NULL_TREE
),
5273 original_args_size
.constant
, args_size
.constant
,
5275 targetm
.calls
.function_arg (args_so_far
,
5276 VOIDmode
, void_type_node
, true),
5278 old_inhibit_defer_pop
+ 1, call_fusage
, flags
, args_so_far
);
5283 gcc_assert (GET_CODE (datum
) == SYMBOL_REF
);
5284 rtx_call_insn
*last
= last_call_insn ();
5285 add_reg_note (last
, REG_CALL_DECL
, datum
);
5288 /* Right-shift returned value if necessary. */
5289 if (!pcc_struct_value
5290 && TYPE_MODE (tfom
) != BLKmode
5291 && targetm
.calls
.return_in_msb (tfom
))
5293 shift_return_value (TYPE_MODE (tfom
), false, valreg
);
5294 valreg
= gen_rtx_REG (TYPE_MODE (tfom
), REGNO (valreg
));
5297 targetm
.calls
.end_call_args ();
5299 /* For calls to `setjmp', etc., inform function.c:setjmp_warnings
5300 that it should complain if nonvolatile values are live. For
5301 functions that cannot return, inform flow that control does not
5303 if (flags
& ECF_NORETURN
)
5305 /* The barrier note must be emitted
5306 immediately after the CALL_INSN. Some ports emit more than
5307 just a CALL_INSN above, so we must search for it here. */
5308 rtx_insn
*last
= get_last_insn ();
5309 while (!CALL_P (last
))
5311 last
= PREV_INSN (last
);
5312 /* There was no CALL_INSN? */
5313 gcc_assert (last
!= before_call
);
5316 emit_barrier_after (last
);
5319 /* Consider that "regular" libcalls, i.e. all of them except for LCT_THROW
5320 and LCT_RETURNS_TWICE, cannot perform non-local gotos. */
5321 if (flags
& ECF_NOTHROW
)
5323 rtx_insn
*last
= get_last_insn ();
5324 while (!CALL_P (last
))
5326 last
= PREV_INSN (last
);
5327 /* There was no CALL_INSN? */
5328 gcc_assert (last
!= before_call
);
5331 make_reg_eh_region_note_nothrow_nononlocal (last
);
5334 /* Now restore inhibit_defer_pop to its actual original value. */
5339 /* Copy the value to the right place. */
5340 if (outmode
!= VOIDmode
&& retval
)
5346 if (value
!= mem_value
)
5347 emit_move_insn (value
, mem_value
);
5349 else if (GET_CODE (valreg
) == PARALLEL
)
5352 value
= gen_reg_rtx (outmode
);
5353 emit_group_store (value
, valreg
, NULL_TREE
, GET_MODE_SIZE (outmode
));
5357 /* Convert to the proper mode if a promotion has been active. */
5358 if (GET_MODE (valreg
) != outmode
)
5360 int unsignedp
= TYPE_UNSIGNED (tfom
);
5362 gcc_assert (promote_function_mode (tfom
, outmode
, &unsignedp
,
5363 fndecl
? TREE_TYPE (fndecl
) : fntype
, 1)
5364 == GET_MODE (valreg
));
5365 valreg
= convert_modes (outmode
, GET_MODE (valreg
), valreg
, 0);
5369 emit_move_insn (value
, valreg
);
5375 if (ACCUMULATE_OUTGOING_ARGS
)
5377 #ifdef REG_PARM_STACK_SPACE
5379 restore_fixed_argument_area (save_area
, argblock
,
5380 high_to_save
, low_to_save
);
5383 /* If we saved any argument areas, restore them. */
5384 for (count
= 0; count
< nargs
; count
++)
5385 if (argvec
[count
].save_area
)
5387 machine_mode save_mode
= GET_MODE (argvec
[count
].save_area
);
5388 rtx adr
= plus_constant (Pmode
, argblock
,
5389 argvec
[count
].locate
.offset
.constant
);
5390 rtx stack_area
= gen_rtx_MEM (save_mode
,
5391 memory_address (save_mode
, adr
));
5393 if (save_mode
== BLKmode
)
5394 emit_block_move (stack_area
,
5396 (copy_rtx (argvec
[count
].save_area
)),
5398 (argvec
[count
].locate
.size
.constant
, Pmode
)),
5399 BLOCK_OP_CALL_PARM
);
5401 emit_move_insn (stack_area
, argvec
[count
].save_area
);
5404 highest_outgoing_arg_in_use
= initial_highest_arg_in_use
;
5405 stack_usage_map
= initial_stack_usage_map
;
5406 stack_usage_watermark
= initial_stack_usage_watermark
;
5409 free (stack_usage_map_buf
);
5416 /* Store pointer bounds argument ARG into Bounds Table entry
5417 associated with PARM. */
5419 store_bounds (struct arg_data
*arg
, struct arg_data
*parm
)
5421 rtx slot
= NULL
, ptr
= NULL
, addr
= NULL
;
5423 /* We may pass bounds not associated with any pointer. */
5426 gcc_assert (arg
->special_slot
);
5427 slot
= arg
->special_slot
;
5430 /* Find pointer associated with bounds and where it is
5436 gcc_assert (!arg
->special_slot
);
5438 addr
= adjust_address (parm
->stack
, Pmode
, arg
->pointer_offset
);
5440 else if (REG_P (parm
->reg
))
5442 gcc_assert (arg
->special_slot
);
5443 slot
= arg
->special_slot
;
5445 if (MEM_P (parm
->value
))
5446 addr
= adjust_address (parm
->value
, Pmode
, arg
->pointer_offset
);
5447 else if (REG_P (parm
->value
))
5448 ptr
= gen_rtx_SUBREG (Pmode
, parm
->value
, arg
->pointer_offset
);
5451 gcc_assert (!arg
->pointer_offset
);
5457 gcc_assert (GET_CODE (parm
->reg
) == PARALLEL
);
5459 gcc_assert (arg
->special_slot
);
5460 slot
= arg
->special_slot
;
5462 if (parm
->parallel_value
)
5463 ptr
= chkp_get_value_with_offs (parm
->parallel_value
,
5464 GEN_INT (arg
->pointer_offset
));
5470 /* Expand bounds. */
5472 arg
->value
= expand_normal (arg
->tree_value
);
5474 targetm
.calls
.store_bounds_for_arg (ptr
, addr
, arg
->value
, slot
);
5477 /* Store a single argument for a function call
5478 into the register or memory area where it must be passed.
5479 *ARG describes the argument value and where to pass it.
5481 ARGBLOCK is the address of the stack-block for all the arguments,
5482 or 0 on a machine where arguments are pushed individually.
5484 MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
5485 so must be careful about how the stack is used.
5487 VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
5488 argument stack. This is used if ACCUMULATE_OUTGOING_ARGS to indicate
5489 that we need not worry about saving and restoring the stack.
5491 FNDECL is the declaration of the function we are calling.
5493 Return nonzero if this arg should cause sibcall failure,
5497 store_one_arg (struct arg_data
*arg
, rtx argblock
, int flags
,
5498 int variable_size ATTRIBUTE_UNUSED
, int reg_parm_stack_space
)
5500 tree pval
= arg
->tree_value
;
5503 poly_int64 used
= 0;
5504 poly_int64 lower_bound
= 0, upper_bound
= 0;
5505 int sibcall_failure
= 0;
5507 if (TREE_CODE (pval
) == ERROR_MARK
)
5510 /* Push a new temporary level for any temporaries we make for
5514 if (ACCUMULATE_OUTGOING_ARGS
&& !(flags
& ECF_SIBCALL
))
5516 /* If this is being stored into a pre-allocated, fixed-size, stack area,
5517 save any previous data at that location. */
5518 if (argblock
&& ! variable_size
&& arg
->stack
)
5520 if (ARGS_GROW_DOWNWARD
)
5522 /* stack_slot is negative, but we want to index stack_usage_map
5523 with positive values. */
5524 if (GET_CODE (XEXP (arg
->stack_slot
, 0)) == PLUS
)
5526 rtx offset
= XEXP (XEXP (arg
->stack_slot
, 0), 1);
5527 upper_bound
= -rtx_to_poly_int64 (offset
) + 1;
5532 lower_bound
= upper_bound
- arg
->locate
.size
.constant
;
5536 if (GET_CODE (XEXP (arg
->stack_slot
, 0)) == PLUS
)
5538 rtx offset
= XEXP (XEXP (arg
->stack_slot
, 0), 1);
5539 lower_bound
= rtx_to_poly_int64 (offset
);
5544 upper_bound
= lower_bound
+ arg
->locate
.size
.constant
;
5547 if (stack_region_maybe_used_p (lower_bound
, upper_bound
,
5548 reg_parm_stack_space
))
5550 /* We need to make a save area. */
5551 poly_uint64 size
= arg
->locate
.size
.constant
* BITS_PER_UNIT
;
5552 machine_mode save_mode
5553 = int_mode_for_size (size
, 1).else_blk ();
5554 rtx adr
= memory_address (save_mode
, XEXP (arg
->stack_slot
, 0));
5555 rtx stack_area
= gen_rtx_MEM (save_mode
, adr
);
5557 if (save_mode
== BLKmode
)
5560 = assign_temp (TREE_TYPE (arg
->tree_value
), 1, 1);
5561 preserve_temp_slots (arg
->save_area
);
5562 emit_block_move (validize_mem (copy_rtx (arg
->save_area
)),
5565 (arg
->locate
.size
.constant
, Pmode
)),
5566 BLOCK_OP_CALL_PARM
);
5570 arg
->save_area
= gen_reg_rtx (save_mode
);
5571 emit_move_insn (arg
->save_area
, stack_area
);
5577 /* If this isn't going to be placed on both the stack and in registers,
5578 set up the register and number of words. */
5579 if (! arg
->pass_on_stack
)
5581 if (flags
& ECF_SIBCALL
)
5582 reg
= arg
->tail_call_reg
;
5585 partial
= arg
->partial
;
5588 /* Being passed entirely in a register. We shouldn't be called in
5590 gcc_assert (reg
== 0 || partial
!= 0);
5592 /* If this arg needs special alignment, don't load the registers
5594 if (arg
->n_aligned_regs
!= 0)
5597 /* If this is being passed partially in a register, we can't evaluate
5598 it directly into its stack slot. Otherwise, we can. */
5599 if (arg
->value
== 0)
5601 /* stack_arg_under_construction is nonzero if a function argument is
5602 being evaluated directly into the outgoing argument list and
5603 expand_call must take special action to preserve the argument list
5604 if it is called recursively.
5606 For scalar function arguments stack_usage_map is sufficient to
5607 determine which stack slots must be saved and restored. Scalar
5608 arguments in general have pass_on_stack == 0.
5610 If this argument is initialized by a function which takes the
5611 address of the argument (a C++ constructor or a C function
5612 returning a BLKmode structure), then stack_usage_map is
5613 insufficient and expand_call must push the stack around the
5614 function call. Such arguments have pass_on_stack == 1.
5616 Note that it is always safe to set stack_arg_under_construction,
5617 but this generates suboptimal code if set when not needed. */
5619 if (arg
->pass_on_stack
)
5620 stack_arg_under_construction
++;
5622 arg
->value
= expand_expr (pval
,
5624 || TYPE_MODE (TREE_TYPE (pval
)) != arg
->mode
)
5625 ? NULL_RTX
: arg
->stack
,
5626 VOIDmode
, EXPAND_STACK_PARM
);
5628 /* If we are promoting object (or for any other reason) the mode
5629 doesn't agree, convert the mode. */
5631 if (arg
->mode
!= TYPE_MODE (TREE_TYPE (pval
)))
5632 arg
->value
= convert_modes (arg
->mode
, TYPE_MODE (TREE_TYPE (pval
)),
5633 arg
->value
, arg
->unsignedp
);
5635 if (arg
->pass_on_stack
)
5636 stack_arg_under_construction
--;
5639 /* Check for overlap with already clobbered argument area. */
5640 if ((flags
& ECF_SIBCALL
)
5641 && MEM_P (arg
->value
)
5642 && mem_might_overlap_already_clobbered_arg_p (XEXP (arg
->value
, 0),
5643 arg
->locate
.size
.constant
))
5644 sibcall_failure
= 1;
5646 /* Don't allow anything left on stack from computation
5647 of argument to alloca. */
5648 if (flags
& ECF_MAY_BE_ALLOCA
)
5649 do_pending_stack_adjust ();
5651 if (arg
->value
== arg
->stack
)
5652 /* If the value is already in the stack slot, we are done. */
5654 else if (arg
->mode
!= BLKmode
)
5656 unsigned int parm_align
;
5658 /* Argument is a scalar, not entirely passed in registers.
5659 (If part is passed in registers, arg->partial says how much
5660 and emit_push_insn will take care of putting it there.)
5662 Push it, and if its size is less than the
5663 amount of space allocated to it,
5664 also bump stack pointer by the additional space.
5665 Note that in C the default argument promotions
5666 will prevent such mismatches. */
5668 poly_int64 size
= (TYPE_EMPTY_P (TREE_TYPE (pval
))
5669 ? 0 : GET_MODE_SIZE (arg
->mode
));
5671 /* Compute how much space the push instruction will push.
5672 On many machines, pushing a byte will advance the stack
5673 pointer by a halfword. */
5674 #ifdef PUSH_ROUNDING
5675 size
= PUSH_ROUNDING (size
);
5679 /* Compute how much space the argument should get:
5680 round up to a multiple of the alignment for arguments. */
5681 if (targetm
.calls
.function_arg_padding (arg
->mode
, TREE_TYPE (pval
))
5683 /* At the moment we don't (need to) support ABIs for which the
5684 padding isn't known at compile time. In principle it should
5685 be easy to add though. */
5686 used
= force_align_up (size
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
5688 /* Compute the alignment of the pushed argument. */
5689 parm_align
= arg
->locate
.boundary
;
5690 if (targetm
.calls
.function_arg_padding (arg
->mode
, TREE_TYPE (pval
))
5693 poly_int64 pad
= used
- size
;
5694 unsigned int pad_align
= known_alignment (pad
) * BITS_PER_UNIT
;
5696 parm_align
= MIN (parm_align
, pad_align
);
5699 /* This isn't already where we want it on the stack, so put it there.
5700 This can either be done with push or copy insns. */
5701 if (maybe_ne (used
, 0)
5702 && !emit_push_insn (arg
->value
, arg
->mode
, TREE_TYPE (pval
),
5703 NULL_RTX
, parm_align
, partial
, reg
, used
- size
,
5704 argblock
, ARGS_SIZE_RTX (arg
->locate
.offset
),
5705 reg_parm_stack_space
,
5706 ARGS_SIZE_RTX (arg
->locate
.alignment_pad
), true))
5707 sibcall_failure
= 1;
5709 /* Unless this is a partially-in-register argument, the argument is now
5712 arg
->value
= arg
->stack
;
5716 /* BLKmode, at least partly to be pushed. */
5718 unsigned int parm_align
;
5722 /* Pushing a nonscalar.
5723 If part is passed in registers, PARTIAL says how much
5724 and emit_push_insn will take care of putting it there. */
5726 /* Round its size up to a multiple
5727 of the allocation unit for arguments. */
5729 if (arg
->locate
.size
.var
!= 0)
5732 size_rtx
= ARGS_SIZE_RTX (arg
->locate
.size
);
5736 /* PUSH_ROUNDING has no effect on us, because emit_push_insn
5737 for BLKmode is careful to avoid it. */
5738 excess
= (arg
->locate
.size
.constant
5739 - arg_int_size_in_bytes (TREE_TYPE (pval
))
5741 size_rtx
= expand_expr (arg_size_in_bytes (TREE_TYPE (pval
)),
5742 NULL_RTX
, TYPE_MODE (sizetype
),
5746 parm_align
= arg
->locate
.boundary
;
5748 /* When an argument is padded down, the block is aligned to
5749 PARM_BOUNDARY, but the actual argument isn't. */
5750 if (targetm
.calls
.function_arg_padding (arg
->mode
, TREE_TYPE (pval
))
5753 if (arg
->locate
.size
.var
)
5754 parm_align
= BITS_PER_UNIT
;
5757 unsigned int excess_align
5758 = known_alignment (excess
) * BITS_PER_UNIT
;
5759 if (excess_align
!= 0)
5760 parm_align
= MIN (parm_align
, excess_align
);
5764 if ((flags
& ECF_SIBCALL
) && MEM_P (arg
->value
))
5766 /* emit_push_insn might not work properly if arg->value and
5767 argblock + arg->locate.offset areas overlap. */
5771 if (XEXP (x
, 0) == crtl
->args
.internal_arg_pointer
5772 || (GET_CODE (XEXP (x
, 0)) == PLUS
5773 && XEXP (XEXP (x
, 0), 0) ==
5774 crtl
->args
.internal_arg_pointer
5775 && CONST_INT_P (XEXP (XEXP (x
, 0), 1))))
5777 if (XEXP (x
, 0) != crtl
->args
.internal_arg_pointer
)
5778 i
= rtx_to_poly_int64 (XEXP (XEXP (x
, 0), 1));
5780 /* arg.locate doesn't contain the pretend_args_size offset,
5781 it's part of argblock. Ensure we don't count it in I. */
5782 if (STACK_GROWS_DOWNWARD
)
5783 i
-= crtl
->args
.pretend_args_size
;
5785 i
+= crtl
->args
.pretend_args_size
;
5787 /* expand_call should ensure this. */
5788 gcc_assert (!arg
->locate
.offset
.var
5789 && arg
->locate
.size
.var
== 0);
5790 poly_int64 size_val
= rtx_to_poly_int64 (size_rtx
);
5792 if (known_eq (arg
->locate
.offset
.constant
, i
))
5794 /* Even though they appear to be at the same location,
5795 if part of the outgoing argument is in registers,
5796 they aren't really at the same location. Check for
5797 this by making sure that the incoming size is the
5798 same as the outgoing size. */
5799 if (maybe_ne (arg
->locate
.size
.constant
, size_val
))
5800 sibcall_failure
= 1;
5802 else if (maybe_in_range_p (arg
->locate
.offset
.constant
,
5804 sibcall_failure
= 1;
5805 /* Use arg->locate.size.constant instead of size_rtx
5806 because we only care about the part of the argument
5808 else if (maybe_in_range_p (i
, arg
->locate
.offset
.constant
,
5809 arg
->locate
.size
.constant
))
5810 sibcall_failure
= 1;
5814 if (!CONST_INT_P (size_rtx
) || INTVAL (size_rtx
) != 0)
5815 emit_push_insn (arg
->value
, arg
->mode
, TREE_TYPE (pval
), size_rtx
,
5816 parm_align
, partial
, reg
, excess
, argblock
,
5817 ARGS_SIZE_RTX (arg
->locate
.offset
),
5818 reg_parm_stack_space
,
5819 ARGS_SIZE_RTX (arg
->locate
.alignment_pad
), false);
5821 /* Unless this is a partially-in-register argument, the argument is now
5824 ??? Unlike the case above, in which we want the actual
5825 address of the data, so that we can load it directly into a
5826 register, here we want the address of the stack slot, so that
5827 it's properly aligned for word-by-word copying or something
5828 like that. It's not clear that this is always correct. */
5830 arg
->value
= arg
->stack_slot
;
5833 if (arg
->reg
&& GET_CODE (arg
->reg
) == PARALLEL
)
5835 tree type
= TREE_TYPE (arg
->tree_value
);
5837 = emit_group_load_into_temps (arg
->reg
, arg
->value
, type
,
5838 int_size_in_bytes (type
));
5841 /* Mark all slots this store used. */
5842 if (ACCUMULATE_OUTGOING_ARGS
&& !(flags
& ECF_SIBCALL
)
5843 && argblock
&& ! variable_size
&& arg
->stack
)
5844 mark_stack_region_used (lower_bound
, upper_bound
);
5846 /* Once we have pushed something, pops can't safely
5847 be deferred during the rest of the arguments. */
5850 /* Free any temporary slots made in processing this argument. */
5853 return sibcall_failure
;
5856 /* Nonzero if we do not know how to pass TYPE solely in registers. */
5859 must_pass_in_stack_var_size (machine_mode mode ATTRIBUTE_UNUSED
,
5865 /* If the type has variable size... */
5866 if (TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
5869 /* If the type is marked as addressable (it is required
5870 to be constructed into the stack)... */
5871 if (TREE_ADDRESSABLE (type
))
5877 /* Another version of the TARGET_MUST_PASS_IN_STACK hook. This one
5878 takes trailing padding of a structure into account. */
5879 /* ??? Should be able to merge these two by examining BLOCK_REG_PADDING. */
5882 must_pass_in_stack_var_size_or_pad (machine_mode mode
, const_tree type
)
5887 /* If the type has variable size... */
5888 if (TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
5891 /* If the type is marked as addressable (it is required
5892 to be constructed into the stack)... */
5893 if (TREE_ADDRESSABLE (type
))
5896 if (TYPE_EMPTY_P (type
))
5899 /* If the padding and mode of the type is such that a copy into
5900 a register would put it into the wrong part of the register. */
5902 && int_size_in_bytes (type
) % (PARM_BOUNDARY
/ BITS_PER_UNIT
)
5903 && (targetm
.calls
.function_arg_padding (mode
, type
)
5904 == (BYTES_BIG_ENDIAN
? PAD_UPWARD
: PAD_DOWNWARD
)))
5910 /* Tell the garbage collector about GTY markers in this source file. */
5911 #include "gt-calls.h"