1 /* Convert function calls to rtl insns, for GNU C compiler.
2 Copyright (C) 1989-2018 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
22 #include "coretypes.h"
31 #include "stringpool.h"
36 #include "diagnostic-core.h"
37 #include "fold-const.h"
38 #include "stor-layout.h"
40 #include "internal-fn.h"
46 #include "langhooks.h"
50 #include "tree-chkp.h"
52 #include "tree-ssanames.h"
55 #include "stringpool.h"
58 #include "gimple-fold.h"
60 /* Like PREFERRED_STACK_BOUNDARY but in units of bytes, not bits. */
61 #define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)
63 /* Data structure and subroutines used within expand_call. */
67 /* Tree node for this argument. */
69 /* Mode for value; TYPE_MODE unless promoted. */
71 /* Current RTL value for argument, or 0 if it isn't precomputed. */
73 /* Initially-compute RTL value for argument; only for const functions. */
75 /* Register to pass this argument in, 0 if passed on stack, or an
76 PARALLEL if the arg is to be copied into multiple non-contiguous
79 /* Register to pass this argument in when generating tail call sequence.
80 This is not the same register as for normal calls on machines with
83 /* If REG is a PARALLEL, this is a copy of VALUE pulled into the correct
84 form for emit_group_move. */
86 /* If value is passed in neither reg nor stack, this field holds a number
87 of a special slot to be used. */
89 /* For pointer bounds hold an index of parm bounds are bound to. -1 if
90 there is no such pointer. */
92 /* If pointer_arg refers a structure, then pointer_offset holds an offset
93 of a pointer in this structure. */
95 /* If REG was promoted from the actual mode of the argument expression,
96 indicates whether the promotion is sign- or zero-extended. */
98 /* Number of bytes to put in registers. 0 means put the whole arg
99 in registers. Also 0 if not passed in registers. */
101 /* Nonzero if argument must be passed on stack.
102 Note that some arguments may be passed on the stack
103 even though pass_on_stack is zero, just because FUNCTION_ARG says so.
104 pass_on_stack identifies arguments that *cannot* go in registers. */
106 /* Some fields packaged up for locate_and_pad_parm. */
107 struct locate_and_pad_arg_data locate
;
108 /* Location on the stack at which parameter should be stored. The store
109 has already been done if STACK == VALUE. */
111 /* Location on the stack of the start of this argument slot. This can
112 differ from STACK if this arg pads downward. This location is known
113 to be aligned to TARGET_FUNCTION_ARG_BOUNDARY. */
115 /* Place that this stack area has been saved, if needed. */
117 /* If an argument's alignment does not permit direct copying into registers,
118 copy in smaller-sized pieces into pseudos. These are stored in a
119 block pointed to by this field. The next field says how many
120 word-sized pseudos we made. */
125 /* A vector of one char per byte of stack space. A byte if nonzero if
126 the corresponding stack location has been used.
127 This vector is used to prevent a function call within an argument from
128 clobbering any stack already set up. */
129 static char *stack_usage_map
;
131 /* Size of STACK_USAGE_MAP. */
132 static unsigned int highest_outgoing_arg_in_use
;
134 /* Assume that any stack location at this byte index is used,
135 without checking the contents of stack_usage_map. */
136 static unsigned HOST_WIDE_INT stack_usage_watermark
= HOST_WIDE_INT_M1U
;
138 /* A bitmap of virtual-incoming stack space. Bit is set if the corresponding
139 stack location's tail call argument has been already stored into the stack.
140 This bitmap is used to prevent sibling call optimization if function tries
141 to use parent's incoming argument slots when they have been already
142 overwritten with tail call arguments. */
143 static sbitmap stored_args_map
;
145 /* Assume that any virtual-incoming location at this byte index has been
146 stored, without checking the contents of stored_args_map. */
147 static unsigned HOST_WIDE_INT stored_args_watermark
;
149 /* stack_arg_under_construction is nonzero when an argument may be
150 initialized with a constructor call (including a C function that
151 returns a BLKmode struct) and expand_call must take special action
152 to make sure the object being constructed does not overlap the
153 argument list for the constructor call. */
154 static int stack_arg_under_construction
;
156 static void precompute_register_parameters (int, struct arg_data
*, int *);
157 static void store_bounds (struct arg_data
*, struct arg_data
*);
158 static int store_one_arg (struct arg_data
*, rtx
, int, int, int);
159 static void store_unaligned_arguments_into_pseudos (struct arg_data
*, int);
160 static int finalize_must_preallocate (int, int, struct arg_data
*,
162 static void precompute_arguments (int, struct arg_data
*);
163 static void compute_argument_addresses (struct arg_data
*, rtx
, int);
164 static rtx
rtx_for_function_call (tree
, tree
);
165 static void load_register_parameters (struct arg_data
*, int, rtx
*, int,
167 static int special_function_p (const_tree
, int);
168 static int check_sibcall_argument_overlap_1 (rtx
);
169 static int check_sibcall_argument_overlap (rtx_insn
*, struct arg_data
*, int);
171 static tree
split_complex_types (tree
);
173 #ifdef REG_PARM_STACK_SPACE
174 static rtx
save_fixed_argument_area (int, rtx
, int *, int *);
175 static void restore_fixed_argument_area (rtx
, rtx
, int, int);
178 /* Return true if bytes [LOWER_BOUND, UPPER_BOUND) of the outgoing
179 stack region might already be in use. */
182 stack_region_maybe_used_p (poly_uint64 lower_bound
, poly_uint64 upper_bound
,
183 unsigned int reg_parm_stack_space
)
185 unsigned HOST_WIDE_INT const_lower
, const_upper
;
186 const_lower
= constant_lower_bound (lower_bound
);
187 if (!upper_bound
.is_constant (&const_upper
))
188 const_upper
= HOST_WIDE_INT_M1U
;
190 if (const_upper
> stack_usage_watermark
)
193 /* Don't worry about things in the fixed argument area;
194 it has already been saved. */
195 const_lower
= MAX (const_lower
, reg_parm_stack_space
);
196 const_upper
= MIN (const_upper
, highest_outgoing_arg_in_use
);
197 for (unsigned HOST_WIDE_INT i
= const_lower
; i
< const_upper
; ++i
)
198 if (stack_usage_map
[i
])
203 /* Record that bytes [LOWER_BOUND, UPPER_BOUND) of the outgoing
204 stack region are now in use. */
207 mark_stack_region_used (poly_uint64 lower_bound
, poly_uint64 upper_bound
)
209 unsigned HOST_WIDE_INT const_lower
, const_upper
;
210 const_lower
= constant_lower_bound (lower_bound
);
211 if (upper_bound
.is_constant (&const_upper
))
212 for (unsigned HOST_WIDE_INT i
= const_lower
; i
< const_upper
; ++i
)
213 stack_usage_map
[i
] = 1;
215 stack_usage_watermark
= MIN (stack_usage_watermark
, const_lower
);
218 /* Force FUNEXP into a form suitable for the address of a CALL,
219 and return that as an rtx. Also load the static chain register
220 if FNDECL is a nested function.
222 CALL_FUSAGE points to a variable holding the prospective
223 CALL_INSN_FUNCTION_USAGE information. */
226 prepare_call_address (tree fndecl_or_type
, rtx funexp
, rtx static_chain_value
,
227 rtx
*call_fusage
, int reg_parm_seen
, int flags
)
229 /* Make a valid memory address and copy constants through pseudo-regs,
230 but not for a constant address if -fno-function-cse. */
231 if (GET_CODE (funexp
) != SYMBOL_REF
)
233 /* If it's an indirect call by descriptor, generate code to perform
234 runtime identification of the pointer and load the descriptor. */
235 if ((flags
& ECF_BY_DESCRIPTOR
) && !flag_trampolines
)
237 const int bit_val
= targetm
.calls
.custom_function_descriptors
;
238 rtx call_lab
= gen_label_rtx ();
240 gcc_assert (fndecl_or_type
&& TYPE_P (fndecl_or_type
));
242 = build_decl (UNKNOWN_LOCATION
, FUNCTION_DECL
, NULL_TREE
,
244 DECL_STATIC_CHAIN (fndecl_or_type
) = 1;
245 rtx chain
= targetm
.calls
.static_chain (fndecl_or_type
, false);
247 if (GET_MODE (funexp
) != Pmode
)
248 funexp
= convert_memory_address (Pmode
, funexp
);
250 /* Avoid long live ranges around function calls. */
251 funexp
= copy_to_mode_reg (Pmode
, funexp
);
254 emit_insn (gen_rtx_CLOBBER (VOIDmode
, chain
));
256 /* Emit the runtime identification pattern. */
257 rtx mask
= gen_rtx_AND (Pmode
, funexp
, GEN_INT (bit_val
));
258 emit_cmp_and_jump_insns (mask
, const0_rtx
, EQ
, NULL_RTX
, Pmode
, 1,
261 /* Statically predict the branch to very likely taken. */
262 rtx_insn
*insn
= get_last_insn ();
264 predict_insn_def (insn
, PRED_BUILTIN_EXPECT
, TAKEN
);
266 /* Load the descriptor. */
267 rtx mem
= gen_rtx_MEM (ptr_mode
,
268 plus_constant (Pmode
, funexp
, - bit_val
));
269 MEM_NOTRAP_P (mem
) = 1;
270 mem
= convert_memory_address (Pmode
, mem
);
271 emit_move_insn (chain
, mem
);
273 mem
= gen_rtx_MEM (ptr_mode
,
274 plus_constant (Pmode
, funexp
,
275 POINTER_SIZE
/ BITS_PER_UNIT
277 MEM_NOTRAP_P (mem
) = 1;
278 mem
= convert_memory_address (Pmode
, mem
);
279 emit_move_insn (funexp
, mem
);
281 emit_label (call_lab
);
285 use_reg (call_fusage
, chain
);
286 STATIC_CHAIN_REG_P (chain
) = 1;
289 /* Make sure we're not going to be overwritten below. */
290 gcc_assert (!static_chain_value
);
293 /* If we are using registers for parameters, force the
294 function address into a register now. */
295 funexp
= ((reg_parm_seen
296 && targetm
.small_register_classes_for_mode_p (FUNCTION_MODE
))
297 ? force_not_mem (memory_address (FUNCTION_MODE
, funexp
))
298 : memory_address (FUNCTION_MODE
, funexp
));
302 /* funexp could be a SYMBOL_REF represents a function pointer which is
303 of ptr_mode. In this case, it should be converted into address mode
304 to be a valid address for memory rtx pattern. See PR 64971. */
305 if (GET_MODE (funexp
) != Pmode
)
306 funexp
= convert_memory_address (Pmode
, funexp
);
308 if (!(flags
& ECF_SIBCALL
))
310 if (!NO_FUNCTION_CSE
&& optimize
&& ! flag_no_function_cse
)
311 funexp
= force_reg (Pmode
, funexp
);
315 if (static_chain_value
!= 0
316 && (TREE_CODE (fndecl_or_type
) != FUNCTION_DECL
317 || DECL_STATIC_CHAIN (fndecl_or_type
)))
321 chain
= targetm
.calls
.static_chain (fndecl_or_type
, false);
322 static_chain_value
= convert_memory_address (Pmode
, static_chain_value
);
324 emit_move_insn (chain
, static_chain_value
);
327 use_reg (call_fusage
, chain
);
328 STATIC_CHAIN_REG_P (chain
) = 1;
335 /* Generate instructions to call function FUNEXP,
336 and optionally pop the results.
337 The CALL_INSN is the first insn generated.
339 FNDECL is the declaration node of the function. This is given to the
340 hook TARGET_RETURN_POPS_ARGS to determine whether this function pops
343 FUNTYPE is the data type of the function. This is given to the hook
344 TARGET_RETURN_POPS_ARGS to determine whether this function pops its
345 own args. We used to allow an identifier for library functions, but
346 that doesn't work when the return type is an aggregate type and the
347 calling convention says that the pointer to this aggregate is to be
348 popped by the callee.
350 STACK_SIZE is the number of bytes of arguments on the stack,
351 ROUNDED_STACK_SIZE is that number rounded up to
352 PREFERRED_STACK_BOUNDARY; zero if the size is variable. This is
353 both to put into the call insn and to generate explicit popping
356 STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
357 It is zero if this call doesn't want a structure value.
359 NEXT_ARG_REG is the rtx that results from executing
360 targetm.calls.function_arg (&args_so_far, VOIDmode, void_type_node, true)
361 just after all the args have had their registers assigned.
362 This could be whatever you like, but normally it is the first
363 arg-register beyond those used for args in this call,
364 or 0 if all the arg-registers are used in this call.
365 It is passed on to `gen_call' so you can put this info in the call insn.
367 VALREG is a hard register in which a value is returned,
368 or 0 if the call does not return a value.
370 OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before
371 the args to this call were processed.
372 We restore `inhibit_defer_pop' to that value.
374 CALL_FUSAGE is either empty or an EXPR_LIST of USE expressions that
375 denote registers used by the called function. */
378 emit_call_1 (rtx funexp
, tree fntree ATTRIBUTE_UNUSED
, tree fndecl ATTRIBUTE_UNUSED
,
379 tree funtype ATTRIBUTE_UNUSED
,
380 poly_int64 stack_size ATTRIBUTE_UNUSED
,
381 poly_int64 rounded_stack_size
,
382 poly_int64 struct_value_size ATTRIBUTE_UNUSED
,
383 rtx next_arg_reg ATTRIBUTE_UNUSED
, rtx valreg
,
384 int old_inhibit_defer_pop
, rtx call_fusage
, int ecf_flags
,
385 cumulative_args_t args_so_far ATTRIBUTE_UNUSED
)
387 rtx rounded_stack_size_rtx
= gen_int_mode (rounded_stack_size
, Pmode
);
388 rtx call
, funmem
, pat
;
389 int already_popped
= 0;
390 poly_int64 n_popped
= 0;
392 /* Sibling call patterns never pop arguments (no sibcall(_value)_pop
393 patterns exist). Any popping that the callee does on return will
394 be from our caller's frame rather than ours. */
395 if (!(ecf_flags
& ECF_SIBCALL
))
397 n_popped
+= targetm
.calls
.return_pops_args (fndecl
, funtype
, stack_size
);
399 #ifdef CALL_POPS_ARGS
400 n_popped
+= CALL_POPS_ARGS (*get_cumulative_args (args_so_far
));
404 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
405 and we don't want to load it into a register as an optimization,
406 because prepare_call_address already did it if it should be done. */
407 if (GET_CODE (funexp
) != SYMBOL_REF
)
408 funexp
= memory_address (FUNCTION_MODE
, funexp
);
410 funmem
= gen_rtx_MEM (FUNCTION_MODE
, funexp
);
411 if (fndecl
&& TREE_CODE (fndecl
) == FUNCTION_DECL
)
415 /* Although a built-in FUNCTION_DECL and its non-__builtin
416 counterpart compare equal and get a shared mem_attrs, they
417 produce different dump output in compare-debug compilations,
418 if an entry gets garbage collected in one compilation, then
419 adds a different (but equivalent) entry, while the other
420 doesn't run the garbage collector at the same spot and then
421 shares the mem_attr with the equivalent entry. */
422 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
424 tree t2
= builtin_decl_explicit (DECL_FUNCTION_CODE (t
));
429 set_mem_expr (funmem
, t
);
432 set_mem_expr (funmem
, build_simple_mem_ref (CALL_EXPR_FN (fntree
)));
434 if (ecf_flags
& ECF_SIBCALL
)
437 pat
= targetm
.gen_sibcall_value (valreg
, funmem
,
438 rounded_stack_size_rtx
,
439 next_arg_reg
, NULL_RTX
);
441 pat
= targetm
.gen_sibcall (funmem
, rounded_stack_size_rtx
,
443 gen_int_mode (struct_value_size
, Pmode
));
445 /* If the target has "call" or "call_value" insns, then prefer them
446 if no arguments are actually popped. If the target does not have
447 "call" or "call_value" insns, then we must use the popping versions
448 even if the call has no arguments to pop. */
449 else if (maybe_ne (n_popped
, 0)
451 ? targetm
.have_call_value ()
452 : targetm
.have_call ()))
454 rtx n_pop
= gen_int_mode (n_popped
, Pmode
);
456 /* If this subroutine pops its own args, record that in the call insn
457 if possible, for the sake of frame pointer elimination. */
460 pat
= targetm
.gen_call_value_pop (valreg
, funmem
,
461 rounded_stack_size_rtx
,
462 next_arg_reg
, n_pop
);
464 pat
= targetm
.gen_call_pop (funmem
, rounded_stack_size_rtx
,
465 next_arg_reg
, n_pop
);
472 pat
= targetm
.gen_call_value (valreg
, funmem
, rounded_stack_size_rtx
,
473 next_arg_reg
, NULL_RTX
);
475 pat
= targetm
.gen_call (funmem
, rounded_stack_size_rtx
, next_arg_reg
,
476 gen_int_mode (struct_value_size
, Pmode
));
480 /* Find the call we just emitted. */
481 rtx_call_insn
*call_insn
= last_call_insn ();
483 /* Some target create a fresh MEM instead of reusing the one provided
484 above. Set its MEM_EXPR. */
485 call
= get_call_rtx_from (call_insn
);
487 && MEM_EXPR (XEXP (call
, 0)) == NULL_TREE
488 && MEM_EXPR (funmem
) != NULL_TREE
)
489 set_mem_expr (XEXP (call
, 0), MEM_EXPR (funmem
));
491 /* Mark instrumented calls. */
493 CALL_EXPR_WITH_BOUNDS_P (call
) = CALL_WITH_BOUNDS_P (fntree
);
495 /* Put the register usage information there. */
496 add_function_usage_to (call_insn
, call_fusage
);
498 /* If this is a const call, then set the insn's unchanging bit. */
499 if (ecf_flags
& ECF_CONST
)
500 RTL_CONST_CALL_P (call_insn
) = 1;
502 /* If this is a pure call, then set the insn's unchanging bit. */
503 if (ecf_flags
& ECF_PURE
)
504 RTL_PURE_CALL_P (call_insn
) = 1;
506 /* If this is a const call, then set the insn's unchanging bit. */
507 if (ecf_flags
& ECF_LOOPING_CONST_OR_PURE
)
508 RTL_LOOPING_CONST_OR_PURE_CALL_P (call_insn
) = 1;
510 /* Create a nothrow REG_EH_REGION note, if needed. */
511 make_reg_eh_region_note (call_insn
, ecf_flags
, 0);
513 if (ecf_flags
& ECF_NORETURN
)
514 add_reg_note (call_insn
, REG_NORETURN
, const0_rtx
);
516 if (ecf_flags
& ECF_RETURNS_TWICE
)
518 add_reg_note (call_insn
, REG_SETJMP
, const0_rtx
);
519 cfun
->calls_setjmp
= 1;
522 SIBLING_CALL_P (call_insn
) = ((ecf_flags
& ECF_SIBCALL
) != 0);
524 /* Restore this now, so that we do defer pops for this call's args
525 if the context of the call as a whole permits. */
526 inhibit_defer_pop
= old_inhibit_defer_pop
;
528 if (maybe_ne (n_popped
, 0))
531 CALL_INSN_FUNCTION_USAGE (call_insn
)
532 = gen_rtx_EXPR_LIST (VOIDmode
,
533 gen_rtx_CLOBBER (VOIDmode
, stack_pointer_rtx
),
534 CALL_INSN_FUNCTION_USAGE (call_insn
));
535 rounded_stack_size
-= n_popped
;
536 rounded_stack_size_rtx
= gen_int_mode (rounded_stack_size
, Pmode
);
537 stack_pointer_delta
-= n_popped
;
539 add_args_size_note (call_insn
, stack_pointer_delta
);
541 /* If popup is needed, stack realign must use DRAP */
542 if (SUPPORTS_STACK_ALIGNMENT
)
543 crtl
->need_drap
= true;
545 /* For noreturn calls when not accumulating outgoing args force
546 REG_ARGS_SIZE note to prevent crossjumping of calls with different
548 else if (!ACCUMULATE_OUTGOING_ARGS
&& (ecf_flags
& ECF_NORETURN
) != 0)
549 add_args_size_note (call_insn
, stack_pointer_delta
);
551 if (!ACCUMULATE_OUTGOING_ARGS
)
553 /* If returning from the subroutine does not automatically pop the args,
554 we need an instruction to pop them sooner or later.
555 Perhaps do it now; perhaps just record how much space to pop later.
557 If returning from the subroutine does pop the args, indicate that the
558 stack pointer will be changed. */
560 if (maybe_ne (rounded_stack_size
, 0))
562 if (ecf_flags
& ECF_NORETURN
)
563 /* Just pretend we did the pop. */
564 stack_pointer_delta
-= rounded_stack_size
;
565 else if (flag_defer_pop
&& inhibit_defer_pop
== 0
566 && ! (ecf_flags
& (ECF_CONST
| ECF_PURE
)))
567 pending_stack_adjust
+= rounded_stack_size
;
569 adjust_stack (rounded_stack_size_rtx
);
572 /* When we accumulate outgoing args, we must avoid any stack manipulations.
573 Restore the stack pointer to its original value now. Usually
574 ACCUMULATE_OUTGOING_ARGS targets don't get here, but there are exceptions.
575 On i386 ACCUMULATE_OUTGOING_ARGS can be enabled on demand, and
576 popping variants of functions exist as well.
578 ??? We may optimize similar to defer_pop above, but it is
579 probably not worthwhile.
581 ??? It will be worthwhile to enable combine_stack_adjustments even for
583 else if (maybe_ne (n_popped
, 0))
584 anti_adjust_stack (gen_int_mode (n_popped
, Pmode
));
587 /* Determine if the function identified by FNDECL is one with
588 special properties we wish to know about. Modify FLAGS accordingly.
590 For example, if the function might return more than one time (setjmp), then
591 set ECF_RETURNS_TWICE.
593 Set ECF_MAY_BE_ALLOCA for any memory allocation function that might allocate
594 space from the stack such as alloca. */
597 special_function_p (const_tree fndecl
, int flags
)
599 tree name_decl
= DECL_NAME (fndecl
);
601 /* For instrumentation clones we want to derive flags
602 from the original name. */
603 if (cgraph_node::get (fndecl
)
604 && cgraph_node::get (fndecl
)->instrumentation_clone
)
605 name_decl
= DECL_NAME (cgraph_node::get (fndecl
)->orig_decl
);
607 if (fndecl
&& name_decl
608 && IDENTIFIER_LENGTH (name_decl
) <= 11
609 /* Exclude functions not at the file scope, or not `extern',
610 since they are not the magic functions we would otherwise
612 FIXME: this should be handled with attributes, not with this
613 hacky imitation of DECL_ASSEMBLER_NAME. It's (also) wrong
614 because you can declare fork() inside a function if you
616 && (DECL_CONTEXT (fndecl
) == NULL_TREE
617 || TREE_CODE (DECL_CONTEXT (fndecl
)) == TRANSLATION_UNIT_DECL
)
618 && TREE_PUBLIC (fndecl
))
620 const char *name
= IDENTIFIER_POINTER (name_decl
);
621 const char *tname
= name
;
623 /* We assume that alloca will always be called by name. It
624 makes no sense to pass it as a pointer-to-function to
625 anything that does not understand its behavior. */
626 if (IDENTIFIER_LENGTH (name_decl
) == 6
628 && ! strcmp (name
, "alloca"))
629 flags
|= ECF_MAY_BE_ALLOCA
;
631 /* Disregard prefix _ or __. */
640 /* ECF_RETURNS_TWICE is safe even for -ffreestanding. */
641 if (! strcmp (tname
, "setjmp")
642 || ! strcmp (tname
, "sigsetjmp")
643 || ! strcmp (name
, "savectx")
644 || ! strcmp (name
, "vfork")
645 || ! strcmp (name
, "getcontext"))
646 flags
|= ECF_RETURNS_TWICE
;
649 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
650 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl
)))
651 flags
|= ECF_MAY_BE_ALLOCA
;
656 /* Similar to special_function_p; return a set of ERF_ flags for the
659 decl_return_flags (tree fndecl
)
662 tree type
= TREE_TYPE (fndecl
);
666 attr
= lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type
));
670 attr
= TREE_VALUE (TREE_VALUE (attr
));
671 if (!attr
|| TREE_STRING_LENGTH (attr
) < 1)
674 switch (TREE_STRING_POINTER (attr
)[0])
680 return ERF_RETURNS_ARG
| (TREE_STRING_POINTER (attr
)[0] - '1');
691 /* Return nonzero when FNDECL represents a call to setjmp. */
694 setjmp_call_p (const_tree fndecl
)
696 if (DECL_IS_RETURNS_TWICE (fndecl
))
697 return ECF_RETURNS_TWICE
;
698 return special_function_p (fndecl
, 0) & ECF_RETURNS_TWICE
;
702 /* Return true if STMT may be an alloca call. */
705 gimple_maybe_alloca_call_p (const gimple
*stmt
)
709 if (!is_gimple_call (stmt
))
712 fndecl
= gimple_call_fndecl (stmt
);
713 if (fndecl
&& (special_function_p (fndecl
, 0) & ECF_MAY_BE_ALLOCA
))
719 /* Return true if STMT is a builtin alloca call. */
722 gimple_alloca_call_p (const gimple
*stmt
)
726 if (!is_gimple_call (stmt
))
729 fndecl
= gimple_call_fndecl (stmt
);
730 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
731 switch (DECL_FUNCTION_CODE (fndecl
))
733 CASE_BUILT_IN_ALLOCA
:
734 return gimple_call_num_args (stmt
) > 0;
742 /* Return true when exp contains a builtin alloca call. */
745 alloca_call_p (const_tree exp
)
748 if (TREE_CODE (exp
) == CALL_EXPR
749 && (fndecl
= get_callee_fndecl (exp
))
750 && DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
751 switch (DECL_FUNCTION_CODE (fndecl
))
753 CASE_BUILT_IN_ALLOCA
:
762 /* Return TRUE if FNDECL is either a TM builtin or a TM cloned
763 function. Return FALSE otherwise. */
766 is_tm_builtin (const_tree fndecl
)
771 if (decl_is_tm_clone (fndecl
))
774 if (DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
776 switch (DECL_FUNCTION_CODE (fndecl
))
778 case BUILT_IN_TM_COMMIT
:
779 case BUILT_IN_TM_COMMIT_EH
:
780 case BUILT_IN_TM_ABORT
:
781 case BUILT_IN_TM_IRREVOCABLE
:
782 case BUILT_IN_TM_GETTMCLONE_IRR
:
783 case BUILT_IN_TM_MEMCPY
:
784 case BUILT_IN_TM_MEMMOVE
:
785 case BUILT_IN_TM_MEMSET
:
786 CASE_BUILT_IN_TM_STORE (1):
787 CASE_BUILT_IN_TM_STORE (2):
788 CASE_BUILT_IN_TM_STORE (4):
789 CASE_BUILT_IN_TM_STORE (8):
790 CASE_BUILT_IN_TM_STORE (FLOAT
):
791 CASE_BUILT_IN_TM_STORE (DOUBLE
):
792 CASE_BUILT_IN_TM_STORE (LDOUBLE
):
793 CASE_BUILT_IN_TM_STORE (M64
):
794 CASE_BUILT_IN_TM_STORE (M128
):
795 CASE_BUILT_IN_TM_STORE (M256
):
796 CASE_BUILT_IN_TM_LOAD (1):
797 CASE_BUILT_IN_TM_LOAD (2):
798 CASE_BUILT_IN_TM_LOAD (4):
799 CASE_BUILT_IN_TM_LOAD (8):
800 CASE_BUILT_IN_TM_LOAD (FLOAT
):
801 CASE_BUILT_IN_TM_LOAD (DOUBLE
):
802 CASE_BUILT_IN_TM_LOAD (LDOUBLE
):
803 CASE_BUILT_IN_TM_LOAD (M64
):
804 CASE_BUILT_IN_TM_LOAD (M128
):
805 CASE_BUILT_IN_TM_LOAD (M256
):
806 case BUILT_IN_TM_LOG
:
807 case BUILT_IN_TM_LOG_1
:
808 case BUILT_IN_TM_LOG_2
:
809 case BUILT_IN_TM_LOG_4
:
810 case BUILT_IN_TM_LOG_8
:
811 case BUILT_IN_TM_LOG_FLOAT
:
812 case BUILT_IN_TM_LOG_DOUBLE
:
813 case BUILT_IN_TM_LOG_LDOUBLE
:
814 case BUILT_IN_TM_LOG_M64
:
815 case BUILT_IN_TM_LOG_M128
:
816 case BUILT_IN_TM_LOG_M256
:
825 /* Detect flags (function attributes) from the function decl or type node. */
828 flags_from_decl_or_type (const_tree exp
)
834 /* The function exp may have the `malloc' attribute. */
835 if (DECL_IS_MALLOC (exp
))
838 /* The function exp may have the `returns_twice' attribute. */
839 if (DECL_IS_RETURNS_TWICE (exp
))
840 flags
|= ECF_RETURNS_TWICE
;
842 /* Process the pure and const attributes. */
843 if (TREE_READONLY (exp
))
845 if (DECL_PURE_P (exp
))
847 if (DECL_LOOPING_CONST_OR_PURE_P (exp
))
848 flags
|= ECF_LOOPING_CONST_OR_PURE
;
850 if (DECL_IS_NOVOPS (exp
))
852 if (lookup_attribute ("leaf", DECL_ATTRIBUTES (exp
)))
854 if (lookup_attribute ("cold", DECL_ATTRIBUTES (exp
)))
857 if (TREE_NOTHROW (exp
))
858 flags
|= ECF_NOTHROW
;
862 if (is_tm_builtin (exp
))
863 flags
|= ECF_TM_BUILTIN
;
864 else if ((flags
& (ECF_CONST
|ECF_NOVOPS
)) != 0
865 || lookup_attribute ("transaction_pure",
866 TYPE_ATTRIBUTES (TREE_TYPE (exp
))))
867 flags
|= ECF_TM_PURE
;
870 flags
= special_function_p (exp
, flags
);
872 else if (TYPE_P (exp
))
874 if (TYPE_READONLY (exp
))
878 && ((flags
& ECF_CONST
) != 0
879 || lookup_attribute ("transaction_pure", TYPE_ATTRIBUTES (exp
))))
880 flags
|= ECF_TM_PURE
;
885 if (TREE_THIS_VOLATILE (exp
))
887 flags
|= ECF_NORETURN
;
888 if (flags
& (ECF_CONST
|ECF_PURE
))
889 flags
|= ECF_LOOPING_CONST_OR_PURE
;
895 /* Detect flags from a CALL_EXPR. */
898 call_expr_flags (const_tree t
)
901 tree decl
= get_callee_fndecl (t
);
904 flags
= flags_from_decl_or_type (decl
);
905 else if (CALL_EXPR_FN (t
) == NULL_TREE
)
906 flags
= internal_fn_flags (CALL_EXPR_IFN (t
));
909 tree type
= TREE_TYPE (CALL_EXPR_FN (t
));
910 if (type
&& TREE_CODE (type
) == POINTER_TYPE
)
911 flags
= flags_from_decl_or_type (TREE_TYPE (type
));
914 if (CALL_EXPR_BY_DESCRIPTOR (t
))
915 flags
|= ECF_BY_DESCRIPTOR
;
921 /* Return true if TYPE should be passed by invisible reference. */
924 pass_by_reference (CUMULATIVE_ARGS
*ca
, machine_mode mode
,
925 tree type
, bool named_arg
)
929 /* If this type contains non-trivial constructors, then it is
930 forbidden for the middle-end to create any new copies. */
931 if (TREE_ADDRESSABLE (type
))
934 /* GCC post 3.4 passes *all* variable sized types by reference. */
935 if (!TYPE_SIZE (type
) || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
938 /* If a record type should be passed the same as its first (and only)
939 member, use the type and mode of that member. */
940 if (TREE_CODE (type
) == RECORD_TYPE
&& TYPE_TRANSPARENT_AGGR (type
))
942 type
= TREE_TYPE (first_field (type
));
943 mode
= TYPE_MODE (type
);
947 return targetm
.calls
.pass_by_reference (pack_cumulative_args (ca
), mode
,
951 /* Return true if TYPE, which is passed by reference, should be callee
952 copied instead of caller copied. */
955 reference_callee_copied (CUMULATIVE_ARGS
*ca
, machine_mode mode
,
956 tree type
, bool named_arg
)
958 if (type
&& TREE_ADDRESSABLE (type
))
960 return targetm
.calls
.callee_copies (pack_cumulative_args (ca
), mode
, type
,
965 /* Precompute all register parameters as described by ARGS, storing values
966 into fields within the ARGS array.
968 NUM_ACTUALS indicates the total number elements in the ARGS array.
970 Set REG_PARM_SEEN if we encounter a register parameter. */
973 precompute_register_parameters (int num_actuals
, struct arg_data
*args
,
980 for (i
= 0; i
< num_actuals
; i
++)
981 if (args
[i
].reg
!= 0 && ! args
[i
].pass_on_stack
)
985 if (args
[i
].value
== 0)
988 args
[i
].value
= expand_normal (args
[i
].tree_value
);
989 preserve_temp_slots (args
[i
].value
);
993 /* If we are to promote the function arg to a wider mode,
996 if (args
[i
].mode
!= TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)))
998 = convert_modes (args
[i
].mode
,
999 TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)),
1000 args
[i
].value
, args
[i
].unsignedp
);
1002 /* If the value is a non-legitimate constant, force it into a
1003 pseudo now. TLS symbols sometimes need a call to resolve. */
1004 if (CONSTANT_P (args
[i
].value
)
1005 && !targetm
.legitimate_constant_p (args
[i
].mode
, args
[i
].value
))
1006 args
[i
].value
= force_reg (args
[i
].mode
, args
[i
].value
);
1008 /* If we're going to have to load the value by parts, pull the
1009 parts into pseudos. The part extraction process can involve
1010 non-trivial computation. */
1011 if (GET_CODE (args
[i
].reg
) == PARALLEL
)
1013 tree type
= TREE_TYPE (args
[i
].tree_value
);
1014 args
[i
].parallel_value
1015 = emit_group_load_into_temps (args
[i
].reg
, args
[i
].value
,
1016 type
, int_size_in_bytes (type
));
1019 /* If the value is expensive, and we are inside an appropriately
1020 short loop, put the value into a pseudo and then put the pseudo
1023 For small register classes, also do this if this call uses
1024 register parameters. This is to avoid reload conflicts while
1025 loading the parameters registers. */
1027 else if ((! (REG_P (args
[i
].value
)
1028 || (GET_CODE (args
[i
].value
) == SUBREG
1029 && REG_P (SUBREG_REG (args
[i
].value
)))))
1030 && args
[i
].mode
!= BLKmode
1031 && (set_src_cost (args
[i
].value
, args
[i
].mode
,
1032 optimize_insn_for_speed_p ())
1033 > COSTS_N_INSNS (1))
1035 && targetm
.small_register_classes_for_mode_p (args
[i
].mode
))
1037 args
[i
].value
= copy_to_mode_reg (args
[i
].mode
, args
[i
].value
);
1041 #ifdef REG_PARM_STACK_SPACE
1043 /* The argument list is the property of the called routine and it
1044 may clobber it. If the fixed area has been used for previous
1045 parameters, we must save and restore it. */
1048 save_fixed_argument_area (int reg_parm_stack_space
, rtx argblock
, int *low_to_save
, int *high_to_save
)
1053 /* Compute the boundary of the area that needs to be saved, if any. */
1054 high
= reg_parm_stack_space
;
1055 if (ARGS_GROW_DOWNWARD
)
1058 if (high
> highest_outgoing_arg_in_use
)
1059 high
= highest_outgoing_arg_in_use
;
1061 for (low
= 0; low
< high
; low
++)
1062 if (stack_usage_map
[low
] != 0 || low
>= stack_usage_watermark
)
1065 machine_mode save_mode
;
1071 while (stack_usage_map
[--high
] == 0)
1075 *high_to_save
= high
;
1077 num_to_save
= high
- low
+ 1;
1079 /* If we don't have the required alignment, must do this
1081 scalar_int_mode imode
;
1082 if (int_mode_for_size (num_to_save
* BITS_PER_UNIT
, 1).exists (&imode
)
1083 && (low
& (MIN (GET_MODE_SIZE (imode
),
1084 BIGGEST_ALIGNMENT
/ UNITS_PER_WORD
) - 1)) == 0)
1087 save_mode
= BLKmode
;
1089 if (ARGS_GROW_DOWNWARD
)
1094 addr
= plus_constant (Pmode
, argblock
, delta
);
1095 stack_area
= gen_rtx_MEM (save_mode
, memory_address (save_mode
, addr
));
1097 set_mem_align (stack_area
, PARM_BOUNDARY
);
1098 if (save_mode
== BLKmode
)
1100 save_area
= assign_stack_temp (BLKmode
, num_to_save
);
1101 emit_block_move (validize_mem (save_area
), stack_area
,
1102 GEN_INT (num_to_save
), BLOCK_OP_CALL_PARM
);
1106 save_area
= gen_reg_rtx (save_mode
);
1107 emit_move_insn (save_area
, stack_area
);
1117 restore_fixed_argument_area (rtx save_area
, rtx argblock
, int high_to_save
, int low_to_save
)
1119 machine_mode save_mode
= GET_MODE (save_area
);
1121 rtx addr
, stack_area
;
1123 if (ARGS_GROW_DOWNWARD
)
1124 delta
= -high_to_save
;
1126 delta
= low_to_save
;
1128 addr
= plus_constant (Pmode
, argblock
, delta
);
1129 stack_area
= gen_rtx_MEM (save_mode
, memory_address (save_mode
, addr
));
1130 set_mem_align (stack_area
, PARM_BOUNDARY
);
1132 if (save_mode
!= BLKmode
)
1133 emit_move_insn (stack_area
, save_area
);
1135 emit_block_move (stack_area
, validize_mem (save_area
),
1136 GEN_INT (high_to_save
- low_to_save
+ 1),
1137 BLOCK_OP_CALL_PARM
);
1139 #endif /* REG_PARM_STACK_SPACE */
1141 /* If any elements in ARGS refer to parameters that are to be passed in
1142 registers, but not in memory, and whose alignment does not permit a
1143 direct copy into registers. Copy the values into a group of pseudos
1144 which we will later copy into the appropriate hard registers.
1146 Pseudos for each unaligned argument will be stored into the array
1147 args[argnum].aligned_regs. The caller is responsible for deallocating
1148 the aligned_regs array if it is nonzero. */
1151 store_unaligned_arguments_into_pseudos (struct arg_data
*args
, int num_actuals
)
1155 for (i
= 0; i
< num_actuals
; i
++)
1156 if (args
[i
].reg
!= 0 && ! args
[i
].pass_on_stack
1157 && GET_CODE (args
[i
].reg
) != PARALLEL
1158 && args
[i
].mode
== BLKmode
1159 && MEM_P (args
[i
].value
)
1160 && (MEM_ALIGN (args
[i
].value
)
1161 < (unsigned int) MIN (BIGGEST_ALIGNMENT
, BITS_PER_WORD
)))
1163 int bytes
= int_size_in_bytes (TREE_TYPE (args
[i
].tree_value
));
1164 int endian_correction
= 0;
1166 if (args
[i
].partial
)
1168 gcc_assert (args
[i
].partial
% UNITS_PER_WORD
== 0);
1169 args
[i
].n_aligned_regs
= args
[i
].partial
/ UNITS_PER_WORD
;
1173 args
[i
].n_aligned_regs
1174 = (bytes
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
1177 args
[i
].aligned_regs
= XNEWVEC (rtx
, args
[i
].n_aligned_regs
);
1179 /* Structures smaller than a word are normally aligned to the
1180 least significant byte. On a BYTES_BIG_ENDIAN machine,
1181 this means we must skip the empty high order bytes when
1182 calculating the bit offset. */
1183 if (bytes
< UNITS_PER_WORD
1184 #ifdef BLOCK_REG_PADDING
1185 && (BLOCK_REG_PADDING (args
[i
].mode
,
1186 TREE_TYPE (args
[i
].tree_value
), 1)
1192 endian_correction
= BITS_PER_WORD
- bytes
* BITS_PER_UNIT
;
1194 for (j
= 0; j
< args
[i
].n_aligned_regs
; j
++)
1196 rtx reg
= gen_reg_rtx (word_mode
);
1197 rtx word
= operand_subword_force (args
[i
].value
, j
, BLKmode
);
1198 int bitsize
= MIN (bytes
* BITS_PER_UNIT
, BITS_PER_WORD
);
1200 args
[i
].aligned_regs
[j
] = reg
;
1201 word
= extract_bit_field (word
, bitsize
, 0, 1, NULL_RTX
,
1202 word_mode
, word_mode
, false, NULL
);
1204 /* There is no need to restrict this code to loading items
1205 in TYPE_ALIGN sized hunks. The bitfield instructions can
1206 load up entire word sized registers efficiently.
1208 ??? This may not be needed anymore.
1209 We use to emit a clobber here but that doesn't let later
1210 passes optimize the instructions we emit. By storing 0 into
1211 the register later passes know the first AND to zero out the
1212 bitfield being set in the register is unnecessary. The store
1213 of 0 will be deleted as will at least the first AND. */
1215 emit_move_insn (reg
, const0_rtx
);
1217 bytes
-= bitsize
/ BITS_PER_UNIT
;
1218 store_bit_field (reg
, bitsize
, endian_correction
, 0, 0,
1219 word_mode
, word
, false);
1224 /* The limit set by -Walloc-larger-than=. */
1225 static GTY(()) tree alloc_object_size_limit
;
1227 /* Initialize ALLOC_OBJECT_SIZE_LIMIT based on the -Walloc-size-larger-than=
1228 setting if the option is specified, or to the maximum object size if it
1229 is not. Return the initialized value. */
1232 alloc_max_size (void)
1234 if (!alloc_object_size_limit
)
1236 alloc_object_size_limit
= max_object_size ();
1238 if (warn_alloc_size_limit
)
1242 unsigned HOST_WIDE_INT unit
= 1;
1243 unsigned HOST_WIDE_INT limit
1244 = strtoull (warn_alloc_size_limit
, &end
, 10);
1250 /* Numeric option arguments are at most INT_MAX. Make it
1251 possible to specify a larger value by accepting common
1253 if (!strcmp (end
, "kB"))
1255 else if (!strcasecmp (end
, "KiB") || strcmp (end
, "KB"))
1257 else if (!strcmp (end
, "MB"))
1258 unit
= HOST_WIDE_INT_UC (1000) * 1000;
1259 else if (!strcasecmp (end
, "MiB"))
1260 unit
= HOST_WIDE_INT_UC (1024) * 1024;
1261 else if (!strcasecmp (end
, "GB"))
1262 unit
= HOST_WIDE_INT_UC (1000) * 1000 * 1000;
1263 else if (!strcasecmp (end
, "GiB"))
1264 unit
= HOST_WIDE_INT_UC (1024) * 1024 * 1024;
1265 else if (!strcasecmp (end
, "TB"))
1266 unit
= HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000;
1267 else if (!strcasecmp (end
, "TiB"))
1268 unit
= HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024;
1269 else if (!strcasecmp (end
, "PB"))
1270 unit
= HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000 * 1000;
1271 else if (!strcasecmp (end
, "PiB"))
1272 unit
= HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024 * 1024;
1273 else if (!strcasecmp (end
, "EB"))
1274 unit
= HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000 * 1000
1276 else if (!strcasecmp (end
, "EiB"))
1277 unit
= HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024 * 1024
1285 widest_int w
= wi::mul (limit
, unit
);
1286 if (w
< wi::to_widest (alloc_object_size_limit
))
1287 alloc_object_size_limit
1288 = wide_int_to_tree (ptrdiff_type_node
, w
);
1293 return alloc_object_size_limit
;
1296 /* Return true when EXP's range can be determined and set RANGE[] to it
1297 after adjusting it if necessary to make EXP a represents a valid size
1298 of object, or a valid size argument to an allocation function declared
1299 with attribute alloc_size (whose argument may be signed), or to a string
1300 manipulation function like memset. When ALLOW_ZERO is true, allow
1301 returning a range of [0, 0] for a size in an anti-range [1, N] where
1302 N > PTRDIFF_MAX. A zero range is a (nearly) invalid argument to
1303 allocation functions like malloc but it is a valid argument to
1304 functions like memset. */
1307 get_size_range (tree exp
, tree range
[2], bool allow_zero
/* = false */)
1309 if (tree_fits_uhwi_p (exp
))
1311 /* EXP is a constant. */
1312 range
[0] = range
[1] = exp
;
1316 tree exptype
= TREE_TYPE (exp
);
1317 bool integral
= INTEGRAL_TYPE_P (exptype
);
1320 enum value_range_type range_type
;
1322 if (TREE_CODE (exp
) == SSA_NAME
&& integral
)
1323 range_type
= get_range_info (exp
, &min
, &max
);
1325 range_type
= VR_VARYING
;
1327 if (range_type
== VR_VARYING
)
1331 /* Use the full range of the type of the expression when
1332 no value range information is available. */
1333 range
[0] = TYPE_MIN_VALUE (exptype
);
1334 range
[1] = TYPE_MAX_VALUE (exptype
);
1338 range
[0] = NULL_TREE
;
1339 range
[1] = NULL_TREE
;
1343 unsigned expprec
= TYPE_PRECISION (exptype
);
1345 bool signed_p
= !TYPE_UNSIGNED (exptype
);
1347 if (range_type
== VR_ANTI_RANGE
)
1351 if (wi::les_p (max
, 0))
1353 /* EXP is not in a strictly negative range. That means
1354 it must be in some (not necessarily strictly) positive
1355 range which includes zero. Since in signed to unsigned
1356 conversions negative values end up converted to large
1357 positive values, and otherwise they are not valid sizes,
1358 the resulting range is in both cases [0, TYPE_MAX]. */
1359 min
= wi::zero (expprec
);
1360 max
= wi::to_wide (TYPE_MAX_VALUE (exptype
));
1362 else if (wi::les_p (min
- 1, 0))
1364 /* EXP is not in a negative-positive range. That means EXP
1365 is either negative, or greater than max. Since negative
1366 sizes are invalid make the range [MAX + 1, TYPE_MAX]. */
1368 max
= wi::to_wide (TYPE_MAX_VALUE (exptype
));
1373 min
= wi::zero (expprec
);
1376 else if (wi::eq_p (0, min
- 1))
1378 /* EXP is unsigned and not in the range [1, MAX]. That means
1379 it's either zero or greater than MAX. Even though 0 would
1380 normally be detected by -Walloc-zero, unless ALLOW_ZERO
1381 is true, set the range to [MAX, TYPE_MAX] so that when MAX
1382 is greater than the limit the whole range is diagnosed. */
1384 min
= max
= wi::zero (expprec
);
1388 max
= wi::to_wide (TYPE_MAX_VALUE (exptype
));
1394 min
= wi::zero (expprec
);
1398 range
[0] = wide_int_to_tree (exptype
, min
);
1399 range
[1] = wide_int_to_tree (exptype
, max
);
1404 /* Diagnose a call EXP to function FN decorated with attribute alloc_size
1405 whose argument numbers given by IDX with values given by ARGS exceed
1406 the maximum object size or cause an unsigned oveflow (wrapping) when
1407 multiplied. When ARGS[0] is null the function does nothing. ARGS[1]
1408 may be null for functions like malloc, and non-null for those like
1409 calloc that are decorated with a two-argument attribute alloc_size. */
1412 maybe_warn_alloc_args_overflow (tree fn
, tree exp
, tree args
[2], int idx
[2])
1414 /* The range each of the (up to) two arguments is known to be in. */
1415 tree argrange
[2][2] = { { NULL_TREE
, NULL_TREE
}, { NULL_TREE
, NULL_TREE
} };
1417 /* Maximum object size set by -Walloc-size-larger-than= or SIZE_MAX / 2. */
1418 tree maxobjsize
= alloc_max_size ();
1420 location_t loc
= EXPR_LOCATION (exp
);
1422 bool warned
= false;
1424 /* Validate each argument individually. */
1425 for (unsigned i
= 0; i
!= 2 && args
[i
]; ++i
)
1427 if (TREE_CODE (args
[i
]) == INTEGER_CST
)
1429 argrange
[i
][0] = args
[i
];
1430 argrange
[i
][1] = args
[i
];
1432 if (tree_int_cst_lt (args
[i
], integer_zero_node
))
1434 warned
= warning_at (loc
, OPT_Walloc_size_larger_than_
,
1435 "%Kargument %i value %qE is negative",
1436 exp
, idx
[i
] + 1, args
[i
]);
1438 else if (integer_zerop (args
[i
]))
1440 /* Avoid issuing -Walloc-zero for allocation functions other
1441 than __builtin_alloca that are declared with attribute
1442 returns_nonnull because there's no portability risk. This
1443 avoids warning for such calls to libiberty's xmalloc and
1445 Also avoid issuing the warning for calls to function named
1447 if ((DECL_FUNCTION_CODE (fn
) == BUILT_IN_ALLOCA
1448 && IDENTIFIER_LENGTH (DECL_NAME (fn
)) != 6)
1449 || (DECL_FUNCTION_CODE (fn
) != BUILT_IN_ALLOCA
1450 && !lookup_attribute ("returns_nonnull",
1451 TYPE_ATTRIBUTES (TREE_TYPE (fn
)))))
1452 warned
= warning_at (loc
, OPT_Walloc_zero
,
1453 "%Kargument %i value is zero",
1456 else if (tree_int_cst_lt (maxobjsize
, args
[i
]))
1458 /* G++ emits calls to ::operator new[](SIZE_MAX) in C++98
1459 mode and with -fno-exceptions as a way to indicate array
1460 size overflow. There's no good way to detect C++98 here
1461 so avoid diagnosing these calls for all C++ modes. */
1465 && DECL_IS_OPERATOR_NEW (fn
)
1466 && integer_all_onesp (args
[i
]))
1469 warned
= warning_at (loc
, OPT_Walloc_size_larger_than_
,
1470 "%Kargument %i value %qE exceeds "
1471 "maximum object size %E",
1472 exp
, idx
[i
] + 1, args
[i
], maxobjsize
);
1475 else if (TREE_CODE (args
[i
]) == SSA_NAME
1476 && get_size_range (args
[i
], argrange
[i
]))
1478 /* Verify that the argument's range is not negative (including
1479 upper bound of zero). */
1480 if (tree_int_cst_lt (argrange
[i
][0], integer_zero_node
)
1481 && tree_int_cst_le (argrange
[i
][1], integer_zero_node
))
1483 warned
= warning_at (loc
, OPT_Walloc_size_larger_than_
,
1484 "%Kargument %i range [%E, %E] is negative",
1486 argrange
[i
][0], argrange
[i
][1]);
1488 else if (tree_int_cst_lt (maxobjsize
, argrange
[i
][0]))
1490 warned
= warning_at (loc
, OPT_Walloc_size_larger_than_
,
1491 "%Kargument %i range [%E, %E] exceeds "
1492 "maximum object size %E",
1494 argrange
[i
][0], argrange
[i
][1],
1503 /* For a two-argument alloc_size, validate the product of the two
1504 arguments if both of their values or ranges are known. */
1505 if (!warned
&& tree_fits_uhwi_p (argrange
[0][0])
1506 && argrange
[1][0] && tree_fits_uhwi_p (argrange
[1][0])
1507 && !integer_onep (argrange
[0][0])
1508 && !integer_onep (argrange
[1][0]))
1510 /* Check for overflow in the product of a function decorated with
1511 attribute alloc_size (X, Y). */
1512 unsigned szprec
= TYPE_PRECISION (size_type_node
);
1513 wide_int x
= wi::to_wide (argrange
[0][0], szprec
);
1514 wide_int y
= wi::to_wide (argrange
[1][0], szprec
);
1517 wide_int prod
= wi::umul (x
, y
, &vflow
);
1520 warned
= warning_at (loc
, OPT_Walloc_size_larger_than_
,
1521 "%Kproduct %<%E * %E%> of arguments %i and %i "
1522 "exceeds %<SIZE_MAX%>",
1523 exp
, argrange
[0][0], argrange
[1][0],
1524 idx
[0] + 1, idx
[1] + 1);
1525 else if (wi::ltu_p (wi::to_wide (maxobjsize
, szprec
), prod
))
1526 warned
= warning_at (loc
, OPT_Walloc_size_larger_than_
,
1527 "%Kproduct %<%E * %E%> of arguments %i and %i "
1528 "exceeds maximum object size %E",
1529 exp
, argrange
[0][0], argrange
[1][0],
1530 idx
[0] + 1, idx
[1] + 1,
1535 /* Print the full range of each of the two arguments to make
1536 it clear when it is, in fact, in a range and not constant. */
1537 if (argrange
[0][0] != argrange
[0][1])
1538 inform (loc
, "argument %i in the range [%E, %E]",
1539 idx
[0] + 1, argrange
[0][0], argrange
[0][1]);
1540 if (argrange
[1][0] != argrange
[1][1])
1541 inform (loc
, "argument %i in the range [%E, %E]",
1542 idx
[1] + 1, argrange
[1][0], argrange
[1][1]);
1548 location_t fnloc
= DECL_SOURCE_LOCATION (fn
);
1550 if (DECL_IS_BUILTIN (fn
))
1552 "in a call to built-in allocation function %qD", fn
);
1555 "in a call to allocation function %qD declared here", fn
);
1559 /* If EXPR refers to a character array or pointer declared attribute
1560 nonstring return a decl for that array or pointer and set *REF to
1561 the referenced enclosing object or pointer. Otherwise returns
1565 get_attr_nonstring_decl (tree expr
, tree
*ref
)
1568 if (TREE_CODE (decl
) == SSA_NAME
)
1570 gimple
*def
= SSA_NAME_DEF_STMT (decl
);
1572 if (is_gimple_assign (def
))
1574 tree_code code
= gimple_assign_rhs_code (def
);
1575 if (code
== ADDR_EXPR
1576 || code
== COMPONENT_REF
1577 || code
== VAR_DECL
)
1578 decl
= gimple_assign_rhs1 (def
);
1580 else if (tree var
= SSA_NAME_VAR (decl
))
1584 if (TREE_CODE (decl
) == ADDR_EXPR
)
1585 decl
= TREE_OPERAND (decl
, 0);
1590 if (TREE_CODE (decl
) == ARRAY_REF
)
1591 decl
= TREE_OPERAND (decl
, 0);
1592 else if (TREE_CODE (decl
) == COMPONENT_REF
)
1593 decl
= TREE_OPERAND (decl
, 1);
1594 else if (TREE_CODE (decl
) == MEM_REF
)
1595 return get_attr_nonstring_decl (TREE_OPERAND (decl
, 0), ref
);
1598 && lookup_attribute ("nonstring", DECL_ATTRIBUTES (decl
)))
1604 /* Warn about passing a non-string array/pointer to a function that
1605 expects a nul-terminated string argument. */
1608 maybe_warn_nonstring_arg (tree fndecl
, tree exp
)
1610 if (!fndecl
|| DECL_BUILT_IN_CLASS (fndecl
) != BUILT_IN_NORMAL
)
1613 bool with_bounds
= CALL_WITH_BOUNDS_P (exp
);
1615 unsigned nargs
= call_expr_nargs (exp
);
1617 /* The bound argument to a bounded string function like strncpy. */
1618 tree bound
= NULL_TREE
;
1620 /* The range of lengths of a string argument to one of the comparison
1621 functions. If the length is less than the bound it is used instead. */
1622 tree lenrng
[2] = { NULL_TREE
, NULL_TREE
};
1624 /* It's safe to call "bounded" string functions with a non-string
1625 argument since the functions provide an explicit bound for this
1627 switch (DECL_FUNCTION_CODE (fndecl
))
1629 case BUILT_IN_STRCMP
:
1630 case BUILT_IN_STRNCMP
:
1631 case BUILT_IN_STRNCASECMP
:
1633 /* For these, if one argument refers to one or more of a set
1634 of string constants or arrays of known size, determine
1635 the range of their known or possible lengths and use it
1636 conservatively as the bound for the unbounded function,
1637 and to adjust the range of the bound of the bounded ones. */
1638 unsigned stride
= with_bounds
? 2 : 1;
1639 for (unsigned argno
= 0; argno
< nargs
&& !*lenrng
; argno
+= stride
)
1641 tree arg
= CALL_EXPR_ARG (exp
, argno
);
1642 if (!get_attr_nonstring_decl (arg
))
1643 get_range_strlen (arg
, lenrng
);
1648 case BUILT_IN_STPNCPY
:
1649 case BUILT_IN_STPNCPY_CHK
:
1650 case BUILT_IN_STRNCPY
:
1651 case BUILT_IN_STRNCPY_CHK
:
1653 unsigned argno
= with_bounds
? 4 : 2;
1655 bound
= CALL_EXPR_ARG (exp
, argno
);
1659 case BUILT_IN_STRNDUP
:
1661 unsigned argno
= with_bounds
? 2 : 1;
1663 bound
= CALL_EXPR_ARG (exp
, argno
);
1671 /* Determine the range of the bound argument (if specified). */
1672 tree bndrng
[2] = { NULL_TREE
, NULL_TREE
};
1674 get_size_range (bound
, bndrng
);
1678 /* Add one for the nul. */
1679 lenrng
[0] = const_binop (PLUS_EXPR
, TREE_TYPE (lenrng
[0]),
1680 lenrng
[0], size_one_node
);
1681 lenrng
[1] = const_binop (PLUS_EXPR
, TREE_TYPE (lenrng
[1]),
1682 lenrng
[1], size_one_node
);
1686 /* Conservatively use the upper bound of the lengths for
1687 both the lower and the upper bound of the operation. */
1688 bndrng
[0] = lenrng
[1];
1689 bndrng
[1] = lenrng
[1];
1690 bound
= void_type_node
;
1694 /* Replace the bound on the oparation with the upper bound
1695 of the length of the string if the latter is smaller. */
1696 if (tree_int_cst_lt (lenrng
[1], bndrng
[0]))
1697 bndrng
[0] = lenrng
[1];
1698 else if (tree_int_cst_lt (lenrng
[1], bndrng
[1]))
1699 bndrng
[1] = lenrng
[1];
1703 /* Iterate over the built-in function's formal arguments and check
1704 each const char* against the actual argument. If the actual
1705 argument is declared attribute non-string issue a warning unless
1706 the argument's maximum length is bounded. */
1707 function_args_iterator it
;
1708 function_args_iter_init (&it
, TREE_TYPE (fndecl
));
1710 for (unsigned argno
= 0; ; ++argno
, function_args_iter_next (&it
))
1712 /* Avoid iterating past the declared argument in a call
1713 to function declared without a prototype. */
1717 tree argtype
= function_args_iter_cond (&it
);
1721 if (TREE_CODE (argtype
) != POINTER_TYPE
)
1724 argtype
= TREE_TYPE (argtype
);
1726 if (TREE_CODE (argtype
) != INTEGER_TYPE
1727 || !TYPE_READONLY (argtype
))
1730 argtype
= TYPE_MAIN_VARIANT (argtype
);
1731 if (argtype
!= char_type_node
)
1734 tree callarg
= CALL_EXPR_ARG (exp
, argno
);
1735 if (TREE_CODE (callarg
) == ADDR_EXPR
)
1736 callarg
= TREE_OPERAND (callarg
, 0);
1738 /* See if the destination is declared with attribute "nonstring". */
1739 tree decl
= get_attr_nonstring_decl (callarg
);
1743 tree type
= TREE_TYPE (decl
);
1745 /* The maximum number of array elements accessed. */
1746 offset_int wibnd
= 0;
1748 wibnd
= wi::to_offset (bndrng
[0]);
1750 /* Size of the array. */
1751 offset_int asize
= wibnd
;
1753 /* Determine the array size. For arrays of unknown bound and
1754 pointers reset BOUND to trigger the appropriate warning. */
1755 if (TREE_CODE (type
) == ARRAY_TYPE
)
1757 if (tree arrbnd
= TYPE_DOMAIN (type
))
1759 if ((arrbnd
= TYPE_MAX_VALUE (arrbnd
)))
1760 asize
= wi::to_offset (arrbnd
) + 1;
1762 else if (bound
== void_type_node
)
1765 else if (bound
== void_type_node
)
1768 location_t loc
= EXPR_LOCATION (exp
);
1770 bool warned
= false;
1772 if (wi::ltu_p (asize
, wibnd
))
1773 warned
= warning_at (loc
, OPT_Wstringop_overflow_
,
1774 "%qD argument %i declared attribute %<nonstring%> "
1775 "is smaller than the specified bound %E",
1776 fndecl
, argno
+ 1, bndrng
[0]);
1778 warned
= warning_at (loc
, OPT_Wstringop_overflow_
,
1779 "%qD argument %i declared attribute %<nonstring%>",
1783 inform (DECL_SOURCE_LOCATION (decl
),
1784 "argument %qD declared here", decl
);
1788 /* Issue an error if CALL_EXPR was flagged as requiring
1789 tall-call optimization. */
1792 maybe_complain_about_tail_call (tree call_expr
, const char *reason
)
1794 gcc_assert (TREE_CODE (call_expr
) == CALL_EXPR
);
1795 if (!CALL_EXPR_MUST_TAIL_CALL (call_expr
))
1798 error_at (EXPR_LOCATION (call_expr
), "cannot tail-call: %s", reason
);
1801 /* Fill in ARGS_SIZE and ARGS array based on the parameters found in
1804 NUM_ACTUALS is the total number of parameters.
1806 N_NAMED_ARGS is the total number of named arguments.
1808 STRUCT_VALUE_ADDR_VALUE is the implicit argument for a struct return
1811 FNDECL is the tree code for the target of this call (if known)
1813 ARGS_SO_FAR holds state needed by the target to know where to place
1816 REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
1817 for arguments which are passed in registers.
1819 OLD_STACK_LEVEL is a pointer to an rtx which olds the old stack level
1820 and may be modified by this routine.
1822 OLD_PENDING_ADJ, MUST_PREALLOCATE and FLAGS are pointers to integer
1823 flags which may be modified by this routine.
1825 MAY_TAILCALL is cleared if we encounter an invisible pass-by-reference
1826 that requires allocation of stack space.
1828 CALL_FROM_THUNK_P is true if this call is the jump from a thunk to
1829 the thunked-to function. */
1832 initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED
,
1833 struct arg_data
*args
,
1834 struct args_size
*args_size
,
1835 int n_named_args ATTRIBUTE_UNUSED
,
1836 tree exp
, tree struct_value_addr_value
,
1837 tree fndecl
, tree fntype
,
1838 cumulative_args_t args_so_far
,
1839 int reg_parm_stack_space
,
1840 rtx
*old_stack_level
,
1841 poly_int64_pod
*old_pending_adj
,
1842 int *must_preallocate
, int *ecf_flags
,
1843 bool *may_tailcall
, bool call_from_thunk_p
)
1845 CUMULATIVE_ARGS
*args_so_far_pnt
= get_cumulative_args (args_so_far
);
1846 location_t loc
= EXPR_LOCATION (exp
);
1848 /* Count arg position in order args appear. */
1853 args_size
->constant
= 0;
1856 bitmap_obstack_initialize (NULL
);
1858 /* In this loop, we consider args in the order they are written.
1859 We fill up ARGS from the back. */
1861 i
= num_actuals
- 1;
1863 int j
= i
, ptr_arg
= -1;
1864 call_expr_arg_iterator iter
;
1866 bitmap slots
= NULL
;
1868 if (struct_value_addr_value
)
1870 args
[j
].tree_value
= struct_value_addr_value
;
1873 /* If we pass structure address then we need to
1874 create bounds for it. Since created bounds is
1875 a call statement, we expand it right here to avoid
1876 fixing all other places where it may be expanded. */
1877 if (CALL_WITH_BOUNDS_P (exp
))
1879 args
[j
].value
= gen_reg_rtx (targetm
.chkp_bound_mode ());
1881 = chkp_make_bounds_for_struct_addr (struct_value_addr_value
);
1882 expand_expr_real (args
[j
].tree_value
, args
[j
].value
, VOIDmode
,
1883 EXPAND_NORMAL
, 0, false);
1884 args
[j
].pointer_arg
= j
+ 1;
1889 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
1891 tree argtype
= TREE_TYPE (arg
);
1893 /* Remember last param with pointer and associate it
1894 with following pointer bounds. */
1895 if (CALL_WITH_BOUNDS_P (exp
)
1896 && chkp_type_has_pointer (argtype
))
1899 BITMAP_FREE (slots
);
1901 if (!BOUNDED_TYPE_P (argtype
))
1903 slots
= BITMAP_ALLOC (NULL
);
1904 chkp_find_bound_slots (argtype
, slots
);
1907 else if (CALL_WITH_BOUNDS_P (exp
)
1908 && pass_by_reference (NULL
, TYPE_MODE (argtype
), argtype
,
1909 argpos
< n_named_args
))
1912 BITMAP_FREE (slots
);
1915 else if (POINTER_BOUNDS_TYPE_P (argtype
))
1917 /* We expect bounds in instrumented calls only.
1918 Otherwise it is a sign we lost flag due to some optimization
1919 and may emit call args incorrectly. */
1920 gcc_assert (CALL_WITH_BOUNDS_P (exp
));
1922 /* For structures look for the next available pointer. */
1923 if (ptr_arg
!= -1 && slots
)
1925 unsigned bnd_no
= bitmap_first_set_bit (slots
);
1926 args
[j
].pointer_offset
=
1927 bnd_no
* POINTER_SIZE
/ BITS_PER_UNIT
;
1929 bitmap_clear_bit (slots
, bnd_no
);
1931 /* Check we have no more pointers in the structure. */
1932 if (bitmap_empty_p (slots
))
1933 BITMAP_FREE (slots
);
1935 args
[j
].pointer_arg
= ptr_arg
;
1937 /* Check we covered all pointers in the previous
1945 if (targetm
.calls
.split_complex_arg
1947 && TREE_CODE (argtype
) == COMPLEX_TYPE
1948 && targetm
.calls
.split_complex_arg (argtype
))
1950 tree subtype
= TREE_TYPE (argtype
);
1951 args
[j
].tree_value
= build1 (REALPART_EXPR
, subtype
, arg
);
1953 args
[j
].tree_value
= build1 (IMAGPART_EXPR
, subtype
, arg
);
1956 args
[j
].tree_value
= arg
;
1962 BITMAP_FREE (slots
);
1965 bitmap_obstack_release (NULL
);
1967 /* Extract attribute alloc_size and if set, store the indices of
1968 the corresponding arguments in ALLOC_IDX, and then the actual
1969 argument(s) at those indices in ALLOC_ARGS. */
1970 int alloc_idx
[2] = { -1, -1 };
1972 = (fndecl
? lookup_attribute ("alloc_size",
1973 TYPE_ATTRIBUTES (TREE_TYPE (fndecl
)))
1976 tree args
= TREE_VALUE (alloc_size
);
1977 alloc_idx
[0] = TREE_INT_CST_LOW (TREE_VALUE (args
)) - 1;
1978 if (TREE_CHAIN (args
))
1979 alloc_idx
[1] = TREE_INT_CST_LOW (TREE_VALUE (TREE_CHAIN (args
))) - 1;
1982 /* Array for up to the two attribute alloc_size arguments. */
1983 tree alloc_args
[] = { NULL_TREE
, NULL_TREE
};
1985 /* I counts args in order (to be) pushed; ARGPOS counts in order written. */
1986 for (argpos
= 0; argpos
< num_actuals
; i
--, argpos
++)
1988 tree type
= TREE_TYPE (args
[i
].tree_value
);
1992 /* Replace erroneous argument with constant zero. */
1993 if (type
== error_mark_node
|| !COMPLETE_TYPE_P (type
))
1994 args
[i
].tree_value
= integer_zero_node
, type
= integer_type_node
;
1996 /* If TYPE is a transparent union or record, pass things the way
1997 we would pass the first field of the union or record. We have
1998 already verified that the modes are the same. */
1999 if ((TREE_CODE (type
) == UNION_TYPE
|| TREE_CODE (type
) == RECORD_TYPE
)
2000 && TYPE_TRANSPARENT_AGGR (type
))
2001 type
= TREE_TYPE (first_field (type
));
2003 /* Decide where to pass this arg.
2005 args[i].reg is nonzero if all or part is passed in registers.
2007 args[i].partial is nonzero if part but not all is passed in registers,
2008 and the exact value says how many bytes are passed in registers.
2010 args[i].pass_on_stack is nonzero if the argument must at least be
2011 computed on the stack. It may then be loaded back into registers
2012 if args[i].reg is nonzero.
2014 These decisions are driven by the FUNCTION_... macros and must agree
2015 with those made by function.c. */
2017 /* See if this argument should be passed by invisible reference. */
2018 if (pass_by_reference (args_so_far_pnt
, TYPE_MODE (type
),
2019 type
, argpos
< n_named_args
))
2022 tree base
= NULL_TREE
;
2025 = reference_callee_copied (args_so_far_pnt
, TYPE_MODE (type
),
2026 type
, argpos
< n_named_args
);
2028 /* If we're compiling a thunk, pass through invisible references
2029 instead of making a copy. */
2030 if (call_from_thunk_p
2032 && !TREE_ADDRESSABLE (type
)
2033 && (base
= get_base_address (args
[i
].tree_value
))
2034 && TREE_CODE (base
) != SSA_NAME
2035 && (!DECL_P (base
) || MEM_P (DECL_RTL (base
)))))
2037 /* We may have turned the parameter value into an SSA name.
2038 Go back to the original parameter so we can take the
2040 if (TREE_CODE (args
[i
].tree_value
) == SSA_NAME
)
2042 gcc_assert (SSA_NAME_IS_DEFAULT_DEF (args
[i
].tree_value
));
2043 args
[i
].tree_value
= SSA_NAME_VAR (args
[i
].tree_value
);
2044 gcc_assert (TREE_CODE (args
[i
].tree_value
) == PARM_DECL
);
2046 /* Argument setup code may have copied the value to register. We
2047 revert that optimization now because the tail call code must
2048 use the original location. */
2049 if (TREE_CODE (args
[i
].tree_value
) == PARM_DECL
2050 && !MEM_P (DECL_RTL (args
[i
].tree_value
))
2051 && DECL_INCOMING_RTL (args
[i
].tree_value
)
2052 && MEM_P (DECL_INCOMING_RTL (args
[i
].tree_value
)))
2053 set_decl_rtl (args
[i
].tree_value
,
2054 DECL_INCOMING_RTL (args
[i
].tree_value
));
2056 mark_addressable (args
[i
].tree_value
);
2058 /* We can't use sibcalls if a callee-copied argument is
2059 stored in the current function's frame. */
2060 if (!call_from_thunk_p
&& DECL_P (base
) && !TREE_STATIC (base
))
2062 *may_tailcall
= false;
2063 maybe_complain_about_tail_call (exp
,
2064 "a callee-copied argument is"
2065 " stored in the current"
2066 " function's frame");
2069 args
[i
].tree_value
= build_fold_addr_expr_loc (loc
,
2070 args
[i
].tree_value
);
2071 type
= TREE_TYPE (args
[i
].tree_value
);
2073 if (*ecf_flags
& ECF_CONST
)
2074 *ecf_flags
&= ~(ECF_CONST
| ECF_LOOPING_CONST_OR_PURE
);
2078 /* We make a copy of the object and pass the address to the
2079 function being called. */
2082 if (!COMPLETE_TYPE_P (type
)
2083 || TREE_CODE (TYPE_SIZE_UNIT (type
)) != INTEGER_CST
2084 || (flag_stack_check
== GENERIC_STACK_CHECK
2085 && compare_tree_int (TYPE_SIZE_UNIT (type
),
2086 STACK_CHECK_MAX_VAR_SIZE
) > 0))
2088 /* This is a variable-sized object. Make space on the stack
2090 rtx size_rtx
= expr_size (args
[i
].tree_value
);
2092 if (*old_stack_level
== 0)
2094 emit_stack_save (SAVE_BLOCK
, old_stack_level
);
2095 *old_pending_adj
= pending_stack_adjust
;
2096 pending_stack_adjust
= 0;
2099 /* We can pass TRUE as the 4th argument because we just
2100 saved the stack pointer and will restore it right after
2102 copy
= allocate_dynamic_stack_space (size_rtx
,
2105 max_int_size_in_bytes
2108 copy
= gen_rtx_MEM (BLKmode
, copy
);
2109 set_mem_attributes (copy
, type
, 1);
2112 copy
= assign_temp (type
, 1, 0);
2114 store_expr (args
[i
].tree_value
, copy
, 0, false, false);
2116 /* Just change the const function to pure and then let
2117 the next test clear the pure based on
2119 if (*ecf_flags
& ECF_CONST
)
2121 *ecf_flags
&= ~ECF_CONST
;
2122 *ecf_flags
|= ECF_PURE
;
2125 if (!callee_copies
&& *ecf_flags
& ECF_PURE
)
2126 *ecf_flags
&= ~(ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
);
2129 = build_fold_addr_expr_loc (loc
, make_tree (type
, copy
));
2130 type
= TREE_TYPE (args
[i
].tree_value
);
2131 *may_tailcall
= false;
2132 maybe_complain_about_tail_call (exp
,
2133 "argument must be passed"
2138 unsignedp
= TYPE_UNSIGNED (type
);
2139 mode
= promote_function_mode (type
, TYPE_MODE (type
), &unsignedp
,
2140 fndecl
? TREE_TYPE (fndecl
) : fntype
, 0);
2142 args
[i
].unsignedp
= unsignedp
;
2143 args
[i
].mode
= mode
;
2145 targetm
.calls
.warn_parameter_passing_abi (args_so_far
, type
);
2147 args
[i
].reg
= targetm
.calls
.function_arg (args_so_far
, mode
, type
,
2148 argpos
< n_named_args
);
2150 if (args
[i
].reg
&& CONST_INT_P (args
[i
].reg
))
2152 args
[i
].special_slot
= args
[i
].reg
;
2156 /* If this is a sibling call and the machine has register windows, the
2157 register window has to be unwinded before calling the routine, so
2158 arguments have to go into the incoming registers. */
2159 if (targetm
.calls
.function_incoming_arg
!= targetm
.calls
.function_arg
)
2160 args
[i
].tail_call_reg
2161 = targetm
.calls
.function_incoming_arg (args_so_far
, mode
, type
,
2162 argpos
< n_named_args
);
2164 args
[i
].tail_call_reg
= args
[i
].reg
;
2168 = targetm
.calls
.arg_partial_bytes (args_so_far
, mode
, type
,
2169 argpos
< n_named_args
);
2171 args
[i
].pass_on_stack
= targetm
.calls
.must_pass_in_stack (mode
, type
);
2173 /* If FUNCTION_ARG returned a (parallel [(expr_list (nil) ...) ...]),
2174 it means that we are to pass this arg in the register(s) designated
2175 by the PARALLEL, but also to pass it in the stack. */
2176 if (args
[i
].reg
&& GET_CODE (args
[i
].reg
) == PARALLEL
2177 && XEXP (XVECEXP (args
[i
].reg
, 0, 0), 0) == 0)
2178 args
[i
].pass_on_stack
= 1;
2180 /* If this is an addressable type, we must preallocate the stack
2181 since we must evaluate the object into its final location.
2183 If this is to be passed in both registers and the stack, it is simpler
2185 if (TREE_ADDRESSABLE (type
)
2186 || (args
[i
].pass_on_stack
&& args
[i
].reg
!= 0))
2187 *must_preallocate
= 1;
2189 /* No stack allocation and padding for bounds. */
2190 if (POINTER_BOUNDS_P (args
[i
].tree_value
))
2192 /* Compute the stack-size of this argument. */
2193 else if (args
[i
].reg
== 0 || args
[i
].partial
!= 0
2194 || reg_parm_stack_space
> 0
2195 || args
[i
].pass_on_stack
)
2196 locate_and_pad_parm (mode
, type
,
2197 #ifdef STACK_PARMS_IN_REG_PARM_AREA
2202 reg_parm_stack_space
,
2203 args
[i
].pass_on_stack
? 0 : args
[i
].partial
,
2204 fndecl
, args_size
, &args
[i
].locate
);
2205 #ifdef BLOCK_REG_PADDING
2207 /* The argument is passed entirely in registers. See at which
2208 end it should be padded. */
2209 args
[i
].locate
.where_pad
=
2210 BLOCK_REG_PADDING (mode
, type
,
2211 int_size_in_bytes (type
) <= UNITS_PER_WORD
);
2214 /* Update ARGS_SIZE, the total stack space for args so far. */
2216 args_size
->constant
+= args
[i
].locate
.size
.constant
;
2217 if (args
[i
].locate
.size
.var
)
2218 ADD_PARM_SIZE (*args_size
, args
[i
].locate
.size
.var
);
2220 /* Increment ARGS_SO_FAR, which has info about which arg-registers
2221 have been used, etc. */
2223 targetm
.calls
.function_arg_advance (args_so_far
, TYPE_MODE (type
),
2224 type
, argpos
< n_named_args
);
2226 /* Store argument values for functions decorated with attribute
2228 if (argpos
== alloc_idx
[0])
2229 alloc_args
[0] = args
[i
].tree_value
;
2230 else if (argpos
== alloc_idx
[1])
2231 alloc_args
[1] = args
[i
].tree_value
;
2236 /* Check the arguments of functions decorated with attribute
2238 maybe_warn_alloc_args_overflow (fndecl
, exp
, alloc_args
, alloc_idx
);
2241 /* Detect passing non-string arguments to functions expecting
2242 nul-terminated strings. */
2243 maybe_warn_nonstring_arg (fndecl
, exp
);
2246 /* Update ARGS_SIZE to contain the total size for the argument block.
2247 Return the original constant component of the argument block's size.
2249 REG_PARM_STACK_SPACE holds the number of bytes of stack space reserved
2250 for arguments passed in registers. */
2253 compute_argument_block_size (int reg_parm_stack_space
,
2254 struct args_size
*args_size
,
2255 tree fndecl ATTRIBUTE_UNUSED
,
2256 tree fntype ATTRIBUTE_UNUSED
,
2257 int preferred_stack_boundary ATTRIBUTE_UNUSED
)
2259 poly_int64 unadjusted_args_size
= args_size
->constant
;
2261 /* For accumulate outgoing args mode we don't need to align, since the frame
2262 will be already aligned. Align to STACK_BOUNDARY in order to prevent
2263 backends from generating misaligned frame sizes. */
2264 if (ACCUMULATE_OUTGOING_ARGS
&& preferred_stack_boundary
> STACK_BOUNDARY
)
2265 preferred_stack_boundary
= STACK_BOUNDARY
;
2267 /* Compute the actual size of the argument block required. The variable
2268 and constant sizes must be combined, the size may have to be rounded,
2269 and there may be a minimum required size. */
2273 args_size
->var
= ARGS_SIZE_TREE (*args_size
);
2274 args_size
->constant
= 0;
2276 preferred_stack_boundary
/= BITS_PER_UNIT
;
2277 if (preferred_stack_boundary
> 1)
2279 /* We don't handle this case yet. To handle it correctly we have
2280 to add the delta, round and subtract the delta.
2281 Currently no machine description requires this support. */
2282 gcc_assert (multiple_p (stack_pointer_delta
,
2283 preferred_stack_boundary
));
2284 args_size
->var
= round_up (args_size
->var
, preferred_stack_boundary
);
2287 if (reg_parm_stack_space
> 0)
2290 = size_binop (MAX_EXPR
, args_size
->var
,
2291 ssize_int (reg_parm_stack_space
));
2293 /* The area corresponding to register parameters is not to count in
2294 the size of the block we need. So make the adjustment. */
2295 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
2297 = size_binop (MINUS_EXPR
, args_size
->var
,
2298 ssize_int (reg_parm_stack_space
));
2303 preferred_stack_boundary
/= BITS_PER_UNIT
;
2304 if (preferred_stack_boundary
< 1)
2305 preferred_stack_boundary
= 1;
2306 args_size
->constant
= (aligned_upper_bound (args_size
->constant
2307 + stack_pointer_delta
,
2308 preferred_stack_boundary
)
2309 - stack_pointer_delta
);
2311 args_size
->constant
= upper_bound (args_size
->constant
,
2312 reg_parm_stack_space
);
2314 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
2315 args_size
->constant
-= reg_parm_stack_space
;
2317 return unadjusted_args_size
;
2320 /* Precompute parameters as needed for a function call.
2322 FLAGS is mask of ECF_* constants.
2324 NUM_ACTUALS is the number of arguments.
2326 ARGS is an array containing information for each argument; this
2327 routine fills in the INITIAL_VALUE and VALUE fields for each
2328 precomputed argument. */
2331 precompute_arguments (int num_actuals
, struct arg_data
*args
)
2335 /* If this is a libcall, then precompute all arguments so that we do not
2336 get extraneous instructions emitted as part of the libcall sequence. */
2338 /* If we preallocated the stack space, and some arguments must be passed
2339 on the stack, then we must precompute any parameter which contains a
2340 function call which will store arguments on the stack.
2341 Otherwise, evaluating the parameter may clobber previous parameters
2342 which have already been stored into the stack. (we have code to avoid
2343 such case by saving the outgoing stack arguments, but it results in
2345 if (!ACCUMULATE_OUTGOING_ARGS
)
2348 for (i
= 0; i
< num_actuals
; i
++)
2353 if (TREE_CODE (args
[i
].tree_value
) != CALL_EXPR
)
2356 /* If this is an addressable type, we cannot pre-evaluate it. */
2357 type
= TREE_TYPE (args
[i
].tree_value
);
2358 gcc_assert (!TREE_ADDRESSABLE (type
));
2360 args
[i
].initial_value
= args
[i
].value
2361 = expand_normal (args
[i
].tree_value
);
2363 mode
= TYPE_MODE (type
);
2364 if (mode
!= args
[i
].mode
)
2366 int unsignedp
= args
[i
].unsignedp
;
2368 = convert_modes (args
[i
].mode
, mode
,
2369 args
[i
].value
, args
[i
].unsignedp
);
2371 /* CSE will replace this only if it contains args[i].value
2372 pseudo, so convert it down to the declared mode using
2374 if (REG_P (args
[i
].value
)
2375 && GET_MODE_CLASS (args
[i
].mode
) == MODE_INT
2376 && promote_mode (type
, mode
, &unsignedp
) != args
[i
].mode
)
2378 args
[i
].initial_value
2379 = gen_lowpart_SUBREG (mode
, args
[i
].value
);
2380 SUBREG_PROMOTED_VAR_P (args
[i
].initial_value
) = 1;
2381 SUBREG_PROMOTED_SET (args
[i
].initial_value
, args
[i
].unsignedp
);
2387 /* Given the current state of MUST_PREALLOCATE and information about
2388 arguments to a function call in NUM_ACTUALS, ARGS and ARGS_SIZE,
2389 compute and return the final value for MUST_PREALLOCATE. */
2392 finalize_must_preallocate (int must_preallocate
, int num_actuals
,
2393 struct arg_data
*args
, struct args_size
*args_size
)
2395 /* See if we have or want to preallocate stack space.
2397 If we would have to push a partially-in-regs parm
2398 before other stack parms, preallocate stack space instead.
2400 If the size of some parm is not a multiple of the required stack
2401 alignment, we must preallocate.
2403 If the total size of arguments that would otherwise create a copy in
2404 a temporary (such as a CALL) is more than half the total argument list
2405 size, preallocation is faster.
2407 Another reason to preallocate is if we have a machine (like the m88k)
2408 where stack alignment is required to be maintained between every
2409 pair of insns, not just when the call is made. However, we assume here
2410 that such machines either do not have push insns (and hence preallocation
2411 would occur anyway) or the problem is taken care of with
2414 if (! must_preallocate
)
2416 int partial_seen
= 0;
2417 poly_int64 copy_to_evaluate_size
= 0;
2420 for (i
= 0; i
< num_actuals
&& ! must_preallocate
; i
++)
2422 if (args
[i
].partial
> 0 && ! args
[i
].pass_on_stack
)
2424 else if (partial_seen
&& args
[i
].reg
== 0)
2425 must_preallocate
= 1;
2426 /* We preallocate in case there are bounds passed
2427 in the bounds table to have precomputed address
2428 for bounds association. */
2429 else if (POINTER_BOUNDS_P (args
[i
].tree_value
)
2431 must_preallocate
= 1;
2433 if (TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)) == BLKmode
2434 && (TREE_CODE (args
[i
].tree_value
) == CALL_EXPR
2435 || TREE_CODE (args
[i
].tree_value
) == TARGET_EXPR
2436 || TREE_CODE (args
[i
].tree_value
) == COND_EXPR
2437 || TREE_ADDRESSABLE (TREE_TYPE (args
[i
].tree_value
))))
2438 copy_to_evaluate_size
2439 += int_size_in_bytes (TREE_TYPE (args
[i
].tree_value
));
2442 if (maybe_ne (args_size
->constant
, 0)
2443 && maybe_ge (copy_to_evaluate_size
* 2, args_size
->constant
))
2444 must_preallocate
= 1;
2446 return must_preallocate
;
2449 /* If we preallocated stack space, compute the address of each argument
2450 and store it into the ARGS array.
2452 We need not ensure it is a valid memory address here; it will be
2453 validized when it is used.
2455 ARGBLOCK is an rtx for the address of the outgoing arguments. */
2458 compute_argument_addresses (struct arg_data
*args
, rtx argblock
, int num_actuals
)
2462 rtx arg_reg
= argblock
;
2464 poly_int64 arg_offset
= 0;
2466 if (GET_CODE (argblock
) == PLUS
)
2468 arg_reg
= XEXP (argblock
, 0);
2469 arg_offset
= rtx_to_poly_int64 (XEXP (argblock
, 1));
2472 for (i
= 0; i
< num_actuals
; i
++)
2474 rtx offset
= ARGS_SIZE_RTX (args
[i
].locate
.offset
);
2475 rtx slot_offset
= ARGS_SIZE_RTX (args
[i
].locate
.slot_offset
);
2477 unsigned int align
, boundary
;
2478 poly_uint64 units_on_stack
= 0;
2479 machine_mode partial_mode
= VOIDmode
;
2481 /* Skip this parm if it will not be passed on the stack. */
2482 if (! args
[i
].pass_on_stack
2484 && args
[i
].partial
== 0)
2487 if (TYPE_EMPTY_P (TREE_TYPE (args
[i
].tree_value
)))
2490 /* Pointer Bounds are never passed on the stack. */
2491 if (POINTER_BOUNDS_P (args
[i
].tree_value
))
2494 addr
= simplify_gen_binary (PLUS
, Pmode
, arg_reg
, offset
);
2495 addr
= plus_constant (Pmode
, addr
, arg_offset
);
2497 if (args
[i
].partial
!= 0)
2499 /* Only part of the parameter is being passed on the stack.
2500 Generate a simple memory reference of the correct size. */
2501 units_on_stack
= args
[i
].locate
.size
.constant
;
2502 poly_uint64 bits_on_stack
= units_on_stack
* BITS_PER_UNIT
;
2503 partial_mode
= int_mode_for_size (bits_on_stack
, 1).else_blk ();
2504 args
[i
].stack
= gen_rtx_MEM (partial_mode
, addr
);
2505 set_mem_size (args
[i
].stack
, units_on_stack
);
2509 args
[i
].stack
= gen_rtx_MEM (args
[i
].mode
, addr
);
2510 set_mem_attributes (args
[i
].stack
,
2511 TREE_TYPE (args
[i
].tree_value
), 1);
2513 align
= BITS_PER_UNIT
;
2514 boundary
= args
[i
].locate
.boundary
;
2515 poly_int64 offset_val
;
2516 if (args
[i
].locate
.where_pad
!= PAD_DOWNWARD
)
2518 else if (poly_int_rtx_p (offset
, &offset_val
))
2520 align
= least_bit_hwi (boundary
);
2521 unsigned int offset_align
2522 = known_alignment (offset_val
) * BITS_PER_UNIT
;
2523 if (offset_align
!= 0)
2524 align
= MIN (align
, offset_align
);
2526 set_mem_align (args
[i
].stack
, align
);
2528 addr
= simplify_gen_binary (PLUS
, Pmode
, arg_reg
, slot_offset
);
2529 addr
= plus_constant (Pmode
, addr
, arg_offset
);
2531 if (args
[i
].partial
!= 0)
2533 /* Only part of the parameter is being passed on the stack.
2534 Generate a simple memory reference of the correct size.
2536 args
[i
].stack_slot
= gen_rtx_MEM (partial_mode
, addr
);
2537 set_mem_size (args
[i
].stack_slot
, units_on_stack
);
2541 args
[i
].stack_slot
= gen_rtx_MEM (args
[i
].mode
, addr
);
2542 set_mem_attributes (args
[i
].stack_slot
,
2543 TREE_TYPE (args
[i
].tree_value
), 1);
2545 set_mem_align (args
[i
].stack_slot
, args
[i
].locate
.boundary
);
2547 /* Function incoming arguments may overlap with sibling call
2548 outgoing arguments and we cannot allow reordering of reads
2549 from function arguments with stores to outgoing arguments
2550 of sibling calls. */
2551 set_mem_alias_set (args
[i
].stack
, 0);
2552 set_mem_alias_set (args
[i
].stack_slot
, 0);
2557 /* Given a FNDECL and EXP, return an rtx suitable for use as a target address
2558 in a call instruction.
2560 FNDECL is the tree node for the target function. For an indirect call
2561 FNDECL will be NULL_TREE.
2563 ADDR is the operand 0 of CALL_EXPR for this call. */
2566 rtx_for_function_call (tree fndecl
, tree addr
)
2570 /* Get the function to call, in the form of RTL. */
2573 if (!TREE_USED (fndecl
) && fndecl
!= current_function_decl
)
2574 TREE_USED (fndecl
) = 1;
2576 /* Get a SYMBOL_REF rtx for the function address. */
2577 funexp
= XEXP (DECL_RTL (fndecl
), 0);
2580 /* Generate an rtx (probably a pseudo-register) for the address. */
2583 funexp
= expand_normal (addr
);
2584 pop_temp_slots (); /* FUNEXP can't be BLKmode. */
2589 /* Return the static chain for this function, if any. */
2592 rtx_for_static_chain (const_tree fndecl_or_type
, bool incoming_p
)
2594 if (DECL_P (fndecl_or_type
) && !DECL_STATIC_CHAIN (fndecl_or_type
))
2597 return targetm
.calls
.static_chain (fndecl_or_type
, incoming_p
);
2600 /* Internal state for internal_arg_pointer_based_exp and its helpers. */
2603 /* Last insn that has been scanned by internal_arg_pointer_based_exp_scan,
2604 or NULL_RTX if none has been scanned yet. */
2605 rtx_insn
*scan_start
;
2606 /* Vector indexed by REGNO - FIRST_PSEUDO_REGISTER, recording if a pseudo is
2607 based on crtl->args.internal_arg_pointer. The element is NULL_RTX if the
2608 pseudo isn't based on it, a CONST_INT offset if the pseudo is based on it
2609 with fixed offset, or PC if this is with variable or unknown offset. */
2611 } internal_arg_pointer_exp_state
;
2613 static rtx
internal_arg_pointer_based_exp (const_rtx
, bool);
2615 /* Helper function for internal_arg_pointer_based_exp. Scan insns in
2616 the tail call sequence, starting with first insn that hasn't been
2617 scanned yet, and note for each pseudo on the LHS whether it is based
2618 on crtl->args.internal_arg_pointer or not, and what offset from that
2619 that pointer it has. */
2622 internal_arg_pointer_based_exp_scan (void)
2624 rtx_insn
*insn
, *scan_start
= internal_arg_pointer_exp_state
.scan_start
;
2626 if (scan_start
== NULL_RTX
)
2627 insn
= get_insns ();
2629 insn
= NEXT_INSN (scan_start
);
2633 rtx set
= single_set (insn
);
2634 if (set
&& REG_P (SET_DEST (set
)) && !HARD_REGISTER_P (SET_DEST (set
)))
2637 unsigned int idx
= REGNO (SET_DEST (set
)) - FIRST_PSEUDO_REGISTER
;
2638 /* Punt on pseudos set multiple times. */
2639 if (idx
< internal_arg_pointer_exp_state
.cache
.length ()
2640 && (internal_arg_pointer_exp_state
.cache
[idx
]
2644 val
= internal_arg_pointer_based_exp (SET_SRC (set
), false);
2645 if (val
!= NULL_RTX
)
2647 if (idx
>= internal_arg_pointer_exp_state
.cache
.length ())
2648 internal_arg_pointer_exp_state
.cache
2649 .safe_grow_cleared (idx
+ 1);
2650 internal_arg_pointer_exp_state
.cache
[idx
] = val
;
2653 if (NEXT_INSN (insn
) == NULL_RTX
)
2655 insn
= NEXT_INSN (insn
);
2658 internal_arg_pointer_exp_state
.scan_start
= scan_start
;
2661 /* Compute whether RTL is based on crtl->args.internal_arg_pointer. Return
2662 NULL_RTX if RTL isn't based on it, a CONST_INT offset if RTL is based on
2663 it with fixed offset, or PC if this is with variable or unknown offset.
2664 TOPLEVEL is true if the function is invoked at the topmost level. */
2667 internal_arg_pointer_based_exp (const_rtx rtl
, bool toplevel
)
2669 if (CONSTANT_P (rtl
))
2672 if (rtl
== crtl
->args
.internal_arg_pointer
)
2675 if (REG_P (rtl
) && HARD_REGISTER_P (rtl
))
2679 if (GET_CODE (rtl
) == PLUS
&& poly_int_rtx_p (XEXP (rtl
, 1), &offset
))
2681 rtx val
= internal_arg_pointer_based_exp (XEXP (rtl
, 0), toplevel
);
2682 if (val
== NULL_RTX
|| val
== pc_rtx
)
2684 return plus_constant (Pmode
, val
, offset
);
2687 /* When called at the topmost level, scan pseudo assignments in between the
2688 last scanned instruction in the tail call sequence and the latest insn
2689 in that sequence. */
2691 internal_arg_pointer_based_exp_scan ();
2695 unsigned int idx
= REGNO (rtl
) - FIRST_PSEUDO_REGISTER
;
2696 if (idx
< internal_arg_pointer_exp_state
.cache
.length ())
2697 return internal_arg_pointer_exp_state
.cache
[idx
];
2702 subrtx_iterator::array_type array
;
2703 FOR_EACH_SUBRTX (iter
, array
, rtl
, NONCONST
)
2705 const_rtx x
= *iter
;
2706 if (REG_P (x
) && internal_arg_pointer_based_exp (x
, false) != NULL_RTX
)
2709 iter
.skip_subrtxes ();
2715 /* Return true if SIZE bytes starting from address ADDR might overlap an
2716 already-clobbered argument area. This function is used to determine
2717 if we should give up a sibcall. */
2720 mem_might_overlap_already_clobbered_arg_p (rtx addr
, poly_uint64 size
)
2723 unsigned HOST_WIDE_INT start
, end
;
2726 if (bitmap_empty_p (stored_args_map
)
2727 && stored_args_watermark
== HOST_WIDE_INT_M1U
)
2729 val
= internal_arg_pointer_based_exp (addr
, true);
2730 if (val
== NULL_RTX
)
2732 else if (!poly_int_rtx_p (val
, &i
))
2735 if (known_eq (size
, 0U))
2738 if (STACK_GROWS_DOWNWARD
)
2739 i
-= crtl
->args
.pretend_args_size
;
2741 i
+= crtl
->args
.pretend_args_size
;
2743 if (ARGS_GROW_DOWNWARD
)
2746 /* We can ignore any references to the function's pretend args,
2747 which at this point would manifest as negative values of I. */
2748 if (known_le (i
, 0) && known_le (size
, poly_uint64 (-i
)))
2751 start
= maybe_lt (i
, 0) ? 0 : constant_lower_bound (i
);
2752 if (!(i
+ size
).is_constant (&end
))
2753 end
= HOST_WIDE_INT_M1U
;
2755 if (end
> stored_args_watermark
)
2758 end
= MIN (end
, SBITMAP_SIZE (stored_args_map
));
2759 for (unsigned HOST_WIDE_INT k
= start
; k
< end
; ++k
)
2760 if (bitmap_bit_p (stored_args_map
, k
))
2766 /* Do the register loads required for any wholly-register parms or any
2767 parms which are passed both on the stack and in a register. Their
2768 expressions were already evaluated.
2770 Mark all register-parms as living through the call, putting these USE
2771 insns in the CALL_INSN_FUNCTION_USAGE field.
2773 When IS_SIBCALL, perform the check_sibcall_argument_overlap
2774 checking, setting *SIBCALL_FAILURE if appropriate. */
2777 load_register_parameters (struct arg_data
*args
, int num_actuals
,
2778 rtx
*call_fusage
, int flags
, int is_sibcall
,
2779 int *sibcall_failure
)
2783 for (i
= 0; i
< num_actuals
; i
++)
2785 rtx reg
= ((flags
& ECF_SIBCALL
)
2786 ? args
[i
].tail_call_reg
: args
[i
].reg
);
2789 int partial
= args
[i
].partial
;
2791 poly_int64 size
= 0;
2792 HOST_WIDE_INT const_size
= 0;
2793 rtx_insn
*before_arg
= get_last_insn ();
2794 /* Set non-negative if we must move a word at a time, even if
2795 just one word (e.g, partial == 4 && mode == DFmode). Set
2796 to -1 if we just use a normal move insn. This value can be
2797 zero if the argument is a zero size structure. */
2799 if (GET_CODE (reg
) == PARALLEL
)
2803 gcc_assert (partial
% UNITS_PER_WORD
== 0);
2804 nregs
= partial
/ UNITS_PER_WORD
;
2806 else if (TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)) == BLKmode
)
2808 /* Variable-sized parameters should be described by a
2809 PARALLEL instead. */
2810 const_size
= int_size_in_bytes (TREE_TYPE (args
[i
].tree_value
));
2811 gcc_assert (const_size
>= 0);
2812 nregs
= (const_size
+ (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
;
2816 size
= GET_MODE_SIZE (args
[i
].mode
);
2818 /* Handle calls that pass values in multiple non-contiguous
2819 locations. The Irix 6 ABI has examples of this. */
2821 if (GET_CODE (reg
) == PARALLEL
)
2822 emit_group_move (reg
, args
[i
].parallel_value
);
2824 /* If simple case, just do move. If normal partial, store_one_arg
2825 has already loaded the register for us. In all other cases,
2826 load the register(s) from memory. */
2828 else if (nregs
== -1)
2830 emit_move_insn (reg
, args
[i
].value
);
2831 #ifdef BLOCK_REG_PADDING
2832 /* Handle case where we have a value that needs shifting
2833 up to the msb. eg. a QImode value and we're padding
2834 upward on a BYTES_BIG_ENDIAN machine. */
2835 if (args
[i
].locate
.where_pad
2836 == (BYTES_BIG_ENDIAN
? PAD_UPWARD
: PAD_DOWNWARD
))
2838 gcc_checking_assert (ordered_p (size
, UNITS_PER_WORD
));
2839 if (maybe_lt (size
, UNITS_PER_WORD
))
2843 = (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
2845 /* Assigning REG here rather than a temp makes
2846 CALL_FUSAGE report the whole reg as used.
2847 Strictly speaking, the call only uses SIZE
2848 bytes at the msb end, but it doesn't seem worth
2849 generating rtl to say that. */
2850 reg
= gen_rtx_REG (word_mode
, REGNO (reg
));
2851 x
= expand_shift (LSHIFT_EXPR
, word_mode
,
2852 reg
, shift
, reg
, 1);
2854 emit_move_insn (reg
, x
);
2860 /* If we have pre-computed the values to put in the registers in
2861 the case of non-aligned structures, copy them in now. */
2863 else if (args
[i
].n_aligned_regs
!= 0)
2864 for (j
= 0; j
< args
[i
].n_aligned_regs
; j
++)
2865 emit_move_insn (gen_rtx_REG (word_mode
, REGNO (reg
) + j
),
2866 args
[i
].aligned_regs
[j
]);
2868 else if (partial
== 0 || args
[i
].pass_on_stack
)
2870 /* SIZE and CONST_SIZE are 0 for partial arguments and
2871 the size of a BLKmode type otherwise. */
2872 gcc_checking_assert (known_eq (size
, const_size
));
2873 rtx mem
= validize_mem (copy_rtx (args
[i
].value
));
2875 /* Check for overlap with already clobbered argument area,
2876 providing that this has non-zero size. */
2879 && (mem_might_overlap_already_clobbered_arg_p
2880 (XEXP (args
[i
].value
, 0), const_size
)))
2881 *sibcall_failure
= 1;
2883 if (const_size
% UNITS_PER_WORD
== 0
2884 || MEM_ALIGN (mem
) % BITS_PER_WORD
== 0)
2885 move_block_to_reg (REGNO (reg
), mem
, nregs
, args
[i
].mode
);
2889 move_block_to_reg (REGNO (reg
), mem
, nregs
- 1,
2891 rtx dest
= gen_rtx_REG (word_mode
, REGNO (reg
) + nregs
- 1);
2892 unsigned int bitoff
= (nregs
- 1) * BITS_PER_WORD
;
2893 unsigned int bitsize
= const_size
* BITS_PER_UNIT
- bitoff
;
2894 rtx x
= extract_bit_field (mem
, bitsize
, bitoff
, 1, dest
,
2895 word_mode
, word_mode
, false,
2897 if (BYTES_BIG_ENDIAN
)
2898 x
= expand_shift (LSHIFT_EXPR
, word_mode
, x
,
2899 BITS_PER_WORD
- bitsize
, dest
, 1);
2901 emit_move_insn (dest
, x
);
2904 /* Handle a BLKmode that needs shifting. */
2905 if (nregs
== 1 && const_size
< UNITS_PER_WORD
2906 #ifdef BLOCK_REG_PADDING
2907 && args
[i
].locate
.where_pad
== PAD_DOWNWARD
2913 rtx dest
= gen_rtx_REG (word_mode
, REGNO (reg
));
2914 int shift
= (UNITS_PER_WORD
- const_size
) * BITS_PER_UNIT
;
2915 enum tree_code dir
= (BYTES_BIG_ENDIAN
2916 ? RSHIFT_EXPR
: LSHIFT_EXPR
);
2919 x
= expand_shift (dir
, word_mode
, dest
, shift
, dest
, 1);
2921 emit_move_insn (dest
, x
);
2925 /* When a parameter is a block, and perhaps in other cases, it is
2926 possible that it did a load from an argument slot that was
2927 already clobbered. */
2929 && check_sibcall_argument_overlap (before_arg
, &args
[i
], 0))
2930 *sibcall_failure
= 1;
2932 /* Handle calls that pass values in multiple non-contiguous
2933 locations. The Irix 6 ABI has examples of this. */
2934 if (GET_CODE (reg
) == PARALLEL
)
2935 use_group_regs (call_fusage
, reg
);
2936 else if (nregs
== -1)
2937 use_reg_mode (call_fusage
, reg
,
2938 TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)));
2940 use_regs (call_fusage
, REGNO (reg
), nregs
);
2945 /* We need to pop PENDING_STACK_ADJUST bytes. But, if the arguments
2946 wouldn't fill up an even multiple of PREFERRED_UNIT_STACK_BOUNDARY
2947 bytes, then we would need to push some additional bytes to pad the
2948 arguments. So, we try to compute an adjust to the stack pointer for an
2949 amount that will leave the stack under-aligned by UNADJUSTED_ARGS_SIZE
2950 bytes. Then, when the arguments are pushed the stack will be perfectly
2953 Return true if this optimization is possible, storing the adjustment
2954 in ADJUSTMENT_OUT and setting ARGS_SIZE->CONSTANT to the number of
2955 bytes that should be popped after the call. */
2958 combine_pending_stack_adjustment_and_call (poly_int64_pod
*adjustment_out
,
2959 poly_int64 unadjusted_args_size
,
2960 struct args_size
*args_size
,
2961 unsigned int preferred_unit_stack_boundary
)
2963 /* The number of bytes to pop so that the stack will be
2964 under-aligned by UNADJUSTED_ARGS_SIZE bytes. */
2965 poly_int64 adjustment
;
2966 /* The alignment of the stack after the arguments are pushed, if we
2967 just pushed the arguments without adjust the stack here. */
2968 unsigned HOST_WIDE_INT unadjusted_alignment
;
2970 if (!known_misalignment (stack_pointer_delta
+ unadjusted_args_size
,
2971 preferred_unit_stack_boundary
,
2972 &unadjusted_alignment
))
2975 /* We want to get rid of as many of the PENDING_STACK_ADJUST bytes
2976 as possible -- leaving just enough left to cancel out the
2977 UNADJUSTED_ALIGNMENT. In other words, we want to ensure that the
2978 PENDING_STACK_ADJUST is non-negative, and congruent to
2979 -UNADJUSTED_ALIGNMENT modulo the PREFERRED_UNIT_STACK_BOUNDARY. */
2981 /* Begin by trying to pop all the bytes. */
2982 unsigned HOST_WIDE_INT tmp_misalignment
;
2983 if (!known_misalignment (pending_stack_adjust
,
2984 preferred_unit_stack_boundary
,
2987 unadjusted_alignment
-= tmp_misalignment
;
2988 adjustment
= pending_stack_adjust
;
2989 /* Push enough additional bytes that the stack will be aligned
2990 after the arguments are pushed. */
2991 if (preferred_unit_stack_boundary
> 1 && unadjusted_alignment
)
2992 adjustment
-= preferred_unit_stack_boundary
- unadjusted_alignment
;
2994 /* We need to know whether the adjusted argument size
2995 (UNADJUSTED_ARGS_SIZE - ADJUSTMENT) constitutes an allocation
2996 or a deallocation. */
2997 if (!ordered_p (adjustment
, unadjusted_args_size
))
3000 /* Now, sets ARGS_SIZE->CONSTANT so that we pop the right number of
3001 bytes after the call. The right number is the entire
3002 PENDING_STACK_ADJUST less our ADJUSTMENT plus the amount required
3003 by the arguments in the first place. */
3005 = pending_stack_adjust
- adjustment
+ unadjusted_args_size
;
3007 *adjustment_out
= adjustment
;
3011 /* Scan X expression if it does not dereference any argument slots
3012 we already clobbered by tail call arguments (as noted in stored_args_map
3014 Return nonzero if X expression dereferences such argument slots,
3018 check_sibcall_argument_overlap_1 (rtx x
)
3027 code
= GET_CODE (x
);
3029 /* We need not check the operands of the CALL expression itself. */
3034 return (mem_might_overlap_already_clobbered_arg_p
3035 (XEXP (x
, 0), GET_MODE_SIZE (GET_MODE (x
))));
3037 /* Scan all subexpressions. */
3038 fmt
= GET_RTX_FORMAT (code
);
3039 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++, fmt
++)
3043 if (check_sibcall_argument_overlap_1 (XEXP (x
, i
)))
3046 else if (*fmt
== 'E')
3048 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3049 if (check_sibcall_argument_overlap_1 (XVECEXP (x
, i
, j
)))
3056 /* Scan sequence after INSN if it does not dereference any argument slots
3057 we already clobbered by tail call arguments (as noted in stored_args_map
3058 bitmap). If MARK_STORED_ARGS_MAP, add stack slots for ARG to
3059 stored_args_map bitmap afterwards (when ARG is a register MARK_STORED_ARGS_MAP
3060 should be 0). Return nonzero if sequence after INSN dereferences such argument
3061 slots, zero otherwise. */
3064 check_sibcall_argument_overlap (rtx_insn
*insn
, struct arg_data
*arg
,
3065 int mark_stored_args_map
)
3067 poly_uint64 low
, high
;
3068 unsigned HOST_WIDE_INT const_low
, const_high
;
3070 if (insn
== NULL_RTX
)
3071 insn
= get_insns ();
3073 insn
= NEXT_INSN (insn
);
3075 for (; insn
; insn
= NEXT_INSN (insn
))
3077 && check_sibcall_argument_overlap_1 (PATTERN (insn
)))
3080 if (mark_stored_args_map
)
3082 if (ARGS_GROW_DOWNWARD
)
3083 low
= -arg
->locate
.slot_offset
.constant
- arg
->locate
.size
.constant
;
3085 low
= arg
->locate
.slot_offset
.constant
;
3086 high
= low
+ arg
->locate
.size
.constant
;
3088 const_low
= constant_lower_bound (low
);
3089 if (high
.is_constant (&const_high
))
3090 for (unsigned HOST_WIDE_INT i
= const_low
; i
< const_high
; ++i
)
3091 bitmap_set_bit (stored_args_map
, i
);
3093 stored_args_watermark
= MIN (stored_args_watermark
, const_low
);
3095 return insn
!= NULL_RTX
;
3098 /* Given that a function returns a value of mode MODE at the most
3099 significant end of hard register VALUE, shift VALUE left or right
3100 as specified by LEFT_P. Return true if some action was needed. */
3103 shift_return_value (machine_mode mode
, bool left_p
, rtx value
)
3105 gcc_assert (REG_P (value
) && HARD_REGISTER_P (value
));
3106 machine_mode value_mode
= GET_MODE (value
);
3107 poly_int64 shift
= GET_MODE_BITSIZE (value_mode
) - GET_MODE_BITSIZE (mode
);
3109 if (known_eq (shift
, 0))
3112 /* Use ashr rather than lshr for right shifts. This is for the benefit
3113 of the MIPS port, which requires SImode values to be sign-extended
3114 when stored in 64-bit registers. */
3115 if (!force_expand_binop (value_mode
, left_p
? ashl_optab
: ashr_optab
,
3116 value
, gen_int_shift_amount (value_mode
, shift
),
3117 value
, 1, OPTAB_WIDEN
))
3122 /* If X is a likely-spilled register value, copy it to a pseudo
3123 register and return that register. Return X otherwise. */
3126 avoid_likely_spilled_reg (rtx x
)
3131 && HARD_REGISTER_P (x
)
3132 && targetm
.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (x
))))
3134 /* Make sure that we generate a REG rather than a CONCAT.
3135 Moves into CONCATs can need nontrivial instructions,
3136 and the whole point of this function is to avoid
3137 using the hard register directly in such a situation. */
3138 generating_concat_p
= 0;
3139 new_rtx
= gen_reg_rtx (GET_MODE (x
));
3140 generating_concat_p
= 1;
3141 emit_move_insn (new_rtx
, x
);
3147 /* Helper function for expand_call.
3148 Return false is EXP is not implementable as a sibling call. */
3151 can_implement_as_sibling_call_p (tree exp
,
3152 rtx structure_value_addr
,
3154 int reg_parm_stack_space ATTRIBUTE_UNUSED
,
3158 const args_size
&args_size
)
3160 if (!targetm
.have_sibcall_epilogue ())
3162 maybe_complain_about_tail_call
3164 "machine description does not have"
3165 " a sibcall_epilogue instruction pattern");
3169 /* Doing sibling call optimization needs some work, since
3170 structure_value_addr can be allocated on the stack.
3171 It does not seem worth the effort since few optimizable
3172 sibling calls will return a structure. */
3173 if (structure_value_addr
!= NULL_RTX
)
3175 maybe_complain_about_tail_call (exp
, "callee returns a structure");
3179 #ifdef REG_PARM_STACK_SPACE
3180 /* If outgoing reg parm stack space changes, we can not do sibcall. */
3181 if (OUTGOING_REG_PARM_STACK_SPACE (funtype
)
3182 != OUTGOING_REG_PARM_STACK_SPACE (TREE_TYPE (current_function_decl
))
3183 || (reg_parm_stack_space
!= REG_PARM_STACK_SPACE (current_function_decl
)))
3185 maybe_complain_about_tail_call (exp
,
3186 "inconsistent size of stack space"
3187 " allocated for arguments which are"
3188 " passed in registers");
3193 /* Check whether the target is able to optimize the call
3195 if (!targetm
.function_ok_for_sibcall (fndecl
, exp
))
3197 maybe_complain_about_tail_call (exp
,
3198 "target is not able to optimize the"
3199 " call into a sibling call");
3203 /* Functions that do not return exactly once may not be sibcall
3205 if (flags
& ECF_RETURNS_TWICE
)
3207 maybe_complain_about_tail_call (exp
, "callee returns twice");
3210 if (flags
& ECF_NORETURN
)
3212 maybe_complain_about_tail_call (exp
, "callee does not return");
3216 if (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (addr
))))
3218 maybe_complain_about_tail_call (exp
, "volatile function type");
3222 /* If the called function is nested in the current one, it might access
3223 some of the caller's arguments, but could clobber them beforehand if
3224 the argument areas are shared. */
3225 if (fndecl
&& decl_function_context (fndecl
) == current_function_decl
)
3227 maybe_complain_about_tail_call (exp
, "nested function");
3231 /* If this function requires more stack slots than the current
3232 function, we cannot change it into a sibling call.
3233 crtl->args.pretend_args_size is not part of the
3234 stack allocated by our caller. */
3235 if (maybe_gt (args_size
.constant
,
3236 crtl
->args
.size
- crtl
->args
.pretend_args_size
))
3238 maybe_complain_about_tail_call (exp
,
3239 "callee required more stack slots"
3240 " than the caller");
3244 /* If the callee pops its own arguments, then it must pop exactly
3245 the same number of arguments as the current function. */
3246 if (maybe_ne (targetm
.calls
.return_pops_args (fndecl
, funtype
,
3247 args_size
.constant
),
3248 targetm
.calls
.return_pops_args (current_function_decl
,
3250 (current_function_decl
),
3253 maybe_complain_about_tail_call (exp
,
3254 "inconsistent number of"
3255 " popped arguments");
3259 if (!lang_hooks
.decls
.ok_for_sibcall (fndecl
))
3261 maybe_complain_about_tail_call (exp
, "frontend does not support"
3266 /* All checks passed. */
3270 /* Generate all the code for a CALL_EXPR exp
3271 and return an rtx for its value.
3272 Store the value in TARGET (specified as an rtx) if convenient.
3273 If the value is stored in TARGET then TARGET is returned.
3274 If IGNORE is nonzero, then we ignore the value of the function call. */
3277 expand_call (tree exp
, rtx target
, int ignore
)
3279 /* Nonzero if we are currently expanding a call. */
3280 static int currently_expanding_call
= 0;
3282 /* RTX for the function to be called. */
3284 /* Sequence of insns to perform a normal "call". */
3285 rtx_insn
*normal_call_insns
= NULL
;
3286 /* Sequence of insns to perform a tail "call". */
3287 rtx_insn
*tail_call_insns
= NULL
;
3288 /* Data type of the function. */
3290 tree type_arg_types
;
3292 /* Declaration of the function being called,
3293 or 0 if the function is computed (not known by name). */
3295 /* The type of the function being called. */
3297 bool try_tail_call
= CALL_EXPR_TAILCALL (exp
);
3298 bool must_tail_call
= CALL_EXPR_MUST_TAIL_CALL (exp
);
3301 /* Register in which non-BLKmode value will be returned,
3302 or 0 if no value or if value is BLKmode. */
3304 /* Register(s) in which bounds are returned. */
3306 /* Address where we should return a BLKmode value;
3307 0 if value not BLKmode. */
3308 rtx structure_value_addr
= 0;
3309 /* Nonzero if that address is being passed by treating it as
3310 an extra, implicit first parameter. Otherwise,
3311 it is passed by being copied directly into struct_value_rtx. */
3312 int structure_value_addr_parm
= 0;
3313 /* Holds the value of implicit argument for the struct value. */
3314 tree structure_value_addr_value
= NULL_TREE
;
3315 /* Size of aggregate value wanted, or zero if none wanted
3316 or if we are using the non-reentrant PCC calling convention
3317 or expecting the value in registers. */
3318 poly_int64 struct_value_size
= 0;
3319 /* Nonzero if called function returns an aggregate in memory PCC style,
3320 by returning the address of where to find it. */
3321 int pcc_struct_value
= 0;
3322 rtx struct_value
= 0;
3324 /* Number of actual parameters in this call, including struct value addr. */
3326 /* Number of named args. Args after this are anonymous ones
3327 and they must all go on the stack. */
3329 /* Number of complex actual arguments that need to be split. */
3330 int num_complex_actuals
= 0;
3332 /* Vector of information about each argument.
3333 Arguments are numbered in the order they will be pushed,
3334 not the order they are written. */
3335 struct arg_data
*args
;
3337 /* Total size in bytes of all the stack-parms scanned so far. */
3338 struct args_size args_size
;
3339 struct args_size adjusted_args_size
;
3340 /* Size of arguments before any adjustments (such as rounding). */
3341 poly_int64 unadjusted_args_size
;
3342 /* Data on reg parms scanned so far. */
3343 CUMULATIVE_ARGS args_so_far_v
;
3344 cumulative_args_t args_so_far
;
3345 /* Nonzero if a reg parm has been scanned. */
3347 /* Nonzero if this is an indirect function call. */
3349 /* Nonzero if we must avoid push-insns in the args for this call.
3350 If stack space is allocated for register parameters, but not by the
3351 caller, then it is preallocated in the fixed part of the stack frame.
3352 So the entire argument block must then be preallocated (i.e., we
3353 ignore PUSH_ROUNDING in that case). */
3355 int must_preallocate
= !PUSH_ARGS
;
3357 /* Size of the stack reserved for parameter registers. */
3358 int reg_parm_stack_space
= 0;
3360 /* Address of space preallocated for stack parms
3361 (on machines that lack push insns), or 0 if space not preallocated. */
3364 /* Mask of ECF_ and ERF_ flags. */
3366 int return_flags
= 0;
3367 #ifdef REG_PARM_STACK_SPACE
3368 /* Define the boundary of the register parm stack space that needs to be
3370 int low_to_save
, high_to_save
;
3371 rtx save_area
= 0; /* Place that it is saved */
3374 unsigned int initial_highest_arg_in_use
= highest_outgoing_arg_in_use
;
3375 char *initial_stack_usage_map
= stack_usage_map
;
3376 unsigned HOST_WIDE_INT initial_stack_usage_watermark
= stack_usage_watermark
;
3377 char *stack_usage_map_buf
= NULL
;
3379 poly_int64 old_stack_allocated
;
3381 /* State variables to track stack modifications. */
3382 rtx old_stack_level
= 0;
3383 int old_stack_arg_under_construction
= 0;
3384 poly_int64 old_pending_adj
= 0;
3385 int old_inhibit_defer_pop
= inhibit_defer_pop
;
3387 /* Some stack pointer alterations we make are performed via
3388 allocate_dynamic_stack_space. This modifies the stack_pointer_delta,
3389 which we then also need to save/restore along the way. */
3390 poly_int64 old_stack_pointer_delta
= 0;
3393 tree addr
= CALL_EXPR_FN (exp
);
3395 /* The alignment of the stack, in bits. */
3396 unsigned HOST_WIDE_INT preferred_stack_boundary
;
3397 /* The alignment of the stack, in bytes. */
3398 unsigned HOST_WIDE_INT preferred_unit_stack_boundary
;
3399 /* The static chain value to use for this call. */
3400 rtx static_chain_value
;
3401 /* See if this is "nothrow" function call. */
3402 if (TREE_NOTHROW (exp
))
3403 flags
|= ECF_NOTHROW
;
3405 /* See if we can find a DECL-node for the actual function, and get the
3406 function attributes (flags) from the function decl or type node. */
3407 fndecl
= get_callee_fndecl (exp
);
3410 fntype
= TREE_TYPE (fndecl
);
3411 flags
|= flags_from_decl_or_type (fndecl
);
3412 return_flags
|= decl_return_flags (fndecl
);
3416 fntype
= TREE_TYPE (TREE_TYPE (addr
));
3417 flags
|= flags_from_decl_or_type (fntype
);
3418 if (CALL_EXPR_BY_DESCRIPTOR (exp
))
3419 flags
|= ECF_BY_DESCRIPTOR
;
3421 rettype
= TREE_TYPE (exp
);
3423 struct_value
= targetm
.calls
.struct_value_rtx (fntype
, 0);
3425 /* Warn if this value is an aggregate type,
3426 regardless of which calling convention we are using for it. */
3427 if (AGGREGATE_TYPE_P (rettype
))
3428 warning (OPT_Waggregate_return
, "function call has aggregate value");
3430 /* If the result of a non looping pure or const function call is
3431 ignored (or void), and none of its arguments are volatile, we can
3432 avoid expanding the call and just evaluate the arguments for
3434 if ((flags
& (ECF_CONST
| ECF_PURE
))
3435 && (!(flags
& ECF_LOOPING_CONST_OR_PURE
))
3436 && (ignore
|| target
== const0_rtx
3437 || TYPE_MODE (rettype
) == VOIDmode
))
3439 bool volatilep
= false;
3441 call_expr_arg_iterator iter
;
3443 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
3444 if (TREE_THIS_VOLATILE (arg
))
3452 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
3453 expand_expr (arg
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
3458 #ifdef REG_PARM_STACK_SPACE
3459 reg_parm_stack_space
= REG_PARM_STACK_SPACE (!fndecl
? fntype
: fndecl
);
3462 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
)))
3463 && reg_parm_stack_space
> 0 && PUSH_ARGS
)
3464 must_preallocate
= 1;
3466 /* Set up a place to return a structure. */
3468 /* Cater to broken compilers. */
3469 if (aggregate_value_p (exp
, fntype
))
3471 /* This call returns a big structure. */
3472 flags
&= ~(ECF_CONST
| ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
);
3474 #ifdef PCC_STATIC_STRUCT_RETURN
3476 pcc_struct_value
= 1;
3478 #else /* not PCC_STATIC_STRUCT_RETURN */
3480 if (!poly_int_tree_p (TYPE_SIZE_UNIT (rettype
), &struct_value_size
))
3481 struct_value_size
= -1;
3483 /* Even if it is semantically safe to use the target as the return
3484 slot, it may be not sufficiently aligned for the return type. */
3485 if (CALL_EXPR_RETURN_SLOT_OPT (exp
)
3488 /* If rettype is addressable, we may not create a temporary.
3489 If target is properly aligned at runtime and the compiler
3490 just doesn't know about it, it will work fine, otherwise it
3492 && (TREE_ADDRESSABLE (rettype
)
3493 || !(MEM_ALIGN (target
) < TYPE_ALIGN (rettype
)
3494 && targetm
.slow_unaligned_access (TYPE_MODE (rettype
),
3495 MEM_ALIGN (target
)))))
3496 structure_value_addr
= XEXP (target
, 0);
3499 /* For variable-sized objects, we must be called with a target
3500 specified. If we were to allocate space on the stack here,
3501 we would have no way of knowing when to free it. */
3502 rtx d
= assign_temp (rettype
, 1, 1);
3503 structure_value_addr
= XEXP (d
, 0);
3507 #endif /* not PCC_STATIC_STRUCT_RETURN */
3510 /* Figure out the amount to which the stack should be aligned. */
3511 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
3514 struct cgraph_rtl_info
*i
= cgraph_node::rtl_info (fndecl
);
3515 /* Without automatic stack alignment, we can't increase preferred
3516 stack boundary. With automatic stack alignment, it is
3517 unnecessary since unless we can guarantee that all callers will
3518 align the outgoing stack properly, callee has to align its
3521 && i
->preferred_incoming_stack_boundary
3522 && i
->preferred_incoming_stack_boundary
< preferred_stack_boundary
)
3523 preferred_stack_boundary
= i
->preferred_incoming_stack_boundary
;
3526 /* Operand 0 is a pointer-to-function; get the type of the function. */
3527 funtype
= TREE_TYPE (addr
);
3528 gcc_assert (POINTER_TYPE_P (funtype
));
3529 funtype
= TREE_TYPE (funtype
);
3531 /* Count whether there are actual complex arguments that need to be split
3532 into their real and imaginary parts. Munge the type_arg_types
3533 appropriately here as well. */
3534 if (targetm
.calls
.split_complex_arg
)
3536 call_expr_arg_iterator iter
;
3538 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
3540 tree type
= TREE_TYPE (arg
);
3541 if (type
&& TREE_CODE (type
) == COMPLEX_TYPE
3542 && targetm
.calls
.split_complex_arg (type
))
3543 num_complex_actuals
++;
3545 type_arg_types
= split_complex_types (TYPE_ARG_TYPES (funtype
));
3548 type_arg_types
= TYPE_ARG_TYPES (funtype
);
3550 if (flags
& ECF_MAY_BE_ALLOCA
)
3551 cfun
->calls_alloca
= 1;
3553 /* If struct_value_rtx is 0, it means pass the address
3554 as if it were an extra parameter. Put the argument expression
3555 in structure_value_addr_value. */
3556 if (structure_value_addr
&& struct_value
== 0)
3558 /* If structure_value_addr is a REG other than
3559 virtual_outgoing_args_rtx, we can use always use it. If it
3560 is not a REG, we must always copy it into a register.
3561 If it is virtual_outgoing_args_rtx, we must copy it to another
3562 register in some cases. */
3563 rtx temp
= (!REG_P (structure_value_addr
)
3564 || (ACCUMULATE_OUTGOING_ARGS
3565 && stack_arg_under_construction
3566 && structure_value_addr
== virtual_outgoing_args_rtx
)
3567 ? copy_addr_to_reg (convert_memory_address
3568 (Pmode
, structure_value_addr
))
3569 : structure_value_addr
);
3571 structure_value_addr_value
=
3572 make_tree (build_pointer_type (TREE_TYPE (funtype
)), temp
);
3573 structure_value_addr_parm
= CALL_WITH_BOUNDS_P (exp
) ? 2 : 1;
3576 /* Count the arguments and set NUM_ACTUALS. */
3578 call_expr_nargs (exp
) + num_complex_actuals
+ structure_value_addr_parm
;
3580 /* Compute number of named args.
3581 First, do a raw count of the args for INIT_CUMULATIVE_ARGS. */
3583 if (type_arg_types
!= 0)
3585 = (list_length (type_arg_types
)
3586 /* Count the struct value address, if it is passed as a parm. */
3587 + structure_value_addr_parm
);
3589 /* If we know nothing, treat all args as named. */
3590 n_named_args
= num_actuals
;
3592 /* Start updating where the next arg would go.
3594 On some machines (such as the PA) indirect calls have a different
3595 calling convention than normal calls. The fourth argument in
3596 INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
3598 INIT_CUMULATIVE_ARGS (args_so_far_v
, funtype
, NULL_RTX
, fndecl
, n_named_args
);
3599 args_so_far
= pack_cumulative_args (&args_so_far_v
);
3601 /* Now possibly adjust the number of named args.
3602 Normally, don't include the last named arg if anonymous args follow.
3603 We do include the last named arg if
3604 targetm.calls.strict_argument_naming() returns nonzero.
3605 (If no anonymous args follow, the result of list_length is actually
3606 one too large. This is harmless.)
3608 If targetm.calls.pretend_outgoing_varargs_named() returns
3609 nonzero, and targetm.calls.strict_argument_naming() returns zero,
3610 this machine will be able to place unnamed args that were passed
3611 in registers into the stack. So treat all args as named. This
3612 allows the insns emitting for a specific argument list to be
3613 independent of the function declaration.
3615 If targetm.calls.pretend_outgoing_varargs_named() returns zero,
3616 we do not have any reliable way to pass unnamed args in
3617 registers, so we must force them into memory. */
3619 if (type_arg_types
!= 0
3620 && targetm
.calls
.strict_argument_naming (args_so_far
))
3622 else if (type_arg_types
!= 0
3623 && ! targetm
.calls
.pretend_outgoing_varargs_named (args_so_far
))
3624 /* Don't include the last named arg. */
3627 /* Treat all args as named. */
3628 n_named_args
= num_actuals
;
3630 /* Make a vector to hold all the information about each arg. */
3631 args
= XCNEWVEC (struct arg_data
, num_actuals
);
3633 /* Build up entries in the ARGS array, compute the size of the
3634 arguments into ARGS_SIZE, etc. */
3635 initialize_argument_information (num_actuals
, args
, &args_size
,
3637 structure_value_addr_value
, fndecl
, fntype
,
3638 args_so_far
, reg_parm_stack_space
,
3639 &old_stack_level
, &old_pending_adj
,
3640 &must_preallocate
, &flags
,
3641 &try_tail_call
, CALL_FROM_THUNK_P (exp
));
3644 must_preallocate
= 1;
3646 /* Now make final decision about preallocating stack space. */
3647 must_preallocate
= finalize_must_preallocate (must_preallocate
,
3651 /* If the structure value address will reference the stack pointer, we
3652 must stabilize it. We don't need to do this if we know that we are
3653 not going to adjust the stack pointer in processing this call. */
3655 if (structure_value_addr
3656 && (reg_mentioned_p (virtual_stack_dynamic_rtx
, structure_value_addr
)
3657 || reg_mentioned_p (virtual_outgoing_args_rtx
,
3658 structure_value_addr
))
3660 || (!ACCUMULATE_OUTGOING_ARGS
3661 && maybe_ne (args_size
.constant
, 0))))
3662 structure_value_addr
= copy_to_reg (structure_value_addr
);
3664 /* Tail calls can make things harder to debug, and we've traditionally
3665 pushed these optimizations into -O2. Don't try if we're already
3666 expanding a call, as that means we're an argument. Don't try if
3667 there's cleanups, as we know there's code to follow the call. */
3669 if (currently_expanding_call
++ != 0
3670 || !flag_optimize_sibling_calls
3672 || dbg_cnt (tail_call
) == false)
3675 /* If the user has marked the function as requiring tail-call
3676 optimization, attempt it. */
3680 /* Rest of purposes for tail call optimizations to fail. */
3682 try_tail_call
= can_implement_as_sibling_call_p (exp
,
3683 structure_value_addr
,
3685 reg_parm_stack_space
,
3687 flags
, addr
, args_size
);
3689 /* Check if caller and callee disagree in promotion of function
3693 machine_mode caller_mode
, caller_promoted_mode
;
3694 machine_mode callee_mode
, callee_promoted_mode
;
3695 int caller_unsignedp
, callee_unsignedp
;
3696 tree caller_res
= DECL_RESULT (current_function_decl
);
3698 caller_unsignedp
= TYPE_UNSIGNED (TREE_TYPE (caller_res
));
3699 caller_mode
= DECL_MODE (caller_res
);
3700 callee_unsignedp
= TYPE_UNSIGNED (TREE_TYPE (funtype
));
3701 callee_mode
= TYPE_MODE (TREE_TYPE (funtype
));
3702 caller_promoted_mode
3703 = promote_function_mode (TREE_TYPE (caller_res
), caller_mode
,
3705 TREE_TYPE (current_function_decl
), 1);
3706 callee_promoted_mode
3707 = promote_function_mode (TREE_TYPE (funtype
), callee_mode
,
3710 if (caller_mode
!= VOIDmode
3711 && (caller_promoted_mode
!= callee_promoted_mode
3712 || ((caller_mode
!= caller_promoted_mode
3713 || callee_mode
!= callee_promoted_mode
)
3714 && (caller_unsignedp
!= callee_unsignedp
3715 || partial_subreg_p (caller_mode
, callee_mode
)))))
3718 maybe_complain_about_tail_call (exp
,
3719 "caller and callee disagree in"
3720 " promotion of function"
3725 /* Ensure current function's preferred stack boundary is at least
3726 what we need. Stack alignment may also increase preferred stack
3728 if (crtl
->preferred_stack_boundary
< preferred_stack_boundary
)
3729 crtl
->preferred_stack_boundary
= preferred_stack_boundary
;
3731 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
3733 preferred_unit_stack_boundary
= preferred_stack_boundary
/ BITS_PER_UNIT
;
3735 /* We want to make two insn chains; one for a sibling call, the other
3736 for a normal call. We will select one of the two chains after
3737 initial RTL generation is complete. */
3738 for (pass
= try_tail_call
? 0 : 1; pass
< 2; pass
++)
3740 int sibcall_failure
= 0;
3741 /* We want to emit any pending stack adjustments before the tail
3742 recursion "call". That way we know any adjustment after the tail
3743 recursion call can be ignored if we indeed use the tail
3745 saved_pending_stack_adjust save
;
3746 rtx_insn
*insns
, *before_call
, *after_args
;
3751 /* State variables we need to save and restore between
3753 save_pending_stack_adjust (&save
);
3756 flags
&= ~ECF_SIBCALL
;
3758 flags
|= ECF_SIBCALL
;
3760 /* Other state variables that we must reinitialize each time
3761 through the loop (that are not initialized by the loop itself). */
3765 /* Start a new sequence for the normal call case.
3767 From this point on, if the sibling call fails, we want to set
3768 sibcall_failure instead of continuing the loop. */
3771 /* Don't let pending stack adjusts add up to too much.
3772 Also, do all pending adjustments now if there is any chance
3773 this might be a call to alloca or if we are expanding a sibling
3775 Also do the adjustments before a throwing call, otherwise
3776 exception handling can fail; PR 19225. */
3777 if (maybe_ge (pending_stack_adjust
, 32)
3778 || (maybe_ne (pending_stack_adjust
, 0)
3779 && (flags
& ECF_MAY_BE_ALLOCA
))
3780 || (maybe_ne (pending_stack_adjust
, 0)
3781 && flag_exceptions
&& !(flags
& ECF_NOTHROW
))
3783 do_pending_stack_adjust ();
3785 /* Precompute any arguments as needed. */
3787 precompute_arguments (num_actuals
, args
);
3789 /* Now we are about to start emitting insns that can be deleted
3790 if a libcall is deleted. */
3791 if (pass
&& (flags
& ECF_MALLOC
))
3795 && crtl
->stack_protect_guard
3796 && targetm
.stack_protect_runtime_enabled_p ())
3797 stack_protect_epilogue ();
3799 adjusted_args_size
= args_size
;
3800 /* Compute the actual size of the argument block required. The variable
3801 and constant sizes must be combined, the size may have to be rounded,
3802 and there may be a minimum required size. When generating a sibcall
3803 pattern, do not round up, since we'll be re-using whatever space our
3805 unadjusted_args_size
3806 = compute_argument_block_size (reg_parm_stack_space
,
3807 &adjusted_args_size
,
3810 : preferred_stack_boundary
));
3812 old_stack_allocated
= stack_pointer_delta
- pending_stack_adjust
;
3814 /* The argument block when performing a sibling call is the
3815 incoming argument block. */
3818 argblock
= crtl
->args
.internal_arg_pointer
;
3819 if (STACK_GROWS_DOWNWARD
)
3821 = plus_constant (Pmode
, argblock
, crtl
->args
.pretend_args_size
);
3824 = plus_constant (Pmode
, argblock
, -crtl
->args
.pretend_args_size
);
3826 HOST_WIDE_INT map_size
= constant_lower_bound (args_size
.constant
);
3827 stored_args_map
= sbitmap_alloc (map_size
);
3828 bitmap_clear (stored_args_map
);
3829 stored_args_watermark
= HOST_WIDE_INT_M1U
;
3832 /* If we have no actual push instructions, or shouldn't use them,
3833 make space for all args right now. */
3834 else if (adjusted_args_size
.var
!= 0)
3836 if (old_stack_level
== 0)
3838 emit_stack_save (SAVE_BLOCK
, &old_stack_level
);
3839 old_stack_pointer_delta
= stack_pointer_delta
;
3840 old_pending_adj
= pending_stack_adjust
;
3841 pending_stack_adjust
= 0;
3842 /* stack_arg_under_construction says whether a stack arg is
3843 being constructed at the old stack level. Pushing the stack
3844 gets a clean outgoing argument block. */
3845 old_stack_arg_under_construction
= stack_arg_under_construction
;
3846 stack_arg_under_construction
= 0;
3848 argblock
= push_block (ARGS_SIZE_RTX (adjusted_args_size
), 0, 0);
3849 if (flag_stack_usage_info
)
3850 current_function_has_unbounded_dynamic_stack_size
= 1;
3854 /* Note that we must go through the motions of allocating an argument
3855 block even if the size is zero because we may be storing args
3856 in the area reserved for register arguments, which may be part of
3859 poly_int64 needed
= adjusted_args_size
.constant
;
3861 /* Store the maximum argument space used. It will be pushed by
3862 the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
3865 crtl
->outgoing_args_size
= upper_bound (crtl
->outgoing_args_size
,
3868 if (must_preallocate
)
3870 if (ACCUMULATE_OUTGOING_ARGS
)
3872 /* Since the stack pointer will never be pushed, it is
3873 possible for the evaluation of a parm to clobber
3874 something we have already written to the stack.
3875 Since most function calls on RISC machines do not use
3876 the stack, this is uncommon, but must work correctly.
3878 Therefore, we save any area of the stack that was already
3879 written and that we are using. Here we set up to do this
3880 by making a new stack usage map from the old one. The
3881 actual save will be done by store_one_arg.
3883 Another approach might be to try to reorder the argument
3884 evaluations to avoid this conflicting stack usage. */
3886 /* Since we will be writing into the entire argument area,
3887 the map must be allocated for its entire size, not just
3888 the part that is the responsibility of the caller. */
3889 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
3890 needed
+= reg_parm_stack_space
;
3892 poly_int64 limit
= needed
;
3893 if (ARGS_GROW_DOWNWARD
)
3896 /* For polynomial sizes, this is the maximum possible
3897 size needed for arguments with a constant size
3899 HOST_WIDE_INT const_limit
= constant_lower_bound (limit
);
3900 highest_outgoing_arg_in_use
3901 = MAX (initial_highest_arg_in_use
, const_limit
);
3903 free (stack_usage_map_buf
);
3904 stack_usage_map_buf
= XNEWVEC (char, highest_outgoing_arg_in_use
);
3905 stack_usage_map
= stack_usage_map_buf
;
3907 if (initial_highest_arg_in_use
)
3908 memcpy (stack_usage_map
, initial_stack_usage_map
,
3909 initial_highest_arg_in_use
);
3911 if (initial_highest_arg_in_use
!= highest_outgoing_arg_in_use
)
3912 memset (&stack_usage_map
[initial_highest_arg_in_use
], 0,
3913 (highest_outgoing_arg_in_use
3914 - initial_highest_arg_in_use
));
3917 /* The address of the outgoing argument list must not be
3918 copied to a register here, because argblock would be left
3919 pointing to the wrong place after the call to
3920 allocate_dynamic_stack_space below. */
3922 argblock
= virtual_outgoing_args_rtx
;
3926 /* Try to reuse some or all of the pending_stack_adjust
3927 to get this space. */
3928 if (inhibit_defer_pop
== 0
3929 && (combine_pending_stack_adjustment_and_call
3931 unadjusted_args_size
,
3932 &adjusted_args_size
,
3933 preferred_unit_stack_boundary
)))
3935 /* combine_pending_stack_adjustment_and_call computes
3936 an adjustment before the arguments are allocated.
3937 Account for them and see whether or not the stack
3938 needs to go up or down. */
3939 needed
= unadjusted_args_size
- needed
;
3942 combine_pending_stack_adjustment_and_call. */
3943 gcc_checking_assert (ordered_p (needed
, 0));
3944 if (maybe_lt (needed
, 0))
3946 /* We're releasing stack space. */
3947 /* ??? We can avoid any adjustment at all if we're
3948 already aligned. FIXME. */
3949 pending_stack_adjust
= -needed
;
3950 do_pending_stack_adjust ();
3954 /* We need to allocate space. We'll do that in
3955 push_block below. */
3956 pending_stack_adjust
= 0;
3959 /* Special case this because overhead of `push_block' in
3960 this case is non-trivial. */
3961 if (known_eq (needed
, 0))
3962 argblock
= virtual_outgoing_args_rtx
;
3965 rtx needed_rtx
= gen_int_mode (needed
, Pmode
);
3966 argblock
= push_block (needed_rtx
, 0, 0);
3967 if (ARGS_GROW_DOWNWARD
)
3968 argblock
= plus_constant (Pmode
, argblock
, needed
);
3971 /* We only really need to call `copy_to_reg' in the case
3972 where push insns are going to be used to pass ARGBLOCK
3973 to a function call in ARGS. In that case, the stack
3974 pointer changes value from the allocation point to the
3975 call point, and hence the value of
3976 VIRTUAL_OUTGOING_ARGS_RTX changes as well. But might
3977 as well always do it. */
3978 argblock
= copy_to_reg (argblock
);
3983 if (ACCUMULATE_OUTGOING_ARGS
)
3985 /* The save/restore code in store_one_arg handles all
3986 cases except one: a constructor call (including a C
3987 function returning a BLKmode struct) to initialize
3989 if (stack_arg_under_construction
)
3993 (adjusted_args_size
.constant
3994 + (OUTGOING_REG_PARM_STACK_SPACE (!fndecl
? fntype
3995 : TREE_TYPE (fndecl
))
3996 ? 0 : reg_parm_stack_space
), Pmode
));
3997 if (old_stack_level
== 0)
3999 emit_stack_save (SAVE_BLOCK
, &old_stack_level
);
4000 old_stack_pointer_delta
= stack_pointer_delta
;
4001 old_pending_adj
= pending_stack_adjust
;
4002 pending_stack_adjust
= 0;
4003 /* stack_arg_under_construction says whether a stack
4004 arg is being constructed at the old stack level.
4005 Pushing the stack gets a clean outgoing argument
4007 old_stack_arg_under_construction
4008 = stack_arg_under_construction
;
4009 stack_arg_under_construction
= 0;
4010 /* Make a new map for the new argument list. */
4011 free (stack_usage_map_buf
);
4012 stack_usage_map_buf
= XCNEWVEC (char, highest_outgoing_arg_in_use
);
4013 stack_usage_map
= stack_usage_map_buf
;
4014 highest_outgoing_arg_in_use
= 0;
4015 stack_usage_watermark
= HOST_WIDE_INT_M1U
;
4017 /* We can pass TRUE as the 4th argument because we just
4018 saved the stack pointer and will restore it right after
4020 allocate_dynamic_stack_space (push_size
, 0, BIGGEST_ALIGNMENT
,
4024 /* If argument evaluation might modify the stack pointer,
4025 copy the address of the argument list to a register. */
4026 for (i
= 0; i
< num_actuals
; i
++)
4027 if (args
[i
].pass_on_stack
)
4029 argblock
= copy_addr_to_reg (argblock
);
4034 compute_argument_addresses (args
, argblock
, num_actuals
);
4036 /* Stack is properly aligned, pops can't safely be deferred during
4037 the evaluation of the arguments. */
4040 /* Precompute all register parameters. It isn't safe to compute
4041 anything once we have started filling any specific hard regs.
4042 TLS symbols sometimes need a call to resolve. Precompute
4043 register parameters before any stack pointer manipulation
4044 to avoid unaligned stack in the called function. */
4045 precompute_register_parameters (num_actuals
, args
, ®_parm_seen
);
4049 /* Perform stack alignment before the first push (the last arg). */
4051 && maybe_gt (adjusted_args_size
.constant
, reg_parm_stack_space
)
4052 && maybe_ne (adjusted_args_size
.constant
, unadjusted_args_size
))
4054 /* When the stack adjustment is pending, we get better code
4055 by combining the adjustments. */
4056 if (maybe_ne (pending_stack_adjust
, 0)
4057 && ! inhibit_defer_pop
4058 && (combine_pending_stack_adjustment_and_call
4059 (&pending_stack_adjust
,
4060 unadjusted_args_size
,
4061 &adjusted_args_size
,
4062 preferred_unit_stack_boundary
)))
4063 do_pending_stack_adjust ();
4064 else if (argblock
== 0)
4065 anti_adjust_stack (gen_int_mode (adjusted_args_size
.constant
4066 - unadjusted_args_size
,
4069 /* Now that the stack is properly aligned, pops can't safely
4070 be deferred during the evaluation of the arguments. */
4073 /* Record the maximum pushed stack space size. We need to delay
4074 doing it this far to take into account the optimization done
4075 by combine_pending_stack_adjustment_and_call. */
4076 if (flag_stack_usage_info
4077 && !ACCUMULATE_OUTGOING_ARGS
4079 && adjusted_args_size
.var
== 0)
4081 poly_int64 pushed
= (adjusted_args_size
.constant
4082 + pending_stack_adjust
);
4083 current_function_pushed_stack_size
4084 = upper_bound (current_function_pushed_stack_size
, pushed
);
4087 funexp
= rtx_for_function_call (fndecl
, addr
);
4089 if (CALL_EXPR_STATIC_CHAIN (exp
))
4090 static_chain_value
= expand_normal (CALL_EXPR_STATIC_CHAIN (exp
));
4092 static_chain_value
= 0;
4094 #ifdef REG_PARM_STACK_SPACE
4095 /* Save the fixed argument area if it's part of the caller's frame and
4096 is clobbered by argument setup for this call. */
4097 if (ACCUMULATE_OUTGOING_ARGS
&& pass
)
4098 save_area
= save_fixed_argument_area (reg_parm_stack_space
, argblock
,
4099 &low_to_save
, &high_to_save
);
4102 /* Now store (and compute if necessary) all non-register parms.
4103 These come before register parms, since they can require block-moves,
4104 which could clobber the registers used for register parms.
4105 Parms which have partial registers are not stored here,
4106 but we do preallocate space here if they want that. */
4108 for (i
= 0; i
< num_actuals
; i
++)
4110 /* Delay bounds until all other args are stored. */
4111 if (POINTER_BOUNDS_P (args
[i
].tree_value
))
4113 else if (args
[i
].reg
== 0 || args
[i
].pass_on_stack
)
4115 rtx_insn
*before_arg
= get_last_insn ();
4117 /* We don't allow passing huge (> 2^30 B) arguments
4118 by value. It would cause an overflow later on. */
4119 if (constant_lower_bound (adjusted_args_size
.constant
)
4120 >= (1 << (HOST_BITS_PER_INT
- 2)))
4122 sorry ("passing too large argument on stack");
4126 if (store_one_arg (&args
[i
], argblock
, flags
,
4127 adjusted_args_size
.var
!= 0,
4128 reg_parm_stack_space
)
4130 && check_sibcall_argument_overlap (before_arg
,
4132 sibcall_failure
= 1;
4137 = gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)),
4138 gen_rtx_USE (VOIDmode
, args
[i
].stack
),
4142 /* If we have a parm that is passed in registers but not in memory
4143 and whose alignment does not permit a direct copy into registers,
4144 make a group of pseudos that correspond to each register that we
4146 if (STRICT_ALIGNMENT
)
4147 store_unaligned_arguments_into_pseudos (args
, num_actuals
);
4149 /* Now store any partially-in-registers parm.
4150 This is the last place a block-move can happen. */
4152 for (i
= 0; i
< num_actuals
; i
++)
4153 if (args
[i
].partial
!= 0 && ! args
[i
].pass_on_stack
)
4155 rtx_insn
*before_arg
= get_last_insn ();
4157 /* On targets with weird calling conventions (e.g. PA) it's
4158 hard to ensure that all cases of argument overlap between
4159 stack and registers work. Play it safe and bail out. */
4160 if (ARGS_GROW_DOWNWARD
&& !STACK_GROWS_DOWNWARD
)
4162 sibcall_failure
= 1;
4166 if (store_one_arg (&args
[i
], argblock
, flags
,
4167 adjusted_args_size
.var
!= 0,
4168 reg_parm_stack_space
)
4170 && check_sibcall_argument_overlap (before_arg
,
4172 sibcall_failure
= 1;
4175 bool any_regs
= false;
4176 for (i
= 0; i
< num_actuals
; i
++)
4177 if (args
[i
].reg
!= NULL_RTX
)
4180 targetm
.calls
.call_args (args
[i
].reg
, funtype
);
4183 targetm
.calls
.call_args (pc_rtx
, funtype
);
4185 /* Figure out the register where the value, if any, will come back. */
4188 if (TYPE_MODE (rettype
) != VOIDmode
4189 && ! structure_value_addr
)
4191 if (pcc_struct_value
)
4193 valreg
= hard_function_value (build_pointer_type (rettype
),
4194 fndecl
, NULL
, (pass
== 0));
4195 if (CALL_WITH_BOUNDS_P (exp
))
4196 valbnd
= targetm
.calls
.
4197 chkp_function_value_bounds (build_pointer_type (rettype
),
4198 fndecl
, (pass
== 0));
4202 valreg
= hard_function_value (rettype
, fndecl
, fntype
,
4204 if (CALL_WITH_BOUNDS_P (exp
))
4205 valbnd
= targetm
.calls
.chkp_function_value_bounds (rettype
,
4210 /* If VALREG is a PARALLEL whose first member has a zero
4211 offset, use that. This is for targets such as m68k that
4212 return the same value in multiple places. */
4213 if (GET_CODE (valreg
) == PARALLEL
)
4215 rtx elem
= XVECEXP (valreg
, 0, 0);
4216 rtx where
= XEXP (elem
, 0);
4217 rtx offset
= XEXP (elem
, 1);
4218 if (offset
== const0_rtx
4219 && GET_MODE (where
) == GET_MODE (valreg
))
4224 /* Store all bounds not passed in registers. */
4225 for (i
= 0; i
< num_actuals
; i
++)
4227 if (POINTER_BOUNDS_P (args
[i
].tree_value
)
4229 store_bounds (&args
[i
],
4230 args
[i
].pointer_arg
== -1
4232 : &args
[args
[i
].pointer_arg
]);
4235 /* If register arguments require space on the stack and stack space
4236 was not preallocated, allocate stack space here for arguments
4237 passed in registers. */
4238 if (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
)))
4239 && !ACCUMULATE_OUTGOING_ARGS
4240 && must_preallocate
== 0 && reg_parm_stack_space
> 0)
4241 anti_adjust_stack (GEN_INT (reg_parm_stack_space
));
4243 /* Pass the function the address in which to return a
4245 if (pass
!= 0 && structure_value_addr
&& ! structure_value_addr_parm
)
4247 structure_value_addr
4248 = convert_memory_address (Pmode
, structure_value_addr
);
4249 emit_move_insn (struct_value
,
4251 force_operand (structure_value_addr
,
4254 if (REG_P (struct_value
))
4255 use_reg (&call_fusage
, struct_value
);
4258 after_args
= get_last_insn ();
4259 funexp
= prepare_call_address (fndecl
? fndecl
: fntype
, funexp
,
4260 static_chain_value
, &call_fusage
,
4261 reg_parm_seen
, flags
);
4263 load_register_parameters (args
, num_actuals
, &call_fusage
, flags
,
4264 pass
== 0, &sibcall_failure
);
4266 /* Save a pointer to the last insn before the call, so that we can
4267 later safely search backwards to find the CALL_INSN. */
4268 before_call
= get_last_insn ();
4270 /* Set up next argument register. For sibling calls on machines
4271 with register windows this should be the incoming register. */
4273 next_arg_reg
= targetm
.calls
.function_incoming_arg (args_so_far
,
4278 next_arg_reg
= targetm
.calls
.function_arg (args_so_far
,
4279 VOIDmode
, void_type_node
,
4282 if (pass
== 1 && (return_flags
& ERF_RETURNS_ARG
))
4284 int arg_nr
= return_flags
& ERF_RETURN_ARG_MASK
;
4285 arg_nr
= num_actuals
- arg_nr
- 1;
4287 && arg_nr
< num_actuals
4291 && GET_MODE (args
[arg_nr
].reg
) == GET_MODE (valreg
))
4293 = gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args
[arg_nr
].tree_value
)),
4294 gen_rtx_SET (valreg
, args
[arg_nr
].reg
),
4297 /* All arguments and registers used for the call must be set up by
4300 /* Stack must be properly aligned now. */
4302 || multiple_p (stack_pointer_delta
,
4303 preferred_unit_stack_boundary
));
4305 /* Generate the actual call instruction. */
4306 emit_call_1 (funexp
, exp
, fndecl
, funtype
, unadjusted_args_size
,
4307 adjusted_args_size
.constant
, struct_value_size
,
4308 next_arg_reg
, valreg
, old_inhibit_defer_pop
, call_fusage
,
4309 flags
, args_so_far
);
4313 rtx_call_insn
*last
;
4314 rtx datum
= NULL_RTX
;
4315 if (fndecl
!= NULL_TREE
)
4317 datum
= XEXP (DECL_RTL (fndecl
), 0);
4318 gcc_assert (datum
!= NULL_RTX
4319 && GET_CODE (datum
) == SYMBOL_REF
);
4321 last
= last_call_insn ();
4322 add_reg_note (last
, REG_CALL_DECL
, datum
);
4325 /* If the call setup or the call itself overlaps with anything
4326 of the argument setup we probably clobbered our call address.
4327 In that case we can't do sibcalls. */
4329 && check_sibcall_argument_overlap (after_args
, 0, 0))
4330 sibcall_failure
= 1;
4332 /* If a non-BLKmode value is returned at the most significant end
4333 of a register, shift the register right by the appropriate amount
4334 and update VALREG accordingly. BLKmode values are handled by the
4335 group load/store machinery below. */
4336 if (!structure_value_addr
4337 && !pcc_struct_value
4338 && TYPE_MODE (rettype
) != VOIDmode
4339 && TYPE_MODE (rettype
) != BLKmode
4341 && targetm
.calls
.return_in_msb (rettype
))
4343 if (shift_return_value (TYPE_MODE (rettype
), false, valreg
))
4344 sibcall_failure
= 1;
4345 valreg
= gen_rtx_REG (TYPE_MODE (rettype
), REGNO (valreg
));
4348 if (pass
&& (flags
& ECF_MALLOC
))
4350 rtx temp
= gen_reg_rtx (GET_MODE (valreg
));
4351 rtx_insn
*last
, *insns
;
4353 /* The return value from a malloc-like function is a pointer. */
4354 if (TREE_CODE (rettype
) == POINTER_TYPE
)
4355 mark_reg_pointer (temp
, MALLOC_ABI_ALIGNMENT
);
4357 emit_move_insn (temp
, valreg
);
4359 /* The return value from a malloc-like function can not alias
4361 last
= get_last_insn ();
4362 add_reg_note (last
, REG_NOALIAS
, temp
);
4364 /* Write out the sequence. */
4365 insns
= get_insns ();
4371 /* For calls to `setjmp', etc., inform
4372 function.c:setjmp_warnings that it should complain if
4373 nonvolatile values are live. For functions that cannot
4374 return, inform flow that control does not fall through. */
4376 if ((flags
& ECF_NORETURN
) || pass
== 0)
4378 /* The barrier must be emitted
4379 immediately after the CALL_INSN. Some ports emit more
4380 than just a CALL_INSN above, so we must search for it here. */
4382 rtx_insn
*last
= get_last_insn ();
4383 while (!CALL_P (last
))
4385 last
= PREV_INSN (last
);
4386 /* There was no CALL_INSN? */
4387 gcc_assert (last
!= before_call
);
4390 emit_barrier_after (last
);
4392 /* Stack adjustments after a noreturn call are dead code.
4393 However when NO_DEFER_POP is in effect, we must preserve
4394 stack_pointer_delta. */
4395 if (inhibit_defer_pop
== 0)
4397 stack_pointer_delta
= old_stack_allocated
;
4398 pending_stack_adjust
= 0;
4402 /* If value type not void, return an rtx for the value. */
4404 if (TYPE_MODE (rettype
) == VOIDmode
4406 target
= const0_rtx
;
4407 else if (structure_value_addr
)
4409 if (target
== 0 || !MEM_P (target
))
4412 = gen_rtx_MEM (TYPE_MODE (rettype
),
4413 memory_address (TYPE_MODE (rettype
),
4414 structure_value_addr
));
4415 set_mem_attributes (target
, rettype
, 1);
4418 else if (pcc_struct_value
)
4420 /* This is the special C++ case where we need to
4421 know what the true target was. We take care to
4422 never use this value more than once in one expression. */
4423 target
= gen_rtx_MEM (TYPE_MODE (rettype
),
4424 copy_to_reg (valreg
));
4425 set_mem_attributes (target
, rettype
, 1);
4427 /* Handle calls that return values in multiple non-contiguous locations.
4428 The Irix 6 ABI has examples of this. */
4429 else if (GET_CODE (valreg
) == PARALLEL
)
4432 target
= emit_group_move_into_temps (valreg
);
4433 else if (rtx_equal_p (target
, valreg
))
4435 else if (GET_CODE (target
) == PARALLEL
)
4436 /* Handle the result of a emit_group_move_into_temps
4437 call in the previous pass. */
4438 emit_group_move (target
, valreg
);
4440 emit_group_store (target
, valreg
, rettype
,
4441 int_size_in_bytes (rettype
));
4444 && GET_MODE (target
) == TYPE_MODE (rettype
)
4445 && GET_MODE (target
) == GET_MODE (valreg
))
4447 bool may_overlap
= false;
4449 /* We have to copy a return value in a CLASS_LIKELY_SPILLED hard
4450 reg to a plain register. */
4451 if (!REG_P (target
) || HARD_REGISTER_P (target
))
4452 valreg
= avoid_likely_spilled_reg (valreg
);
4454 /* If TARGET is a MEM in the argument area, and we have
4455 saved part of the argument area, then we can't store
4456 directly into TARGET as it may get overwritten when we
4457 restore the argument save area below. Don't work too
4458 hard though and simply force TARGET to a register if it
4459 is a MEM; the optimizer is quite likely to sort it out. */
4460 if (ACCUMULATE_OUTGOING_ARGS
&& pass
&& MEM_P (target
))
4461 for (i
= 0; i
< num_actuals
; i
++)
4462 if (args
[i
].save_area
)
4469 target
= copy_to_reg (valreg
);
4472 /* TARGET and VALREG cannot be equal at this point
4473 because the latter would not have
4474 REG_FUNCTION_VALUE_P true, while the former would if
4475 it were referring to the same register.
4477 If they refer to the same register, this move will be
4478 a no-op, except when function inlining is being
4480 emit_move_insn (target
, valreg
);
4482 /* If we are setting a MEM, this code must be executed.
4483 Since it is emitted after the call insn, sibcall
4484 optimization cannot be performed in that case. */
4486 sibcall_failure
= 1;
4490 target
= copy_to_reg (avoid_likely_spilled_reg (valreg
));
4492 /* If we promoted this return value, make the proper SUBREG.
4493 TARGET might be const0_rtx here, so be careful. */
4495 && TYPE_MODE (rettype
) != BLKmode
4496 && GET_MODE (target
) != TYPE_MODE (rettype
))
4498 tree type
= rettype
;
4499 int unsignedp
= TYPE_UNSIGNED (type
);
4502 /* Ensure we promote as expected, and get the new unsignedness. */
4503 pmode
= promote_function_mode (type
, TYPE_MODE (type
), &unsignedp
,
4505 gcc_assert (GET_MODE (target
) == pmode
);
4507 poly_uint64 offset
= subreg_lowpart_offset (TYPE_MODE (type
),
4509 target
= gen_rtx_SUBREG (TYPE_MODE (type
), target
, offset
);
4510 SUBREG_PROMOTED_VAR_P (target
) = 1;
4511 SUBREG_PROMOTED_SET (target
, unsignedp
);
4514 /* If size of args is variable or this was a constructor call for a stack
4515 argument, restore saved stack-pointer value. */
4517 if (old_stack_level
)
4519 rtx_insn
*prev
= get_last_insn ();
4521 emit_stack_restore (SAVE_BLOCK
, old_stack_level
);
4522 stack_pointer_delta
= old_stack_pointer_delta
;
4524 fixup_args_size_notes (prev
, get_last_insn (), stack_pointer_delta
);
4526 pending_stack_adjust
= old_pending_adj
;
4527 old_stack_allocated
= stack_pointer_delta
- pending_stack_adjust
;
4528 stack_arg_under_construction
= old_stack_arg_under_construction
;
4529 highest_outgoing_arg_in_use
= initial_highest_arg_in_use
;
4530 stack_usage_map
= initial_stack_usage_map
;
4531 stack_usage_watermark
= initial_stack_usage_watermark
;
4532 sibcall_failure
= 1;
4534 else if (ACCUMULATE_OUTGOING_ARGS
&& pass
)
4536 #ifdef REG_PARM_STACK_SPACE
4538 restore_fixed_argument_area (save_area
, argblock
,
4539 high_to_save
, low_to_save
);
4542 /* If we saved any argument areas, restore them. */
4543 for (i
= 0; i
< num_actuals
; i
++)
4544 if (args
[i
].save_area
)
4546 machine_mode save_mode
= GET_MODE (args
[i
].save_area
);
4548 = gen_rtx_MEM (save_mode
,
4549 memory_address (save_mode
,
4550 XEXP (args
[i
].stack_slot
, 0)));
4552 if (save_mode
!= BLKmode
)
4553 emit_move_insn (stack_area
, args
[i
].save_area
);
4555 emit_block_move (stack_area
, args
[i
].save_area
,
4557 (args
[i
].locate
.size
.constant
, Pmode
)),
4558 BLOCK_OP_CALL_PARM
);
4561 highest_outgoing_arg_in_use
= initial_highest_arg_in_use
;
4562 stack_usage_map
= initial_stack_usage_map
;
4563 stack_usage_watermark
= initial_stack_usage_watermark
;
4566 /* If this was alloca, record the new stack level. */
4567 if (flags
& ECF_MAY_BE_ALLOCA
)
4568 record_new_stack_level ();
4570 /* Free up storage we no longer need. */
4571 for (i
= 0; i
< num_actuals
; ++i
)
4572 free (args
[i
].aligned_regs
);
4574 targetm
.calls
.end_call_args ();
4576 insns
= get_insns ();
4581 tail_call_insns
= insns
;
4583 /* Restore the pending stack adjustment now that we have
4584 finished generating the sibling call sequence. */
4586 restore_pending_stack_adjust (&save
);
4588 /* Prepare arg structure for next iteration. */
4589 for (i
= 0; i
< num_actuals
; i
++)
4592 args
[i
].aligned_regs
= 0;
4596 sbitmap_free (stored_args_map
);
4597 internal_arg_pointer_exp_state
.scan_start
= NULL
;
4598 internal_arg_pointer_exp_state
.cache
.release ();
4602 normal_call_insns
= insns
;
4604 /* Verify that we've deallocated all the stack we used. */
4605 gcc_assert ((flags
& ECF_NORETURN
)
4606 || known_eq (old_stack_allocated
,
4608 - pending_stack_adjust
));
4611 /* If something prevents making this a sibling call,
4612 zero out the sequence. */
4613 if (sibcall_failure
)
4614 tail_call_insns
= NULL
;
4619 /* If tail call production succeeded, we need to remove REG_EQUIV notes on
4620 arguments too, as argument area is now clobbered by the call. */
4621 if (tail_call_insns
)
4623 emit_insn (tail_call_insns
);
4624 crtl
->tail_call_emit
= true;
4628 emit_insn (normal_call_insns
);
4630 /* Ideally we'd emit a message for all of the ways that it could
4632 maybe_complain_about_tail_call (exp
, "tail call production failed");
4635 currently_expanding_call
--;
4637 free (stack_usage_map_buf
);
4640 /* Join result with returned bounds so caller may use them if needed. */
4641 target
= chkp_join_splitted_slot (target
, valbnd
);
4646 /* A sibling call sequence invalidates any REG_EQUIV notes made for
4647 this function's incoming arguments.
4649 At the start of RTL generation we know the only REG_EQUIV notes
4650 in the rtl chain are those for incoming arguments, so we can look
4651 for REG_EQUIV notes between the start of the function and the
4652 NOTE_INSN_FUNCTION_BEG.
4654 This is (slight) overkill. We could keep track of the highest
4655 argument we clobber and be more selective in removing notes, but it
4656 does not seem to be worth the effort. */
4659 fixup_tail_calls (void)
4663 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
4667 /* There are never REG_EQUIV notes for the incoming arguments
4668 after the NOTE_INSN_FUNCTION_BEG note, so stop if we see it. */
4670 && NOTE_KIND (insn
) == NOTE_INSN_FUNCTION_BEG
)
4673 note
= find_reg_note (insn
, REG_EQUIV
, 0);
4675 remove_note (insn
, note
);
4676 note
= find_reg_note (insn
, REG_EQUIV
, 0);
4681 /* Traverse a list of TYPES and expand all complex types into their
4684 split_complex_types (tree types
)
4688 /* Before allocating memory, check for the common case of no complex. */
4689 for (p
= types
; p
; p
= TREE_CHAIN (p
))
4691 tree type
= TREE_VALUE (p
);
4692 if (TREE_CODE (type
) == COMPLEX_TYPE
4693 && targetm
.calls
.split_complex_arg (type
))
4699 types
= copy_list (types
);
4701 for (p
= types
; p
; p
= TREE_CHAIN (p
))
4703 tree complex_type
= TREE_VALUE (p
);
4705 if (TREE_CODE (complex_type
) == COMPLEX_TYPE
4706 && targetm
.calls
.split_complex_arg (complex_type
))
4710 /* Rewrite complex type with component type. */
4711 TREE_VALUE (p
) = TREE_TYPE (complex_type
);
4712 next
= TREE_CHAIN (p
);
4714 /* Add another component type for the imaginary part. */
4715 imag
= build_tree_list (NULL_TREE
, TREE_VALUE (p
));
4716 TREE_CHAIN (p
) = imag
;
4717 TREE_CHAIN (imag
) = next
;
4719 /* Skip the newly created node. */
4727 /* Output a library call to function ORGFUN (a SYMBOL_REF rtx)
4728 for a value of mode OUTMODE,
4729 with NARGS different arguments, passed as ARGS.
4730 Store the return value if RETVAL is nonzero: store it in VALUE if
4731 VALUE is nonnull, otherwise pick a convenient location. In either
4732 case return the location of the stored value.
4734 FN_TYPE should be LCT_NORMAL for `normal' calls, LCT_CONST for
4735 `const' calls, LCT_PURE for `pure' calls, or another LCT_ value for
4736 other types of library calls. */
4739 emit_library_call_value_1 (int retval
, rtx orgfun
, rtx value
,
4740 enum libcall_type fn_type
,
4741 machine_mode outmode
, int nargs
, rtx_mode_t
*args
)
4743 /* Total size in bytes of all the stack-parms scanned so far. */
4744 struct args_size args_size
;
4745 /* Size of arguments before any adjustments (such as rounding). */
4746 struct args_size original_args_size
;
4749 /* Todo, choose the correct decl type of orgfun. Sadly this information
4750 isn't present here, so we default to native calling abi here. */
4751 tree fndecl ATTRIBUTE_UNUSED
= NULL_TREE
; /* library calls default to host calling abi ? */
4752 tree fntype ATTRIBUTE_UNUSED
= NULL_TREE
; /* library calls default to host calling abi ? */
4755 CUMULATIVE_ARGS args_so_far_v
;
4756 cumulative_args_t args_so_far
;
4763 struct locate_and_pad_arg_data locate
;
4767 int old_inhibit_defer_pop
= inhibit_defer_pop
;
4768 rtx call_fusage
= 0;
4771 int pcc_struct_value
= 0;
4772 poly_int64 struct_value_size
= 0;
4774 int reg_parm_stack_space
= 0;
4776 rtx_insn
*before_call
;
4777 bool have_push_fusage
;
4778 tree tfom
; /* type_for_mode (outmode, 0) */
4780 #ifdef REG_PARM_STACK_SPACE
4781 /* Define the boundary of the register parm stack space that needs to be
4783 int low_to_save
= 0, high_to_save
= 0;
4784 rtx save_area
= 0; /* Place that it is saved. */
4787 /* Size of the stack reserved for parameter registers. */
4788 unsigned int initial_highest_arg_in_use
= highest_outgoing_arg_in_use
;
4789 char *initial_stack_usage_map
= stack_usage_map
;
4790 unsigned HOST_WIDE_INT initial_stack_usage_watermark
= stack_usage_watermark
;
4791 char *stack_usage_map_buf
= NULL
;
4793 rtx struct_value
= targetm
.calls
.struct_value_rtx (0, 0);
4795 #ifdef REG_PARM_STACK_SPACE
4796 reg_parm_stack_space
= REG_PARM_STACK_SPACE ((tree
) 0);
4799 /* By default, library functions cannot throw. */
4800 flags
= ECF_NOTHROW
;
4813 flags
|= ECF_NORETURN
;
4816 flags
&= ~ECF_NOTHROW
;
4818 case LCT_RETURNS_TWICE
:
4819 flags
= ECF_RETURNS_TWICE
;
4824 /* Ensure current function's preferred stack boundary is at least
4826 if (crtl
->preferred_stack_boundary
< PREFERRED_STACK_BOUNDARY
)
4827 crtl
->preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
4829 /* If this kind of value comes back in memory,
4830 decide where in memory it should come back. */
4831 if (outmode
!= VOIDmode
)
4833 tfom
= lang_hooks
.types
.type_for_mode (outmode
, 0);
4834 if (aggregate_value_p (tfom
, 0))
4836 #ifdef PCC_STATIC_STRUCT_RETURN
4838 = hard_function_value (build_pointer_type (tfom
), 0, 0, 0);
4839 mem_value
= gen_rtx_MEM (outmode
, pointer_reg
);
4840 pcc_struct_value
= 1;
4842 value
= gen_reg_rtx (outmode
);
4843 #else /* not PCC_STATIC_STRUCT_RETURN */
4844 struct_value_size
= GET_MODE_SIZE (outmode
);
4845 if (value
!= 0 && MEM_P (value
))
4848 mem_value
= assign_temp (tfom
, 1, 1);
4850 /* This call returns a big structure. */
4851 flags
&= ~(ECF_CONST
| ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
);
4855 tfom
= void_type_node
;
4857 /* ??? Unfinished: must pass the memory address as an argument. */
4859 /* Copy all the libcall-arguments out of the varargs data
4860 and into a vector ARGVEC.
4862 Compute how to pass each argument. We only support a very small subset
4863 of the full argument passing conventions to limit complexity here since
4864 library functions shouldn't have many args. */
4866 argvec
= XALLOCAVEC (struct arg
, nargs
+ 1);
4867 memset (argvec
, 0, (nargs
+ 1) * sizeof (struct arg
));
4869 #ifdef INIT_CUMULATIVE_LIBCALL_ARGS
4870 INIT_CUMULATIVE_LIBCALL_ARGS (args_so_far_v
, outmode
, fun
);
4872 INIT_CUMULATIVE_ARGS (args_so_far_v
, NULL_TREE
, fun
, 0, nargs
);
4874 args_so_far
= pack_cumulative_args (&args_so_far_v
);
4876 args_size
.constant
= 0;
4883 /* If there's a structure value address to be passed,
4884 either pass it in the special place, or pass it as an extra argument. */
4885 if (mem_value
&& struct_value
== 0 && ! pcc_struct_value
)
4887 rtx addr
= XEXP (mem_value
, 0);
4891 /* Make sure it is a reasonable operand for a move or push insn. */
4892 if (!REG_P (addr
) && !MEM_P (addr
)
4893 && !(CONSTANT_P (addr
)
4894 && targetm
.legitimate_constant_p (Pmode
, addr
)))
4895 addr
= force_operand (addr
, NULL_RTX
);
4897 argvec
[count
].value
= addr
;
4898 argvec
[count
].mode
= Pmode
;
4899 argvec
[count
].partial
= 0;
4901 argvec
[count
].reg
= targetm
.calls
.function_arg (args_so_far
,
4902 Pmode
, NULL_TREE
, true);
4903 gcc_assert (targetm
.calls
.arg_partial_bytes (args_so_far
, Pmode
,
4904 NULL_TREE
, 1) == 0);
4906 locate_and_pad_parm (Pmode
, NULL_TREE
,
4907 #ifdef STACK_PARMS_IN_REG_PARM_AREA
4910 argvec
[count
].reg
!= 0,
4912 reg_parm_stack_space
, 0,
4913 NULL_TREE
, &args_size
, &argvec
[count
].locate
);
4915 if (argvec
[count
].reg
== 0 || argvec
[count
].partial
!= 0
4916 || reg_parm_stack_space
> 0)
4917 args_size
.constant
+= argvec
[count
].locate
.size
.constant
;
4919 targetm
.calls
.function_arg_advance (args_so_far
, Pmode
, (tree
) 0, true);
4924 for (unsigned int i
= 0; count
< nargs
; i
++, count
++)
4926 rtx val
= args
[i
].first
;
4927 machine_mode mode
= args
[i
].second
;
4930 /* We cannot convert the arg value to the mode the library wants here;
4931 must do it earlier where we know the signedness of the arg. */
4932 gcc_assert (mode
!= BLKmode
4933 && (GET_MODE (val
) == mode
|| GET_MODE (val
) == VOIDmode
));
4935 /* Make sure it is a reasonable operand for a move or push insn. */
4936 if (!REG_P (val
) && !MEM_P (val
)
4937 && !(CONSTANT_P (val
) && targetm
.legitimate_constant_p (mode
, val
)))
4938 val
= force_operand (val
, NULL_RTX
);
4940 if (pass_by_reference (&args_so_far_v
, mode
, NULL_TREE
, 1))
4944 = !reference_callee_copied (&args_so_far_v
, mode
, NULL_TREE
, 1);
4946 /* If this was a CONST function, it is now PURE since it now
4948 if (flags
& ECF_CONST
)
4950 flags
&= ~ECF_CONST
;
4954 if (MEM_P (val
) && !must_copy
)
4956 tree val_expr
= MEM_EXPR (val
);
4958 mark_addressable (val_expr
);
4963 slot
= assign_temp (lang_hooks
.types
.type_for_mode (mode
, 0),
4965 emit_move_insn (slot
, val
);
4968 call_fusage
= gen_rtx_EXPR_LIST (VOIDmode
,
4969 gen_rtx_USE (VOIDmode
, slot
),
4972 call_fusage
= gen_rtx_EXPR_LIST (VOIDmode
,
4973 gen_rtx_CLOBBER (VOIDmode
,
4978 val
= force_operand (XEXP (slot
, 0), NULL_RTX
);
4981 mode
= promote_function_mode (NULL_TREE
, mode
, &unsigned_p
, NULL_TREE
, 0);
4982 argvec
[count
].mode
= mode
;
4983 argvec
[count
].value
= convert_modes (mode
, GET_MODE (val
), val
, unsigned_p
);
4984 argvec
[count
].reg
= targetm
.calls
.function_arg (args_so_far
, mode
,
4987 argvec
[count
].partial
4988 = targetm
.calls
.arg_partial_bytes (args_so_far
, mode
, NULL_TREE
, 1);
4990 if (argvec
[count
].reg
== 0
4991 || argvec
[count
].partial
!= 0
4992 || reg_parm_stack_space
> 0)
4994 locate_and_pad_parm (mode
, NULL_TREE
,
4995 #ifdef STACK_PARMS_IN_REG_PARM_AREA
4998 argvec
[count
].reg
!= 0,
5000 reg_parm_stack_space
, argvec
[count
].partial
,
5001 NULL_TREE
, &args_size
, &argvec
[count
].locate
);
5002 args_size
.constant
+= argvec
[count
].locate
.size
.constant
;
5003 gcc_assert (!argvec
[count
].locate
.size
.var
);
5005 #ifdef BLOCK_REG_PADDING
5007 /* The argument is passed entirely in registers. See at which
5008 end it should be padded. */
5009 argvec
[count
].locate
.where_pad
=
5010 BLOCK_REG_PADDING (mode
, NULL_TREE
,
5011 known_le (GET_MODE_SIZE (mode
), UNITS_PER_WORD
));
5014 targetm
.calls
.function_arg_advance (args_so_far
, mode
, (tree
) 0, true);
5017 /* If this machine requires an external definition for library
5018 functions, write one out. */
5019 assemble_external_libcall (fun
);
5021 original_args_size
= args_size
;
5022 args_size
.constant
= (aligned_upper_bound (args_size
.constant
5023 + stack_pointer_delta
,
5025 - stack_pointer_delta
);
5027 args_size
.constant
= upper_bound (args_size
.constant
,
5028 reg_parm_stack_space
);
5030 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
5031 args_size
.constant
-= reg_parm_stack_space
;
5033 crtl
->outgoing_args_size
= upper_bound (crtl
->outgoing_args_size
,
5034 args_size
.constant
);
5036 if (flag_stack_usage_info
&& !ACCUMULATE_OUTGOING_ARGS
)
5038 poly_int64 pushed
= args_size
.constant
+ pending_stack_adjust
;
5039 current_function_pushed_stack_size
5040 = upper_bound (current_function_pushed_stack_size
, pushed
);
5043 if (ACCUMULATE_OUTGOING_ARGS
)
5045 /* Since the stack pointer will never be pushed, it is possible for
5046 the evaluation of a parm to clobber something we have already
5047 written to the stack. Since most function calls on RISC machines
5048 do not use the stack, this is uncommon, but must work correctly.
5050 Therefore, we save any area of the stack that was already written
5051 and that we are using. Here we set up to do this by making a new
5052 stack usage map from the old one.
5054 Another approach might be to try to reorder the argument
5055 evaluations to avoid this conflicting stack usage. */
5057 needed
= args_size
.constant
;
5059 /* Since we will be writing into the entire argument area, the
5060 map must be allocated for its entire size, not just the part that
5061 is the responsibility of the caller. */
5062 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
5063 needed
+= reg_parm_stack_space
;
5065 poly_int64 limit
= needed
;
5066 if (ARGS_GROW_DOWNWARD
)
5069 /* For polynomial sizes, this is the maximum possible size needed
5070 for arguments with a constant size and offset. */
5071 HOST_WIDE_INT const_limit
= constant_lower_bound (limit
);
5072 highest_outgoing_arg_in_use
= MAX (initial_highest_arg_in_use
,
5075 stack_usage_map_buf
= XNEWVEC (char, highest_outgoing_arg_in_use
);
5076 stack_usage_map
= stack_usage_map_buf
;
5078 if (initial_highest_arg_in_use
)
5079 memcpy (stack_usage_map
, initial_stack_usage_map
,
5080 initial_highest_arg_in_use
);
5082 if (initial_highest_arg_in_use
!= highest_outgoing_arg_in_use
)
5083 memset (&stack_usage_map
[initial_highest_arg_in_use
], 0,
5084 highest_outgoing_arg_in_use
- initial_highest_arg_in_use
);
5087 /* We must be careful to use virtual regs before they're instantiated,
5088 and real regs afterwards. Loop optimization, for example, can create
5089 new libcalls after we've instantiated the virtual regs, and if we
5090 use virtuals anyway, they won't match the rtl patterns. */
5092 if (virtuals_instantiated
)
5093 argblock
= plus_constant (Pmode
, stack_pointer_rtx
,
5094 STACK_POINTER_OFFSET
);
5096 argblock
= virtual_outgoing_args_rtx
;
5101 argblock
= push_block (gen_int_mode (args_size
.constant
, Pmode
), 0, 0);
5104 /* We push args individually in reverse order, perform stack alignment
5105 before the first push (the last arg). */
5107 anti_adjust_stack (gen_int_mode (args_size
.constant
5108 - original_args_size
.constant
,
5113 #ifdef REG_PARM_STACK_SPACE
5114 if (ACCUMULATE_OUTGOING_ARGS
)
5116 /* The argument list is the property of the called routine and it
5117 may clobber it. If the fixed area has been used for previous
5118 parameters, we must save and restore it. */
5119 save_area
= save_fixed_argument_area (reg_parm_stack_space
, argblock
,
5120 &low_to_save
, &high_to_save
);
5124 /* When expanding a normal call, args are stored in push order,
5125 which is the reverse of what we have here. */
5126 bool any_regs
= false;
5127 for (int i
= nargs
; i
-- > 0; )
5128 if (argvec
[i
].reg
!= NULL_RTX
)
5130 targetm
.calls
.call_args (argvec
[i
].reg
, NULL_TREE
);
5134 targetm
.calls
.call_args (pc_rtx
, NULL_TREE
);
5136 /* Push the args that need to be pushed. */
5138 have_push_fusage
= false;
5140 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
5141 are to be pushed. */
5142 for (count
= 0; count
< nargs
; count
++, argnum
--)
5144 machine_mode mode
= argvec
[argnum
].mode
;
5145 rtx val
= argvec
[argnum
].value
;
5146 rtx reg
= argvec
[argnum
].reg
;
5147 int partial
= argvec
[argnum
].partial
;
5148 unsigned int parm_align
= argvec
[argnum
].locate
.boundary
;
5149 poly_int64 lower_bound
= 0, upper_bound
= 0;
5151 if (! (reg
!= 0 && partial
== 0))
5155 if (ACCUMULATE_OUTGOING_ARGS
)
5157 /* If this is being stored into a pre-allocated, fixed-size,
5158 stack area, save any previous data at that location. */
5160 if (ARGS_GROW_DOWNWARD
)
5162 /* stack_slot is negative, but we want to index stack_usage_map
5163 with positive values. */
5164 upper_bound
= -argvec
[argnum
].locate
.slot_offset
.constant
+ 1;
5165 lower_bound
= upper_bound
- argvec
[argnum
].locate
.size
.constant
;
5169 lower_bound
= argvec
[argnum
].locate
.slot_offset
.constant
;
5170 upper_bound
= lower_bound
+ argvec
[argnum
].locate
.size
.constant
;
5173 if (stack_region_maybe_used_p (lower_bound
, upper_bound
,
5174 reg_parm_stack_space
))
5176 /* We need to make a save area. */
5178 = argvec
[argnum
].locate
.size
.constant
* BITS_PER_UNIT
;
5179 machine_mode save_mode
5180 = int_mode_for_size (size
, 1).else_blk ();
5182 = plus_constant (Pmode
, argblock
,
5183 argvec
[argnum
].locate
.offset
.constant
);
5185 = gen_rtx_MEM (save_mode
, memory_address (save_mode
, adr
));
5187 if (save_mode
== BLKmode
)
5189 argvec
[argnum
].save_area
5190 = assign_stack_temp (BLKmode
,
5191 argvec
[argnum
].locate
.size
.constant
5194 emit_block_move (validize_mem
5195 (copy_rtx (argvec
[argnum
].save_area
)),
5198 (argvec
[argnum
].locate
.size
.constant
,
5200 BLOCK_OP_CALL_PARM
);
5204 argvec
[argnum
].save_area
= gen_reg_rtx (save_mode
);
5206 emit_move_insn (argvec
[argnum
].save_area
, stack_area
);
5211 emit_push_insn (val
, mode
, NULL_TREE
, NULL_RTX
, parm_align
,
5212 partial
, reg
, 0, argblock
,
5214 (argvec
[argnum
].locate
.offset
.constant
, Pmode
)),
5215 reg_parm_stack_space
,
5216 ARGS_SIZE_RTX (argvec
[argnum
].locate
.alignment_pad
), false);
5218 /* Now mark the segment we just used. */
5219 if (ACCUMULATE_OUTGOING_ARGS
)
5220 mark_stack_region_used (lower_bound
, upper_bound
);
5224 /* Indicate argument access so that alias.c knows that these
5227 use
= plus_constant (Pmode
, argblock
,
5228 argvec
[argnum
].locate
.offset
.constant
);
5229 else if (have_push_fusage
)
5233 /* When arguments are pushed, trying to tell alias.c where
5234 exactly this argument is won't work, because the
5235 auto-increment causes confusion. So we merely indicate
5236 that we access something with a known mode somewhere on
5238 use
= gen_rtx_PLUS (Pmode
, stack_pointer_rtx
,
5239 gen_rtx_SCRATCH (Pmode
));
5240 have_push_fusage
= true;
5242 use
= gen_rtx_MEM (argvec
[argnum
].mode
, use
);
5243 use
= gen_rtx_USE (VOIDmode
, use
);
5244 call_fusage
= gen_rtx_EXPR_LIST (VOIDmode
, use
, call_fusage
);
5250 fun
= prepare_call_address (NULL
, fun
, NULL
, &call_fusage
, 0, 0);
5252 /* Now load any reg parms into their regs. */
5254 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
5255 are to be pushed. */
5256 for (count
= 0; count
< nargs
; count
++, argnum
--)
5258 machine_mode mode
= argvec
[argnum
].mode
;
5259 rtx val
= argvec
[argnum
].value
;
5260 rtx reg
= argvec
[argnum
].reg
;
5261 int partial
= argvec
[argnum
].partial
;
5263 /* Handle calls that pass values in multiple non-contiguous
5264 locations. The PA64 has examples of this for library calls. */
5265 if (reg
!= 0 && GET_CODE (reg
) == PARALLEL
)
5266 emit_group_load (reg
, val
, NULL_TREE
, GET_MODE_SIZE (mode
));
5267 else if (reg
!= 0 && partial
== 0)
5269 emit_move_insn (reg
, val
);
5270 #ifdef BLOCK_REG_PADDING
5271 poly_int64 size
= GET_MODE_SIZE (argvec
[argnum
].mode
);
5273 /* Copied from load_register_parameters. */
5275 /* Handle case where we have a value that needs shifting
5276 up to the msb. eg. a QImode value and we're padding
5277 upward on a BYTES_BIG_ENDIAN machine. */
5278 if (known_lt (size
, UNITS_PER_WORD
)
5279 && (argvec
[argnum
].locate
.where_pad
5280 == (BYTES_BIG_ENDIAN
? PAD_UPWARD
: PAD_DOWNWARD
)))
5283 poly_int64 shift
= (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
5285 /* Assigning REG here rather than a temp makes CALL_FUSAGE
5286 report the whole reg as used. Strictly speaking, the
5287 call only uses SIZE bytes at the msb end, but it doesn't
5288 seem worth generating rtl to say that. */
5289 reg
= gen_rtx_REG (word_mode
, REGNO (reg
));
5290 x
= expand_shift (LSHIFT_EXPR
, word_mode
, reg
, shift
, reg
, 1);
5292 emit_move_insn (reg
, x
);
5300 /* Any regs containing parms remain in use through the call. */
5301 for (count
= 0; count
< nargs
; count
++)
5303 rtx reg
= argvec
[count
].reg
;
5304 if (reg
!= 0 && GET_CODE (reg
) == PARALLEL
)
5305 use_group_regs (&call_fusage
, reg
);
5308 int partial
= argvec
[count
].partial
;
5312 gcc_assert (partial
% UNITS_PER_WORD
== 0);
5313 nregs
= partial
/ UNITS_PER_WORD
;
5314 use_regs (&call_fusage
, REGNO (reg
), nregs
);
5317 use_reg (&call_fusage
, reg
);
5321 /* Pass the function the address in which to return a structure value. */
5322 if (mem_value
!= 0 && struct_value
!= 0 && ! pcc_struct_value
)
5324 emit_move_insn (struct_value
,
5326 force_operand (XEXP (mem_value
, 0),
5328 if (REG_P (struct_value
))
5329 use_reg (&call_fusage
, struct_value
);
5332 /* Don't allow popping to be deferred, since then
5333 cse'ing of library calls could delete a call and leave the pop. */
5335 valreg
= (mem_value
== 0 && outmode
!= VOIDmode
5336 ? hard_libcall_value (outmode
, orgfun
) : NULL_RTX
);
5338 /* Stack must be properly aligned now. */
5339 gcc_assert (multiple_p (stack_pointer_delta
,
5340 PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
));
5342 before_call
= get_last_insn ();
5344 /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
5345 will set inhibit_defer_pop to that value. */
5346 /* The return type is needed to decide how many bytes the function pops.
5347 Signedness plays no role in that, so for simplicity, we pretend it's
5348 always signed. We also assume that the list of arguments passed has
5349 no impact, so we pretend it is unknown. */
5351 emit_call_1 (fun
, NULL
,
5352 get_identifier (XSTR (orgfun
, 0)),
5353 build_function_type (tfom
, NULL_TREE
),
5354 original_args_size
.constant
, args_size
.constant
,
5356 targetm
.calls
.function_arg (args_so_far
,
5357 VOIDmode
, void_type_node
, true),
5359 old_inhibit_defer_pop
+ 1, call_fusage
, flags
, args_so_far
);
5364 gcc_assert (GET_CODE (datum
) == SYMBOL_REF
);
5365 rtx_call_insn
*last
= last_call_insn ();
5366 add_reg_note (last
, REG_CALL_DECL
, datum
);
5369 /* Right-shift returned value if necessary. */
5370 if (!pcc_struct_value
5371 && TYPE_MODE (tfom
) != BLKmode
5372 && targetm
.calls
.return_in_msb (tfom
))
5374 shift_return_value (TYPE_MODE (tfom
), false, valreg
);
5375 valreg
= gen_rtx_REG (TYPE_MODE (tfom
), REGNO (valreg
));
5378 targetm
.calls
.end_call_args ();
5380 /* For calls to `setjmp', etc., inform function.c:setjmp_warnings
5381 that it should complain if nonvolatile values are live. For
5382 functions that cannot return, inform flow that control does not
5384 if (flags
& ECF_NORETURN
)
5386 /* The barrier note must be emitted
5387 immediately after the CALL_INSN. Some ports emit more than
5388 just a CALL_INSN above, so we must search for it here. */
5389 rtx_insn
*last
= get_last_insn ();
5390 while (!CALL_P (last
))
5392 last
= PREV_INSN (last
);
5393 /* There was no CALL_INSN? */
5394 gcc_assert (last
!= before_call
);
5397 emit_barrier_after (last
);
5400 /* Consider that "regular" libcalls, i.e. all of them except for LCT_THROW
5401 and LCT_RETURNS_TWICE, cannot perform non-local gotos. */
5402 if (flags
& ECF_NOTHROW
)
5404 rtx_insn
*last
= get_last_insn ();
5405 while (!CALL_P (last
))
5407 last
= PREV_INSN (last
);
5408 /* There was no CALL_INSN? */
5409 gcc_assert (last
!= before_call
);
5412 make_reg_eh_region_note_nothrow_nononlocal (last
);
5415 /* Now restore inhibit_defer_pop to its actual original value. */
5420 /* Copy the value to the right place. */
5421 if (outmode
!= VOIDmode
&& retval
)
5427 if (value
!= mem_value
)
5428 emit_move_insn (value
, mem_value
);
5430 else if (GET_CODE (valreg
) == PARALLEL
)
5433 value
= gen_reg_rtx (outmode
);
5434 emit_group_store (value
, valreg
, NULL_TREE
, GET_MODE_SIZE (outmode
));
5438 /* Convert to the proper mode if a promotion has been active. */
5439 if (GET_MODE (valreg
) != outmode
)
5441 int unsignedp
= TYPE_UNSIGNED (tfom
);
5443 gcc_assert (promote_function_mode (tfom
, outmode
, &unsignedp
,
5444 fndecl
? TREE_TYPE (fndecl
) : fntype
, 1)
5445 == GET_MODE (valreg
));
5446 valreg
= convert_modes (outmode
, GET_MODE (valreg
), valreg
, 0);
5450 emit_move_insn (value
, valreg
);
5456 if (ACCUMULATE_OUTGOING_ARGS
)
5458 #ifdef REG_PARM_STACK_SPACE
5460 restore_fixed_argument_area (save_area
, argblock
,
5461 high_to_save
, low_to_save
);
5464 /* If we saved any argument areas, restore them. */
5465 for (count
= 0; count
< nargs
; count
++)
5466 if (argvec
[count
].save_area
)
5468 machine_mode save_mode
= GET_MODE (argvec
[count
].save_area
);
5469 rtx adr
= plus_constant (Pmode
, argblock
,
5470 argvec
[count
].locate
.offset
.constant
);
5471 rtx stack_area
= gen_rtx_MEM (save_mode
,
5472 memory_address (save_mode
, adr
));
5474 if (save_mode
== BLKmode
)
5475 emit_block_move (stack_area
,
5477 (copy_rtx (argvec
[count
].save_area
)),
5479 (argvec
[count
].locate
.size
.constant
, Pmode
)),
5480 BLOCK_OP_CALL_PARM
);
5482 emit_move_insn (stack_area
, argvec
[count
].save_area
);
5485 highest_outgoing_arg_in_use
= initial_highest_arg_in_use
;
5486 stack_usage_map
= initial_stack_usage_map
;
5487 stack_usage_watermark
= initial_stack_usage_watermark
;
5490 free (stack_usage_map_buf
);
5497 /* Store pointer bounds argument ARG into Bounds Table entry
5498 associated with PARM. */
5500 store_bounds (struct arg_data
*arg
, struct arg_data
*parm
)
5502 rtx slot
= NULL
, ptr
= NULL
, addr
= NULL
;
5504 /* We may pass bounds not associated with any pointer. */
5507 gcc_assert (arg
->special_slot
);
5508 slot
= arg
->special_slot
;
5511 /* Find pointer associated with bounds and where it is
5517 gcc_assert (!arg
->special_slot
);
5519 addr
= adjust_address (parm
->stack
, Pmode
, arg
->pointer_offset
);
5521 else if (REG_P (parm
->reg
))
5523 gcc_assert (arg
->special_slot
);
5524 slot
= arg
->special_slot
;
5526 if (MEM_P (parm
->value
))
5527 addr
= adjust_address (parm
->value
, Pmode
, arg
->pointer_offset
);
5528 else if (REG_P (parm
->value
))
5529 ptr
= gen_rtx_SUBREG (Pmode
, parm
->value
, arg
->pointer_offset
);
5532 gcc_assert (!arg
->pointer_offset
);
5538 gcc_assert (GET_CODE (parm
->reg
) == PARALLEL
);
5540 gcc_assert (arg
->special_slot
);
5541 slot
= arg
->special_slot
;
5543 if (parm
->parallel_value
)
5544 ptr
= chkp_get_value_with_offs (parm
->parallel_value
,
5545 GEN_INT (arg
->pointer_offset
));
5551 /* Expand bounds. */
5553 arg
->value
= expand_normal (arg
->tree_value
);
5555 targetm
.calls
.store_bounds_for_arg (ptr
, addr
, arg
->value
, slot
);
5558 /* Store a single argument for a function call
5559 into the register or memory area where it must be passed.
5560 *ARG describes the argument value and where to pass it.
5562 ARGBLOCK is the address of the stack-block for all the arguments,
5563 or 0 on a machine where arguments are pushed individually.
5565 MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
5566 so must be careful about how the stack is used.
5568 VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
5569 argument stack. This is used if ACCUMULATE_OUTGOING_ARGS to indicate
5570 that we need not worry about saving and restoring the stack.
5572 FNDECL is the declaration of the function we are calling.
5574 Return nonzero if this arg should cause sibcall failure,
5578 store_one_arg (struct arg_data
*arg
, rtx argblock
, int flags
,
5579 int variable_size ATTRIBUTE_UNUSED
, int reg_parm_stack_space
)
5581 tree pval
= arg
->tree_value
;
5584 poly_int64 used
= 0;
5585 poly_int64 lower_bound
= 0, upper_bound
= 0;
5586 int sibcall_failure
= 0;
5588 if (TREE_CODE (pval
) == ERROR_MARK
)
5591 /* Push a new temporary level for any temporaries we make for
5595 if (ACCUMULATE_OUTGOING_ARGS
&& !(flags
& ECF_SIBCALL
))
5597 /* If this is being stored into a pre-allocated, fixed-size, stack area,
5598 save any previous data at that location. */
5599 if (argblock
&& ! variable_size
&& arg
->stack
)
5601 if (ARGS_GROW_DOWNWARD
)
5603 /* stack_slot is negative, but we want to index stack_usage_map
5604 with positive values. */
5605 if (GET_CODE (XEXP (arg
->stack_slot
, 0)) == PLUS
)
5607 rtx offset
= XEXP (XEXP (arg
->stack_slot
, 0), 1);
5608 upper_bound
= -rtx_to_poly_int64 (offset
) + 1;
5613 lower_bound
= upper_bound
- arg
->locate
.size
.constant
;
5617 if (GET_CODE (XEXP (arg
->stack_slot
, 0)) == PLUS
)
5619 rtx offset
= XEXP (XEXP (arg
->stack_slot
, 0), 1);
5620 lower_bound
= rtx_to_poly_int64 (offset
);
5625 upper_bound
= lower_bound
+ arg
->locate
.size
.constant
;
5628 if (stack_region_maybe_used_p (lower_bound
, upper_bound
,
5629 reg_parm_stack_space
))
5631 /* We need to make a save area. */
5632 poly_uint64 size
= arg
->locate
.size
.constant
* BITS_PER_UNIT
;
5633 machine_mode save_mode
5634 = int_mode_for_size (size
, 1).else_blk ();
5635 rtx adr
= memory_address (save_mode
, XEXP (arg
->stack_slot
, 0));
5636 rtx stack_area
= gen_rtx_MEM (save_mode
, adr
);
5638 if (save_mode
== BLKmode
)
5641 = assign_temp (TREE_TYPE (arg
->tree_value
), 1, 1);
5642 preserve_temp_slots (arg
->save_area
);
5643 emit_block_move (validize_mem (copy_rtx (arg
->save_area
)),
5646 (arg
->locate
.size
.constant
, Pmode
)),
5647 BLOCK_OP_CALL_PARM
);
5651 arg
->save_area
= gen_reg_rtx (save_mode
);
5652 emit_move_insn (arg
->save_area
, stack_area
);
5658 /* If this isn't going to be placed on both the stack and in registers,
5659 set up the register and number of words. */
5660 if (! arg
->pass_on_stack
)
5662 if (flags
& ECF_SIBCALL
)
5663 reg
= arg
->tail_call_reg
;
5666 partial
= arg
->partial
;
5669 /* Being passed entirely in a register. We shouldn't be called in
5671 gcc_assert (reg
== 0 || partial
!= 0);
5673 /* If this arg needs special alignment, don't load the registers
5675 if (arg
->n_aligned_regs
!= 0)
5678 /* If this is being passed partially in a register, we can't evaluate
5679 it directly into its stack slot. Otherwise, we can. */
5680 if (arg
->value
== 0)
5682 /* stack_arg_under_construction is nonzero if a function argument is
5683 being evaluated directly into the outgoing argument list and
5684 expand_call must take special action to preserve the argument list
5685 if it is called recursively.
5687 For scalar function arguments stack_usage_map is sufficient to
5688 determine which stack slots must be saved and restored. Scalar
5689 arguments in general have pass_on_stack == 0.
5691 If this argument is initialized by a function which takes the
5692 address of the argument (a C++ constructor or a C function
5693 returning a BLKmode structure), then stack_usage_map is
5694 insufficient and expand_call must push the stack around the
5695 function call. Such arguments have pass_on_stack == 1.
5697 Note that it is always safe to set stack_arg_under_construction,
5698 but this generates suboptimal code if set when not needed. */
5700 if (arg
->pass_on_stack
)
5701 stack_arg_under_construction
++;
5703 arg
->value
= expand_expr (pval
,
5705 || TYPE_MODE (TREE_TYPE (pval
)) != arg
->mode
)
5706 ? NULL_RTX
: arg
->stack
,
5707 VOIDmode
, EXPAND_STACK_PARM
);
5709 /* If we are promoting object (or for any other reason) the mode
5710 doesn't agree, convert the mode. */
5712 if (arg
->mode
!= TYPE_MODE (TREE_TYPE (pval
)))
5713 arg
->value
= convert_modes (arg
->mode
, TYPE_MODE (TREE_TYPE (pval
)),
5714 arg
->value
, arg
->unsignedp
);
5716 if (arg
->pass_on_stack
)
5717 stack_arg_under_construction
--;
5720 /* Check for overlap with already clobbered argument area. */
5721 if ((flags
& ECF_SIBCALL
)
5722 && MEM_P (arg
->value
)
5723 && mem_might_overlap_already_clobbered_arg_p (XEXP (arg
->value
, 0),
5724 arg
->locate
.size
.constant
))
5725 sibcall_failure
= 1;
5727 /* Don't allow anything left on stack from computation
5728 of argument to alloca. */
5729 if (flags
& ECF_MAY_BE_ALLOCA
)
5730 do_pending_stack_adjust ();
5732 if (arg
->value
== arg
->stack
)
5733 /* If the value is already in the stack slot, we are done. */
5735 else if (arg
->mode
!= BLKmode
)
5737 unsigned int parm_align
;
5739 /* Argument is a scalar, not entirely passed in registers.
5740 (If part is passed in registers, arg->partial says how much
5741 and emit_push_insn will take care of putting it there.)
5743 Push it, and if its size is less than the
5744 amount of space allocated to it,
5745 also bump stack pointer by the additional space.
5746 Note that in C the default argument promotions
5747 will prevent such mismatches. */
5749 poly_int64 size
= (TYPE_EMPTY_P (TREE_TYPE (pval
))
5750 ? 0 : GET_MODE_SIZE (arg
->mode
));
5752 /* Compute how much space the push instruction will push.
5753 On many machines, pushing a byte will advance the stack
5754 pointer by a halfword. */
5755 #ifdef PUSH_ROUNDING
5756 size
= PUSH_ROUNDING (size
);
5760 /* Compute how much space the argument should get:
5761 round up to a multiple of the alignment for arguments. */
5762 if (targetm
.calls
.function_arg_padding (arg
->mode
, TREE_TYPE (pval
))
5764 /* At the moment we don't (need to) support ABIs for which the
5765 padding isn't known at compile time. In principle it should
5766 be easy to add though. */
5767 used
= force_align_up (size
, PARM_BOUNDARY
/ BITS_PER_UNIT
);
5769 /* Compute the alignment of the pushed argument. */
5770 parm_align
= arg
->locate
.boundary
;
5771 if (targetm
.calls
.function_arg_padding (arg
->mode
, TREE_TYPE (pval
))
5774 poly_int64 pad
= used
- size
;
5775 unsigned int pad_align
= known_alignment (pad
) * BITS_PER_UNIT
;
5777 parm_align
= MIN (parm_align
, pad_align
);
5780 /* This isn't already where we want it on the stack, so put it there.
5781 This can either be done with push or copy insns. */
5782 if (maybe_ne (used
, 0)
5783 && !emit_push_insn (arg
->value
, arg
->mode
, TREE_TYPE (pval
),
5784 NULL_RTX
, parm_align
, partial
, reg
, used
- size
,
5785 argblock
, ARGS_SIZE_RTX (arg
->locate
.offset
),
5786 reg_parm_stack_space
,
5787 ARGS_SIZE_RTX (arg
->locate
.alignment_pad
), true))
5788 sibcall_failure
= 1;
5790 /* Unless this is a partially-in-register argument, the argument is now
5793 arg
->value
= arg
->stack
;
5797 /* BLKmode, at least partly to be pushed. */
5799 unsigned int parm_align
;
5803 /* Pushing a nonscalar.
5804 If part is passed in registers, PARTIAL says how much
5805 and emit_push_insn will take care of putting it there. */
5807 /* Round its size up to a multiple
5808 of the allocation unit for arguments. */
5810 if (arg
->locate
.size
.var
!= 0)
5813 size_rtx
= ARGS_SIZE_RTX (arg
->locate
.size
);
5817 /* PUSH_ROUNDING has no effect on us, because emit_push_insn
5818 for BLKmode is careful to avoid it. */
5819 excess
= (arg
->locate
.size
.constant
5820 - arg_int_size_in_bytes (TREE_TYPE (pval
))
5822 size_rtx
= expand_expr (arg_size_in_bytes (TREE_TYPE (pval
)),
5823 NULL_RTX
, TYPE_MODE (sizetype
),
5827 parm_align
= arg
->locate
.boundary
;
5829 /* When an argument is padded down, the block is aligned to
5830 PARM_BOUNDARY, but the actual argument isn't. */
5831 if (targetm
.calls
.function_arg_padding (arg
->mode
, TREE_TYPE (pval
))
5834 if (arg
->locate
.size
.var
)
5835 parm_align
= BITS_PER_UNIT
;
5838 unsigned int excess_align
5839 = known_alignment (excess
) * BITS_PER_UNIT
;
5840 if (excess_align
!= 0)
5841 parm_align
= MIN (parm_align
, excess_align
);
5845 if ((flags
& ECF_SIBCALL
) && MEM_P (arg
->value
))
5847 /* emit_push_insn might not work properly if arg->value and
5848 argblock + arg->locate.offset areas overlap. */
5852 if (XEXP (x
, 0) == crtl
->args
.internal_arg_pointer
5853 || (GET_CODE (XEXP (x
, 0)) == PLUS
5854 && XEXP (XEXP (x
, 0), 0) ==
5855 crtl
->args
.internal_arg_pointer
5856 && CONST_INT_P (XEXP (XEXP (x
, 0), 1))))
5858 if (XEXP (x
, 0) != crtl
->args
.internal_arg_pointer
)
5859 i
= rtx_to_poly_int64 (XEXP (XEXP (x
, 0), 1));
5861 /* arg.locate doesn't contain the pretend_args_size offset,
5862 it's part of argblock. Ensure we don't count it in I. */
5863 if (STACK_GROWS_DOWNWARD
)
5864 i
-= crtl
->args
.pretend_args_size
;
5866 i
+= crtl
->args
.pretend_args_size
;
5868 /* expand_call should ensure this. */
5869 gcc_assert (!arg
->locate
.offset
.var
5870 && arg
->locate
.size
.var
== 0);
5871 poly_int64 size_val
= rtx_to_poly_int64 (size_rtx
);
5873 if (known_eq (arg
->locate
.offset
.constant
, i
))
5875 /* Even though they appear to be at the same location,
5876 if part of the outgoing argument is in registers,
5877 they aren't really at the same location. Check for
5878 this by making sure that the incoming size is the
5879 same as the outgoing size. */
5880 if (maybe_ne (arg
->locate
.size
.constant
, size_val
))
5881 sibcall_failure
= 1;
5883 else if (maybe_in_range_p (arg
->locate
.offset
.constant
,
5885 sibcall_failure
= 1;
5886 /* Use arg->locate.size.constant instead of size_rtx
5887 because we only care about the part of the argument
5889 else if (maybe_in_range_p (i
, arg
->locate
.offset
.constant
,
5890 arg
->locate
.size
.constant
))
5891 sibcall_failure
= 1;
5895 if (!CONST_INT_P (size_rtx
) || INTVAL (size_rtx
) != 0)
5896 emit_push_insn (arg
->value
, arg
->mode
, TREE_TYPE (pval
), size_rtx
,
5897 parm_align
, partial
, reg
, excess
, argblock
,
5898 ARGS_SIZE_RTX (arg
->locate
.offset
),
5899 reg_parm_stack_space
,
5900 ARGS_SIZE_RTX (arg
->locate
.alignment_pad
), false);
5902 /* Unless this is a partially-in-register argument, the argument is now
5905 ??? Unlike the case above, in which we want the actual
5906 address of the data, so that we can load it directly into a
5907 register, here we want the address of the stack slot, so that
5908 it's properly aligned for word-by-word copying or something
5909 like that. It's not clear that this is always correct. */
5911 arg
->value
= arg
->stack_slot
;
5914 if (arg
->reg
&& GET_CODE (arg
->reg
) == PARALLEL
)
5916 tree type
= TREE_TYPE (arg
->tree_value
);
5918 = emit_group_load_into_temps (arg
->reg
, arg
->value
, type
,
5919 int_size_in_bytes (type
));
5922 /* Mark all slots this store used. */
5923 if (ACCUMULATE_OUTGOING_ARGS
&& !(flags
& ECF_SIBCALL
)
5924 && argblock
&& ! variable_size
&& arg
->stack
)
5925 mark_stack_region_used (lower_bound
, upper_bound
);
5927 /* Once we have pushed something, pops can't safely
5928 be deferred during the rest of the arguments. */
5931 /* Free any temporary slots made in processing this argument. */
5934 return sibcall_failure
;
5937 /* Nonzero if we do not know how to pass TYPE solely in registers. */
5940 must_pass_in_stack_var_size (machine_mode mode ATTRIBUTE_UNUSED
,
5946 /* If the type has variable size... */
5947 if (TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
5950 /* If the type is marked as addressable (it is required
5951 to be constructed into the stack)... */
5952 if (TREE_ADDRESSABLE (type
))
5958 /* Another version of the TARGET_MUST_PASS_IN_STACK hook. This one
5959 takes trailing padding of a structure into account. */
5960 /* ??? Should be able to merge these two by examining BLOCK_REG_PADDING. */
5963 must_pass_in_stack_var_size_or_pad (machine_mode mode
, const_tree type
)
5968 /* If the type has variable size... */
5969 if (TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
5972 /* If the type is marked as addressable (it is required
5973 to be constructed into the stack)... */
5974 if (TREE_ADDRESSABLE (type
))
5977 if (TYPE_EMPTY_P (type
))
5980 /* If the padding and mode of the type is such that a copy into
5981 a register would put it into the wrong part of the register. */
5983 && int_size_in_bytes (type
) % (PARM_BOUNDARY
/ BITS_PER_UNIT
)
5984 && (targetm
.calls
.function_arg_padding (mode
, type
)
5985 == (BYTES_BIG_ENDIAN
? PAD_UPWARD
: PAD_DOWNWARD
)))
5991 /* Tell the garbage collector about GTY markers in this source file. */
5992 #include "gt-calls.h"