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"
38 #include "langhooks.h"
43 #ifndef STACK_POINTER_OFFSET
44 #define STACK_POINTER_OFFSET 0
47 /* Like PREFERRED_STACK_BOUNDARY but in units of bytes, not bits. */
48 #define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)
50 /* Data structure and subroutines used within expand_call. */
54 /* Tree node for this argument. */
56 /* Mode for value; TYPE_MODE unless promoted. */
57 enum machine_mode mode;
58 /* Current RTL value for argument, or 0 if it isn't precomputed. */
60 /* Initially-compute RTL value for argument; only for const functions. */
62 /* Register to pass this argument in, 0 if passed on stack, or an
63 PARALLEL if the arg is to be copied into multiple non-contiguous
66 /* Register to pass this argument in when generating tail call sequence.
67 This is not the same register as for normal calls on machines with
70 /* If REG was promoted from the actual mode of the argument expression,
71 indicates whether the promotion is sign- or zero-extended. */
73 /* Number of registers to use. 0 means put the whole arg in registers.
74 Also 0 if not passed in registers. */
76 /* Nonzero if argument must be passed on stack.
77 Note that some arguments may be passed on the stack
78 even though pass_on_stack is zero, just because FUNCTION_ARG says so.
79 pass_on_stack identifies arguments that *cannot* go in registers. */
81 /* Some fields packaged up for locate_and_pad_parm. */
82 struct locate_and_pad_arg_data locate;
83 /* Location on the stack at which parameter should be stored. The store
84 has already been done if STACK == VALUE. */
86 /* Location on the stack of the start of this argument slot. This can
87 differ from STACK if this arg pads downward. This location is known
88 to be aligned to FUNCTION_ARG_BOUNDARY. */
90 /* Place that this stack area has been saved, if needed. */
92 /* If an argument's alignment does not permit direct copying into registers,
93 copy in smaller-sized pieces into pseudos. These are stored in a
94 block pointed to by this field. The next field says how many
95 word-sized pseudos we made. */
100 /* A vector of one char per byte of stack space. A byte if nonzero if
101 the corresponding stack location has been used.
102 This vector is used to prevent a function call within an argument from
103 clobbering any stack already set up. */
104 static char *stack_usage_map;
106 /* Size of STACK_USAGE_MAP. */
107 static int highest_outgoing_arg_in_use;
109 /* A bitmap of virtual-incoming stack space. Bit is set if the corresponding
110 stack location's tail call argument has been already stored into the stack.
111 This bitmap is used to prevent sibling call optimization if function tries
112 to use parent's incoming argument slots when they have been already
113 overwritten with tail call arguments. */
114 static sbitmap stored_args_map;
116 /* stack_arg_under_construction is nonzero when an argument may be
117 initialized with a constructor call (including a C function that
118 returns a BLKmode struct) and expand_call must take special action
119 to make sure the object being constructed does not overlap the
120 argument list for the constructor call. */
121 int stack_arg_under_construction;
123 static int calls_function (tree, int);
124 static int calls_function_1 (tree, int);
126 static void emit_call_1 (rtx, tree, tree, HOST_WIDE_INT, HOST_WIDE_INT,
127 HOST_WIDE_INT, rtx, rtx, int, rtx, int,
129 static void precompute_register_parameters (int, struct arg_data *, int *);
130 static int store_one_arg (struct arg_data *, rtx, int, int, int);
131 static void store_unaligned_arguments_into_pseudos (struct arg_data *, int);
132 static int finalize_must_preallocate (int, int, struct arg_data *,
134 static void precompute_arguments (int, int, struct arg_data *);
135 static int compute_argument_block_size (int, struct args_size *, int);
136 static void initialize_argument_information (int, struct arg_data *,
137 struct args_size *, int, tree,
138 tree, CUMULATIVE_ARGS *, int,
139 rtx *, int *, int *, int *);
140 static void compute_argument_addresses (struct arg_data *, rtx, int);
141 static rtx rtx_for_function_call (tree, tree);
142 static void load_register_parameters (struct arg_data *, int, rtx *, int,
144 static rtx emit_library_call_value_1 (int, rtx, rtx, enum libcall_type,
145 enum machine_mode, int, va_list);
146 static int special_function_p (tree, int);
147 static rtx try_to_integrate (tree, tree, rtx, int, tree, rtx);
148 static int check_sibcall_argument_overlap_1 (rtx);
149 static int check_sibcall_argument_overlap (rtx, struct arg_data *, int);
151 static int combine_pending_stack_adjustment_and_call (int, struct args_size *,
153 static tree fix_unsafe_tree (tree);
155 #ifdef REG_PARM_STACK_SPACE
156 static rtx save_fixed_argument_area (int, rtx, int *, int *);
157 static void restore_fixed_argument_area (rtx, rtx, int, int);
160 /* If WHICH is 1, return 1 if EXP contains a call to the built-in function
163 If WHICH is 0, return 1 if EXP contains a call to any function.
164 Actually, we only need return 1 if evaluating EXP would require pushing
165 arguments on the stack, but that is too difficult to compute, so we just
166 assume any function call might require the stack. */
168 static tree calls_function_save_exprs;
171 calls_function (tree exp, int which)
175 calls_function_save_exprs = 0;
176 val = calls_function_1 (exp, which);
177 calls_function_save_exprs = 0;
181 /* Recursive function to do the work of above function. */
184 calls_function_1 (tree exp, int which)
187 enum tree_code code = TREE_CODE (exp);
188 int class = TREE_CODE_CLASS (code);
189 int length = first_rtl_op (code);
191 /* If this code is language-specific, we don't know what it will do. */
192 if ((int) code >= NUM_TREE_CODES)
200 else if ((TREE_CODE (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))))
202 && (TYPE_RETURNS_STACK_DEPRESSED
203 (TREE_TYPE (TREE_TYPE (TREE_OPERAND (exp, 0))))))
205 else if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
206 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
208 && (special_function_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
210 & ECF_MAY_BE_ALLOCA))
219 for (tem = CONSTRUCTOR_ELTS (exp); tem != 0; tem = TREE_CHAIN (tem))
220 if (calls_function_1 (TREE_VALUE (tem), which))
227 if (SAVE_EXPR_RTL (exp) != 0)
229 if (value_member (exp, calls_function_save_exprs))
231 calls_function_save_exprs = tree_cons (NULL_TREE, exp,
232 calls_function_save_exprs);
233 return (TREE_OPERAND (exp, 0) != 0
234 && calls_function_1 (TREE_OPERAND (exp, 0), which));
241 for (local = BLOCK_VARS (exp); local; local = TREE_CHAIN (local))
242 if (DECL_INITIAL (local) != 0
243 && calls_function_1 (DECL_INITIAL (local), which))
246 for (subblock = BLOCK_SUBBLOCKS (exp);
248 subblock = TREE_CHAIN (subblock))
249 if (calls_function_1 (subblock, which))
255 for (; exp != 0; exp = TREE_CHAIN (exp))
256 if (calls_function_1 (TREE_VALUE (exp), which))
264 /* Only expressions, references, and blocks can contain calls. */
265 if (! IS_EXPR_CODE_CLASS (class) && class != 'r' && class != 'b')
268 for (i = 0; i < length; i++)
269 if (TREE_OPERAND (exp, i) != 0
270 && calls_function_1 (TREE_OPERAND (exp, i), which))
276 /* Force FUNEXP into a form suitable for the address of a CALL,
277 and return that as an rtx. Also load the static chain register
278 if FNDECL is a nested function.
280 CALL_FUSAGE points to a variable holding the prospective
281 CALL_INSN_FUNCTION_USAGE information. */
284 prepare_call_address (rtx funexp, tree fndecl, rtx *call_fusage,
285 int reg_parm_seen, int sibcallp)
287 rtx static_chain_value = 0;
289 funexp = protect_from_queue (funexp, 0);
292 /* Get possible static chain value for nested function in C. */
293 static_chain_value = lookup_static_chain (fndecl);
295 /* Make a valid memory address and copy constants thru pseudo-regs,
296 but not for a constant address if -fno-function-cse. */
297 if (GET_CODE (funexp) != SYMBOL_REF)
298 /* If we are using registers for parameters, force the
299 function address into a register now. */
300 funexp = ((SMALL_REGISTER_CLASSES && reg_parm_seen)
301 ? force_not_mem (memory_address (FUNCTION_MODE, funexp))
302 : memory_address (FUNCTION_MODE, funexp));
305 #ifndef NO_FUNCTION_CSE
306 if (optimize && ! flag_no_function_cse)
307 #ifdef NO_RECURSIVE_FUNCTION_CSE
308 if (fndecl != current_function_decl)
310 funexp = force_reg (Pmode, funexp);
314 if (static_chain_value != 0)
316 emit_move_insn (static_chain_rtx, static_chain_value);
318 if (GET_CODE (static_chain_rtx) == REG)
319 use_reg (call_fusage, static_chain_rtx);
325 /* Generate instructions to call function FUNEXP,
326 and optionally pop the results.
327 The CALL_INSN is the first insn generated.
329 FNDECL is the declaration node of the function. This is given to the
330 macro RETURN_POPS_ARGS to determine whether this function pops its own args.
332 FUNTYPE is the data type of the function. This is given to the macro
333 RETURN_POPS_ARGS to determine whether this function pops its own args.
334 We used to allow an identifier for library functions, but that doesn't
335 work when the return type is an aggregate type and the calling convention
336 says that the pointer to this aggregate is to be popped by the callee.
338 STACK_SIZE is the number of bytes of arguments on the stack,
339 ROUNDED_STACK_SIZE is that number rounded up to
340 PREFERRED_STACK_BOUNDARY; zero if the size is variable. This is
341 both to put into the call insn and to generate explicit popping
344 STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
345 It is zero if this call doesn't want a structure value.
347 NEXT_ARG_REG is the rtx that results from executing
348 FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1)
349 just after all the args have had their registers assigned.
350 This could be whatever you like, but normally it is the first
351 arg-register beyond those used for args in this call,
352 or 0 if all the arg-registers are used in this call.
353 It is passed on to `gen_call' so you can put this info in the call insn.
355 VALREG is a hard register in which a value is returned,
356 or 0 if the call does not return a value.
358 OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before
359 the args to this call were processed.
360 We restore `inhibit_defer_pop' to that value.
362 CALL_FUSAGE is either empty or an EXPR_LIST of USE expressions that
363 denote registers used by the called function. */
366 emit_call_1 (rtx funexp, tree fndecl ATTRIBUTE_UNUSED, tree funtype ATTRIBUTE_UNUSED,
367 HOST_WIDE_INT stack_size ATTRIBUTE_UNUSED,
368 HOST_WIDE_INT rounded_stack_size,
369 HOST_WIDE_INT struct_value_size ATTRIBUTE_UNUSED,
370 rtx next_arg_reg ATTRIBUTE_UNUSED, rtx valreg,
371 int old_inhibit_defer_pop, rtx call_fusage, int ecf_flags,
372 CUMULATIVE_ARGS *args_so_far ATTRIBUTE_UNUSED)
374 rtx rounded_stack_size_rtx = GEN_INT (rounded_stack_size);
376 int already_popped = 0;
377 HOST_WIDE_INT n_popped = RETURN_POPS_ARGS (fndecl, funtype, stack_size);
378 #if defined (HAVE_call) && defined (HAVE_call_value)
379 rtx struct_value_size_rtx;
380 struct_value_size_rtx = GEN_INT (struct_value_size);
383 #ifdef CALL_POPS_ARGS
384 n_popped += CALL_POPS_ARGS (* args_so_far);
387 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
388 and we don't want to load it into a register as an optimization,
389 because prepare_call_address already did it if it should be done. */
390 if (GET_CODE (funexp) != SYMBOL_REF)
391 funexp = memory_address (FUNCTION_MODE, funexp);
393 #if defined (HAVE_sibcall_pop) && defined (HAVE_sibcall_value_pop)
394 if ((ecf_flags & ECF_SIBCALL)
395 && HAVE_sibcall_pop && HAVE_sibcall_value_pop
396 && (n_popped > 0 || stack_size == 0))
398 rtx n_pop = GEN_INT (n_popped);
401 /* If this subroutine pops its own args, record that in the call insn
402 if possible, for the sake of frame pointer elimination. */
405 pat = GEN_SIBCALL_VALUE_POP (valreg,
406 gen_rtx_MEM (FUNCTION_MODE, funexp),
407 rounded_stack_size_rtx, next_arg_reg,
410 pat = GEN_SIBCALL_POP (gen_rtx_MEM (FUNCTION_MODE, funexp),
411 rounded_stack_size_rtx, next_arg_reg, n_pop);
413 emit_call_insn (pat);
419 #if defined (HAVE_call_pop) && defined (HAVE_call_value_pop)
420 /* If the target has "call" or "call_value" insns, then prefer them
421 if no arguments are actually popped. If the target does not have
422 "call" or "call_value" insns, then we must use the popping versions
423 even if the call has no arguments to pop. */
424 #if defined (HAVE_call) && defined (HAVE_call_value)
425 if (HAVE_call && HAVE_call_value && HAVE_call_pop && HAVE_call_value_pop
426 && n_popped > 0 && ! (ecf_flags & ECF_SP_DEPRESSED))
428 if (HAVE_call_pop && HAVE_call_value_pop)
431 rtx n_pop = GEN_INT (n_popped);
434 /* If this subroutine pops its own args, record that in the call insn
435 if possible, for the sake of frame pointer elimination. */
438 pat = GEN_CALL_VALUE_POP (valreg,
439 gen_rtx_MEM (FUNCTION_MODE, funexp),
440 rounded_stack_size_rtx, next_arg_reg, n_pop);
442 pat = GEN_CALL_POP (gen_rtx_MEM (FUNCTION_MODE, funexp),
443 rounded_stack_size_rtx, next_arg_reg, n_pop);
445 emit_call_insn (pat);
451 #if defined (HAVE_sibcall) && defined (HAVE_sibcall_value)
452 if ((ecf_flags & ECF_SIBCALL)
453 && HAVE_sibcall && HAVE_sibcall_value)
456 emit_call_insn (GEN_SIBCALL_VALUE (valreg,
457 gen_rtx_MEM (FUNCTION_MODE, funexp),
458 rounded_stack_size_rtx,
459 next_arg_reg, NULL_RTX));
461 emit_call_insn (GEN_SIBCALL (gen_rtx_MEM (FUNCTION_MODE, funexp),
462 rounded_stack_size_rtx, next_arg_reg,
463 struct_value_size_rtx));
468 #if defined (HAVE_call) && defined (HAVE_call_value)
469 if (HAVE_call && HAVE_call_value)
472 emit_call_insn (GEN_CALL_VALUE (valreg,
473 gen_rtx_MEM (FUNCTION_MODE, funexp),
474 rounded_stack_size_rtx, next_arg_reg,
477 emit_call_insn (GEN_CALL (gen_rtx_MEM (FUNCTION_MODE, funexp),
478 rounded_stack_size_rtx, next_arg_reg,
479 struct_value_size_rtx));
485 /* Find the call we just emitted. */
486 call_insn = last_call_insn ();
488 /* Mark memory as used for "pure" function call. */
489 if (ecf_flags & ECF_PURE)
493 gen_rtx_USE (VOIDmode,
494 gen_rtx_MEM (BLKmode, gen_rtx_SCRATCH (VOIDmode))),
497 /* Put the register usage information there. */
498 add_function_usage_to (call_insn, call_fusage);
500 /* If this is a const call, then set the insn's unchanging bit. */
501 if (ecf_flags & (ECF_CONST | ECF_PURE))
502 CONST_OR_PURE_CALL_P (call_insn) = 1;
504 /* If this call can't throw, attach a REG_EH_REGION reg note to that
506 if (ecf_flags & ECF_NOTHROW)
507 REG_NOTES (call_insn) = gen_rtx_EXPR_LIST (REG_EH_REGION, const0_rtx,
508 REG_NOTES (call_insn));
510 note_eh_region_may_contain_throw ();
512 if (ecf_flags & ECF_NORETURN)
513 REG_NOTES (call_insn) = gen_rtx_EXPR_LIST (REG_NORETURN, const0_rtx,
514 REG_NOTES (call_insn));
515 if (ecf_flags & ECF_ALWAYS_RETURN)
516 REG_NOTES (call_insn) = gen_rtx_EXPR_LIST (REG_ALWAYS_RETURN, const0_rtx,
517 REG_NOTES (call_insn));
519 if (ecf_flags & ECF_RETURNS_TWICE)
521 REG_NOTES (call_insn) = gen_rtx_EXPR_LIST (REG_SETJMP, const0_rtx,
522 REG_NOTES (call_insn));
523 current_function_calls_setjmp = 1;
526 SIBLING_CALL_P (call_insn) = ((ecf_flags & ECF_SIBCALL) != 0);
528 /* Restore this now, so that we do defer pops for this call's args
529 if the context of the call as a whole permits. */
530 inhibit_defer_pop = old_inhibit_defer_pop;
535 CALL_INSN_FUNCTION_USAGE (call_insn)
536 = gen_rtx_EXPR_LIST (VOIDmode,
537 gen_rtx_CLOBBER (VOIDmode, stack_pointer_rtx),
538 CALL_INSN_FUNCTION_USAGE (call_insn));
539 rounded_stack_size -= n_popped;
540 rounded_stack_size_rtx = GEN_INT (rounded_stack_size);
541 stack_pointer_delta -= n_popped;
544 if (!ACCUMULATE_OUTGOING_ARGS)
546 /* If returning from the subroutine does not automatically pop the args,
547 we need an instruction to pop them sooner or later.
548 Perhaps do it now; perhaps just record how much space to pop later.
550 If returning from the subroutine does pop the args, indicate that the
551 stack pointer will be changed. */
553 if (rounded_stack_size != 0)
555 if (ecf_flags & ECF_SP_DEPRESSED)
556 /* Just pretend we did the pop. */
557 stack_pointer_delta -= rounded_stack_size;
558 else if (flag_defer_pop && inhibit_defer_pop == 0
559 && ! (ecf_flags & (ECF_CONST | ECF_PURE)))
560 pending_stack_adjust += rounded_stack_size;
562 adjust_stack (rounded_stack_size_rtx);
565 /* When we accumulate outgoing args, we must avoid any stack manipulations.
566 Restore the stack pointer to its original value now. Usually
567 ACCUMULATE_OUTGOING_ARGS targets don't get here, but there are exceptions.
568 On i386 ACCUMULATE_OUTGOING_ARGS can be enabled on demand, and
569 popping variants of functions exist as well.
571 ??? We may optimize similar to defer_pop above, but it is
572 probably not worthwhile.
574 ??? It will be worthwhile to enable combine_stack_adjustments even for
577 anti_adjust_stack (GEN_INT (n_popped));
580 /* Determine if the function identified by NAME and FNDECL is one with
581 special properties we wish to know about.
583 For example, if the function might return more than one time (setjmp), then
584 set RETURNS_TWICE to a nonzero value.
586 Similarly set LONGJMP for if the function is in the longjmp family.
588 Set MAY_BE_ALLOCA for any memory allocation function that might allocate
589 space from the stack such as alloca. */
592 special_function_p (tree fndecl, int flags)
594 if (! (flags & ECF_MALLOC)
595 && fndecl && DECL_NAME (fndecl)
596 && IDENTIFIER_LENGTH (DECL_NAME (fndecl)) <= 17
597 /* Exclude functions not at the file scope, or not `extern',
598 since they are not the magic functions we would otherwise
600 && DECL_CONTEXT (fndecl) == NULL_TREE && TREE_PUBLIC (fndecl))
602 const char *name = IDENTIFIER_POINTER (DECL_NAME (fndecl));
603 const char *tname = name;
605 /* We assume that alloca will always be called by name. It
606 makes no sense to pass it as a pointer-to-function to
607 anything that does not understand its behavior. */
608 if (((IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 6
610 && ! strcmp (name, "alloca"))
611 || (IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 16
613 && ! strcmp (name, "__builtin_alloca"))))
614 flags |= ECF_MAY_BE_ALLOCA;
616 /* Disregard prefix _, __ or __x. */
619 if (name[1] == '_' && name[2] == 'x')
621 else if (name[1] == '_')
630 && (! strcmp (tname, "setjmp")
631 || ! strcmp (tname, "setjmp_syscall")))
633 && ! strcmp (tname, "sigsetjmp"))
635 && ! strcmp (tname, "savectx")))
636 flags |= ECF_RETURNS_TWICE;
639 && ! strcmp (tname, "siglongjmp"))
640 flags |= ECF_LONGJMP;
642 else if ((tname[0] == 'q' && tname[1] == 's'
643 && ! strcmp (tname, "qsetjmp"))
644 || (tname[0] == 'v' && tname[1] == 'f'
645 && ! strcmp (tname, "vfork")))
646 flags |= ECF_RETURNS_TWICE;
648 else if (tname[0] == 'l' && tname[1] == 'o'
649 && ! strcmp (tname, "longjmp"))
650 flags |= ECF_LONGJMP;
652 else if ((tname[0] == 'f' && tname[1] == 'o'
653 && ! strcmp (tname, "fork"))
654 /* Linux specific: __clone. check NAME to insist on the
655 leading underscores, to avoid polluting the ISO / POSIX
657 || (name[0] == '_' && name[1] == '_'
658 && ! strcmp (tname, "clone"))
659 || (tname[0] == 'e' && tname[1] == 'x' && tname[2] == 'e'
660 && tname[3] == 'c' && (tname[4] == 'l' || tname[4] == 'v')
662 || ((tname[5] == 'p' || tname[5] == 'e')
663 && tname[6] == '\0'))))
664 flags |= ECF_FORK_OR_EXEC;
669 /* Return nonzero when tree represent call to longjmp. */
672 setjmp_call_p (tree fndecl)
674 return special_function_p (fndecl, 0) & ECF_RETURNS_TWICE;
677 /* Return true when exp contains alloca call. */
679 alloca_call_p (tree exp)
681 if (TREE_CODE (exp) == CALL_EXPR
682 && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
683 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
685 && (special_function_p (TREE_OPERAND (TREE_OPERAND (exp, 0), 0),
686 0) & ECF_MAY_BE_ALLOCA))
691 /* Detect flags (function attributes) from the function decl or type node. */
694 flags_from_decl_or_type (tree exp)
701 struct cgraph_rtl_info *i = cgraph_rtl_info (exp);
702 type = TREE_TYPE (exp);
706 if (i->pure_function)
707 flags |= ECF_PURE | ECF_LIBCALL_BLOCK;
708 if (i->const_function)
709 flags |= ECF_CONST | ECF_LIBCALL_BLOCK;
712 /* The function exp may have the `malloc' attribute. */
713 if (DECL_IS_MALLOC (exp))
716 /* The function exp may have the `pure' attribute. */
717 if (DECL_IS_PURE (exp))
718 flags |= ECF_PURE | ECF_LIBCALL_BLOCK;
720 if (TREE_NOTHROW (exp))
721 flags |= ECF_NOTHROW;
724 if (TREE_READONLY (exp) && ! TREE_THIS_VOLATILE (exp))
725 flags |= ECF_CONST | ECF_LIBCALL_BLOCK;
727 if (TREE_THIS_VOLATILE (exp))
728 flags |= ECF_NORETURN;
730 /* Mark if the function returns with the stack pointer depressed. We
731 cannot consider it pure or constant in that case. */
732 if (TREE_CODE (type) == FUNCTION_TYPE && TYPE_RETURNS_STACK_DEPRESSED (type))
734 flags |= ECF_SP_DEPRESSED;
735 flags &= ~(ECF_PURE | ECF_CONST | ECF_LIBCALL_BLOCK);
741 /* Precompute all register parameters as described by ARGS, storing values
742 into fields within the ARGS array.
744 NUM_ACTUALS indicates the total number elements in the ARGS array.
746 Set REG_PARM_SEEN if we encounter a register parameter. */
749 precompute_register_parameters (int num_actuals, struct arg_data *args, int *reg_parm_seen)
755 for (i = 0; i < num_actuals; i++)
756 if (args[i].reg != 0 && ! args[i].pass_on_stack)
760 if (args[i].value == 0)
763 args[i].value = expand_expr (args[i].tree_value, NULL_RTX,
765 preserve_temp_slots (args[i].value);
768 /* ANSI doesn't require a sequence point here,
769 but PCC has one, so this will avoid some problems. */
773 /* If the value is a non-legitimate constant, force it into a
774 pseudo now. TLS symbols sometimes need a call to resolve. */
775 if (CONSTANT_P (args[i].value)
776 && !LEGITIMATE_CONSTANT_P (args[i].value))
777 args[i].value = force_reg (args[i].mode, args[i].value);
779 /* If we are to promote the function arg to a wider mode,
782 if (args[i].mode != TYPE_MODE (TREE_TYPE (args[i].tree_value)))
784 = convert_modes (args[i].mode,
785 TYPE_MODE (TREE_TYPE (args[i].tree_value)),
786 args[i].value, args[i].unsignedp);
788 /* If the value is expensive, and we are inside an appropriately
789 short loop, put the value into a pseudo and then put the pseudo
792 For small register classes, also do this if this call uses
793 register parameters. This is to avoid reload conflicts while
794 loading the parameters registers. */
796 if ((! (GET_CODE (args[i].value) == REG
797 || (GET_CODE (args[i].value) == SUBREG
798 && GET_CODE (SUBREG_REG (args[i].value)) == REG)))
799 && args[i].mode != BLKmode
800 && rtx_cost (args[i].value, SET) > COSTS_N_INSNS (1)
801 && ((SMALL_REGISTER_CLASSES && *reg_parm_seen)
802 || preserve_subexpressions_p ()))
803 args[i].value = copy_to_mode_reg (args[i].mode, args[i].value);
807 #ifdef REG_PARM_STACK_SPACE
809 /* The argument list is the property of the called routine and it
810 may clobber it. If the fixed area has been used for previous
811 parameters, we must save and restore it. */
814 save_fixed_argument_area (int reg_parm_stack_space, rtx argblock, int *low_to_save, int *high_to_save)
819 /* Compute the boundary of the area that needs to be saved, if any. */
820 high = reg_parm_stack_space;
821 #ifdef ARGS_GROW_DOWNWARD
824 if (high > highest_outgoing_arg_in_use)
825 high = highest_outgoing_arg_in_use;
827 for (low = 0; low < high; low++)
828 if (stack_usage_map[low] != 0)
831 enum machine_mode save_mode;
836 while (stack_usage_map[--high] == 0)
840 *high_to_save = high;
842 num_to_save = high - low + 1;
843 save_mode = mode_for_size (num_to_save * BITS_PER_UNIT, MODE_INT, 1);
845 /* If we don't have the required alignment, must do this
847 if ((low & (MIN (GET_MODE_SIZE (save_mode),
848 BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1)))
851 #ifdef ARGS_GROW_DOWNWARD
856 stack_area = gen_rtx_MEM (save_mode,
857 memory_address (save_mode,
858 plus_constant (argblock,
861 set_mem_align (stack_area, PARM_BOUNDARY);
862 if (save_mode == BLKmode)
864 save_area = assign_stack_temp (BLKmode, num_to_save, 0);
865 emit_block_move (validize_mem (save_area), stack_area,
866 GEN_INT (num_to_save), BLOCK_OP_CALL_PARM);
870 save_area = gen_reg_rtx (save_mode);
871 emit_move_insn (save_area, stack_area);
881 restore_fixed_argument_area (rtx save_area, rtx argblock, int high_to_save, int low_to_save)
883 enum machine_mode save_mode = GET_MODE (save_area);
887 #ifdef ARGS_GROW_DOWNWARD
888 delta = -high_to_save;
892 stack_area = gen_rtx_MEM (save_mode,
893 memory_address (save_mode,
894 plus_constant (argblock, delta)));
895 set_mem_align (stack_area, PARM_BOUNDARY);
897 if (save_mode != BLKmode)
898 emit_move_insn (stack_area, save_area);
900 emit_block_move (stack_area, validize_mem (save_area),
901 GEN_INT (high_to_save - low_to_save + 1),
904 #endif /* REG_PARM_STACK_SPACE */
906 /* If any elements in ARGS refer to parameters that are to be passed in
907 registers, but not in memory, and whose alignment does not permit a
908 direct copy into registers. Copy the values into a group of pseudos
909 which we will later copy into the appropriate hard registers.
911 Pseudos for each unaligned argument will be stored into the array
912 args[argnum].aligned_regs. The caller is responsible for deallocating
913 the aligned_regs array if it is nonzero. */
916 store_unaligned_arguments_into_pseudos (struct arg_data *args, int num_actuals)
920 for (i = 0; i < num_actuals; i++)
921 if (args[i].reg != 0 && ! args[i].pass_on_stack
922 && args[i].mode == BLKmode
923 && (TYPE_ALIGN (TREE_TYPE (args[i].tree_value))
924 < (unsigned int) MIN (BIGGEST_ALIGNMENT, BITS_PER_WORD)))
926 int bytes = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
927 int big_endian_correction = 0;
929 args[i].n_aligned_regs
930 = args[i].partial ? args[i].partial
931 : (bytes + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
933 args[i].aligned_regs = (rtx *) xmalloc (sizeof (rtx)
934 * args[i].n_aligned_regs);
936 /* Structures smaller than a word are aligned to the least
937 significant byte (to the right). On a BYTES_BIG_ENDIAN machine,
938 this means we must skip the empty high order bytes when
939 calculating the bit offset. */
941 && bytes < UNITS_PER_WORD)
942 big_endian_correction = (BITS_PER_WORD - (bytes * BITS_PER_UNIT));
944 for (j = 0; j < args[i].n_aligned_regs; j++)
946 rtx reg = gen_reg_rtx (word_mode);
947 rtx word = operand_subword_force (args[i].value, j, BLKmode);
948 int bitsize = MIN (bytes * BITS_PER_UNIT, BITS_PER_WORD);
950 args[i].aligned_regs[j] = reg;
952 /* There is no need to restrict this code to loading items
953 in TYPE_ALIGN sized hunks. The bitfield instructions can
954 load up entire word sized registers efficiently.
956 ??? This may not be needed anymore.
957 We use to emit a clobber here but that doesn't let later
958 passes optimize the instructions we emit. By storing 0 into
959 the register later passes know the first AND to zero out the
960 bitfield being set in the register is unnecessary. The store
961 of 0 will be deleted as will at least the first AND. */
963 emit_move_insn (reg, const0_rtx);
965 bytes -= bitsize / BITS_PER_UNIT;
966 store_bit_field (reg, bitsize, big_endian_correction, word_mode,
967 extract_bit_field (word, bitsize, 0, 1, NULL_RTX,
968 word_mode, word_mode,
975 /* Fill in ARGS_SIZE and ARGS array based on the parameters found in
978 NUM_ACTUALS is the total number of parameters.
980 N_NAMED_ARGS is the total number of named arguments.
982 FNDECL is the tree code for the target of this call (if known)
984 ARGS_SO_FAR holds state needed by the target to know where to place
987 REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
988 for arguments which are passed in registers.
990 OLD_STACK_LEVEL is a pointer to an rtx which olds the old stack level
991 and may be modified by this routine.
993 OLD_PENDING_ADJ, MUST_PREALLOCATE and FLAGS are pointers to integer
994 flags which may may be modified by this routine. */
997 initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
998 struct arg_data *args,
999 struct args_size *args_size,
1000 int n_named_args ATTRIBUTE_UNUSED,
1001 tree actparms, tree fndecl,
1002 CUMULATIVE_ARGS *args_so_far,
1003 int reg_parm_stack_space,
1004 rtx *old_stack_level, int *old_pending_adj,
1005 int *must_preallocate, int *ecf_flags)
1007 /* 1 if scanning parms front to back, -1 if scanning back to front. */
1010 /* Count arg position in order args appear. */
1016 args_size->constant = 0;
1019 /* In this loop, we consider args in the order they are written.
1020 We fill up ARGS from the front or from the back if necessary
1021 so that in any case the first arg to be pushed ends up at the front. */
1023 if (PUSH_ARGS_REVERSED)
1025 i = num_actuals - 1, inc = -1;
1026 /* In this case, must reverse order of args
1027 so that we compute and push the last arg first. */
1034 /* I counts args in order (to be) pushed; ARGPOS counts in order written. */
1035 for (p = actparms, argpos = 0; p; p = TREE_CHAIN (p), i += inc, argpos++)
1037 tree type = TREE_TYPE (TREE_VALUE (p));
1039 enum machine_mode mode;
1041 args[i].tree_value = TREE_VALUE (p);
1043 /* Replace erroneous argument with constant zero. */
1044 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
1045 args[i].tree_value = integer_zero_node, type = integer_type_node;
1047 /* If TYPE is a transparent union, pass things the way we would
1048 pass the first field of the union. We have already verified that
1049 the modes are the same. */
1050 if (TREE_CODE (type) == UNION_TYPE && TYPE_TRANSPARENT_UNION (type))
1051 type = TREE_TYPE (TYPE_FIELDS (type));
1053 /* Decide where to pass this arg.
1055 args[i].reg is nonzero if all or part is passed in registers.
1057 args[i].partial is nonzero if part but not all is passed in registers,
1058 and the exact value says how many words are passed in registers.
1060 args[i].pass_on_stack is nonzero if the argument must at least be
1061 computed on the stack. It may then be loaded back into registers
1062 if args[i].reg is nonzero.
1064 These decisions are driven by the FUNCTION_... macros and must agree
1065 with those made by function.c. */
1067 /* See if this argument should be passed by invisible reference. */
1068 if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
1069 || TREE_ADDRESSABLE (type)
1070 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
1071 || FUNCTION_ARG_PASS_BY_REFERENCE (*args_so_far, TYPE_MODE (type),
1072 type, argpos < n_named_args)
1076 /* If we're compiling a thunk, pass through invisible
1077 references instead of making a copy. */
1078 if (current_function_is_thunk
1079 #ifdef FUNCTION_ARG_CALLEE_COPIES
1080 || (FUNCTION_ARG_CALLEE_COPIES (*args_so_far, TYPE_MODE (type),
1081 type, argpos < n_named_args)
1082 /* If it's in a register, we must make a copy of it too. */
1083 /* ??? Is this a sufficient test? Is there a better one? */
1084 && !(TREE_CODE (args[i].tree_value) == VAR_DECL
1085 && REG_P (DECL_RTL (args[i].tree_value)))
1086 && ! TREE_ADDRESSABLE (type))
1090 /* C++ uses a TARGET_EXPR to indicate that we want to make a
1091 new object from the argument. If we are passing by
1092 invisible reference, the callee will do that for us, so we
1093 can strip off the TARGET_EXPR. This is not always safe,
1094 but it is safe in the only case where this is a useful
1095 optimization; namely, when the argument is a plain object.
1096 In that case, the frontend is just asking the backend to
1097 make a bitwise copy of the argument. */
1099 if (TREE_CODE (args[i].tree_value) == TARGET_EXPR
1100 && (DECL_P (TREE_OPERAND (args[i].tree_value, 1)))
1101 && ! REG_P (DECL_RTL (TREE_OPERAND (args[i].tree_value, 1))))
1102 args[i].tree_value = TREE_OPERAND (args[i].tree_value, 1);
1104 args[i].tree_value = build1 (ADDR_EXPR,
1105 build_pointer_type (type),
1106 args[i].tree_value);
1107 type = build_pointer_type (type);
1109 else if (TREE_CODE (args[i].tree_value) == TARGET_EXPR)
1111 /* In the V3 C++ ABI, parameters are destroyed in the caller.
1112 We implement this by passing the address of the temporary
1113 rather than expanding it into another allocated slot. */
1114 args[i].tree_value = build1 (ADDR_EXPR,
1115 build_pointer_type (type),
1116 args[i].tree_value);
1117 type = build_pointer_type (type);
1121 /* We make a copy of the object and pass the address to the
1122 function being called. */
1125 if (!COMPLETE_TYPE_P (type)
1126 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST
1127 || (flag_stack_check && ! STACK_CHECK_BUILTIN
1128 && (0 < compare_tree_int (TYPE_SIZE_UNIT (type),
1129 STACK_CHECK_MAX_VAR_SIZE))))
1131 /* This is a variable-sized object. Make space on the stack
1133 rtx size_rtx = expr_size (TREE_VALUE (p));
1135 if (*old_stack_level == 0)
1137 emit_stack_save (SAVE_BLOCK, old_stack_level, NULL_RTX);
1138 *old_pending_adj = pending_stack_adjust;
1139 pending_stack_adjust = 0;
1142 copy = gen_rtx_MEM (BLKmode,
1143 allocate_dynamic_stack_space
1144 (size_rtx, NULL_RTX, TYPE_ALIGN (type)));
1145 set_mem_attributes (copy, type, 1);
1148 copy = assign_temp (type, 0, 1, 0);
1150 store_expr (args[i].tree_value, copy, 0);
1151 *ecf_flags &= ~(ECF_CONST | ECF_PURE | ECF_LIBCALL_BLOCK);
1153 args[i].tree_value = build1 (ADDR_EXPR,
1154 build_pointer_type (type),
1155 make_tree (type, copy));
1156 type = build_pointer_type (type);
1160 mode = TYPE_MODE (type);
1161 unsignedp = TREE_UNSIGNED (type);
1163 #ifdef PROMOTE_FUNCTION_ARGS
1164 mode = promote_mode (type, mode, &unsignedp, 1);
1167 args[i].unsignedp = unsignedp;
1168 args[i].mode = mode;
1170 args[i].reg = FUNCTION_ARG (*args_so_far, mode, type,
1171 argpos < n_named_args);
1172 #ifdef FUNCTION_INCOMING_ARG
1173 /* If this is a sibling call and the machine has register windows, the
1174 register window has to be unwinded before calling the routine, so
1175 arguments have to go into the incoming registers. */
1176 args[i].tail_call_reg = FUNCTION_INCOMING_ARG (*args_so_far, mode, type,
1177 argpos < n_named_args);
1179 args[i].tail_call_reg = args[i].reg;
1182 #ifdef FUNCTION_ARG_PARTIAL_NREGS
1185 = FUNCTION_ARG_PARTIAL_NREGS (*args_so_far, mode, type,
1186 argpos < n_named_args);
1189 args[i].pass_on_stack = MUST_PASS_IN_STACK (mode, type);
1191 /* If FUNCTION_ARG returned a (parallel [(expr_list (nil) ...) ...]),
1192 it means that we are to pass this arg in the register(s) designated
1193 by the PARALLEL, but also to pass it in the stack. */
1194 if (args[i].reg && GET_CODE (args[i].reg) == PARALLEL
1195 && XEXP (XVECEXP (args[i].reg, 0, 0), 0) == 0)
1196 args[i].pass_on_stack = 1;
1198 /* If this is an addressable type, we must preallocate the stack
1199 since we must evaluate the object into its final location.
1201 If this is to be passed in both registers and the stack, it is simpler
1203 if (TREE_ADDRESSABLE (type)
1204 || (args[i].pass_on_stack && args[i].reg != 0))
1205 *must_preallocate = 1;
1207 /* If this is an addressable type, we cannot pre-evaluate it. Thus,
1208 we cannot consider this function call constant. */
1209 if (TREE_ADDRESSABLE (type))
1210 *ecf_flags &= ~ECF_LIBCALL_BLOCK;
1212 /* Compute the stack-size of this argument. */
1213 if (args[i].reg == 0 || args[i].partial != 0
1214 || reg_parm_stack_space > 0
1215 || args[i].pass_on_stack)
1216 locate_and_pad_parm (mode, type,
1217 #ifdef STACK_PARMS_IN_REG_PARM_AREA
1222 args[i].pass_on_stack ? 0 : args[i].partial,
1223 fndecl, args_size, &args[i].locate);
1225 /* Update ARGS_SIZE, the total stack space for args so far. */
1227 args_size->constant += args[i].locate.size.constant;
1228 if (args[i].locate.size.var)
1229 ADD_PARM_SIZE (*args_size, args[i].locate.size.var);
1231 /* Increment ARGS_SO_FAR, which has info about which arg-registers
1232 have been used, etc. */
1234 FUNCTION_ARG_ADVANCE (*args_so_far, TYPE_MODE (type), type,
1235 argpos < n_named_args);
1239 /* Update ARGS_SIZE to contain the total size for the argument block.
1240 Return the original constant component of the argument block's size.
1242 REG_PARM_STACK_SPACE holds the number of bytes of stack space reserved
1243 for arguments passed in registers. */
1246 compute_argument_block_size (int reg_parm_stack_space,
1247 struct args_size *args_size,
1248 int preferred_stack_boundary ATTRIBUTE_UNUSED)
1250 int unadjusted_args_size = args_size->constant;
1252 /* For accumulate outgoing args mode we don't need to align, since the frame
1253 will be already aligned. Align to STACK_BOUNDARY in order to prevent
1254 backends from generating misaligned frame sizes. */
1255 if (ACCUMULATE_OUTGOING_ARGS && preferred_stack_boundary > STACK_BOUNDARY)
1256 preferred_stack_boundary = STACK_BOUNDARY;
1258 /* Compute the actual size of the argument block required. The variable
1259 and constant sizes must be combined, the size may have to be rounded,
1260 and there may be a minimum required size. */
1264 args_size->var = ARGS_SIZE_TREE (*args_size);
1265 args_size->constant = 0;
1267 preferred_stack_boundary /= BITS_PER_UNIT;
1268 if (preferred_stack_boundary > 1)
1270 /* We don't handle this case yet. To handle it correctly we have
1271 to add the delta, round and subtract the delta.
1272 Currently no machine description requires this support. */
1273 if (stack_pointer_delta & (preferred_stack_boundary - 1))
1275 args_size->var = round_up (args_size->var, preferred_stack_boundary);
1278 if (reg_parm_stack_space > 0)
1281 = size_binop (MAX_EXPR, args_size->var,
1282 ssize_int (reg_parm_stack_space));
1284 #ifndef OUTGOING_REG_PARM_STACK_SPACE
1285 /* The area corresponding to register parameters is not to count in
1286 the size of the block we need. So make the adjustment. */
1288 = size_binop (MINUS_EXPR, args_size->var,
1289 ssize_int (reg_parm_stack_space));
1295 preferred_stack_boundary /= BITS_PER_UNIT;
1296 if (preferred_stack_boundary < 1)
1297 preferred_stack_boundary = 1;
1298 args_size->constant = (((args_size->constant
1299 + stack_pointer_delta
1300 + preferred_stack_boundary - 1)
1301 / preferred_stack_boundary
1302 * preferred_stack_boundary)
1303 - stack_pointer_delta);
1305 args_size->constant = MAX (args_size->constant,
1306 reg_parm_stack_space);
1308 #ifdef MAYBE_REG_PARM_STACK_SPACE
1309 if (reg_parm_stack_space == 0)
1310 args_size->constant = 0;
1313 #ifndef OUTGOING_REG_PARM_STACK_SPACE
1314 args_size->constant -= reg_parm_stack_space;
1317 return unadjusted_args_size;
1320 /* Precompute parameters as needed for a function call.
1322 FLAGS is mask of ECF_* constants.
1324 NUM_ACTUALS is the number of arguments.
1326 ARGS is an array containing information for each argument; this
1327 routine fills in the INITIAL_VALUE and VALUE fields for each
1328 precomputed argument. */
1331 precompute_arguments (int flags, int num_actuals, struct arg_data *args)
1335 /* If this function call is cse'able, precompute all the parameters.
1336 Note that if the parameter is constructed into a temporary, this will
1337 cause an additional copy because the parameter will be constructed
1338 into a temporary location and then copied into the outgoing arguments.
1339 If a parameter contains a call to alloca and this function uses the
1340 stack, precompute the parameter. */
1342 /* If we preallocated the stack space, and some arguments must be passed
1343 on the stack, then we must precompute any parameter which contains a
1344 function call which will store arguments on the stack.
1345 Otherwise, evaluating the parameter may clobber previous parameters
1346 which have already been stored into the stack. (we have code to avoid
1347 such case by saving the outgoing stack arguments, but it results in
1350 for (i = 0; i < num_actuals; i++)
1351 if ((flags & ECF_LIBCALL_BLOCK)
1352 || calls_function (args[i].tree_value, !ACCUMULATE_OUTGOING_ARGS))
1354 enum machine_mode mode;
1356 /* If this is an addressable type, we cannot pre-evaluate it. */
1357 if (TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value)))
1361 = expand_expr (args[i].tree_value, NULL_RTX, VOIDmode, 0);
1363 /* ANSI doesn't require a sequence point here,
1364 but PCC has one, so this will avoid some problems. */
1367 args[i].initial_value = args[i].value
1368 = protect_from_queue (args[i].value, 0);
1370 mode = TYPE_MODE (TREE_TYPE (args[i].tree_value));
1371 if (mode != args[i].mode)
1374 = convert_modes (args[i].mode, mode,
1375 args[i].value, args[i].unsignedp);
1376 #ifdef PROMOTE_FOR_CALL_ONLY
1377 /* CSE will replace this only if it contains args[i].value
1378 pseudo, so convert it down to the declared mode using
1380 if (GET_CODE (args[i].value) == REG
1381 && GET_MODE_CLASS (args[i].mode) == MODE_INT)
1383 args[i].initial_value
1384 = gen_lowpart_SUBREG (mode, args[i].value);
1385 SUBREG_PROMOTED_VAR_P (args[i].initial_value) = 1;
1386 SUBREG_PROMOTED_UNSIGNED_SET (args[i].initial_value,
1394 /* Given the current state of MUST_PREALLOCATE and information about
1395 arguments to a function call in NUM_ACTUALS, ARGS and ARGS_SIZE,
1396 compute and return the final value for MUST_PREALLOCATE. */
1399 finalize_must_preallocate (int must_preallocate, int num_actuals, struct arg_data *args, struct args_size *args_size)
1401 /* See if we have or want to preallocate stack space.
1403 If we would have to push a partially-in-regs parm
1404 before other stack parms, preallocate stack space instead.
1406 If the size of some parm is not a multiple of the required stack
1407 alignment, we must preallocate.
1409 If the total size of arguments that would otherwise create a copy in
1410 a temporary (such as a CALL) is more than half the total argument list
1411 size, preallocation is faster.
1413 Another reason to preallocate is if we have a machine (like the m88k)
1414 where stack alignment is required to be maintained between every
1415 pair of insns, not just when the call is made. However, we assume here
1416 that such machines either do not have push insns (and hence preallocation
1417 would occur anyway) or the problem is taken care of with
1420 if (! must_preallocate)
1422 int partial_seen = 0;
1423 int copy_to_evaluate_size = 0;
1426 for (i = 0; i < num_actuals && ! must_preallocate; i++)
1428 if (args[i].partial > 0 && ! args[i].pass_on_stack)
1430 else if (partial_seen && args[i].reg == 0)
1431 must_preallocate = 1;
1433 if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
1434 && (TREE_CODE (args[i].tree_value) == CALL_EXPR
1435 || TREE_CODE (args[i].tree_value) == TARGET_EXPR
1436 || TREE_CODE (args[i].tree_value) == COND_EXPR
1437 || TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value))))
1438 copy_to_evaluate_size
1439 += int_size_in_bytes (TREE_TYPE (args[i].tree_value));
1442 if (copy_to_evaluate_size * 2 >= args_size->constant
1443 && args_size->constant > 0)
1444 must_preallocate = 1;
1446 return must_preallocate;
1449 /* If we preallocated stack space, compute the address of each argument
1450 and store it into the ARGS array.
1452 We need not ensure it is a valid memory address here; it will be
1453 validized when it is used.
1455 ARGBLOCK is an rtx for the address of the outgoing arguments. */
1458 compute_argument_addresses (struct arg_data *args, rtx argblock, int num_actuals)
1462 rtx arg_reg = argblock;
1463 int i, arg_offset = 0;
1465 if (GET_CODE (argblock) == PLUS)
1466 arg_reg = XEXP (argblock, 0), arg_offset = INTVAL (XEXP (argblock, 1));
1468 for (i = 0; i < num_actuals; i++)
1470 rtx offset = ARGS_SIZE_RTX (args[i].locate.offset);
1471 rtx slot_offset = ARGS_SIZE_RTX (args[i].locate.slot_offset);
1474 /* Skip this parm if it will not be passed on the stack. */
1475 if (! args[i].pass_on_stack && args[i].reg != 0)
1478 if (GET_CODE (offset) == CONST_INT)
1479 addr = plus_constant (arg_reg, INTVAL (offset));
1481 addr = gen_rtx_PLUS (Pmode, arg_reg, offset);
1483 addr = plus_constant (addr, arg_offset);
1484 args[i].stack = gen_rtx_MEM (args[i].mode, addr);
1485 set_mem_align (args[i].stack, PARM_BOUNDARY);
1486 set_mem_attributes (args[i].stack,
1487 TREE_TYPE (args[i].tree_value), 1);
1489 if (GET_CODE (slot_offset) == CONST_INT)
1490 addr = plus_constant (arg_reg, INTVAL (slot_offset));
1492 addr = gen_rtx_PLUS (Pmode, arg_reg, slot_offset);
1494 addr = plus_constant (addr, arg_offset);
1495 args[i].stack_slot = gen_rtx_MEM (args[i].mode, addr);
1496 set_mem_align (args[i].stack_slot, PARM_BOUNDARY);
1497 set_mem_attributes (args[i].stack_slot,
1498 TREE_TYPE (args[i].tree_value), 1);
1500 /* Function incoming arguments may overlap with sibling call
1501 outgoing arguments and we cannot allow reordering of reads
1502 from function arguments with stores to outgoing arguments
1503 of sibling calls. */
1504 set_mem_alias_set (args[i].stack, 0);
1505 set_mem_alias_set (args[i].stack_slot, 0);
1510 /* Given a FNDECL and EXP, return an rtx suitable for use as a target address
1511 in a call instruction.
1513 FNDECL is the tree node for the target function. For an indirect call
1514 FNDECL will be NULL_TREE.
1516 ADDR is the operand 0 of CALL_EXPR for this call. */
1519 rtx_for_function_call (tree fndecl, tree addr)
1523 /* Get the function to call, in the form of RTL. */
1526 /* If this is the first use of the function, see if we need to
1527 make an external definition for it. */
1528 if (! TREE_USED (fndecl))
1530 assemble_external (fndecl);
1531 TREE_USED (fndecl) = 1;
1534 /* Get a SYMBOL_REF rtx for the function address. */
1535 funexp = XEXP (DECL_RTL (fndecl), 0);
1538 /* Generate an rtx (probably a pseudo-register) for the address. */
1541 funexp = expand_expr (addr, NULL_RTX, VOIDmode, 0);
1542 pop_temp_slots (); /* FUNEXP can't be BLKmode. */
1548 /* Do the register loads required for any wholly-register parms or any
1549 parms which are passed both on the stack and in a register. Their
1550 expressions were already evaluated.
1552 Mark all register-parms as living through the call, putting these USE
1553 insns in the CALL_INSN_FUNCTION_USAGE field.
1555 When IS_SIBCALL, perform the check_sibcall_overlap_argument_overlap
1556 checking, setting *SIBCALL_FAILURE if appropriate. */
1559 load_register_parameters (struct arg_data *args, int num_actuals,
1560 rtx *call_fusage, int flags, int is_sibcall,
1561 int *sibcall_failure)
1565 #ifdef LOAD_ARGS_REVERSED
1566 for (i = num_actuals - 1; i >= 0; i--)
1568 for (i = 0; i < num_actuals; i++)
1571 rtx reg = ((flags & ECF_SIBCALL)
1572 ? args[i].tail_call_reg : args[i].reg);
1573 int partial = args[i].partial;
1578 rtx before_arg = get_last_insn ();
1579 /* Set to non-negative if must move a word at a time, even if just
1580 one word (e.g, partial == 1 && mode == DFmode). Set to -1 if
1581 we just use a normal move insn. This value can be zero if the
1582 argument is a zero size structure with no fields. */
1583 nregs = (partial ? partial
1584 : (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
1585 ? ((int_size_in_bytes (TREE_TYPE (args[i].tree_value))
1586 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
1589 /* Handle calls that pass values in multiple non-contiguous
1590 locations. The Irix 6 ABI has examples of this. */
1592 if (GET_CODE (reg) == PARALLEL)
1593 emit_group_load (reg, args[i].value,
1594 int_size_in_bytes (TREE_TYPE (args[i].tree_value)));
1596 /* If simple case, just do move. If normal partial, store_one_arg
1597 has already loaded the register for us. In all other cases,
1598 load the register(s) from memory. */
1600 else if (nregs == -1)
1601 emit_move_insn (reg, args[i].value);
1603 /* If we have pre-computed the values to put in the registers in
1604 the case of non-aligned structures, copy them in now. */
1606 else if (args[i].n_aligned_regs != 0)
1607 for (j = 0; j < args[i].n_aligned_regs; j++)
1608 emit_move_insn (gen_rtx_REG (word_mode, REGNO (reg) + j),
1609 args[i].aligned_regs[j]);
1611 else if (partial == 0 || args[i].pass_on_stack)
1612 move_block_to_reg (REGNO (reg),
1613 validize_mem (args[i].value), nregs,
1616 /* When a parameter is a block, and perhaps in other cases, it is
1617 possible that it did a load from an argument slot that was
1618 already clobbered. */
1620 && check_sibcall_argument_overlap (before_arg, &args[i], 0))
1621 *sibcall_failure = 1;
1623 /* Handle calls that pass values in multiple non-contiguous
1624 locations. The Irix 6 ABI has examples of this. */
1625 if (GET_CODE (reg) == PARALLEL)
1626 use_group_regs (call_fusage, reg);
1627 else if (nregs == -1)
1628 use_reg (call_fusage, reg);
1630 use_regs (call_fusage, REGNO (reg), nregs == 0 ? 1 : nregs);
1635 /* Try to integrate function. See expand_inline_function for documentation
1636 about the parameters. */
1639 try_to_integrate (tree fndecl, tree actparms, rtx target, int ignore,
1640 tree type, rtx structure_value_addr)
1645 rtx old_stack_level = 0;
1646 int reg_parm_stack_space = 0;
1648 #ifdef REG_PARM_STACK_SPACE
1649 #ifdef MAYBE_REG_PARM_STACK_SPACE
1650 reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
1652 reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
1656 before_call = get_last_insn ();
1658 timevar_push (TV_INTEGRATION);
1660 temp = expand_inline_function (fndecl, actparms, target,
1662 structure_value_addr);
1664 timevar_pop (TV_INTEGRATION);
1666 /* If inlining succeeded, return. */
1667 if (temp != (rtx) (size_t) - 1)
1669 if (ACCUMULATE_OUTGOING_ARGS)
1671 /* If the outgoing argument list must be preserved, push
1672 the stack before executing the inlined function if it
1675 i = reg_parm_stack_space;
1676 if (i > highest_outgoing_arg_in_use)
1677 i = highest_outgoing_arg_in_use;
1678 while (--i >= 0 && stack_usage_map[i] == 0)
1681 if (stack_arg_under_construction || i >= 0)
1684 = before_call ? NEXT_INSN (before_call) : get_insns ();
1685 rtx insn = NULL_RTX, seq;
1687 /* Look for a call in the inline function code.
1688 If DECL_SAVED_INSNS (fndecl)->outgoing_args_size is
1689 nonzero then there is a call and it is not necessary
1690 to scan the insns. */
1692 if (DECL_SAVED_INSNS (fndecl)->outgoing_args_size == 0)
1693 for (insn = first_insn; insn; insn = NEXT_INSN (insn))
1694 if (GET_CODE (insn) == CALL_INSN)
1699 /* Reserve enough stack space so that the largest
1700 argument list of any function call in the inline
1701 function does not overlap the argument list being
1702 evaluated. This is usually an overestimate because
1703 allocate_dynamic_stack_space reserves space for an
1704 outgoing argument list in addition to the requested
1705 space, but there is no way to ask for stack space such
1706 that an argument list of a certain length can be
1709 Add the stack space reserved for register arguments, if
1710 any, in the inline function. What is really needed is the
1711 largest value of reg_parm_stack_space in the inline
1712 function, but that is not available. Using the current
1713 value of reg_parm_stack_space is wrong, but gives
1714 correct results on all supported machines. */
1716 int adjust = (DECL_SAVED_INSNS (fndecl)->outgoing_args_size
1717 + reg_parm_stack_space);
1720 emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1721 allocate_dynamic_stack_space (GEN_INT (adjust),
1722 NULL_RTX, BITS_PER_UNIT);
1725 emit_insn_before (seq, first_insn);
1726 emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1731 /* If the result is equivalent to TARGET, return TARGET to simplify
1732 checks in store_expr. They can be equivalent but not equal in the
1733 case of a function that returns BLKmode. */
1734 if (temp != target && rtx_equal_p (temp, target))
1739 /* If inlining failed, mark FNDECL as needing to be compiled
1740 separately after all. If function was declared inline,
1742 if (DECL_INLINE (fndecl) && warn_inline && !flag_no_inline
1743 && optimize > 0 && !TREE_ADDRESSABLE (fndecl))
1745 warning_with_decl (fndecl, "inlining failed in call to `%s'");
1746 warning ("called from here");
1748 (*lang_hooks.mark_addressable) (fndecl);
1749 return (rtx) (size_t) - 1;
1752 /* We need to pop PENDING_STACK_ADJUST bytes. But, if the arguments
1753 wouldn't fill up an even multiple of PREFERRED_UNIT_STACK_BOUNDARY
1754 bytes, then we would need to push some additional bytes to pad the
1755 arguments. So, we compute an adjust to the stack pointer for an
1756 amount that will leave the stack under-aligned by UNADJUSTED_ARGS_SIZE
1757 bytes. Then, when the arguments are pushed the stack will be perfectly
1758 aligned. ARGS_SIZE->CONSTANT is set to the number of bytes that should
1759 be popped after the call. Returns the adjustment. */
1762 combine_pending_stack_adjustment_and_call (int unadjusted_args_size,
1763 struct args_size *args_size,
1764 int preferred_unit_stack_boundary)
1766 /* The number of bytes to pop so that the stack will be
1767 under-aligned by UNADJUSTED_ARGS_SIZE bytes. */
1768 HOST_WIDE_INT adjustment;
1769 /* The alignment of the stack after the arguments are pushed, if we
1770 just pushed the arguments without adjust the stack here. */
1771 HOST_WIDE_INT unadjusted_alignment;
1773 unadjusted_alignment
1774 = ((stack_pointer_delta + unadjusted_args_size)
1775 % preferred_unit_stack_boundary);
1777 /* We want to get rid of as many of the PENDING_STACK_ADJUST bytes
1778 as possible -- leaving just enough left to cancel out the
1779 UNADJUSTED_ALIGNMENT. In other words, we want to ensure that the
1780 PENDING_STACK_ADJUST is non-negative, and congruent to
1781 -UNADJUSTED_ALIGNMENT modulo the PREFERRED_UNIT_STACK_BOUNDARY. */
1783 /* Begin by trying to pop all the bytes. */
1784 unadjusted_alignment
1785 = (unadjusted_alignment
1786 - (pending_stack_adjust % preferred_unit_stack_boundary));
1787 adjustment = pending_stack_adjust;
1788 /* Push enough additional bytes that the stack will be aligned
1789 after the arguments are pushed. */
1790 if (preferred_unit_stack_boundary > 1)
1792 if (unadjusted_alignment > 0)
1793 adjustment -= preferred_unit_stack_boundary - unadjusted_alignment;
1795 adjustment += unadjusted_alignment;
1798 /* Now, sets ARGS_SIZE->CONSTANT so that we pop the right number of
1799 bytes after the call. The right number is the entire
1800 PENDING_STACK_ADJUST less our ADJUSTMENT plus the amount required
1801 by the arguments in the first place. */
1803 = pending_stack_adjust - adjustment + unadjusted_args_size;
1808 /* Scan X expression if it does not dereference any argument slots
1809 we already clobbered by tail call arguments (as noted in stored_args_map
1811 Return nonzero if X expression dereferences such argument slots,
1815 check_sibcall_argument_overlap_1 (rtx x)
1825 code = GET_CODE (x);
1829 if (XEXP (x, 0) == current_function_internal_arg_pointer)
1831 else if (GET_CODE (XEXP (x, 0)) == PLUS
1832 && XEXP (XEXP (x, 0), 0) ==
1833 current_function_internal_arg_pointer
1834 && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
1835 i = INTVAL (XEXP (XEXP (x, 0), 1));
1839 #ifdef ARGS_GROW_DOWNWARD
1840 i = -i - GET_MODE_SIZE (GET_MODE (x));
1843 for (k = 0; k < GET_MODE_SIZE (GET_MODE (x)); k++)
1844 if (i + k < stored_args_map->n_bits
1845 && TEST_BIT (stored_args_map, i + k))
1851 /* Scan all subexpressions. */
1852 fmt = GET_RTX_FORMAT (code);
1853 for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
1857 if (check_sibcall_argument_overlap_1 (XEXP (x, i)))
1860 else if (*fmt == 'E')
1862 for (j = 0; j < XVECLEN (x, i); j++)
1863 if (check_sibcall_argument_overlap_1 (XVECEXP (x, i, j)))
1870 /* Scan sequence after INSN if it does not dereference any argument slots
1871 we already clobbered by tail call arguments (as noted in stored_args_map
1872 bitmap). If MARK_STORED_ARGS_MAP, add stack slots for ARG to
1873 stored_args_map bitmap afterwards (when ARG is a register MARK_STORED_ARGS_MAP
1874 should be 0). Return nonzero if sequence after INSN dereferences such argument
1875 slots, zero otherwise. */
1878 check_sibcall_argument_overlap (rtx insn, struct arg_data *arg, int mark_stored_args_map)
1882 if (insn == NULL_RTX)
1883 insn = get_insns ();
1885 insn = NEXT_INSN (insn);
1887 for (; insn; insn = NEXT_INSN (insn))
1889 && check_sibcall_argument_overlap_1 (PATTERN (insn)))
1892 if (mark_stored_args_map)
1894 #ifdef ARGS_GROW_DOWNWARD
1895 low = -arg->locate.slot_offset.constant - arg->locate.size.constant;
1897 low = arg->locate.slot_offset.constant;
1900 for (high = low + arg->locate.size.constant; low < high; low++)
1901 SET_BIT (stored_args_map, low);
1903 return insn != NULL_RTX;
1907 fix_unsafe_tree (tree t)
1909 switch (unsafe_for_reeval (t))
1914 case 1: /* Mildly unsafe. */
1915 t = unsave_expr (t);
1918 case 2: /* Wildly unsafe. */
1920 tree var = build_decl (VAR_DECL, NULL_TREE,
1923 expand_expr (t, NULL_RTX, VOIDmode, EXPAND_NORMAL));
1934 /* Generate all the code for a function call
1935 and return an rtx for its value.
1936 Store the value in TARGET (specified as an rtx) if convenient.
1937 If the value is stored in TARGET then TARGET is returned.
1938 If IGNORE is nonzero, then we ignore the value of the function call. */
1941 expand_call (tree exp, rtx target, int ignore)
1943 /* Nonzero if we are currently expanding a call. */
1944 static int currently_expanding_call = 0;
1946 /* List of actual parameters. */
1947 tree actparms = TREE_OPERAND (exp, 1);
1948 /* RTX for the function to be called. */
1950 /* Sequence of insns to perform a tail recursive "call". */
1951 rtx tail_recursion_insns = NULL_RTX;
1952 /* Sequence of insns to perform a normal "call". */
1953 rtx normal_call_insns = NULL_RTX;
1954 /* Sequence of insns to perform a tail recursive "call". */
1955 rtx tail_call_insns = NULL_RTX;
1956 /* Data type of the function. */
1958 tree type_arg_types;
1959 /* Declaration of the function being called,
1960 or 0 if the function is computed (not known by name). */
1963 int try_tail_call = 1;
1964 int try_tail_recursion = 1;
1967 /* Register in which non-BLKmode value will be returned,
1968 or 0 if no value or if value is BLKmode. */
1970 /* Address where we should return a BLKmode value;
1971 0 if value not BLKmode. */
1972 rtx structure_value_addr = 0;
1973 /* Nonzero if that address is being passed by treating it as
1974 an extra, implicit first parameter. Otherwise,
1975 it is passed by being copied directly into struct_value_rtx. */
1976 int structure_value_addr_parm = 0;
1977 /* Size of aggregate value wanted, or zero if none wanted
1978 or if we are using the non-reentrant PCC calling convention
1979 or expecting the value in registers. */
1980 HOST_WIDE_INT struct_value_size = 0;
1981 /* Nonzero if called function returns an aggregate in memory PCC style,
1982 by returning the address of where to find it. */
1983 int pcc_struct_value = 0;
1985 /* Number of actual parameters in this call, including struct value addr. */
1987 /* Number of named args. Args after this are anonymous ones
1988 and they must all go on the stack. */
1991 /* Vector of information about each argument.
1992 Arguments are numbered in the order they will be pushed,
1993 not the order they are written. */
1994 struct arg_data *args;
1996 /* Total size in bytes of all the stack-parms scanned so far. */
1997 struct args_size args_size;
1998 struct args_size adjusted_args_size;
1999 /* Size of arguments before any adjustments (such as rounding). */
2000 int unadjusted_args_size;
2001 /* Data on reg parms scanned so far. */
2002 CUMULATIVE_ARGS args_so_far;
2003 /* Nonzero if a reg parm has been scanned. */
2005 /* Nonzero if this is an indirect function call. */
2007 /* Nonzero if we must avoid push-insns in the args for this call.
2008 If stack space is allocated for register parameters, but not by the
2009 caller, then it is preallocated in the fixed part of the stack frame.
2010 So the entire argument block must then be preallocated (i.e., we
2011 ignore PUSH_ROUNDING in that case). */
2013 int must_preallocate = !PUSH_ARGS;
2015 /* Size of the stack reserved for parameter registers. */
2016 int reg_parm_stack_space = 0;
2018 /* Address of space preallocated for stack parms
2019 (on machines that lack push insns), or 0 if space not preallocated. */
2022 /* Mask of ECF_ flags. */
2024 /* Nonzero if this is a call to an inline function. */
2025 int is_integrable = 0;
2026 #ifdef REG_PARM_STACK_SPACE
2027 /* Define the boundary of the register parm stack space that needs to be
2029 int low_to_save, high_to_save;
2030 rtx save_area = 0; /* Place that it is saved */
2033 int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
2034 char *initial_stack_usage_map = stack_usage_map;
2036 int old_stack_allocated;
2038 /* State variables to track stack modifications. */
2039 rtx old_stack_level = 0;
2040 int old_stack_arg_under_construction = 0;
2041 int old_pending_adj = 0;
2042 int old_inhibit_defer_pop = inhibit_defer_pop;
2044 /* Some stack pointer alterations we make are performed via
2045 allocate_dynamic_stack_space. This modifies the stack_pointer_delta,
2046 which we then also need to save/restore along the way. */
2047 int old_stack_pointer_delta = 0;
2050 tree p = TREE_OPERAND (exp, 0);
2051 tree addr = TREE_OPERAND (exp, 0);
2053 /* The alignment of the stack, in bits. */
2054 HOST_WIDE_INT preferred_stack_boundary;
2055 /* The alignment of the stack, in bytes. */
2056 HOST_WIDE_INT preferred_unit_stack_boundary;
2058 /* See if this is "nothrow" function call. */
2059 if (TREE_NOTHROW (exp))
2060 flags |= ECF_NOTHROW;
2062 /* See if we can find a DECL-node for the actual function.
2063 As a result, decide whether this is a call to an integrable function. */
2065 fndecl = get_callee_fndecl (exp);
2069 && fndecl != current_function_decl
2070 && DECL_INLINE (fndecl)
2071 && DECL_SAVED_INSNS (fndecl)
2072 && DECL_SAVED_INSNS (fndecl)->inlinable)
2074 else if (! TREE_ADDRESSABLE (fndecl))
2076 /* In case this function later becomes inlinable,
2077 record that there was already a non-inline call to it.
2079 Use abstraction instead of setting TREE_ADDRESSABLE
2081 if (DECL_INLINE (fndecl) && warn_inline && !flag_no_inline
2084 warning_with_decl (fndecl, "can't inline call to `%s'");
2085 warning ("called from here");
2087 (*lang_hooks.mark_addressable) (fndecl);
2090 flags |= flags_from_decl_or_type (fndecl);
2093 /* If we don't have specific function to call, see if we have a
2094 attributes set in the type. */
2096 flags |= flags_from_decl_or_type (TREE_TYPE (TREE_TYPE (p)));
2098 /* Warn if this value is an aggregate type,
2099 regardless of which calling convention we are using for it. */
2100 if (warn_aggregate_return && AGGREGATE_TYPE_P (TREE_TYPE (exp)))
2101 warning ("function call has aggregate value");
2103 /* If the result of a pure or const function call is ignored (or void),
2104 and none of its arguments are volatile, we can avoid expanding the
2105 call and just evaluate the arguments for side-effects. */
2106 if ((flags & (ECF_CONST | ECF_PURE))
2107 && (ignore || target == const0_rtx
2108 || TYPE_MODE (TREE_TYPE (exp)) == VOIDmode))
2110 bool volatilep = false;
2113 for (arg = actparms; arg; arg = TREE_CHAIN (arg))
2114 if (TREE_THIS_VOLATILE (TREE_VALUE (arg)))
2122 for (arg = actparms; arg; arg = TREE_CHAIN (arg))
2123 expand_expr (TREE_VALUE (arg), const0_rtx,
2124 VOIDmode, EXPAND_NORMAL);
2129 #ifdef REG_PARM_STACK_SPACE
2130 #ifdef MAYBE_REG_PARM_STACK_SPACE
2131 reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
2133 reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
2137 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2138 if (reg_parm_stack_space > 0 && PUSH_ARGS)
2139 must_preallocate = 1;
2142 /* Set up a place to return a structure. */
2144 /* Cater to broken compilers. */
2145 if (aggregate_value_p (exp))
2147 /* This call returns a big structure. */
2148 flags &= ~(ECF_CONST | ECF_PURE | ECF_LIBCALL_BLOCK);
2150 #ifdef PCC_STATIC_STRUCT_RETURN
2152 pcc_struct_value = 1;
2153 /* Easier than making that case work right. */
2156 /* In case this is a static function, note that it has been
2158 if (! TREE_ADDRESSABLE (fndecl))
2159 (*lang_hooks.mark_addressable) (fndecl);
2163 #else /* not PCC_STATIC_STRUCT_RETURN */
2165 struct_value_size = int_size_in_bytes (TREE_TYPE (exp));
2167 if (CALL_EXPR_HAS_RETURN_SLOT_ADDR (exp))
2169 /* The structure value address arg is already in actparms.
2170 Pull it out. It might be nice to just leave it there, but
2171 we need to set structure_value_addr. */
2172 tree return_arg = TREE_VALUE (actparms);
2173 actparms = TREE_CHAIN (actparms);
2174 structure_value_addr = expand_expr (return_arg, NULL_RTX,
2175 VOIDmode, EXPAND_NORMAL);
2177 else if (target && GET_CODE (target) == MEM)
2178 structure_value_addr = XEXP (target, 0);
2181 /* For variable-sized objects, we must be called with a target
2182 specified. If we were to allocate space on the stack here,
2183 we would have no way of knowing when to free it. */
2184 rtx d = assign_temp (TREE_TYPE (exp), 1, 1, 1);
2186 mark_temp_addr_taken (d);
2187 structure_value_addr = XEXP (d, 0);
2191 #endif /* not PCC_STATIC_STRUCT_RETURN */
2194 /* If called function is inline, try to integrate it. */
2198 rtx temp = try_to_integrate (fndecl, actparms, target,
2199 ignore, TREE_TYPE (exp),
2200 structure_value_addr);
2201 if (temp != (rtx) (size_t) - 1)
2205 /* Figure out the amount to which the stack should be aligned. */
2206 preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
2209 struct cgraph_rtl_info *i = cgraph_rtl_info (fndecl);
2210 if (i && i->preferred_incoming_stack_boundary)
2211 preferred_stack_boundary = i->preferred_incoming_stack_boundary;
2214 /* Operand 0 is a pointer-to-function; get the type of the function. */
2215 funtype = TREE_TYPE (addr);
2216 if (! POINTER_TYPE_P (funtype))
2218 funtype = TREE_TYPE (funtype);
2220 /* Munge the tree to split complex arguments into their imaginary
2222 if (SPLIT_COMPLEX_ARGS)
2224 type_arg_types = split_complex_types (TYPE_ARG_TYPES (funtype));
2225 actparms = split_complex_values (actparms);
2228 type_arg_types = TYPE_ARG_TYPES (funtype);
2230 /* See if this is a call to a function that can return more than once
2231 or a call to longjmp or malloc. */
2232 flags |= special_function_p (fndecl, flags);
2234 if (flags & ECF_MAY_BE_ALLOCA)
2235 current_function_calls_alloca = 1;
2237 /* If struct_value_rtx is 0, it means pass the address
2238 as if it were an extra parameter. */
2239 if (structure_value_addr && struct_value_rtx == 0)
2241 /* If structure_value_addr is a REG other than
2242 virtual_outgoing_args_rtx, we can use always use it. If it
2243 is not a REG, we must always copy it into a register.
2244 If it is virtual_outgoing_args_rtx, we must copy it to another
2245 register in some cases. */
2246 rtx temp = (GET_CODE (structure_value_addr) != REG
2247 || (ACCUMULATE_OUTGOING_ARGS
2248 && stack_arg_under_construction
2249 && structure_value_addr == virtual_outgoing_args_rtx)
2250 ? copy_addr_to_reg (structure_value_addr)
2251 : structure_value_addr);
2254 = tree_cons (error_mark_node,
2255 make_tree (build_pointer_type (TREE_TYPE (funtype)),
2258 structure_value_addr_parm = 1;
2261 /* Count the arguments and set NUM_ACTUALS. */
2262 for (p = actparms, num_actuals = 0; p; p = TREE_CHAIN (p))
2265 /* Compute number of named args.
2266 Normally, don't include the last named arg if anonymous args follow.
2267 We do include the last named arg if STRICT_ARGUMENT_NAMING is nonzero.
2268 (If no anonymous args follow, the result of list_length is actually
2269 one too large. This is harmless.)
2271 If PRETEND_OUTGOING_VARARGS_NAMED is set and STRICT_ARGUMENT_NAMING is
2272 zero, this machine will be able to place unnamed args that were
2273 passed in registers into the stack. So treat all args as named.
2274 This allows the insns emitting for a specific argument list to be
2275 independent of the function declaration.
2277 If PRETEND_OUTGOING_VARARGS_NAMED is not set, we do not have any
2278 reliable way to pass unnamed args in registers, so we must force
2279 them into memory. */
2281 if ((STRICT_ARGUMENT_NAMING
2282 || ! PRETEND_OUTGOING_VARARGS_NAMED)
2283 && type_arg_types != 0)
2285 = (list_length (type_arg_types)
2286 /* Don't include the last named arg. */
2287 - (STRICT_ARGUMENT_NAMING ? 0 : 1)
2288 /* Count the struct value address, if it is passed as a parm. */
2289 + structure_value_addr_parm);
2291 /* If we know nothing, treat all args as named. */
2292 n_named_args = num_actuals;
2294 /* Start updating where the next arg would go.
2296 On some machines (such as the PA) indirect calls have a different
2297 calling convention than normal calls. The last argument in
2298 INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
2300 INIT_CUMULATIVE_ARGS (args_so_far, funtype, NULL_RTX, fndecl);
2302 /* Make a vector to hold all the information about each arg. */
2303 args = (struct arg_data *) alloca (num_actuals * sizeof (struct arg_data));
2304 memset ((char *) args, 0, num_actuals * sizeof (struct arg_data));
2306 /* Build up entries in the ARGS array, compute the size of the
2307 arguments into ARGS_SIZE, etc. */
2308 initialize_argument_information (num_actuals, args, &args_size,
2309 n_named_args, actparms, fndecl,
2310 &args_so_far, reg_parm_stack_space,
2311 &old_stack_level, &old_pending_adj,
2312 &must_preallocate, &flags);
2316 /* If this function requires a variable-sized argument list, don't
2317 try to make a cse'able block for this call. We may be able to
2318 do this eventually, but it is too complicated to keep track of
2319 what insns go in the cse'able block and which don't. */
2321 flags &= ~ECF_LIBCALL_BLOCK;
2322 must_preallocate = 1;
2325 /* Now make final decision about preallocating stack space. */
2326 must_preallocate = finalize_must_preallocate (must_preallocate,
2330 /* If the structure value address will reference the stack pointer, we
2331 must stabilize it. We don't need to do this if we know that we are
2332 not going to adjust the stack pointer in processing this call. */
2334 if (structure_value_addr
2335 && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
2336 || reg_mentioned_p (virtual_outgoing_args_rtx,
2337 structure_value_addr))
2339 || (!ACCUMULATE_OUTGOING_ARGS && args_size.constant)))
2340 structure_value_addr = copy_to_reg (structure_value_addr);
2342 /* Tail calls can make things harder to debug, and we're traditionally
2343 pushed these optimizations into -O2. Don't try if we're already
2344 expanding a call, as that means we're an argument. Don't try if
2345 there's cleanups, as we know there's code to follow the call.
2347 If rtx_equal_function_value_matters is false, that means we've
2348 finished with regular parsing. Which means that some of the
2349 machinery we use to generate tail-calls is no longer in place.
2350 This is most often true of sjlj-exceptions, which we couldn't
2351 tail-call to anyway. */
2353 if (currently_expanding_call++ != 0
2354 || !flag_optimize_sibling_calls
2355 || !rtx_equal_function_value_matters
2356 || any_pending_cleanups ()
2358 try_tail_call = try_tail_recursion = 0;
2360 /* Tail recursion fails, when we are not dealing with recursive calls. */
2361 if (!try_tail_recursion
2362 || TREE_CODE (addr) != ADDR_EXPR
2363 || TREE_OPERAND (addr, 0) != current_function_decl)
2364 try_tail_recursion = 0;
2366 /* Rest of purposes for tail call optimizations to fail. */
2368 #ifdef HAVE_sibcall_epilogue
2369 !HAVE_sibcall_epilogue
2374 /* Doing sibling call optimization needs some work, since
2375 structure_value_addr can be allocated on the stack.
2376 It does not seem worth the effort since few optimizable
2377 sibling calls will return a structure. */
2378 || structure_value_addr != NULL_RTX
2379 /* Check whether the target is able to optimize the call
2381 || !(*targetm.function_ok_for_sibcall) (fndecl, exp)
2382 /* Functions that do not return exactly once may not be sibcall
2384 || (flags & (ECF_RETURNS_TWICE | ECF_LONGJMP | ECF_NORETURN))
2385 || TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (addr)))
2386 /* If the called function is nested in the current one, it might access
2387 some of the caller's arguments, but could clobber them beforehand if
2388 the argument areas are shared. */
2389 || (fndecl && decl_function_context (fndecl) == current_function_decl)
2390 /* If this function requires more stack slots than the current
2391 function, we cannot change it into a sibling call. */
2392 || args_size.constant > current_function_args_size
2393 /* If the callee pops its own arguments, then it must pop exactly
2394 the same number of arguments as the current function. */
2395 || (RETURN_POPS_ARGS (fndecl, funtype, args_size.constant)
2396 != RETURN_POPS_ARGS (current_function_decl,
2397 TREE_TYPE (current_function_decl),
2398 current_function_args_size))
2399 || !(*lang_hooks.decls.ok_for_sibcall) (fndecl))
2402 if (try_tail_call || try_tail_recursion)
2405 actparms = NULL_TREE;
2406 /* Ok, we're going to give the tail call the old college try.
2407 This means we're going to evaluate the function arguments
2408 up to three times. There are two degrees of badness we can
2409 encounter, those that can be unsaved and those that can't.
2410 (See unsafe_for_reeval commentary for details.)
2412 Generate a new argument list. Pass safe arguments through
2413 unchanged. For the easy badness wrap them in UNSAVE_EXPRs.
2414 For hard badness, evaluate them now and put their resulting
2415 rtx in a temporary VAR_DECL.
2417 initialize_argument_information has ordered the array for the
2418 order to be pushed, and we must remember this when reconstructing
2419 the original argument order. */
2421 if (PUSH_ARGS_REVERSED)
2430 i = num_actuals - 1;
2434 for (; i != end; i += inc)
2436 args[i].tree_value = fix_unsafe_tree (args[i].tree_value);
2437 /* We need to build actparms for optimize_tail_recursion. We can
2438 safely trash away TREE_PURPOSE, since it is unused by this
2440 if (try_tail_recursion)
2441 actparms = tree_cons (NULL_TREE, args[i].tree_value, actparms);
2443 /* Do the same for the function address if it is an expression. */
2445 addr = fix_unsafe_tree (addr);
2446 /* Expanding one of those dangerous arguments could have added
2447 cleanups, but otherwise give it a whirl. */
2448 if (any_pending_cleanups ())
2449 try_tail_call = try_tail_recursion = 0;
2452 /* Generate a tail recursion sequence when calling ourselves. */
2454 if (try_tail_recursion)
2456 /* We want to emit any pending stack adjustments before the tail
2457 recursion "call". That way we know any adjustment after the tail
2458 recursion call can be ignored if we indeed use the tail recursion
2460 int save_pending_stack_adjust = pending_stack_adjust;
2461 int save_stack_pointer_delta = stack_pointer_delta;
2463 /* Emit any queued insns now; otherwise they would end up in
2464 only one of the alternates. */
2467 /* Use a new sequence to hold any RTL we generate. We do not even
2468 know if we will use this RTL yet. The final decision can not be
2469 made until after RTL generation for the entire function is
2472 /* If expanding any of the arguments creates cleanups, we can't
2473 do a tailcall. So, we'll need to pop the pending cleanups
2474 list. If, however, all goes well, and there are no cleanups
2475 then the call to expand_start_target_temps will have no
2477 expand_start_target_temps ();
2478 if (optimize_tail_recursion (actparms, get_last_insn ()))
2480 if (any_pending_cleanups ())
2481 try_tail_call = try_tail_recursion = 0;
2483 tail_recursion_insns = get_insns ();
2485 expand_end_target_temps ();
2488 /* Restore the original pending stack adjustment for the sibling and
2489 normal call cases below. */
2490 pending_stack_adjust = save_pending_stack_adjust;
2491 stack_pointer_delta = save_stack_pointer_delta;
2494 if (profile_arc_flag && (flags & ECF_FORK_OR_EXEC))
2496 /* A fork duplicates the profile information, and an exec discards
2497 it. We can't rely on fork/exec to be paired. So write out the
2498 profile information we have gathered so far, and clear it. */
2499 /* ??? When Linux's __clone is called with CLONE_VM set, profiling
2500 is subject to race conditions, just as with multithreaded
2503 emit_library_call (gcov_flush_libfunc, LCT_ALWAYS_RETURN, VOIDmode, 0);
2506 /* Ensure current function's preferred stack boundary is at least
2507 what we need. We don't have to increase alignment for recursive
2509 if (cfun->preferred_stack_boundary < preferred_stack_boundary
2510 && fndecl != current_function_decl)
2511 cfun->preferred_stack_boundary = preferred_stack_boundary;
2512 if (fndecl == current_function_decl)
2513 cfun->recursive_call_emit = true;
2515 preferred_unit_stack_boundary = preferred_stack_boundary / BITS_PER_UNIT;
2517 function_call_count++;
2519 /* We want to make two insn chains; one for a sibling call, the other
2520 for a normal call. We will select one of the two chains after
2521 initial RTL generation is complete. */
2522 for (pass = try_tail_call ? 0 : 1; pass < 2; pass++)
2524 int sibcall_failure = 0;
2525 /* We want to emit any pending stack adjustments before the tail
2526 recursion "call". That way we know any adjustment after the tail
2527 recursion call can be ignored if we indeed use the tail recursion
2529 int save_pending_stack_adjust = 0;
2530 int save_stack_pointer_delta = 0;
2532 rtx before_call, next_arg_reg;
2536 /* Emit any queued insns now; otherwise they would end up in
2537 only one of the alternates. */
2540 /* State variables we need to save and restore between
2542 save_pending_stack_adjust = pending_stack_adjust;
2543 save_stack_pointer_delta = stack_pointer_delta;
2546 flags &= ~ECF_SIBCALL;
2548 flags |= ECF_SIBCALL;
2550 /* Other state variables that we must reinitialize each time
2551 through the loop (that are not initialized by the loop itself). */
2555 /* Start a new sequence for the normal call case.
2557 From this point on, if the sibling call fails, we want to set
2558 sibcall_failure instead of continuing the loop. */
2563 /* We know at this point that there are not currently any
2564 pending cleanups. If, however, in the process of evaluating
2565 the arguments we were to create some, we'll need to be
2566 able to get rid of them. */
2567 expand_start_target_temps ();
2570 /* Don't let pending stack adjusts add up to too much.
2571 Also, do all pending adjustments now if there is any chance
2572 this might be a call to alloca or if we are expanding a sibling
2573 call sequence or if we are calling a function that is to return
2574 with stack pointer depressed. */
2575 if (pending_stack_adjust >= 32
2576 || (pending_stack_adjust > 0
2577 && (flags & (ECF_MAY_BE_ALLOCA | ECF_SP_DEPRESSED)))
2579 do_pending_stack_adjust ();
2581 /* When calling a const function, we must pop the stack args right away,
2582 so that the pop is deleted or moved with the call. */
2583 if (pass && (flags & ECF_LIBCALL_BLOCK))
2586 #ifdef FINAL_REG_PARM_STACK_SPACE
2587 reg_parm_stack_space = FINAL_REG_PARM_STACK_SPACE (args_size.constant,
2590 /* Precompute any arguments as needed. */
2592 precompute_arguments (flags, num_actuals, args);
2594 /* Now we are about to start emitting insns that can be deleted
2595 if a libcall is deleted. */
2596 if (pass && (flags & (ECF_LIBCALL_BLOCK | ECF_MALLOC)))
2599 adjusted_args_size = args_size;
2600 /* Compute the actual size of the argument block required. The variable
2601 and constant sizes must be combined, the size may have to be rounded,
2602 and there may be a minimum required size. When generating a sibcall
2603 pattern, do not round up, since we'll be re-using whatever space our
2605 unadjusted_args_size
2606 = compute_argument_block_size (reg_parm_stack_space,
2607 &adjusted_args_size,
2609 : preferred_stack_boundary));
2611 old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
2613 /* The argument block when performing a sibling call is the
2614 incoming argument block. */
2617 argblock = virtual_incoming_args_rtx;
2619 #ifdef STACK_GROWS_DOWNWARD
2620 = plus_constant (argblock, current_function_pretend_args_size);
2622 = plus_constant (argblock, -current_function_pretend_args_size);
2624 stored_args_map = sbitmap_alloc (args_size.constant);
2625 sbitmap_zero (stored_args_map);
2628 /* If we have no actual push instructions, or shouldn't use them,
2629 make space for all args right now. */
2630 else if (adjusted_args_size.var != 0)
2632 if (old_stack_level == 0)
2634 emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
2635 old_stack_pointer_delta = stack_pointer_delta;
2636 old_pending_adj = pending_stack_adjust;
2637 pending_stack_adjust = 0;
2638 /* stack_arg_under_construction says whether a stack arg is
2639 being constructed at the old stack level. Pushing the stack
2640 gets a clean outgoing argument block. */
2641 old_stack_arg_under_construction = stack_arg_under_construction;
2642 stack_arg_under_construction = 0;
2644 argblock = push_block (ARGS_SIZE_RTX (adjusted_args_size), 0, 0);
2648 /* Note that we must go through the motions of allocating an argument
2649 block even if the size is zero because we may be storing args
2650 in the area reserved for register arguments, which may be part of
2653 int needed = adjusted_args_size.constant;
2655 /* Store the maximum argument space used. It will be pushed by
2656 the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
2659 if (needed > current_function_outgoing_args_size)
2660 current_function_outgoing_args_size = needed;
2662 if (must_preallocate)
2664 if (ACCUMULATE_OUTGOING_ARGS)
2666 /* Since the stack pointer will never be pushed, it is
2667 possible for the evaluation of a parm to clobber
2668 something we have already written to the stack.
2669 Since most function calls on RISC machines do not use
2670 the stack, this is uncommon, but must work correctly.
2672 Therefore, we save any area of the stack that was already
2673 written and that we are using. Here we set up to do this
2674 by making a new stack usage map from the old one. The
2675 actual save will be done by store_one_arg.
2677 Another approach might be to try to reorder the argument
2678 evaluations to avoid this conflicting stack usage. */
2680 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2681 /* Since we will be writing into the entire argument area,
2682 the map must be allocated for its entire size, not just
2683 the part that is the responsibility of the caller. */
2684 needed += reg_parm_stack_space;
2687 #ifdef ARGS_GROW_DOWNWARD
2688 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
2691 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
2695 = (char *) alloca (highest_outgoing_arg_in_use);
2697 if (initial_highest_arg_in_use)
2698 memcpy (stack_usage_map, initial_stack_usage_map,
2699 initial_highest_arg_in_use);
2701 if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
2702 memset (&stack_usage_map[initial_highest_arg_in_use], 0,
2703 (highest_outgoing_arg_in_use
2704 - initial_highest_arg_in_use));
2707 /* The address of the outgoing argument list must not be
2708 copied to a register here, because argblock would be left
2709 pointing to the wrong place after the call to
2710 allocate_dynamic_stack_space below. */
2712 argblock = virtual_outgoing_args_rtx;
2716 if (inhibit_defer_pop == 0)
2718 /* Try to reuse some or all of the pending_stack_adjust
2719 to get this space. */
2721 = (combine_pending_stack_adjustment_and_call
2722 (unadjusted_args_size,
2723 &adjusted_args_size,
2724 preferred_unit_stack_boundary));
2726 /* combine_pending_stack_adjustment_and_call computes
2727 an adjustment before the arguments are allocated.
2728 Account for them and see whether or not the stack
2729 needs to go up or down. */
2730 needed = unadjusted_args_size - needed;
2734 /* We're releasing stack space. */
2735 /* ??? We can avoid any adjustment at all if we're
2736 already aligned. FIXME. */
2737 pending_stack_adjust = -needed;
2738 do_pending_stack_adjust ();
2742 /* We need to allocate space. We'll do that in
2743 push_block below. */
2744 pending_stack_adjust = 0;
2747 /* Special case this because overhead of `push_block' in
2748 this case is non-trivial. */
2750 argblock = virtual_outgoing_args_rtx;
2753 argblock = push_block (GEN_INT (needed), 0, 0);
2754 #ifdef ARGS_GROW_DOWNWARD
2755 argblock = plus_constant (argblock, needed);
2759 /* We only really need to call `copy_to_reg' in the case
2760 where push insns are going to be used to pass ARGBLOCK
2761 to a function call in ARGS. In that case, the stack
2762 pointer changes value from the allocation point to the
2763 call point, and hence the value of
2764 VIRTUAL_OUTGOING_ARGS_RTX changes as well. But might
2765 as well always do it. */
2766 argblock = copy_to_reg (argblock);
2771 if (ACCUMULATE_OUTGOING_ARGS)
2773 /* The save/restore code in store_one_arg handles all
2774 cases except one: a constructor call (including a C
2775 function returning a BLKmode struct) to initialize
2777 if (stack_arg_under_construction)
2779 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2780 rtx push_size = GEN_INT (reg_parm_stack_space
2781 + adjusted_args_size.constant);
2783 rtx push_size = GEN_INT (adjusted_args_size.constant);
2785 if (old_stack_level == 0)
2787 emit_stack_save (SAVE_BLOCK, &old_stack_level,
2789 old_stack_pointer_delta = stack_pointer_delta;
2790 old_pending_adj = pending_stack_adjust;
2791 pending_stack_adjust = 0;
2792 /* stack_arg_under_construction says whether a stack
2793 arg is being constructed at the old stack level.
2794 Pushing the stack gets a clean outgoing argument
2796 old_stack_arg_under_construction
2797 = stack_arg_under_construction;
2798 stack_arg_under_construction = 0;
2799 /* Make a new map for the new argument list. */
2800 stack_usage_map = (char *)
2801 alloca (highest_outgoing_arg_in_use);
2802 memset (stack_usage_map, 0, highest_outgoing_arg_in_use);
2803 highest_outgoing_arg_in_use = 0;
2805 allocate_dynamic_stack_space (push_size, NULL_RTX,
2809 /* If argument evaluation might modify the stack pointer,
2810 copy the address of the argument list to a register. */
2811 for (i = 0; i < num_actuals; i++)
2812 if (args[i].pass_on_stack)
2814 argblock = copy_addr_to_reg (argblock);
2819 compute_argument_addresses (args, argblock, num_actuals);
2821 /* If we push args individually in reverse order, perform stack alignment
2822 before the first push (the last arg). */
2823 if (PUSH_ARGS_REVERSED && argblock == 0
2824 && adjusted_args_size.constant != unadjusted_args_size)
2826 /* When the stack adjustment is pending, we get better code
2827 by combining the adjustments. */
2828 if (pending_stack_adjust
2829 && ! (flags & ECF_LIBCALL_BLOCK)
2830 && ! inhibit_defer_pop)
2832 pending_stack_adjust
2833 = (combine_pending_stack_adjustment_and_call
2834 (unadjusted_args_size,
2835 &adjusted_args_size,
2836 preferred_unit_stack_boundary));
2837 do_pending_stack_adjust ();
2839 else if (argblock == 0)
2840 anti_adjust_stack (GEN_INT (adjusted_args_size.constant
2841 - unadjusted_args_size));
2843 /* Now that the stack is properly aligned, pops can't safely
2844 be deferred during the evaluation of the arguments. */
2847 funexp = rtx_for_function_call (fndecl, addr);
2849 /* Figure out the register where the value, if any, will come back. */
2851 if (TYPE_MODE (TREE_TYPE (exp)) != VOIDmode
2852 && ! structure_value_addr)
2854 if (pcc_struct_value)
2855 valreg = hard_function_value (build_pointer_type (TREE_TYPE (exp)),
2856 fndecl, (pass == 0));
2858 valreg = hard_function_value (TREE_TYPE (exp), fndecl, (pass == 0));
2861 /* Precompute all register parameters. It isn't safe to compute anything
2862 once we have started filling any specific hard regs. */
2863 precompute_register_parameters (num_actuals, args, ®_parm_seen);
2865 #ifdef REG_PARM_STACK_SPACE
2866 /* Save the fixed argument area if it's part of the caller's frame and
2867 is clobbered by argument setup for this call. */
2868 if (ACCUMULATE_OUTGOING_ARGS && pass)
2869 save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
2870 &low_to_save, &high_to_save);
2873 /* Now store (and compute if necessary) all non-register parms.
2874 These come before register parms, since they can require block-moves,
2875 which could clobber the registers used for register parms.
2876 Parms which have partial registers are not stored here,
2877 but we do preallocate space here if they want that. */
2879 for (i = 0; i < num_actuals; i++)
2880 if (args[i].reg == 0 || args[i].pass_on_stack)
2882 rtx before_arg = get_last_insn ();
2884 if (store_one_arg (&args[i], argblock, flags,
2885 adjusted_args_size.var != 0,
2886 reg_parm_stack_space)
2888 && check_sibcall_argument_overlap (before_arg,
2890 sibcall_failure = 1;
2893 /* If we have a parm that is passed in registers but not in memory
2894 and whose alignment does not permit a direct copy into registers,
2895 make a group of pseudos that correspond to each register that we
2897 if (STRICT_ALIGNMENT)
2898 store_unaligned_arguments_into_pseudos (args, num_actuals);
2900 /* Now store any partially-in-registers parm.
2901 This is the last place a block-move can happen. */
2903 for (i = 0; i < num_actuals; i++)
2904 if (args[i].partial != 0 && ! args[i].pass_on_stack)
2906 rtx before_arg = get_last_insn ();
2908 if (store_one_arg (&args[i], argblock, flags,
2909 adjusted_args_size.var != 0,
2910 reg_parm_stack_space)
2912 && check_sibcall_argument_overlap (before_arg,
2914 sibcall_failure = 1;
2917 /* If we pushed args in forward order, perform stack alignment
2918 after pushing the last arg. */
2919 if (!PUSH_ARGS_REVERSED && argblock == 0)
2920 anti_adjust_stack (GEN_INT (adjusted_args_size.constant
2921 - unadjusted_args_size));
2923 /* If register arguments require space on the stack and stack space
2924 was not preallocated, allocate stack space here for arguments
2925 passed in registers. */
2926 #ifdef OUTGOING_REG_PARM_STACK_SPACE
2927 if (!ACCUMULATE_OUTGOING_ARGS
2928 && must_preallocate == 0 && reg_parm_stack_space > 0)
2929 anti_adjust_stack (GEN_INT (reg_parm_stack_space));
2932 /* Pass the function the address in which to return a
2934 if (pass != 0 && structure_value_addr && ! structure_value_addr_parm)
2936 #ifdef POINTERS_EXTEND_UNSIGNED
2937 if (GET_MODE (structure_value_addr) != Pmode)
2938 structure_value_addr = convert_memory_address
2939 (Pmode, structure_value_addr);
2941 emit_move_insn (struct_value_rtx,
2943 force_operand (structure_value_addr,
2946 if (GET_CODE (struct_value_rtx) == REG)
2947 use_reg (&call_fusage, struct_value_rtx);
2950 funexp = prepare_call_address (funexp, fndecl, &call_fusage,
2951 reg_parm_seen, pass == 0);
2953 load_register_parameters (args, num_actuals, &call_fusage, flags,
2954 pass == 0, &sibcall_failure);
2956 /* Perform postincrements before actually calling the function. */
2959 /* Save a pointer to the last insn before the call, so that we can
2960 later safely search backwards to find the CALL_INSN. */
2961 before_call = get_last_insn ();
2963 /* Set up next argument register. For sibling calls on machines
2964 with register windows this should be the incoming register. */
2965 #ifdef FUNCTION_INCOMING_ARG
2967 next_arg_reg = FUNCTION_INCOMING_ARG (args_so_far, VOIDmode,
2971 next_arg_reg = FUNCTION_ARG (args_so_far, VOIDmode,
2974 /* All arguments and registers used for the call must be set up by
2977 /* Stack must be properly aligned now. */
2978 if (pass && stack_pointer_delta % preferred_unit_stack_boundary)
2981 /* Generate the actual call instruction. */
2982 emit_call_1 (funexp, fndecl, funtype, unadjusted_args_size,
2983 adjusted_args_size.constant, struct_value_size,
2984 next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
2985 flags, & args_so_far);
2987 /* If call is cse'able, make appropriate pair of reg-notes around it.
2988 Test valreg so we don't crash; may safely ignore `const'
2989 if return type is void. Disable for PARALLEL return values, because
2990 we have no way to move such values into a pseudo register. */
2991 if (pass && (flags & ECF_LIBCALL_BLOCK))
2995 if (valreg == 0 || GET_CODE (valreg) == PARALLEL)
2997 insns = get_insns ();
3004 rtx temp = gen_reg_rtx (GET_MODE (valreg));
3006 /* Mark the return value as a pointer if needed. */
3007 if (TREE_CODE (TREE_TYPE (exp)) == POINTER_TYPE)
3008 mark_reg_pointer (temp,
3009 TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp))));
3011 /* Construct an "equal form" for the value which mentions all the
3012 arguments in order as well as the function name. */
3013 for (i = 0; i < num_actuals; i++)
3014 note = gen_rtx_EXPR_LIST (VOIDmode,
3015 args[i].initial_value, note);
3016 note = gen_rtx_EXPR_LIST (VOIDmode, funexp, note);
3018 insns = get_insns ();
3021 if (flags & ECF_PURE)
3022 note = gen_rtx_EXPR_LIST (VOIDmode,
3023 gen_rtx_USE (VOIDmode,
3024 gen_rtx_MEM (BLKmode,
3025 gen_rtx_SCRATCH (VOIDmode))),
3028 emit_libcall_block (insns, temp, valreg, note);
3033 else if (pass && (flags & ECF_MALLOC))
3035 rtx temp = gen_reg_rtx (GET_MODE (valreg));
3038 /* The return value from a malloc-like function is a pointer. */
3039 if (TREE_CODE (TREE_TYPE (exp)) == POINTER_TYPE)
3040 mark_reg_pointer (temp, BIGGEST_ALIGNMENT);
3042 emit_move_insn (temp, valreg);
3044 /* The return value from a malloc-like function can not alias
3046 last = get_last_insn ();
3048 gen_rtx_EXPR_LIST (REG_NOALIAS, temp, REG_NOTES (last));
3050 /* Write out the sequence. */
3051 insns = get_insns ();
3057 /* For calls to `setjmp', etc., inform flow.c it should complain
3058 if nonvolatile values are live. For functions that cannot return,
3059 inform flow that control does not fall through. */
3061 if ((flags & (ECF_NORETURN | ECF_LONGJMP)) || pass == 0)
3063 /* The barrier must be emitted
3064 immediately after the CALL_INSN. Some ports emit more
3065 than just a CALL_INSN above, so we must search for it here. */
3067 rtx last = get_last_insn ();
3068 while (GET_CODE (last) != CALL_INSN)
3070 last = PREV_INSN (last);
3071 /* There was no CALL_INSN? */
3072 if (last == before_call)
3076 emit_barrier_after (last);
3079 if (flags & ECF_LONGJMP)
3080 current_function_calls_longjmp = 1;
3082 /* If value type not void, return an rtx for the value. */
3084 /* If there are cleanups to be called, don't use a hard reg as target.
3085 We need to double check this and see if it matters anymore. */
3086 if (any_pending_cleanups ())
3088 if (target && REG_P (target)
3089 && REGNO (target) < FIRST_PSEUDO_REGISTER)
3091 sibcall_failure = 1;
3094 if (TYPE_MODE (TREE_TYPE (exp)) == VOIDmode
3096 target = const0_rtx;
3097 else if (structure_value_addr)
3099 if (target == 0 || GET_CODE (target) != MEM)
3102 = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
3103 memory_address (TYPE_MODE (TREE_TYPE (exp)),
3104 structure_value_addr));
3105 set_mem_attributes (target, exp, 1);
3108 else if (pcc_struct_value)
3110 /* This is the special C++ case where we need to
3111 know what the true target was. We take care to
3112 never use this value more than once in one expression. */
3113 target = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
3114 copy_to_reg (valreg));
3115 set_mem_attributes (target, exp, 1);
3117 /* Handle calls that return values in multiple non-contiguous locations.
3118 The Irix 6 ABI has examples of this. */
3119 else if (GET_CODE (valreg) == PARALLEL)
3123 /* This will only be assigned once, so it can be readonly. */
3124 tree nt = build_qualified_type (TREE_TYPE (exp),
3125 (TYPE_QUALS (TREE_TYPE (exp))
3126 | TYPE_QUAL_CONST));
3128 target = assign_temp (nt, 0, 1, 1);
3129 preserve_temp_slots (target);
3132 if (! rtx_equal_p (target, valreg))
3133 emit_group_store (target, valreg,
3134 int_size_in_bytes (TREE_TYPE (exp)));
3136 /* We can not support sibling calls for this case. */
3137 sibcall_failure = 1;
3140 && GET_MODE (target) == TYPE_MODE (TREE_TYPE (exp))
3141 && GET_MODE (target) == GET_MODE (valreg))
3143 /* TARGET and VALREG cannot be equal at this point because the
3144 latter would not have REG_FUNCTION_VALUE_P true, while the
3145 former would if it were referring to the same register.
3147 If they refer to the same register, this move will be a no-op,
3148 except when function inlining is being done. */
3149 emit_move_insn (target, valreg);
3151 /* If we are setting a MEM, this code must be executed. Since it is
3152 emitted after the call insn, sibcall optimization cannot be
3153 performed in that case. */
3154 if (GET_CODE (target) == MEM)
3155 sibcall_failure = 1;
3157 else if (TYPE_MODE (TREE_TYPE (exp)) == BLKmode)
3159 target = copy_blkmode_from_reg (target, valreg, TREE_TYPE (exp));
3161 /* We can not support sibling calls for this case. */
3162 sibcall_failure = 1;
3165 target = copy_to_reg (valreg);
3167 #ifdef PROMOTE_FUNCTION_RETURN
3168 /* If we promoted this return value, make the proper SUBREG. TARGET
3169 might be const0_rtx here, so be careful. */
3170 if (GET_CODE (target) == REG
3171 && TYPE_MODE (TREE_TYPE (exp)) != BLKmode
3172 && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
3174 tree type = TREE_TYPE (exp);
3175 int unsignedp = TREE_UNSIGNED (type);
3178 /* If we don't promote as expected, something is wrong. */
3179 if (GET_MODE (target)
3180 != promote_mode (type, TYPE_MODE (type), &unsignedp, 1))
3183 if ((WORDS_BIG_ENDIAN || BYTES_BIG_ENDIAN)
3184 && GET_MODE_SIZE (GET_MODE (target))
3185 > GET_MODE_SIZE (TYPE_MODE (type)))
3187 offset = GET_MODE_SIZE (GET_MODE (target))
3188 - GET_MODE_SIZE (TYPE_MODE (type));
3189 if (! BYTES_BIG_ENDIAN)
3190 offset = (offset / UNITS_PER_WORD) * UNITS_PER_WORD;
3191 else if (! WORDS_BIG_ENDIAN)
3192 offset %= UNITS_PER_WORD;
3194 target = gen_rtx_SUBREG (TYPE_MODE (type), target, offset);
3195 SUBREG_PROMOTED_VAR_P (target) = 1;
3196 SUBREG_PROMOTED_UNSIGNED_SET (target, unsignedp);
3200 /* If size of args is variable or this was a constructor call for a stack
3201 argument, restore saved stack-pointer value. */
3203 if (old_stack_level && ! (flags & ECF_SP_DEPRESSED))
3205 emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
3206 stack_pointer_delta = old_stack_pointer_delta;
3207 pending_stack_adjust = old_pending_adj;
3208 stack_arg_under_construction = old_stack_arg_under_construction;
3209 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3210 stack_usage_map = initial_stack_usage_map;
3211 sibcall_failure = 1;
3213 else if (ACCUMULATE_OUTGOING_ARGS && pass)
3215 #ifdef REG_PARM_STACK_SPACE
3217 restore_fixed_argument_area (save_area, argblock,
3218 high_to_save, low_to_save);
3221 /* If we saved any argument areas, restore them. */
3222 for (i = 0; i < num_actuals; i++)
3223 if (args[i].save_area)
3225 enum machine_mode save_mode = GET_MODE (args[i].save_area);
3227 = gen_rtx_MEM (save_mode,
3228 memory_address (save_mode,
3229 XEXP (args[i].stack_slot, 0)));
3231 if (save_mode != BLKmode)
3232 emit_move_insn (stack_area, args[i].save_area);
3234 emit_block_move (stack_area, args[i].save_area,
3235 GEN_INT (args[i].locate.size.constant),
3236 BLOCK_OP_CALL_PARM);
3239 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3240 stack_usage_map = initial_stack_usage_map;
3243 /* If this was alloca, record the new stack level for nonlocal gotos.
3244 Check for the handler slots since we might not have a save area
3245 for non-local gotos. */
3247 if ((flags & ECF_MAY_BE_ALLOCA) && nonlocal_goto_handler_slots != 0)
3248 emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
3250 /* Free up storage we no longer need. */
3251 for (i = 0; i < num_actuals; ++i)
3252 if (args[i].aligned_regs)
3253 free (args[i].aligned_regs);
3257 /* Undo the fake expand_start_target_temps we did earlier. If
3258 there had been any cleanups created, we've already set
3260 expand_end_target_temps ();
3263 /* If this function is returning into a memory location marked as
3264 readonly, it means it is initializing that location. We normally treat
3265 functions as not clobbering such locations, so we need to specify that
3266 this one does. We do this by adding the appropriate CLOBBER to the
3267 CALL_INSN function usage list. This cannot be done by emitting a
3268 standalone CLOBBER after the call because the latter would be ignored
3269 by at least the delay slot scheduling pass. We do this now instead of
3270 adding to call_fusage before the call to emit_call_1 because TARGET
3271 may be modified in the meantime. */
3272 if (structure_value_addr != 0 && target != 0
3273 && GET_CODE (target) == MEM && RTX_UNCHANGING_P (target))
3274 add_function_usage_to
3276 gen_rtx_EXPR_LIST (VOIDmode, gen_rtx_CLOBBER (VOIDmode, target),
3279 insns = get_insns ();
3284 tail_call_insns = insns;
3286 /* Restore the pending stack adjustment now that we have
3287 finished generating the sibling call sequence. */
3289 pending_stack_adjust = save_pending_stack_adjust;
3290 stack_pointer_delta = save_stack_pointer_delta;
3292 /* Prepare arg structure for next iteration. */
3293 for (i = 0; i < num_actuals; i++)
3296 args[i].aligned_regs = 0;
3300 sbitmap_free (stored_args_map);
3304 normal_call_insns = insns;
3306 /* Verify that we've deallocated all the stack we used. */
3307 if (old_stack_allocated !=
3308 stack_pointer_delta - pending_stack_adjust)
3312 /* If something prevents making this a sibling call,
3313 zero out the sequence. */
3314 if (sibcall_failure)
3315 tail_call_insns = NULL_RTX;
3318 /* The function optimize_sibling_and_tail_recursive_calls doesn't
3319 handle CALL_PLACEHOLDERs inside other CALL_PLACEHOLDERs. This
3320 can happen if the arguments to this function call an inline
3321 function who's expansion contains another CALL_PLACEHOLDER.
3323 If there are any C_Ps in any of these sequences, replace them
3324 with their normal call. */
3326 for (insn = normal_call_insns; insn; insn = NEXT_INSN (insn))
3327 if (GET_CODE (insn) == CALL_INSN
3328 && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
3329 replace_call_placeholder (insn, sibcall_use_normal);
3331 for (insn = tail_call_insns; insn; insn = NEXT_INSN (insn))
3332 if (GET_CODE (insn) == CALL_INSN
3333 && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
3334 replace_call_placeholder (insn, sibcall_use_normal);
3336 for (insn = tail_recursion_insns; insn; insn = NEXT_INSN (insn))
3337 if (GET_CODE (insn) == CALL_INSN
3338 && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
3339 replace_call_placeholder (insn, sibcall_use_normal);
3341 /* If this was a potential tail recursion site, then emit a
3342 CALL_PLACEHOLDER with the normal and the tail recursion streams.
3343 One of them will be selected later. */
3344 if (tail_recursion_insns || tail_call_insns)
3346 /* The tail recursion label must be kept around. We could expose
3347 its use in the CALL_PLACEHOLDER, but that creates unwanted edges
3348 and makes determining true tail recursion sites difficult.
3350 So we set LABEL_PRESERVE_P here, then clear it when we select
3351 one of the call sequences after rtl generation is complete. */
3352 if (tail_recursion_insns)
3353 LABEL_PRESERVE_P (tail_recursion_label) = 1;
3354 emit_call_insn (gen_rtx_CALL_PLACEHOLDER (VOIDmode, normal_call_insns,
3356 tail_recursion_insns,
3357 tail_recursion_label));
3360 emit_insn (normal_call_insns);
3362 currently_expanding_call--;
3364 /* If this function returns with the stack pointer depressed, ensure
3365 this block saves and restores the stack pointer, show it was
3366 changed, and adjust for any outgoing arg space. */
3367 if (flags & ECF_SP_DEPRESSED)
3369 clear_pending_stack_adjust ();
3370 emit_insn (gen_rtx (CLOBBER, VOIDmode, stack_pointer_rtx));
3371 emit_move_insn (virtual_stack_dynamic_rtx, stack_pointer_rtx);
3372 save_stack_pointer ();
3378 /* Traverse an argument list in VALUES and expand all complex
3379 arguments into their components. */
3381 split_complex_values (tree values)
3385 values = copy_list (values);
3387 for (p = values; p; p = TREE_CHAIN (p))
3389 tree complex_value = TREE_VALUE (p);
3392 complex_type = TREE_TYPE (complex_value);
3396 if (TREE_CODE (complex_type) == COMPLEX_TYPE)
3399 tree real, imag, next;
3401 subtype = TREE_TYPE (complex_type);
3402 complex_value = save_expr (complex_value);
3403 real = build1 (REALPART_EXPR, subtype, complex_value);
3404 imag = build1 (IMAGPART_EXPR, subtype, complex_value);
3406 TREE_VALUE (p) = real;
3407 next = TREE_CHAIN (p);
3408 imag = build_tree_list (NULL_TREE, imag);
3409 TREE_CHAIN (p) = imag;
3410 TREE_CHAIN (imag) = next;
3412 /* Skip the newly created node. */
3420 /* Traverse a list of TYPES and expand all complex types into their
3423 split_complex_types (tree types)
3427 types = copy_list (types);
3429 for (p = types; p; p = TREE_CHAIN (p))
3431 tree complex_type = TREE_VALUE (p);
3433 if (TREE_CODE (complex_type) == COMPLEX_TYPE)
3437 /* Rewrite complex type with component type. */
3438 TREE_VALUE (p) = TREE_TYPE (complex_type);
3439 next = TREE_CHAIN (p);
3441 /* Add another component type for the imaginary part. */
3442 imag = build_tree_list (NULL_TREE, TREE_VALUE (p));
3443 TREE_CHAIN (p) = imag;
3444 TREE_CHAIN (imag) = next;
3446 /* Skip the newly created node. */
3454 /* Output a library call to function FUN (a SYMBOL_REF rtx).
3455 The RETVAL parameter specifies whether return value needs to be saved, other
3456 parameters are documented in the emit_library_call function below. */
3459 emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
3460 enum libcall_type fn_type,
3461 enum machine_mode outmode, int nargs, va_list p)
3463 /* Total size in bytes of all the stack-parms scanned so far. */
3464 struct args_size args_size;
3465 /* Size of arguments before any adjustments (such as rounding). */
3466 struct args_size original_args_size;
3472 CUMULATIVE_ARGS args_so_far;
3476 enum machine_mode mode;
3479 struct locate_and_pad_arg_data locate;
3483 int old_inhibit_defer_pop = inhibit_defer_pop;
3484 rtx call_fusage = 0;
3487 int pcc_struct_value = 0;
3488 int struct_value_size = 0;
3490 int reg_parm_stack_space = 0;
3493 tree tfom; /* type_for_mode (outmode, 0) */
3495 #ifdef REG_PARM_STACK_SPACE
3496 /* Define the boundary of the register parm stack space that needs to be
3498 int low_to_save, high_to_save;
3499 rtx save_area = 0; /* Place that it is saved. */
3502 /* Size of the stack reserved for parameter registers. */
3503 int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
3504 char *initial_stack_usage_map = stack_usage_map;
3506 #ifdef REG_PARM_STACK_SPACE
3507 #ifdef MAYBE_REG_PARM_STACK_SPACE
3508 reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
3510 reg_parm_stack_space = REG_PARM_STACK_SPACE ((tree) 0);
3514 /* By default, library functions can not throw. */
3515 flags = ECF_NOTHROW;
3527 case LCT_CONST_MAKE_BLOCK:
3528 flags |= ECF_CONST | ECF_LIBCALL_BLOCK;
3530 case LCT_PURE_MAKE_BLOCK:
3531 flags |= ECF_PURE | ECF_LIBCALL_BLOCK;
3534 flags |= ECF_NORETURN;
3537 flags = ECF_NORETURN;
3539 case LCT_ALWAYS_RETURN:
3540 flags = ECF_ALWAYS_RETURN;
3542 case LCT_RETURNS_TWICE:
3543 flags = ECF_RETURNS_TWICE;
3548 /* Ensure current function's preferred stack boundary is at least
3550 if (cfun->preferred_stack_boundary < PREFERRED_STACK_BOUNDARY)
3551 cfun->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
3553 /* If this kind of value comes back in memory,
3554 decide where in memory it should come back. */
3555 if (outmode != VOIDmode)
3557 tfom = (*lang_hooks.types.type_for_mode) (outmode, 0);
3558 if (aggregate_value_p (tfom))
3560 #ifdef PCC_STATIC_STRUCT_RETURN
3562 = hard_function_value (build_pointer_type (tfom), 0, 0);
3563 mem_value = gen_rtx_MEM (outmode, pointer_reg);
3564 pcc_struct_value = 1;
3566 value = gen_reg_rtx (outmode);
3567 #else /* not PCC_STATIC_STRUCT_RETURN */
3568 struct_value_size = GET_MODE_SIZE (outmode);
3569 if (value != 0 && GET_CODE (value) == MEM)
3572 mem_value = assign_temp (tfom, 0, 1, 1);
3574 /* This call returns a big structure. */
3575 flags &= ~(ECF_CONST | ECF_PURE | ECF_LIBCALL_BLOCK);
3579 tfom = void_type_node;
3581 /* ??? Unfinished: must pass the memory address as an argument. */
3583 /* Copy all the libcall-arguments out of the varargs data
3584 and into a vector ARGVEC.
3586 Compute how to pass each argument. We only support a very small subset
3587 of the full argument passing conventions to limit complexity here since
3588 library functions shouldn't have many args. */
3590 argvec = (struct arg *) alloca ((nargs + 1) * sizeof (struct arg));
3591 memset ((char *) argvec, 0, (nargs + 1) * sizeof (struct arg));
3593 #ifdef INIT_CUMULATIVE_LIBCALL_ARGS
3594 INIT_CUMULATIVE_LIBCALL_ARGS (args_so_far, outmode, fun);
3596 INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE, fun, 0);
3599 args_size.constant = 0;
3604 /* Now we are about to start emitting insns that can be deleted
3605 if a libcall is deleted. */
3606 if (flags & ECF_LIBCALL_BLOCK)
3611 /* If there's a structure value address to be passed,
3612 either pass it in the special place, or pass it as an extra argument. */
3613 if (mem_value && struct_value_rtx == 0 && ! pcc_struct_value)
3615 rtx addr = XEXP (mem_value, 0);
3618 /* Make sure it is a reasonable operand for a move or push insn. */
3619 if (GET_CODE (addr) != REG && GET_CODE (addr) != MEM
3620 && ! (CONSTANT_P (addr) && LEGITIMATE_CONSTANT_P (addr)))
3621 addr = force_operand (addr, NULL_RTX);
3623 argvec[count].value = addr;
3624 argvec[count].mode = Pmode;
3625 argvec[count].partial = 0;
3627 argvec[count].reg = FUNCTION_ARG (args_so_far, Pmode, NULL_TREE, 1);
3628 #ifdef FUNCTION_ARG_PARTIAL_NREGS
3629 if (FUNCTION_ARG_PARTIAL_NREGS (args_so_far, Pmode, NULL_TREE, 1))
3633 locate_and_pad_parm (Pmode, NULL_TREE,
3634 #ifdef STACK_PARMS_IN_REG_PARM_AREA
3637 argvec[count].reg != 0,
3639 0, NULL_TREE, &args_size, &argvec[count].locate);
3641 if (argvec[count].reg == 0 || argvec[count].partial != 0
3642 || reg_parm_stack_space > 0)
3643 args_size.constant += argvec[count].locate.size.constant;
3645 FUNCTION_ARG_ADVANCE (args_so_far, Pmode, (tree) 0, 1);
3650 for (; count < nargs; count++)
3652 rtx val = va_arg (p, rtx);
3653 enum machine_mode mode = va_arg (p, enum machine_mode);
3655 /* We cannot convert the arg value to the mode the library wants here;
3656 must do it earlier where we know the signedness of the arg. */
3658 || (GET_MODE (val) != mode && GET_MODE (val) != VOIDmode))
3661 /* On some machines, there's no way to pass a float to a library fcn.
3662 Pass it as a double instead. */
3663 #ifdef LIBGCC_NEEDS_DOUBLE
3664 if (LIBGCC_NEEDS_DOUBLE && mode == SFmode)
3665 val = convert_modes (DFmode, SFmode, val, 0), mode = DFmode;
3668 /* There's no need to call protect_from_queue, because
3669 either emit_move_insn or emit_push_insn will do that. */
3671 /* Make sure it is a reasonable operand for a move or push insn. */
3672 if (GET_CODE (val) != REG && GET_CODE (val) != MEM
3673 && ! (CONSTANT_P (val) && LEGITIMATE_CONSTANT_P (val)))
3674 val = force_operand (val, NULL_RTX);
3676 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
3677 if (FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, mode, NULL_TREE, 1))
3681 #ifdef FUNCTION_ARG_CALLEE_COPIES
3682 && ! FUNCTION_ARG_CALLEE_COPIES (args_so_far, mode,
3687 /* loop.c won't look at CALL_INSN_FUNCTION_USAGE of const/pure
3688 functions, so we have to pretend this isn't such a function. */
3689 if (flags & ECF_LIBCALL_BLOCK)
3691 rtx insns = get_insns ();
3695 flags &= ~(ECF_CONST | ECF_PURE | ECF_LIBCALL_BLOCK);
3697 /* If this was a CONST function, it is now PURE since
3698 it now reads memory. */
3699 if (flags & ECF_CONST)
3701 flags &= ~ECF_CONST;
3705 if (GET_MODE (val) == MEM && ! must_copy)
3709 slot = assign_temp ((*lang_hooks.types.type_for_mode) (mode, 0),
3711 emit_move_insn (slot, val);
3715 tree type = (*lang_hooks.types.type_for_mode) (mode, 0);
3718 = gen_rtx_MEM (mode,
3719 expand_expr (build1 (ADDR_EXPR,
3720 build_pointer_type (type),
3721 make_tree (type, val)),
3722 NULL_RTX, VOIDmode, 0));
3725 call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
3726 gen_rtx_USE (VOIDmode, slot),
3729 call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
3730 gen_rtx_CLOBBER (VOIDmode,
3735 val = force_operand (XEXP (slot, 0), NULL_RTX);
3739 argvec[count].value = val;
3740 argvec[count].mode = mode;
3742 argvec[count].reg = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1);
3744 #ifdef FUNCTION_ARG_PARTIAL_NREGS
3745 argvec[count].partial
3746 = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, NULL_TREE, 1);
3748 argvec[count].partial = 0;
3751 locate_and_pad_parm (mode, NULL_TREE,
3752 #ifdef STACK_PARMS_IN_REG_PARM_AREA
3755 argvec[count].reg != 0,
3757 argvec[count].partial,
3758 NULL_TREE, &args_size, &argvec[count].locate);
3760 if (argvec[count].locate.size.var)
3763 if (argvec[count].reg == 0 || argvec[count].partial != 0
3764 || reg_parm_stack_space > 0)
3765 args_size.constant += argvec[count].locate.size.constant;
3767 FUNCTION_ARG_ADVANCE (args_so_far, mode, (tree) 0, 1);
3770 #ifdef FINAL_REG_PARM_STACK_SPACE
3771 reg_parm_stack_space = FINAL_REG_PARM_STACK_SPACE (args_size.constant,
3774 /* If this machine requires an external definition for library
3775 functions, write one out. */
3776 assemble_external_libcall (fun);
3778 original_args_size = args_size;
3779 args_size.constant = (((args_size.constant
3780 + stack_pointer_delta
3784 - stack_pointer_delta);
3786 args_size.constant = MAX (args_size.constant,
3787 reg_parm_stack_space);
3789 #ifndef OUTGOING_REG_PARM_STACK_SPACE
3790 args_size.constant -= reg_parm_stack_space;
3793 if (args_size.constant > current_function_outgoing_args_size)
3794 current_function_outgoing_args_size = args_size.constant;
3796 if (ACCUMULATE_OUTGOING_ARGS)
3798 /* Since the stack pointer will never be pushed, it is possible for
3799 the evaluation of a parm to clobber something we have already
3800 written to the stack. Since most function calls on RISC machines
3801 do not use the stack, this is uncommon, but must work correctly.
3803 Therefore, we save any area of the stack that was already written
3804 and that we are using. Here we set up to do this by making a new
3805 stack usage map from the old one.
3807 Another approach might be to try to reorder the argument
3808 evaluations to avoid this conflicting stack usage. */
3810 needed = args_size.constant;
3812 #ifndef OUTGOING_REG_PARM_STACK_SPACE
3813 /* Since we will be writing into the entire argument area, the
3814 map must be allocated for its entire size, not just the part that
3815 is the responsibility of the caller. */
3816 needed += reg_parm_stack_space;
3819 #ifdef ARGS_GROW_DOWNWARD
3820 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
3823 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
3826 stack_usage_map = (char *) alloca (highest_outgoing_arg_in_use);
3828 if (initial_highest_arg_in_use)
3829 memcpy (stack_usage_map, initial_stack_usage_map,
3830 initial_highest_arg_in_use);
3832 if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
3833 memset (&stack_usage_map[initial_highest_arg_in_use], 0,
3834 highest_outgoing_arg_in_use - initial_highest_arg_in_use);
3837 /* We must be careful to use virtual regs before they're instantiated,
3838 and real regs afterwards. Loop optimization, for example, can create
3839 new libcalls after we've instantiated the virtual regs, and if we
3840 use virtuals anyway, they won't match the rtl patterns. */
3842 if (virtuals_instantiated)
3843 argblock = plus_constant (stack_pointer_rtx, STACK_POINTER_OFFSET);
3845 argblock = virtual_outgoing_args_rtx;
3850 argblock = push_block (GEN_INT (args_size.constant), 0, 0);
3853 /* If we push args individually in reverse order, perform stack alignment
3854 before the first push (the last arg). */
3855 if (argblock == 0 && PUSH_ARGS_REVERSED)
3856 anti_adjust_stack (GEN_INT (args_size.constant
3857 - original_args_size.constant));
3859 if (PUSH_ARGS_REVERSED)
3870 #ifdef REG_PARM_STACK_SPACE
3871 if (ACCUMULATE_OUTGOING_ARGS)
3873 /* The argument list is the property of the called routine and it
3874 may clobber it. If the fixed area has been used for previous
3875 parameters, we must save and restore it. */
3876 save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
3877 &low_to_save, &high_to_save);
3881 /* Push the args that need to be pushed. */
3883 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
3884 are to be pushed. */
3885 for (count = 0; count < nargs; count++, argnum += inc)
3887 enum machine_mode mode = argvec[argnum].mode;
3888 rtx val = argvec[argnum].value;
3889 rtx reg = argvec[argnum].reg;
3890 int partial = argvec[argnum].partial;
3891 int lower_bound = 0, upper_bound = 0, i;
3893 if (! (reg != 0 && partial == 0))
3895 if (ACCUMULATE_OUTGOING_ARGS)
3897 /* If this is being stored into a pre-allocated, fixed-size,
3898 stack area, save any previous data at that location. */
3900 #ifdef ARGS_GROW_DOWNWARD
3901 /* stack_slot is negative, but we want to index stack_usage_map
3902 with positive values. */
3903 upper_bound = -argvec[argnum].locate.offset.constant + 1;
3904 lower_bound = upper_bound - argvec[argnum].locate.size.constant;
3906 lower_bound = argvec[argnum].locate.offset.constant;
3907 upper_bound = lower_bound + argvec[argnum].locate.size.constant;
3911 /* Don't worry about things in the fixed argument area;
3912 it has already been saved. */
3913 if (i < reg_parm_stack_space)
3914 i = reg_parm_stack_space;
3915 while (i < upper_bound && stack_usage_map[i] == 0)
3918 if (i < upper_bound)
3920 /* We need to make a save area. */
3922 = argvec[argnum].locate.size.constant * BITS_PER_UNIT;
3923 enum machine_mode save_mode
3924 = mode_for_size (size, MODE_INT, 1);
3926 = plus_constant (argblock,
3927 argvec[argnum].locate.offset.constant);
3929 = gen_rtx_MEM (save_mode, memory_address (save_mode, adr));
3930 argvec[argnum].save_area = gen_reg_rtx (save_mode);
3932 emit_move_insn (argvec[argnum].save_area, stack_area);
3936 emit_push_insn (val, mode, NULL_TREE, NULL_RTX, PARM_BOUNDARY,
3937 partial, reg, 0, argblock,
3938 GEN_INT (argvec[argnum].locate.offset.constant),
3939 reg_parm_stack_space,
3940 ARGS_SIZE_RTX (argvec[argnum].locate.alignment_pad));
3942 /* Now mark the segment we just used. */
3943 if (ACCUMULATE_OUTGOING_ARGS)
3944 for (i = lower_bound; i < upper_bound; i++)
3945 stack_usage_map[i] = 1;
3951 /* If we pushed args in forward order, perform stack alignment
3952 after pushing the last arg. */
3953 if (argblock == 0 && !PUSH_ARGS_REVERSED)
3954 anti_adjust_stack (GEN_INT (args_size.constant
3955 - original_args_size.constant));
3957 if (PUSH_ARGS_REVERSED)
3962 fun = prepare_call_address (fun, NULL_TREE, &call_fusage, 0, 0);
3964 /* Now load any reg parms into their regs. */
3966 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
3967 are to be pushed. */
3968 for (count = 0; count < nargs; count++, argnum += inc)
3970 rtx val = argvec[argnum].value;
3971 rtx reg = argvec[argnum].reg;
3972 int partial = argvec[argnum].partial;
3974 /* Handle calls that pass values in multiple non-contiguous
3975 locations. The PA64 has examples of this for library calls. */
3976 if (reg != 0 && GET_CODE (reg) == PARALLEL)
3977 emit_group_load (reg, val, GET_MODE_SIZE (GET_MODE (val)));
3978 else if (reg != 0 && partial == 0)
3979 emit_move_insn (reg, val);
3984 /* Any regs containing parms remain in use through the call. */
3985 for (count = 0; count < nargs; count++)
3987 rtx reg = argvec[count].reg;
3988 if (reg != 0 && GET_CODE (reg) == PARALLEL)
3989 use_group_regs (&call_fusage, reg);
3991 use_reg (&call_fusage, reg);
3994 /* Pass the function the address in which to return a structure value. */
3995 if (mem_value != 0 && struct_value_rtx != 0 && ! pcc_struct_value)
3997 emit_move_insn (struct_value_rtx,
3999 force_operand (XEXP (mem_value, 0),
4001 if (GET_CODE (struct_value_rtx) == REG)
4002 use_reg (&call_fusage, struct_value_rtx);
4005 /* Don't allow popping to be deferred, since then
4006 cse'ing of library calls could delete a call and leave the pop. */
4008 valreg = (mem_value == 0 && outmode != VOIDmode
4009 ? hard_libcall_value (outmode) : NULL_RTX);
4011 /* Stack must be properly aligned now. */
4012 if (stack_pointer_delta & (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1))
4015 before_call = get_last_insn ();
4017 /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
4018 will set inhibit_defer_pop to that value. */
4019 /* The return type is needed to decide how many bytes the function pops.
4020 Signedness plays no role in that, so for simplicity, we pretend it's
4021 always signed. We also assume that the list of arguments passed has
4022 no impact, so we pretend it is unknown. */
4025 get_identifier (XSTR (orgfun, 0)),
4026 build_function_type (tfom, NULL_TREE),
4027 original_args_size.constant, args_size.constant,
4029 FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
4031 old_inhibit_defer_pop + 1, call_fusage, flags, & args_so_far);
4033 /* For calls to `setjmp', etc., inform flow.c it should complain
4034 if nonvolatile values are live. For functions that cannot return,
4035 inform flow that control does not fall through. */
4037 if (flags & (ECF_NORETURN | ECF_LONGJMP))
4039 /* The barrier note must be emitted
4040 immediately after the CALL_INSN. Some ports emit more than
4041 just a CALL_INSN above, so we must search for it here. */
4043 rtx last = get_last_insn ();
4044 while (GET_CODE (last) != CALL_INSN)
4046 last = PREV_INSN (last);
4047 /* There was no CALL_INSN? */
4048 if (last == before_call)
4052 emit_barrier_after (last);
4055 /* Now restore inhibit_defer_pop to its actual original value. */
4058 /* If call is cse'able, make appropriate pair of reg-notes around it.
4059 Test valreg so we don't crash; may safely ignore `const'
4060 if return type is void. Disable for PARALLEL return values, because
4061 we have no way to move such values into a pseudo register. */
4062 if (flags & ECF_LIBCALL_BLOCK)
4068 insns = get_insns ();
4078 if (GET_CODE (valreg) == PARALLEL)
4080 temp = gen_reg_rtx (outmode);
4081 emit_group_store (temp, valreg, outmode);
4085 temp = gen_reg_rtx (GET_MODE (valreg));
4087 /* Construct an "equal form" for the value which mentions all the
4088 arguments in order as well as the function name. */
4089 for (i = 0; i < nargs; i++)
4090 note = gen_rtx_EXPR_LIST (VOIDmode, argvec[i].value, note);
4091 note = gen_rtx_EXPR_LIST (VOIDmode, fun, note);
4093 insns = get_insns ();
4096 if (flags & ECF_PURE)
4097 note = gen_rtx_EXPR_LIST (VOIDmode,
4098 gen_rtx_USE (VOIDmode,
4099 gen_rtx_MEM (BLKmode,
4100 gen_rtx_SCRATCH (VOIDmode))),
4103 emit_libcall_block (insns, temp, valreg, note);
4110 /* Copy the value to the right place. */
4111 if (outmode != VOIDmode && retval)
4117 if (value != mem_value)
4118 emit_move_insn (value, mem_value);
4120 else if (GET_CODE (valreg) == PARALLEL)
4123 value = gen_reg_rtx (outmode);
4124 emit_group_store (value, valreg, outmode);
4126 else if (value != 0)
4127 emit_move_insn (value, valreg);
4132 if (ACCUMULATE_OUTGOING_ARGS)
4134 #ifdef REG_PARM_STACK_SPACE
4136 restore_fixed_argument_area (save_area, argblock,
4137 high_to_save, low_to_save);
4140 /* If we saved any argument areas, restore them. */
4141 for (count = 0; count < nargs; count++)
4142 if (argvec[count].save_area)
4144 enum machine_mode save_mode = GET_MODE (argvec[count].save_area);
4145 rtx adr = plus_constant (argblock,
4146 argvec[count].locate.offset.constant);
4147 rtx stack_area = gen_rtx_MEM (save_mode,
4148 memory_address (save_mode, adr));
4150 emit_move_insn (stack_area, argvec[count].save_area);
4153 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
4154 stack_usage_map = initial_stack_usage_map;
4161 /* Output a library call to function FUN (a SYMBOL_REF rtx)
4162 (emitting the queue unless NO_QUEUE is nonzero),
4163 for a value of mode OUTMODE,
4164 with NARGS different arguments, passed as alternating rtx values
4165 and machine_modes to convert them to.
4166 The rtx values should have been passed through protect_from_queue already.
4168 FN_TYPE should be LCT_NORMAL for `normal' calls, LCT_CONST for `const'
4169 calls, LCT_PURE for `pure' calls, LCT_CONST_MAKE_BLOCK for `const' calls
4170 which should be enclosed in REG_LIBCALL/REG_RETVAL notes,
4171 LCT_PURE_MAKE_BLOCK for `purep' calls which should be enclosed in
4172 REG_LIBCALL/REG_RETVAL notes with extra (use (memory (scratch)),
4173 or other LCT_ value for other types of library calls. */
4176 emit_library_call (rtx orgfun, enum libcall_type fn_type,
4177 enum machine_mode outmode, int nargs, ...)
4181 va_start (p, nargs);
4182 emit_library_call_value_1 (0, orgfun, NULL_RTX, fn_type, outmode, nargs, p);
4186 /* Like emit_library_call except that an extra argument, VALUE,
4187 comes second and says where to store the result.
4188 (If VALUE is zero, this function chooses a convenient way
4189 to return the value.
4191 This function returns an rtx for where the value is to be found.
4192 If VALUE is nonzero, VALUE is returned. */
4195 emit_library_call_value (rtx orgfun, rtx value,
4196 enum libcall_type fn_type,
4197 enum machine_mode outmode, int nargs, ...)
4202 va_start (p, nargs);
4203 result = emit_library_call_value_1 (1, orgfun, value, fn_type, outmode,
4210 /* Store a single argument for a function call
4211 into the register or memory area where it must be passed.
4212 *ARG describes the argument value and where to pass it.
4214 ARGBLOCK is the address of the stack-block for all the arguments,
4215 or 0 on a machine where arguments are pushed individually.
4217 MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
4218 so must be careful about how the stack is used.
4220 VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
4221 argument stack. This is used if ACCUMULATE_OUTGOING_ARGS to indicate
4222 that we need not worry about saving and restoring the stack.
4224 FNDECL is the declaration of the function we are calling.
4226 Return nonzero if this arg should cause sibcall failure,
4230 store_one_arg (struct arg_data *arg, rtx argblock, int flags,
4231 int variable_size ATTRIBUTE_UNUSED, int reg_parm_stack_space)
4233 tree pval = arg->tree_value;
4237 int i, lower_bound = 0, upper_bound = 0;
4238 int sibcall_failure = 0;
4240 if (TREE_CODE (pval) == ERROR_MARK)
4243 /* Push a new temporary level for any temporaries we make for
4247 if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL))
4249 /* If this is being stored into a pre-allocated, fixed-size, stack area,
4250 save any previous data at that location. */
4251 if (argblock && ! variable_size && arg->stack)
4253 #ifdef ARGS_GROW_DOWNWARD
4254 /* stack_slot is negative, but we want to index stack_usage_map
4255 with positive values. */
4256 if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
4257 upper_bound = -INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1)) + 1;
4261 lower_bound = upper_bound - arg->locate.size.constant;
4263 if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
4264 lower_bound = INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1));
4268 upper_bound = lower_bound + arg->locate.size.constant;
4272 /* Don't worry about things in the fixed argument area;
4273 it has already been saved. */
4274 if (i < reg_parm_stack_space)
4275 i = reg_parm_stack_space;
4276 while (i < upper_bound && stack_usage_map[i] == 0)
4279 if (i < upper_bound)
4281 /* We need to make a save area. */
4282 unsigned int size = arg->locate.size.constant * BITS_PER_UNIT;
4283 enum machine_mode save_mode = mode_for_size (size, MODE_INT, 1);
4284 rtx adr = memory_address (save_mode, XEXP (arg->stack_slot, 0));
4285 rtx stack_area = gen_rtx_MEM (save_mode, adr);
4287 if (save_mode == BLKmode)
4289 tree ot = TREE_TYPE (arg->tree_value);
4290 tree nt = build_qualified_type (ot, (TYPE_QUALS (ot)
4291 | TYPE_QUAL_CONST));
4293 arg->save_area = assign_temp (nt, 0, 1, 1);
4294 preserve_temp_slots (arg->save_area);
4295 emit_block_move (validize_mem (arg->save_area), stack_area,
4296 expr_size (arg->tree_value),
4297 BLOCK_OP_CALL_PARM);
4301 arg->save_area = gen_reg_rtx (save_mode);
4302 emit_move_insn (arg->save_area, stack_area);
4308 /* If this isn't going to be placed on both the stack and in registers,
4309 set up the register and number of words. */
4310 if (! arg->pass_on_stack)
4312 if (flags & ECF_SIBCALL)
4313 reg = arg->tail_call_reg;
4316 partial = arg->partial;
4319 if (reg != 0 && partial == 0)
4320 /* Being passed entirely in a register. We shouldn't be called in
4324 /* If this arg needs special alignment, don't load the registers
4326 if (arg->n_aligned_regs != 0)
4329 /* If this is being passed partially in a register, we can't evaluate
4330 it directly into its stack slot. Otherwise, we can. */
4331 if (arg->value == 0)
4333 /* stack_arg_under_construction is nonzero if a function argument is
4334 being evaluated directly into the outgoing argument list and
4335 expand_call must take special action to preserve the argument list
4336 if it is called recursively.
4338 For scalar function arguments stack_usage_map is sufficient to
4339 determine which stack slots must be saved and restored. Scalar
4340 arguments in general have pass_on_stack == 0.
4342 If this argument is initialized by a function which takes the
4343 address of the argument (a C++ constructor or a C function
4344 returning a BLKmode structure), then stack_usage_map is
4345 insufficient and expand_call must push the stack around the
4346 function call. Such arguments have pass_on_stack == 1.
4348 Note that it is always safe to set stack_arg_under_construction,
4349 but this generates suboptimal code if set when not needed. */
4351 if (arg->pass_on_stack)
4352 stack_arg_under_construction++;
4354 arg->value = expand_expr (pval,
4356 || TYPE_MODE (TREE_TYPE (pval)) != arg->mode)
4357 ? NULL_RTX : arg->stack,
4358 VOIDmode, EXPAND_STACK_PARM);
4360 /* If we are promoting object (or for any other reason) the mode
4361 doesn't agree, convert the mode. */
4363 if (arg->mode != TYPE_MODE (TREE_TYPE (pval)))
4364 arg->value = convert_modes (arg->mode, TYPE_MODE (TREE_TYPE (pval)),
4365 arg->value, arg->unsignedp);
4367 if (arg->pass_on_stack)
4368 stack_arg_under_construction--;
4371 /* Don't allow anything left on stack from computation
4372 of argument to alloca. */
4373 if (flags & ECF_MAY_BE_ALLOCA)
4374 do_pending_stack_adjust ();
4376 if (arg->value == arg->stack)
4377 /* If the value is already in the stack slot, we are done. */
4379 else if (arg->mode != BLKmode)
4383 /* Argument is a scalar, not entirely passed in registers.
4384 (If part is passed in registers, arg->partial says how much
4385 and emit_push_insn will take care of putting it there.)
4387 Push it, and if its size is less than the
4388 amount of space allocated to it,
4389 also bump stack pointer by the additional space.
4390 Note that in C the default argument promotions
4391 will prevent such mismatches. */
4393 size = GET_MODE_SIZE (arg->mode);
4394 /* Compute how much space the push instruction will push.
4395 On many machines, pushing a byte will advance the stack
4396 pointer by a halfword. */
4397 #ifdef PUSH_ROUNDING
4398 size = PUSH_ROUNDING (size);
4402 /* Compute how much space the argument should get:
4403 round up to a multiple of the alignment for arguments. */
4404 if (none != FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)))
4405 used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1)
4406 / (PARM_BOUNDARY / BITS_PER_UNIT))
4407 * (PARM_BOUNDARY / BITS_PER_UNIT));
4409 /* This isn't already where we want it on the stack, so put it there.
4410 This can either be done with push or copy insns. */
4411 emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX,
4412 PARM_BOUNDARY, partial, reg, used - size, argblock,
4413 ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
4414 ARGS_SIZE_RTX (arg->locate.alignment_pad));
4416 /* Unless this is a partially-in-register argument, the argument is now
4419 arg->value = arg->stack;
4423 /* BLKmode, at least partly to be pushed. */
4425 unsigned int parm_align;
4429 /* Pushing a nonscalar.
4430 If part is passed in registers, PARTIAL says how much
4431 and emit_push_insn will take care of putting it there. */
4433 /* Round its size up to a multiple
4434 of the allocation unit for arguments. */
4436 if (arg->locate.size.var != 0)
4439 size_rtx = ARGS_SIZE_RTX (arg->locate.size);
4443 /* PUSH_ROUNDING has no effect on us, because
4444 emit_push_insn for BLKmode is careful to avoid it. */
4445 excess = (arg->locate.size.constant
4446 - int_size_in_bytes (TREE_TYPE (pval))
4447 + partial * UNITS_PER_WORD);
4448 size_rtx = expand_expr (size_in_bytes (TREE_TYPE (pval)),
4449 NULL_RTX, TYPE_MODE (sizetype), 0);
4452 /* Some types will require stricter alignment, which will be
4453 provided for elsewhere in argument layout. */
4454 parm_align = MAX (PARM_BOUNDARY, TYPE_ALIGN (TREE_TYPE (pval)));
4456 /* When an argument is padded down, the block is aligned to
4457 PARM_BOUNDARY, but the actual argument isn't. */
4458 if (FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)) == downward)
4460 if (arg->locate.size.var)
4461 parm_align = BITS_PER_UNIT;
4464 unsigned int excess_align = (excess & -excess) * BITS_PER_UNIT;
4465 parm_align = MIN (parm_align, excess_align);
4469 if ((flags & ECF_SIBCALL) && GET_CODE (arg->value) == MEM)
4471 /* emit_push_insn might not work properly if arg->value and
4472 argblock + arg->locate.offset areas overlap. */
4476 if (XEXP (x, 0) == current_function_internal_arg_pointer
4477 || (GET_CODE (XEXP (x, 0)) == PLUS
4478 && XEXP (XEXP (x, 0), 0) ==
4479 current_function_internal_arg_pointer
4480 && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT))
4482 if (XEXP (x, 0) != current_function_internal_arg_pointer)
4483 i = INTVAL (XEXP (XEXP (x, 0), 1));
4485 /* expand_call should ensure this */
4486 if (arg->locate.offset.var || GET_CODE (size_rtx) != CONST_INT)
4489 if (arg->locate.offset.constant > i)
4491 if (arg->locate.offset.constant < i + INTVAL (size_rtx))
4492 sibcall_failure = 1;
4494 else if (arg->locate.offset.constant < i)
4496 if (i < arg->locate.offset.constant + INTVAL (size_rtx))
4497 sibcall_failure = 1;
4502 emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
4503 parm_align, partial, reg, excess, argblock,
4504 ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
4505 ARGS_SIZE_RTX (arg->locate.alignment_pad));
4507 /* Unless this is a partially-in-register argument, the argument is now
4510 ??? Unlike the case above, in which we want the actual
4511 address of the data, so that we can load it directly into a
4512 register, here we want the address of the stack slot, so that
4513 it's properly aligned for word-by-word copying or something
4514 like that. It's not clear that this is always correct. */
4516 arg->value = arg->stack_slot;
4519 /* Mark all slots this store used. */
4520 if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL)
4521 && argblock && ! variable_size && arg->stack)
4522 for (i = lower_bound; i < upper_bound; i++)
4523 stack_usage_map[i] = 1;
4525 /* Once we have pushed something, pops can't safely
4526 be deferred during the rest of the arguments. */
4529 /* ANSI doesn't require a sequence point here,
4530 but PCC has one, so this will avoid some problems. */
4533 /* Free any temporary slots made in processing this argument. Show
4534 that we might have taken the address of something and pushed that
4536 preserve_temp_slots (NULL_RTX);
4540 return sibcall_failure;
4543 /* Nonzero if we do not know how to pass TYPE solely in registers.
4544 We cannot do so in the following cases:
4546 - if the type has variable size
4547 - if the type is marked as addressable (it is required to be constructed
4549 - if the padding and mode of the type is such that a copy into a register
4550 would put it into the wrong part of the register.
4552 Which padding can't be supported depends on the byte endianness.
4554 A value in a register is implicitly padded at the most significant end.
4555 On a big-endian machine, that is the lower end in memory.
4556 So a value padded in memory at the upper end can't go in a register.
4557 For a little-endian machine, the reverse is true. */
4560 default_must_pass_in_stack (enum machine_mode mode, tree type)
4565 /* If the type has variable size... */
4566 if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4569 /* If the type is marked as addressable (it is required
4570 to be constructed into the stack)... */
4571 if (TREE_ADDRESSABLE (type))
4574 /* If the padding and mode of the type is such that a copy into
4575 a register would put it into the wrong part of the register. */
4577 && int_size_in_bytes (type) % (PARM_BOUNDARY / BITS_PER_UNIT)
4578 && (FUNCTION_ARG_PADDING (mode, type)
4579 == (BYTES_BIG_ENDIAN ? upward : downward)))