Remove unused debug_str_hash_forced from dwarf2out.
[official-gcc.git] / gcc / calls.c
blob98f3009905a55a7d3ab1c27390939d91922de446
1 /* Convert function calls to rtl insns, for GNU C compiler.
2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
4 2011 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "rtl.h"
27 #include "tree.h"
28 #include "gimple.h"
29 #include "flags.h"
30 #include "expr.h"
31 #include "optabs.h"
32 #include "libfuncs.h"
33 #include "function.h"
34 #include "regs.h"
35 #include "diagnostic-core.h"
36 #include "output.h"
37 #include "tm_p.h"
38 #include "timevar.h"
39 #include "sbitmap.h"
40 #include "langhooks.h"
41 #include "target.h"
42 #include "cgraph.h"
43 #include "except.h"
44 #include "dbgcnt.h"
45 #include "tree-flow.h"
47 /* Like PREFERRED_STACK_BOUNDARY but in units of bytes, not bits. */
48 #define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)
50 /* Data structure and subroutines used within expand_call. */
52 struct arg_data
54 /* Tree node for this argument. */
55 tree tree_value;
56 /* Mode for value; TYPE_MODE unless promoted. */
57 enum machine_mode mode;
58 /* Current RTL value for argument, or 0 if it isn't precomputed. */
59 rtx value;
60 /* Initially-compute RTL value for argument; only for const functions. */
61 rtx initial_value;
62 /* Register to pass this argument in, 0 if passed on stack, or an
63 PARALLEL if the arg is to be copied into multiple non-contiguous
64 registers. */
65 rtx reg;
66 /* Register to pass this argument in when generating tail call sequence.
67 This is not the same register as for normal calls on machines with
68 register windows. */
69 rtx tail_call_reg;
70 /* If REG is a PARALLEL, this is a copy of VALUE pulled into the correct
71 form for emit_group_move. */
72 rtx parallel_value;
73 /* If REG was promoted from the actual mode of the argument expression,
74 indicates whether the promotion is sign- or zero-extended. */
75 int unsignedp;
76 /* Number of bytes to put in registers. 0 means put the whole arg
77 in registers. Also 0 if not passed in registers. */
78 int partial;
79 /* Nonzero if argument must be passed on stack.
80 Note that some arguments may be passed on the stack
81 even though pass_on_stack is zero, just because FUNCTION_ARG says so.
82 pass_on_stack identifies arguments that *cannot* go in registers. */
83 int pass_on_stack;
84 /* Some fields packaged up for locate_and_pad_parm. */
85 struct locate_and_pad_arg_data locate;
86 /* Location on the stack at which parameter should be stored. The store
87 has already been done if STACK == VALUE. */
88 rtx stack;
89 /* Location on the stack of the start of this argument slot. This can
90 differ from STACK if this arg pads downward. This location is known
91 to be aligned to TARGET_FUNCTION_ARG_BOUNDARY. */
92 rtx stack_slot;
93 /* Place that this stack area has been saved, if needed. */
94 rtx save_area;
95 /* If an argument's alignment does not permit direct copying into registers,
96 copy in smaller-sized pieces into pseudos. These are stored in a
97 block pointed to by this field. The next field says how many
98 word-sized pseudos we made. */
99 rtx *aligned_regs;
100 int n_aligned_regs;
103 /* A vector of one char per byte of stack space. A byte if nonzero if
104 the corresponding stack location has been used.
105 This vector is used to prevent a function call within an argument from
106 clobbering any stack already set up. */
107 static char *stack_usage_map;
109 /* Size of STACK_USAGE_MAP. */
110 static int highest_outgoing_arg_in_use;
112 /* A bitmap of virtual-incoming stack space. Bit is set if the corresponding
113 stack location's tail call argument has been already stored into the stack.
114 This bitmap is used to prevent sibling call optimization if function tries
115 to use parent's incoming argument slots when they have been already
116 overwritten with tail call arguments. */
117 static sbitmap stored_args_map;
119 /* stack_arg_under_construction is nonzero when an argument may be
120 initialized with a constructor call (including a C function that
121 returns a BLKmode struct) and expand_call must take special action
122 to make sure the object being constructed does not overlap the
123 argument list for the constructor call. */
124 static int stack_arg_under_construction;
126 static void emit_call_1 (rtx, tree, tree, tree, HOST_WIDE_INT, HOST_WIDE_INT,
127 HOST_WIDE_INT, rtx, rtx, int, rtx, int,
128 CUMULATIVE_ARGS *);
129 static void precompute_register_parameters (int, struct arg_data *, int *);
130 static int store_one_arg (struct arg_data *, rtx, int, int, int);
131 static void store_unaligned_arguments_into_pseudos (struct arg_data *, int);
132 static int finalize_must_preallocate (int, int, struct arg_data *,
133 struct args_size *);
134 static void precompute_arguments (int, struct arg_data *);
135 static int compute_argument_block_size (int, struct args_size *, tree, tree, int);
136 static void initialize_argument_information (int, struct arg_data *,
137 struct args_size *, int,
138 tree, tree,
139 tree, tree, CUMULATIVE_ARGS *, int,
140 rtx *, int *, int *, int *,
141 bool *, bool);
142 static void compute_argument_addresses (struct arg_data *, rtx, int);
143 static rtx rtx_for_function_call (tree, tree);
144 static void load_register_parameters (struct arg_data *, int, rtx *, int,
145 int, int *);
146 static rtx emit_library_call_value_1 (int, rtx, rtx, enum libcall_type,
147 enum machine_mode, int, va_list);
148 static int special_function_p (const_tree, int);
149 static int check_sibcall_argument_overlap_1 (rtx);
150 static int check_sibcall_argument_overlap (rtx, struct arg_data *, int);
152 static int combine_pending_stack_adjustment_and_call (int, struct args_size *,
153 unsigned int);
154 static tree split_complex_types (tree);
156 #ifdef REG_PARM_STACK_SPACE
157 static rtx save_fixed_argument_area (int, rtx, int *, int *);
158 static void restore_fixed_argument_area (rtx, rtx, int, int);
159 #endif
161 /* Force FUNEXP into a form suitable for the address of a CALL,
162 and return that as an rtx. Also load the static chain register
163 if FNDECL is a nested function.
165 CALL_FUSAGE points to a variable holding the prospective
166 CALL_INSN_FUNCTION_USAGE information. */
169 prepare_call_address (tree fndecl, rtx funexp, rtx static_chain_value,
170 rtx *call_fusage, int reg_parm_seen, int sibcallp)
172 /* Make a valid memory address and copy constants through pseudo-regs,
173 but not for a constant address if -fno-function-cse. */
174 if (GET_CODE (funexp) != SYMBOL_REF)
175 /* If we are using registers for parameters, force the
176 function address into a register now. */
177 funexp = ((reg_parm_seen
178 && targetm.small_register_classes_for_mode_p (FUNCTION_MODE))
179 ? force_not_mem (memory_address (FUNCTION_MODE, funexp))
180 : memory_address (FUNCTION_MODE, funexp));
181 else if (! sibcallp)
183 #ifndef NO_FUNCTION_CSE
184 if (optimize && ! flag_no_function_cse)
185 funexp = force_reg (Pmode, funexp);
186 #endif
189 if (static_chain_value != 0)
191 rtx chain;
193 gcc_assert (fndecl);
194 chain = targetm.calls.static_chain (fndecl, false);
195 static_chain_value = convert_memory_address (Pmode, static_chain_value);
197 emit_move_insn (chain, static_chain_value);
198 if (REG_P (chain))
199 use_reg (call_fusage, chain);
202 return funexp;
205 /* Generate instructions to call function FUNEXP,
206 and optionally pop the results.
207 The CALL_INSN is the first insn generated.
209 FNDECL is the declaration node of the function. This is given to the
210 hook TARGET_RETURN_POPS_ARGS to determine whether this function pops
211 its own args.
213 FUNTYPE is the data type of the function. This is given to the hook
214 TARGET_RETURN_POPS_ARGS to determine whether this function pops its
215 own args. We used to allow an identifier for library functions, but
216 that doesn't work when the return type is an aggregate type and the
217 calling convention says that the pointer to this aggregate is to be
218 popped by the callee.
220 STACK_SIZE is the number of bytes of arguments on the stack,
221 ROUNDED_STACK_SIZE is that number rounded up to
222 PREFERRED_STACK_BOUNDARY; zero if the size is variable. This is
223 both to put into the call insn and to generate explicit popping
224 code if necessary.
226 STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
227 It is zero if this call doesn't want a structure value.
229 NEXT_ARG_REG is the rtx that results from executing
230 targetm.calls.function_arg (&args_so_far, VOIDmode, void_type_node, true)
231 just after all the args have had their registers assigned.
232 This could be whatever you like, but normally it is the first
233 arg-register beyond those used for args in this call,
234 or 0 if all the arg-registers are used in this call.
235 It is passed on to `gen_call' so you can put this info in the call insn.
237 VALREG is a hard register in which a value is returned,
238 or 0 if the call does not return a value.
240 OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before
241 the args to this call were processed.
242 We restore `inhibit_defer_pop' to that value.
244 CALL_FUSAGE is either empty or an EXPR_LIST of USE expressions that
245 denote registers used by the called function. */
247 static void
248 emit_call_1 (rtx funexp, tree fntree ATTRIBUTE_UNUSED, tree fndecl ATTRIBUTE_UNUSED,
249 tree funtype ATTRIBUTE_UNUSED,
250 HOST_WIDE_INT stack_size ATTRIBUTE_UNUSED,
251 HOST_WIDE_INT rounded_stack_size,
252 HOST_WIDE_INT struct_value_size ATTRIBUTE_UNUSED,
253 rtx next_arg_reg ATTRIBUTE_UNUSED, rtx valreg,
254 int old_inhibit_defer_pop, rtx call_fusage, int ecf_flags,
255 CUMULATIVE_ARGS *args_so_far ATTRIBUTE_UNUSED)
257 rtx rounded_stack_size_rtx = GEN_INT (rounded_stack_size);
258 rtx call_insn, call, funmem;
259 int already_popped = 0;
260 HOST_WIDE_INT n_popped
261 = targetm.calls.return_pops_args (fndecl, funtype, stack_size);
263 #ifdef CALL_POPS_ARGS
264 n_popped += CALL_POPS_ARGS (* args_so_far);
265 #endif
267 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
268 and we don't want to load it into a register as an optimization,
269 because prepare_call_address already did it if it should be done. */
270 if (GET_CODE (funexp) != SYMBOL_REF)
271 funexp = memory_address (FUNCTION_MODE, funexp);
273 funmem = gen_rtx_MEM (FUNCTION_MODE, funexp);
274 if (fndecl && TREE_CODE (fndecl) == FUNCTION_DECL)
275 set_mem_expr (funmem, fndecl);
276 else if (fntree)
277 set_mem_expr (funmem, build_simple_mem_ref (CALL_EXPR_FN (fntree)));
279 #if defined (HAVE_sibcall_pop) && defined (HAVE_sibcall_value_pop)
280 if ((ecf_flags & ECF_SIBCALL)
281 && HAVE_sibcall_pop && HAVE_sibcall_value_pop
282 && (n_popped > 0 || stack_size == 0))
284 rtx n_pop = GEN_INT (n_popped);
285 rtx pat;
287 /* If this subroutine pops its own args, record that in the call insn
288 if possible, for the sake of frame pointer elimination. */
290 if (valreg)
291 pat = GEN_SIBCALL_VALUE_POP (valreg, funmem, rounded_stack_size_rtx,
292 next_arg_reg, n_pop);
293 else
294 pat = GEN_SIBCALL_POP (funmem, rounded_stack_size_rtx, next_arg_reg,
295 n_pop);
297 emit_call_insn (pat);
298 already_popped = 1;
300 else
301 #endif
303 #if defined (HAVE_call_pop) && defined (HAVE_call_value_pop)
304 /* If the target has "call" or "call_value" insns, then prefer them
305 if no arguments are actually popped. If the target does not have
306 "call" or "call_value" insns, then we must use the popping versions
307 even if the call has no arguments to pop. */
308 #if defined (HAVE_call) && defined (HAVE_call_value)
309 if (HAVE_call && HAVE_call_value && HAVE_call_pop && HAVE_call_value_pop
310 && n_popped > 0)
311 #else
312 if (HAVE_call_pop && HAVE_call_value_pop)
313 #endif
315 rtx n_pop = GEN_INT (n_popped);
316 rtx pat;
318 /* If this subroutine pops its own args, record that in the call insn
319 if possible, for the sake of frame pointer elimination. */
321 if (valreg)
322 pat = GEN_CALL_VALUE_POP (valreg, funmem, rounded_stack_size_rtx,
323 next_arg_reg, n_pop);
324 else
325 pat = GEN_CALL_POP (funmem, rounded_stack_size_rtx, next_arg_reg,
326 n_pop);
328 emit_call_insn (pat);
329 already_popped = 1;
331 else
332 #endif
334 #if defined (HAVE_sibcall) && defined (HAVE_sibcall_value)
335 if ((ecf_flags & ECF_SIBCALL)
336 && HAVE_sibcall && HAVE_sibcall_value)
338 if (valreg)
339 emit_call_insn (GEN_SIBCALL_VALUE (valreg, funmem,
340 rounded_stack_size_rtx,
341 next_arg_reg, NULL_RTX));
342 else
343 emit_call_insn (GEN_SIBCALL (funmem, rounded_stack_size_rtx,
344 next_arg_reg,
345 GEN_INT (struct_value_size)));
347 else
348 #endif
350 #if defined (HAVE_call) && defined (HAVE_call_value)
351 if (HAVE_call && HAVE_call_value)
353 if (valreg)
354 emit_call_insn (GEN_CALL_VALUE (valreg, funmem, rounded_stack_size_rtx,
355 next_arg_reg, NULL_RTX));
356 else
357 emit_call_insn (GEN_CALL (funmem, rounded_stack_size_rtx, next_arg_reg,
358 GEN_INT (struct_value_size)));
360 else
361 #endif
362 gcc_unreachable ();
364 /* Find the call we just emitted. */
365 call_insn = last_call_insn ();
367 /* Some target create a fresh MEM instead of reusing the one provided
368 above. Set its MEM_EXPR. */
369 call = PATTERN (call_insn);
370 if (GET_CODE (call) == PARALLEL)
371 call = XVECEXP (call, 0, 0);
372 if (GET_CODE (call) == SET)
373 call = SET_SRC (call);
374 if (GET_CODE (call) == CALL
375 && MEM_P (XEXP (call, 0))
376 && MEM_EXPR (XEXP (call, 0)) == NULL_TREE
377 && MEM_EXPR (funmem) != NULL_TREE)
378 set_mem_expr (XEXP (call, 0), MEM_EXPR (funmem));
380 /* Put the register usage information there. */
381 add_function_usage_to (call_insn, call_fusage);
383 /* If this is a const call, then set the insn's unchanging bit. */
384 if (ecf_flags & ECF_CONST)
385 RTL_CONST_CALL_P (call_insn) = 1;
387 /* If this is a pure call, then set the insn's unchanging bit. */
388 if (ecf_flags & ECF_PURE)
389 RTL_PURE_CALL_P (call_insn) = 1;
391 /* If this is a const call, then set the insn's unchanging bit. */
392 if (ecf_flags & ECF_LOOPING_CONST_OR_PURE)
393 RTL_LOOPING_CONST_OR_PURE_CALL_P (call_insn) = 1;
395 /* Create a nothrow REG_EH_REGION note, if needed. */
396 make_reg_eh_region_note (call_insn, ecf_flags, 0);
398 if (ecf_flags & ECF_NORETURN)
399 add_reg_note (call_insn, REG_NORETURN, const0_rtx);
401 if (ecf_flags & ECF_RETURNS_TWICE)
403 add_reg_note (call_insn, REG_SETJMP, const0_rtx);
404 cfun->calls_setjmp = 1;
407 SIBLING_CALL_P (call_insn) = ((ecf_flags & ECF_SIBCALL) != 0);
409 /* Restore this now, so that we do defer pops for this call's args
410 if the context of the call as a whole permits. */
411 inhibit_defer_pop = old_inhibit_defer_pop;
413 if (n_popped > 0)
415 if (!already_popped)
416 CALL_INSN_FUNCTION_USAGE (call_insn)
417 = gen_rtx_EXPR_LIST (VOIDmode,
418 gen_rtx_CLOBBER (VOIDmode, stack_pointer_rtx),
419 CALL_INSN_FUNCTION_USAGE (call_insn));
420 rounded_stack_size -= n_popped;
421 rounded_stack_size_rtx = GEN_INT (rounded_stack_size);
422 stack_pointer_delta -= n_popped;
424 /* If popup is needed, stack realign must use DRAP */
425 if (SUPPORTS_STACK_ALIGNMENT)
426 crtl->need_drap = true;
429 if (!ACCUMULATE_OUTGOING_ARGS)
431 /* If returning from the subroutine does not automatically pop the args,
432 we need an instruction to pop them sooner or later.
433 Perhaps do it now; perhaps just record how much space to pop later.
435 If returning from the subroutine does pop the args, indicate that the
436 stack pointer will be changed. */
438 if (rounded_stack_size != 0)
440 if (ecf_flags & ECF_NORETURN)
441 /* Just pretend we did the pop. */
442 stack_pointer_delta -= rounded_stack_size;
443 else if (flag_defer_pop && inhibit_defer_pop == 0
444 && ! (ecf_flags & (ECF_CONST | ECF_PURE)))
445 pending_stack_adjust += rounded_stack_size;
446 else
447 adjust_stack (rounded_stack_size_rtx);
450 /* When we accumulate outgoing args, we must avoid any stack manipulations.
451 Restore the stack pointer to its original value now. Usually
452 ACCUMULATE_OUTGOING_ARGS targets don't get here, but there are exceptions.
453 On i386 ACCUMULATE_OUTGOING_ARGS can be enabled on demand, and
454 popping variants of functions exist as well.
456 ??? We may optimize similar to defer_pop above, but it is
457 probably not worthwhile.
459 ??? It will be worthwhile to enable combine_stack_adjustments even for
460 such machines. */
461 else if (n_popped)
462 anti_adjust_stack (GEN_INT (n_popped));
465 /* Determine if the function identified by NAME and FNDECL is one with
466 special properties we wish to know about.
468 For example, if the function might return more than one time (setjmp), then
469 set RETURNS_TWICE to a nonzero value.
471 Similarly set NORETURN if the function is in the longjmp family.
473 Set MAY_BE_ALLOCA for any memory allocation function that might allocate
474 space from the stack such as alloca. */
476 static int
477 special_function_p (const_tree fndecl, int flags)
479 if (fndecl && DECL_NAME (fndecl)
480 && IDENTIFIER_LENGTH (DECL_NAME (fndecl)) <= 17
481 /* Exclude functions not at the file scope, or not `extern',
482 since they are not the magic functions we would otherwise
483 think they are.
484 FIXME: this should be handled with attributes, not with this
485 hacky imitation of DECL_ASSEMBLER_NAME. It's (also) wrong
486 because you can declare fork() inside a function if you
487 wish. */
488 && (DECL_CONTEXT (fndecl) == NULL_TREE
489 || TREE_CODE (DECL_CONTEXT (fndecl)) == TRANSLATION_UNIT_DECL)
490 && TREE_PUBLIC (fndecl))
492 const char *name = IDENTIFIER_POINTER (DECL_NAME (fndecl));
493 const char *tname = name;
495 /* We assume that alloca will always be called by name. It
496 makes no sense to pass it as a pointer-to-function to
497 anything that does not understand its behavior. */
498 if (((IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 6
499 && name[0] == 'a'
500 && ! strcmp (name, "alloca"))
501 || (IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 16
502 && name[0] == '_'
503 && ! strcmp (name, "__builtin_alloca"))))
504 flags |= ECF_MAY_BE_ALLOCA;
506 /* Disregard prefix _, __, __x or __builtin_. */
507 if (name[0] == '_')
509 if (name[1] == '_'
510 && name[2] == 'b'
511 && !strncmp (name + 3, "uiltin_", 7))
512 tname += 10;
513 else if (name[1] == '_' && name[2] == 'x')
514 tname += 3;
515 else if (name[1] == '_')
516 tname += 2;
517 else
518 tname += 1;
521 if (tname[0] == 's')
523 if ((tname[1] == 'e'
524 && (! strcmp (tname, "setjmp")
525 || ! strcmp (tname, "setjmp_syscall")))
526 || (tname[1] == 'i'
527 && ! strcmp (tname, "sigsetjmp"))
528 || (tname[1] == 'a'
529 && ! strcmp (tname, "savectx")))
530 flags |= ECF_RETURNS_TWICE;
532 if (tname[1] == 'i'
533 && ! strcmp (tname, "siglongjmp"))
534 flags |= ECF_NORETURN;
536 else if ((tname[0] == 'q' && tname[1] == 's'
537 && ! strcmp (tname, "qsetjmp"))
538 || (tname[0] == 'v' && tname[1] == 'f'
539 && ! strcmp (tname, "vfork"))
540 || (tname[0] == 'g' && tname[1] == 'e'
541 && !strcmp (tname, "getcontext")))
542 flags |= ECF_RETURNS_TWICE;
544 else if (tname[0] == 'l' && tname[1] == 'o'
545 && ! strcmp (tname, "longjmp"))
546 flags |= ECF_NORETURN;
549 return flags;
552 /* Return nonzero when FNDECL represents a call to setjmp. */
555 setjmp_call_p (const_tree fndecl)
557 return special_function_p (fndecl, 0) & ECF_RETURNS_TWICE;
561 /* Return true if STMT is an alloca call. */
563 bool
564 gimple_alloca_call_p (const_gimple stmt)
566 tree fndecl;
568 if (!is_gimple_call (stmt))
569 return false;
571 fndecl = gimple_call_fndecl (stmt);
572 if (fndecl && (special_function_p (fndecl, 0) & ECF_MAY_BE_ALLOCA))
573 return true;
575 return false;
578 /* Return true when exp contains alloca call. */
580 bool
581 alloca_call_p (const_tree exp)
583 if (TREE_CODE (exp) == CALL_EXPR
584 && TREE_CODE (CALL_EXPR_FN (exp)) == ADDR_EXPR
585 && (TREE_CODE (TREE_OPERAND (CALL_EXPR_FN (exp), 0)) == FUNCTION_DECL)
586 && (special_function_p (TREE_OPERAND (CALL_EXPR_FN (exp), 0), 0)
587 & ECF_MAY_BE_ALLOCA))
588 return true;
589 return false;
592 /* Detect flags (function attributes) from the function decl or type node. */
595 flags_from_decl_or_type (const_tree exp)
597 int flags = 0;
599 if (DECL_P (exp))
601 /* The function exp may have the `malloc' attribute. */
602 if (DECL_IS_MALLOC (exp))
603 flags |= ECF_MALLOC;
605 /* The function exp may have the `returns_twice' attribute. */
606 if (DECL_IS_RETURNS_TWICE (exp))
607 flags |= ECF_RETURNS_TWICE;
609 /* Process the pure and const attributes. */
610 if (TREE_READONLY (exp))
611 flags |= ECF_CONST;
612 if (DECL_PURE_P (exp))
613 flags |= ECF_PURE;
614 if (DECL_LOOPING_CONST_OR_PURE_P (exp))
615 flags |= ECF_LOOPING_CONST_OR_PURE;
617 if (DECL_IS_NOVOPS (exp))
618 flags |= ECF_NOVOPS;
619 if (lookup_attribute ("leaf", DECL_ATTRIBUTES (exp)))
620 flags |= ECF_LEAF;
622 if (TREE_NOTHROW (exp))
623 flags |= ECF_NOTHROW;
625 flags = special_function_p (exp, flags);
627 else if (TYPE_P (exp) && TYPE_READONLY (exp))
628 flags |= ECF_CONST;
630 if (TREE_THIS_VOLATILE (exp))
632 flags |= ECF_NORETURN;
633 if (flags & (ECF_CONST|ECF_PURE))
634 flags |= ECF_LOOPING_CONST_OR_PURE;
637 return flags;
640 /* Detect flags from a CALL_EXPR. */
643 call_expr_flags (const_tree t)
645 int flags;
646 tree decl = get_callee_fndecl (t);
648 if (decl)
649 flags = flags_from_decl_or_type (decl);
650 else
652 t = TREE_TYPE (CALL_EXPR_FN (t));
653 if (t && TREE_CODE (t) == POINTER_TYPE)
654 flags = flags_from_decl_or_type (TREE_TYPE (t));
655 else
656 flags = 0;
659 return flags;
662 /* Precompute all register parameters as described by ARGS, storing values
663 into fields within the ARGS array.
665 NUM_ACTUALS indicates the total number elements in the ARGS array.
667 Set REG_PARM_SEEN if we encounter a register parameter. */
669 static void
670 precompute_register_parameters (int num_actuals, struct arg_data *args,
671 int *reg_parm_seen)
673 int i;
675 *reg_parm_seen = 0;
677 for (i = 0; i < num_actuals; i++)
678 if (args[i].reg != 0 && ! args[i].pass_on_stack)
680 *reg_parm_seen = 1;
682 if (args[i].value == 0)
684 push_temp_slots ();
685 args[i].value = expand_normal (args[i].tree_value);
686 preserve_temp_slots (args[i].value);
687 pop_temp_slots ();
690 /* If the value is a non-legitimate constant, force it into a
691 pseudo now. TLS symbols sometimes need a call to resolve. */
692 if (CONSTANT_P (args[i].value)
693 && !targetm.legitimate_constant_p (args[i].mode, args[i].value))
694 args[i].value = force_reg (args[i].mode, args[i].value);
696 /* If we are to promote the function arg to a wider mode,
697 do it now. */
699 if (args[i].mode != TYPE_MODE (TREE_TYPE (args[i].tree_value)))
700 args[i].value
701 = convert_modes (args[i].mode,
702 TYPE_MODE (TREE_TYPE (args[i].tree_value)),
703 args[i].value, args[i].unsignedp);
705 /* If we're going to have to load the value by parts, pull the
706 parts into pseudos. The part extraction process can involve
707 non-trivial computation. */
708 if (GET_CODE (args[i].reg) == PARALLEL)
710 tree type = TREE_TYPE (args[i].tree_value);
711 args[i].parallel_value
712 = emit_group_load_into_temps (args[i].reg, args[i].value,
713 type, int_size_in_bytes (type));
716 /* If the value is expensive, and we are inside an appropriately
717 short loop, put the value into a pseudo and then put the pseudo
718 into the hard reg.
720 For small register classes, also do this if this call uses
721 register parameters. This is to avoid reload conflicts while
722 loading the parameters registers. */
724 else if ((! (REG_P (args[i].value)
725 || (GET_CODE (args[i].value) == SUBREG
726 && REG_P (SUBREG_REG (args[i].value)))))
727 && args[i].mode != BLKmode
728 && rtx_cost (args[i].value, SET, optimize_insn_for_speed_p ())
729 > COSTS_N_INSNS (1)
730 && ((*reg_parm_seen
731 && targetm.small_register_classes_for_mode_p (args[i].mode))
732 || optimize))
733 args[i].value = copy_to_mode_reg (args[i].mode, args[i].value);
737 #ifdef REG_PARM_STACK_SPACE
739 /* The argument list is the property of the called routine and it
740 may clobber it. If the fixed area has been used for previous
741 parameters, we must save and restore it. */
743 static rtx
744 save_fixed_argument_area (int reg_parm_stack_space, rtx argblock, int *low_to_save, int *high_to_save)
746 int low;
747 int high;
749 /* Compute the boundary of the area that needs to be saved, if any. */
750 high = reg_parm_stack_space;
751 #ifdef ARGS_GROW_DOWNWARD
752 high += 1;
753 #endif
754 if (high > highest_outgoing_arg_in_use)
755 high = highest_outgoing_arg_in_use;
757 for (low = 0; low < high; low++)
758 if (stack_usage_map[low] != 0)
760 int num_to_save;
761 enum machine_mode save_mode;
762 int delta;
763 rtx stack_area;
764 rtx save_area;
766 while (stack_usage_map[--high] == 0)
769 *low_to_save = low;
770 *high_to_save = high;
772 num_to_save = high - low + 1;
773 save_mode = mode_for_size (num_to_save * BITS_PER_UNIT, MODE_INT, 1);
775 /* If we don't have the required alignment, must do this
776 in BLKmode. */
777 if ((low & (MIN (GET_MODE_SIZE (save_mode),
778 BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1)))
779 save_mode = BLKmode;
781 #ifdef ARGS_GROW_DOWNWARD
782 delta = -high;
783 #else
784 delta = low;
785 #endif
786 stack_area = gen_rtx_MEM (save_mode,
787 memory_address (save_mode,
788 plus_constant (argblock,
789 delta)));
791 set_mem_align (stack_area, PARM_BOUNDARY);
792 if (save_mode == BLKmode)
794 save_area = assign_stack_temp (BLKmode, num_to_save, 0);
795 emit_block_move (validize_mem (save_area), stack_area,
796 GEN_INT (num_to_save), BLOCK_OP_CALL_PARM);
798 else
800 save_area = gen_reg_rtx (save_mode);
801 emit_move_insn (save_area, stack_area);
804 return save_area;
807 return NULL_RTX;
810 static void
811 restore_fixed_argument_area (rtx save_area, rtx argblock, int high_to_save, int low_to_save)
813 enum machine_mode save_mode = GET_MODE (save_area);
814 int delta;
815 rtx stack_area;
817 #ifdef ARGS_GROW_DOWNWARD
818 delta = -high_to_save;
819 #else
820 delta = low_to_save;
821 #endif
822 stack_area = gen_rtx_MEM (save_mode,
823 memory_address (save_mode,
824 plus_constant (argblock, delta)));
825 set_mem_align (stack_area, PARM_BOUNDARY);
827 if (save_mode != BLKmode)
828 emit_move_insn (stack_area, save_area);
829 else
830 emit_block_move (stack_area, validize_mem (save_area),
831 GEN_INT (high_to_save - low_to_save + 1),
832 BLOCK_OP_CALL_PARM);
834 #endif /* REG_PARM_STACK_SPACE */
836 /* If any elements in ARGS refer to parameters that are to be passed in
837 registers, but not in memory, and whose alignment does not permit a
838 direct copy into registers. Copy the values into a group of pseudos
839 which we will later copy into the appropriate hard registers.
841 Pseudos for each unaligned argument will be stored into the array
842 args[argnum].aligned_regs. The caller is responsible for deallocating
843 the aligned_regs array if it is nonzero. */
845 static void
846 store_unaligned_arguments_into_pseudos (struct arg_data *args, int num_actuals)
848 int i, j;
850 for (i = 0; i < num_actuals; i++)
851 if (args[i].reg != 0 && ! args[i].pass_on_stack
852 && args[i].mode == BLKmode
853 && MEM_P (args[i].value)
854 && (MEM_ALIGN (args[i].value)
855 < (unsigned int) MIN (BIGGEST_ALIGNMENT, BITS_PER_WORD)))
857 int bytes = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
858 int endian_correction = 0;
860 if (args[i].partial)
862 gcc_assert (args[i].partial % UNITS_PER_WORD == 0);
863 args[i].n_aligned_regs = args[i].partial / UNITS_PER_WORD;
865 else
867 args[i].n_aligned_regs
868 = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
871 args[i].aligned_regs = XNEWVEC (rtx, args[i].n_aligned_regs);
873 /* Structures smaller than a word are normally aligned to the
874 least significant byte. On a BYTES_BIG_ENDIAN machine,
875 this means we must skip the empty high order bytes when
876 calculating the bit offset. */
877 if (bytes < UNITS_PER_WORD
878 #ifdef BLOCK_REG_PADDING
879 && (BLOCK_REG_PADDING (args[i].mode,
880 TREE_TYPE (args[i].tree_value), 1)
881 == downward)
882 #else
883 && BYTES_BIG_ENDIAN
884 #endif
886 endian_correction = BITS_PER_WORD - bytes * BITS_PER_UNIT;
888 for (j = 0; j < args[i].n_aligned_regs; j++)
890 rtx reg = gen_reg_rtx (word_mode);
891 rtx word = operand_subword_force (args[i].value, j, BLKmode);
892 int bitsize = MIN (bytes * BITS_PER_UNIT, BITS_PER_WORD);
894 args[i].aligned_regs[j] = reg;
895 word = extract_bit_field (word, bitsize, 0, 1, false, NULL_RTX,
896 word_mode, word_mode);
898 /* There is no need to restrict this code to loading items
899 in TYPE_ALIGN sized hunks. The bitfield instructions can
900 load up entire word sized registers efficiently.
902 ??? This may not be needed anymore.
903 We use to emit a clobber here but that doesn't let later
904 passes optimize the instructions we emit. By storing 0 into
905 the register later passes know the first AND to zero out the
906 bitfield being set in the register is unnecessary. The store
907 of 0 will be deleted as will at least the first AND. */
909 emit_move_insn (reg, const0_rtx);
911 bytes -= bitsize / BITS_PER_UNIT;
912 store_bit_field (reg, bitsize, endian_correction, word_mode,
913 word);
918 /* Fill in ARGS_SIZE and ARGS array based on the parameters found in
919 CALL_EXPR EXP.
921 NUM_ACTUALS is the total number of parameters.
923 N_NAMED_ARGS is the total number of named arguments.
925 STRUCT_VALUE_ADDR_VALUE is the implicit argument for a struct return
926 value, or null.
928 FNDECL is the tree code for the target of this call (if known)
930 ARGS_SO_FAR holds state needed by the target to know where to place
931 the next argument.
933 REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
934 for arguments which are passed in registers.
936 OLD_STACK_LEVEL is a pointer to an rtx which olds the old stack level
937 and may be modified by this routine.
939 OLD_PENDING_ADJ, MUST_PREALLOCATE and FLAGS are pointers to integer
940 flags which may may be modified by this routine.
942 MAY_TAILCALL is cleared if we encounter an invisible pass-by-reference
943 that requires allocation of stack space.
945 CALL_FROM_THUNK_P is true if this call is the jump from a thunk to
946 the thunked-to function. */
948 static void
949 initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
950 struct arg_data *args,
951 struct args_size *args_size,
952 int n_named_args ATTRIBUTE_UNUSED,
953 tree exp, tree struct_value_addr_value,
954 tree fndecl, tree fntype,
955 CUMULATIVE_ARGS *args_so_far,
956 int reg_parm_stack_space,
957 rtx *old_stack_level, int *old_pending_adj,
958 int *must_preallocate, int *ecf_flags,
959 bool *may_tailcall, bool call_from_thunk_p)
961 location_t loc = EXPR_LOCATION (exp);
962 /* 1 if scanning parms front to back, -1 if scanning back to front. */
963 int inc;
965 /* Count arg position in order args appear. */
966 int argpos;
968 int i;
970 args_size->constant = 0;
971 args_size->var = 0;
973 /* In this loop, we consider args in the order they are written.
974 We fill up ARGS from the front or from the back if necessary
975 so that in any case the first arg to be pushed ends up at the front. */
977 if (PUSH_ARGS_REVERSED)
979 i = num_actuals - 1, inc = -1;
980 /* In this case, must reverse order of args
981 so that we compute and push the last arg first. */
983 else
985 i = 0, inc = 1;
988 /* First fill in the actual arguments in the ARGS array, splitting
989 complex arguments if necessary. */
991 int j = i;
992 call_expr_arg_iterator iter;
993 tree arg;
995 if (struct_value_addr_value)
997 args[j].tree_value = struct_value_addr_value;
998 j += inc;
1000 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
1002 tree argtype = TREE_TYPE (arg);
1003 if (targetm.calls.split_complex_arg
1004 && argtype
1005 && TREE_CODE (argtype) == COMPLEX_TYPE
1006 && targetm.calls.split_complex_arg (argtype))
1008 tree subtype = TREE_TYPE (argtype);
1009 args[j].tree_value = build1 (REALPART_EXPR, subtype, arg);
1010 j += inc;
1011 args[j].tree_value = build1 (IMAGPART_EXPR, subtype, arg);
1013 else
1014 args[j].tree_value = arg;
1015 j += inc;
1019 /* I counts args in order (to be) pushed; ARGPOS counts in order written. */
1020 for (argpos = 0; argpos < num_actuals; i += inc, argpos++)
1022 tree type = TREE_TYPE (args[i].tree_value);
1023 int unsignedp;
1024 enum machine_mode mode;
1026 /* Replace erroneous argument with constant zero. */
1027 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
1028 args[i].tree_value = integer_zero_node, type = integer_type_node;
1030 /* If TYPE is a transparent union or record, pass things the way
1031 we would pass the first field of the union or record. We have
1032 already verified that the modes are the same. */
1033 if ((TREE_CODE (type) == UNION_TYPE || TREE_CODE (type) == RECORD_TYPE)
1034 && TYPE_TRANSPARENT_AGGR (type))
1035 type = TREE_TYPE (first_field (type));
1037 /* Decide where to pass this arg.
1039 args[i].reg is nonzero if all or part is passed in registers.
1041 args[i].partial is nonzero if part but not all is passed in registers,
1042 and the exact value says how many bytes are passed in registers.
1044 args[i].pass_on_stack is nonzero if the argument must at least be
1045 computed on the stack. It may then be loaded back into registers
1046 if args[i].reg is nonzero.
1048 These decisions are driven by the FUNCTION_... macros and must agree
1049 with those made by function.c. */
1051 /* See if this argument should be passed by invisible reference. */
1052 if (pass_by_reference (args_so_far, TYPE_MODE (type),
1053 type, argpos < n_named_args))
1055 bool callee_copies;
1056 tree base;
1058 callee_copies
1059 = reference_callee_copied (args_so_far, TYPE_MODE (type),
1060 type, argpos < n_named_args);
1062 /* If we're compiling a thunk, pass through invisible references
1063 instead of making a copy. */
1064 if (call_from_thunk_p
1065 || (callee_copies
1066 && !TREE_ADDRESSABLE (type)
1067 && (base = get_base_address (args[i].tree_value))
1068 && TREE_CODE (base) != SSA_NAME
1069 && (!DECL_P (base) || MEM_P (DECL_RTL (base)))))
1071 /* We can't use sibcalls if a callee-copied argument is
1072 stored in the current function's frame. */
1073 if (!call_from_thunk_p && DECL_P (base) && !TREE_STATIC (base))
1074 *may_tailcall = false;
1076 args[i].tree_value = build_fold_addr_expr_loc (loc,
1077 args[i].tree_value);
1078 type = TREE_TYPE (args[i].tree_value);
1080 if (*ecf_flags & ECF_CONST)
1081 *ecf_flags &= ~(ECF_CONST | ECF_LOOPING_CONST_OR_PURE);
1083 else
1085 /* We make a copy of the object and pass the address to the
1086 function being called. */
1087 rtx copy;
1089 if (!COMPLETE_TYPE_P (type)
1090 || TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST
1091 || (flag_stack_check == GENERIC_STACK_CHECK
1092 && compare_tree_int (TYPE_SIZE_UNIT (type),
1093 STACK_CHECK_MAX_VAR_SIZE) > 0))
1095 /* This is a variable-sized object. Make space on the stack
1096 for it. */
1097 rtx size_rtx = expr_size (args[i].tree_value);
1099 if (*old_stack_level == 0)
1101 emit_stack_save (SAVE_BLOCK, old_stack_level);
1102 *old_pending_adj = pending_stack_adjust;
1103 pending_stack_adjust = 0;
1106 /* We can pass TRUE as the 4th argument because we just
1107 saved the stack pointer and will restore it right after
1108 the call. */
1109 copy = allocate_dynamic_stack_space (size_rtx,
1110 TYPE_ALIGN (type),
1111 TYPE_ALIGN (type),
1112 true);
1113 copy = gen_rtx_MEM (BLKmode, copy);
1114 set_mem_attributes (copy, type, 1);
1116 else
1117 copy = assign_temp (type, 0, 1, 0);
1119 store_expr (args[i].tree_value, copy, 0, false);
1121 /* Just change the const function to pure and then let
1122 the next test clear the pure based on
1123 callee_copies. */
1124 if (*ecf_flags & ECF_CONST)
1126 *ecf_flags &= ~ECF_CONST;
1127 *ecf_flags |= ECF_PURE;
1130 if (!callee_copies && *ecf_flags & ECF_PURE)
1131 *ecf_flags &= ~(ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
1133 args[i].tree_value
1134 = build_fold_addr_expr_loc (loc, make_tree (type, copy));
1135 type = TREE_TYPE (args[i].tree_value);
1136 *may_tailcall = false;
1140 unsignedp = TYPE_UNSIGNED (type);
1141 mode = promote_function_mode (type, TYPE_MODE (type), &unsignedp,
1142 fndecl ? TREE_TYPE (fndecl) : fntype, 0);
1144 args[i].unsignedp = unsignedp;
1145 args[i].mode = mode;
1147 args[i].reg = targetm.calls.function_arg (args_so_far, mode, type,
1148 argpos < n_named_args);
1150 /* If this is a sibling call and the machine has register windows, the
1151 register window has to be unwinded before calling the routine, so
1152 arguments have to go into the incoming registers. */
1153 if (targetm.calls.function_incoming_arg != targetm.calls.function_arg)
1154 args[i].tail_call_reg
1155 = targetm.calls.function_incoming_arg (args_so_far, mode, type,
1156 argpos < n_named_args);
1157 else
1158 args[i].tail_call_reg = args[i].reg;
1160 if (args[i].reg)
1161 args[i].partial
1162 = targetm.calls.arg_partial_bytes (args_so_far, mode, type,
1163 argpos < n_named_args);
1165 args[i].pass_on_stack = targetm.calls.must_pass_in_stack (mode, type);
1167 /* If FUNCTION_ARG returned a (parallel [(expr_list (nil) ...) ...]),
1168 it means that we are to pass this arg in the register(s) designated
1169 by the PARALLEL, but also to pass it in the stack. */
1170 if (args[i].reg && GET_CODE (args[i].reg) == PARALLEL
1171 && XEXP (XVECEXP (args[i].reg, 0, 0), 0) == 0)
1172 args[i].pass_on_stack = 1;
1174 /* If this is an addressable type, we must preallocate the stack
1175 since we must evaluate the object into its final location.
1177 If this is to be passed in both registers and the stack, it is simpler
1178 to preallocate. */
1179 if (TREE_ADDRESSABLE (type)
1180 || (args[i].pass_on_stack && args[i].reg != 0))
1181 *must_preallocate = 1;
1183 /* Compute the stack-size of this argument. */
1184 if (args[i].reg == 0 || args[i].partial != 0
1185 || reg_parm_stack_space > 0
1186 || args[i].pass_on_stack)
1187 locate_and_pad_parm (mode, type,
1188 #ifdef STACK_PARMS_IN_REG_PARM_AREA
1190 #else
1191 args[i].reg != 0,
1192 #endif
1193 args[i].pass_on_stack ? 0 : args[i].partial,
1194 fndecl, args_size, &args[i].locate);
1195 #ifdef BLOCK_REG_PADDING
1196 else
1197 /* The argument is passed entirely in registers. See at which
1198 end it should be padded. */
1199 args[i].locate.where_pad =
1200 BLOCK_REG_PADDING (mode, type,
1201 int_size_in_bytes (type) <= UNITS_PER_WORD);
1202 #endif
1204 /* Update ARGS_SIZE, the total stack space for args so far. */
1206 args_size->constant += args[i].locate.size.constant;
1207 if (args[i].locate.size.var)
1208 ADD_PARM_SIZE (*args_size, args[i].locate.size.var);
1210 /* Increment ARGS_SO_FAR, which has info about which arg-registers
1211 have been used, etc. */
1213 targetm.calls.function_arg_advance (args_so_far, TYPE_MODE (type),
1214 type, argpos < n_named_args);
1218 /* Update ARGS_SIZE to contain the total size for the argument block.
1219 Return the original constant component of the argument block's size.
1221 REG_PARM_STACK_SPACE holds the number of bytes of stack space reserved
1222 for arguments passed in registers. */
1224 static int
1225 compute_argument_block_size (int reg_parm_stack_space,
1226 struct args_size *args_size,
1227 tree fndecl ATTRIBUTE_UNUSED,
1228 tree fntype ATTRIBUTE_UNUSED,
1229 int preferred_stack_boundary ATTRIBUTE_UNUSED)
1231 int unadjusted_args_size = args_size->constant;
1233 /* For accumulate outgoing args mode we don't need to align, since the frame
1234 will be already aligned. Align to STACK_BOUNDARY in order to prevent
1235 backends from generating misaligned frame sizes. */
1236 if (ACCUMULATE_OUTGOING_ARGS && preferred_stack_boundary > STACK_BOUNDARY)
1237 preferred_stack_boundary = STACK_BOUNDARY;
1239 /* Compute the actual size of the argument block required. The variable
1240 and constant sizes must be combined, the size may have to be rounded,
1241 and there may be a minimum required size. */
1243 if (args_size->var)
1245 args_size->var = ARGS_SIZE_TREE (*args_size);
1246 args_size->constant = 0;
1248 preferred_stack_boundary /= BITS_PER_UNIT;
1249 if (preferred_stack_boundary > 1)
1251 /* We don't handle this case yet. To handle it correctly we have
1252 to add the delta, round and subtract the delta.
1253 Currently no machine description requires this support. */
1254 gcc_assert (!(stack_pointer_delta & (preferred_stack_boundary - 1)));
1255 args_size->var = round_up (args_size->var, preferred_stack_boundary);
1258 if (reg_parm_stack_space > 0)
1260 args_size->var
1261 = size_binop (MAX_EXPR, args_size->var,
1262 ssize_int (reg_parm_stack_space));
1264 /* The area corresponding to register parameters is not to count in
1265 the size of the block we need. So make the adjustment. */
1266 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
1267 args_size->var
1268 = size_binop (MINUS_EXPR, args_size->var,
1269 ssize_int (reg_parm_stack_space));
1272 else
1274 preferred_stack_boundary /= BITS_PER_UNIT;
1275 if (preferred_stack_boundary < 1)
1276 preferred_stack_boundary = 1;
1277 args_size->constant = (((args_size->constant
1278 + stack_pointer_delta
1279 + preferred_stack_boundary - 1)
1280 / preferred_stack_boundary
1281 * preferred_stack_boundary)
1282 - stack_pointer_delta);
1284 args_size->constant = MAX (args_size->constant,
1285 reg_parm_stack_space);
1287 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
1288 args_size->constant -= reg_parm_stack_space;
1290 return unadjusted_args_size;
1293 /* Precompute parameters as needed for a function call.
1295 FLAGS is mask of ECF_* constants.
1297 NUM_ACTUALS is the number of arguments.
1299 ARGS is an array containing information for each argument; this
1300 routine fills in the INITIAL_VALUE and VALUE fields for each
1301 precomputed argument. */
1303 static void
1304 precompute_arguments (int num_actuals, struct arg_data *args)
1306 int i;
1308 /* If this is a libcall, then precompute all arguments so that we do not
1309 get extraneous instructions emitted as part of the libcall sequence. */
1311 /* If we preallocated the stack space, and some arguments must be passed
1312 on the stack, then we must precompute any parameter which contains a
1313 function call which will store arguments on the stack.
1314 Otherwise, evaluating the parameter may clobber previous parameters
1315 which have already been stored into the stack. (we have code to avoid
1316 such case by saving the outgoing stack arguments, but it results in
1317 worse code) */
1318 if (!ACCUMULATE_OUTGOING_ARGS)
1319 return;
1321 for (i = 0; i < num_actuals; i++)
1323 tree type;
1324 enum machine_mode mode;
1326 if (TREE_CODE (args[i].tree_value) != CALL_EXPR)
1327 continue;
1329 /* If this is an addressable type, we cannot pre-evaluate it. */
1330 type = TREE_TYPE (args[i].tree_value);
1331 gcc_assert (!TREE_ADDRESSABLE (type));
1333 args[i].initial_value = args[i].value
1334 = expand_normal (args[i].tree_value);
1336 mode = TYPE_MODE (type);
1337 if (mode != args[i].mode)
1339 int unsignedp = args[i].unsignedp;
1340 args[i].value
1341 = convert_modes (args[i].mode, mode,
1342 args[i].value, args[i].unsignedp);
1344 /* CSE will replace this only if it contains args[i].value
1345 pseudo, so convert it down to the declared mode using
1346 a SUBREG. */
1347 if (REG_P (args[i].value)
1348 && GET_MODE_CLASS (args[i].mode) == MODE_INT
1349 && promote_mode (type, mode, &unsignedp) != args[i].mode)
1351 args[i].initial_value
1352 = gen_lowpart_SUBREG (mode, args[i].value);
1353 SUBREG_PROMOTED_VAR_P (args[i].initial_value) = 1;
1354 SUBREG_PROMOTED_UNSIGNED_SET (args[i].initial_value,
1355 args[i].unsignedp);
1361 /* Given the current state of MUST_PREALLOCATE and information about
1362 arguments to a function call in NUM_ACTUALS, ARGS and ARGS_SIZE,
1363 compute and return the final value for MUST_PREALLOCATE. */
1365 static int
1366 finalize_must_preallocate (int must_preallocate, int num_actuals,
1367 struct arg_data *args, struct args_size *args_size)
1369 /* See if we have or want to preallocate stack space.
1371 If we would have to push a partially-in-regs parm
1372 before other stack parms, preallocate stack space instead.
1374 If the size of some parm is not a multiple of the required stack
1375 alignment, we must preallocate.
1377 If the total size of arguments that would otherwise create a copy in
1378 a temporary (such as a CALL) is more than half the total argument list
1379 size, preallocation is faster.
1381 Another reason to preallocate is if we have a machine (like the m88k)
1382 where stack alignment is required to be maintained between every
1383 pair of insns, not just when the call is made. However, we assume here
1384 that such machines either do not have push insns (and hence preallocation
1385 would occur anyway) or the problem is taken care of with
1386 PUSH_ROUNDING. */
1388 if (! must_preallocate)
1390 int partial_seen = 0;
1391 int copy_to_evaluate_size = 0;
1392 int i;
1394 for (i = 0; i < num_actuals && ! must_preallocate; i++)
1396 if (args[i].partial > 0 && ! args[i].pass_on_stack)
1397 partial_seen = 1;
1398 else if (partial_seen && args[i].reg == 0)
1399 must_preallocate = 1;
1401 if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
1402 && (TREE_CODE (args[i].tree_value) == CALL_EXPR
1403 || TREE_CODE (args[i].tree_value) == TARGET_EXPR
1404 || TREE_CODE (args[i].tree_value) == COND_EXPR
1405 || TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value))))
1406 copy_to_evaluate_size
1407 += int_size_in_bytes (TREE_TYPE (args[i].tree_value));
1410 if (copy_to_evaluate_size * 2 >= args_size->constant
1411 && args_size->constant > 0)
1412 must_preallocate = 1;
1414 return must_preallocate;
1417 /* If we preallocated stack space, compute the address of each argument
1418 and store it into the ARGS array.
1420 We need not ensure it is a valid memory address here; it will be
1421 validized when it is used.
1423 ARGBLOCK is an rtx for the address of the outgoing arguments. */
1425 static void
1426 compute_argument_addresses (struct arg_data *args, rtx argblock, int num_actuals)
1428 if (argblock)
1430 rtx arg_reg = argblock;
1431 int i, arg_offset = 0;
1433 if (GET_CODE (argblock) == PLUS)
1434 arg_reg = XEXP (argblock, 0), arg_offset = INTVAL (XEXP (argblock, 1));
1436 for (i = 0; i < num_actuals; i++)
1438 rtx offset = ARGS_SIZE_RTX (args[i].locate.offset);
1439 rtx slot_offset = ARGS_SIZE_RTX (args[i].locate.slot_offset);
1440 rtx addr;
1441 unsigned int align, boundary;
1442 unsigned int units_on_stack = 0;
1443 enum machine_mode partial_mode = VOIDmode;
1445 /* Skip this parm if it will not be passed on the stack. */
1446 if (! args[i].pass_on_stack
1447 && args[i].reg != 0
1448 && args[i].partial == 0)
1449 continue;
1451 if (CONST_INT_P (offset))
1452 addr = plus_constant (arg_reg, INTVAL (offset));
1453 else
1454 addr = gen_rtx_PLUS (Pmode, arg_reg, offset);
1456 addr = plus_constant (addr, arg_offset);
1458 if (args[i].partial != 0)
1460 /* Only part of the parameter is being passed on the stack.
1461 Generate a simple memory reference of the correct size. */
1462 units_on_stack = args[i].locate.size.constant;
1463 partial_mode = mode_for_size (units_on_stack * BITS_PER_UNIT,
1464 MODE_INT, 1);
1465 args[i].stack = gen_rtx_MEM (partial_mode, addr);
1466 set_mem_size (args[i].stack, GEN_INT (units_on_stack));
1468 else
1470 args[i].stack = gen_rtx_MEM (args[i].mode, addr);
1471 set_mem_attributes (args[i].stack,
1472 TREE_TYPE (args[i].tree_value), 1);
1474 align = BITS_PER_UNIT;
1475 boundary = args[i].locate.boundary;
1476 if (args[i].locate.where_pad != downward)
1477 align = boundary;
1478 else if (CONST_INT_P (offset))
1480 align = INTVAL (offset) * BITS_PER_UNIT | boundary;
1481 align = align & -align;
1483 set_mem_align (args[i].stack, align);
1485 if (CONST_INT_P (slot_offset))
1486 addr = plus_constant (arg_reg, INTVAL (slot_offset));
1487 else
1488 addr = gen_rtx_PLUS (Pmode, arg_reg, slot_offset);
1490 addr = plus_constant (addr, arg_offset);
1492 if (args[i].partial != 0)
1494 /* Only part of the parameter is being passed on the stack.
1495 Generate a simple memory reference of the correct size.
1497 args[i].stack_slot = gen_rtx_MEM (partial_mode, addr);
1498 set_mem_size (args[i].stack_slot, GEN_INT (units_on_stack));
1500 else
1502 args[i].stack_slot = gen_rtx_MEM (args[i].mode, addr);
1503 set_mem_attributes (args[i].stack_slot,
1504 TREE_TYPE (args[i].tree_value), 1);
1506 set_mem_align (args[i].stack_slot, args[i].locate.boundary);
1508 /* Function incoming arguments may overlap with sibling call
1509 outgoing arguments and we cannot allow reordering of reads
1510 from function arguments with stores to outgoing arguments
1511 of sibling calls. */
1512 set_mem_alias_set (args[i].stack, 0);
1513 set_mem_alias_set (args[i].stack_slot, 0);
1518 /* Given a FNDECL and EXP, return an rtx suitable for use as a target address
1519 in a call instruction.
1521 FNDECL is the tree node for the target function. For an indirect call
1522 FNDECL will be NULL_TREE.
1524 ADDR is the operand 0 of CALL_EXPR for this call. */
1526 static rtx
1527 rtx_for_function_call (tree fndecl, tree addr)
1529 rtx funexp;
1531 /* Get the function to call, in the form of RTL. */
1532 if (fndecl)
1534 /* If this is the first use of the function, see if we need to
1535 make an external definition for it. */
1536 if (!TREE_USED (fndecl) && fndecl != current_function_decl)
1538 assemble_external (fndecl);
1539 TREE_USED (fndecl) = 1;
1542 /* Get a SYMBOL_REF rtx for the function address. */
1543 funexp = XEXP (DECL_RTL (fndecl), 0);
1545 else
1546 /* Generate an rtx (probably a pseudo-register) for the address. */
1548 push_temp_slots ();
1549 funexp = expand_normal (addr);
1550 pop_temp_slots (); /* FUNEXP can't be BLKmode. */
1552 return funexp;
1555 /* Return true if and only if SIZE storage units (usually bytes)
1556 starting from address ADDR overlap with already clobbered argument
1557 area. This function is used to determine if we should give up a
1558 sibcall. */
1560 static bool
1561 mem_overlaps_already_clobbered_arg_p (rtx addr, unsigned HOST_WIDE_INT size)
1563 HOST_WIDE_INT i;
1565 if (addr == crtl->args.internal_arg_pointer)
1566 i = 0;
1567 else if (GET_CODE (addr) == PLUS
1568 && XEXP (addr, 0) == crtl->args.internal_arg_pointer
1569 && CONST_INT_P (XEXP (addr, 1)))
1570 i = INTVAL (XEXP (addr, 1));
1571 /* Return true for arg pointer based indexed addressing. */
1572 else if (GET_CODE (addr) == PLUS
1573 && (XEXP (addr, 0) == crtl->args.internal_arg_pointer
1574 || XEXP (addr, 1) == crtl->args.internal_arg_pointer))
1575 return true;
1576 else
1577 return false;
1579 #ifdef ARGS_GROW_DOWNWARD
1580 i = -i - size;
1581 #endif
1582 if (size > 0)
1584 unsigned HOST_WIDE_INT k;
1586 for (k = 0; k < size; k++)
1587 if (i + k < stored_args_map->n_bits
1588 && TEST_BIT (stored_args_map, i + k))
1589 return true;
1592 return false;
1595 /* Do the register loads required for any wholly-register parms or any
1596 parms which are passed both on the stack and in a register. Their
1597 expressions were already evaluated.
1599 Mark all register-parms as living through the call, putting these USE
1600 insns in the CALL_INSN_FUNCTION_USAGE field.
1602 When IS_SIBCALL, perform the check_sibcall_argument_overlap
1603 checking, setting *SIBCALL_FAILURE if appropriate. */
1605 static void
1606 load_register_parameters (struct arg_data *args, int num_actuals,
1607 rtx *call_fusage, int flags, int is_sibcall,
1608 int *sibcall_failure)
1610 int i, j;
1612 for (i = 0; i < num_actuals; i++)
1614 rtx reg = ((flags & ECF_SIBCALL)
1615 ? args[i].tail_call_reg : args[i].reg);
1616 if (reg)
1618 int partial = args[i].partial;
1619 int nregs;
1620 int size = 0;
1621 rtx before_arg = get_last_insn ();
1622 /* Set non-negative if we must move a word at a time, even if
1623 just one word (e.g, partial == 4 && mode == DFmode). Set
1624 to -1 if we just use a normal move insn. This value can be
1625 zero if the argument is a zero size structure. */
1626 nregs = -1;
1627 if (GET_CODE (reg) == PARALLEL)
1629 else if (partial)
1631 gcc_assert (partial % UNITS_PER_WORD == 0);
1632 nregs = partial / UNITS_PER_WORD;
1634 else if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode)
1636 size = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
1637 nregs = (size + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
1639 else
1640 size = GET_MODE_SIZE (args[i].mode);
1642 /* Handle calls that pass values in multiple non-contiguous
1643 locations. The Irix 6 ABI has examples of this. */
1645 if (GET_CODE (reg) == PARALLEL)
1646 emit_group_move (reg, args[i].parallel_value);
1648 /* If simple case, just do move. If normal partial, store_one_arg
1649 has already loaded the register for us. In all other cases,
1650 load the register(s) from memory. */
1652 else if (nregs == -1)
1654 emit_move_insn (reg, args[i].value);
1655 #ifdef BLOCK_REG_PADDING
1656 /* Handle case where we have a value that needs shifting
1657 up to the msb. eg. a QImode value and we're padding
1658 upward on a BYTES_BIG_ENDIAN machine. */
1659 if (size < UNITS_PER_WORD
1660 && (args[i].locate.where_pad
1661 == (BYTES_BIG_ENDIAN ? upward : downward)))
1663 rtx x;
1664 int shift = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
1666 /* Assigning REG here rather than a temp makes CALL_FUSAGE
1667 report the whole reg as used. Strictly speaking, the
1668 call only uses SIZE bytes at the msb end, but it doesn't
1669 seem worth generating rtl to say that. */
1670 reg = gen_rtx_REG (word_mode, REGNO (reg));
1671 x = expand_shift (LSHIFT_EXPR, word_mode, reg, shift, reg, 1);
1672 if (x != reg)
1673 emit_move_insn (reg, x);
1675 #endif
1678 /* If we have pre-computed the values to put in the registers in
1679 the case of non-aligned structures, copy them in now. */
1681 else if (args[i].n_aligned_regs != 0)
1682 for (j = 0; j < args[i].n_aligned_regs; j++)
1683 emit_move_insn (gen_rtx_REG (word_mode, REGNO (reg) + j),
1684 args[i].aligned_regs[j]);
1686 else if (partial == 0 || args[i].pass_on_stack)
1688 rtx mem = validize_mem (args[i].value);
1690 /* Check for overlap with already clobbered argument area,
1691 providing that this has non-zero size. */
1692 if (is_sibcall
1693 && (size == 0
1694 || mem_overlaps_already_clobbered_arg_p
1695 (XEXP (args[i].value, 0), size)))
1696 *sibcall_failure = 1;
1698 /* Handle a BLKmode that needs shifting. */
1699 if (nregs == 1 && size < UNITS_PER_WORD
1700 #ifdef BLOCK_REG_PADDING
1701 && args[i].locate.where_pad == downward
1702 #else
1703 && BYTES_BIG_ENDIAN
1704 #endif
1707 rtx tem = operand_subword_force (mem, 0, args[i].mode);
1708 rtx ri = gen_rtx_REG (word_mode, REGNO (reg));
1709 rtx x = gen_reg_rtx (word_mode);
1710 int shift = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
1711 enum tree_code dir = BYTES_BIG_ENDIAN ? RSHIFT_EXPR
1712 : LSHIFT_EXPR;
1714 emit_move_insn (x, tem);
1715 x = expand_shift (dir, word_mode, x, shift, ri, 1);
1716 if (x != ri)
1717 emit_move_insn (ri, x);
1719 else
1720 move_block_to_reg (REGNO (reg), mem, nregs, args[i].mode);
1723 /* When a parameter is a block, and perhaps in other cases, it is
1724 possible that it did a load from an argument slot that was
1725 already clobbered. */
1726 if (is_sibcall
1727 && check_sibcall_argument_overlap (before_arg, &args[i], 0))
1728 *sibcall_failure = 1;
1730 /* Handle calls that pass values in multiple non-contiguous
1731 locations. The Irix 6 ABI has examples of this. */
1732 if (GET_CODE (reg) == PARALLEL)
1733 use_group_regs (call_fusage, reg);
1734 else if (nregs == -1)
1735 use_reg (call_fusage, reg);
1736 else if (nregs > 0)
1737 use_regs (call_fusage, REGNO (reg), nregs);
1742 /* We need to pop PENDING_STACK_ADJUST bytes. But, if the arguments
1743 wouldn't fill up an even multiple of PREFERRED_UNIT_STACK_BOUNDARY
1744 bytes, then we would need to push some additional bytes to pad the
1745 arguments. So, we compute an adjust to the stack pointer for an
1746 amount that will leave the stack under-aligned by UNADJUSTED_ARGS_SIZE
1747 bytes. Then, when the arguments are pushed the stack will be perfectly
1748 aligned. ARGS_SIZE->CONSTANT is set to the number of bytes that should
1749 be popped after the call. Returns the adjustment. */
1751 static int
1752 combine_pending_stack_adjustment_and_call (int unadjusted_args_size,
1753 struct args_size *args_size,
1754 unsigned int preferred_unit_stack_boundary)
1756 /* The number of bytes to pop so that the stack will be
1757 under-aligned by UNADJUSTED_ARGS_SIZE bytes. */
1758 HOST_WIDE_INT adjustment;
1759 /* The alignment of the stack after the arguments are pushed, if we
1760 just pushed the arguments without adjust the stack here. */
1761 unsigned HOST_WIDE_INT unadjusted_alignment;
1763 unadjusted_alignment
1764 = ((stack_pointer_delta + unadjusted_args_size)
1765 % preferred_unit_stack_boundary);
1767 /* We want to get rid of as many of the PENDING_STACK_ADJUST bytes
1768 as possible -- leaving just enough left to cancel out the
1769 UNADJUSTED_ALIGNMENT. In other words, we want to ensure that the
1770 PENDING_STACK_ADJUST is non-negative, and congruent to
1771 -UNADJUSTED_ALIGNMENT modulo the PREFERRED_UNIT_STACK_BOUNDARY. */
1773 /* Begin by trying to pop all the bytes. */
1774 unadjusted_alignment
1775 = (unadjusted_alignment
1776 - (pending_stack_adjust % preferred_unit_stack_boundary));
1777 adjustment = pending_stack_adjust;
1778 /* Push enough additional bytes that the stack will be aligned
1779 after the arguments are pushed. */
1780 if (preferred_unit_stack_boundary > 1)
1782 if (unadjusted_alignment > 0)
1783 adjustment -= preferred_unit_stack_boundary - unadjusted_alignment;
1784 else
1785 adjustment += unadjusted_alignment;
1788 /* Now, sets ARGS_SIZE->CONSTANT so that we pop the right number of
1789 bytes after the call. The right number is the entire
1790 PENDING_STACK_ADJUST less our ADJUSTMENT plus the amount required
1791 by the arguments in the first place. */
1792 args_size->constant
1793 = pending_stack_adjust - adjustment + unadjusted_args_size;
1795 return adjustment;
1798 /* Scan X expression if it does not dereference any argument slots
1799 we already clobbered by tail call arguments (as noted in stored_args_map
1800 bitmap).
1801 Return nonzero if X expression dereferences such argument slots,
1802 zero otherwise. */
1804 static int
1805 check_sibcall_argument_overlap_1 (rtx x)
1807 RTX_CODE code;
1808 int i, j;
1809 const char *fmt;
1811 if (x == NULL_RTX)
1812 return 0;
1814 code = GET_CODE (x);
1816 if (code == MEM)
1817 return mem_overlaps_already_clobbered_arg_p (XEXP (x, 0),
1818 GET_MODE_SIZE (GET_MODE (x)));
1820 /* Scan all subexpressions. */
1821 fmt = GET_RTX_FORMAT (code);
1822 for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
1824 if (*fmt == 'e')
1826 if (check_sibcall_argument_overlap_1 (XEXP (x, i)))
1827 return 1;
1829 else if (*fmt == 'E')
1831 for (j = 0; j < XVECLEN (x, i); j++)
1832 if (check_sibcall_argument_overlap_1 (XVECEXP (x, i, j)))
1833 return 1;
1836 return 0;
1839 /* Scan sequence after INSN if it does not dereference any argument slots
1840 we already clobbered by tail call arguments (as noted in stored_args_map
1841 bitmap). If MARK_STORED_ARGS_MAP, add stack slots for ARG to
1842 stored_args_map bitmap afterwards (when ARG is a register MARK_STORED_ARGS_MAP
1843 should be 0). Return nonzero if sequence after INSN dereferences such argument
1844 slots, zero otherwise. */
1846 static int
1847 check_sibcall_argument_overlap (rtx insn, struct arg_data *arg, int mark_stored_args_map)
1849 int low, high;
1851 if (insn == NULL_RTX)
1852 insn = get_insns ();
1853 else
1854 insn = NEXT_INSN (insn);
1856 for (; insn; insn = NEXT_INSN (insn))
1857 if (INSN_P (insn)
1858 && check_sibcall_argument_overlap_1 (PATTERN (insn)))
1859 break;
1861 if (mark_stored_args_map)
1863 #ifdef ARGS_GROW_DOWNWARD
1864 low = -arg->locate.slot_offset.constant - arg->locate.size.constant;
1865 #else
1866 low = arg->locate.slot_offset.constant;
1867 #endif
1869 for (high = low + arg->locate.size.constant; low < high; low++)
1870 SET_BIT (stored_args_map, low);
1872 return insn != NULL_RTX;
1875 /* Given that a function returns a value of mode MODE at the most
1876 significant end of hard register VALUE, shift VALUE left or right
1877 as specified by LEFT_P. Return true if some action was needed. */
1879 bool
1880 shift_return_value (enum machine_mode mode, bool left_p, rtx value)
1882 HOST_WIDE_INT shift;
1884 gcc_assert (REG_P (value) && HARD_REGISTER_P (value));
1885 shift = GET_MODE_BITSIZE (GET_MODE (value)) - GET_MODE_BITSIZE (mode);
1886 if (shift == 0)
1887 return false;
1889 /* Use ashr rather than lshr for right shifts. This is for the benefit
1890 of the MIPS port, which requires SImode values to be sign-extended
1891 when stored in 64-bit registers. */
1892 if (!force_expand_binop (GET_MODE (value), left_p ? ashl_optab : ashr_optab,
1893 value, GEN_INT (shift), value, 1, OPTAB_WIDEN))
1894 gcc_unreachable ();
1895 return true;
1898 /* If X is a likely-spilled register value, copy it to a pseudo
1899 register and return that register. Return X otherwise. */
1901 static rtx
1902 avoid_likely_spilled_reg (rtx x)
1904 rtx new_rtx;
1906 if (REG_P (x)
1907 && HARD_REGISTER_P (x)
1908 && targetm.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (x))))
1910 /* Make sure that we generate a REG rather than a CONCAT.
1911 Moves into CONCATs can need nontrivial instructions,
1912 and the whole point of this function is to avoid
1913 using the hard register directly in such a situation. */
1914 generating_concat_p = 0;
1915 new_rtx = gen_reg_rtx (GET_MODE (x));
1916 generating_concat_p = 1;
1917 emit_move_insn (new_rtx, x);
1918 return new_rtx;
1920 return x;
1923 /* Generate all the code for a CALL_EXPR exp
1924 and return an rtx for its value.
1925 Store the value in TARGET (specified as an rtx) if convenient.
1926 If the value is stored in TARGET then TARGET is returned.
1927 If IGNORE is nonzero, then we ignore the value of the function call. */
1930 expand_call (tree exp, rtx target, int ignore)
1932 /* Nonzero if we are currently expanding a call. */
1933 static int currently_expanding_call = 0;
1935 /* RTX for the function to be called. */
1936 rtx funexp;
1937 /* Sequence of insns to perform a normal "call". */
1938 rtx normal_call_insns = NULL_RTX;
1939 /* Sequence of insns to perform a tail "call". */
1940 rtx tail_call_insns = NULL_RTX;
1941 /* Data type of the function. */
1942 tree funtype;
1943 tree type_arg_types;
1944 tree rettype;
1945 /* Declaration of the function being called,
1946 or 0 if the function is computed (not known by name). */
1947 tree fndecl = 0;
1948 /* The type of the function being called. */
1949 tree fntype;
1950 bool try_tail_call = CALL_EXPR_TAILCALL (exp);
1951 int pass;
1953 /* Register in which non-BLKmode value will be returned,
1954 or 0 if no value or if value is BLKmode. */
1955 rtx valreg;
1956 /* Address where we should return a BLKmode value;
1957 0 if value not BLKmode. */
1958 rtx structure_value_addr = 0;
1959 /* Nonzero if that address is being passed by treating it as
1960 an extra, implicit first parameter. Otherwise,
1961 it is passed by being copied directly into struct_value_rtx. */
1962 int structure_value_addr_parm = 0;
1963 /* Holds the value of implicit argument for the struct value. */
1964 tree structure_value_addr_value = NULL_TREE;
1965 /* Size of aggregate value wanted, or zero if none wanted
1966 or if we are using the non-reentrant PCC calling convention
1967 or expecting the value in registers. */
1968 HOST_WIDE_INT struct_value_size = 0;
1969 /* Nonzero if called function returns an aggregate in memory PCC style,
1970 by returning the address of where to find it. */
1971 int pcc_struct_value = 0;
1972 rtx struct_value = 0;
1974 /* Number of actual parameters in this call, including struct value addr. */
1975 int num_actuals;
1976 /* Number of named args. Args after this are anonymous ones
1977 and they must all go on the stack. */
1978 int n_named_args;
1979 /* Number of complex actual arguments that need to be split. */
1980 int num_complex_actuals = 0;
1982 /* Vector of information about each argument.
1983 Arguments are numbered in the order they will be pushed,
1984 not the order they are written. */
1985 struct arg_data *args;
1987 /* Total size in bytes of all the stack-parms scanned so far. */
1988 struct args_size args_size;
1989 struct args_size adjusted_args_size;
1990 /* Size of arguments before any adjustments (such as rounding). */
1991 int unadjusted_args_size;
1992 /* Data on reg parms scanned so far. */
1993 CUMULATIVE_ARGS args_so_far;
1994 /* Nonzero if a reg parm has been scanned. */
1995 int reg_parm_seen;
1996 /* Nonzero if this is an indirect function call. */
1998 /* Nonzero if we must avoid push-insns in the args for this call.
1999 If stack space is allocated for register parameters, but not by the
2000 caller, then it is preallocated in the fixed part of the stack frame.
2001 So the entire argument block must then be preallocated (i.e., we
2002 ignore PUSH_ROUNDING in that case). */
2004 int must_preallocate = !PUSH_ARGS;
2006 /* Size of the stack reserved for parameter registers. */
2007 int reg_parm_stack_space = 0;
2009 /* Address of space preallocated for stack parms
2010 (on machines that lack push insns), or 0 if space not preallocated. */
2011 rtx argblock = 0;
2013 /* Mask of ECF_ flags. */
2014 int flags = 0;
2015 #ifdef REG_PARM_STACK_SPACE
2016 /* Define the boundary of the register parm stack space that needs to be
2017 saved, if any. */
2018 int low_to_save, high_to_save;
2019 rtx save_area = 0; /* Place that it is saved */
2020 #endif
2022 int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
2023 char *initial_stack_usage_map = stack_usage_map;
2024 char *stack_usage_map_buf = NULL;
2026 int old_stack_allocated;
2028 /* State variables to track stack modifications. */
2029 rtx old_stack_level = 0;
2030 int old_stack_arg_under_construction = 0;
2031 int old_pending_adj = 0;
2032 int old_inhibit_defer_pop = inhibit_defer_pop;
2034 /* Some stack pointer alterations we make are performed via
2035 allocate_dynamic_stack_space. This modifies the stack_pointer_delta,
2036 which we then also need to save/restore along the way. */
2037 int old_stack_pointer_delta = 0;
2039 rtx call_fusage;
2040 tree addr = CALL_EXPR_FN (exp);
2041 int i;
2042 /* The alignment of the stack, in bits. */
2043 unsigned HOST_WIDE_INT preferred_stack_boundary;
2044 /* The alignment of the stack, in bytes. */
2045 unsigned HOST_WIDE_INT preferred_unit_stack_boundary;
2046 /* The static chain value to use for this call. */
2047 rtx static_chain_value;
2048 /* See if this is "nothrow" function call. */
2049 if (TREE_NOTHROW (exp))
2050 flags |= ECF_NOTHROW;
2052 /* See if we can find a DECL-node for the actual function, and get the
2053 function attributes (flags) from the function decl or type node. */
2054 fndecl = get_callee_fndecl (exp);
2055 if (fndecl)
2057 fntype = TREE_TYPE (fndecl);
2058 flags |= flags_from_decl_or_type (fndecl);
2060 else
2062 fntype = TREE_TYPE (TREE_TYPE (addr));
2063 flags |= flags_from_decl_or_type (fntype);
2065 rettype = TREE_TYPE (exp);
2067 struct_value = targetm.calls.struct_value_rtx (fntype, 0);
2069 /* Warn if this value is an aggregate type,
2070 regardless of which calling convention we are using for it. */
2071 if (AGGREGATE_TYPE_P (rettype))
2072 warning (OPT_Waggregate_return, "function call has aggregate value");
2074 /* If the result of a non looping pure or const function call is
2075 ignored (or void), and none of its arguments are volatile, we can
2076 avoid expanding the call and just evaluate the arguments for
2077 side-effects. */
2078 if ((flags & (ECF_CONST | ECF_PURE))
2079 && (!(flags & ECF_LOOPING_CONST_OR_PURE))
2080 && (ignore || target == const0_rtx
2081 || TYPE_MODE (rettype) == VOIDmode))
2083 bool volatilep = false;
2084 tree arg;
2085 call_expr_arg_iterator iter;
2087 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
2088 if (TREE_THIS_VOLATILE (arg))
2090 volatilep = true;
2091 break;
2094 if (! volatilep)
2096 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
2097 expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
2098 return const0_rtx;
2102 #ifdef REG_PARM_STACK_SPACE
2103 reg_parm_stack_space = REG_PARM_STACK_SPACE (!fndecl ? fntype : fndecl);
2104 #endif
2106 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))
2107 && reg_parm_stack_space > 0 && PUSH_ARGS)
2108 must_preallocate = 1;
2110 /* Set up a place to return a structure. */
2112 /* Cater to broken compilers. */
2113 if (aggregate_value_p (exp, fntype))
2115 /* This call returns a big structure. */
2116 flags &= ~(ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
2118 #ifdef PCC_STATIC_STRUCT_RETURN
2120 pcc_struct_value = 1;
2122 #else /* not PCC_STATIC_STRUCT_RETURN */
2124 struct_value_size = int_size_in_bytes (rettype);
2126 if (target && MEM_P (target) && CALL_EXPR_RETURN_SLOT_OPT (exp))
2127 structure_value_addr = XEXP (target, 0);
2128 else
2130 /* For variable-sized objects, we must be called with a target
2131 specified. If we were to allocate space on the stack here,
2132 we would have no way of knowing when to free it. */
2133 rtx d = assign_temp (rettype, 0, 1, 1);
2135 mark_temp_addr_taken (d);
2136 structure_value_addr = XEXP (d, 0);
2137 target = 0;
2140 #endif /* not PCC_STATIC_STRUCT_RETURN */
2143 /* Figure out the amount to which the stack should be aligned. */
2144 preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
2145 if (fndecl)
2147 struct cgraph_rtl_info *i = cgraph_rtl_info (fndecl);
2148 /* Without automatic stack alignment, we can't increase preferred
2149 stack boundary. With automatic stack alignment, it is
2150 unnecessary since unless we can guarantee that all callers will
2151 align the outgoing stack properly, callee has to align its
2152 stack anyway. */
2153 if (i
2154 && i->preferred_incoming_stack_boundary
2155 && i->preferred_incoming_stack_boundary < preferred_stack_boundary)
2156 preferred_stack_boundary = i->preferred_incoming_stack_boundary;
2159 /* Operand 0 is a pointer-to-function; get the type of the function. */
2160 funtype = TREE_TYPE (addr);
2161 gcc_assert (POINTER_TYPE_P (funtype));
2162 funtype = TREE_TYPE (funtype);
2164 /* Count whether there are actual complex arguments that need to be split
2165 into their real and imaginary parts. Munge the type_arg_types
2166 appropriately here as well. */
2167 if (targetm.calls.split_complex_arg)
2169 call_expr_arg_iterator iter;
2170 tree arg;
2171 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
2173 tree type = TREE_TYPE (arg);
2174 if (type && TREE_CODE (type) == COMPLEX_TYPE
2175 && targetm.calls.split_complex_arg (type))
2176 num_complex_actuals++;
2178 type_arg_types = split_complex_types (TYPE_ARG_TYPES (funtype));
2180 else
2181 type_arg_types = TYPE_ARG_TYPES (funtype);
2183 if (flags & ECF_MAY_BE_ALLOCA)
2184 cfun->calls_alloca = 1;
2186 /* If struct_value_rtx is 0, it means pass the address
2187 as if it were an extra parameter. Put the argument expression
2188 in structure_value_addr_value. */
2189 if (structure_value_addr && struct_value == 0)
2191 /* If structure_value_addr is a REG other than
2192 virtual_outgoing_args_rtx, we can use always use it. If it
2193 is not a REG, we must always copy it into a register.
2194 If it is virtual_outgoing_args_rtx, we must copy it to another
2195 register in some cases. */
2196 rtx temp = (!REG_P (structure_value_addr)
2197 || (ACCUMULATE_OUTGOING_ARGS
2198 && stack_arg_under_construction
2199 && structure_value_addr == virtual_outgoing_args_rtx)
2200 ? copy_addr_to_reg (convert_memory_address
2201 (Pmode, structure_value_addr))
2202 : structure_value_addr);
2204 structure_value_addr_value =
2205 make_tree (build_pointer_type (TREE_TYPE (funtype)), temp);
2206 structure_value_addr_parm = 1;
2209 /* Count the arguments and set NUM_ACTUALS. */
2210 num_actuals =
2211 call_expr_nargs (exp) + num_complex_actuals + structure_value_addr_parm;
2213 /* Compute number of named args.
2214 First, do a raw count of the args for INIT_CUMULATIVE_ARGS. */
2216 if (type_arg_types != 0)
2217 n_named_args
2218 = (list_length (type_arg_types)
2219 /* Count the struct value address, if it is passed as a parm. */
2220 + structure_value_addr_parm);
2221 else
2222 /* If we know nothing, treat all args as named. */
2223 n_named_args = num_actuals;
2225 /* Start updating where the next arg would go.
2227 On some machines (such as the PA) indirect calls have a different
2228 calling convention than normal calls. The fourth argument in
2229 INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
2230 or not. */
2231 INIT_CUMULATIVE_ARGS (args_so_far, funtype, NULL_RTX, fndecl, n_named_args);
2233 /* Now possibly adjust the number of named args.
2234 Normally, don't include the last named arg if anonymous args follow.
2235 We do include the last named arg if
2236 targetm.calls.strict_argument_naming() returns nonzero.
2237 (If no anonymous args follow, the result of list_length is actually
2238 one too large. This is harmless.)
2240 If targetm.calls.pretend_outgoing_varargs_named() returns
2241 nonzero, and targetm.calls.strict_argument_naming() returns zero,
2242 this machine will be able to place unnamed args that were passed
2243 in registers into the stack. So treat all args as named. This
2244 allows the insns emitting for a specific argument list to be
2245 independent of the function declaration.
2247 If targetm.calls.pretend_outgoing_varargs_named() returns zero,
2248 we do not have any reliable way to pass unnamed args in
2249 registers, so we must force them into memory. */
2251 if (type_arg_types != 0
2252 && targetm.calls.strict_argument_naming (&args_so_far))
2254 else if (type_arg_types != 0
2255 && ! targetm.calls.pretend_outgoing_varargs_named (&args_so_far))
2256 /* Don't include the last named arg. */
2257 --n_named_args;
2258 else
2259 /* Treat all args as named. */
2260 n_named_args = num_actuals;
2262 /* Make a vector to hold all the information about each arg. */
2263 args = XALLOCAVEC (struct arg_data, num_actuals);
2264 memset (args, 0, num_actuals * sizeof (struct arg_data));
2266 /* Build up entries in the ARGS array, compute the size of the
2267 arguments into ARGS_SIZE, etc. */
2268 initialize_argument_information (num_actuals, args, &args_size,
2269 n_named_args, exp,
2270 structure_value_addr_value, fndecl, fntype,
2271 &args_so_far, reg_parm_stack_space,
2272 &old_stack_level, &old_pending_adj,
2273 &must_preallocate, &flags,
2274 &try_tail_call, CALL_FROM_THUNK_P (exp));
2276 if (args_size.var)
2277 must_preallocate = 1;
2279 /* Now make final decision about preallocating stack space. */
2280 must_preallocate = finalize_must_preallocate (must_preallocate,
2281 num_actuals, args,
2282 &args_size);
2284 /* If the structure value address will reference the stack pointer, we
2285 must stabilize it. We don't need to do this if we know that we are
2286 not going to adjust the stack pointer in processing this call. */
2288 if (structure_value_addr
2289 && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
2290 || reg_mentioned_p (virtual_outgoing_args_rtx,
2291 structure_value_addr))
2292 && (args_size.var
2293 || (!ACCUMULATE_OUTGOING_ARGS && args_size.constant)))
2294 structure_value_addr = copy_to_reg (structure_value_addr);
2296 /* Tail calls can make things harder to debug, and we've traditionally
2297 pushed these optimizations into -O2. Don't try if we're already
2298 expanding a call, as that means we're an argument. Don't try if
2299 there's cleanups, as we know there's code to follow the call. */
2301 if (currently_expanding_call++ != 0
2302 || !flag_optimize_sibling_calls
2303 || args_size.var
2304 || dbg_cnt (tail_call) == false)
2305 try_tail_call = 0;
2307 /* Rest of purposes for tail call optimizations to fail. */
2308 if (
2309 #ifdef HAVE_sibcall_epilogue
2310 !HAVE_sibcall_epilogue
2311 #else
2313 #endif
2314 || !try_tail_call
2315 /* Doing sibling call optimization needs some work, since
2316 structure_value_addr can be allocated on the stack.
2317 It does not seem worth the effort since few optimizable
2318 sibling calls will return a structure. */
2319 || structure_value_addr != NULL_RTX
2320 #ifdef REG_PARM_STACK_SPACE
2321 /* If outgoing reg parm stack space changes, we can not do sibcall. */
2322 || (OUTGOING_REG_PARM_STACK_SPACE (funtype)
2323 != OUTGOING_REG_PARM_STACK_SPACE (TREE_TYPE (current_function_decl)))
2324 || (reg_parm_stack_space != REG_PARM_STACK_SPACE (fndecl))
2325 #endif
2326 /* Check whether the target is able to optimize the call
2327 into a sibcall. */
2328 || !targetm.function_ok_for_sibcall (fndecl, exp)
2329 /* Functions that do not return exactly once may not be sibcall
2330 optimized. */
2331 || (flags & (ECF_RETURNS_TWICE | ECF_NORETURN))
2332 || TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (addr)))
2333 /* If the called function is nested in the current one, it might access
2334 some of the caller's arguments, but could clobber them beforehand if
2335 the argument areas are shared. */
2336 || (fndecl && decl_function_context (fndecl) == current_function_decl)
2337 /* If this function requires more stack slots than the current
2338 function, we cannot change it into a sibling call.
2339 crtl->args.pretend_args_size is not part of the
2340 stack allocated by our caller. */
2341 || args_size.constant > (crtl->args.size
2342 - crtl->args.pretend_args_size)
2343 /* If the callee pops its own arguments, then it must pop exactly
2344 the same number of arguments as the current function. */
2345 || (targetm.calls.return_pops_args (fndecl, funtype, args_size.constant)
2346 != targetm.calls.return_pops_args (current_function_decl,
2347 TREE_TYPE (current_function_decl),
2348 crtl->args.size))
2349 || !lang_hooks.decls.ok_for_sibcall (fndecl))
2350 try_tail_call = 0;
2352 /* Check if caller and callee disagree in promotion of function
2353 return value. */
2354 if (try_tail_call)
2356 enum machine_mode caller_mode, caller_promoted_mode;
2357 enum machine_mode callee_mode, callee_promoted_mode;
2358 int caller_unsignedp, callee_unsignedp;
2359 tree caller_res = DECL_RESULT (current_function_decl);
2361 caller_unsignedp = TYPE_UNSIGNED (TREE_TYPE (caller_res));
2362 caller_mode = DECL_MODE (caller_res);
2363 callee_unsignedp = TYPE_UNSIGNED (TREE_TYPE (funtype));
2364 callee_mode = TYPE_MODE (TREE_TYPE (funtype));
2365 caller_promoted_mode
2366 = promote_function_mode (TREE_TYPE (caller_res), caller_mode,
2367 &caller_unsignedp,
2368 TREE_TYPE (current_function_decl), 1);
2369 callee_promoted_mode
2370 = promote_function_mode (TREE_TYPE (funtype), callee_mode,
2371 &callee_unsignedp,
2372 funtype, 1);
2373 if (caller_mode != VOIDmode
2374 && (caller_promoted_mode != callee_promoted_mode
2375 || ((caller_mode != caller_promoted_mode
2376 || callee_mode != callee_promoted_mode)
2377 && (caller_unsignedp != callee_unsignedp
2378 || GET_MODE_BITSIZE (caller_mode)
2379 < GET_MODE_BITSIZE (callee_mode)))))
2380 try_tail_call = 0;
2383 /* Ensure current function's preferred stack boundary is at least
2384 what we need. Stack alignment may also increase preferred stack
2385 boundary. */
2386 if (crtl->preferred_stack_boundary < preferred_stack_boundary)
2387 crtl->preferred_stack_boundary = preferred_stack_boundary;
2388 else
2389 preferred_stack_boundary = crtl->preferred_stack_boundary;
2391 preferred_unit_stack_boundary = preferred_stack_boundary / BITS_PER_UNIT;
2393 /* We want to make two insn chains; one for a sibling call, the other
2394 for a normal call. We will select one of the two chains after
2395 initial RTL generation is complete. */
2396 for (pass = try_tail_call ? 0 : 1; pass < 2; pass++)
2398 int sibcall_failure = 0;
2399 /* We want to emit any pending stack adjustments before the tail
2400 recursion "call". That way we know any adjustment after the tail
2401 recursion call can be ignored if we indeed use the tail
2402 call expansion. */
2403 int save_pending_stack_adjust = 0;
2404 int save_stack_pointer_delta = 0;
2405 rtx insns;
2406 rtx before_call, next_arg_reg, after_args;
2408 if (pass == 0)
2410 /* State variables we need to save and restore between
2411 iterations. */
2412 save_pending_stack_adjust = pending_stack_adjust;
2413 save_stack_pointer_delta = stack_pointer_delta;
2415 if (pass)
2416 flags &= ~ECF_SIBCALL;
2417 else
2418 flags |= ECF_SIBCALL;
2420 /* Other state variables that we must reinitialize each time
2421 through the loop (that are not initialized by the loop itself). */
2422 argblock = 0;
2423 call_fusage = 0;
2425 /* Start a new sequence for the normal call case.
2427 From this point on, if the sibling call fails, we want to set
2428 sibcall_failure instead of continuing the loop. */
2429 start_sequence ();
2431 /* Don't let pending stack adjusts add up to too much.
2432 Also, do all pending adjustments now if there is any chance
2433 this might be a call to alloca or if we are expanding a sibling
2434 call sequence.
2435 Also do the adjustments before a throwing call, otherwise
2436 exception handling can fail; PR 19225. */
2437 if (pending_stack_adjust >= 32
2438 || (pending_stack_adjust > 0
2439 && (flags & ECF_MAY_BE_ALLOCA))
2440 || (pending_stack_adjust > 0
2441 && flag_exceptions && !(flags & ECF_NOTHROW))
2442 || pass == 0)
2443 do_pending_stack_adjust ();
2445 /* Precompute any arguments as needed. */
2446 if (pass)
2447 precompute_arguments (num_actuals, args);
2449 /* Now we are about to start emitting insns that can be deleted
2450 if a libcall is deleted. */
2451 if (pass && (flags & ECF_MALLOC))
2452 start_sequence ();
2454 if (pass == 0 && crtl->stack_protect_guard)
2455 stack_protect_epilogue ();
2457 adjusted_args_size = args_size;
2458 /* Compute the actual size of the argument block required. The variable
2459 and constant sizes must be combined, the size may have to be rounded,
2460 and there may be a minimum required size. When generating a sibcall
2461 pattern, do not round up, since we'll be re-using whatever space our
2462 caller provided. */
2463 unadjusted_args_size
2464 = compute_argument_block_size (reg_parm_stack_space,
2465 &adjusted_args_size,
2466 fndecl, fntype,
2467 (pass == 0 ? 0
2468 : preferred_stack_boundary));
2470 old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
2472 /* The argument block when performing a sibling call is the
2473 incoming argument block. */
2474 if (pass == 0)
2476 argblock = crtl->args.internal_arg_pointer;
2477 argblock
2478 #ifdef STACK_GROWS_DOWNWARD
2479 = plus_constant (argblock, crtl->args.pretend_args_size);
2480 #else
2481 = plus_constant (argblock, -crtl->args.pretend_args_size);
2482 #endif
2483 stored_args_map = sbitmap_alloc (args_size.constant);
2484 sbitmap_zero (stored_args_map);
2487 /* If we have no actual push instructions, or shouldn't use them,
2488 make space for all args right now. */
2489 else if (adjusted_args_size.var != 0)
2491 if (old_stack_level == 0)
2493 emit_stack_save (SAVE_BLOCK, &old_stack_level);
2494 old_stack_pointer_delta = stack_pointer_delta;
2495 old_pending_adj = pending_stack_adjust;
2496 pending_stack_adjust = 0;
2497 /* stack_arg_under_construction says whether a stack arg is
2498 being constructed at the old stack level. Pushing the stack
2499 gets a clean outgoing argument block. */
2500 old_stack_arg_under_construction = stack_arg_under_construction;
2501 stack_arg_under_construction = 0;
2503 argblock = push_block (ARGS_SIZE_RTX (adjusted_args_size), 0, 0);
2504 if (flag_stack_usage)
2505 current_function_has_unbounded_dynamic_stack_size = 1;
2507 else
2509 /* Note that we must go through the motions of allocating an argument
2510 block even if the size is zero because we may be storing args
2511 in the area reserved for register arguments, which may be part of
2512 the stack frame. */
2514 int needed = adjusted_args_size.constant;
2516 /* Store the maximum argument space used. It will be pushed by
2517 the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
2518 checking). */
2520 if (needed > crtl->outgoing_args_size)
2521 crtl->outgoing_args_size = needed;
2523 if (must_preallocate)
2525 if (ACCUMULATE_OUTGOING_ARGS)
2527 /* Since the stack pointer will never be pushed, it is
2528 possible for the evaluation of a parm to clobber
2529 something we have already written to the stack.
2530 Since most function calls on RISC machines do not use
2531 the stack, this is uncommon, but must work correctly.
2533 Therefore, we save any area of the stack that was already
2534 written and that we are using. Here we set up to do this
2535 by making a new stack usage map from the old one. The
2536 actual save will be done by store_one_arg.
2538 Another approach might be to try to reorder the argument
2539 evaluations to avoid this conflicting stack usage. */
2541 /* Since we will be writing into the entire argument area,
2542 the map must be allocated for its entire size, not just
2543 the part that is the responsibility of the caller. */
2544 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
2545 needed += reg_parm_stack_space;
2547 #ifdef ARGS_GROW_DOWNWARD
2548 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
2549 needed + 1);
2550 #else
2551 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
2552 needed);
2553 #endif
2554 free (stack_usage_map_buf);
2555 stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
2556 stack_usage_map = stack_usage_map_buf;
2558 if (initial_highest_arg_in_use)
2559 memcpy (stack_usage_map, initial_stack_usage_map,
2560 initial_highest_arg_in_use);
2562 if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
2563 memset (&stack_usage_map[initial_highest_arg_in_use], 0,
2564 (highest_outgoing_arg_in_use
2565 - initial_highest_arg_in_use));
2566 needed = 0;
2568 /* The address of the outgoing argument list must not be
2569 copied to a register here, because argblock would be left
2570 pointing to the wrong place after the call to
2571 allocate_dynamic_stack_space below. */
2573 argblock = virtual_outgoing_args_rtx;
2575 else
2577 if (inhibit_defer_pop == 0)
2579 /* Try to reuse some or all of the pending_stack_adjust
2580 to get this space. */
2581 needed
2582 = (combine_pending_stack_adjustment_and_call
2583 (unadjusted_args_size,
2584 &adjusted_args_size,
2585 preferred_unit_stack_boundary));
2587 /* combine_pending_stack_adjustment_and_call computes
2588 an adjustment before the arguments are allocated.
2589 Account for them and see whether or not the stack
2590 needs to go up or down. */
2591 needed = unadjusted_args_size - needed;
2593 if (needed < 0)
2595 /* We're releasing stack space. */
2596 /* ??? We can avoid any adjustment at all if we're
2597 already aligned. FIXME. */
2598 pending_stack_adjust = -needed;
2599 do_pending_stack_adjust ();
2600 needed = 0;
2602 else
2603 /* We need to allocate space. We'll do that in
2604 push_block below. */
2605 pending_stack_adjust = 0;
2608 /* Special case this because overhead of `push_block' in
2609 this case is non-trivial. */
2610 if (needed == 0)
2611 argblock = virtual_outgoing_args_rtx;
2612 else
2614 argblock = push_block (GEN_INT (needed), 0, 0);
2615 #ifdef ARGS_GROW_DOWNWARD
2616 argblock = plus_constant (argblock, needed);
2617 #endif
2620 /* We only really need to call `copy_to_reg' in the case
2621 where push insns are going to be used to pass ARGBLOCK
2622 to a function call in ARGS. In that case, the stack
2623 pointer changes value from the allocation point to the
2624 call point, and hence the value of
2625 VIRTUAL_OUTGOING_ARGS_RTX changes as well. But might
2626 as well always do it. */
2627 argblock = copy_to_reg (argblock);
2632 if (ACCUMULATE_OUTGOING_ARGS)
2634 /* The save/restore code in store_one_arg handles all
2635 cases except one: a constructor call (including a C
2636 function returning a BLKmode struct) to initialize
2637 an argument. */
2638 if (stack_arg_under_construction)
2640 rtx push_size
2641 = GEN_INT (adjusted_args_size.constant
2642 + (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype
2643 : TREE_TYPE (fndecl))) ? 0
2644 : reg_parm_stack_space));
2645 if (old_stack_level == 0)
2647 emit_stack_save (SAVE_BLOCK, &old_stack_level);
2648 old_stack_pointer_delta = stack_pointer_delta;
2649 old_pending_adj = pending_stack_adjust;
2650 pending_stack_adjust = 0;
2651 /* stack_arg_under_construction says whether a stack
2652 arg is being constructed at the old stack level.
2653 Pushing the stack gets a clean outgoing argument
2654 block. */
2655 old_stack_arg_under_construction
2656 = stack_arg_under_construction;
2657 stack_arg_under_construction = 0;
2658 /* Make a new map for the new argument list. */
2659 free (stack_usage_map_buf);
2660 stack_usage_map_buf = XCNEWVEC (char, highest_outgoing_arg_in_use);
2661 stack_usage_map = stack_usage_map_buf;
2662 highest_outgoing_arg_in_use = 0;
2664 /* We can pass TRUE as the 4th argument because we just
2665 saved the stack pointer and will restore it right after
2666 the call. */
2667 allocate_dynamic_stack_space (push_size, 0,
2668 BIGGEST_ALIGNMENT, true);
2671 /* If argument evaluation might modify the stack pointer,
2672 copy the address of the argument list to a register. */
2673 for (i = 0; i < num_actuals; i++)
2674 if (args[i].pass_on_stack)
2676 argblock = copy_addr_to_reg (argblock);
2677 break;
2681 compute_argument_addresses (args, argblock, num_actuals);
2683 /* If we push args individually in reverse order, perform stack alignment
2684 before the first push (the last arg). */
2685 if (PUSH_ARGS_REVERSED && argblock == 0
2686 && adjusted_args_size.constant != unadjusted_args_size)
2688 /* When the stack adjustment is pending, we get better code
2689 by combining the adjustments. */
2690 if (pending_stack_adjust
2691 && ! inhibit_defer_pop)
2693 pending_stack_adjust
2694 = (combine_pending_stack_adjustment_and_call
2695 (unadjusted_args_size,
2696 &adjusted_args_size,
2697 preferred_unit_stack_boundary));
2698 do_pending_stack_adjust ();
2700 else if (argblock == 0)
2701 anti_adjust_stack (GEN_INT (adjusted_args_size.constant
2702 - unadjusted_args_size));
2704 /* Now that the stack is properly aligned, pops can't safely
2705 be deferred during the evaluation of the arguments. */
2706 NO_DEFER_POP;
2708 /* Record the maximum pushed stack space size. We need to delay
2709 doing it this far to take into account the optimization done
2710 by combine_pending_stack_adjustment_and_call. */
2711 if (flag_stack_usage
2712 && !ACCUMULATE_OUTGOING_ARGS
2713 && pass
2714 && adjusted_args_size.var == 0)
2716 int pushed = adjusted_args_size.constant + pending_stack_adjust;
2717 if (pushed > current_function_pushed_stack_size)
2718 current_function_pushed_stack_size = pushed;
2721 funexp = rtx_for_function_call (fndecl, addr);
2723 /* Figure out the register where the value, if any, will come back. */
2724 valreg = 0;
2725 if (TYPE_MODE (rettype) != VOIDmode
2726 && ! structure_value_addr)
2728 if (pcc_struct_value)
2729 valreg = hard_function_value (build_pointer_type (rettype),
2730 fndecl, NULL, (pass == 0));
2731 else
2732 valreg = hard_function_value (rettype, fndecl, fntype,
2733 (pass == 0));
2735 /* If VALREG is a PARALLEL whose first member has a zero
2736 offset, use that. This is for targets such as m68k that
2737 return the same value in multiple places. */
2738 if (GET_CODE (valreg) == PARALLEL)
2740 rtx elem = XVECEXP (valreg, 0, 0);
2741 rtx where = XEXP (elem, 0);
2742 rtx offset = XEXP (elem, 1);
2743 if (offset == const0_rtx
2744 && GET_MODE (where) == GET_MODE (valreg))
2745 valreg = where;
2749 /* Precompute all register parameters. It isn't safe to compute anything
2750 once we have started filling any specific hard regs. */
2751 precompute_register_parameters (num_actuals, args, &reg_parm_seen);
2753 if (CALL_EXPR_STATIC_CHAIN (exp))
2754 static_chain_value = expand_normal (CALL_EXPR_STATIC_CHAIN (exp));
2755 else
2756 static_chain_value = 0;
2758 #ifdef REG_PARM_STACK_SPACE
2759 /* Save the fixed argument area if it's part of the caller's frame and
2760 is clobbered by argument setup for this call. */
2761 if (ACCUMULATE_OUTGOING_ARGS && pass)
2762 save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
2763 &low_to_save, &high_to_save);
2764 #endif
2766 /* Now store (and compute if necessary) all non-register parms.
2767 These come before register parms, since they can require block-moves,
2768 which could clobber the registers used for register parms.
2769 Parms which have partial registers are not stored here,
2770 but we do preallocate space here if they want that. */
2772 for (i = 0; i < num_actuals; i++)
2774 if (args[i].reg == 0 || args[i].pass_on_stack)
2776 rtx before_arg = get_last_insn ();
2778 if (store_one_arg (&args[i], argblock, flags,
2779 adjusted_args_size.var != 0,
2780 reg_parm_stack_space)
2781 || (pass == 0
2782 && check_sibcall_argument_overlap (before_arg,
2783 &args[i], 1)))
2784 sibcall_failure = 1;
2787 if (args[i].stack)
2788 call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
2789 gen_rtx_USE (VOIDmode,
2790 args[i].stack),
2791 call_fusage);
2794 /* If we have a parm that is passed in registers but not in memory
2795 and whose alignment does not permit a direct copy into registers,
2796 make a group of pseudos that correspond to each register that we
2797 will later fill. */
2798 if (STRICT_ALIGNMENT)
2799 store_unaligned_arguments_into_pseudos (args, num_actuals);
2801 /* Now store any partially-in-registers parm.
2802 This is the last place a block-move can happen. */
2803 if (reg_parm_seen)
2804 for (i = 0; i < num_actuals; i++)
2805 if (args[i].partial != 0 && ! args[i].pass_on_stack)
2807 rtx before_arg = get_last_insn ();
2809 if (store_one_arg (&args[i], argblock, flags,
2810 adjusted_args_size.var != 0,
2811 reg_parm_stack_space)
2812 || (pass == 0
2813 && check_sibcall_argument_overlap (before_arg,
2814 &args[i], 1)))
2815 sibcall_failure = 1;
2818 /* If we pushed args in forward order, perform stack alignment
2819 after pushing the last arg. */
2820 if (!PUSH_ARGS_REVERSED && argblock == 0)
2821 anti_adjust_stack (GEN_INT (adjusted_args_size.constant
2822 - unadjusted_args_size));
2824 /* If register arguments require space on the stack and stack space
2825 was not preallocated, allocate stack space here for arguments
2826 passed in registers. */
2827 if (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))
2828 && !ACCUMULATE_OUTGOING_ARGS
2829 && must_preallocate == 0 && reg_parm_stack_space > 0)
2830 anti_adjust_stack (GEN_INT (reg_parm_stack_space));
2832 /* Pass the function the address in which to return a
2833 structure value. */
2834 if (pass != 0 && structure_value_addr && ! structure_value_addr_parm)
2836 structure_value_addr
2837 = convert_memory_address (Pmode, structure_value_addr);
2838 emit_move_insn (struct_value,
2839 force_reg (Pmode,
2840 force_operand (structure_value_addr,
2841 NULL_RTX)));
2843 if (REG_P (struct_value))
2844 use_reg (&call_fusage, struct_value);
2847 after_args = get_last_insn ();
2848 funexp = prepare_call_address (fndecl, funexp, static_chain_value,
2849 &call_fusage, reg_parm_seen, pass == 0);
2851 load_register_parameters (args, num_actuals, &call_fusage, flags,
2852 pass == 0, &sibcall_failure);
2854 /* Save a pointer to the last insn before the call, so that we can
2855 later safely search backwards to find the CALL_INSN. */
2856 before_call = get_last_insn ();
2858 /* Set up next argument register. For sibling calls on machines
2859 with register windows this should be the incoming register. */
2860 if (pass == 0)
2861 next_arg_reg = targetm.calls.function_incoming_arg (&args_so_far,
2862 VOIDmode,
2863 void_type_node,
2864 true);
2865 else
2866 next_arg_reg = targetm.calls.function_arg (&args_so_far,
2867 VOIDmode, void_type_node,
2868 true);
2870 /* All arguments and registers used for the call must be set up by
2871 now! */
2873 /* Stack must be properly aligned now. */
2874 gcc_assert (!pass
2875 || !(stack_pointer_delta % preferred_unit_stack_boundary));
2877 /* Generate the actual call instruction. */
2878 emit_call_1 (funexp, exp, fndecl, funtype, unadjusted_args_size,
2879 adjusted_args_size.constant, struct_value_size,
2880 next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
2881 flags, & args_so_far);
2883 /* If the call setup or the call itself overlaps with anything
2884 of the argument setup we probably clobbered our call address.
2885 In that case we can't do sibcalls. */
2886 if (pass == 0
2887 && check_sibcall_argument_overlap (after_args, 0, 0))
2888 sibcall_failure = 1;
2890 /* If a non-BLKmode value is returned at the most significant end
2891 of a register, shift the register right by the appropriate amount
2892 and update VALREG accordingly. BLKmode values are handled by the
2893 group load/store machinery below. */
2894 if (!structure_value_addr
2895 && !pcc_struct_value
2896 && TYPE_MODE (rettype) != BLKmode
2897 && targetm.calls.return_in_msb (rettype))
2899 if (shift_return_value (TYPE_MODE (rettype), false, valreg))
2900 sibcall_failure = 1;
2901 valreg = gen_rtx_REG (TYPE_MODE (rettype), REGNO (valreg));
2904 if (pass && (flags & ECF_MALLOC))
2906 rtx temp = gen_reg_rtx (GET_MODE (valreg));
2907 rtx last, insns;
2909 /* The return value from a malloc-like function is a pointer. */
2910 if (TREE_CODE (rettype) == POINTER_TYPE)
2911 mark_reg_pointer (temp, BIGGEST_ALIGNMENT);
2913 emit_move_insn (temp, valreg);
2915 /* The return value from a malloc-like function can not alias
2916 anything else. */
2917 last = get_last_insn ();
2918 add_reg_note (last, REG_NOALIAS, temp);
2920 /* Write out the sequence. */
2921 insns = get_insns ();
2922 end_sequence ();
2923 emit_insn (insns);
2924 valreg = temp;
2927 /* For calls to `setjmp', etc., inform
2928 function.c:setjmp_warnings that it should complain if
2929 nonvolatile values are live. For functions that cannot
2930 return, inform flow that control does not fall through. */
2932 if ((flags & ECF_NORETURN) || pass == 0)
2934 /* The barrier must be emitted
2935 immediately after the CALL_INSN. Some ports emit more
2936 than just a CALL_INSN above, so we must search for it here. */
2938 rtx last = get_last_insn ();
2939 while (!CALL_P (last))
2941 last = PREV_INSN (last);
2942 /* There was no CALL_INSN? */
2943 gcc_assert (last != before_call);
2946 emit_barrier_after (last);
2948 /* Stack adjustments after a noreturn call are dead code.
2949 However when NO_DEFER_POP is in effect, we must preserve
2950 stack_pointer_delta. */
2951 if (inhibit_defer_pop == 0)
2953 stack_pointer_delta = old_stack_allocated;
2954 pending_stack_adjust = 0;
2958 /* If value type not void, return an rtx for the value. */
2960 if (TYPE_MODE (rettype) == VOIDmode
2961 || ignore)
2962 target = const0_rtx;
2963 else if (structure_value_addr)
2965 if (target == 0 || !MEM_P (target))
2967 target
2968 = gen_rtx_MEM (TYPE_MODE (rettype),
2969 memory_address (TYPE_MODE (rettype),
2970 structure_value_addr));
2971 set_mem_attributes (target, rettype, 1);
2974 else if (pcc_struct_value)
2976 /* This is the special C++ case where we need to
2977 know what the true target was. We take care to
2978 never use this value more than once in one expression. */
2979 target = gen_rtx_MEM (TYPE_MODE (rettype),
2980 copy_to_reg (valreg));
2981 set_mem_attributes (target, rettype, 1);
2983 /* Handle calls that return values in multiple non-contiguous locations.
2984 The Irix 6 ABI has examples of this. */
2985 else if (GET_CODE (valreg) == PARALLEL)
2987 if (target == 0)
2989 /* This will only be assigned once, so it can be readonly. */
2990 tree nt = build_qualified_type (rettype,
2991 (TYPE_QUALS (rettype)
2992 | TYPE_QUAL_CONST));
2994 target = assign_temp (nt, 0, 1, 1);
2997 if (! rtx_equal_p (target, valreg))
2998 emit_group_store (target, valreg, rettype,
2999 int_size_in_bytes (rettype));
3001 /* We can not support sibling calls for this case. */
3002 sibcall_failure = 1;
3004 else if (target
3005 && GET_MODE (target) == TYPE_MODE (rettype)
3006 && GET_MODE (target) == GET_MODE (valreg))
3008 bool may_overlap = false;
3010 /* We have to copy a return value in a CLASS_LIKELY_SPILLED hard
3011 reg to a plain register. */
3012 if (!REG_P (target) || HARD_REGISTER_P (target))
3013 valreg = avoid_likely_spilled_reg (valreg);
3015 /* If TARGET is a MEM in the argument area, and we have
3016 saved part of the argument area, then we can't store
3017 directly into TARGET as it may get overwritten when we
3018 restore the argument save area below. Don't work too
3019 hard though and simply force TARGET to a register if it
3020 is a MEM; the optimizer is quite likely to sort it out. */
3021 if (ACCUMULATE_OUTGOING_ARGS && pass && MEM_P (target))
3022 for (i = 0; i < num_actuals; i++)
3023 if (args[i].save_area)
3025 may_overlap = true;
3026 break;
3029 if (may_overlap)
3030 target = copy_to_reg (valreg);
3031 else
3033 /* TARGET and VALREG cannot be equal at this point
3034 because the latter would not have
3035 REG_FUNCTION_VALUE_P true, while the former would if
3036 it were referring to the same register.
3038 If they refer to the same register, this move will be
3039 a no-op, except when function inlining is being
3040 done. */
3041 emit_move_insn (target, valreg);
3043 /* If we are setting a MEM, this code must be executed.
3044 Since it is emitted after the call insn, sibcall
3045 optimization cannot be performed in that case. */
3046 if (MEM_P (target))
3047 sibcall_failure = 1;
3050 else if (TYPE_MODE (rettype) == BLKmode)
3052 rtx val = valreg;
3053 if (GET_MODE (val) != BLKmode)
3054 val = avoid_likely_spilled_reg (val);
3055 target = copy_blkmode_from_reg (target, val, rettype);
3057 /* We can not support sibling calls for this case. */
3058 sibcall_failure = 1;
3060 else
3061 target = copy_to_reg (avoid_likely_spilled_reg (valreg));
3063 /* If we promoted this return value, make the proper SUBREG.
3064 TARGET might be const0_rtx here, so be careful. */
3065 if (REG_P (target)
3066 && TYPE_MODE (rettype) != BLKmode
3067 && GET_MODE (target) != TYPE_MODE (rettype))
3069 tree type = rettype;
3070 int unsignedp = TYPE_UNSIGNED (type);
3071 int offset = 0;
3072 enum machine_mode pmode;
3074 /* Ensure we promote as expected, and get the new unsignedness. */
3075 pmode = promote_function_mode (type, TYPE_MODE (type), &unsignedp,
3076 funtype, 1);
3077 gcc_assert (GET_MODE (target) == pmode);
3079 if ((WORDS_BIG_ENDIAN || BYTES_BIG_ENDIAN)
3080 && (GET_MODE_SIZE (GET_MODE (target))
3081 > GET_MODE_SIZE (TYPE_MODE (type))))
3083 offset = GET_MODE_SIZE (GET_MODE (target))
3084 - GET_MODE_SIZE (TYPE_MODE (type));
3085 if (! BYTES_BIG_ENDIAN)
3086 offset = (offset / UNITS_PER_WORD) * UNITS_PER_WORD;
3087 else if (! WORDS_BIG_ENDIAN)
3088 offset %= UNITS_PER_WORD;
3091 target = gen_rtx_SUBREG (TYPE_MODE (type), target, offset);
3092 SUBREG_PROMOTED_VAR_P (target) = 1;
3093 SUBREG_PROMOTED_UNSIGNED_SET (target, unsignedp);
3096 /* If size of args is variable or this was a constructor call for a stack
3097 argument, restore saved stack-pointer value. */
3099 if (old_stack_level)
3101 emit_stack_restore (SAVE_BLOCK, old_stack_level);
3102 stack_pointer_delta = old_stack_pointer_delta;
3103 pending_stack_adjust = old_pending_adj;
3104 old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
3105 stack_arg_under_construction = old_stack_arg_under_construction;
3106 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3107 stack_usage_map = initial_stack_usage_map;
3108 sibcall_failure = 1;
3110 else if (ACCUMULATE_OUTGOING_ARGS && pass)
3112 #ifdef REG_PARM_STACK_SPACE
3113 if (save_area)
3114 restore_fixed_argument_area (save_area, argblock,
3115 high_to_save, low_to_save);
3116 #endif
3118 /* If we saved any argument areas, restore them. */
3119 for (i = 0; i < num_actuals; i++)
3120 if (args[i].save_area)
3122 enum machine_mode save_mode = GET_MODE (args[i].save_area);
3123 rtx stack_area
3124 = gen_rtx_MEM (save_mode,
3125 memory_address (save_mode,
3126 XEXP (args[i].stack_slot, 0)));
3128 if (save_mode != BLKmode)
3129 emit_move_insn (stack_area, args[i].save_area);
3130 else
3131 emit_block_move (stack_area, args[i].save_area,
3132 GEN_INT (args[i].locate.size.constant),
3133 BLOCK_OP_CALL_PARM);
3136 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3137 stack_usage_map = initial_stack_usage_map;
3140 /* If this was alloca, record the new stack level for nonlocal gotos.
3141 Check for the handler slots since we might not have a save area
3142 for non-local gotos. */
3144 if ((flags & ECF_MAY_BE_ALLOCA) && cfun->nonlocal_goto_save_area != 0)
3145 update_nonlocal_goto_save_area ();
3147 /* Free up storage we no longer need. */
3148 for (i = 0; i < num_actuals; ++i)
3149 free (args[i].aligned_regs);
3151 insns = get_insns ();
3152 end_sequence ();
3154 if (pass == 0)
3156 tail_call_insns = insns;
3158 /* Restore the pending stack adjustment now that we have
3159 finished generating the sibling call sequence. */
3161 pending_stack_adjust = save_pending_stack_adjust;
3162 stack_pointer_delta = save_stack_pointer_delta;
3164 /* Prepare arg structure for next iteration. */
3165 for (i = 0; i < num_actuals; i++)
3167 args[i].value = 0;
3168 args[i].aligned_regs = 0;
3169 args[i].stack = 0;
3172 sbitmap_free (stored_args_map);
3174 else
3176 normal_call_insns = insns;
3178 /* Verify that we've deallocated all the stack we used. */
3179 gcc_assert ((flags & ECF_NORETURN)
3180 || (old_stack_allocated
3181 == stack_pointer_delta - pending_stack_adjust));
3184 /* If something prevents making this a sibling call,
3185 zero out the sequence. */
3186 if (sibcall_failure)
3187 tail_call_insns = NULL_RTX;
3188 else
3189 break;
3192 /* If tail call production succeeded, we need to remove REG_EQUIV notes on
3193 arguments too, as argument area is now clobbered by the call. */
3194 if (tail_call_insns)
3196 emit_insn (tail_call_insns);
3197 crtl->tail_call_emit = true;
3199 else
3200 emit_insn (normal_call_insns);
3202 currently_expanding_call--;
3204 free (stack_usage_map_buf);
3206 return target;
3209 /* A sibling call sequence invalidates any REG_EQUIV notes made for
3210 this function's incoming arguments.
3212 At the start of RTL generation we know the only REG_EQUIV notes
3213 in the rtl chain are those for incoming arguments, so we can look
3214 for REG_EQUIV notes between the start of the function and the
3215 NOTE_INSN_FUNCTION_BEG.
3217 This is (slight) overkill. We could keep track of the highest
3218 argument we clobber and be more selective in removing notes, but it
3219 does not seem to be worth the effort. */
3221 void
3222 fixup_tail_calls (void)
3224 rtx insn;
3226 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3228 rtx note;
3230 /* There are never REG_EQUIV notes for the incoming arguments
3231 after the NOTE_INSN_FUNCTION_BEG note, so stop if we see it. */
3232 if (NOTE_P (insn)
3233 && NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG)
3234 break;
3236 note = find_reg_note (insn, REG_EQUIV, 0);
3237 if (note)
3238 remove_note (insn, note);
3239 note = find_reg_note (insn, REG_EQUIV, 0);
3240 gcc_assert (!note);
3244 /* Traverse a list of TYPES and expand all complex types into their
3245 components. */
3246 static tree
3247 split_complex_types (tree types)
3249 tree p;
3251 /* Before allocating memory, check for the common case of no complex. */
3252 for (p = types; p; p = TREE_CHAIN (p))
3254 tree type = TREE_VALUE (p);
3255 if (TREE_CODE (type) == COMPLEX_TYPE
3256 && targetm.calls.split_complex_arg (type))
3257 goto found;
3259 return types;
3261 found:
3262 types = copy_list (types);
3264 for (p = types; p; p = TREE_CHAIN (p))
3266 tree complex_type = TREE_VALUE (p);
3268 if (TREE_CODE (complex_type) == COMPLEX_TYPE
3269 && targetm.calls.split_complex_arg (complex_type))
3271 tree next, imag;
3273 /* Rewrite complex type with component type. */
3274 TREE_VALUE (p) = TREE_TYPE (complex_type);
3275 next = TREE_CHAIN (p);
3277 /* Add another component type for the imaginary part. */
3278 imag = build_tree_list (NULL_TREE, TREE_VALUE (p));
3279 TREE_CHAIN (p) = imag;
3280 TREE_CHAIN (imag) = next;
3282 /* Skip the newly created node. */
3283 p = TREE_CHAIN (p);
3287 return types;
3290 /* Output a library call to function FUN (a SYMBOL_REF rtx).
3291 The RETVAL parameter specifies whether return value needs to be saved, other
3292 parameters are documented in the emit_library_call function below. */
3294 static rtx
3295 emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
3296 enum libcall_type fn_type,
3297 enum machine_mode outmode, int nargs, va_list p)
3299 /* Total size in bytes of all the stack-parms scanned so far. */
3300 struct args_size args_size;
3301 /* Size of arguments before any adjustments (such as rounding). */
3302 struct args_size original_args_size;
3303 int argnum;
3304 rtx fun;
3305 /* Todo, choose the correct decl type of orgfun. Sadly this information
3306 isn't present here, so we default to native calling abi here. */
3307 tree fndecl ATTRIBUTE_UNUSED = NULL_TREE; /* library calls default to host calling abi ? */
3308 tree fntype ATTRIBUTE_UNUSED = NULL_TREE; /* library calls default to host calling abi ? */
3309 int inc;
3310 int count;
3311 rtx argblock = 0;
3312 CUMULATIVE_ARGS args_so_far;
3313 struct arg
3315 rtx value;
3316 enum machine_mode mode;
3317 rtx reg;
3318 int partial;
3319 struct locate_and_pad_arg_data locate;
3320 rtx save_area;
3322 struct arg *argvec;
3323 int old_inhibit_defer_pop = inhibit_defer_pop;
3324 rtx call_fusage = 0;
3325 rtx mem_value = 0;
3326 rtx valreg;
3327 int pcc_struct_value = 0;
3328 int struct_value_size = 0;
3329 int flags;
3330 int reg_parm_stack_space = 0;
3331 int needed;
3332 rtx before_call;
3333 tree tfom; /* type_for_mode (outmode, 0) */
3335 #ifdef REG_PARM_STACK_SPACE
3336 /* Define the boundary of the register parm stack space that needs to be
3337 save, if any. */
3338 int low_to_save = 0, high_to_save = 0;
3339 rtx save_area = 0; /* Place that it is saved. */
3340 #endif
3342 /* Size of the stack reserved for parameter registers. */
3343 int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
3344 char *initial_stack_usage_map = stack_usage_map;
3345 char *stack_usage_map_buf = NULL;
3347 rtx struct_value = targetm.calls.struct_value_rtx (0, 0);
3349 #ifdef REG_PARM_STACK_SPACE
3350 reg_parm_stack_space = REG_PARM_STACK_SPACE ((tree) 0);
3351 #endif
3353 /* By default, library functions can not throw. */
3354 flags = ECF_NOTHROW;
3356 switch (fn_type)
3358 case LCT_NORMAL:
3359 break;
3360 case LCT_CONST:
3361 flags |= ECF_CONST;
3362 break;
3363 case LCT_PURE:
3364 flags |= ECF_PURE;
3365 break;
3366 case LCT_NORETURN:
3367 flags |= ECF_NORETURN;
3368 break;
3369 case LCT_THROW:
3370 flags = ECF_NORETURN;
3371 break;
3372 case LCT_RETURNS_TWICE:
3373 flags = ECF_RETURNS_TWICE;
3374 break;
3376 fun = orgfun;
3378 /* Ensure current function's preferred stack boundary is at least
3379 what we need. */
3380 if (crtl->preferred_stack_boundary < PREFERRED_STACK_BOUNDARY)
3381 crtl->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
3383 /* If this kind of value comes back in memory,
3384 decide where in memory it should come back. */
3385 if (outmode != VOIDmode)
3387 tfom = lang_hooks.types.type_for_mode (outmode, 0);
3388 if (aggregate_value_p (tfom, 0))
3390 #ifdef PCC_STATIC_STRUCT_RETURN
3391 rtx pointer_reg
3392 = hard_function_value (build_pointer_type (tfom), 0, 0, 0);
3393 mem_value = gen_rtx_MEM (outmode, pointer_reg);
3394 pcc_struct_value = 1;
3395 if (value == 0)
3396 value = gen_reg_rtx (outmode);
3397 #else /* not PCC_STATIC_STRUCT_RETURN */
3398 struct_value_size = GET_MODE_SIZE (outmode);
3399 if (value != 0 && MEM_P (value))
3400 mem_value = value;
3401 else
3402 mem_value = assign_temp (tfom, 0, 1, 1);
3403 #endif
3404 /* This call returns a big structure. */
3405 flags &= ~(ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
3408 else
3409 tfom = void_type_node;
3411 /* ??? Unfinished: must pass the memory address as an argument. */
3413 /* Copy all the libcall-arguments out of the varargs data
3414 and into a vector ARGVEC.
3416 Compute how to pass each argument. We only support a very small subset
3417 of the full argument passing conventions to limit complexity here since
3418 library functions shouldn't have many args. */
3420 argvec = XALLOCAVEC (struct arg, nargs + 1);
3421 memset (argvec, 0, (nargs + 1) * sizeof (struct arg));
3423 #ifdef INIT_CUMULATIVE_LIBCALL_ARGS
3424 INIT_CUMULATIVE_LIBCALL_ARGS (args_so_far, outmode, fun);
3425 #else
3426 INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE, fun, 0, nargs);
3427 #endif
3429 args_size.constant = 0;
3430 args_size.var = 0;
3432 count = 0;
3434 push_temp_slots ();
3436 /* If there's a structure value address to be passed,
3437 either pass it in the special place, or pass it as an extra argument. */
3438 if (mem_value && struct_value == 0 && ! pcc_struct_value)
3440 rtx addr = XEXP (mem_value, 0);
3442 nargs++;
3444 /* Make sure it is a reasonable operand for a move or push insn. */
3445 if (!REG_P (addr) && !MEM_P (addr)
3446 && !(CONSTANT_P (addr)
3447 && targetm.legitimate_constant_p (Pmode, addr)))
3448 addr = force_operand (addr, NULL_RTX);
3450 argvec[count].value = addr;
3451 argvec[count].mode = Pmode;
3452 argvec[count].partial = 0;
3454 argvec[count].reg = targetm.calls.function_arg (&args_so_far,
3455 Pmode, NULL_TREE, true);
3456 gcc_assert (targetm.calls.arg_partial_bytes (&args_so_far, Pmode,
3457 NULL_TREE, 1) == 0);
3459 locate_and_pad_parm (Pmode, NULL_TREE,
3460 #ifdef STACK_PARMS_IN_REG_PARM_AREA
3462 #else
3463 argvec[count].reg != 0,
3464 #endif
3465 0, NULL_TREE, &args_size, &argvec[count].locate);
3467 if (argvec[count].reg == 0 || argvec[count].partial != 0
3468 || reg_parm_stack_space > 0)
3469 args_size.constant += argvec[count].locate.size.constant;
3471 targetm.calls.function_arg_advance (&args_so_far, Pmode, (tree) 0, true);
3473 count++;
3476 for (; count < nargs; count++)
3478 rtx val = va_arg (p, rtx);
3479 enum machine_mode mode = (enum machine_mode) va_arg (p, int);
3481 /* We cannot convert the arg value to the mode the library wants here;
3482 must do it earlier where we know the signedness of the arg. */
3483 gcc_assert (mode != BLKmode
3484 && (GET_MODE (val) == mode || GET_MODE (val) == VOIDmode));
3486 /* Make sure it is a reasonable operand for a move or push insn. */
3487 if (!REG_P (val) && !MEM_P (val)
3488 && !(CONSTANT_P (val) && targetm.legitimate_constant_p (mode, val)))
3489 val = force_operand (val, NULL_RTX);
3491 if (pass_by_reference (&args_so_far, mode, NULL_TREE, 1))
3493 rtx slot;
3494 int must_copy
3495 = !reference_callee_copied (&args_so_far, mode, NULL_TREE, 1);
3497 /* If this was a CONST function, it is now PURE since it now
3498 reads memory. */
3499 if (flags & ECF_CONST)
3501 flags &= ~ECF_CONST;
3502 flags |= ECF_PURE;
3505 if (MEM_P (val) && !must_copy)
3506 slot = val;
3507 else
3509 slot = assign_temp (lang_hooks.types.type_for_mode (mode, 0),
3510 0, 1, 1);
3511 emit_move_insn (slot, val);
3514 call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
3515 gen_rtx_USE (VOIDmode, slot),
3516 call_fusage);
3517 if (must_copy)
3518 call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
3519 gen_rtx_CLOBBER (VOIDmode,
3520 slot),
3521 call_fusage);
3523 mode = Pmode;
3524 val = force_operand (XEXP (slot, 0), NULL_RTX);
3527 argvec[count].value = val;
3528 argvec[count].mode = mode;
3530 argvec[count].reg = targetm.calls.function_arg (&args_so_far, mode,
3531 NULL_TREE, true);
3533 argvec[count].partial
3534 = targetm.calls.arg_partial_bytes (&args_so_far, mode, NULL_TREE, 1);
3536 locate_and_pad_parm (mode, NULL_TREE,
3537 #ifdef STACK_PARMS_IN_REG_PARM_AREA
3539 #else
3540 argvec[count].reg != 0,
3541 #endif
3542 argvec[count].partial,
3543 NULL_TREE, &args_size, &argvec[count].locate);
3545 gcc_assert (!argvec[count].locate.size.var);
3547 if (argvec[count].reg == 0 || argvec[count].partial != 0
3548 || reg_parm_stack_space > 0)
3549 args_size.constant += argvec[count].locate.size.constant;
3551 targetm.calls.function_arg_advance (&args_so_far, mode, (tree) 0, true);
3554 /* If this machine requires an external definition for library
3555 functions, write one out. */
3556 assemble_external_libcall (fun);
3558 original_args_size = args_size;
3559 args_size.constant = (((args_size.constant
3560 + stack_pointer_delta
3561 + STACK_BYTES - 1)
3562 / STACK_BYTES
3563 * STACK_BYTES)
3564 - stack_pointer_delta);
3566 args_size.constant = MAX (args_size.constant,
3567 reg_parm_stack_space);
3569 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
3570 args_size.constant -= reg_parm_stack_space;
3572 if (args_size.constant > crtl->outgoing_args_size)
3573 crtl->outgoing_args_size = args_size.constant;
3575 if (flag_stack_usage && !ACCUMULATE_OUTGOING_ARGS)
3577 int pushed = args_size.constant + pending_stack_adjust;
3578 if (pushed > current_function_pushed_stack_size)
3579 current_function_pushed_stack_size = pushed;
3582 if (ACCUMULATE_OUTGOING_ARGS)
3584 /* Since the stack pointer will never be pushed, it is possible for
3585 the evaluation of a parm to clobber something we have already
3586 written to the stack. Since most function calls on RISC machines
3587 do not use the stack, this is uncommon, but must work correctly.
3589 Therefore, we save any area of the stack that was already written
3590 and that we are using. Here we set up to do this by making a new
3591 stack usage map from the old one.
3593 Another approach might be to try to reorder the argument
3594 evaluations to avoid this conflicting stack usage. */
3596 needed = args_size.constant;
3598 /* Since we will be writing into the entire argument area, the
3599 map must be allocated for its entire size, not just the part that
3600 is the responsibility of the caller. */
3601 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
3602 needed += reg_parm_stack_space;
3604 #ifdef ARGS_GROW_DOWNWARD
3605 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
3606 needed + 1);
3607 #else
3608 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
3609 needed);
3610 #endif
3611 stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
3612 stack_usage_map = stack_usage_map_buf;
3614 if (initial_highest_arg_in_use)
3615 memcpy (stack_usage_map, initial_stack_usage_map,
3616 initial_highest_arg_in_use);
3618 if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
3619 memset (&stack_usage_map[initial_highest_arg_in_use], 0,
3620 highest_outgoing_arg_in_use - initial_highest_arg_in_use);
3621 needed = 0;
3623 /* We must be careful to use virtual regs before they're instantiated,
3624 and real regs afterwards. Loop optimization, for example, can create
3625 new libcalls after we've instantiated the virtual regs, and if we
3626 use virtuals anyway, they won't match the rtl patterns. */
3628 if (virtuals_instantiated)
3629 argblock = plus_constant (stack_pointer_rtx, STACK_POINTER_OFFSET);
3630 else
3631 argblock = virtual_outgoing_args_rtx;
3633 else
3635 if (!PUSH_ARGS)
3636 argblock = push_block (GEN_INT (args_size.constant), 0, 0);
3639 /* If we push args individually in reverse order, perform stack alignment
3640 before the first push (the last arg). */
3641 if (argblock == 0 && PUSH_ARGS_REVERSED)
3642 anti_adjust_stack (GEN_INT (args_size.constant
3643 - original_args_size.constant));
3645 if (PUSH_ARGS_REVERSED)
3647 inc = -1;
3648 argnum = nargs - 1;
3650 else
3652 inc = 1;
3653 argnum = 0;
3656 #ifdef REG_PARM_STACK_SPACE
3657 if (ACCUMULATE_OUTGOING_ARGS)
3659 /* The argument list is the property of the called routine and it
3660 may clobber it. If the fixed area has been used for previous
3661 parameters, we must save and restore it. */
3662 save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
3663 &low_to_save, &high_to_save);
3665 #endif
3667 /* Push the args that need to be pushed. */
3669 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
3670 are to be pushed. */
3671 for (count = 0; count < nargs; count++, argnum += inc)
3673 enum machine_mode mode = argvec[argnum].mode;
3674 rtx val = argvec[argnum].value;
3675 rtx reg = argvec[argnum].reg;
3676 int partial = argvec[argnum].partial;
3677 unsigned int parm_align = argvec[argnum].locate.boundary;
3678 int lower_bound = 0, upper_bound = 0, i;
3680 if (! (reg != 0 && partial == 0))
3682 rtx use;
3684 if (ACCUMULATE_OUTGOING_ARGS)
3686 /* If this is being stored into a pre-allocated, fixed-size,
3687 stack area, save any previous data at that location. */
3689 #ifdef ARGS_GROW_DOWNWARD
3690 /* stack_slot is negative, but we want to index stack_usage_map
3691 with positive values. */
3692 upper_bound = -argvec[argnum].locate.slot_offset.constant + 1;
3693 lower_bound = upper_bound - argvec[argnum].locate.size.constant;
3694 #else
3695 lower_bound = argvec[argnum].locate.slot_offset.constant;
3696 upper_bound = lower_bound + argvec[argnum].locate.size.constant;
3697 #endif
3699 i = lower_bound;
3700 /* Don't worry about things in the fixed argument area;
3701 it has already been saved. */
3702 if (i < reg_parm_stack_space)
3703 i = reg_parm_stack_space;
3704 while (i < upper_bound && stack_usage_map[i] == 0)
3705 i++;
3707 if (i < upper_bound)
3709 /* We need to make a save area. */
3710 unsigned int size
3711 = argvec[argnum].locate.size.constant * BITS_PER_UNIT;
3712 enum machine_mode save_mode
3713 = mode_for_size (size, MODE_INT, 1);
3714 rtx adr
3715 = plus_constant (argblock,
3716 argvec[argnum].locate.offset.constant);
3717 rtx stack_area
3718 = gen_rtx_MEM (save_mode, memory_address (save_mode, adr));
3720 if (save_mode == BLKmode)
3722 argvec[argnum].save_area
3723 = assign_stack_temp (BLKmode,
3724 argvec[argnum].locate.size.constant,
3727 emit_block_move (validize_mem (argvec[argnum].save_area),
3728 stack_area,
3729 GEN_INT (argvec[argnum].locate.size.constant),
3730 BLOCK_OP_CALL_PARM);
3732 else
3734 argvec[argnum].save_area = gen_reg_rtx (save_mode);
3736 emit_move_insn (argvec[argnum].save_area, stack_area);
3741 emit_push_insn (val, mode, NULL_TREE, NULL_RTX, parm_align,
3742 partial, reg, 0, argblock,
3743 GEN_INT (argvec[argnum].locate.offset.constant),
3744 reg_parm_stack_space,
3745 ARGS_SIZE_RTX (argvec[argnum].locate.alignment_pad));
3747 /* Now mark the segment we just used. */
3748 if (ACCUMULATE_OUTGOING_ARGS)
3749 for (i = lower_bound; i < upper_bound; i++)
3750 stack_usage_map[i] = 1;
3752 NO_DEFER_POP;
3754 /* Indicate argument access so that alias.c knows that these
3755 values are live. */
3756 if (argblock)
3757 use = plus_constant (argblock,
3758 argvec[argnum].locate.offset.constant);
3759 else
3760 /* When arguments are pushed, trying to tell alias.c where
3761 exactly this argument is won't work, because the
3762 auto-increment causes confusion. So we merely indicate
3763 that we access something with a known mode somewhere on
3764 the stack. */
3765 use = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
3766 gen_rtx_SCRATCH (Pmode));
3767 use = gen_rtx_MEM (argvec[argnum].mode, use);
3768 use = gen_rtx_USE (VOIDmode, use);
3769 call_fusage = gen_rtx_EXPR_LIST (VOIDmode, use, call_fusage);
3773 /* If we pushed args in forward order, perform stack alignment
3774 after pushing the last arg. */
3775 if (argblock == 0 && !PUSH_ARGS_REVERSED)
3776 anti_adjust_stack (GEN_INT (args_size.constant
3777 - original_args_size.constant));
3779 if (PUSH_ARGS_REVERSED)
3780 argnum = nargs - 1;
3781 else
3782 argnum = 0;
3784 fun = prepare_call_address (NULL, fun, NULL, &call_fusage, 0, 0);
3786 /* Now load any reg parms into their regs. */
3788 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
3789 are to be pushed. */
3790 for (count = 0; count < nargs; count++, argnum += inc)
3792 enum machine_mode mode = argvec[argnum].mode;
3793 rtx val = argvec[argnum].value;
3794 rtx reg = argvec[argnum].reg;
3795 int partial = argvec[argnum].partial;
3797 /* Handle calls that pass values in multiple non-contiguous
3798 locations. The PA64 has examples of this for library calls. */
3799 if (reg != 0 && GET_CODE (reg) == PARALLEL)
3800 emit_group_load (reg, val, NULL_TREE, GET_MODE_SIZE (mode));
3801 else if (reg != 0 && partial == 0)
3802 emit_move_insn (reg, val);
3804 NO_DEFER_POP;
3807 /* Any regs containing parms remain in use through the call. */
3808 for (count = 0; count < nargs; count++)
3810 rtx reg = argvec[count].reg;
3811 if (reg != 0 && GET_CODE (reg) == PARALLEL)
3812 use_group_regs (&call_fusage, reg);
3813 else if (reg != 0)
3815 int partial = argvec[count].partial;
3816 if (partial)
3818 int nregs;
3819 gcc_assert (partial % UNITS_PER_WORD == 0);
3820 nregs = partial / UNITS_PER_WORD;
3821 use_regs (&call_fusage, REGNO (reg), nregs);
3823 else
3824 use_reg (&call_fusage, reg);
3828 /* Pass the function the address in which to return a structure value. */
3829 if (mem_value != 0 && struct_value != 0 && ! pcc_struct_value)
3831 emit_move_insn (struct_value,
3832 force_reg (Pmode,
3833 force_operand (XEXP (mem_value, 0),
3834 NULL_RTX)));
3835 if (REG_P (struct_value))
3836 use_reg (&call_fusage, struct_value);
3839 /* Don't allow popping to be deferred, since then
3840 cse'ing of library calls could delete a call and leave the pop. */
3841 NO_DEFER_POP;
3842 valreg = (mem_value == 0 && outmode != VOIDmode
3843 ? hard_libcall_value (outmode, orgfun) : NULL_RTX);
3845 /* Stack must be properly aligned now. */
3846 gcc_assert (!(stack_pointer_delta
3847 & (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1)));
3849 before_call = get_last_insn ();
3851 /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
3852 will set inhibit_defer_pop to that value. */
3853 /* The return type is needed to decide how many bytes the function pops.
3854 Signedness plays no role in that, so for simplicity, we pretend it's
3855 always signed. We also assume that the list of arguments passed has
3856 no impact, so we pretend it is unknown. */
3858 emit_call_1 (fun, NULL,
3859 get_identifier (XSTR (orgfun, 0)),
3860 build_function_type (tfom, NULL_TREE),
3861 original_args_size.constant, args_size.constant,
3862 struct_value_size,
3863 targetm.calls.function_arg (&args_so_far,
3864 VOIDmode, void_type_node, true),
3865 valreg,
3866 old_inhibit_defer_pop + 1, call_fusage, flags, & args_so_far);
3868 /* For calls to `setjmp', etc., inform function.c:setjmp_warnings
3869 that it should complain if nonvolatile values are live. For
3870 functions that cannot return, inform flow that control does not
3871 fall through. */
3873 if (flags & ECF_NORETURN)
3875 /* The barrier note must be emitted
3876 immediately after the CALL_INSN. Some ports emit more than
3877 just a CALL_INSN above, so we must search for it here. */
3879 rtx last = get_last_insn ();
3880 while (!CALL_P (last))
3882 last = PREV_INSN (last);
3883 /* There was no CALL_INSN? */
3884 gcc_assert (last != before_call);
3887 emit_barrier_after (last);
3890 /* Now restore inhibit_defer_pop to its actual original value. */
3891 OK_DEFER_POP;
3893 pop_temp_slots ();
3895 /* Copy the value to the right place. */
3896 if (outmode != VOIDmode && retval)
3898 if (mem_value)
3900 if (value == 0)
3901 value = mem_value;
3902 if (value != mem_value)
3903 emit_move_insn (value, mem_value);
3905 else if (GET_CODE (valreg) == PARALLEL)
3907 if (value == 0)
3908 value = gen_reg_rtx (outmode);
3909 emit_group_store (value, valreg, NULL_TREE, GET_MODE_SIZE (outmode));
3911 else
3913 /* Convert to the proper mode if a promotion has been active. */
3914 if (GET_MODE (valreg) != outmode)
3916 int unsignedp = TYPE_UNSIGNED (tfom);
3918 gcc_assert (promote_function_mode (tfom, outmode, &unsignedp,
3919 fndecl ? TREE_TYPE (fndecl) : fntype, 1)
3920 == GET_MODE (valreg));
3921 valreg = convert_modes (outmode, GET_MODE (valreg), valreg, 0);
3924 if (value != 0)
3925 emit_move_insn (value, valreg);
3926 else
3927 value = valreg;
3931 if (ACCUMULATE_OUTGOING_ARGS)
3933 #ifdef REG_PARM_STACK_SPACE
3934 if (save_area)
3935 restore_fixed_argument_area (save_area, argblock,
3936 high_to_save, low_to_save);
3937 #endif
3939 /* If we saved any argument areas, restore them. */
3940 for (count = 0; count < nargs; count++)
3941 if (argvec[count].save_area)
3943 enum machine_mode save_mode = GET_MODE (argvec[count].save_area);
3944 rtx adr = plus_constant (argblock,
3945 argvec[count].locate.offset.constant);
3946 rtx stack_area = gen_rtx_MEM (save_mode,
3947 memory_address (save_mode, adr));
3949 if (save_mode == BLKmode)
3950 emit_block_move (stack_area,
3951 validize_mem (argvec[count].save_area),
3952 GEN_INT (argvec[count].locate.size.constant),
3953 BLOCK_OP_CALL_PARM);
3954 else
3955 emit_move_insn (stack_area, argvec[count].save_area);
3958 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3959 stack_usage_map = initial_stack_usage_map;
3962 free (stack_usage_map_buf);
3964 return value;
3968 /* Output a library call to function FUN (a SYMBOL_REF rtx)
3969 (emitting the queue unless NO_QUEUE is nonzero),
3970 for a value of mode OUTMODE,
3971 with NARGS different arguments, passed as alternating rtx values
3972 and machine_modes to convert them to.
3974 FN_TYPE should be LCT_NORMAL for `normal' calls, LCT_CONST for
3975 `const' calls, LCT_PURE for `pure' calls, or other LCT_ value for
3976 other types of library calls. */
3978 void
3979 emit_library_call (rtx orgfun, enum libcall_type fn_type,
3980 enum machine_mode outmode, int nargs, ...)
3982 va_list p;
3984 va_start (p, nargs);
3985 emit_library_call_value_1 (0, orgfun, NULL_RTX, fn_type, outmode, nargs, p);
3986 va_end (p);
3989 /* Like emit_library_call except that an extra argument, VALUE,
3990 comes second and says where to store the result.
3991 (If VALUE is zero, this function chooses a convenient way
3992 to return the value.
3994 This function returns an rtx for where the value is to be found.
3995 If VALUE is nonzero, VALUE is returned. */
3998 emit_library_call_value (rtx orgfun, rtx value,
3999 enum libcall_type fn_type,
4000 enum machine_mode outmode, int nargs, ...)
4002 rtx result;
4003 va_list p;
4005 va_start (p, nargs);
4006 result = emit_library_call_value_1 (1, orgfun, value, fn_type, outmode,
4007 nargs, p);
4008 va_end (p);
4010 return result;
4013 /* Store a single argument for a function call
4014 into the register or memory area where it must be passed.
4015 *ARG describes the argument value and where to pass it.
4017 ARGBLOCK is the address of the stack-block for all the arguments,
4018 or 0 on a machine where arguments are pushed individually.
4020 MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
4021 so must be careful about how the stack is used.
4023 VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
4024 argument stack. This is used if ACCUMULATE_OUTGOING_ARGS to indicate
4025 that we need not worry about saving and restoring the stack.
4027 FNDECL is the declaration of the function we are calling.
4029 Return nonzero if this arg should cause sibcall failure,
4030 zero otherwise. */
4032 static int
4033 store_one_arg (struct arg_data *arg, rtx argblock, int flags,
4034 int variable_size ATTRIBUTE_UNUSED, int reg_parm_stack_space)
4036 tree pval = arg->tree_value;
4037 rtx reg = 0;
4038 int partial = 0;
4039 int used = 0;
4040 int i, lower_bound = 0, upper_bound = 0;
4041 int sibcall_failure = 0;
4043 if (TREE_CODE (pval) == ERROR_MARK)
4044 return 1;
4046 /* Push a new temporary level for any temporaries we make for
4047 this argument. */
4048 push_temp_slots ();
4050 if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL))
4052 /* If this is being stored into a pre-allocated, fixed-size, stack area,
4053 save any previous data at that location. */
4054 if (argblock && ! variable_size && arg->stack)
4056 #ifdef ARGS_GROW_DOWNWARD
4057 /* stack_slot is negative, but we want to index stack_usage_map
4058 with positive values. */
4059 if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
4060 upper_bound = -INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1)) + 1;
4061 else
4062 upper_bound = 0;
4064 lower_bound = upper_bound - arg->locate.size.constant;
4065 #else
4066 if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
4067 lower_bound = INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1));
4068 else
4069 lower_bound = 0;
4071 upper_bound = lower_bound + arg->locate.size.constant;
4072 #endif
4074 i = lower_bound;
4075 /* Don't worry about things in the fixed argument area;
4076 it has already been saved. */
4077 if (i < reg_parm_stack_space)
4078 i = reg_parm_stack_space;
4079 while (i < upper_bound && stack_usage_map[i] == 0)
4080 i++;
4082 if (i < upper_bound)
4084 /* We need to make a save area. */
4085 unsigned int size = arg->locate.size.constant * BITS_PER_UNIT;
4086 enum machine_mode save_mode = mode_for_size (size, MODE_INT, 1);
4087 rtx adr = memory_address (save_mode, XEXP (arg->stack_slot, 0));
4088 rtx stack_area = gen_rtx_MEM (save_mode, adr);
4090 if (save_mode == BLKmode)
4092 tree ot = TREE_TYPE (arg->tree_value);
4093 tree nt = build_qualified_type (ot, (TYPE_QUALS (ot)
4094 | TYPE_QUAL_CONST));
4096 arg->save_area = assign_temp (nt, 0, 1, 1);
4097 preserve_temp_slots (arg->save_area);
4098 emit_block_move (validize_mem (arg->save_area), stack_area,
4099 GEN_INT (arg->locate.size.constant),
4100 BLOCK_OP_CALL_PARM);
4102 else
4104 arg->save_area = gen_reg_rtx (save_mode);
4105 emit_move_insn (arg->save_area, stack_area);
4111 /* If this isn't going to be placed on both the stack and in registers,
4112 set up the register and number of words. */
4113 if (! arg->pass_on_stack)
4115 if (flags & ECF_SIBCALL)
4116 reg = arg->tail_call_reg;
4117 else
4118 reg = arg->reg;
4119 partial = arg->partial;
4122 /* Being passed entirely in a register. We shouldn't be called in
4123 this case. */
4124 gcc_assert (reg == 0 || partial != 0);
4126 /* If this arg needs special alignment, don't load the registers
4127 here. */
4128 if (arg->n_aligned_regs != 0)
4129 reg = 0;
4131 /* If this is being passed partially in a register, we can't evaluate
4132 it directly into its stack slot. Otherwise, we can. */
4133 if (arg->value == 0)
4135 /* stack_arg_under_construction is nonzero if a function argument is
4136 being evaluated directly into the outgoing argument list and
4137 expand_call must take special action to preserve the argument list
4138 if it is called recursively.
4140 For scalar function arguments stack_usage_map is sufficient to
4141 determine which stack slots must be saved and restored. Scalar
4142 arguments in general have pass_on_stack == 0.
4144 If this argument is initialized by a function which takes the
4145 address of the argument (a C++ constructor or a C function
4146 returning a BLKmode structure), then stack_usage_map is
4147 insufficient and expand_call must push the stack around the
4148 function call. Such arguments have pass_on_stack == 1.
4150 Note that it is always safe to set stack_arg_under_construction,
4151 but this generates suboptimal code if set when not needed. */
4153 if (arg->pass_on_stack)
4154 stack_arg_under_construction++;
4156 arg->value = expand_expr (pval,
4157 (partial
4158 || TYPE_MODE (TREE_TYPE (pval)) != arg->mode)
4159 ? NULL_RTX : arg->stack,
4160 VOIDmode, EXPAND_STACK_PARM);
4162 /* If we are promoting object (or for any other reason) the mode
4163 doesn't agree, convert the mode. */
4165 if (arg->mode != TYPE_MODE (TREE_TYPE (pval)))
4166 arg->value = convert_modes (arg->mode, TYPE_MODE (TREE_TYPE (pval)),
4167 arg->value, arg->unsignedp);
4169 if (arg->pass_on_stack)
4170 stack_arg_under_construction--;
4173 /* Check for overlap with already clobbered argument area. */
4174 if ((flags & ECF_SIBCALL)
4175 && MEM_P (arg->value)
4176 && mem_overlaps_already_clobbered_arg_p (XEXP (arg->value, 0),
4177 arg->locate.size.constant))
4178 sibcall_failure = 1;
4180 /* Don't allow anything left on stack from computation
4181 of argument to alloca. */
4182 if (flags & ECF_MAY_BE_ALLOCA)
4183 do_pending_stack_adjust ();
4185 if (arg->value == arg->stack)
4186 /* If the value is already in the stack slot, we are done. */
4188 else if (arg->mode != BLKmode)
4190 int size;
4191 unsigned int parm_align;
4193 /* Argument is a scalar, not entirely passed in registers.
4194 (If part is passed in registers, arg->partial says how much
4195 and emit_push_insn will take care of putting it there.)
4197 Push it, and if its size is less than the
4198 amount of space allocated to it,
4199 also bump stack pointer by the additional space.
4200 Note that in C the default argument promotions
4201 will prevent such mismatches. */
4203 size = GET_MODE_SIZE (arg->mode);
4204 /* Compute how much space the push instruction will push.
4205 On many machines, pushing a byte will advance the stack
4206 pointer by a halfword. */
4207 #ifdef PUSH_ROUNDING
4208 size = PUSH_ROUNDING (size);
4209 #endif
4210 used = size;
4212 /* Compute how much space the argument should get:
4213 round up to a multiple of the alignment for arguments. */
4214 if (none != FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)))
4215 used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1)
4216 / (PARM_BOUNDARY / BITS_PER_UNIT))
4217 * (PARM_BOUNDARY / BITS_PER_UNIT));
4219 /* Compute the alignment of the pushed argument. */
4220 parm_align = arg->locate.boundary;
4221 if (FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)) == downward)
4223 int pad = used - size;
4224 if (pad)
4226 unsigned int pad_align = (pad & -pad) * BITS_PER_UNIT;
4227 parm_align = MIN (parm_align, pad_align);
4231 /* This isn't already where we want it on the stack, so put it there.
4232 This can either be done with push or copy insns. */
4233 emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX,
4234 parm_align, partial, reg, used - size, argblock,
4235 ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
4236 ARGS_SIZE_RTX (arg->locate.alignment_pad));
4238 /* Unless this is a partially-in-register argument, the argument is now
4239 in the stack. */
4240 if (partial == 0)
4241 arg->value = arg->stack;
4243 else
4245 /* BLKmode, at least partly to be pushed. */
4247 unsigned int parm_align;
4248 int excess;
4249 rtx size_rtx;
4251 /* Pushing a nonscalar.
4252 If part is passed in registers, PARTIAL says how much
4253 and emit_push_insn will take care of putting it there. */
4255 /* Round its size up to a multiple
4256 of the allocation unit for arguments. */
4258 if (arg->locate.size.var != 0)
4260 excess = 0;
4261 size_rtx = ARGS_SIZE_RTX (arg->locate.size);
4263 else
4265 /* PUSH_ROUNDING has no effect on us, because emit_push_insn
4266 for BLKmode is careful to avoid it. */
4267 excess = (arg->locate.size.constant
4268 - int_size_in_bytes (TREE_TYPE (pval))
4269 + partial);
4270 size_rtx = expand_expr (size_in_bytes (TREE_TYPE (pval)),
4271 NULL_RTX, TYPE_MODE (sizetype),
4272 EXPAND_NORMAL);
4275 parm_align = arg->locate.boundary;
4277 /* When an argument is padded down, the block is aligned to
4278 PARM_BOUNDARY, but the actual argument isn't. */
4279 if (FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)) == downward)
4281 if (arg->locate.size.var)
4282 parm_align = BITS_PER_UNIT;
4283 else if (excess)
4285 unsigned int excess_align = (excess & -excess) * BITS_PER_UNIT;
4286 parm_align = MIN (parm_align, excess_align);
4290 if ((flags & ECF_SIBCALL) && MEM_P (arg->value))
4292 /* emit_push_insn might not work properly if arg->value and
4293 argblock + arg->locate.offset areas overlap. */
4294 rtx x = arg->value;
4295 int i = 0;
4297 if (XEXP (x, 0) == crtl->args.internal_arg_pointer
4298 || (GET_CODE (XEXP (x, 0)) == PLUS
4299 && XEXP (XEXP (x, 0), 0) ==
4300 crtl->args.internal_arg_pointer
4301 && CONST_INT_P (XEXP (XEXP (x, 0), 1))))
4303 if (XEXP (x, 0) != crtl->args.internal_arg_pointer)
4304 i = INTVAL (XEXP (XEXP (x, 0), 1));
4306 /* expand_call should ensure this. */
4307 gcc_assert (!arg->locate.offset.var
4308 && arg->locate.size.var == 0
4309 && CONST_INT_P (size_rtx));
4311 if (arg->locate.offset.constant > i)
4313 if (arg->locate.offset.constant < i + INTVAL (size_rtx))
4314 sibcall_failure = 1;
4316 else if (arg->locate.offset.constant < i)
4318 /* Use arg->locate.size.constant instead of size_rtx
4319 because we only care about the part of the argument
4320 on the stack. */
4321 if (i < (arg->locate.offset.constant
4322 + arg->locate.size.constant))
4323 sibcall_failure = 1;
4325 else
4327 /* Even though they appear to be at the same location,
4328 if part of the outgoing argument is in registers,
4329 they aren't really at the same location. Check for
4330 this by making sure that the incoming size is the
4331 same as the outgoing size. */
4332 if (arg->locate.size.constant != INTVAL (size_rtx))
4333 sibcall_failure = 1;
4338 emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
4339 parm_align, partial, reg, excess, argblock,
4340 ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
4341 ARGS_SIZE_RTX (arg->locate.alignment_pad));
4343 /* Unless this is a partially-in-register argument, the argument is now
4344 in the stack.
4346 ??? Unlike the case above, in which we want the actual
4347 address of the data, so that we can load it directly into a
4348 register, here we want the address of the stack slot, so that
4349 it's properly aligned for word-by-word copying or something
4350 like that. It's not clear that this is always correct. */
4351 if (partial == 0)
4352 arg->value = arg->stack_slot;
4355 if (arg->reg && GET_CODE (arg->reg) == PARALLEL)
4357 tree type = TREE_TYPE (arg->tree_value);
4358 arg->parallel_value
4359 = emit_group_load_into_temps (arg->reg, arg->value, type,
4360 int_size_in_bytes (type));
4363 /* Mark all slots this store used. */
4364 if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL)
4365 && argblock && ! variable_size && arg->stack)
4366 for (i = lower_bound; i < upper_bound; i++)
4367 stack_usage_map[i] = 1;
4369 /* Once we have pushed something, pops can't safely
4370 be deferred during the rest of the arguments. */
4371 NO_DEFER_POP;
4373 /* Free any temporary slots made in processing this argument. Show
4374 that we might have taken the address of something and pushed that
4375 as an operand. */
4376 preserve_temp_slots (NULL_RTX);
4377 free_temp_slots ();
4378 pop_temp_slots ();
4380 return sibcall_failure;
4383 /* Nonzero if we do not know how to pass TYPE solely in registers. */
4385 bool
4386 must_pass_in_stack_var_size (enum machine_mode mode ATTRIBUTE_UNUSED,
4387 const_tree type)
4389 if (!type)
4390 return false;
4392 /* If the type has variable size... */
4393 if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4394 return true;
4396 /* If the type is marked as addressable (it is required
4397 to be constructed into the stack)... */
4398 if (TREE_ADDRESSABLE (type))
4399 return true;
4401 return false;
4404 /* Another version of the TARGET_MUST_PASS_IN_STACK hook. This one
4405 takes trailing padding of a structure into account. */
4406 /* ??? Should be able to merge these two by examining BLOCK_REG_PADDING. */
4408 bool
4409 must_pass_in_stack_var_size_or_pad (enum machine_mode mode, const_tree type)
4411 if (!type)
4412 return false;
4414 /* If the type has variable size... */
4415 if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
4416 return true;
4418 /* If the type is marked as addressable (it is required
4419 to be constructed into the stack)... */
4420 if (TREE_ADDRESSABLE (type))
4421 return true;
4423 /* If the padding and mode of the type is such that a copy into
4424 a register would put it into the wrong part of the register. */
4425 if (mode == BLKmode
4426 && int_size_in_bytes (type) % (PARM_BOUNDARY / BITS_PER_UNIT)
4427 && (FUNCTION_ARG_PADDING (mode, type)
4428 == (BYTES_BIG_ENDIAN ? upward : downward)))
4429 return true;
4431 return false;