1 /* Convert function calls to rtl insns, for GNU C compiler.
2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
4 2011 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
24 #include "coretypes.h"
35 #include "diagnostic-core.h"
40 #include "langhooks.h"
45 #include "tree-flow.h"
47 /* Like PREFERRED_STACK_BOUNDARY but in units of bytes, not bits. */
48 #define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)
50 /* Data structure and subroutines used within expand_call. */
54 /* Tree node for this argument. */
56 /* Mode for value; TYPE_MODE unless promoted. */
57 enum machine_mode mode
;
58 /* Current RTL value for argument, or 0 if it isn't precomputed. */
60 /* Initially-compute RTL value for argument; only for const functions. */
62 /* Register to pass this argument in, 0 if passed on stack, or an
63 PARALLEL if the arg is to be copied into multiple non-contiguous
66 /* Register to pass this argument in when generating tail call sequence.
67 This is not the same register as for normal calls on machines with
70 /* If REG is a PARALLEL, this is a copy of VALUE pulled into the correct
71 form for emit_group_move. */
73 /* If REG was promoted from the actual mode of the argument expression,
74 indicates whether the promotion is sign- or zero-extended. */
76 /* Number of bytes to put in registers. 0 means put the whole arg
77 in registers. Also 0 if not passed in registers. */
79 /* Nonzero if argument must be passed on stack.
80 Note that some arguments may be passed on the stack
81 even though pass_on_stack is zero, just because FUNCTION_ARG says so.
82 pass_on_stack identifies arguments that *cannot* go in registers. */
84 /* Some fields packaged up for locate_and_pad_parm. */
85 struct locate_and_pad_arg_data locate
;
86 /* Location on the stack at which parameter should be stored. The store
87 has already been done if STACK == VALUE. */
89 /* Location on the stack of the start of this argument slot. This can
90 differ from STACK if this arg pads downward. This location is known
91 to be aligned to TARGET_FUNCTION_ARG_BOUNDARY. */
93 /* Place that this stack area has been saved, if needed. */
95 /* If an argument's alignment does not permit direct copying into registers,
96 copy in smaller-sized pieces into pseudos. These are stored in a
97 block pointed to by this field. The next field says how many
98 word-sized pseudos we made. */
103 /* A vector of one char per byte of stack space. A byte if nonzero if
104 the corresponding stack location has been used.
105 This vector is used to prevent a function call within an argument from
106 clobbering any stack already set up. */
107 static char *stack_usage_map
;
109 /* Size of STACK_USAGE_MAP. */
110 static int highest_outgoing_arg_in_use
;
112 /* A bitmap of virtual-incoming stack space. Bit is set if the corresponding
113 stack location's tail call argument has been already stored into the stack.
114 This bitmap is used to prevent sibling call optimization if function tries
115 to use parent's incoming argument slots when they have been already
116 overwritten with tail call arguments. */
117 static sbitmap stored_args_map
;
119 /* stack_arg_under_construction is nonzero when an argument may be
120 initialized with a constructor call (including a C function that
121 returns a BLKmode struct) and expand_call must take special action
122 to make sure the object being constructed does not overlap the
123 argument list for the constructor call. */
124 static int stack_arg_under_construction
;
126 static void emit_call_1 (rtx
, tree
, tree
, tree
, HOST_WIDE_INT
, HOST_WIDE_INT
,
127 HOST_WIDE_INT
, rtx
, rtx
, int, rtx
, int,
129 static void precompute_register_parameters (int, struct arg_data
*, int *);
130 static int store_one_arg (struct arg_data
*, rtx
, int, int, int);
131 static void store_unaligned_arguments_into_pseudos (struct arg_data
*, int);
132 static int finalize_must_preallocate (int, int, struct arg_data
*,
134 static void precompute_arguments (int, struct arg_data
*);
135 static int compute_argument_block_size (int, struct args_size
*, tree
, tree
, int);
136 static void initialize_argument_information (int, struct arg_data
*,
137 struct args_size
*, int,
139 tree
, tree
, cumulative_args_t
, int,
140 rtx
*, int *, int *, int *,
142 static void compute_argument_addresses (struct arg_data
*, rtx
, int);
143 static rtx
rtx_for_function_call (tree
, tree
);
144 static void load_register_parameters (struct arg_data
*, int, rtx
*, int,
146 static rtx
emit_library_call_value_1 (int, rtx
, rtx
, enum libcall_type
,
147 enum machine_mode
, int, va_list);
148 static int special_function_p (const_tree
, int);
149 static int check_sibcall_argument_overlap_1 (rtx
);
150 static int check_sibcall_argument_overlap (rtx
, struct arg_data
*, int);
152 static int combine_pending_stack_adjustment_and_call (int, struct args_size
*,
154 static tree
split_complex_types (tree
);
156 #ifdef REG_PARM_STACK_SPACE
157 static rtx
save_fixed_argument_area (int, rtx
, int *, int *);
158 static void restore_fixed_argument_area (rtx
, rtx
, int, int);
161 /* Force FUNEXP into a form suitable for the address of a CALL,
162 and return that as an rtx. Also load the static chain register
163 if FNDECL is a nested function.
165 CALL_FUSAGE points to a variable holding the prospective
166 CALL_INSN_FUNCTION_USAGE information. */
169 prepare_call_address (tree fndecl
, rtx funexp
, rtx static_chain_value
,
170 rtx
*call_fusage
, int reg_parm_seen
, int sibcallp
)
172 /* Make a valid memory address and copy constants through pseudo-regs,
173 but not for a constant address if -fno-function-cse. */
174 if (GET_CODE (funexp
) != SYMBOL_REF
)
175 /* If we are using registers for parameters, force the
176 function address into a register now. */
177 funexp
= ((reg_parm_seen
178 && targetm
.small_register_classes_for_mode_p (FUNCTION_MODE
))
179 ? force_not_mem (memory_address (FUNCTION_MODE
, funexp
))
180 : memory_address (FUNCTION_MODE
, funexp
));
183 #ifndef NO_FUNCTION_CSE
184 if (optimize
&& ! flag_no_function_cse
)
185 funexp
= force_reg (Pmode
, funexp
);
189 if (static_chain_value
!= 0)
194 chain
= targetm
.calls
.static_chain (fndecl
, false);
195 static_chain_value
= convert_memory_address (Pmode
, static_chain_value
);
197 emit_move_insn (chain
, static_chain_value
);
199 use_reg (call_fusage
, chain
);
205 /* Generate instructions to call function FUNEXP,
206 and optionally pop the results.
207 The CALL_INSN is the first insn generated.
209 FNDECL is the declaration node of the function. This is given to the
210 hook TARGET_RETURN_POPS_ARGS to determine whether this function pops
213 FUNTYPE is the data type of the function. This is given to the hook
214 TARGET_RETURN_POPS_ARGS to determine whether this function pops its
215 own args. We used to allow an identifier for library functions, but
216 that doesn't work when the return type is an aggregate type and the
217 calling convention says that the pointer to this aggregate is to be
218 popped by the callee.
220 STACK_SIZE is the number of bytes of arguments on the stack,
221 ROUNDED_STACK_SIZE is that number rounded up to
222 PREFERRED_STACK_BOUNDARY; zero if the size is variable. This is
223 both to put into the call insn and to generate explicit popping
226 STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
227 It is zero if this call doesn't want a structure value.
229 NEXT_ARG_REG is the rtx that results from executing
230 targetm.calls.function_arg (&args_so_far, VOIDmode, void_type_node, true)
231 just after all the args have had their registers assigned.
232 This could be whatever you like, but normally it is the first
233 arg-register beyond those used for args in this call,
234 or 0 if all the arg-registers are used in this call.
235 It is passed on to `gen_call' so you can put this info in the call insn.
237 VALREG is a hard register in which a value is returned,
238 or 0 if the call does not return a value.
240 OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before
241 the args to this call were processed.
242 We restore `inhibit_defer_pop' to that value.
244 CALL_FUSAGE is either empty or an EXPR_LIST of USE expressions that
245 denote registers used by the called function. */
248 emit_call_1 (rtx funexp
, tree fntree ATTRIBUTE_UNUSED
, tree fndecl ATTRIBUTE_UNUSED
,
249 tree funtype ATTRIBUTE_UNUSED
,
250 HOST_WIDE_INT stack_size ATTRIBUTE_UNUSED
,
251 HOST_WIDE_INT rounded_stack_size
,
252 HOST_WIDE_INT struct_value_size ATTRIBUTE_UNUSED
,
253 rtx next_arg_reg ATTRIBUTE_UNUSED
, rtx valreg
,
254 int old_inhibit_defer_pop
, rtx call_fusage
, int ecf_flags
,
255 cumulative_args_t args_so_far ATTRIBUTE_UNUSED
)
257 rtx rounded_stack_size_rtx
= GEN_INT (rounded_stack_size
);
258 rtx call_insn
, call
, funmem
;
259 int already_popped
= 0;
260 HOST_WIDE_INT n_popped
261 = targetm
.calls
.return_pops_args (fndecl
, funtype
, stack_size
);
263 #ifdef CALL_POPS_ARGS
264 n_popped
+= CALL_POPS_ARGS (*get_cumulative_args (args_so_far
));
267 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
268 and we don't want to load it into a register as an optimization,
269 because prepare_call_address already did it if it should be done. */
270 if (GET_CODE (funexp
) != SYMBOL_REF
)
271 funexp
= memory_address (FUNCTION_MODE
, funexp
);
273 funmem
= gen_rtx_MEM (FUNCTION_MODE
, funexp
);
274 if (fndecl
&& TREE_CODE (fndecl
) == FUNCTION_DECL
)
278 /* Although a built-in FUNCTION_DECL and its non-__builtin
279 counterpart compare equal and get a shared mem_attrs, they
280 produce different dump output in compare-debug compilations,
281 if an entry gets garbage collected in one compilation, then
282 adds a different (but equivalent) entry, while the other
283 doesn't run the garbage collector at the same spot and then
284 shares the mem_attr with the equivalent entry. */
285 if (DECL_BUILT_IN_CLASS (t
) == BUILT_IN_NORMAL
)
287 tree t2
= builtin_decl_explicit (DECL_FUNCTION_CODE (t
));
292 set_mem_expr (funmem
, t
);
295 set_mem_expr (funmem
, build_simple_mem_ref (CALL_EXPR_FN (fntree
)));
297 #if defined (HAVE_sibcall_pop) && defined (HAVE_sibcall_value_pop)
298 if ((ecf_flags
& ECF_SIBCALL
)
299 && HAVE_sibcall_pop
&& HAVE_sibcall_value_pop
300 && (n_popped
> 0 || stack_size
== 0))
302 rtx n_pop
= GEN_INT (n_popped
);
305 /* If this subroutine pops its own args, record that in the call insn
306 if possible, for the sake of frame pointer elimination. */
309 pat
= GEN_SIBCALL_VALUE_POP (valreg
, funmem
, rounded_stack_size_rtx
,
310 next_arg_reg
, n_pop
);
312 pat
= GEN_SIBCALL_POP (funmem
, rounded_stack_size_rtx
, next_arg_reg
,
315 emit_call_insn (pat
);
321 #if defined (HAVE_call_pop) && defined (HAVE_call_value_pop)
322 /* If the target has "call" or "call_value" insns, then prefer them
323 if no arguments are actually popped. If the target does not have
324 "call" or "call_value" insns, then we must use the popping versions
325 even if the call has no arguments to pop. */
326 #if defined (HAVE_call) && defined (HAVE_call_value)
327 if (HAVE_call
&& HAVE_call_value
&& HAVE_call_pop
&& HAVE_call_value_pop
330 if (HAVE_call_pop
&& HAVE_call_value_pop
)
333 rtx n_pop
= GEN_INT (n_popped
);
336 /* If this subroutine pops its own args, record that in the call insn
337 if possible, for the sake of frame pointer elimination. */
340 pat
= GEN_CALL_VALUE_POP (valreg
, funmem
, rounded_stack_size_rtx
,
341 next_arg_reg
, n_pop
);
343 pat
= GEN_CALL_POP (funmem
, rounded_stack_size_rtx
, next_arg_reg
,
346 emit_call_insn (pat
);
352 #if defined (HAVE_sibcall) && defined (HAVE_sibcall_value)
353 if ((ecf_flags
& ECF_SIBCALL
)
354 && HAVE_sibcall
&& HAVE_sibcall_value
)
357 emit_call_insn (GEN_SIBCALL_VALUE (valreg
, funmem
,
358 rounded_stack_size_rtx
,
359 next_arg_reg
, NULL_RTX
));
361 emit_call_insn (GEN_SIBCALL (funmem
, rounded_stack_size_rtx
,
363 GEN_INT (struct_value_size
)));
368 #if defined (HAVE_call) && defined (HAVE_call_value)
369 if (HAVE_call
&& HAVE_call_value
)
372 emit_call_insn (GEN_CALL_VALUE (valreg
, funmem
, rounded_stack_size_rtx
,
373 next_arg_reg
, NULL_RTX
));
375 emit_call_insn (GEN_CALL (funmem
, rounded_stack_size_rtx
, next_arg_reg
,
376 GEN_INT (struct_value_size
)));
382 /* Find the call we just emitted. */
383 call_insn
= last_call_insn ();
385 /* Some target create a fresh MEM instead of reusing the one provided
386 above. Set its MEM_EXPR. */
387 call
= PATTERN (call_insn
);
388 if (GET_CODE (call
) == PARALLEL
)
389 call
= XVECEXP (call
, 0, 0);
390 if (GET_CODE (call
) == SET
)
391 call
= SET_SRC (call
);
392 if (GET_CODE (call
) == CALL
393 && MEM_P (XEXP (call
, 0))
394 && MEM_EXPR (XEXP (call
, 0)) == NULL_TREE
395 && MEM_EXPR (funmem
) != NULL_TREE
)
396 set_mem_expr (XEXP (call
, 0), MEM_EXPR (funmem
));
398 /* Put the register usage information there. */
399 add_function_usage_to (call_insn
, call_fusage
);
401 /* If this is a const call, then set the insn's unchanging bit. */
402 if (ecf_flags
& ECF_CONST
)
403 RTL_CONST_CALL_P (call_insn
) = 1;
405 /* If this is a pure call, then set the insn's unchanging bit. */
406 if (ecf_flags
& ECF_PURE
)
407 RTL_PURE_CALL_P (call_insn
) = 1;
409 /* If this is a const call, then set the insn's unchanging bit. */
410 if (ecf_flags
& ECF_LOOPING_CONST_OR_PURE
)
411 RTL_LOOPING_CONST_OR_PURE_CALL_P (call_insn
) = 1;
413 /* Create a nothrow REG_EH_REGION note, if needed. */
414 make_reg_eh_region_note (call_insn
, ecf_flags
, 0);
416 if (ecf_flags
& ECF_NORETURN
)
417 add_reg_note (call_insn
, REG_NORETURN
, const0_rtx
);
419 if (ecf_flags
& ECF_RETURNS_TWICE
)
421 add_reg_note (call_insn
, REG_SETJMP
, const0_rtx
);
422 cfun
->calls_setjmp
= 1;
425 SIBLING_CALL_P (call_insn
) = ((ecf_flags
& ECF_SIBCALL
) != 0);
427 /* Restore this now, so that we do defer pops for this call's args
428 if the context of the call as a whole permits. */
429 inhibit_defer_pop
= old_inhibit_defer_pop
;
434 CALL_INSN_FUNCTION_USAGE (call_insn
)
435 = gen_rtx_EXPR_LIST (VOIDmode
,
436 gen_rtx_CLOBBER (VOIDmode
, stack_pointer_rtx
),
437 CALL_INSN_FUNCTION_USAGE (call_insn
));
438 rounded_stack_size
-= n_popped
;
439 rounded_stack_size_rtx
= GEN_INT (rounded_stack_size
);
440 stack_pointer_delta
-= n_popped
;
442 add_reg_note (call_insn
, REG_ARGS_SIZE
, GEN_INT (stack_pointer_delta
));
444 /* If popup is needed, stack realign must use DRAP */
445 if (SUPPORTS_STACK_ALIGNMENT
)
446 crtl
->need_drap
= true;
449 if (!ACCUMULATE_OUTGOING_ARGS
)
451 /* If returning from the subroutine does not automatically pop the args,
452 we need an instruction to pop them sooner or later.
453 Perhaps do it now; perhaps just record how much space to pop later.
455 If returning from the subroutine does pop the args, indicate that the
456 stack pointer will be changed. */
458 if (rounded_stack_size
!= 0)
460 if (ecf_flags
& ECF_NORETURN
)
461 /* Just pretend we did the pop. */
462 stack_pointer_delta
-= rounded_stack_size
;
463 else if (flag_defer_pop
&& inhibit_defer_pop
== 0
464 && ! (ecf_flags
& (ECF_CONST
| ECF_PURE
)))
465 pending_stack_adjust
+= rounded_stack_size
;
467 adjust_stack (rounded_stack_size_rtx
);
470 /* When we accumulate outgoing args, we must avoid any stack manipulations.
471 Restore the stack pointer to its original value now. Usually
472 ACCUMULATE_OUTGOING_ARGS targets don't get here, but there are exceptions.
473 On i386 ACCUMULATE_OUTGOING_ARGS can be enabled on demand, and
474 popping variants of functions exist as well.
476 ??? We may optimize similar to defer_pop above, but it is
477 probably not worthwhile.
479 ??? It will be worthwhile to enable combine_stack_adjustments even for
482 anti_adjust_stack (GEN_INT (n_popped
));
485 /* Determine if the function identified by NAME and FNDECL is one with
486 special properties we wish to know about.
488 For example, if the function might return more than one time (setjmp), then
489 set RETURNS_TWICE to a nonzero value.
491 Similarly set NORETURN if the function is in the longjmp family.
493 Set MAY_BE_ALLOCA for any memory allocation function that might allocate
494 space from the stack such as alloca. */
497 special_function_p (const_tree fndecl
, int flags
)
499 if (fndecl
&& DECL_NAME (fndecl
)
500 && IDENTIFIER_LENGTH (DECL_NAME (fndecl
)) <= 17
501 /* Exclude functions not at the file scope, or not `extern',
502 since they are not the magic functions we would otherwise
504 FIXME: this should be handled with attributes, not with this
505 hacky imitation of DECL_ASSEMBLER_NAME. It's (also) wrong
506 because you can declare fork() inside a function if you
508 && (DECL_CONTEXT (fndecl
) == NULL_TREE
509 || TREE_CODE (DECL_CONTEXT (fndecl
)) == TRANSLATION_UNIT_DECL
)
510 && TREE_PUBLIC (fndecl
))
512 const char *name
= IDENTIFIER_POINTER (DECL_NAME (fndecl
));
513 const char *tname
= name
;
515 /* We assume that alloca will always be called by name. It
516 makes no sense to pass it as a pointer-to-function to
517 anything that does not understand its behavior. */
518 if (((IDENTIFIER_LENGTH (DECL_NAME (fndecl
)) == 6
520 && ! strcmp (name
, "alloca"))
521 || (IDENTIFIER_LENGTH (DECL_NAME (fndecl
)) == 16
523 && ! strcmp (name
, "__builtin_alloca"))))
524 flags
|= ECF_MAY_BE_ALLOCA
;
526 /* Disregard prefix _, __, __x or __builtin_. */
531 && !strncmp (name
+ 3, "uiltin_", 7))
533 else if (name
[1] == '_' && name
[2] == 'x')
535 else if (name
[1] == '_')
544 && (! strcmp (tname
, "setjmp")
545 || ! strcmp (tname
, "setjmp_syscall")))
547 && ! strcmp (tname
, "sigsetjmp"))
549 && ! strcmp (tname
, "savectx")))
550 flags
|= ECF_RETURNS_TWICE
;
553 && ! strcmp (tname
, "siglongjmp"))
554 flags
|= ECF_NORETURN
;
556 else if ((tname
[0] == 'q' && tname
[1] == 's'
557 && ! strcmp (tname
, "qsetjmp"))
558 || (tname
[0] == 'v' && tname
[1] == 'f'
559 && ! strcmp (tname
, "vfork"))
560 || (tname
[0] == 'g' && tname
[1] == 'e'
561 && !strcmp (tname
, "getcontext")))
562 flags
|= ECF_RETURNS_TWICE
;
564 else if (tname
[0] == 'l' && tname
[1] == 'o'
565 && ! strcmp (tname
, "longjmp"))
566 flags
|= ECF_NORETURN
;
572 /* Return nonzero when FNDECL represents a call to setjmp. */
575 setjmp_call_p (const_tree fndecl
)
577 if (DECL_IS_RETURNS_TWICE (fndecl
))
578 return ECF_RETURNS_TWICE
;
579 return special_function_p (fndecl
, 0) & ECF_RETURNS_TWICE
;
583 /* Return true if STMT is an alloca call. */
586 gimple_alloca_call_p (const_gimple stmt
)
590 if (!is_gimple_call (stmt
))
593 fndecl
= gimple_call_fndecl (stmt
);
594 if (fndecl
&& (special_function_p (fndecl
, 0) & ECF_MAY_BE_ALLOCA
))
600 /* Return true when exp contains alloca call. */
603 alloca_call_p (const_tree exp
)
605 if (TREE_CODE (exp
) == CALL_EXPR
606 && TREE_CODE (CALL_EXPR_FN (exp
)) == ADDR_EXPR
607 && (TREE_CODE (TREE_OPERAND (CALL_EXPR_FN (exp
), 0)) == FUNCTION_DECL
)
608 && (special_function_p (TREE_OPERAND (CALL_EXPR_FN (exp
), 0), 0)
609 & ECF_MAY_BE_ALLOCA
))
614 /* Detect flags (function attributes) from the function decl or type node. */
617 flags_from_decl_or_type (const_tree exp
)
623 /* The function exp may have the `malloc' attribute. */
624 if (DECL_IS_MALLOC (exp
))
627 /* The function exp may have the `returns_twice' attribute. */
628 if (DECL_IS_RETURNS_TWICE (exp
))
629 flags
|= ECF_RETURNS_TWICE
;
631 /* Process the pure and const attributes. */
632 if (TREE_READONLY (exp
))
634 if (DECL_PURE_P (exp
))
636 if (DECL_LOOPING_CONST_OR_PURE_P (exp
))
637 flags
|= ECF_LOOPING_CONST_OR_PURE
;
639 if (DECL_IS_NOVOPS (exp
))
641 if (lookup_attribute ("leaf", DECL_ATTRIBUTES (exp
)))
644 if (TREE_NOTHROW (exp
))
645 flags
|= ECF_NOTHROW
;
647 flags
= special_function_p (exp
, flags
);
649 else if (TYPE_P (exp
) && TYPE_READONLY (exp
))
652 if (TREE_THIS_VOLATILE (exp
))
654 flags
|= ECF_NORETURN
;
655 if (flags
& (ECF_CONST
|ECF_PURE
))
656 flags
|= ECF_LOOPING_CONST_OR_PURE
;
662 /* Detect flags from a CALL_EXPR. */
665 call_expr_flags (const_tree t
)
668 tree decl
= get_callee_fndecl (t
);
671 flags
= flags_from_decl_or_type (decl
);
674 t
= TREE_TYPE (CALL_EXPR_FN (t
));
675 if (t
&& TREE_CODE (t
) == POINTER_TYPE
)
676 flags
= flags_from_decl_or_type (TREE_TYPE (t
));
684 /* Precompute all register parameters as described by ARGS, storing values
685 into fields within the ARGS array.
687 NUM_ACTUALS indicates the total number elements in the ARGS array.
689 Set REG_PARM_SEEN if we encounter a register parameter. */
692 precompute_register_parameters (int num_actuals
, struct arg_data
*args
,
699 for (i
= 0; i
< num_actuals
; i
++)
700 if (args
[i
].reg
!= 0 && ! args
[i
].pass_on_stack
)
704 if (args
[i
].value
== 0)
707 args
[i
].value
= expand_normal (args
[i
].tree_value
);
708 preserve_temp_slots (args
[i
].value
);
712 /* If we are to promote the function arg to a wider mode,
715 if (args
[i
].mode
!= TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)))
717 = convert_modes (args
[i
].mode
,
718 TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)),
719 args
[i
].value
, args
[i
].unsignedp
);
721 /* If the value is a non-legitimate constant, force it into a
722 pseudo now. TLS symbols sometimes need a call to resolve. */
723 if (CONSTANT_P (args
[i
].value
)
724 && !targetm
.legitimate_constant_p (args
[i
].mode
, args
[i
].value
))
725 args
[i
].value
= force_reg (args
[i
].mode
, args
[i
].value
);
727 /* If we're going to have to load the value by parts, pull the
728 parts into pseudos. The part extraction process can involve
729 non-trivial computation. */
730 if (GET_CODE (args
[i
].reg
) == PARALLEL
)
732 tree type
= TREE_TYPE (args
[i
].tree_value
);
733 args
[i
].parallel_value
734 = emit_group_load_into_temps (args
[i
].reg
, args
[i
].value
,
735 type
, int_size_in_bytes (type
));
738 /* If the value is expensive, and we are inside an appropriately
739 short loop, put the value into a pseudo and then put the pseudo
742 For small register classes, also do this if this call uses
743 register parameters. This is to avoid reload conflicts while
744 loading the parameters registers. */
746 else if ((! (REG_P (args
[i
].value
)
747 || (GET_CODE (args
[i
].value
) == SUBREG
748 && REG_P (SUBREG_REG (args
[i
].value
)))))
749 && args
[i
].mode
!= BLKmode
750 && set_src_cost (args
[i
].value
, optimize_insn_for_speed_p ())
753 && targetm
.small_register_classes_for_mode_p (args
[i
].mode
))
755 args
[i
].value
= copy_to_mode_reg (args
[i
].mode
, args
[i
].value
);
759 #ifdef REG_PARM_STACK_SPACE
761 /* The argument list is the property of the called routine and it
762 may clobber it. If the fixed area has been used for previous
763 parameters, we must save and restore it. */
766 save_fixed_argument_area (int reg_parm_stack_space
, rtx argblock
, int *low_to_save
, int *high_to_save
)
771 /* Compute the boundary of the area that needs to be saved, if any. */
772 high
= reg_parm_stack_space
;
773 #ifdef ARGS_GROW_DOWNWARD
776 if (high
> highest_outgoing_arg_in_use
)
777 high
= highest_outgoing_arg_in_use
;
779 for (low
= 0; low
< high
; low
++)
780 if (stack_usage_map
[low
] != 0)
783 enum machine_mode save_mode
;
788 while (stack_usage_map
[--high
] == 0)
792 *high_to_save
= high
;
794 num_to_save
= high
- low
+ 1;
795 save_mode
= mode_for_size (num_to_save
* BITS_PER_UNIT
, MODE_INT
, 1);
797 /* If we don't have the required alignment, must do this
799 if ((low
& (MIN (GET_MODE_SIZE (save_mode
),
800 BIGGEST_ALIGNMENT
/ UNITS_PER_WORD
) - 1)))
803 #ifdef ARGS_GROW_DOWNWARD
808 stack_area
= gen_rtx_MEM (save_mode
,
809 memory_address (save_mode
,
810 plus_constant (argblock
,
813 set_mem_align (stack_area
, PARM_BOUNDARY
);
814 if (save_mode
== BLKmode
)
816 save_area
= assign_stack_temp (BLKmode
, num_to_save
, 0);
817 emit_block_move (validize_mem (save_area
), stack_area
,
818 GEN_INT (num_to_save
), BLOCK_OP_CALL_PARM
);
822 save_area
= gen_reg_rtx (save_mode
);
823 emit_move_insn (save_area
, stack_area
);
833 restore_fixed_argument_area (rtx save_area
, rtx argblock
, int high_to_save
, int low_to_save
)
835 enum machine_mode save_mode
= GET_MODE (save_area
);
839 #ifdef ARGS_GROW_DOWNWARD
840 delta
= -high_to_save
;
844 stack_area
= gen_rtx_MEM (save_mode
,
845 memory_address (save_mode
,
846 plus_constant (argblock
, delta
)));
847 set_mem_align (stack_area
, PARM_BOUNDARY
);
849 if (save_mode
!= BLKmode
)
850 emit_move_insn (stack_area
, save_area
);
852 emit_block_move (stack_area
, validize_mem (save_area
),
853 GEN_INT (high_to_save
- low_to_save
+ 1),
856 #endif /* REG_PARM_STACK_SPACE */
858 /* If any elements in ARGS refer to parameters that are to be passed in
859 registers, but not in memory, and whose alignment does not permit a
860 direct copy into registers. Copy the values into a group of pseudos
861 which we will later copy into the appropriate hard registers.
863 Pseudos for each unaligned argument will be stored into the array
864 args[argnum].aligned_regs. The caller is responsible for deallocating
865 the aligned_regs array if it is nonzero. */
868 store_unaligned_arguments_into_pseudos (struct arg_data
*args
, int num_actuals
)
872 for (i
= 0; i
< num_actuals
; i
++)
873 if (args
[i
].reg
!= 0 && ! args
[i
].pass_on_stack
874 && args
[i
].mode
== BLKmode
875 && MEM_P (args
[i
].value
)
876 && (MEM_ALIGN (args
[i
].value
)
877 < (unsigned int) MIN (BIGGEST_ALIGNMENT
, BITS_PER_WORD
)))
879 int bytes
= int_size_in_bytes (TREE_TYPE (args
[i
].tree_value
));
880 int endian_correction
= 0;
884 gcc_assert (args
[i
].partial
% UNITS_PER_WORD
== 0);
885 args
[i
].n_aligned_regs
= args
[i
].partial
/ UNITS_PER_WORD
;
889 args
[i
].n_aligned_regs
890 = (bytes
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
893 args
[i
].aligned_regs
= XNEWVEC (rtx
, args
[i
].n_aligned_regs
);
895 /* Structures smaller than a word are normally aligned to the
896 least significant byte. On a BYTES_BIG_ENDIAN machine,
897 this means we must skip the empty high order bytes when
898 calculating the bit offset. */
899 if (bytes
< UNITS_PER_WORD
900 #ifdef BLOCK_REG_PADDING
901 && (BLOCK_REG_PADDING (args
[i
].mode
,
902 TREE_TYPE (args
[i
].tree_value
), 1)
908 endian_correction
= BITS_PER_WORD
- bytes
* BITS_PER_UNIT
;
910 for (j
= 0; j
< args
[i
].n_aligned_regs
; j
++)
912 rtx reg
= gen_reg_rtx (word_mode
);
913 rtx word
= operand_subword_force (args
[i
].value
, j
, BLKmode
);
914 int bitsize
= MIN (bytes
* BITS_PER_UNIT
, BITS_PER_WORD
);
916 args
[i
].aligned_regs
[j
] = reg
;
917 word
= extract_bit_field (word
, bitsize
, 0, 1, false, NULL_RTX
,
918 word_mode
, word_mode
);
920 /* There is no need to restrict this code to loading items
921 in TYPE_ALIGN sized hunks. The bitfield instructions can
922 load up entire word sized registers efficiently.
924 ??? This may not be needed anymore.
925 We use to emit a clobber here but that doesn't let later
926 passes optimize the instructions we emit. By storing 0 into
927 the register later passes know the first AND to zero out the
928 bitfield being set in the register is unnecessary. The store
929 of 0 will be deleted as will at least the first AND. */
931 emit_move_insn (reg
, const0_rtx
);
933 bytes
-= bitsize
/ BITS_PER_UNIT
;
934 store_bit_field (reg
, bitsize
, endian_correction
, 0, 0,
940 /* Fill in ARGS_SIZE and ARGS array based on the parameters found in
943 NUM_ACTUALS is the total number of parameters.
945 N_NAMED_ARGS is the total number of named arguments.
947 STRUCT_VALUE_ADDR_VALUE is the implicit argument for a struct return
950 FNDECL is the tree code for the target of this call (if known)
952 ARGS_SO_FAR holds state needed by the target to know where to place
955 REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
956 for arguments which are passed in registers.
958 OLD_STACK_LEVEL is a pointer to an rtx which olds the old stack level
959 and may be modified by this routine.
961 OLD_PENDING_ADJ, MUST_PREALLOCATE and FLAGS are pointers to integer
962 flags which may may be modified by this routine.
964 MAY_TAILCALL is cleared if we encounter an invisible pass-by-reference
965 that requires allocation of stack space.
967 CALL_FROM_THUNK_P is true if this call is the jump from a thunk to
968 the thunked-to function. */
971 initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED
,
972 struct arg_data
*args
,
973 struct args_size
*args_size
,
974 int n_named_args ATTRIBUTE_UNUSED
,
975 tree exp
, tree struct_value_addr_value
,
976 tree fndecl
, tree fntype
,
977 cumulative_args_t args_so_far
,
978 int reg_parm_stack_space
,
979 rtx
*old_stack_level
, int *old_pending_adj
,
980 int *must_preallocate
, int *ecf_flags
,
981 bool *may_tailcall
, bool call_from_thunk_p
)
983 CUMULATIVE_ARGS
*args_so_far_pnt
= get_cumulative_args (args_so_far
);
984 location_t loc
= EXPR_LOCATION (exp
);
985 /* 1 if scanning parms front to back, -1 if scanning back to front. */
988 /* Count arg position in order args appear. */
993 args_size
->constant
= 0;
996 /* In this loop, we consider args in the order they are written.
997 We fill up ARGS from the front or from the back if necessary
998 so that in any case the first arg to be pushed ends up at the front. */
1000 if (PUSH_ARGS_REVERSED
)
1002 i
= num_actuals
- 1, inc
= -1;
1003 /* In this case, must reverse order of args
1004 so that we compute and push the last arg first. */
1011 /* First fill in the actual arguments in the ARGS array, splitting
1012 complex arguments if necessary. */
1015 call_expr_arg_iterator iter
;
1018 if (struct_value_addr_value
)
1020 args
[j
].tree_value
= struct_value_addr_value
;
1023 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
1025 tree argtype
= TREE_TYPE (arg
);
1026 if (targetm
.calls
.split_complex_arg
1028 && TREE_CODE (argtype
) == COMPLEX_TYPE
1029 && targetm
.calls
.split_complex_arg (argtype
))
1031 tree subtype
= TREE_TYPE (argtype
);
1032 args
[j
].tree_value
= build1 (REALPART_EXPR
, subtype
, arg
);
1034 args
[j
].tree_value
= build1 (IMAGPART_EXPR
, subtype
, arg
);
1037 args
[j
].tree_value
= arg
;
1042 /* I counts args in order (to be) pushed; ARGPOS counts in order written. */
1043 for (argpos
= 0; argpos
< num_actuals
; i
+= inc
, argpos
++)
1045 tree type
= TREE_TYPE (args
[i
].tree_value
);
1047 enum machine_mode mode
;
1049 /* Replace erroneous argument with constant zero. */
1050 if (type
== error_mark_node
|| !COMPLETE_TYPE_P (type
))
1051 args
[i
].tree_value
= integer_zero_node
, type
= integer_type_node
;
1053 /* If TYPE is a transparent union or record, pass things the way
1054 we would pass the first field of the union or record. We have
1055 already verified that the modes are the same. */
1056 if ((TREE_CODE (type
) == UNION_TYPE
|| TREE_CODE (type
) == RECORD_TYPE
)
1057 && TYPE_TRANSPARENT_AGGR (type
))
1058 type
= TREE_TYPE (first_field (type
));
1060 /* Decide where to pass this arg.
1062 args[i].reg is nonzero if all or part is passed in registers.
1064 args[i].partial is nonzero if part but not all is passed in registers,
1065 and the exact value says how many bytes are passed in registers.
1067 args[i].pass_on_stack is nonzero if the argument must at least be
1068 computed on the stack. It may then be loaded back into registers
1069 if args[i].reg is nonzero.
1071 These decisions are driven by the FUNCTION_... macros and must agree
1072 with those made by function.c. */
1074 /* See if this argument should be passed by invisible reference. */
1075 if (pass_by_reference (args_so_far_pnt
, TYPE_MODE (type
),
1076 type
, argpos
< n_named_args
))
1082 = reference_callee_copied (args_so_far_pnt
, TYPE_MODE (type
),
1083 type
, argpos
< n_named_args
);
1085 /* If we're compiling a thunk, pass through invisible references
1086 instead of making a copy. */
1087 if (call_from_thunk_p
1089 && !TREE_ADDRESSABLE (type
)
1090 && (base
= get_base_address (args
[i
].tree_value
))
1091 && TREE_CODE (base
) != SSA_NAME
1092 && (!DECL_P (base
) || MEM_P (DECL_RTL (base
)))))
1094 mark_addressable (args
[i
].tree_value
);
1096 /* We can't use sibcalls if a callee-copied argument is
1097 stored in the current function's frame. */
1098 if (!call_from_thunk_p
&& DECL_P (base
) && !TREE_STATIC (base
))
1099 *may_tailcall
= false;
1101 args
[i
].tree_value
= build_fold_addr_expr_loc (loc
,
1102 args
[i
].tree_value
);
1103 type
= TREE_TYPE (args
[i
].tree_value
);
1105 if (*ecf_flags
& ECF_CONST
)
1106 *ecf_flags
&= ~(ECF_CONST
| ECF_LOOPING_CONST_OR_PURE
);
1110 /* We make a copy of the object and pass the address to the
1111 function being called. */
1114 if (!COMPLETE_TYPE_P (type
)
1115 || TREE_CODE (TYPE_SIZE_UNIT (type
)) != INTEGER_CST
1116 || (flag_stack_check
== GENERIC_STACK_CHECK
1117 && compare_tree_int (TYPE_SIZE_UNIT (type
),
1118 STACK_CHECK_MAX_VAR_SIZE
) > 0))
1120 /* This is a variable-sized object. Make space on the stack
1122 rtx size_rtx
= expr_size (args
[i
].tree_value
);
1124 if (*old_stack_level
== 0)
1126 emit_stack_save (SAVE_BLOCK
, old_stack_level
);
1127 *old_pending_adj
= pending_stack_adjust
;
1128 pending_stack_adjust
= 0;
1131 /* We can pass TRUE as the 4th argument because we just
1132 saved the stack pointer and will restore it right after
1134 copy
= allocate_dynamic_stack_space (size_rtx
,
1138 copy
= gen_rtx_MEM (BLKmode
, copy
);
1139 set_mem_attributes (copy
, type
, 1);
1142 copy
= assign_temp (type
, 0, 1, 0);
1144 store_expr (args
[i
].tree_value
, copy
, 0, false);
1146 /* Just change the const function to pure and then let
1147 the next test clear the pure based on
1149 if (*ecf_flags
& ECF_CONST
)
1151 *ecf_flags
&= ~ECF_CONST
;
1152 *ecf_flags
|= ECF_PURE
;
1155 if (!callee_copies
&& *ecf_flags
& ECF_PURE
)
1156 *ecf_flags
&= ~(ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
);
1159 = build_fold_addr_expr_loc (loc
, make_tree (type
, copy
));
1160 type
= TREE_TYPE (args
[i
].tree_value
);
1161 *may_tailcall
= false;
1165 unsignedp
= TYPE_UNSIGNED (type
);
1166 mode
= promote_function_mode (type
, TYPE_MODE (type
), &unsignedp
,
1167 fndecl
? TREE_TYPE (fndecl
) : fntype
, 0);
1169 args
[i
].unsignedp
= unsignedp
;
1170 args
[i
].mode
= mode
;
1172 args
[i
].reg
= targetm
.calls
.function_arg (args_so_far
, mode
, type
,
1173 argpos
< n_named_args
);
1175 /* If this is a sibling call and the machine has register windows, the
1176 register window has to be unwinded before calling the routine, so
1177 arguments have to go into the incoming registers. */
1178 if (targetm
.calls
.function_incoming_arg
!= targetm
.calls
.function_arg
)
1179 args
[i
].tail_call_reg
1180 = targetm
.calls
.function_incoming_arg (args_so_far
, mode
, type
,
1181 argpos
< n_named_args
);
1183 args
[i
].tail_call_reg
= args
[i
].reg
;
1187 = targetm
.calls
.arg_partial_bytes (args_so_far
, mode
, type
,
1188 argpos
< n_named_args
);
1190 args
[i
].pass_on_stack
= targetm
.calls
.must_pass_in_stack (mode
, type
);
1192 /* If FUNCTION_ARG returned a (parallel [(expr_list (nil) ...) ...]),
1193 it means that we are to pass this arg in the register(s) designated
1194 by the PARALLEL, but also to pass it in the stack. */
1195 if (args
[i
].reg
&& GET_CODE (args
[i
].reg
) == PARALLEL
1196 && XEXP (XVECEXP (args
[i
].reg
, 0, 0), 0) == 0)
1197 args
[i
].pass_on_stack
= 1;
1199 /* If this is an addressable type, we must preallocate the stack
1200 since we must evaluate the object into its final location.
1202 If this is to be passed in both registers and the stack, it is simpler
1204 if (TREE_ADDRESSABLE (type
)
1205 || (args
[i
].pass_on_stack
&& args
[i
].reg
!= 0))
1206 *must_preallocate
= 1;
1208 /* Compute the stack-size of this argument. */
1209 if (args
[i
].reg
== 0 || args
[i
].partial
!= 0
1210 || reg_parm_stack_space
> 0
1211 || args
[i
].pass_on_stack
)
1212 locate_and_pad_parm (mode
, type
,
1213 #ifdef STACK_PARMS_IN_REG_PARM_AREA
1218 args
[i
].pass_on_stack
? 0 : args
[i
].partial
,
1219 fndecl
, args_size
, &args
[i
].locate
);
1220 #ifdef BLOCK_REG_PADDING
1222 /* The argument is passed entirely in registers. See at which
1223 end it should be padded. */
1224 args
[i
].locate
.where_pad
=
1225 BLOCK_REG_PADDING (mode
, type
,
1226 int_size_in_bytes (type
) <= UNITS_PER_WORD
);
1229 /* Update ARGS_SIZE, the total stack space for args so far. */
1231 args_size
->constant
+= args
[i
].locate
.size
.constant
;
1232 if (args
[i
].locate
.size
.var
)
1233 ADD_PARM_SIZE (*args_size
, args
[i
].locate
.size
.var
);
1235 /* Increment ARGS_SO_FAR, which has info about which arg-registers
1236 have been used, etc. */
1238 targetm
.calls
.function_arg_advance (args_so_far
, TYPE_MODE (type
),
1239 type
, argpos
< n_named_args
);
1243 /* Update ARGS_SIZE to contain the total size for the argument block.
1244 Return the original constant component of the argument block's size.
1246 REG_PARM_STACK_SPACE holds the number of bytes of stack space reserved
1247 for arguments passed in registers. */
1250 compute_argument_block_size (int reg_parm_stack_space
,
1251 struct args_size
*args_size
,
1252 tree fndecl ATTRIBUTE_UNUSED
,
1253 tree fntype ATTRIBUTE_UNUSED
,
1254 int preferred_stack_boundary ATTRIBUTE_UNUSED
)
1256 int unadjusted_args_size
= args_size
->constant
;
1258 /* For accumulate outgoing args mode we don't need to align, since the frame
1259 will be already aligned. Align to STACK_BOUNDARY in order to prevent
1260 backends from generating misaligned frame sizes. */
1261 if (ACCUMULATE_OUTGOING_ARGS
&& preferred_stack_boundary
> STACK_BOUNDARY
)
1262 preferred_stack_boundary
= STACK_BOUNDARY
;
1264 /* Compute the actual size of the argument block required. The variable
1265 and constant sizes must be combined, the size may have to be rounded,
1266 and there may be a minimum required size. */
1270 args_size
->var
= ARGS_SIZE_TREE (*args_size
);
1271 args_size
->constant
= 0;
1273 preferred_stack_boundary
/= BITS_PER_UNIT
;
1274 if (preferred_stack_boundary
> 1)
1276 /* We don't handle this case yet. To handle it correctly we have
1277 to add the delta, round and subtract the delta.
1278 Currently no machine description requires this support. */
1279 gcc_assert (!(stack_pointer_delta
& (preferred_stack_boundary
- 1)));
1280 args_size
->var
= round_up (args_size
->var
, preferred_stack_boundary
);
1283 if (reg_parm_stack_space
> 0)
1286 = size_binop (MAX_EXPR
, args_size
->var
,
1287 ssize_int (reg_parm_stack_space
));
1289 /* The area corresponding to register parameters is not to count in
1290 the size of the block we need. So make the adjustment. */
1291 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
1293 = size_binop (MINUS_EXPR
, args_size
->var
,
1294 ssize_int (reg_parm_stack_space
));
1299 preferred_stack_boundary
/= BITS_PER_UNIT
;
1300 if (preferred_stack_boundary
< 1)
1301 preferred_stack_boundary
= 1;
1302 args_size
->constant
= (((args_size
->constant
1303 + stack_pointer_delta
1304 + preferred_stack_boundary
- 1)
1305 / preferred_stack_boundary
1306 * preferred_stack_boundary
)
1307 - stack_pointer_delta
);
1309 args_size
->constant
= MAX (args_size
->constant
,
1310 reg_parm_stack_space
);
1312 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
1313 args_size
->constant
-= reg_parm_stack_space
;
1315 return unadjusted_args_size
;
1318 /* Precompute parameters as needed for a function call.
1320 FLAGS is mask of ECF_* constants.
1322 NUM_ACTUALS is the number of arguments.
1324 ARGS is an array containing information for each argument; this
1325 routine fills in the INITIAL_VALUE and VALUE fields for each
1326 precomputed argument. */
1329 precompute_arguments (int num_actuals
, struct arg_data
*args
)
1333 /* If this is a libcall, then precompute all arguments so that we do not
1334 get extraneous instructions emitted as part of the libcall sequence. */
1336 /* If we preallocated the stack space, and some arguments must be passed
1337 on the stack, then we must precompute any parameter which contains a
1338 function call which will store arguments on the stack.
1339 Otherwise, evaluating the parameter may clobber previous parameters
1340 which have already been stored into the stack. (we have code to avoid
1341 such case by saving the outgoing stack arguments, but it results in
1343 if (!ACCUMULATE_OUTGOING_ARGS
)
1346 for (i
= 0; i
< num_actuals
; i
++)
1349 enum machine_mode mode
;
1351 if (TREE_CODE (args
[i
].tree_value
) != CALL_EXPR
)
1354 /* If this is an addressable type, we cannot pre-evaluate it. */
1355 type
= TREE_TYPE (args
[i
].tree_value
);
1356 gcc_assert (!TREE_ADDRESSABLE (type
));
1358 args
[i
].initial_value
= args
[i
].value
1359 = expand_normal (args
[i
].tree_value
);
1361 mode
= TYPE_MODE (type
);
1362 if (mode
!= args
[i
].mode
)
1364 int unsignedp
= args
[i
].unsignedp
;
1366 = convert_modes (args
[i
].mode
, mode
,
1367 args
[i
].value
, args
[i
].unsignedp
);
1369 /* CSE will replace this only if it contains args[i].value
1370 pseudo, so convert it down to the declared mode using
1372 if (REG_P (args
[i
].value
)
1373 && GET_MODE_CLASS (args
[i
].mode
) == MODE_INT
1374 && promote_mode (type
, mode
, &unsignedp
) != args
[i
].mode
)
1376 args
[i
].initial_value
1377 = gen_lowpart_SUBREG (mode
, args
[i
].value
);
1378 SUBREG_PROMOTED_VAR_P (args
[i
].initial_value
) = 1;
1379 SUBREG_PROMOTED_UNSIGNED_SET (args
[i
].initial_value
,
1386 /* Given the current state of MUST_PREALLOCATE and information about
1387 arguments to a function call in NUM_ACTUALS, ARGS and ARGS_SIZE,
1388 compute and return the final value for MUST_PREALLOCATE. */
1391 finalize_must_preallocate (int must_preallocate
, int num_actuals
,
1392 struct arg_data
*args
, struct args_size
*args_size
)
1394 /* See if we have or want to preallocate stack space.
1396 If we would have to push a partially-in-regs parm
1397 before other stack parms, preallocate stack space instead.
1399 If the size of some parm is not a multiple of the required stack
1400 alignment, we must preallocate.
1402 If the total size of arguments that would otherwise create a copy in
1403 a temporary (such as a CALL) is more than half the total argument list
1404 size, preallocation is faster.
1406 Another reason to preallocate is if we have a machine (like the m88k)
1407 where stack alignment is required to be maintained between every
1408 pair of insns, not just when the call is made. However, we assume here
1409 that such machines either do not have push insns (and hence preallocation
1410 would occur anyway) or the problem is taken care of with
1413 if (! must_preallocate
)
1415 int partial_seen
= 0;
1416 int copy_to_evaluate_size
= 0;
1419 for (i
= 0; i
< num_actuals
&& ! must_preallocate
; i
++)
1421 if (args
[i
].partial
> 0 && ! args
[i
].pass_on_stack
)
1423 else if (partial_seen
&& args
[i
].reg
== 0)
1424 must_preallocate
= 1;
1426 if (TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)) == BLKmode
1427 && (TREE_CODE (args
[i
].tree_value
) == CALL_EXPR
1428 || TREE_CODE (args
[i
].tree_value
) == TARGET_EXPR
1429 || TREE_CODE (args
[i
].tree_value
) == COND_EXPR
1430 || TREE_ADDRESSABLE (TREE_TYPE (args
[i
].tree_value
))))
1431 copy_to_evaluate_size
1432 += int_size_in_bytes (TREE_TYPE (args
[i
].tree_value
));
1435 if (copy_to_evaluate_size
* 2 >= args_size
->constant
1436 && args_size
->constant
> 0)
1437 must_preallocate
= 1;
1439 return must_preallocate
;
1442 /* If we preallocated stack space, compute the address of each argument
1443 and store it into the ARGS array.
1445 We need not ensure it is a valid memory address here; it will be
1446 validized when it is used.
1448 ARGBLOCK is an rtx for the address of the outgoing arguments. */
1451 compute_argument_addresses (struct arg_data
*args
, rtx argblock
, int num_actuals
)
1455 rtx arg_reg
= argblock
;
1456 int i
, arg_offset
= 0;
1458 if (GET_CODE (argblock
) == PLUS
)
1459 arg_reg
= XEXP (argblock
, 0), arg_offset
= INTVAL (XEXP (argblock
, 1));
1461 for (i
= 0; i
< num_actuals
; i
++)
1463 rtx offset
= ARGS_SIZE_RTX (args
[i
].locate
.offset
);
1464 rtx slot_offset
= ARGS_SIZE_RTX (args
[i
].locate
.slot_offset
);
1466 unsigned int align
, boundary
;
1467 unsigned int units_on_stack
= 0;
1468 enum machine_mode partial_mode
= VOIDmode
;
1470 /* Skip this parm if it will not be passed on the stack. */
1471 if (! args
[i
].pass_on_stack
1473 && args
[i
].partial
== 0)
1476 if (CONST_INT_P (offset
))
1477 addr
= plus_constant (arg_reg
, INTVAL (offset
));
1479 addr
= gen_rtx_PLUS (Pmode
, arg_reg
, offset
);
1481 addr
= plus_constant (addr
, arg_offset
);
1483 if (args
[i
].partial
!= 0)
1485 /* Only part of the parameter is being passed on the stack.
1486 Generate a simple memory reference of the correct size. */
1487 units_on_stack
= args
[i
].locate
.size
.constant
;
1488 partial_mode
= mode_for_size (units_on_stack
* BITS_PER_UNIT
,
1490 args
[i
].stack
= gen_rtx_MEM (partial_mode
, addr
);
1491 set_mem_size (args
[i
].stack
, units_on_stack
);
1495 args
[i
].stack
= gen_rtx_MEM (args
[i
].mode
, addr
);
1496 set_mem_attributes (args
[i
].stack
,
1497 TREE_TYPE (args
[i
].tree_value
), 1);
1499 align
= BITS_PER_UNIT
;
1500 boundary
= args
[i
].locate
.boundary
;
1501 if (args
[i
].locate
.where_pad
!= downward
)
1503 else if (CONST_INT_P (offset
))
1505 align
= INTVAL (offset
) * BITS_PER_UNIT
| boundary
;
1506 align
= align
& -align
;
1508 set_mem_align (args
[i
].stack
, align
);
1510 if (CONST_INT_P (slot_offset
))
1511 addr
= plus_constant (arg_reg
, INTVAL (slot_offset
));
1513 addr
= gen_rtx_PLUS (Pmode
, arg_reg
, slot_offset
);
1515 addr
= plus_constant (addr
, arg_offset
);
1517 if (args
[i
].partial
!= 0)
1519 /* Only part of the parameter is being passed on the stack.
1520 Generate a simple memory reference of the correct size.
1522 args
[i
].stack_slot
= gen_rtx_MEM (partial_mode
, addr
);
1523 set_mem_size (args
[i
].stack_slot
, units_on_stack
);
1527 args
[i
].stack_slot
= gen_rtx_MEM (args
[i
].mode
, addr
);
1528 set_mem_attributes (args
[i
].stack_slot
,
1529 TREE_TYPE (args
[i
].tree_value
), 1);
1531 set_mem_align (args
[i
].stack_slot
, args
[i
].locate
.boundary
);
1533 /* Function incoming arguments may overlap with sibling call
1534 outgoing arguments and we cannot allow reordering of reads
1535 from function arguments with stores to outgoing arguments
1536 of sibling calls. */
1537 set_mem_alias_set (args
[i
].stack
, 0);
1538 set_mem_alias_set (args
[i
].stack_slot
, 0);
1543 /* Given a FNDECL and EXP, return an rtx suitable for use as a target address
1544 in a call instruction.
1546 FNDECL is the tree node for the target function. For an indirect call
1547 FNDECL will be NULL_TREE.
1549 ADDR is the operand 0 of CALL_EXPR for this call. */
1552 rtx_for_function_call (tree fndecl
, tree addr
)
1556 /* Get the function to call, in the form of RTL. */
1559 /* If this is the first use of the function, see if we need to
1560 make an external definition for it. */
1561 if (!TREE_USED (fndecl
) && fndecl
!= current_function_decl
)
1563 assemble_external (fndecl
);
1564 TREE_USED (fndecl
) = 1;
1567 /* Get a SYMBOL_REF rtx for the function address. */
1568 funexp
= XEXP (DECL_RTL (fndecl
), 0);
1571 /* Generate an rtx (probably a pseudo-register) for the address. */
1574 funexp
= expand_normal (addr
);
1575 pop_temp_slots (); /* FUNEXP can't be BLKmode. */
1580 /* Return true if and only if SIZE storage units (usually bytes)
1581 starting from address ADDR overlap with already clobbered argument
1582 area. This function is used to determine if we should give up a
1586 mem_overlaps_already_clobbered_arg_p (rtx addr
, unsigned HOST_WIDE_INT size
)
1590 if (addr
== crtl
->args
.internal_arg_pointer
)
1592 else if (GET_CODE (addr
) == PLUS
1593 && XEXP (addr
, 0) == crtl
->args
.internal_arg_pointer
1594 && CONST_INT_P (XEXP (addr
, 1)))
1595 i
= INTVAL (XEXP (addr
, 1));
1596 /* Return true for arg pointer based indexed addressing. */
1597 else if (GET_CODE (addr
) == PLUS
1598 && (XEXP (addr
, 0) == crtl
->args
.internal_arg_pointer
1599 || XEXP (addr
, 1) == crtl
->args
.internal_arg_pointer
))
1601 /* If the address comes in a register, we have no idea of its origin so
1602 give up and conservatively return true. */
1603 else if (REG_P(addr
))
1608 #ifdef ARGS_GROW_DOWNWARD
1613 unsigned HOST_WIDE_INT k
;
1615 for (k
= 0; k
< size
; k
++)
1616 if (i
+ k
< stored_args_map
->n_bits
1617 && TEST_BIT (stored_args_map
, i
+ k
))
1624 /* Do the register loads required for any wholly-register parms or any
1625 parms which are passed both on the stack and in a register. Their
1626 expressions were already evaluated.
1628 Mark all register-parms as living through the call, putting these USE
1629 insns in the CALL_INSN_FUNCTION_USAGE field.
1631 When IS_SIBCALL, perform the check_sibcall_argument_overlap
1632 checking, setting *SIBCALL_FAILURE if appropriate. */
1635 load_register_parameters (struct arg_data
*args
, int num_actuals
,
1636 rtx
*call_fusage
, int flags
, int is_sibcall
,
1637 int *sibcall_failure
)
1641 for (i
= 0; i
< num_actuals
; i
++)
1643 rtx reg
= ((flags
& ECF_SIBCALL
)
1644 ? args
[i
].tail_call_reg
: args
[i
].reg
);
1647 int partial
= args
[i
].partial
;
1650 rtx before_arg
= get_last_insn ();
1651 /* Set non-negative if we must move a word at a time, even if
1652 just one word (e.g, partial == 4 && mode == DFmode). Set
1653 to -1 if we just use a normal move insn. This value can be
1654 zero if the argument is a zero size structure. */
1656 if (GET_CODE (reg
) == PARALLEL
)
1660 gcc_assert (partial
% UNITS_PER_WORD
== 0);
1661 nregs
= partial
/ UNITS_PER_WORD
;
1663 else if (TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)) == BLKmode
)
1665 size
= int_size_in_bytes (TREE_TYPE (args
[i
].tree_value
));
1666 nregs
= (size
+ (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
;
1669 size
= GET_MODE_SIZE (args
[i
].mode
);
1671 /* Handle calls that pass values in multiple non-contiguous
1672 locations. The Irix 6 ABI has examples of this. */
1674 if (GET_CODE (reg
) == PARALLEL
)
1675 emit_group_move (reg
, args
[i
].parallel_value
);
1677 /* If simple case, just do move. If normal partial, store_one_arg
1678 has already loaded the register for us. In all other cases,
1679 load the register(s) from memory. */
1681 else if (nregs
== -1)
1683 emit_move_insn (reg
, args
[i
].value
);
1684 #ifdef BLOCK_REG_PADDING
1685 /* Handle case where we have a value that needs shifting
1686 up to the msb. eg. a QImode value and we're padding
1687 upward on a BYTES_BIG_ENDIAN machine. */
1688 if (size
< UNITS_PER_WORD
1689 && (args
[i
].locate
.where_pad
1690 == (BYTES_BIG_ENDIAN
? upward
: downward
)))
1693 int shift
= (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
1695 /* Assigning REG here rather than a temp makes CALL_FUSAGE
1696 report the whole reg as used. Strictly speaking, the
1697 call only uses SIZE bytes at the msb end, but it doesn't
1698 seem worth generating rtl to say that. */
1699 reg
= gen_rtx_REG (word_mode
, REGNO (reg
));
1700 x
= expand_shift (LSHIFT_EXPR
, word_mode
, reg
, shift
, reg
, 1);
1702 emit_move_insn (reg
, x
);
1707 /* If we have pre-computed the values to put in the registers in
1708 the case of non-aligned structures, copy them in now. */
1710 else if (args
[i
].n_aligned_regs
!= 0)
1711 for (j
= 0; j
< args
[i
].n_aligned_regs
; j
++)
1712 emit_move_insn (gen_rtx_REG (word_mode
, REGNO (reg
) + j
),
1713 args
[i
].aligned_regs
[j
]);
1715 else if (partial
== 0 || args
[i
].pass_on_stack
)
1717 rtx mem
= validize_mem (args
[i
].value
);
1719 /* Check for overlap with already clobbered argument area,
1720 providing that this has non-zero size. */
1723 || mem_overlaps_already_clobbered_arg_p
1724 (XEXP (args
[i
].value
, 0), size
)))
1725 *sibcall_failure
= 1;
1727 /* Handle a BLKmode that needs shifting. */
1728 if (nregs
== 1 && size
< UNITS_PER_WORD
1729 #ifdef BLOCK_REG_PADDING
1730 && args
[i
].locate
.where_pad
== downward
1736 rtx tem
= operand_subword_force (mem
, 0, args
[i
].mode
);
1737 rtx ri
= gen_rtx_REG (word_mode
, REGNO (reg
));
1738 rtx x
= gen_reg_rtx (word_mode
);
1739 int shift
= (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
1740 enum tree_code dir
= BYTES_BIG_ENDIAN
? RSHIFT_EXPR
1743 emit_move_insn (x
, tem
);
1744 x
= expand_shift (dir
, word_mode
, x
, shift
, ri
, 1);
1746 emit_move_insn (ri
, x
);
1749 move_block_to_reg (REGNO (reg
), mem
, nregs
, args
[i
].mode
);
1752 /* When a parameter is a block, and perhaps in other cases, it is
1753 possible that it did a load from an argument slot that was
1754 already clobbered. */
1756 && check_sibcall_argument_overlap (before_arg
, &args
[i
], 0))
1757 *sibcall_failure
= 1;
1759 /* Handle calls that pass values in multiple non-contiguous
1760 locations. The Irix 6 ABI has examples of this. */
1761 if (GET_CODE (reg
) == PARALLEL
)
1762 use_group_regs (call_fusage
, reg
);
1763 else if (nregs
== -1)
1764 use_reg_mode (call_fusage
, reg
,
1765 TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)));
1767 use_regs (call_fusage
, REGNO (reg
), nregs
);
1772 /* We need to pop PENDING_STACK_ADJUST bytes. But, if the arguments
1773 wouldn't fill up an even multiple of PREFERRED_UNIT_STACK_BOUNDARY
1774 bytes, then we would need to push some additional bytes to pad the
1775 arguments. So, we compute an adjust to the stack pointer for an
1776 amount that will leave the stack under-aligned by UNADJUSTED_ARGS_SIZE
1777 bytes. Then, when the arguments are pushed the stack will be perfectly
1778 aligned. ARGS_SIZE->CONSTANT is set to the number of bytes that should
1779 be popped after the call. Returns the adjustment. */
1782 combine_pending_stack_adjustment_and_call (int unadjusted_args_size
,
1783 struct args_size
*args_size
,
1784 unsigned int preferred_unit_stack_boundary
)
1786 /* The number of bytes to pop so that the stack will be
1787 under-aligned by UNADJUSTED_ARGS_SIZE bytes. */
1788 HOST_WIDE_INT adjustment
;
1789 /* The alignment of the stack after the arguments are pushed, if we
1790 just pushed the arguments without adjust the stack here. */
1791 unsigned HOST_WIDE_INT unadjusted_alignment
;
1793 unadjusted_alignment
1794 = ((stack_pointer_delta
+ unadjusted_args_size
)
1795 % preferred_unit_stack_boundary
);
1797 /* We want to get rid of as many of the PENDING_STACK_ADJUST bytes
1798 as possible -- leaving just enough left to cancel out the
1799 UNADJUSTED_ALIGNMENT. In other words, we want to ensure that the
1800 PENDING_STACK_ADJUST is non-negative, and congruent to
1801 -UNADJUSTED_ALIGNMENT modulo the PREFERRED_UNIT_STACK_BOUNDARY. */
1803 /* Begin by trying to pop all the bytes. */
1804 unadjusted_alignment
1805 = (unadjusted_alignment
1806 - (pending_stack_adjust
% preferred_unit_stack_boundary
));
1807 adjustment
= pending_stack_adjust
;
1808 /* Push enough additional bytes that the stack will be aligned
1809 after the arguments are pushed. */
1810 if (preferred_unit_stack_boundary
> 1)
1812 if (unadjusted_alignment
> 0)
1813 adjustment
-= preferred_unit_stack_boundary
- unadjusted_alignment
;
1815 adjustment
+= unadjusted_alignment
;
1818 /* Now, sets ARGS_SIZE->CONSTANT so that we pop the right number of
1819 bytes after the call. The right number is the entire
1820 PENDING_STACK_ADJUST less our ADJUSTMENT plus the amount required
1821 by the arguments in the first place. */
1823 = pending_stack_adjust
- adjustment
+ unadjusted_args_size
;
1828 /* Scan X expression if it does not dereference any argument slots
1829 we already clobbered by tail call arguments (as noted in stored_args_map
1831 Return nonzero if X expression dereferences such argument slots,
1835 check_sibcall_argument_overlap_1 (rtx x
)
1844 code
= GET_CODE (x
);
1846 /* We need not check the operands of the CALL expression itself. */
1851 return mem_overlaps_already_clobbered_arg_p (XEXP (x
, 0),
1852 GET_MODE_SIZE (GET_MODE (x
)));
1854 /* Scan all subexpressions. */
1855 fmt
= GET_RTX_FORMAT (code
);
1856 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++, fmt
++)
1860 if (check_sibcall_argument_overlap_1 (XEXP (x
, i
)))
1863 else if (*fmt
== 'E')
1865 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1866 if (check_sibcall_argument_overlap_1 (XVECEXP (x
, i
, j
)))
1873 /* Scan sequence after INSN if it does not dereference any argument slots
1874 we already clobbered by tail call arguments (as noted in stored_args_map
1875 bitmap). If MARK_STORED_ARGS_MAP, add stack slots for ARG to
1876 stored_args_map bitmap afterwards (when ARG is a register MARK_STORED_ARGS_MAP
1877 should be 0). Return nonzero if sequence after INSN dereferences such argument
1878 slots, zero otherwise. */
1881 check_sibcall_argument_overlap (rtx insn
, struct arg_data
*arg
, int mark_stored_args_map
)
1885 if (insn
== NULL_RTX
)
1886 insn
= get_insns ();
1888 insn
= NEXT_INSN (insn
);
1890 for (; insn
; insn
= NEXT_INSN (insn
))
1892 && check_sibcall_argument_overlap_1 (PATTERN (insn
)))
1895 if (mark_stored_args_map
)
1897 #ifdef ARGS_GROW_DOWNWARD
1898 low
= -arg
->locate
.slot_offset
.constant
- arg
->locate
.size
.constant
;
1900 low
= arg
->locate
.slot_offset
.constant
;
1903 for (high
= low
+ arg
->locate
.size
.constant
; low
< high
; low
++)
1904 SET_BIT (stored_args_map
, low
);
1906 return insn
!= NULL_RTX
;
1909 /* Given that a function returns a value of mode MODE at the most
1910 significant end of hard register VALUE, shift VALUE left or right
1911 as specified by LEFT_P. Return true if some action was needed. */
1914 shift_return_value (enum machine_mode mode
, bool left_p
, rtx value
)
1916 HOST_WIDE_INT shift
;
1918 gcc_assert (REG_P (value
) && HARD_REGISTER_P (value
));
1919 shift
= GET_MODE_BITSIZE (GET_MODE (value
)) - GET_MODE_BITSIZE (mode
);
1923 /* Use ashr rather than lshr for right shifts. This is for the benefit
1924 of the MIPS port, which requires SImode values to be sign-extended
1925 when stored in 64-bit registers. */
1926 if (!force_expand_binop (GET_MODE (value
), left_p
? ashl_optab
: ashr_optab
,
1927 value
, GEN_INT (shift
), value
, 1, OPTAB_WIDEN
))
1932 /* If X is a likely-spilled register value, copy it to a pseudo
1933 register and return that register. Return X otherwise. */
1936 avoid_likely_spilled_reg (rtx x
)
1941 && HARD_REGISTER_P (x
)
1942 && targetm
.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (x
))))
1944 /* Make sure that we generate a REG rather than a CONCAT.
1945 Moves into CONCATs can need nontrivial instructions,
1946 and the whole point of this function is to avoid
1947 using the hard register directly in such a situation. */
1948 generating_concat_p
= 0;
1949 new_rtx
= gen_reg_rtx (GET_MODE (x
));
1950 generating_concat_p
= 1;
1951 emit_move_insn (new_rtx
, x
);
1957 /* Generate all the code for a CALL_EXPR exp
1958 and return an rtx for its value.
1959 Store the value in TARGET (specified as an rtx) if convenient.
1960 If the value is stored in TARGET then TARGET is returned.
1961 If IGNORE is nonzero, then we ignore the value of the function call. */
1964 expand_call (tree exp
, rtx target
, int ignore
)
1966 /* Nonzero if we are currently expanding a call. */
1967 static int currently_expanding_call
= 0;
1969 /* RTX for the function to be called. */
1971 /* Sequence of insns to perform a normal "call". */
1972 rtx normal_call_insns
= NULL_RTX
;
1973 /* Sequence of insns to perform a tail "call". */
1974 rtx tail_call_insns
= NULL_RTX
;
1975 /* Data type of the function. */
1977 tree type_arg_types
;
1979 /* Declaration of the function being called,
1980 or 0 if the function is computed (not known by name). */
1982 /* The type of the function being called. */
1984 bool try_tail_call
= CALL_EXPR_TAILCALL (exp
);
1987 /* Register in which non-BLKmode value will be returned,
1988 or 0 if no value or if value is BLKmode. */
1990 /* Address where we should return a BLKmode value;
1991 0 if value not BLKmode. */
1992 rtx structure_value_addr
= 0;
1993 /* Nonzero if that address is being passed by treating it as
1994 an extra, implicit first parameter. Otherwise,
1995 it is passed by being copied directly into struct_value_rtx. */
1996 int structure_value_addr_parm
= 0;
1997 /* Holds the value of implicit argument for the struct value. */
1998 tree structure_value_addr_value
= NULL_TREE
;
1999 /* Size of aggregate value wanted, or zero if none wanted
2000 or if we are using the non-reentrant PCC calling convention
2001 or expecting the value in registers. */
2002 HOST_WIDE_INT struct_value_size
= 0;
2003 /* Nonzero if called function returns an aggregate in memory PCC style,
2004 by returning the address of where to find it. */
2005 int pcc_struct_value
= 0;
2006 rtx struct_value
= 0;
2008 /* Number of actual parameters in this call, including struct value addr. */
2010 /* Number of named args. Args after this are anonymous ones
2011 and they must all go on the stack. */
2013 /* Number of complex actual arguments that need to be split. */
2014 int num_complex_actuals
= 0;
2016 /* Vector of information about each argument.
2017 Arguments are numbered in the order they will be pushed,
2018 not the order they are written. */
2019 struct arg_data
*args
;
2021 /* Total size in bytes of all the stack-parms scanned so far. */
2022 struct args_size args_size
;
2023 struct args_size adjusted_args_size
;
2024 /* Size of arguments before any adjustments (such as rounding). */
2025 int unadjusted_args_size
;
2026 /* Data on reg parms scanned so far. */
2027 CUMULATIVE_ARGS args_so_far_v
;
2028 cumulative_args_t args_so_far
;
2029 /* Nonzero if a reg parm has been scanned. */
2031 /* Nonzero if this is an indirect function call. */
2033 /* Nonzero if we must avoid push-insns in the args for this call.
2034 If stack space is allocated for register parameters, but not by the
2035 caller, then it is preallocated in the fixed part of the stack frame.
2036 So the entire argument block must then be preallocated (i.e., we
2037 ignore PUSH_ROUNDING in that case). */
2039 int must_preallocate
= !PUSH_ARGS
;
2041 /* Size of the stack reserved for parameter registers. */
2042 int reg_parm_stack_space
= 0;
2044 /* Address of space preallocated for stack parms
2045 (on machines that lack push insns), or 0 if space not preallocated. */
2048 /* Mask of ECF_ flags. */
2050 #ifdef REG_PARM_STACK_SPACE
2051 /* Define the boundary of the register parm stack space that needs to be
2053 int low_to_save
, high_to_save
;
2054 rtx save_area
= 0; /* Place that it is saved */
2057 int initial_highest_arg_in_use
= highest_outgoing_arg_in_use
;
2058 char *initial_stack_usage_map
= stack_usage_map
;
2059 char *stack_usage_map_buf
= NULL
;
2061 int old_stack_allocated
;
2063 /* State variables to track stack modifications. */
2064 rtx old_stack_level
= 0;
2065 int old_stack_arg_under_construction
= 0;
2066 int old_pending_adj
= 0;
2067 int old_inhibit_defer_pop
= inhibit_defer_pop
;
2069 /* Some stack pointer alterations we make are performed via
2070 allocate_dynamic_stack_space. This modifies the stack_pointer_delta,
2071 which we then also need to save/restore along the way. */
2072 int old_stack_pointer_delta
= 0;
2075 tree addr
= CALL_EXPR_FN (exp
);
2077 /* The alignment of the stack, in bits. */
2078 unsigned HOST_WIDE_INT preferred_stack_boundary
;
2079 /* The alignment of the stack, in bytes. */
2080 unsigned HOST_WIDE_INT preferred_unit_stack_boundary
;
2081 /* The static chain value to use for this call. */
2082 rtx static_chain_value
;
2083 /* See if this is "nothrow" function call. */
2084 if (TREE_NOTHROW (exp
))
2085 flags
|= ECF_NOTHROW
;
2087 /* See if we can find a DECL-node for the actual function, and get the
2088 function attributes (flags) from the function decl or type node. */
2089 fndecl
= get_callee_fndecl (exp
);
2092 fntype
= TREE_TYPE (fndecl
);
2093 flags
|= flags_from_decl_or_type (fndecl
);
2097 fntype
= TREE_TYPE (TREE_TYPE (addr
));
2098 flags
|= flags_from_decl_or_type (fntype
);
2100 rettype
= TREE_TYPE (exp
);
2102 struct_value
= targetm
.calls
.struct_value_rtx (fntype
, 0);
2104 /* Warn if this value is an aggregate type,
2105 regardless of which calling convention we are using for it. */
2106 if (AGGREGATE_TYPE_P (rettype
))
2107 warning (OPT_Waggregate_return
, "function call has aggregate value");
2109 /* If the result of a non looping pure or const function call is
2110 ignored (or void), and none of its arguments are volatile, we can
2111 avoid expanding the call and just evaluate the arguments for
2113 if ((flags
& (ECF_CONST
| ECF_PURE
))
2114 && (!(flags
& ECF_LOOPING_CONST_OR_PURE
))
2115 && (ignore
|| target
== const0_rtx
2116 || TYPE_MODE (rettype
) == VOIDmode
))
2118 bool volatilep
= false;
2120 call_expr_arg_iterator iter
;
2122 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
2123 if (TREE_THIS_VOLATILE (arg
))
2131 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
2132 expand_expr (arg
, const0_rtx
, VOIDmode
, EXPAND_NORMAL
);
2137 #ifdef REG_PARM_STACK_SPACE
2138 reg_parm_stack_space
= REG_PARM_STACK_SPACE (!fndecl
? fntype
: fndecl
);
2141 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
)))
2142 && reg_parm_stack_space
> 0 && PUSH_ARGS
)
2143 must_preallocate
= 1;
2145 /* Set up a place to return a structure. */
2147 /* Cater to broken compilers. */
2148 if (aggregate_value_p (exp
, fntype
))
2150 /* This call returns a big structure. */
2151 flags
&= ~(ECF_CONST
| ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
);
2153 #ifdef PCC_STATIC_STRUCT_RETURN
2155 pcc_struct_value
= 1;
2157 #else /* not PCC_STATIC_STRUCT_RETURN */
2159 struct_value_size
= int_size_in_bytes (rettype
);
2161 if (target
&& MEM_P (target
) && CALL_EXPR_RETURN_SLOT_OPT (exp
))
2162 structure_value_addr
= XEXP (target
, 0);
2165 /* For variable-sized objects, we must be called with a target
2166 specified. If we were to allocate space on the stack here,
2167 we would have no way of knowing when to free it. */
2168 rtx d
= assign_temp (rettype
, 0, 1, 1);
2170 mark_temp_addr_taken (d
);
2171 structure_value_addr
= XEXP (d
, 0);
2175 #endif /* not PCC_STATIC_STRUCT_RETURN */
2178 /* Figure out the amount to which the stack should be aligned. */
2179 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
2182 struct cgraph_rtl_info
*i
= cgraph_rtl_info (fndecl
);
2183 /* Without automatic stack alignment, we can't increase preferred
2184 stack boundary. With automatic stack alignment, it is
2185 unnecessary since unless we can guarantee that all callers will
2186 align the outgoing stack properly, callee has to align its
2189 && i
->preferred_incoming_stack_boundary
2190 && i
->preferred_incoming_stack_boundary
< preferred_stack_boundary
)
2191 preferred_stack_boundary
= i
->preferred_incoming_stack_boundary
;
2194 /* Operand 0 is a pointer-to-function; get the type of the function. */
2195 funtype
= TREE_TYPE (addr
);
2196 gcc_assert (POINTER_TYPE_P (funtype
));
2197 funtype
= TREE_TYPE (funtype
);
2199 /* Count whether there are actual complex arguments that need to be split
2200 into their real and imaginary parts. Munge the type_arg_types
2201 appropriately here as well. */
2202 if (targetm
.calls
.split_complex_arg
)
2204 call_expr_arg_iterator iter
;
2206 FOR_EACH_CALL_EXPR_ARG (arg
, iter
, exp
)
2208 tree type
= TREE_TYPE (arg
);
2209 if (type
&& TREE_CODE (type
) == COMPLEX_TYPE
2210 && targetm
.calls
.split_complex_arg (type
))
2211 num_complex_actuals
++;
2213 type_arg_types
= split_complex_types (TYPE_ARG_TYPES (funtype
));
2216 type_arg_types
= TYPE_ARG_TYPES (funtype
);
2218 if (flags
& ECF_MAY_BE_ALLOCA
)
2219 cfun
->calls_alloca
= 1;
2221 /* If struct_value_rtx is 0, it means pass the address
2222 as if it were an extra parameter. Put the argument expression
2223 in structure_value_addr_value. */
2224 if (structure_value_addr
&& struct_value
== 0)
2226 /* If structure_value_addr is a REG other than
2227 virtual_outgoing_args_rtx, we can use always use it. If it
2228 is not a REG, we must always copy it into a register.
2229 If it is virtual_outgoing_args_rtx, we must copy it to another
2230 register in some cases. */
2231 rtx temp
= (!REG_P (structure_value_addr
)
2232 || (ACCUMULATE_OUTGOING_ARGS
2233 && stack_arg_under_construction
2234 && structure_value_addr
== virtual_outgoing_args_rtx
)
2235 ? copy_addr_to_reg (convert_memory_address
2236 (Pmode
, structure_value_addr
))
2237 : structure_value_addr
);
2239 structure_value_addr_value
=
2240 make_tree (build_pointer_type (TREE_TYPE (funtype
)), temp
);
2241 structure_value_addr_parm
= 1;
2244 /* Count the arguments and set NUM_ACTUALS. */
2246 call_expr_nargs (exp
) + num_complex_actuals
+ structure_value_addr_parm
;
2248 /* Compute number of named args.
2249 First, do a raw count of the args for INIT_CUMULATIVE_ARGS. */
2251 if (type_arg_types
!= 0)
2253 = (list_length (type_arg_types
)
2254 /* Count the struct value address, if it is passed as a parm. */
2255 + structure_value_addr_parm
);
2257 /* If we know nothing, treat all args as named. */
2258 n_named_args
= num_actuals
;
2260 /* Start updating where the next arg would go.
2262 On some machines (such as the PA) indirect calls have a different
2263 calling convention than normal calls. The fourth argument in
2264 INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
2266 INIT_CUMULATIVE_ARGS (args_so_far_v
, funtype
, NULL_RTX
, fndecl
, n_named_args
);
2267 args_so_far
= pack_cumulative_args (&args_so_far_v
);
2269 /* Now possibly adjust the number of named args.
2270 Normally, don't include the last named arg if anonymous args follow.
2271 We do include the last named arg if
2272 targetm.calls.strict_argument_naming() returns nonzero.
2273 (If no anonymous args follow, the result of list_length is actually
2274 one too large. This is harmless.)
2276 If targetm.calls.pretend_outgoing_varargs_named() returns
2277 nonzero, and targetm.calls.strict_argument_naming() returns zero,
2278 this machine will be able to place unnamed args that were passed
2279 in registers into the stack. So treat all args as named. This
2280 allows the insns emitting for a specific argument list to be
2281 independent of the function declaration.
2283 If targetm.calls.pretend_outgoing_varargs_named() returns zero,
2284 we do not have any reliable way to pass unnamed args in
2285 registers, so we must force them into memory. */
2287 if (type_arg_types
!= 0
2288 && targetm
.calls
.strict_argument_naming (args_so_far
))
2290 else if (type_arg_types
!= 0
2291 && ! targetm
.calls
.pretend_outgoing_varargs_named (args_so_far
))
2292 /* Don't include the last named arg. */
2295 /* Treat all args as named. */
2296 n_named_args
= num_actuals
;
2298 /* Make a vector to hold all the information about each arg. */
2299 args
= XALLOCAVEC (struct arg_data
, num_actuals
);
2300 memset (args
, 0, num_actuals
* sizeof (struct arg_data
));
2302 /* Build up entries in the ARGS array, compute the size of the
2303 arguments into ARGS_SIZE, etc. */
2304 initialize_argument_information (num_actuals
, args
, &args_size
,
2306 structure_value_addr_value
, fndecl
, fntype
,
2307 args_so_far
, reg_parm_stack_space
,
2308 &old_stack_level
, &old_pending_adj
,
2309 &must_preallocate
, &flags
,
2310 &try_tail_call
, CALL_FROM_THUNK_P (exp
));
2313 must_preallocate
= 1;
2315 /* Now make final decision about preallocating stack space. */
2316 must_preallocate
= finalize_must_preallocate (must_preallocate
,
2320 /* If the structure value address will reference the stack pointer, we
2321 must stabilize it. We don't need to do this if we know that we are
2322 not going to adjust the stack pointer in processing this call. */
2324 if (structure_value_addr
2325 && (reg_mentioned_p (virtual_stack_dynamic_rtx
, structure_value_addr
)
2326 || reg_mentioned_p (virtual_outgoing_args_rtx
,
2327 structure_value_addr
))
2329 || (!ACCUMULATE_OUTGOING_ARGS
&& args_size
.constant
)))
2330 structure_value_addr
= copy_to_reg (structure_value_addr
);
2332 /* Tail calls can make things harder to debug, and we've traditionally
2333 pushed these optimizations into -O2. Don't try if we're already
2334 expanding a call, as that means we're an argument. Don't try if
2335 there's cleanups, as we know there's code to follow the call. */
2337 if (currently_expanding_call
++ != 0
2338 || !flag_optimize_sibling_calls
2340 || dbg_cnt (tail_call
) == false)
2343 /* Rest of purposes for tail call optimizations to fail. */
2345 #ifdef HAVE_sibcall_epilogue
2346 !HAVE_sibcall_epilogue
2351 /* Doing sibling call optimization needs some work, since
2352 structure_value_addr can be allocated on the stack.
2353 It does not seem worth the effort since few optimizable
2354 sibling calls will return a structure. */
2355 || structure_value_addr
!= NULL_RTX
2356 #ifdef REG_PARM_STACK_SPACE
2357 /* If outgoing reg parm stack space changes, we can not do sibcall. */
2358 || (OUTGOING_REG_PARM_STACK_SPACE (funtype
)
2359 != OUTGOING_REG_PARM_STACK_SPACE (TREE_TYPE (current_function_decl
)))
2360 || (reg_parm_stack_space
!= REG_PARM_STACK_SPACE (fndecl
))
2362 /* Check whether the target is able to optimize the call
2364 || !targetm
.function_ok_for_sibcall (fndecl
, exp
)
2365 /* Functions that do not return exactly once may not be sibcall
2367 || (flags
& (ECF_RETURNS_TWICE
| ECF_NORETURN
))
2368 || TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (addr
)))
2369 /* If the called function is nested in the current one, it might access
2370 some of the caller's arguments, but could clobber them beforehand if
2371 the argument areas are shared. */
2372 || (fndecl
&& decl_function_context (fndecl
) == current_function_decl
)
2373 /* If this function requires more stack slots than the current
2374 function, we cannot change it into a sibling call.
2375 crtl->args.pretend_args_size is not part of the
2376 stack allocated by our caller. */
2377 || args_size
.constant
> (crtl
->args
.size
2378 - crtl
->args
.pretend_args_size
)
2379 /* If the callee pops its own arguments, then it must pop exactly
2380 the same number of arguments as the current function. */
2381 || (targetm
.calls
.return_pops_args (fndecl
, funtype
, args_size
.constant
)
2382 != targetm
.calls
.return_pops_args (current_function_decl
,
2383 TREE_TYPE (current_function_decl
),
2385 || !lang_hooks
.decls
.ok_for_sibcall (fndecl
))
2388 /* Check if caller and callee disagree in promotion of function
2392 enum machine_mode caller_mode
, caller_promoted_mode
;
2393 enum machine_mode callee_mode
, callee_promoted_mode
;
2394 int caller_unsignedp
, callee_unsignedp
;
2395 tree caller_res
= DECL_RESULT (current_function_decl
);
2397 caller_unsignedp
= TYPE_UNSIGNED (TREE_TYPE (caller_res
));
2398 caller_mode
= DECL_MODE (caller_res
);
2399 callee_unsignedp
= TYPE_UNSIGNED (TREE_TYPE (funtype
));
2400 callee_mode
= TYPE_MODE (TREE_TYPE (funtype
));
2401 caller_promoted_mode
2402 = promote_function_mode (TREE_TYPE (caller_res
), caller_mode
,
2404 TREE_TYPE (current_function_decl
), 1);
2405 callee_promoted_mode
2406 = promote_function_mode (TREE_TYPE (funtype
), callee_mode
,
2409 if (caller_mode
!= VOIDmode
2410 && (caller_promoted_mode
!= callee_promoted_mode
2411 || ((caller_mode
!= caller_promoted_mode
2412 || callee_mode
!= callee_promoted_mode
)
2413 && (caller_unsignedp
!= callee_unsignedp
2414 || GET_MODE_BITSIZE (caller_mode
)
2415 < GET_MODE_BITSIZE (callee_mode
)))))
2419 /* Ensure current function's preferred stack boundary is at least
2420 what we need. Stack alignment may also increase preferred stack
2422 if (crtl
->preferred_stack_boundary
< preferred_stack_boundary
)
2423 crtl
->preferred_stack_boundary
= preferred_stack_boundary
;
2425 preferred_stack_boundary
= crtl
->preferred_stack_boundary
;
2427 preferred_unit_stack_boundary
= preferred_stack_boundary
/ BITS_PER_UNIT
;
2429 /* We want to make two insn chains; one for a sibling call, the other
2430 for a normal call. We will select one of the two chains after
2431 initial RTL generation is complete. */
2432 for (pass
= try_tail_call
? 0 : 1; pass
< 2; pass
++)
2434 int sibcall_failure
= 0;
2435 /* We want to emit any pending stack adjustments before the tail
2436 recursion "call". That way we know any adjustment after the tail
2437 recursion call can be ignored if we indeed use the tail
2439 int save_pending_stack_adjust
= 0;
2440 int save_stack_pointer_delta
= 0;
2442 rtx before_call
, next_arg_reg
, after_args
;
2446 /* State variables we need to save and restore between
2448 save_pending_stack_adjust
= pending_stack_adjust
;
2449 save_stack_pointer_delta
= stack_pointer_delta
;
2452 flags
&= ~ECF_SIBCALL
;
2454 flags
|= ECF_SIBCALL
;
2456 /* Other state variables that we must reinitialize each time
2457 through the loop (that are not initialized by the loop itself). */
2461 /* Start a new sequence for the normal call case.
2463 From this point on, if the sibling call fails, we want to set
2464 sibcall_failure instead of continuing the loop. */
2467 /* Don't let pending stack adjusts add up to too much.
2468 Also, do all pending adjustments now if there is any chance
2469 this might be a call to alloca or if we are expanding a sibling
2471 Also do the adjustments before a throwing call, otherwise
2472 exception handling can fail; PR 19225. */
2473 if (pending_stack_adjust
>= 32
2474 || (pending_stack_adjust
> 0
2475 && (flags
& ECF_MAY_BE_ALLOCA
))
2476 || (pending_stack_adjust
> 0
2477 && flag_exceptions
&& !(flags
& ECF_NOTHROW
))
2479 do_pending_stack_adjust ();
2481 /* Precompute any arguments as needed. */
2483 precompute_arguments (num_actuals
, args
);
2485 /* Now we are about to start emitting insns that can be deleted
2486 if a libcall is deleted. */
2487 if (pass
&& (flags
& ECF_MALLOC
))
2490 if (pass
== 0 && crtl
->stack_protect_guard
)
2491 stack_protect_epilogue ();
2493 adjusted_args_size
= args_size
;
2494 /* Compute the actual size of the argument block required. The variable
2495 and constant sizes must be combined, the size may have to be rounded,
2496 and there may be a minimum required size. When generating a sibcall
2497 pattern, do not round up, since we'll be re-using whatever space our
2499 unadjusted_args_size
2500 = compute_argument_block_size (reg_parm_stack_space
,
2501 &adjusted_args_size
,
2504 : preferred_stack_boundary
));
2506 old_stack_allocated
= stack_pointer_delta
- pending_stack_adjust
;
2508 /* The argument block when performing a sibling call is the
2509 incoming argument block. */
2512 argblock
= crtl
->args
.internal_arg_pointer
;
2514 #ifdef STACK_GROWS_DOWNWARD
2515 = plus_constant (argblock
, crtl
->args
.pretend_args_size
);
2517 = plus_constant (argblock
, -crtl
->args
.pretend_args_size
);
2519 stored_args_map
= sbitmap_alloc (args_size
.constant
);
2520 sbitmap_zero (stored_args_map
);
2523 /* If we have no actual push instructions, or shouldn't use them,
2524 make space for all args right now. */
2525 else if (adjusted_args_size
.var
!= 0)
2527 if (old_stack_level
== 0)
2529 emit_stack_save (SAVE_BLOCK
, &old_stack_level
);
2530 old_stack_pointer_delta
= stack_pointer_delta
;
2531 old_pending_adj
= pending_stack_adjust
;
2532 pending_stack_adjust
= 0;
2533 /* stack_arg_under_construction says whether a stack arg is
2534 being constructed at the old stack level. Pushing the stack
2535 gets a clean outgoing argument block. */
2536 old_stack_arg_under_construction
= stack_arg_under_construction
;
2537 stack_arg_under_construction
= 0;
2539 argblock
= push_block (ARGS_SIZE_RTX (adjusted_args_size
), 0, 0);
2540 if (flag_stack_usage_info
)
2541 current_function_has_unbounded_dynamic_stack_size
= 1;
2545 /* Note that we must go through the motions of allocating an argument
2546 block even if the size is zero because we may be storing args
2547 in the area reserved for register arguments, which may be part of
2550 int needed
= adjusted_args_size
.constant
;
2552 /* Store the maximum argument space used. It will be pushed by
2553 the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
2556 if (needed
> crtl
->outgoing_args_size
)
2557 crtl
->outgoing_args_size
= needed
;
2559 if (must_preallocate
)
2561 if (ACCUMULATE_OUTGOING_ARGS
)
2563 /* Since the stack pointer will never be pushed, it is
2564 possible for the evaluation of a parm to clobber
2565 something we have already written to the stack.
2566 Since most function calls on RISC machines do not use
2567 the stack, this is uncommon, but must work correctly.
2569 Therefore, we save any area of the stack that was already
2570 written and that we are using. Here we set up to do this
2571 by making a new stack usage map from the old one. The
2572 actual save will be done by store_one_arg.
2574 Another approach might be to try to reorder the argument
2575 evaluations to avoid this conflicting stack usage. */
2577 /* Since we will be writing into the entire argument area,
2578 the map must be allocated for its entire size, not just
2579 the part that is the responsibility of the caller. */
2580 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
2581 needed
+= reg_parm_stack_space
;
2583 #ifdef ARGS_GROW_DOWNWARD
2584 highest_outgoing_arg_in_use
= MAX (initial_highest_arg_in_use
,
2587 highest_outgoing_arg_in_use
= MAX (initial_highest_arg_in_use
,
2590 free (stack_usage_map_buf
);
2591 stack_usage_map_buf
= XNEWVEC (char, highest_outgoing_arg_in_use
);
2592 stack_usage_map
= stack_usage_map_buf
;
2594 if (initial_highest_arg_in_use
)
2595 memcpy (stack_usage_map
, initial_stack_usage_map
,
2596 initial_highest_arg_in_use
);
2598 if (initial_highest_arg_in_use
!= highest_outgoing_arg_in_use
)
2599 memset (&stack_usage_map
[initial_highest_arg_in_use
], 0,
2600 (highest_outgoing_arg_in_use
2601 - initial_highest_arg_in_use
));
2604 /* The address of the outgoing argument list must not be
2605 copied to a register here, because argblock would be left
2606 pointing to the wrong place after the call to
2607 allocate_dynamic_stack_space below. */
2609 argblock
= virtual_outgoing_args_rtx
;
2613 if (inhibit_defer_pop
== 0)
2615 /* Try to reuse some or all of the pending_stack_adjust
2616 to get this space. */
2618 = (combine_pending_stack_adjustment_and_call
2619 (unadjusted_args_size
,
2620 &adjusted_args_size
,
2621 preferred_unit_stack_boundary
));
2623 /* combine_pending_stack_adjustment_and_call computes
2624 an adjustment before the arguments are allocated.
2625 Account for them and see whether or not the stack
2626 needs to go up or down. */
2627 needed
= unadjusted_args_size
- needed
;
2631 /* We're releasing stack space. */
2632 /* ??? We can avoid any adjustment at all if we're
2633 already aligned. FIXME. */
2634 pending_stack_adjust
= -needed
;
2635 do_pending_stack_adjust ();
2639 /* We need to allocate space. We'll do that in
2640 push_block below. */
2641 pending_stack_adjust
= 0;
2644 /* Special case this because overhead of `push_block' in
2645 this case is non-trivial. */
2647 argblock
= virtual_outgoing_args_rtx
;
2650 argblock
= push_block (GEN_INT (needed
), 0, 0);
2651 #ifdef ARGS_GROW_DOWNWARD
2652 argblock
= plus_constant (argblock
, needed
);
2656 /* We only really need to call `copy_to_reg' in the case
2657 where push insns are going to be used to pass ARGBLOCK
2658 to a function call in ARGS. In that case, the stack
2659 pointer changes value from the allocation point to the
2660 call point, and hence the value of
2661 VIRTUAL_OUTGOING_ARGS_RTX changes as well. But might
2662 as well always do it. */
2663 argblock
= copy_to_reg (argblock
);
2668 if (ACCUMULATE_OUTGOING_ARGS
)
2670 /* The save/restore code in store_one_arg handles all
2671 cases except one: a constructor call (including a C
2672 function returning a BLKmode struct) to initialize
2674 if (stack_arg_under_construction
)
2677 = GEN_INT (adjusted_args_size
.constant
2678 + (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
2679 : TREE_TYPE (fndecl
))) ? 0
2680 : reg_parm_stack_space
));
2681 if (old_stack_level
== 0)
2683 emit_stack_save (SAVE_BLOCK
, &old_stack_level
);
2684 old_stack_pointer_delta
= stack_pointer_delta
;
2685 old_pending_adj
= pending_stack_adjust
;
2686 pending_stack_adjust
= 0;
2687 /* stack_arg_under_construction says whether a stack
2688 arg is being constructed at the old stack level.
2689 Pushing the stack gets a clean outgoing argument
2691 old_stack_arg_under_construction
2692 = stack_arg_under_construction
;
2693 stack_arg_under_construction
= 0;
2694 /* Make a new map for the new argument list. */
2695 free (stack_usage_map_buf
);
2696 stack_usage_map_buf
= XCNEWVEC (char, highest_outgoing_arg_in_use
);
2697 stack_usage_map
= stack_usage_map_buf
;
2698 highest_outgoing_arg_in_use
= 0;
2700 /* We can pass TRUE as the 4th argument because we just
2701 saved the stack pointer and will restore it right after
2703 allocate_dynamic_stack_space (push_size
, 0,
2704 BIGGEST_ALIGNMENT
, true);
2707 /* If argument evaluation might modify the stack pointer,
2708 copy the address of the argument list to a register. */
2709 for (i
= 0; i
< num_actuals
; i
++)
2710 if (args
[i
].pass_on_stack
)
2712 argblock
= copy_addr_to_reg (argblock
);
2717 compute_argument_addresses (args
, argblock
, num_actuals
);
2719 /* If we push args individually in reverse order, perform stack alignment
2720 before the first push (the last arg). */
2721 if (PUSH_ARGS_REVERSED
&& argblock
== 0
2722 && adjusted_args_size
.constant
!= unadjusted_args_size
)
2724 /* When the stack adjustment is pending, we get better code
2725 by combining the adjustments. */
2726 if (pending_stack_adjust
2727 && ! inhibit_defer_pop
)
2729 pending_stack_adjust
2730 = (combine_pending_stack_adjustment_and_call
2731 (unadjusted_args_size
,
2732 &adjusted_args_size
,
2733 preferred_unit_stack_boundary
));
2734 do_pending_stack_adjust ();
2736 else if (argblock
== 0)
2737 anti_adjust_stack (GEN_INT (adjusted_args_size
.constant
2738 - unadjusted_args_size
));
2740 /* Now that the stack is properly aligned, pops can't safely
2741 be deferred during the evaluation of the arguments. */
2744 /* Record the maximum pushed stack space size. We need to delay
2745 doing it this far to take into account the optimization done
2746 by combine_pending_stack_adjustment_and_call. */
2747 if (flag_stack_usage_info
2748 && !ACCUMULATE_OUTGOING_ARGS
2750 && adjusted_args_size
.var
== 0)
2752 int pushed
= adjusted_args_size
.constant
+ pending_stack_adjust
;
2753 if (pushed
> current_function_pushed_stack_size
)
2754 current_function_pushed_stack_size
= pushed
;
2757 funexp
= rtx_for_function_call (fndecl
, addr
);
2759 /* Figure out the register where the value, if any, will come back. */
2761 if (TYPE_MODE (rettype
) != VOIDmode
2762 && ! structure_value_addr
)
2764 if (pcc_struct_value
)
2765 valreg
= hard_function_value (build_pointer_type (rettype
),
2766 fndecl
, NULL
, (pass
== 0));
2768 valreg
= hard_function_value (rettype
, fndecl
, fntype
,
2771 /* If VALREG is a PARALLEL whose first member has a zero
2772 offset, use that. This is for targets such as m68k that
2773 return the same value in multiple places. */
2774 if (GET_CODE (valreg
) == PARALLEL
)
2776 rtx elem
= XVECEXP (valreg
, 0, 0);
2777 rtx where
= XEXP (elem
, 0);
2778 rtx offset
= XEXP (elem
, 1);
2779 if (offset
== const0_rtx
2780 && GET_MODE (where
) == GET_MODE (valreg
))
2785 /* Precompute all register parameters. It isn't safe to compute anything
2786 once we have started filling any specific hard regs. */
2787 precompute_register_parameters (num_actuals
, args
, ®_parm_seen
);
2789 if (CALL_EXPR_STATIC_CHAIN (exp
))
2790 static_chain_value
= expand_normal (CALL_EXPR_STATIC_CHAIN (exp
));
2792 static_chain_value
= 0;
2794 #ifdef REG_PARM_STACK_SPACE
2795 /* Save the fixed argument area if it's part of the caller's frame and
2796 is clobbered by argument setup for this call. */
2797 if (ACCUMULATE_OUTGOING_ARGS
&& pass
)
2798 save_area
= save_fixed_argument_area (reg_parm_stack_space
, argblock
,
2799 &low_to_save
, &high_to_save
);
2802 /* Now store (and compute if necessary) all non-register parms.
2803 These come before register parms, since they can require block-moves,
2804 which could clobber the registers used for register parms.
2805 Parms which have partial registers are not stored here,
2806 but we do preallocate space here if they want that. */
2808 for (i
= 0; i
< num_actuals
; i
++)
2810 if (args
[i
].reg
== 0 || args
[i
].pass_on_stack
)
2812 rtx before_arg
= get_last_insn ();
2814 if (store_one_arg (&args
[i
], argblock
, flags
,
2815 adjusted_args_size
.var
!= 0,
2816 reg_parm_stack_space
)
2818 && check_sibcall_argument_overlap (before_arg
,
2820 sibcall_failure
= 1;
2825 = gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)),
2826 gen_rtx_USE (VOIDmode
, args
[i
].stack
),
2830 /* If we have a parm that is passed in registers but not in memory
2831 and whose alignment does not permit a direct copy into registers,
2832 make a group of pseudos that correspond to each register that we
2834 if (STRICT_ALIGNMENT
)
2835 store_unaligned_arguments_into_pseudos (args
, num_actuals
);
2837 /* Now store any partially-in-registers parm.
2838 This is the last place a block-move can happen. */
2840 for (i
= 0; i
< num_actuals
; i
++)
2841 if (args
[i
].partial
!= 0 && ! args
[i
].pass_on_stack
)
2843 rtx before_arg
= get_last_insn ();
2845 if (store_one_arg (&args
[i
], argblock
, flags
,
2846 adjusted_args_size
.var
!= 0,
2847 reg_parm_stack_space
)
2849 && check_sibcall_argument_overlap (before_arg
,
2851 sibcall_failure
= 1;
2854 /* If we pushed args in forward order, perform stack alignment
2855 after pushing the last arg. */
2856 if (!PUSH_ARGS_REVERSED
&& argblock
== 0)
2857 anti_adjust_stack (GEN_INT (adjusted_args_size
.constant
2858 - unadjusted_args_size
));
2860 /* If register arguments require space on the stack and stack space
2861 was not preallocated, allocate stack space here for arguments
2862 passed in registers. */
2863 if (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
)))
2864 && !ACCUMULATE_OUTGOING_ARGS
2865 && must_preallocate
== 0 && reg_parm_stack_space
> 0)
2866 anti_adjust_stack (GEN_INT (reg_parm_stack_space
));
2868 /* Pass the function the address in which to return a
2870 if (pass
!= 0 && structure_value_addr
&& ! structure_value_addr_parm
)
2872 structure_value_addr
2873 = convert_memory_address (Pmode
, structure_value_addr
);
2874 emit_move_insn (struct_value
,
2876 force_operand (structure_value_addr
,
2879 if (REG_P (struct_value
))
2880 use_reg (&call_fusage
, struct_value
);
2883 after_args
= get_last_insn ();
2884 funexp
= prepare_call_address (fndecl
, funexp
, static_chain_value
,
2885 &call_fusage
, reg_parm_seen
, pass
== 0);
2887 load_register_parameters (args
, num_actuals
, &call_fusage
, flags
,
2888 pass
== 0, &sibcall_failure
);
2890 /* Save a pointer to the last insn before the call, so that we can
2891 later safely search backwards to find the CALL_INSN. */
2892 before_call
= get_last_insn ();
2894 /* Set up next argument register. For sibling calls on machines
2895 with register windows this should be the incoming register. */
2897 next_arg_reg
= targetm
.calls
.function_incoming_arg (args_so_far
,
2902 next_arg_reg
= targetm
.calls
.function_arg (args_so_far
,
2903 VOIDmode
, void_type_node
,
2906 /* All arguments and registers used for the call must be set up by
2909 /* Stack must be properly aligned now. */
2911 || !(stack_pointer_delta
% preferred_unit_stack_boundary
));
2913 /* Generate the actual call instruction. */
2914 emit_call_1 (funexp
, exp
, fndecl
, funtype
, unadjusted_args_size
,
2915 adjusted_args_size
.constant
, struct_value_size
,
2916 next_arg_reg
, valreg
, old_inhibit_defer_pop
, call_fusage
,
2917 flags
, args_so_far
);
2919 /* If the call setup or the call itself overlaps with anything
2920 of the argument setup we probably clobbered our call address.
2921 In that case we can't do sibcalls. */
2923 && check_sibcall_argument_overlap (after_args
, 0, 0))
2924 sibcall_failure
= 1;
2926 /* If a non-BLKmode value is returned at the most significant end
2927 of a register, shift the register right by the appropriate amount
2928 and update VALREG accordingly. BLKmode values are handled by the
2929 group load/store machinery below. */
2930 if (!structure_value_addr
2931 && !pcc_struct_value
2932 && TYPE_MODE (rettype
) != BLKmode
2933 && targetm
.calls
.return_in_msb (rettype
))
2935 if (shift_return_value (TYPE_MODE (rettype
), false, valreg
))
2936 sibcall_failure
= 1;
2937 valreg
= gen_rtx_REG (TYPE_MODE (rettype
), REGNO (valreg
));
2940 if (pass
&& (flags
& ECF_MALLOC
))
2942 rtx temp
= gen_reg_rtx (GET_MODE (valreg
));
2945 /* The return value from a malloc-like function is a pointer. */
2946 if (TREE_CODE (rettype
) == POINTER_TYPE
)
2947 mark_reg_pointer (temp
, BIGGEST_ALIGNMENT
);
2949 emit_move_insn (temp
, valreg
);
2951 /* The return value from a malloc-like function can not alias
2953 last
= get_last_insn ();
2954 add_reg_note (last
, REG_NOALIAS
, temp
);
2956 /* Write out the sequence. */
2957 insns
= get_insns ();
2963 /* For calls to `setjmp', etc., inform
2964 function.c:setjmp_warnings that it should complain if
2965 nonvolatile values are live. For functions that cannot
2966 return, inform flow that control does not fall through. */
2968 if ((flags
& ECF_NORETURN
) || pass
== 0)
2970 /* The barrier must be emitted
2971 immediately after the CALL_INSN. Some ports emit more
2972 than just a CALL_INSN above, so we must search for it here. */
2974 rtx last
= get_last_insn ();
2975 while (!CALL_P (last
))
2977 last
= PREV_INSN (last
);
2978 /* There was no CALL_INSN? */
2979 gcc_assert (last
!= before_call
);
2982 emit_barrier_after (last
);
2984 /* Stack adjustments after a noreturn call are dead code.
2985 However when NO_DEFER_POP is in effect, we must preserve
2986 stack_pointer_delta. */
2987 if (inhibit_defer_pop
== 0)
2989 stack_pointer_delta
= old_stack_allocated
;
2990 pending_stack_adjust
= 0;
2994 /* If value type not void, return an rtx for the value. */
2996 if (TYPE_MODE (rettype
) == VOIDmode
2998 target
= const0_rtx
;
2999 else if (structure_value_addr
)
3001 if (target
== 0 || !MEM_P (target
))
3004 = gen_rtx_MEM (TYPE_MODE (rettype
),
3005 memory_address (TYPE_MODE (rettype
),
3006 structure_value_addr
));
3007 set_mem_attributes (target
, rettype
, 1);
3010 else if (pcc_struct_value
)
3012 /* This is the special C++ case where we need to
3013 know what the true target was. We take care to
3014 never use this value more than once in one expression. */
3015 target
= gen_rtx_MEM (TYPE_MODE (rettype
),
3016 copy_to_reg (valreg
));
3017 set_mem_attributes (target
, rettype
, 1);
3019 /* Handle calls that return values in multiple non-contiguous locations.
3020 The Irix 6 ABI has examples of this. */
3021 else if (GET_CODE (valreg
) == PARALLEL
)
3025 /* This will only be assigned once, so it can be readonly. */
3026 tree nt
= build_qualified_type (rettype
,
3027 (TYPE_QUALS (rettype
)
3028 | TYPE_QUAL_CONST
));
3030 target
= assign_temp (nt
, 0, 1, 1);
3033 if (! rtx_equal_p (target
, valreg
))
3034 emit_group_store (target
, valreg
, rettype
,
3035 int_size_in_bytes (rettype
));
3037 /* We can not support sibling calls for this case. */
3038 sibcall_failure
= 1;
3041 && GET_MODE (target
) == TYPE_MODE (rettype
)
3042 && GET_MODE (target
) == GET_MODE (valreg
))
3044 bool may_overlap
= false;
3046 /* We have to copy a return value in a CLASS_LIKELY_SPILLED hard
3047 reg to a plain register. */
3048 if (!REG_P (target
) || HARD_REGISTER_P (target
))
3049 valreg
= avoid_likely_spilled_reg (valreg
);
3051 /* If TARGET is a MEM in the argument area, and we have
3052 saved part of the argument area, then we can't store
3053 directly into TARGET as it may get overwritten when we
3054 restore the argument save area below. Don't work too
3055 hard though and simply force TARGET to a register if it
3056 is a MEM; the optimizer is quite likely to sort it out. */
3057 if (ACCUMULATE_OUTGOING_ARGS
&& pass
&& MEM_P (target
))
3058 for (i
= 0; i
< num_actuals
; i
++)
3059 if (args
[i
].save_area
)
3066 target
= copy_to_reg (valreg
);
3069 /* TARGET and VALREG cannot be equal at this point
3070 because the latter would not have
3071 REG_FUNCTION_VALUE_P true, while the former would if
3072 it were referring to the same register.
3074 If they refer to the same register, this move will be
3075 a no-op, except when function inlining is being
3077 emit_move_insn (target
, valreg
);
3079 /* If we are setting a MEM, this code must be executed.
3080 Since it is emitted after the call insn, sibcall
3081 optimization cannot be performed in that case. */
3083 sibcall_failure
= 1;
3086 else if (TYPE_MODE (rettype
) == BLKmode
)
3089 if (GET_MODE (val
) != BLKmode
)
3090 val
= avoid_likely_spilled_reg (val
);
3091 target
= copy_blkmode_from_reg (target
, val
, rettype
);
3093 /* We can not support sibling calls for this case. */
3094 sibcall_failure
= 1;
3097 target
= copy_to_reg (avoid_likely_spilled_reg (valreg
));
3099 /* If we promoted this return value, make the proper SUBREG.
3100 TARGET might be const0_rtx here, so be careful. */
3102 && TYPE_MODE (rettype
) != BLKmode
3103 && GET_MODE (target
) != TYPE_MODE (rettype
))
3105 tree type
= rettype
;
3106 int unsignedp
= TYPE_UNSIGNED (type
);
3108 enum machine_mode pmode
;
3110 /* Ensure we promote as expected, and get the new unsignedness. */
3111 pmode
= promote_function_mode (type
, TYPE_MODE (type
), &unsignedp
,
3113 gcc_assert (GET_MODE (target
) == pmode
);
3115 if ((WORDS_BIG_ENDIAN
|| BYTES_BIG_ENDIAN
)
3116 && (GET_MODE_SIZE (GET_MODE (target
))
3117 > GET_MODE_SIZE (TYPE_MODE (type
))))
3119 offset
= GET_MODE_SIZE (GET_MODE (target
))
3120 - GET_MODE_SIZE (TYPE_MODE (type
));
3121 if (! BYTES_BIG_ENDIAN
)
3122 offset
= (offset
/ UNITS_PER_WORD
) * UNITS_PER_WORD
;
3123 else if (! WORDS_BIG_ENDIAN
)
3124 offset
%= UNITS_PER_WORD
;
3127 target
= gen_rtx_SUBREG (TYPE_MODE (type
), target
, offset
);
3128 SUBREG_PROMOTED_VAR_P (target
) = 1;
3129 SUBREG_PROMOTED_UNSIGNED_SET (target
, unsignedp
);
3132 /* If size of args is variable or this was a constructor call for a stack
3133 argument, restore saved stack-pointer value. */
3135 if (old_stack_level
)
3137 rtx prev
= get_last_insn ();
3139 emit_stack_restore (SAVE_BLOCK
, old_stack_level
);
3140 stack_pointer_delta
= old_stack_pointer_delta
;
3142 fixup_args_size_notes (prev
, get_last_insn (), stack_pointer_delta
);
3144 pending_stack_adjust
= old_pending_adj
;
3145 old_stack_allocated
= stack_pointer_delta
- pending_stack_adjust
;
3146 stack_arg_under_construction
= old_stack_arg_under_construction
;
3147 highest_outgoing_arg_in_use
= initial_highest_arg_in_use
;
3148 stack_usage_map
= initial_stack_usage_map
;
3149 sibcall_failure
= 1;
3151 else if (ACCUMULATE_OUTGOING_ARGS
&& pass
)
3153 #ifdef REG_PARM_STACK_SPACE
3155 restore_fixed_argument_area (save_area
, argblock
,
3156 high_to_save
, low_to_save
);
3159 /* If we saved any argument areas, restore them. */
3160 for (i
= 0; i
< num_actuals
; i
++)
3161 if (args
[i
].save_area
)
3163 enum machine_mode save_mode
= GET_MODE (args
[i
].save_area
);
3165 = gen_rtx_MEM (save_mode
,
3166 memory_address (save_mode
,
3167 XEXP (args
[i
].stack_slot
, 0)));
3169 if (save_mode
!= BLKmode
)
3170 emit_move_insn (stack_area
, args
[i
].save_area
);
3172 emit_block_move (stack_area
, args
[i
].save_area
,
3173 GEN_INT (args
[i
].locate
.size
.constant
),
3174 BLOCK_OP_CALL_PARM
);
3177 highest_outgoing_arg_in_use
= initial_highest_arg_in_use
;
3178 stack_usage_map
= initial_stack_usage_map
;
3181 /* If this was alloca, record the new stack level for nonlocal gotos.
3182 Check for the handler slots since we might not have a save area
3183 for non-local gotos. */
3185 if ((flags
& ECF_MAY_BE_ALLOCA
) && cfun
->nonlocal_goto_save_area
!= 0)
3186 update_nonlocal_goto_save_area ();
3188 /* Free up storage we no longer need. */
3189 for (i
= 0; i
< num_actuals
; ++i
)
3190 free (args
[i
].aligned_regs
);
3192 insns
= get_insns ();
3197 tail_call_insns
= insns
;
3199 /* Restore the pending stack adjustment now that we have
3200 finished generating the sibling call sequence. */
3202 pending_stack_adjust
= save_pending_stack_adjust
;
3203 stack_pointer_delta
= save_stack_pointer_delta
;
3205 /* Prepare arg structure for next iteration. */
3206 for (i
= 0; i
< num_actuals
; i
++)
3209 args
[i
].aligned_regs
= 0;
3213 sbitmap_free (stored_args_map
);
3217 normal_call_insns
= insns
;
3219 /* Verify that we've deallocated all the stack we used. */
3220 gcc_assert ((flags
& ECF_NORETURN
)
3221 || (old_stack_allocated
3222 == stack_pointer_delta
- pending_stack_adjust
));
3225 /* If something prevents making this a sibling call,
3226 zero out the sequence. */
3227 if (sibcall_failure
)
3228 tail_call_insns
= NULL_RTX
;
3233 /* If tail call production succeeded, we need to remove REG_EQUIV notes on
3234 arguments too, as argument area is now clobbered by the call. */
3235 if (tail_call_insns
)
3237 emit_insn (tail_call_insns
);
3238 crtl
->tail_call_emit
= true;
3241 emit_insn (normal_call_insns
);
3243 currently_expanding_call
--;
3245 free (stack_usage_map_buf
);
3250 /* A sibling call sequence invalidates any REG_EQUIV notes made for
3251 this function's incoming arguments.
3253 At the start of RTL generation we know the only REG_EQUIV notes
3254 in the rtl chain are those for incoming arguments, so we can look
3255 for REG_EQUIV notes between the start of the function and the
3256 NOTE_INSN_FUNCTION_BEG.
3258 This is (slight) overkill. We could keep track of the highest
3259 argument we clobber and be more selective in removing notes, but it
3260 does not seem to be worth the effort. */
3263 fixup_tail_calls (void)
3267 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
3271 /* There are never REG_EQUIV notes for the incoming arguments
3272 after the NOTE_INSN_FUNCTION_BEG note, so stop if we see it. */
3274 && NOTE_KIND (insn
) == NOTE_INSN_FUNCTION_BEG
)
3277 note
= find_reg_note (insn
, REG_EQUIV
, 0);
3279 remove_note (insn
, note
);
3280 note
= find_reg_note (insn
, REG_EQUIV
, 0);
3285 /* Traverse a list of TYPES and expand all complex types into their
3288 split_complex_types (tree types
)
3292 /* Before allocating memory, check for the common case of no complex. */
3293 for (p
= types
; p
; p
= TREE_CHAIN (p
))
3295 tree type
= TREE_VALUE (p
);
3296 if (TREE_CODE (type
) == COMPLEX_TYPE
3297 && targetm
.calls
.split_complex_arg (type
))
3303 types
= copy_list (types
);
3305 for (p
= types
; p
; p
= TREE_CHAIN (p
))
3307 tree complex_type
= TREE_VALUE (p
);
3309 if (TREE_CODE (complex_type
) == COMPLEX_TYPE
3310 && targetm
.calls
.split_complex_arg (complex_type
))
3314 /* Rewrite complex type with component type. */
3315 TREE_VALUE (p
) = TREE_TYPE (complex_type
);
3316 next
= TREE_CHAIN (p
);
3318 /* Add another component type for the imaginary part. */
3319 imag
= build_tree_list (NULL_TREE
, TREE_VALUE (p
));
3320 TREE_CHAIN (p
) = imag
;
3321 TREE_CHAIN (imag
) = next
;
3323 /* Skip the newly created node. */
3331 /* Output a library call to function FUN (a SYMBOL_REF rtx).
3332 The RETVAL parameter specifies whether return value needs to be saved, other
3333 parameters are documented in the emit_library_call function below. */
3336 emit_library_call_value_1 (int retval
, rtx orgfun
, rtx value
,
3337 enum libcall_type fn_type
,
3338 enum machine_mode outmode
, int nargs
, va_list p
)
3340 /* Total size in bytes of all the stack-parms scanned so far. */
3341 struct args_size args_size
;
3342 /* Size of arguments before any adjustments (such as rounding). */
3343 struct args_size original_args_size
;
3346 /* Todo, choose the correct decl type of orgfun. Sadly this information
3347 isn't present here, so we default to native calling abi here. */
3348 tree fndecl ATTRIBUTE_UNUSED
= NULL_TREE
; /* library calls default to host calling abi ? */
3349 tree fntype ATTRIBUTE_UNUSED
= NULL_TREE
; /* library calls default to host calling abi ? */
3353 CUMULATIVE_ARGS args_so_far_v
;
3354 cumulative_args_t args_so_far
;
3358 enum machine_mode mode
;
3361 struct locate_and_pad_arg_data locate
;
3365 int old_inhibit_defer_pop
= inhibit_defer_pop
;
3366 rtx call_fusage
= 0;
3369 int pcc_struct_value
= 0;
3370 int struct_value_size
= 0;
3372 int reg_parm_stack_space
= 0;
3375 tree tfom
; /* type_for_mode (outmode, 0) */
3377 #ifdef REG_PARM_STACK_SPACE
3378 /* Define the boundary of the register parm stack space that needs to be
3380 int low_to_save
= 0, high_to_save
= 0;
3381 rtx save_area
= 0; /* Place that it is saved. */
3384 /* Size of the stack reserved for parameter registers. */
3385 int initial_highest_arg_in_use
= highest_outgoing_arg_in_use
;
3386 char *initial_stack_usage_map
= stack_usage_map
;
3387 char *stack_usage_map_buf
= NULL
;
3389 rtx struct_value
= targetm
.calls
.struct_value_rtx (0, 0);
3391 #ifdef REG_PARM_STACK_SPACE
3392 reg_parm_stack_space
= REG_PARM_STACK_SPACE ((tree
) 0);
3395 /* By default, library functions can not throw. */
3396 flags
= ECF_NOTHROW
;
3409 flags
|= ECF_NORETURN
;
3412 flags
= ECF_NORETURN
;
3414 case LCT_RETURNS_TWICE
:
3415 flags
= ECF_RETURNS_TWICE
;
3420 /* Ensure current function's preferred stack boundary is at least
3422 if (crtl
->preferred_stack_boundary
< PREFERRED_STACK_BOUNDARY
)
3423 crtl
->preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
3425 /* If this kind of value comes back in memory,
3426 decide where in memory it should come back. */
3427 if (outmode
!= VOIDmode
)
3429 tfom
= lang_hooks
.types
.type_for_mode (outmode
, 0);
3430 if (aggregate_value_p (tfom
, 0))
3432 #ifdef PCC_STATIC_STRUCT_RETURN
3434 = hard_function_value (build_pointer_type (tfom
), 0, 0, 0);
3435 mem_value
= gen_rtx_MEM (outmode
, pointer_reg
);
3436 pcc_struct_value
= 1;
3438 value
= gen_reg_rtx (outmode
);
3439 #else /* not PCC_STATIC_STRUCT_RETURN */
3440 struct_value_size
= GET_MODE_SIZE (outmode
);
3441 if (value
!= 0 && MEM_P (value
))
3444 mem_value
= assign_temp (tfom
, 0, 1, 1);
3446 /* This call returns a big structure. */
3447 flags
&= ~(ECF_CONST
| ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
);
3451 tfom
= void_type_node
;
3453 /* ??? Unfinished: must pass the memory address as an argument. */
3455 /* Copy all the libcall-arguments out of the varargs data
3456 and into a vector ARGVEC.
3458 Compute how to pass each argument. We only support a very small subset
3459 of the full argument passing conventions to limit complexity here since
3460 library functions shouldn't have many args. */
3462 argvec
= XALLOCAVEC (struct arg
, nargs
+ 1);
3463 memset (argvec
, 0, (nargs
+ 1) * sizeof (struct arg
));
3465 #ifdef INIT_CUMULATIVE_LIBCALL_ARGS
3466 INIT_CUMULATIVE_LIBCALL_ARGS (args_so_far_v
, outmode
, fun
);
3468 INIT_CUMULATIVE_ARGS (args_so_far_v
, NULL_TREE
, fun
, 0, nargs
);
3470 args_so_far
= pack_cumulative_args (&args_so_far_v
);
3472 args_size
.constant
= 0;
3479 /* If there's a structure value address to be passed,
3480 either pass it in the special place, or pass it as an extra argument. */
3481 if (mem_value
&& struct_value
== 0 && ! pcc_struct_value
)
3483 rtx addr
= XEXP (mem_value
, 0);
3487 /* Make sure it is a reasonable operand for a move or push insn. */
3488 if (!REG_P (addr
) && !MEM_P (addr
)
3489 && !(CONSTANT_P (addr
)
3490 && targetm
.legitimate_constant_p (Pmode
, addr
)))
3491 addr
= force_operand (addr
, NULL_RTX
);
3493 argvec
[count
].value
= addr
;
3494 argvec
[count
].mode
= Pmode
;
3495 argvec
[count
].partial
= 0;
3497 argvec
[count
].reg
= targetm
.calls
.function_arg (args_so_far
,
3498 Pmode
, NULL_TREE
, true);
3499 gcc_assert (targetm
.calls
.arg_partial_bytes (args_so_far
, Pmode
,
3500 NULL_TREE
, 1) == 0);
3502 locate_and_pad_parm (Pmode
, NULL_TREE
,
3503 #ifdef STACK_PARMS_IN_REG_PARM_AREA
3506 argvec
[count
].reg
!= 0,
3508 0, NULL_TREE
, &args_size
, &argvec
[count
].locate
);
3510 if (argvec
[count
].reg
== 0 || argvec
[count
].partial
!= 0
3511 || reg_parm_stack_space
> 0)
3512 args_size
.constant
+= argvec
[count
].locate
.size
.constant
;
3514 targetm
.calls
.function_arg_advance (args_so_far
, Pmode
, (tree
) 0, true);
3519 for (; count
< nargs
; count
++)
3521 rtx val
= va_arg (p
, rtx
);
3522 enum machine_mode mode
= (enum machine_mode
) va_arg (p
, int);
3525 /* We cannot convert the arg value to the mode the library wants here;
3526 must do it earlier where we know the signedness of the arg. */
3527 gcc_assert (mode
!= BLKmode
3528 && (GET_MODE (val
) == mode
|| GET_MODE (val
) == VOIDmode
));
3530 /* Make sure it is a reasonable operand for a move or push insn. */
3531 if (!REG_P (val
) && !MEM_P (val
)
3532 && !(CONSTANT_P (val
) && targetm
.legitimate_constant_p (mode
, val
)))
3533 val
= force_operand (val
, NULL_RTX
);
3535 if (pass_by_reference (&args_so_far_v
, mode
, NULL_TREE
, 1))
3539 = !reference_callee_copied (&args_so_far_v
, mode
, NULL_TREE
, 1);
3541 /* If this was a CONST function, it is now PURE since it now
3543 if (flags
& ECF_CONST
)
3545 flags
&= ~ECF_CONST
;
3549 if (MEM_P (val
) && !must_copy
)
3551 tree val_expr
= MEM_EXPR (val
);
3553 mark_addressable (val_expr
);
3558 slot
= assign_temp (lang_hooks
.types
.type_for_mode (mode
, 0),
3560 emit_move_insn (slot
, val
);
3563 call_fusage
= gen_rtx_EXPR_LIST (VOIDmode
,
3564 gen_rtx_USE (VOIDmode
, slot
),
3567 call_fusage
= gen_rtx_EXPR_LIST (VOIDmode
,
3568 gen_rtx_CLOBBER (VOIDmode
,
3573 val
= force_operand (XEXP (slot
, 0), NULL_RTX
);
3576 mode
= promote_function_mode (NULL_TREE
, mode
, &unsigned_p
, NULL_TREE
, 0);
3577 argvec
[count
].mode
= mode
;
3578 argvec
[count
].value
= convert_modes (mode
, GET_MODE (val
), val
, unsigned_p
);
3579 argvec
[count
].reg
= targetm
.calls
.function_arg (args_so_far
, mode
,
3582 argvec
[count
].partial
3583 = targetm
.calls
.arg_partial_bytes (args_so_far
, mode
, NULL_TREE
, 1);
3585 if (argvec
[count
].reg
== 0
3586 || argvec
[count
].partial
!= 0
3587 || reg_parm_stack_space
> 0)
3589 locate_and_pad_parm (mode
, NULL_TREE
,
3590 #ifdef STACK_PARMS_IN_REG_PARM_AREA
3593 argvec
[count
].reg
!= 0,
3595 argvec
[count
].partial
,
3596 NULL_TREE
, &args_size
, &argvec
[count
].locate
);
3597 args_size
.constant
+= argvec
[count
].locate
.size
.constant
;
3598 gcc_assert (!argvec
[count
].locate
.size
.var
);
3600 #ifdef BLOCK_REG_PADDING
3602 /* The argument is passed entirely in registers. See at which
3603 end it should be padded. */
3604 argvec
[count
].locate
.where_pad
=
3605 BLOCK_REG_PADDING (mode
, NULL_TREE
,
3606 GET_MODE_SIZE (mode
) <= UNITS_PER_WORD
);
3609 targetm
.calls
.function_arg_advance (args_so_far
, mode
, (tree
) 0, true);
3612 /* If this machine requires an external definition for library
3613 functions, write one out. */
3614 assemble_external_libcall (fun
);
3616 original_args_size
= args_size
;
3617 args_size
.constant
= (((args_size
.constant
3618 + stack_pointer_delta
3622 - stack_pointer_delta
);
3624 args_size
.constant
= MAX (args_size
.constant
,
3625 reg_parm_stack_space
);
3627 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
3628 args_size
.constant
-= reg_parm_stack_space
;
3630 if (args_size
.constant
> crtl
->outgoing_args_size
)
3631 crtl
->outgoing_args_size
= args_size
.constant
;
3633 if (flag_stack_usage_info
&& !ACCUMULATE_OUTGOING_ARGS
)
3635 int pushed
= args_size
.constant
+ pending_stack_adjust
;
3636 if (pushed
> current_function_pushed_stack_size
)
3637 current_function_pushed_stack_size
= pushed
;
3640 if (ACCUMULATE_OUTGOING_ARGS
)
3642 /* Since the stack pointer will never be pushed, it is possible for
3643 the evaluation of a parm to clobber something we have already
3644 written to the stack. Since most function calls on RISC machines
3645 do not use the stack, this is uncommon, but must work correctly.
3647 Therefore, we save any area of the stack that was already written
3648 and that we are using. Here we set up to do this by making a new
3649 stack usage map from the old one.
3651 Another approach might be to try to reorder the argument
3652 evaluations to avoid this conflicting stack usage. */
3654 needed
= args_size
.constant
;
3656 /* Since we will be writing into the entire argument area, the
3657 map must be allocated for its entire size, not just the part that
3658 is the responsibility of the caller. */
3659 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl
? fntype
: TREE_TYPE (fndecl
))))
3660 needed
+= reg_parm_stack_space
;
3662 #ifdef ARGS_GROW_DOWNWARD
3663 highest_outgoing_arg_in_use
= MAX (initial_highest_arg_in_use
,
3666 highest_outgoing_arg_in_use
= MAX (initial_highest_arg_in_use
,
3669 stack_usage_map_buf
= XNEWVEC (char, highest_outgoing_arg_in_use
);
3670 stack_usage_map
= stack_usage_map_buf
;
3672 if (initial_highest_arg_in_use
)
3673 memcpy (stack_usage_map
, initial_stack_usage_map
,
3674 initial_highest_arg_in_use
);
3676 if (initial_highest_arg_in_use
!= highest_outgoing_arg_in_use
)
3677 memset (&stack_usage_map
[initial_highest_arg_in_use
], 0,
3678 highest_outgoing_arg_in_use
- initial_highest_arg_in_use
);
3681 /* We must be careful to use virtual regs before they're instantiated,
3682 and real regs afterwards. Loop optimization, for example, can create
3683 new libcalls after we've instantiated the virtual regs, and if we
3684 use virtuals anyway, they won't match the rtl patterns. */
3686 if (virtuals_instantiated
)
3687 argblock
= plus_constant (stack_pointer_rtx
, STACK_POINTER_OFFSET
);
3689 argblock
= virtual_outgoing_args_rtx
;
3694 argblock
= push_block (GEN_INT (args_size
.constant
), 0, 0);
3697 /* If we push args individually in reverse order, perform stack alignment
3698 before the first push (the last arg). */
3699 if (argblock
== 0 && PUSH_ARGS_REVERSED
)
3700 anti_adjust_stack (GEN_INT (args_size
.constant
3701 - original_args_size
.constant
));
3703 if (PUSH_ARGS_REVERSED
)
3714 #ifdef REG_PARM_STACK_SPACE
3715 if (ACCUMULATE_OUTGOING_ARGS
)
3717 /* The argument list is the property of the called routine and it
3718 may clobber it. If the fixed area has been used for previous
3719 parameters, we must save and restore it. */
3720 save_area
= save_fixed_argument_area (reg_parm_stack_space
, argblock
,
3721 &low_to_save
, &high_to_save
);
3725 /* Push the args that need to be pushed. */
3727 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
3728 are to be pushed. */
3729 for (count
= 0; count
< nargs
; count
++, argnum
+= inc
)
3731 enum machine_mode mode
= argvec
[argnum
].mode
;
3732 rtx val
= argvec
[argnum
].value
;
3733 rtx reg
= argvec
[argnum
].reg
;
3734 int partial
= argvec
[argnum
].partial
;
3735 unsigned int parm_align
= argvec
[argnum
].locate
.boundary
;
3736 int lower_bound
= 0, upper_bound
= 0, i
;
3738 if (! (reg
!= 0 && partial
== 0))
3742 if (ACCUMULATE_OUTGOING_ARGS
)
3744 /* If this is being stored into a pre-allocated, fixed-size,
3745 stack area, save any previous data at that location. */
3747 #ifdef ARGS_GROW_DOWNWARD
3748 /* stack_slot is negative, but we want to index stack_usage_map
3749 with positive values. */
3750 upper_bound
= -argvec
[argnum
].locate
.slot_offset
.constant
+ 1;
3751 lower_bound
= upper_bound
- argvec
[argnum
].locate
.size
.constant
;
3753 lower_bound
= argvec
[argnum
].locate
.slot_offset
.constant
;
3754 upper_bound
= lower_bound
+ argvec
[argnum
].locate
.size
.constant
;
3758 /* Don't worry about things in the fixed argument area;
3759 it has already been saved. */
3760 if (i
< reg_parm_stack_space
)
3761 i
= reg_parm_stack_space
;
3762 while (i
< upper_bound
&& stack_usage_map
[i
] == 0)
3765 if (i
< upper_bound
)
3767 /* We need to make a save area. */
3769 = argvec
[argnum
].locate
.size
.constant
* BITS_PER_UNIT
;
3770 enum machine_mode save_mode
3771 = mode_for_size (size
, MODE_INT
, 1);
3773 = plus_constant (argblock
,
3774 argvec
[argnum
].locate
.offset
.constant
);
3776 = gen_rtx_MEM (save_mode
, memory_address (save_mode
, adr
));
3778 if (save_mode
== BLKmode
)
3780 argvec
[argnum
].save_area
3781 = assign_stack_temp (BLKmode
,
3782 argvec
[argnum
].locate
.size
.constant
,
3785 emit_block_move (validize_mem (argvec
[argnum
].save_area
),
3787 GEN_INT (argvec
[argnum
].locate
.size
.constant
),
3788 BLOCK_OP_CALL_PARM
);
3792 argvec
[argnum
].save_area
= gen_reg_rtx (save_mode
);
3794 emit_move_insn (argvec
[argnum
].save_area
, stack_area
);
3799 emit_push_insn (val
, mode
, NULL_TREE
, NULL_RTX
, parm_align
,
3800 partial
, reg
, 0, argblock
,
3801 GEN_INT (argvec
[argnum
].locate
.offset
.constant
),
3802 reg_parm_stack_space
,
3803 ARGS_SIZE_RTX (argvec
[argnum
].locate
.alignment_pad
));
3805 /* Now mark the segment we just used. */
3806 if (ACCUMULATE_OUTGOING_ARGS
)
3807 for (i
= lower_bound
; i
< upper_bound
; i
++)
3808 stack_usage_map
[i
] = 1;
3812 /* Indicate argument access so that alias.c knows that these
3815 use
= plus_constant (argblock
,
3816 argvec
[argnum
].locate
.offset
.constant
);
3818 /* When arguments are pushed, trying to tell alias.c where
3819 exactly this argument is won't work, because the
3820 auto-increment causes confusion. So we merely indicate
3821 that we access something with a known mode somewhere on
3823 use
= gen_rtx_PLUS (Pmode
, virtual_outgoing_args_rtx
,
3824 gen_rtx_SCRATCH (Pmode
));
3825 use
= gen_rtx_MEM (argvec
[argnum
].mode
, use
);
3826 use
= gen_rtx_USE (VOIDmode
, use
);
3827 call_fusage
= gen_rtx_EXPR_LIST (VOIDmode
, use
, call_fusage
);
3831 /* If we pushed args in forward order, perform stack alignment
3832 after pushing the last arg. */
3833 if (argblock
== 0 && !PUSH_ARGS_REVERSED
)
3834 anti_adjust_stack (GEN_INT (args_size
.constant
3835 - original_args_size
.constant
));
3837 if (PUSH_ARGS_REVERSED
)
3842 fun
= prepare_call_address (NULL
, fun
, NULL
, &call_fusage
, 0, 0);
3844 /* Now load any reg parms into their regs. */
3846 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
3847 are to be pushed. */
3848 for (count
= 0; count
< nargs
; count
++, argnum
+= inc
)
3850 enum machine_mode mode
= argvec
[argnum
].mode
;
3851 rtx val
= argvec
[argnum
].value
;
3852 rtx reg
= argvec
[argnum
].reg
;
3853 int partial
= argvec
[argnum
].partial
;
3854 #ifdef BLOCK_REG_PADDING
3858 /* Handle calls that pass values in multiple non-contiguous
3859 locations. The PA64 has examples of this for library calls. */
3860 if (reg
!= 0 && GET_CODE (reg
) == PARALLEL
)
3861 emit_group_load (reg
, val
, NULL_TREE
, GET_MODE_SIZE (mode
));
3862 else if (reg
!= 0 && partial
== 0)
3864 emit_move_insn (reg
, val
);
3865 #ifdef BLOCK_REG_PADDING
3866 size
= GET_MODE_SIZE (argvec
[argnum
].mode
);
3868 /* Copied from load_register_parameters. */
3870 /* Handle case where we have a value that needs shifting
3871 up to the msb. eg. a QImode value and we're padding
3872 upward on a BYTES_BIG_ENDIAN machine. */
3873 if (size
< UNITS_PER_WORD
3874 && (argvec
[argnum
].locate
.where_pad
3875 == (BYTES_BIG_ENDIAN
? upward
: downward
)))
3878 int shift
= (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
3880 /* Assigning REG here rather than a temp makes CALL_FUSAGE
3881 report the whole reg as used. Strictly speaking, the
3882 call only uses SIZE bytes at the msb end, but it doesn't
3883 seem worth generating rtl to say that. */
3884 reg
= gen_rtx_REG (word_mode
, REGNO (reg
));
3885 x
= expand_shift (LSHIFT_EXPR
, word_mode
, reg
, shift
, reg
, 1);
3887 emit_move_insn (reg
, x
);
3895 /* Any regs containing parms remain in use through the call. */
3896 for (count
= 0; count
< nargs
; count
++)
3898 rtx reg
= argvec
[count
].reg
;
3899 if (reg
!= 0 && GET_CODE (reg
) == PARALLEL
)
3900 use_group_regs (&call_fusage
, reg
);
3903 int partial
= argvec
[count
].partial
;
3907 gcc_assert (partial
% UNITS_PER_WORD
== 0);
3908 nregs
= partial
/ UNITS_PER_WORD
;
3909 use_regs (&call_fusage
, REGNO (reg
), nregs
);
3912 use_reg (&call_fusage
, reg
);
3916 /* Pass the function the address in which to return a structure value. */
3917 if (mem_value
!= 0 && struct_value
!= 0 && ! pcc_struct_value
)
3919 emit_move_insn (struct_value
,
3921 force_operand (XEXP (mem_value
, 0),
3923 if (REG_P (struct_value
))
3924 use_reg (&call_fusage
, struct_value
);
3927 /* Don't allow popping to be deferred, since then
3928 cse'ing of library calls could delete a call and leave the pop. */
3930 valreg
= (mem_value
== 0 && outmode
!= VOIDmode
3931 ? hard_libcall_value (outmode
, orgfun
) : NULL_RTX
);
3933 /* Stack must be properly aligned now. */
3934 gcc_assert (!(stack_pointer_delta
3935 & (PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
- 1)));
3937 before_call
= get_last_insn ();
3939 /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
3940 will set inhibit_defer_pop to that value. */
3941 /* The return type is needed to decide how many bytes the function pops.
3942 Signedness plays no role in that, so for simplicity, we pretend it's
3943 always signed. We also assume that the list of arguments passed has
3944 no impact, so we pretend it is unknown. */
3946 emit_call_1 (fun
, NULL
,
3947 get_identifier (XSTR (orgfun
, 0)),
3948 build_function_type (tfom
, NULL_TREE
),
3949 original_args_size
.constant
, args_size
.constant
,
3951 targetm
.calls
.function_arg (args_so_far
,
3952 VOIDmode
, void_type_node
, true),
3954 old_inhibit_defer_pop
+ 1, call_fusage
, flags
, args_so_far
);
3956 /* Right-shift returned value if necessary. */
3957 if (!pcc_struct_value
3958 && TYPE_MODE (tfom
) != BLKmode
3959 && targetm
.calls
.return_in_msb (tfom
))
3961 shift_return_value (TYPE_MODE (tfom
), false, valreg
);
3962 valreg
= gen_rtx_REG (TYPE_MODE (tfom
), REGNO (valreg
));
3965 /* For calls to `setjmp', etc., inform function.c:setjmp_warnings
3966 that it should complain if nonvolatile values are live. For
3967 functions that cannot return, inform flow that control does not
3970 if (flags
& ECF_NORETURN
)
3972 /* The barrier note must be emitted
3973 immediately after the CALL_INSN. Some ports emit more than
3974 just a CALL_INSN above, so we must search for it here. */
3976 rtx last
= get_last_insn ();
3977 while (!CALL_P (last
))
3979 last
= PREV_INSN (last
);
3980 /* There was no CALL_INSN? */
3981 gcc_assert (last
!= before_call
);
3984 emit_barrier_after (last
);
3987 /* Now restore inhibit_defer_pop to its actual original value. */
3992 /* Copy the value to the right place. */
3993 if (outmode
!= VOIDmode
&& retval
)
3999 if (value
!= mem_value
)
4000 emit_move_insn (value
, mem_value
);
4002 else if (GET_CODE (valreg
) == PARALLEL
)
4005 value
= gen_reg_rtx (outmode
);
4006 emit_group_store (value
, valreg
, NULL_TREE
, GET_MODE_SIZE (outmode
));
4010 /* Convert to the proper mode if a promotion has been active. */
4011 if (GET_MODE (valreg
) != outmode
)
4013 int unsignedp
= TYPE_UNSIGNED (tfom
);
4015 gcc_assert (promote_function_mode (tfom
, outmode
, &unsignedp
,
4016 fndecl
? TREE_TYPE (fndecl
) : fntype
, 1)
4017 == GET_MODE (valreg
));
4018 valreg
= convert_modes (outmode
, GET_MODE (valreg
), valreg
, 0);
4022 emit_move_insn (value
, valreg
);
4028 if (ACCUMULATE_OUTGOING_ARGS
)
4030 #ifdef REG_PARM_STACK_SPACE
4032 restore_fixed_argument_area (save_area
, argblock
,
4033 high_to_save
, low_to_save
);
4036 /* If we saved any argument areas, restore them. */
4037 for (count
= 0; count
< nargs
; count
++)
4038 if (argvec
[count
].save_area
)
4040 enum machine_mode save_mode
= GET_MODE (argvec
[count
].save_area
);
4041 rtx adr
= plus_constant (argblock
,
4042 argvec
[count
].locate
.offset
.constant
);
4043 rtx stack_area
= gen_rtx_MEM (save_mode
,
4044 memory_address (save_mode
, adr
));
4046 if (save_mode
== BLKmode
)
4047 emit_block_move (stack_area
,
4048 validize_mem (argvec
[count
].save_area
),
4049 GEN_INT (argvec
[count
].locate
.size
.constant
),
4050 BLOCK_OP_CALL_PARM
);
4052 emit_move_insn (stack_area
, argvec
[count
].save_area
);
4055 highest_outgoing_arg_in_use
= initial_highest_arg_in_use
;
4056 stack_usage_map
= initial_stack_usage_map
;
4059 free (stack_usage_map_buf
);
4065 /* Output a library call to function FUN (a SYMBOL_REF rtx)
4066 (emitting the queue unless NO_QUEUE is nonzero),
4067 for a value of mode OUTMODE,
4068 with NARGS different arguments, passed as alternating rtx values
4069 and machine_modes to convert them to.
4071 FN_TYPE should be LCT_NORMAL for `normal' calls, LCT_CONST for
4072 `const' calls, LCT_PURE for `pure' calls, or other LCT_ value for
4073 other types of library calls. */
4076 emit_library_call (rtx orgfun
, enum libcall_type fn_type
,
4077 enum machine_mode outmode
, int nargs
, ...)
4081 va_start (p
, nargs
);
4082 emit_library_call_value_1 (0, orgfun
, NULL_RTX
, fn_type
, outmode
, nargs
, p
);
4086 /* Like emit_library_call except that an extra argument, VALUE,
4087 comes second and says where to store the result.
4088 (If VALUE is zero, this function chooses a convenient way
4089 to return the value.
4091 This function returns an rtx for where the value is to be found.
4092 If VALUE is nonzero, VALUE is returned. */
4095 emit_library_call_value (rtx orgfun
, rtx value
,
4096 enum libcall_type fn_type
,
4097 enum machine_mode outmode
, int nargs
, ...)
4102 va_start (p
, nargs
);
4103 result
= emit_library_call_value_1 (1, orgfun
, value
, fn_type
, outmode
,
4110 /* Store a single argument for a function call
4111 into the register or memory area where it must be passed.
4112 *ARG describes the argument value and where to pass it.
4114 ARGBLOCK is the address of the stack-block for all the arguments,
4115 or 0 on a machine where arguments are pushed individually.
4117 MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
4118 so must be careful about how the stack is used.
4120 VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
4121 argument stack. This is used if ACCUMULATE_OUTGOING_ARGS to indicate
4122 that we need not worry about saving and restoring the stack.
4124 FNDECL is the declaration of the function we are calling.
4126 Return nonzero if this arg should cause sibcall failure,
4130 store_one_arg (struct arg_data
*arg
, rtx argblock
, int flags
,
4131 int variable_size ATTRIBUTE_UNUSED
, int reg_parm_stack_space
)
4133 tree pval
= arg
->tree_value
;
4137 int i
, lower_bound
= 0, upper_bound
= 0;
4138 int sibcall_failure
= 0;
4140 if (TREE_CODE (pval
) == ERROR_MARK
)
4143 /* Push a new temporary level for any temporaries we make for
4147 if (ACCUMULATE_OUTGOING_ARGS
&& !(flags
& ECF_SIBCALL
))
4149 /* If this is being stored into a pre-allocated, fixed-size, stack area,
4150 save any previous data at that location. */
4151 if (argblock
&& ! variable_size
&& arg
->stack
)
4153 #ifdef ARGS_GROW_DOWNWARD
4154 /* stack_slot is negative, but we want to index stack_usage_map
4155 with positive values. */
4156 if (GET_CODE (XEXP (arg
->stack_slot
, 0)) == PLUS
)
4157 upper_bound
= -INTVAL (XEXP (XEXP (arg
->stack_slot
, 0), 1)) + 1;
4161 lower_bound
= upper_bound
- arg
->locate
.size
.constant
;
4163 if (GET_CODE (XEXP (arg
->stack_slot
, 0)) == PLUS
)
4164 lower_bound
= INTVAL (XEXP (XEXP (arg
->stack_slot
, 0), 1));
4168 upper_bound
= lower_bound
+ arg
->locate
.size
.constant
;
4172 /* Don't worry about things in the fixed argument area;
4173 it has already been saved. */
4174 if (i
< reg_parm_stack_space
)
4175 i
= reg_parm_stack_space
;
4176 while (i
< upper_bound
&& stack_usage_map
[i
] == 0)
4179 if (i
< upper_bound
)
4181 /* We need to make a save area. */
4182 unsigned int size
= arg
->locate
.size
.constant
* BITS_PER_UNIT
;
4183 enum machine_mode save_mode
= mode_for_size (size
, MODE_INT
, 1);
4184 rtx adr
= memory_address (save_mode
, XEXP (arg
->stack_slot
, 0));
4185 rtx stack_area
= gen_rtx_MEM (save_mode
, adr
);
4187 if (save_mode
== BLKmode
)
4189 tree ot
= TREE_TYPE (arg
->tree_value
);
4190 tree nt
= build_qualified_type (ot
, (TYPE_QUALS (ot
)
4191 | TYPE_QUAL_CONST
));
4193 arg
->save_area
= assign_temp (nt
, 0, 1, 1);
4194 preserve_temp_slots (arg
->save_area
);
4195 emit_block_move (validize_mem (arg
->save_area
), stack_area
,
4196 GEN_INT (arg
->locate
.size
.constant
),
4197 BLOCK_OP_CALL_PARM
);
4201 arg
->save_area
= gen_reg_rtx (save_mode
);
4202 emit_move_insn (arg
->save_area
, stack_area
);
4208 /* If this isn't going to be placed on both the stack and in registers,
4209 set up the register and number of words. */
4210 if (! arg
->pass_on_stack
)
4212 if (flags
& ECF_SIBCALL
)
4213 reg
= arg
->tail_call_reg
;
4216 partial
= arg
->partial
;
4219 /* Being passed entirely in a register. We shouldn't be called in
4221 gcc_assert (reg
== 0 || partial
!= 0);
4223 /* If this arg needs special alignment, don't load the registers
4225 if (arg
->n_aligned_regs
!= 0)
4228 /* If this is being passed partially in a register, we can't evaluate
4229 it directly into its stack slot. Otherwise, we can. */
4230 if (arg
->value
== 0)
4232 /* stack_arg_under_construction is nonzero if a function argument is
4233 being evaluated directly into the outgoing argument list and
4234 expand_call must take special action to preserve the argument list
4235 if it is called recursively.
4237 For scalar function arguments stack_usage_map is sufficient to
4238 determine which stack slots must be saved and restored. Scalar
4239 arguments in general have pass_on_stack == 0.
4241 If this argument is initialized by a function which takes the
4242 address of the argument (a C++ constructor or a C function
4243 returning a BLKmode structure), then stack_usage_map is
4244 insufficient and expand_call must push the stack around the
4245 function call. Such arguments have pass_on_stack == 1.
4247 Note that it is always safe to set stack_arg_under_construction,
4248 but this generates suboptimal code if set when not needed. */
4250 if (arg
->pass_on_stack
)
4251 stack_arg_under_construction
++;
4253 arg
->value
= expand_expr (pval
,
4255 || TYPE_MODE (TREE_TYPE (pval
)) != arg
->mode
)
4256 ? NULL_RTX
: arg
->stack
,
4257 VOIDmode
, EXPAND_STACK_PARM
);
4259 /* If we are promoting object (or for any other reason) the mode
4260 doesn't agree, convert the mode. */
4262 if (arg
->mode
!= TYPE_MODE (TREE_TYPE (pval
)))
4263 arg
->value
= convert_modes (arg
->mode
, TYPE_MODE (TREE_TYPE (pval
)),
4264 arg
->value
, arg
->unsignedp
);
4266 if (arg
->pass_on_stack
)
4267 stack_arg_under_construction
--;
4270 /* Check for overlap with already clobbered argument area. */
4271 if ((flags
& ECF_SIBCALL
)
4272 && MEM_P (arg
->value
)
4273 && mem_overlaps_already_clobbered_arg_p (XEXP (arg
->value
, 0),
4274 arg
->locate
.size
.constant
))
4275 sibcall_failure
= 1;
4277 /* Don't allow anything left on stack from computation
4278 of argument to alloca. */
4279 if (flags
& ECF_MAY_BE_ALLOCA
)
4280 do_pending_stack_adjust ();
4282 if (arg
->value
== arg
->stack
)
4283 /* If the value is already in the stack slot, we are done. */
4285 else if (arg
->mode
!= BLKmode
)
4288 unsigned int parm_align
;
4290 /* Argument is a scalar, not entirely passed in registers.
4291 (If part is passed in registers, arg->partial says how much
4292 and emit_push_insn will take care of putting it there.)
4294 Push it, and if its size is less than the
4295 amount of space allocated to it,
4296 also bump stack pointer by the additional space.
4297 Note that in C the default argument promotions
4298 will prevent such mismatches. */
4300 size
= GET_MODE_SIZE (arg
->mode
);
4301 /* Compute how much space the push instruction will push.
4302 On many machines, pushing a byte will advance the stack
4303 pointer by a halfword. */
4304 #ifdef PUSH_ROUNDING
4305 size
= PUSH_ROUNDING (size
);
4309 /* Compute how much space the argument should get:
4310 round up to a multiple of the alignment for arguments. */
4311 if (none
!= FUNCTION_ARG_PADDING (arg
->mode
, TREE_TYPE (pval
)))
4312 used
= (((size
+ PARM_BOUNDARY
/ BITS_PER_UNIT
- 1)
4313 / (PARM_BOUNDARY
/ BITS_PER_UNIT
))
4314 * (PARM_BOUNDARY
/ BITS_PER_UNIT
));
4316 /* Compute the alignment of the pushed argument. */
4317 parm_align
= arg
->locate
.boundary
;
4318 if (FUNCTION_ARG_PADDING (arg
->mode
, TREE_TYPE (pval
)) == downward
)
4320 int pad
= used
- size
;
4323 unsigned int pad_align
= (pad
& -pad
) * BITS_PER_UNIT
;
4324 parm_align
= MIN (parm_align
, pad_align
);
4328 /* This isn't already where we want it on the stack, so put it there.
4329 This can either be done with push or copy insns. */
4330 emit_push_insn (arg
->value
, arg
->mode
, TREE_TYPE (pval
), NULL_RTX
,
4331 parm_align
, partial
, reg
, used
- size
, argblock
,
4332 ARGS_SIZE_RTX (arg
->locate
.offset
), reg_parm_stack_space
,
4333 ARGS_SIZE_RTX (arg
->locate
.alignment_pad
));
4335 /* Unless this is a partially-in-register argument, the argument is now
4338 arg
->value
= arg
->stack
;
4342 /* BLKmode, at least partly to be pushed. */
4344 unsigned int parm_align
;
4348 /* Pushing a nonscalar.
4349 If part is passed in registers, PARTIAL says how much
4350 and emit_push_insn will take care of putting it there. */
4352 /* Round its size up to a multiple
4353 of the allocation unit for arguments. */
4355 if (arg
->locate
.size
.var
!= 0)
4358 size_rtx
= ARGS_SIZE_RTX (arg
->locate
.size
);
4362 /* PUSH_ROUNDING has no effect on us, because emit_push_insn
4363 for BLKmode is careful to avoid it. */
4364 excess
= (arg
->locate
.size
.constant
4365 - int_size_in_bytes (TREE_TYPE (pval
))
4367 size_rtx
= expand_expr (size_in_bytes (TREE_TYPE (pval
)),
4368 NULL_RTX
, TYPE_MODE (sizetype
),
4372 parm_align
= arg
->locate
.boundary
;
4374 /* When an argument is padded down, the block is aligned to
4375 PARM_BOUNDARY, but the actual argument isn't. */
4376 if (FUNCTION_ARG_PADDING (arg
->mode
, TREE_TYPE (pval
)) == downward
)
4378 if (arg
->locate
.size
.var
)
4379 parm_align
= BITS_PER_UNIT
;
4382 unsigned int excess_align
= (excess
& -excess
) * BITS_PER_UNIT
;
4383 parm_align
= MIN (parm_align
, excess_align
);
4387 if ((flags
& ECF_SIBCALL
) && MEM_P (arg
->value
))
4389 /* emit_push_insn might not work properly if arg->value and
4390 argblock + arg->locate.offset areas overlap. */
4394 if (XEXP (x
, 0) == crtl
->args
.internal_arg_pointer
4395 || (GET_CODE (XEXP (x
, 0)) == PLUS
4396 && XEXP (XEXP (x
, 0), 0) ==
4397 crtl
->args
.internal_arg_pointer
4398 && CONST_INT_P (XEXP (XEXP (x
, 0), 1))))
4400 if (XEXP (x
, 0) != crtl
->args
.internal_arg_pointer
)
4401 i
= INTVAL (XEXP (XEXP (x
, 0), 1));
4403 /* expand_call should ensure this. */
4404 gcc_assert (!arg
->locate
.offset
.var
4405 && arg
->locate
.size
.var
== 0
4406 && CONST_INT_P (size_rtx
));
4408 if (arg
->locate
.offset
.constant
> i
)
4410 if (arg
->locate
.offset
.constant
< i
+ INTVAL (size_rtx
))
4411 sibcall_failure
= 1;
4413 else if (arg
->locate
.offset
.constant
< i
)
4415 /* Use arg->locate.size.constant instead of size_rtx
4416 because we only care about the part of the argument
4418 if (i
< (arg
->locate
.offset
.constant
4419 + arg
->locate
.size
.constant
))
4420 sibcall_failure
= 1;
4424 /* Even though they appear to be at the same location,
4425 if part of the outgoing argument is in registers,
4426 they aren't really at the same location. Check for
4427 this by making sure that the incoming size is the
4428 same as the outgoing size. */
4429 if (arg
->locate
.size
.constant
!= INTVAL (size_rtx
))
4430 sibcall_failure
= 1;
4435 emit_push_insn (arg
->value
, arg
->mode
, TREE_TYPE (pval
), size_rtx
,
4436 parm_align
, partial
, reg
, excess
, argblock
,
4437 ARGS_SIZE_RTX (arg
->locate
.offset
), reg_parm_stack_space
,
4438 ARGS_SIZE_RTX (arg
->locate
.alignment_pad
));
4440 /* Unless this is a partially-in-register argument, the argument is now
4443 ??? Unlike the case above, in which we want the actual
4444 address of the data, so that we can load it directly into a
4445 register, here we want the address of the stack slot, so that
4446 it's properly aligned for word-by-word copying or something
4447 like that. It's not clear that this is always correct. */
4449 arg
->value
= arg
->stack_slot
;
4452 if (arg
->reg
&& GET_CODE (arg
->reg
) == PARALLEL
)
4454 tree type
= TREE_TYPE (arg
->tree_value
);
4456 = emit_group_load_into_temps (arg
->reg
, arg
->value
, type
,
4457 int_size_in_bytes (type
));
4460 /* Mark all slots this store used. */
4461 if (ACCUMULATE_OUTGOING_ARGS
&& !(flags
& ECF_SIBCALL
)
4462 && argblock
&& ! variable_size
&& arg
->stack
)
4463 for (i
= lower_bound
; i
< upper_bound
; i
++)
4464 stack_usage_map
[i
] = 1;
4466 /* Once we have pushed something, pops can't safely
4467 be deferred during the rest of the arguments. */
4470 /* Free any temporary slots made in processing this argument. Show
4471 that we might have taken the address of something and pushed that
4473 preserve_temp_slots (NULL_RTX
);
4477 return sibcall_failure
;
4480 /* Nonzero if we do not know how to pass TYPE solely in registers. */
4483 must_pass_in_stack_var_size (enum machine_mode mode ATTRIBUTE_UNUSED
,
4489 /* If the type has variable size... */
4490 if (TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
4493 /* If the type is marked as addressable (it is required
4494 to be constructed into the stack)... */
4495 if (TREE_ADDRESSABLE (type
))
4501 /* Another version of the TARGET_MUST_PASS_IN_STACK hook. This one
4502 takes trailing padding of a structure into account. */
4503 /* ??? Should be able to merge these two by examining BLOCK_REG_PADDING. */
4506 must_pass_in_stack_var_size_or_pad (enum machine_mode mode
, const_tree type
)
4511 /* If the type has variable size... */
4512 if (TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
4515 /* If the type is marked as addressable (it is required
4516 to be constructed into the stack)... */
4517 if (TREE_ADDRESSABLE (type
))
4520 /* If the padding and mode of the type is such that a copy into
4521 a register would put it into the wrong part of the register. */
4523 && int_size_in_bytes (type
) % (PARM_BOUNDARY
/ BITS_PER_UNIT
)
4524 && (FUNCTION_ARG_PADDING (mode
, type
)
4525 == (BYTES_BIG_ENDIAN
? upward
: downward
)))