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 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
30 #include "insn-flags.h"
35 #ifndef ACCUMULATE_OUTGOING_ARGS
36 #define ACCUMULATE_OUTGOING_ARGS 0
39 /* Supply a default definition for PUSH_ARGS. */
42 #define PUSH_ARGS !ACCUMULATE_OUTGOING_ARGS
48 #if !defined FUNCTION_OK_FOR_SIBCALL
49 #define FUNCTION_OK_FOR_SIBCALL(DECL) 1
52 #if !defined PREFERRED_STACK_BOUNDARY && defined STACK_BOUNDARY
53 #define PREFERRED_STACK_BOUNDARY STACK_BOUNDARY
56 /* Decide whether a function's arguments should be processed
57 from first to last or from last to first.
59 They should if the stack and args grow in opposite directions, but
60 only if we have push insns. */
64 #if defined (STACK_GROWS_DOWNWARD) != defined (ARGS_GROW_DOWNWARD)
65 #define PUSH_ARGS_REVERSED PUSH_ARGS
70 #ifndef PUSH_ARGS_REVERSED
71 #define PUSH_ARGS_REVERSED 0
74 /* Like PREFERRED_STACK_BOUNDARY but in units of bytes, not bits. */
75 #define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)
77 /* Data structure and subroutines used within expand_call. */
81 /* Tree node for this argument. */
83 /* Mode for value; TYPE_MODE unless promoted. */
84 enum machine_mode mode;
85 /* Current RTL value for argument, or 0 if it isn't precomputed. */
87 /* Initially-compute RTL value for argument; only for const functions. */
89 /* Register to pass this argument in, 0 if passed on stack, or an
90 PARALLEL if the arg is to be copied into multiple non-contiguous
93 /* If REG was promoted from the actual mode of the argument expression,
94 indicates whether the promotion is sign- or zero-extended. */
96 /* Number of registers to use. 0 means put the whole arg in registers.
97 Also 0 if not passed in registers. */
99 /* Non-zero if argument must be passed on stack.
100 Note that some arguments may be passed on the stack
101 even though pass_on_stack is zero, just because FUNCTION_ARG says so.
102 pass_on_stack identifies arguments that *cannot* go in registers. */
104 /* Offset of this argument from beginning of stack-args. */
105 struct args_size offset;
106 /* Similar, but offset to the start of the stack slot. Different from
107 OFFSET if this arg pads downward. */
108 struct args_size slot_offset;
109 /* Size of this argument on the stack, rounded up for any padding it gets,
110 parts of the argument passed in registers do not count.
111 If REG_PARM_STACK_SPACE is defined, then register parms
112 are counted here as well. */
113 struct args_size size;
114 /* Location on the stack at which parameter should be stored. The store
115 has already been done if STACK == VALUE. */
117 /* Location on the stack of the start of this argument slot. This can
118 differ from STACK if this arg pads downward. This location is known
119 to be aligned to FUNCTION_ARG_BOUNDARY. */
121 /* Place that this stack area has been saved, if needed. */
123 /* If an argument's alignment does not permit direct copying into registers,
124 copy in smaller-sized pieces into pseudos. These are stored in a
125 block pointed to by this field. The next field says how many
126 word-sized pseudos we made. */
129 /* The amount that the stack pointer needs to be adjusted to
130 force alignment for the next argument. */
131 struct args_size alignment_pad;
134 /* A vector of one char per byte of stack space. A byte if non-zero if
135 the corresponding stack location has been used.
136 This vector is used to prevent a function call within an argument from
137 clobbering any stack already set up. */
138 static char *stack_usage_map;
140 /* Size of STACK_USAGE_MAP. */
141 static int highest_outgoing_arg_in_use;
143 /* stack_arg_under_construction is nonzero when an argument may be
144 initialized with a constructor call (including a C function that
145 returns a BLKmode struct) and expand_call must take special action
146 to make sure the object being constructed does not overlap the
147 argument list for the constructor call. */
148 int stack_arg_under_construction;
150 static int calls_function PARAMS ((tree, int));
151 static int calls_function_1 PARAMS ((tree, int));
153 /* Nonzero if this is a call to a `const' function. */
155 /* Nonzero if this is a call to a `volatile' function. */
156 #define ECF_NORETURN 2
157 /* Nonzero if this is a call to malloc or a related function. */
159 /* Nonzero if it is plausible that this is a call to alloca. */
160 #define ECF_MAY_BE_ALLOCA 8
161 /* Nonzero if this is a call to a function that won't throw an exception. */
162 #define ECF_NOTHROW 16
163 /* Nonzero if this is a call to setjmp or a related function. */
164 #define ECF_RETURNS_TWICE 32
165 /* Nonzero if this is a call to `longjmp'. */
166 #define ECF_LONGJMP 64
167 /* Nonzero if this is a syscall that makes a new process in the image of
169 #define ECF_FORK_OR_EXEC 128
170 #define ECF_SIBCALL 256
172 static void emit_call_1 PARAMS ((rtx, tree, tree, HOST_WIDE_INT,
173 HOST_WIDE_INT, HOST_WIDE_INT, rtx,
174 rtx, int, rtx, int));
175 static void precompute_register_parameters PARAMS ((int,
178 static void store_one_arg PARAMS ((struct arg_data *, rtx, int, int,
180 static void store_unaligned_arguments_into_pseudos PARAMS ((struct arg_data *,
182 static int finalize_must_preallocate PARAMS ((int, int,
184 struct args_size *));
185 static void precompute_arguments PARAMS ((int, int, int,
187 struct args_size *));
188 static int compute_argument_block_size PARAMS ((int,
191 static void initialize_argument_information PARAMS ((int,
198 static void compute_argument_addresses PARAMS ((struct arg_data *,
200 static rtx rtx_for_function_call PARAMS ((tree, tree));
201 static void load_register_parameters PARAMS ((struct arg_data *,
203 static int libfunc_nothrow PARAMS ((rtx));
204 static rtx emit_library_call_value_1 PARAMS ((int, rtx, rtx, int,
207 static int special_function_p PARAMS ((tree, int));
208 static int flags_from_decl_or_type PARAMS ((tree));
209 static rtx try_to_integrate PARAMS ((tree, tree, rtx,
212 #ifdef REG_PARM_STACK_SPACE
213 static rtx save_fixed_argument_area PARAMS ((int, rtx, int *, int *));
214 static void restore_fixed_argument_area PARAMS ((rtx, rtx, int, int));
217 /* If WHICH is 1, return 1 if EXP contains a call to the built-in function
220 If WHICH is 0, return 1 if EXP contains a call to any function.
221 Actually, we only need return 1 if evaluating EXP would require pushing
222 arguments on the stack, but that is too difficult to compute, so we just
223 assume any function call might require the stack. */
225 static tree calls_function_save_exprs;
228 calls_function (exp, which)
233 calls_function_save_exprs = 0;
234 val = calls_function_1 (exp, which);
235 calls_function_save_exprs = 0;
240 calls_function_1 (exp, which)
245 enum tree_code code = TREE_CODE (exp);
246 int type = TREE_CODE_CLASS (code);
247 int length = tree_code_length[(int) code];
249 /* If this code is language-specific, we don't know what it will do. */
250 if ((int) code >= NUM_TREE_CODES)
253 /* Only expressions and references can contain calls. */
254 if (type != 'e' && type != '<' && type != '1' && type != '2' && type != 'r'
263 else if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
264 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
267 tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
269 if ((DECL_BUILT_IN (fndecl)
270 && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
271 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_ALLOCA)
272 || (DECL_SAVED_INSNS (fndecl)
273 && DECL_SAVED_INSNS (fndecl)->calls_alloca))
277 /* Third operand is RTL. */
282 if (SAVE_EXPR_RTL (exp) != 0)
284 if (value_member (exp, calls_function_save_exprs))
286 calls_function_save_exprs = tree_cons (NULL_TREE, exp,
287 calls_function_save_exprs);
288 return (TREE_OPERAND (exp, 0) != 0
289 && calls_function_1 (TREE_OPERAND (exp, 0), which));
295 for (local = BLOCK_VARS (exp); local; local = TREE_CHAIN (local))
296 if (DECL_INITIAL (local) != 0
297 && calls_function_1 (DECL_INITIAL (local), which))
301 register tree subblock;
303 for (subblock = BLOCK_SUBBLOCKS (exp);
305 subblock = TREE_CHAIN (subblock))
306 if (calls_function_1 (subblock, which))
311 case METHOD_CALL_EXPR:
315 case WITH_CLEANUP_EXPR:
326 for (i = 0; i < length; i++)
327 if (TREE_OPERAND (exp, i) != 0
328 && calls_function_1 (TREE_OPERAND (exp, i), which))
334 /* Force FUNEXP into a form suitable for the address of a CALL,
335 and return that as an rtx. Also load the static chain register
336 if FNDECL is a nested function.
338 CALL_FUSAGE points to a variable holding the prospective
339 CALL_INSN_FUNCTION_USAGE information. */
342 prepare_call_address (funexp, fndecl, call_fusage, reg_parm_seen)
348 rtx static_chain_value = 0;
350 funexp = protect_from_queue (funexp, 0);
353 /* Get possible static chain value for nested function in C. */
354 static_chain_value = lookup_static_chain (fndecl);
356 /* Make a valid memory address and copy constants thru pseudo-regs,
357 but not for a constant address if -fno-function-cse. */
358 if (GET_CODE (funexp) != SYMBOL_REF)
359 /* If we are using registers for parameters, force the
360 function address into a register now. */
361 funexp = ((SMALL_REGISTER_CLASSES && reg_parm_seen)
362 ? force_not_mem (memory_address (FUNCTION_MODE, funexp))
363 : memory_address (FUNCTION_MODE, funexp));
366 #ifndef NO_FUNCTION_CSE
367 if (optimize && ! flag_no_function_cse)
368 #ifdef NO_RECURSIVE_FUNCTION_CSE
369 if (fndecl != current_function_decl)
371 funexp = force_reg (Pmode, funexp);
375 if (static_chain_value != 0)
377 emit_move_insn (static_chain_rtx, static_chain_value);
379 if (GET_CODE (static_chain_rtx) == REG)
380 use_reg (call_fusage, static_chain_rtx);
386 /* Generate instructions to call function FUNEXP,
387 and optionally pop the results.
388 The CALL_INSN is the first insn generated.
390 FNDECL is the declaration node of the function. This is given to the
391 macro RETURN_POPS_ARGS to determine whether this function pops its own args.
393 FUNTYPE is the data type of the function. This is given to the macro
394 RETURN_POPS_ARGS to determine whether this function pops its own args.
395 We used to allow an identifier for library functions, but that doesn't
396 work when the return type is an aggregate type and the calling convention
397 says that the pointer to this aggregate is to be popped by the callee.
399 STACK_SIZE is the number of bytes of arguments on the stack,
400 ROUNDED_STACK_SIZE is that number rounded up to
401 PREFERRED_STACK_BOUNDARY; zero if the size is variable. This is
402 both to put into the call insn and to generate explicit popping
405 STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
406 It is zero if this call doesn't want a structure value.
408 NEXT_ARG_REG is the rtx that results from executing
409 FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1)
410 just after all the args have had their registers assigned.
411 This could be whatever you like, but normally it is the first
412 arg-register beyond those used for args in this call,
413 or 0 if all the arg-registers are used in this call.
414 It is passed on to `gen_call' so you can put this info in the call insn.
416 VALREG is a hard register in which a value is returned,
417 or 0 if the call does not return a value.
419 OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before
420 the args to this call were processed.
421 We restore `inhibit_defer_pop' to that value.
423 CALL_FUSAGE is either empty or an EXPR_LIST of USE expressions that
424 denote registers used by the called function. */
427 emit_call_1 (funexp, fndecl, funtype, stack_size, rounded_stack_size,
428 struct_value_size, next_arg_reg, valreg, old_inhibit_defer_pop,
429 call_fusage, ecf_flags)
431 tree fndecl ATTRIBUTE_UNUSED;
432 tree funtype ATTRIBUTE_UNUSED;
433 HOST_WIDE_INT stack_size ATTRIBUTE_UNUSED;
434 HOST_WIDE_INT rounded_stack_size;
435 HOST_WIDE_INT struct_value_size ATTRIBUTE_UNUSED;
438 int old_inhibit_defer_pop;
442 rtx rounded_stack_size_rtx = GEN_INT (rounded_stack_size);
443 #if defined (HAVE_call) && defined (HAVE_call_value)
444 rtx struct_value_size_rtx = GEN_INT (struct_value_size);
447 int already_popped = 0;
448 HOST_WIDE_INT n_popped = RETURN_POPS_ARGS (fndecl, funtype, stack_size);
450 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
451 and we don't want to load it into a register as an optimization,
452 because prepare_call_address already did it if it should be done. */
453 if (GET_CODE (funexp) != SYMBOL_REF)
454 funexp = memory_address (FUNCTION_MODE, funexp);
456 #if defined (HAVE_sibcall_pop) && defined (HAVE_sibcall_value_pop)
457 if ((ecf_flags & ECF_SIBCALL)
458 && HAVE_sibcall_pop && HAVE_sibcall_value_pop
459 && (RETURN_POPS_ARGS (fndecl, funtype, stack_size) > 0
462 rtx n_pop = GEN_INT (RETURN_POPS_ARGS (fndecl, funtype, stack_size));
465 /* If this subroutine pops its own args, record that in the call insn
466 if possible, for the sake of frame pointer elimination. */
469 pat = gen_sibcall_value_pop (valreg,
470 gen_rtx_MEM (FUNCTION_MODE, funexp),
471 rounded_stack_size_rtx, next_arg_reg,
474 pat = gen_sibcall_pop (gen_rtx_MEM (FUNCTION_MODE, funexp),
475 rounded_stack_size_rtx, next_arg_reg, n_pop);
477 emit_call_insn (pat);
483 #if defined (HAVE_call_pop) && defined (HAVE_call_value_pop)
484 /* If the target has "call" or "call_value" insns, then prefer them
485 if no arguments are actually popped. If the target does not have
486 "call" or "call_value" insns, then we must use the popping versions
487 even if the call has no arguments to pop. */
488 #if defined (HAVE_call) && defined (HAVE_call_value)
489 if (HAVE_call && HAVE_call_value && HAVE_call_pop && HAVE_call_value_pop
492 if (HAVE_call_pop && HAVE_call_value_pop)
495 rtx n_pop = GEN_INT (n_popped);
498 /* If this subroutine pops its own args, record that in the call insn
499 if possible, for the sake of frame pointer elimination. */
502 pat = gen_call_value_pop (valreg,
503 gen_rtx_MEM (FUNCTION_MODE, funexp),
504 rounded_stack_size_rtx, next_arg_reg, n_pop);
506 pat = gen_call_pop (gen_rtx_MEM (FUNCTION_MODE, funexp),
507 rounded_stack_size_rtx, next_arg_reg, n_pop);
509 emit_call_insn (pat);
515 #if defined (HAVE_sibcall) && defined (HAVE_sibcall_value)
516 if ((ecf_flags & ECF_SIBCALL)
517 && HAVE_sibcall && HAVE_sibcall_value)
520 emit_call_insn (gen_sibcall_value (valreg,
521 gen_rtx_MEM (FUNCTION_MODE, funexp),
522 rounded_stack_size_rtx,
523 next_arg_reg, NULL_RTX));
525 emit_call_insn (gen_sibcall (gen_rtx_MEM (FUNCTION_MODE, funexp),
526 rounded_stack_size_rtx, next_arg_reg,
527 struct_value_size_rtx));
532 #if defined (HAVE_call) && defined (HAVE_call_value)
533 if (HAVE_call && HAVE_call_value)
536 emit_call_insn (gen_call_value (valreg,
537 gen_rtx_MEM (FUNCTION_MODE, funexp),
538 rounded_stack_size_rtx, next_arg_reg,
541 emit_call_insn (gen_call (gen_rtx_MEM (FUNCTION_MODE, funexp),
542 rounded_stack_size_rtx, next_arg_reg,
543 struct_value_size_rtx));
549 /* Find the CALL insn we just emitted. */
550 for (call_insn = get_last_insn ();
551 call_insn && GET_CODE (call_insn) != CALL_INSN;
552 call_insn = PREV_INSN (call_insn))
558 /* Put the register usage information on the CALL. If there is already
559 some usage information, put ours at the end. */
560 if (CALL_INSN_FUNCTION_USAGE (call_insn))
564 for (link = CALL_INSN_FUNCTION_USAGE (call_insn); XEXP (link, 1) != 0;
565 link = XEXP (link, 1))
568 XEXP (link, 1) = call_fusage;
571 CALL_INSN_FUNCTION_USAGE (call_insn) = call_fusage;
573 /* If this is a const call, then set the insn's unchanging bit. */
574 if (ecf_flags & ECF_CONST)
575 CONST_CALL_P (call_insn) = 1;
577 /* If this call can't throw, attach a REG_EH_REGION reg note to that
579 if (ecf_flags & ECF_NOTHROW)
580 REG_NOTES (call_insn) = gen_rtx_EXPR_LIST (REG_EH_REGION, const0_rtx,
581 REG_NOTES (call_insn));
583 SIBLING_CALL_P (call_insn) = ((ecf_flags & ECF_SIBCALL) != 0);
585 /* Restore this now, so that we do defer pops for this call's args
586 if the context of the call as a whole permits. */
587 inhibit_defer_pop = old_inhibit_defer_pop;
592 CALL_INSN_FUNCTION_USAGE (call_insn)
593 = gen_rtx_EXPR_LIST (VOIDmode,
594 gen_rtx_CLOBBER (VOIDmode, stack_pointer_rtx),
595 CALL_INSN_FUNCTION_USAGE (call_insn));
596 rounded_stack_size -= n_popped;
597 rounded_stack_size_rtx = GEN_INT (rounded_stack_size);
598 stack_pointer_delta -= n_popped;
601 if (!ACCUMULATE_OUTGOING_ARGS)
603 /* If returning from the subroutine does not automatically pop the args,
604 we need an instruction to pop them sooner or later.
605 Perhaps do it now; perhaps just record how much space to pop later.
607 If returning from the subroutine does pop the args, indicate that the
608 stack pointer will be changed. */
610 if (rounded_stack_size != 0)
612 if (flag_defer_pop && inhibit_defer_pop == 0
613 && !(ecf_flags & ECF_CONST))
614 pending_stack_adjust += rounded_stack_size;
616 adjust_stack (rounded_stack_size_rtx);
619 /* When we accumulate outgoing args, we must avoid any stack manipulations.
620 Restore the stack pointer to its original value now. Usually
621 ACCUMULATE_OUTGOING_ARGS targets don't get here, but there are exceptions.
622 On i386 ACCUMULATE_OUTGOING_ARGS can be enabled on demand, and
623 popping variants of functions exist as well.
625 ??? We may optimize similar to defer_pop above, but it is
626 probably not worthwhile.
628 ??? It will be worthwhile to enable combine_stack_adjustments even for
631 anti_adjust_stack (GEN_INT (n_popped));
634 /* Determine if the function identified by NAME and FNDECL is one with
635 special properties we wish to know about.
637 For example, if the function might return more than one time (setjmp), then
638 set RETURNS_TWICE to a nonzero value.
640 Similarly set LONGJMP for if the function is in the longjmp family.
642 Set MALLOC for any of the standard memory allocation functions which
643 allocate from the heap.
645 Set MAY_BE_ALLOCA for any memory allocation function that might allocate
646 space from the stack such as alloca. */
649 special_function_p (fndecl, flags)
653 if (! (flags & ECF_MALLOC)
654 && fndecl && DECL_NAME (fndecl)
655 && IDENTIFIER_LENGTH (DECL_NAME (fndecl)) <= 17
656 /* Exclude functions not at the file scope, or not `extern',
657 since they are not the magic functions we would otherwise
659 && DECL_CONTEXT (fndecl) == NULL_TREE && TREE_PUBLIC (fndecl))
661 char *name = IDENTIFIER_POINTER (DECL_NAME (fndecl));
664 /* We assume that alloca will always be called by name. It
665 makes no sense to pass it as a pointer-to-function to
666 anything that does not understand its behavior. */
667 if (((IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 6
669 && ! strcmp (name, "alloca"))
670 || (IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 16
672 && ! strcmp (name, "__builtin_alloca"))))
673 flags |= ECF_MAY_BE_ALLOCA;
675 /* Disregard prefix _, __ or __x. */
678 if (name[1] == '_' && name[2] == 'x')
680 else if (name[1] == '_')
689 && (! strcmp (tname, "setjmp")
690 || ! strcmp (tname, "setjmp_syscall")))
692 && ! strcmp (tname, "sigsetjmp"))
694 && ! strcmp (tname, "savectx")))
695 flags |= ECF_RETURNS_TWICE;
698 && ! strcmp (tname, "siglongjmp"))
699 flags |= ECF_LONGJMP;
701 else if ((tname[0] == 'q' && tname[1] == 's'
702 && ! strcmp (tname, "qsetjmp"))
703 || (tname[0] == 'v' && tname[1] == 'f'
704 && ! strcmp (tname, "vfork")))
705 flags |= ECF_RETURNS_TWICE;
707 else if (tname[0] == 'l' && tname[1] == 'o'
708 && ! strcmp (tname, "longjmp"))
709 flags |= ECF_LONGJMP;
711 else if ((tname[0] == 'f' && tname[1] == 'o'
712 && ! strcmp (tname, "fork"))
713 /* Linux specific: __clone. check NAME to insist on the
714 leading underscores, to avoid polluting the ISO / POSIX
716 || (name[0] == '_' && name[1] == '_'
717 && ! strcmp (tname, "clone"))
718 || (tname[0] == 'e' && tname[1] == 'x' && tname[2] == 'e'
719 && tname[3] == 'c' && (tname[4] == 'l' || tname[4] == 'v')
721 || ((tname[5] == 'p' || tname[5] == 'e')
722 && tname[6] == '\0'))))
723 flags |= ECF_FORK_OR_EXEC;
725 /* Do not add any more malloc-like functions to this list,
726 instead mark them as malloc functions using the malloc attribute.
727 Note, realloc is not suitable for attribute malloc since
728 it may return the same address across multiple calls.
729 C++ operator new is not suitable because it is not required
730 to return a unique pointer; indeed, the standard placement new
731 just returns its argument. */
732 else if (TYPE_MODE (TREE_TYPE (TREE_TYPE (fndecl))) == Pmode
733 && (! strcmp (tname, "malloc")
734 || ! strcmp (tname, "calloc")
735 || ! strcmp (tname, "strdup")))
741 /* Return nonzero when tree represent call to longjmp. */
743 setjmp_call_p (fndecl)
746 return special_function_p (fndecl, 0) & ECF_RETURNS_TWICE;
749 /* Detect flags (function attributes) from the function type node. */
751 flags_from_decl_or_type (exp)
755 /* ??? We can't set IS_MALLOC for function types? */
758 /* The function exp may have the `malloc' attribute. */
759 if (DECL_P (exp) && DECL_IS_MALLOC (exp))
762 if (TREE_NOTHROW (exp))
763 flags |= ECF_NOTHROW;
766 if (TREE_READONLY (exp) && !TREE_THIS_VOLATILE (exp))
769 if (TREE_THIS_VOLATILE (exp))
770 flags |= ECF_NORETURN;
776 /* Precompute all register parameters as described by ARGS, storing values
777 into fields within the ARGS array.
779 NUM_ACTUALS indicates the total number elements in the ARGS array.
781 Set REG_PARM_SEEN if we encounter a register parameter. */
784 precompute_register_parameters (num_actuals, args, reg_parm_seen)
786 struct arg_data *args;
793 for (i = 0; i < num_actuals; i++)
794 if (args[i].reg != 0 && ! args[i].pass_on_stack)
798 if (args[i].value == 0)
801 args[i].value = expand_expr (args[i].tree_value, NULL_RTX,
803 preserve_temp_slots (args[i].value);
806 /* ANSI doesn't require a sequence point here,
807 but PCC has one, so this will avoid some problems. */
811 /* If we are to promote the function arg to a wider mode,
814 if (args[i].mode != TYPE_MODE (TREE_TYPE (args[i].tree_value)))
816 = convert_modes (args[i].mode,
817 TYPE_MODE (TREE_TYPE (args[i].tree_value)),
818 args[i].value, args[i].unsignedp);
820 /* If the value is expensive, and we are inside an appropriately
821 short loop, put the value into a pseudo and then put the pseudo
824 For small register classes, also do this if this call uses
825 register parameters. This is to avoid reload conflicts while
826 loading the parameters registers. */
828 if ((! (GET_CODE (args[i].value) == REG
829 || (GET_CODE (args[i].value) == SUBREG
830 && GET_CODE (SUBREG_REG (args[i].value)) == REG)))
831 && args[i].mode != BLKmode
832 && rtx_cost (args[i].value, SET) > 2
833 && ((SMALL_REGISTER_CLASSES && *reg_parm_seen)
834 || preserve_subexpressions_p ()))
835 args[i].value = copy_to_mode_reg (args[i].mode, args[i].value);
839 #ifdef REG_PARM_STACK_SPACE
841 /* The argument list is the property of the called routine and it
842 may clobber it. If the fixed area has been used for previous
843 parameters, we must save and restore it. */
845 save_fixed_argument_area (reg_parm_stack_space, argblock,
846 low_to_save, high_to_save)
847 int reg_parm_stack_space;
853 rtx save_area = NULL_RTX;
855 /* Compute the boundary of the that needs to be saved, if any. */
856 #ifdef ARGS_GROW_DOWNWARD
857 for (i = 0; i < reg_parm_stack_space + 1; i++)
859 for (i = 0; i < reg_parm_stack_space; i++)
862 if (i >= highest_outgoing_arg_in_use
863 || stack_usage_map[i] == 0)
866 if (*low_to_save == -1)
872 if (*low_to_save >= 0)
874 int num_to_save = *high_to_save - *low_to_save + 1;
875 enum machine_mode save_mode
876 = mode_for_size (num_to_save * BITS_PER_UNIT, MODE_INT, 1);
879 /* If we don't have the required alignment, must do this in BLKmode. */
880 if ((*low_to_save & (MIN (GET_MODE_SIZE (save_mode),
881 BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1)))
884 #ifdef ARGS_GROW_DOWNWARD
885 stack_area = gen_rtx_MEM (save_mode,
886 memory_address (save_mode,
887 plus_constant (argblock,
890 stack_area = gen_rtx_MEM (save_mode,
891 memory_address (save_mode,
892 plus_constant (argblock,
895 if (save_mode == BLKmode)
897 save_area = assign_stack_temp (BLKmode, num_to_save, 0);
898 /* Cannot use emit_block_move here because it can be done by a
899 library call which in turn gets into this place again and deadly
900 infinite recursion happens. */
901 move_by_pieces (validize_mem (save_area), stack_area, num_to_save,
906 save_area = gen_reg_rtx (save_mode);
907 emit_move_insn (save_area, stack_area);
914 restore_fixed_argument_area (save_area, argblock, high_to_save, low_to_save)
920 enum machine_mode save_mode = GET_MODE (save_area);
921 #ifdef ARGS_GROW_DOWNWARD
923 = gen_rtx_MEM (save_mode,
924 memory_address (save_mode,
925 plus_constant (argblock,
929 = gen_rtx_MEM (save_mode,
930 memory_address (save_mode,
931 plus_constant (argblock,
935 if (save_mode != BLKmode)
936 emit_move_insn (stack_area, save_area);
938 /* Cannot use emit_block_move here because it can be done by a library
939 call which in turn gets into this place again and deadly infinite
940 recursion happens. */
941 move_by_pieces (stack_area, validize_mem (save_area),
942 high_to_save - low_to_save + 1, PARM_BOUNDARY);
946 /* If any elements in ARGS refer to parameters that are to be passed in
947 registers, but not in memory, and whose alignment does not permit a
948 direct copy into registers. Copy the values into a group of pseudos
949 which we will later copy into the appropriate hard registers.
951 Pseudos for each unaligned argument will be stored into the array
952 args[argnum].aligned_regs. The caller is responsible for deallocating
953 the aligned_regs array if it is nonzero. */
956 store_unaligned_arguments_into_pseudos (args, num_actuals)
957 struct arg_data *args;
962 for (i = 0; i < num_actuals; i++)
963 if (args[i].reg != 0 && ! args[i].pass_on_stack
964 && args[i].mode == BLKmode
965 && (TYPE_ALIGN (TREE_TYPE (args[i].tree_value))
966 < (unsigned int) MIN (BIGGEST_ALIGNMENT, BITS_PER_WORD)))
968 int bytes = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
969 int big_endian_correction = 0;
971 args[i].n_aligned_regs
972 = args[i].partial ? args[i].partial
973 : (bytes + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
975 args[i].aligned_regs = (rtx *) xmalloc (sizeof (rtx)
976 * args[i].n_aligned_regs);
978 /* Structures smaller than a word are aligned to the least
979 significant byte (to the right). On a BYTES_BIG_ENDIAN machine,
980 this means we must skip the empty high order bytes when
981 calculating the bit offset. */
982 if (BYTES_BIG_ENDIAN && bytes < UNITS_PER_WORD)
983 big_endian_correction = (BITS_PER_WORD - (bytes * BITS_PER_UNIT));
985 for (j = 0; j < args[i].n_aligned_regs; j++)
987 rtx reg = gen_reg_rtx (word_mode);
988 rtx word = operand_subword_force (args[i].value, j, BLKmode);
989 int bitsize = MIN (bytes * BITS_PER_UNIT, BITS_PER_WORD);
990 int bitalign = TYPE_ALIGN (TREE_TYPE (args[i].tree_value));
992 args[i].aligned_regs[j] = reg;
994 /* There is no need to restrict this code to loading items
995 in TYPE_ALIGN sized hunks. The bitfield instructions can
996 load up entire word sized registers efficiently.
998 ??? This may not be needed anymore.
999 We use to emit a clobber here but that doesn't let later
1000 passes optimize the instructions we emit. By storing 0 into
1001 the register later passes know the first AND to zero out the
1002 bitfield being set in the register is unnecessary. The store
1003 of 0 will be deleted as will at least the first AND. */
1005 emit_move_insn (reg, const0_rtx);
1007 bytes -= bitsize / BITS_PER_UNIT;
1008 store_bit_field (reg, bitsize, big_endian_correction, word_mode,
1009 extract_bit_field (word, bitsize, 0, 1, NULL_RTX,
1010 word_mode, word_mode, bitalign,
1012 bitalign, BITS_PER_WORD);
1017 /* Fill in ARGS_SIZE and ARGS array based on the parameters found in
1020 NUM_ACTUALS is the total number of parameters.
1022 N_NAMED_ARGS is the total number of named arguments.
1024 FNDECL is the tree code for the target of this call (if known)
1026 ARGS_SO_FAR holds state needed by the target to know where to place
1029 REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
1030 for arguments which are passed in registers.
1032 OLD_STACK_LEVEL is a pointer to an rtx which olds the old stack level
1033 and may be modified by this routine.
1035 OLD_PENDING_ADJ, MUST_PREALLOCATE and FLAGS are pointers to integer
1036 flags which may may be modified by this routine. */
1039 initialize_argument_information (num_actuals, args, args_size, n_named_args,
1040 actparms, fndecl, args_so_far,
1041 reg_parm_stack_space, old_stack_level,
1042 old_pending_adj, must_preallocate,
1044 int num_actuals ATTRIBUTE_UNUSED;
1045 struct arg_data *args;
1046 struct args_size *args_size;
1047 int n_named_args ATTRIBUTE_UNUSED;
1050 CUMULATIVE_ARGS *args_so_far;
1051 int reg_parm_stack_space;
1052 rtx *old_stack_level;
1053 int *old_pending_adj;
1054 int *must_preallocate;
1057 /* 1 if scanning parms front to back, -1 if scanning back to front. */
1060 /* Count arg position in order args appear. */
1063 struct args_size alignment_pad;
1067 args_size->constant = 0;
1070 /* In this loop, we consider args in the order they are written.
1071 We fill up ARGS from the front or from the back if necessary
1072 so that in any case the first arg to be pushed ends up at the front. */
1074 if (PUSH_ARGS_REVERSED)
1076 i = num_actuals - 1, inc = -1;
1077 /* In this case, must reverse order of args
1078 so that we compute and push the last arg first. */
1085 /* I counts args in order (to be) pushed; ARGPOS counts in order written. */
1086 for (p = actparms, argpos = 0; p; p = TREE_CHAIN (p), i += inc, argpos++)
1088 tree type = TREE_TYPE (TREE_VALUE (p));
1090 enum machine_mode mode;
1092 args[i].tree_value = TREE_VALUE (p);
1094 /* Replace erroneous argument with constant zero. */
1095 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
1096 args[i].tree_value = integer_zero_node, type = integer_type_node;
1098 /* If TYPE is a transparent union, pass things the way we would
1099 pass the first field of the union. We have already verified that
1100 the modes are the same. */
1101 if (TYPE_TRANSPARENT_UNION (type))
1102 type = TREE_TYPE (TYPE_FIELDS (type));
1104 /* Decide where to pass this arg.
1106 args[i].reg is nonzero if all or part is passed in registers.
1108 args[i].partial is nonzero if part but not all is passed in registers,
1109 and the exact value says how many words are passed in registers.
1111 args[i].pass_on_stack is nonzero if the argument must at least be
1112 computed on the stack. It may then be loaded back into registers
1113 if args[i].reg is nonzero.
1115 These decisions are driven by the FUNCTION_... macros and must agree
1116 with those made by function.c. */
1118 /* See if this argument should be passed by invisible reference. */
1119 if ((TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST
1120 && contains_placeholder_p (TYPE_SIZE (type)))
1121 || TREE_ADDRESSABLE (type)
1122 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
1123 || FUNCTION_ARG_PASS_BY_REFERENCE (*args_so_far, TYPE_MODE (type),
1124 type, argpos < n_named_args)
1128 /* If we're compiling a thunk, pass through invisible
1129 references instead of making a copy. */
1130 if (current_function_is_thunk
1131 #ifdef FUNCTION_ARG_CALLEE_COPIES
1132 || (FUNCTION_ARG_CALLEE_COPIES (*args_so_far, TYPE_MODE (type),
1133 type, argpos < n_named_args)
1134 /* If it's in a register, we must make a copy of it too. */
1135 /* ??? Is this a sufficient test? Is there a better one? */
1136 && !(TREE_CODE (args[i].tree_value) == VAR_DECL
1137 && REG_P (DECL_RTL (args[i].tree_value)))
1138 && ! TREE_ADDRESSABLE (type))
1142 /* C++ uses a TARGET_EXPR to indicate that we want to make a
1143 new object from the argument. If we are passing by
1144 invisible reference, the callee will do that for us, so we
1145 can strip off the TARGET_EXPR. This is not always safe,
1146 but it is safe in the only case where this is a useful
1147 optimization; namely, when the argument is a plain object.
1148 In that case, the frontend is just asking the backend to
1149 make a bitwise copy of the argument. */
1151 if (TREE_CODE (args[i].tree_value) == TARGET_EXPR
1152 && (DECL_P (TREE_OPERAND (args[i].tree_value, 1)))
1153 && ! REG_P (DECL_RTL (TREE_OPERAND (args[i].tree_value, 1))))
1154 args[i].tree_value = TREE_OPERAND (args[i].tree_value, 1);
1156 args[i].tree_value = build1 (ADDR_EXPR,
1157 build_pointer_type (type),
1158 args[i].tree_value);
1159 type = build_pointer_type (type);
1163 /* We make a copy of the object and pass the address to the
1164 function being called. */
1167 if (!COMPLETE_TYPE_P (type)
1168 || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST
1169 || (flag_stack_check && ! STACK_CHECK_BUILTIN
1170 && (0 < compare_tree_int (TYPE_SIZE_UNIT (type),
1171 STACK_CHECK_MAX_VAR_SIZE))))
1173 /* This is a variable-sized object. Make space on the stack
1175 rtx size_rtx = expr_size (TREE_VALUE (p));
1177 if (*old_stack_level == 0)
1179 emit_stack_save (SAVE_BLOCK, old_stack_level, NULL_RTX);
1180 *old_pending_adj = pending_stack_adjust;
1181 pending_stack_adjust = 0;
1184 copy = gen_rtx_MEM (BLKmode,
1185 allocate_dynamic_stack_space (size_rtx,
1187 TYPE_ALIGN (type)));
1191 int size = int_size_in_bytes (type);
1192 copy = assign_stack_temp (TYPE_MODE (type), size, 0);
1195 MEM_SET_IN_STRUCT_P (copy, AGGREGATE_TYPE_P (type));
1197 store_expr (args[i].tree_value, copy, 0);
1198 *ecf_flags &= ~ECF_CONST;
1200 args[i].tree_value = build1 (ADDR_EXPR,
1201 build_pointer_type (type),
1202 make_tree (type, copy));
1203 type = build_pointer_type (type);
1207 mode = TYPE_MODE (type);
1208 unsignedp = TREE_UNSIGNED (type);
1210 #ifdef PROMOTE_FUNCTION_ARGS
1211 mode = promote_mode (type, mode, &unsignedp, 1);
1214 args[i].unsignedp = unsignedp;
1215 args[i].mode = mode;
1217 #ifdef FUNCTION_INCOMING_ARG
1218 /* If this is a sibling call and the machine has register windows, the
1219 register window has to be unwinded before calling the routine, so
1220 arguments have to go into the incoming registers. */
1221 if (ecf_flags & ECF_SIBCALL)
1222 args[i].reg = FUNCTION_INCOMING_ARG (*args_so_far, mode, type,
1223 argpos < n_named_args);
1226 args[i].reg = FUNCTION_ARG (*args_so_far, mode, type,
1227 argpos < n_named_args);
1229 #ifdef FUNCTION_ARG_PARTIAL_NREGS
1232 = FUNCTION_ARG_PARTIAL_NREGS (*args_so_far, mode, type,
1233 argpos < n_named_args);
1236 args[i].pass_on_stack = MUST_PASS_IN_STACK (mode, type);
1238 /* If FUNCTION_ARG returned a (parallel [(expr_list (nil) ...) ...]),
1239 it means that we are to pass this arg in the register(s) designated
1240 by the PARALLEL, but also to pass it in the stack. */
1241 if (args[i].reg && GET_CODE (args[i].reg) == PARALLEL
1242 && XEXP (XVECEXP (args[i].reg, 0, 0), 0) == 0)
1243 args[i].pass_on_stack = 1;
1245 /* If this is an addressable type, we must preallocate the stack
1246 since we must evaluate the object into its final location.
1248 If this is to be passed in both registers and the stack, it is simpler
1250 if (TREE_ADDRESSABLE (type)
1251 || (args[i].pass_on_stack && args[i].reg != 0))
1252 *must_preallocate = 1;
1254 /* If this is an addressable type, we cannot pre-evaluate it. Thus,
1255 we cannot consider this function call constant. */
1256 if (TREE_ADDRESSABLE (type))
1257 *ecf_flags &= ~ECF_CONST;
1259 /* Compute the stack-size of this argument. */
1260 if (args[i].reg == 0 || args[i].partial != 0
1261 || reg_parm_stack_space > 0
1262 || args[i].pass_on_stack)
1263 locate_and_pad_parm (mode, type,
1264 #ifdef STACK_PARMS_IN_REG_PARM_AREA
1269 fndecl, args_size, &args[i].offset,
1270 &args[i].size, &alignment_pad);
1272 #ifndef ARGS_GROW_DOWNWARD
1273 args[i].slot_offset = *args_size;
1276 args[i].alignment_pad = alignment_pad;
1278 /* If a part of the arg was put into registers,
1279 don't include that part in the amount pushed. */
1280 if (reg_parm_stack_space == 0 && ! args[i].pass_on_stack)
1281 args[i].size.constant -= ((args[i].partial * UNITS_PER_WORD)
1282 / (PARM_BOUNDARY / BITS_PER_UNIT)
1283 * (PARM_BOUNDARY / BITS_PER_UNIT));
1285 /* Update ARGS_SIZE, the total stack space for args so far. */
1287 args_size->constant += args[i].size.constant;
1288 if (args[i].size.var)
1290 ADD_PARM_SIZE (*args_size, args[i].size.var);
1293 /* Since the slot offset points to the bottom of the slot,
1294 we must record it after incrementing if the args grow down. */
1295 #ifdef ARGS_GROW_DOWNWARD
1296 args[i].slot_offset = *args_size;
1298 args[i].slot_offset.constant = -args_size->constant;
1300 SUB_PARM_SIZE (args[i].slot_offset, args_size->var);
1303 /* Increment ARGS_SO_FAR, which has info about which arg-registers
1304 have been used, etc. */
1306 FUNCTION_ARG_ADVANCE (*args_so_far, TYPE_MODE (type), type,
1307 argpos < n_named_args);
1311 /* Update ARGS_SIZE to contain the total size for the argument block.
1312 Return the original constant component of the argument block's size.
1314 REG_PARM_STACK_SPACE holds the number of bytes of stack space reserved
1315 for arguments passed in registers. */
1318 compute_argument_block_size (reg_parm_stack_space, args_size,
1319 preferred_stack_boundary)
1320 int reg_parm_stack_space;
1321 struct args_size *args_size;
1322 int preferred_stack_boundary ATTRIBUTE_UNUSED;
1324 int unadjusted_args_size = args_size->constant;
1326 /* For accumulate outgoing args mode we don't need to align, since the frame
1327 will be already aligned. Align to STACK_BOUNDARY in order to prevent
1328 backends from generating missaligned frame sizes. */
1329 #ifdef STACK_BOUNDARY
1330 if (ACCUMULATE_OUTGOING_ARGS && preferred_stack_boundary > STACK_BOUNDARY)
1331 preferred_stack_boundary = STACK_BOUNDARY;
1334 /* Compute the actual size of the argument block required. The variable
1335 and constant sizes must be combined, the size may have to be rounded,
1336 and there may be a minimum required size. */
1340 args_size->var = ARGS_SIZE_TREE (*args_size);
1341 args_size->constant = 0;
1343 #ifdef PREFERRED_STACK_BOUNDARY
1344 preferred_stack_boundary /= BITS_PER_UNIT;
1345 if (preferred_stack_boundary > 1)
1347 /* We don't handle this case yet. To handle it correctly we have
1348 to add the delta, round and substract the delta.
1349 Currently no machine description requires this support. */
1350 if (stack_pointer_delta & (preferred_stack_boundary - 1))
1352 args_size->var = round_up (args_size->var, preferred_stack_boundary);
1356 if (reg_parm_stack_space > 0)
1359 = size_binop (MAX_EXPR, args_size->var,
1360 ssize_int (reg_parm_stack_space));
1362 #ifndef OUTGOING_REG_PARM_STACK_SPACE
1363 /* The area corresponding to register parameters is not to count in
1364 the size of the block we need. So make the adjustment. */
1366 = size_binop (MINUS_EXPR, args_size->var,
1367 ssize_int (reg_parm_stack_space));
1373 #ifdef PREFERRED_STACK_BOUNDARY
1374 preferred_stack_boundary /= BITS_PER_UNIT;
1375 if (preferred_stack_boundary < 1)
1376 preferred_stack_boundary = 1;
1377 args_size->constant = (((args_size->constant
1378 + stack_pointer_delta
1379 + preferred_stack_boundary - 1)
1380 / preferred_stack_boundary
1381 * preferred_stack_boundary)
1382 - stack_pointer_delta);
1385 args_size->constant = MAX (args_size->constant,
1386 reg_parm_stack_space);
1388 #ifdef MAYBE_REG_PARM_STACK_SPACE
1389 if (reg_parm_stack_space == 0)
1390 args_size->constant = 0;
1393 #ifndef OUTGOING_REG_PARM_STACK_SPACE
1394 args_size->constant -= reg_parm_stack_space;
1397 return unadjusted_args_size;
1400 /* Precompute parameters as needed for a function call.
1402 FLAGS is mask of ECF_* constants.
1404 MUST_PREALLOCATE indicates that we must preallocate stack space for
1405 any stack arguments.
1407 NUM_ACTUALS is the number of arguments.
1409 ARGS is an array containing information for each argument; this routine
1410 fills in the INITIAL_VALUE and VALUE fields for each precomputed argument.
1412 ARGS_SIZE contains information about the size of the arg list. */
1415 precompute_arguments (flags, must_preallocate, num_actuals, args, args_size)
1417 int must_preallocate;
1419 struct arg_data *args;
1420 struct args_size *args_size;
1424 /* If this function call is cse'able, precompute all the parameters.
1425 Note that if the parameter is constructed into a temporary, this will
1426 cause an additional copy because the parameter will be constructed
1427 into a temporary location and then copied into the outgoing arguments.
1428 If a parameter contains a call to alloca and this function uses the
1429 stack, precompute the parameter. */
1431 /* If we preallocated the stack space, and some arguments must be passed
1432 on the stack, then we must precompute any parameter which contains a
1433 function call which will store arguments on the stack.
1434 Otherwise, evaluating the parameter may clobber previous parameters
1435 which have already been stored into the stack. */
1437 for (i = 0; i < num_actuals; i++)
1438 if ((flags & ECF_CONST)
1439 || ((args_size->var != 0 || args_size->constant != 0)
1440 && calls_function (args[i].tree_value, 1))
1441 || (must_preallocate
1442 && (args_size->var != 0 || args_size->constant != 0)
1443 && calls_function (args[i].tree_value, 0)))
1445 /* If this is an addressable type, we cannot pre-evaluate it. */
1446 if (TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value)))
1452 = expand_expr (args[i].tree_value, NULL_RTX, VOIDmode, 0);
1454 preserve_temp_slots (args[i].value);
1457 /* ANSI doesn't require a sequence point here,
1458 but PCC has one, so this will avoid some problems. */
1461 args[i].initial_value = args[i].value
1462 = protect_from_queue (args[i].value, 0);
1464 if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) != args[i].mode)
1467 = convert_modes (args[i].mode,
1468 TYPE_MODE (TREE_TYPE (args[i].tree_value)),
1469 args[i].value, args[i].unsignedp);
1470 #ifdef PROMOTE_FOR_CALL_ONLY
1471 /* CSE will replace this only if it contains args[i].value
1472 pseudo, so convert it down to the declared mode using
1474 if (GET_CODE (args[i].value) == REG
1475 && GET_MODE_CLASS (args[i].mode) == MODE_INT)
1477 args[i].initial_value
1478 = gen_rtx_SUBREG (TYPE_MODE (TREE_TYPE (args[i].tree_value)),
1480 SUBREG_PROMOTED_VAR_P (args[i].initial_value) = 1;
1481 SUBREG_PROMOTED_UNSIGNED_P (args[i].initial_value)
1482 = args[i].unsignedp;
1489 /* Given the current state of MUST_PREALLOCATE and information about
1490 arguments to a function call in NUM_ACTUALS, ARGS and ARGS_SIZE,
1491 compute and return the final value for MUST_PREALLOCATE. */
1494 finalize_must_preallocate (must_preallocate, num_actuals, args, args_size)
1495 int must_preallocate;
1497 struct arg_data *args;
1498 struct args_size *args_size;
1500 /* See if we have or want to preallocate stack space.
1502 If we would have to push a partially-in-regs parm
1503 before other stack parms, preallocate stack space instead.
1505 If the size of some parm is not a multiple of the required stack
1506 alignment, we must preallocate.
1508 If the total size of arguments that would otherwise create a copy in
1509 a temporary (such as a CALL) is more than half the total argument list
1510 size, preallocation is faster.
1512 Another reason to preallocate is if we have a machine (like the m88k)
1513 where stack alignment is required to be maintained between every
1514 pair of insns, not just when the call is made. However, we assume here
1515 that such machines either do not have push insns (and hence preallocation
1516 would occur anyway) or the problem is taken care of with
1519 if (! must_preallocate)
1521 int partial_seen = 0;
1522 int copy_to_evaluate_size = 0;
1525 for (i = 0; i < num_actuals && ! must_preallocate; i++)
1527 if (args[i].partial > 0 && ! args[i].pass_on_stack)
1529 else if (partial_seen && args[i].reg == 0)
1530 must_preallocate = 1;
1532 if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
1533 && (TREE_CODE (args[i].tree_value) == CALL_EXPR
1534 || TREE_CODE (args[i].tree_value) == TARGET_EXPR
1535 || TREE_CODE (args[i].tree_value) == COND_EXPR
1536 || TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value))))
1537 copy_to_evaluate_size
1538 += int_size_in_bytes (TREE_TYPE (args[i].tree_value));
1541 if (copy_to_evaluate_size * 2 >= args_size->constant
1542 && args_size->constant > 0)
1543 must_preallocate = 1;
1545 return must_preallocate;
1548 /* If we preallocated stack space, compute the address of each argument
1549 and store it into the ARGS array.
1551 We need not ensure it is a valid memory address here; it will be
1552 validized when it is used.
1554 ARGBLOCK is an rtx for the address of the outgoing arguments. */
1557 compute_argument_addresses (args, argblock, num_actuals)
1558 struct arg_data *args;
1564 rtx arg_reg = argblock;
1565 int i, arg_offset = 0;
1567 if (GET_CODE (argblock) == PLUS)
1568 arg_reg = XEXP (argblock, 0), arg_offset = INTVAL (XEXP (argblock, 1));
1570 for (i = 0; i < num_actuals; i++)
1572 rtx offset = ARGS_SIZE_RTX (args[i].offset);
1573 rtx slot_offset = ARGS_SIZE_RTX (args[i].slot_offset);
1576 /* Skip this parm if it will not be passed on the stack. */
1577 if (! args[i].pass_on_stack && args[i].reg != 0)
1580 if (GET_CODE (offset) == CONST_INT)
1581 addr = plus_constant (arg_reg, INTVAL (offset));
1583 addr = gen_rtx_PLUS (Pmode, arg_reg, offset);
1585 addr = plus_constant (addr, arg_offset);
1586 args[i].stack = gen_rtx_MEM (args[i].mode, addr);
1589 AGGREGATE_TYPE_P (TREE_TYPE (args[i].tree_value)));
1591 if (GET_CODE (slot_offset) == CONST_INT)
1592 addr = plus_constant (arg_reg, INTVAL (slot_offset));
1594 addr = gen_rtx_PLUS (Pmode, arg_reg, slot_offset);
1596 addr = plus_constant (addr, arg_offset);
1597 args[i].stack_slot = gen_rtx_MEM (args[i].mode, addr);
1602 /* Given a FNDECL and EXP, return an rtx suitable for use as a target address
1603 in a call instruction.
1605 FNDECL is the tree node for the target function. For an indirect call
1606 FNDECL will be NULL_TREE.
1608 EXP is the CALL_EXPR for this call. */
1611 rtx_for_function_call (fndecl, exp)
1617 /* Get the function to call, in the form of RTL. */
1620 /* If this is the first use of the function, see if we need to
1621 make an external definition for it. */
1622 if (! TREE_USED (fndecl))
1624 assemble_external (fndecl);
1625 TREE_USED (fndecl) = 1;
1628 /* Get a SYMBOL_REF rtx for the function address. */
1629 funexp = XEXP (DECL_RTL (fndecl), 0);
1632 /* Generate an rtx (probably a pseudo-register) for the address. */
1637 expand_expr (TREE_OPERAND (exp, 0), NULL_RTX, VOIDmode, 0);
1638 pop_temp_slots (); /* FUNEXP can't be BLKmode */
1640 /* Check the function is executable. */
1641 if (current_function_check_memory_usage)
1643 #ifdef POINTERS_EXTEND_UNSIGNED
1644 /* It might be OK to convert funexp in place, but there's
1645 a lot going on between here and when it happens naturally
1646 that this seems safer. */
1647 funaddr = convert_memory_address (Pmode, funexp);
1649 emit_library_call (chkr_check_exec_libfunc, 1,
1658 /* Do the register loads required for any wholly-register parms or any
1659 parms which are passed both on the stack and in a register. Their
1660 expressions were already evaluated.
1662 Mark all register-parms as living through the call, putting these USE
1663 insns in the CALL_INSN_FUNCTION_USAGE field. */
1666 load_register_parameters (args, num_actuals, call_fusage)
1667 struct arg_data *args;
1673 #ifdef LOAD_ARGS_REVERSED
1674 for (i = num_actuals - 1; i >= 0; i--)
1676 for (i = 0; i < num_actuals; i++)
1679 rtx reg = args[i].reg;
1680 int partial = args[i].partial;
1685 /* Set to non-negative if must move a word at a time, even if just
1686 one word (e.g, partial == 1 && mode == DFmode). Set to -1 if
1687 we just use a normal move insn. This value can be zero if the
1688 argument is a zero size structure with no fields. */
1689 nregs = (partial ? partial
1690 : (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
1691 ? ((int_size_in_bytes (TREE_TYPE (args[i].tree_value))
1692 + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
1695 /* Handle calls that pass values in multiple non-contiguous
1696 locations. The Irix 6 ABI has examples of this. */
1698 if (GET_CODE (reg) == PARALLEL)
1699 emit_group_load (reg, args[i].value,
1700 int_size_in_bytes (TREE_TYPE (args[i].tree_value)),
1701 TYPE_ALIGN (TREE_TYPE (args[i].tree_value)));
1703 /* If simple case, just do move. If normal partial, store_one_arg
1704 has already loaded the register for us. In all other cases,
1705 load the register(s) from memory. */
1707 else if (nregs == -1)
1708 emit_move_insn (reg, args[i].value);
1710 /* If we have pre-computed the values to put in the registers in
1711 the case of non-aligned structures, copy them in now. */
1713 else if (args[i].n_aligned_regs != 0)
1714 for (j = 0; j < args[i].n_aligned_regs; j++)
1715 emit_move_insn (gen_rtx_REG (word_mode, REGNO (reg) + j),
1716 args[i].aligned_regs[j]);
1718 else if (partial == 0 || args[i].pass_on_stack)
1719 move_block_to_reg (REGNO (reg),
1720 validize_mem (args[i].value), nregs,
1723 /* Handle calls that pass values in multiple non-contiguous
1724 locations. The Irix 6 ABI has examples of this. */
1725 if (GET_CODE (reg) == PARALLEL)
1726 use_group_regs (call_fusage, reg);
1727 else if (nregs == -1)
1728 use_reg (call_fusage, reg);
1730 use_regs (call_fusage, REGNO (reg), nregs == 0 ? 1 : nregs);
1735 /* Try to integreate function. See expand_inline_function for documentation
1736 about the parameters. */
1739 try_to_integrate (fndecl, actparms, target, ignore, type, structure_value_addr)
1745 rtx structure_value_addr;
1750 rtx old_stack_level = 0;
1751 int reg_parm_stack_space;
1753 #ifdef REG_PARM_STACK_SPACE
1754 #ifdef MAYBE_REG_PARM_STACK_SPACE
1755 reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
1757 reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
1761 before_call = get_last_insn ();
1763 temp = expand_inline_function (fndecl, actparms, target,
1765 structure_value_addr);
1767 /* If inlining succeeded, return. */
1768 if (temp != (rtx) (HOST_WIDE_INT) - 1)
1770 if (ACCUMULATE_OUTGOING_ARGS)
1772 /* If the outgoing argument list must be preserved, push
1773 the stack before executing the inlined function if it
1776 for (i = reg_parm_stack_space - 1; i >= 0; i--)
1777 if (i < highest_outgoing_arg_in_use && stack_usage_map[i] != 0)
1780 if (stack_arg_under_construction || i >= 0)
1783 = before_call ? NEXT_INSN (before_call) : get_insns ();
1784 rtx insn = NULL_RTX, seq;
1786 /* Look for a call in the inline function code.
1787 If DECL_SAVED_INSNS (fndecl)->outgoing_args_size is
1788 nonzero then there is a call and it is not necessary
1789 to scan the insns. */
1791 if (DECL_SAVED_INSNS (fndecl)->outgoing_args_size == 0)
1792 for (insn = first_insn; insn; insn = NEXT_INSN (insn))
1793 if (GET_CODE (insn) == CALL_INSN)
1798 /* Reserve enough stack space so that the largest
1799 argument list of any function call in the inline
1800 function does not overlap the argument list being
1801 evaluated. This is usually an overestimate because
1802 allocate_dynamic_stack_space reserves space for an
1803 outgoing argument list in addition to the requested
1804 space, but there is no way to ask for stack space such
1805 that an argument list of a certain length can be
1808 Add the stack space reserved for register arguments, if
1809 any, in the inline function. What is really needed is the
1810 largest value of reg_parm_stack_space in the inline
1811 function, but that is not available. Using the current
1812 value of reg_parm_stack_space is wrong, but gives
1813 correct results on all supported machines. */
1815 int adjust = (DECL_SAVED_INSNS (fndecl)->outgoing_args_size
1816 + reg_parm_stack_space);
1819 emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
1820 allocate_dynamic_stack_space (GEN_INT (adjust),
1821 NULL_RTX, BITS_PER_UNIT);
1824 emit_insns_before (seq, first_insn);
1825 emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
1830 /* If the result is equivalent to TARGET, return TARGET to simplify
1831 checks in store_expr. They can be equivalent but not equal in the
1832 case of a function that returns BLKmode. */
1833 if (temp != target && rtx_equal_p (temp, target))
1838 /* If inlining failed, mark FNDECL as needing to be compiled
1839 separately after all. If function was declared inline,
1841 if (DECL_INLINE (fndecl) && warn_inline && !flag_no_inline
1842 && optimize > 0 && !TREE_ADDRESSABLE (fndecl))
1844 warning_with_decl (fndecl, "inlining failed in call to `%s'");
1845 warning ("called from here");
1847 mark_addressable (fndecl);
1848 return (rtx) (HOST_WIDE_INT) - 1;
1851 /* Generate all the code for a function call
1852 and return an rtx for its value.
1853 Store the value in TARGET (specified as an rtx) if convenient.
1854 If the value is stored in TARGET then TARGET is returned.
1855 If IGNORE is nonzero, then we ignore the value of the function call. */
1858 expand_call (exp, target, ignore)
1863 /* Nonzero if we are currently expanding a call. */
1864 static int currently_expanding_call = 0;
1866 /* List of actual parameters. */
1867 tree actparms = TREE_OPERAND (exp, 1);
1868 /* RTX for the function to be called. */
1870 /* Sequence of insns to perform a tail recursive "call". */
1871 rtx tail_recursion_insns = NULL_RTX;
1872 /* Sequence of insns to perform a normal "call". */
1873 rtx normal_call_insns = NULL_RTX;
1874 /* Sequence of insns to perform a tail recursive "call". */
1875 rtx tail_call_insns = NULL_RTX;
1876 /* Data type of the function. */
1878 /* Declaration of the function being called,
1879 or 0 if the function is computed (not known by name). */
1886 /* Register in which non-BLKmode value will be returned,
1887 or 0 if no value or if value is BLKmode. */
1889 /* Address where we should return a BLKmode value;
1890 0 if value not BLKmode. */
1891 rtx structure_value_addr = 0;
1892 /* Nonzero if that address is being passed by treating it as
1893 an extra, implicit first parameter. Otherwise,
1894 it is passed by being copied directly into struct_value_rtx. */
1895 int structure_value_addr_parm = 0;
1896 /* Size of aggregate value wanted, or zero if none wanted
1897 or if we are using the non-reentrant PCC calling convention
1898 or expecting the value in registers. */
1899 HOST_WIDE_INT struct_value_size = 0;
1900 /* Nonzero if called function returns an aggregate in memory PCC style,
1901 by returning the address of where to find it. */
1902 int pcc_struct_value = 0;
1904 /* Number of actual parameters in this call, including struct value addr. */
1906 /* Number of named args. Args after this are anonymous ones
1907 and they must all go on the stack. */
1910 /* Vector of information about each argument.
1911 Arguments are numbered in the order they will be pushed,
1912 not the order they are written. */
1913 struct arg_data *args;
1915 /* Total size in bytes of all the stack-parms scanned so far. */
1916 struct args_size args_size;
1917 /* Size of arguments before any adjustments (such as rounding). */
1918 int unadjusted_args_size;
1919 /* Data on reg parms scanned so far. */
1920 CUMULATIVE_ARGS args_so_far;
1921 /* Nonzero if a reg parm has been scanned. */
1923 /* Nonzero if this is an indirect function call. */
1925 /* Nonzero if we must avoid push-insns in the args for this call.
1926 If stack space is allocated for register parameters, but not by the
1927 caller, then it is preallocated in the fixed part of the stack frame.
1928 So the entire argument block must then be preallocated (i.e., we
1929 ignore PUSH_ROUNDING in that case). */
1931 int must_preallocate = !PUSH_ARGS;
1933 /* Size of the stack reserved for parameter registers. */
1934 int reg_parm_stack_space = 0;
1936 /* Address of space preallocated for stack parms
1937 (on machines that lack push insns), or 0 if space not preallocated. */
1940 /* Mask of ECF_ flags. */
1942 /* Nonzero if this is a call to an inline function. */
1943 int is_integrable = 0;
1944 #ifdef REG_PARM_STACK_SPACE
1945 /* Define the boundary of the register parm stack space that needs to be
1947 int low_to_save = -1, high_to_save;
1948 rtx save_area = 0; /* Place that it is saved */
1951 int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
1952 char *initial_stack_usage_map = stack_usage_map;
1953 int old_stack_arg_under_construction = 0;
1955 rtx old_stack_level = 0;
1956 int old_pending_adj = 0;
1957 int old_inhibit_defer_pop = inhibit_defer_pop;
1958 int old_stack_allocated;
1962 int preferred_stack_boundary;
1964 /* The value of the function call can be put in a hard register. But
1965 if -fcheck-memory-usage, code which invokes functions (and thus
1966 damages some hard registers) can be inserted before using the value.
1967 So, target is always a pseudo-register in that case. */
1968 if (current_function_check_memory_usage)
1971 /* See if this is "nothrow" function call. */
1972 if (TREE_NOTHROW (exp))
1973 flags |= ECF_NOTHROW;
1975 /* See if we can find a DECL-node for the actual function.
1976 As a result, decide whether this is a call to an integrable function. */
1978 p = TREE_OPERAND (exp, 0);
1979 if (TREE_CODE (p) == ADDR_EXPR)
1981 fndecl = TREE_OPERAND (p, 0);
1982 if (TREE_CODE (fndecl) != FUNCTION_DECL)
1987 && fndecl != current_function_decl
1988 && DECL_INLINE (fndecl)
1989 && DECL_SAVED_INSNS (fndecl)
1990 && DECL_SAVED_INSNS (fndecl)->inlinable)
1992 else if (! TREE_ADDRESSABLE (fndecl))
1994 /* In case this function later becomes inlinable,
1995 record that there was already a non-inline call to it.
1997 Use abstraction instead of setting TREE_ADDRESSABLE
1999 if (DECL_INLINE (fndecl) && warn_inline && !flag_no_inline
2002 warning_with_decl (fndecl, "can't inline call to `%s'");
2003 warning ("called from here");
2005 mark_addressable (fndecl);
2008 flags |= flags_from_decl_or_type (fndecl);
2012 /* If we don't have specific function to call, see if we have a
2013 attributes set in the type. */
2016 flags |= flags_from_decl_or_type (TREE_TYPE (TREE_TYPE (p)));
2019 #ifdef REG_PARM_STACK_SPACE
2020 #ifdef MAYBE_REG_PARM_STACK_SPACE
2021 reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
2023 reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
2027 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2028 if (reg_parm_stack_space > 0 && PUSH_ARGS)
2029 must_preallocate = 1;
2032 /* Warn if this value is an aggregate type,
2033 regardless of which calling convention we are using for it. */
2034 if (warn_aggregate_return && AGGREGATE_TYPE_P (TREE_TYPE (exp)))
2035 warning ("function call has aggregate value");
2037 /* Set up a place to return a structure. */
2039 /* Cater to broken compilers. */
2040 if (aggregate_value_p (exp))
2042 /* This call returns a big structure. */
2043 flags &= ~ECF_CONST;
2045 #ifdef PCC_STATIC_STRUCT_RETURN
2047 pcc_struct_value = 1;
2048 /* Easier than making that case work right. */
2051 /* In case this is a static function, note that it has been
2053 if (! TREE_ADDRESSABLE (fndecl))
2054 mark_addressable (fndecl);
2058 #else /* not PCC_STATIC_STRUCT_RETURN */
2060 struct_value_size = int_size_in_bytes (TREE_TYPE (exp));
2062 if (target && GET_CODE (target) == MEM)
2063 structure_value_addr = XEXP (target, 0);
2066 /* Assign a temporary to hold the value. */
2069 /* For variable-sized objects, we must be called with a target
2070 specified. If we were to allocate space on the stack here,
2071 we would have no way of knowing when to free it. */
2073 if (struct_value_size < 0)
2076 /* This DECL is just something to feed to mark_addressable;
2077 it doesn't get pushed. */
2078 d = build_decl (VAR_DECL, NULL_TREE, TREE_TYPE (exp));
2079 DECL_RTL (d) = assign_temp (TREE_TYPE (exp), 1, 0, 1);
2080 mark_addressable (d);
2081 mark_temp_addr_taken (DECL_RTL (d));
2082 structure_value_addr = XEXP (DECL_RTL (d), 0);
2087 #endif /* not PCC_STATIC_STRUCT_RETURN */
2090 /* If called function is inline, try to integrate it. */
2094 rtx temp = try_to_integrate (fndecl, actparms, target,
2095 ignore, TREE_TYPE (exp),
2096 structure_value_addr);
2097 if (temp != (rtx) (HOST_WIDE_INT) - 1)
2101 currently_expanding_call++;
2103 /* Tail calls can make things harder to debug, and we're traditionally
2104 pushed these optimizations into -O2. Don't try if we're already
2105 expanding a call, as that means we're an argument. Similarly, if
2106 there's pending loops or cleanups we know there's code to follow
2110 if (flag_optimize_sibling_calls
2111 && currently_expanding_call == 1
2112 && stmt_loop_nest_empty ()
2113 && ! any_pending_cleanups (1))
2115 tree new_actparms = NULL_TREE;
2117 /* Ok, we're going to give the tail call the old college try.
2118 This means we're going to evaluate the function arguments
2119 up to three times. There are two degrees of badness we can
2120 encounter, those that can be unsaved and those that can't.
2121 (See unsafe_for_reeval commentary for details.)
2123 Generate a new argument list. Pass safe arguments through
2124 unchanged. For the easy badness wrap them in UNSAVE_EXPRs.
2125 For hard badness, evaluate them now and put their resulting
2126 rtx in a temporary VAR_DECL. */
2128 for (p = actparms; p; p = TREE_CHAIN (p))
2129 switch (unsafe_for_reeval (TREE_VALUE (p)))
2132 new_actparms = tree_cons (TREE_PURPOSE (p), TREE_VALUE (p),
2136 case 1: /* Mildly unsafe. */
2137 new_actparms = tree_cons (TREE_PURPOSE (p),
2138 unsave_expr (TREE_VALUE (p)),
2142 case 2: /* Wildly unsafe. */
2144 tree var = build_decl (VAR_DECL, NULL_TREE,
2145 TREE_TYPE (TREE_VALUE (p)));
2146 DECL_RTL (var) = expand_expr (TREE_VALUE (p), NULL_RTX,
2147 VOIDmode, EXPAND_NORMAL);
2148 new_actparms = tree_cons (TREE_PURPOSE (p), var, new_actparms);
2156 /* We built the new argument chain backwards. */
2157 actparms = nreverse (new_actparms);
2159 /* Expanding one of those dangerous arguments could have added
2160 cleanups, but otherwise give it a whirl. */
2161 try_tail_call = ! any_pending_cleanups (1);
2164 /* Generate a tail recursion sequence when calling ourselves. */
2167 && TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
2168 && TREE_OPERAND (TREE_OPERAND (exp, 0), 0) == current_function_decl)
2170 /* We want to emit any pending stack adjustments before the tail
2171 recursion "call". That way we know any adjustment after the tail
2172 recursion call can be ignored if we indeed use the tail recursion
2174 int save_pending_stack_adjust = pending_stack_adjust;
2175 int save_stack_pointer_delta = stack_pointer_delta;
2177 /* Use a new sequence to hold any RTL we generate. We do not even
2178 know if we will use this RTL yet. The final decision can not be
2179 made until after RTL generation for the entire function is
2183 /* Emit the pending stack adjustments before we expand any arguments. */
2184 do_pending_stack_adjust ();
2186 if (optimize_tail_recursion (actparms, get_last_insn ()))
2187 tail_recursion_insns = get_insns ();
2190 /* Restore the original pending stack adjustment for the sibling and
2191 normal call cases below. */
2192 pending_stack_adjust = save_pending_stack_adjust;
2193 stack_pointer_delta = save_stack_pointer_delta;
2196 function_call_count++;
2198 if (fndecl && DECL_NAME (fndecl))
2199 name = IDENTIFIER_POINTER (DECL_NAME (fndecl));
2201 #ifdef PREFERRED_STACK_BOUNDARY
2202 preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
2204 preferred_stack_boundary = STACK_BOUNDARY;
2207 /* Ensure current function's preferred stack boundary is at least
2208 what we need. We don't have to increase alignment for recursive
2210 if (cfun->preferred_stack_boundary < preferred_stack_boundary
2211 && fndecl != current_function_decl)
2212 cfun->preferred_stack_boundary = preferred_stack_boundary;
2214 /* See if this is a call to a function that can return more than once
2215 or a call to longjmp or malloc. */
2216 flags |= special_function_p (fndecl, flags);
2218 if (flags & ECF_MAY_BE_ALLOCA)
2219 current_function_calls_alloca = 1;
2221 /* Operand 0 is a pointer-to-function; get the type of the function. */
2222 funtype = TREE_TYPE (TREE_OPERAND (exp, 0));
2223 if (! POINTER_TYPE_P (funtype))
2225 funtype = TREE_TYPE (funtype);
2227 /* We want to make two insn chains; one for a sibling call, the other
2228 for a normal call. We will select one of the two chains after
2229 initial RTL generation is complete. */
2230 for (pass = 0; pass < 2; pass++)
2232 int sibcall_failure = 0;
2233 /* We want to emit ay pending stack adjustments before the tail
2234 recursion "call". That way we know any adjustment after the tail
2235 recursion call can be ignored if we indeed use the tail recursion
2237 int save_pending_stack_adjust;
2238 int save_stack_pointer_delta;
2240 rtx before_call, next_arg_reg;
2244 /* Various reasons we can not use a sibling call. */
2246 #ifdef HAVE_sibcall_epilogue
2247 || ! HAVE_sibcall_epilogue
2251 /* The structure value address is used and modified in the
2252 loop below. It does not seem worth the effort to save and
2253 restore it as a state variable since few optimizable
2254 sibling calls will return a structure. */
2255 || structure_value_addr != NULL_RTX
2256 /* If the register holding the address is a callee saved
2257 register, then we lose. We have no way to prevent that,
2258 so we only allow calls to named functions. */
2259 /* ??? This could be done by having the insn constraints
2260 use a register class that is all call-clobbered. Any
2261 reload insns generated to fix things up would appear
2262 before the sibcall_epilogue. */
2263 || fndecl == NULL_TREE
2264 || ! FUNCTION_OK_FOR_SIBCALL (fndecl))
2267 /* We know at this point that there are not currently any
2268 pending cleanups. If, however, in the process of evaluating
2269 the arguments we were to create some, we'll need to be
2270 able to get rid of them. */
2271 expand_start_target_temps ();
2273 /* State variables we need to save and restore between
2275 save_pending_stack_adjust = pending_stack_adjust;
2276 save_stack_pointer_delta = stack_pointer_delta;
2279 flags &= ~ECF_SIBCALL;
2281 flags |= ECF_SIBCALL;
2283 /* Other state variables that we must reinitialize each time
2284 through the loop (that are not initialized by the loop itself). */
2288 /* Start a new sequence for the normal call case.
2290 From this point on, if the sibling call fails, we want to set
2291 sibcall_failure instead of continuing the loop. */
2294 /* When calling a const function, we must pop the stack args right away,
2295 so that the pop is deleted or moved with the call. */
2296 if (flags & ECF_CONST)
2299 /* Don't let pending stack adjusts add up to too much.
2300 Also, do all pending adjustments now if there is any chance
2301 this might be a call to alloca or if we are expanding a sibling
2303 if (pending_stack_adjust >= 32
2304 || (pending_stack_adjust > 0 && (flags & ECF_MAY_BE_ALLOCA))
2306 do_pending_stack_adjust ();
2308 if (profile_arc_flag && (flags & ECF_FORK_OR_EXEC))
2310 /* A fork duplicates the profile information, and an exec discards
2311 it. We can't rely on fork/exec to be paired. So write out the
2312 profile information we have gathered so far, and clear it. */
2313 /* ??? When Linux's __clone is called with CLONE_VM set, profiling
2314 is subject to race conditions, just as with multithreaded
2317 emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__bb_fork_func"), 0,
2321 /* Push the temporary stack slot level so that we can free any
2322 temporaries we make. */
2325 /* Start updating where the next arg would go.
2327 On some machines (such as the PA) indirect calls have a different
2328 calling convention than normal calls. The last argument in
2329 INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
2331 INIT_CUMULATIVE_ARGS (args_so_far, funtype, NULL_RTX, (fndecl == 0));
2333 /* If struct_value_rtx is 0, it means pass the address
2334 as if it were an extra parameter. */
2335 if (structure_value_addr && struct_value_rtx == 0)
2337 /* If structure_value_addr is a REG other than
2338 virtual_outgoing_args_rtx, we can use always use it. If it
2339 is not a REG, we must always copy it into a register.
2340 If it is virtual_outgoing_args_rtx, we must copy it to another
2341 register in some cases. */
2342 rtx temp = (GET_CODE (structure_value_addr) != REG
2343 || (ACCUMULATE_OUTGOING_ARGS
2344 && stack_arg_under_construction
2345 && structure_value_addr == virtual_outgoing_args_rtx)
2346 ? copy_addr_to_reg (structure_value_addr)
2347 : structure_value_addr);
2350 = tree_cons (error_mark_node,
2351 make_tree (build_pointer_type (TREE_TYPE (funtype)),
2354 structure_value_addr_parm = 1;
2357 /* Count the arguments and set NUM_ACTUALS. */
2358 for (p = actparms, i = 0; p; p = TREE_CHAIN (p)) i++;
2361 /* Compute number of named args.
2362 Normally, don't include the last named arg if anonymous args follow.
2363 We do include the last named arg if STRICT_ARGUMENT_NAMING is nonzero.
2364 (If no anonymous args follow, the result of list_length is actually
2365 one too large. This is harmless.)
2367 If PRETEND_OUTGOING_VARARGS_NAMED is set and STRICT_ARGUMENT_NAMING is
2368 zero, this machine will be able to place unnamed args that were
2369 passed in registers into the stack. So treat all args as named.
2370 This allows the insns emitting for a specific argument list to be
2371 independent of the function declaration.
2373 If PRETEND_OUTGOING_VARARGS_NAMED is not set, we do not have any
2374 reliable way to pass unnamed args in registers, so we must force
2375 them into memory. */
2377 if ((STRICT_ARGUMENT_NAMING
2378 || ! PRETEND_OUTGOING_VARARGS_NAMED)
2379 && TYPE_ARG_TYPES (funtype) != 0)
2381 = (list_length (TYPE_ARG_TYPES (funtype))
2382 /* Don't include the last named arg. */
2383 - (STRICT_ARGUMENT_NAMING ? 0 : 1)
2384 /* Count the struct value address, if it is passed as a parm. */
2385 + structure_value_addr_parm);
2387 /* If we know nothing, treat all args as named. */
2388 n_named_args = num_actuals;
2390 /* Make a vector to hold all the information about each arg. */
2391 args = (struct arg_data *) alloca (num_actuals
2392 * sizeof (struct arg_data));
2393 bzero ((char *) args, num_actuals * sizeof (struct arg_data));
2395 /* Build up entries inthe ARGS array, compute the size of the arguments
2396 into ARGS_SIZE, etc. */
2397 initialize_argument_information (num_actuals, args, &args_size,
2398 n_named_args, actparms, fndecl,
2399 &args_so_far, reg_parm_stack_space,
2400 &old_stack_level, &old_pending_adj,
2401 &must_preallocate, &flags);
2403 #ifdef FINAL_REG_PARM_STACK_SPACE
2404 reg_parm_stack_space = FINAL_REG_PARM_STACK_SPACE (args_size.constant,
2410 /* If this function requires a variable-sized argument list, don't
2411 try to make a cse'able block for this call. We may be able to
2412 do this eventually, but it is too complicated to keep track of
2413 what insns go in the cse'able block and which don't.
2415 Also do not make a sibling call. */
2417 flags &= ~ECF_CONST;
2418 must_preallocate = 1;
2419 sibcall_failure = 1;
2422 if (args_size.constant > current_function_args_size)
2424 /* If this function requires more stack slots than the current
2425 function, we cannot change it into a sibling call. */
2426 sibcall_failure = 1;
2429 /* Compute the actual size of the argument block required. The variable
2430 and constant sizes must be combined, the size may have to be rounded,
2431 and there may be a minimum required size. When generating a sibcall
2432 pattern, do not round up, since we'll be re-using whatever space our
2434 unadjusted_args_size
2435 = compute_argument_block_size (reg_parm_stack_space, &args_size,
2437 : preferred_stack_boundary));
2439 /* If the callee pops its own arguments, then it must pop exactly
2440 the same number of arguments as the current function. */
2441 if (RETURN_POPS_ARGS (fndecl, funtype, unadjusted_args_size)
2442 != RETURN_POPS_ARGS (current_function_decl,
2443 TREE_TYPE (current_function_decl),
2444 current_function_args_size))
2445 sibcall_failure = 1;
2447 /* Now make final decision about preallocating stack space. */
2448 must_preallocate = finalize_must_preallocate (must_preallocate,
2452 /* If the structure value address will reference the stack pointer, we
2453 must stabilize it. We don't need to do this if we know that we are
2454 not going to adjust the stack pointer in processing this call. */
2456 if (structure_value_addr
2457 && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
2458 || reg_mentioned_p (virtual_outgoing_args_rtx,
2459 structure_value_addr))
2461 || (!ACCUMULATE_OUTGOING_ARGS && args_size.constant)
2463 structure_value_addr = copy_to_reg (structure_value_addr);
2465 /* Precompute any arguments as needed. */
2466 precompute_arguments (flags, must_preallocate, num_actuals,
2469 /* Now we are about to start emitting insns that can be deleted
2470 if a libcall is deleted. */
2471 if (flags & (ECF_CONST | ECF_MALLOC))
2474 old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
2476 /* If we have no actual push instructions, or shouldn't use them,
2477 make space for all args right now. */
2479 if (args_size.var != 0)
2481 if (old_stack_level == 0)
2483 emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
2484 old_pending_adj = pending_stack_adjust;
2485 pending_stack_adjust = 0;
2486 /* stack_arg_under_construction says whether a stack arg is
2487 being constructed at the old stack level. Pushing the stack
2488 gets a clean outgoing argument block. */
2489 old_stack_arg_under_construction = stack_arg_under_construction;
2490 stack_arg_under_construction = 0;
2492 argblock = push_block (ARGS_SIZE_RTX (args_size), 0, 0);
2496 /* Note that we must go through the motions of allocating an argument
2497 block even if the size is zero because we may be storing args
2498 in the area reserved for register arguments, which may be part of
2501 int needed = args_size.constant;
2503 /* Store the maximum argument space used. It will be pushed by
2504 the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
2507 if (needed > current_function_outgoing_args_size)
2508 current_function_outgoing_args_size = needed;
2510 if (must_preallocate)
2512 if (ACCUMULATE_OUTGOING_ARGS)
2514 /* Since the stack pointer will never be pushed, it is possible
2515 for the evaluation of a parm to clobber something we have
2516 already written to the stack. Since most function calls on
2517 RISC machines do not use the stack, this is uncommon, but
2518 must work correctly.
2520 Therefore, we save any area of the stack that was already
2521 written and that we are using. Here we set up to do this by
2522 making a new stack usage map from the old one. The actual
2523 save will be done by store_one_arg.
2525 Another approach might be to try to reorder the argument
2526 evaluations to avoid this conflicting stack usage. */
2528 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2529 /* Since we will be writing into the entire argument area, the
2530 map must be allocated for its entire size, not just the part
2531 that is the responsibility of the caller. */
2532 needed += reg_parm_stack_space;
2535 #ifdef ARGS_GROW_DOWNWARD
2536 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
2539 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
2542 stack_usage_map = (char *) alloca (highest_outgoing_arg_in_use);
2544 if (initial_highest_arg_in_use)
2545 bcopy (initial_stack_usage_map, stack_usage_map,
2546 initial_highest_arg_in_use);
2548 if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
2549 bzero (&stack_usage_map[initial_highest_arg_in_use],
2550 (highest_outgoing_arg_in_use
2551 - initial_highest_arg_in_use));
2554 /* The address of the outgoing argument list must not be copied
2555 to a register here, because argblock would be left pointing
2556 to the wrong place after the call to
2557 allocate_dynamic_stack_space below. */
2559 argblock = virtual_outgoing_args_rtx;
2563 if (inhibit_defer_pop == 0)
2565 /* Try to reuse some or all of the pending_stack_adjust
2566 to get this space. Maybe we can avoid any pushing. */
2567 if (needed > pending_stack_adjust)
2569 needed -= pending_stack_adjust;
2570 pending_stack_adjust = 0;
2574 pending_stack_adjust -= needed;
2578 /* Special case this because overhead of `push_block' in this
2579 case is non-trivial. */
2581 argblock = virtual_outgoing_args_rtx;
2583 argblock = push_block (GEN_INT (needed), 0, 0);
2585 /* We only really need to call `copy_to_reg' in the case where
2586 push insns are going to be used to pass ARGBLOCK to a function
2587 call in ARGS. In that case, the stack pointer changes value
2588 from the allocation point to the call point, and hence
2589 the value of VIRTUAL_OUTGOING_ARGS_RTX changes as well.
2590 But might as well always do it. */
2591 argblock = copy_to_reg (argblock);
2596 /* The argument block when performing a sibling call is the
2597 incoming argument block. */
2600 rtx temp = plus_constant (arg_pointer_rtx,
2601 FIRST_PARM_OFFSET (current_function_decl));
2602 argblock = force_reg (Pmode, force_operand (temp, NULL_RTX));
2605 if (ACCUMULATE_OUTGOING_ARGS)
2607 /* The save/restore code in store_one_arg handles all cases except one:
2608 a constructor call (including a C function returning a BLKmode struct)
2609 to initialize an argument. */
2610 if (stack_arg_under_construction)
2612 #ifndef OUTGOING_REG_PARM_STACK_SPACE
2613 rtx push_size = GEN_INT (reg_parm_stack_space + args_size.constant);
2615 rtx push_size = GEN_INT (args_size.constant);
2617 if (old_stack_level == 0)
2619 emit_stack_save (SAVE_BLOCK, &old_stack_level, NULL_RTX);
2620 old_pending_adj = pending_stack_adjust;
2621 pending_stack_adjust = 0;
2622 /* stack_arg_under_construction says whether a stack arg is
2623 being constructed at the old stack level. Pushing the stack
2624 gets a clean outgoing argument block. */
2625 old_stack_arg_under_construction = stack_arg_under_construction;
2626 stack_arg_under_construction = 0;
2627 /* Make a new map for the new argument list. */
2628 stack_usage_map = (char *)alloca (highest_outgoing_arg_in_use);
2629 bzero (stack_usage_map, highest_outgoing_arg_in_use);
2630 highest_outgoing_arg_in_use = 0;
2632 allocate_dynamic_stack_space (push_size, NULL_RTX, BITS_PER_UNIT);
2634 /* If argument evaluation might modify the stack pointer, copy the
2635 address of the argument list to a register. */
2636 for (i = 0; i < num_actuals; i++)
2637 if (args[i].pass_on_stack)
2639 argblock = copy_addr_to_reg (argblock);
2644 compute_argument_addresses (args, argblock, num_actuals);
2646 #ifdef PREFERRED_STACK_BOUNDARY
2647 /* If we push args individually in reverse order, perform stack alignment
2648 before the first push (the last arg). */
2649 if (PUSH_ARGS_REVERSED && argblock == 0
2650 && args_size.constant != unadjusted_args_size)
2652 /* When the stack adjustment is pending, we get better code
2653 by combining the adjustments. */
2654 if (pending_stack_adjust && ! (flags & ECF_CONST)
2655 && ! inhibit_defer_pop)
2658 args_size.constant = (unadjusted_args_size
2659 + ((pending_stack_adjust
2660 + args_size.constant
2661 - unadjusted_args_size)
2662 % (preferred_stack_boundary
2664 adjust = (pending_stack_adjust - args_size.constant
2665 + unadjusted_args_size);
2666 adjust_stack (GEN_INT (adjust));
2667 pending_stack_adjust = 0;
2669 else if (argblock == 0)
2670 anti_adjust_stack (GEN_INT (args_size.constant
2671 - unadjusted_args_size));
2672 /* Now that the stack is properly aligned, pops can't safely
2673 be deferred during the evaluation of the arguments. */
2678 /* Don't try to defer pops if preallocating, not even from the first arg,
2679 since ARGBLOCK probably refers to the SP. */
2683 funexp = rtx_for_function_call (fndecl, exp);
2685 /* Figure out the register where the value, if any, will come back. */
2687 if (TYPE_MODE (TREE_TYPE (exp)) != VOIDmode
2688 && ! structure_value_addr)
2690 if (pcc_struct_value)
2691 valreg = hard_function_value (build_pointer_type (TREE_TYPE (exp)),
2692 fndecl, (pass == 0));
2694 valreg = hard_function_value (TREE_TYPE (exp), fndecl, (pass == 0));
2697 /* Precompute all register parameters. It isn't safe to compute anything
2698 once we have started filling any specific hard regs. */
2699 precompute_register_parameters (num_actuals, args, ®_parm_seen);
2701 #ifdef REG_PARM_STACK_SPACE
2702 /* Save the fixed argument area if it's part of the caller's frame and
2703 is clobbered by argument setup for this call. */
2704 if (ACCUMULATE_OUTGOING_ARGS)
2705 save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
2706 &low_to_save, &high_to_save);
2709 /* Now store (and compute if necessary) all non-register parms.
2710 These come before register parms, since they can require block-moves,
2711 which could clobber the registers used for register parms.
2712 Parms which have partial registers are not stored here,
2713 but we do preallocate space here if they want that. */
2715 for (i = 0; i < num_actuals; i++)
2716 if (args[i].reg == 0 || args[i].pass_on_stack)
2717 store_one_arg (&args[i], argblock, flags & ECF_MAY_BE_ALLOCA,
2718 args_size.var != 0, reg_parm_stack_space);
2720 /* If we have a parm that is passed in registers but not in memory
2721 and whose alignment does not permit a direct copy into registers,
2722 make a group of pseudos that correspond to each register that we
2724 if (STRICT_ALIGNMENT)
2725 store_unaligned_arguments_into_pseudos (args, num_actuals);
2727 /* Now store any partially-in-registers parm.
2728 This is the last place a block-move can happen. */
2730 for (i = 0; i < num_actuals; i++)
2731 if (args[i].partial != 0 && ! args[i].pass_on_stack)
2732 store_one_arg (&args[i], argblock, flags & ECF_MAY_BE_ALLOCA,
2733 args_size.var != 0, reg_parm_stack_space);
2735 #ifdef PREFERRED_STACK_BOUNDARY
2736 /* If we pushed args in forward order, perform stack alignment
2737 after pushing the last arg. */
2738 if (!PUSH_ARGS_REVERSED && argblock == 0)
2739 anti_adjust_stack (GEN_INT (args_size.constant
2740 - unadjusted_args_size));
2743 /* If register arguments require space on the stack and stack space
2744 was not preallocated, allocate stack space here for arguments
2745 passed in registers. */
2746 #ifdef OUTGOING_REG_PARM_STACK_SPACE
2747 if (!ACCUMULATE_OUTGOING_ARGS
2748 && must_preallocate == 0 && reg_parm_stack_space > 0)
2749 anti_adjust_stack (GEN_INT (reg_parm_stack_space));
2752 /* Pass the function the address in which to return a
2754 if (pass != 0 && structure_value_addr && ! structure_value_addr_parm)
2756 emit_move_insn (struct_value_rtx,
2758 force_operand (structure_value_addr,
2761 /* Mark the memory for the aggregate as write-only. */
2762 if (current_function_check_memory_usage)
2763 emit_library_call (chkr_set_right_libfunc, 1,
2765 structure_value_addr, ptr_mode,
2766 GEN_INT (struct_value_size),
2767 TYPE_MODE (sizetype),
2768 GEN_INT (MEMORY_USE_WO),
2769 TYPE_MODE (integer_type_node));
2771 if (GET_CODE (struct_value_rtx) == REG)
2772 use_reg (&call_fusage, struct_value_rtx);
2775 funexp = prepare_call_address (funexp, fndecl, &call_fusage,
2778 load_register_parameters (args, num_actuals, &call_fusage);
2780 /* Perform postincrements before actually calling the function. */
2783 /* Save a pointer to the last insn before the call, so that we can
2784 later safely search backwards to find the CALL_INSN. */
2785 before_call = get_last_insn ();
2787 /* Set up next argument register. For sibling calls on machines
2788 with register windows this should be the incoming register. */
2789 #ifdef FUNCTION_INCOMING_ARG
2791 next_arg_reg = FUNCTION_INCOMING_ARG (args_so_far, VOIDmode,
2795 next_arg_reg = FUNCTION_ARG (args_so_far, VOIDmode,
2798 /* All arguments and registers used for the call must be set up by
2801 /* Generate the actual call instruction. */
2802 emit_call_1 (funexp, fndecl, funtype, unadjusted_args_size,
2803 args_size.constant, struct_value_size,
2804 next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
2807 /* Verify that we've deallocated all the stack we used. */
2809 && old_stack_allocated != stack_pointer_delta - pending_stack_adjust)
2812 /* If call is cse'able, make appropriate pair of reg-notes around it.
2813 Test valreg so we don't crash; may safely ignore `const'
2814 if return type is void. Disable for PARALLEL return values, because
2815 we have no way to move such values into a pseudo register. */
2816 if ((flags & ECF_CONST) && valreg != 0 && GET_CODE (valreg) != PARALLEL)
2819 rtx temp = gen_reg_rtx (GET_MODE (valreg));
2822 /* Mark the return value as a pointer if needed. */
2823 if (TREE_CODE (TREE_TYPE (exp)) == POINTER_TYPE)
2824 mark_reg_pointer (temp, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (exp))));
2826 /* Construct an "equal form" for the value which mentions all the
2827 arguments in order as well as the function name. */
2828 if (PUSH_ARGS_REVERSED)
2829 for (i = 0; i < num_actuals; i++)
2830 note = gen_rtx_EXPR_LIST (VOIDmode, args[i].initial_value, note);
2832 for (i = num_actuals - 1; i >= 0; i--)
2833 note = gen_rtx_EXPR_LIST (VOIDmode, args[i].initial_value, note);
2834 note = gen_rtx_EXPR_LIST (VOIDmode, funexp, note);
2836 insns = get_insns ();
2839 emit_libcall_block (insns, temp, valreg, note);
2843 else if (flags & ECF_CONST)
2845 /* Otherwise, just write out the sequence without a note. */
2846 rtx insns = get_insns ();
2851 else if (flags & ECF_MALLOC)
2853 rtx temp = gen_reg_rtx (GET_MODE (valreg));
2856 /* The return value from a malloc-like function is a pointer. */
2857 if (TREE_CODE (TREE_TYPE (exp)) == POINTER_TYPE)
2858 mark_reg_pointer (temp, BIGGEST_ALIGNMENT);
2860 emit_move_insn (temp, valreg);
2862 /* The return value from a malloc-like function can not alias
2864 last = get_last_insn ();
2866 gen_rtx_EXPR_LIST (REG_NOALIAS, temp, REG_NOTES (last));
2868 /* Write out the sequence. */
2869 insns = get_insns ();
2875 /* For calls to `setjmp', etc., inform flow.c it should complain
2876 if nonvolatile values are live. For functions that cannot return,
2877 inform flow that control does not fall through. */
2879 if ((flags & (ECF_RETURNS_TWICE | ECF_NORETURN | ECF_LONGJMP)) || pass == 0)
2881 /* The barrier or NOTE_INSN_SETJMP note must be emitted
2882 immediately after the CALL_INSN. Some ports emit more
2883 than just a CALL_INSN above, so we must search for it here. */
2885 rtx last = get_last_insn ();
2886 while (GET_CODE (last) != CALL_INSN)
2888 last = PREV_INSN (last);
2889 /* There was no CALL_INSN? */
2890 if (last == before_call)
2894 if (flags & ECF_RETURNS_TWICE)
2896 emit_note_after (NOTE_INSN_SETJMP, last);
2897 current_function_calls_setjmp = 1;
2898 sibcall_failure = 1;
2901 emit_barrier_after (last);
2904 if (flags & ECF_LONGJMP)
2905 current_function_calls_longjmp = 1, sibcall_failure = 1;
2907 /* If this function is returning into a memory location marked as
2908 readonly, it means it is initializing that location. But we normally
2909 treat functions as not clobbering such locations, so we need to
2910 specify that this one does. */
2911 if (target != 0 && GET_CODE (target) == MEM
2912 && structure_value_addr != 0 && RTX_UNCHANGING_P (target))
2913 emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
2915 /* If value type not void, return an rtx for the value. */
2917 /* If there are cleanups to be called, don't use a hard reg as target.
2918 We need to double check this and see if it matters anymore. */
2919 if (any_pending_cleanups (1))
2921 if (target && REG_P (target)
2922 && REGNO (target) < FIRST_PSEUDO_REGISTER)
2924 sibcall_failure = 1;
2927 if (TYPE_MODE (TREE_TYPE (exp)) == VOIDmode
2930 target = const0_rtx;
2932 else if (structure_value_addr)
2934 if (target == 0 || GET_CODE (target) != MEM)
2936 target = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
2937 memory_address (TYPE_MODE (TREE_TYPE (exp)),
2938 structure_value_addr));
2939 MEM_SET_IN_STRUCT_P (target,
2940 AGGREGATE_TYPE_P (TREE_TYPE (exp)));
2943 else if (pcc_struct_value)
2945 /* This is the special C++ case where we need to
2946 know what the true target was. We take care to
2947 never use this value more than once in one expression. */
2948 target = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
2949 copy_to_reg (valreg));
2950 MEM_SET_IN_STRUCT_P (target, AGGREGATE_TYPE_P (TREE_TYPE (exp)));
2952 /* Handle calls that return values in multiple non-contiguous locations.
2953 The Irix 6 ABI has examples of this. */
2954 else if (GET_CODE (valreg) == PARALLEL)
2956 int bytes = int_size_in_bytes (TREE_TYPE (exp));
2960 target = assign_stack_temp (TYPE_MODE (TREE_TYPE (exp)),
2962 MEM_SET_IN_STRUCT_P (target, AGGREGATE_TYPE_P (TREE_TYPE (exp)));
2963 preserve_temp_slots (target);
2966 if (! rtx_equal_p (target, valreg))
2967 emit_group_store (target, valreg, bytes,
2968 TYPE_ALIGN (TREE_TYPE (exp)));
2970 /* We can not support sibling calls for this case. */
2971 sibcall_failure = 1;
2974 && GET_MODE (target) == TYPE_MODE (TREE_TYPE (exp))
2975 && GET_MODE (target) == GET_MODE (valreg))
2977 /* TARGET and VALREG cannot be equal at this point because the
2978 latter would not have REG_FUNCTION_VALUE_P true, while the
2979 former would if it were referring to the same register.
2981 If they refer to the same register, this move will be a no-op,
2982 except when function inlining is being done. */
2983 emit_move_insn (target, valreg);
2985 else if (TYPE_MODE (TREE_TYPE (exp)) == BLKmode)
2986 target = copy_blkmode_from_reg (target, valreg, TREE_TYPE (exp));
2988 target = copy_to_reg (valreg);
2990 #ifdef PROMOTE_FUNCTION_RETURN
2991 /* If we promoted this return value, make the proper SUBREG. TARGET
2992 might be const0_rtx here, so be careful. */
2993 if (GET_CODE (target) == REG
2994 && TYPE_MODE (TREE_TYPE (exp)) != BLKmode
2995 && GET_MODE (target) != TYPE_MODE (TREE_TYPE (exp)))
2997 tree type = TREE_TYPE (exp);
2998 int unsignedp = TREE_UNSIGNED (type);
3000 /* If we don't promote as expected, something is wrong. */
3001 if (GET_MODE (target)
3002 != promote_mode (type, TYPE_MODE (type), &unsignedp, 1))
3005 target = gen_rtx_SUBREG (TYPE_MODE (type), target, 0);
3006 SUBREG_PROMOTED_VAR_P (target) = 1;
3007 SUBREG_PROMOTED_UNSIGNED_P (target) = unsignedp;
3011 /* If size of args is variable or this was a constructor call for a stack
3012 argument, restore saved stack-pointer value. */
3014 if (old_stack_level)
3016 emit_stack_restore (SAVE_BLOCK, old_stack_level, NULL_RTX);
3017 pending_stack_adjust = old_pending_adj;
3018 stack_arg_under_construction = old_stack_arg_under_construction;
3019 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3020 stack_usage_map = initial_stack_usage_map;
3021 sibcall_failure = 1;
3023 else if (ACCUMULATE_OUTGOING_ARGS)
3025 #ifdef REG_PARM_STACK_SPACE
3028 restore_fixed_argument_area (save_area, argblock,
3029 high_to_save, low_to_save);
3030 sibcall_failure = 1;
3034 /* If we saved any argument areas, restore them. */
3035 for (i = 0; i < num_actuals; i++)
3036 if (args[i].save_area)
3038 enum machine_mode save_mode = GET_MODE (args[i].save_area);
3040 = gen_rtx_MEM (save_mode,
3041 memory_address (save_mode,
3042 XEXP (args[i].stack_slot, 0)));
3044 if (save_mode != BLKmode)
3045 emit_move_insn (stack_area, args[i].save_area);
3047 emit_block_move (stack_area,
3048 validize_mem (args[i].save_area),
3049 GEN_INT (args[i].size.constant),
3051 sibcall_failure = 1;
3054 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3055 stack_usage_map = initial_stack_usage_map;
3058 /* If this was alloca, record the new stack level for nonlocal gotos.
3059 Check for the handler slots since we might not have a save area
3060 for non-local gotos. */
3062 if ((flags & ECF_MAY_BE_ALLOCA) && nonlocal_goto_handler_slots != 0)
3063 emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
3067 /* Free up storage we no longer need. */
3068 for (i = 0; i < num_actuals; ++i)
3069 if (args[i].aligned_regs)
3070 free (args[i].aligned_regs);
3074 /* Undo the fake expand_start_target_temps we did earlier. If
3075 there had been any cleanups created, we've already set
3077 expand_end_target_temps ();
3080 insns = get_insns ();
3085 tail_call_insns = insns;
3087 /* If something prevents making this a sibling call,
3088 zero out the sequence. */
3089 if (sibcall_failure)
3090 tail_call_insns = NULL_RTX;
3091 /* Restore the pending stack adjustment now that we have
3092 finished generating the sibling call sequence. */
3094 pending_stack_adjust = save_pending_stack_adjust;
3095 stack_pointer_delta = save_stack_pointer_delta;
3098 normal_call_insns = insns;
3101 /* The function optimize_sibling_and_tail_recursive_calls doesn't
3102 handle CALL_PLACEHOLDERs inside other CALL_PLACEHOLDERs. This
3103 can happen if the arguments to this function call an inline
3104 function who's expansion contains another CALL_PLACEHOLDER.
3106 If there are any C_Ps in any of these sequences, replace them
3107 with their normal call. */
3109 for (insn = normal_call_insns; insn; insn = NEXT_INSN (insn))
3110 if (GET_CODE (insn) == CALL_INSN
3111 && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
3112 replace_call_placeholder (insn, sibcall_use_normal);
3114 for (insn = tail_call_insns; insn; insn = NEXT_INSN (insn))
3115 if (GET_CODE (insn) == CALL_INSN
3116 && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
3117 replace_call_placeholder (insn, sibcall_use_normal);
3119 for (insn = tail_recursion_insns; insn; insn = NEXT_INSN (insn))
3120 if (GET_CODE (insn) == CALL_INSN
3121 && GET_CODE (PATTERN (insn)) == CALL_PLACEHOLDER)
3122 replace_call_placeholder (insn, sibcall_use_normal);
3124 /* If this was a potential tail recursion site, then emit a
3125 CALL_PLACEHOLDER with the normal and the tail recursion streams.
3126 One of them will be selected later. */
3127 if (tail_recursion_insns || tail_call_insns)
3129 /* The tail recursion label must be kept around. We could expose
3130 its use in the CALL_PLACEHOLDER, but that creates unwanted edges
3131 and makes determining true tail recursion sites difficult.
3133 So we set LABEL_PRESERVE_P here, then clear it when we select
3134 one of the call sequences after rtl generation is complete. */
3135 if (tail_recursion_insns)
3136 LABEL_PRESERVE_P (tail_recursion_label) = 1;
3137 emit_call_insn (gen_rtx_CALL_PLACEHOLDER (VOIDmode, normal_call_insns,
3139 tail_recursion_insns,
3140 tail_recursion_label));
3143 emit_insns (normal_call_insns);
3145 currently_expanding_call--;
3150 /* Returns nonzero if FUN is the symbol for a library function which can
3154 libfunc_nothrow (fun)
3157 if (fun == throw_libfunc
3158 || fun == rethrow_libfunc
3159 || fun == sjthrow_libfunc
3160 || fun == sjpopnthrow_libfunc)
3166 /* Output a library call to function FUN (a SYMBOL_REF rtx).
3167 The RETVAL parameter specifies whether return value needs to be saved, other
3168 parameters are documented in the emit_library_call function bellow. */
3170 emit_library_call_value_1 (retval, orgfun, value, no_queue, outmode, nargs, p)
3175 enum machine_mode outmode;
3179 /* Total size in bytes of all the stack-parms scanned so far. */
3180 struct args_size args_size;
3181 /* Size of arguments before any adjustments (such as rounding). */
3182 struct args_size original_args_size;
3183 register int argnum;
3187 struct args_size alignment_pad;
3189 CUMULATIVE_ARGS args_so_far;
3190 struct arg { rtx value; enum machine_mode mode; rtx reg; int partial;
3191 struct args_size offset; struct args_size size; rtx save_area; };
3193 int old_inhibit_defer_pop = inhibit_defer_pop;
3194 rtx call_fusage = 0;
3196 int pcc_struct_value = 0;
3197 int struct_value_size = 0;
3199 int reg_parm_stack_space = 0;
3202 #ifdef REG_PARM_STACK_SPACE
3203 /* Define the boundary of the register parm stack space that needs to be
3205 int low_to_save = -1, high_to_save = 0;
3206 rtx save_area = 0; /* Place that it is saved */
3209 /* Size of the stack reserved for parameter registers. */
3210 int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
3211 char *initial_stack_usage_map = stack_usage_map;
3213 #ifdef REG_PARM_STACK_SPACE
3214 #ifdef MAYBE_REG_PARM_STACK_SPACE
3215 reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
3217 reg_parm_stack_space = REG_PARM_STACK_SPACE ((tree) 0);
3225 if (libfunc_nothrow (fun))
3226 flags |= ECF_NOTHROW;
3228 #ifdef PREFERRED_STACK_BOUNDARY
3229 /* Ensure current function's preferred stack boundary is at least
3231 if (cfun->preferred_stack_boundary < PREFERRED_STACK_BOUNDARY)
3232 cfun->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
3235 /* If this kind of value comes back in memory,
3236 decide where in memory it should come back. */
3237 if (outmode != VOIDmode && aggregate_value_p (type_for_mode (outmode, 0)))
3239 #ifdef PCC_STATIC_STRUCT_RETURN
3241 = hard_function_value (build_pointer_type (type_for_mode (outmode, 0)),
3243 mem_value = gen_rtx_MEM (outmode, pointer_reg);
3244 pcc_struct_value = 1;
3246 value = gen_reg_rtx (outmode);
3247 #else /* not PCC_STATIC_STRUCT_RETURN */
3248 struct_value_size = GET_MODE_SIZE (outmode);
3249 if (value != 0 && GET_CODE (value) == MEM)
3252 mem_value = assign_stack_temp (outmode, GET_MODE_SIZE (outmode), 0);
3255 /* This call returns a big structure. */
3256 flags &= ~ECF_CONST;
3259 /* ??? Unfinished: must pass the memory address as an argument. */
3261 /* Copy all the libcall-arguments out of the varargs data
3262 and into a vector ARGVEC.
3264 Compute how to pass each argument. We only support a very small subset
3265 of the full argument passing conventions to limit complexity here since
3266 library functions shouldn't have many args. */
3268 argvec = (struct arg *) alloca ((nargs + 1) * sizeof (struct arg));
3269 bzero ((char *) argvec, (nargs + 1) * sizeof (struct arg));
3271 INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE, fun, 0);
3273 args_size.constant = 0;
3280 /* If there's a structure value address to be passed,
3281 either pass it in the special place, or pass it as an extra argument. */
3282 if (mem_value && struct_value_rtx == 0 && ! pcc_struct_value)
3284 rtx addr = XEXP (mem_value, 0);
3287 /* Make sure it is a reasonable operand for a move or push insn. */
3288 if (GET_CODE (addr) != REG && GET_CODE (addr) != MEM
3289 && ! (CONSTANT_P (addr) && LEGITIMATE_CONSTANT_P (addr)))
3290 addr = force_operand (addr, NULL_RTX);
3292 argvec[count].value = addr;
3293 argvec[count].mode = Pmode;
3294 argvec[count].partial = 0;
3296 argvec[count].reg = FUNCTION_ARG (args_so_far, Pmode, NULL_TREE, 1);
3297 #ifdef FUNCTION_ARG_PARTIAL_NREGS
3298 if (FUNCTION_ARG_PARTIAL_NREGS (args_so_far, Pmode, NULL_TREE, 1))
3302 locate_and_pad_parm (Pmode, NULL_TREE,
3303 argvec[count].reg && argvec[count].partial == 0,
3304 NULL_TREE, &args_size, &argvec[count].offset,
3305 &argvec[count].size, &alignment_pad);
3308 if (argvec[count].reg == 0 || argvec[count].partial != 0
3309 || reg_parm_stack_space > 0)
3310 args_size.constant += argvec[count].size.constant;
3312 FUNCTION_ARG_ADVANCE (args_so_far, Pmode, (tree) 0, 1);
3317 for (; count < nargs; count++)
3319 rtx val = va_arg (p, rtx);
3320 enum machine_mode mode = va_arg (p, enum machine_mode);
3322 /* We cannot convert the arg value to the mode the library wants here;
3323 must do it earlier where we know the signedness of the arg. */
3325 || (GET_MODE (val) != mode && GET_MODE (val) != VOIDmode))
3328 /* On some machines, there's no way to pass a float to a library fcn.
3329 Pass it as a double instead. */
3330 #ifdef LIBGCC_NEEDS_DOUBLE
3331 if (LIBGCC_NEEDS_DOUBLE && mode == SFmode)
3332 val = convert_modes (DFmode, SFmode, val, 0), mode = DFmode;
3335 /* There's no need to call protect_from_queue, because
3336 either emit_move_insn or emit_push_insn will do that. */
3338 /* Make sure it is a reasonable operand for a move or push insn. */
3339 if (GET_CODE (val) != REG && GET_CODE (val) != MEM
3340 && ! (CONSTANT_P (val) && LEGITIMATE_CONSTANT_P (val)))
3341 val = force_operand (val, NULL_RTX);
3343 #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
3344 if (FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, mode, NULL_TREE, 1))
3346 /* We do not support FUNCTION_ARG_CALLEE_COPIES here since it can
3347 be viewed as just an efficiency improvement. */
3348 rtx slot = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0);
3349 emit_move_insn (slot, val);
3350 val = force_operand (XEXP (slot, 0), NULL_RTX);
3355 argvec[count].value = val;
3356 argvec[count].mode = mode;
3358 argvec[count].reg = FUNCTION_ARG (args_so_far, mode, NULL_TREE, 1);
3360 #ifdef FUNCTION_ARG_PARTIAL_NREGS
3361 argvec[count].partial
3362 = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, mode, NULL_TREE, 1);
3364 argvec[count].partial = 0;
3367 locate_and_pad_parm (mode, NULL_TREE,
3368 argvec[count].reg && argvec[count].partial == 0,
3369 NULL_TREE, &args_size, &argvec[count].offset,
3370 &argvec[count].size, &alignment_pad);
3372 if (argvec[count].size.var)
3375 if (reg_parm_stack_space == 0 && argvec[count].partial)
3376 argvec[count].size.constant -= argvec[count].partial * UNITS_PER_WORD;
3378 if (argvec[count].reg == 0 || argvec[count].partial != 0
3379 || reg_parm_stack_space > 0)
3380 args_size.constant += argvec[count].size.constant;
3382 FUNCTION_ARG_ADVANCE (args_so_far, mode, (tree) 0, 1);
3385 #ifdef FINAL_REG_PARM_STACK_SPACE
3386 reg_parm_stack_space = FINAL_REG_PARM_STACK_SPACE (args_size.constant,
3389 /* If this machine requires an external definition for library
3390 functions, write one out. */
3391 assemble_external_libcall (fun);
3393 original_args_size = args_size;
3394 #ifdef PREFERRED_STACK_BOUNDARY
3395 args_size.constant = (((args_size.constant
3396 + stack_pointer_delta
3400 - stack_pointer_delta);
3403 args_size.constant = MAX (args_size.constant,
3404 reg_parm_stack_space);
3406 #ifndef OUTGOING_REG_PARM_STACK_SPACE
3407 args_size.constant -= reg_parm_stack_space;
3410 if (args_size.constant > current_function_outgoing_args_size)
3411 current_function_outgoing_args_size = args_size.constant;
3413 if (ACCUMULATE_OUTGOING_ARGS)
3415 /* Since the stack pointer will never be pushed, it is possible for
3416 the evaluation of a parm to clobber something we have already
3417 written to the stack. Since most function calls on RISC machines
3418 do not use the stack, this is uncommon, but must work correctly.
3420 Therefore, we save any area of the stack that was already written
3421 and that we are using. Here we set up to do this by making a new
3422 stack usage map from the old one.
3424 Another approach might be to try to reorder the argument
3425 evaluations to avoid this conflicting stack usage. */
3427 needed = args_size.constant;
3429 #ifndef OUTGOING_REG_PARM_STACK_SPACE
3430 /* Since we will be writing into the entire argument area, the
3431 map must be allocated for its entire size, not just the part that
3432 is the responsibility of the caller. */
3433 needed += reg_parm_stack_space;
3436 #ifdef ARGS_GROW_DOWNWARD
3437 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
3440 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
3443 stack_usage_map = (char *) alloca (highest_outgoing_arg_in_use);
3445 if (initial_highest_arg_in_use)
3446 bcopy (initial_stack_usage_map, stack_usage_map,
3447 initial_highest_arg_in_use);
3449 if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
3450 bzero (&stack_usage_map[initial_highest_arg_in_use],
3451 highest_outgoing_arg_in_use - initial_highest_arg_in_use);
3454 /* The address of the outgoing argument list must not be copied to a
3455 register here, because argblock would be left pointing to the
3456 wrong place after the call to allocate_dynamic_stack_space below.
3459 argblock = virtual_outgoing_args_rtx;
3464 argblock = push_block (GEN_INT (args_size.constant), 0, 0);
3467 #ifdef PREFERRED_STACK_BOUNDARY
3468 /* If we push args individually in reverse order, perform stack alignment
3469 before the first push (the last arg). */
3470 if (argblock == 0 && PUSH_ARGS_REVERSED)
3471 anti_adjust_stack (GEN_INT (args_size.constant
3472 - original_args_size.constant));
3475 if (PUSH_ARGS_REVERSED)
3486 #ifdef REG_PARM_STACK_SPACE
3487 if (ACCUMULATE_OUTGOING_ARGS)
3489 /* The argument list is the property of the called routine and it
3490 may clobber it. If the fixed area has been used for previous
3491 parameters, we must save and restore it.
3493 Here we compute the boundary of the that needs to be saved, if any. */
3495 #ifdef ARGS_GROW_DOWNWARD
3496 for (count = 0; count < reg_parm_stack_space + 1; count++)
3498 for (count = 0; count < reg_parm_stack_space; count++)
3501 if (count >= highest_outgoing_arg_in_use
3502 || stack_usage_map[count] == 0)
3505 if (low_to_save == -1)
3506 low_to_save = count;
3508 high_to_save = count;
3511 if (low_to_save >= 0)
3513 int num_to_save = high_to_save - low_to_save + 1;
3514 enum machine_mode save_mode
3515 = mode_for_size (num_to_save * BITS_PER_UNIT, MODE_INT, 1);
3518 /* If we don't have the required alignment, must do this in BLKmode. */
3519 if ((low_to_save & (MIN (GET_MODE_SIZE (save_mode),
3520 BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1)))
3521 save_mode = BLKmode;
3523 #ifdef ARGS_GROW_DOWNWARD
3524 stack_area = gen_rtx_MEM (save_mode,
3525 memory_address (save_mode,
3526 plus_constant (argblock,
3529 stack_area = gen_rtx_MEM (save_mode,
3530 memory_address (save_mode,
3531 plus_constant (argblock,
3534 if (save_mode == BLKmode)
3536 save_area = assign_stack_temp (BLKmode, num_to_save, 0);
3537 emit_block_move (validize_mem (save_area), stack_area,
3538 GEN_INT (num_to_save), PARM_BOUNDARY);
3542 save_area = gen_reg_rtx (save_mode);
3543 emit_move_insn (save_area, stack_area);
3549 /* Push the args that need to be pushed. */
3551 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
3552 are to be pushed. */
3553 for (count = 0; count < nargs; count++, argnum += inc)
3555 register enum machine_mode mode = argvec[argnum].mode;
3556 register rtx val = argvec[argnum].value;
3557 rtx reg = argvec[argnum].reg;
3558 int partial = argvec[argnum].partial;
3559 int lower_bound = 0, upper_bound = 0, i;
3561 if (! (reg != 0 && partial == 0))
3563 if (ACCUMULATE_OUTGOING_ARGS)
3565 /* If this is being stored into a pre-allocated, fixed-size, stack
3566 area, save any previous data at that location. */
3568 #ifdef ARGS_GROW_DOWNWARD
3569 /* stack_slot is negative, but we want to index stack_usage_map
3570 with positive values. */
3571 upper_bound = -argvec[argnum].offset.constant + 1;
3572 lower_bound = upper_bound - argvec[argnum].size.constant;
3574 lower_bound = argvec[argnum].offset.constant;
3575 upper_bound = lower_bound + argvec[argnum].size.constant;
3578 for (i = lower_bound; i < upper_bound; i++)
3579 if (stack_usage_map[i]
3580 /* Don't store things in the fixed argument area at this point;
3581 it has already been saved. */
3582 && i > reg_parm_stack_space)
3585 if (i != upper_bound)
3587 /* We need to make a save area. See what mode we can make it. */
3588 enum machine_mode save_mode
3589 = mode_for_size (argvec[argnum].size.constant * BITS_PER_UNIT,
3596 plus_constant (argblock,
3597 argvec[argnum].offset.constant)));
3598 argvec[argnum].save_area = gen_reg_rtx (save_mode);
3600 emit_move_insn (argvec[argnum].save_area, stack_area);
3604 emit_push_insn (val, mode, NULL_TREE, NULL_RTX, 0, partial, reg, 0,
3605 argblock, GEN_INT (argvec[argnum].offset.constant),
3606 reg_parm_stack_space, ARGS_SIZE_RTX (alignment_pad));
3608 /* Now mark the segment we just used. */
3609 if (ACCUMULATE_OUTGOING_ARGS)
3610 for (i = lower_bound; i < upper_bound; i++)
3611 stack_usage_map[i] = 1;
3617 #ifdef PREFERRED_STACK_BOUNDARY
3618 /* If we pushed args in forward order, perform stack alignment
3619 after pushing the last arg. */
3620 if (argblock == 0 && !PUSH_ARGS_REVERSED)
3621 anti_adjust_stack (GEN_INT (args_size.constant
3622 - original_args_size.constant));
3625 if (PUSH_ARGS_REVERSED)
3630 fun = prepare_call_address (fun, NULL_TREE, &call_fusage, 0);
3632 /* Now load any reg parms into their regs. */
3634 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
3635 are to be pushed. */
3636 for (count = 0; count < nargs; count++, argnum += inc)
3638 register rtx val = argvec[argnum].value;
3639 rtx reg = argvec[argnum].reg;
3640 int partial = argvec[argnum].partial;
3642 /* Handle calls that pass values in multiple non-contiguous
3643 locations. The PA64 has examples of this for library calls. */
3644 if (reg != 0 && GET_CODE (reg) == PARALLEL)
3645 emit_group_load (reg, val,
3646 GET_MODE_SIZE (GET_MODE (val)),
3647 GET_MODE_ALIGNMENT (GET_MODE (val)));
3648 else if (reg != 0 && partial == 0)
3649 emit_move_insn (reg, val);
3655 /* For version 1.37, try deleting this entirely. */
3660 /* Any regs containing parms remain in use through the call. */
3661 for (count = 0; count < nargs; count++)
3663 rtx reg = argvec[count].reg;
3664 if (reg != 0 && GET_CODE (reg) == PARALLEL)
3665 use_group_regs (&call_fusage, reg);
3667 use_reg (&call_fusage, reg);
3670 /* Pass the function the address in which to return a structure value. */
3671 if (mem_value != 0 && struct_value_rtx != 0 && ! pcc_struct_value)
3673 emit_move_insn (struct_value_rtx,
3675 force_operand (XEXP (mem_value, 0),
3677 if (GET_CODE (struct_value_rtx) == REG)
3678 use_reg (&call_fusage, struct_value_rtx);
3681 /* Don't allow popping to be deferred, since then
3682 cse'ing of library calls could delete a call and leave the pop. */
3685 /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
3686 will set inhibit_defer_pop to that value. */
3687 /* The return type is needed to decide how many bytes the function pops.
3688 Signedness plays no role in that, so for simplicity, we pretend it's
3689 always signed. We also assume that the list of arguments passed has
3690 no impact, so we pretend it is unknown. */
3693 get_identifier (XSTR (orgfun, 0)),
3694 build_function_type (outmode == VOIDmode ? void_type_node
3695 : type_for_mode (outmode, 0), NULL_TREE),
3696 original_args_size.constant, args_size.constant,
3698 FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
3699 mem_value == 0 && outmode != VOIDmode ? hard_libcall_value (outmode) : NULL_RTX,
3700 old_inhibit_defer_pop + 1, call_fusage, flags);
3702 /* Now restore inhibit_defer_pop to its actual original value. */
3707 /* Copy the value to the right place. */
3708 if (outmode != VOIDmode && retval)
3714 if (value != mem_value)
3715 emit_move_insn (value, mem_value);
3717 else if (value != 0)
3718 emit_move_insn (value, hard_libcall_value (outmode));
3720 value = hard_libcall_value (outmode);
3723 if (ACCUMULATE_OUTGOING_ARGS)
3725 #ifdef REG_PARM_STACK_SPACE
3728 enum machine_mode save_mode = GET_MODE (save_area);
3729 #ifdef ARGS_GROW_DOWNWARD
3731 = gen_rtx_MEM (save_mode,
3732 memory_address (save_mode,
3733 plus_constant (argblock,
3737 = gen_rtx_MEM (save_mode,
3738 memory_address (save_mode,
3739 plus_constant (argblock, low_to_save)));
3741 if (save_mode != BLKmode)
3742 emit_move_insn (stack_area, save_area);
3744 emit_block_move (stack_area, validize_mem (save_area),
3745 GEN_INT (high_to_save - low_to_save + 1),
3750 /* If we saved any argument areas, restore them. */
3751 for (count = 0; count < nargs; count++)
3752 if (argvec[count].save_area)
3754 enum machine_mode save_mode = GET_MODE (argvec[count].save_area);
3756 = gen_rtx_MEM (save_mode,
3759 plus_constant (argblock,
3760 argvec[count].offset.constant)));
3762 emit_move_insn (stack_area, argvec[count].save_area);
3765 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3766 stack_usage_map = initial_stack_usage_map;
3773 /* Output a library call to function FUN (a SYMBOL_REF rtx)
3774 (emitting the queue unless NO_QUEUE is nonzero),
3775 for a value of mode OUTMODE,
3776 with NARGS different arguments, passed as alternating rtx values
3777 and machine_modes to convert them to.
3778 The rtx values should have been passed through protect_from_queue already.
3780 NO_QUEUE will be true if and only if the library call is a `const' call
3781 which will be enclosed in REG_LIBCALL/REG_RETVAL notes; it is equivalent
3782 to the flag ECF_CONST in expand_call.
3784 NO_QUEUE must be true for const calls, because if it isn't, then
3785 any pending increment will be emitted between REG_LIBCALL/REG_RETVAL notes,
3786 and will be lost if the libcall sequence is optimized away.
3788 NO_QUEUE must be false for non-const calls, because if it isn't, the
3789 call insn will have its CONST_CALL_P bit set, and it will be incorrectly
3790 optimized. For instance, the instruction scheduler may incorrectly
3791 move memory references across the non-const call. */
3794 emit_library_call VPARAMS((rtx orgfun, int no_queue, enum machine_mode outmode,
3797 #ifndef ANSI_PROTOTYPES
3800 enum machine_mode outmode;
3805 VA_START (p, nargs);
3807 #ifndef ANSI_PROTOTYPES
3808 orgfun = va_arg (p, rtx);
3809 no_queue = va_arg (p, int);
3810 outmode = va_arg (p, enum machine_mode);
3811 nargs = va_arg (p, int);
3814 emit_library_call_value_1 (0, orgfun, NULL_RTX, no_queue, outmode, nargs, p);
3819 /* Like emit_library_call except that an extra argument, VALUE,
3820 comes second and says where to store the result.
3821 (If VALUE is zero, this function chooses a convenient way
3822 to return the value.
3824 This function returns an rtx for where the value is to be found.
3825 If VALUE is nonzero, VALUE is returned. */
3828 emit_library_call_value VPARAMS((rtx orgfun, rtx value, int no_queue,
3829 enum machine_mode outmode, int nargs, ...))
3831 #ifndef ANSI_PROTOTYPES
3835 enum machine_mode outmode;
3840 VA_START (p, nargs);
3842 #ifndef ANSI_PROTOTYPES
3843 orgfun = va_arg (p, rtx);
3844 value = va_arg (p, rtx);
3845 no_queue = va_arg (p, int);
3846 outmode = va_arg (p, enum machine_mode);
3847 nargs = va_arg (p, int);
3850 value = emit_library_call_value_1 (1, orgfun, value, no_queue, outmode, nargs, p);
3858 /* Return an rtx which represents a suitable home on the stack
3859 given TYPE, the type of the argument looking for a home.
3860 This is called only for BLKmode arguments.
3862 SIZE is the size needed for this target.
3863 ARGS_ADDR is the address of the bottom of the argument block for this call.
3864 OFFSET describes this parameter's offset into ARGS_ADDR. It is meaningless
3865 if this machine uses push insns. */
3868 target_for_arg (type, size, args_addr, offset)
3872 struct args_size offset;
3875 rtx offset_rtx = ARGS_SIZE_RTX (offset);
3877 /* We do not call memory_address if possible,
3878 because we want to address as close to the stack
3879 as possible. For non-variable sized arguments,
3880 this will be stack-pointer relative addressing. */
3881 if (GET_CODE (offset_rtx) == CONST_INT)
3882 target = plus_constant (args_addr, INTVAL (offset_rtx));
3885 /* I have no idea how to guarantee that this
3886 will work in the presence of register parameters. */
3887 target = gen_rtx_PLUS (Pmode, args_addr, offset_rtx);
3888 target = memory_address (QImode, target);
3891 return gen_rtx_MEM (BLKmode, target);
3895 /* Store a single argument for a function call
3896 into the register or memory area where it must be passed.
3897 *ARG describes the argument value and where to pass it.
3899 ARGBLOCK is the address of the stack-block for all the arguments,
3900 or 0 on a machine where arguments are pushed individually.
3902 MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
3903 so must be careful about how the stack is used.
3905 VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
3906 argument stack. This is used if ACCUMULATE_OUTGOING_ARGS to indicate
3907 that we need not worry about saving and restoring the stack.
3909 FNDECL is the declaration of the function we are calling. */
3912 store_one_arg (arg, argblock, may_be_alloca, variable_size,
3913 reg_parm_stack_space)
3914 struct arg_data *arg;
3917 int variable_size ATTRIBUTE_UNUSED;
3918 int reg_parm_stack_space;
3920 register tree pval = arg->tree_value;
3924 int i, lower_bound = 0, upper_bound = 0;
3926 if (TREE_CODE (pval) == ERROR_MARK)
3929 /* Push a new temporary level for any temporaries we make for
3933 if (ACCUMULATE_OUTGOING_ARGS)
3935 /* If this is being stored into a pre-allocated, fixed-size, stack area,
3936 save any previous data at that location. */
3937 if (argblock && ! variable_size && arg->stack)
3939 #ifdef ARGS_GROW_DOWNWARD
3940 /* stack_slot is negative, but we want to index stack_usage_map
3941 with positive values. */
3942 if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
3943 upper_bound = -INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1)) + 1;
3947 lower_bound = upper_bound - arg->size.constant;
3949 if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
3950 lower_bound = INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1));
3954 upper_bound = lower_bound + arg->size.constant;
3957 for (i = lower_bound; i < upper_bound; i++)
3958 if (stack_usage_map[i]
3959 /* Don't store things in the fixed argument area at this point;
3960 it has already been saved. */
3961 && i > reg_parm_stack_space)
3964 if (i != upper_bound)
3966 /* We need to make a save area. See what mode we can make it. */
3967 enum machine_mode save_mode
3968 = mode_for_size (arg->size.constant * BITS_PER_UNIT, MODE_INT, 1);
3970 = gen_rtx_MEM (save_mode,
3971 memory_address (save_mode,
3972 XEXP (arg->stack_slot, 0)));
3974 if (save_mode == BLKmode)
3976 arg->save_area = assign_stack_temp (BLKmode,
3977 arg->size.constant, 0);
3978 MEM_SET_IN_STRUCT_P (arg->save_area,
3979 AGGREGATE_TYPE_P (TREE_TYPE
3980 (arg->tree_value)));
3981 preserve_temp_slots (arg->save_area);
3982 emit_block_move (validize_mem (arg->save_area), stack_area,
3983 GEN_INT (arg->size.constant),
3988 arg->save_area = gen_reg_rtx (save_mode);
3989 emit_move_insn (arg->save_area, stack_area);
3993 /* Now that we have saved any slots that will be overwritten by this
3994 store, mark all slots this store will use. We must do this before
3995 we actually expand the argument since the expansion itself may
3996 trigger library calls which might need to use the same stack slot. */
3997 if (argblock && ! variable_size && arg->stack)
3998 for (i = lower_bound; i < upper_bound; i++)
3999 stack_usage_map[i] = 1;
4002 /* If this isn't going to be placed on both the stack and in registers,
4003 set up the register and number of words. */
4004 if (! arg->pass_on_stack)
4005 reg = arg->reg, partial = arg->partial;
4007 if (reg != 0 && partial == 0)
4008 /* Being passed entirely in a register. We shouldn't be called in
4012 /* If this arg needs special alignment, don't load the registers
4014 if (arg->n_aligned_regs != 0)
4017 /* If this is being passed partially in a register, we can't evaluate
4018 it directly into its stack slot. Otherwise, we can. */
4019 if (arg->value == 0)
4021 /* stack_arg_under_construction is nonzero if a function argument is
4022 being evaluated directly into the outgoing argument list and
4023 expand_call must take special action to preserve the argument list
4024 if it is called recursively.
4026 For scalar function arguments stack_usage_map is sufficient to
4027 determine which stack slots must be saved and restored. Scalar
4028 arguments in general have pass_on_stack == 0.
4030 If this argument is initialized by a function which takes the
4031 address of the argument (a C++ constructor or a C function
4032 returning a BLKmode structure), then stack_usage_map is
4033 insufficient and expand_call must push the stack around the
4034 function call. Such arguments have pass_on_stack == 1.
4036 Note that it is always safe to set stack_arg_under_construction,
4037 but this generates suboptimal code if set when not needed. */
4039 if (arg->pass_on_stack)
4040 stack_arg_under_construction++;
4042 arg->value = expand_expr (pval,
4044 || TYPE_MODE (TREE_TYPE (pval)) != arg->mode)
4045 ? NULL_RTX : arg->stack,
4048 /* If we are promoting object (or for any other reason) the mode
4049 doesn't agree, convert the mode. */
4051 if (arg->mode != TYPE_MODE (TREE_TYPE (pval)))
4052 arg->value = convert_modes (arg->mode, TYPE_MODE (TREE_TYPE (pval)),
4053 arg->value, arg->unsignedp);
4055 if (arg->pass_on_stack)
4056 stack_arg_under_construction--;
4059 /* Don't allow anything left on stack from computation
4060 of argument to alloca. */
4062 do_pending_stack_adjust ();
4064 if (arg->value == arg->stack)
4066 /* If the value is already in the stack slot, we are done. */
4067 if (current_function_check_memory_usage && GET_CODE (arg->stack) == MEM)
4069 emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
4070 XEXP (arg->stack, 0), Pmode,
4071 ARGS_SIZE_RTX (arg->size),
4072 TYPE_MODE (sizetype),
4073 GEN_INT (MEMORY_USE_RW),
4074 TYPE_MODE (integer_type_node));
4077 else if (arg->mode != BLKmode)
4081 /* Argument is a scalar, not entirely passed in registers.
4082 (If part is passed in registers, arg->partial says how much
4083 and emit_push_insn will take care of putting it there.)
4085 Push it, and if its size is less than the
4086 amount of space allocated to it,
4087 also bump stack pointer by the additional space.
4088 Note that in C the default argument promotions
4089 will prevent such mismatches. */
4091 size = GET_MODE_SIZE (arg->mode);
4092 /* Compute how much space the push instruction will push.
4093 On many machines, pushing a byte will advance the stack
4094 pointer by a halfword. */
4095 #ifdef PUSH_ROUNDING
4096 size = PUSH_ROUNDING (size);
4100 /* Compute how much space the argument should get:
4101 round up to a multiple of the alignment for arguments. */
4102 if (none != FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)))
4103 used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1)
4104 / (PARM_BOUNDARY / BITS_PER_UNIT))
4105 * (PARM_BOUNDARY / BITS_PER_UNIT));
4107 /* This isn't already where we want it on the stack, so put it there.
4108 This can either be done with push or copy insns. */
4109 emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX, 0,
4110 partial, reg, used - size, argblock,
4111 ARGS_SIZE_RTX (arg->offset), reg_parm_stack_space,
4112 ARGS_SIZE_RTX (arg->alignment_pad));
4116 /* BLKmode, at least partly to be pushed. */
4118 register int excess;
4121 /* Pushing a nonscalar.
4122 If part is passed in registers, PARTIAL says how much
4123 and emit_push_insn will take care of putting it there. */
4125 /* Round its size up to a multiple
4126 of the allocation unit for arguments. */
4128 if (arg->size.var != 0)
4131 size_rtx = ARGS_SIZE_RTX (arg->size);
4135 /* PUSH_ROUNDING has no effect on us, because
4136 emit_push_insn for BLKmode is careful to avoid it. */
4137 excess = (arg->size.constant - int_size_in_bytes (TREE_TYPE (pval))
4138 + partial * UNITS_PER_WORD);
4139 size_rtx = expr_size (pval);
4142 emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
4143 TYPE_ALIGN (TREE_TYPE (pval)), partial, reg, excess,
4144 argblock, ARGS_SIZE_RTX (arg->offset),
4145 reg_parm_stack_space,
4146 ARGS_SIZE_RTX (arg->alignment_pad));
4150 /* Unless this is a partially-in-register argument, the argument is now
4153 ??? Note that this can change arg->value from arg->stack to
4154 arg->stack_slot and it matters when they are not the same.
4155 It isn't totally clear that this is correct in all cases. */
4157 arg->value = arg->stack_slot;
4159 /* Once we have pushed something, pops can't safely
4160 be deferred during the rest of the arguments. */
4163 /* ANSI doesn't require a sequence point here,
4164 but PCC has one, so this will avoid some problems. */
4167 /* Free any temporary slots made in processing this argument. Show
4168 that we might have taken the address of something and pushed that
4170 preserve_temp_slots (NULL_RTX);