Daily bump.
[official-gcc.git] / gcc / calls.c
blob345331fa6db2f3b04d61fe26ad984d2c4f0547b2
1 /* Convert function calls to rtl insns, for GNU C compiler.
2 Copyright (C) 1989-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "tm.h"
24 #include "rtl.h"
25 #include "tree.h"
26 #include "stor-layout.h"
27 #include "varasm.h"
28 #include "stringpool.h"
29 #include "attribs.h"
30 #include "basic-block.h"
31 #include "tree-ssa-alias.h"
32 #include "internal-fn.h"
33 #include "gimple-expr.h"
34 #include "is-a.h"
35 #include "gimple.h"
36 #include "flags.h"
37 #include "expr.h"
38 #include "optabs.h"
39 #include "libfuncs.h"
40 #include "function.h"
41 #include "regs.h"
42 #include "diagnostic-core.h"
43 #include "output.h"
44 #include "tm_p.h"
45 #include "timevar.h"
46 #include "sbitmap.h"
47 #include "langhooks.h"
48 #include "target.h"
49 #include "cgraph.h"
50 #include "except.h"
51 #include "dbgcnt.h"
52 #include "rtl-iter.h"
54 /* Like PREFERRED_STACK_BOUNDARY but in units of bytes, not bits. */
55 #define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)
57 /* Data structure and subroutines used within expand_call. */
59 struct arg_data
61 /* Tree node for this argument. */
62 tree tree_value;
63 /* Mode for value; TYPE_MODE unless promoted. */
64 enum machine_mode mode;
65 /* Current RTL value for argument, or 0 if it isn't precomputed. */
66 rtx value;
67 /* Initially-compute RTL value for argument; only for const functions. */
68 rtx initial_value;
69 /* Register to pass this argument in, 0 if passed on stack, or an
70 PARALLEL if the arg is to be copied into multiple non-contiguous
71 registers. */
72 rtx reg;
73 /* Register to pass this argument in when generating tail call sequence.
74 This is not the same register as for normal calls on machines with
75 register windows. */
76 rtx tail_call_reg;
77 /* If REG is a PARALLEL, this is a copy of VALUE pulled into the correct
78 form for emit_group_move. */
79 rtx parallel_value;
80 /* If REG was promoted from the actual mode of the argument expression,
81 indicates whether the promotion is sign- or zero-extended. */
82 int unsignedp;
83 /* Number of bytes to put in registers. 0 means put the whole arg
84 in registers. Also 0 if not passed in registers. */
85 int partial;
86 /* Nonzero if argument must be passed on stack.
87 Note that some arguments may be passed on the stack
88 even though pass_on_stack is zero, just because FUNCTION_ARG says so.
89 pass_on_stack identifies arguments that *cannot* go in registers. */
90 int pass_on_stack;
91 /* Some fields packaged up for locate_and_pad_parm. */
92 struct locate_and_pad_arg_data locate;
93 /* Location on the stack at which parameter should be stored. The store
94 has already been done if STACK == VALUE. */
95 rtx stack;
96 /* Location on the stack of the start of this argument slot. This can
97 differ from STACK if this arg pads downward. This location is known
98 to be aligned to TARGET_FUNCTION_ARG_BOUNDARY. */
99 rtx stack_slot;
100 /* Place that this stack area has been saved, if needed. */
101 rtx save_area;
102 /* If an argument's alignment does not permit direct copying into registers,
103 copy in smaller-sized pieces into pseudos. These are stored in a
104 block pointed to by this field. The next field says how many
105 word-sized pseudos we made. */
106 rtx *aligned_regs;
107 int n_aligned_regs;
110 /* A vector of one char per byte of stack space. A byte if nonzero if
111 the corresponding stack location has been used.
112 This vector is used to prevent a function call within an argument from
113 clobbering any stack already set up. */
114 static char *stack_usage_map;
116 /* Size of STACK_USAGE_MAP. */
117 static int highest_outgoing_arg_in_use;
119 /* A bitmap of virtual-incoming stack space. Bit is set if the corresponding
120 stack location's tail call argument has been already stored into the stack.
121 This bitmap is used to prevent sibling call optimization if function tries
122 to use parent's incoming argument slots when they have been already
123 overwritten with tail call arguments. */
124 static sbitmap stored_args_map;
126 /* stack_arg_under_construction is nonzero when an argument may be
127 initialized with a constructor call (including a C function that
128 returns a BLKmode struct) and expand_call must take special action
129 to make sure the object being constructed does not overlap the
130 argument list for the constructor call. */
131 static int stack_arg_under_construction;
133 static void emit_call_1 (rtx, tree, tree, tree, HOST_WIDE_INT, HOST_WIDE_INT,
134 HOST_WIDE_INT, rtx, rtx, int, rtx, int,
135 cumulative_args_t);
136 static void precompute_register_parameters (int, struct arg_data *, int *);
137 static int store_one_arg (struct arg_data *, rtx, int, int, int);
138 static void store_unaligned_arguments_into_pseudos (struct arg_data *, int);
139 static int finalize_must_preallocate (int, int, struct arg_data *,
140 struct args_size *);
141 static void precompute_arguments (int, struct arg_data *);
142 static int compute_argument_block_size (int, struct args_size *, tree, tree, int);
143 static void initialize_argument_information (int, struct arg_data *,
144 struct args_size *, int,
145 tree, tree,
146 tree, tree, cumulative_args_t, int,
147 rtx *, int *, int *, int *,
148 bool *, bool);
149 static void compute_argument_addresses (struct arg_data *, rtx, int);
150 static rtx rtx_for_function_call (tree, tree);
151 static void load_register_parameters (struct arg_data *, int, rtx *, int,
152 int, int *);
153 static rtx emit_library_call_value_1 (int, rtx, rtx, enum libcall_type,
154 enum machine_mode, int, va_list);
155 static int special_function_p (const_tree, int);
156 static int check_sibcall_argument_overlap_1 (rtx);
157 static int check_sibcall_argument_overlap (rtx_insn *, struct arg_data *, int);
159 static int combine_pending_stack_adjustment_and_call (int, struct args_size *,
160 unsigned int);
161 static tree split_complex_types (tree);
163 #ifdef REG_PARM_STACK_SPACE
164 static rtx save_fixed_argument_area (int, rtx, int *, int *);
165 static void restore_fixed_argument_area (rtx, rtx, int, int);
166 #endif
168 /* Force FUNEXP into a form suitable for the address of a CALL,
169 and return that as an rtx. Also load the static chain register
170 if FNDECL is a nested function.
172 CALL_FUSAGE points to a variable holding the prospective
173 CALL_INSN_FUNCTION_USAGE information. */
176 prepare_call_address (tree fndecl, rtx funexp, rtx static_chain_value,
177 rtx *call_fusage, int reg_parm_seen, int sibcallp)
179 /* Make a valid memory address and copy constants through pseudo-regs,
180 but not for a constant address if -fno-function-cse. */
181 if (GET_CODE (funexp) != SYMBOL_REF)
182 /* If we are using registers for parameters, force the
183 function address into a register now. */
184 funexp = ((reg_parm_seen
185 && targetm.small_register_classes_for_mode_p (FUNCTION_MODE))
186 ? force_not_mem (memory_address (FUNCTION_MODE, funexp))
187 : memory_address (FUNCTION_MODE, funexp));
188 else if (! sibcallp)
190 #ifndef NO_FUNCTION_CSE
191 if (optimize && ! flag_no_function_cse)
192 funexp = force_reg (Pmode, funexp);
193 #endif
196 if (static_chain_value != 0)
198 rtx chain;
200 gcc_assert (fndecl);
201 chain = targetm.calls.static_chain (fndecl, false);
202 static_chain_value = convert_memory_address (Pmode, static_chain_value);
204 emit_move_insn (chain, static_chain_value);
205 if (REG_P (chain))
206 use_reg (call_fusage, chain);
209 return funexp;
212 /* Generate instructions to call function FUNEXP,
213 and optionally pop the results.
214 The CALL_INSN is the first insn generated.
216 FNDECL is the declaration node of the function. This is given to the
217 hook TARGET_RETURN_POPS_ARGS to determine whether this function pops
218 its own args.
220 FUNTYPE is the data type of the function. This is given to the hook
221 TARGET_RETURN_POPS_ARGS to determine whether this function pops its
222 own args. We used to allow an identifier for library functions, but
223 that doesn't work when the return type is an aggregate type and the
224 calling convention says that the pointer to this aggregate is to be
225 popped by the callee.
227 STACK_SIZE is the number of bytes of arguments on the stack,
228 ROUNDED_STACK_SIZE is that number rounded up to
229 PREFERRED_STACK_BOUNDARY; zero if the size is variable. This is
230 both to put into the call insn and to generate explicit popping
231 code if necessary.
233 STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
234 It is zero if this call doesn't want a structure value.
236 NEXT_ARG_REG is the rtx that results from executing
237 targetm.calls.function_arg (&args_so_far, VOIDmode, void_type_node, true)
238 just after all the args have had their registers assigned.
239 This could be whatever you like, but normally it is the first
240 arg-register beyond those used for args in this call,
241 or 0 if all the arg-registers are used in this call.
242 It is passed on to `gen_call' so you can put this info in the call insn.
244 VALREG is a hard register in which a value is returned,
245 or 0 if the call does not return a value.
247 OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before
248 the args to this call were processed.
249 We restore `inhibit_defer_pop' to that value.
251 CALL_FUSAGE is either empty or an EXPR_LIST of USE expressions that
252 denote registers used by the called function. */
254 static void
255 emit_call_1 (rtx funexp, tree fntree ATTRIBUTE_UNUSED, tree fndecl ATTRIBUTE_UNUSED,
256 tree funtype ATTRIBUTE_UNUSED,
257 HOST_WIDE_INT stack_size ATTRIBUTE_UNUSED,
258 HOST_WIDE_INT rounded_stack_size,
259 HOST_WIDE_INT struct_value_size ATTRIBUTE_UNUSED,
260 rtx next_arg_reg ATTRIBUTE_UNUSED, rtx valreg,
261 int old_inhibit_defer_pop, rtx call_fusage, int ecf_flags,
262 cumulative_args_t args_so_far ATTRIBUTE_UNUSED)
264 rtx rounded_stack_size_rtx = GEN_INT (rounded_stack_size);
265 rtx_insn *call_insn;
266 rtx call, funmem;
267 int already_popped = 0;
268 HOST_WIDE_INT n_popped
269 = targetm.calls.return_pops_args (fndecl, funtype, stack_size);
271 #ifdef CALL_POPS_ARGS
272 n_popped += CALL_POPS_ARGS (*get_cumulative_args (args_so_far));
273 #endif
275 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
276 and we don't want to load it into a register as an optimization,
277 because prepare_call_address already did it if it should be done. */
278 if (GET_CODE (funexp) != SYMBOL_REF)
279 funexp = memory_address (FUNCTION_MODE, funexp);
281 funmem = gen_rtx_MEM (FUNCTION_MODE, funexp);
282 if (fndecl && TREE_CODE (fndecl) == FUNCTION_DECL)
284 tree t = fndecl;
286 /* Although a built-in FUNCTION_DECL and its non-__builtin
287 counterpart compare equal and get a shared mem_attrs, they
288 produce different dump output in compare-debug compilations,
289 if an entry gets garbage collected in one compilation, then
290 adds a different (but equivalent) entry, while the other
291 doesn't run the garbage collector at the same spot and then
292 shares the mem_attr with the equivalent entry. */
293 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL)
295 tree t2 = builtin_decl_explicit (DECL_FUNCTION_CODE (t));
296 if (t2)
297 t = t2;
300 set_mem_expr (funmem, t);
302 else if (fntree)
303 set_mem_expr (funmem, build_simple_mem_ref (CALL_EXPR_FN (fntree)));
305 #if defined (HAVE_sibcall_pop) && defined (HAVE_sibcall_value_pop)
306 if ((ecf_flags & ECF_SIBCALL)
307 && HAVE_sibcall_pop && HAVE_sibcall_value_pop
308 && (n_popped > 0 || stack_size == 0))
310 rtx n_pop = GEN_INT (n_popped);
311 rtx pat;
313 /* If this subroutine pops its own args, record that in the call insn
314 if possible, for the sake of frame pointer elimination. */
316 if (valreg)
317 pat = GEN_SIBCALL_VALUE_POP (valreg, funmem, rounded_stack_size_rtx,
318 next_arg_reg, n_pop);
319 else
320 pat = GEN_SIBCALL_POP (funmem, rounded_stack_size_rtx, next_arg_reg,
321 n_pop);
323 emit_call_insn (pat);
324 already_popped = 1;
326 else
327 #endif
329 #if defined (HAVE_call_pop) && defined (HAVE_call_value_pop)
330 /* If the target has "call" or "call_value" insns, then prefer them
331 if no arguments are actually popped. If the target does not have
332 "call" or "call_value" insns, then we must use the popping versions
333 even if the call has no arguments to pop. */
334 #if defined (HAVE_call) && defined (HAVE_call_value)
335 if (HAVE_call && HAVE_call_value && HAVE_call_pop && HAVE_call_value_pop
336 && n_popped > 0)
337 #else
338 if (HAVE_call_pop && HAVE_call_value_pop)
339 #endif
341 rtx n_pop = GEN_INT (n_popped);
342 rtx pat;
344 /* If this subroutine pops its own args, record that in the call insn
345 if possible, for the sake of frame pointer elimination. */
347 if (valreg)
348 pat = GEN_CALL_VALUE_POP (valreg, funmem, rounded_stack_size_rtx,
349 next_arg_reg, n_pop);
350 else
351 pat = GEN_CALL_POP (funmem, rounded_stack_size_rtx, next_arg_reg,
352 n_pop);
354 emit_call_insn (pat);
355 already_popped = 1;
357 else
358 #endif
360 #if defined (HAVE_sibcall) && defined (HAVE_sibcall_value)
361 if ((ecf_flags & ECF_SIBCALL)
362 && HAVE_sibcall && HAVE_sibcall_value)
364 if (valreg)
365 emit_call_insn (GEN_SIBCALL_VALUE (valreg, funmem,
366 rounded_stack_size_rtx,
367 next_arg_reg, NULL_RTX));
368 else
369 emit_call_insn (GEN_SIBCALL (funmem, rounded_stack_size_rtx,
370 next_arg_reg,
371 GEN_INT (struct_value_size)));
373 else
374 #endif
376 #if defined (HAVE_call) && defined (HAVE_call_value)
377 if (HAVE_call && HAVE_call_value)
379 if (valreg)
380 emit_call_insn (GEN_CALL_VALUE (valreg, funmem, rounded_stack_size_rtx,
381 next_arg_reg, NULL_RTX));
382 else
383 emit_call_insn (GEN_CALL (funmem, rounded_stack_size_rtx, next_arg_reg,
384 GEN_INT (struct_value_size)));
386 else
387 #endif
388 gcc_unreachable ();
390 /* Find the call we just emitted. */
391 call_insn = last_call_insn ();
393 /* Some target create a fresh MEM instead of reusing the one provided
394 above. Set its MEM_EXPR. */
395 call = get_call_rtx_from (call_insn);
396 if (call
397 && MEM_EXPR (XEXP (call, 0)) == NULL_TREE
398 && MEM_EXPR (funmem) != NULL_TREE)
399 set_mem_expr (XEXP (call, 0), MEM_EXPR (funmem));
401 /* Put the register usage information there. */
402 add_function_usage_to (call_insn, call_fusage);
404 /* If this is a const call, then set the insn's unchanging bit. */
405 if (ecf_flags & ECF_CONST)
406 RTL_CONST_CALL_P (call_insn) = 1;
408 /* If this is a pure call, then set the insn's unchanging bit. */
409 if (ecf_flags & ECF_PURE)
410 RTL_PURE_CALL_P (call_insn) = 1;
412 /* If this is a const call, then set the insn's unchanging bit. */
413 if (ecf_flags & ECF_LOOPING_CONST_OR_PURE)
414 RTL_LOOPING_CONST_OR_PURE_CALL_P (call_insn) = 1;
416 /* Create a nothrow REG_EH_REGION note, if needed. */
417 make_reg_eh_region_note (call_insn, ecf_flags, 0);
419 if (ecf_flags & ECF_NORETURN)
420 add_reg_note (call_insn, REG_NORETURN, const0_rtx);
422 if (ecf_flags & ECF_RETURNS_TWICE)
424 add_reg_note (call_insn, REG_SETJMP, const0_rtx);
425 cfun->calls_setjmp = 1;
428 SIBLING_CALL_P (call_insn) = ((ecf_flags & ECF_SIBCALL) != 0);
430 /* Restore this now, so that we do defer pops for this call's args
431 if the context of the call as a whole permits. */
432 inhibit_defer_pop = old_inhibit_defer_pop;
434 if (n_popped > 0)
436 if (!already_popped)
437 CALL_INSN_FUNCTION_USAGE (call_insn)
438 = gen_rtx_EXPR_LIST (VOIDmode,
439 gen_rtx_CLOBBER (VOIDmode, stack_pointer_rtx),
440 CALL_INSN_FUNCTION_USAGE (call_insn));
441 rounded_stack_size -= n_popped;
442 rounded_stack_size_rtx = GEN_INT (rounded_stack_size);
443 stack_pointer_delta -= n_popped;
445 add_reg_note (call_insn, REG_ARGS_SIZE, GEN_INT (stack_pointer_delta));
447 /* If popup is needed, stack realign must use DRAP */
448 if (SUPPORTS_STACK_ALIGNMENT)
449 crtl->need_drap = true;
451 /* For noreturn calls when not accumulating outgoing args force
452 REG_ARGS_SIZE note to prevent crossjumping of calls with different
453 args sizes. */
454 else if (!ACCUMULATE_OUTGOING_ARGS && (ecf_flags & ECF_NORETURN) != 0)
455 add_reg_note (call_insn, REG_ARGS_SIZE, GEN_INT (stack_pointer_delta));
457 if (!ACCUMULATE_OUTGOING_ARGS)
459 /* If returning from the subroutine does not automatically pop the args,
460 we need an instruction to pop them sooner or later.
461 Perhaps do it now; perhaps just record how much space to pop later.
463 If returning from the subroutine does pop the args, indicate that the
464 stack pointer will be changed. */
466 if (rounded_stack_size != 0)
468 if (ecf_flags & ECF_NORETURN)
469 /* Just pretend we did the pop. */
470 stack_pointer_delta -= rounded_stack_size;
471 else if (flag_defer_pop && inhibit_defer_pop == 0
472 && ! (ecf_flags & (ECF_CONST | ECF_PURE)))
473 pending_stack_adjust += rounded_stack_size;
474 else
475 adjust_stack (rounded_stack_size_rtx);
478 /* When we accumulate outgoing args, we must avoid any stack manipulations.
479 Restore the stack pointer to its original value now. Usually
480 ACCUMULATE_OUTGOING_ARGS targets don't get here, but there are exceptions.
481 On i386 ACCUMULATE_OUTGOING_ARGS can be enabled on demand, and
482 popping variants of functions exist as well.
484 ??? We may optimize similar to defer_pop above, but it is
485 probably not worthwhile.
487 ??? It will be worthwhile to enable combine_stack_adjustments even for
488 such machines. */
489 else if (n_popped)
490 anti_adjust_stack (GEN_INT (n_popped));
493 /* Determine if the function identified by NAME and FNDECL is one with
494 special properties we wish to know about.
496 For example, if the function might return more than one time (setjmp), then
497 set RETURNS_TWICE to a nonzero value.
499 Similarly set NORETURN if the function is in the longjmp family.
501 Set MAY_BE_ALLOCA for any memory allocation function that might allocate
502 space from the stack such as alloca. */
504 static int
505 special_function_p (const_tree fndecl, int flags)
507 if (fndecl && DECL_NAME (fndecl)
508 && IDENTIFIER_LENGTH (DECL_NAME (fndecl)) <= 17
509 /* Exclude functions not at the file scope, or not `extern',
510 since they are not the magic functions we would otherwise
511 think they are.
512 FIXME: this should be handled with attributes, not with this
513 hacky imitation of DECL_ASSEMBLER_NAME. It's (also) wrong
514 because you can declare fork() inside a function if you
515 wish. */
516 && (DECL_CONTEXT (fndecl) == NULL_TREE
517 || TREE_CODE (DECL_CONTEXT (fndecl)) == TRANSLATION_UNIT_DECL)
518 && TREE_PUBLIC (fndecl))
520 const char *name = IDENTIFIER_POINTER (DECL_NAME (fndecl));
521 const char *tname = name;
523 /* We assume that alloca will always be called by name. It
524 makes no sense to pass it as a pointer-to-function to
525 anything that does not understand its behavior. */
526 if (((IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 6
527 && name[0] == 'a'
528 && ! strcmp (name, "alloca"))
529 || (IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 16
530 && name[0] == '_'
531 && ! strcmp (name, "__builtin_alloca"))))
532 flags |= ECF_MAY_BE_ALLOCA;
534 /* Disregard prefix _, __, __x or __builtin_. */
535 if (name[0] == '_')
537 if (name[1] == '_'
538 && name[2] == 'b'
539 && !strncmp (name + 3, "uiltin_", 7))
540 tname += 10;
541 else if (name[1] == '_' && name[2] == 'x')
542 tname += 3;
543 else if (name[1] == '_')
544 tname += 2;
545 else
546 tname += 1;
549 if (tname[0] == 's')
551 if ((tname[1] == 'e'
552 && (! strcmp (tname, "setjmp")
553 || ! strcmp (tname, "setjmp_syscall")))
554 || (tname[1] == 'i'
555 && ! strcmp (tname, "sigsetjmp"))
556 || (tname[1] == 'a'
557 && ! strcmp (tname, "savectx")))
558 flags |= ECF_RETURNS_TWICE | ECF_LEAF;
560 if (tname[1] == 'i'
561 && ! strcmp (tname, "siglongjmp"))
562 flags |= ECF_NORETURN;
564 else if ((tname[0] == 'q' && tname[1] == 's'
565 && ! strcmp (tname, "qsetjmp"))
566 || (tname[0] == 'v' && tname[1] == 'f'
567 && ! strcmp (tname, "vfork"))
568 || (tname[0] == 'g' && tname[1] == 'e'
569 && !strcmp (tname, "getcontext")))
570 flags |= ECF_RETURNS_TWICE | ECF_LEAF;
572 else if (tname[0] == 'l' && tname[1] == 'o'
573 && ! strcmp (tname, "longjmp"))
574 flags |= ECF_NORETURN;
577 return flags;
580 /* Similar to special_function_p; return a set of ERF_ flags for the
581 function FNDECL. */
582 static int
583 decl_return_flags (tree fndecl)
585 tree attr;
586 tree type = TREE_TYPE (fndecl);
587 if (!type)
588 return 0;
590 attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
591 if (!attr)
592 return 0;
594 attr = TREE_VALUE (TREE_VALUE (attr));
595 if (!attr || TREE_STRING_LENGTH (attr) < 1)
596 return 0;
598 switch (TREE_STRING_POINTER (attr)[0])
600 case '1':
601 case '2':
602 case '3':
603 case '4':
604 return ERF_RETURNS_ARG | (TREE_STRING_POINTER (attr)[0] - '1');
606 case 'm':
607 return ERF_NOALIAS;
609 case '.':
610 default:
611 return 0;
615 /* Return nonzero when FNDECL represents a call to setjmp. */
618 setjmp_call_p (const_tree fndecl)
620 if (DECL_IS_RETURNS_TWICE (fndecl))
621 return ECF_RETURNS_TWICE;
622 return special_function_p (fndecl, 0) & ECF_RETURNS_TWICE;
626 /* Return true if STMT is an alloca call. */
628 bool
629 gimple_alloca_call_p (const_gimple stmt)
631 tree fndecl;
633 if (!is_gimple_call (stmt))
634 return false;
636 fndecl = gimple_call_fndecl (stmt);
637 if (fndecl && (special_function_p (fndecl, 0) & ECF_MAY_BE_ALLOCA))
638 return true;
640 return false;
643 /* Return true when exp contains alloca call. */
645 bool
646 alloca_call_p (const_tree exp)
648 tree fndecl;
649 if (TREE_CODE (exp) == CALL_EXPR
650 && (fndecl = get_callee_fndecl (exp))
651 && (special_function_p (fndecl, 0) & ECF_MAY_BE_ALLOCA))
652 return true;
653 return false;
656 /* Return TRUE if FNDECL is either a TM builtin or a TM cloned
657 function. Return FALSE otherwise. */
659 static bool
660 is_tm_builtin (const_tree fndecl)
662 if (fndecl == NULL)
663 return false;
665 if (decl_is_tm_clone (fndecl))
666 return true;
668 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
670 switch (DECL_FUNCTION_CODE (fndecl))
672 case BUILT_IN_TM_COMMIT:
673 case BUILT_IN_TM_COMMIT_EH:
674 case BUILT_IN_TM_ABORT:
675 case BUILT_IN_TM_IRREVOCABLE:
676 case BUILT_IN_TM_GETTMCLONE_IRR:
677 case BUILT_IN_TM_MEMCPY:
678 case BUILT_IN_TM_MEMMOVE:
679 case BUILT_IN_TM_MEMSET:
680 CASE_BUILT_IN_TM_STORE (1):
681 CASE_BUILT_IN_TM_STORE (2):
682 CASE_BUILT_IN_TM_STORE (4):
683 CASE_BUILT_IN_TM_STORE (8):
684 CASE_BUILT_IN_TM_STORE (FLOAT):
685 CASE_BUILT_IN_TM_STORE (DOUBLE):
686 CASE_BUILT_IN_TM_STORE (LDOUBLE):
687 CASE_BUILT_IN_TM_STORE (M64):
688 CASE_BUILT_IN_TM_STORE (M128):
689 CASE_BUILT_IN_TM_STORE (M256):
690 CASE_BUILT_IN_TM_LOAD (1):
691 CASE_BUILT_IN_TM_LOAD (2):
692 CASE_BUILT_IN_TM_LOAD (4):
693 CASE_BUILT_IN_TM_LOAD (8):
694 CASE_BUILT_IN_TM_LOAD (FLOAT):
695 CASE_BUILT_IN_TM_LOAD (DOUBLE):
696 CASE_BUILT_IN_TM_LOAD (LDOUBLE):
697 CASE_BUILT_IN_TM_LOAD (M64):
698 CASE_BUILT_IN_TM_LOAD (M128):
699 CASE_BUILT_IN_TM_LOAD (M256):
700 case BUILT_IN_TM_LOG:
701 case BUILT_IN_TM_LOG_1:
702 case BUILT_IN_TM_LOG_2:
703 case BUILT_IN_TM_LOG_4:
704 case BUILT_IN_TM_LOG_8:
705 case BUILT_IN_TM_LOG_FLOAT:
706 case BUILT_IN_TM_LOG_DOUBLE:
707 case BUILT_IN_TM_LOG_LDOUBLE:
708 case BUILT_IN_TM_LOG_M64:
709 case BUILT_IN_TM_LOG_M128:
710 case BUILT_IN_TM_LOG_M256:
711 return true;
712 default:
713 break;
716 return false;
719 /* Detect flags (function attributes) from the function decl or type node. */
722 flags_from_decl_or_type (const_tree exp)
724 int flags = 0;
726 if (DECL_P (exp))
728 /* The function exp may have the `malloc' attribute. */
729 if (DECL_IS_MALLOC (exp))
730 flags |= ECF_MALLOC;
732 /* The function exp may have the `returns_twice' attribute. */
733 if (DECL_IS_RETURNS_TWICE (exp))
734 flags |= ECF_RETURNS_TWICE;
736 /* Process the pure and const attributes. */
737 if (TREE_READONLY (exp))
738 flags |= ECF_CONST;
739 if (DECL_PURE_P (exp))
740 flags |= ECF_PURE;
741 if (DECL_LOOPING_CONST_OR_PURE_P (exp))
742 flags |= ECF_LOOPING_CONST_OR_PURE;
744 if (DECL_IS_NOVOPS (exp))
745 flags |= ECF_NOVOPS;
746 if (lookup_attribute ("leaf", DECL_ATTRIBUTES (exp)))
747 flags |= ECF_LEAF;
749 if (TREE_NOTHROW (exp))
750 flags |= ECF_NOTHROW;
752 if (flag_tm)
754 if (is_tm_builtin (exp))
755 flags |= ECF_TM_BUILTIN;
756 else if ((flags & (ECF_CONST|ECF_NOVOPS)) != 0
757 || lookup_attribute ("transaction_pure",
758 TYPE_ATTRIBUTES (TREE_TYPE (exp))))
759 flags |= ECF_TM_PURE;
762 flags = special_function_p (exp, flags);
764 else if (TYPE_P (exp))
766 if (TYPE_READONLY (exp))
767 flags |= ECF_CONST;
769 if (flag_tm
770 && ((flags & ECF_CONST) != 0
771 || lookup_attribute ("transaction_pure", TYPE_ATTRIBUTES (exp))))
772 flags |= ECF_TM_PURE;
774 else
775 gcc_unreachable ();
777 if (TREE_THIS_VOLATILE (exp))
779 flags |= ECF_NORETURN;
780 if (flags & (ECF_CONST|ECF_PURE))
781 flags |= ECF_LOOPING_CONST_OR_PURE;
784 return flags;
787 /* Detect flags from a CALL_EXPR. */
790 call_expr_flags (const_tree t)
792 int flags;
793 tree decl = get_callee_fndecl (t);
795 if (decl)
796 flags = flags_from_decl_or_type (decl);
797 else
799 t = TREE_TYPE (CALL_EXPR_FN (t));
800 if (t && TREE_CODE (t) == POINTER_TYPE)
801 flags = flags_from_decl_or_type (TREE_TYPE (t));
802 else
803 flags = 0;
806 return flags;
809 /* Precompute all register parameters as described by ARGS, storing values
810 into fields within the ARGS array.
812 NUM_ACTUALS indicates the total number elements in the ARGS array.
814 Set REG_PARM_SEEN if we encounter a register parameter. */
816 static void
817 precompute_register_parameters (int num_actuals, struct arg_data *args,
818 int *reg_parm_seen)
820 int i;
822 *reg_parm_seen = 0;
824 for (i = 0; i < num_actuals; i++)
825 if (args[i].reg != 0 && ! args[i].pass_on_stack)
827 *reg_parm_seen = 1;
829 if (args[i].value == 0)
831 push_temp_slots ();
832 args[i].value = expand_normal (args[i].tree_value);
833 preserve_temp_slots (args[i].value);
834 pop_temp_slots ();
837 /* If we are to promote the function arg to a wider mode,
838 do it now. */
840 if (args[i].mode != TYPE_MODE (TREE_TYPE (args[i].tree_value)))
841 args[i].value
842 = convert_modes (args[i].mode,
843 TYPE_MODE (TREE_TYPE (args[i].tree_value)),
844 args[i].value, args[i].unsignedp);
846 /* If the value is a non-legitimate constant, force it into a
847 pseudo now. TLS symbols sometimes need a call to resolve. */
848 if (CONSTANT_P (args[i].value)
849 && !targetm.legitimate_constant_p (args[i].mode, args[i].value))
850 args[i].value = force_reg (args[i].mode, args[i].value);
852 /* If we're going to have to load the value by parts, pull the
853 parts into pseudos. The part extraction process can involve
854 non-trivial computation. */
855 if (GET_CODE (args[i].reg) == PARALLEL)
857 tree type = TREE_TYPE (args[i].tree_value);
858 args[i].parallel_value
859 = emit_group_load_into_temps (args[i].reg, args[i].value,
860 type, int_size_in_bytes (type));
863 /* If the value is expensive, and we are inside an appropriately
864 short loop, put the value into a pseudo and then put the pseudo
865 into the hard reg.
867 For small register classes, also do this if this call uses
868 register parameters. This is to avoid reload conflicts while
869 loading the parameters registers. */
871 else if ((! (REG_P (args[i].value)
872 || (GET_CODE (args[i].value) == SUBREG
873 && REG_P (SUBREG_REG (args[i].value)))))
874 && args[i].mode != BLKmode
875 && set_src_cost (args[i].value, optimize_insn_for_speed_p ())
876 > COSTS_N_INSNS (1)
877 && ((*reg_parm_seen
878 && targetm.small_register_classes_for_mode_p (args[i].mode))
879 || optimize))
880 args[i].value = copy_to_mode_reg (args[i].mode, args[i].value);
884 #ifdef REG_PARM_STACK_SPACE
886 /* The argument list is the property of the called routine and it
887 may clobber it. If the fixed area has been used for previous
888 parameters, we must save and restore it. */
890 static rtx
891 save_fixed_argument_area (int reg_parm_stack_space, rtx argblock, int *low_to_save, int *high_to_save)
893 int low;
894 int high;
896 /* Compute the boundary of the area that needs to be saved, if any. */
897 high = reg_parm_stack_space;
898 #ifdef ARGS_GROW_DOWNWARD
899 high += 1;
900 #endif
901 if (high > highest_outgoing_arg_in_use)
902 high = highest_outgoing_arg_in_use;
904 for (low = 0; low < high; low++)
905 if (stack_usage_map[low] != 0)
907 int num_to_save;
908 enum machine_mode save_mode;
909 int delta;
910 rtx addr;
911 rtx stack_area;
912 rtx save_area;
914 while (stack_usage_map[--high] == 0)
917 *low_to_save = low;
918 *high_to_save = high;
920 num_to_save = high - low + 1;
921 save_mode = mode_for_size (num_to_save * BITS_PER_UNIT, MODE_INT, 1);
923 /* If we don't have the required alignment, must do this
924 in BLKmode. */
925 if ((low & (MIN (GET_MODE_SIZE (save_mode),
926 BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1)))
927 save_mode = BLKmode;
929 #ifdef ARGS_GROW_DOWNWARD
930 delta = -high;
931 #else
932 delta = low;
933 #endif
934 addr = plus_constant (Pmode, argblock, delta);
935 stack_area = gen_rtx_MEM (save_mode, memory_address (save_mode, addr));
937 set_mem_align (stack_area, PARM_BOUNDARY);
938 if (save_mode == BLKmode)
940 save_area = assign_stack_temp (BLKmode, num_to_save);
941 emit_block_move (validize_mem (save_area), stack_area,
942 GEN_INT (num_to_save), BLOCK_OP_CALL_PARM);
944 else
946 save_area = gen_reg_rtx (save_mode);
947 emit_move_insn (save_area, stack_area);
950 return save_area;
953 return NULL_RTX;
956 static void
957 restore_fixed_argument_area (rtx save_area, rtx argblock, int high_to_save, int low_to_save)
959 enum machine_mode save_mode = GET_MODE (save_area);
960 int delta;
961 rtx addr, stack_area;
963 #ifdef ARGS_GROW_DOWNWARD
964 delta = -high_to_save;
965 #else
966 delta = low_to_save;
967 #endif
968 addr = plus_constant (Pmode, argblock, delta);
969 stack_area = gen_rtx_MEM (save_mode, memory_address (save_mode, addr));
970 set_mem_align (stack_area, PARM_BOUNDARY);
972 if (save_mode != BLKmode)
973 emit_move_insn (stack_area, save_area);
974 else
975 emit_block_move (stack_area, validize_mem (save_area),
976 GEN_INT (high_to_save - low_to_save + 1),
977 BLOCK_OP_CALL_PARM);
979 #endif /* REG_PARM_STACK_SPACE */
981 /* If any elements in ARGS refer to parameters that are to be passed in
982 registers, but not in memory, and whose alignment does not permit a
983 direct copy into registers. Copy the values into a group of pseudos
984 which we will later copy into the appropriate hard registers.
986 Pseudos for each unaligned argument will be stored into the array
987 args[argnum].aligned_regs. The caller is responsible for deallocating
988 the aligned_regs array if it is nonzero. */
990 static void
991 store_unaligned_arguments_into_pseudos (struct arg_data *args, int num_actuals)
993 int i, j;
995 for (i = 0; i < num_actuals; i++)
996 if (args[i].reg != 0 && ! args[i].pass_on_stack
997 && GET_CODE (args[i].reg) != PARALLEL
998 && args[i].mode == BLKmode
999 && MEM_P (args[i].value)
1000 && (MEM_ALIGN (args[i].value)
1001 < (unsigned int) MIN (BIGGEST_ALIGNMENT, BITS_PER_WORD)))
1003 int bytes = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
1004 int endian_correction = 0;
1006 if (args[i].partial)
1008 gcc_assert (args[i].partial % UNITS_PER_WORD == 0);
1009 args[i].n_aligned_regs = args[i].partial / UNITS_PER_WORD;
1011 else
1013 args[i].n_aligned_regs
1014 = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
1017 args[i].aligned_regs = XNEWVEC (rtx, args[i].n_aligned_regs);
1019 /* Structures smaller than a word are normally aligned to the
1020 least significant byte. On a BYTES_BIG_ENDIAN machine,
1021 this means we must skip the empty high order bytes when
1022 calculating the bit offset. */
1023 if (bytes < UNITS_PER_WORD
1024 #ifdef BLOCK_REG_PADDING
1025 && (BLOCK_REG_PADDING (args[i].mode,
1026 TREE_TYPE (args[i].tree_value), 1)
1027 == downward)
1028 #else
1029 && BYTES_BIG_ENDIAN
1030 #endif
1032 endian_correction = BITS_PER_WORD - bytes * BITS_PER_UNIT;
1034 for (j = 0; j < args[i].n_aligned_regs; j++)
1036 rtx reg = gen_reg_rtx (word_mode);
1037 rtx word = operand_subword_force (args[i].value, j, BLKmode);
1038 int bitsize = MIN (bytes * BITS_PER_UNIT, BITS_PER_WORD);
1040 args[i].aligned_regs[j] = reg;
1041 word = extract_bit_field (word, bitsize, 0, 1, NULL_RTX,
1042 word_mode, word_mode);
1044 /* There is no need to restrict this code to loading items
1045 in TYPE_ALIGN sized hunks. The bitfield instructions can
1046 load up entire word sized registers efficiently.
1048 ??? This may not be needed anymore.
1049 We use to emit a clobber here but that doesn't let later
1050 passes optimize the instructions we emit. By storing 0 into
1051 the register later passes know the first AND to zero out the
1052 bitfield being set in the register is unnecessary. The store
1053 of 0 will be deleted as will at least the first AND. */
1055 emit_move_insn (reg, const0_rtx);
1057 bytes -= bitsize / BITS_PER_UNIT;
1058 store_bit_field (reg, bitsize, endian_correction, 0, 0,
1059 word_mode, word);
1064 /* Fill in ARGS_SIZE and ARGS array based on the parameters found in
1065 CALL_EXPR EXP.
1067 NUM_ACTUALS is the total number of parameters.
1069 N_NAMED_ARGS is the total number of named arguments.
1071 STRUCT_VALUE_ADDR_VALUE is the implicit argument for a struct return
1072 value, or null.
1074 FNDECL is the tree code for the target of this call (if known)
1076 ARGS_SO_FAR holds state needed by the target to know where to place
1077 the next argument.
1079 REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
1080 for arguments which are passed in registers.
1082 OLD_STACK_LEVEL is a pointer to an rtx which olds the old stack level
1083 and may be modified by this routine.
1085 OLD_PENDING_ADJ, MUST_PREALLOCATE and FLAGS are pointers to integer
1086 flags which may may be modified by this routine.
1088 MAY_TAILCALL is cleared if we encounter an invisible pass-by-reference
1089 that requires allocation of stack space.
1091 CALL_FROM_THUNK_P is true if this call is the jump from a thunk to
1092 the thunked-to function. */
1094 static void
1095 initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
1096 struct arg_data *args,
1097 struct args_size *args_size,
1098 int n_named_args ATTRIBUTE_UNUSED,
1099 tree exp, tree struct_value_addr_value,
1100 tree fndecl, tree fntype,
1101 cumulative_args_t args_so_far,
1102 int reg_parm_stack_space,
1103 rtx *old_stack_level, int *old_pending_adj,
1104 int *must_preallocate, int *ecf_flags,
1105 bool *may_tailcall, bool call_from_thunk_p)
1107 CUMULATIVE_ARGS *args_so_far_pnt = get_cumulative_args (args_so_far);
1108 location_t loc = EXPR_LOCATION (exp);
1110 /* Count arg position in order args appear. */
1111 int argpos;
1113 int i;
1115 args_size->constant = 0;
1116 args_size->var = 0;
1118 /* In this loop, we consider args in the order they are written.
1119 We fill up ARGS from the back. */
1121 i = num_actuals - 1;
1123 int j = i;
1124 call_expr_arg_iterator iter;
1125 tree arg;
1127 if (struct_value_addr_value)
1129 args[j].tree_value = struct_value_addr_value;
1130 j--;
1132 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
1134 tree argtype = TREE_TYPE (arg);
1135 if (targetm.calls.split_complex_arg
1136 && argtype
1137 && TREE_CODE (argtype) == COMPLEX_TYPE
1138 && targetm.calls.split_complex_arg (argtype))
1140 tree subtype = TREE_TYPE (argtype);
1141 args[j].tree_value = build1 (REALPART_EXPR, subtype, arg);
1142 j--;
1143 args[j].tree_value = build1 (IMAGPART_EXPR, subtype, arg);
1145 else
1146 args[j].tree_value = arg;
1147 j--;
1151 /* I counts args in order (to be) pushed; ARGPOS counts in order written. */
1152 for (argpos = 0; argpos < num_actuals; i--, argpos++)
1154 tree type = TREE_TYPE (args[i].tree_value);
1155 int unsignedp;
1156 enum machine_mode mode;
1158 /* Replace erroneous argument with constant zero. */
1159 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
1160 args[i].tree_value = integer_zero_node, type = integer_type_node;
1162 /* If TYPE is a transparent union or record, pass things the way
1163 we would pass the first field of the union or record. We have
1164 already verified that the modes are the same. */
1165 if ((TREE_CODE (type) == UNION_TYPE || TREE_CODE (type) == RECORD_TYPE)
1166 && TYPE_TRANSPARENT_AGGR (type))
1167 type = TREE_TYPE (first_field (type));
1169 /* Decide where to pass this arg.
1171 args[i].reg is nonzero if all or part is passed in registers.
1173 args[i].partial is nonzero if part but not all is passed in registers,
1174 and the exact value says how many bytes are passed in registers.
1176 args[i].pass_on_stack is nonzero if the argument must at least be
1177 computed on the stack. It may then be loaded back into registers
1178 if args[i].reg is nonzero.
1180 These decisions are driven by the FUNCTION_... macros and must agree
1181 with those made by function.c. */
1183 /* See if this argument should be passed by invisible reference. */
1184 if (pass_by_reference (args_so_far_pnt, TYPE_MODE (type),
1185 type, argpos < n_named_args))
1187 bool callee_copies;
1188 tree base = NULL_TREE;
1190 callee_copies
1191 = reference_callee_copied (args_so_far_pnt, TYPE_MODE (type),
1192 type, argpos < n_named_args);
1194 /* If we're compiling a thunk, pass through invisible references
1195 instead of making a copy. */
1196 if (call_from_thunk_p
1197 || (callee_copies
1198 && !TREE_ADDRESSABLE (type)
1199 && (base = get_base_address (args[i].tree_value))
1200 && TREE_CODE (base) != SSA_NAME
1201 && (!DECL_P (base) || MEM_P (DECL_RTL (base)))))
1203 mark_addressable (args[i].tree_value);
1205 /* We can't use sibcalls if a callee-copied argument is
1206 stored in the current function's frame. */
1207 if (!call_from_thunk_p && DECL_P (base) && !TREE_STATIC (base))
1208 *may_tailcall = false;
1210 args[i].tree_value = build_fold_addr_expr_loc (loc,
1211 args[i].tree_value);
1212 type = TREE_TYPE (args[i].tree_value);
1214 if (*ecf_flags & ECF_CONST)
1215 *ecf_flags &= ~(ECF_CONST | ECF_LOOPING_CONST_OR_PURE);
1217 else
1219 /* We make a copy of the object and pass the address to the
1220 function being called. */
1221 rtx copy;
1223 if (!COMPLETE_TYPE_P (type)
1224 || TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST
1225 || (flag_stack_check == GENERIC_STACK_CHECK
1226 && compare_tree_int (TYPE_SIZE_UNIT (type),
1227 STACK_CHECK_MAX_VAR_SIZE) > 0))
1229 /* This is a variable-sized object. Make space on the stack
1230 for it. */
1231 rtx size_rtx = expr_size (args[i].tree_value);
1233 if (*old_stack_level == 0)
1235 emit_stack_save (SAVE_BLOCK, old_stack_level);
1236 *old_pending_adj = pending_stack_adjust;
1237 pending_stack_adjust = 0;
1240 /* We can pass TRUE as the 4th argument because we just
1241 saved the stack pointer and will restore it right after
1242 the call. */
1243 copy = allocate_dynamic_stack_space (size_rtx,
1244 TYPE_ALIGN (type),
1245 TYPE_ALIGN (type),
1246 true);
1247 copy = gen_rtx_MEM (BLKmode, copy);
1248 set_mem_attributes (copy, type, 1);
1250 else
1251 copy = assign_temp (type, 1, 0);
1253 store_expr (args[i].tree_value, copy, 0, false);
1255 /* Just change the const function to pure and then let
1256 the next test clear the pure based on
1257 callee_copies. */
1258 if (*ecf_flags & ECF_CONST)
1260 *ecf_flags &= ~ECF_CONST;
1261 *ecf_flags |= ECF_PURE;
1264 if (!callee_copies && *ecf_flags & ECF_PURE)
1265 *ecf_flags &= ~(ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
1267 args[i].tree_value
1268 = build_fold_addr_expr_loc (loc, make_tree (type, copy));
1269 type = TREE_TYPE (args[i].tree_value);
1270 *may_tailcall = false;
1274 unsignedp = TYPE_UNSIGNED (type);
1275 mode = promote_function_mode (type, TYPE_MODE (type), &unsignedp,
1276 fndecl ? TREE_TYPE (fndecl) : fntype, 0);
1278 args[i].unsignedp = unsignedp;
1279 args[i].mode = mode;
1281 args[i].reg = targetm.calls.function_arg (args_so_far, mode, type,
1282 argpos < n_named_args);
1284 /* If this is a sibling call and the machine has register windows, the
1285 register window has to be unwinded before calling the routine, so
1286 arguments have to go into the incoming registers. */
1287 if (targetm.calls.function_incoming_arg != targetm.calls.function_arg)
1288 args[i].tail_call_reg
1289 = targetm.calls.function_incoming_arg (args_so_far, mode, type,
1290 argpos < n_named_args);
1291 else
1292 args[i].tail_call_reg = args[i].reg;
1294 if (args[i].reg)
1295 args[i].partial
1296 = targetm.calls.arg_partial_bytes (args_so_far, mode, type,
1297 argpos < n_named_args);
1299 args[i].pass_on_stack = targetm.calls.must_pass_in_stack (mode, type);
1301 /* If FUNCTION_ARG returned a (parallel [(expr_list (nil) ...) ...]),
1302 it means that we are to pass this arg in the register(s) designated
1303 by the PARALLEL, but also to pass it in the stack. */
1304 if (args[i].reg && GET_CODE (args[i].reg) == PARALLEL
1305 && XEXP (XVECEXP (args[i].reg, 0, 0), 0) == 0)
1306 args[i].pass_on_stack = 1;
1308 /* If this is an addressable type, we must preallocate the stack
1309 since we must evaluate the object into its final location.
1311 If this is to be passed in both registers and the stack, it is simpler
1312 to preallocate. */
1313 if (TREE_ADDRESSABLE (type)
1314 || (args[i].pass_on_stack && args[i].reg != 0))
1315 *must_preallocate = 1;
1317 /* Compute the stack-size of this argument. */
1318 if (args[i].reg == 0 || args[i].partial != 0
1319 || reg_parm_stack_space > 0
1320 || args[i].pass_on_stack)
1321 locate_and_pad_parm (mode, type,
1322 #ifdef STACK_PARMS_IN_REG_PARM_AREA
1324 #else
1325 args[i].reg != 0,
1326 #endif
1327 reg_parm_stack_space,
1328 args[i].pass_on_stack ? 0 : args[i].partial,
1329 fndecl, args_size, &args[i].locate);
1330 #ifdef BLOCK_REG_PADDING
1331 else
1332 /* The argument is passed entirely in registers. See at which
1333 end it should be padded. */
1334 args[i].locate.where_pad =
1335 BLOCK_REG_PADDING (mode, type,
1336 int_size_in_bytes (type) <= UNITS_PER_WORD);
1337 #endif
1339 /* Update ARGS_SIZE, the total stack space for args so far. */
1341 args_size->constant += args[i].locate.size.constant;
1342 if (args[i].locate.size.var)
1343 ADD_PARM_SIZE (*args_size, args[i].locate.size.var);
1345 /* Increment ARGS_SO_FAR, which has info about which arg-registers
1346 have been used, etc. */
1348 targetm.calls.function_arg_advance (args_so_far, TYPE_MODE (type),
1349 type, argpos < n_named_args);
1353 /* Update ARGS_SIZE to contain the total size for the argument block.
1354 Return the original constant component of the argument block's size.
1356 REG_PARM_STACK_SPACE holds the number of bytes of stack space reserved
1357 for arguments passed in registers. */
1359 static int
1360 compute_argument_block_size (int reg_parm_stack_space,
1361 struct args_size *args_size,
1362 tree fndecl ATTRIBUTE_UNUSED,
1363 tree fntype ATTRIBUTE_UNUSED,
1364 int preferred_stack_boundary ATTRIBUTE_UNUSED)
1366 int unadjusted_args_size = args_size->constant;
1368 /* For accumulate outgoing args mode we don't need to align, since the frame
1369 will be already aligned. Align to STACK_BOUNDARY in order to prevent
1370 backends from generating misaligned frame sizes. */
1371 if (ACCUMULATE_OUTGOING_ARGS && preferred_stack_boundary > STACK_BOUNDARY)
1372 preferred_stack_boundary = STACK_BOUNDARY;
1374 /* Compute the actual size of the argument block required. The variable
1375 and constant sizes must be combined, the size may have to be rounded,
1376 and there may be a minimum required size. */
1378 if (args_size->var)
1380 args_size->var = ARGS_SIZE_TREE (*args_size);
1381 args_size->constant = 0;
1383 preferred_stack_boundary /= BITS_PER_UNIT;
1384 if (preferred_stack_boundary > 1)
1386 /* We don't handle this case yet. To handle it correctly we have
1387 to add the delta, round and subtract the delta.
1388 Currently no machine description requires this support. */
1389 gcc_assert (!(stack_pointer_delta & (preferred_stack_boundary - 1)));
1390 args_size->var = round_up (args_size->var, preferred_stack_boundary);
1393 if (reg_parm_stack_space > 0)
1395 args_size->var
1396 = size_binop (MAX_EXPR, args_size->var,
1397 ssize_int (reg_parm_stack_space));
1399 /* The area corresponding to register parameters is not to count in
1400 the size of the block we need. So make the adjustment. */
1401 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
1402 args_size->var
1403 = size_binop (MINUS_EXPR, args_size->var,
1404 ssize_int (reg_parm_stack_space));
1407 else
1409 preferred_stack_boundary /= BITS_PER_UNIT;
1410 if (preferred_stack_boundary < 1)
1411 preferred_stack_boundary = 1;
1412 args_size->constant = (((args_size->constant
1413 + stack_pointer_delta
1414 + preferred_stack_boundary - 1)
1415 / preferred_stack_boundary
1416 * preferred_stack_boundary)
1417 - stack_pointer_delta);
1419 args_size->constant = MAX (args_size->constant,
1420 reg_parm_stack_space);
1422 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
1423 args_size->constant -= reg_parm_stack_space;
1425 return unadjusted_args_size;
1428 /* Precompute parameters as needed for a function call.
1430 FLAGS is mask of ECF_* constants.
1432 NUM_ACTUALS is the number of arguments.
1434 ARGS is an array containing information for each argument; this
1435 routine fills in the INITIAL_VALUE and VALUE fields for each
1436 precomputed argument. */
1438 static void
1439 precompute_arguments (int num_actuals, struct arg_data *args)
1441 int i;
1443 /* If this is a libcall, then precompute all arguments so that we do not
1444 get extraneous instructions emitted as part of the libcall sequence. */
1446 /* If we preallocated the stack space, and some arguments must be passed
1447 on the stack, then we must precompute any parameter which contains a
1448 function call which will store arguments on the stack.
1449 Otherwise, evaluating the parameter may clobber previous parameters
1450 which have already been stored into the stack. (we have code to avoid
1451 such case by saving the outgoing stack arguments, but it results in
1452 worse code) */
1453 if (!ACCUMULATE_OUTGOING_ARGS)
1454 return;
1456 for (i = 0; i < num_actuals; i++)
1458 tree type;
1459 enum machine_mode mode;
1461 if (TREE_CODE (args[i].tree_value) != CALL_EXPR)
1462 continue;
1464 /* If this is an addressable type, we cannot pre-evaluate it. */
1465 type = TREE_TYPE (args[i].tree_value);
1466 gcc_assert (!TREE_ADDRESSABLE (type));
1468 args[i].initial_value = args[i].value
1469 = expand_normal (args[i].tree_value);
1471 mode = TYPE_MODE (type);
1472 if (mode != args[i].mode)
1474 int unsignedp = args[i].unsignedp;
1475 args[i].value
1476 = convert_modes (args[i].mode, mode,
1477 args[i].value, args[i].unsignedp);
1479 /* CSE will replace this only if it contains args[i].value
1480 pseudo, so convert it down to the declared mode using
1481 a SUBREG. */
1482 if (REG_P (args[i].value)
1483 && GET_MODE_CLASS (args[i].mode) == MODE_INT
1484 && promote_mode (type, mode, &unsignedp) != args[i].mode)
1486 args[i].initial_value
1487 = gen_lowpart_SUBREG (mode, args[i].value);
1488 SUBREG_PROMOTED_VAR_P (args[i].initial_value) = 1;
1489 SUBREG_PROMOTED_SET (args[i].initial_value, args[i].unsignedp);
1495 /* Given the current state of MUST_PREALLOCATE and information about
1496 arguments to a function call in NUM_ACTUALS, ARGS and ARGS_SIZE,
1497 compute and return the final value for MUST_PREALLOCATE. */
1499 static int
1500 finalize_must_preallocate (int must_preallocate, int num_actuals,
1501 struct arg_data *args, struct args_size *args_size)
1503 /* See if we have or want to preallocate stack space.
1505 If we would have to push a partially-in-regs parm
1506 before other stack parms, preallocate stack space instead.
1508 If the size of some parm is not a multiple of the required stack
1509 alignment, we must preallocate.
1511 If the total size of arguments that would otherwise create a copy in
1512 a temporary (such as a CALL) is more than half the total argument list
1513 size, preallocation is faster.
1515 Another reason to preallocate is if we have a machine (like the m88k)
1516 where stack alignment is required to be maintained between every
1517 pair of insns, not just when the call is made. However, we assume here
1518 that such machines either do not have push insns (and hence preallocation
1519 would occur anyway) or the problem is taken care of with
1520 PUSH_ROUNDING. */
1522 if (! must_preallocate)
1524 int partial_seen = 0;
1525 int copy_to_evaluate_size = 0;
1526 int i;
1528 for (i = 0; i < num_actuals && ! must_preallocate; i++)
1530 if (args[i].partial > 0 && ! args[i].pass_on_stack)
1531 partial_seen = 1;
1532 else if (partial_seen && args[i].reg == 0)
1533 must_preallocate = 1;
1535 if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
1536 && (TREE_CODE (args[i].tree_value) == CALL_EXPR
1537 || TREE_CODE (args[i].tree_value) == TARGET_EXPR
1538 || TREE_CODE (args[i].tree_value) == COND_EXPR
1539 || TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value))))
1540 copy_to_evaluate_size
1541 += int_size_in_bytes (TREE_TYPE (args[i].tree_value));
1544 if (copy_to_evaluate_size * 2 >= args_size->constant
1545 && args_size->constant > 0)
1546 must_preallocate = 1;
1548 return must_preallocate;
1551 /* If we preallocated stack space, compute the address of each argument
1552 and store it into the ARGS array.
1554 We need not ensure it is a valid memory address here; it will be
1555 validized when it is used.
1557 ARGBLOCK is an rtx for the address of the outgoing arguments. */
1559 static void
1560 compute_argument_addresses (struct arg_data *args, rtx argblock, int num_actuals)
1562 if (argblock)
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].locate.offset);
1573 rtx slot_offset = ARGS_SIZE_RTX (args[i].locate.slot_offset);
1574 rtx addr;
1575 unsigned int align, boundary;
1576 unsigned int units_on_stack = 0;
1577 enum machine_mode partial_mode = VOIDmode;
1579 /* Skip this parm if it will not be passed on the stack. */
1580 if (! args[i].pass_on_stack
1581 && args[i].reg != 0
1582 && args[i].partial == 0)
1583 continue;
1585 if (CONST_INT_P (offset))
1586 addr = plus_constant (Pmode, arg_reg, INTVAL (offset));
1587 else
1588 addr = gen_rtx_PLUS (Pmode, arg_reg, offset);
1590 addr = plus_constant (Pmode, addr, arg_offset);
1592 if (args[i].partial != 0)
1594 /* Only part of the parameter is being passed on the stack.
1595 Generate a simple memory reference of the correct size. */
1596 units_on_stack = args[i].locate.size.constant;
1597 partial_mode = mode_for_size (units_on_stack * BITS_PER_UNIT,
1598 MODE_INT, 1);
1599 args[i].stack = gen_rtx_MEM (partial_mode, addr);
1600 set_mem_size (args[i].stack, units_on_stack);
1602 else
1604 args[i].stack = gen_rtx_MEM (args[i].mode, addr);
1605 set_mem_attributes (args[i].stack,
1606 TREE_TYPE (args[i].tree_value), 1);
1608 align = BITS_PER_UNIT;
1609 boundary = args[i].locate.boundary;
1610 if (args[i].locate.where_pad != downward)
1611 align = boundary;
1612 else if (CONST_INT_P (offset))
1614 align = INTVAL (offset) * BITS_PER_UNIT | boundary;
1615 align = align & -align;
1617 set_mem_align (args[i].stack, align);
1619 if (CONST_INT_P (slot_offset))
1620 addr = plus_constant (Pmode, arg_reg, INTVAL (slot_offset));
1621 else
1622 addr = gen_rtx_PLUS (Pmode, arg_reg, slot_offset);
1624 addr = plus_constant (Pmode, addr, arg_offset);
1626 if (args[i].partial != 0)
1628 /* Only part of the parameter is being passed on the stack.
1629 Generate a simple memory reference of the correct size.
1631 args[i].stack_slot = gen_rtx_MEM (partial_mode, addr);
1632 set_mem_size (args[i].stack_slot, units_on_stack);
1634 else
1636 args[i].stack_slot = gen_rtx_MEM (args[i].mode, addr);
1637 set_mem_attributes (args[i].stack_slot,
1638 TREE_TYPE (args[i].tree_value), 1);
1640 set_mem_align (args[i].stack_slot, args[i].locate.boundary);
1642 /* Function incoming arguments may overlap with sibling call
1643 outgoing arguments and we cannot allow reordering of reads
1644 from function arguments with stores to outgoing arguments
1645 of sibling calls. */
1646 set_mem_alias_set (args[i].stack, 0);
1647 set_mem_alias_set (args[i].stack_slot, 0);
1652 /* Given a FNDECL and EXP, return an rtx suitable for use as a target address
1653 in a call instruction.
1655 FNDECL is the tree node for the target function. For an indirect call
1656 FNDECL will be NULL_TREE.
1658 ADDR is the operand 0 of CALL_EXPR for this call. */
1660 static rtx
1661 rtx_for_function_call (tree fndecl, tree addr)
1663 rtx funexp;
1665 /* Get the function to call, in the form of RTL. */
1666 if (fndecl)
1668 if (!TREE_USED (fndecl) && fndecl != current_function_decl)
1669 TREE_USED (fndecl) = 1;
1671 /* Get a SYMBOL_REF rtx for the function address. */
1672 funexp = XEXP (DECL_RTL (fndecl), 0);
1674 else
1675 /* Generate an rtx (probably a pseudo-register) for the address. */
1677 push_temp_slots ();
1678 funexp = expand_normal (addr);
1679 pop_temp_slots (); /* FUNEXP can't be BLKmode. */
1681 return funexp;
1684 /* Internal state for internal_arg_pointer_based_exp and its helpers. */
1685 static struct
1687 /* Last insn that has been scanned by internal_arg_pointer_based_exp_scan,
1688 or NULL_RTX if none has been scanned yet. */
1689 rtx_insn *scan_start;
1690 /* Vector indexed by REGNO - FIRST_PSEUDO_REGISTER, recording if a pseudo is
1691 based on crtl->args.internal_arg_pointer. The element is NULL_RTX if the
1692 pseudo isn't based on it, a CONST_INT offset if the pseudo is based on it
1693 with fixed offset, or PC if this is with variable or unknown offset. */
1694 vec<rtx> cache;
1695 } internal_arg_pointer_exp_state;
1697 static rtx internal_arg_pointer_based_exp (const_rtx, bool);
1699 /* Helper function for internal_arg_pointer_based_exp. Scan insns in
1700 the tail call sequence, starting with first insn that hasn't been
1701 scanned yet, and note for each pseudo on the LHS whether it is based
1702 on crtl->args.internal_arg_pointer or not, and what offset from that
1703 that pointer it has. */
1705 static void
1706 internal_arg_pointer_based_exp_scan (void)
1708 rtx_insn *insn, *scan_start = internal_arg_pointer_exp_state.scan_start;
1710 if (scan_start == NULL_RTX)
1711 insn = get_insns ();
1712 else
1713 insn = NEXT_INSN (scan_start);
1715 while (insn)
1717 rtx set = single_set (insn);
1718 if (set && REG_P (SET_DEST (set)) && !HARD_REGISTER_P (SET_DEST (set)))
1720 rtx val = NULL_RTX;
1721 unsigned int idx = REGNO (SET_DEST (set)) - FIRST_PSEUDO_REGISTER;
1722 /* Punt on pseudos set multiple times. */
1723 if (idx < internal_arg_pointer_exp_state.cache.length ()
1724 && (internal_arg_pointer_exp_state.cache[idx]
1725 != NULL_RTX))
1726 val = pc_rtx;
1727 else
1728 val = internal_arg_pointer_based_exp (SET_SRC (set), false);
1729 if (val != NULL_RTX)
1731 if (idx >= internal_arg_pointer_exp_state.cache.length ())
1732 internal_arg_pointer_exp_state.cache
1733 .safe_grow_cleared (idx + 1);
1734 internal_arg_pointer_exp_state.cache[idx] = val;
1737 if (NEXT_INSN (insn) == NULL_RTX)
1738 scan_start = insn;
1739 insn = NEXT_INSN (insn);
1742 internal_arg_pointer_exp_state.scan_start = scan_start;
1745 /* Compute whether RTL is based on crtl->args.internal_arg_pointer. Return
1746 NULL_RTX if RTL isn't based on it, a CONST_INT offset if RTL is based on
1747 it with fixed offset, or PC if this is with variable or unknown offset.
1748 TOPLEVEL is true if the function is invoked at the topmost level. */
1750 static rtx
1751 internal_arg_pointer_based_exp (const_rtx rtl, bool toplevel)
1753 if (CONSTANT_P (rtl))
1754 return NULL_RTX;
1756 if (rtl == crtl->args.internal_arg_pointer)
1757 return const0_rtx;
1759 if (REG_P (rtl) && HARD_REGISTER_P (rtl))
1760 return NULL_RTX;
1762 if (GET_CODE (rtl) == PLUS && CONST_INT_P (XEXP (rtl, 1)))
1764 rtx val = internal_arg_pointer_based_exp (XEXP (rtl, 0), toplevel);
1765 if (val == NULL_RTX || val == pc_rtx)
1766 return val;
1767 return plus_constant (Pmode, val, INTVAL (XEXP (rtl, 1)));
1770 /* When called at the topmost level, scan pseudo assignments in between the
1771 last scanned instruction in the tail call sequence and the latest insn
1772 in that sequence. */
1773 if (toplevel)
1774 internal_arg_pointer_based_exp_scan ();
1776 if (REG_P (rtl))
1778 unsigned int idx = REGNO (rtl) - FIRST_PSEUDO_REGISTER;
1779 if (idx < internal_arg_pointer_exp_state.cache.length ())
1780 return internal_arg_pointer_exp_state.cache[idx];
1782 return NULL_RTX;
1785 subrtx_iterator::array_type array;
1786 FOR_EACH_SUBRTX (iter, array, rtl, NONCONST)
1788 const_rtx x = *iter;
1789 if (REG_P (x) && internal_arg_pointer_based_exp (x, false) != NULL_RTX)
1790 return pc_rtx;
1791 if (MEM_P (x))
1792 iter.skip_subrtxes ();
1795 return NULL_RTX;
1798 /* Return true if and only if SIZE storage units (usually bytes)
1799 starting from address ADDR overlap with already clobbered argument
1800 area. This function is used to determine if we should give up a
1801 sibcall. */
1803 static bool
1804 mem_overlaps_already_clobbered_arg_p (rtx addr, unsigned HOST_WIDE_INT size)
1806 HOST_WIDE_INT i;
1807 rtx val;
1809 if (bitmap_empty_p (stored_args_map))
1810 return false;
1811 val = internal_arg_pointer_based_exp (addr, true);
1812 if (val == NULL_RTX)
1813 return false;
1814 else if (val == pc_rtx)
1815 return true;
1816 else
1817 i = INTVAL (val);
1818 #ifdef STACK_GROWS_DOWNWARD
1819 i -= crtl->args.pretend_args_size;
1820 #else
1821 i += crtl->args.pretend_args_size;
1822 #endif
1824 #ifdef ARGS_GROW_DOWNWARD
1825 i = -i - size;
1826 #endif
1827 if (size > 0)
1829 unsigned HOST_WIDE_INT k;
1831 for (k = 0; k < size; k++)
1832 if (i + k < SBITMAP_SIZE (stored_args_map)
1833 && bitmap_bit_p (stored_args_map, i + k))
1834 return true;
1837 return false;
1840 /* Do the register loads required for any wholly-register parms or any
1841 parms which are passed both on the stack and in a register. Their
1842 expressions were already evaluated.
1844 Mark all register-parms as living through the call, putting these USE
1845 insns in the CALL_INSN_FUNCTION_USAGE field.
1847 When IS_SIBCALL, perform the check_sibcall_argument_overlap
1848 checking, setting *SIBCALL_FAILURE if appropriate. */
1850 static void
1851 load_register_parameters (struct arg_data *args, int num_actuals,
1852 rtx *call_fusage, int flags, int is_sibcall,
1853 int *sibcall_failure)
1855 int i, j;
1857 for (i = 0; i < num_actuals; i++)
1859 rtx reg = ((flags & ECF_SIBCALL)
1860 ? args[i].tail_call_reg : args[i].reg);
1861 if (reg)
1863 int partial = args[i].partial;
1864 int nregs;
1865 int size = 0;
1866 rtx_insn *before_arg = get_last_insn ();
1867 /* Set non-negative if we must move a word at a time, even if
1868 just one word (e.g, partial == 4 && mode == DFmode). Set
1869 to -1 if we just use a normal move insn. This value can be
1870 zero if the argument is a zero size structure. */
1871 nregs = -1;
1872 if (GET_CODE (reg) == PARALLEL)
1874 else if (partial)
1876 gcc_assert (partial % UNITS_PER_WORD == 0);
1877 nregs = partial / UNITS_PER_WORD;
1879 else if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode)
1881 size = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
1882 nregs = (size + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
1884 else
1885 size = GET_MODE_SIZE (args[i].mode);
1887 /* Handle calls that pass values in multiple non-contiguous
1888 locations. The Irix 6 ABI has examples of this. */
1890 if (GET_CODE (reg) == PARALLEL)
1891 emit_group_move (reg, args[i].parallel_value);
1893 /* If simple case, just do move. If normal partial, store_one_arg
1894 has already loaded the register for us. In all other cases,
1895 load the register(s) from memory. */
1897 else if (nregs == -1)
1899 emit_move_insn (reg, args[i].value);
1900 #ifdef BLOCK_REG_PADDING
1901 /* Handle case where we have a value that needs shifting
1902 up to the msb. eg. a QImode value and we're padding
1903 upward on a BYTES_BIG_ENDIAN machine. */
1904 if (size < UNITS_PER_WORD
1905 && (args[i].locate.where_pad
1906 == (BYTES_BIG_ENDIAN ? upward : downward)))
1908 rtx x;
1909 int shift = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
1911 /* Assigning REG here rather than a temp makes CALL_FUSAGE
1912 report the whole reg as used. Strictly speaking, the
1913 call only uses SIZE bytes at the msb end, but it doesn't
1914 seem worth generating rtl to say that. */
1915 reg = gen_rtx_REG (word_mode, REGNO (reg));
1916 x = expand_shift (LSHIFT_EXPR, word_mode, reg, shift, reg, 1);
1917 if (x != reg)
1918 emit_move_insn (reg, x);
1920 #endif
1923 /* If we have pre-computed the values to put in the registers in
1924 the case of non-aligned structures, copy them in now. */
1926 else if (args[i].n_aligned_regs != 0)
1927 for (j = 0; j < args[i].n_aligned_regs; j++)
1928 emit_move_insn (gen_rtx_REG (word_mode, REGNO (reg) + j),
1929 args[i].aligned_regs[j]);
1931 else if (partial == 0 || args[i].pass_on_stack)
1933 rtx mem = validize_mem (copy_rtx (args[i].value));
1935 /* Check for overlap with already clobbered argument area,
1936 providing that this has non-zero size. */
1937 if (is_sibcall
1938 && (size == 0
1939 || mem_overlaps_already_clobbered_arg_p
1940 (XEXP (args[i].value, 0), size)))
1941 *sibcall_failure = 1;
1943 /* Handle a BLKmode that needs shifting. */
1944 if (nregs == 1 && size < UNITS_PER_WORD
1945 #ifdef BLOCK_REG_PADDING
1946 && args[i].locate.where_pad == downward
1947 #else
1948 && BYTES_BIG_ENDIAN
1949 #endif
1952 rtx tem = operand_subword_force (mem, 0, args[i].mode);
1953 rtx ri = gen_rtx_REG (word_mode, REGNO (reg));
1954 rtx x = gen_reg_rtx (word_mode);
1955 int shift = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
1956 enum tree_code dir = BYTES_BIG_ENDIAN ? RSHIFT_EXPR
1957 : LSHIFT_EXPR;
1959 emit_move_insn (x, tem);
1960 x = expand_shift (dir, word_mode, x, shift, ri, 1);
1961 if (x != ri)
1962 emit_move_insn (ri, x);
1964 else
1965 move_block_to_reg (REGNO (reg), mem, nregs, args[i].mode);
1968 /* When a parameter is a block, and perhaps in other cases, it is
1969 possible that it did a load from an argument slot that was
1970 already clobbered. */
1971 if (is_sibcall
1972 && check_sibcall_argument_overlap (before_arg, &args[i], 0))
1973 *sibcall_failure = 1;
1975 /* Handle calls that pass values in multiple non-contiguous
1976 locations. The Irix 6 ABI has examples of this. */
1977 if (GET_CODE (reg) == PARALLEL)
1978 use_group_regs (call_fusage, reg);
1979 else if (nregs == -1)
1980 use_reg_mode (call_fusage, reg,
1981 TYPE_MODE (TREE_TYPE (args[i].tree_value)));
1982 else if (nregs > 0)
1983 use_regs (call_fusage, REGNO (reg), nregs);
1988 /* We need to pop PENDING_STACK_ADJUST bytes. But, if the arguments
1989 wouldn't fill up an even multiple of PREFERRED_UNIT_STACK_BOUNDARY
1990 bytes, then we would need to push some additional bytes to pad the
1991 arguments. So, we compute an adjust to the stack pointer for an
1992 amount that will leave the stack under-aligned by UNADJUSTED_ARGS_SIZE
1993 bytes. Then, when the arguments are pushed the stack will be perfectly
1994 aligned. ARGS_SIZE->CONSTANT is set to the number of bytes that should
1995 be popped after the call. Returns the adjustment. */
1997 static int
1998 combine_pending_stack_adjustment_and_call (int unadjusted_args_size,
1999 struct args_size *args_size,
2000 unsigned int preferred_unit_stack_boundary)
2002 /* The number of bytes to pop so that the stack will be
2003 under-aligned by UNADJUSTED_ARGS_SIZE bytes. */
2004 HOST_WIDE_INT adjustment;
2005 /* The alignment of the stack after the arguments are pushed, if we
2006 just pushed the arguments without adjust the stack here. */
2007 unsigned HOST_WIDE_INT unadjusted_alignment;
2009 unadjusted_alignment
2010 = ((stack_pointer_delta + unadjusted_args_size)
2011 % preferred_unit_stack_boundary);
2013 /* We want to get rid of as many of the PENDING_STACK_ADJUST bytes
2014 as possible -- leaving just enough left to cancel out the
2015 UNADJUSTED_ALIGNMENT. In other words, we want to ensure that the
2016 PENDING_STACK_ADJUST is non-negative, and congruent to
2017 -UNADJUSTED_ALIGNMENT modulo the PREFERRED_UNIT_STACK_BOUNDARY. */
2019 /* Begin by trying to pop all the bytes. */
2020 unadjusted_alignment
2021 = (unadjusted_alignment
2022 - (pending_stack_adjust % preferred_unit_stack_boundary));
2023 adjustment = pending_stack_adjust;
2024 /* Push enough additional bytes that the stack will be aligned
2025 after the arguments are pushed. */
2026 if (preferred_unit_stack_boundary > 1)
2028 if (unadjusted_alignment > 0)
2029 adjustment -= preferred_unit_stack_boundary - unadjusted_alignment;
2030 else
2031 adjustment += unadjusted_alignment;
2034 /* Now, sets ARGS_SIZE->CONSTANT so that we pop the right number of
2035 bytes after the call. The right number is the entire
2036 PENDING_STACK_ADJUST less our ADJUSTMENT plus the amount required
2037 by the arguments in the first place. */
2038 args_size->constant
2039 = pending_stack_adjust - adjustment + unadjusted_args_size;
2041 return adjustment;
2044 /* Scan X expression if it does not dereference any argument slots
2045 we already clobbered by tail call arguments (as noted in stored_args_map
2046 bitmap).
2047 Return nonzero if X expression dereferences such argument slots,
2048 zero otherwise. */
2050 static int
2051 check_sibcall_argument_overlap_1 (rtx x)
2053 RTX_CODE code;
2054 int i, j;
2055 const char *fmt;
2057 if (x == NULL_RTX)
2058 return 0;
2060 code = GET_CODE (x);
2062 /* We need not check the operands of the CALL expression itself. */
2063 if (code == CALL)
2064 return 0;
2066 if (code == MEM)
2067 return mem_overlaps_already_clobbered_arg_p (XEXP (x, 0),
2068 GET_MODE_SIZE (GET_MODE (x)));
2070 /* Scan all subexpressions. */
2071 fmt = GET_RTX_FORMAT (code);
2072 for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
2074 if (*fmt == 'e')
2076 if (check_sibcall_argument_overlap_1 (XEXP (x, i)))
2077 return 1;
2079 else if (*fmt == 'E')
2081 for (j = 0; j < XVECLEN (x, i); j++)
2082 if (check_sibcall_argument_overlap_1 (XVECEXP (x, i, j)))
2083 return 1;
2086 return 0;
2089 /* Scan sequence after INSN if it does not dereference any argument slots
2090 we already clobbered by tail call arguments (as noted in stored_args_map
2091 bitmap). If MARK_STORED_ARGS_MAP, add stack slots for ARG to
2092 stored_args_map bitmap afterwards (when ARG is a register MARK_STORED_ARGS_MAP
2093 should be 0). Return nonzero if sequence after INSN dereferences such argument
2094 slots, zero otherwise. */
2096 static int
2097 check_sibcall_argument_overlap (rtx_insn *insn, struct arg_data *arg,
2098 int mark_stored_args_map)
2100 int low, high;
2102 if (insn == NULL_RTX)
2103 insn = get_insns ();
2104 else
2105 insn = NEXT_INSN (insn);
2107 for (; insn; insn = NEXT_INSN (insn))
2108 if (INSN_P (insn)
2109 && check_sibcall_argument_overlap_1 (PATTERN (insn)))
2110 break;
2112 if (mark_stored_args_map)
2114 #ifdef ARGS_GROW_DOWNWARD
2115 low = -arg->locate.slot_offset.constant - arg->locate.size.constant;
2116 #else
2117 low = arg->locate.slot_offset.constant;
2118 #endif
2120 for (high = low + arg->locate.size.constant; low < high; low++)
2121 bitmap_set_bit (stored_args_map, low);
2123 return insn != NULL_RTX;
2126 /* Given that a function returns a value of mode MODE at the most
2127 significant end of hard register VALUE, shift VALUE left or right
2128 as specified by LEFT_P. Return true if some action was needed. */
2130 bool
2131 shift_return_value (enum machine_mode mode, bool left_p, rtx value)
2133 HOST_WIDE_INT shift;
2135 gcc_assert (REG_P (value) && HARD_REGISTER_P (value));
2136 shift = GET_MODE_BITSIZE (GET_MODE (value)) - GET_MODE_BITSIZE (mode);
2137 if (shift == 0)
2138 return false;
2140 /* Use ashr rather than lshr for right shifts. This is for the benefit
2141 of the MIPS port, which requires SImode values to be sign-extended
2142 when stored in 64-bit registers. */
2143 if (!force_expand_binop (GET_MODE (value), left_p ? ashl_optab : ashr_optab,
2144 value, GEN_INT (shift), value, 1, OPTAB_WIDEN))
2145 gcc_unreachable ();
2146 return true;
2149 /* If X is a likely-spilled register value, copy it to a pseudo
2150 register and return that register. Return X otherwise. */
2152 static rtx
2153 avoid_likely_spilled_reg (rtx x)
2155 rtx new_rtx;
2157 if (REG_P (x)
2158 && HARD_REGISTER_P (x)
2159 && targetm.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (x))))
2161 /* Make sure that we generate a REG rather than a CONCAT.
2162 Moves into CONCATs can need nontrivial instructions,
2163 and the whole point of this function is to avoid
2164 using the hard register directly in such a situation. */
2165 generating_concat_p = 0;
2166 new_rtx = gen_reg_rtx (GET_MODE (x));
2167 generating_concat_p = 1;
2168 emit_move_insn (new_rtx, x);
2169 return new_rtx;
2171 return x;
2174 /* Generate all the code for a CALL_EXPR exp
2175 and return an rtx for its value.
2176 Store the value in TARGET (specified as an rtx) if convenient.
2177 If the value is stored in TARGET then TARGET is returned.
2178 If IGNORE is nonzero, then we ignore the value of the function call. */
2181 expand_call (tree exp, rtx target, int ignore)
2183 /* Nonzero if we are currently expanding a call. */
2184 static int currently_expanding_call = 0;
2186 /* RTX for the function to be called. */
2187 rtx funexp;
2188 /* Sequence of insns to perform a normal "call". */
2189 rtx_insn *normal_call_insns = NULL;
2190 /* Sequence of insns to perform a tail "call". */
2191 rtx_insn *tail_call_insns = NULL;
2192 /* Data type of the function. */
2193 tree funtype;
2194 tree type_arg_types;
2195 tree rettype;
2196 /* Declaration of the function being called,
2197 or 0 if the function is computed (not known by name). */
2198 tree fndecl = 0;
2199 /* The type of the function being called. */
2200 tree fntype;
2201 bool try_tail_call = CALL_EXPR_TAILCALL (exp);
2202 int pass;
2204 /* Register in which non-BLKmode value will be returned,
2205 or 0 if no value or if value is BLKmode. */
2206 rtx valreg;
2207 /* Address where we should return a BLKmode value;
2208 0 if value not BLKmode. */
2209 rtx structure_value_addr = 0;
2210 /* Nonzero if that address is being passed by treating it as
2211 an extra, implicit first parameter. Otherwise,
2212 it is passed by being copied directly into struct_value_rtx. */
2213 int structure_value_addr_parm = 0;
2214 /* Holds the value of implicit argument for the struct value. */
2215 tree structure_value_addr_value = NULL_TREE;
2216 /* Size of aggregate value wanted, or zero if none wanted
2217 or if we are using the non-reentrant PCC calling convention
2218 or expecting the value in registers. */
2219 HOST_WIDE_INT struct_value_size = 0;
2220 /* Nonzero if called function returns an aggregate in memory PCC style,
2221 by returning the address of where to find it. */
2222 int pcc_struct_value = 0;
2223 rtx struct_value = 0;
2225 /* Number of actual parameters in this call, including struct value addr. */
2226 int num_actuals;
2227 /* Number of named args. Args after this are anonymous ones
2228 and they must all go on the stack. */
2229 int n_named_args;
2230 /* Number of complex actual arguments that need to be split. */
2231 int num_complex_actuals = 0;
2233 /* Vector of information about each argument.
2234 Arguments are numbered in the order they will be pushed,
2235 not the order they are written. */
2236 struct arg_data *args;
2238 /* Total size in bytes of all the stack-parms scanned so far. */
2239 struct args_size args_size;
2240 struct args_size adjusted_args_size;
2241 /* Size of arguments before any adjustments (such as rounding). */
2242 int unadjusted_args_size;
2243 /* Data on reg parms scanned so far. */
2244 CUMULATIVE_ARGS args_so_far_v;
2245 cumulative_args_t args_so_far;
2246 /* Nonzero if a reg parm has been scanned. */
2247 int reg_parm_seen;
2248 /* Nonzero if this is an indirect function call. */
2250 /* Nonzero if we must avoid push-insns in the args for this call.
2251 If stack space is allocated for register parameters, but not by the
2252 caller, then it is preallocated in the fixed part of the stack frame.
2253 So the entire argument block must then be preallocated (i.e., we
2254 ignore PUSH_ROUNDING in that case). */
2256 int must_preallocate = !PUSH_ARGS;
2258 /* Size of the stack reserved for parameter registers. */
2259 int reg_parm_stack_space = 0;
2261 /* Address of space preallocated for stack parms
2262 (on machines that lack push insns), or 0 if space not preallocated. */
2263 rtx argblock = 0;
2265 /* Mask of ECF_ and ERF_ flags. */
2266 int flags = 0;
2267 int return_flags = 0;
2268 #ifdef REG_PARM_STACK_SPACE
2269 /* Define the boundary of the register parm stack space that needs to be
2270 saved, if any. */
2271 int low_to_save, high_to_save;
2272 rtx save_area = 0; /* Place that it is saved */
2273 #endif
2275 int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
2276 char *initial_stack_usage_map = stack_usage_map;
2277 char *stack_usage_map_buf = NULL;
2279 int old_stack_allocated;
2281 /* State variables to track stack modifications. */
2282 rtx old_stack_level = 0;
2283 int old_stack_arg_under_construction = 0;
2284 int old_pending_adj = 0;
2285 int old_inhibit_defer_pop = inhibit_defer_pop;
2287 /* Some stack pointer alterations we make are performed via
2288 allocate_dynamic_stack_space. This modifies the stack_pointer_delta,
2289 which we then also need to save/restore along the way. */
2290 int old_stack_pointer_delta = 0;
2292 rtx call_fusage;
2293 tree addr = CALL_EXPR_FN (exp);
2294 int i;
2295 /* The alignment of the stack, in bits. */
2296 unsigned HOST_WIDE_INT preferred_stack_boundary;
2297 /* The alignment of the stack, in bytes. */
2298 unsigned HOST_WIDE_INT preferred_unit_stack_boundary;
2299 /* The static chain value to use for this call. */
2300 rtx static_chain_value;
2301 /* See if this is "nothrow" function call. */
2302 if (TREE_NOTHROW (exp))
2303 flags |= ECF_NOTHROW;
2305 /* See if we can find a DECL-node for the actual function, and get the
2306 function attributes (flags) from the function decl or type node. */
2307 fndecl = get_callee_fndecl (exp);
2308 if (fndecl)
2310 fntype = TREE_TYPE (fndecl);
2311 flags |= flags_from_decl_or_type (fndecl);
2312 return_flags |= decl_return_flags (fndecl);
2314 else
2316 fntype = TREE_TYPE (TREE_TYPE (addr));
2317 flags |= flags_from_decl_or_type (fntype);
2319 rettype = TREE_TYPE (exp);
2321 struct_value = targetm.calls.struct_value_rtx (fntype, 0);
2323 /* Warn if this value is an aggregate type,
2324 regardless of which calling convention we are using for it. */
2325 if (AGGREGATE_TYPE_P (rettype))
2326 warning (OPT_Waggregate_return, "function call has aggregate value");
2328 /* If the result of a non looping pure or const function call is
2329 ignored (or void), and none of its arguments are volatile, we can
2330 avoid expanding the call and just evaluate the arguments for
2331 side-effects. */
2332 if ((flags & (ECF_CONST | ECF_PURE))
2333 && (!(flags & ECF_LOOPING_CONST_OR_PURE))
2334 && (ignore || target == const0_rtx
2335 || TYPE_MODE (rettype) == VOIDmode))
2337 bool volatilep = false;
2338 tree arg;
2339 call_expr_arg_iterator iter;
2341 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
2342 if (TREE_THIS_VOLATILE (arg))
2344 volatilep = true;
2345 break;
2348 if (! volatilep)
2350 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
2351 expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
2352 return const0_rtx;
2356 #ifdef REG_PARM_STACK_SPACE
2357 reg_parm_stack_space = REG_PARM_STACK_SPACE (!fndecl ? fntype : fndecl);
2358 #endif
2360 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))
2361 && reg_parm_stack_space > 0 && PUSH_ARGS)
2362 must_preallocate = 1;
2364 /* Set up a place to return a structure. */
2366 /* Cater to broken compilers. */
2367 if (aggregate_value_p (exp, fntype))
2369 /* This call returns a big structure. */
2370 flags &= ~(ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
2372 #ifdef PCC_STATIC_STRUCT_RETURN
2374 pcc_struct_value = 1;
2376 #else /* not PCC_STATIC_STRUCT_RETURN */
2378 struct_value_size = int_size_in_bytes (rettype);
2380 if (target && MEM_P (target) && CALL_EXPR_RETURN_SLOT_OPT (exp))
2381 structure_value_addr = XEXP (target, 0);
2382 else
2384 /* For variable-sized objects, we must be called with a target
2385 specified. If we were to allocate space on the stack here,
2386 we would have no way of knowing when to free it. */
2387 rtx d = assign_temp (rettype, 1, 1);
2388 structure_value_addr = XEXP (d, 0);
2389 target = 0;
2392 #endif /* not PCC_STATIC_STRUCT_RETURN */
2395 /* Figure out the amount to which the stack should be aligned. */
2396 preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
2397 if (fndecl)
2399 struct cgraph_rtl_info *i = cgraph_node::rtl_info (fndecl);
2400 /* Without automatic stack alignment, we can't increase preferred
2401 stack boundary. With automatic stack alignment, it is
2402 unnecessary since unless we can guarantee that all callers will
2403 align the outgoing stack properly, callee has to align its
2404 stack anyway. */
2405 if (i
2406 && i->preferred_incoming_stack_boundary
2407 && i->preferred_incoming_stack_boundary < preferred_stack_boundary)
2408 preferred_stack_boundary = i->preferred_incoming_stack_boundary;
2411 /* Operand 0 is a pointer-to-function; get the type of the function. */
2412 funtype = TREE_TYPE (addr);
2413 gcc_assert (POINTER_TYPE_P (funtype));
2414 funtype = TREE_TYPE (funtype);
2416 /* Count whether there are actual complex arguments that need to be split
2417 into their real and imaginary parts. Munge the type_arg_types
2418 appropriately here as well. */
2419 if (targetm.calls.split_complex_arg)
2421 call_expr_arg_iterator iter;
2422 tree arg;
2423 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
2425 tree type = TREE_TYPE (arg);
2426 if (type && TREE_CODE (type) == COMPLEX_TYPE
2427 && targetm.calls.split_complex_arg (type))
2428 num_complex_actuals++;
2430 type_arg_types = split_complex_types (TYPE_ARG_TYPES (funtype));
2432 else
2433 type_arg_types = TYPE_ARG_TYPES (funtype);
2435 if (flags & ECF_MAY_BE_ALLOCA)
2436 cfun->calls_alloca = 1;
2438 /* If struct_value_rtx is 0, it means pass the address
2439 as if it were an extra parameter. Put the argument expression
2440 in structure_value_addr_value. */
2441 if (structure_value_addr && struct_value == 0)
2443 /* If structure_value_addr is a REG other than
2444 virtual_outgoing_args_rtx, we can use always use it. If it
2445 is not a REG, we must always copy it into a register.
2446 If it is virtual_outgoing_args_rtx, we must copy it to another
2447 register in some cases. */
2448 rtx temp = (!REG_P (structure_value_addr)
2449 || (ACCUMULATE_OUTGOING_ARGS
2450 && stack_arg_under_construction
2451 && structure_value_addr == virtual_outgoing_args_rtx)
2452 ? copy_addr_to_reg (convert_memory_address
2453 (Pmode, structure_value_addr))
2454 : structure_value_addr);
2456 structure_value_addr_value =
2457 make_tree (build_pointer_type (TREE_TYPE (funtype)), temp);
2458 structure_value_addr_parm = 1;
2461 /* Count the arguments and set NUM_ACTUALS. */
2462 num_actuals =
2463 call_expr_nargs (exp) + num_complex_actuals + structure_value_addr_parm;
2465 /* Compute number of named args.
2466 First, do a raw count of the args for INIT_CUMULATIVE_ARGS. */
2468 if (type_arg_types != 0)
2469 n_named_args
2470 = (list_length (type_arg_types)
2471 /* Count the struct value address, if it is passed as a parm. */
2472 + structure_value_addr_parm);
2473 else
2474 /* If we know nothing, treat all args as named. */
2475 n_named_args = num_actuals;
2477 /* Start updating where the next arg would go.
2479 On some machines (such as the PA) indirect calls have a different
2480 calling convention than normal calls. The fourth argument in
2481 INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
2482 or not. */
2483 INIT_CUMULATIVE_ARGS (args_so_far_v, funtype, NULL_RTX, fndecl, n_named_args);
2484 args_so_far = pack_cumulative_args (&args_so_far_v);
2486 /* Now possibly adjust the number of named args.
2487 Normally, don't include the last named arg if anonymous args follow.
2488 We do include the last named arg if
2489 targetm.calls.strict_argument_naming() returns nonzero.
2490 (If no anonymous args follow, the result of list_length is actually
2491 one too large. This is harmless.)
2493 If targetm.calls.pretend_outgoing_varargs_named() returns
2494 nonzero, and targetm.calls.strict_argument_naming() returns zero,
2495 this machine will be able to place unnamed args that were passed
2496 in registers into the stack. So treat all args as named. This
2497 allows the insns emitting for a specific argument list to be
2498 independent of the function declaration.
2500 If targetm.calls.pretend_outgoing_varargs_named() returns zero,
2501 we do not have any reliable way to pass unnamed args in
2502 registers, so we must force them into memory. */
2504 if (type_arg_types != 0
2505 && targetm.calls.strict_argument_naming (args_so_far))
2507 else if (type_arg_types != 0
2508 && ! targetm.calls.pretend_outgoing_varargs_named (args_so_far))
2509 /* Don't include the last named arg. */
2510 --n_named_args;
2511 else
2512 /* Treat all args as named. */
2513 n_named_args = num_actuals;
2515 /* Make a vector to hold all the information about each arg. */
2516 args = XALLOCAVEC (struct arg_data, num_actuals);
2517 memset (args, 0, num_actuals * sizeof (struct arg_data));
2519 /* Build up entries in the ARGS array, compute the size of the
2520 arguments into ARGS_SIZE, etc. */
2521 initialize_argument_information (num_actuals, args, &args_size,
2522 n_named_args, exp,
2523 structure_value_addr_value, fndecl, fntype,
2524 args_so_far, reg_parm_stack_space,
2525 &old_stack_level, &old_pending_adj,
2526 &must_preallocate, &flags,
2527 &try_tail_call, CALL_FROM_THUNK_P (exp));
2529 if (args_size.var)
2530 must_preallocate = 1;
2532 /* Now make final decision about preallocating stack space. */
2533 must_preallocate = finalize_must_preallocate (must_preallocate,
2534 num_actuals, args,
2535 &args_size);
2537 /* If the structure value address will reference the stack pointer, we
2538 must stabilize it. We don't need to do this if we know that we are
2539 not going to adjust the stack pointer in processing this call. */
2541 if (structure_value_addr
2542 && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
2543 || reg_mentioned_p (virtual_outgoing_args_rtx,
2544 structure_value_addr))
2545 && (args_size.var
2546 || (!ACCUMULATE_OUTGOING_ARGS && args_size.constant)))
2547 structure_value_addr = copy_to_reg (structure_value_addr);
2549 /* Tail calls can make things harder to debug, and we've traditionally
2550 pushed these optimizations into -O2. Don't try if we're already
2551 expanding a call, as that means we're an argument. Don't try if
2552 there's cleanups, as we know there's code to follow the call. */
2554 if (currently_expanding_call++ != 0
2555 || !flag_optimize_sibling_calls
2556 || args_size.var
2557 || dbg_cnt (tail_call) == false)
2558 try_tail_call = 0;
2560 /* Rest of purposes for tail call optimizations to fail. */
2561 if (
2562 #ifdef HAVE_sibcall_epilogue
2563 !HAVE_sibcall_epilogue
2564 #else
2566 #endif
2567 || !try_tail_call
2568 /* Doing sibling call optimization needs some work, since
2569 structure_value_addr can be allocated on the stack.
2570 It does not seem worth the effort since few optimizable
2571 sibling calls will return a structure. */
2572 || structure_value_addr != NULL_RTX
2573 #ifdef REG_PARM_STACK_SPACE
2574 /* If outgoing reg parm stack space changes, we can not do sibcall. */
2575 || (OUTGOING_REG_PARM_STACK_SPACE (funtype)
2576 != OUTGOING_REG_PARM_STACK_SPACE (TREE_TYPE (current_function_decl)))
2577 || (reg_parm_stack_space != REG_PARM_STACK_SPACE (current_function_decl))
2578 #endif
2579 /* Check whether the target is able to optimize the call
2580 into a sibcall. */
2581 || !targetm.function_ok_for_sibcall (fndecl, exp)
2582 /* Functions that do not return exactly once may not be sibcall
2583 optimized. */
2584 || (flags & (ECF_RETURNS_TWICE | ECF_NORETURN))
2585 || TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (addr)))
2586 /* If the called function is nested in the current one, it might access
2587 some of the caller's arguments, but could clobber them beforehand if
2588 the argument areas are shared. */
2589 || (fndecl && decl_function_context (fndecl) == current_function_decl)
2590 /* If this function requires more stack slots than the current
2591 function, we cannot change it into a sibling call.
2592 crtl->args.pretend_args_size is not part of the
2593 stack allocated by our caller. */
2594 || args_size.constant > (crtl->args.size
2595 - crtl->args.pretend_args_size)
2596 /* If the callee pops its own arguments, then it must pop exactly
2597 the same number of arguments as the current function. */
2598 || (targetm.calls.return_pops_args (fndecl, funtype, args_size.constant)
2599 != targetm.calls.return_pops_args (current_function_decl,
2600 TREE_TYPE (current_function_decl),
2601 crtl->args.size))
2602 || !lang_hooks.decls.ok_for_sibcall (fndecl))
2603 try_tail_call = 0;
2605 /* Check if caller and callee disagree in promotion of function
2606 return value. */
2607 if (try_tail_call)
2609 enum machine_mode caller_mode, caller_promoted_mode;
2610 enum machine_mode callee_mode, callee_promoted_mode;
2611 int caller_unsignedp, callee_unsignedp;
2612 tree caller_res = DECL_RESULT (current_function_decl);
2614 caller_unsignedp = TYPE_UNSIGNED (TREE_TYPE (caller_res));
2615 caller_mode = DECL_MODE (caller_res);
2616 callee_unsignedp = TYPE_UNSIGNED (TREE_TYPE (funtype));
2617 callee_mode = TYPE_MODE (TREE_TYPE (funtype));
2618 caller_promoted_mode
2619 = promote_function_mode (TREE_TYPE (caller_res), caller_mode,
2620 &caller_unsignedp,
2621 TREE_TYPE (current_function_decl), 1);
2622 callee_promoted_mode
2623 = promote_function_mode (TREE_TYPE (funtype), callee_mode,
2624 &callee_unsignedp,
2625 funtype, 1);
2626 if (caller_mode != VOIDmode
2627 && (caller_promoted_mode != callee_promoted_mode
2628 || ((caller_mode != caller_promoted_mode
2629 || callee_mode != callee_promoted_mode)
2630 && (caller_unsignedp != callee_unsignedp
2631 || GET_MODE_BITSIZE (caller_mode)
2632 < GET_MODE_BITSIZE (callee_mode)))))
2633 try_tail_call = 0;
2636 /* Ensure current function's preferred stack boundary is at least
2637 what we need. Stack alignment may also increase preferred stack
2638 boundary. */
2639 if (crtl->preferred_stack_boundary < preferred_stack_boundary)
2640 crtl->preferred_stack_boundary = preferred_stack_boundary;
2641 else
2642 preferred_stack_boundary = crtl->preferred_stack_boundary;
2644 preferred_unit_stack_boundary = preferred_stack_boundary / BITS_PER_UNIT;
2646 /* We want to make two insn chains; one for a sibling call, the other
2647 for a normal call. We will select one of the two chains after
2648 initial RTL generation is complete. */
2649 for (pass = try_tail_call ? 0 : 1; pass < 2; pass++)
2651 int sibcall_failure = 0;
2652 /* We want to emit any pending stack adjustments before the tail
2653 recursion "call". That way we know any adjustment after the tail
2654 recursion call can be ignored if we indeed use the tail
2655 call expansion. */
2656 saved_pending_stack_adjust save;
2657 rtx_insn *insns, *before_call, *after_args;
2658 rtx next_arg_reg;
2660 if (pass == 0)
2662 /* State variables we need to save and restore between
2663 iterations. */
2664 save_pending_stack_adjust (&save);
2666 if (pass)
2667 flags &= ~ECF_SIBCALL;
2668 else
2669 flags |= ECF_SIBCALL;
2671 /* Other state variables that we must reinitialize each time
2672 through the loop (that are not initialized by the loop itself). */
2673 argblock = 0;
2674 call_fusage = 0;
2676 /* Start a new sequence for the normal call case.
2678 From this point on, if the sibling call fails, we want to set
2679 sibcall_failure instead of continuing the loop. */
2680 start_sequence ();
2682 /* Don't let pending stack adjusts add up to too much.
2683 Also, do all pending adjustments now if there is any chance
2684 this might be a call to alloca or if we are expanding a sibling
2685 call sequence.
2686 Also do the adjustments before a throwing call, otherwise
2687 exception handling can fail; PR 19225. */
2688 if (pending_stack_adjust >= 32
2689 || (pending_stack_adjust > 0
2690 && (flags & ECF_MAY_BE_ALLOCA))
2691 || (pending_stack_adjust > 0
2692 && flag_exceptions && !(flags & ECF_NOTHROW))
2693 || pass == 0)
2694 do_pending_stack_adjust ();
2696 /* Precompute any arguments as needed. */
2697 if (pass)
2698 precompute_arguments (num_actuals, args);
2700 /* Now we are about to start emitting insns that can be deleted
2701 if a libcall is deleted. */
2702 if (pass && (flags & ECF_MALLOC))
2703 start_sequence ();
2705 if (pass == 0 && crtl->stack_protect_guard)
2706 stack_protect_epilogue ();
2708 adjusted_args_size = args_size;
2709 /* Compute the actual size of the argument block required. The variable
2710 and constant sizes must be combined, the size may have to be rounded,
2711 and there may be a minimum required size. When generating a sibcall
2712 pattern, do not round up, since we'll be re-using whatever space our
2713 caller provided. */
2714 unadjusted_args_size
2715 = compute_argument_block_size (reg_parm_stack_space,
2716 &adjusted_args_size,
2717 fndecl, fntype,
2718 (pass == 0 ? 0
2719 : preferred_stack_boundary));
2721 old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
2723 /* The argument block when performing a sibling call is the
2724 incoming argument block. */
2725 if (pass == 0)
2727 argblock = crtl->args.internal_arg_pointer;
2728 argblock
2729 #ifdef STACK_GROWS_DOWNWARD
2730 = plus_constant (Pmode, argblock, crtl->args.pretend_args_size);
2731 #else
2732 = plus_constant (Pmode, argblock, -crtl->args.pretend_args_size);
2733 #endif
2734 stored_args_map = sbitmap_alloc (args_size.constant);
2735 bitmap_clear (stored_args_map);
2738 /* If we have no actual push instructions, or shouldn't use them,
2739 make space for all args right now. */
2740 else if (adjusted_args_size.var != 0)
2742 if (old_stack_level == 0)
2744 emit_stack_save (SAVE_BLOCK, &old_stack_level);
2745 old_stack_pointer_delta = stack_pointer_delta;
2746 old_pending_adj = pending_stack_adjust;
2747 pending_stack_adjust = 0;
2748 /* stack_arg_under_construction says whether a stack arg is
2749 being constructed at the old stack level. Pushing the stack
2750 gets a clean outgoing argument block. */
2751 old_stack_arg_under_construction = stack_arg_under_construction;
2752 stack_arg_under_construction = 0;
2754 argblock = push_block (ARGS_SIZE_RTX (adjusted_args_size), 0, 0);
2755 if (flag_stack_usage_info)
2756 current_function_has_unbounded_dynamic_stack_size = 1;
2758 else
2760 /* Note that we must go through the motions of allocating an argument
2761 block even if the size is zero because we may be storing args
2762 in the area reserved for register arguments, which may be part of
2763 the stack frame. */
2765 int needed = adjusted_args_size.constant;
2767 /* Store the maximum argument space used. It will be pushed by
2768 the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
2769 checking). */
2771 if (needed > crtl->outgoing_args_size)
2772 crtl->outgoing_args_size = needed;
2774 if (must_preallocate)
2776 if (ACCUMULATE_OUTGOING_ARGS)
2778 /* Since the stack pointer will never be pushed, it is
2779 possible for the evaluation of a parm to clobber
2780 something we have already written to the stack.
2781 Since most function calls on RISC machines do not use
2782 the stack, this is uncommon, but must work correctly.
2784 Therefore, we save any area of the stack that was already
2785 written and that we are using. Here we set up to do this
2786 by making a new stack usage map from the old one. The
2787 actual save will be done by store_one_arg.
2789 Another approach might be to try to reorder the argument
2790 evaluations to avoid this conflicting stack usage. */
2792 /* Since we will be writing into the entire argument area,
2793 the map must be allocated for its entire size, not just
2794 the part that is the responsibility of the caller. */
2795 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
2796 needed += reg_parm_stack_space;
2798 #ifdef ARGS_GROW_DOWNWARD
2799 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
2800 needed + 1);
2801 #else
2802 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
2803 needed);
2804 #endif
2805 free (stack_usage_map_buf);
2806 stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
2807 stack_usage_map = stack_usage_map_buf;
2809 if (initial_highest_arg_in_use)
2810 memcpy (stack_usage_map, initial_stack_usage_map,
2811 initial_highest_arg_in_use);
2813 if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
2814 memset (&stack_usage_map[initial_highest_arg_in_use], 0,
2815 (highest_outgoing_arg_in_use
2816 - initial_highest_arg_in_use));
2817 needed = 0;
2819 /* The address of the outgoing argument list must not be
2820 copied to a register here, because argblock would be left
2821 pointing to the wrong place after the call to
2822 allocate_dynamic_stack_space below. */
2824 argblock = virtual_outgoing_args_rtx;
2826 else
2828 if (inhibit_defer_pop == 0)
2830 /* Try to reuse some or all of the pending_stack_adjust
2831 to get this space. */
2832 needed
2833 = (combine_pending_stack_adjustment_and_call
2834 (unadjusted_args_size,
2835 &adjusted_args_size,
2836 preferred_unit_stack_boundary));
2838 /* combine_pending_stack_adjustment_and_call computes
2839 an adjustment before the arguments are allocated.
2840 Account for them and see whether or not the stack
2841 needs to go up or down. */
2842 needed = unadjusted_args_size - needed;
2844 if (needed < 0)
2846 /* We're releasing stack space. */
2847 /* ??? We can avoid any adjustment at all if we're
2848 already aligned. FIXME. */
2849 pending_stack_adjust = -needed;
2850 do_pending_stack_adjust ();
2851 needed = 0;
2853 else
2854 /* We need to allocate space. We'll do that in
2855 push_block below. */
2856 pending_stack_adjust = 0;
2859 /* Special case this because overhead of `push_block' in
2860 this case is non-trivial. */
2861 if (needed == 0)
2862 argblock = virtual_outgoing_args_rtx;
2863 else
2865 argblock = push_block (GEN_INT (needed), 0, 0);
2866 #ifdef ARGS_GROW_DOWNWARD
2867 argblock = plus_constant (Pmode, argblock, needed);
2868 #endif
2871 /* We only really need to call `copy_to_reg' in the case
2872 where push insns are going to be used to pass ARGBLOCK
2873 to a function call in ARGS. In that case, the stack
2874 pointer changes value from the allocation point to the
2875 call point, and hence the value of
2876 VIRTUAL_OUTGOING_ARGS_RTX changes as well. But might
2877 as well always do it. */
2878 argblock = copy_to_reg (argblock);
2883 if (ACCUMULATE_OUTGOING_ARGS)
2885 /* The save/restore code in store_one_arg handles all
2886 cases except one: a constructor call (including a C
2887 function returning a BLKmode struct) to initialize
2888 an argument. */
2889 if (stack_arg_under_construction)
2891 rtx push_size
2892 = GEN_INT (adjusted_args_size.constant
2893 + (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype
2894 : TREE_TYPE (fndecl))) ? 0
2895 : reg_parm_stack_space));
2896 if (old_stack_level == 0)
2898 emit_stack_save (SAVE_BLOCK, &old_stack_level);
2899 old_stack_pointer_delta = stack_pointer_delta;
2900 old_pending_adj = pending_stack_adjust;
2901 pending_stack_adjust = 0;
2902 /* stack_arg_under_construction says whether a stack
2903 arg is being constructed at the old stack level.
2904 Pushing the stack gets a clean outgoing argument
2905 block. */
2906 old_stack_arg_under_construction
2907 = stack_arg_under_construction;
2908 stack_arg_under_construction = 0;
2909 /* Make a new map for the new argument list. */
2910 free (stack_usage_map_buf);
2911 stack_usage_map_buf = XCNEWVEC (char, highest_outgoing_arg_in_use);
2912 stack_usage_map = stack_usage_map_buf;
2913 highest_outgoing_arg_in_use = 0;
2915 /* We can pass TRUE as the 4th argument because we just
2916 saved the stack pointer and will restore it right after
2917 the call. */
2918 allocate_dynamic_stack_space (push_size, 0,
2919 BIGGEST_ALIGNMENT, true);
2922 /* If argument evaluation might modify the stack pointer,
2923 copy the address of the argument list to a register. */
2924 for (i = 0; i < num_actuals; i++)
2925 if (args[i].pass_on_stack)
2927 argblock = copy_addr_to_reg (argblock);
2928 break;
2932 compute_argument_addresses (args, argblock, num_actuals);
2934 /* Perform stack alignment before the first push (the last arg). */
2935 if (argblock == 0
2936 && adjusted_args_size.constant > reg_parm_stack_space
2937 && adjusted_args_size.constant != unadjusted_args_size)
2939 /* When the stack adjustment is pending, we get better code
2940 by combining the adjustments. */
2941 if (pending_stack_adjust
2942 && ! inhibit_defer_pop)
2944 pending_stack_adjust
2945 = (combine_pending_stack_adjustment_and_call
2946 (unadjusted_args_size,
2947 &adjusted_args_size,
2948 preferred_unit_stack_boundary));
2949 do_pending_stack_adjust ();
2951 else if (argblock == 0)
2952 anti_adjust_stack (GEN_INT (adjusted_args_size.constant
2953 - unadjusted_args_size));
2955 /* Now that the stack is properly aligned, pops can't safely
2956 be deferred during the evaluation of the arguments. */
2957 NO_DEFER_POP;
2959 /* Record the maximum pushed stack space size. We need to delay
2960 doing it this far to take into account the optimization done
2961 by combine_pending_stack_adjustment_and_call. */
2962 if (flag_stack_usage_info
2963 && !ACCUMULATE_OUTGOING_ARGS
2964 && pass
2965 && adjusted_args_size.var == 0)
2967 int pushed = adjusted_args_size.constant + pending_stack_adjust;
2968 if (pushed > current_function_pushed_stack_size)
2969 current_function_pushed_stack_size = pushed;
2972 funexp = rtx_for_function_call (fndecl, addr);
2974 /* Figure out the register where the value, if any, will come back. */
2975 valreg = 0;
2976 if (TYPE_MODE (rettype) != VOIDmode
2977 && ! structure_value_addr)
2979 if (pcc_struct_value)
2980 valreg = hard_function_value (build_pointer_type (rettype),
2981 fndecl, NULL, (pass == 0));
2982 else
2983 valreg = hard_function_value (rettype, fndecl, fntype,
2984 (pass == 0));
2986 /* If VALREG is a PARALLEL whose first member has a zero
2987 offset, use that. This is for targets such as m68k that
2988 return the same value in multiple places. */
2989 if (GET_CODE (valreg) == PARALLEL)
2991 rtx elem = XVECEXP (valreg, 0, 0);
2992 rtx where = XEXP (elem, 0);
2993 rtx offset = XEXP (elem, 1);
2994 if (offset == const0_rtx
2995 && GET_MODE (where) == GET_MODE (valreg))
2996 valreg = where;
3000 /* Precompute all register parameters. It isn't safe to compute anything
3001 once we have started filling any specific hard regs. */
3002 precompute_register_parameters (num_actuals, args, &reg_parm_seen);
3004 if (CALL_EXPR_STATIC_CHAIN (exp))
3005 static_chain_value = expand_normal (CALL_EXPR_STATIC_CHAIN (exp));
3006 else
3007 static_chain_value = 0;
3009 #ifdef REG_PARM_STACK_SPACE
3010 /* Save the fixed argument area if it's part of the caller's frame and
3011 is clobbered by argument setup for this call. */
3012 if (ACCUMULATE_OUTGOING_ARGS && pass)
3013 save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
3014 &low_to_save, &high_to_save);
3015 #endif
3017 /* Now store (and compute if necessary) all non-register parms.
3018 These come before register parms, since they can require block-moves,
3019 which could clobber the registers used for register parms.
3020 Parms which have partial registers are not stored here,
3021 but we do preallocate space here if they want that. */
3023 for (i = 0; i < num_actuals; i++)
3025 if (args[i].reg == 0 || args[i].pass_on_stack)
3027 rtx_insn *before_arg = get_last_insn ();
3029 /* We don't allow passing huge (> 2^30 B) arguments
3030 by value. It would cause an overflow later on. */
3031 if (adjusted_args_size.constant
3032 >= (1 << (HOST_BITS_PER_INT - 2)))
3034 sorry ("passing too large argument on stack");
3035 continue;
3038 if (store_one_arg (&args[i], argblock, flags,
3039 adjusted_args_size.var != 0,
3040 reg_parm_stack_space)
3041 || (pass == 0
3042 && check_sibcall_argument_overlap (before_arg,
3043 &args[i], 1)))
3044 sibcall_failure = 1;
3047 if (args[i].stack)
3048 call_fusage
3049 = gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args[i].tree_value)),
3050 gen_rtx_USE (VOIDmode, args[i].stack),
3051 call_fusage);
3054 /* If we have a parm that is passed in registers but not in memory
3055 and whose alignment does not permit a direct copy into registers,
3056 make a group of pseudos that correspond to each register that we
3057 will later fill. */
3058 if (STRICT_ALIGNMENT)
3059 store_unaligned_arguments_into_pseudos (args, num_actuals);
3061 /* Now store any partially-in-registers parm.
3062 This is the last place a block-move can happen. */
3063 if (reg_parm_seen)
3064 for (i = 0; i < num_actuals; i++)
3065 if (args[i].partial != 0 && ! args[i].pass_on_stack)
3067 rtx_insn *before_arg = get_last_insn ();
3069 if (store_one_arg (&args[i], argblock, flags,
3070 adjusted_args_size.var != 0,
3071 reg_parm_stack_space)
3072 || (pass == 0
3073 && check_sibcall_argument_overlap (before_arg,
3074 &args[i], 1)))
3075 sibcall_failure = 1;
3078 /* If register arguments require space on the stack and stack space
3079 was not preallocated, allocate stack space here for arguments
3080 passed in registers. */
3081 if (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))
3082 && !ACCUMULATE_OUTGOING_ARGS
3083 && must_preallocate == 0 && reg_parm_stack_space > 0)
3084 anti_adjust_stack (GEN_INT (reg_parm_stack_space));
3086 /* Pass the function the address in which to return a
3087 structure value. */
3088 if (pass != 0 && structure_value_addr && ! structure_value_addr_parm)
3090 structure_value_addr
3091 = convert_memory_address (Pmode, structure_value_addr);
3092 emit_move_insn (struct_value,
3093 force_reg (Pmode,
3094 force_operand (structure_value_addr,
3095 NULL_RTX)));
3097 if (REG_P (struct_value))
3098 use_reg (&call_fusage, struct_value);
3101 after_args = get_last_insn ();
3102 funexp = prepare_call_address (fndecl, funexp, static_chain_value,
3103 &call_fusage, reg_parm_seen, pass == 0);
3105 load_register_parameters (args, num_actuals, &call_fusage, flags,
3106 pass == 0, &sibcall_failure);
3108 /* Save a pointer to the last insn before the call, so that we can
3109 later safely search backwards to find the CALL_INSN. */
3110 before_call = get_last_insn ();
3112 /* Set up next argument register. For sibling calls on machines
3113 with register windows this should be the incoming register. */
3114 if (pass == 0)
3115 next_arg_reg = targetm.calls.function_incoming_arg (args_so_far,
3116 VOIDmode,
3117 void_type_node,
3118 true);
3119 else
3120 next_arg_reg = targetm.calls.function_arg (args_so_far,
3121 VOIDmode, void_type_node,
3122 true);
3124 if (pass == 1 && (return_flags & ERF_RETURNS_ARG))
3126 int arg_nr = return_flags & ERF_RETURN_ARG_MASK;
3127 arg_nr = num_actuals - arg_nr - 1;
3128 if (arg_nr >= 0
3129 && arg_nr < num_actuals
3130 && args[arg_nr].reg
3131 && valreg
3132 && REG_P (valreg)
3133 && GET_MODE (args[arg_nr].reg) == GET_MODE (valreg))
3134 call_fusage
3135 = gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args[arg_nr].tree_value)),
3136 gen_rtx_SET (VOIDmode, valreg, args[arg_nr].reg),
3137 call_fusage);
3139 /* All arguments and registers used for the call must be set up by
3140 now! */
3142 /* Stack must be properly aligned now. */
3143 gcc_assert (!pass
3144 || !(stack_pointer_delta % preferred_unit_stack_boundary));
3146 /* Generate the actual call instruction. */
3147 emit_call_1 (funexp, exp, fndecl, funtype, unadjusted_args_size,
3148 adjusted_args_size.constant, struct_value_size,
3149 next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
3150 flags, args_so_far);
3152 if (flag_use_caller_save)
3154 rtx_call_insn *last;
3155 rtx datum = NULL_RTX;
3156 if (fndecl != NULL_TREE)
3158 datum = XEXP (DECL_RTL (fndecl), 0);
3159 gcc_assert (datum != NULL_RTX
3160 && GET_CODE (datum) == SYMBOL_REF);
3162 last = last_call_insn ();
3163 add_reg_note (last, REG_CALL_DECL, datum);
3166 /* If the call setup or the call itself overlaps with anything
3167 of the argument setup we probably clobbered our call address.
3168 In that case we can't do sibcalls. */
3169 if (pass == 0
3170 && check_sibcall_argument_overlap (after_args, 0, 0))
3171 sibcall_failure = 1;
3173 /* If a non-BLKmode value is returned at the most significant end
3174 of a register, shift the register right by the appropriate amount
3175 and update VALREG accordingly. BLKmode values are handled by the
3176 group load/store machinery below. */
3177 if (!structure_value_addr
3178 && !pcc_struct_value
3179 && TYPE_MODE (rettype) != VOIDmode
3180 && TYPE_MODE (rettype) != BLKmode
3181 && REG_P (valreg)
3182 && targetm.calls.return_in_msb (rettype))
3184 if (shift_return_value (TYPE_MODE (rettype), false, valreg))
3185 sibcall_failure = 1;
3186 valreg = gen_rtx_REG (TYPE_MODE (rettype), REGNO (valreg));
3189 if (pass && (flags & ECF_MALLOC))
3191 rtx temp = gen_reg_rtx (GET_MODE (valreg));
3192 rtx_insn *last, *insns;
3194 /* The return value from a malloc-like function is a pointer. */
3195 if (TREE_CODE (rettype) == POINTER_TYPE)
3196 mark_reg_pointer (temp, MALLOC_ABI_ALIGNMENT);
3198 emit_move_insn (temp, valreg);
3200 /* The return value from a malloc-like function can not alias
3201 anything else. */
3202 last = get_last_insn ();
3203 add_reg_note (last, REG_NOALIAS, temp);
3205 /* Write out the sequence. */
3206 insns = get_insns ();
3207 end_sequence ();
3208 emit_insn (insns);
3209 valreg = temp;
3212 /* For calls to `setjmp', etc., inform
3213 function.c:setjmp_warnings that it should complain if
3214 nonvolatile values are live. For functions that cannot
3215 return, inform flow that control does not fall through. */
3217 if ((flags & ECF_NORETURN) || pass == 0)
3219 /* The barrier must be emitted
3220 immediately after the CALL_INSN. Some ports emit more
3221 than just a CALL_INSN above, so we must search for it here. */
3223 rtx_insn *last = get_last_insn ();
3224 while (!CALL_P (last))
3226 last = PREV_INSN (last);
3227 /* There was no CALL_INSN? */
3228 gcc_assert (last != before_call);
3231 emit_barrier_after (last);
3233 /* Stack adjustments after a noreturn call are dead code.
3234 However when NO_DEFER_POP is in effect, we must preserve
3235 stack_pointer_delta. */
3236 if (inhibit_defer_pop == 0)
3238 stack_pointer_delta = old_stack_allocated;
3239 pending_stack_adjust = 0;
3243 /* If value type not void, return an rtx for the value. */
3245 if (TYPE_MODE (rettype) == VOIDmode
3246 || ignore)
3247 target = const0_rtx;
3248 else if (structure_value_addr)
3250 if (target == 0 || !MEM_P (target))
3252 target
3253 = gen_rtx_MEM (TYPE_MODE (rettype),
3254 memory_address (TYPE_MODE (rettype),
3255 structure_value_addr));
3256 set_mem_attributes (target, rettype, 1);
3259 else if (pcc_struct_value)
3261 /* This is the special C++ case where we need to
3262 know what the true target was. We take care to
3263 never use this value more than once in one expression. */
3264 target = gen_rtx_MEM (TYPE_MODE (rettype),
3265 copy_to_reg (valreg));
3266 set_mem_attributes (target, rettype, 1);
3268 /* Handle calls that return values in multiple non-contiguous locations.
3269 The Irix 6 ABI has examples of this. */
3270 else if (GET_CODE (valreg) == PARALLEL)
3272 if (target == 0)
3273 target = emit_group_move_into_temps (valreg);
3274 else if (rtx_equal_p (target, valreg))
3276 else if (GET_CODE (target) == PARALLEL)
3277 /* Handle the result of a emit_group_move_into_temps
3278 call in the previous pass. */
3279 emit_group_move (target, valreg);
3280 else
3281 emit_group_store (target, valreg, rettype,
3282 int_size_in_bytes (rettype));
3284 else if (target
3285 && GET_MODE (target) == TYPE_MODE (rettype)
3286 && GET_MODE (target) == GET_MODE (valreg))
3288 bool may_overlap = false;
3290 /* We have to copy a return value in a CLASS_LIKELY_SPILLED hard
3291 reg to a plain register. */
3292 if (!REG_P (target) || HARD_REGISTER_P (target))
3293 valreg = avoid_likely_spilled_reg (valreg);
3295 /* If TARGET is a MEM in the argument area, and we have
3296 saved part of the argument area, then we can't store
3297 directly into TARGET as it may get overwritten when we
3298 restore the argument save area below. Don't work too
3299 hard though and simply force TARGET to a register if it
3300 is a MEM; the optimizer is quite likely to sort it out. */
3301 if (ACCUMULATE_OUTGOING_ARGS && pass && MEM_P (target))
3302 for (i = 0; i < num_actuals; i++)
3303 if (args[i].save_area)
3305 may_overlap = true;
3306 break;
3309 if (may_overlap)
3310 target = copy_to_reg (valreg);
3311 else
3313 /* TARGET and VALREG cannot be equal at this point
3314 because the latter would not have
3315 REG_FUNCTION_VALUE_P true, while the former would if
3316 it were referring to the same register.
3318 If they refer to the same register, this move will be
3319 a no-op, except when function inlining is being
3320 done. */
3321 emit_move_insn (target, valreg);
3323 /* If we are setting a MEM, this code must be executed.
3324 Since it is emitted after the call insn, sibcall
3325 optimization cannot be performed in that case. */
3326 if (MEM_P (target))
3327 sibcall_failure = 1;
3330 else
3331 target = copy_to_reg (avoid_likely_spilled_reg (valreg));
3333 /* If we promoted this return value, make the proper SUBREG.
3334 TARGET might be const0_rtx here, so be careful. */
3335 if (REG_P (target)
3336 && TYPE_MODE (rettype) != BLKmode
3337 && GET_MODE (target) != TYPE_MODE (rettype))
3339 tree type = rettype;
3340 int unsignedp = TYPE_UNSIGNED (type);
3341 int offset = 0;
3342 enum machine_mode pmode;
3344 /* Ensure we promote as expected, and get the new unsignedness. */
3345 pmode = promote_function_mode (type, TYPE_MODE (type), &unsignedp,
3346 funtype, 1);
3347 gcc_assert (GET_MODE (target) == pmode);
3349 if ((WORDS_BIG_ENDIAN || BYTES_BIG_ENDIAN)
3350 && (GET_MODE_SIZE (GET_MODE (target))
3351 > GET_MODE_SIZE (TYPE_MODE (type))))
3353 offset = GET_MODE_SIZE (GET_MODE (target))
3354 - GET_MODE_SIZE (TYPE_MODE (type));
3355 if (! BYTES_BIG_ENDIAN)
3356 offset = (offset / UNITS_PER_WORD) * UNITS_PER_WORD;
3357 else if (! WORDS_BIG_ENDIAN)
3358 offset %= UNITS_PER_WORD;
3361 target = gen_rtx_SUBREG (TYPE_MODE (type), target, offset);
3362 SUBREG_PROMOTED_VAR_P (target) = 1;
3363 SUBREG_PROMOTED_SET (target, unsignedp);
3366 /* If size of args is variable or this was a constructor call for a stack
3367 argument, restore saved stack-pointer value. */
3369 if (old_stack_level)
3371 rtx_insn *prev = get_last_insn ();
3373 emit_stack_restore (SAVE_BLOCK, old_stack_level);
3374 stack_pointer_delta = old_stack_pointer_delta;
3376 fixup_args_size_notes (prev, get_last_insn (), stack_pointer_delta);
3378 pending_stack_adjust = old_pending_adj;
3379 old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
3380 stack_arg_under_construction = old_stack_arg_under_construction;
3381 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3382 stack_usage_map = initial_stack_usage_map;
3383 sibcall_failure = 1;
3385 else if (ACCUMULATE_OUTGOING_ARGS && pass)
3387 #ifdef REG_PARM_STACK_SPACE
3388 if (save_area)
3389 restore_fixed_argument_area (save_area, argblock,
3390 high_to_save, low_to_save);
3391 #endif
3393 /* If we saved any argument areas, restore them. */
3394 for (i = 0; i < num_actuals; i++)
3395 if (args[i].save_area)
3397 enum machine_mode save_mode = GET_MODE (args[i].save_area);
3398 rtx stack_area
3399 = gen_rtx_MEM (save_mode,
3400 memory_address (save_mode,
3401 XEXP (args[i].stack_slot, 0)));
3403 if (save_mode != BLKmode)
3404 emit_move_insn (stack_area, args[i].save_area);
3405 else
3406 emit_block_move (stack_area, args[i].save_area,
3407 GEN_INT (args[i].locate.size.constant),
3408 BLOCK_OP_CALL_PARM);
3411 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3412 stack_usage_map = initial_stack_usage_map;
3415 /* If this was alloca, record the new stack level for nonlocal gotos.
3416 Check for the handler slots since we might not have a save area
3417 for non-local gotos. */
3419 if ((flags & ECF_MAY_BE_ALLOCA) && cfun->nonlocal_goto_save_area != 0)
3420 update_nonlocal_goto_save_area ();
3422 /* Free up storage we no longer need. */
3423 for (i = 0; i < num_actuals; ++i)
3424 free (args[i].aligned_regs);
3426 insns = get_insns ();
3427 end_sequence ();
3429 if (pass == 0)
3431 tail_call_insns = insns;
3433 /* Restore the pending stack adjustment now that we have
3434 finished generating the sibling call sequence. */
3436 restore_pending_stack_adjust (&save);
3438 /* Prepare arg structure for next iteration. */
3439 for (i = 0; i < num_actuals; i++)
3441 args[i].value = 0;
3442 args[i].aligned_regs = 0;
3443 args[i].stack = 0;
3446 sbitmap_free (stored_args_map);
3447 internal_arg_pointer_exp_state.scan_start = NULL;
3448 internal_arg_pointer_exp_state.cache.release ();
3450 else
3452 normal_call_insns = insns;
3454 /* Verify that we've deallocated all the stack we used. */
3455 gcc_assert ((flags & ECF_NORETURN)
3456 || (old_stack_allocated
3457 == stack_pointer_delta - pending_stack_adjust));
3460 /* If something prevents making this a sibling call,
3461 zero out the sequence. */
3462 if (sibcall_failure)
3463 tail_call_insns = NULL;
3464 else
3465 break;
3468 /* If tail call production succeeded, we need to remove REG_EQUIV notes on
3469 arguments too, as argument area is now clobbered by the call. */
3470 if (tail_call_insns)
3472 emit_insn (tail_call_insns);
3473 crtl->tail_call_emit = true;
3475 else
3476 emit_insn (normal_call_insns);
3478 currently_expanding_call--;
3480 free (stack_usage_map_buf);
3482 return target;
3485 /* A sibling call sequence invalidates any REG_EQUIV notes made for
3486 this function's incoming arguments.
3488 At the start of RTL generation we know the only REG_EQUIV notes
3489 in the rtl chain are those for incoming arguments, so we can look
3490 for REG_EQUIV notes between the start of the function and the
3491 NOTE_INSN_FUNCTION_BEG.
3493 This is (slight) overkill. We could keep track of the highest
3494 argument we clobber and be more selective in removing notes, but it
3495 does not seem to be worth the effort. */
3497 void
3498 fixup_tail_calls (void)
3500 rtx_insn *insn;
3502 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3504 rtx note;
3506 /* There are never REG_EQUIV notes for the incoming arguments
3507 after the NOTE_INSN_FUNCTION_BEG note, so stop if we see it. */
3508 if (NOTE_P (insn)
3509 && NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG)
3510 break;
3512 note = find_reg_note (insn, REG_EQUIV, 0);
3513 if (note)
3514 remove_note (insn, note);
3515 note = find_reg_note (insn, REG_EQUIV, 0);
3516 gcc_assert (!note);
3520 /* Traverse a list of TYPES and expand all complex types into their
3521 components. */
3522 static tree
3523 split_complex_types (tree types)
3525 tree p;
3527 /* Before allocating memory, check for the common case of no complex. */
3528 for (p = types; p; p = TREE_CHAIN (p))
3530 tree type = TREE_VALUE (p);
3531 if (TREE_CODE (type) == COMPLEX_TYPE
3532 && targetm.calls.split_complex_arg (type))
3533 goto found;
3535 return types;
3537 found:
3538 types = copy_list (types);
3540 for (p = types; p; p = TREE_CHAIN (p))
3542 tree complex_type = TREE_VALUE (p);
3544 if (TREE_CODE (complex_type) == COMPLEX_TYPE
3545 && targetm.calls.split_complex_arg (complex_type))
3547 tree next, imag;
3549 /* Rewrite complex type with component type. */
3550 TREE_VALUE (p) = TREE_TYPE (complex_type);
3551 next = TREE_CHAIN (p);
3553 /* Add another component type for the imaginary part. */
3554 imag = build_tree_list (NULL_TREE, TREE_VALUE (p));
3555 TREE_CHAIN (p) = imag;
3556 TREE_CHAIN (imag) = next;
3558 /* Skip the newly created node. */
3559 p = TREE_CHAIN (p);
3563 return types;
3566 /* Output a library call to function FUN (a SYMBOL_REF rtx).
3567 The RETVAL parameter specifies whether return value needs to be saved, other
3568 parameters are documented in the emit_library_call function below. */
3570 static rtx
3571 emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
3572 enum libcall_type fn_type,
3573 enum machine_mode outmode, int nargs, va_list p)
3575 /* Total size in bytes of all the stack-parms scanned so far. */
3576 struct args_size args_size;
3577 /* Size of arguments before any adjustments (such as rounding). */
3578 struct args_size original_args_size;
3579 int argnum;
3580 rtx fun;
3581 /* Todo, choose the correct decl type of orgfun. Sadly this information
3582 isn't present here, so we default to native calling abi here. */
3583 tree fndecl ATTRIBUTE_UNUSED = NULL_TREE; /* library calls default to host calling abi ? */
3584 tree fntype ATTRIBUTE_UNUSED = NULL_TREE; /* library calls default to host calling abi ? */
3585 int count;
3586 rtx argblock = 0;
3587 CUMULATIVE_ARGS args_so_far_v;
3588 cumulative_args_t args_so_far;
3589 struct arg
3591 rtx value;
3592 enum machine_mode mode;
3593 rtx reg;
3594 int partial;
3595 struct locate_and_pad_arg_data locate;
3596 rtx save_area;
3598 struct arg *argvec;
3599 int old_inhibit_defer_pop = inhibit_defer_pop;
3600 rtx call_fusage = 0;
3601 rtx mem_value = 0;
3602 rtx valreg;
3603 int pcc_struct_value = 0;
3604 int struct_value_size = 0;
3605 int flags;
3606 int reg_parm_stack_space = 0;
3607 int needed;
3608 rtx_insn *before_call;
3609 tree tfom; /* type_for_mode (outmode, 0) */
3611 #ifdef REG_PARM_STACK_SPACE
3612 /* Define the boundary of the register parm stack space that needs to be
3613 save, if any. */
3614 int low_to_save = 0, high_to_save = 0;
3615 rtx save_area = 0; /* Place that it is saved. */
3616 #endif
3618 /* Size of the stack reserved for parameter registers. */
3619 int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
3620 char *initial_stack_usage_map = stack_usage_map;
3621 char *stack_usage_map_buf = NULL;
3623 rtx struct_value = targetm.calls.struct_value_rtx (0, 0);
3625 #ifdef REG_PARM_STACK_SPACE
3626 reg_parm_stack_space = REG_PARM_STACK_SPACE ((tree) 0);
3627 #endif
3629 /* By default, library functions can not throw. */
3630 flags = ECF_NOTHROW;
3632 switch (fn_type)
3634 case LCT_NORMAL:
3635 break;
3636 case LCT_CONST:
3637 flags |= ECF_CONST;
3638 break;
3639 case LCT_PURE:
3640 flags |= ECF_PURE;
3641 break;
3642 case LCT_NORETURN:
3643 flags |= ECF_NORETURN;
3644 break;
3645 case LCT_THROW:
3646 flags = ECF_NORETURN;
3647 break;
3648 case LCT_RETURNS_TWICE:
3649 flags = ECF_RETURNS_TWICE;
3650 break;
3652 fun = orgfun;
3654 /* Ensure current function's preferred stack boundary is at least
3655 what we need. */
3656 if (crtl->preferred_stack_boundary < PREFERRED_STACK_BOUNDARY)
3657 crtl->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
3659 /* If this kind of value comes back in memory,
3660 decide where in memory it should come back. */
3661 if (outmode != VOIDmode)
3663 tfom = lang_hooks.types.type_for_mode (outmode, 0);
3664 if (aggregate_value_p (tfom, 0))
3666 #ifdef PCC_STATIC_STRUCT_RETURN
3667 rtx pointer_reg
3668 = hard_function_value (build_pointer_type (tfom), 0, 0, 0);
3669 mem_value = gen_rtx_MEM (outmode, pointer_reg);
3670 pcc_struct_value = 1;
3671 if (value == 0)
3672 value = gen_reg_rtx (outmode);
3673 #else /* not PCC_STATIC_STRUCT_RETURN */
3674 struct_value_size = GET_MODE_SIZE (outmode);
3675 if (value != 0 && MEM_P (value))
3676 mem_value = value;
3677 else
3678 mem_value = assign_temp (tfom, 1, 1);
3679 #endif
3680 /* This call returns a big structure. */
3681 flags &= ~(ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
3684 else
3685 tfom = void_type_node;
3687 /* ??? Unfinished: must pass the memory address as an argument. */
3689 /* Copy all the libcall-arguments out of the varargs data
3690 and into a vector ARGVEC.
3692 Compute how to pass each argument. We only support a very small subset
3693 of the full argument passing conventions to limit complexity here since
3694 library functions shouldn't have many args. */
3696 argvec = XALLOCAVEC (struct arg, nargs + 1);
3697 memset (argvec, 0, (nargs + 1) * sizeof (struct arg));
3699 #ifdef INIT_CUMULATIVE_LIBCALL_ARGS
3700 INIT_CUMULATIVE_LIBCALL_ARGS (args_so_far_v, outmode, fun);
3701 #else
3702 INIT_CUMULATIVE_ARGS (args_so_far_v, NULL_TREE, fun, 0, nargs);
3703 #endif
3704 args_so_far = pack_cumulative_args (&args_so_far_v);
3706 args_size.constant = 0;
3707 args_size.var = 0;
3709 count = 0;
3711 push_temp_slots ();
3713 /* If there's a structure value address to be passed,
3714 either pass it in the special place, or pass it as an extra argument. */
3715 if (mem_value && struct_value == 0 && ! pcc_struct_value)
3717 rtx addr = XEXP (mem_value, 0);
3719 nargs++;
3721 /* Make sure it is a reasonable operand for a move or push insn. */
3722 if (!REG_P (addr) && !MEM_P (addr)
3723 && !(CONSTANT_P (addr)
3724 && targetm.legitimate_constant_p (Pmode, addr)))
3725 addr = force_operand (addr, NULL_RTX);
3727 argvec[count].value = addr;
3728 argvec[count].mode = Pmode;
3729 argvec[count].partial = 0;
3731 argvec[count].reg = targetm.calls.function_arg (args_so_far,
3732 Pmode, NULL_TREE, true);
3733 gcc_assert (targetm.calls.arg_partial_bytes (args_so_far, Pmode,
3734 NULL_TREE, 1) == 0);
3736 locate_and_pad_parm (Pmode, NULL_TREE,
3737 #ifdef STACK_PARMS_IN_REG_PARM_AREA
3739 #else
3740 argvec[count].reg != 0,
3741 #endif
3742 reg_parm_stack_space, 0,
3743 NULL_TREE, &args_size, &argvec[count].locate);
3745 if (argvec[count].reg == 0 || argvec[count].partial != 0
3746 || reg_parm_stack_space > 0)
3747 args_size.constant += argvec[count].locate.size.constant;
3749 targetm.calls.function_arg_advance (args_so_far, Pmode, (tree) 0, true);
3751 count++;
3754 for (; count < nargs; count++)
3756 rtx val = va_arg (p, rtx);
3757 enum machine_mode mode = (enum machine_mode) va_arg (p, int);
3758 int unsigned_p = 0;
3760 /* We cannot convert the arg value to the mode the library wants here;
3761 must do it earlier where we know the signedness of the arg. */
3762 gcc_assert (mode != BLKmode
3763 && (GET_MODE (val) == mode || GET_MODE (val) == VOIDmode));
3765 /* Make sure it is a reasonable operand for a move or push insn. */
3766 if (!REG_P (val) && !MEM_P (val)
3767 && !(CONSTANT_P (val) && targetm.legitimate_constant_p (mode, val)))
3768 val = force_operand (val, NULL_RTX);
3770 if (pass_by_reference (&args_so_far_v, mode, NULL_TREE, 1))
3772 rtx slot;
3773 int must_copy
3774 = !reference_callee_copied (&args_so_far_v, mode, NULL_TREE, 1);
3776 /* If this was a CONST function, it is now PURE since it now
3777 reads memory. */
3778 if (flags & ECF_CONST)
3780 flags &= ~ECF_CONST;
3781 flags |= ECF_PURE;
3784 if (MEM_P (val) && !must_copy)
3786 tree val_expr = MEM_EXPR (val);
3787 if (val_expr)
3788 mark_addressable (val_expr);
3789 slot = val;
3791 else
3793 slot = assign_temp (lang_hooks.types.type_for_mode (mode, 0),
3794 1, 1);
3795 emit_move_insn (slot, val);
3798 call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
3799 gen_rtx_USE (VOIDmode, slot),
3800 call_fusage);
3801 if (must_copy)
3802 call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
3803 gen_rtx_CLOBBER (VOIDmode,
3804 slot),
3805 call_fusage);
3807 mode = Pmode;
3808 val = force_operand (XEXP (slot, 0), NULL_RTX);
3811 mode = promote_function_mode (NULL_TREE, mode, &unsigned_p, NULL_TREE, 0);
3812 argvec[count].mode = mode;
3813 argvec[count].value = convert_modes (mode, GET_MODE (val), val, unsigned_p);
3814 argvec[count].reg = targetm.calls.function_arg (args_so_far, mode,
3815 NULL_TREE, true);
3817 argvec[count].partial
3818 = targetm.calls.arg_partial_bytes (args_so_far, mode, NULL_TREE, 1);
3820 if (argvec[count].reg == 0
3821 || argvec[count].partial != 0
3822 || reg_parm_stack_space > 0)
3824 locate_and_pad_parm (mode, NULL_TREE,
3825 #ifdef STACK_PARMS_IN_REG_PARM_AREA
3827 #else
3828 argvec[count].reg != 0,
3829 #endif
3830 reg_parm_stack_space, argvec[count].partial,
3831 NULL_TREE, &args_size, &argvec[count].locate);
3832 args_size.constant += argvec[count].locate.size.constant;
3833 gcc_assert (!argvec[count].locate.size.var);
3835 #ifdef BLOCK_REG_PADDING
3836 else
3837 /* The argument is passed entirely in registers. See at which
3838 end it should be padded. */
3839 argvec[count].locate.where_pad =
3840 BLOCK_REG_PADDING (mode, NULL_TREE,
3841 GET_MODE_SIZE (mode) <= UNITS_PER_WORD);
3842 #endif
3844 targetm.calls.function_arg_advance (args_so_far, mode, (tree) 0, true);
3847 /* If this machine requires an external definition for library
3848 functions, write one out. */
3849 assemble_external_libcall (fun);
3851 original_args_size = args_size;
3852 args_size.constant = (((args_size.constant
3853 + stack_pointer_delta
3854 + STACK_BYTES - 1)
3855 / STACK_BYTES
3856 * STACK_BYTES)
3857 - stack_pointer_delta);
3859 args_size.constant = MAX (args_size.constant,
3860 reg_parm_stack_space);
3862 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
3863 args_size.constant -= reg_parm_stack_space;
3865 if (args_size.constant > crtl->outgoing_args_size)
3866 crtl->outgoing_args_size = args_size.constant;
3868 if (flag_stack_usage_info && !ACCUMULATE_OUTGOING_ARGS)
3870 int pushed = args_size.constant + pending_stack_adjust;
3871 if (pushed > current_function_pushed_stack_size)
3872 current_function_pushed_stack_size = pushed;
3875 if (ACCUMULATE_OUTGOING_ARGS)
3877 /* Since the stack pointer will never be pushed, it is possible for
3878 the evaluation of a parm to clobber something we have already
3879 written to the stack. Since most function calls on RISC machines
3880 do not use the stack, this is uncommon, but must work correctly.
3882 Therefore, we save any area of the stack that was already written
3883 and that we are using. Here we set up to do this by making a new
3884 stack usage map from the old one.
3886 Another approach might be to try to reorder the argument
3887 evaluations to avoid this conflicting stack usage. */
3889 needed = args_size.constant;
3891 /* Since we will be writing into the entire argument area, the
3892 map must be allocated for its entire size, not just the part that
3893 is the responsibility of the caller. */
3894 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
3895 needed += reg_parm_stack_space;
3897 #ifdef ARGS_GROW_DOWNWARD
3898 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
3899 needed + 1);
3900 #else
3901 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
3902 needed);
3903 #endif
3904 stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
3905 stack_usage_map = stack_usage_map_buf;
3907 if (initial_highest_arg_in_use)
3908 memcpy (stack_usage_map, initial_stack_usage_map,
3909 initial_highest_arg_in_use);
3911 if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
3912 memset (&stack_usage_map[initial_highest_arg_in_use], 0,
3913 highest_outgoing_arg_in_use - initial_highest_arg_in_use);
3914 needed = 0;
3916 /* We must be careful to use virtual regs before they're instantiated,
3917 and real regs afterwards. Loop optimization, for example, can create
3918 new libcalls after we've instantiated the virtual regs, and if we
3919 use virtuals anyway, they won't match the rtl patterns. */
3921 if (virtuals_instantiated)
3922 argblock = plus_constant (Pmode, stack_pointer_rtx,
3923 STACK_POINTER_OFFSET);
3924 else
3925 argblock = virtual_outgoing_args_rtx;
3927 else
3929 if (!PUSH_ARGS)
3930 argblock = push_block (GEN_INT (args_size.constant), 0, 0);
3933 /* We push args individually in reverse order, perform stack alignment
3934 before the first push (the last arg). */
3935 if (argblock == 0)
3936 anti_adjust_stack (GEN_INT (args_size.constant
3937 - original_args_size.constant));
3939 argnum = nargs - 1;
3941 #ifdef REG_PARM_STACK_SPACE
3942 if (ACCUMULATE_OUTGOING_ARGS)
3944 /* The argument list is the property of the called routine and it
3945 may clobber it. If the fixed area has been used for previous
3946 parameters, we must save and restore it. */
3947 save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
3948 &low_to_save, &high_to_save);
3950 #endif
3952 /* Push the args that need to be pushed. */
3954 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
3955 are to be pushed. */
3956 for (count = 0; count < nargs; count++, argnum--)
3958 enum machine_mode mode = argvec[argnum].mode;
3959 rtx val = argvec[argnum].value;
3960 rtx reg = argvec[argnum].reg;
3961 int partial = argvec[argnum].partial;
3962 unsigned int parm_align = argvec[argnum].locate.boundary;
3963 int lower_bound = 0, upper_bound = 0, i;
3965 if (! (reg != 0 && partial == 0))
3967 rtx use;
3969 if (ACCUMULATE_OUTGOING_ARGS)
3971 /* If this is being stored into a pre-allocated, fixed-size,
3972 stack area, save any previous data at that location. */
3974 #ifdef ARGS_GROW_DOWNWARD
3975 /* stack_slot is negative, but we want to index stack_usage_map
3976 with positive values. */
3977 upper_bound = -argvec[argnum].locate.slot_offset.constant + 1;
3978 lower_bound = upper_bound - argvec[argnum].locate.size.constant;
3979 #else
3980 lower_bound = argvec[argnum].locate.slot_offset.constant;
3981 upper_bound = lower_bound + argvec[argnum].locate.size.constant;
3982 #endif
3984 i = lower_bound;
3985 /* Don't worry about things in the fixed argument area;
3986 it has already been saved. */
3987 if (i < reg_parm_stack_space)
3988 i = reg_parm_stack_space;
3989 while (i < upper_bound && stack_usage_map[i] == 0)
3990 i++;
3992 if (i < upper_bound)
3994 /* We need to make a save area. */
3995 unsigned int size
3996 = argvec[argnum].locate.size.constant * BITS_PER_UNIT;
3997 enum machine_mode save_mode
3998 = mode_for_size (size, MODE_INT, 1);
3999 rtx adr
4000 = plus_constant (Pmode, argblock,
4001 argvec[argnum].locate.offset.constant);
4002 rtx stack_area
4003 = gen_rtx_MEM (save_mode, memory_address (save_mode, adr));
4005 if (save_mode == BLKmode)
4007 argvec[argnum].save_area
4008 = assign_stack_temp (BLKmode,
4009 argvec[argnum].locate.size.constant
4012 emit_block_move (validize_mem
4013 (copy_rtx (argvec[argnum].save_area)),
4014 stack_area,
4015 GEN_INT (argvec[argnum].locate.size.constant),
4016 BLOCK_OP_CALL_PARM);
4018 else
4020 argvec[argnum].save_area = gen_reg_rtx (save_mode);
4022 emit_move_insn (argvec[argnum].save_area, stack_area);
4027 emit_push_insn (val, mode, NULL_TREE, NULL_RTX, parm_align,
4028 partial, reg, 0, argblock,
4029 GEN_INT (argvec[argnum].locate.offset.constant),
4030 reg_parm_stack_space,
4031 ARGS_SIZE_RTX (argvec[argnum].locate.alignment_pad));
4033 /* Now mark the segment we just used. */
4034 if (ACCUMULATE_OUTGOING_ARGS)
4035 for (i = lower_bound; i < upper_bound; i++)
4036 stack_usage_map[i] = 1;
4038 NO_DEFER_POP;
4040 /* Indicate argument access so that alias.c knows that these
4041 values are live. */
4042 if (argblock)
4043 use = plus_constant (Pmode, argblock,
4044 argvec[argnum].locate.offset.constant);
4045 else
4046 /* When arguments are pushed, trying to tell alias.c where
4047 exactly this argument is won't work, because the
4048 auto-increment causes confusion. So we merely indicate
4049 that we access something with a known mode somewhere on
4050 the stack. */
4051 use = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
4052 gen_rtx_SCRATCH (Pmode));
4053 use = gen_rtx_MEM (argvec[argnum].mode, use);
4054 use = gen_rtx_USE (VOIDmode, use);
4055 call_fusage = gen_rtx_EXPR_LIST (VOIDmode, use, call_fusage);
4059 argnum = nargs - 1;
4061 fun = prepare_call_address (NULL, fun, NULL, &call_fusage, 0, 0);
4063 /* Now load any reg parms into their regs. */
4065 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
4066 are to be pushed. */
4067 for (count = 0; count < nargs; count++, argnum--)
4069 enum machine_mode mode = argvec[argnum].mode;
4070 rtx val = argvec[argnum].value;
4071 rtx reg = argvec[argnum].reg;
4072 int partial = argvec[argnum].partial;
4073 #ifdef BLOCK_REG_PADDING
4074 int size = 0;
4075 #endif
4077 /* Handle calls that pass values in multiple non-contiguous
4078 locations. The PA64 has examples of this for library calls. */
4079 if (reg != 0 && GET_CODE (reg) == PARALLEL)
4080 emit_group_load (reg, val, NULL_TREE, GET_MODE_SIZE (mode));
4081 else if (reg != 0 && partial == 0)
4083 emit_move_insn (reg, val);
4084 #ifdef BLOCK_REG_PADDING
4085 size = GET_MODE_SIZE (argvec[argnum].mode);
4087 /* Copied from load_register_parameters. */
4089 /* Handle case where we have a value that needs shifting
4090 up to the msb. eg. a QImode value and we're padding
4091 upward on a BYTES_BIG_ENDIAN machine. */
4092 if (size < UNITS_PER_WORD
4093 && (argvec[argnum].locate.where_pad
4094 == (BYTES_BIG_ENDIAN ? upward : downward)))
4096 rtx x;
4097 int shift = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
4099 /* Assigning REG here rather than a temp makes CALL_FUSAGE
4100 report the whole reg as used. Strictly speaking, the
4101 call only uses SIZE bytes at the msb end, but it doesn't
4102 seem worth generating rtl to say that. */
4103 reg = gen_rtx_REG (word_mode, REGNO (reg));
4104 x = expand_shift (LSHIFT_EXPR, word_mode, reg, shift, reg, 1);
4105 if (x != reg)
4106 emit_move_insn (reg, x);
4108 #endif
4111 NO_DEFER_POP;
4114 /* Any regs containing parms remain in use through the call. */
4115 for (count = 0; count < nargs; count++)
4117 rtx reg = argvec[count].reg;
4118 if (reg != 0 && GET_CODE (reg) == PARALLEL)
4119 use_group_regs (&call_fusage, reg);
4120 else if (reg != 0)
4122 int partial = argvec[count].partial;
4123 if (partial)
4125 int nregs;
4126 gcc_assert (partial % UNITS_PER_WORD == 0);
4127 nregs = partial / UNITS_PER_WORD;
4128 use_regs (&call_fusage, REGNO (reg), nregs);
4130 else
4131 use_reg (&call_fusage, reg);
4135 /* Pass the function the address in which to return a structure value. */
4136 if (mem_value != 0 && struct_value != 0 && ! pcc_struct_value)
4138 emit_move_insn (struct_value,
4139 force_reg (Pmode,
4140 force_operand (XEXP (mem_value, 0),
4141 NULL_RTX)));
4142 if (REG_P (struct_value))
4143 use_reg (&call_fusage, struct_value);
4146 /* Don't allow popping to be deferred, since then
4147 cse'ing of library calls could delete a call and leave the pop. */
4148 NO_DEFER_POP;
4149 valreg = (mem_value == 0 && outmode != VOIDmode
4150 ? hard_libcall_value (outmode, orgfun) : NULL_RTX);
4152 /* Stack must be properly aligned now. */
4153 gcc_assert (!(stack_pointer_delta
4154 & (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1)));
4156 before_call = get_last_insn ();
4158 /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
4159 will set inhibit_defer_pop to that value. */
4160 /* The return type is needed to decide how many bytes the function pops.
4161 Signedness plays no role in that, so for simplicity, we pretend it's
4162 always signed. We also assume that the list of arguments passed has
4163 no impact, so we pretend it is unknown. */
4165 emit_call_1 (fun, NULL,
4166 get_identifier (XSTR (orgfun, 0)),
4167 build_function_type (tfom, NULL_TREE),
4168 original_args_size.constant, args_size.constant,
4169 struct_value_size,
4170 targetm.calls.function_arg (args_so_far,
4171 VOIDmode, void_type_node, true),
4172 valreg,
4173 old_inhibit_defer_pop + 1, call_fusage, flags, args_so_far);
4175 if (flag_use_caller_save)
4177 rtx last, datum = orgfun;
4178 gcc_assert (GET_CODE (datum) == SYMBOL_REF);
4179 last = last_call_insn ();
4180 add_reg_note (last, REG_CALL_DECL, datum);
4183 /* Right-shift returned value if necessary. */
4184 if (!pcc_struct_value
4185 && TYPE_MODE (tfom) != BLKmode
4186 && targetm.calls.return_in_msb (tfom))
4188 shift_return_value (TYPE_MODE (tfom), false, valreg);
4189 valreg = gen_rtx_REG (TYPE_MODE (tfom), REGNO (valreg));
4192 /* For calls to `setjmp', etc., inform function.c:setjmp_warnings
4193 that it should complain if nonvolatile values are live. For
4194 functions that cannot return, inform flow that control does not
4195 fall through. */
4196 if (flags & ECF_NORETURN)
4198 /* The barrier note must be emitted
4199 immediately after the CALL_INSN. Some ports emit more than
4200 just a CALL_INSN above, so we must search for it here. */
4201 rtx_insn *last = get_last_insn ();
4202 while (!CALL_P (last))
4204 last = PREV_INSN (last);
4205 /* There was no CALL_INSN? */
4206 gcc_assert (last != before_call);
4209 emit_barrier_after (last);
4212 /* Consider that "regular" libcalls, i.e. all of them except for LCT_THROW
4213 and LCT_RETURNS_TWICE, cannot perform non-local gotos. */
4214 if (flags & ECF_NOTHROW)
4216 rtx_insn *last = get_last_insn ();
4217 while (!CALL_P (last))
4219 last = PREV_INSN (last);
4220 /* There was no CALL_INSN? */
4221 gcc_assert (last != before_call);
4224 make_reg_eh_region_note_nothrow_nononlocal (last);
4227 /* Now restore inhibit_defer_pop to its actual original value. */
4228 OK_DEFER_POP;
4230 pop_temp_slots ();
4232 /* Copy the value to the right place. */
4233 if (outmode != VOIDmode && retval)
4235 if (mem_value)
4237 if (value == 0)
4238 value = mem_value;
4239 if (value != mem_value)
4240 emit_move_insn (value, mem_value);
4242 else if (GET_CODE (valreg) == PARALLEL)
4244 if (value == 0)
4245 value = gen_reg_rtx (outmode);
4246 emit_group_store (value, valreg, NULL_TREE, GET_MODE_SIZE (outmode));
4248 else
4250 /* Convert to the proper mode if a promotion has been active. */
4251 if (GET_MODE (valreg) != outmode)
4253 int unsignedp = TYPE_UNSIGNED (tfom);
4255 gcc_assert (promote_function_mode (tfom, outmode, &unsignedp,
4256 fndecl ? TREE_TYPE (fndecl) : fntype, 1)
4257 == GET_MODE (valreg));
4258 valreg = convert_modes (outmode, GET_MODE (valreg), valreg, 0);
4261 if (value != 0)
4262 emit_move_insn (value, valreg);
4263 else
4264 value = valreg;
4268 if (ACCUMULATE_OUTGOING_ARGS)
4270 #ifdef REG_PARM_STACK_SPACE
4271 if (save_area)
4272 restore_fixed_argument_area (save_area, argblock,
4273 high_to_save, low_to_save);
4274 #endif
4276 /* If we saved any argument areas, restore them. */
4277 for (count = 0; count < nargs; count++)
4278 if (argvec[count].save_area)
4280 enum machine_mode save_mode = GET_MODE (argvec[count].save_area);
4281 rtx adr = plus_constant (Pmode, argblock,
4282 argvec[count].locate.offset.constant);
4283 rtx stack_area = gen_rtx_MEM (save_mode,
4284 memory_address (save_mode, adr));
4286 if (save_mode == BLKmode)
4287 emit_block_move (stack_area,
4288 validize_mem
4289 (copy_rtx (argvec[count].save_area)),
4290 GEN_INT (argvec[count].locate.size.constant),
4291 BLOCK_OP_CALL_PARM);
4292 else
4293 emit_move_insn (stack_area, argvec[count].save_area);
4296 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
4297 stack_usage_map = initial_stack_usage_map;
4300 free (stack_usage_map_buf);
4302 return value;
4306 /* Output a library call to function FUN (a SYMBOL_REF rtx)
4307 (emitting the queue unless NO_QUEUE is nonzero),
4308 for a value of mode OUTMODE,
4309 with NARGS different arguments, passed as alternating rtx values
4310 and machine_modes to convert them to.
4312 FN_TYPE should be LCT_NORMAL for `normal' calls, LCT_CONST for
4313 `const' calls, LCT_PURE for `pure' calls, or other LCT_ value for
4314 other types of library calls. */
4316 void
4317 emit_library_call (rtx orgfun, enum libcall_type fn_type,
4318 enum machine_mode outmode, int nargs, ...)
4320 va_list p;
4322 va_start (p, nargs);
4323 emit_library_call_value_1 (0, orgfun, NULL_RTX, fn_type, outmode, nargs, p);
4324 va_end (p);
4327 /* Like emit_library_call except that an extra argument, VALUE,
4328 comes second and says where to store the result.
4329 (If VALUE is zero, this function chooses a convenient way
4330 to return the value.
4332 This function returns an rtx for where the value is to be found.
4333 If VALUE is nonzero, VALUE is returned. */
4336 emit_library_call_value (rtx orgfun, rtx value,
4337 enum libcall_type fn_type,
4338 enum machine_mode outmode, int nargs, ...)
4340 rtx result;
4341 va_list p;
4343 va_start (p, nargs);
4344 result = emit_library_call_value_1 (1, orgfun, value, fn_type, outmode,
4345 nargs, p);
4346 va_end (p);
4348 return result;
4351 /* Store a single argument for a function call
4352 into the register or memory area where it must be passed.
4353 *ARG describes the argument value and where to pass it.
4355 ARGBLOCK is the address of the stack-block for all the arguments,
4356 or 0 on a machine where arguments are pushed individually.
4358 MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
4359 so must be careful about how the stack is used.
4361 VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
4362 argument stack. This is used if ACCUMULATE_OUTGOING_ARGS to indicate
4363 that we need not worry about saving and restoring the stack.
4365 FNDECL is the declaration of the function we are calling.
4367 Return nonzero if this arg should cause sibcall failure,
4368 zero otherwise. */
4370 static int
4371 store_one_arg (struct arg_data *arg, rtx argblock, int flags,
4372 int variable_size ATTRIBUTE_UNUSED, int reg_parm_stack_space)
4374 tree pval = arg->tree_value;
4375 rtx reg = 0;
4376 int partial = 0;
4377 int used = 0;
4378 int i, lower_bound = 0, upper_bound = 0;
4379 int sibcall_failure = 0;
4381 if (TREE_CODE (pval) == ERROR_MARK)
4382 return 1;
4384 /* Push a new temporary level for any temporaries we make for
4385 this argument. */
4386 push_temp_slots ();
4388 if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL))
4390 /* If this is being stored into a pre-allocated, fixed-size, stack area,
4391 save any previous data at that location. */
4392 if (argblock && ! variable_size && arg->stack)
4394 #ifdef ARGS_GROW_DOWNWARD
4395 /* stack_slot is negative, but we want to index stack_usage_map
4396 with positive values. */
4397 if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
4398 upper_bound = -INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1)) + 1;
4399 else
4400 upper_bound = 0;
4402 lower_bound = upper_bound - arg->locate.size.constant;
4403 #else
4404 if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
4405 lower_bound = INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1));
4406 else
4407 lower_bound = 0;
4409 upper_bound = lower_bound + arg->locate.size.constant;
4410 #endif
4412 i = lower_bound;
4413 /* Don't worry about things in the fixed argument area;
4414 it has already been saved. */
4415 if (i < reg_parm_stack_space)
4416 i = reg_parm_stack_space;
4417 while (i < upper_bound && stack_usage_map[i] == 0)
4418 i++;
4420 if (i < upper_bound)
4422 /* We need to make a save area. */
4423 unsigned int size = arg->locate.size.constant * BITS_PER_UNIT;
4424 enum machine_mode save_mode = mode_for_size (size, MODE_INT, 1);
4425 rtx adr = memory_address (save_mode, XEXP (arg->stack_slot, 0));
4426 rtx stack_area = gen_rtx_MEM (save_mode, adr);
4428 if (save_mode == BLKmode)
4430 arg->save_area
4431 = assign_temp (TREE_TYPE (arg->tree_value), 1, 1);
4432 preserve_temp_slots (arg->save_area);
4433 emit_block_move (validize_mem (copy_rtx (arg->save_area)),
4434 stack_area,
4435 GEN_INT (arg->locate.size.constant),
4436 BLOCK_OP_CALL_PARM);
4438 else
4440 arg->save_area = gen_reg_rtx (save_mode);
4441 emit_move_insn (arg->save_area, stack_area);
4447 /* If this isn't going to be placed on both the stack and in registers,
4448 set up the register and number of words. */
4449 if (! arg->pass_on_stack)
4451 if (flags & ECF_SIBCALL)
4452 reg = arg->tail_call_reg;
4453 else
4454 reg = arg->reg;
4455 partial = arg->partial;
4458 /* Being passed entirely in a register. We shouldn't be called in
4459 this case. */
4460 gcc_assert (reg == 0 || partial != 0);
4462 /* If this arg needs special alignment, don't load the registers
4463 here. */
4464 if (arg->n_aligned_regs != 0)
4465 reg = 0;
4467 /* If this is being passed partially in a register, we can't evaluate
4468 it directly into its stack slot. Otherwise, we can. */
4469 if (arg->value == 0)
4471 /* stack_arg_under_construction is nonzero if a function argument is
4472 being evaluated directly into the outgoing argument list and
4473 expand_call must take special action to preserve the argument list
4474 if it is called recursively.
4476 For scalar function arguments stack_usage_map is sufficient to
4477 determine which stack slots must be saved and restored. Scalar
4478 arguments in general have pass_on_stack == 0.
4480 If this argument is initialized by a function which takes the
4481 address of the argument (a C++ constructor or a C function
4482 returning a BLKmode structure), then stack_usage_map is
4483 insufficient and expand_call must push the stack around the
4484 function call. Such arguments have pass_on_stack == 1.
4486 Note that it is always safe to set stack_arg_under_construction,
4487 but this generates suboptimal code if set when not needed. */
4489 if (arg->pass_on_stack)
4490 stack_arg_under_construction++;
4492 arg->value = expand_expr (pval,
4493 (partial
4494 || TYPE_MODE (TREE_TYPE (pval)) != arg->mode)
4495 ? NULL_RTX : arg->stack,
4496 VOIDmode, EXPAND_STACK_PARM);
4498 /* If we are promoting object (or for any other reason) the mode
4499 doesn't agree, convert the mode. */
4501 if (arg->mode != TYPE_MODE (TREE_TYPE (pval)))
4502 arg->value = convert_modes (arg->mode, TYPE_MODE (TREE_TYPE (pval)),
4503 arg->value, arg->unsignedp);
4505 if (arg->pass_on_stack)
4506 stack_arg_under_construction--;
4509 /* Check for overlap with already clobbered argument area. */
4510 if ((flags & ECF_SIBCALL)
4511 && MEM_P (arg->value)
4512 && mem_overlaps_already_clobbered_arg_p (XEXP (arg->value, 0),
4513 arg->locate.size.constant))
4514 sibcall_failure = 1;
4516 /* Don't allow anything left on stack from computation
4517 of argument to alloca. */
4518 if (flags & ECF_MAY_BE_ALLOCA)
4519 do_pending_stack_adjust ();
4521 if (arg->value == arg->stack)
4522 /* If the value is already in the stack slot, we are done. */
4524 else if (arg->mode != BLKmode)
4526 int size;
4527 unsigned int parm_align;
4529 /* Argument is a scalar, not entirely passed in registers.
4530 (If part is passed in registers, arg->partial says how much
4531 and emit_push_insn will take care of putting it there.)
4533 Push it, and if its size is less than the
4534 amount of space allocated to it,
4535 also bump stack pointer by the additional space.
4536 Note that in C the default argument promotions
4537 will prevent such mismatches. */
4539 size = GET_MODE_SIZE (arg->mode);
4540 /* Compute how much space the push instruction will push.
4541 On many machines, pushing a byte will advance the stack
4542 pointer by a halfword. */
4543 #ifdef PUSH_ROUNDING
4544 size = PUSH_ROUNDING (size);
4545 #endif
4546 used = size;
4548 /* Compute how much space the argument should get:
4549 round up to a multiple of the alignment for arguments. */
4550 if (none != FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)))
4551 used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1)
4552 / (PARM_BOUNDARY / BITS_PER_UNIT))
4553 * (PARM_BOUNDARY / BITS_PER_UNIT));
4555 /* Compute the alignment of the pushed argument. */
4556 parm_align = arg->locate.boundary;
4557 if (FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)) == downward)
4559 int pad = used - size;
4560 if (pad)
4562 unsigned int pad_align = (pad & -pad) * BITS_PER_UNIT;
4563 parm_align = MIN (parm_align, pad_align);
4567 /* This isn't already where we want it on the stack, so put it there.
4568 This can either be done with push or copy insns. */
4569 emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX,
4570 parm_align, partial, reg, used - size, argblock,
4571 ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
4572 ARGS_SIZE_RTX (arg->locate.alignment_pad));
4574 /* Unless this is a partially-in-register argument, the argument is now
4575 in the stack. */
4576 if (partial == 0)
4577 arg->value = arg->stack;
4579 else
4581 /* BLKmode, at least partly to be pushed. */
4583 unsigned int parm_align;
4584 int excess;
4585 rtx size_rtx;
4587 /* Pushing a nonscalar.
4588 If part is passed in registers, PARTIAL says how much
4589 and emit_push_insn will take care of putting it there. */
4591 /* Round its size up to a multiple
4592 of the allocation unit for arguments. */
4594 if (arg->locate.size.var != 0)
4596 excess = 0;
4597 size_rtx = ARGS_SIZE_RTX (arg->locate.size);
4599 else
4601 /* PUSH_ROUNDING has no effect on us, because emit_push_insn
4602 for BLKmode is careful to avoid it. */
4603 excess = (arg->locate.size.constant
4604 - int_size_in_bytes (TREE_TYPE (pval))
4605 + partial);
4606 size_rtx = expand_expr (size_in_bytes (TREE_TYPE (pval)),
4607 NULL_RTX, TYPE_MODE (sizetype),
4608 EXPAND_NORMAL);
4611 parm_align = arg->locate.boundary;
4613 /* When an argument is padded down, the block is aligned to
4614 PARM_BOUNDARY, but the actual argument isn't. */
4615 if (FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)) == downward)
4617 if (arg->locate.size.var)
4618 parm_align = BITS_PER_UNIT;
4619 else if (excess)
4621 unsigned int excess_align = (excess & -excess) * BITS_PER_UNIT;
4622 parm_align = MIN (parm_align, excess_align);
4626 if ((flags & ECF_SIBCALL) && MEM_P (arg->value))
4628 /* emit_push_insn might not work properly if arg->value and
4629 argblock + arg->locate.offset areas overlap. */
4630 rtx x = arg->value;
4631 int i = 0;
4633 if (XEXP (x, 0) == crtl->args.internal_arg_pointer
4634 || (GET_CODE (XEXP (x, 0)) == PLUS
4635 && XEXP (XEXP (x, 0), 0) ==
4636 crtl->args.internal_arg_pointer
4637 && CONST_INT_P (XEXP (XEXP (x, 0), 1))))
4639 if (XEXP (x, 0) != crtl->args.internal_arg_pointer)
4640 i = INTVAL (XEXP (XEXP (x, 0), 1));
4642 /* expand_call should ensure this. */
4643 gcc_assert (!arg->locate.offset.var
4644 && arg->locate.size.var == 0
4645 && CONST_INT_P (size_rtx));
4647 if (arg->locate.offset.constant > i)
4649 if (arg->locate.offset.constant < i + INTVAL (size_rtx))
4650 sibcall_failure = 1;
4652 else if (arg->locate.offset.constant < i)
4654 /* Use arg->locate.size.constant instead of size_rtx
4655 because we only care about the part of the argument
4656 on the stack. */
4657 if (i < (arg->locate.offset.constant
4658 + arg->locate.size.constant))
4659 sibcall_failure = 1;
4661 else
4663 /* Even though they appear to be at the same location,
4664 if part of the outgoing argument is in registers,
4665 they aren't really at the same location. Check for
4666 this by making sure that the incoming size is the
4667 same as the outgoing size. */
4668 if (arg->locate.size.constant != INTVAL (size_rtx))
4669 sibcall_failure = 1;
4674 emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
4675 parm_align, partial, reg, excess, argblock,
4676 ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
4677 ARGS_SIZE_RTX (arg->locate.alignment_pad));
4679 /* Unless this is a partially-in-register argument, the argument is now
4680 in the stack.
4682 ??? Unlike the case above, in which we want the actual
4683 address of the data, so that we can load it directly into a
4684 register, here we want the address of the stack slot, so that
4685 it's properly aligned for word-by-word copying or something
4686 like that. It's not clear that this is always correct. */
4687 if (partial == 0)
4688 arg->value = arg->stack_slot;
4691 if (arg->reg && GET_CODE (arg->reg) == PARALLEL)
4693 tree type = TREE_TYPE (arg->tree_value);
4694 arg->parallel_value
4695 = emit_group_load_into_temps (arg->reg, arg->value, type,
4696 int_size_in_bytes (type));
4699 /* Mark all slots this store used. */
4700 if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL)
4701 && argblock && ! variable_size && arg->stack)
4702 for (i = lower_bound; i < upper_bound; i++)
4703 stack_usage_map[i] = 1;
4705 /* Once we have pushed something, pops can't safely
4706 be deferred during the rest of the arguments. */
4707 NO_DEFER_POP;
4709 /* Free any temporary slots made in processing this argument. */
4710 pop_temp_slots ();
4712 return sibcall_failure;
4715 /* Nonzero if we do not know how to pass TYPE solely in registers. */
4717 bool
4718 must_pass_in_stack_var_size (enum machine_mode mode ATTRIBUTE_UNUSED,
4719 const_tree type)
4721 if (!type)
4722 return false;
4724 /* If the type has variable size... */
4725 if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4726 return true;
4728 /* If the type is marked as addressable (it is required
4729 to be constructed into the stack)... */
4730 if (TREE_ADDRESSABLE (type))
4731 return true;
4733 return false;
4736 /* Another version of the TARGET_MUST_PASS_IN_STACK hook. This one
4737 takes trailing padding of a structure into account. */
4738 /* ??? Should be able to merge these two by examining BLOCK_REG_PADDING. */
4740 bool
4741 must_pass_in_stack_var_size_or_pad (enum machine_mode mode, const_tree type)
4743 if (!type)
4744 return false;
4746 /* If the type has variable size... */
4747 if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4748 return true;
4750 /* If the type is marked as addressable (it is required
4751 to be constructed into the stack)... */
4752 if (TREE_ADDRESSABLE (type))
4753 return true;
4755 /* If the padding and mode of the type is such that a copy into
4756 a register would put it into the wrong part of the register. */
4757 if (mode == BLKmode
4758 && int_size_in_bytes (type) % (PARM_BOUNDARY / BITS_PER_UNIT)
4759 && (FUNCTION_ARG_PADDING (mode, type)
4760 == (BYTES_BIG_ENDIAN ? upward : downward)))
4761 return true;
4763 return false;