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"
53 #include "tree-ssa-strlen.h"
56 #include "stringpool.h"
59 #include "gimple-fold.h"
61 /* Like PREFERRED_STACK_BOUNDARY but in units of bytes, not bits. */
62 #define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)
64 /* Data structure and subroutines used within expand_call. */
68 /* Tree node for this argument. */
70 /* Mode for value; TYPE_MODE unless promoted. */
72 /* Current RTL value for argument, or 0 if it isn't precomputed. */
74 /* Initially-compute RTL value for argument; only for const functions. */
76 /* Register to pass this argument in, 0 if passed on stack, or an
77 PARALLEL if the arg is to be copied into multiple non-contiguous
80 /* Register to pass this argument in when generating tail call sequence.
81 This is not the same register as for normal calls on machines with
84 /* If REG is a PARALLEL, this is a copy of VALUE pulled into the correct
85 form for emit_group_move. */
87 /* If value is passed in neither reg nor stack, this field holds a number
88 of a special slot to be used. */
90 /* For pointer bounds hold an index of parm bounds are bound to. -1 if
91 there is no such pointer. */
93 /* If pointer_arg refers a structure, then pointer_offset holds an offset
94 of a pointer in this structure. */
96 /* If REG was promoted from the actual mode of the argument expression,
97 indicates whether the promotion is sign- or zero-extended. */
99 /* Number of bytes to put in registers. 0 means put the whole arg
100 in registers. Also 0 if not passed in registers. */
102 /* Nonzero if argument must be passed on stack.
103 Note that some arguments may be passed on the stack
104 even though pass_on_stack is zero, just because FUNCTION_ARG says so.
105 pass_on_stack identifies arguments that *cannot* go in registers. */
107 /* Some fields packaged up for locate_and_pad_parm. */
108 struct locate_and_pad_arg_data locate;
109 /* Location on the stack at which parameter should be stored. The store
110 has already been done if STACK == VALUE. */
112 /* Location on the stack of the start of this argument slot. This can
113 differ from STACK if this arg pads downward. This location is known
114 to be aligned to TARGET_FUNCTION_ARG_BOUNDARY. */
116 /* Place that this stack area has been saved, if needed. */
118 /* If an argument's alignment does not permit direct copying into registers,
119 copy in smaller-sized pieces into pseudos. These are stored in a
120 block pointed to by this field. The next field says how many
121 word-sized pseudos we made. */
126 /* A vector of one char per byte of stack space. A byte if nonzero if
127 the corresponding stack location has been used.
128 This vector is used to prevent a function call within an argument from
129 clobbering any stack already set up. */
130 static char *stack_usage_map;
132 /* Size of STACK_USAGE_MAP. */
133 static unsigned int highest_outgoing_arg_in_use;
135 /* Assume that any stack location at this byte index is used,
136 without checking the contents of stack_usage_map. */
137 static unsigned HOST_WIDE_INT stack_usage_watermark = HOST_WIDE_INT_M1U;
139 /* A bitmap of virtual-incoming stack space. Bit is set if the corresponding
140 stack location's tail call argument has been already stored into the stack.
141 This bitmap is used to prevent sibling call optimization if function tries
142 to use parent's incoming argument slots when they have been already
143 overwritten with tail call arguments. */
144 static sbitmap stored_args_map;
146 /* Assume that any virtual-incoming location at this byte index has been
147 stored, without checking the contents of stored_args_map. */
148 static unsigned HOST_WIDE_INT stored_args_watermark;
150 /* stack_arg_under_construction is nonzero when an argument may be
151 initialized with a constructor call (including a C function that
152 returns a BLKmode struct) and expand_call must take special action
153 to make sure the object being constructed does not overlap the
154 argument list for the constructor call. */
155 static int stack_arg_under_construction;
157 static void precompute_register_parameters (int, struct arg_data *, int *);
158 static void store_bounds (struct arg_data *, struct arg_data *);
159 static int store_one_arg (struct arg_data *, rtx, int, int, int);
160 static void store_unaligned_arguments_into_pseudos (struct arg_data *, int);
161 static int finalize_must_preallocate (int, int, struct arg_data *,
163 static void precompute_arguments (int, struct arg_data *);
164 static void compute_argument_addresses (struct arg_data *, rtx, int);
165 static rtx rtx_for_function_call (tree, tree);
166 static void load_register_parameters (struct arg_data *, int, rtx *, int,
168 static int special_function_p (const_tree, int);
169 static int check_sibcall_argument_overlap_1 (rtx);
170 static int check_sibcall_argument_overlap (rtx_insn *, struct arg_data *, int);
172 static tree split_complex_types (tree);
174 #ifdef REG_PARM_STACK_SPACE
175 static rtx save_fixed_argument_area (int, rtx, int *, int *);
176 static void restore_fixed_argument_area (rtx, rtx, int, int);
179 /* Return true if bytes [LOWER_BOUND, UPPER_BOUND) of the outgoing
180 stack region might already be in use. */
183 stack_region_maybe_used_p (poly_uint64 lower_bound, poly_uint64 upper_bound,
184 unsigned int reg_parm_stack_space)
186 unsigned HOST_WIDE_INT const_lower, const_upper;
187 const_lower = constant_lower_bound (lower_bound);
188 if (!upper_bound.is_constant (&const_upper))
189 const_upper = HOST_WIDE_INT_M1U;
191 if (const_upper > stack_usage_watermark)
194 /* Don't worry about things in the fixed argument area;
195 it has already been saved. */
196 const_lower = MAX (const_lower, reg_parm_stack_space);
197 const_upper = MIN (const_upper, highest_outgoing_arg_in_use);
198 for (unsigned HOST_WIDE_INT i = const_lower; i < const_upper; ++i)
199 if (stack_usage_map[i])
204 /* Record that bytes [LOWER_BOUND, UPPER_BOUND) of the outgoing
205 stack region are now in use. */
208 mark_stack_region_used (poly_uint64 lower_bound, poly_uint64 upper_bound)
210 unsigned HOST_WIDE_INT const_lower, const_upper;
211 const_lower = constant_lower_bound (lower_bound);
212 if (upper_bound.is_constant (&const_upper))
213 for (unsigned HOST_WIDE_INT i = const_lower; i < const_upper; ++i)
214 stack_usage_map[i] = 1;
216 stack_usage_watermark = MIN (stack_usage_watermark, const_lower);
219 /* Force FUNEXP into a form suitable for the address of a CALL,
220 and return that as an rtx. Also load the static chain register
221 if FNDECL is a nested function.
223 CALL_FUSAGE points to a variable holding the prospective
224 CALL_INSN_FUNCTION_USAGE information. */
227 prepare_call_address (tree fndecl_or_type, rtx funexp, rtx static_chain_value,
228 rtx *call_fusage, int reg_parm_seen, int flags)
230 /* Make a valid memory address and copy constants through pseudo-regs,
231 but not for a constant address if -fno-function-cse. */
232 if (GET_CODE (funexp) != SYMBOL_REF)
234 /* If it's an indirect call by descriptor, generate code to perform
235 runtime identification of the pointer and load the descriptor. */
236 if ((flags & ECF_BY_DESCRIPTOR) && !flag_trampolines)
238 const int bit_val = targetm.calls.custom_function_descriptors;
239 rtx call_lab = gen_label_rtx ();
241 gcc_assert (fndecl_or_type && TYPE_P (fndecl_or_type));
243 = build_decl (UNKNOWN_LOCATION, FUNCTION_DECL, NULL_TREE,
245 DECL_STATIC_CHAIN (fndecl_or_type) = 1;
246 rtx chain = targetm.calls.static_chain (fndecl_or_type, false);
248 if (GET_MODE (funexp) != Pmode)
249 funexp = convert_memory_address (Pmode, funexp);
251 /* Avoid long live ranges around function calls. */
252 funexp = copy_to_mode_reg (Pmode, funexp);
255 emit_insn (gen_rtx_CLOBBER (VOIDmode, chain));
257 /* Emit the runtime identification pattern. */
258 rtx mask = gen_rtx_AND (Pmode, funexp, GEN_INT (bit_val));
259 emit_cmp_and_jump_insns (mask, const0_rtx, EQ, NULL_RTX, Pmode, 1,
262 /* Statically predict the branch to very likely taken. */
263 rtx_insn *insn = get_last_insn ();
265 predict_insn_def (insn, PRED_BUILTIN_EXPECT, TAKEN);
267 /* Load the descriptor. */
268 rtx mem = gen_rtx_MEM (ptr_mode,
269 plus_constant (Pmode, funexp, - bit_val));
270 MEM_NOTRAP_P (mem) = 1;
271 mem = convert_memory_address (Pmode, mem);
272 emit_move_insn (chain, mem);
274 mem = gen_rtx_MEM (ptr_mode,
275 plus_constant (Pmode, funexp,
276 POINTER_SIZE / BITS_PER_UNIT
278 MEM_NOTRAP_P (mem) = 1;
279 mem = convert_memory_address (Pmode, mem);
280 emit_move_insn (funexp, mem);
282 emit_label (call_lab);
286 use_reg (call_fusage, chain);
287 STATIC_CHAIN_REG_P (chain) = 1;
290 /* Make sure we're not going to be overwritten below. */
291 gcc_assert (!static_chain_value);
294 /* If we are using registers for parameters, force the
295 function address into a register now. */
296 funexp = ((reg_parm_seen
297 && targetm.small_register_classes_for_mode_p (FUNCTION_MODE))
298 ? force_not_mem (memory_address (FUNCTION_MODE, funexp))
299 : memory_address (FUNCTION_MODE, funexp));
303 /* funexp could be a SYMBOL_REF represents a function pointer which is
304 of ptr_mode. In this case, it should be converted into address mode
305 to be a valid address for memory rtx pattern. See PR 64971. */
306 if (GET_MODE (funexp) != Pmode)
307 funexp = convert_memory_address (Pmode, funexp);
309 if (!(flags & ECF_SIBCALL))
311 if (!NO_FUNCTION_CSE && optimize && ! flag_no_function_cse)
312 funexp = force_reg (Pmode, funexp);
316 if (static_chain_value != 0
317 && (TREE_CODE (fndecl_or_type) != FUNCTION_DECL
318 || DECL_STATIC_CHAIN (fndecl_or_type)))
322 chain = targetm.calls.static_chain (fndecl_or_type, false);
323 static_chain_value = convert_memory_address (Pmode, static_chain_value);
325 emit_move_insn (chain, static_chain_value);
328 use_reg (call_fusage, chain);
329 STATIC_CHAIN_REG_P (chain) = 1;
336 /* Generate instructions to call function FUNEXP,
337 and optionally pop the results.
338 The CALL_INSN is the first insn generated.
340 FNDECL is the declaration node of the function. This is given to the
341 hook TARGET_RETURN_POPS_ARGS to determine whether this function pops
344 FUNTYPE is the data type of the function. This is given to the hook
345 TARGET_RETURN_POPS_ARGS to determine whether this function pops its
346 own args. We used to allow an identifier for library functions, but
347 that doesn't work when the return type is an aggregate type and the
348 calling convention says that the pointer to this aggregate is to be
349 popped by the callee.
351 STACK_SIZE is the number of bytes of arguments on the stack,
352 ROUNDED_STACK_SIZE is that number rounded up to
353 PREFERRED_STACK_BOUNDARY; zero if the size is variable. This is
354 both to put into the call insn and to generate explicit popping
357 STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
358 It is zero if this call doesn't want a structure value.
360 NEXT_ARG_REG is the rtx that results from executing
361 targetm.calls.function_arg (&args_so_far, VOIDmode, void_type_node, true)
362 just after all the args have had their registers assigned.
363 This could be whatever you like, but normally it is the first
364 arg-register beyond those used for args in this call,
365 or 0 if all the arg-registers are used in this call.
366 It is passed on to `gen_call' so you can put this info in the call insn.
368 VALREG is a hard register in which a value is returned,
369 or 0 if the call does not return a value.
371 OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before
372 the args to this call were processed.
373 We restore `inhibit_defer_pop' to that value.
375 CALL_FUSAGE is either empty or an EXPR_LIST of USE expressions that
376 denote registers used by the called function. */
379 emit_call_1 (rtx funexp, tree fntree ATTRIBUTE_UNUSED, tree fndecl ATTRIBUTE_UNUSED,
380 tree funtype ATTRIBUTE_UNUSED,
381 poly_int64 stack_size ATTRIBUTE_UNUSED,
382 poly_int64 rounded_stack_size,
383 poly_int64 struct_value_size ATTRIBUTE_UNUSED,
384 rtx next_arg_reg ATTRIBUTE_UNUSED, rtx valreg,
385 int old_inhibit_defer_pop, rtx call_fusage, int ecf_flags,
386 cumulative_args_t args_so_far ATTRIBUTE_UNUSED)
388 rtx rounded_stack_size_rtx = gen_int_mode (rounded_stack_size, Pmode);
389 rtx call, funmem, pat;
390 int already_popped = 0;
391 poly_int64 n_popped = 0;
393 /* Sibling call patterns never pop arguments (no sibcall(_value)_pop
394 patterns exist). Any popping that the callee does on return will
395 be from our caller's frame rather than ours. */
396 if (!(ecf_flags & ECF_SIBCALL))
398 n_popped += targetm.calls.return_pops_args (fndecl, funtype, stack_size);
400 #ifdef CALL_POPS_ARGS
401 n_popped += CALL_POPS_ARGS (*get_cumulative_args (args_so_far));
405 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
406 and we don't want to load it into a register as an optimization,
407 because prepare_call_address already did it if it should be done. */
408 if (GET_CODE (funexp) != SYMBOL_REF)
409 funexp = memory_address (FUNCTION_MODE, funexp);
411 funmem = gen_rtx_MEM (FUNCTION_MODE, funexp);
412 if (fndecl && TREE_CODE (fndecl) == FUNCTION_DECL)
416 /* Although a built-in FUNCTION_DECL and its non-__builtin
417 counterpart compare equal and get a shared mem_attrs, they
418 produce different dump output in compare-debug compilations,
419 if an entry gets garbage collected in one compilation, then
420 adds a different (but equivalent) entry, while the other
421 doesn't run the garbage collector at the same spot and then
422 shares the mem_attr with the equivalent entry. */
423 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL)
425 tree t2 = builtin_decl_explicit (DECL_FUNCTION_CODE (t));
430 set_mem_expr (funmem, t);
433 set_mem_expr (funmem, build_simple_mem_ref (CALL_EXPR_FN (fntree)));
435 if (ecf_flags & ECF_SIBCALL)
438 pat = targetm.gen_sibcall_value (valreg, funmem,
439 rounded_stack_size_rtx,
440 next_arg_reg, NULL_RTX);
442 pat = targetm.gen_sibcall (funmem, rounded_stack_size_rtx,
444 gen_int_mode (struct_value_size, Pmode));
446 /* If the target has "call" or "call_value" insns, then prefer them
447 if no arguments are actually popped. If the target does not have
448 "call" or "call_value" insns, then we must use the popping versions
449 even if the call has no arguments to pop. */
450 else if (maybe_ne (n_popped, 0)
452 ? targetm.have_call_value ()
453 : targetm.have_call ()))
455 rtx n_pop = gen_int_mode (n_popped, Pmode);
457 /* If this subroutine pops its own args, record that in the call insn
458 if possible, for the sake of frame pointer elimination. */
461 pat = targetm.gen_call_value_pop (valreg, funmem,
462 rounded_stack_size_rtx,
463 next_arg_reg, n_pop);
465 pat = targetm.gen_call_pop (funmem, rounded_stack_size_rtx,
466 next_arg_reg, n_pop);
473 pat = targetm.gen_call_value (valreg, funmem, rounded_stack_size_rtx,
474 next_arg_reg, NULL_RTX);
476 pat = targetm.gen_call (funmem, rounded_stack_size_rtx, next_arg_reg,
477 gen_int_mode (struct_value_size, Pmode));
481 /* Find the call we just emitted. */
482 rtx_call_insn *call_insn = last_call_insn ();
484 /* Some target create a fresh MEM instead of reusing the one provided
485 above. Set its MEM_EXPR. */
486 call = get_call_rtx_from (call_insn);
488 && MEM_EXPR (XEXP (call, 0)) == NULL_TREE
489 && MEM_EXPR (funmem) != NULL_TREE)
490 set_mem_expr (XEXP (call, 0), MEM_EXPR (funmem));
492 /* Mark instrumented calls. */
494 CALL_EXPR_WITH_BOUNDS_P (call) = CALL_WITH_BOUNDS_P (fntree);
496 /* Put the register usage information there. */
497 add_function_usage_to (call_insn, call_fusage);
499 /* If this is a const call, then set the insn's unchanging bit. */
500 if (ecf_flags & ECF_CONST)
501 RTL_CONST_CALL_P (call_insn) = 1;
503 /* If this is a pure call, then set the insn's unchanging bit. */
504 if (ecf_flags & ECF_PURE)
505 RTL_PURE_CALL_P (call_insn) = 1;
507 /* If this is a const call, then set the insn's unchanging bit. */
508 if (ecf_flags & ECF_LOOPING_CONST_OR_PURE)
509 RTL_LOOPING_CONST_OR_PURE_CALL_P (call_insn) = 1;
511 /* Create a nothrow REG_EH_REGION note, if needed. */
512 make_reg_eh_region_note (call_insn, ecf_flags, 0);
514 if (ecf_flags & ECF_NORETURN)
515 add_reg_note (call_insn, REG_NORETURN, const0_rtx);
517 if (ecf_flags & ECF_RETURNS_TWICE)
519 add_reg_note (call_insn, REG_SETJMP, const0_rtx);
520 cfun->calls_setjmp = 1;
523 SIBLING_CALL_P (call_insn) = ((ecf_flags & ECF_SIBCALL) != 0);
525 /* Restore this now, so that we do defer pops for this call's args
526 if the context of the call as a whole permits. */
527 inhibit_defer_pop = old_inhibit_defer_pop;
529 if (maybe_ne (n_popped, 0))
532 CALL_INSN_FUNCTION_USAGE (call_insn)
533 = gen_rtx_EXPR_LIST (VOIDmode,
534 gen_rtx_CLOBBER (VOIDmode, stack_pointer_rtx),
535 CALL_INSN_FUNCTION_USAGE (call_insn));
536 rounded_stack_size -= n_popped;
537 rounded_stack_size_rtx = gen_int_mode (rounded_stack_size, Pmode);
538 stack_pointer_delta -= n_popped;
540 add_args_size_note (call_insn, stack_pointer_delta);
542 /* If popup is needed, stack realign must use DRAP */
543 if (SUPPORTS_STACK_ALIGNMENT)
544 crtl->need_drap = true;
546 /* For noreturn calls when not accumulating outgoing args force
547 REG_ARGS_SIZE note to prevent crossjumping of calls with different
549 else if (!ACCUMULATE_OUTGOING_ARGS && (ecf_flags & ECF_NORETURN) != 0)
550 add_args_size_note (call_insn, stack_pointer_delta);
552 if (!ACCUMULATE_OUTGOING_ARGS)
554 /* If returning from the subroutine does not automatically pop the args,
555 we need an instruction to pop them sooner or later.
556 Perhaps do it now; perhaps just record how much space to pop later.
558 If returning from the subroutine does pop the args, indicate that the
559 stack pointer will be changed. */
561 if (maybe_ne (rounded_stack_size, 0))
563 if (ecf_flags & ECF_NORETURN)
564 /* Just pretend we did the pop. */
565 stack_pointer_delta -= rounded_stack_size;
566 else if (flag_defer_pop && inhibit_defer_pop == 0
567 && ! (ecf_flags & (ECF_CONST | ECF_PURE)))
568 pending_stack_adjust += rounded_stack_size;
570 adjust_stack (rounded_stack_size_rtx);
573 /* When we accumulate outgoing args, we must avoid any stack manipulations.
574 Restore the stack pointer to its original value now. Usually
575 ACCUMULATE_OUTGOING_ARGS targets don't get here, but there are exceptions.
576 On i386 ACCUMULATE_OUTGOING_ARGS can be enabled on demand, and
577 popping variants of functions exist as well.
579 ??? We may optimize similar to defer_pop above, but it is
580 probably not worthwhile.
582 ??? It will be worthwhile to enable combine_stack_adjustments even for
584 else if (maybe_ne (n_popped, 0))
585 anti_adjust_stack (gen_int_mode (n_popped, Pmode));
588 /* Determine if the function identified by FNDECL is one with
589 special properties we wish to know about. Modify FLAGS accordingly.
591 For example, if the function might return more than one time (setjmp), then
592 set ECF_RETURNS_TWICE.
594 Set ECF_MAY_BE_ALLOCA for any memory allocation function that might allocate
595 space from the stack such as alloca. */
598 special_function_p (const_tree fndecl, int flags)
600 tree name_decl = DECL_NAME (fndecl);
602 /* For instrumentation clones we want to derive flags
603 from the original name. */
604 if (cgraph_node::get (fndecl)
605 && cgraph_node::get (fndecl)->instrumentation_clone)
606 name_decl = DECL_NAME (cgraph_node::get (fndecl)->orig_decl);
608 if (fndecl && name_decl
609 && IDENTIFIER_LENGTH (name_decl) <= 11
610 /* Exclude functions not at the file scope, or not `extern',
611 since they are not the magic functions we would otherwise
613 FIXME: this should be handled with attributes, not with this
614 hacky imitation of DECL_ASSEMBLER_NAME. It's (also) wrong
615 because you can declare fork() inside a function if you
617 && (DECL_CONTEXT (fndecl) == NULL_TREE
618 || TREE_CODE (DECL_CONTEXT (fndecl)) == TRANSLATION_UNIT_DECL)
619 && TREE_PUBLIC (fndecl))
621 const char *name = IDENTIFIER_POINTER (name_decl);
622 const char *tname = name;
624 /* We assume that alloca will always be called by name. It
625 makes no sense to pass it as a pointer-to-function to
626 anything that does not understand its behavior. */
627 if (IDENTIFIER_LENGTH (name_decl) == 6
629 && ! strcmp (name, "alloca"))
630 flags |= ECF_MAY_BE_ALLOCA;
632 /* Disregard prefix _ or __. */
641 /* ECF_RETURNS_TWICE is safe even for -ffreestanding. */
642 if (! strcmp (tname, "setjmp")
643 || ! strcmp (tname, "sigsetjmp")
644 || ! strcmp (name, "savectx")
645 || ! strcmp (name, "vfork")
646 || ! strcmp (name, "getcontext"))
647 flags |= ECF_RETURNS_TWICE;
650 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
651 && ALLOCA_FUNCTION_CODE_P (DECL_FUNCTION_CODE (fndecl)))
652 flags |= ECF_MAY_BE_ALLOCA;
657 /* Similar to special_function_p; return a set of ERF_ flags for the
660 decl_return_flags (tree fndecl)
663 tree type = TREE_TYPE (fndecl);
667 attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
671 attr = TREE_VALUE (TREE_VALUE (attr));
672 if (!attr || TREE_STRING_LENGTH (attr) < 1)
675 switch (TREE_STRING_POINTER (attr)[0])
681 return ERF_RETURNS_ARG | (TREE_STRING_POINTER (attr)[0] - '1');
692 /* Return nonzero when FNDECL represents a call to setjmp. */
695 setjmp_call_p (const_tree fndecl)
697 if (DECL_IS_RETURNS_TWICE (fndecl))
698 return ECF_RETURNS_TWICE;
699 return special_function_p (fndecl, 0) & ECF_RETURNS_TWICE;
703 /* Return true if STMT may be an alloca call. */
706 gimple_maybe_alloca_call_p (const gimple *stmt)
710 if (!is_gimple_call (stmt))
713 fndecl = gimple_call_fndecl (stmt);
714 if (fndecl && (special_function_p (fndecl, 0) & ECF_MAY_BE_ALLOCA))
720 /* Return true if STMT is a builtin alloca call. */
723 gimple_alloca_call_p (const gimple *stmt)
727 if (!is_gimple_call (stmt))
730 fndecl = gimple_call_fndecl (stmt);
731 if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
732 switch (DECL_FUNCTION_CODE (fndecl))
734 CASE_BUILT_IN_ALLOCA:
735 return gimple_call_num_args (stmt) > 0;
743 /* Return true when exp contains a builtin alloca call. */
746 alloca_call_p (const_tree exp)
749 if (TREE_CODE (exp) == CALL_EXPR
750 && (fndecl = get_callee_fndecl (exp))
751 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
752 switch (DECL_FUNCTION_CODE (fndecl))
754 CASE_BUILT_IN_ALLOCA:
763 /* Return TRUE if FNDECL is either a TM builtin or a TM cloned
764 function. Return FALSE otherwise. */
767 is_tm_builtin (const_tree fndecl)
772 if (decl_is_tm_clone (fndecl))
775 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
777 switch (DECL_FUNCTION_CODE (fndecl))
779 case BUILT_IN_TM_COMMIT:
780 case BUILT_IN_TM_COMMIT_EH:
781 case BUILT_IN_TM_ABORT:
782 case BUILT_IN_TM_IRREVOCABLE:
783 case BUILT_IN_TM_GETTMCLONE_IRR:
784 case BUILT_IN_TM_MEMCPY:
785 case BUILT_IN_TM_MEMMOVE:
786 case BUILT_IN_TM_MEMSET:
787 CASE_BUILT_IN_TM_STORE (1):
788 CASE_BUILT_IN_TM_STORE (2):
789 CASE_BUILT_IN_TM_STORE (4):
790 CASE_BUILT_IN_TM_STORE (8):
791 CASE_BUILT_IN_TM_STORE (FLOAT):
792 CASE_BUILT_IN_TM_STORE (DOUBLE):
793 CASE_BUILT_IN_TM_STORE (LDOUBLE):
794 CASE_BUILT_IN_TM_STORE (M64):
795 CASE_BUILT_IN_TM_STORE (M128):
796 CASE_BUILT_IN_TM_STORE (M256):
797 CASE_BUILT_IN_TM_LOAD (1):
798 CASE_BUILT_IN_TM_LOAD (2):
799 CASE_BUILT_IN_TM_LOAD (4):
800 CASE_BUILT_IN_TM_LOAD (8):
801 CASE_BUILT_IN_TM_LOAD (FLOAT):
802 CASE_BUILT_IN_TM_LOAD (DOUBLE):
803 CASE_BUILT_IN_TM_LOAD (LDOUBLE):
804 CASE_BUILT_IN_TM_LOAD (M64):
805 CASE_BUILT_IN_TM_LOAD (M128):
806 CASE_BUILT_IN_TM_LOAD (M256):
807 case BUILT_IN_TM_LOG:
808 case BUILT_IN_TM_LOG_1:
809 case BUILT_IN_TM_LOG_2:
810 case BUILT_IN_TM_LOG_4:
811 case BUILT_IN_TM_LOG_8:
812 case BUILT_IN_TM_LOG_FLOAT:
813 case BUILT_IN_TM_LOG_DOUBLE:
814 case BUILT_IN_TM_LOG_LDOUBLE:
815 case BUILT_IN_TM_LOG_M64:
816 case BUILT_IN_TM_LOG_M128:
817 case BUILT_IN_TM_LOG_M256:
826 /* Detect flags (function attributes) from the function decl or type node. */
829 flags_from_decl_or_type (const_tree exp)
835 /* The function exp may have the `malloc' attribute. */
836 if (DECL_IS_MALLOC (exp))
839 /* The function exp may have the `returns_twice' attribute. */
840 if (DECL_IS_RETURNS_TWICE (exp))
841 flags |= ECF_RETURNS_TWICE;
843 /* Process the pure and const attributes. */
844 if (TREE_READONLY (exp))
846 if (DECL_PURE_P (exp))
848 if (DECL_LOOPING_CONST_OR_PURE_P (exp))
849 flags |= ECF_LOOPING_CONST_OR_PURE;
851 if (DECL_IS_NOVOPS (exp))
853 if (lookup_attribute ("leaf", DECL_ATTRIBUTES (exp)))
855 if (lookup_attribute ("cold", DECL_ATTRIBUTES (exp)))
858 if (TREE_NOTHROW (exp))
859 flags |= ECF_NOTHROW;
863 if (is_tm_builtin (exp))
864 flags |= ECF_TM_BUILTIN;
865 else if ((flags & (ECF_CONST|ECF_NOVOPS)) != 0
866 || lookup_attribute ("transaction_pure",
867 TYPE_ATTRIBUTES (TREE_TYPE (exp))))
868 flags |= ECF_TM_PURE;
871 flags = special_function_p (exp, flags);
873 else if (TYPE_P (exp))
875 if (TYPE_READONLY (exp))
879 && ((flags & ECF_CONST) != 0
880 || lookup_attribute ("transaction_pure", TYPE_ATTRIBUTES (exp))))
881 flags |= ECF_TM_PURE;
886 if (TREE_THIS_VOLATILE (exp))
888 flags |= ECF_NORETURN;
889 if (flags & (ECF_CONST|ECF_PURE))
890 flags |= ECF_LOOPING_CONST_OR_PURE;
896 /* Detect flags from a CALL_EXPR. */
899 call_expr_flags (const_tree t)
902 tree decl = get_callee_fndecl (t);
905 flags = flags_from_decl_or_type (decl);
906 else if (CALL_EXPR_FN (t) == NULL_TREE)
907 flags = internal_fn_flags (CALL_EXPR_IFN (t));
910 tree type = TREE_TYPE (CALL_EXPR_FN (t));
911 if (type && TREE_CODE (type) == POINTER_TYPE)
912 flags = flags_from_decl_or_type (TREE_TYPE (type));
915 if (CALL_EXPR_BY_DESCRIPTOR (t))
916 flags |= ECF_BY_DESCRIPTOR;
922 /* Return true if TYPE should be passed by invisible reference. */
925 pass_by_reference (CUMULATIVE_ARGS *ca, machine_mode mode,
926 tree type, bool named_arg)
930 /* If this type contains non-trivial constructors, then it is
931 forbidden for the middle-end to create any new copies. */
932 if (TREE_ADDRESSABLE (type))
935 /* GCC post 3.4 passes *all* variable sized types by reference. */
936 if (!TYPE_SIZE (type) || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
939 /* If a record type should be passed the same as its first (and only)
940 member, use the type and mode of that member. */
941 if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type))
943 type = TREE_TYPE (first_field (type));
944 mode = TYPE_MODE (type);
948 return targetm.calls.pass_by_reference (pack_cumulative_args (ca), mode,
952 /* Return true if TYPE, which is passed by reference, should be callee
953 copied instead of caller copied. */
956 reference_callee_copied (CUMULATIVE_ARGS *ca, machine_mode mode,
957 tree type, bool named_arg)
959 if (type && TREE_ADDRESSABLE (type))
961 return targetm.calls.callee_copies (pack_cumulative_args (ca), mode, type,
966 /* Precompute all register parameters as described by ARGS, storing values
967 into fields within the ARGS array.
969 NUM_ACTUALS indicates the total number elements in the ARGS array.
971 Set REG_PARM_SEEN if we encounter a register parameter. */
974 precompute_register_parameters (int num_actuals, struct arg_data *args,
981 for (i = 0; i < num_actuals; i++)
982 if (args[i].reg != 0 && ! args[i].pass_on_stack)
986 if (args[i].value == 0)
989 args[i].value = expand_normal (args[i].tree_value);
990 preserve_temp_slots (args[i].value);
994 /* If we are to promote the function arg to a wider mode,
997 if (args[i].mode != TYPE_MODE (TREE_TYPE (args[i].tree_value)))
999 = convert_modes (args[i].mode,
1000 TYPE_MODE (TREE_TYPE (args[i].tree_value)),
1001 args[i].value, args[i].unsignedp);
1003 /* If the value is a non-legitimate constant, force it into a
1004 pseudo now. TLS symbols sometimes need a call to resolve. */
1005 if (CONSTANT_P (args[i].value)
1006 && !targetm.legitimate_constant_p (args[i].mode, args[i].value))
1007 args[i].value = force_reg (args[i].mode, args[i].value);
1009 /* If we're going to have to load the value by parts, pull the
1010 parts into pseudos. The part extraction process can involve
1011 non-trivial computation. */
1012 if (GET_CODE (args[i].reg) == PARALLEL)
1014 tree type = TREE_TYPE (args[i].tree_value);
1015 args[i].parallel_value
1016 = emit_group_load_into_temps (args[i].reg, args[i].value,
1017 type, int_size_in_bytes (type));
1020 /* If the value is expensive, and we are inside an appropriately
1021 short loop, put the value into a pseudo and then put the pseudo
1024 For small register classes, also do this if this call uses
1025 register parameters. This is to avoid reload conflicts while
1026 loading the parameters registers. */
1028 else if ((! (REG_P (args[i].value)
1029 || (GET_CODE (args[i].value) == SUBREG
1030 && REG_P (SUBREG_REG (args[i].value)))))
1031 && args[i].mode != BLKmode
1032 && (set_src_cost (args[i].value, args[i].mode,
1033 optimize_insn_for_speed_p ())
1034 > COSTS_N_INSNS (1))
1036 && targetm.small_register_classes_for_mode_p (args[i].mode))
1038 args[i].value = copy_to_mode_reg (args[i].mode, args[i].value);
1042 #ifdef REG_PARM_STACK_SPACE
1044 /* The argument list is the property of the called routine and it
1045 may clobber it. If the fixed area has been used for previous
1046 parameters, we must save and restore it. */
1049 save_fixed_argument_area (int reg_parm_stack_space, rtx argblock, int *low_to_save, int *high_to_save)
1054 /* Compute the boundary of the area that needs to be saved, if any. */
1055 high = reg_parm_stack_space;
1056 if (ARGS_GROW_DOWNWARD)
1059 if (high > highest_outgoing_arg_in_use)
1060 high = highest_outgoing_arg_in_use;
1062 for (low = 0; low < high; low++)
1063 if (stack_usage_map[low] != 0 || low >= stack_usage_watermark)
1066 machine_mode save_mode;
1072 while (stack_usage_map[--high] == 0)
1076 *high_to_save = high;
1078 num_to_save = high - low + 1;
1080 /* If we don't have the required alignment, must do this
1082 scalar_int_mode imode;
1083 if (int_mode_for_size (num_to_save * BITS_PER_UNIT, 1).exists (&imode)
1084 && (low & (MIN (GET_MODE_SIZE (imode),
1085 BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1)) == 0)
1088 save_mode = BLKmode;
1090 if (ARGS_GROW_DOWNWARD)
1095 addr = plus_constant (Pmode, argblock, delta);
1096 stack_area = gen_rtx_MEM (save_mode, memory_address (save_mode, addr));
1098 set_mem_align (stack_area, PARM_BOUNDARY);
1099 if (save_mode == BLKmode)
1101 save_area = assign_stack_temp (BLKmode, num_to_save);
1102 emit_block_move (validize_mem (save_area), stack_area,
1103 GEN_INT (num_to_save), BLOCK_OP_CALL_PARM);
1107 save_area = gen_reg_rtx (save_mode);
1108 emit_move_insn (save_area, stack_area);
1118 restore_fixed_argument_area (rtx save_area, rtx argblock, int high_to_save, int low_to_save)
1120 machine_mode save_mode = GET_MODE (save_area);
1122 rtx addr, stack_area;
1124 if (ARGS_GROW_DOWNWARD)
1125 delta = -high_to_save;
1127 delta = low_to_save;
1129 addr = plus_constant (Pmode, argblock, delta);
1130 stack_area = gen_rtx_MEM (save_mode, memory_address (save_mode, addr));
1131 set_mem_align (stack_area, PARM_BOUNDARY);
1133 if (save_mode != BLKmode)
1134 emit_move_insn (stack_area, save_area);
1136 emit_block_move (stack_area, validize_mem (save_area),
1137 GEN_INT (high_to_save - low_to_save + 1),
1138 BLOCK_OP_CALL_PARM);
1140 #endif /* REG_PARM_STACK_SPACE */
1142 /* If any elements in ARGS refer to parameters that are to be passed in
1143 registers, but not in memory, and whose alignment does not permit a
1144 direct copy into registers. Copy the values into a group of pseudos
1145 which we will later copy into the appropriate hard registers.
1147 Pseudos for each unaligned argument will be stored into the array
1148 args[argnum].aligned_regs. The caller is responsible for deallocating
1149 the aligned_regs array if it is nonzero. */
1152 store_unaligned_arguments_into_pseudos (struct arg_data *args, int num_actuals)
1156 for (i = 0; i < num_actuals; i++)
1157 if (args[i].reg != 0 && ! args[i].pass_on_stack
1158 && GET_CODE (args[i].reg) != PARALLEL
1159 && args[i].mode == BLKmode
1160 && MEM_P (args[i].value)
1161 && (MEM_ALIGN (args[i].value)
1162 < (unsigned int) MIN (BIGGEST_ALIGNMENT, BITS_PER_WORD)))
1164 int bytes = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
1165 int endian_correction = 0;
1167 if (args[i].partial)
1169 gcc_assert (args[i].partial % UNITS_PER_WORD == 0);
1170 args[i].n_aligned_regs = args[i].partial / UNITS_PER_WORD;
1174 args[i].n_aligned_regs
1175 = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
1178 args[i].aligned_regs = XNEWVEC (rtx, args[i].n_aligned_regs);
1180 /* Structures smaller than a word are normally aligned to the
1181 least significant byte. On a BYTES_BIG_ENDIAN machine,
1182 this means we must skip the empty high order bytes when
1183 calculating the bit offset. */
1184 if (bytes < UNITS_PER_WORD
1185 #ifdef BLOCK_REG_PADDING
1186 && (BLOCK_REG_PADDING (args[i].mode,
1187 TREE_TYPE (args[i].tree_value), 1)
1193 endian_correction = BITS_PER_WORD - bytes * BITS_PER_UNIT;
1195 for (j = 0; j < args[i].n_aligned_regs; j++)
1197 rtx reg = gen_reg_rtx (word_mode);
1198 rtx word = operand_subword_force (args[i].value, j, BLKmode);
1199 int bitsize = MIN (bytes * BITS_PER_UNIT, BITS_PER_WORD);
1201 args[i].aligned_regs[j] = reg;
1202 word = extract_bit_field (word, bitsize, 0, 1, NULL_RTX,
1203 word_mode, word_mode, false, NULL);
1205 /* There is no need to restrict this code to loading items
1206 in TYPE_ALIGN sized hunks. The bitfield instructions can
1207 load up entire word sized registers efficiently.
1209 ??? This may not be needed anymore.
1210 We use to emit a clobber here but that doesn't let later
1211 passes optimize the instructions we emit. By storing 0 into
1212 the register later passes know the first AND to zero out the
1213 bitfield being set in the register is unnecessary. The store
1214 of 0 will be deleted as will at least the first AND. */
1216 emit_move_insn (reg, const0_rtx);
1218 bytes -= bitsize / BITS_PER_UNIT;
1219 store_bit_field (reg, bitsize, endian_correction, 0, 0,
1220 word_mode, word, false);
1225 /* The limit set by -Walloc-larger-than=. */
1226 static GTY(()) tree alloc_object_size_limit;
1228 /* Initialize ALLOC_OBJECT_SIZE_LIMIT based on the -Walloc-size-larger-than=
1229 setting if the option is specified, or to the maximum object size if it
1230 is not. Return the initialized value. */
1233 alloc_max_size (void)
1235 if (alloc_object_size_limit)
1236 return alloc_object_size_limit;
1238 alloc_object_size_limit = max_object_size ();
1240 if (!warn_alloc_size_limit)
1241 return alloc_object_size_limit;
1243 const char *optname = "-Walloc-size-larger-than=";
1247 unsigned HOST_WIDE_INT unit = 1;
1248 unsigned HOST_WIDE_INT limit
1249 = strtoull (warn_alloc_size_limit, &end, 10);
1251 /* If the value is too large to be represented use the maximum
1252 representable value that strtoull sets limit to (setting
1253 errno to ERANGE). */
1257 /* Numeric option arguments are at most INT_MAX. Make it
1258 possible to specify a larger value by accepting common
1260 if (!strcmp (end, "kB"))
1262 else if (!strcasecmp (end, "KiB") || !strcmp (end, "KB"))
1264 else if (!strcmp (end, "MB"))
1265 unit = HOST_WIDE_INT_UC (1000) * 1000;
1266 else if (!strcasecmp (end, "MiB"))
1267 unit = HOST_WIDE_INT_UC (1024) * 1024;
1268 else if (!strcasecmp (end, "GB"))
1269 unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000;
1270 else if (!strcasecmp (end, "GiB"))
1271 unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024;
1272 else if (!strcasecmp (end, "TB"))
1273 unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000;
1274 else if (!strcasecmp (end, "TiB"))
1275 unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024;
1276 else if (!strcasecmp (end, "PB"))
1277 unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000 * 1000;
1278 else if (!strcasecmp (end, "PiB"))
1279 unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024 * 1024;
1280 else if (!strcasecmp (end, "EB"))
1281 unit = HOST_WIDE_INT_UC (1000) * 1000 * 1000 * 1000 * 1000
1283 else if (!strcasecmp (end, "EiB"))
1284 unit = HOST_WIDE_INT_UC (1024) * 1024 * 1024 * 1024 * 1024
1288 /* This could mean an unknown suffix or a bad prefix, like
1290 warning_at (UNKNOWN_LOCATION, 0,
1291 "invalid argument %qs to %qs",
1292 warn_alloc_size_limit, optname);
1294 /* Ignore the limit extracted by strtoull. */
1301 widest_int w = wi::mul (limit, unit);
1302 if (w < wi::to_widest (alloc_object_size_limit))
1303 alloc_object_size_limit
1304 = wide_int_to_tree (ptrdiff_type_node, w);
1306 alloc_object_size_limit = build_all_ones_cst (size_type_node);
1310 return alloc_object_size_limit;
1313 /* Return true when EXP's range can be determined and set RANGE[] to it
1314 after adjusting it if necessary to make EXP a represents a valid size
1315 of object, or a valid size argument to an allocation function declared
1316 with attribute alloc_size (whose argument may be signed), or to a string
1317 manipulation function like memset. When ALLOW_ZERO is true, allow
1318 returning a range of [0, 0] for a size in an anti-range [1, N] where
1319 N > PTRDIFF_MAX. A zero range is a (nearly) invalid argument to
1320 allocation functions like malloc but it is a valid argument to
1321 functions like memset. */
1324 get_size_range (tree exp, tree range[2], bool allow_zero /* = false */)
1326 if (tree_fits_uhwi_p (exp))
1328 /* EXP is a constant. */
1329 range[0] = range[1] = exp;
1333 tree exptype = TREE_TYPE (exp);
1334 bool integral = INTEGRAL_TYPE_P (exptype);
1337 enum value_range_type range_type;
1339 if (TREE_CODE (exp) == SSA_NAME && integral)
1340 range_type = get_range_info (exp, &min, &max);
1342 range_type = VR_VARYING;
1344 if (range_type == VR_VARYING)
1348 /* Use the full range of the type of the expression when
1349 no value range information is available. */
1350 range[0] = TYPE_MIN_VALUE (exptype);
1351 range[1] = TYPE_MAX_VALUE (exptype);
1355 range[0] = NULL_TREE;
1356 range[1] = NULL_TREE;
1360 unsigned expprec = TYPE_PRECISION (exptype);
1362 bool signed_p = !TYPE_UNSIGNED (exptype);
1364 if (range_type == VR_ANTI_RANGE)
1368 if (wi::les_p (max, 0))
1370 /* EXP is not in a strictly negative range. That means
1371 it must be in some (not necessarily strictly) positive
1372 range which includes zero. Since in signed to unsigned
1373 conversions negative values end up converted to large
1374 positive values, and otherwise they are not valid sizes,
1375 the resulting range is in both cases [0, TYPE_MAX]. */
1376 min = wi::zero (expprec);
1377 max = wi::to_wide (TYPE_MAX_VALUE (exptype));
1379 else if (wi::les_p (min - 1, 0))
1381 /* EXP is not in a negative-positive range. That means EXP
1382 is either negative, or greater than max. Since negative
1383 sizes are invalid make the range [MAX + 1, TYPE_MAX]. */
1385 max = wi::to_wide (TYPE_MAX_VALUE (exptype));
1390 min = wi::zero (expprec);
1393 else if (wi::eq_p (0, min - 1))
1395 /* EXP is unsigned and not in the range [1, MAX]. That means
1396 it's either zero or greater than MAX. Even though 0 would
1397 normally be detected by -Walloc-zero, unless ALLOW_ZERO
1398 is true, set the range to [MAX, TYPE_MAX] so that when MAX
1399 is greater than the limit the whole range is diagnosed. */
1401 min = max = wi::zero (expprec);
1405 max = wi::to_wide (TYPE_MAX_VALUE (exptype));
1411 min = wi::zero (expprec);
1415 range[0] = wide_int_to_tree (exptype, min);
1416 range[1] = wide_int_to_tree (exptype, max);
1421 /* Diagnose a call EXP to function FN decorated with attribute alloc_size
1422 whose argument numbers given by IDX with values given by ARGS exceed
1423 the maximum object size or cause an unsigned oveflow (wrapping) when
1424 multiplied. When ARGS[0] is null the function does nothing. ARGS[1]
1425 may be null for functions like malloc, and non-null for those like
1426 calloc that are decorated with a two-argument attribute alloc_size. */
1429 maybe_warn_alloc_args_overflow (tree fn, tree exp, tree args[2], int idx[2])
1431 /* The range each of the (up to) two arguments is known to be in. */
1432 tree argrange[2][2] = { { NULL_TREE, NULL_TREE }, { NULL_TREE, NULL_TREE } };
1434 /* Maximum object size set by -Walloc-size-larger-than= or SIZE_MAX / 2. */
1435 tree maxobjsize = alloc_max_size ();
1437 location_t loc = EXPR_LOCATION (exp);
1439 bool warned = false;
1441 /* Validate each argument individually. */
1442 for (unsigned i = 0; i != 2 && args[i]; ++i)
1444 if (TREE_CODE (args[i]) == INTEGER_CST)
1446 argrange[i][0] = args[i];
1447 argrange[i][1] = args[i];
1449 if (tree_int_cst_lt (args[i], integer_zero_node))
1451 warned = warning_at (loc, OPT_Walloc_size_larger_than_,
1452 "%Kargument %i value %qE is negative",
1453 exp, idx[i] + 1, args[i]);
1455 else if (integer_zerop (args[i]))
1457 /* Avoid issuing -Walloc-zero for allocation functions other
1458 than __builtin_alloca that are declared with attribute
1459 returns_nonnull because there's no portability risk. This
1460 avoids warning for such calls to libiberty's xmalloc and
1462 Also avoid issuing the warning for calls to function named
1464 if ((DECL_FUNCTION_CODE (fn) == BUILT_IN_ALLOCA
1465 && IDENTIFIER_LENGTH (DECL_NAME (fn)) != 6)
1466 || (DECL_FUNCTION_CODE (fn) != BUILT_IN_ALLOCA
1467 && !lookup_attribute ("returns_nonnull",
1468 TYPE_ATTRIBUTES (TREE_TYPE (fn)))))
1469 warned = warning_at (loc, OPT_Walloc_zero,
1470 "%Kargument %i value is zero",
1473 else if (tree_int_cst_lt (maxobjsize, args[i]))
1475 /* G++ emits calls to ::operator new[](SIZE_MAX) in C++98
1476 mode and with -fno-exceptions as a way to indicate array
1477 size overflow. There's no good way to detect C++98 here
1478 so avoid diagnosing these calls for all C++ modes. */
1482 && DECL_IS_OPERATOR_NEW (fn)
1483 && integer_all_onesp (args[i]))
1486 warned = warning_at (loc, OPT_Walloc_size_larger_than_,
1487 "%Kargument %i value %qE exceeds "
1488 "maximum object size %E",
1489 exp, idx[i] + 1, args[i], maxobjsize);
1492 else if (TREE_CODE (args[i]) == SSA_NAME
1493 && get_size_range (args[i], argrange[i]))
1495 /* Verify that the argument's range is not negative (including
1496 upper bound of zero). */
1497 if (tree_int_cst_lt (argrange[i][0], integer_zero_node)
1498 && tree_int_cst_le (argrange[i][1], integer_zero_node))
1500 warned = warning_at (loc, OPT_Walloc_size_larger_than_,
1501 "%Kargument %i range [%E, %E] is negative",
1503 argrange[i][0], argrange[i][1]);
1505 else if (tree_int_cst_lt (maxobjsize, argrange[i][0]))
1507 warned = warning_at (loc, OPT_Walloc_size_larger_than_,
1508 "%Kargument %i range [%E, %E] exceeds "
1509 "maximum object size %E",
1511 argrange[i][0], argrange[i][1],
1520 /* For a two-argument alloc_size, validate the product of the two
1521 arguments if both of their values or ranges are known. */
1522 if (!warned && tree_fits_uhwi_p (argrange[0][0])
1523 && argrange[1][0] && tree_fits_uhwi_p (argrange[1][0])
1524 && !integer_onep (argrange[0][0])
1525 && !integer_onep (argrange[1][0]))
1527 /* Check for overflow in the product of a function decorated with
1528 attribute alloc_size (X, Y). */
1529 unsigned szprec = TYPE_PRECISION (size_type_node);
1530 wide_int x = wi::to_wide (argrange[0][0], szprec);
1531 wide_int y = wi::to_wide (argrange[1][0], szprec);
1534 wide_int prod = wi::umul (x, y, &vflow);
1537 warned = warning_at (loc, OPT_Walloc_size_larger_than_,
1538 "%Kproduct %<%E * %E%> of arguments %i and %i "
1539 "exceeds %<SIZE_MAX%>",
1540 exp, argrange[0][0], argrange[1][0],
1541 idx[0] + 1, idx[1] + 1);
1542 else if (wi::ltu_p (wi::to_wide (maxobjsize, szprec), prod))
1543 warned = warning_at (loc, OPT_Walloc_size_larger_than_,
1544 "%Kproduct %<%E * %E%> of arguments %i and %i "
1545 "exceeds maximum object size %E",
1546 exp, argrange[0][0], argrange[1][0],
1547 idx[0] + 1, idx[1] + 1,
1552 /* Print the full range of each of the two arguments to make
1553 it clear when it is, in fact, in a range and not constant. */
1554 if (argrange[0][0] != argrange [0][1])
1555 inform (loc, "argument %i in the range [%E, %E]",
1556 idx[0] + 1, argrange[0][0], argrange[0][1]);
1557 if (argrange[1][0] != argrange [1][1])
1558 inform (loc, "argument %i in the range [%E, %E]",
1559 idx[1] + 1, argrange[1][0], argrange[1][1]);
1565 location_t fnloc = DECL_SOURCE_LOCATION (fn);
1567 if (DECL_IS_BUILTIN (fn))
1569 "in a call to built-in allocation function %qD", fn);
1572 "in a call to allocation function %qD declared here", fn);
1576 /* If EXPR refers to a character array or pointer declared attribute
1577 nonstring return a decl for that array or pointer and set *REF to
1578 the referenced enclosing object or pointer. Otherwise returns
1582 get_attr_nonstring_decl (tree expr, tree *ref)
1585 if (TREE_CODE (decl) == SSA_NAME)
1587 gimple *def = SSA_NAME_DEF_STMT (decl);
1589 if (is_gimple_assign (def))
1591 tree_code code = gimple_assign_rhs_code (def);
1592 if (code == ADDR_EXPR
1593 || code == COMPONENT_REF
1594 || code == VAR_DECL)
1595 decl = gimple_assign_rhs1 (def);
1597 else if (tree var = SSA_NAME_VAR (decl))
1601 if (TREE_CODE (decl) == ADDR_EXPR)
1602 decl = TREE_OPERAND (decl, 0);
1607 if (TREE_CODE (decl) == ARRAY_REF)
1608 decl = TREE_OPERAND (decl, 0);
1609 else if (TREE_CODE (decl) == COMPONENT_REF)
1610 decl = TREE_OPERAND (decl, 1);
1611 else if (TREE_CODE (decl) == MEM_REF)
1612 return get_attr_nonstring_decl (TREE_OPERAND (decl, 0), ref);
1615 && lookup_attribute ("nonstring", DECL_ATTRIBUTES (decl)))
1621 /* Warn about passing a non-string array/pointer to a function that
1622 expects a nul-terminated string argument. */
1625 maybe_warn_nonstring_arg (tree fndecl, tree exp)
1627 if (!fndecl || DECL_BUILT_IN_CLASS (fndecl) != BUILT_IN_NORMAL)
1630 if (!warn_stringop_overflow)
1633 bool with_bounds = CALL_WITH_BOUNDS_P (exp);
1635 unsigned nargs = call_expr_nargs (exp);
1637 /* The bound argument to a bounded string function like strncpy. */
1638 tree bound = NULL_TREE;
1640 /* The range of lengths of a string argument to one of the comparison
1641 functions. If the length is less than the bound it is used instead. */
1642 tree lenrng[2] = { NULL_TREE, NULL_TREE };
1644 /* It's safe to call "bounded" string functions with a non-string
1645 argument since the functions provide an explicit bound for this
1646 purpose. The exception is strncat where the bound may refer to
1647 either the destination or the source. */
1648 int fncode = DECL_FUNCTION_CODE (fndecl);
1651 case BUILT_IN_STRCMP:
1652 case BUILT_IN_STRNCMP:
1653 case BUILT_IN_STRNCASECMP:
1655 /* For these, if one argument refers to one or more of a set
1656 of string constants or arrays of known size, determine
1657 the range of their known or possible lengths and use it
1658 conservatively as the bound for the unbounded function,
1659 and to adjust the range of the bound of the bounded ones. */
1660 unsigned stride = with_bounds ? 2 : 1;
1661 for (unsigned argno = 0;
1662 argno < MIN (nargs, 2 * stride)
1663 && !(lenrng[1] && TREE_CODE (lenrng[1]) == INTEGER_CST);
1666 tree arg = CALL_EXPR_ARG (exp, argno);
1667 if (!get_attr_nonstring_decl (arg))
1668 get_range_strlen (arg, lenrng);
1673 case BUILT_IN_STRNCAT:
1674 case BUILT_IN_STPNCPY:
1675 case BUILT_IN_STPNCPY_CHK:
1676 case BUILT_IN_STRNCPY:
1677 case BUILT_IN_STRNCPY_CHK:
1679 unsigned argno = with_bounds ? 4 : 2;
1681 bound = CALL_EXPR_ARG (exp, argno);
1685 case BUILT_IN_STRNDUP:
1687 unsigned argno = with_bounds ? 2 : 1;
1689 bound = CALL_EXPR_ARG (exp, argno);
1697 /* Determine the range of the bound argument (if specified). */
1698 tree bndrng[2] = { NULL_TREE, NULL_TREE };
1700 get_size_range (bound, bndrng);
1702 if (lenrng[1] && TREE_CODE (lenrng[1]) == INTEGER_CST)
1704 /* Add one for the nul. */
1705 lenrng[1] = const_binop (PLUS_EXPR, TREE_TYPE (lenrng[1]),
1706 lenrng[1], size_one_node);
1710 /* Conservatively use the upper bound of the lengths for
1711 both the lower and the upper bound of the operation. */
1712 bndrng[0] = lenrng[1];
1713 bndrng[1] = lenrng[1];
1714 bound = void_type_node;
1718 /* Replace the bound on the oparation with the upper bound
1719 of the length of the string if the latter is smaller. */
1720 if (tree_int_cst_lt (lenrng[1], bndrng[0]))
1721 bndrng[0] = lenrng[1];
1722 else if (tree_int_cst_lt (lenrng[1], bndrng[1]))
1723 bndrng[1] = lenrng[1];
1727 /* Iterate over the built-in function's formal arguments and check
1728 each const char* against the actual argument. If the actual
1729 argument is declared attribute non-string issue a warning unless
1730 the argument's maximum length is bounded. */
1731 function_args_iterator it;
1732 function_args_iter_init (&it, TREE_TYPE (fndecl));
1734 for (unsigned argno = 0; ; ++argno, function_args_iter_next (&it))
1736 /* Avoid iterating past the declared argument in a call
1737 to function declared without a prototype. */
1741 tree argtype = function_args_iter_cond (&it);
1745 if (TREE_CODE (argtype) != POINTER_TYPE)
1748 argtype = TREE_TYPE (argtype);
1750 if (TREE_CODE (argtype) != INTEGER_TYPE
1751 || !TYPE_READONLY (argtype))
1754 argtype = TYPE_MAIN_VARIANT (argtype);
1755 if (argtype != char_type_node)
1758 tree callarg = CALL_EXPR_ARG (exp, argno);
1759 if (TREE_CODE (callarg) == ADDR_EXPR)
1760 callarg = TREE_OPERAND (callarg, 0);
1762 /* See if the destination is declared with attribute "nonstring". */
1763 tree decl = get_attr_nonstring_decl (callarg);
1767 /* The maximum number of array elements accessed. */
1768 offset_int wibnd = 0;
1770 if (argno && fncode == BUILT_IN_STRNCAT)
1772 /* See if the bound in strncat is derived from the length
1773 of the strlen of the destination (as it's expected to be).
1774 If so, reset BOUND and FNCODE to trigger a warning. */
1775 tree dstarg = CALL_EXPR_ARG (exp, 0);
1776 if (is_strlen_related_p (dstarg, bound))
1778 /* The bound applies to the destination, not to the source,
1779 so reset these to trigger a warning without mentioning
1785 /* Use the upper bound of the range for strncat. */
1786 wibnd = wi::to_offset (bndrng[1]);
1789 /* Use the lower bound of the range for functions other than
1791 wibnd = wi::to_offset (bndrng[0]);
1793 /* Determine the size of the argument array if it is one. */
1794 offset_int asize = wibnd;
1795 bool known_size = false;
1796 tree type = TREE_TYPE (decl);
1798 /* Determine the array size. For arrays of unknown bound and
1799 pointers reset BOUND to trigger the appropriate warning. */
1800 if (TREE_CODE (type) == ARRAY_TYPE)
1802 if (tree arrbnd = TYPE_DOMAIN (type))
1804 if ((arrbnd = TYPE_MAX_VALUE (arrbnd)))
1806 asize = wi::to_offset (arrbnd) + 1;
1810 else if (bound == void_type_node)
1813 else if (bound == void_type_node)
1816 location_t loc = EXPR_LOCATION (exp);
1818 /* In a call to strncat with a bound in a range whose lower but
1819 not upper bound is less than the array size, reset ASIZE to
1820 be the same as the bound and the other variable to trigger
1821 the apprpriate warning below. */
1822 if (fncode == BUILT_IN_STRNCAT
1823 && bndrng[0] != bndrng[1]
1824 && wi::ltu_p (wi::to_offset (bndrng[0]), asize)
1826 || wi::ltu_p (asize, wibnd)))
1833 bool warned = false;
1835 if (wi::ltu_p (asize, wibnd))
1837 if (bndrng[0] == bndrng[1])
1838 warned = warning_at (loc, OPT_Wstringop_overflow_,
1839 "%qD argument %i declared attribute "
1840 "%<nonstring%> is smaller than the specified "
1842 fndecl, argno + 1, wibnd.to_uhwi ());
1843 else if (wi::ltu_p (asize, wi::to_offset (bndrng[0])))
1844 warned = warning_at (loc, OPT_Wstringop_overflow_,
1845 "%qD argument %i declared attribute "
1846 "%<nonstring%> is smaller than "
1847 "the specified bound [%E, %E]",
1848 fndecl, argno + 1, bndrng[0], bndrng[1]);
1850 warned = warning_at (loc, OPT_Wstringop_overflow_,
1851 "%qD argument %i declared attribute "
1852 "%<nonstring%> may be smaller than "
1853 "the specified bound [%E, %E]",
1854 fndecl, argno + 1, bndrng[0], bndrng[1]);
1856 else if (fncode == BUILT_IN_STRNCAT)
1857 ; /* Avoid warning for calls to strncat() when the bound
1858 is equal to the size of the non-string argument. */
1860 warned = warning_at (loc, OPT_Wstringop_overflow_,
1861 "%qD argument %i declared attribute %<nonstring%>",
1865 inform (DECL_SOURCE_LOCATION (decl),
1866 "argument %qD declared here", decl);
1870 /* Issue an error if CALL_EXPR was flagged as requiring
1871 tall-call optimization. */
1874 maybe_complain_about_tail_call (tree call_expr, const char *reason)
1876 gcc_assert (TREE_CODE (call_expr) == CALL_EXPR);
1877 if (!CALL_EXPR_MUST_TAIL_CALL (call_expr))
1880 error_at (EXPR_LOCATION (call_expr), "cannot tail-call: %s", reason);
1883 /* Fill in ARGS_SIZE and ARGS array based on the parameters found in
1886 NUM_ACTUALS is the total number of parameters.
1888 N_NAMED_ARGS is the total number of named arguments.
1890 STRUCT_VALUE_ADDR_VALUE is the implicit argument for a struct return
1893 FNDECL is the tree code for the target of this call (if known)
1895 ARGS_SO_FAR holds state needed by the target to know where to place
1898 REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
1899 for arguments which are passed in registers.
1901 OLD_STACK_LEVEL is a pointer to an rtx which olds the old stack level
1902 and may be modified by this routine.
1904 OLD_PENDING_ADJ, MUST_PREALLOCATE and FLAGS are pointers to integer
1905 flags which may be modified by this routine.
1907 MAY_TAILCALL is cleared if we encounter an invisible pass-by-reference
1908 that requires allocation of stack space.
1910 CALL_FROM_THUNK_P is true if this call is the jump from a thunk to
1911 the thunked-to function. */
1914 initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
1915 struct arg_data *args,
1916 struct args_size *args_size,
1917 int n_named_args ATTRIBUTE_UNUSED,
1918 tree exp, tree struct_value_addr_value,
1919 tree fndecl, tree fntype,
1920 cumulative_args_t args_so_far,
1921 int reg_parm_stack_space,
1922 rtx *old_stack_level,
1923 poly_int64_pod *old_pending_adj,
1924 int *must_preallocate, int *ecf_flags,
1925 bool *may_tailcall, bool call_from_thunk_p)
1927 CUMULATIVE_ARGS *args_so_far_pnt = get_cumulative_args (args_so_far);
1928 location_t loc = EXPR_LOCATION (exp);
1930 /* Count arg position in order args appear. */
1935 args_size->constant = 0;
1938 bitmap_obstack_initialize (NULL);
1940 /* In this loop, we consider args in the order they are written.
1941 We fill up ARGS from the back. */
1943 i = num_actuals - 1;
1945 int j = i, ptr_arg = -1;
1946 call_expr_arg_iterator iter;
1948 bitmap slots = NULL;
1950 if (struct_value_addr_value)
1952 args[j].tree_value = struct_value_addr_value;
1955 /* If we pass structure address then we need to
1956 create bounds for it. Since created bounds is
1957 a call statement, we expand it right here to avoid
1958 fixing all other places where it may be expanded. */
1959 if (CALL_WITH_BOUNDS_P (exp))
1961 args[j].value = gen_reg_rtx (targetm.chkp_bound_mode ());
1963 = chkp_make_bounds_for_struct_addr (struct_value_addr_value);
1964 expand_expr_real (args[j].tree_value, args[j].value, VOIDmode,
1965 EXPAND_NORMAL, 0, false);
1966 args[j].pointer_arg = j + 1;
1971 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
1973 tree argtype = TREE_TYPE (arg);
1975 /* Remember last param with pointer and associate it
1976 with following pointer bounds. */
1977 if (CALL_WITH_BOUNDS_P (exp)
1978 && chkp_type_has_pointer (argtype))
1981 BITMAP_FREE (slots);
1983 if (!BOUNDED_TYPE_P (argtype))
1985 slots = BITMAP_ALLOC (NULL);
1986 chkp_find_bound_slots (argtype, slots);
1989 else if (CALL_WITH_BOUNDS_P (exp)
1990 && pass_by_reference (NULL, TYPE_MODE (argtype), argtype,
1991 argpos < n_named_args))
1994 BITMAP_FREE (slots);
1997 else if (POINTER_BOUNDS_TYPE_P (argtype))
1999 /* We expect bounds in instrumented calls only.
2000 Otherwise it is a sign we lost flag due to some optimization
2001 and may emit call args incorrectly. */
2002 gcc_assert (CALL_WITH_BOUNDS_P (exp));
2004 /* For structures look for the next available pointer. */
2005 if (ptr_arg != -1 && slots)
2007 unsigned bnd_no = bitmap_first_set_bit (slots);
2008 args[j].pointer_offset =
2009 bnd_no * POINTER_SIZE / BITS_PER_UNIT;
2011 bitmap_clear_bit (slots, bnd_no);
2013 /* Check we have no more pointers in the structure. */
2014 if (bitmap_empty_p (slots))
2015 BITMAP_FREE (slots);
2017 args[j].pointer_arg = ptr_arg;
2019 /* Check we covered all pointers in the previous
2027 if (targetm.calls.split_complex_arg
2029 && TREE_CODE (argtype) == COMPLEX_TYPE
2030 && targetm.calls.split_complex_arg (argtype))
2032 tree subtype = TREE_TYPE (argtype);
2033 args[j].tree_value = build1 (REALPART_EXPR, subtype, arg);
2035 args[j].tree_value = build1 (IMAGPART_EXPR, subtype, arg);
2038 args[j].tree_value = arg;
2044 BITMAP_FREE (slots);
2047 bitmap_obstack_release (NULL);
2049 /* Extract attribute alloc_size and if set, store the indices of
2050 the corresponding arguments in ALLOC_IDX, and then the actual
2051 argument(s) at those indices in ALLOC_ARGS. */
2052 int alloc_idx[2] = { -1, -1 };
2054 = (fndecl ? lookup_attribute ("alloc_size",
2055 TYPE_ATTRIBUTES (TREE_TYPE (fndecl)))
2058 tree args = TREE_VALUE (alloc_size);
2059 alloc_idx[0] = TREE_INT_CST_LOW (TREE_VALUE (args)) - 1;
2060 if (TREE_CHAIN (args))
2061 alloc_idx[1] = TREE_INT_CST_LOW (TREE_VALUE (TREE_CHAIN (args))) - 1;
2064 /* Array for up to the two attribute alloc_size arguments. */
2065 tree alloc_args[] = { NULL_TREE, NULL_TREE };
2067 /* I counts args in order (to be) pushed; ARGPOS counts in order written. */
2068 for (argpos = 0; argpos < num_actuals; i--, argpos++)
2070 tree type = TREE_TYPE (args[i].tree_value);
2074 /* Replace erroneous argument with constant zero. */
2075 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
2076 args[i].tree_value = integer_zero_node, type = integer_type_node;
2078 /* If TYPE is a transparent union or record, pass things the way
2079 we would pass the first field of the union or record. We have
2080 already verified that the modes are the same. */
2081 if ((TREE_CODE (type) == UNION_TYPE || TREE_CODE (type) == RECORD_TYPE)
2082 && TYPE_TRANSPARENT_AGGR (type))
2083 type = TREE_TYPE (first_field (type));
2085 /* Decide where to pass this arg.
2087 args[i].reg is nonzero if all or part is passed in registers.
2089 args[i].partial is nonzero if part but not all is passed in registers,
2090 and the exact value says how many bytes are passed in registers.
2092 args[i].pass_on_stack is nonzero if the argument must at least be
2093 computed on the stack. It may then be loaded back into registers
2094 if args[i].reg is nonzero.
2096 These decisions are driven by the FUNCTION_... macros and must agree
2097 with those made by function.c. */
2099 /* See if this argument should be passed by invisible reference. */
2100 if (pass_by_reference (args_so_far_pnt, TYPE_MODE (type),
2101 type, argpos < n_named_args))
2104 tree base = NULL_TREE;
2107 = reference_callee_copied (args_so_far_pnt, TYPE_MODE (type),
2108 type, argpos < n_named_args);
2110 /* If we're compiling a thunk, pass through invisible references
2111 instead of making a copy. */
2112 if (call_from_thunk_p
2114 && !TREE_ADDRESSABLE (type)
2115 && (base = get_base_address (args[i].tree_value))
2116 && TREE_CODE (base) != SSA_NAME
2117 && (!DECL_P (base) || MEM_P (DECL_RTL (base)))))
2119 /* We may have turned the parameter value into an SSA name.
2120 Go back to the original parameter so we can take the
2122 if (TREE_CODE (args[i].tree_value) == SSA_NAME)
2124 gcc_assert (SSA_NAME_IS_DEFAULT_DEF (args[i].tree_value));
2125 args[i].tree_value = SSA_NAME_VAR (args[i].tree_value);
2126 gcc_assert (TREE_CODE (args[i].tree_value) == PARM_DECL);
2128 /* Argument setup code may have copied the value to register. We
2129 revert that optimization now because the tail call code must
2130 use the original location. */
2131 if (TREE_CODE (args[i].tree_value) == PARM_DECL
2132 && !MEM_P (DECL_RTL (args[i].tree_value))
2133 && DECL_INCOMING_RTL (args[i].tree_value)
2134 && MEM_P (DECL_INCOMING_RTL (args[i].tree_value)))
2135 set_decl_rtl (args[i].tree_value,
2136 DECL_INCOMING_RTL (args[i].tree_value));
2138 mark_addressable (args[i].tree_value);
2140 /* We can't use sibcalls if a callee-copied argument is
2141 stored in the current function's frame. */
2142 if (!call_from_thunk_p && DECL_P (base) && !TREE_STATIC (base))
2144 *may_tailcall = false;
2145 maybe_complain_about_tail_call (exp,
2146 "a callee-copied argument is"
2147 " stored in the current"
2148 " function's frame");
2151 args[i].tree_value = build_fold_addr_expr_loc (loc,
2152 args[i].tree_value);
2153 type = TREE_TYPE (args[i].tree_value);
2155 if (*ecf_flags & ECF_CONST)
2156 *ecf_flags &= ~(ECF_CONST | ECF_LOOPING_CONST_OR_PURE);
2160 /* We make a copy of the object and pass the address to the
2161 function being called. */
2164 if (!COMPLETE_TYPE_P (type)
2165 || TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST
2166 || (flag_stack_check == GENERIC_STACK_CHECK
2167 && compare_tree_int (TYPE_SIZE_UNIT (type),
2168 STACK_CHECK_MAX_VAR_SIZE) > 0))
2170 /* This is a variable-sized object. Make space on the stack
2172 rtx size_rtx = expr_size (args[i].tree_value);
2174 if (*old_stack_level == 0)
2176 emit_stack_save (SAVE_BLOCK, old_stack_level);
2177 *old_pending_adj = pending_stack_adjust;
2178 pending_stack_adjust = 0;
2181 /* We can pass TRUE as the 4th argument because we just
2182 saved the stack pointer and will restore it right after
2184 copy = allocate_dynamic_stack_space (size_rtx,
2187 max_int_size_in_bytes
2190 copy = gen_rtx_MEM (BLKmode, copy);
2191 set_mem_attributes (copy, type, 1);
2194 copy = assign_temp (type, 1, 0);
2196 store_expr (args[i].tree_value, copy, 0, false, false);
2198 /* Just change the const function to pure and then let
2199 the next test clear the pure based on
2201 if (*ecf_flags & ECF_CONST)
2203 *ecf_flags &= ~ECF_CONST;
2204 *ecf_flags |= ECF_PURE;
2207 if (!callee_copies && *ecf_flags & ECF_PURE)
2208 *ecf_flags &= ~(ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
2211 = build_fold_addr_expr_loc (loc, make_tree (type, copy));
2212 type = TREE_TYPE (args[i].tree_value);
2213 *may_tailcall = false;
2214 maybe_complain_about_tail_call (exp,
2215 "argument must be passed"
2220 unsignedp = TYPE_UNSIGNED (type);
2221 mode = promote_function_mode (type, TYPE_MODE (type), &unsignedp,
2222 fndecl ? TREE_TYPE (fndecl) : fntype, 0);
2224 args[i].unsignedp = unsignedp;
2225 args[i].mode = mode;
2227 targetm.calls.warn_parameter_passing_abi (args_so_far, type);
2229 args[i].reg = targetm.calls.function_arg (args_so_far, mode, type,
2230 argpos < n_named_args);
2232 if (args[i].reg && CONST_INT_P (args[i].reg))
2234 args[i].special_slot = args[i].reg;
2238 /* If this is a sibling call and the machine has register windows, the
2239 register window has to be unwinded before calling the routine, so
2240 arguments have to go into the incoming registers. */
2241 if (targetm.calls.function_incoming_arg != targetm.calls.function_arg)
2242 args[i].tail_call_reg
2243 = targetm.calls.function_incoming_arg (args_so_far, mode, type,
2244 argpos < n_named_args);
2246 args[i].tail_call_reg = args[i].reg;
2250 = targetm.calls.arg_partial_bytes (args_so_far, mode, type,
2251 argpos < n_named_args);
2253 args[i].pass_on_stack = targetm.calls.must_pass_in_stack (mode, type);
2255 /* If FUNCTION_ARG returned a (parallel [(expr_list (nil) ...) ...]),
2256 it means that we are to pass this arg in the register(s) designated
2257 by the PARALLEL, but also to pass it in the stack. */
2258 if (args[i].reg && GET_CODE (args[i].reg) == PARALLEL
2259 && XEXP (XVECEXP (args[i].reg, 0, 0), 0) == 0)
2260 args[i].pass_on_stack = 1;
2262 /* If this is an addressable type, we must preallocate the stack
2263 since we must evaluate the object into its final location.
2265 If this is to be passed in both registers and the stack, it is simpler
2267 if (TREE_ADDRESSABLE (type)
2268 || (args[i].pass_on_stack && args[i].reg != 0))
2269 *must_preallocate = 1;
2271 /* No stack allocation and padding for bounds. */
2272 if (POINTER_BOUNDS_P (args[i].tree_value))
2274 /* Compute the stack-size of this argument. */
2275 else if (args[i].reg == 0 || args[i].partial != 0
2276 || reg_parm_stack_space > 0
2277 || args[i].pass_on_stack)
2278 locate_and_pad_parm (mode, type,
2279 #ifdef STACK_PARMS_IN_REG_PARM_AREA
2284 reg_parm_stack_space,
2285 args[i].pass_on_stack ? 0 : args[i].partial,
2286 fndecl, args_size, &args[i].locate);
2287 #ifdef BLOCK_REG_PADDING
2289 /* The argument is passed entirely in registers. See at which
2290 end it should be padded. */
2291 args[i].locate.where_pad =
2292 BLOCK_REG_PADDING (mode, type,
2293 int_size_in_bytes (type) <= UNITS_PER_WORD);
2296 /* Update ARGS_SIZE, the total stack space for args so far. */
2298 args_size->constant += args[i].locate.size.constant;
2299 if (args[i].locate.size.var)
2300 ADD_PARM_SIZE (*args_size, args[i].locate.size.var);
2302 /* Increment ARGS_SO_FAR, which has info about which arg-registers
2303 have been used, etc. */
2305 targetm.calls.function_arg_advance (args_so_far, TYPE_MODE (type),
2306 type, argpos < n_named_args);
2308 /* Store argument values for functions decorated with attribute
2310 if (argpos == alloc_idx[0])
2311 alloc_args[0] = args[i].tree_value;
2312 else if (argpos == alloc_idx[1])
2313 alloc_args[1] = args[i].tree_value;
2318 /* Check the arguments of functions decorated with attribute
2320 maybe_warn_alloc_args_overflow (fndecl, exp, alloc_args, alloc_idx);
2323 /* Detect passing non-string arguments to functions expecting
2324 nul-terminated strings. */
2325 maybe_warn_nonstring_arg (fndecl, exp);
2328 /* Update ARGS_SIZE to contain the total size for the argument block.
2329 Return the original constant component of the argument block's size.
2331 REG_PARM_STACK_SPACE holds the number of bytes of stack space reserved
2332 for arguments passed in registers. */
2335 compute_argument_block_size (int reg_parm_stack_space,
2336 struct args_size *args_size,
2337 tree fndecl ATTRIBUTE_UNUSED,
2338 tree fntype ATTRIBUTE_UNUSED,
2339 int preferred_stack_boundary ATTRIBUTE_UNUSED)
2341 poly_int64 unadjusted_args_size = args_size->constant;
2343 /* For accumulate outgoing args mode we don't need to align, since the frame
2344 will be already aligned. Align to STACK_BOUNDARY in order to prevent
2345 backends from generating misaligned frame sizes. */
2346 if (ACCUMULATE_OUTGOING_ARGS && preferred_stack_boundary > STACK_BOUNDARY)
2347 preferred_stack_boundary = STACK_BOUNDARY;
2349 /* Compute the actual size of the argument block required. The variable
2350 and constant sizes must be combined, the size may have to be rounded,
2351 and there may be a minimum required size. */
2355 args_size->var = ARGS_SIZE_TREE (*args_size);
2356 args_size->constant = 0;
2358 preferred_stack_boundary /= BITS_PER_UNIT;
2359 if (preferred_stack_boundary > 1)
2361 /* We don't handle this case yet. To handle it correctly we have
2362 to add the delta, round and subtract the delta.
2363 Currently no machine description requires this support. */
2364 gcc_assert (multiple_p (stack_pointer_delta,
2365 preferred_stack_boundary));
2366 args_size->var = round_up (args_size->var, preferred_stack_boundary);
2369 if (reg_parm_stack_space > 0)
2372 = size_binop (MAX_EXPR, args_size->var,
2373 ssize_int (reg_parm_stack_space));
2375 /* The area corresponding to register parameters is not to count in
2376 the size of the block we need. So make the adjustment. */
2377 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
2379 = size_binop (MINUS_EXPR, args_size->var,
2380 ssize_int (reg_parm_stack_space));
2385 preferred_stack_boundary /= BITS_PER_UNIT;
2386 if (preferred_stack_boundary < 1)
2387 preferred_stack_boundary = 1;
2388 args_size->constant = (aligned_upper_bound (args_size->constant
2389 + stack_pointer_delta,
2390 preferred_stack_boundary)
2391 - stack_pointer_delta);
2393 args_size->constant = upper_bound (args_size->constant,
2394 reg_parm_stack_space);
2396 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
2397 args_size->constant -= reg_parm_stack_space;
2399 return unadjusted_args_size;
2402 /* Precompute parameters as needed for a function call.
2404 FLAGS is mask of ECF_* constants.
2406 NUM_ACTUALS is the number of arguments.
2408 ARGS is an array containing information for each argument; this
2409 routine fills in the INITIAL_VALUE and VALUE fields for each
2410 precomputed argument. */
2413 precompute_arguments (int num_actuals, struct arg_data *args)
2417 /* If this is a libcall, then precompute all arguments so that we do not
2418 get extraneous instructions emitted as part of the libcall sequence. */
2420 /* If we preallocated the stack space, and some arguments must be passed
2421 on the stack, then we must precompute any parameter which contains a
2422 function call which will store arguments on the stack.
2423 Otherwise, evaluating the parameter may clobber previous parameters
2424 which have already been stored into the stack. (we have code to avoid
2425 such case by saving the outgoing stack arguments, but it results in
2427 if (!ACCUMULATE_OUTGOING_ARGS)
2430 for (i = 0; i < num_actuals; i++)
2435 if (TREE_CODE (args[i].tree_value) != CALL_EXPR)
2438 /* If this is an addressable type, we cannot pre-evaluate it. */
2439 type = TREE_TYPE (args[i].tree_value);
2440 gcc_assert (!TREE_ADDRESSABLE (type));
2442 args[i].initial_value = args[i].value
2443 = expand_normal (args[i].tree_value);
2445 mode = TYPE_MODE (type);
2446 if (mode != args[i].mode)
2448 int unsignedp = args[i].unsignedp;
2450 = convert_modes (args[i].mode, mode,
2451 args[i].value, args[i].unsignedp);
2453 /* CSE will replace this only if it contains args[i].value
2454 pseudo, so convert it down to the declared mode using
2456 if (REG_P (args[i].value)
2457 && GET_MODE_CLASS (args[i].mode) == MODE_INT
2458 && promote_mode (type, mode, &unsignedp) != args[i].mode)
2460 args[i].initial_value
2461 = gen_lowpart_SUBREG (mode, args[i].value);
2462 SUBREG_PROMOTED_VAR_P (args[i].initial_value) = 1;
2463 SUBREG_PROMOTED_SET (args[i].initial_value, args[i].unsignedp);
2469 /* Given the current state of MUST_PREALLOCATE and information about
2470 arguments to a function call in NUM_ACTUALS, ARGS and ARGS_SIZE,
2471 compute and return the final value for MUST_PREALLOCATE. */
2474 finalize_must_preallocate (int must_preallocate, int num_actuals,
2475 struct arg_data *args, struct args_size *args_size)
2477 /* See if we have or want to preallocate stack space.
2479 If we would have to push a partially-in-regs parm
2480 before other stack parms, preallocate stack space instead.
2482 If the size of some parm is not a multiple of the required stack
2483 alignment, we must preallocate.
2485 If the total size of arguments that would otherwise create a copy in
2486 a temporary (such as a CALL) is more than half the total argument list
2487 size, preallocation is faster.
2489 Another reason to preallocate is if we have a machine (like the m88k)
2490 where stack alignment is required to be maintained between every
2491 pair of insns, not just when the call is made. However, we assume here
2492 that such machines either do not have push insns (and hence preallocation
2493 would occur anyway) or the problem is taken care of with
2496 if (! must_preallocate)
2498 int partial_seen = 0;
2499 poly_int64 copy_to_evaluate_size = 0;
2502 for (i = 0; i < num_actuals && ! must_preallocate; i++)
2504 if (args[i].partial > 0 && ! args[i].pass_on_stack)
2506 else if (partial_seen && args[i].reg == 0)
2507 must_preallocate = 1;
2508 /* We preallocate in case there are bounds passed
2509 in the bounds table to have precomputed address
2510 for bounds association. */
2511 else if (POINTER_BOUNDS_P (args[i].tree_value)
2513 must_preallocate = 1;
2515 if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
2516 && (TREE_CODE (args[i].tree_value) == CALL_EXPR
2517 || TREE_CODE (args[i].tree_value) == TARGET_EXPR
2518 || TREE_CODE (args[i].tree_value) == COND_EXPR
2519 || TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value))))
2520 copy_to_evaluate_size
2521 += int_size_in_bytes (TREE_TYPE (args[i].tree_value));
2524 if (maybe_ne (args_size->constant, 0)
2525 && maybe_ge (copy_to_evaluate_size * 2, args_size->constant))
2526 must_preallocate = 1;
2528 return must_preallocate;
2531 /* If we preallocated stack space, compute the address of each argument
2532 and store it into the ARGS array.
2534 We need not ensure it is a valid memory address here; it will be
2535 validized when it is used.
2537 ARGBLOCK is an rtx for the address of the outgoing arguments. */
2540 compute_argument_addresses (struct arg_data *args, rtx argblock, int num_actuals)
2544 rtx arg_reg = argblock;
2546 poly_int64 arg_offset = 0;
2548 if (GET_CODE (argblock) == PLUS)
2550 arg_reg = XEXP (argblock, 0);
2551 arg_offset = rtx_to_poly_int64 (XEXP (argblock, 1));
2554 for (i = 0; i < num_actuals; i++)
2556 rtx offset = ARGS_SIZE_RTX (args[i].locate.offset);
2557 rtx slot_offset = ARGS_SIZE_RTX (args[i].locate.slot_offset);
2559 unsigned int align, boundary;
2560 poly_uint64 units_on_stack = 0;
2561 machine_mode partial_mode = VOIDmode;
2563 /* Skip this parm if it will not be passed on the stack. */
2564 if (! args[i].pass_on_stack
2566 && args[i].partial == 0)
2569 if (TYPE_EMPTY_P (TREE_TYPE (args[i].tree_value)))
2572 /* Pointer Bounds are never passed on the stack. */
2573 if (POINTER_BOUNDS_P (args[i].tree_value))
2576 addr = simplify_gen_binary (PLUS, Pmode, arg_reg, offset);
2577 addr = plus_constant (Pmode, addr, arg_offset);
2579 if (args[i].partial != 0)
2581 /* Only part of the parameter is being passed on the stack.
2582 Generate a simple memory reference of the correct size. */
2583 units_on_stack = args[i].locate.size.constant;
2584 poly_uint64 bits_on_stack = units_on_stack * BITS_PER_UNIT;
2585 partial_mode = int_mode_for_size (bits_on_stack, 1).else_blk ();
2586 args[i].stack = gen_rtx_MEM (partial_mode, addr);
2587 set_mem_size (args[i].stack, units_on_stack);
2591 args[i].stack = gen_rtx_MEM (args[i].mode, addr);
2592 set_mem_attributes (args[i].stack,
2593 TREE_TYPE (args[i].tree_value), 1);
2595 align = BITS_PER_UNIT;
2596 boundary = args[i].locate.boundary;
2597 poly_int64 offset_val;
2598 if (args[i].locate.where_pad != PAD_DOWNWARD)
2600 else if (poly_int_rtx_p (offset, &offset_val))
2602 align = least_bit_hwi (boundary);
2603 unsigned int offset_align
2604 = known_alignment (offset_val) * BITS_PER_UNIT;
2605 if (offset_align != 0)
2606 align = MIN (align, offset_align);
2608 set_mem_align (args[i].stack, align);
2610 addr = simplify_gen_binary (PLUS, Pmode, arg_reg, slot_offset);
2611 addr = plus_constant (Pmode, addr, arg_offset);
2613 if (args[i].partial != 0)
2615 /* Only part of the parameter is being passed on the stack.
2616 Generate a simple memory reference of the correct size.
2618 args[i].stack_slot = gen_rtx_MEM (partial_mode, addr);
2619 set_mem_size (args[i].stack_slot, units_on_stack);
2623 args[i].stack_slot = gen_rtx_MEM (args[i].mode, addr);
2624 set_mem_attributes (args[i].stack_slot,
2625 TREE_TYPE (args[i].tree_value), 1);
2627 set_mem_align (args[i].stack_slot, args[i].locate.boundary);
2629 /* Function incoming arguments may overlap with sibling call
2630 outgoing arguments and we cannot allow reordering of reads
2631 from function arguments with stores to outgoing arguments
2632 of sibling calls. */
2633 set_mem_alias_set (args[i].stack, 0);
2634 set_mem_alias_set (args[i].stack_slot, 0);
2639 /* Given a FNDECL and EXP, return an rtx suitable for use as a target address
2640 in a call instruction.
2642 FNDECL is the tree node for the target function. For an indirect call
2643 FNDECL will be NULL_TREE.
2645 ADDR is the operand 0 of CALL_EXPR for this call. */
2648 rtx_for_function_call (tree fndecl, tree addr)
2652 /* Get the function to call, in the form of RTL. */
2655 if (!TREE_USED (fndecl) && fndecl != current_function_decl)
2656 TREE_USED (fndecl) = 1;
2658 /* Get a SYMBOL_REF rtx for the function address. */
2659 funexp = XEXP (DECL_RTL (fndecl), 0);
2662 /* Generate an rtx (probably a pseudo-register) for the address. */
2665 funexp = expand_normal (addr);
2666 pop_temp_slots (); /* FUNEXP can't be BLKmode. */
2671 /* Return the static chain for this function, if any. */
2674 rtx_for_static_chain (const_tree fndecl_or_type, bool incoming_p)
2676 if (DECL_P (fndecl_or_type) && !DECL_STATIC_CHAIN (fndecl_or_type))
2679 return targetm.calls.static_chain (fndecl_or_type, incoming_p);
2682 /* Internal state for internal_arg_pointer_based_exp and its helpers. */
2685 /* Last insn that has been scanned by internal_arg_pointer_based_exp_scan,
2686 or NULL_RTX if none has been scanned yet. */
2687 rtx_insn *scan_start;
2688 /* Vector indexed by REGNO - FIRST_PSEUDO_REGISTER, recording if a pseudo is
2689 based on crtl->args.internal_arg_pointer. The element is NULL_RTX if the
2690 pseudo isn't based on it, a CONST_INT offset if the pseudo is based on it
2691 with fixed offset, or PC if this is with variable or unknown offset. */
2693 } internal_arg_pointer_exp_state;
2695 static rtx internal_arg_pointer_based_exp (const_rtx, bool);
2697 /* Helper function for internal_arg_pointer_based_exp. Scan insns in
2698 the tail call sequence, starting with first insn that hasn't been
2699 scanned yet, and note for each pseudo on the LHS whether it is based
2700 on crtl->args.internal_arg_pointer or not, and what offset from that
2701 that pointer it has. */
2704 internal_arg_pointer_based_exp_scan (void)
2706 rtx_insn *insn, *scan_start = internal_arg_pointer_exp_state.scan_start;
2708 if (scan_start == NULL_RTX)
2709 insn = get_insns ();
2711 insn = NEXT_INSN (scan_start);
2715 rtx set = single_set (insn);
2716 if (set && REG_P (SET_DEST (set)) && !HARD_REGISTER_P (SET_DEST (set)))
2719 unsigned int idx = REGNO (SET_DEST (set)) - FIRST_PSEUDO_REGISTER;
2720 /* Punt on pseudos set multiple times. */
2721 if (idx < internal_arg_pointer_exp_state.cache.length ()
2722 && (internal_arg_pointer_exp_state.cache[idx]
2726 val = internal_arg_pointer_based_exp (SET_SRC (set), false);
2727 if (val != NULL_RTX)
2729 if (idx >= internal_arg_pointer_exp_state.cache.length ())
2730 internal_arg_pointer_exp_state.cache
2731 .safe_grow_cleared (idx + 1);
2732 internal_arg_pointer_exp_state.cache[idx] = val;
2735 if (NEXT_INSN (insn) == NULL_RTX)
2737 insn = NEXT_INSN (insn);
2740 internal_arg_pointer_exp_state.scan_start = scan_start;
2743 /* Compute whether RTL is based on crtl->args.internal_arg_pointer. Return
2744 NULL_RTX if RTL isn't based on it, a CONST_INT offset if RTL is based on
2745 it with fixed offset, or PC if this is with variable or unknown offset.
2746 TOPLEVEL is true if the function is invoked at the topmost level. */
2749 internal_arg_pointer_based_exp (const_rtx rtl, bool toplevel)
2751 if (CONSTANT_P (rtl))
2754 if (rtl == crtl->args.internal_arg_pointer)
2757 if (REG_P (rtl) && HARD_REGISTER_P (rtl))
2761 if (GET_CODE (rtl) == PLUS && poly_int_rtx_p (XEXP (rtl, 1), &offset))
2763 rtx val = internal_arg_pointer_based_exp (XEXP (rtl, 0), toplevel);
2764 if (val == NULL_RTX || val == pc_rtx)
2766 return plus_constant (Pmode, val, offset);
2769 /* When called at the topmost level, scan pseudo assignments in between the
2770 last scanned instruction in the tail call sequence and the latest insn
2771 in that sequence. */
2773 internal_arg_pointer_based_exp_scan ();
2777 unsigned int idx = REGNO (rtl) - FIRST_PSEUDO_REGISTER;
2778 if (idx < internal_arg_pointer_exp_state.cache.length ())
2779 return internal_arg_pointer_exp_state.cache[idx];
2784 subrtx_iterator::array_type array;
2785 FOR_EACH_SUBRTX (iter, array, rtl, NONCONST)
2787 const_rtx x = *iter;
2788 if (REG_P (x) && internal_arg_pointer_based_exp (x, false) != NULL_RTX)
2791 iter.skip_subrtxes ();
2797 /* Return true if SIZE bytes starting from address ADDR might overlap an
2798 already-clobbered argument area. This function is used to determine
2799 if we should give up a sibcall. */
2802 mem_might_overlap_already_clobbered_arg_p (rtx addr, poly_uint64 size)
2805 unsigned HOST_WIDE_INT start, end;
2808 if (bitmap_empty_p (stored_args_map)
2809 && stored_args_watermark == HOST_WIDE_INT_M1U)
2811 val = internal_arg_pointer_based_exp (addr, true);
2812 if (val == NULL_RTX)
2814 else if (!poly_int_rtx_p (val, &i))
2817 if (known_eq (size, 0U))
2820 if (STACK_GROWS_DOWNWARD)
2821 i -= crtl->args.pretend_args_size;
2823 i += crtl->args.pretend_args_size;
2825 if (ARGS_GROW_DOWNWARD)
2828 /* We can ignore any references to the function's pretend args,
2829 which at this point would manifest as negative values of I. */
2830 if (known_le (i, 0) && known_le (size, poly_uint64 (-i)))
2833 start = maybe_lt (i, 0) ? 0 : constant_lower_bound (i);
2834 if (!(i + size).is_constant (&end))
2835 end = HOST_WIDE_INT_M1U;
2837 if (end > stored_args_watermark)
2840 end = MIN (end, SBITMAP_SIZE (stored_args_map));
2841 for (unsigned HOST_WIDE_INT k = start; k < end; ++k)
2842 if (bitmap_bit_p (stored_args_map, k))
2848 /* Do the register loads required for any wholly-register parms or any
2849 parms which are passed both on the stack and in a register. Their
2850 expressions were already evaluated.
2852 Mark all register-parms as living through the call, putting these USE
2853 insns in the CALL_INSN_FUNCTION_USAGE field.
2855 When IS_SIBCALL, perform the check_sibcall_argument_overlap
2856 checking, setting *SIBCALL_FAILURE if appropriate. */
2859 load_register_parameters (struct arg_data *args, int num_actuals,
2860 rtx *call_fusage, int flags, int is_sibcall,
2861 int *sibcall_failure)
2865 for (i = 0; i < num_actuals; i++)
2867 rtx reg = ((flags & ECF_SIBCALL)
2868 ? args[i].tail_call_reg : args[i].reg);
2871 int partial = args[i].partial;
2873 poly_int64 size = 0;
2874 HOST_WIDE_INT const_size = 0;
2875 rtx_insn *before_arg = get_last_insn ();
2876 /* Set non-negative if we must move a word at a time, even if
2877 just one word (e.g, partial == 4 && mode == DFmode). Set
2878 to -1 if we just use a normal move insn. This value can be
2879 zero if the argument is a zero size structure. */
2881 if (GET_CODE (reg) == PARALLEL)
2885 gcc_assert (partial % UNITS_PER_WORD == 0);
2886 nregs = partial / UNITS_PER_WORD;
2888 else if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode)
2890 /* Variable-sized parameters should be described by a
2891 PARALLEL instead. */
2892 const_size = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
2893 gcc_assert (const_size >= 0);
2894 nregs = (const_size + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
2898 size = GET_MODE_SIZE (args[i].mode);
2900 /* Handle calls that pass values in multiple non-contiguous
2901 locations. The Irix 6 ABI has examples of this. */
2903 if (GET_CODE (reg) == PARALLEL)
2904 emit_group_move (reg, args[i].parallel_value);
2906 /* If simple case, just do move. If normal partial, store_one_arg
2907 has already loaded the register for us. In all other cases,
2908 load the register(s) from memory. */
2910 else if (nregs == -1)
2912 emit_move_insn (reg, args[i].value);
2913 #ifdef BLOCK_REG_PADDING
2914 /* Handle case where we have a value that needs shifting
2915 up to the msb. eg. a QImode value and we're padding
2916 upward on a BYTES_BIG_ENDIAN machine. */
2917 if (args[i].locate.where_pad
2918 == (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD))
2920 gcc_checking_assert (ordered_p (size, UNITS_PER_WORD));
2921 if (maybe_lt (size, UNITS_PER_WORD))
2925 = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
2927 /* Assigning REG here rather than a temp makes
2928 CALL_FUSAGE report the whole reg as used.
2929 Strictly speaking, the call only uses SIZE
2930 bytes at the msb end, but it doesn't seem worth
2931 generating rtl to say that. */
2932 reg = gen_rtx_REG (word_mode, REGNO (reg));
2933 x = expand_shift (LSHIFT_EXPR, word_mode,
2934 reg, shift, reg, 1);
2936 emit_move_insn (reg, x);
2942 /* If we have pre-computed the values to put in the registers in
2943 the case of non-aligned structures, copy them in now. */
2945 else if (args[i].n_aligned_regs != 0)
2946 for (j = 0; j < args[i].n_aligned_regs; j++)
2947 emit_move_insn (gen_rtx_REG (word_mode, REGNO (reg) + j),
2948 args[i].aligned_regs[j]);
2950 else if (partial == 0 || args[i].pass_on_stack)
2952 /* SIZE and CONST_SIZE are 0 for partial arguments and
2953 the size of a BLKmode type otherwise. */
2954 gcc_checking_assert (known_eq (size, const_size));
2955 rtx mem = validize_mem (copy_rtx (args[i].value));
2957 /* Check for overlap with already clobbered argument area,
2958 providing that this has non-zero size. */
2961 && (mem_might_overlap_already_clobbered_arg_p
2962 (XEXP (args[i].value, 0), const_size)))
2963 *sibcall_failure = 1;
2965 if (const_size % UNITS_PER_WORD == 0
2966 || MEM_ALIGN (mem) % BITS_PER_WORD == 0)
2967 move_block_to_reg (REGNO (reg), mem, nregs, args[i].mode);
2971 move_block_to_reg (REGNO (reg), mem, nregs - 1,
2973 rtx dest = gen_rtx_REG (word_mode, REGNO (reg) + nregs - 1);
2974 unsigned int bitoff = (nregs - 1) * BITS_PER_WORD;
2975 unsigned int bitsize = const_size * BITS_PER_UNIT - bitoff;
2976 rtx x = extract_bit_field (mem, bitsize, bitoff, 1, dest,
2977 word_mode, word_mode, false,
2979 if (BYTES_BIG_ENDIAN)
2980 x = expand_shift (LSHIFT_EXPR, word_mode, x,
2981 BITS_PER_WORD - bitsize, dest, 1);
2983 emit_move_insn (dest, x);
2986 /* Handle a BLKmode that needs shifting. */
2987 if (nregs == 1 && const_size < UNITS_PER_WORD
2988 #ifdef BLOCK_REG_PADDING
2989 && args[i].locate.where_pad == PAD_DOWNWARD
2995 rtx dest = gen_rtx_REG (word_mode, REGNO (reg));
2996 int shift = (UNITS_PER_WORD - const_size) * BITS_PER_UNIT;
2997 enum tree_code dir = (BYTES_BIG_ENDIAN
2998 ? RSHIFT_EXPR : LSHIFT_EXPR);
3001 x = expand_shift (dir, word_mode, dest, shift, dest, 1);
3003 emit_move_insn (dest, x);
3007 /* When a parameter is a block, and perhaps in other cases, it is
3008 possible that it did a load from an argument slot that was
3009 already clobbered. */
3011 && check_sibcall_argument_overlap (before_arg, &args[i], 0))
3012 *sibcall_failure = 1;
3014 /* Handle calls that pass values in multiple non-contiguous
3015 locations. The Irix 6 ABI has examples of this. */
3016 if (GET_CODE (reg) == PARALLEL)
3017 use_group_regs (call_fusage, reg);
3018 else if (nregs == -1)
3019 use_reg_mode (call_fusage, reg,
3020 TYPE_MODE (TREE_TYPE (args[i].tree_value)));
3022 use_regs (call_fusage, REGNO (reg), nregs);
3027 /* We need to pop PENDING_STACK_ADJUST bytes. But, if the arguments
3028 wouldn't fill up an even multiple of PREFERRED_UNIT_STACK_BOUNDARY
3029 bytes, then we would need to push some additional bytes to pad the
3030 arguments. So, we try to compute an adjust to the stack pointer for an
3031 amount that will leave the stack under-aligned by UNADJUSTED_ARGS_SIZE
3032 bytes. Then, when the arguments are pushed the stack will be perfectly
3035 Return true if this optimization is possible, storing the adjustment
3036 in ADJUSTMENT_OUT and setting ARGS_SIZE->CONSTANT to the number of
3037 bytes that should be popped after the call. */
3040 combine_pending_stack_adjustment_and_call (poly_int64_pod *adjustment_out,
3041 poly_int64 unadjusted_args_size,
3042 struct args_size *args_size,
3043 unsigned int preferred_unit_stack_boundary)
3045 /* The number of bytes to pop so that the stack will be
3046 under-aligned by UNADJUSTED_ARGS_SIZE bytes. */
3047 poly_int64 adjustment;
3048 /* The alignment of the stack after the arguments are pushed, if we
3049 just pushed the arguments without adjust the stack here. */
3050 unsigned HOST_WIDE_INT unadjusted_alignment;
3052 if (!known_misalignment (stack_pointer_delta + unadjusted_args_size,
3053 preferred_unit_stack_boundary,
3054 &unadjusted_alignment))
3057 /* We want to get rid of as many of the PENDING_STACK_ADJUST bytes
3058 as possible -- leaving just enough left to cancel out the
3059 UNADJUSTED_ALIGNMENT. In other words, we want to ensure that the
3060 PENDING_STACK_ADJUST is non-negative, and congruent to
3061 -UNADJUSTED_ALIGNMENT modulo the PREFERRED_UNIT_STACK_BOUNDARY. */
3063 /* Begin by trying to pop all the bytes. */
3064 unsigned HOST_WIDE_INT tmp_misalignment;
3065 if (!known_misalignment (pending_stack_adjust,
3066 preferred_unit_stack_boundary,
3069 unadjusted_alignment -= tmp_misalignment;
3070 adjustment = pending_stack_adjust;
3071 /* Push enough additional bytes that the stack will be aligned
3072 after the arguments are pushed. */
3073 if (preferred_unit_stack_boundary > 1 && unadjusted_alignment)
3074 adjustment -= preferred_unit_stack_boundary - unadjusted_alignment;
3076 /* We need to know whether the adjusted argument size
3077 (UNADJUSTED_ARGS_SIZE - ADJUSTMENT) constitutes an allocation
3078 or a deallocation. */
3079 if (!ordered_p (adjustment, unadjusted_args_size))
3082 /* Now, sets ARGS_SIZE->CONSTANT so that we pop the right number of
3083 bytes after the call. The right number is the entire
3084 PENDING_STACK_ADJUST less our ADJUSTMENT plus the amount required
3085 by the arguments in the first place. */
3087 = pending_stack_adjust - adjustment + unadjusted_args_size;
3089 *adjustment_out = adjustment;
3093 /* Scan X expression if it does not dereference any argument slots
3094 we already clobbered by tail call arguments (as noted in stored_args_map
3096 Return nonzero if X expression dereferences such argument slots,
3100 check_sibcall_argument_overlap_1 (rtx x)
3109 code = GET_CODE (x);
3111 /* We need not check the operands of the CALL expression itself. */
3116 return (mem_might_overlap_already_clobbered_arg_p
3117 (XEXP (x, 0), GET_MODE_SIZE (GET_MODE (x))));
3119 /* Scan all subexpressions. */
3120 fmt = GET_RTX_FORMAT (code);
3121 for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
3125 if (check_sibcall_argument_overlap_1 (XEXP (x, i)))
3128 else if (*fmt == 'E')
3130 for (j = 0; j < XVECLEN (x, i); j++)
3131 if (check_sibcall_argument_overlap_1 (XVECEXP (x, i, j)))
3138 /* Scan sequence after INSN if it does not dereference any argument slots
3139 we already clobbered by tail call arguments (as noted in stored_args_map
3140 bitmap). If MARK_STORED_ARGS_MAP, add stack slots for ARG to
3141 stored_args_map bitmap afterwards (when ARG is a register MARK_STORED_ARGS_MAP
3142 should be 0). Return nonzero if sequence after INSN dereferences such argument
3143 slots, zero otherwise. */
3146 check_sibcall_argument_overlap (rtx_insn *insn, struct arg_data *arg,
3147 int mark_stored_args_map)
3149 poly_uint64 low, high;
3150 unsigned HOST_WIDE_INT const_low, const_high;
3152 if (insn == NULL_RTX)
3153 insn = get_insns ();
3155 insn = NEXT_INSN (insn);
3157 for (; insn; insn = NEXT_INSN (insn))
3159 && check_sibcall_argument_overlap_1 (PATTERN (insn)))
3162 if (mark_stored_args_map)
3164 if (ARGS_GROW_DOWNWARD)
3165 low = -arg->locate.slot_offset.constant - arg->locate.size.constant;
3167 low = arg->locate.slot_offset.constant;
3168 high = low + arg->locate.size.constant;
3170 const_low = constant_lower_bound (low);
3171 if (high.is_constant (&const_high))
3172 for (unsigned HOST_WIDE_INT i = const_low; i < const_high; ++i)
3173 bitmap_set_bit (stored_args_map, i);
3175 stored_args_watermark = MIN (stored_args_watermark, const_low);
3177 return insn != NULL_RTX;
3180 /* Given that a function returns a value of mode MODE at the most
3181 significant end of hard register VALUE, shift VALUE left or right
3182 as specified by LEFT_P. Return true if some action was needed. */
3185 shift_return_value (machine_mode mode, bool left_p, rtx value)
3187 gcc_assert (REG_P (value) && HARD_REGISTER_P (value));
3188 machine_mode value_mode = GET_MODE (value);
3189 poly_int64 shift = GET_MODE_BITSIZE (value_mode) - GET_MODE_BITSIZE (mode);
3191 if (known_eq (shift, 0))
3194 /* Use ashr rather than lshr for right shifts. This is for the benefit
3195 of the MIPS port, which requires SImode values to be sign-extended
3196 when stored in 64-bit registers. */
3197 if (!force_expand_binop (value_mode, left_p ? ashl_optab : ashr_optab,
3198 value, gen_int_shift_amount (value_mode, shift),
3199 value, 1, OPTAB_WIDEN))
3204 /* If X is a likely-spilled register value, copy it to a pseudo
3205 register and return that register. Return X otherwise. */
3208 avoid_likely_spilled_reg (rtx x)
3213 && HARD_REGISTER_P (x)
3214 && targetm.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (x))))
3216 /* Make sure that we generate a REG rather than a CONCAT.
3217 Moves into CONCATs can need nontrivial instructions,
3218 and the whole point of this function is to avoid
3219 using the hard register directly in such a situation. */
3220 generating_concat_p = 0;
3221 new_rtx = gen_reg_rtx (GET_MODE (x));
3222 generating_concat_p = 1;
3223 emit_move_insn (new_rtx, x);
3229 /* Helper function for expand_call.
3230 Return false is EXP is not implementable as a sibling call. */
3233 can_implement_as_sibling_call_p (tree exp,
3234 rtx structure_value_addr,
3236 int reg_parm_stack_space ATTRIBUTE_UNUSED,
3240 const args_size &args_size)
3242 if (!targetm.have_sibcall_epilogue ())
3244 maybe_complain_about_tail_call
3246 "machine description does not have"
3247 " a sibcall_epilogue instruction pattern");
3251 /* Doing sibling call optimization needs some work, since
3252 structure_value_addr can be allocated on the stack.
3253 It does not seem worth the effort since few optimizable
3254 sibling calls will return a structure. */
3255 if (structure_value_addr != NULL_RTX)
3257 maybe_complain_about_tail_call (exp, "callee returns a structure");
3261 #ifdef REG_PARM_STACK_SPACE
3262 /* If outgoing reg parm stack space changes, we can not do sibcall. */
3263 if (OUTGOING_REG_PARM_STACK_SPACE (funtype)
3264 != OUTGOING_REG_PARM_STACK_SPACE (TREE_TYPE (current_function_decl))
3265 || (reg_parm_stack_space != REG_PARM_STACK_SPACE (current_function_decl)))
3267 maybe_complain_about_tail_call (exp,
3268 "inconsistent size of stack space"
3269 " allocated for arguments which are"
3270 " passed in registers");
3275 /* Check whether the target is able to optimize the call
3277 if (!targetm.function_ok_for_sibcall (fndecl, exp))
3279 maybe_complain_about_tail_call (exp,
3280 "target is not able to optimize the"
3281 " call into a sibling call");
3285 /* Functions that do not return exactly once may not be sibcall
3287 if (flags & ECF_RETURNS_TWICE)
3289 maybe_complain_about_tail_call (exp, "callee returns twice");
3292 if (flags & ECF_NORETURN)
3294 maybe_complain_about_tail_call (exp, "callee does not return");
3298 if (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (addr))))
3300 maybe_complain_about_tail_call (exp, "volatile function type");
3304 /* If the called function is nested in the current one, it might access
3305 some of the caller's arguments, but could clobber them beforehand if
3306 the argument areas are shared. */
3307 if (fndecl && decl_function_context (fndecl) == current_function_decl)
3309 maybe_complain_about_tail_call (exp, "nested function");
3313 /* If this function requires more stack slots than the current
3314 function, we cannot change it into a sibling call.
3315 crtl->args.pretend_args_size is not part of the
3316 stack allocated by our caller. */
3317 if (maybe_gt (args_size.constant,
3318 crtl->args.size - crtl->args.pretend_args_size))
3320 maybe_complain_about_tail_call (exp,
3321 "callee required more stack slots"
3322 " than the caller");
3326 /* If the callee pops its own arguments, then it must pop exactly
3327 the same number of arguments as the current function. */
3328 if (maybe_ne (targetm.calls.return_pops_args (fndecl, funtype,
3329 args_size.constant),
3330 targetm.calls.return_pops_args (current_function_decl,
3332 (current_function_decl),
3335 maybe_complain_about_tail_call (exp,
3336 "inconsistent number of"
3337 " popped arguments");
3341 if (!lang_hooks.decls.ok_for_sibcall (fndecl))
3343 maybe_complain_about_tail_call (exp, "frontend does not support"
3348 /* All checks passed. */
3352 /* Generate all the code for a CALL_EXPR exp
3353 and return an rtx for its value.
3354 Store the value in TARGET (specified as an rtx) if convenient.
3355 If the value is stored in TARGET then TARGET is returned.
3356 If IGNORE is nonzero, then we ignore the value of the function call. */
3359 expand_call (tree exp, rtx target, int ignore)
3361 /* Nonzero if we are currently expanding a call. */
3362 static int currently_expanding_call = 0;
3364 /* RTX for the function to be called. */
3366 /* Sequence of insns to perform a normal "call". */
3367 rtx_insn *normal_call_insns = NULL;
3368 /* Sequence of insns to perform a tail "call". */
3369 rtx_insn *tail_call_insns = NULL;
3370 /* Data type of the function. */
3372 tree type_arg_types;
3374 /* Declaration of the function being called,
3375 or 0 if the function is computed (not known by name). */
3377 /* The type of the function being called. */
3379 bool try_tail_call = CALL_EXPR_TAILCALL (exp);
3380 bool must_tail_call = CALL_EXPR_MUST_TAIL_CALL (exp);
3383 /* Register in which non-BLKmode value will be returned,
3384 or 0 if no value or if value is BLKmode. */
3386 /* Register(s) in which bounds are returned. */
3388 /* Address where we should return a BLKmode value;
3389 0 if value not BLKmode. */
3390 rtx structure_value_addr = 0;
3391 /* Nonzero if that address is being passed by treating it as
3392 an extra, implicit first parameter. Otherwise,
3393 it is passed by being copied directly into struct_value_rtx. */
3394 int structure_value_addr_parm = 0;
3395 /* Holds the value of implicit argument for the struct value. */
3396 tree structure_value_addr_value = NULL_TREE;
3397 /* Size of aggregate value wanted, or zero if none wanted
3398 or if we are using the non-reentrant PCC calling convention
3399 or expecting the value in registers. */
3400 poly_int64 struct_value_size = 0;
3401 /* Nonzero if called function returns an aggregate in memory PCC style,
3402 by returning the address of where to find it. */
3403 int pcc_struct_value = 0;
3404 rtx struct_value = 0;
3406 /* Number of actual parameters in this call, including struct value addr. */
3408 /* Number of named args. Args after this are anonymous ones
3409 and they must all go on the stack. */
3411 /* Number of complex actual arguments that need to be split. */
3412 int num_complex_actuals = 0;
3414 /* Vector of information about each argument.
3415 Arguments are numbered in the order they will be pushed,
3416 not the order they are written. */
3417 struct arg_data *args;
3419 /* Total size in bytes of all the stack-parms scanned so far. */
3420 struct args_size args_size;
3421 struct args_size adjusted_args_size;
3422 /* Size of arguments before any adjustments (such as rounding). */
3423 poly_int64 unadjusted_args_size;
3424 /* Data on reg parms scanned so far. */
3425 CUMULATIVE_ARGS args_so_far_v;
3426 cumulative_args_t args_so_far;
3427 /* Nonzero if a reg parm has been scanned. */
3429 /* Nonzero if this is an indirect function call. */
3431 /* Nonzero if we must avoid push-insns in the args for this call.
3432 If stack space is allocated for register parameters, but not by the
3433 caller, then it is preallocated in the fixed part of the stack frame.
3434 So the entire argument block must then be preallocated (i.e., we
3435 ignore PUSH_ROUNDING in that case). */
3437 int must_preallocate = !PUSH_ARGS;
3439 /* Size of the stack reserved for parameter registers. */
3440 int reg_parm_stack_space = 0;
3442 /* Address of space preallocated for stack parms
3443 (on machines that lack push insns), or 0 if space not preallocated. */
3446 /* Mask of ECF_ and ERF_ flags. */
3448 int return_flags = 0;
3449 #ifdef REG_PARM_STACK_SPACE
3450 /* Define the boundary of the register parm stack space that needs to be
3452 int low_to_save, high_to_save;
3453 rtx save_area = 0; /* Place that it is saved */
3456 unsigned int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
3457 char *initial_stack_usage_map = stack_usage_map;
3458 unsigned HOST_WIDE_INT initial_stack_usage_watermark = stack_usage_watermark;
3459 char *stack_usage_map_buf = NULL;
3461 poly_int64 old_stack_allocated;
3463 /* State variables to track stack modifications. */
3464 rtx old_stack_level = 0;
3465 int old_stack_arg_under_construction = 0;
3466 poly_int64 old_pending_adj = 0;
3467 int old_inhibit_defer_pop = inhibit_defer_pop;
3469 /* Some stack pointer alterations we make are performed via
3470 allocate_dynamic_stack_space. This modifies the stack_pointer_delta,
3471 which we then also need to save/restore along the way. */
3472 poly_int64 old_stack_pointer_delta = 0;
3475 tree addr = CALL_EXPR_FN (exp);
3477 /* The alignment of the stack, in bits. */
3478 unsigned HOST_WIDE_INT preferred_stack_boundary;
3479 /* The alignment of the stack, in bytes. */
3480 unsigned HOST_WIDE_INT preferred_unit_stack_boundary;
3481 /* The static chain value to use for this call. */
3482 rtx static_chain_value;
3483 /* See if this is "nothrow" function call. */
3484 if (TREE_NOTHROW (exp))
3485 flags |= ECF_NOTHROW;
3487 /* See if we can find a DECL-node for the actual function, and get the
3488 function attributes (flags) from the function decl or type node. */
3489 fndecl = get_callee_fndecl (exp);
3492 fntype = TREE_TYPE (fndecl);
3493 flags |= flags_from_decl_or_type (fndecl);
3494 return_flags |= decl_return_flags (fndecl);
3498 fntype = TREE_TYPE (TREE_TYPE (addr));
3499 flags |= flags_from_decl_or_type (fntype);
3500 if (CALL_EXPR_BY_DESCRIPTOR (exp))
3501 flags |= ECF_BY_DESCRIPTOR;
3503 rettype = TREE_TYPE (exp);
3505 struct_value = targetm.calls.struct_value_rtx (fntype, 0);
3507 /* Warn if this value is an aggregate type,
3508 regardless of which calling convention we are using for it. */
3509 if (AGGREGATE_TYPE_P (rettype))
3510 warning (OPT_Waggregate_return, "function call has aggregate value");
3512 /* If the result of a non looping pure or const function call is
3513 ignored (or void), and none of its arguments are volatile, we can
3514 avoid expanding the call and just evaluate the arguments for
3516 if ((flags & (ECF_CONST | ECF_PURE))
3517 && (!(flags & ECF_LOOPING_CONST_OR_PURE))
3518 && (ignore || target == const0_rtx
3519 || TYPE_MODE (rettype) == VOIDmode))
3521 bool volatilep = false;
3523 call_expr_arg_iterator iter;
3525 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
3526 if (TREE_THIS_VOLATILE (arg))
3534 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
3535 expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
3540 #ifdef REG_PARM_STACK_SPACE
3541 reg_parm_stack_space = REG_PARM_STACK_SPACE (!fndecl ? fntype : fndecl);
3544 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))
3545 && reg_parm_stack_space > 0 && PUSH_ARGS)
3546 must_preallocate = 1;
3548 /* Set up a place to return a structure. */
3550 /* Cater to broken compilers. */
3551 if (aggregate_value_p (exp, fntype))
3553 /* This call returns a big structure. */
3554 flags &= ~(ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
3556 #ifdef PCC_STATIC_STRUCT_RETURN
3558 pcc_struct_value = 1;
3560 #else /* not PCC_STATIC_STRUCT_RETURN */
3562 if (!poly_int_tree_p (TYPE_SIZE_UNIT (rettype), &struct_value_size))
3563 struct_value_size = -1;
3565 /* Even if it is semantically safe to use the target as the return
3566 slot, it may be not sufficiently aligned for the return type. */
3567 if (CALL_EXPR_RETURN_SLOT_OPT (exp)
3570 /* If rettype is addressable, we may not create a temporary.
3571 If target is properly aligned at runtime and the compiler
3572 just doesn't know about it, it will work fine, otherwise it
3574 && (TREE_ADDRESSABLE (rettype)
3575 || !(MEM_ALIGN (target) < TYPE_ALIGN (rettype)
3576 && targetm.slow_unaligned_access (TYPE_MODE (rettype),
3577 MEM_ALIGN (target)))))
3578 structure_value_addr = XEXP (target, 0);
3581 /* For variable-sized objects, we must be called with a target
3582 specified. If we were to allocate space on the stack here,
3583 we would have no way of knowing when to free it. */
3584 rtx d = assign_temp (rettype, 1, 1);
3585 structure_value_addr = XEXP (d, 0);
3589 #endif /* not PCC_STATIC_STRUCT_RETURN */
3592 /* Figure out the amount to which the stack should be aligned. */
3593 preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
3596 struct cgraph_rtl_info *i = cgraph_node::rtl_info (fndecl);
3597 /* Without automatic stack alignment, we can't increase preferred
3598 stack boundary. With automatic stack alignment, it is
3599 unnecessary since unless we can guarantee that all callers will
3600 align the outgoing stack properly, callee has to align its
3603 && i->preferred_incoming_stack_boundary
3604 && i->preferred_incoming_stack_boundary < preferred_stack_boundary)
3605 preferred_stack_boundary = i->preferred_incoming_stack_boundary;
3608 /* Operand 0 is a pointer-to-function; get the type of the function. */
3609 funtype = TREE_TYPE (addr);
3610 gcc_assert (POINTER_TYPE_P (funtype));
3611 funtype = TREE_TYPE (funtype);
3613 /* Count whether there are actual complex arguments that need to be split
3614 into their real and imaginary parts. Munge the type_arg_types
3615 appropriately here as well. */
3616 if (targetm.calls.split_complex_arg)
3618 call_expr_arg_iterator iter;
3620 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
3622 tree type = TREE_TYPE (arg);
3623 if (type && TREE_CODE (type) == COMPLEX_TYPE
3624 && targetm.calls.split_complex_arg (type))
3625 num_complex_actuals++;
3627 type_arg_types = split_complex_types (TYPE_ARG_TYPES (funtype));
3630 type_arg_types = TYPE_ARG_TYPES (funtype);
3632 if (flags & ECF_MAY_BE_ALLOCA)
3633 cfun->calls_alloca = 1;
3635 /* If struct_value_rtx is 0, it means pass the address
3636 as if it were an extra parameter. Put the argument expression
3637 in structure_value_addr_value. */
3638 if (structure_value_addr && struct_value == 0)
3640 /* If structure_value_addr is a REG other than
3641 virtual_outgoing_args_rtx, we can use always use it. If it
3642 is not a REG, we must always copy it into a register.
3643 If it is virtual_outgoing_args_rtx, we must copy it to another
3644 register in some cases. */
3645 rtx temp = (!REG_P (structure_value_addr)
3646 || (ACCUMULATE_OUTGOING_ARGS
3647 && stack_arg_under_construction
3648 && structure_value_addr == virtual_outgoing_args_rtx)
3649 ? copy_addr_to_reg (convert_memory_address
3650 (Pmode, structure_value_addr))
3651 : structure_value_addr);
3653 structure_value_addr_value =
3654 make_tree (build_pointer_type (TREE_TYPE (funtype)), temp);
3655 structure_value_addr_parm = CALL_WITH_BOUNDS_P (exp) ? 2 : 1;
3658 /* Count the arguments and set NUM_ACTUALS. */
3660 call_expr_nargs (exp) + num_complex_actuals + structure_value_addr_parm;
3662 /* Compute number of named args.
3663 First, do a raw count of the args for INIT_CUMULATIVE_ARGS. */
3665 if (type_arg_types != 0)
3667 = (list_length (type_arg_types)
3668 /* Count the struct value address, if it is passed as a parm. */
3669 + structure_value_addr_parm);
3671 /* If we know nothing, treat all args as named. */
3672 n_named_args = num_actuals;
3674 /* Start updating where the next arg would go.
3676 On some machines (such as the PA) indirect calls have a different
3677 calling convention than normal calls. The fourth argument in
3678 INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
3680 INIT_CUMULATIVE_ARGS (args_so_far_v, funtype, NULL_RTX, fndecl, n_named_args);
3681 args_so_far = pack_cumulative_args (&args_so_far_v);
3683 /* Now possibly adjust the number of named args.
3684 Normally, don't include the last named arg if anonymous args follow.
3685 We do include the last named arg if
3686 targetm.calls.strict_argument_naming() returns nonzero.
3687 (If no anonymous args follow, the result of list_length is actually
3688 one too large. This is harmless.)
3690 If targetm.calls.pretend_outgoing_varargs_named() returns
3691 nonzero, and targetm.calls.strict_argument_naming() returns zero,
3692 this machine will be able to place unnamed args that were passed
3693 in registers into the stack. So treat all args as named. This
3694 allows the insns emitting for a specific argument list to be
3695 independent of the function declaration.
3697 If targetm.calls.pretend_outgoing_varargs_named() returns zero,
3698 we do not have any reliable way to pass unnamed args in
3699 registers, so we must force them into memory. */
3701 if (type_arg_types != 0
3702 && targetm.calls.strict_argument_naming (args_so_far))
3704 else if (type_arg_types != 0
3705 && ! targetm.calls.pretend_outgoing_varargs_named (args_so_far))
3706 /* Don't include the last named arg. */
3709 /* Treat all args as named. */
3710 n_named_args = num_actuals;
3712 /* Make a vector to hold all the information about each arg. */
3713 args = XCNEWVEC (struct arg_data, num_actuals);
3715 /* Build up entries in the ARGS array, compute the size of the
3716 arguments into ARGS_SIZE, etc. */
3717 initialize_argument_information (num_actuals, args, &args_size,
3719 structure_value_addr_value, fndecl, fntype,
3720 args_so_far, reg_parm_stack_space,
3721 &old_stack_level, &old_pending_adj,
3722 &must_preallocate, &flags,
3723 &try_tail_call, CALL_FROM_THUNK_P (exp));
3726 must_preallocate = 1;
3728 /* Now make final decision about preallocating stack space. */
3729 must_preallocate = finalize_must_preallocate (must_preallocate,
3733 /* If the structure value address will reference the stack pointer, we
3734 must stabilize it. We don't need to do this if we know that we are
3735 not going to adjust the stack pointer in processing this call. */
3737 if (structure_value_addr
3738 && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
3739 || reg_mentioned_p (virtual_outgoing_args_rtx,
3740 structure_value_addr))
3742 || (!ACCUMULATE_OUTGOING_ARGS
3743 && maybe_ne (args_size.constant, 0))))
3744 structure_value_addr = copy_to_reg (structure_value_addr);
3746 /* Tail calls can make things harder to debug, and we've traditionally
3747 pushed these optimizations into -O2. Don't try if we're already
3748 expanding a call, as that means we're an argument. Don't try if
3749 there's cleanups, as we know there's code to follow the call. */
3751 if (currently_expanding_call++ != 0
3752 || !flag_optimize_sibling_calls
3754 || dbg_cnt (tail_call) == false)
3757 /* If the user has marked the function as requiring tail-call
3758 optimization, attempt it. */
3762 /* Rest of purposes for tail call optimizations to fail. */
3764 try_tail_call = can_implement_as_sibling_call_p (exp,
3765 structure_value_addr,
3767 reg_parm_stack_space,
3769 flags, addr, args_size);
3771 /* Check if caller and callee disagree in promotion of function
3775 machine_mode caller_mode, caller_promoted_mode;
3776 machine_mode callee_mode, callee_promoted_mode;
3777 int caller_unsignedp, callee_unsignedp;
3778 tree caller_res = DECL_RESULT (current_function_decl);
3780 caller_unsignedp = TYPE_UNSIGNED (TREE_TYPE (caller_res));
3781 caller_mode = DECL_MODE (caller_res);
3782 callee_unsignedp = TYPE_UNSIGNED (TREE_TYPE (funtype));
3783 callee_mode = TYPE_MODE (TREE_TYPE (funtype));
3784 caller_promoted_mode
3785 = promote_function_mode (TREE_TYPE (caller_res), caller_mode,
3787 TREE_TYPE (current_function_decl), 1);
3788 callee_promoted_mode
3789 = promote_function_mode (TREE_TYPE (funtype), callee_mode,
3792 if (caller_mode != VOIDmode
3793 && (caller_promoted_mode != callee_promoted_mode
3794 || ((caller_mode != caller_promoted_mode
3795 || callee_mode != callee_promoted_mode)
3796 && (caller_unsignedp != callee_unsignedp
3797 || partial_subreg_p (caller_mode, callee_mode)))))
3800 maybe_complain_about_tail_call (exp,
3801 "caller and callee disagree in"
3802 " promotion of function"
3807 /* Ensure current function's preferred stack boundary is at least
3808 what we need. Stack alignment may also increase preferred stack
3810 if (crtl->preferred_stack_boundary < preferred_stack_boundary)
3811 crtl->preferred_stack_boundary = preferred_stack_boundary;
3813 preferred_stack_boundary = crtl->preferred_stack_boundary;
3815 preferred_unit_stack_boundary = preferred_stack_boundary / BITS_PER_UNIT;
3817 /* We want to make two insn chains; one for a sibling call, the other
3818 for a normal call. We will select one of the two chains after
3819 initial RTL generation is complete. */
3820 for (pass = try_tail_call ? 0 : 1; pass < 2; pass++)
3822 int sibcall_failure = 0;
3823 /* We want to emit any pending stack adjustments before the tail
3824 recursion "call". That way we know any adjustment after the tail
3825 recursion call can be ignored if we indeed use the tail
3827 saved_pending_stack_adjust save;
3828 rtx_insn *insns, *before_call, *after_args;
3833 /* State variables we need to save and restore between
3835 save_pending_stack_adjust (&save);
3838 flags &= ~ECF_SIBCALL;
3840 flags |= ECF_SIBCALL;
3842 /* Other state variables that we must reinitialize each time
3843 through the loop (that are not initialized by the loop itself). */
3847 /* Start a new sequence for the normal call case.
3849 From this point on, if the sibling call fails, we want to set
3850 sibcall_failure instead of continuing the loop. */
3853 /* Don't let pending stack adjusts add up to too much.
3854 Also, do all pending adjustments now if there is any chance
3855 this might be a call to alloca or if we are expanding a sibling
3857 Also do the adjustments before a throwing call, otherwise
3858 exception handling can fail; PR 19225. */
3859 if (maybe_ge (pending_stack_adjust, 32)
3860 || (maybe_ne (pending_stack_adjust, 0)
3861 && (flags & ECF_MAY_BE_ALLOCA))
3862 || (maybe_ne (pending_stack_adjust, 0)
3863 && flag_exceptions && !(flags & ECF_NOTHROW))
3865 do_pending_stack_adjust ();
3867 /* Precompute any arguments as needed. */
3869 precompute_arguments (num_actuals, args);
3871 /* Now we are about to start emitting insns that can be deleted
3872 if a libcall is deleted. */
3873 if (pass && (flags & ECF_MALLOC))
3877 && crtl->stack_protect_guard
3878 && targetm.stack_protect_runtime_enabled_p ())
3879 stack_protect_epilogue ();
3881 adjusted_args_size = args_size;
3882 /* Compute the actual size of the argument block required. The variable
3883 and constant sizes must be combined, the size may have to be rounded,
3884 and there may be a minimum required size. When generating a sibcall
3885 pattern, do not round up, since we'll be re-using whatever space our
3887 unadjusted_args_size
3888 = compute_argument_block_size (reg_parm_stack_space,
3889 &adjusted_args_size,
3892 : preferred_stack_boundary));
3894 old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
3896 /* The argument block when performing a sibling call is the
3897 incoming argument block. */
3900 argblock = crtl->args.internal_arg_pointer;
3901 if (STACK_GROWS_DOWNWARD)
3903 = plus_constant (Pmode, argblock, crtl->args.pretend_args_size);
3906 = plus_constant (Pmode, argblock, -crtl->args.pretend_args_size);
3908 HOST_WIDE_INT map_size = constant_lower_bound (args_size.constant);
3909 stored_args_map = sbitmap_alloc (map_size);
3910 bitmap_clear (stored_args_map);
3911 stored_args_watermark = HOST_WIDE_INT_M1U;
3914 /* If we have no actual push instructions, or shouldn't use them,
3915 make space for all args right now. */
3916 else if (adjusted_args_size.var != 0)
3918 if (old_stack_level == 0)
3920 emit_stack_save (SAVE_BLOCK, &old_stack_level);
3921 old_stack_pointer_delta = stack_pointer_delta;
3922 old_pending_adj = pending_stack_adjust;
3923 pending_stack_adjust = 0;
3924 /* stack_arg_under_construction says whether a stack arg is
3925 being constructed at the old stack level. Pushing the stack
3926 gets a clean outgoing argument block. */
3927 old_stack_arg_under_construction = stack_arg_under_construction;
3928 stack_arg_under_construction = 0;
3930 argblock = push_block (ARGS_SIZE_RTX (adjusted_args_size), 0, 0);
3931 if (flag_stack_usage_info)
3932 current_function_has_unbounded_dynamic_stack_size = 1;
3936 /* Note that we must go through the motions of allocating an argument
3937 block even if the size is zero because we may be storing args
3938 in the area reserved for register arguments, which may be part of
3941 poly_int64 needed = adjusted_args_size.constant;
3943 /* Store the maximum argument space used. It will be pushed by
3944 the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
3947 crtl->outgoing_args_size = upper_bound (crtl->outgoing_args_size,
3950 if (must_preallocate)
3952 if (ACCUMULATE_OUTGOING_ARGS)
3954 /* Since the stack pointer will never be pushed, it is
3955 possible for the evaluation of a parm to clobber
3956 something we have already written to the stack.
3957 Since most function calls on RISC machines do not use
3958 the stack, this is uncommon, but must work correctly.
3960 Therefore, we save any area of the stack that was already
3961 written and that we are using. Here we set up to do this
3962 by making a new stack usage map from the old one. The
3963 actual save will be done by store_one_arg.
3965 Another approach might be to try to reorder the argument
3966 evaluations to avoid this conflicting stack usage. */
3968 /* Since we will be writing into the entire argument area,
3969 the map must be allocated for its entire size, not just
3970 the part that is the responsibility of the caller. */
3971 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
3972 needed += reg_parm_stack_space;
3974 poly_int64 limit = needed;
3975 if (ARGS_GROW_DOWNWARD)
3978 /* For polynomial sizes, this is the maximum possible
3979 size needed for arguments with a constant size
3981 HOST_WIDE_INT const_limit = constant_lower_bound (limit);
3982 highest_outgoing_arg_in_use
3983 = MAX (initial_highest_arg_in_use, const_limit);
3985 free (stack_usage_map_buf);
3986 stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
3987 stack_usage_map = stack_usage_map_buf;
3989 if (initial_highest_arg_in_use)
3990 memcpy (stack_usage_map, initial_stack_usage_map,
3991 initial_highest_arg_in_use);
3993 if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
3994 memset (&stack_usage_map[initial_highest_arg_in_use], 0,
3995 (highest_outgoing_arg_in_use
3996 - initial_highest_arg_in_use));
3999 /* The address of the outgoing argument list must not be
4000 copied to a register here, because argblock would be left
4001 pointing to the wrong place after the call to
4002 allocate_dynamic_stack_space below. */
4004 argblock = virtual_outgoing_args_rtx;
4008 /* Try to reuse some or all of the pending_stack_adjust
4009 to get this space. */
4010 if (inhibit_defer_pop == 0
4011 && (combine_pending_stack_adjustment_and_call
4013 unadjusted_args_size,
4014 &adjusted_args_size,
4015 preferred_unit_stack_boundary)))
4017 /* combine_pending_stack_adjustment_and_call computes
4018 an adjustment before the arguments are allocated.
4019 Account for them and see whether or not the stack
4020 needs to go up or down. */
4021 needed = unadjusted_args_size - needed;
4024 combine_pending_stack_adjustment_and_call. */
4025 gcc_checking_assert (ordered_p (needed, 0));
4026 if (maybe_lt (needed, 0))
4028 /* We're releasing stack space. */
4029 /* ??? We can avoid any adjustment at all if we're
4030 already aligned. FIXME. */
4031 pending_stack_adjust = -needed;
4032 do_pending_stack_adjust ();
4036 /* We need to allocate space. We'll do that in
4037 push_block below. */
4038 pending_stack_adjust = 0;
4041 /* Special case this because overhead of `push_block' in
4042 this case is non-trivial. */
4043 if (known_eq (needed, 0))
4044 argblock = virtual_outgoing_args_rtx;
4047 rtx needed_rtx = gen_int_mode (needed, Pmode);
4048 argblock = push_block (needed_rtx, 0, 0);
4049 if (ARGS_GROW_DOWNWARD)
4050 argblock = plus_constant (Pmode, argblock, needed);
4053 /* We only really need to call `copy_to_reg' in the case
4054 where push insns are going to be used to pass ARGBLOCK
4055 to a function call in ARGS. In that case, the stack
4056 pointer changes value from the allocation point to the
4057 call point, and hence the value of
4058 VIRTUAL_OUTGOING_ARGS_RTX changes as well. But might
4059 as well always do it. */
4060 argblock = copy_to_reg (argblock);
4065 if (ACCUMULATE_OUTGOING_ARGS)
4067 /* The save/restore code in store_one_arg handles all
4068 cases except one: a constructor call (including a C
4069 function returning a BLKmode struct) to initialize
4071 if (stack_arg_under_construction)
4075 (adjusted_args_size.constant
4076 + (OUTGOING_REG_PARM_STACK_SPACE (!fndecl ? fntype
4077 : TREE_TYPE (fndecl))
4078 ? 0 : reg_parm_stack_space), Pmode));
4079 if (old_stack_level == 0)
4081 emit_stack_save (SAVE_BLOCK, &old_stack_level);
4082 old_stack_pointer_delta = stack_pointer_delta;
4083 old_pending_adj = pending_stack_adjust;
4084 pending_stack_adjust = 0;
4085 /* stack_arg_under_construction says whether a stack
4086 arg is being constructed at the old stack level.
4087 Pushing the stack gets a clean outgoing argument
4089 old_stack_arg_under_construction
4090 = stack_arg_under_construction;
4091 stack_arg_under_construction = 0;
4092 /* Make a new map for the new argument list. */
4093 free (stack_usage_map_buf);
4094 stack_usage_map_buf = XCNEWVEC (char, highest_outgoing_arg_in_use);
4095 stack_usage_map = stack_usage_map_buf;
4096 highest_outgoing_arg_in_use = 0;
4097 stack_usage_watermark = HOST_WIDE_INT_M1U;
4099 /* We can pass TRUE as the 4th argument because we just
4100 saved the stack pointer and will restore it right after
4102 allocate_dynamic_stack_space (push_size, 0, BIGGEST_ALIGNMENT,
4106 /* If argument evaluation might modify the stack pointer,
4107 copy the address of the argument list to a register. */
4108 for (i = 0; i < num_actuals; i++)
4109 if (args[i].pass_on_stack)
4111 argblock = copy_addr_to_reg (argblock);
4116 compute_argument_addresses (args, argblock, num_actuals);
4118 /* Stack is properly aligned, pops can't safely be deferred during
4119 the evaluation of the arguments. */
4122 /* Precompute all register parameters. It isn't safe to compute
4123 anything once we have started filling any specific hard regs.
4124 TLS symbols sometimes need a call to resolve. Precompute
4125 register parameters before any stack pointer manipulation
4126 to avoid unaligned stack in the called function. */
4127 precompute_register_parameters (num_actuals, args, ®_parm_seen);
4131 /* Perform stack alignment before the first push (the last arg). */
4133 && maybe_gt (adjusted_args_size.constant, reg_parm_stack_space)
4134 && maybe_ne (adjusted_args_size.constant, unadjusted_args_size))
4136 /* When the stack adjustment is pending, we get better code
4137 by combining the adjustments. */
4138 if (maybe_ne (pending_stack_adjust, 0)
4139 && ! inhibit_defer_pop
4140 && (combine_pending_stack_adjustment_and_call
4141 (&pending_stack_adjust,
4142 unadjusted_args_size,
4143 &adjusted_args_size,
4144 preferred_unit_stack_boundary)))
4145 do_pending_stack_adjust ();
4146 else if (argblock == 0)
4147 anti_adjust_stack (gen_int_mode (adjusted_args_size.constant
4148 - unadjusted_args_size,
4151 /* Now that the stack is properly aligned, pops can't safely
4152 be deferred during the evaluation of the arguments. */
4155 /* Record the maximum pushed stack space size. We need to delay
4156 doing it this far to take into account the optimization done
4157 by combine_pending_stack_adjustment_and_call. */
4158 if (flag_stack_usage_info
4159 && !ACCUMULATE_OUTGOING_ARGS
4161 && adjusted_args_size.var == 0)
4163 poly_int64 pushed = (adjusted_args_size.constant
4164 + pending_stack_adjust);
4165 current_function_pushed_stack_size
4166 = upper_bound (current_function_pushed_stack_size, pushed);
4169 funexp = rtx_for_function_call (fndecl, addr);
4171 if (CALL_EXPR_STATIC_CHAIN (exp))
4172 static_chain_value = expand_normal (CALL_EXPR_STATIC_CHAIN (exp));
4174 static_chain_value = 0;
4176 #ifdef REG_PARM_STACK_SPACE
4177 /* Save the fixed argument area if it's part of the caller's frame and
4178 is clobbered by argument setup for this call. */
4179 if (ACCUMULATE_OUTGOING_ARGS && pass)
4180 save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
4181 &low_to_save, &high_to_save);
4184 /* Now store (and compute if necessary) all non-register parms.
4185 These come before register parms, since they can require block-moves,
4186 which could clobber the registers used for register parms.
4187 Parms which have partial registers are not stored here,
4188 but we do preallocate space here if they want that. */
4190 for (i = 0; i < num_actuals; i++)
4192 /* Delay bounds until all other args are stored. */
4193 if (POINTER_BOUNDS_P (args[i].tree_value))
4195 else if (args[i].reg == 0 || args[i].pass_on_stack)
4197 rtx_insn *before_arg = get_last_insn ();
4199 /* We don't allow passing huge (> 2^30 B) arguments
4200 by value. It would cause an overflow later on. */
4201 if (constant_lower_bound (adjusted_args_size.constant)
4202 >= (1 << (HOST_BITS_PER_INT - 2)))
4204 sorry ("passing too large argument on stack");
4208 if (store_one_arg (&args[i], argblock, flags,
4209 adjusted_args_size.var != 0,
4210 reg_parm_stack_space)
4212 && check_sibcall_argument_overlap (before_arg,
4214 sibcall_failure = 1;
4219 = gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args[i].tree_value)),
4220 gen_rtx_USE (VOIDmode, args[i].stack),
4224 /* If we have a parm that is passed in registers but not in memory
4225 and whose alignment does not permit a direct copy into registers,
4226 make a group of pseudos that correspond to each register that we
4228 if (STRICT_ALIGNMENT)
4229 store_unaligned_arguments_into_pseudos (args, num_actuals);
4231 /* Now store any partially-in-registers parm.
4232 This is the last place a block-move can happen. */
4234 for (i = 0; i < num_actuals; i++)
4235 if (args[i].partial != 0 && ! args[i].pass_on_stack)
4237 rtx_insn *before_arg = get_last_insn ();
4239 /* On targets with weird calling conventions (e.g. PA) it's
4240 hard to ensure that all cases of argument overlap between
4241 stack and registers work. Play it safe and bail out. */
4242 if (ARGS_GROW_DOWNWARD && !STACK_GROWS_DOWNWARD)
4244 sibcall_failure = 1;
4248 if (store_one_arg (&args[i], argblock, flags,
4249 adjusted_args_size.var != 0,
4250 reg_parm_stack_space)
4252 && check_sibcall_argument_overlap (before_arg,
4254 sibcall_failure = 1;
4257 bool any_regs = false;
4258 for (i = 0; i < num_actuals; i++)
4259 if (args[i].reg != NULL_RTX)
4262 targetm.calls.call_args (args[i].reg, funtype);
4265 targetm.calls.call_args (pc_rtx, funtype);
4267 /* Figure out the register where the value, if any, will come back. */
4270 if (TYPE_MODE (rettype) != VOIDmode
4271 && ! structure_value_addr)
4273 if (pcc_struct_value)
4275 valreg = hard_function_value (build_pointer_type (rettype),
4276 fndecl, NULL, (pass == 0));
4277 if (CALL_WITH_BOUNDS_P (exp))
4278 valbnd = targetm.calls.
4279 chkp_function_value_bounds (build_pointer_type (rettype),
4280 fndecl, (pass == 0));
4284 valreg = hard_function_value (rettype, fndecl, fntype,
4286 if (CALL_WITH_BOUNDS_P (exp))
4287 valbnd = targetm.calls.chkp_function_value_bounds (rettype,
4292 /* If VALREG is a PARALLEL whose first member has a zero
4293 offset, use that. This is for targets such as m68k that
4294 return the same value in multiple places. */
4295 if (GET_CODE (valreg) == PARALLEL)
4297 rtx elem = XVECEXP (valreg, 0, 0);
4298 rtx where = XEXP (elem, 0);
4299 rtx offset = XEXP (elem, 1);
4300 if (offset == const0_rtx
4301 && GET_MODE (where) == GET_MODE (valreg))
4306 /* Store all bounds not passed in registers. */
4307 for (i = 0; i < num_actuals; i++)
4309 if (POINTER_BOUNDS_P (args[i].tree_value)
4311 store_bounds (&args[i],
4312 args[i].pointer_arg == -1
4314 : &args[args[i].pointer_arg]);
4317 /* If register arguments require space on the stack and stack space
4318 was not preallocated, allocate stack space here for arguments
4319 passed in registers. */
4320 if (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))
4321 && !ACCUMULATE_OUTGOING_ARGS
4322 && must_preallocate == 0 && reg_parm_stack_space > 0)
4323 anti_adjust_stack (GEN_INT (reg_parm_stack_space));
4325 /* Pass the function the address in which to return a
4327 if (pass != 0 && structure_value_addr && ! structure_value_addr_parm)
4329 structure_value_addr
4330 = convert_memory_address (Pmode, structure_value_addr);
4331 emit_move_insn (struct_value,
4333 force_operand (structure_value_addr,
4336 if (REG_P (struct_value))
4337 use_reg (&call_fusage, struct_value);
4340 after_args = get_last_insn ();
4341 funexp = prepare_call_address (fndecl ? fndecl : fntype, funexp,
4342 static_chain_value, &call_fusage,
4343 reg_parm_seen, flags);
4345 load_register_parameters (args, num_actuals, &call_fusage, flags,
4346 pass == 0, &sibcall_failure);
4348 /* Save a pointer to the last insn before the call, so that we can
4349 later safely search backwards to find the CALL_INSN. */
4350 before_call = get_last_insn ();
4352 /* Set up next argument register. For sibling calls on machines
4353 with register windows this should be the incoming register. */
4355 next_arg_reg = targetm.calls.function_incoming_arg (args_so_far,
4360 next_arg_reg = targetm.calls.function_arg (args_so_far,
4361 VOIDmode, void_type_node,
4364 if (pass == 1 && (return_flags & ERF_RETURNS_ARG))
4366 int arg_nr = return_flags & ERF_RETURN_ARG_MASK;
4367 arg_nr = num_actuals - arg_nr - 1;
4369 && arg_nr < num_actuals
4373 && GET_MODE (args[arg_nr].reg) == GET_MODE (valreg))
4375 = gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args[arg_nr].tree_value)),
4376 gen_rtx_SET (valreg, args[arg_nr].reg),
4379 /* All arguments and registers used for the call must be set up by
4382 /* Stack must be properly aligned now. */
4384 || multiple_p (stack_pointer_delta,
4385 preferred_unit_stack_boundary));
4387 /* Generate the actual call instruction. */
4388 emit_call_1 (funexp, exp, fndecl, funtype, unadjusted_args_size,
4389 adjusted_args_size.constant, struct_value_size,
4390 next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
4391 flags, args_so_far);
4395 rtx_call_insn *last;
4396 rtx datum = NULL_RTX;
4397 if (fndecl != NULL_TREE)
4399 datum = XEXP (DECL_RTL (fndecl), 0);
4400 gcc_assert (datum != NULL_RTX
4401 && GET_CODE (datum) == SYMBOL_REF);
4403 last = last_call_insn ();
4404 add_reg_note (last, REG_CALL_DECL, datum);
4407 /* If the call setup or the call itself overlaps with anything
4408 of the argument setup we probably clobbered our call address.
4409 In that case we can't do sibcalls. */
4411 && check_sibcall_argument_overlap (after_args, 0, 0))
4412 sibcall_failure = 1;
4414 /* If a non-BLKmode value is returned at the most significant end
4415 of a register, shift the register right by the appropriate amount
4416 and update VALREG accordingly. BLKmode values are handled by the
4417 group load/store machinery below. */
4418 if (!structure_value_addr
4419 && !pcc_struct_value
4420 && TYPE_MODE (rettype) != VOIDmode
4421 && TYPE_MODE (rettype) != BLKmode
4423 && targetm.calls.return_in_msb (rettype))
4425 if (shift_return_value (TYPE_MODE (rettype), false, valreg))
4426 sibcall_failure = 1;
4427 valreg = gen_rtx_REG (TYPE_MODE (rettype), REGNO (valreg));
4430 if (pass && (flags & ECF_MALLOC))
4432 rtx temp = gen_reg_rtx (GET_MODE (valreg));
4433 rtx_insn *last, *insns;
4435 /* The return value from a malloc-like function is a pointer. */
4436 if (TREE_CODE (rettype) == POINTER_TYPE)
4437 mark_reg_pointer (temp, MALLOC_ABI_ALIGNMENT);
4439 emit_move_insn (temp, valreg);
4441 /* The return value from a malloc-like function can not alias
4443 last = get_last_insn ();
4444 add_reg_note (last, REG_NOALIAS, temp);
4446 /* Write out the sequence. */
4447 insns = get_insns ();
4453 /* For calls to `setjmp', etc., inform
4454 function.c:setjmp_warnings that it should complain if
4455 nonvolatile values are live. For functions that cannot
4456 return, inform flow that control does not fall through. */
4458 if ((flags & ECF_NORETURN) || pass == 0)
4460 /* The barrier must be emitted
4461 immediately after the CALL_INSN. Some ports emit more
4462 than just a CALL_INSN above, so we must search for it here. */
4464 rtx_insn *last = get_last_insn ();
4465 while (!CALL_P (last))
4467 last = PREV_INSN (last);
4468 /* There was no CALL_INSN? */
4469 gcc_assert (last != before_call);
4472 emit_barrier_after (last);
4474 /* Stack adjustments after a noreturn call are dead code.
4475 However when NO_DEFER_POP is in effect, we must preserve
4476 stack_pointer_delta. */
4477 if (inhibit_defer_pop == 0)
4479 stack_pointer_delta = old_stack_allocated;
4480 pending_stack_adjust = 0;
4484 /* If value type not void, return an rtx for the value. */
4486 if (TYPE_MODE (rettype) == VOIDmode
4488 target = const0_rtx;
4489 else if (structure_value_addr)
4491 if (target == 0 || !MEM_P (target))
4494 = gen_rtx_MEM (TYPE_MODE (rettype),
4495 memory_address (TYPE_MODE (rettype),
4496 structure_value_addr));
4497 set_mem_attributes (target, rettype, 1);
4500 else if (pcc_struct_value)
4502 /* This is the special C++ case where we need to
4503 know what the true target was. We take care to
4504 never use this value more than once in one expression. */
4505 target = gen_rtx_MEM (TYPE_MODE (rettype),
4506 copy_to_reg (valreg));
4507 set_mem_attributes (target, rettype, 1);
4509 /* Handle calls that return values in multiple non-contiguous locations.
4510 The Irix 6 ABI has examples of this. */
4511 else if (GET_CODE (valreg) == PARALLEL)
4514 target = emit_group_move_into_temps (valreg);
4515 else if (rtx_equal_p (target, valreg))
4517 else if (GET_CODE (target) == PARALLEL)
4518 /* Handle the result of a emit_group_move_into_temps
4519 call in the previous pass. */
4520 emit_group_move (target, valreg);
4522 emit_group_store (target, valreg, rettype,
4523 int_size_in_bytes (rettype));
4526 && GET_MODE (target) == TYPE_MODE (rettype)
4527 && GET_MODE (target) == GET_MODE (valreg))
4529 bool may_overlap = false;
4531 /* We have to copy a return value in a CLASS_LIKELY_SPILLED hard
4532 reg to a plain register. */
4533 if (!REG_P (target) || HARD_REGISTER_P (target))
4534 valreg = avoid_likely_spilled_reg (valreg);
4536 /* If TARGET is a MEM in the argument area, and we have
4537 saved part of the argument area, then we can't store
4538 directly into TARGET as it may get overwritten when we
4539 restore the argument save area below. Don't work too
4540 hard though and simply force TARGET to a register if it
4541 is a MEM; the optimizer is quite likely to sort it out. */
4542 if (ACCUMULATE_OUTGOING_ARGS && pass && MEM_P (target))
4543 for (i = 0; i < num_actuals; i++)
4544 if (args[i].save_area)
4551 target = copy_to_reg (valreg);
4554 /* TARGET and VALREG cannot be equal at this point
4555 because the latter would not have
4556 REG_FUNCTION_VALUE_P true, while the former would if
4557 it were referring to the same register.
4559 If they refer to the same register, this move will be
4560 a no-op, except when function inlining is being
4562 emit_move_insn (target, valreg);
4564 /* If we are setting a MEM, this code must be executed.
4565 Since it is emitted after the call insn, sibcall
4566 optimization cannot be performed in that case. */
4568 sibcall_failure = 1;
4572 target = copy_to_reg (avoid_likely_spilled_reg (valreg));
4574 /* If we promoted this return value, make the proper SUBREG.
4575 TARGET might be const0_rtx here, so be careful. */
4577 && TYPE_MODE (rettype) != BLKmode
4578 && GET_MODE (target) != TYPE_MODE (rettype))
4580 tree type = rettype;
4581 int unsignedp = TYPE_UNSIGNED (type);
4584 /* Ensure we promote as expected, and get the new unsignedness. */
4585 pmode = promote_function_mode (type, TYPE_MODE (type), &unsignedp,
4587 gcc_assert (GET_MODE (target) == pmode);
4589 poly_uint64 offset = subreg_lowpart_offset (TYPE_MODE (type),
4591 target = gen_rtx_SUBREG (TYPE_MODE (type), target, offset);
4592 SUBREG_PROMOTED_VAR_P (target) = 1;
4593 SUBREG_PROMOTED_SET (target, unsignedp);
4596 /* If size of args is variable or this was a constructor call for a stack
4597 argument, restore saved stack-pointer value. */
4599 if (old_stack_level)
4601 rtx_insn *prev = get_last_insn ();
4603 emit_stack_restore (SAVE_BLOCK, old_stack_level);
4604 stack_pointer_delta = old_stack_pointer_delta;
4606 fixup_args_size_notes (prev, get_last_insn (), stack_pointer_delta);
4608 pending_stack_adjust = old_pending_adj;
4609 old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
4610 stack_arg_under_construction = old_stack_arg_under_construction;
4611 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
4612 stack_usage_map = initial_stack_usage_map;
4613 stack_usage_watermark = initial_stack_usage_watermark;
4614 sibcall_failure = 1;
4616 else if (ACCUMULATE_OUTGOING_ARGS && pass)
4618 #ifdef REG_PARM_STACK_SPACE
4620 restore_fixed_argument_area (save_area, argblock,
4621 high_to_save, low_to_save);
4624 /* If we saved any argument areas, restore them. */
4625 for (i = 0; i < num_actuals; i++)
4626 if (args[i].save_area)
4628 machine_mode save_mode = GET_MODE (args[i].save_area);
4630 = gen_rtx_MEM (save_mode,
4631 memory_address (save_mode,
4632 XEXP (args[i].stack_slot, 0)));
4634 if (save_mode != BLKmode)
4635 emit_move_insn (stack_area, args[i].save_area);
4637 emit_block_move (stack_area, args[i].save_area,
4639 (args[i].locate.size.constant, Pmode)),
4640 BLOCK_OP_CALL_PARM);
4643 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
4644 stack_usage_map = initial_stack_usage_map;
4645 stack_usage_watermark = initial_stack_usage_watermark;
4648 /* If this was alloca, record the new stack level. */
4649 if (flags & ECF_MAY_BE_ALLOCA)
4650 record_new_stack_level ();
4652 /* Free up storage we no longer need. */
4653 for (i = 0; i < num_actuals; ++i)
4654 free (args[i].aligned_regs);
4656 targetm.calls.end_call_args ();
4658 insns = get_insns ();
4663 tail_call_insns = insns;
4665 /* Restore the pending stack adjustment now that we have
4666 finished generating the sibling call sequence. */
4668 restore_pending_stack_adjust (&save);
4670 /* Prepare arg structure for next iteration. */
4671 for (i = 0; i < num_actuals; i++)
4674 args[i].aligned_regs = 0;
4678 sbitmap_free (stored_args_map);
4679 internal_arg_pointer_exp_state.scan_start = NULL;
4680 internal_arg_pointer_exp_state.cache.release ();
4684 normal_call_insns = insns;
4686 /* Verify that we've deallocated all the stack we used. */
4687 gcc_assert ((flags & ECF_NORETURN)
4688 || known_eq (old_stack_allocated,
4690 - pending_stack_adjust));
4693 /* If something prevents making this a sibling call,
4694 zero out the sequence. */
4695 if (sibcall_failure)
4696 tail_call_insns = NULL;
4701 /* If tail call production succeeded, we need to remove REG_EQUIV notes on
4702 arguments too, as argument area is now clobbered by the call. */
4703 if (tail_call_insns)
4705 emit_insn (tail_call_insns);
4706 crtl->tail_call_emit = true;
4710 emit_insn (normal_call_insns);
4712 /* Ideally we'd emit a message for all of the ways that it could
4714 maybe_complain_about_tail_call (exp, "tail call production failed");
4717 currently_expanding_call--;
4719 free (stack_usage_map_buf);
4722 /* Join result with returned bounds so caller may use them if needed. */
4723 target = chkp_join_splitted_slot (target, valbnd);
4728 /* A sibling call sequence invalidates any REG_EQUIV notes made for
4729 this function's incoming arguments.
4731 At the start of RTL generation we know the only REG_EQUIV notes
4732 in the rtl chain are those for incoming arguments, so we can look
4733 for REG_EQUIV notes between the start of the function and the
4734 NOTE_INSN_FUNCTION_BEG.
4736 This is (slight) overkill. We could keep track of the highest
4737 argument we clobber and be more selective in removing notes, but it
4738 does not seem to be worth the effort. */
4741 fixup_tail_calls (void)
4745 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4749 /* There are never REG_EQUIV notes for the incoming arguments
4750 after the NOTE_INSN_FUNCTION_BEG note, so stop if we see it. */
4752 && NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG)
4755 note = find_reg_note (insn, REG_EQUIV, 0);
4757 remove_note (insn, note);
4758 note = find_reg_note (insn, REG_EQUIV, 0);
4763 /* Traverse a list of TYPES and expand all complex types into their
4766 split_complex_types (tree types)
4770 /* Before allocating memory, check for the common case of no complex. */
4771 for (p = types; p; p = TREE_CHAIN (p))
4773 tree type = TREE_VALUE (p);
4774 if (TREE_CODE (type) == COMPLEX_TYPE
4775 && targetm.calls.split_complex_arg (type))
4781 types = copy_list (types);
4783 for (p = types; p; p = TREE_CHAIN (p))
4785 tree complex_type = TREE_VALUE (p);
4787 if (TREE_CODE (complex_type) == COMPLEX_TYPE
4788 && targetm.calls.split_complex_arg (complex_type))
4792 /* Rewrite complex type with component type. */
4793 TREE_VALUE (p) = TREE_TYPE (complex_type);
4794 next = TREE_CHAIN (p);
4796 /* Add another component type for the imaginary part. */
4797 imag = build_tree_list (NULL_TREE, TREE_VALUE (p));
4798 TREE_CHAIN (p) = imag;
4799 TREE_CHAIN (imag) = next;
4801 /* Skip the newly created node. */
4809 /* Output a library call to function ORGFUN (a SYMBOL_REF rtx)
4810 for a value of mode OUTMODE,
4811 with NARGS different arguments, passed as ARGS.
4812 Store the return value if RETVAL is nonzero: store it in VALUE if
4813 VALUE is nonnull, otherwise pick a convenient location. In either
4814 case return the location of the stored value.
4816 FN_TYPE should be LCT_NORMAL for `normal' calls, LCT_CONST for
4817 `const' calls, LCT_PURE for `pure' calls, or another LCT_ value for
4818 other types of library calls. */
4821 emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
4822 enum libcall_type fn_type,
4823 machine_mode outmode, int nargs, rtx_mode_t *args)
4825 /* Total size in bytes of all the stack-parms scanned so far. */
4826 struct args_size args_size;
4827 /* Size of arguments before any adjustments (such as rounding). */
4828 struct args_size original_args_size;
4831 /* Todo, choose the correct decl type of orgfun. Sadly this information
4832 isn't present here, so we default to native calling abi here. */
4833 tree fndecl ATTRIBUTE_UNUSED = NULL_TREE; /* library calls default to host calling abi ? */
4834 tree fntype ATTRIBUTE_UNUSED = NULL_TREE; /* library calls default to host calling abi ? */
4837 CUMULATIVE_ARGS args_so_far_v;
4838 cumulative_args_t args_so_far;
4845 struct locate_and_pad_arg_data locate;
4849 int old_inhibit_defer_pop = inhibit_defer_pop;
4850 rtx call_fusage = 0;
4853 int pcc_struct_value = 0;
4854 poly_int64 struct_value_size = 0;
4856 int reg_parm_stack_space = 0;
4858 rtx_insn *before_call;
4859 bool have_push_fusage;
4860 tree tfom; /* type_for_mode (outmode, 0) */
4862 #ifdef REG_PARM_STACK_SPACE
4863 /* Define the boundary of the register parm stack space that needs to be
4865 int low_to_save = 0, high_to_save = 0;
4866 rtx save_area = 0; /* Place that it is saved. */
4869 /* Size of the stack reserved for parameter registers. */
4870 unsigned int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
4871 char *initial_stack_usage_map = stack_usage_map;
4872 unsigned HOST_WIDE_INT initial_stack_usage_watermark = stack_usage_watermark;
4873 char *stack_usage_map_buf = NULL;
4875 rtx struct_value = targetm.calls.struct_value_rtx (0, 0);
4877 #ifdef REG_PARM_STACK_SPACE
4878 reg_parm_stack_space = REG_PARM_STACK_SPACE ((tree) 0);
4881 /* By default, library functions cannot throw. */
4882 flags = ECF_NOTHROW;
4895 flags |= ECF_NORETURN;
4898 flags &= ~ECF_NOTHROW;
4900 case LCT_RETURNS_TWICE:
4901 flags = ECF_RETURNS_TWICE;
4906 /* Ensure current function's preferred stack boundary is at least
4908 if (crtl->preferred_stack_boundary < PREFERRED_STACK_BOUNDARY)
4909 crtl->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
4911 /* If this kind of value comes back in memory,
4912 decide where in memory it should come back. */
4913 if (outmode != VOIDmode)
4915 tfom = lang_hooks.types.type_for_mode (outmode, 0);
4916 if (aggregate_value_p (tfom, 0))
4918 #ifdef PCC_STATIC_STRUCT_RETURN
4920 = hard_function_value (build_pointer_type (tfom), 0, 0, 0);
4921 mem_value = gen_rtx_MEM (outmode, pointer_reg);
4922 pcc_struct_value = 1;
4924 value = gen_reg_rtx (outmode);
4925 #else /* not PCC_STATIC_STRUCT_RETURN */
4926 struct_value_size = GET_MODE_SIZE (outmode);
4927 if (value != 0 && MEM_P (value))
4930 mem_value = assign_temp (tfom, 1, 1);
4932 /* This call returns a big structure. */
4933 flags &= ~(ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
4937 tfom = void_type_node;
4939 /* ??? Unfinished: must pass the memory address as an argument. */
4941 /* Copy all the libcall-arguments out of the varargs data
4942 and into a vector ARGVEC.
4944 Compute how to pass each argument. We only support a very small subset
4945 of the full argument passing conventions to limit complexity here since
4946 library functions shouldn't have many args. */
4948 argvec = XALLOCAVEC (struct arg, nargs + 1);
4949 memset (argvec, 0, (nargs + 1) * sizeof (struct arg));
4951 #ifdef INIT_CUMULATIVE_LIBCALL_ARGS
4952 INIT_CUMULATIVE_LIBCALL_ARGS (args_so_far_v, outmode, fun);
4954 INIT_CUMULATIVE_ARGS (args_so_far_v, NULL_TREE, fun, 0, nargs);
4956 args_so_far = pack_cumulative_args (&args_so_far_v);
4958 args_size.constant = 0;
4965 /* If there's a structure value address to be passed,
4966 either pass it in the special place, or pass it as an extra argument. */
4967 if (mem_value && struct_value == 0 && ! pcc_struct_value)
4969 rtx addr = XEXP (mem_value, 0);
4973 /* Make sure it is a reasonable operand for a move or push insn. */
4974 if (!REG_P (addr) && !MEM_P (addr)
4975 && !(CONSTANT_P (addr)
4976 && targetm.legitimate_constant_p (Pmode, addr)))
4977 addr = force_operand (addr, NULL_RTX);
4979 argvec[count].value = addr;
4980 argvec[count].mode = Pmode;
4981 argvec[count].partial = 0;
4983 argvec[count].reg = targetm.calls.function_arg (args_so_far,
4984 Pmode, NULL_TREE, true);
4985 gcc_assert (targetm.calls.arg_partial_bytes (args_so_far, Pmode,
4986 NULL_TREE, 1) == 0);
4988 locate_and_pad_parm (Pmode, NULL_TREE,
4989 #ifdef STACK_PARMS_IN_REG_PARM_AREA
4992 argvec[count].reg != 0,
4994 reg_parm_stack_space, 0,
4995 NULL_TREE, &args_size, &argvec[count].locate);
4997 if (argvec[count].reg == 0 || argvec[count].partial != 0
4998 || reg_parm_stack_space > 0)
4999 args_size.constant += argvec[count].locate.size.constant;
5001 targetm.calls.function_arg_advance (args_so_far, Pmode, (tree) 0, true);
5006 for (unsigned int i = 0; count < nargs; i++, count++)
5008 rtx val = args[i].first;
5009 machine_mode mode = args[i].second;
5012 /* We cannot convert the arg value to the mode the library wants here;
5013 must do it earlier where we know the signedness of the arg. */
5014 gcc_assert (mode != BLKmode
5015 && (GET_MODE (val) == mode || GET_MODE (val) == VOIDmode));
5017 /* Make sure it is a reasonable operand for a move or push insn. */
5018 if (!REG_P (val) && !MEM_P (val)
5019 && !(CONSTANT_P (val) && targetm.legitimate_constant_p (mode, val)))
5020 val = force_operand (val, NULL_RTX);
5022 if (pass_by_reference (&args_so_far_v, mode, NULL_TREE, 1))
5026 = !reference_callee_copied (&args_so_far_v, mode, NULL_TREE, 1);
5028 /* If this was a CONST function, it is now PURE since it now
5030 if (flags & ECF_CONST)
5032 flags &= ~ECF_CONST;
5036 if (MEM_P (val) && !must_copy)
5038 tree val_expr = MEM_EXPR (val);
5040 mark_addressable (val_expr);
5045 slot = assign_temp (lang_hooks.types.type_for_mode (mode, 0),
5047 emit_move_insn (slot, val);
5050 call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
5051 gen_rtx_USE (VOIDmode, slot),
5054 call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
5055 gen_rtx_CLOBBER (VOIDmode,
5060 val = force_operand (XEXP (slot, 0), NULL_RTX);
5063 mode = promote_function_mode (NULL_TREE, mode, &unsigned_p, NULL_TREE, 0);
5064 argvec[count].mode = mode;
5065 argvec[count].value = convert_modes (mode, GET_MODE (val), val, unsigned_p);
5066 argvec[count].reg = targetm.calls.function_arg (args_so_far, mode,
5069 argvec[count].partial
5070 = targetm.calls.arg_partial_bytes (args_so_far, mode, NULL_TREE, 1);
5072 if (argvec[count].reg == 0
5073 || argvec[count].partial != 0
5074 || reg_parm_stack_space > 0)
5076 locate_and_pad_parm (mode, NULL_TREE,
5077 #ifdef STACK_PARMS_IN_REG_PARM_AREA
5080 argvec[count].reg != 0,
5082 reg_parm_stack_space, argvec[count].partial,
5083 NULL_TREE, &args_size, &argvec[count].locate);
5084 args_size.constant += argvec[count].locate.size.constant;
5085 gcc_assert (!argvec[count].locate.size.var);
5087 #ifdef BLOCK_REG_PADDING
5089 /* The argument is passed entirely in registers. See at which
5090 end it should be padded. */
5091 argvec[count].locate.where_pad =
5092 BLOCK_REG_PADDING (mode, NULL_TREE,
5093 known_le (GET_MODE_SIZE (mode), UNITS_PER_WORD));
5096 targetm.calls.function_arg_advance (args_so_far, mode, (tree) 0, true);
5099 /* If this machine requires an external definition for library
5100 functions, write one out. */
5101 assemble_external_libcall (fun);
5103 original_args_size = args_size;
5104 args_size.constant = (aligned_upper_bound (args_size.constant
5105 + stack_pointer_delta,
5107 - stack_pointer_delta);
5109 args_size.constant = upper_bound (args_size.constant,
5110 reg_parm_stack_space);
5112 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
5113 args_size.constant -= reg_parm_stack_space;
5115 crtl->outgoing_args_size = upper_bound (crtl->outgoing_args_size,
5116 args_size.constant);
5118 if (flag_stack_usage_info && !ACCUMULATE_OUTGOING_ARGS)
5120 poly_int64 pushed = args_size.constant + pending_stack_adjust;
5121 current_function_pushed_stack_size
5122 = upper_bound (current_function_pushed_stack_size, pushed);
5125 if (ACCUMULATE_OUTGOING_ARGS)
5127 /* Since the stack pointer will never be pushed, it is possible for
5128 the evaluation of a parm to clobber something we have already
5129 written to the stack. Since most function calls on RISC machines
5130 do not use the stack, this is uncommon, but must work correctly.
5132 Therefore, we save any area of the stack that was already written
5133 and that we are using. Here we set up to do this by making a new
5134 stack usage map from the old one.
5136 Another approach might be to try to reorder the argument
5137 evaluations to avoid this conflicting stack usage. */
5139 needed = args_size.constant;
5141 /* Since we will be writing into the entire argument area, the
5142 map must be allocated for its entire size, not just the part that
5143 is the responsibility of the caller. */
5144 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
5145 needed += reg_parm_stack_space;
5147 poly_int64 limit = needed;
5148 if (ARGS_GROW_DOWNWARD)
5151 /* For polynomial sizes, this is the maximum possible size needed
5152 for arguments with a constant size and offset. */
5153 HOST_WIDE_INT const_limit = constant_lower_bound (limit);
5154 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
5157 stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
5158 stack_usage_map = stack_usage_map_buf;
5160 if (initial_highest_arg_in_use)
5161 memcpy (stack_usage_map, initial_stack_usage_map,
5162 initial_highest_arg_in_use);
5164 if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
5165 memset (&stack_usage_map[initial_highest_arg_in_use], 0,
5166 highest_outgoing_arg_in_use - initial_highest_arg_in_use);
5169 /* We must be careful to use virtual regs before they're instantiated,
5170 and real regs afterwards. Loop optimization, for example, can create
5171 new libcalls after we've instantiated the virtual regs, and if we
5172 use virtuals anyway, they won't match the rtl patterns. */
5174 if (virtuals_instantiated)
5175 argblock = plus_constant (Pmode, stack_pointer_rtx,
5176 STACK_POINTER_OFFSET);
5178 argblock = virtual_outgoing_args_rtx;
5183 argblock = push_block (gen_int_mode (args_size.constant, Pmode), 0, 0);
5186 /* We push args individually in reverse order, perform stack alignment
5187 before the first push (the last arg). */
5189 anti_adjust_stack (gen_int_mode (args_size.constant
5190 - original_args_size.constant,
5195 #ifdef REG_PARM_STACK_SPACE
5196 if (ACCUMULATE_OUTGOING_ARGS)
5198 /* The argument list is the property of the called routine and it
5199 may clobber it. If the fixed area has been used for previous
5200 parameters, we must save and restore it. */
5201 save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
5202 &low_to_save, &high_to_save);
5206 /* When expanding a normal call, args are stored in push order,
5207 which is the reverse of what we have here. */
5208 bool any_regs = false;
5209 for (int i = nargs; i-- > 0; )
5210 if (argvec[i].reg != NULL_RTX)
5212 targetm.calls.call_args (argvec[i].reg, NULL_TREE);
5216 targetm.calls.call_args (pc_rtx, NULL_TREE);
5218 /* Push the args that need to be pushed. */
5220 have_push_fusage = false;
5222 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
5223 are to be pushed. */
5224 for (count = 0; count < nargs; count++, argnum--)
5226 machine_mode mode = argvec[argnum].mode;
5227 rtx val = argvec[argnum].value;
5228 rtx reg = argvec[argnum].reg;
5229 int partial = argvec[argnum].partial;
5230 unsigned int parm_align = argvec[argnum].locate.boundary;
5231 poly_int64 lower_bound = 0, upper_bound = 0;
5233 if (! (reg != 0 && partial == 0))
5237 if (ACCUMULATE_OUTGOING_ARGS)
5239 /* If this is being stored into a pre-allocated, fixed-size,
5240 stack area, save any previous data at that location. */
5242 if (ARGS_GROW_DOWNWARD)
5244 /* stack_slot is negative, but we want to index stack_usage_map
5245 with positive values. */
5246 upper_bound = -argvec[argnum].locate.slot_offset.constant + 1;
5247 lower_bound = upper_bound - argvec[argnum].locate.size.constant;
5251 lower_bound = argvec[argnum].locate.slot_offset.constant;
5252 upper_bound = lower_bound + argvec[argnum].locate.size.constant;
5255 if (stack_region_maybe_used_p (lower_bound, upper_bound,
5256 reg_parm_stack_space))
5258 /* We need to make a save area. */
5260 = argvec[argnum].locate.size.constant * BITS_PER_UNIT;
5261 machine_mode save_mode
5262 = int_mode_for_size (size, 1).else_blk ();
5264 = plus_constant (Pmode, argblock,
5265 argvec[argnum].locate.offset.constant);
5267 = gen_rtx_MEM (save_mode, memory_address (save_mode, adr));
5269 if (save_mode == BLKmode)
5271 argvec[argnum].save_area
5272 = assign_stack_temp (BLKmode,
5273 argvec[argnum].locate.size.constant
5276 emit_block_move (validize_mem
5277 (copy_rtx (argvec[argnum].save_area)),
5280 (argvec[argnum].locate.size.constant,
5282 BLOCK_OP_CALL_PARM);
5286 argvec[argnum].save_area = gen_reg_rtx (save_mode);
5288 emit_move_insn (argvec[argnum].save_area, stack_area);
5293 emit_push_insn (val, mode, NULL_TREE, NULL_RTX, parm_align,
5294 partial, reg, 0, argblock,
5296 (argvec[argnum].locate.offset.constant, Pmode)),
5297 reg_parm_stack_space,
5298 ARGS_SIZE_RTX (argvec[argnum].locate.alignment_pad), false);
5300 /* Now mark the segment we just used. */
5301 if (ACCUMULATE_OUTGOING_ARGS)
5302 mark_stack_region_used (lower_bound, upper_bound);
5306 /* Indicate argument access so that alias.c knows that these
5309 use = plus_constant (Pmode, argblock,
5310 argvec[argnum].locate.offset.constant);
5311 else if (have_push_fusage)
5315 /* When arguments are pushed, trying to tell alias.c where
5316 exactly this argument is won't work, because the
5317 auto-increment causes confusion. So we merely indicate
5318 that we access something with a known mode somewhere on
5320 use = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
5321 gen_rtx_SCRATCH (Pmode));
5322 have_push_fusage = true;
5324 use = gen_rtx_MEM (argvec[argnum].mode, use);
5325 use = gen_rtx_USE (VOIDmode, use);
5326 call_fusage = gen_rtx_EXPR_LIST (VOIDmode, use, call_fusage);
5332 fun = prepare_call_address (NULL, fun, NULL, &call_fusage, 0, 0);
5334 /* Now load any reg parms into their regs. */
5336 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
5337 are to be pushed. */
5338 for (count = 0; count < nargs; count++, argnum--)
5340 machine_mode mode = argvec[argnum].mode;
5341 rtx val = argvec[argnum].value;
5342 rtx reg = argvec[argnum].reg;
5343 int partial = argvec[argnum].partial;
5345 /* Handle calls that pass values in multiple non-contiguous
5346 locations. The PA64 has examples of this for library calls. */
5347 if (reg != 0 && GET_CODE (reg) == PARALLEL)
5348 emit_group_load (reg, val, NULL_TREE, GET_MODE_SIZE (mode));
5349 else if (reg != 0 && partial == 0)
5351 emit_move_insn (reg, val);
5352 #ifdef BLOCK_REG_PADDING
5353 poly_int64 size = GET_MODE_SIZE (argvec[argnum].mode);
5355 /* Copied from load_register_parameters. */
5357 /* Handle case where we have a value that needs shifting
5358 up to the msb. eg. a QImode value and we're padding
5359 upward on a BYTES_BIG_ENDIAN machine. */
5360 if (known_lt (size, UNITS_PER_WORD)
5361 && (argvec[argnum].locate.where_pad
5362 == (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD)))
5365 poly_int64 shift = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
5367 /* Assigning REG here rather than a temp makes CALL_FUSAGE
5368 report the whole reg as used. Strictly speaking, the
5369 call only uses SIZE bytes at the msb end, but it doesn't
5370 seem worth generating rtl to say that. */
5371 reg = gen_rtx_REG (word_mode, REGNO (reg));
5372 x = expand_shift (LSHIFT_EXPR, word_mode, reg, shift, reg, 1);
5374 emit_move_insn (reg, x);
5382 /* Any regs containing parms remain in use through the call. */
5383 for (count = 0; count < nargs; count++)
5385 rtx reg = argvec[count].reg;
5386 if (reg != 0 && GET_CODE (reg) == PARALLEL)
5387 use_group_regs (&call_fusage, reg);
5390 int partial = argvec[count].partial;
5394 gcc_assert (partial % UNITS_PER_WORD == 0);
5395 nregs = partial / UNITS_PER_WORD;
5396 use_regs (&call_fusage, REGNO (reg), nregs);
5399 use_reg (&call_fusage, reg);
5403 /* Pass the function the address in which to return a structure value. */
5404 if (mem_value != 0 && struct_value != 0 && ! pcc_struct_value)
5406 emit_move_insn (struct_value,
5408 force_operand (XEXP (mem_value, 0),
5410 if (REG_P (struct_value))
5411 use_reg (&call_fusage, struct_value);
5414 /* Don't allow popping to be deferred, since then
5415 cse'ing of library calls could delete a call and leave the pop. */
5417 valreg = (mem_value == 0 && outmode != VOIDmode
5418 ? hard_libcall_value (outmode, orgfun) : NULL_RTX);
5420 /* Stack must be properly aligned now. */
5421 gcc_assert (multiple_p (stack_pointer_delta,
5422 PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT));
5424 before_call = get_last_insn ();
5426 /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
5427 will set inhibit_defer_pop to that value. */
5428 /* The return type is needed to decide how many bytes the function pops.
5429 Signedness plays no role in that, so for simplicity, we pretend it's
5430 always signed. We also assume that the list of arguments passed has
5431 no impact, so we pretend it is unknown. */
5433 emit_call_1 (fun, NULL,
5434 get_identifier (XSTR (orgfun, 0)),
5435 build_function_type (tfom, NULL_TREE),
5436 original_args_size.constant, args_size.constant,
5438 targetm.calls.function_arg (args_so_far,
5439 VOIDmode, void_type_node, true),
5441 old_inhibit_defer_pop + 1, call_fusage, flags, args_so_far);
5446 gcc_assert (GET_CODE (datum) == SYMBOL_REF);
5447 rtx_call_insn *last = last_call_insn ();
5448 add_reg_note (last, REG_CALL_DECL, datum);
5451 /* Right-shift returned value if necessary. */
5452 if (!pcc_struct_value
5453 && TYPE_MODE (tfom) != BLKmode
5454 && targetm.calls.return_in_msb (tfom))
5456 shift_return_value (TYPE_MODE (tfom), false, valreg);
5457 valreg = gen_rtx_REG (TYPE_MODE (tfom), REGNO (valreg));
5460 targetm.calls.end_call_args ();
5462 /* For calls to `setjmp', etc., inform function.c:setjmp_warnings
5463 that it should complain if nonvolatile values are live. For
5464 functions that cannot return, inform flow that control does not
5466 if (flags & ECF_NORETURN)
5468 /* The barrier note must be emitted
5469 immediately after the CALL_INSN. Some ports emit more than
5470 just a CALL_INSN above, so we must search for it here. */
5471 rtx_insn *last = get_last_insn ();
5472 while (!CALL_P (last))
5474 last = PREV_INSN (last);
5475 /* There was no CALL_INSN? */
5476 gcc_assert (last != before_call);
5479 emit_barrier_after (last);
5482 /* Consider that "regular" libcalls, i.e. all of them except for LCT_THROW
5483 and LCT_RETURNS_TWICE, cannot perform non-local gotos. */
5484 if (flags & ECF_NOTHROW)
5486 rtx_insn *last = get_last_insn ();
5487 while (!CALL_P (last))
5489 last = PREV_INSN (last);
5490 /* There was no CALL_INSN? */
5491 gcc_assert (last != before_call);
5494 make_reg_eh_region_note_nothrow_nononlocal (last);
5497 /* Now restore inhibit_defer_pop to its actual original value. */
5502 /* Copy the value to the right place. */
5503 if (outmode != VOIDmode && retval)
5509 if (value != mem_value)
5510 emit_move_insn (value, mem_value);
5512 else if (GET_CODE (valreg) == PARALLEL)
5515 value = gen_reg_rtx (outmode);
5516 emit_group_store (value, valreg, NULL_TREE, GET_MODE_SIZE (outmode));
5520 /* Convert to the proper mode if a promotion has been active. */
5521 if (GET_MODE (valreg) != outmode)
5523 int unsignedp = TYPE_UNSIGNED (tfom);
5525 gcc_assert (promote_function_mode (tfom, outmode, &unsignedp,
5526 fndecl ? TREE_TYPE (fndecl) : fntype, 1)
5527 == GET_MODE (valreg));
5528 valreg = convert_modes (outmode, GET_MODE (valreg), valreg, 0);
5532 emit_move_insn (value, valreg);
5538 if (ACCUMULATE_OUTGOING_ARGS)
5540 #ifdef REG_PARM_STACK_SPACE
5542 restore_fixed_argument_area (save_area, argblock,
5543 high_to_save, low_to_save);
5546 /* If we saved any argument areas, restore them. */
5547 for (count = 0; count < nargs; count++)
5548 if (argvec[count].save_area)
5550 machine_mode save_mode = GET_MODE (argvec[count].save_area);
5551 rtx adr = plus_constant (Pmode, argblock,
5552 argvec[count].locate.offset.constant);
5553 rtx stack_area = gen_rtx_MEM (save_mode,
5554 memory_address (save_mode, adr));
5556 if (save_mode == BLKmode)
5557 emit_block_move (stack_area,
5559 (copy_rtx (argvec[count].save_area)),
5561 (argvec[count].locate.size.constant, Pmode)),
5562 BLOCK_OP_CALL_PARM);
5564 emit_move_insn (stack_area, argvec[count].save_area);
5567 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
5568 stack_usage_map = initial_stack_usage_map;
5569 stack_usage_watermark = initial_stack_usage_watermark;
5572 free (stack_usage_map_buf);
5579 /* Store pointer bounds argument ARG into Bounds Table entry
5580 associated with PARM. */
5582 store_bounds (struct arg_data *arg, struct arg_data *parm)
5584 rtx slot = NULL, ptr = NULL, addr = NULL;
5586 /* We may pass bounds not associated with any pointer. */
5589 gcc_assert (arg->special_slot);
5590 slot = arg->special_slot;
5593 /* Find pointer associated with bounds and where it is
5599 gcc_assert (!arg->special_slot);
5601 addr = adjust_address (parm->stack, Pmode, arg->pointer_offset);
5603 else if (REG_P (parm->reg))
5605 gcc_assert (arg->special_slot);
5606 slot = arg->special_slot;
5608 if (MEM_P (parm->value))
5609 addr = adjust_address (parm->value, Pmode, arg->pointer_offset);
5610 else if (REG_P (parm->value))
5611 ptr = gen_rtx_SUBREG (Pmode, parm->value, arg->pointer_offset);
5614 gcc_assert (!arg->pointer_offset);
5620 gcc_assert (GET_CODE (parm->reg) == PARALLEL);
5622 gcc_assert (arg->special_slot);
5623 slot = arg->special_slot;
5625 if (parm->parallel_value)
5626 ptr = chkp_get_value_with_offs (parm->parallel_value,
5627 GEN_INT (arg->pointer_offset));
5633 /* Expand bounds. */
5635 arg->value = expand_normal (arg->tree_value);
5637 targetm.calls.store_bounds_for_arg (ptr, addr, arg->value, slot);
5640 /* Store a single argument for a function call
5641 into the register or memory area where it must be passed.
5642 *ARG describes the argument value and where to pass it.
5644 ARGBLOCK is the address of the stack-block for all the arguments,
5645 or 0 on a machine where arguments are pushed individually.
5647 MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
5648 so must be careful about how the stack is used.
5650 VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
5651 argument stack. This is used if ACCUMULATE_OUTGOING_ARGS to indicate
5652 that we need not worry about saving and restoring the stack.
5654 FNDECL is the declaration of the function we are calling.
5656 Return nonzero if this arg should cause sibcall failure,
5660 store_one_arg (struct arg_data *arg, rtx argblock, int flags,
5661 int variable_size ATTRIBUTE_UNUSED, int reg_parm_stack_space)
5663 tree pval = arg->tree_value;
5666 poly_int64 used = 0;
5667 poly_int64 lower_bound = 0, upper_bound = 0;
5668 int sibcall_failure = 0;
5670 if (TREE_CODE (pval) == ERROR_MARK)
5673 /* Push a new temporary level for any temporaries we make for
5677 if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL))
5679 /* If this is being stored into a pre-allocated, fixed-size, stack area,
5680 save any previous data at that location. */
5681 if (argblock && ! variable_size && arg->stack)
5683 if (ARGS_GROW_DOWNWARD)
5685 /* stack_slot is negative, but we want to index stack_usage_map
5686 with positive values. */
5687 if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
5689 rtx offset = XEXP (XEXP (arg->stack_slot, 0), 1);
5690 upper_bound = -rtx_to_poly_int64 (offset) + 1;
5695 lower_bound = upper_bound - arg->locate.size.constant;
5699 if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
5701 rtx offset = XEXP (XEXP (arg->stack_slot, 0), 1);
5702 lower_bound = rtx_to_poly_int64 (offset);
5707 upper_bound = lower_bound + arg->locate.size.constant;
5710 if (stack_region_maybe_used_p (lower_bound, upper_bound,
5711 reg_parm_stack_space))
5713 /* We need to make a save area. */
5714 poly_uint64 size = arg->locate.size.constant * BITS_PER_UNIT;
5715 machine_mode save_mode
5716 = int_mode_for_size (size, 1).else_blk ();
5717 rtx adr = memory_address (save_mode, XEXP (arg->stack_slot, 0));
5718 rtx stack_area = gen_rtx_MEM (save_mode, adr);
5720 if (save_mode == BLKmode)
5723 = assign_temp (TREE_TYPE (arg->tree_value), 1, 1);
5724 preserve_temp_slots (arg->save_area);
5725 emit_block_move (validize_mem (copy_rtx (arg->save_area)),
5728 (arg->locate.size.constant, Pmode)),
5729 BLOCK_OP_CALL_PARM);
5733 arg->save_area = gen_reg_rtx (save_mode);
5734 emit_move_insn (arg->save_area, stack_area);
5740 /* If this isn't going to be placed on both the stack and in registers,
5741 set up the register and number of words. */
5742 if (! arg->pass_on_stack)
5744 if (flags & ECF_SIBCALL)
5745 reg = arg->tail_call_reg;
5748 partial = arg->partial;
5751 /* Being passed entirely in a register. We shouldn't be called in
5753 gcc_assert (reg == 0 || partial != 0);
5755 /* If this arg needs special alignment, don't load the registers
5757 if (arg->n_aligned_regs != 0)
5760 /* If this is being passed partially in a register, we can't evaluate
5761 it directly into its stack slot. Otherwise, we can. */
5762 if (arg->value == 0)
5764 /* stack_arg_under_construction is nonzero if a function argument is
5765 being evaluated directly into the outgoing argument list and
5766 expand_call must take special action to preserve the argument list
5767 if it is called recursively.
5769 For scalar function arguments stack_usage_map is sufficient to
5770 determine which stack slots must be saved and restored. Scalar
5771 arguments in general have pass_on_stack == 0.
5773 If this argument is initialized by a function which takes the
5774 address of the argument (a C++ constructor or a C function
5775 returning a BLKmode structure), then stack_usage_map is
5776 insufficient and expand_call must push the stack around the
5777 function call. Such arguments have pass_on_stack == 1.
5779 Note that it is always safe to set stack_arg_under_construction,
5780 but this generates suboptimal code if set when not needed. */
5782 if (arg->pass_on_stack)
5783 stack_arg_under_construction++;
5785 arg->value = expand_expr (pval,
5787 || TYPE_MODE (TREE_TYPE (pval)) != arg->mode)
5788 ? NULL_RTX : arg->stack,
5789 VOIDmode, EXPAND_STACK_PARM);
5791 /* If we are promoting object (or for any other reason) the mode
5792 doesn't agree, convert the mode. */
5794 if (arg->mode != TYPE_MODE (TREE_TYPE (pval)))
5795 arg->value = convert_modes (arg->mode, TYPE_MODE (TREE_TYPE (pval)),
5796 arg->value, arg->unsignedp);
5798 if (arg->pass_on_stack)
5799 stack_arg_under_construction--;
5802 /* Check for overlap with already clobbered argument area. */
5803 if ((flags & ECF_SIBCALL)
5804 && MEM_P (arg->value)
5805 && mem_might_overlap_already_clobbered_arg_p (XEXP (arg->value, 0),
5806 arg->locate.size.constant))
5807 sibcall_failure = 1;
5809 /* Don't allow anything left on stack from computation
5810 of argument to alloca. */
5811 if (flags & ECF_MAY_BE_ALLOCA)
5812 do_pending_stack_adjust ();
5814 if (arg->value == arg->stack)
5815 /* If the value is already in the stack slot, we are done. */
5817 else if (arg->mode != BLKmode)
5819 unsigned int parm_align;
5821 /* Argument is a scalar, not entirely passed in registers.
5822 (If part is passed in registers, arg->partial says how much
5823 and emit_push_insn will take care of putting it there.)
5825 Push it, and if its size is less than the
5826 amount of space allocated to it,
5827 also bump stack pointer by the additional space.
5828 Note that in C the default argument promotions
5829 will prevent such mismatches. */
5831 poly_int64 size = (TYPE_EMPTY_P (TREE_TYPE (pval))
5832 ? 0 : GET_MODE_SIZE (arg->mode));
5834 /* Compute how much space the push instruction will push.
5835 On many machines, pushing a byte will advance the stack
5836 pointer by a halfword. */
5837 #ifdef PUSH_ROUNDING
5838 size = PUSH_ROUNDING (size);
5842 /* Compute how much space the argument should get:
5843 round up to a multiple of the alignment for arguments. */
5844 if (targetm.calls.function_arg_padding (arg->mode, TREE_TYPE (pval))
5846 /* At the moment we don't (need to) support ABIs for which the
5847 padding isn't known at compile time. In principle it should
5848 be easy to add though. */
5849 used = force_align_up (size, PARM_BOUNDARY / BITS_PER_UNIT);
5851 /* Compute the alignment of the pushed argument. */
5852 parm_align = arg->locate.boundary;
5853 if (targetm.calls.function_arg_padding (arg->mode, TREE_TYPE (pval))
5856 poly_int64 pad = used - size;
5857 unsigned int pad_align = known_alignment (pad) * BITS_PER_UNIT;
5859 parm_align = MIN (parm_align, pad_align);
5862 /* This isn't already where we want it on the stack, so put it there.
5863 This can either be done with push or copy insns. */
5864 if (maybe_ne (used, 0)
5865 && !emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval),
5866 NULL_RTX, parm_align, partial, reg, used - size,
5867 argblock, ARGS_SIZE_RTX (arg->locate.offset),
5868 reg_parm_stack_space,
5869 ARGS_SIZE_RTX (arg->locate.alignment_pad), true))
5870 sibcall_failure = 1;
5872 /* Unless this is a partially-in-register argument, the argument is now
5875 arg->value = arg->stack;
5879 /* BLKmode, at least partly to be pushed. */
5881 unsigned int parm_align;
5885 /* Pushing a nonscalar.
5886 If part is passed in registers, PARTIAL says how much
5887 and emit_push_insn will take care of putting it there. */
5889 /* Round its size up to a multiple
5890 of the allocation unit for arguments. */
5892 if (arg->locate.size.var != 0)
5895 size_rtx = ARGS_SIZE_RTX (arg->locate.size);
5899 /* PUSH_ROUNDING has no effect on us, because emit_push_insn
5900 for BLKmode is careful to avoid it. */
5901 excess = (arg->locate.size.constant
5902 - arg_int_size_in_bytes (TREE_TYPE (pval))
5904 size_rtx = expand_expr (arg_size_in_bytes (TREE_TYPE (pval)),
5905 NULL_RTX, TYPE_MODE (sizetype),
5909 parm_align = arg->locate.boundary;
5911 /* When an argument is padded down, the block is aligned to
5912 PARM_BOUNDARY, but the actual argument isn't. */
5913 if (targetm.calls.function_arg_padding (arg->mode, TREE_TYPE (pval))
5916 if (arg->locate.size.var)
5917 parm_align = BITS_PER_UNIT;
5920 unsigned int excess_align
5921 = known_alignment (excess) * BITS_PER_UNIT;
5922 if (excess_align != 0)
5923 parm_align = MIN (parm_align, excess_align);
5927 if ((flags & ECF_SIBCALL) && MEM_P (arg->value))
5929 /* emit_push_insn might not work properly if arg->value and
5930 argblock + arg->locate.offset areas overlap. */
5934 if (XEXP (x, 0) == crtl->args.internal_arg_pointer
5935 || (GET_CODE (XEXP (x, 0)) == PLUS
5936 && XEXP (XEXP (x, 0), 0) ==
5937 crtl->args.internal_arg_pointer
5938 && CONST_INT_P (XEXP (XEXP (x, 0), 1))))
5940 if (XEXP (x, 0) != crtl->args.internal_arg_pointer)
5941 i = rtx_to_poly_int64 (XEXP (XEXP (x, 0), 1));
5943 /* arg.locate doesn't contain the pretend_args_size offset,
5944 it's part of argblock. Ensure we don't count it in I. */
5945 if (STACK_GROWS_DOWNWARD)
5946 i -= crtl->args.pretend_args_size;
5948 i += crtl->args.pretend_args_size;
5950 /* expand_call should ensure this. */
5951 gcc_assert (!arg->locate.offset.var
5952 && arg->locate.size.var == 0);
5953 poly_int64 size_val = rtx_to_poly_int64 (size_rtx);
5955 if (known_eq (arg->locate.offset.constant, i))
5957 /* Even though they appear to be at the same location,
5958 if part of the outgoing argument is in registers,
5959 they aren't really at the same location. Check for
5960 this by making sure that the incoming size is the
5961 same as the outgoing size. */
5962 if (maybe_ne (arg->locate.size.constant, size_val))
5963 sibcall_failure = 1;
5965 else if (maybe_in_range_p (arg->locate.offset.constant,
5967 sibcall_failure = 1;
5968 /* Use arg->locate.size.constant instead of size_rtx
5969 because we only care about the part of the argument
5971 else if (maybe_in_range_p (i, arg->locate.offset.constant,
5972 arg->locate.size.constant))
5973 sibcall_failure = 1;
5977 if (!CONST_INT_P (size_rtx) || INTVAL (size_rtx) != 0)
5978 emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
5979 parm_align, partial, reg, excess, argblock,
5980 ARGS_SIZE_RTX (arg->locate.offset),
5981 reg_parm_stack_space,
5982 ARGS_SIZE_RTX (arg->locate.alignment_pad), false);
5984 /* Unless this is a partially-in-register argument, the argument is now
5987 ??? Unlike the case above, in which we want the actual
5988 address of the data, so that we can load it directly into a
5989 register, here we want the address of the stack slot, so that
5990 it's properly aligned for word-by-word copying or something
5991 like that. It's not clear that this is always correct. */
5993 arg->value = arg->stack_slot;
5996 if (arg->reg && GET_CODE (arg->reg) == PARALLEL)
5998 tree type = TREE_TYPE (arg->tree_value);
6000 = emit_group_load_into_temps (arg->reg, arg->value, type,
6001 int_size_in_bytes (type));
6004 /* Mark all slots this store used. */
6005 if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL)
6006 && argblock && ! variable_size && arg->stack)
6007 mark_stack_region_used (lower_bound, upper_bound);
6009 /* Once we have pushed something, pops can't safely
6010 be deferred during the rest of the arguments. */
6013 /* Free any temporary slots made in processing this argument. */
6016 return sibcall_failure;
6019 /* Nonzero if we do not know how to pass TYPE solely in registers. */
6022 must_pass_in_stack_var_size (machine_mode mode ATTRIBUTE_UNUSED,
6028 /* If the type has variable size... */
6029 if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
6032 /* If the type is marked as addressable (it is required
6033 to be constructed into the stack)... */
6034 if (TREE_ADDRESSABLE (type))
6040 /* Another version of the TARGET_MUST_PASS_IN_STACK hook. This one
6041 takes trailing padding of a structure into account. */
6042 /* ??? Should be able to merge these two by examining BLOCK_REG_PADDING. */
6045 must_pass_in_stack_var_size_or_pad (machine_mode mode, const_tree type)
6050 /* If the type has variable size... */
6051 if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
6054 /* If the type is marked as addressable (it is required
6055 to be constructed into the stack)... */
6056 if (TREE_ADDRESSABLE (type))
6059 if (TYPE_EMPTY_P (type))
6062 /* If the padding and mode of the type is such that a copy into
6063 a register would put it into the wrong part of the register. */
6065 && int_size_in_bytes (type) % (PARM_BOUNDARY / BITS_PER_UNIT)
6066 && (targetm.calls.function_arg_padding (mode, type)
6067 == (BYTES_BIG_ENDIAN ? PAD_UPWARD : PAD_DOWNWARD)))
6073 /* Tell the garbage collector about GTY markers in this source file. */
6074 #include "gt-calls.h"