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 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 #include "coretypes.h"
39 #include "langhooks.h"
44 /* Like PREFERRED_STACK_BOUNDARY but in units of bytes, not bits. */
45 #define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)
47 /* Data structure and subroutines used within expand_call. */
51 /* Tree node for this argument. */
53 /* Mode for value; TYPE_MODE unless promoted. */
54 enum machine_mode mode
;
55 /* Current RTL value for argument, or 0 if it isn't precomputed. */
57 /* Initially-compute RTL value for argument; only for const functions. */
59 /* Register to pass this argument in, 0 if passed on stack, or an
60 PARALLEL if the arg is to be copied into multiple non-contiguous
63 /* Register to pass this argument in when generating tail call sequence.
64 This is not the same register as for normal calls on machines with
67 /* If REG was promoted from the actual mode of the argument expression,
68 indicates whether the promotion is sign- or zero-extended. */
70 /* Number of registers to use. 0 means put the whole arg in registers.
71 Also 0 if not passed in registers. */
73 /* Nonzero if argument must be passed on stack.
74 Note that some arguments may be passed on the stack
75 even though pass_on_stack is zero, just because FUNCTION_ARG says so.
76 pass_on_stack identifies arguments that *cannot* go in registers. */
78 /* Some fields packaged up for locate_and_pad_parm. */
79 struct locate_and_pad_arg_data locate
;
80 /* Location on the stack at which parameter should be stored. The store
81 has already been done if STACK == VALUE. */
83 /* Location on the stack of the start of this argument slot. This can
84 differ from STACK if this arg pads downward. This location is known
85 to be aligned to FUNCTION_ARG_BOUNDARY. */
87 /* Place that this stack area has been saved, if needed. */
89 /* If an argument's alignment does not permit direct copying into registers,
90 copy in smaller-sized pieces into pseudos. These are stored in a
91 block pointed to by this field. The next field says how many
92 word-sized pseudos we made. */
97 /* A vector of one char per byte of stack space. A byte if nonzero if
98 the corresponding stack location has been used.
99 This vector is used to prevent a function call within an argument from
100 clobbering any stack already set up. */
101 static char *stack_usage_map
;
103 /* Size of STACK_USAGE_MAP. */
104 static int highest_outgoing_arg_in_use
;
106 /* A bitmap of virtual-incoming stack space. Bit is set if the corresponding
107 stack location's tail call argument has been already stored into the stack.
108 This bitmap is used to prevent sibling call optimization if function tries
109 to use parent's incoming argument slots when they have been already
110 overwritten with tail call arguments. */
111 static sbitmap stored_args_map
;
113 /* stack_arg_under_construction is nonzero when an argument may be
114 initialized with a constructor call (including a C function that
115 returns a BLKmode struct) and expand_call must take special action
116 to make sure the object being constructed does not overlap the
117 argument list for the constructor call. */
118 int stack_arg_under_construction
;
120 static int calls_function (tree
, int);
121 static int calls_function_1 (tree
, int);
123 static void emit_call_1 (rtx
, tree
, tree
, HOST_WIDE_INT
, HOST_WIDE_INT
,
124 HOST_WIDE_INT
, rtx
, rtx
, int, rtx
, int,
126 static void precompute_register_parameters (int, struct arg_data
*, int *);
127 static int store_one_arg (struct arg_data
*, rtx
, int, int, int);
128 static void store_unaligned_arguments_into_pseudos (struct arg_data
*, int);
129 static int finalize_must_preallocate (int, int, struct arg_data
*,
131 static void precompute_arguments (int, int, struct arg_data
*);
132 static int compute_argument_block_size (int, struct args_size
*, int);
133 static void initialize_argument_information (int, struct arg_data
*,
134 struct args_size
*, int, tree
,
135 tree
, CUMULATIVE_ARGS
*, int,
136 rtx
*, int *, int *, int *);
137 static void compute_argument_addresses (struct arg_data
*, rtx
, int);
138 static rtx
rtx_for_function_call (tree
, tree
);
139 static void load_register_parameters (struct arg_data
*, int, rtx
*, int,
141 static rtx
emit_library_call_value_1 (int, rtx
, rtx
, enum libcall_type
,
142 enum machine_mode
, int, va_list);
143 static int special_function_p (tree
, int);
144 static rtx
try_to_integrate (tree
, tree
, rtx
, int, tree
, rtx
);
145 static int check_sibcall_argument_overlap_1 (rtx
);
146 static int check_sibcall_argument_overlap (rtx
, struct arg_data
*, int);
148 static int combine_pending_stack_adjustment_and_call (int, struct args_size
*,
150 static tree
fix_unsafe_tree (tree
);
152 #ifdef REG_PARM_STACK_SPACE
153 static rtx
save_fixed_argument_area (int, rtx
, int *, int *);
154 static void restore_fixed_argument_area (rtx
, rtx
, int, int);
157 /* If WHICH is 1, return 1 if EXP contains a call to the built-in function
160 If WHICH is 0, return 1 if EXP contains a call to any function.
161 Actually, we only need return 1 if evaluating EXP would require pushing
162 arguments on the stack, but that is too difficult to compute, so we just
163 assume any function call might require the stack. */
165 static tree calls_function_save_exprs
;
168 calls_function (tree exp
, int which
)
172 calls_function_save_exprs
= 0;
173 val
= calls_function_1 (exp
, which
);
174 calls_function_save_exprs
= 0;
178 /* Recursive function to do the work of above function. */
181 calls_function_1 (tree exp
, int which
)
184 enum tree_code code
= TREE_CODE (exp
);
185 int class = TREE_CODE_CLASS (code
);
186 int length
= first_rtl_op (code
);
188 /* If this code is language-specific, we don't know what it will do. */
189 if ((int) code
>= NUM_TREE_CODES
)
197 else if ((TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))))
199 && (TYPE_RETURNS_STACK_DEPRESSED
200 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp
, 0))))))
202 else if (TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
203 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
205 && (special_function_p (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0),
207 & ECF_MAY_BE_ALLOCA
))
216 for (tem
= CONSTRUCTOR_ELTS (exp
); tem
!= 0; tem
= TREE_CHAIN (tem
))
217 if (calls_function_1 (TREE_VALUE (tem
), which
))
224 if (SAVE_EXPR_RTL (exp
) != 0)
226 if (value_member (exp
, calls_function_save_exprs
))
228 calls_function_save_exprs
= tree_cons (NULL_TREE
, exp
,
229 calls_function_save_exprs
);
230 return (TREE_OPERAND (exp
, 0) != 0
231 && calls_function_1 (TREE_OPERAND (exp
, 0), which
));
238 for (local
= BLOCK_VARS (exp
); local
; local
= TREE_CHAIN (local
))
239 if (DECL_INITIAL (local
) != 0
240 && calls_function_1 (DECL_INITIAL (local
), which
))
243 for (subblock
= BLOCK_SUBBLOCKS (exp
);
245 subblock
= TREE_CHAIN (subblock
))
246 if (calls_function_1 (subblock
, which
))
252 for (; exp
!= 0; exp
= TREE_CHAIN (exp
))
253 if (calls_function_1 (TREE_VALUE (exp
), which
))
261 /* Only expressions and blocks can contain calls. */
262 if (! IS_EXPR_CODE_CLASS (class) && class != 'b')
265 for (i
= 0; i
< length
; i
++)
266 if (TREE_OPERAND (exp
, i
) != 0
267 && calls_function_1 (TREE_OPERAND (exp
, i
), which
))
273 /* Force FUNEXP into a form suitable for the address of a CALL,
274 and return that as an rtx. Also load the static chain register
275 if FNDECL is a nested function.
277 CALL_FUSAGE points to a variable holding the prospective
278 CALL_INSN_FUNCTION_USAGE information. */
281 prepare_call_address (rtx funexp
, tree fndecl
, rtx
*call_fusage
,
282 int reg_parm_seen
, int sibcallp
)
284 rtx static_chain_value
= 0;
286 funexp
= protect_from_queue (funexp
, 0);
289 /* Get possible static chain value for nested function in C. */
290 static_chain_value
= lookup_static_chain (fndecl
);
292 /* Make a valid memory address and copy constants thru pseudo-regs,
293 but not for a constant address if -fno-function-cse. */
294 if (GET_CODE (funexp
) != SYMBOL_REF
)
295 /* If we are using registers for parameters, force the
296 function address into a register now. */
297 funexp
= ((SMALL_REGISTER_CLASSES
&& reg_parm_seen
)
298 ? force_not_mem (memory_address (FUNCTION_MODE
, funexp
))
299 : memory_address (FUNCTION_MODE
, funexp
));
302 #ifndef NO_FUNCTION_CSE
303 if (optimize
&& ! flag_no_function_cse
)
304 #ifdef NO_RECURSIVE_FUNCTION_CSE
305 if (fndecl
!= current_function_decl
)
307 funexp
= force_reg (Pmode
, funexp
);
311 if (static_chain_value
!= 0)
313 emit_move_insn (static_chain_rtx
, static_chain_value
);
315 if (GET_CODE (static_chain_rtx
) == REG
)
316 use_reg (call_fusage
, static_chain_rtx
);
322 /* Generate instructions to call function FUNEXP,
323 and optionally pop the results.
324 The CALL_INSN is the first insn generated.
326 FNDECL is the declaration node of the function. This is given to the
327 macro RETURN_POPS_ARGS to determine whether this function pops its own args.
329 FUNTYPE is the data type of the function. This is given to the macro
330 RETURN_POPS_ARGS to determine whether this function pops its own args.
331 We used to allow an identifier for library functions, but that doesn't
332 work when the return type is an aggregate type and the calling convention
333 says that the pointer to this aggregate is to be popped by the callee.
335 STACK_SIZE is the number of bytes of arguments on the stack,
336 ROUNDED_STACK_SIZE is that number rounded up to
337 PREFERRED_STACK_BOUNDARY; zero if the size is variable. This is
338 both to put into the call insn and to generate explicit popping
341 STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
342 It is zero if this call doesn't want a structure value.
344 NEXT_ARG_REG is the rtx that results from executing
345 FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1)
346 just after all the args have had their registers assigned.
347 This could be whatever you like, but normally it is the first
348 arg-register beyond those used for args in this call,
349 or 0 if all the arg-registers are used in this call.
350 It is passed on to `gen_call' so you can put this info in the call insn.
352 VALREG is a hard register in which a value is returned,
353 or 0 if the call does not return a value.
355 OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before
356 the args to this call were processed.
357 We restore `inhibit_defer_pop' to that value.
359 CALL_FUSAGE is either empty or an EXPR_LIST of USE expressions that
360 denote registers used by the called function. */
363 emit_call_1 (rtx funexp
, tree fndecl ATTRIBUTE_UNUSED
, tree funtype ATTRIBUTE_UNUSED
,
364 HOST_WIDE_INT stack_size ATTRIBUTE_UNUSED
,
365 HOST_WIDE_INT rounded_stack_size
,
366 HOST_WIDE_INT struct_value_size ATTRIBUTE_UNUSED
,
367 rtx next_arg_reg ATTRIBUTE_UNUSED
, rtx valreg
,
368 int old_inhibit_defer_pop
, rtx call_fusage
, int ecf_flags
,
369 CUMULATIVE_ARGS
*args_so_far ATTRIBUTE_UNUSED
)
371 rtx rounded_stack_size_rtx
= GEN_INT (rounded_stack_size
);
373 int already_popped
= 0;
374 HOST_WIDE_INT n_popped
= RETURN_POPS_ARGS (fndecl
, funtype
, stack_size
);
375 #if defined (HAVE_call) && defined (HAVE_call_value)
376 rtx struct_value_size_rtx
;
377 struct_value_size_rtx
= GEN_INT (struct_value_size
);
380 #ifdef CALL_POPS_ARGS
381 n_popped
+= CALL_POPS_ARGS (* args_so_far
);
384 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
385 and we don't want to load it into a register as an optimization,
386 because prepare_call_address already did it if it should be done. */
387 if (GET_CODE (funexp
) != SYMBOL_REF
)
388 funexp
= memory_address (FUNCTION_MODE
, funexp
);
390 #if defined (HAVE_sibcall_pop) && defined (HAVE_sibcall_value_pop)
391 if ((ecf_flags
& ECF_SIBCALL
)
392 && HAVE_sibcall_pop
&& HAVE_sibcall_value_pop
393 && (n_popped
> 0 || stack_size
== 0))
395 rtx n_pop
= GEN_INT (n_popped
);
398 /* If this subroutine pops its own args, record that in the call insn
399 if possible, for the sake of frame pointer elimination. */
402 pat
= GEN_SIBCALL_VALUE_POP (valreg
,
403 gen_rtx_MEM (FUNCTION_MODE
, funexp
),
404 rounded_stack_size_rtx
, next_arg_reg
,
407 pat
= GEN_SIBCALL_POP (gen_rtx_MEM (FUNCTION_MODE
, funexp
),
408 rounded_stack_size_rtx
, next_arg_reg
, n_pop
);
410 emit_call_insn (pat
);
416 #if defined (HAVE_call_pop) && defined (HAVE_call_value_pop)
417 /* If the target has "call" or "call_value" insns, then prefer them
418 if no arguments are actually popped. If the target does not have
419 "call" or "call_value" insns, then we must use the popping versions
420 even if the call has no arguments to pop. */
421 #if defined (HAVE_call) && defined (HAVE_call_value)
422 if (HAVE_call
&& HAVE_call_value
&& HAVE_call_pop
&& HAVE_call_value_pop
423 && n_popped
> 0 && ! (ecf_flags
& ECF_SP_DEPRESSED
))
425 if (HAVE_call_pop
&& HAVE_call_value_pop
)
428 rtx n_pop
= GEN_INT (n_popped
);
431 /* If this subroutine pops its own args, record that in the call insn
432 if possible, for the sake of frame pointer elimination. */
435 pat
= GEN_CALL_VALUE_POP (valreg
,
436 gen_rtx_MEM (FUNCTION_MODE
, funexp
),
437 rounded_stack_size_rtx
, next_arg_reg
, n_pop
);
439 pat
= GEN_CALL_POP (gen_rtx_MEM (FUNCTION_MODE
, funexp
),
440 rounded_stack_size_rtx
, next_arg_reg
, n_pop
);
442 emit_call_insn (pat
);
448 #if defined (HAVE_sibcall) && defined (HAVE_sibcall_value)
449 if ((ecf_flags
& ECF_SIBCALL
)
450 && HAVE_sibcall
&& HAVE_sibcall_value
)
453 emit_call_insn (GEN_SIBCALL_VALUE (valreg
,
454 gen_rtx_MEM (FUNCTION_MODE
, funexp
),
455 rounded_stack_size_rtx
,
456 next_arg_reg
, NULL_RTX
));
458 emit_call_insn (GEN_SIBCALL (gen_rtx_MEM (FUNCTION_MODE
, funexp
),
459 rounded_stack_size_rtx
, next_arg_reg
,
460 struct_value_size_rtx
));
465 #if defined (HAVE_call) && defined (HAVE_call_value)
466 if (HAVE_call
&& HAVE_call_value
)
469 emit_call_insn (GEN_CALL_VALUE (valreg
,
470 gen_rtx_MEM (FUNCTION_MODE
, funexp
),
471 rounded_stack_size_rtx
, next_arg_reg
,
474 emit_call_insn (GEN_CALL (gen_rtx_MEM (FUNCTION_MODE
, funexp
),
475 rounded_stack_size_rtx
, next_arg_reg
,
476 struct_value_size_rtx
));
482 /* Find the call we just emitted. */
483 call_insn
= last_call_insn ();
485 /* Mark memory as used for "pure" function call. */
486 if (ecf_flags
& ECF_PURE
)
490 gen_rtx_USE (VOIDmode
,
491 gen_rtx_MEM (BLKmode
, gen_rtx_SCRATCH (VOIDmode
))),
494 /* Put the register usage information there. */
495 add_function_usage_to (call_insn
, call_fusage
);
497 /* If this is a const call, then set the insn's unchanging bit. */
498 if (ecf_flags
& (ECF_CONST
| ECF_PURE
))
499 CONST_OR_PURE_CALL_P (call_insn
) = 1;
501 /* If this call can't throw, attach a REG_EH_REGION reg note to that
503 if (ecf_flags
& ECF_NOTHROW
)
504 REG_NOTES (call_insn
) = gen_rtx_EXPR_LIST (REG_EH_REGION
, const0_rtx
,
505 REG_NOTES (call_insn
));
507 note_eh_region_may_contain_throw ();
509 if (ecf_flags
& ECF_NORETURN
)
510 REG_NOTES (call_insn
) = gen_rtx_EXPR_LIST (REG_NORETURN
, const0_rtx
,
511 REG_NOTES (call_insn
));
512 if (ecf_flags
& ECF_ALWAYS_RETURN
)
513 REG_NOTES (call_insn
) = gen_rtx_EXPR_LIST (REG_ALWAYS_RETURN
, const0_rtx
,
514 REG_NOTES (call_insn
));
516 if (ecf_flags
& ECF_RETURNS_TWICE
)
518 REG_NOTES (call_insn
) = gen_rtx_EXPR_LIST (REG_SETJMP
, const0_rtx
,
519 REG_NOTES (call_insn
));
520 current_function_calls_setjmp
= 1;
523 SIBLING_CALL_P (call_insn
) = ((ecf_flags
& ECF_SIBCALL
) != 0);
525 /* Restore this now, so that we do defer pops for this call's args
526 if the context of the call as a whole permits. */
527 inhibit_defer_pop
= old_inhibit_defer_pop
;
532 CALL_INSN_FUNCTION_USAGE (call_insn
)
533 = gen_rtx_EXPR_LIST (VOIDmode
,
534 gen_rtx_CLOBBER (VOIDmode
, stack_pointer_rtx
),
535 CALL_INSN_FUNCTION_USAGE (call_insn
));
536 rounded_stack_size
-= n_popped
;
537 rounded_stack_size_rtx
= GEN_INT (rounded_stack_size
);
538 stack_pointer_delta
-= n_popped
;
541 if (!ACCUMULATE_OUTGOING_ARGS
)
543 /* If returning from the subroutine does not automatically pop the args,
544 we need an instruction to pop them sooner or later.
545 Perhaps do it now; perhaps just record how much space to pop later.
547 If returning from the subroutine does pop the args, indicate that the
548 stack pointer will be changed. */
550 if (rounded_stack_size
!= 0)
552 if (ecf_flags
& (ECF_SP_DEPRESSED
| ECF_NORETURN
| ECF_LONGJMP
))
553 /* Just pretend we did the pop. */
554 stack_pointer_delta
-= rounded_stack_size
;
555 else if (flag_defer_pop
&& inhibit_defer_pop
== 0
556 && ! (ecf_flags
& (ECF_CONST
| ECF_PURE
)))
557 pending_stack_adjust
+= rounded_stack_size
;
559 adjust_stack (rounded_stack_size_rtx
);
562 /* When we accumulate outgoing args, we must avoid any stack manipulations.
563 Restore the stack pointer to its original value now. Usually
564 ACCUMULATE_OUTGOING_ARGS targets don't get here, but there are exceptions.
565 On i386 ACCUMULATE_OUTGOING_ARGS can be enabled on demand, and
566 popping variants of functions exist as well.
568 ??? We may optimize similar to defer_pop above, but it is
569 probably not worthwhile.
571 ??? It will be worthwhile to enable combine_stack_adjustments even for
574 anti_adjust_stack (GEN_INT (n_popped
));
577 /* Determine if the function identified by NAME and FNDECL is one with
578 special properties we wish to know about.
580 For example, if the function might return more than one time (setjmp), then
581 set RETURNS_TWICE to a nonzero value.
583 Similarly set LONGJMP for if the function is in the longjmp family.
585 Set MAY_BE_ALLOCA for any memory allocation function that might allocate
586 space from the stack such as alloca. */
589 special_function_p (tree fndecl
, int flags
)
591 if (! (flags
& ECF_MALLOC
)
592 && fndecl
&& DECL_NAME (fndecl
)
593 && IDENTIFIER_LENGTH (DECL_NAME (fndecl
)) <= 17
594 /* Exclude functions not at the file scope, or not `extern',
595 since they are not the magic functions we would otherwise
597 FIXME: this should be handled with attributes, not with this
598 hacky imitation of DECL_ASSEMBLER_NAME. It's (also) wrong
599 because you can declare fork() inside a function if you
601 && (DECL_CONTEXT (fndecl
) == NULL_TREE
602 || TREE_CODE (DECL_CONTEXT (fndecl
)) == TRANSLATION_UNIT_DECL
)
603 && TREE_PUBLIC (fndecl
))
605 const char *name
= IDENTIFIER_POINTER (DECL_NAME (fndecl
));
606 const char *tname
= name
;
608 /* We assume that alloca will always be called by name. It
609 makes no sense to pass it as a pointer-to-function to
610 anything that does not understand its behavior. */
611 if (((IDENTIFIER_LENGTH (DECL_NAME (fndecl
)) == 6
613 && ! strcmp (name
, "alloca"))
614 || (IDENTIFIER_LENGTH (DECL_NAME (fndecl
)) == 16
616 && ! strcmp (name
, "__builtin_alloca"))))
617 flags
|= ECF_MAY_BE_ALLOCA
;
619 /* Disregard prefix _, __ or __x. */
622 if (name
[1] == '_' && name
[2] == 'x')
624 else if (name
[1] == '_')
633 && (! strcmp (tname
, "setjmp")
634 || ! strcmp (tname
, "setjmp_syscall")))
636 && ! strcmp (tname
, "sigsetjmp"))
638 && ! strcmp (tname
, "savectx")))
639 flags
|= ECF_RETURNS_TWICE
;
642 && ! strcmp (tname
, "siglongjmp"))
643 flags
|= ECF_LONGJMP
;
645 else if ((tname
[0] == 'q' && tname
[1] == 's'
646 && ! strcmp (tname
, "qsetjmp"))
647 || (tname
[0] == 'v' && tname
[1] == 'f'
648 && ! strcmp (tname
, "vfork")))
649 flags
|= ECF_RETURNS_TWICE
;
651 else if (tname
[0] == 'l' && tname
[1] == 'o'
652 && ! strcmp (tname
, "longjmp"))
653 flags
|= ECF_LONGJMP
;
655 else if ((tname
[0] == 'f' && tname
[1] == 'o'
656 && ! strcmp (tname
, "fork"))
657 /* Linux specific: __clone. check NAME to insist on the
658 leading underscores, to avoid polluting the ISO / POSIX
660 || (name
[0] == '_' && name
[1] == '_'
661 && ! strcmp (tname
, "clone"))
662 || (tname
[0] == 'e' && tname
[1] == 'x' && tname
[2] == 'e'
663 && tname
[3] == 'c' && (tname
[4] == 'l' || tname
[4] == 'v')
665 || ((tname
[5] == 'p' || tname
[5] == 'e')
666 && tname
[6] == '\0'))))
667 flags
|= ECF_FORK_OR_EXEC
;
672 /* Return nonzero when tree represent call to longjmp. */
675 setjmp_call_p (tree fndecl
)
677 return special_function_p (fndecl
, 0) & ECF_RETURNS_TWICE
;
680 /* Return true when exp contains alloca call. */
682 alloca_call_p (tree exp
)
684 if (TREE_CODE (exp
) == CALL_EXPR
685 && TREE_CODE (TREE_OPERAND (exp
, 0)) == ADDR_EXPR
686 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0))
688 && (special_function_p (TREE_OPERAND (TREE_OPERAND (exp
, 0), 0),
689 0) & ECF_MAY_BE_ALLOCA
))
694 /* Detect flags (function attributes) from the function decl or type node. */
697 flags_from_decl_or_type (tree exp
)
704 struct cgraph_rtl_info
*i
= cgraph_rtl_info (exp
);
705 type
= TREE_TYPE (exp
);
709 if (i
->pure_function
)
710 flags
|= ECF_PURE
| ECF_LIBCALL_BLOCK
;
711 if (i
->const_function
)
712 flags
|= ECF_CONST
| ECF_LIBCALL_BLOCK
;
715 /* The function exp may have the `malloc' attribute. */
716 if (DECL_IS_MALLOC (exp
))
719 /* The function exp may have the `pure' attribute. */
720 if (DECL_IS_PURE (exp
))
721 flags
|= ECF_PURE
| ECF_LIBCALL_BLOCK
;
723 if (TREE_NOTHROW (exp
))
724 flags
|= ECF_NOTHROW
;
726 if (TREE_READONLY (exp
) && ! TREE_THIS_VOLATILE (exp
))
727 flags
|= ECF_LIBCALL_BLOCK
;
730 if (TREE_READONLY (exp
) && ! TREE_THIS_VOLATILE (exp
))
733 if (TREE_THIS_VOLATILE (exp
))
734 flags
|= ECF_NORETURN
;
736 /* Mark if the function returns with the stack pointer depressed. We
737 cannot consider it pure or constant in that case. */
738 if (TREE_CODE (type
) == FUNCTION_TYPE
&& TYPE_RETURNS_STACK_DEPRESSED (type
))
740 flags
|= ECF_SP_DEPRESSED
;
741 flags
&= ~(ECF_PURE
| ECF_CONST
| ECF_LIBCALL_BLOCK
);
747 /* Precompute all register parameters as described by ARGS, storing values
748 into fields within the ARGS array.
750 NUM_ACTUALS indicates the total number elements in the ARGS array.
752 Set REG_PARM_SEEN if we encounter a register parameter. */
755 precompute_register_parameters (int num_actuals
, struct arg_data
*args
, int *reg_parm_seen
)
761 for (i
= 0; i
< num_actuals
; i
++)
762 if (args
[i
].reg
!= 0 && ! args
[i
].pass_on_stack
)
766 if (args
[i
].value
== 0)
769 args
[i
].value
= expand_expr (args
[i
].tree_value
, NULL_RTX
,
771 preserve_temp_slots (args
[i
].value
);
774 /* ANSI doesn't require a sequence point here,
775 but PCC has one, so this will avoid some problems. */
779 /* If the value is a non-legitimate constant, force it into a
780 pseudo now. TLS symbols sometimes need a call to resolve. */
781 if (CONSTANT_P (args
[i
].value
)
782 && !LEGITIMATE_CONSTANT_P (args
[i
].value
))
783 args
[i
].value
= force_reg (args
[i
].mode
, args
[i
].value
);
785 /* If we are to promote the function arg to a wider mode,
788 if (args
[i
].mode
!= TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)))
790 = convert_modes (args
[i
].mode
,
791 TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)),
792 args
[i
].value
, args
[i
].unsignedp
);
794 /* If the value is expensive, and we are inside an appropriately
795 short loop, put the value into a pseudo and then put the pseudo
798 For small register classes, also do this if this call uses
799 register parameters. This is to avoid reload conflicts while
800 loading the parameters registers. */
802 if ((! (GET_CODE (args
[i
].value
) == REG
803 || (GET_CODE (args
[i
].value
) == SUBREG
804 && GET_CODE (SUBREG_REG (args
[i
].value
)) == REG
)))
805 && args
[i
].mode
!= BLKmode
806 && rtx_cost (args
[i
].value
, SET
) > COSTS_N_INSNS (1)
807 && ((SMALL_REGISTER_CLASSES
&& *reg_parm_seen
)
808 || preserve_subexpressions_p ()))
809 args
[i
].value
= copy_to_mode_reg (args
[i
].mode
, args
[i
].value
);
813 #ifdef REG_PARM_STACK_SPACE
815 /* The argument list is the property of the called routine and it
816 may clobber it. If the fixed area has been used for previous
817 parameters, we must save and restore it. */
820 save_fixed_argument_area (int reg_parm_stack_space
, rtx argblock
, int *low_to_save
, int *high_to_save
)
825 /* Compute the boundary of the area that needs to be saved, if any. */
826 high
= reg_parm_stack_space
;
827 #ifdef ARGS_GROW_DOWNWARD
830 if (high
> highest_outgoing_arg_in_use
)
831 high
= highest_outgoing_arg_in_use
;
833 for (low
= 0; low
< high
; low
++)
834 if (stack_usage_map
[low
] != 0)
837 enum machine_mode save_mode
;
842 while (stack_usage_map
[--high
] == 0)
846 *high_to_save
= high
;
848 num_to_save
= high
- low
+ 1;
849 save_mode
= mode_for_size (num_to_save
* BITS_PER_UNIT
, MODE_INT
, 1);
851 /* If we don't have the required alignment, must do this
853 if ((low
& (MIN (GET_MODE_SIZE (save_mode
),
854 BIGGEST_ALIGNMENT
/ UNITS_PER_WORD
) - 1)))
857 #ifdef ARGS_GROW_DOWNWARD
862 stack_area
= gen_rtx_MEM (save_mode
,
863 memory_address (save_mode
,
864 plus_constant (argblock
,
867 set_mem_align (stack_area
, PARM_BOUNDARY
);
868 if (save_mode
== BLKmode
)
870 save_area
= assign_stack_temp (BLKmode
, num_to_save
, 0);
871 emit_block_move (validize_mem (save_area
), stack_area
,
872 GEN_INT (num_to_save
), BLOCK_OP_CALL_PARM
);
876 save_area
= gen_reg_rtx (save_mode
);
877 emit_move_insn (save_area
, stack_area
);
887 restore_fixed_argument_area (rtx save_area
, rtx argblock
, int high_to_save
, int low_to_save
)
889 enum machine_mode save_mode
= GET_MODE (save_area
);
893 #ifdef ARGS_GROW_DOWNWARD
894 delta
= -high_to_save
;
898 stack_area
= gen_rtx_MEM (save_mode
,
899 memory_address (save_mode
,
900 plus_constant (argblock
, delta
)));
901 set_mem_align (stack_area
, PARM_BOUNDARY
);
903 if (save_mode
!= BLKmode
)
904 emit_move_insn (stack_area
, save_area
);
906 emit_block_move (stack_area
, validize_mem (save_area
),
907 GEN_INT (high_to_save
- low_to_save
+ 1),
910 #endif /* REG_PARM_STACK_SPACE */
912 /* If any elements in ARGS refer to parameters that are to be passed in
913 registers, but not in memory, and whose alignment does not permit a
914 direct copy into registers. Copy the values into a group of pseudos
915 which we will later copy into the appropriate hard registers.
917 Pseudos for each unaligned argument will be stored into the array
918 args[argnum].aligned_regs. The caller is responsible for deallocating
919 the aligned_regs array if it is nonzero. */
922 store_unaligned_arguments_into_pseudos (struct arg_data
*args
, int num_actuals
)
926 for (i
= 0; i
< num_actuals
; i
++)
927 if (args
[i
].reg
!= 0 && ! args
[i
].pass_on_stack
928 && args
[i
].mode
== BLKmode
929 && (TYPE_ALIGN (TREE_TYPE (args
[i
].tree_value
))
930 < (unsigned int) MIN (BIGGEST_ALIGNMENT
, BITS_PER_WORD
)))
932 int bytes
= int_size_in_bytes (TREE_TYPE (args
[i
].tree_value
));
933 int nregs
= (bytes
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
934 int endian_correction
= 0;
936 args
[i
].n_aligned_regs
= args
[i
].partial
? args
[i
].partial
: nregs
;
937 args
[i
].aligned_regs
= xmalloc (sizeof (rtx
) * args
[i
].n_aligned_regs
);
939 /* Structures smaller than a word are normally aligned to the
940 least significant byte. On a BYTES_BIG_ENDIAN machine,
941 this means we must skip the empty high order bytes when
942 calculating the bit offset. */
943 if (bytes
< UNITS_PER_WORD
944 #ifdef BLOCK_REG_PADDING
945 && (BLOCK_REG_PADDING (args
[i
].mode
,
946 TREE_TYPE (args
[i
].tree_value
), 1)
952 endian_correction
= BITS_PER_WORD
- bytes
* BITS_PER_UNIT
;
954 for (j
= 0; j
< args
[i
].n_aligned_regs
; j
++)
956 rtx reg
= gen_reg_rtx (word_mode
);
957 rtx word
= operand_subword_force (args
[i
].value
, j
, BLKmode
);
958 int bitsize
= MIN (bytes
* BITS_PER_UNIT
, BITS_PER_WORD
);
960 args
[i
].aligned_regs
[j
] = reg
;
961 word
= extract_bit_field (word
, bitsize
, 0, 1, NULL_RTX
,
962 word_mode
, word_mode
, BITS_PER_WORD
);
964 /* There is no need to restrict this code to loading items
965 in TYPE_ALIGN sized hunks. The bitfield instructions can
966 load up entire word sized registers efficiently.
968 ??? This may not be needed anymore.
969 We use to emit a clobber here but that doesn't let later
970 passes optimize the instructions we emit. By storing 0 into
971 the register later passes know the first AND to zero out the
972 bitfield being set in the register is unnecessary. The store
973 of 0 will be deleted as will at least the first AND. */
975 emit_move_insn (reg
, const0_rtx
);
977 bytes
-= bitsize
/ BITS_PER_UNIT
;
978 store_bit_field (reg
, bitsize
, endian_correction
, word_mode
,
979 word
, BITS_PER_WORD
);
984 /* Fill in ARGS_SIZE and ARGS array based on the parameters found in
987 NUM_ACTUALS is the total number of parameters.
989 N_NAMED_ARGS is the total number of named arguments.
991 FNDECL is the tree code for the target of this call (if known)
993 ARGS_SO_FAR holds state needed by the target to know where to place
996 REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
997 for arguments which are passed in registers.
999 OLD_STACK_LEVEL is a pointer to an rtx which olds the old stack level
1000 and may be modified by this routine.
1002 OLD_PENDING_ADJ, MUST_PREALLOCATE and FLAGS are pointers to integer
1003 flags which may may be modified by this routine. */
1006 initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED
,
1007 struct arg_data
*args
,
1008 struct args_size
*args_size
,
1009 int n_named_args ATTRIBUTE_UNUSED
,
1010 tree actparms
, tree fndecl
,
1011 CUMULATIVE_ARGS
*args_so_far
,
1012 int reg_parm_stack_space
,
1013 rtx
*old_stack_level
, int *old_pending_adj
,
1014 int *must_preallocate
, int *ecf_flags
)
1016 /* 1 if scanning parms front to back, -1 if scanning back to front. */
1019 /* Count arg position in order args appear. */
1025 args_size
->constant
= 0;
1028 /* In this loop, we consider args in the order they are written.
1029 We fill up ARGS from the front or from the back if necessary
1030 so that in any case the first arg to be pushed ends up at the front. */
1032 if (PUSH_ARGS_REVERSED
)
1034 i
= num_actuals
- 1, inc
= -1;
1035 /* In this case, must reverse order of args
1036 so that we compute and push the last arg first. */
1043 /* I counts args in order (to be) pushed; ARGPOS counts in order written. */
1044 for (p
= actparms
, argpos
= 0; p
; p
= TREE_CHAIN (p
), i
+= inc
, argpos
++)
1046 tree type
= TREE_TYPE (TREE_VALUE (p
));
1048 enum machine_mode mode
;
1050 args
[i
].tree_value
= TREE_VALUE (p
);
1052 /* Replace erroneous argument with constant zero. */
1053 if (type
== error_mark_node
|| !COMPLETE_TYPE_P (type
))
1054 args
[i
].tree_value
= integer_zero_node
, type
= integer_type_node
;
1056 /* If TYPE is a transparent union, pass things the way we would
1057 pass the first field of the union. We have already verified that
1058 the modes are the same. */
1059 if (TREE_CODE (type
) == UNION_TYPE
&& TYPE_TRANSPARENT_UNION (type
))
1060 type
= TREE_TYPE (TYPE_FIELDS (type
));
1062 /* Decide where to pass this arg.
1064 args[i].reg is nonzero if all or part is passed in registers.
1066 args[i].partial is nonzero if part but not all is passed in registers,
1067 and the exact value says how many words are passed in registers.
1069 args[i].pass_on_stack is nonzero if the argument must at least be
1070 computed on the stack. It may then be loaded back into registers
1071 if args[i].reg is nonzero.
1073 These decisions are driven by the FUNCTION_... macros and must agree
1074 with those made by function.c. */
1076 /* See if this argument should be passed by invisible reference. */
1077 if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type
))
1078 || TREE_ADDRESSABLE (type
)
1079 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
1080 || FUNCTION_ARG_PASS_BY_REFERENCE (*args_so_far
, TYPE_MODE (type
),
1081 type
, argpos
< n_named_args
)
1085 /* If we're compiling a thunk, pass through invisible
1086 references instead of making a copy. */
1087 if (current_function_is_thunk
1088 #ifdef FUNCTION_ARG_CALLEE_COPIES
1089 || (FUNCTION_ARG_CALLEE_COPIES (*args_so_far
, TYPE_MODE (type
),
1090 type
, argpos
< n_named_args
)
1091 /* If it's in a register, we must make a copy of it too. */
1092 /* ??? Is this a sufficient test? Is there a better one? */
1093 && !(TREE_CODE (args
[i
].tree_value
) == VAR_DECL
1094 && REG_P (DECL_RTL (args
[i
].tree_value
)))
1095 && ! TREE_ADDRESSABLE (type
))
1099 /* C++ uses a TARGET_EXPR to indicate that we want to make a
1100 new object from the argument. If we are passing by
1101 invisible reference, the callee will do that for us, so we
1102 can strip off the TARGET_EXPR. This is not always safe,
1103 but it is safe in the only case where this is a useful
1104 optimization; namely, when the argument is a plain object.
1105 In that case, the frontend is just asking the backend to
1106 make a bitwise copy of the argument. */
1108 if (TREE_CODE (args
[i
].tree_value
) == TARGET_EXPR
1109 && (DECL_P (TREE_OPERAND (args
[i
].tree_value
, 1)))
1110 && ! REG_P (DECL_RTL (TREE_OPERAND (args
[i
].tree_value
, 1))))
1111 args
[i
].tree_value
= TREE_OPERAND (args
[i
].tree_value
, 1);
1113 args
[i
].tree_value
= build1 (ADDR_EXPR
,
1114 build_pointer_type (type
),
1115 args
[i
].tree_value
);
1116 type
= build_pointer_type (type
);
1118 else if (TREE_CODE (args
[i
].tree_value
) == TARGET_EXPR
)
1120 /* In the V3 C++ ABI, parameters are destroyed in the caller.
1121 We implement this by passing the address of the temporary
1122 rather than expanding it into another allocated slot. */
1123 args
[i
].tree_value
= build1 (ADDR_EXPR
,
1124 build_pointer_type (type
),
1125 args
[i
].tree_value
);
1126 type
= build_pointer_type (type
);
1130 /* We make a copy of the object and pass the address to the
1131 function being called. */
1134 if (!COMPLETE_TYPE_P (type
)
1135 || TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
1136 || (flag_stack_check
&& ! STACK_CHECK_BUILTIN
1137 && (0 < compare_tree_int (TYPE_SIZE_UNIT (type
),
1138 STACK_CHECK_MAX_VAR_SIZE
))))
1140 /* This is a variable-sized object. Make space on the stack
1142 rtx size_rtx
= expr_size (TREE_VALUE (p
));
1144 if (*old_stack_level
== 0)
1146 emit_stack_save (SAVE_BLOCK
, old_stack_level
, NULL_RTX
);
1147 *old_pending_adj
= pending_stack_adjust
;
1148 pending_stack_adjust
= 0;
1151 copy
= gen_rtx_MEM (BLKmode
,
1152 allocate_dynamic_stack_space
1153 (size_rtx
, NULL_RTX
, TYPE_ALIGN (type
)));
1154 set_mem_attributes (copy
, type
, 1);
1157 copy
= assign_temp (type
, 0, 1, 0);
1159 store_expr (args
[i
].tree_value
, copy
, 0);
1160 *ecf_flags
&= ~(ECF_CONST
| ECF_PURE
| ECF_LIBCALL_BLOCK
);
1162 args
[i
].tree_value
= build1 (ADDR_EXPR
,
1163 build_pointer_type (type
),
1164 make_tree (type
, copy
));
1165 type
= build_pointer_type (type
);
1169 mode
= TYPE_MODE (type
);
1170 unsignedp
= TREE_UNSIGNED (type
);
1172 if (targetm
.calls
.promote_function_args (fndecl
? TREE_TYPE (fndecl
) : 0))
1173 mode
= promote_mode (type
, mode
, &unsignedp
, 1);
1175 args
[i
].unsignedp
= unsignedp
;
1176 args
[i
].mode
= mode
;
1178 args
[i
].reg
= FUNCTION_ARG (*args_so_far
, mode
, type
,
1179 argpos
< n_named_args
);
1180 #ifdef FUNCTION_INCOMING_ARG
1181 /* If this is a sibling call and the machine has register windows, the
1182 register window has to be unwinded before calling the routine, so
1183 arguments have to go into the incoming registers. */
1184 args
[i
].tail_call_reg
= FUNCTION_INCOMING_ARG (*args_so_far
, mode
, type
,
1185 argpos
< n_named_args
);
1187 args
[i
].tail_call_reg
= args
[i
].reg
;
1190 #ifdef FUNCTION_ARG_PARTIAL_NREGS
1193 = FUNCTION_ARG_PARTIAL_NREGS (*args_so_far
, mode
, type
,
1194 argpos
< n_named_args
);
1197 args
[i
].pass_on_stack
= MUST_PASS_IN_STACK (mode
, type
);
1199 /* If FUNCTION_ARG returned a (parallel [(expr_list (nil) ...) ...]),
1200 it means that we are to pass this arg in the register(s) designated
1201 by the PARALLEL, but also to pass it in the stack. */
1202 if (args
[i
].reg
&& GET_CODE (args
[i
].reg
) == PARALLEL
1203 && XEXP (XVECEXP (args
[i
].reg
, 0, 0), 0) == 0)
1204 args
[i
].pass_on_stack
= 1;
1206 /* If this is an addressable type, we must preallocate the stack
1207 since we must evaluate the object into its final location.
1209 If this is to be passed in both registers and the stack, it is simpler
1211 if (TREE_ADDRESSABLE (type
)
1212 || (args
[i
].pass_on_stack
&& args
[i
].reg
!= 0))
1213 *must_preallocate
= 1;
1215 /* If this is an addressable type, we cannot pre-evaluate it. Thus,
1216 we cannot consider this function call constant. */
1217 if (TREE_ADDRESSABLE (type
))
1218 *ecf_flags
&= ~ECF_LIBCALL_BLOCK
;
1220 /* Compute the stack-size of this argument. */
1221 if (args
[i
].reg
== 0 || args
[i
].partial
!= 0
1222 || reg_parm_stack_space
> 0
1223 || args
[i
].pass_on_stack
)
1224 locate_and_pad_parm (mode
, type
,
1225 #ifdef STACK_PARMS_IN_REG_PARM_AREA
1230 args
[i
].pass_on_stack
? 0 : args
[i
].partial
,
1231 fndecl
, args_size
, &args
[i
].locate
);
1232 #ifdef BLOCK_REG_PADDING
1234 /* The argument is passed entirely in registers. See at which
1235 end it should be padded. */
1236 args
[i
].locate
.where_pad
=
1237 BLOCK_REG_PADDING (mode
, type
,
1238 int_size_in_bytes (type
) <= UNITS_PER_WORD
);
1241 /* Update ARGS_SIZE, the total stack space for args so far. */
1243 args_size
->constant
+= args
[i
].locate
.size
.constant
;
1244 if (args
[i
].locate
.size
.var
)
1245 ADD_PARM_SIZE (*args_size
, args
[i
].locate
.size
.var
);
1247 /* Increment ARGS_SO_FAR, which has info about which arg-registers
1248 have been used, etc. */
1250 FUNCTION_ARG_ADVANCE (*args_so_far
, TYPE_MODE (type
), type
,
1251 argpos
< n_named_args
);
1255 /* Update ARGS_SIZE to contain the total size for the argument block.
1256 Return the original constant component of the argument block's size.
1258 REG_PARM_STACK_SPACE holds the number of bytes of stack space reserved
1259 for arguments passed in registers. */
1262 compute_argument_block_size (int reg_parm_stack_space
,
1263 struct args_size
*args_size
,
1264 int preferred_stack_boundary ATTRIBUTE_UNUSED
)
1266 int unadjusted_args_size
= args_size
->constant
;
1268 /* For accumulate outgoing args mode we don't need to align, since the frame
1269 will be already aligned. Align to STACK_BOUNDARY in order to prevent
1270 backends from generating misaligned frame sizes. */
1271 if (ACCUMULATE_OUTGOING_ARGS
&& preferred_stack_boundary
> STACK_BOUNDARY
)
1272 preferred_stack_boundary
= STACK_BOUNDARY
;
1274 /* Compute the actual size of the argument block required. The variable
1275 and constant sizes must be combined, the size may have to be rounded,
1276 and there may be a minimum required size. */
1280 args_size
->var
= ARGS_SIZE_TREE (*args_size
);
1281 args_size
->constant
= 0;
1283 preferred_stack_boundary
/= BITS_PER_UNIT
;
1284 if (preferred_stack_boundary
> 1)
1286 /* We don't handle this case yet. To handle it correctly we have
1287 to add the delta, round and subtract the delta.
1288 Currently no machine description requires this support. */
1289 if (stack_pointer_delta
& (preferred_stack_boundary
- 1))
1291 args_size
->var
= round_up (args_size
->var
, preferred_stack_boundary
);
1294 if (reg_parm_stack_space
> 0)
1297 = size_binop (MAX_EXPR
, args_size
->var
,
1298 ssize_int (reg_parm_stack_space
));
1300 #ifndef OUTGOING_REG_PARM_STACK_SPACE
1301 /* The area corresponding to register parameters is not to count in
1302 the size of the block we need. So make the adjustment. */
1304 = size_binop (MINUS_EXPR
, args_size
->var
,
1305 ssize_int (reg_parm_stack_space
));
1311 preferred_stack_boundary
/= BITS_PER_UNIT
;
1312 if (preferred_stack_boundary
< 1)
1313 preferred_stack_boundary
= 1;
1314 args_size
->constant
= (((args_size
->constant
1315 + stack_pointer_delta
1316 + preferred_stack_boundary
- 1)
1317 / preferred_stack_boundary
1318 * preferred_stack_boundary
)
1319 - stack_pointer_delta
);
1321 args_size
->constant
= MAX (args_size
->constant
,
1322 reg_parm_stack_space
);
1324 #ifdef MAYBE_REG_PARM_STACK_SPACE
1325 if (reg_parm_stack_space
== 0)
1326 args_size
->constant
= 0;
1329 #ifndef OUTGOING_REG_PARM_STACK_SPACE
1330 args_size
->constant
-= reg_parm_stack_space
;
1333 return unadjusted_args_size
;
1336 /* Precompute parameters as needed for a function call.
1338 FLAGS is mask of ECF_* constants.
1340 NUM_ACTUALS is the number of arguments.
1342 ARGS is an array containing information for each argument; this
1343 routine fills in the INITIAL_VALUE and VALUE fields for each
1344 precomputed argument. */
1347 precompute_arguments (int flags
, int num_actuals
, struct arg_data
*args
)
1351 /* If this function call is cse'able, precompute all the parameters.
1352 Note that if the parameter is constructed into a temporary, this will
1353 cause an additional copy because the parameter will be constructed
1354 into a temporary location and then copied into the outgoing arguments.
1355 If a parameter contains a call to alloca and this function uses the
1356 stack, precompute the parameter. */
1358 /* If we preallocated the stack space, and some arguments must be passed
1359 on the stack, then we must precompute any parameter which contains a
1360 function call which will store arguments on the stack.
1361 Otherwise, evaluating the parameter may clobber previous parameters
1362 which have already been stored into the stack. (we have code to avoid
1363 such case by saving the outgoing stack arguments, but it results in
1366 for (i
= 0; i
< num_actuals
; i
++)
1367 if ((flags
& ECF_LIBCALL_BLOCK
)
1368 || calls_function (args
[i
].tree_value
, !ACCUMULATE_OUTGOING_ARGS
))
1370 enum machine_mode mode
;
1372 /* If this is an addressable type, we cannot pre-evaluate it. */
1373 if (TREE_ADDRESSABLE (TREE_TYPE (args
[i
].tree_value
)))
1377 = expand_expr (args
[i
].tree_value
, NULL_RTX
, VOIDmode
, 0);
1379 /* ANSI doesn't require a sequence point here,
1380 but PCC has one, so this will avoid some problems. */
1383 args
[i
].initial_value
= args
[i
].value
1384 = protect_from_queue (args
[i
].value
, 0);
1386 mode
= TYPE_MODE (TREE_TYPE (args
[i
].tree_value
));
1387 if (mode
!= args
[i
].mode
)
1390 = convert_modes (args
[i
].mode
, mode
,
1391 args
[i
].value
, args
[i
].unsignedp
);
1392 #ifdef PROMOTE_FOR_CALL_ONLY
1393 /* CSE will replace this only if it contains args[i].value
1394 pseudo, so convert it down to the declared mode using
1396 if (GET_CODE (args
[i
].value
) == REG
1397 && GET_MODE_CLASS (args
[i
].mode
) == MODE_INT
)
1399 args
[i
].initial_value
1400 = gen_lowpart_SUBREG (mode
, args
[i
].value
);
1401 SUBREG_PROMOTED_VAR_P (args
[i
].initial_value
) = 1;
1402 SUBREG_PROMOTED_UNSIGNED_SET (args
[i
].initial_value
,
1410 /* Given the current state of MUST_PREALLOCATE and information about
1411 arguments to a function call in NUM_ACTUALS, ARGS and ARGS_SIZE,
1412 compute and return the final value for MUST_PREALLOCATE. */
1415 finalize_must_preallocate (int must_preallocate
, int num_actuals
, struct arg_data
*args
, struct args_size
*args_size
)
1417 /* See if we have or want to preallocate stack space.
1419 If we would have to push a partially-in-regs parm
1420 before other stack parms, preallocate stack space instead.
1422 If the size of some parm is not a multiple of the required stack
1423 alignment, we must preallocate.
1425 If the total size of arguments that would otherwise create a copy in
1426 a temporary (such as a CALL) is more than half the total argument list
1427 size, preallocation is faster.
1429 Another reason to preallocate is if we have a machine (like the m88k)
1430 where stack alignment is required to be maintained between every
1431 pair of insns, not just when the call is made. However, we assume here
1432 that such machines either do not have push insns (and hence preallocation
1433 would occur anyway) or the problem is taken care of with
1436 if (! must_preallocate
)
1438 int partial_seen
= 0;
1439 int copy_to_evaluate_size
= 0;
1442 for (i
= 0; i
< num_actuals
&& ! must_preallocate
; i
++)
1444 if (args
[i
].partial
> 0 && ! args
[i
].pass_on_stack
)
1446 else if (partial_seen
&& args
[i
].reg
== 0)
1447 must_preallocate
= 1;
1449 if (TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)) == BLKmode
1450 && (TREE_CODE (args
[i
].tree_value
) == CALL_EXPR
1451 || TREE_CODE (args
[i
].tree_value
) == TARGET_EXPR
1452 || TREE_CODE (args
[i
].tree_value
) == COND_EXPR
1453 || TREE_ADDRESSABLE (TREE_TYPE (args
[i
].tree_value
))))
1454 copy_to_evaluate_size
1455 += int_size_in_bytes (TREE_TYPE (args
[i
].tree_value
));
1458 if (copy_to_evaluate_size
* 2 >= args_size
->constant
1459 && args_size
->constant
> 0)
1460 must_preallocate
= 1;
1462 return must_preallocate
;
1465 /* If we preallocated stack space, compute the address of each argument
1466 and store it into the ARGS array.
1468 We need not ensure it is a valid memory address here; it will be
1469 validized when it is used.
1471 ARGBLOCK is an rtx for the address of the outgoing arguments. */
1474 compute_argument_addresses (struct arg_data
*args
, rtx argblock
, int num_actuals
)
1478 rtx arg_reg
= argblock
;
1479 int i
, arg_offset
= 0;
1481 if (GET_CODE (argblock
) == PLUS
)
1482 arg_reg
= XEXP (argblock
, 0), arg_offset
= INTVAL (XEXP (argblock
, 1));
1484 for (i
= 0; i
< num_actuals
; i
++)
1486 rtx offset
= ARGS_SIZE_RTX (args
[i
].locate
.offset
);
1487 rtx slot_offset
= ARGS_SIZE_RTX (args
[i
].locate
.slot_offset
);
1490 /* Skip this parm if it will not be passed on the stack. */
1491 if (! args
[i
].pass_on_stack
&& args
[i
].reg
!= 0)
1494 if (GET_CODE (offset
) == CONST_INT
)
1495 addr
= plus_constant (arg_reg
, INTVAL (offset
));
1497 addr
= gen_rtx_PLUS (Pmode
, arg_reg
, offset
);
1499 addr
= plus_constant (addr
, arg_offset
);
1500 args
[i
].stack
= gen_rtx_MEM (args
[i
].mode
, addr
);
1501 set_mem_align (args
[i
].stack
, PARM_BOUNDARY
);
1502 set_mem_attributes (args
[i
].stack
,
1503 TREE_TYPE (args
[i
].tree_value
), 1);
1505 if (GET_CODE (slot_offset
) == CONST_INT
)
1506 addr
= plus_constant (arg_reg
, INTVAL (slot_offset
));
1508 addr
= gen_rtx_PLUS (Pmode
, arg_reg
, slot_offset
);
1510 addr
= plus_constant (addr
, arg_offset
);
1511 args
[i
].stack_slot
= gen_rtx_MEM (args
[i
].mode
, addr
);
1512 set_mem_align (args
[i
].stack_slot
, PARM_BOUNDARY
);
1513 set_mem_attributes (args
[i
].stack_slot
,
1514 TREE_TYPE (args
[i
].tree_value
), 1);
1516 /* Function incoming arguments may overlap with sibling call
1517 outgoing arguments and we cannot allow reordering of reads
1518 from function arguments with stores to outgoing arguments
1519 of sibling calls. */
1520 set_mem_alias_set (args
[i
].stack
, 0);
1521 set_mem_alias_set (args
[i
].stack_slot
, 0);
1526 /* Given a FNDECL and EXP, return an rtx suitable for use as a target address
1527 in a call instruction.
1529 FNDECL is the tree node for the target function. For an indirect call
1530 FNDECL will be NULL_TREE.
1532 ADDR is the operand 0 of CALL_EXPR for this call. */
1535 rtx_for_function_call (tree fndecl
, tree addr
)
1539 /* Get the function to call, in the form of RTL. */
1542 /* If this is the first use of the function, see if we need to
1543 make an external definition for it. */
1544 if (! TREE_USED (fndecl
))
1546 assemble_external (fndecl
);
1547 TREE_USED (fndecl
) = 1;
1550 /* Get a SYMBOL_REF rtx for the function address. */
1551 funexp
= XEXP (DECL_RTL (fndecl
), 0);
1554 /* Generate an rtx (probably a pseudo-register) for the address. */
1557 funexp
= expand_expr (addr
, NULL_RTX
, VOIDmode
, 0);
1558 pop_temp_slots (); /* FUNEXP can't be BLKmode. */
1564 /* Do the register loads required for any wholly-register parms or any
1565 parms which are passed both on the stack and in a register. Their
1566 expressions were already evaluated.
1568 Mark all register-parms as living through the call, putting these USE
1569 insns in the CALL_INSN_FUNCTION_USAGE field.
1571 When IS_SIBCALL, perform the check_sibcall_overlap_argument_overlap
1572 checking, setting *SIBCALL_FAILURE if appropriate. */
1575 load_register_parameters (struct arg_data
*args
, int num_actuals
,
1576 rtx
*call_fusage
, int flags
, int is_sibcall
,
1577 int *sibcall_failure
)
1581 #ifdef LOAD_ARGS_REVERSED
1582 for (i
= num_actuals
- 1; i
>= 0; i
--)
1584 for (i
= 0; i
< num_actuals
; i
++)
1587 rtx reg
= ((flags
& ECF_SIBCALL
)
1588 ? args
[i
].tail_call_reg
: args
[i
].reg
);
1591 int partial
= args
[i
].partial
;
1594 rtx before_arg
= get_last_insn ();
1595 /* Set to non-negative if must move a word at a time, even if just
1596 one word (e.g, partial == 1 && mode == DFmode). Set to -1 if
1597 we just use a normal move insn. This value can be zero if the
1598 argument is a zero size structure with no fields. */
1602 else if (TYPE_MODE (TREE_TYPE (args
[i
].tree_value
)) == BLKmode
)
1604 size
= int_size_in_bytes (TREE_TYPE (args
[i
].tree_value
));
1605 nregs
= (size
+ (UNITS_PER_WORD
- 1)) / UNITS_PER_WORD
;
1608 size
= GET_MODE_SIZE (args
[i
].mode
);
1610 /* Handle calls that pass values in multiple non-contiguous
1611 locations. The Irix 6 ABI has examples of this. */
1613 if (GET_CODE (reg
) == PARALLEL
)
1615 tree type
= TREE_TYPE (args
[i
].tree_value
);
1616 emit_group_load (reg
, args
[i
].value
, type
,
1617 int_size_in_bytes (type
));
1620 /* If simple case, just do move. If normal partial, store_one_arg
1621 has already loaded the register for us. In all other cases,
1622 load the register(s) from memory. */
1624 else if (nregs
== -1)
1626 emit_move_insn (reg
, args
[i
].value
);
1627 #ifdef BLOCK_REG_PADDING
1628 /* Handle case where we have a value that needs shifting
1629 up to the msb. eg. a QImode value and we're padding
1630 upward on a BYTES_BIG_ENDIAN machine. */
1631 if (size
< UNITS_PER_WORD
1632 && (args
[i
].locate
.where_pad
1633 == (BYTES_BIG_ENDIAN
? upward
: downward
)))
1636 int shift
= (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
1638 /* Assigning REG here rather than a temp makes CALL_FUSAGE
1639 report the whole reg as used. Strictly speaking, the
1640 call only uses SIZE bytes at the msb end, but it doesn't
1641 seem worth generating rtl to say that. */
1642 reg
= gen_rtx_REG (word_mode
, REGNO (reg
));
1643 x
= expand_binop (word_mode
, ashl_optab
, reg
,
1644 GEN_INT (shift
), reg
, 1, OPTAB_WIDEN
);
1646 emit_move_insn (reg
, x
);
1651 /* If we have pre-computed the values to put in the registers in
1652 the case of non-aligned structures, copy them in now. */
1654 else if (args
[i
].n_aligned_regs
!= 0)
1655 for (j
= 0; j
< args
[i
].n_aligned_regs
; j
++)
1656 emit_move_insn (gen_rtx_REG (word_mode
, REGNO (reg
) + j
),
1657 args
[i
].aligned_regs
[j
]);
1659 else if (partial
== 0 || args
[i
].pass_on_stack
)
1661 rtx mem
= validize_mem (args
[i
].value
);
1663 #ifdef BLOCK_REG_PADDING
1664 /* Handle a BLKmode that needs shifting. */
1665 if (nregs
== 1 && size
< UNITS_PER_WORD
1666 && args
[i
].locate
.where_pad
== downward
)
1668 rtx tem
= operand_subword_force (mem
, 0, args
[i
].mode
);
1669 rtx ri
= gen_rtx_REG (word_mode
, REGNO (reg
));
1670 rtx x
= gen_reg_rtx (word_mode
);
1671 int shift
= (UNITS_PER_WORD
- size
) * BITS_PER_UNIT
;
1672 optab dir
= BYTES_BIG_ENDIAN
? lshr_optab
: ashl_optab
;
1674 emit_move_insn (x
, tem
);
1675 x
= expand_binop (word_mode
, dir
, x
, GEN_INT (shift
),
1676 ri
, 1, OPTAB_WIDEN
);
1678 emit_move_insn (ri
, x
);
1682 move_block_to_reg (REGNO (reg
), mem
, nregs
, args
[i
].mode
);
1685 /* When a parameter is a block, and perhaps in other cases, it is
1686 possible that it did a load from an argument slot that was
1687 already clobbered. */
1689 && check_sibcall_argument_overlap (before_arg
, &args
[i
], 0))
1690 *sibcall_failure
= 1;
1692 /* Handle calls that pass values in multiple non-contiguous
1693 locations. The Irix 6 ABI has examples of this. */
1694 if (GET_CODE (reg
) == PARALLEL
)
1695 use_group_regs (call_fusage
, reg
);
1696 else if (nregs
== -1)
1697 use_reg (call_fusage
, reg
);
1699 use_regs (call_fusage
, REGNO (reg
), nregs
== 0 ? 1 : nregs
);
1704 /* Try to integrate function. See expand_inline_function for documentation
1705 about the parameters. */
1708 try_to_integrate (tree fndecl
, tree actparms
, rtx target
, int ignore
,
1709 tree type
, rtx structure_value_addr
)
1714 rtx old_stack_level
= 0;
1715 int reg_parm_stack_space
= 0;
1717 #ifdef REG_PARM_STACK_SPACE
1718 #ifdef MAYBE_REG_PARM_STACK_SPACE
1719 reg_parm_stack_space
= MAYBE_REG_PARM_STACK_SPACE
;
1721 reg_parm_stack_space
= REG_PARM_STACK_SPACE (fndecl
);
1725 before_call
= get_last_insn ();
1727 timevar_push (TV_INTEGRATION
);
1729 temp
= expand_inline_function (fndecl
, actparms
, target
,
1731 structure_value_addr
);
1733 timevar_pop (TV_INTEGRATION
);
1735 /* If inlining succeeded, return. */
1736 if (temp
!= (rtx
) (size_t) - 1)
1738 if (ACCUMULATE_OUTGOING_ARGS
)
1740 /* If the outgoing argument list must be preserved, push
1741 the stack before executing the inlined function if it
1744 i
= reg_parm_stack_space
;
1745 if (i
> highest_outgoing_arg_in_use
)
1746 i
= highest_outgoing_arg_in_use
;
1747 while (--i
>= 0 && stack_usage_map
[i
] == 0)
1750 if (stack_arg_under_construction
|| i
>= 0)
1753 = before_call
? NEXT_INSN (before_call
) : get_insns ();
1754 rtx insn
= NULL_RTX
, seq
;
1756 /* Look for a call in the inline function code.
1757 If DECL_SAVED_INSNS (fndecl)->outgoing_args_size is
1758 nonzero then there is a call and it is not necessary
1759 to scan the insns. */
1761 if (DECL_SAVED_INSNS (fndecl
)->outgoing_args_size
== 0)
1762 for (insn
= first_insn
; insn
; insn
= NEXT_INSN (insn
))
1763 if (GET_CODE (insn
) == CALL_INSN
)
1768 /* Reserve enough stack space so that the largest
1769 argument list of any function call in the inline
1770 function does not overlap the argument list being
1771 evaluated. This is usually an overestimate because
1772 allocate_dynamic_stack_space reserves space for an
1773 outgoing argument list in addition to the requested
1774 space, but there is no way to ask for stack space such
1775 that an argument list of a certain length can be
1778 Add the stack space reserved for register arguments, if
1779 any, in the inline function. What is really needed is the
1780 largest value of reg_parm_stack_space in the inline
1781 function, but that is not available. Using the current
1782 value of reg_parm_stack_space is wrong, but gives
1783 correct results on all supported machines. */
1785 int adjust
= (DECL_SAVED_INSNS (fndecl
)->outgoing_args_size
1786 + reg_parm_stack_space
);
1789 emit_stack_save (SAVE_BLOCK
, &old_stack_level
, NULL_RTX
);
1790 allocate_dynamic_stack_space (GEN_INT (adjust
),
1791 NULL_RTX
, BITS_PER_UNIT
);
1794 emit_insn_before (seq
, first_insn
);
1795 emit_stack_restore (SAVE_BLOCK
, old_stack_level
, NULL_RTX
);
1800 /* If the result is equivalent to TARGET, return TARGET to simplify
1801 checks in store_expr. They can be equivalent but not equal in the
1802 case of a function that returns BLKmode. */
1803 if (temp
!= target
&& rtx_equal_p (temp
, target
))
1808 /* If inlining failed, mark FNDECL as needing to be compiled
1809 separately after all. If function was declared inline,
1811 if (DECL_INLINE (fndecl
) && warn_inline
&& !flag_no_inline
1812 && optimize
> 0 && !TREE_ADDRESSABLE (fndecl
))
1814 warning ("%Jinlining failed in call to '%F'", fndecl
, fndecl
);
1815 warning ("called from here");
1817 (*lang_hooks
.mark_addressable
) (fndecl
);
1818 return (rtx
) (size_t) - 1;
1821 /* We need to pop PENDING_STACK_ADJUST bytes. But, if the arguments
1822 wouldn't fill up an even multiple of PREFERRED_UNIT_STACK_BOUNDARY
1823 bytes, then we would need to push some additional bytes to pad the
1824 arguments. So, we compute an adjust to the stack pointer for an
1825 amount that will leave the stack under-aligned by UNADJUSTED_ARGS_SIZE
1826 bytes. Then, when the arguments are pushed the stack will be perfectly
1827 aligned. ARGS_SIZE->CONSTANT is set to the number of bytes that should
1828 be popped after the call. Returns the adjustment. */
1831 combine_pending_stack_adjustment_and_call (int unadjusted_args_size
,
1832 struct args_size
*args_size
,
1833 int preferred_unit_stack_boundary
)
1835 /* The number of bytes to pop so that the stack will be
1836 under-aligned by UNADJUSTED_ARGS_SIZE bytes. */
1837 HOST_WIDE_INT adjustment
;
1838 /* The alignment of the stack after the arguments are pushed, if we
1839 just pushed the arguments without adjust the stack here. */
1840 HOST_WIDE_INT unadjusted_alignment
;
1842 unadjusted_alignment
1843 = ((stack_pointer_delta
+ unadjusted_args_size
)
1844 % preferred_unit_stack_boundary
);
1846 /* We want to get rid of as many of the PENDING_STACK_ADJUST bytes
1847 as possible -- leaving just enough left to cancel out the
1848 UNADJUSTED_ALIGNMENT. In other words, we want to ensure that the
1849 PENDING_STACK_ADJUST is non-negative, and congruent to
1850 -UNADJUSTED_ALIGNMENT modulo the PREFERRED_UNIT_STACK_BOUNDARY. */
1852 /* Begin by trying to pop all the bytes. */
1853 unadjusted_alignment
1854 = (unadjusted_alignment
1855 - (pending_stack_adjust
% preferred_unit_stack_boundary
));
1856 adjustment
= pending_stack_adjust
;
1857 /* Push enough additional bytes that the stack will be aligned
1858 after the arguments are pushed. */
1859 if (preferred_unit_stack_boundary
> 1)
1861 if (unadjusted_alignment
> 0)
1862 adjustment
-= preferred_unit_stack_boundary
- unadjusted_alignment
;
1864 adjustment
+= unadjusted_alignment
;
1867 /* Now, sets ARGS_SIZE->CONSTANT so that we pop the right number of
1868 bytes after the call. The right number is the entire
1869 PENDING_STACK_ADJUST less our ADJUSTMENT plus the amount required
1870 by the arguments in the first place. */
1872 = pending_stack_adjust
- adjustment
+ unadjusted_args_size
;
1877 /* Scan X expression if it does not dereference any argument slots
1878 we already clobbered by tail call arguments (as noted in stored_args_map
1880 Return nonzero if X expression dereferences such argument slots,
1884 check_sibcall_argument_overlap_1 (rtx x
)
1894 code
= GET_CODE (x
);
1898 if (XEXP (x
, 0) == current_function_internal_arg_pointer
)
1900 else if (GET_CODE (XEXP (x
, 0)) == PLUS
1901 && XEXP (XEXP (x
, 0), 0) ==
1902 current_function_internal_arg_pointer
1903 && GET_CODE (XEXP (XEXP (x
, 0), 1)) == CONST_INT
)
1904 i
= INTVAL (XEXP (XEXP (x
, 0), 1));
1908 #ifdef ARGS_GROW_DOWNWARD
1909 i
= -i
- GET_MODE_SIZE (GET_MODE (x
));
1912 for (k
= 0; k
< GET_MODE_SIZE (GET_MODE (x
)); k
++)
1913 if (i
+ k
< stored_args_map
->n_bits
1914 && TEST_BIT (stored_args_map
, i
+ k
))
1920 /* Scan all subexpressions. */
1921 fmt
= GET_RTX_FORMAT (code
);
1922 for (i
= 0; i
< GET_RTX_LENGTH (code
); i
++, fmt
++)
1926 if (check_sibcall_argument_overlap_1 (XEXP (x
, i
)))
1929 else if (*fmt
== 'E')
1931 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
1932 if (check_sibcall_argument_overlap_1 (XVECEXP (x
, i
, j
)))
1939 /* Scan sequence after INSN if it does not dereference any argument slots
1940 we already clobbered by tail call arguments (as noted in stored_args_map
1941 bitmap). If MARK_STORED_ARGS_MAP, add stack slots for ARG to
1942 stored_args_map bitmap afterwards (when ARG is a register MARK_STORED_ARGS_MAP
1943 should be 0). Return nonzero if sequence after INSN dereferences such argument
1944 slots, zero otherwise. */
1947 check_sibcall_argument_overlap (rtx insn
, struct arg_data
*arg
, int mark_stored_args_map
)
1951 if (insn
== NULL_RTX
)
1952 insn
= get_insns ();
1954 insn
= NEXT_INSN (insn
);
1956 for (; insn
; insn
= NEXT_INSN (insn
))
1958 && check_sibcall_argument_overlap_1 (PATTERN (insn
)))
1961 if (mark_stored_args_map
)
1963 #ifdef ARGS_GROW_DOWNWARD
1964 low
= -arg
->locate
.slot_offset
.constant
- arg
->locate
.size
.constant
;
1966 low
= arg
->locate
.slot_offset
.constant
;
1969 for (high
= low
+ arg
->locate
.size
.constant
; low
< high
; low
++)
1970 SET_BIT (stored_args_map
, low
);
1972 return insn
!= NULL_RTX
;
1976 fix_unsafe_tree (tree t
)
1978 switch (unsafe_for_reeval (t
))
1983 case 1: /* Mildly unsafe. */
1984 t
= unsave_expr (t
);
1987 case 2: /* Wildly unsafe. */
1989 tree var
= build_decl (VAR_DECL
, NULL_TREE
,
1992 expand_expr (t
, NULL_RTX
, VOIDmode
, EXPAND_NORMAL
));
2003 /* Generate all the code for a function call
2004 and return an rtx for its value.
2005 Store the value in TARGET (specified as an rtx) if convenient.
2006 If the value is stored in TARGET then TARGET is returned.
2007 If IGNORE is nonzero, then we ignore the value of the function call. */
2010 expand_call (tree exp
, rtx target
, int ignore
)
2012 /* Nonzero if we are currently expanding a call. */
2013 static int currently_expanding_call
= 0;
2015 /* List of actual parameters. */
2016 tree actparms
= TREE_OPERAND (exp
, 1);
2017 /* RTX for the function to be called. */
2019 /* Sequence of insns to perform a tail recursive "call". */
2020 rtx tail_recursion_insns
= NULL_RTX
;
2021 /* Sequence of insns to perform a normal "call". */
2022 rtx normal_call_insns
= NULL_RTX
;
2023 /* Sequence of insns to perform a tail recursive "call". */
2024 rtx tail_call_insns
= NULL_RTX
;
2025 /* Data type of the function. */
2027 tree type_arg_types
;
2028 /* Declaration of the function being called,
2029 or 0 if the function is computed (not known by name). */
2032 int try_tail_call
= 1;
2033 int try_tail_recursion
= 1;
2036 /* Register in which non-BLKmode value will be returned,
2037 or 0 if no value or if value is BLKmode. */
2039 /* Address where we should return a BLKmode value;
2040 0 if value not BLKmode. */
2041 rtx structure_value_addr
= 0;
2042 /* Nonzero if that address is being passed by treating it as
2043 an extra, implicit first parameter. Otherwise,
2044 it is passed by being copied directly into struct_value_rtx. */
2045 int structure_value_addr_parm
= 0;
2046 /* Size of aggregate value wanted, or zero if none wanted
2047 or if we are using the non-reentrant PCC calling convention
2048 or expecting the value in registers. */
2049 HOST_WIDE_INT struct_value_size
= 0;
2050 /* Nonzero if called function returns an aggregate in memory PCC style,
2051 by returning the address of where to find it. */
2052 int pcc_struct_value
= 0;
2053 rtx struct_value
= 0;
2055 /* Number of actual parameters in this call, including struct value addr. */
2057 /* Number of named args. Args after this are anonymous ones
2058 and they must all go on the stack. */
2061 /* Vector of information about each argument.
2062 Arguments are numbered in the order they will be pushed,
2063 not the order they are written. */
2064 struct arg_data
*args
;
2066 /* Total size in bytes of all the stack-parms scanned so far. */
2067 struct args_size args_size
;
2068 struct args_size adjusted_args_size
;
2069 /* Size of arguments before any adjustments (such as rounding). */
2070 int unadjusted_args_size
;
2071 /* Data on reg parms scanned so far. */
2072 CUMULATIVE_ARGS args_so_far
;
2073 /* Nonzero if a reg parm has been scanned. */
2075 /* Nonzero if this is an indirect function call. */
2077 /* Nonzero if we must avoid push-insns in the args for this call.
2078 If stack space is allocated for register parameters, but not by the
2079 caller, then it is preallocated in the fixed part of the stack frame.
2080 So the entire argument block must then be preallocated (i.e., we
2081 ignore PUSH_ROUNDING in that case). */
2083 int must_preallocate
= !PUSH_ARGS
;
2085 /* Size of the stack reserved for parameter registers. */
2086 int reg_parm_stack_space
= 0;
2088 /* Address of space preallocated for stack parms
2089 (on machines that lack push insns), or 0 if space not preallocated. */
2092 /* Mask of ECF_ flags. */
2094 /* Nonzero if this is a call to an inline function. */
2095 int is_integrable
= 0;
2096 #ifdef REG_PARM_STACK_SPACE
2097 /* Define the boundary of the register parm stack space that needs to be
2099 int low_to_save
, high_to_save
;
2100 rtx save_area
= 0; /* Place that it is saved */
2103 int initial_highest_arg_in_use
= highest_outgoing_arg_in_use
;
2104 char *initial_stack_usage_map
= stack_usage_map
;
2106 int old_stack_allocated
;
2108 /* State variables to track stack modifications. */
2109 rtx old_stack_level
= 0;
2110 int old_stack_arg_under_construction
= 0;
2111 int old_pending_adj
= 0;
2112 int old_inhibit_defer_pop
= inhibit_defer_pop
;
2114 /* Some stack pointer alterations we make are performed via
2115 allocate_dynamic_stack_space. This modifies the stack_pointer_delta,
2116 which we then also need to save/restore along the way. */
2117 int old_stack_pointer_delta
= 0;
2120 tree p
= TREE_OPERAND (exp
, 0);
2121 tree addr
= TREE_OPERAND (exp
, 0);
2123 /* The alignment of the stack, in bits. */
2124 HOST_WIDE_INT preferred_stack_boundary
;
2125 /* The alignment of the stack, in bytes. */
2126 HOST_WIDE_INT preferred_unit_stack_boundary
;
2128 /* See if this is "nothrow" function call. */
2129 if (TREE_NOTHROW (exp
))
2130 flags
|= ECF_NOTHROW
;
2132 /* See if we can find a DECL-node for the actual function.
2133 As a result, decide whether this is a call to an integrable function. */
2135 fndecl
= get_callee_fndecl (exp
);
2139 && fndecl
!= current_function_decl
2140 && DECL_INLINE (fndecl
)
2141 && DECL_SAVED_INSNS (fndecl
)
2142 && DECL_SAVED_INSNS (fndecl
)->inlinable
)
2144 else if (! TREE_ADDRESSABLE (fndecl
))
2146 /* In case this function later becomes inlinable,
2147 record that there was already a non-inline call to it.
2149 Use abstraction instead of setting TREE_ADDRESSABLE
2151 if (DECL_INLINE (fndecl
) && warn_inline
&& !flag_no_inline
2154 warning ("%Jcan't inline call to '%F'", fndecl
, fndecl
);
2155 warning ("called from here");
2157 (*lang_hooks
.mark_addressable
) (fndecl
);
2161 && lookup_attribute ("warn_unused_result",
2162 TYPE_ATTRIBUTES (TREE_TYPE (fndecl
))))
2163 warning ("ignoring return value of `%D', "
2164 "declared with attribute warn_unused_result", fndecl
);
2166 flags
|= flags_from_decl_or_type (fndecl
);
2169 /* If we don't have specific function to call, see if we have a
2170 attributes set in the type. */
2174 && lookup_attribute ("warn_unused_result",
2175 TYPE_ATTRIBUTES (TREE_TYPE (TREE_TYPE (p
)))))
2176 warning ("ignoring return value of function "
2177 "declared with attribute warn_unused_result");
2178 flags
|= flags_from_decl_or_type (TREE_TYPE (TREE_TYPE (p
)));
2181 struct_value
= targetm
.calls
.struct_value_rtx (fndecl
? TREE_TYPE (fndecl
) : 0, 0);
2183 /* Warn if this value is an aggregate type,
2184 regardless of which calling convention we are using for it. */
2185 if (warn_aggregate_return
&& AGGREGATE_TYPE_P (TREE_TYPE (exp
)))
2186 warning ("function call has aggregate value");
2188 /* If the result of a pure or const function call is ignored (or void),
2189 and none of its arguments are volatile, we can avoid expanding the
2190 call and just evaluate the arguments for side-effects. */
2191 if ((flags
& (ECF_CONST
| ECF_PURE
))
2192 && (ignore
|| target
== const0_rtx
2193 || TYPE_MODE (TREE_TYPE (exp
)) == VOIDmode
))
2195 bool volatilep
= false;
2198 for (arg
= actparms
; arg
; arg
= TREE_CHAIN (arg
))
2199 if (TREE_THIS_VOLATILE (TREE_VALUE (arg
)))
2207 for (arg
= actparms
; arg
; arg
= TREE_CHAIN (arg
))
2208 expand_expr (TREE_VALUE (arg
), const0_rtx
,
2209 VOIDmode
, EXPAND_NORMAL
);
2214 #ifdef REG_PARM_STACK_SPACE
2215 #ifdef MAYBE_REG_PARM_STACK_SPACE
2216 reg_parm_stack_space
= MAYBE_REG_PARM_STACK_SPACE
;
2218 reg_parm_stack_space
= REG_PARM_STACK_SPACE (fndecl
);
2222 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2223 if (reg_parm_stack_space
> 0 && PUSH_ARGS
)
2224 must_preallocate
= 1;
2227 /* Set up a place to return a structure. */
2229 /* Cater to broken compilers. */
2230 if (aggregate_value_p (exp
, fndecl
))
2232 /* This call returns a big structure. */
2233 flags
&= ~(ECF_CONST
| ECF_PURE
| ECF_LIBCALL_BLOCK
);
2235 #ifdef PCC_STATIC_STRUCT_RETURN
2237 pcc_struct_value
= 1;
2238 /* Easier than making that case work right. */
2241 /* In case this is a static function, note that it has been
2243 if (! TREE_ADDRESSABLE (fndecl
))
2244 (*lang_hooks
.mark_addressable
) (fndecl
);
2248 #else /* not PCC_STATIC_STRUCT_RETURN */
2250 struct_value_size
= int_size_in_bytes (TREE_TYPE (exp
));
2252 if (CALL_EXPR_HAS_RETURN_SLOT_ADDR (exp
))
2254 /* The structure value address arg is already in actparms.
2255 Pull it out. It might be nice to just leave it there, but
2256 we need to set structure_value_addr. */
2257 tree return_arg
= TREE_VALUE (actparms
);
2258 actparms
= TREE_CHAIN (actparms
);
2259 structure_value_addr
= expand_expr (return_arg
, NULL_RTX
,
2260 VOIDmode
, EXPAND_NORMAL
);
2262 else if (target
&& GET_CODE (target
) == MEM
)
2263 structure_value_addr
= XEXP (target
, 0);
2266 /* For variable-sized objects, we must be called with a target
2267 specified. If we were to allocate space on the stack here,
2268 we would have no way of knowing when to free it. */
2269 rtx d
= assign_temp (TREE_TYPE (exp
), 1, 1, 1);
2271 mark_temp_addr_taken (d
);
2272 structure_value_addr
= XEXP (d
, 0);
2276 #endif /* not PCC_STATIC_STRUCT_RETURN */
2279 /* If called function is inline, try to integrate it. */
2283 rtx temp
= try_to_integrate (fndecl
, actparms
, target
,
2284 ignore
, TREE_TYPE (exp
),
2285 structure_value_addr
);
2286 if (temp
!= (rtx
) (size_t) - 1)
2290 /* Figure out the amount to which the stack should be aligned. */
2291 preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
2294 struct cgraph_rtl_info
*i
= cgraph_rtl_info (fndecl
);
2295 if (i
&& i
->preferred_incoming_stack_boundary
)
2296 preferred_stack_boundary
= i
->preferred_incoming_stack_boundary
;
2299 /* Operand 0 is a pointer-to-function; get the type of the function. */
2300 funtype
= TREE_TYPE (addr
);
2301 if (! POINTER_TYPE_P (funtype
))
2303 funtype
= TREE_TYPE (funtype
);
2305 /* Munge the tree to split complex arguments into their imaginary
2307 if (SPLIT_COMPLEX_ARGS
)
2309 type_arg_types
= split_complex_types (TYPE_ARG_TYPES (funtype
));
2310 actparms
= split_complex_values (actparms
);
2313 type_arg_types
= TYPE_ARG_TYPES (funtype
);
2315 /* See if this is a call to a function that can return more than once
2316 or a call to longjmp or malloc. */
2317 flags
|= special_function_p (fndecl
, flags
);
2319 if (flags
& ECF_MAY_BE_ALLOCA
)
2320 current_function_calls_alloca
= 1;
2322 /* If struct_value_rtx is 0, it means pass the address
2323 as if it were an extra parameter. */
2324 if (structure_value_addr
&& struct_value
== 0)
2326 /* If structure_value_addr is a REG other than
2327 virtual_outgoing_args_rtx, we can use always use it. If it
2328 is not a REG, we must always copy it into a register.
2329 If it is virtual_outgoing_args_rtx, we must copy it to another
2330 register in some cases. */
2331 rtx temp
= (GET_CODE (structure_value_addr
) != REG
2332 || (ACCUMULATE_OUTGOING_ARGS
2333 && stack_arg_under_construction
2334 && structure_value_addr
== virtual_outgoing_args_rtx
)
2335 ? copy_addr_to_reg (structure_value_addr
)
2336 : structure_value_addr
);
2339 = tree_cons (error_mark_node
,
2340 make_tree (build_pointer_type (TREE_TYPE (funtype
)),
2343 structure_value_addr_parm
= 1;
2346 /* Count the arguments and set NUM_ACTUALS. */
2347 for (p
= actparms
, num_actuals
= 0; p
; p
= TREE_CHAIN (p
))
2350 /* Start updating where the next arg would go.
2352 On some machines (such as the PA) indirect calls have a different
2353 calling convention than normal calls. The last argument in
2354 INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
2356 INIT_CUMULATIVE_ARGS (args_so_far
, funtype
, NULL_RTX
, fndecl
);
2358 /* Compute number of named args.
2359 Normally, don't include the last named arg if anonymous args follow.
2360 We do include the last named arg if STRICT_ARGUMENT_NAMING is nonzero.
2361 (If no anonymous args follow, the result of list_length is actually
2362 one too large. This is harmless.)
2364 If PRETEND_OUTGOING_VARARGS_NAMED is set and STRICT_ARGUMENT_NAMING is
2365 zero, this machine will be able to place unnamed args that were
2366 passed in registers into the stack. So treat all args as named.
2367 This allows the insns emitting for a specific argument list to be
2368 independent of the function declaration.
2370 If PRETEND_OUTGOING_VARARGS_NAMED is not set, we do not have any
2371 reliable way to pass unnamed args in registers, so we must force
2372 them into memory. */
2374 if ((targetm
.calls
.strict_argument_naming (&args_so_far
)
2375 || ! targetm
.calls
.pretend_outgoing_varargs_named (&args_so_far
))
2376 && type_arg_types
!= 0)
2378 = (list_length (type_arg_types
)
2379 /* Don't include the last named arg. */
2380 - (targetm
.calls
.strict_argument_naming (&args_so_far
) ? 0 : 1)
2381 /* Count the struct value address, if it is passed as a parm. */
2382 + structure_value_addr_parm
);
2384 /* If we know nothing, treat all args as named. */
2385 n_named_args
= num_actuals
;
2387 /* Make a vector to hold all the information about each arg. */
2388 args
= alloca (num_actuals
* sizeof (struct arg_data
));
2389 memset (args
, 0, num_actuals
* sizeof (struct arg_data
));
2391 /* Build up entries in the ARGS array, compute the size of the
2392 arguments into ARGS_SIZE, etc. */
2393 initialize_argument_information (num_actuals
, args
, &args_size
,
2394 n_named_args
, actparms
, fndecl
,
2395 &args_so_far
, reg_parm_stack_space
,
2396 &old_stack_level
, &old_pending_adj
,
2397 &must_preallocate
, &flags
);
2401 /* If this function requires a variable-sized argument list, don't
2402 try to make a cse'able block for this call. We may be able to
2403 do this eventually, but it is too complicated to keep track of
2404 what insns go in the cse'able block and which don't. */
2406 flags
&= ~ECF_LIBCALL_BLOCK
;
2407 must_preallocate
= 1;
2410 /* Now make final decision about preallocating stack space. */
2411 must_preallocate
= finalize_must_preallocate (must_preallocate
,
2415 /* If the structure value address will reference the stack pointer, we
2416 must stabilize it. We don't need to do this if we know that we are
2417 not going to adjust the stack pointer in processing this call. */
2419 if (structure_value_addr
2420 && (reg_mentioned_p (virtual_stack_dynamic_rtx
, structure_value_addr
)
2421 || reg_mentioned_p (virtual_outgoing_args_rtx
,
2422 structure_value_addr
))
2424 || (!ACCUMULATE_OUTGOING_ARGS
&& args_size
.constant
)))
2425 structure_value_addr
= copy_to_reg (structure_value_addr
);
2427 /* Tail calls can make things harder to debug, and we're traditionally
2428 pushed these optimizations into -O2. Don't try if we're already
2429 expanding a call, as that means we're an argument. Don't try if
2430 there's cleanups, as we know there's code to follow the call.
2432 If rtx_equal_function_value_matters is false, that means we've
2433 finished with regular parsing. Which means that some of the
2434 machinery we use to generate tail-calls is no longer in place.
2435 This is most often true of sjlj-exceptions, which we couldn't
2436 tail-call to anyway. */
2438 if (currently_expanding_call
++ != 0
2439 || !flag_optimize_sibling_calls
2440 || !rtx_equal_function_value_matters
2441 || any_pending_cleanups ()
2443 try_tail_call
= try_tail_recursion
= 0;
2445 /* Tail recursion fails, when we are not dealing with recursive calls. */
2446 if (!try_tail_recursion
2447 || TREE_CODE (addr
) != ADDR_EXPR
2448 || TREE_OPERAND (addr
, 0) != current_function_decl
)
2449 try_tail_recursion
= 0;
2451 /* Rest of purposes for tail call optimizations to fail. */
2453 #ifdef HAVE_sibcall_epilogue
2454 !HAVE_sibcall_epilogue
2459 /* Doing sibling call optimization needs some work, since
2460 structure_value_addr can be allocated on the stack.
2461 It does not seem worth the effort since few optimizable
2462 sibling calls will return a structure. */
2463 || structure_value_addr
!= NULL_RTX
2464 /* Check whether the target is able to optimize the call
2466 || !(*targetm
.function_ok_for_sibcall
) (fndecl
, exp
)
2467 /* Functions that do not return exactly once may not be sibcall
2469 || (flags
& (ECF_RETURNS_TWICE
| ECF_LONGJMP
| ECF_NORETURN
))
2470 || TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (addr
)))
2471 /* If the called function is nested in the current one, it might access
2472 some of the caller's arguments, but could clobber them beforehand if
2473 the argument areas are shared. */
2474 || (fndecl
&& decl_function_context (fndecl
) == current_function_decl
)
2475 /* If this function requires more stack slots than the current
2476 function, we cannot change it into a sibling call. */
2477 || args_size
.constant
> current_function_args_size
2478 /* If the callee pops its own arguments, then it must pop exactly
2479 the same number of arguments as the current function. */
2480 || (RETURN_POPS_ARGS (fndecl
, funtype
, args_size
.constant
)
2481 != RETURN_POPS_ARGS (current_function_decl
,
2482 TREE_TYPE (current_function_decl
),
2483 current_function_args_size
))
2484 || !(*lang_hooks
.decls
.ok_for_sibcall
) (fndecl
))
2487 if (try_tail_call
|| try_tail_recursion
)
2490 actparms
= NULL_TREE
;
2491 /* Ok, we're going to give the tail call the old college try.
2492 This means we're going to evaluate the function arguments
2493 up to three times. There are two degrees of badness we can
2494 encounter, those that can be unsaved and those that can't.
2495 (See unsafe_for_reeval commentary for details.)
2497 Generate a new argument list. Pass safe arguments through
2498 unchanged. For the easy badness wrap them in UNSAVE_EXPRs.
2499 For hard badness, evaluate them now and put their resulting
2500 rtx in a temporary VAR_DECL.
2502 initialize_argument_information has ordered the array for the
2503 order to be pushed, and we must remember this when reconstructing
2504 the original argument order. */
2506 if (PUSH_ARGS_REVERSED
)
2515 i
= num_actuals
- 1;
2519 for (; i
!= end
; i
+= inc
)
2521 args
[i
].tree_value
= fix_unsafe_tree (args
[i
].tree_value
);
2522 /* We need to build actparms for optimize_tail_recursion. We can
2523 safely trash away TREE_PURPOSE, since it is unused by this
2525 if (try_tail_recursion
)
2526 actparms
= tree_cons (NULL_TREE
, args
[i
].tree_value
, actparms
);
2528 /* Do the same for the function address if it is an expression. */
2530 addr
= fix_unsafe_tree (addr
);
2531 /* Expanding one of those dangerous arguments could have added
2532 cleanups, but otherwise give it a whirl. */
2533 if (any_pending_cleanups ())
2534 try_tail_call
= try_tail_recursion
= 0;
2537 /* Generate a tail recursion sequence when calling ourselves. */
2539 if (try_tail_recursion
)
2541 /* We want to emit any pending stack adjustments before the tail
2542 recursion "call". That way we know any adjustment after the tail
2543 recursion call can be ignored if we indeed use the tail recursion
2545 int save_pending_stack_adjust
= pending_stack_adjust
;
2546 int save_stack_pointer_delta
= stack_pointer_delta
;
2548 /* Emit any queued insns now; otherwise they would end up in
2549 only one of the alternates. */
2552 /* Use a new sequence to hold any RTL we generate. We do not even
2553 know if we will use this RTL yet. The final decision can not be
2554 made until after RTL generation for the entire function is
2557 /* If expanding any of the arguments creates cleanups, we can't
2558 do a tailcall. So, we'll need to pop the pending cleanups
2559 list. If, however, all goes well, and there are no cleanups
2560 then the call to expand_start_target_temps will have no
2562 expand_start_target_temps ();
2563 if (optimize_tail_recursion (actparms
, get_last_insn ()))
2565 if (any_pending_cleanups ())
2566 try_tail_call
= try_tail_recursion
= 0;
2568 tail_recursion_insns
= get_insns ();
2570 expand_end_target_temps ();
2573 /* Restore the original pending stack adjustment for the sibling and
2574 normal call cases below. */
2575 pending_stack_adjust
= save_pending_stack_adjust
;
2576 stack_pointer_delta
= save_stack_pointer_delta
;
2579 if (profile_arc_flag
&& (flags
& ECF_FORK_OR_EXEC
))
2581 /* A fork duplicates the profile information, and an exec discards
2582 it. We can't rely on fork/exec to be paired. So write out the
2583 profile information we have gathered so far, and clear it. */
2584 /* ??? When Linux's __clone is called with CLONE_VM set, profiling
2585 is subject to race conditions, just as with multithreaded
2588 emit_library_call (gcov_flush_libfunc
, LCT_ALWAYS_RETURN
, VOIDmode
, 0);
2591 /* Ensure current function's preferred stack boundary is at least
2592 what we need. We don't have to increase alignment for recursive
2594 if (cfun
->preferred_stack_boundary
< preferred_stack_boundary
2595 && fndecl
!= current_function_decl
)
2596 cfun
->preferred_stack_boundary
= preferred_stack_boundary
;
2597 if (fndecl
== current_function_decl
)
2598 cfun
->recursive_call_emit
= true;
2600 preferred_unit_stack_boundary
= preferred_stack_boundary
/ BITS_PER_UNIT
;
2602 function_call_count
++;
2604 /* We want to make two insn chains; one for a sibling call, the other
2605 for a normal call. We will select one of the two chains after
2606 initial RTL generation is complete. */
2607 for (pass
= try_tail_call
? 0 : 1; pass
< 2; pass
++)
2609 int sibcall_failure
= 0;
2610 /* We want to emit any pending stack adjustments before the tail
2611 recursion "call". That way we know any adjustment after the tail
2612 recursion call can be ignored if we indeed use the tail recursion
2614 int save_pending_stack_adjust
= 0;
2615 int save_stack_pointer_delta
= 0;
2617 rtx before_call
, next_arg_reg
;
2621 /* Emit any queued insns now; otherwise they would end up in
2622 only one of the alternates. */
2625 /* State variables we need to save and restore between
2627 save_pending_stack_adjust
= pending_stack_adjust
;
2628 save_stack_pointer_delta
= stack_pointer_delta
;
2631 flags
&= ~ECF_SIBCALL
;
2633 flags
|= ECF_SIBCALL
;
2635 /* Other state variables that we must reinitialize each time
2636 through the loop (that are not initialized by the loop itself). */
2640 /* Start a new sequence for the normal call case.
2642 From this point on, if the sibling call fails, we want to set
2643 sibcall_failure instead of continuing the loop. */
2648 /* We know at this point that there are not currently any
2649 pending cleanups. If, however, in the process of evaluating
2650 the arguments we were to create some, we'll need to be
2651 able to get rid of them. */
2652 expand_start_target_temps ();
2655 /* Don't let pending stack adjusts add up to too much.
2656 Also, do all pending adjustments now if there is any chance
2657 this might be a call to alloca or if we are expanding a sibling
2658 call sequence or if we are calling a function that is to return
2659 with stack pointer depressed. */
2660 if (pending_stack_adjust
>= 32
2661 || (pending_stack_adjust
> 0
2662 && (flags
& (ECF_MAY_BE_ALLOCA
| ECF_SP_DEPRESSED
)))
2664 do_pending_stack_adjust ();
2666 /* When calling a const function, we must pop the stack args right away,
2667 so that the pop is deleted or moved with the call. */
2668 if (pass
&& (flags
& ECF_LIBCALL_BLOCK
))
2671 #ifdef FINAL_REG_PARM_STACK_SPACE
2672 reg_parm_stack_space
= FINAL_REG_PARM_STACK_SPACE (args_size
.constant
,
2675 /* Precompute any arguments as needed. */
2677 precompute_arguments (flags
, num_actuals
, args
);
2679 /* Now we are about to start emitting insns that can be deleted
2680 if a libcall is deleted. */
2681 if (pass
&& (flags
& (ECF_LIBCALL_BLOCK
| ECF_MALLOC
)))
2684 adjusted_args_size
= args_size
;
2685 /* Compute the actual size of the argument block required. The variable
2686 and constant sizes must be combined, the size may have to be rounded,
2687 and there may be a minimum required size. When generating a sibcall
2688 pattern, do not round up, since we'll be re-using whatever space our
2690 unadjusted_args_size
2691 = compute_argument_block_size (reg_parm_stack_space
,
2692 &adjusted_args_size
,
2694 : preferred_stack_boundary
));
2696 old_stack_allocated
= stack_pointer_delta
- pending_stack_adjust
;
2698 /* The argument block when performing a sibling call is the
2699 incoming argument block. */
2702 argblock
= virtual_incoming_args_rtx
;
2704 #ifdef STACK_GROWS_DOWNWARD
2705 = plus_constant (argblock
, current_function_pretend_args_size
);
2707 = plus_constant (argblock
, -current_function_pretend_args_size
);
2709 stored_args_map
= sbitmap_alloc (args_size
.constant
);
2710 sbitmap_zero (stored_args_map
);
2713 /* If we have no actual push instructions, or shouldn't use them,
2714 make space for all args right now. */
2715 else if (adjusted_args_size
.var
!= 0)
2717 if (old_stack_level
== 0)
2719 emit_stack_save (SAVE_BLOCK
, &old_stack_level
, NULL_RTX
);
2720 old_stack_pointer_delta
= stack_pointer_delta
;
2721 old_pending_adj
= pending_stack_adjust
;
2722 pending_stack_adjust
= 0;
2723 /* stack_arg_under_construction says whether a stack arg is
2724 being constructed at the old stack level. Pushing the stack
2725 gets a clean outgoing argument block. */
2726 old_stack_arg_under_construction
= stack_arg_under_construction
;
2727 stack_arg_under_construction
= 0;
2729 argblock
= push_block (ARGS_SIZE_RTX (adjusted_args_size
), 0, 0);
2733 /* Note that we must go through the motions of allocating an argument
2734 block even if the size is zero because we may be storing args
2735 in the area reserved for register arguments, which may be part of
2738 int needed
= adjusted_args_size
.constant
;
2740 /* Store the maximum argument space used. It will be pushed by
2741 the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
2744 if (needed
> current_function_outgoing_args_size
)
2745 current_function_outgoing_args_size
= needed
;
2747 if (must_preallocate
)
2749 if (ACCUMULATE_OUTGOING_ARGS
)
2751 /* Since the stack pointer will never be pushed, it is
2752 possible for the evaluation of a parm to clobber
2753 something we have already written to the stack.
2754 Since most function calls on RISC machines do not use
2755 the stack, this is uncommon, but must work correctly.
2757 Therefore, we save any area of the stack that was already
2758 written and that we are using. Here we set up to do this
2759 by making a new stack usage map from the old one. The
2760 actual save will be done by store_one_arg.
2762 Another approach might be to try to reorder the argument
2763 evaluations to avoid this conflicting stack usage. */
2765 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2766 /* Since we will be writing into the entire argument area,
2767 the map must be allocated for its entire size, not just
2768 the part that is the responsibility of the caller. */
2769 needed
+= reg_parm_stack_space
;
2772 #ifdef ARGS_GROW_DOWNWARD
2773 highest_outgoing_arg_in_use
= MAX (initial_highest_arg_in_use
,
2776 highest_outgoing_arg_in_use
= MAX (initial_highest_arg_in_use
,
2779 stack_usage_map
= alloca (highest_outgoing_arg_in_use
);
2781 if (initial_highest_arg_in_use
)
2782 memcpy (stack_usage_map
, initial_stack_usage_map
,
2783 initial_highest_arg_in_use
);
2785 if (initial_highest_arg_in_use
!= highest_outgoing_arg_in_use
)
2786 memset (&stack_usage_map
[initial_highest_arg_in_use
], 0,
2787 (highest_outgoing_arg_in_use
2788 - initial_highest_arg_in_use
));
2791 /* The address of the outgoing argument list must not be
2792 copied to a register here, because argblock would be left
2793 pointing to the wrong place after the call to
2794 allocate_dynamic_stack_space below. */
2796 argblock
= virtual_outgoing_args_rtx
;
2800 if (inhibit_defer_pop
== 0)
2802 /* Try to reuse some or all of the pending_stack_adjust
2803 to get this space. */
2805 = (combine_pending_stack_adjustment_and_call
2806 (unadjusted_args_size
,
2807 &adjusted_args_size
,
2808 preferred_unit_stack_boundary
));
2810 /* combine_pending_stack_adjustment_and_call computes
2811 an adjustment before the arguments are allocated.
2812 Account for them and see whether or not the stack
2813 needs to go up or down. */
2814 needed
= unadjusted_args_size
- needed
;
2818 /* We're releasing stack space. */
2819 /* ??? We can avoid any adjustment at all if we're
2820 already aligned. FIXME. */
2821 pending_stack_adjust
= -needed
;
2822 do_pending_stack_adjust ();
2826 /* We need to allocate space. We'll do that in
2827 push_block below. */
2828 pending_stack_adjust
= 0;
2831 /* Special case this because overhead of `push_block' in
2832 this case is non-trivial. */
2834 argblock
= virtual_outgoing_args_rtx
;
2837 argblock
= push_block (GEN_INT (needed
), 0, 0);
2838 #ifdef ARGS_GROW_DOWNWARD
2839 argblock
= plus_constant (argblock
, needed
);
2843 /* We only really need to call `copy_to_reg' in the case
2844 where push insns are going to be used to pass ARGBLOCK
2845 to a function call in ARGS. In that case, the stack
2846 pointer changes value from the allocation point to the
2847 call point, and hence the value of
2848 VIRTUAL_OUTGOING_ARGS_RTX changes as well. But might
2849 as well always do it. */
2850 argblock
= copy_to_reg (argblock
);
2855 if (ACCUMULATE_OUTGOING_ARGS
)
2857 /* The save/restore code in store_one_arg handles all
2858 cases except one: a constructor call (including a C
2859 function returning a BLKmode struct) to initialize
2861 if (stack_arg_under_construction
)
2863 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2864 rtx push_size
= GEN_INT (reg_parm_stack_space
2865 + adjusted_args_size
.constant
);
2867 rtx push_size
= GEN_INT (adjusted_args_size
.constant
);
2869 if (old_stack_level
== 0)
2871 emit_stack_save (SAVE_BLOCK
, &old_stack_level
,
2873 old_stack_pointer_delta
= stack_pointer_delta
;
2874 old_pending_adj
= pending_stack_adjust
;
2875 pending_stack_adjust
= 0;
2876 /* stack_arg_under_construction says whether a stack
2877 arg is being constructed at the old stack level.
2878 Pushing the stack gets a clean outgoing argument
2880 old_stack_arg_under_construction
2881 = stack_arg_under_construction
;
2882 stack_arg_under_construction
= 0;
2883 /* Make a new map for the new argument list. */
2884 stack_usage_map
= alloca (highest_outgoing_arg_in_use
);
2885 memset (stack_usage_map
, 0, highest_outgoing_arg_in_use
);
2886 highest_outgoing_arg_in_use
= 0;
2888 allocate_dynamic_stack_space (push_size
, NULL_RTX
,
2892 /* If argument evaluation might modify the stack pointer,
2893 copy the address of the argument list to a register. */
2894 for (i
= 0; i
< num_actuals
; i
++)
2895 if (args
[i
].pass_on_stack
)
2897 argblock
= copy_addr_to_reg (argblock
);
2902 compute_argument_addresses (args
, argblock
, num_actuals
);
2904 /* If we push args individually in reverse order, perform stack alignment
2905 before the first push (the last arg). */
2906 if (PUSH_ARGS_REVERSED
&& argblock
== 0
2907 && adjusted_args_size
.constant
!= unadjusted_args_size
)
2909 /* When the stack adjustment is pending, we get better code
2910 by combining the adjustments. */
2911 if (pending_stack_adjust
2912 && ! (flags
& ECF_LIBCALL_BLOCK
)
2913 && ! inhibit_defer_pop
)
2915 pending_stack_adjust
2916 = (combine_pending_stack_adjustment_and_call
2917 (unadjusted_args_size
,
2918 &adjusted_args_size
,
2919 preferred_unit_stack_boundary
));
2920 do_pending_stack_adjust ();
2922 else if (argblock
== 0)
2923 anti_adjust_stack (GEN_INT (adjusted_args_size
.constant
2924 - unadjusted_args_size
));
2926 /* Now that the stack is properly aligned, pops can't safely
2927 be deferred during the evaluation of the arguments. */
2930 funexp
= rtx_for_function_call (fndecl
, addr
);
2932 /* Figure out the register where the value, if any, will come back. */
2934 if (TYPE_MODE (TREE_TYPE (exp
)) != VOIDmode
2935 && ! structure_value_addr
)
2937 if (pcc_struct_value
)
2938 valreg
= hard_function_value (build_pointer_type (TREE_TYPE (exp
)),
2939 fndecl
, (pass
== 0));
2941 valreg
= hard_function_value (TREE_TYPE (exp
), fndecl
, (pass
== 0));
2944 /* Precompute all register parameters. It isn't safe to compute anything
2945 once we have started filling any specific hard regs. */
2946 precompute_register_parameters (num_actuals
, args
, ®_parm_seen
);
2948 #ifdef REG_PARM_STACK_SPACE
2949 /* Save the fixed argument area if it's part of the caller's frame and
2950 is clobbered by argument setup for this call. */
2951 if (ACCUMULATE_OUTGOING_ARGS
&& pass
)
2952 save_area
= save_fixed_argument_area (reg_parm_stack_space
, argblock
,
2953 &low_to_save
, &high_to_save
);
2956 /* Now store (and compute if necessary) all non-register parms.
2957 These come before register parms, since they can require block-moves,
2958 which could clobber the registers used for register parms.
2959 Parms which have partial registers are not stored here,
2960 but we do preallocate space here if they want that. */
2962 for (i
= 0; i
< num_actuals
; i
++)
2963 if (args
[i
].reg
== 0 || args
[i
].pass_on_stack
)
2965 rtx before_arg
= get_last_insn ();
2967 if (store_one_arg (&args
[i
], argblock
, flags
,
2968 adjusted_args_size
.var
!= 0,
2969 reg_parm_stack_space
)
2971 && check_sibcall_argument_overlap (before_arg
,
2973 sibcall_failure
= 1;
2976 /* If we have a parm that is passed in registers but not in memory
2977 and whose alignment does not permit a direct copy into registers,
2978 make a group of pseudos that correspond to each register that we
2980 if (STRICT_ALIGNMENT
)
2981 store_unaligned_arguments_into_pseudos (args
, num_actuals
);
2983 /* Now store any partially-in-registers parm.
2984 This is the last place a block-move can happen. */
2986 for (i
= 0; i
< num_actuals
; i
++)
2987 if (args
[i
].partial
!= 0 && ! args
[i
].pass_on_stack
)
2989 rtx before_arg
= get_last_insn ();
2991 if (store_one_arg (&args
[i
], argblock
, flags
,
2992 adjusted_args_size
.var
!= 0,
2993 reg_parm_stack_space
)
2995 && check_sibcall_argument_overlap (before_arg
,
2997 sibcall_failure
= 1;
3000 /* If we pushed args in forward order, perform stack alignment
3001 after pushing the last arg. */
3002 if (!PUSH_ARGS_REVERSED
&& argblock
== 0)
3003 anti_adjust_stack (GEN_INT (adjusted_args_size
.constant
3004 - unadjusted_args_size
));
3006 /* If register arguments require space on the stack and stack space
3007 was not preallocated, allocate stack space here for arguments
3008 passed in registers. */
3009 #ifdef OUTGOING_REG_PARM_STACK_SPACE
3010 if (!ACCUMULATE_OUTGOING_ARGS
3011 && must_preallocate
== 0 && reg_parm_stack_space
> 0)
3012 anti_adjust_stack (GEN_INT (reg_parm_stack_space
));
3015 /* Pass the function the address in which to return a
3017 if (pass
!= 0 && structure_value_addr
&& ! structure_value_addr_parm
)
3019 structure_value_addr
3020 = convert_memory_address (Pmode
, structure_value_addr
);
3021 emit_move_insn (struct_value
,
3023 force_operand (structure_value_addr
,
3026 if (GET_CODE (struct_value
) == REG
)
3027 use_reg (&call_fusage
, struct_value
);
3030 funexp
= prepare_call_address (funexp
, fndecl
, &call_fusage
,
3031 reg_parm_seen
, pass
== 0);
3033 load_register_parameters (args
, num_actuals
, &call_fusage
, flags
,
3034 pass
== 0, &sibcall_failure
);
3036 /* Perform postincrements before actually calling the function. */
3039 /* Save a pointer to the last insn before the call, so that we can
3040 later safely search backwards to find the CALL_INSN. */
3041 before_call
= get_last_insn ();
3043 /* Set up next argument register. For sibling calls on machines
3044 with register windows this should be the incoming register. */
3045 #ifdef FUNCTION_INCOMING_ARG
3047 next_arg_reg
= FUNCTION_INCOMING_ARG (args_so_far
, VOIDmode
,
3051 next_arg_reg
= FUNCTION_ARG (args_so_far
, VOIDmode
,
3054 /* All arguments and registers used for the call must be set up by
3057 /* Stack must be properly aligned now. */
3058 if (pass
&& stack_pointer_delta
% preferred_unit_stack_boundary
)
3061 /* Generate the actual call instruction. */
3062 emit_call_1 (funexp
, fndecl
, funtype
, unadjusted_args_size
,
3063 adjusted_args_size
.constant
, struct_value_size
,
3064 next_arg_reg
, valreg
, old_inhibit_defer_pop
, call_fusage
,
3065 flags
, & args_so_far
);
3067 /* If call is cse'able, make appropriate pair of reg-notes around it.
3068 Test valreg so we don't crash; may safely ignore `const'
3069 if return type is void. Disable for PARALLEL return values, because
3070 we have no way to move such values into a pseudo register. */
3071 if (pass
&& (flags
& ECF_LIBCALL_BLOCK
))
3075 bool failed
= valreg
== 0 || GET_CODE (valreg
) == PARALLEL
;
3077 insns
= get_insns ();
3079 /* Expansion of block moves possibly introduced a loop that may
3080 not appear inside libcall block. */
3081 for (insn
= insns
; insn
; insn
= NEXT_INSN (insn
))
3082 if (GET_CODE (insn
) == JUMP_INSN
)
3093 rtx temp
= gen_reg_rtx (GET_MODE (valreg
));
3095 /* Mark the return value as a pointer if needed. */
3096 if (TREE_CODE (TREE_TYPE (exp
)) == POINTER_TYPE
)
3097 mark_reg_pointer (temp
,
3098 TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp
))));
3100 /* Construct an "equal form" for the value which mentions all the
3101 arguments in order as well as the function name. */
3102 for (i
= 0; i
< num_actuals
; i
++)
3103 note
= gen_rtx_EXPR_LIST (VOIDmode
,
3104 args
[i
].initial_value
, note
);
3105 note
= gen_rtx_EXPR_LIST (VOIDmode
, funexp
, note
);
3109 if (flags
& ECF_PURE
)
3110 note
= gen_rtx_EXPR_LIST (VOIDmode
,
3111 gen_rtx_USE (VOIDmode
,
3112 gen_rtx_MEM (BLKmode
,
3113 gen_rtx_SCRATCH (VOIDmode
))),
3116 emit_libcall_block (insns
, temp
, valreg
, note
);
3121 else if (pass
&& (flags
& ECF_MALLOC
))
3123 rtx temp
= gen_reg_rtx (GET_MODE (valreg
));
3126 /* The return value from a malloc-like function is a pointer. */
3127 if (TREE_CODE (TREE_TYPE (exp
)) == POINTER_TYPE
)
3128 mark_reg_pointer (temp
, BIGGEST_ALIGNMENT
);
3130 emit_move_insn (temp
, valreg
);
3132 /* The return value from a malloc-like function can not alias
3134 last
= get_last_insn ();
3136 gen_rtx_EXPR_LIST (REG_NOALIAS
, temp
, REG_NOTES (last
));
3138 /* Write out the sequence. */
3139 insns
= get_insns ();
3145 /* For calls to `setjmp', etc., inform flow.c it should complain
3146 if nonvolatile values are live. For functions that cannot return,
3147 inform flow that control does not fall through. */
3149 if ((flags
& (ECF_NORETURN
| ECF_LONGJMP
)) || pass
== 0)
3151 /* The barrier must be emitted
3152 immediately after the CALL_INSN. Some ports emit more
3153 than just a CALL_INSN above, so we must search for it here. */
3155 rtx last
= get_last_insn ();
3156 while (GET_CODE (last
) != CALL_INSN
)
3158 last
= PREV_INSN (last
);
3159 /* There was no CALL_INSN? */
3160 if (last
== before_call
)
3164 emit_barrier_after (last
);
3166 /* Stack adjustments after a noreturn call are dead code.
3167 However when NO_DEFER_POP is in effect, we must preserve
3168 stack_pointer_delta. */
3169 if (inhibit_defer_pop
== 0)
3171 stack_pointer_delta
= old_stack_allocated
;
3172 pending_stack_adjust
= 0;
3176 if (flags
& ECF_LONGJMP
)
3177 current_function_calls_longjmp
= 1;
3179 /* If value type not void, return an rtx for the value. */
3181 /* If there are cleanups to be called, don't use a hard reg as target.
3182 We need to double check this and see if it matters anymore. */
3183 if (any_pending_cleanups ())
3185 if (target
&& REG_P (target
)
3186 && REGNO (target
) < FIRST_PSEUDO_REGISTER
)
3188 sibcall_failure
= 1;
3191 if (TYPE_MODE (TREE_TYPE (exp
)) == VOIDmode
3193 target
= const0_rtx
;
3194 else if (structure_value_addr
)
3196 if (target
== 0 || GET_CODE (target
) != MEM
)
3199 = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp
)),
3200 memory_address (TYPE_MODE (TREE_TYPE (exp
)),
3201 structure_value_addr
));
3202 set_mem_attributes (target
, exp
, 1);
3205 else if (pcc_struct_value
)
3207 /* This is the special C++ case where we need to
3208 know what the true target was. We take care to
3209 never use this value more than once in one expression. */
3210 target
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp
)),
3211 copy_to_reg (valreg
));
3212 set_mem_attributes (target
, exp
, 1);
3214 /* Handle calls that return values in multiple non-contiguous locations.
3215 The Irix 6 ABI has examples of this. */
3216 else if (GET_CODE (valreg
) == PARALLEL
)
3220 /* This will only be assigned once, so it can be readonly. */
3221 tree nt
= build_qualified_type (TREE_TYPE (exp
),
3222 (TYPE_QUALS (TREE_TYPE (exp
))
3223 | TYPE_QUAL_CONST
));
3225 target
= assign_temp (nt
, 0, 1, 1);
3226 preserve_temp_slots (target
);
3229 if (! rtx_equal_p (target
, valreg
))
3230 emit_group_store (target
, valreg
, TREE_TYPE (exp
),
3231 int_size_in_bytes (TREE_TYPE (exp
)));
3233 /* We can not support sibling calls for this case. */
3234 sibcall_failure
= 1;
3237 && GET_MODE (target
) == TYPE_MODE (TREE_TYPE (exp
))
3238 && GET_MODE (target
) == GET_MODE (valreg
))
3240 /* TARGET and VALREG cannot be equal at this point because the
3241 latter would not have REG_FUNCTION_VALUE_P true, while the
3242 former would if it were referring to the same register.
3244 If they refer to the same register, this move will be a no-op,
3245 except when function inlining is being done. */
3246 emit_move_insn (target
, valreg
);
3248 /* If we are setting a MEM, this code must be executed. Since it is
3249 emitted after the call insn, sibcall optimization cannot be
3250 performed in that case. */
3251 if (GET_CODE (target
) == MEM
)
3252 sibcall_failure
= 1;
3254 else if (TYPE_MODE (TREE_TYPE (exp
)) == BLKmode
)
3256 target
= copy_blkmode_from_reg (target
, valreg
, TREE_TYPE (exp
));
3258 /* We can not support sibling calls for this case. */
3259 sibcall_failure
= 1;
3262 target
= copy_to_reg (valreg
);
3264 if (targetm
.calls
.promote_function_return(funtype
))
3266 /* If we promoted this return value, make the proper SUBREG. TARGET
3267 might be const0_rtx here, so be careful. */
3268 if (GET_CODE (target
) == REG
3269 && TYPE_MODE (TREE_TYPE (exp
)) != BLKmode
3270 && GET_MODE (target
) != TYPE_MODE (TREE_TYPE (exp
)))
3272 tree type
= TREE_TYPE (exp
);
3273 int unsignedp
= TREE_UNSIGNED (type
);
3276 /* If we don't promote as expected, something is wrong. */
3277 if (GET_MODE (target
)
3278 != promote_mode (type
, TYPE_MODE (type
), &unsignedp
, 1))
3281 if ((WORDS_BIG_ENDIAN
|| BYTES_BIG_ENDIAN
)
3282 && GET_MODE_SIZE (GET_MODE (target
))
3283 > GET_MODE_SIZE (TYPE_MODE (type
)))
3285 offset
= GET_MODE_SIZE (GET_MODE (target
))
3286 - GET_MODE_SIZE (TYPE_MODE (type
));
3287 if (! BYTES_BIG_ENDIAN
)
3288 offset
= (offset
/ UNITS_PER_WORD
) * UNITS_PER_WORD
;
3289 else if (! WORDS_BIG_ENDIAN
)
3290 offset
%= UNITS_PER_WORD
;
3292 target
= gen_rtx_SUBREG (TYPE_MODE (type
), target
, offset
);
3293 SUBREG_PROMOTED_VAR_P (target
) = 1;
3294 SUBREG_PROMOTED_UNSIGNED_SET (target
, unsignedp
);
3298 /* If size of args is variable or this was a constructor call for a stack
3299 argument, restore saved stack-pointer value. */
3301 if (old_stack_level
&& ! (flags
& ECF_SP_DEPRESSED
))
3303 emit_stack_restore (SAVE_BLOCK
, old_stack_level
, NULL_RTX
);
3304 stack_pointer_delta
= old_stack_pointer_delta
;
3305 pending_stack_adjust
= old_pending_adj
;
3306 stack_arg_under_construction
= old_stack_arg_under_construction
;
3307 highest_outgoing_arg_in_use
= initial_highest_arg_in_use
;
3308 stack_usage_map
= initial_stack_usage_map
;
3309 sibcall_failure
= 1;
3311 else if (ACCUMULATE_OUTGOING_ARGS
&& pass
)
3313 #ifdef REG_PARM_STACK_SPACE
3315 restore_fixed_argument_area (save_area
, argblock
,
3316 high_to_save
, low_to_save
);
3319 /* If we saved any argument areas, restore them. */
3320 for (i
= 0; i
< num_actuals
; i
++)
3321 if (args
[i
].save_area
)
3323 enum machine_mode save_mode
= GET_MODE (args
[i
].save_area
);
3325 = gen_rtx_MEM (save_mode
,
3326 memory_address (save_mode
,
3327 XEXP (args
[i
].stack_slot
, 0)));
3329 if (save_mode
!= BLKmode
)
3330 emit_move_insn (stack_area
, args
[i
].save_area
);
3332 emit_block_move (stack_area
, args
[i
].save_area
,
3333 GEN_INT (args
[i
].locate
.size
.constant
),
3334 BLOCK_OP_CALL_PARM
);
3337 highest_outgoing_arg_in_use
= initial_highest_arg_in_use
;
3338 stack_usage_map
= initial_stack_usage_map
;
3341 /* If this was alloca, record the new stack level for nonlocal gotos.
3342 Check for the handler slots since we might not have a save area
3343 for non-local gotos. */
3345 if ((flags
& ECF_MAY_BE_ALLOCA
) && nonlocal_goto_handler_slots
!= 0)
3346 emit_stack_save (SAVE_NONLOCAL
, &nonlocal_goto_stack_level
, NULL_RTX
);
3348 /* Free up storage we no longer need. */
3349 for (i
= 0; i
< num_actuals
; ++i
)
3350 if (args
[i
].aligned_regs
)
3351 free (args
[i
].aligned_regs
);
3355 /* Undo the fake expand_start_target_temps we did earlier. If
3356 there had been any cleanups created, we've already set
3358 expand_end_target_temps ();
3361 /* If this function is returning into a memory location marked as
3362 readonly, it means it is initializing that location. We normally treat
3363 functions as not clobbering such locations, so we need to specify that
3364 this one does. We do this by adding the appropriate CLOBBER to the
3365 CALL_INSN function usage list. This cannot be done by emitting a
3366 standalone CLOBBER after the call because the latter would be ignored
3367 by at least the delay slot scheduling pass. We do this now instead of
3368 adding to call_fusage before the call to emit_call_1 because TARGET
3369 may be modified in the meantime. */
3370 if (structure_value_addr
!= 0 && target
!= 0
3371 && GET_CODE (target
) == MEM
&& RTX_UNCHANGING_P (target
))
3372 add_function_usage_to
3374 gen_rtx_EXPR_LIST (VOIDmode
, gen_rtx_CLOBBER (VOIDmode
, target
),
3377 insns
= get_insns ();
3382 tail_call_insns
= insns
;
3384 /* Restore the pending stack adjustment now that we have
3385 finished generating the sibling call sequence. */
3387 pending_stack_adjust
= save_pending_stack_adjust
;
3388 stack_pointer_delta
= save_stack_pointer_delta
;
3390 /* Prepare arg structure for next iteration. */
3391 for (i
= 0; i
< num_actuals
; i
++)
3394 args
[i
].aligned_regs
= 0;
3398 sbitmap_free (stored_args_map
);
3402 normal_call_insns
= insns
;
3404 /* Verify that we've deallocated all the stack we used. */
3405 if (! (flags
& (ECF_NORETURN
| ECF_LONGJMP
))
3406 && old_stack_allocated
!= stack_pointer_delta
3407 - pending_stack_adjust
)
3411 /* If something prevents making this a sibling call,
3412 zero out the sequence. */
3413 if (sibcall_failure
)
3414 tail_call_insns
= NULL_RTX
;
3417 /* The function optimize_sibling_and_tail_recursive_calls doesn't
3418 handle CALL_PLACEHOLDERs inside other CALL_PLACEHOLDERs. This
3419 can happen if the arguments to this function call an inline
3420 function who's expansion contains another CALL_PLACEHOLDER.
3422 If there are any C_Ps in any of these sequences, replace them
3423 with their normal call. */
3425 for (insn
= normal_call_insns
; insn
; insn
= NEXT_INSN (insn
))
3426 if (GET_CODE (insn
) == CALL_INSN
3427 && GET_CODE (PATTERN (insn
)) == CALL_PLACEHOLDER
)
3428 replace_call_placeholder (insn
, sibcall_use_normal
);
3430 for (insn
= tail_call_insns
; insn
; insn
= NEXT_INSN (insn
))
3431 if (GET_CODE (insn
) == CALL_INSN
3432 && GET_CODE (PATTERN (insn
)) == CALL_PLACEHOLDER
)
3433 replace_call_placeholder (insn
, sibcall_use_normal
);
3435 for (insn
= tail_recursion_insns
; insn
; insn
= NEXT_INSN (insn
))
3436 if (GET_CODE (insn
) == CALL_INSN
3437 && GET_CODE (PATTERN (insn
)) == CALL_PLACEHOLDER
)
3438 replace_call_placeholder (insn
, sibcall_use_normal
);
3440 /* If this was a potential tail recursion site, then emit a
3441 CALL_PLACEHOLDER with the normal and the tail recursion streams.
3442 One of them will be selected later. */
3443 if (tail_recursion_insns
|| tail_call_insns
)
3445 /* The tail recursion label must be kept around. We could expose
3446 its use in the CALL_PLACEHOLDER, but that creates unwanted edges
3447 and makes determining true tail recursion sites difficult.
3449 So we set LABEL_PRESERVE_P here, then clear it when we select
3450 one of the call sequences after rtl generation is complete. */
3451 if (tail_recursion_insns
)
3452 LABEL_PRESERVE_P (tail_recursion_label
) = 1;
3453 emit_call_insn (gen_rtx_CALL_PLACEHOLDER (VOIDmode
, normal_call_insns
,
3455 tail_recursion_insns
,
3456 tail_recursion_label
));
3459 emit_insn (normal_call_insns
);
3461 currently_expanding_call
--;
3463 /* If this function returns with the stack pointer depressed, ensure
3464 this block saves and restores the stack pointer, show it was
3465 changed, and adjust for any outgoing arg space. */
3466 if (flags
& ECF_SP_DEPRESSED
)
3468 clear_pending_stack_adjust ();
3469 emit_insn (gen_rtx (CLOBBER
, VOIDmode
, stack_pointer_rtx
));
3470 emit_move_insn (virtual_stack_dynamic_rtx
, stack_pointer_rtx
);
3471 save_stack_pointer ();
3477 /* Traverse an argument list in VALUES and expand all complex
3478 arguments into their components. */
3480 split_complex_values (tree values
)
3484 values
= copy_list (values
);
3486 for (p
= values
; p
; p
= TREE_CHAIN (p
))
3488 tree complex_value
= TREE_VALUE (p
);
3491 complex_type
= TREE_TYPE (complex_value
);
3495 if (TREE_CODE (complex_type
) == COMPLEX_TYPE
)
3498 tree real
, imag
, next
;
3500 subtype
= TREE_TYPE (complex_type
);
3501 complex_value
= save_expr (complex_value
);
3502 real
= build1 (REALPART_EXPR
, subtype
, complex_value
);
3503 imag
= build1 (IMAGPART_EXPR
, subtype
, complex_value
);
3505 TREE_VALUE (p
) = real
;
3506 next
= TREE_CHAIN (p
);
3507 imag
= build_tree_list (NULL_TREE
, imag
);
3508 TREE_CHAIN (p
) = imag
;
3509 TREE_CHAIN (imag
) = next
;
3511 /* Skip the newly created node. */
3519 /* Traverse a list of TYPES and expand all complex types into their
3522 split_complex_types (tree types
)
3526 types
= copy_list (types
);
3528 for (p
= types
; p
; p
= TREE_CHAIN (p
))
3530 tree complex_type
= TREE_VALUE (p
);
3532 if (TREE_CODE (complex_type
) == COMPLEX_TYPE
)
3536 /* Rewrite complex type with component type. */
3537 TREE_VALUE (p
) = TREE_TYPE (complex_type
);
3538 next
= TREE_CHAIN (p
);
3540 /* Add another component type for the imaginary part. */
3541 imag
= build_tree_list (NULL_TREE
, TREE_VALUE (p
));
3542 TREE_CHAIN (p
) = imag
;
3543 TREE_CHAIN (imag
) = next
;
3545 /* Skip the newly created node. */
3553 /* Output a library call to function FUN (a SYMBOL_REF rtx).
3554 The RETVAL parameter specifies whether return value needs to be saved, other
3555 parameters are documented in the emit_library_call function below. */
3558 emit_library_call_value_1 (int retval
, rtx orgfun
, rtx value
,
3559 enum libcall_type fn_type
,
3560 enum machine_mode outmode
, int nargs
, va_list p
)
3562 /* Total size in bytes of all the stack-parms scanned so far. */
3563 struct args_size args_size
;
3564 /* Size of arguments before any adjustments (such as rounding). */
3565 struct args_size original_args_size
;
3571 CUMULATIVE_ARGS args_so_far
;
3575 enum machine_mode mode
;
3578 struct locate_and_pad_arg_data locate
;
3582 int old_inhibit_defer_pop
= inhibit_defer_pop
;
3583 rtx call_fusage
= 0;
3586 int pcc_struct_value
= 0;
3587 int struct_value_size
= 0;
3589 int reg_parm_stack_space
= 0;
3592 tree tfom
; /* type_for_mode (outmode, 0) */
3594 #ifdef REG_PARM_STACK_SPACE
3595 /* Define the boundary of the register parm stack space that needs to be
3597 int low_to_save
, high_to_save
;
3598 rtx save_area
= 0; /* Place that it is saved. */
3601 /* Size of the stack reserved for parameter registers. */
3602 int initial_highest_arg_in_use
= highest_outgoing_arg_in_use
;
3603 char *initial_stack_usage_map
= stack_usage_map
;
3605 rtx struct_value
= targetm
.calls
.struct_value_rtx (0, 0);
3607 #ifdef REG_PARM_STACK_SPACE
3608 #ifdef MAYBE_REG_PARM_STACK_SPACE
3609 reg_parm_stack_space
= MAYBE_REG_PARM_STACK_SPACE
;
3611 reg_parm_stack_space
= REG_PARM_STACK_SPACE ((tree
) 0);
3615 /* By default, library functions can not throw. */
3616 flags
= ECF_NOTHROW
;
3628 case LCT_CONST_MAKE_BLOCK
:
3629 flags
|= ECF_CONST
| ECF_LIBCALL_BLOCK
;
3631 case LCT_PURE_MAKE_BLOCK
:
3632 flags
|= ECF_PURE
| ECF_LIBCALL_BLOCK
;
3635 flags
|= ECF_NORETURN
;
3638 flags
= ECF_NORETURN
;
3640 case LCT_ALWAYS_RETURN
:
3641 flags
= ECF_ALWAYS_RETURN
;
3643 case LCT_RETURNS_TWICE
:
3644 flags
= ECF_RETURNS_TWICE
;
3649 /* Ensure current function's preferred stack boundary is at least
3651 if (cfun
->preferred_stack_boundary
< PREFERRED_STACK_BOUNDARY
)
3652 cfun
->preferred_stack_boundary
= PREFERRED_STACK_BOUNDARY
;
3654 /* If this kind of value comes back in memory,
3655 decide where in memory it should come back. */
3656 if (outmode
!= VOIDmode
)
3658 tfom
= (*lang_hooks
.types
.type_for_mode
) (outmode
, 0);
3659 if (aggregate_value_p (tfom
, 0))
3661 #ifdef PCC_STATIC_STRUCT_RETURN
3663 = hard_function_value (build_pointer_type (tfom
), 0, 0);
3664 mem_value
= gen_rtx_MEM (outmode
, pointer_reg
);
3665 pcc_struct_value
= 1;
3667 value
= gen_reg_rtx (outmode
);
3668 #else /* not PCC_STATIC_STRUCT_RETURN */
3669 struct_value_size
= GET_MODE_SIZE (outmode
);
3670 if (value
!= 0 && GET_CODE (value
) == MEM
)
3673 mem_value
= assign_temp (tfom
, 0, 1, 1);
3675 /* This call returns a big structure. */
3676 flags
&= ~(ECF_CONST
| ECF_PURE
| ECF_LIBCALL_BLOCK
);
3680 tfom
= void_type_node
;
3682 /* ??? Unfinished: must pass the memory address as an argument. */
3684 /* Copy all the libcall-arguments out of the varargs data
3685 and into a vector ARGVEC.
3687 Compute how to pass each argument. We only support a very small subset
3688 of the full argument passing conventions to limit complexity here since
3689 library functions shouldn't have many args. */
3691 argvec
= alloca ((nargs
+ 1) * sizeof (struct arg
));
3692 memset (argvec
, 0, (nargs
+ 1) * sizeof (struct arg
));
3694 #ifdef INIT_CUMULATIVE_LIBCALL_ARGS
3695 INIT_CUMULATIVE_LIBCALL_ARGS (args_so_far
, outmode
, fun
);
3697 INIT_CUMULATIVE_ARGS (args_so_far
, NULL_TREE
, fun
, 0);
3700 args_size
.constant
= 0;
3705 /* Now we are about to start emitting insns that can be deleted
3706 if a libcall is deleted. */
3707 if (flags
& ECF_LIBCALL_BLOCK
)
3712 /* If there's a structure value address to be passed,
3713 either pass it in the special place, or pass it as an extra argument. */
3714 if (mem_value
&& struct_value
== 0 && ! pcc_struct_value
)
3716 rtx addr
= XEXP (mem_value
, 0);
3719 /* Make sure it is a reasonable operand for a move or push insn. */
3720 if (GET_CODE (addr
) != REG
&& GET_CODE (addr
) != MEM
3721 && ! (CONSTANT_P (addr
) && LEGITIMATE_CONSTANT_P (addr
)))
3722 addr
= force_operand (addr
, NULL_RTX
);
3724 argvec
[count
].value
= addr
;
3725 argvec
[count
].mode
= Pmode
;
3726 argvec
[count
].partial
= 0;
3728 argvec
[count
].reg
= FUNCTION_ARG (args_so_far
, Pmode
, NULL_TREE
, 1);
3729 #ifdef FUNCTION_ARG_PARTIAL_NREGS
3730 if (FUNCTION_ARG_PARTIAL_NREGS (args_so_far
, Pmode
, NULL_TREE
, 1))
3734 locate_and_pad_parm (Pmode
, NULL_TREE
,
3735 #ifdef STACK_PARMS_IN_REG_PARM_AREA
3738 argvec
[count
].reg
!= 0,
3740 0, NULL_TREE
, &args_size
, &argvec
[count
].locate
);
3742 if (argvec
[count
].reg
== 0 || argvec
[count
].partial
!= 0
3743 || reg_parm_stack_space
> 0)
3744 args_size
.constant
+= argvec
[count
].locate
.size
.constant
;
3746 FUNCTION_ARG_ADVANCE (args_so_far
, Pmode
, (tree
) 0, 1);
3751 for (; count
< nargs
; count
++)
3753 rtx val
= va_arg (p
, rtx
);
3754 enum machine_mode mode
= va_arg (p
, enum machine_mode
);
3756 /* We cannot convert the arg value to the mode the library wants here;
3757 must do it earlier where we know the signedness of the arg. */
3759 || (GET_MODE (val
) != mode
&& GET_MODE (val
) != VOIDmode
))
3762 /* There's no need to call protect_from_queue, because
3763 either emit_move_insn or emit_push_insn will do that. */
3765 /* Make sure it is a reasonable operand for a move or push insn. */
3766 if (GET_CODE (val
) != REG
&& GET_CODE (val
) != MEM
3767 && ! (CONSTANT_P (val
) && LEGITIMATE_CONSTANT_P (val
)))
3768 val
= force_operand (val
, NULL_RTX
);
3770 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
3771 if (FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far
, mode
, NULL_TREE
, 1))
3775 #ifdef FUNCTION_ARG_CALLEE_COPIES
3776 && ! FUNCTION_ARG_CALLEE_COPIES (args_so_far
, mode
,
3781 /* loop.c won't look at CALL_INSN_FUNCTION_USAGE of const/pure
3782 functions, so we have to pretend this isn't such a function. */
3783 if (flags
& ECF_LIBCALL_BLOCK
)
3785 rtx insns
= get_insns ();
3789 flags
&= ~(ECF_CONST
| ECF_PURE
| ECF_LIBCALL_BLOCK
);
3791 /* If this was a CONST function, it is now PURE since
3792 it now reads memory. */
3793 if (flags
& ECF_CONST
)
3795 flags
&= ~ECF_CONST
;
3799 if (GET_MODE (val
) == MEM
&& ! must_copy
)
3803 slot
= assign_temp ((*lang_hooks
.types
.type_for_mode
) (mode
, 0),
3805 emit_move_insn (slot
, val
);
3809 tree type
= (*lang_hooks
.types
.type_for_mode
) (mode
, 0);
3812 = gen_rtx_MEM (mode
,
3813 expand_expr (build1 (ADDR_EXPR
,
3814 build_pointer_type (type
),
3815 make_tree (type
, val
)),
3816 NULL_RTX
, VOIDmode
, 0));
3819 call_fusage
= gen_rtx_EXPR_LIST (VOIDmode
,
3820 gen_rtx_USE (VOIDmode
, slot
),
3823 call_fusage
= gen_rtx_EXPR_LIST (VOIDmode
,
3824 gen_rtx_CLOBBER (VOIDmode
,
3829 val
= force_operand (XEXP (slot
, 0), NULL_RTX
);
3833 argvec
[count
].value
= val
;
3834 argvec
[count
].mode
= mode
;
3836 argvec
[count
].reg
= FUNCTION_ARG (args_so_far
, mode
, NULL_TREE
, 1);
3838 #ifdef FUNCTION_ARG_PARTIAL_NREGS
3839 argvec
[count
].partial
3840 = FUNCTION_ARG_PARTIAL_NREGS (args_so_far
, mode
, NULL_TREE
, 1);
3842 argvec
[count
].partial
= 0;
3845 locate_and_pad_parm (mode
, NULL_TREE
,
3846 #ifdef STACK_PARMS_IN_REG_PARM_AREA
3849 argvec
[count
].reg
!= 0,
3851 argvec
[count
].partial
,
3852 NULL_TREE
, &args_size
, &argvec
[count
].locate
);
3854 if (argvec
[count
].locate
.size
.var
)
3857 if (argvec
[count
].reg
== 0 || argvec
[count
].partial
!= 0
3858 || reg_parm_stack_space
> 0)
3859 args_size
.constant
+= argvec
[count
].locate
.size
.constant
;
3861 FUNCTION_ARG_ADVANCE (args_so_far
, mode
, (tree
) 0, 1);
3864 #ifdef FINAL_REG_PARM_STACK_SPACE
3865 reg_parm_stack_space
= FINAL_REG_PARM_STACK_SPACE (args_size
.constant
,
3868 /* If this machine requires an external definition for library
3869 functions, write one out. */
3870 assemble_external_libcall (fun
);
3872 original_args_size
= args_size
;
3873 args_size
.constant
= (((args_size
.constant
3874 + stack_pointer_delta
3878 - stack_pointer_delta
);
3880 args_size
.constant
= MAX (args_size
.constant
,
3881 reg_parm_stack_space
);
3883 #ifndef OUTGOING_REG_PARM_STACK_SPACE
3884 args_size
.constant
-= reg_parm_stack_space
;
3887 if (args_size
.constant
> current_function_outgoing_args_size
)
3888 current_function_outgoing_args_size
= args_size
.constant
;
3890 if (ACCUMULATE_OUTGOING_ARGS
)
3892 /* Since the stack pointer will never be pushed, it is possible for
3893 the evaluation of a parm to clobber something we have already
3894 written to the stack. Since most function calls on RISC machines
3895 do not use the stack, this is uncommon, but must work correctly.
3897 Therefore, we save any area of the stack that was already written
3898 and that we are using. Here we set up to do this by making a new
3899 stack usage map from the old one.
3901 Another approach might be to try to reorder the argument
3902 evaluations to avoid this conflicting stack usage. */
3904 needed
= args_size
.constant
;
3906 #ifndef OUTGOING_REG_PARM_STACK_SPACE
3907 /* Since we will be writing into the entire argument area, the
3908 map must be allocated for its entire size, not just the part that
3909 is the responsibility of the caller. */
3910 needed
+= reg_parm_stack_space
;
3913 #ifdef ARGS_GROW_DOWNWARD
3914 highest_outgoing_arg_in_use
= MAX (initial_highest_arg_in_use
,
3917 highest_outgoing_arg_in_use
= MAX (initial_highest_arg_in_use
,
3920 stack_usage_map
= alloca (highest_outgoing_arg_in_use
);
3922 if (initial_highest_arg_in_use
)
3923 memcpy (stack_usage_map
, initial_stack_usage_map
,
3924 initial_highest_arg_in_use
);
3926 if (initial_highest_arg_in_use
!= highest_outgoing_arg_in_use
)
3927 memset (&stack_usage_map
[initial_highest_arg_in_use
], 0,
3928 highest_outgoing_arg_in_use
- initial_highest_arg_in_use
);
3931 /* We must be careful to use virtual regs before they're instantiated,
3932 and real regs afterwards. Loop optimization, for example, can create
3933 new libcalls after we've instantiated the virtual regs, and if we
3934 use virtuals anyway, they won't match the rtl patterns. */
3936 if (virtuals_instantiated
)
3937 argblock
= plus_constant (stack_pointer_rtx
, STACK_POINTER_OFFSET
);
3939 argblock
= virtual_outgoing_args_rtx
;
3944 argblock
= push_block (GEN_INT (args_size
.constant
), 0, 0);
3947 /* If we push args individually in reverse order, perform stack alignment
3948 before the first push (the last arg). */
3949 if (argblock
== 0 && PUSH_ARGS_REVERSED
)
3950 anti_adjust_stack (GEN_INT (args_size
.constant
3951 - original_args_size
.constant
));
3953 if (PUSH_ARGS_REVERSED
)
3964 #ifdef REG_PARM_STACK_SPACE
3965 if (ACCUMULATE_OUTGOING_ARGS
)
3967 /* The argument list is the property of the called routine and it
3968 may clobber it. If the fixed area has been used for previous
3969 parameters, we must save and restore it. */
3970 save_area
= save_fixed_argument_area (reg_parm_stack_space
, argblock
,
3971 &low_to_save
, &high_to_save
);
3975 /* Push the args that need to be pushed. */
3977 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
3978 are to be pushed. */
3979 for (count
= 0; count
< nargs
; count
++, argnum
+= inc
)
3981 enum machine_mode mode
= argvec
[argnum
].mode
;
3982 rtx val
= argvec
[argnum
].value
;
3983 rtx reg
= argvec
[argnum
].reg
;
3984 int partial
= argvec
[argnum
].partial
;
3985 int lower_bound
= 0, upper_bound
= 0, i
;
3987 if (! (reg
!= 0 && partial
== 0))
3989 if (ACCUMULATE_OUTGOING_ARGS
)
3991 /* If this is being stored into a pre-allocated, fixed-size,
3992 stack area, save any previous data at that location. */
3994 #ifdef ARGS_GROW_DOWNWARD
3995 /* stack_slot is negative, but we want to index stack_usage_map
3996 with positive values. */
3997 upper_bound
= -argvec
[argnum
].locate
.offset
.constant
+ 1;
3998 lower_bound
= upper_bound
- argvec
[argnum
].locate
.size
.constant
;
4000 lower_bound
= argvec
[argnum
].locate
.offset
.constant
;
4001 upper_bound
= lower_bound
+ argvec
[argnum
].locate
.size
.constant
;
4005 /* Don't worry about things in the fixed argument area;
4006 it has already been saved. */
4007 if (i
< reg_parm_stack_space
)
4008 i
= reg_parm_stack_space
;
4009 while (i
< upper_bound
&& stack_usage_map
[i
] == 0)
4012 if (i
< upper_bound
)
4014 /* We need to make a save area. */
4016 = argvec
[argnum
].locate
.size
.constant
* BITS_PER_UNIT
;
4017 enum machine_mode save_mode
4018 = mode_for_size (size
, MODE_INT
, 1);
4020 = plus_constant (argblock
,
4021 argvec
[argnum
].locate
.offset
.constant
);
4023 = gen_rtx_MEM (save_mode
, memory_address (save_mode
, adr
));
4025 if (save_mode
== BLKmode
)
4027 argvec
[argnum
].save_area
4028 = assign_stack_temp (BLKmode
,
4029 argvec
[argnum
].locate
.size
.constant
,
4032 emit_block_move (validize_mem (argvec
[argnum
].save_area
),
4034 GEN_INT (argvec
[argnum
].locate
.size
.constant
),
4035 BLOCK_OP_CALL_PARM
);
4039 argvec
[argnum
].save_area
= gen_reg_rtx (save_mode
);
4041 emit_move_insn (argvec
[argnum
].save_area
, stack_area
);
4046 emit_push_insn (val
, mode
, NULL_TREE
, NULL_RTX
, PARM_BOUNDARY
,
4047 partial
, reg
, 0, argblock
,
4048 GEN_INT (argvec
[argnum
].locate
.offset
.constant
),
4049 reg_parm_stack_space
,
4050 ARGS_SIZE_RTX (argvec
[argnum
].locate
.alignment_pad
));
4052 /* Now mark the segment we just used. */
4053 if (ACCUMULATE_OUTGOING_ARGS
)
4054 for (i
= lower_bound
; i
< upper_bound
; i
++)
4055 stack_usage_map
[i
] = 1;
4061 /* If we pushed args in forward order, perform stack alignment
4062 after pushing the last arg. */
4063 if (argblock
== 0 && !PUSH_ARGS_REVERSED
)
4064 anti_adjust_stack (GEN_INT (args_size
.constant
4065 - original_args_size
.constant
));
4067 if (PUSH_ARGS_REVERSED
)
4072 fun
= prepare_call_address (fun
, NULL_TREE
, &call_fusage
, 0, 0);
4074 /* Now load any reg parms into their regs. */
4076 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
4077 are to be pushed. */
4078 for (count
= 0; count
< nargs
; count
++, argnum
+= inc
)
4080 rtx val
= argvec
[argnum
].value
;
4081 rtx reg
= argvec
[argnum
].reg
;
4082 int partial
= argvec
[argnum
].partial
;
4084 /* Handle calls that pass values in multiple non-contiguous
4085 locations. The PA64 has examples of this for library calls. */
4086 if (reg
!= 0 && GET_CODE (reg
) == PARALLEL
)
4087 emit_group_load (reg
, val
, NULL_TREE
, GET_MODE_SIZE (GET_MODE (val
)));
4088 else if (reg
!= 0 && partial
== 0)
4089 emit_move_insn (reg
, val
);
4094 /* Any regs containing parms remain in use through the call. */
4095 for (count
= 0; count
< nargs
; count
++)
4097 rtx reg
= argvec
[count
].reg
;
4098 if (reg
!= 0 && GET_CODE (reg
) == PARALLEL
)
4099 use_group_regs (&call_fusage
, reg
);
4101 use_reg (&call_fusage
, reg
);
4104 /* Pass the function the address in which to return a structure value. */
4105 if (mem_value
!= 0 && struct_value
!= 0 && ! pcc_struct_value
)
4107 emit_move_insn (struct_value
,
4109 force_operand (XEXP (mem_value
, 0),
4111 if (GET_CODE (struct_value
) == REG
)
4112 use_reg (&call_fusage
, struct_value
);
4115 /* Don't allow popping to be deferred, since then
4116 cse'ing of library calls could delete a call and leave the pop. */
4118 valreg
= (mem_value
== 0 && outmode
!= VOIDmode
4119 ? hard_libcall_value (outmode
) : NULL_RTX
);
4121 /* Stack must be properly aligned now. */
4122 if (stack_pointer_delta
& (PREFERRED_STACK_BOUNDARY
/ BITS_PER_UNIT
- 1))
4125 before_call
= get_last_insn ();
4127 /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
4128 will set inhibit_defer_pop to that value. */
4129 /* The return type is needed to decide how many bytes the function pops.
4130 Signedness plays no role in that, so for simplicity, we pretend it's
4131 always signed. We also assume that the list of arguments passed has
4132 no impact, so we pretend it is unknown. */
4135 get_identifier (XSTR (orgfun
, 0)),
4136 build_function_type (tfom
, NULL_TREE
),
4137 original_args_size
.constant
, args_size
.constant
,
4139 FUNCTION_ARG (args_so_far
, VOIDmode
, void_type_node
, 1),
4141 old_inhibit_defer_pop
+ 1, call_fusage
, flags
, & args_so_far
);
4143 /* For calls to `setjmp', etc., inform flow.c it should complain
4144 if nonvolatile values are live. For functions that cannot return,
4145 inform flow that control does not fall through. */
4147 if (flags
& (ECF_NORETURN
| ECF_LONGJMP
))
4149 /* The barrier note must be emitted
4150 immediately after the CALL_INSN. Some ports emit more than
4151 just a CALL_INSN above, so we must search for it here. */
4153 rtx last
= get_last_insn ();
4154 while (GET_CODE (last
) != CALL_INSN
)
4156 last
= PREV_INSN (last
);
4157 /* There was no CALL_INSN? */
4158 if (last
== before_call
)
4162 emit_barrier_after (last
);
4165 /* Now restore inhibit_defer_pop to its actual original value. */
4168 /* If call is cse'able, make appropriate pair of reg-notes around it.
4169 Test valreg so we don't crash; may safely ignore `const'
4170 if return type is void. Disable for PARALLEL return values, because
4171 we have no way to move such values into a pseudo register. */
4172 if (flags
& ECF_LIBCALL_BLOCK
)
4178 insns
= get_insns ();
4188 if (GET_CODE (valreg
) == PARALLEL
)
4190 temp
= gen_reg_rtx (outmode
);
4191 emit_group_store (temp
, valreg
, NULL_TREE
,
4192 GET_MODE_SIZE (outmode
));
4196 temp
= gen_reg_rtx (GET_MODE (valreg
));
4198 /* Construct an "equal form" for the value which mentions all the
4199 arguments in order as well as the function name. */
4200 for (i
= 0; i
< nargs
; i
++)
4201 note
= gen_rtx_EXPR_LIST (VOIDmode
, argvec
[i
].value
, note
);
4202 note
= gen_rtx_EXPR_LIST (VOIDmode
, fun
, note
);
4204 insns
= get_insns ();
4207 if (flags
& ECF_PURE
)
4208 note
= gen_rtx_EXPR_LIST (VOIDmode
,
4209 gen_rtx_USE (VOIDmode
,
4210 gen_rtx_MEM (BLKmode
,
4211 gen_rtx_SCRATCH (VOIDmode
))),
4214 emit_libcall_block (insns
, temp
, valreg
, note
);
4221 /* Copy the value to the right place. */
4222 if (outmode
!= VOIDmode
&& retval
)
4228 if (value
!= mem_value
)
4229 emit_move_insn (value
, mem_value
);
4231 else if (GET_CODE (valreg
) == PARALLEL
)
4234 value
= gen_reg_rtx (outmode
);
4235 emit_group_store (value
, valreg
, NULL_TREE
, GET_MODE_SIZE (outmode
));
4237 else if (value
!= 0)
4238 emit_move_insn (value
, valreg
);
4243 if (ACCUMULATE_OUTGOING_ARGS
)
4245 #ifdef REG_PARM_STACK_SPACE
4247 restore_fixed_argument_area (save_area
, argblock
,
4248 high_to_save
, low_to_save
);
4251 /* If we saved any argument areas, restore them. */
4252 for (count
= 0; count
< nargs
; count
++)
4253 if (argvec
[count
].save_area
)
4255 enum machine_mode save_mode
= GET_MODE (argvec
[count
].save_area
);
4256 rtx adr
= plus_constant (argblock
,
4257 argvec
[count
].locate
.offset
.constant
);
4258 rtx stack_area
= gen_rtx_MEM (save_mode
,
4259 memory_address (save_mode
, adr
));
4261 if (save_mode
== BLKmode
)
4262 emit_block_move (stack_area
,
4263 validize_mem (argvec
[count
].save_area
),
4264 GEN_INT (argvec
[count
].locate
.size
.constant
),
4265 BLOCK_OP_CALL_PARM
);
4267 emit_move_insn (stack_area
, argvec
[count
].save_area
);
4270 highest_outgoing_arg_in_use
= initial_highest_arg_in_use
;
4271 stack_usage_map
= initial_stack_usage_map
;
4278 /* Output a library call to function FUN (a SYMBOL_REF rtx)
4279 (emitting the queue unless NO_QUEUE is nonzero),
4280 for a value of mode OUTMODE,
4281 with NARGS different arguments, passed as alternating rtx values
4282 and machine_modes to convert them to.
4283 The rtx values should have been passed through protect_from_queue already.
4285 FN_TYPE should be LCT_NORMAL for `normal' calls, LCT_CONST for `const'
4286 calls, LCT_PURE for `pure' calls, LCT_CONST_MAKE_BLOCK for `const' calls
4287 which should be enclosed in REG_LIBCALL/REG_RETVAL notes,
4288 LCT_PURE_MAKE_BLOCK for `purep' calls which should be enclosed in
4289 REG_LIBCALL/REG_RETVAL notes with extra (use (memory (scratch)),
4290 or other LCT_ value for other types of library calls. */
4293 emit_library_call (rtx orgfun
, enum libcall_type fn_type
,
4294 enum machine_mode outmode
, int nargs
, ...)
4298 va_start (p
, nargs
);
4299 emit_library_call_value_1 (0, orgfun
, NULL_RTX
, fn_type
, outmode
, nargs
, p
);
4303 /* Like emit_library_call except that an extra argument, VALUE,
4304 comes second and says where to store the result.
4305 (If VALUE is zero, this function chooses a convenient way
4306 to return the value.
4308 This function returns an rtx for where the value is to be found.
4309 If VALUE is nonzero, VALUE is returned. */
4312 emit_library_call_value (rtx orgfun
, rtx value
,
4313 enum libcall_type fn_type
,
4314 enum machine_mode outmode
, int nargs
, ...)
4319 va_start (p
, nargs
);
4320 result
= emit_library_call_value_1 (1, orgfun
, value
, fn_type
, outmode
,
4327 /* Store a single argument for a function call
4328 into the register or memory area where it must be passed.
4329 *ARG describes the argument value and where to pass it.
4331 ARGBLOCK is the address of the stack-block for all the arguments,
4332 or 0 on a machine where arguments are pushed individually.
4334 MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
4335 so must be careful about how the stack is used.
4337 VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
4338 argument stack. This is used if ACCUMULATE_OUTGOING_ARGS to indicate
4339 that we need not worry about saving and restoring the stack.
4341 FNDECL is the declaration of the function we are calling.
4343 Return nonzero if this arg should cause sibcall failure,
4347 store_one_arg (struct arg_data
*arg
, rtx argblock
, int flags
,
4348 int variable_size ATTRIBUTE_UNUSED
, int reg_parm_stack_space
)
4350 tree pval
= arg
->tree_value
;
4354 int i
, lower_bound
= 0, upper_bound
= 0;
4355 int sibcall_failure
= 0;
4357 if (TREE_CODE (pval
) == ERROR_MARK
)
4360 /* Push a new temporary level for any temporaries we make for
4364 if (ACCUMULATE_OUTGOING_ARGS
&& !(flags
& ECF_SIBCALL
))
4366 /* If this is being stored into a pre-allocated, fixed-size, stack area,
4367 save any previous data at that location. */
4368 if (argblock
&& ! variable_size
&& arg
->stack
)
4370 #ifdef ARGS_GROW_DOWNWARD
4371 /* stack_slot is negative, but we want to index stack_usage_map
4372 with positive values. */
4373 if (GET_CODE (XEXP (arg
->stack_slot
, 0)) == PLUS
)
4374 upper_bound
= -INTVAL (XEXP (XEXP (arg
->stack_slot
, 0), 1)) + 1;
4378 lower_bound
= upper_bound
- arg
->locate
.size
.constant
;
4380 if (GET_CODE (XEXP (arg
->stack_slot
, 0)) == PLUS
)
4381 lower_bound
= INTVAL (XEXP (XEXP (arg
->stack_slot
, 0), 1));
4385 upper_bound
= lower_bound
+ arg
->locate
.size
.constant
;
4389 /* Don't worry about things in the fixed argument area;
4390 it has already been saved. */
4391 if (i
< reg_parm_stack_space
)
4392 i
= reg_parm_stack_space
;
4393 while (i
< upper_bound
&& stack_usage_map
[i
] == 0)
4396 if (i
< upper_bound
)
4398 /* We need to make a save area. */
4399 unsigned int size
= arg
->locate
.size
.constant
* BITS_PER_UNIT
;
4400 enum machine_mode save_mode
= mode_for_size (size
, MODE_INT
, 1);
4401 rtx adr
= memory_address (save_mode
, XEXP (arg
->stack_slot
, 0));
4402 rtx stack_area
= gen_rtx_MEM (save_mode
, adr
);
4404 if (save_mode
== BLKmode
)
4406 tree ot
= TREE_TYPE (arg
->tree_value
);
4407 tree nt
= build_qualified_type (ot
, (TYPE_QUALS (ot
)
4408 | TYPE_QUAL_CONST
));
4410 arg
->save_area
= assign_temp (nt
, 0, 1, 1);
4411 preserve_temp_slots (arg
->save_area
);
4412 emit_block_move (validize_mem (arg
->save_area
), stack_area
,
4413 expr_size (arg
->tree_value
),
4414 BLOCK_OP_CALL_PARM
);
4418 arg
->save_area
= gen_reg_rtx (save_mode
);
4419 emit_move_insn (arg
->save_area
, stack_area
);
4425 /* If this isn't going to be placed on both the stack and in registers,
4426 set up the register and number of words. */
4427 if (! arg
->pass_on_stack
)
4429 if (flags
& ECF_SIBCALL
)
4430 reg
= arg
->tail_call_reg
;
4433 partial
= arg
->partial
;
4436 if (reg
!= 0 && partial
== 0)
4437 /* Being passed entirely in a register. We shouldn't be called in
4441 /* If this arg needs special alignment, don't load the registers
4443 if (arg
->n_aligned_regs
!= 0)
4446 /* If this is being passed partially in a register, we can't evaluate
4447 it directly into its stack slot. Otherwise, we can. */
4448 if (arg
->value
== 0)
4450 /* stack_arg_under_construction is nonzero if a function argument is
4451 being evaluated directly into the outgoing argument list and
4452 expand_call must take special action to preserve the argument list
4453 if it is called recursively.
4455 For scalar function arguments stack_usage_map is sufficient to
4456 determine which stack slots must be saved and restored. Scalar
4457 arguments in general have pass_on_stack == 0.
4459 If this argument is initialized by a function which takes the
4460 address of the argument (a C++ constructor or a C function
4461 returning a BLKmode structure), then stack_usage_map is
4462 insufficient and expand_call must push the stack around the
4463 function call. Such arguments have pass_on_stack == 1.
4465 Note that it is always safe to set stack_arg_under_construction,
4466 but this generates suboptimal code if set when not needed. */
4468 if (arg
->pass_on_stack
)
4469 stack_arg_under_construction
++;
4471 arg
->value
= expand_expr (pval
,
4473 || TYPE_MODE (TREE_TYPE (pval
)) != arg
->mode
)
4474 ? NULL_RTX
: arg
->stack
,
4475 VOIDmode
, EXPAND_STACK_PARM
);
4477 /* If we are promoting object (or for any other reason) the mode
4478 doesn't agree, convert the mode. */
4480 if (arg
->mode
!= TYPE_MODE (TREE_TYPE (pval
)))
4481 arg
->value
= convert_modes (arg
->mode
, TYPE_MODE (TREE_TYPE (pval
)),
4482 arg
->value
, arg
->unsignedp
);
4484 if (arg
->pass_on_stack
)
4485 stack_arg_under_construction
--;
4488 /* Don't allow anything left on stack from computation
4489 of argument to alloca. */
4490 if (flags
& ECF_MAY_BE_ALLOCA
)
4491 do_pending_stack_adjust ();
4493 if (arg
->value
== arg
->stack
)
4494 /* If the value is already in the stack slot, we are done. */
4496 else if (arg
->mode
!= BLKmode
)
4500 /* Argument is a scalar, not entirely passed in registers.
4501 (If part is passed in registers, arg->partial says how much
4502 and emit_push_insn will take care of putting it there.)
4504 Push it, and if its size is less than the
4505 amount of space allocated to it,
4506 also bump stack pointer by the additional space.
4507 Note that in C the default argument promotions
4508 will prevent such mismatches. */
4510 size
= GET_MODE_SIZE (arg
->mode
);
4511 /* Compute how much space the push instruction will push.
4512 On many machines, pushing a byte will advance the stack
4513 pointer by a halfword. */
4514 #ifdef PUSH_ROUNDING
4515 size
= PUSH_ROUNDING (size
);
4519 /* Compute how much space the argument should get:
4520 round up to a multiple of the alignment for arguments. */
4521 if (none
!= FUNCTION_ARG_PADDING (arg
->mode
, TREE_TYPE (pval
)))
4522 used
= (((size
+ PARM_BOUNDARY
/ BITS_PER_UNIT
- 1)
4523 / (PARM_BOUNDARY
/ BITS_PER_UNIT
))
4524 * (PARM_BOUNDARY
/ BITS_PER_UNIT
));
4526 /* This isn't already where we want it on the stack, so put it there.
4527 This can either be done with push or copy insns. */
4528 emit_push_insn (arg
->value
, arg
->mode
, TREE_TYPE (pval
), NULL_RTX
,
4529 PARM_BOUNDARY
, partial
, reg
, used
- size
, argblock
,
4530 ARGS_SIZE_RTX (arg
->locate
.offset
), reg_parm_stack_space
,
4531 ARGS_SIZE_RTX (arg
->locate
.alignment_pad
));
4533 /* Unless this is a partially-in-register argument, the argument is now
4536 arg
->value
= arg
->stack
;
4540 /* BLKmode, at least partly to be pushed. */
4542 unsigned int parm_align
;
4546 /* Pushing a nonscalar.
4547 If part is passed in registers, PARTIAL says how much
4548 and emit_push_insn will take care of putting it there. */
4550 /* Round its size up to a multiple
4551 of the allocation unit for arguments. */
4553 if (arg
->locate
.size
.var
!= 0)
4556 size_rtx
= ARGS_SIZE_RTX (arg
->locate
.size
);
4560 /* PUSH_ROUNDING has no effect on us, because
4561 emit_push_insn for BLKmode is careful to avoid it. */
4562 excess
= (arg
->locate
.size
.constant
4563 - int_size_in_bytes (TREE_TYPE (pval
))
4564 + partial
* UNITS_PER_WORD
);
4565 size_rtx
= expand_expr (size_in_bytes (TREE_TYPE (pval
)),
4566 NULL_RTX
, TYPE_MODE (sizetype
), 0);
4569 /* Some types will require stricter alignment, which will be
4570 provided for elsewhere in argument layout. */
4571 parm_align
= MAX (PARM_BOUNDARY
, TYPE_ALIGN (TREE_TYPE (pval
)));
4573 /* When an argument is padded down, the block is aligned to
4574 PARM_BOUNDARY, but the actual argument isn't. */
4575 if (FUNCTION_ARG_PADDING (arg
->mode
, TREE_TYPE (pval
)) == downward
)
4577 if (arg
->locate
.size
.var
)
4578 parm_align
= BITS_PER_UNIT
;
4581 unsigned int excess_align
= (excess
& -excess
) * BITS_PER_UNIT
;
4582 parm_align
= MIN (parm_align
, excess_align
);
4586 if ((flags
& ECF_SIBCALL
) && GET_CODE (arg
->value
) == MEM
)
4588 /* emit_push_insn might not work properly if arg->value and
4589 argblock + arg->locate.offset areas overlap. */
4593 if (XEXP (x
, 0) == current_function_internal_arg_pointer
4594 || (GET_CODE (XEXP (x
, 0)) == PLUS
4595 && XEXP (XEXP (x
, 0), 0) ==
4596 current_function_internal_arg_pointer
4597 && GET_CODE (XEXP (XEXP (x
, 0), 1)) == CONST_INT
))
4599 if (XEXP (x
, 0) != current_function_internal_arg_pointer
)
4600 i
= INTVAL (XEXP (XEXP (x
, 0), 1));
4602 /* expand_call should ensure this */
4603 if (arg
->locate
.offset
.var
|| GET_CODE (size_rtx
) != CONST_INT
)
4606 if (arg
->locate
.offset
.constant
> i
)
4608 if (arg
->locate
.offset
.constant
< i
+ INTVAL (size_rtx
))
4609 sibcall_failure
= 1;
4611 else if (arg
->locate
.offset
.constant
< i
)
4613 if (i
< arg
->locate
.offset
.constant
+ INTVAL (size_rtx
))
4614 sibcall_failure
= 1;
4619 emit_push_insn (arg
->value
, arg
->mode
, TREE_TYPE (pval
), size_rtx
,
4620 parm_align
, partial
, reg
, excess
, argblock
,
4621 ARGS_SIZE_RTX (arg
->locate
.offset
), reg_parm_stack_space
,
4622 ARGS_SIZE_RTX (arg
->locate
.alignment_pad
));
4624 /* Unless this is a partially-in-register argument, the argument is now
4627 ??? Unlike the case above, in which we want the actual
4628 address of the data, so that we can load it directly into a
4629 register, here we want the address of the stack slot, so that
4630 it's properly aligned for word-by-word copying or something
4631 like that. It's not clear that this is always correct. */
4633 arg
->value
= arg
->stack_slot
;
4636 /* Mark all slots this store used. */
4637 if (ACCUMULATE_OUTGOING_ARGS
&& !(flags
& ECF_SIBCALL
)
4638 && argblock
&& ! variable_size
&& arg
->stack
)
4639 for (i
= lower_bound
; i
< upper_bound
; i
++)
4640 stack_usage_map
[i
] = 1;
4642 /* Once we have pushed something, pops can't safely
4643 be deferred during the rest of the arguments. */
4646 /* ANSI doesn't require a sequence point here,
4647 but PCC has one, so this will avoid some problems. */
4650 /* Free any temporary slots made in processing this argument. Show
4651 that we might have taken the address of something and pushed that
4653 preserve_temp_slots (NULL_RTX
);
4657 return sibcall_failure
;
4660 /* Nonzero if we do not know how to pass TYPE solely in registers.
4661 We cannot do so in the following cases:
4663 - if the type has variable size
4664 - if the type is marked as addressable (it is required to be constructed
4666 - if the padding and mode of the type is such that a copy into a register
4667 would put it into the wrong part of the register.
4669 Which padding can't be supported depends on the byte endianness.
4671 A value in a register is implicitly padded at the most significant end.
4672 On a big-endian machine, that is the lower end in memory.
4673 So a value padded in memory at the upper end can't go in a register.
4674 For a little-endian machine, the reverse is true. */
4677 default_must_pass_in_stack (enum machine_mode mode
, tree type
)
4682 /* If the type has variable size... */
4683 if (TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
)
4686 /* If the type is marked as addressable (it is required
4687 to be constructed into the stack)... */
4688 if (TREE_ADDRESSABLE (type
))
4691 /* If the padding and mode of the type is such that a copy into
4692 a register would put it into the wrong part of the register. */
4694 && int_size_in_bytes (type
) % (PARM_BOUNDARY
/ BITS_PER_UNIT
)
4695 && (FUNCTION_ARG_PADDING (mode
, type
)
4696 == (BYTES_BIG_ENDIAN
? upward
: downward
)))