1 /* Convert function calls to rtl insns, for GNU C compiler.
2 Copyright (C) 1989-2016 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
10
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
19
20 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "backend.h"
24 #include "target.h"
25 #include "rtl.h"
26 #include "tree.h"
27 #include "gimple.h"
28 #include "predict.h"
29 #include "tm_p.h"
30 #include "stringpool.h"
31 #include "expmed.h"
32 #include "optabs.h"
33 #include "emit-rtl.h"
34 #include "cgraph.h"
35 #include "diagnostic-core.h"
36 #include "fold-const.h"
37 #include "stor-layout.h"
38 #include "varasm.h"
39 #include "internal-fn.h"
40 #include "dojump.h"
41 #include "explow.h"
42 #include "calls.h"
43 #include "expr.h"
44 #include "output.h"
45 #include "langhooks.h"
46 #include "except.h"
47 #include "dbgcnt.h"
48 #include "rtl-iter.h"
49 #include "tree-chkp.h"
50 #include "rtl-chkp.h"
51
52
53 /* Like PREFERRED_STACK_BOUNDARY but in units of bytes, not bits. */
54 #define STACK_BYTES (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT)
55
56 /* Data structure and subroutines used within expand_call. */
57
58 struct arg_data
59 {
60 /* Tree node for this argument. */
61 tree tree_value;
62 /* Mode for value; TYPE_MODE unless promoted. */
63 machine_mode mode;
64 /* Current RTL value for argument, or 0 if it isn't precomputed. */
65 rtx value;
66 /* Initially-compute RTL value for argument; only for const functions. */
67 rtx initial_value;
68 /* Register to pass this argument in, 0 if passed on stack, or an
69 PARALLEL if the arg is to be copied into multiple non-contiguous
70 registers. */
71 rtx reg;
72 /* Register to pass this argument in when generating tail call sequence.
73 This is not the same register as for normal calls on machines with
74 register windows. */
75 rtx tail_call_reg;
76 /* If REG is a PARALLEL, this is a copy of VALUE pulled into the correct
77 form for emit_group_move. */
78 rtx parallel_value;
79 /* If value is passed in neither reg nor stack, this field holds a number
80 of a special slot to be used. */
81 rtx special_slot;
82 /* For pointer bounds hold an index of parm bounds are bound to. -1 if
83 there is no such pointer. */
84 int pointer_arg;
85 /* If pointer_arg refers a structure, then pointer_offset holds an offset
86 of a pointer in this structure. */
87 int pointer_offset;
88 /* If REG was promoted from the actual mode of the argument expression,
89 indicates whether the promotion is sign- or zero-extended. */
90 int unsignedp;
91 /* Number of bytes to put in registers. 0 means put the whole arg
92 in registers. Also 0 if not passed in registers. */
93 int partial;
94 /* Nonzero if argument must be passed on stack.
95 Note that some arguments may be passed on the stack
96 even though pass_on_stack is zero, just because FUNCTION_ARG says so.
97 pass_on_stack identifies arguments that *cannot* go in registers. */
98 int pass_on_stack;
99 /* Some fields packaged up for locate_and_pad_parm. */
100 struct locate_and_pad_arg_data locate;
101 /* Location on the stack at which parameter should be stored. The store
102 has already been done if STACK == VALUE. */
103 rtx stack;
104 /* Location on the stack of the start of this argument slot. This can
105 differ from STACK if this arg pads downward. This location is known
106 to be aligned to TARGET_FUNCTION_ARG_BOUNDARY. */
107 rtx stack_slot;
108 /* Place that this stack area has been saved, if needed. */
109 rtx save_area;
110 /* If an argument's alignment does not permit direct copying into registers,
111 copy in smaller-sized pieces into pseudos. These are stored in a
112 block pointed to by this field. The next field says how many
113 word-sized pseudos we made. */
114 rtx *aligned_regs;
115 int n_aligned_regs;
116 };
117
118 /* A vector of one char per byte of stack space. A byte if nonzero if
119 the corresponding stack location has been used.
120 This vector is used to prevent a function call within an argument from
121 clobbering any stack already set up. */
122 static char *stack_usage_map;
123
124 /* Size of STACK_USAGE_MAP. */
125 static int highest_outgoing_arg_in_use;
126
127 /* A bitmap of virtual-incoming stack space. Bit is set if the corresponding
128 stack location's tail call argument has been already stored into the stack.
129 This bitmap is used to prevent sibling call optimization if function tries
130 to use parent's incoming argument slots when they have been already
131 overwritten with tail call arguments. */
132 static sbitmap stored_args_map;
133
134 /* stack_arg_under_construction is nonzero when an argument may be
135 initialized with a constructor call (including a C function that
136 returns a BLKmode struct) and expand_call must take special action
137 to make sure the object being constructed does not overlap the
138 argument list for the constructor call. */
139 static int stack_arg_under_construction;
140
141 static void emit_call_1 (rtx, tree, tree, tree, HOST_WIDE_INT, HOST_WIDE_INT,
142 HOST_WIDE_INT, rtx, rtx, int, rtx, int,
143 cumulative_args_t);
144 static void precompute_register_parameters (int, struct arg_data *, int *);
145 static void store_bounds (struct arg_data *, struct arg_data *);
146 static int store_one_arg (struct arg_data *, rtx, int, int, int);
147 static void store_unaligned_arguments_into_pseudos (struct arg_data *, int);
148 static int finalize_must_preallocate (int, int, struct arg_data *,
149 struct args_size *);
150 static void precompute_arguments (int, struct arg_data *);
151 static int compute_argument_block_size (int, struct args_size *, tree, tree, int);
152 static void initialize_argument_information (int, struct arg_data *,
153 struct args_size *, int,
154 tree, tree,
155 tree, tree, cumulative_args_t, int,
156 rtx *, int *, int *, int *,
157 bool *, bool);
158 static void compute_argument_addresses (struct arg_data *, rtx, int);
159 static rtx rtx_for_function_call (tree, tree);
160 static void load_register_parameters (struct arg_data *, int, rtx *, int,
161 int, int *);
162 static rtx emit_library_call_value_1 (int, rtx, rtx, enum libcall_type,
163 machine_mode, int, va_list);
164 static int special_function_p (const_tree, int);
165 static int check_sibcall_argument_overlap_1 (rtx);
166 static int check_sibcall_argument_overlap (rtx_insn *, struct arg_data *, int);
167
168 static int combine_pending_stack_adjustment_and_call (int, struct args_size *,
169 unsigned int);
170 static tree split_complex_types (tree);
171
172 #ifdef REG_PARM_STACK_SPACE
173 static rtx save_fixed_argument_area (int, rtx, int *, int *);
174 static void restore_fixed_argument_area (rtx, rtx, int, int);
175 #endif
176
177 /* Force FUNEXP into a form suitable for the address of a CALL,
178 and return that as an rtx. Also load the static chain register
179 if FNDECL is a nested function.
180
181 CALL_FUSAGE points to a variable holding the prospective
182 CALL_INSN_FUNCTION_USAGE information. */
183
184 rtx
prepare_call_address(tree fndecl_or_type,rtx funexp,rtx static_chain_value,rtx * call_fusage,int reg_parm_seen,int sibcallp)185 prepare_call_address (tree fndecl_or_type, rtx funexp, rtx static_chain_value,
186 rtx *call_fusage, int reg_parm_seen, int sibcallp)
187 {
188 /* Make a valid memory address and copy constants through pseudo-regs,
189 but not for a constant address if -fno-function-cse. */
190 if (GET_CODE (funexp) != SYMBOL_REF)
191 /* If we are using registers for parameters, force the
192 function address into a register now. */
193 funexp = ((reg_parm_seen
194 && targetm.small_register_classes_for_mode_p (FUNCTION_MODE))
195 ? force_not_mem (memory_address (FUNCTION_MODE, funexp))
196 : memory_address (FUNCTION_MODE, funexp));
197 else if (! sibcallp)
198 {
199 if (!NO_FUNCTION_CSE && optimize && ! flag_no_function_cse)
200 funexp = force_reg (Pmode, funexp);
201 }
202
203 if (static_chain_value != 0
204 && (TREE_CODE (fndecl_or_type) != FUNCTION_DECL
205 || DECL_STATIC_CHAIN (fndecl_or_type)))
206 {
207 rtx chain;
208
209 chain = targetm.calls.static_chain (fndecl_or_type, false);
210 static_chain_value = convert_memory_address (Pmode, static_chain_value);
211
212 emit_move_insn (chain, static_chain_value);
213 if (REG_P (chain))
214 use_reg (call_fusage, chain);
215 }
216
217 return funexp;
218 }
219
220 /* Generate instructions to call function FUNEXP,
221 and optionally pop the results.
222 The CALL_INSN is the first insn generated.
223
224 FNDECL is the declaration node of the function. This is given to the
225 hook TARGET_RETURN_POPS_ARGS to determine whether this function pops
226 its own args.
227
228 FUNTYPE is the data type of the function. This is given to the hook
229 TARGET_RETURN_POPS_ARGS to determine whether this function pops its
230 own args. We used to allow an identifier for library functions, but
231 that doesn't work when the return type is an aggregate type and the
232 calling convention says that the pointer to this aggregate is to be
233 popped by the callee.
234
235 STACK_SIZE is the number of bytes of arguments on the stack,
236 ROUNDED_STACK_SIZE is that number rounded up to
237 PREFERRED_STACK_BOUNDARY; zero if the size is variable. This is
238 both to put into the call insn and to generate explicit popping
239 code if necessary.
240
241 STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
242 It is zero if this call doesn't want a structure value.
243
244 NEXT_ARG_REG is the rtx that results from executing
245 targetm.calls.function_arg (&args_so_far, VOIDmode, void_type_node, true)
246 just after all the args have had their registers assigned.
247 This could be whatever you like, but normally it is the first
248 arg-register beyond those used for args in this call,
249 or 0 if all the arg-registers are used in this call.
250 It is passed on to `gen_call' so you can put this info in the call insn.
251
252 VALREG is a hard register in which a value is returned,
253 or 0 if the call does not return a value.
254
255 OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before
256 the args to this call were processed.
257 We restore `inhibit_defer_pop' to that value.
258
259 CALL_FUSAGE is either empty or an EXPR_LIST of USE expressions that
260 denote registers used by the called function. */
261
262 static void
emit_call_1(rtx funexp,tree fntree ATTRIBUTE_UNUSED,tree fndecl ATTRIBUTE_UNUSED,tree funtype ATTRIBUTE_UNUSED,HOST_WIDE_INT stack_size ATTRIBUTE_UNUSED,HOST_WIDE_INT rounded_stack_size,HOST_WIDE_INT struct_value_size ATTRIBUTE_UNUSED,rtx next_arg_reg ATTRIBUTE_UNUSED,rtx valreg,int old_inhibit_defer_pop,rtx call_fusage,int ecf_flags,cumulative_args_t args_so_far ATTRIBUTE_UNUSED)263 emit_call_1 (rtx funexp, tree fntree ATTRIBUTE_UNUSED, tree fndecl ATTRIBUTE_UNUSED,
264 tree funtype ATTRIBUTE_UNUSED,
265 HOST_WIDE_INT stack_size ATTRIBUTE_UNUSED,
266 HOST_WIDE_INT rounded_stack_size,
267 HOST_WIDE_INT struct_value_size ATTRIBUTE_UNUSED,
268 rtx next_arg_reg ATTRIBUTE_UNUSED, rtx valreg,
269 int old_inhibit_defer_pop, rtx call_fusage, int ecf_flags,
270 cumulative_args_t args_so_far ATTRIBUTE_UNUSED)
271 {
272 rtx rounded_stack_size_rtx = GEN_INT (rounded_stack_size);
273 rtx call, funmem, pat;
274 int already_popped = 0;
275 HOST_WIDE_INT n_popped = 0;
276
277 /* Sibling call patterns never pop arguments (no sibcall(_value)_pop
278 patterns exist). Any popping that the callee does on return will
279 be from our caller's frame rather than ours. */
280 if (!(ecf_flags & ECF_SIBCALL))
281 {
282 n_popped += targetm.calls.return_pops_args (fndecl, funtype, stack_size);
283
284 #ifdef CALL_POPS_ARGS
285 n_popped += CALL_POPS_ARGS (*get_cumulative_args (args_so_far));
286 #endif
287 }
288
289 /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
290 and we don't want to load it into a register as an optimization,
291 because prepare_call_address already did it if it should be done. */
292 if (GET_CODE (funexp) != SYMBOL_REF)
293 funexp = memory_address (FUNCTION_MODE, funexp);
294
295 funmem = gen_rtx_MEM (FUNCTION_MODE, funexp);
296 if (fndecl && TREE_CODE (fndecl) == FUNCTION_DECL)
297 {
298 tree t = fndecl;
299
300 /* Although a built-in FUNCTION_DECL and its non-__builtin
301 counterpart compare equal and get a shared mem_attrs, they
302 produce different dump output in compare-debug compilations,
303 if an entry gets garbage collected in one compilation, then
304 adds a different (but equivalent) entry, while the other
305 doesn't run the garbage collector at the same spot and then
306 shares the mem_attr with the equivalent entry. */
307 if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL)
308 {
309 tree t2 = builtin_decl_explicit (DECL_FUNCTION_CODE (t));
310 if (t2)
311 t = t2;
312 }
313
314 set_mem_expr (funmem, t);
315 }
316 else if (fntree)
317 set_mem_expr (funmem, build_simple_mem_ref (CALL_EXPR_FN (fntree)));
318
319 if (ecf_flags & ECF_SIBCALL)
320 {
321 if (valreg)
322 pat = targetm.gen_sibcall_value (valreg, funmem,
323 rounded_stack_size_rtx,
324 next_arg_reg, NULL_RTX);
325 else
326 pat = targetm.gen_sibcall (funmem, rounded_stack_size_rtx,
327 next_arg_reg, GEN_INT (struct_value_size));
328 }
329 /* If the target has "call" or "call_value" insns, then prefer them
330 if no arguments are actually popped. If the target does not have
331 "call" or "call_value" insns, then we must use the popping versions
332 even if the call has no arguments to pop. */
333 else if (n_popped > 0
334 || !(valreg
335 ? targetm.have_call_value ()
336 : targetm.have_call ()))
337 {
338 rtx n_pop = GEN_INT (n_popped);
339
340 /* If this subroutine pops its own args, record that in the call insn
341 if possible, for the sake of frame pointer elimination. */
342
343 if (valreg)
344 pat = targetm.gen_call_value_pop (valreg, funmem,
345 rounded_stack_size_rtx,
346 next_arg_reg, n_pop);
347 else
348 pat = targetm.gen_call_pop (funmem, rounded_stack_size_rtx,
349 next_arg_reg, n_pop);
350
351 already_popped = 1;
352 }
353 else
354 {
355 if (valreg)
356 pat = targetm.gen_call_value (valreg, funmem, rounded_stack_size_rtx,
357 next_arg_reg, NULL_RTX);
358 else
359 pat = targetm.gen_call (funmem, rounded_stack_size_rtx, next_arg_reg,
360 GEN_INT (struct_value_size));
361 }
362 emit_insn (pat);
363
364 /* Find the call we just emitted. */
365 rtx_call_insn *call_insn = last_call_insn ();
366
367 /* Some target create a fresh MEM instead of reusing the one provided
368 above. Set its MEM_EXPR. */
369 call = get_call_rtx_from (call_insn);
370 if (call
371 && MEM_EXPR (XEXP (call, 0)) == NULL_TREE
372 && MEM_EXPR (funmem) != NULL_TREE)
373 set_mem_expr (XEXP (call, 0), MEM_EXPR (funmem));
374
375 /* Mark instrumented calls. */
376 if (call && fntree)
377 CALL_EXPR_WITH_BOUNDS_P (call) = CALL_WITH_BOUNDS_P (fntree);
378
379 /* Put the register usage information there. */
380 add_function_usage_to (call_insn, call_fusage);
381
382 /* If this is a const call, then set the insn's unchanging bit. */
383 if (ecf_flags & ECF_CONST)
384 RTL_CONST_CALL_P (call_insn) = 1;
385
386 /* If this is a pure call, then set the insn's unchanging bit. */
387 if (ecf_flags & ECF_PURE)
388 RTL_PURE_CALL_P (call_insn) = 1;
389
390 /* If this is a const call, then set the insn's unchanging bit. */
391 if (ecf_flags & ECF_LOOPING_CONST_OR_PURE)
392 RTL_LOOPING_CONST_OR_PURE_CALL_P (call_insn) = 1;
393
394 /* Create a nothrow REG_EH_REGION note, if needed. */
395 make_reg_eh_region_note (call_insn, ecf_flags, 0);
396
397 if (ecf_flags & ECF_NORETURN)
398 add_reg_note (call_insn, REG_NORETURN, const0_rtx);
399
400 if (ecf_flags & ECF_RETURNS_TWICE)
401 {
402 add_reg_note (call_insn, REG_SETJMP, const0_rtx);
403 cfun->calls_setjmp = 1;
404 }
405
406 SIBLING_CALL_P (call_insn) = ((ecf_flags & ECF_SIBCALL) != 0);
407
408 /* Restore this now, so that we do defer pops for this call's args
409 if the context of the call as a whole permits. */
410 inhibit_defer_pop = old_inhibit_defer_pop;
411
412 if (n_popped > 0)
413 {
414 if (!already_popped)
415 CALL_INSN_FUNCTION_USAGE (call_insn)
416 = gen_rtx_EXPR_LIST (VOIDmode,
417 gen_rtx_CLOBBER (VOIDmode, stack_pointer_rtx),
418 CALL_INSN_FUNCTION_USAGE (call_insn));
419 rounded_stack_size -= n_popped;
420 rounded_stack_size_rtx = GEN_INT (rounded_stack_size);
421 stack_pointer_delta -= n_popped;
422
423 add_reg_note (call_insn, REG_ARGS_SIZE, GEN_INT (stack_pointer_delta));
424
425 /* If popup is needed, stack realign must use DRAP */
426 if (SUPPORTS_STACK_ALIGNMENT)
427 crtl->need_drap = true;
428 }
429 /* For noreturn calls when not accumulating outgoing args force
430 REG_ARGS_SIZE note to prevent crossjumping of calls with different
431 args sizes. */
432 else if (!ACCUMULATE_OUTGOING_ARGS && (ecf_flags & ECF_NORETURN) != 0)
433 add_reg_note (call_insn, REG_ARGS_SIZE, GEN_INT (stack_pointer_delta));
434
435 if (!ACCUMULATE_OUTGOING_ARGS)
436 {
437 /* If returning from the subroutine does not automatically pop the args,
438 we need an instruction to pop them sooner or later.
439 Perhaps do it now; perhaps just record how much space to pop later.
440
441 If returning from the subroutine does pop the args, indicate that the
442 stack pointer will be changed. */
443
444 if (rounded_stack_size != 0)
445 {
446 if (ecf_flags & ECF_NORETURN)
447 /* Just pretend we did the pop. */
448 stack_pointer_delta -= rounded_stack_size;
449 else if (flag_defer_pop && inhibit_defer_pop == 0
450 && ! (ecf_flags & (ECF_CONST | ECF_PURE)))
451 pending_stack_adjust += rounded_stack_size;
452 else
453 adjust_stack (rounded_stack_size_rtx);
454 }
455 }
456 /* When we accumulate outgoing args, we must avoid any stack manipulations.
457 Restore the stack pointer to its original value now. Usually
458 ACCUMULATE_OUTGOING_ARGS targets don't get here, but there are exceptions.
459 On i386 ACCUMULATE_OUTGOING_ARGS can be enabled on demand, and
460 popping variants of functions exist as well.
461
462 ??? We may optimize similar to defer_pop above, but it is
463 probably not worthwhile.
464
465 ??? It will be worthwhile to enable combine_stack_adjustments even for
466 such machines. */
467 else if (n_popped)
468 anti_adjust_stack (GEN_INT (n_popped));
469 }
470
471 /* Determine if the function identified by NAME and FNDECL is one with
472 special properties we wish to know about.
473
474 For example, if the function might return more than one time (setjmp), then
475 set RETURNS_TWICE to a nonzero value.
476
477 Similarly set NORETURN if the function is in the longjmp family.
478
479 Set MAY_BE_ALLOCA for any memory allocation function that might allocate
480 space from the stack such as alloca. */
481
482 static int
special_function_p(const_tree fndecl,int flags)483 special_function_p (const_tree fndecl, int flags)
484 {
485 tree name_decl = DECL_NAME (fndecl);
486
487 /* For instrumentation clones we want to derive flags
488 from the original name. */
489 if (cgraph_node::get (fndecl)
490 && cgraph_node::get (fndecl)->instrumentation_clone)
491 name_decl = DECL_NAME (cgraph_node::get (fndecl)->orig_decl);
492
493 if (fndecl && name_decl
494 && IDENTIFIER_LENGTH (name_decl) <= 17
495 /* Exclude functions not at the file scope, or not `extern',
496 since they are not the magic functions we would otherwise
497 think they are.
498 FIXME: this should be handled with attributes, not with this
499 hacky imitation of DECL_ASSEMBLER_NAME. It's (also) wrong
500 because you can declare fork() inside a function if you
501 wish. */
502 && (DECL_CONTEXT (fndecl) == NULL_TREE
503 || TREE_CODE (DECL_CONTEXT (fndecl)) == TRANSLATION_UNIT_DECL)
504 && TREE_PUBLIC (fndecl))
505 {
506 const char *name = IDENTIFIER_POINTER (name_decl);
507 const char *tname = name;
508
509 /* We assume that alloca will always be called by name. It
510 makes no sense to pass it as a pointer-to-function to
511 anything that does not understand its behavior. */
512 if (IDENTIFIER_LENGTH (name_decl) == 6
513 && name[0] == 'a'
514 && ! strcmp (name, "alloca"))
515 flags |= ECF_MAY_BE_ALLOCA;
516
517 /* Disregard prefix _, __, __x or __builtin_. */
518 if (name[0] == '_')
519 {
520 if (name[1] == '_'
521 && name[2] == 'b'
522 && !strncmp (name + 3, "uiltin_", 7))
523 tname += 10;
524 else if (name[1] == '_' && name[2] == 'x')
525 tname += 3;
526 else if (name[1] == '_')
527 tname += 2;
528 else
529 tname += 1;
530 }
531
532 if (tname[0] == 's')
533 {
534 if ((tname[1] == 'e'
535 && (! strcmp (tname, "setjmp")
536 || ! strcmp (tname, "setjmp_syscall")))
537 || (tname[1] == 'i'
538 && ! strcmp (tname, "sigsetjmp"))
539 || (tname[1] == 'a'
540 && ! strcmp (tname, "savectx")))
541 flags |= ECF_RETURNS_TWICE | ECF_LEAF;
542
543 if (tname[1] == 'i'
544 && ! strcmp (tname, "siglongjmp"))
545 flags |= ECF_NORETURN;
546 }
547 else if ((tname[0] == 'q' && tname[1] == 's'
548 && ! strcmp (tname, "qsetjmp"))
549 || (tname[0] == 'v' && tname[1] == 'f'
550 && ! strcmp (tname, "vfork"))
551 || (tname[0] == 'g' && tname[1] == 'e'
552 && !strcmp (tname, "getcontext")))
553 flags |= ECF_RETURNS_TWICE | ECF_LEAF;
554
555 else if (tname[0] == 'l' && tname[1] == 'o'
556 && ! strcmp (tname, "longjmp"))
557 flags |= ECF_NORETURN;
558 }
559
560 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
561 switch (DECL_FUNCTION_CODE (fndecl))
562 {
563 case BUILT_IN_ALLOCA:
564 case BUILT_IN_ALLOCA_WITH_ALIGN:
565 flags |= ECF_MAY_BE_ALLOCA;
566 break;
567 default:
568 break;
569 }
570
571 return flags;
572 }
573
574 /* Similar to special_function_p; return a set of ERF_ flags for the
575 function FNDECL. */
576 static int
decl_return_flags(tree fndecl)577 decl_return_flags (tree fndecl)
578 {
579 tree attr;
580 tree type = TREE_TYPE (fndecl);
581 if (!type)
582 return 0;
583
584 attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
585 if (!attr)
586 return 0;
587
588 attr = TREE_VALUE (TREE_VALUE (attr));
589 if (!attr || TREE_STRING_LENGTH (attr) < 1)
590 return 0;
591
592 switch (TREE_STRING_POINTER (attr)[0])
593 {
594 case '1':
595 case '2':
596 case '3':
597 case '4':
598 return ERF_RETURNS_ARG | (TREE_STRING_POINTER (attr)[0] - '1');
599
600 case 'm':
601 return ERF_NOALIAS;
602
603 case '.':
604 default:
605 return 0;
606 }
607 }
608
609 /* Return nonzero when FNDECL represents a call to setjmp. */
610
611 int
setjmp_call_p(const_tree fndecl)612 setjmp_call_p (const_tree fndecl)
613 {
614 if (DECL_IS_RETURNS_TWICE (fndecl))
615 return ECF_RETURNS_TWICE;
616 return special_function_p (fndecl, 0) & ECF_RETURNS_TWICE;
617 }
618
619
620 /* Return true if STMT is an alloca call. */
621
622 bool
gimple_alloca_call_p(const gimple * stmt)623 gimple_alloca_call_p (const gimple *stmt)
624 {
625 tree fndecl;
626
627 if (!is_gimple_call (stmt))
628 return false;
629
630 fndecl = gimple_call_fndecl (stmt);
631 if (fndecl && (special_function_p (fndecl, 0) & ECF_MAY_BE_ALLOCA))
632 return true;
633
634 return false;
635 }
636
637 /* Return true when exp contains alloca call. */
638
639 bool
alloca_call_p(const_tree exp)640 alloca_call_p (const_tree exp)
641 {
642 tree fndecl;
643 if (TREE_CODE (exp) == CALL_EXPR
644 && (fndecl = get_callee_fndecl (exp))
645 && (special_function_p (fndecl, 0) & ECF_MAY_BE_ALLOCA))
646 return true;
647 return false;
648 }
649
650 /* Return TRUE if FNDECL is either a TM builtin or a TM cloned
651 function. Return FALSE otherwise. */
652
653 static bool
is_tm_builtin(const_tree fndecl)654 is_tm_builtin (const_tree fndecl)
655 {
656 if (fndecl == NULL)
657 return false;
658
659 if (decl_is_tm_clone (fndecl))
660 return true;
661
662 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
663 {
664 switch (DECL_FUNCTION_CODE (fndecl))
665 {
666 case BUILT_IN_TM_COMMIT:
667 case BUILT_IN_TM_COMMIT_EH:
668 case BUILT_IN_TM_ABORT:
669 case BUILT_IN_TM_IRREVOCABLE:
670 case BUILT_IN_TM_GETTMCLONE_IRR:
671 case BUILT_IN_TM_MEMCPY:
672 case BUILT_IN_TM_MEMMOVE:
673 case BUILT_IN_TM_MEMSET:
674 CASE_BUILT_IN_TM_STORE (1):
675 CASE_BUILT_IN_TM_STORE (2):
676 CASE_BUILT_IN_TM_STORE (4):
677 CASE_BUILT_IN_TM_STORE (8):
678 CASE_BUILT_IN_TM_STORE (FLOAT):
679 CASE_BUILT_IN_TM_STORE (DOUBLE):
680 CASE_BUILT_IN_TM_STORE (LDOUBLE):
681 CASE_BUILT_IN_TM_STORE (M64):
682 CASE_BUILT_IN_TM_STORE (M128):
683 CASE_BUILT_IN_TM_STORE (M256):
684 CASE_BUILT_IN_TM_LOAD (1):
685 CASE_BUILT_IN_TM_LOAD (2):
686 CASE_BUILT_IN_TM_LOAD (4):
687 CASE_BUILT_IN_TM_LOAD (8):
688 CASE_BUILT_IN_TM_LOAD (FLOAT):
689 CASE_BUILT_IN_TM_LOAD (DOUBLE):
690 CASE_BUILT_IN_TM_LOAD (LDOUBLE):
691 CASE_BUILT_IN_TM_LOAD (M64):
692 CASE_BUILT_IN_TM_LOAD (M128):
693 CASE_BUILT_IN_TM_LOAD (M256):
694 case BUILT_IN_TM_LOG:
695 case BUILT_IN_TM_LOG_1:
696 case BUILT_IN_TM_LOG_2:
697 case BUILT_IN_TM_LOG_4:
698 case BUILT_IN_TM_LOG_8:
699 case BUILT_IN_TM_LOG_FLOAT:
700 case BUILT_IN_TM_LOG_DOUBLE:
701 case BUILT_IN_TM_LOG_LDOUBLE:
702 case BUILT_IN_TM_LOG_M64:
703 case BUILT_IN_TM_LOG_M128:
704 case BUILT_IN_TM_LOG_M256:
705 return true;
706 default:
707 break;
708 }
709 }
710 return false;
711 }
712
713 /* Detect flags (function attributes) from the function decl or type node. */
714
715 int
flags_from_decl_or_type(const_tree exp)716 flags_from_decl_or_type (const_tree exp)
717 {
718 int flags = 0;
719
720 if (DECL_P (exp))
721 {
722 /* The function exp may have the `malloc' attribute. */
723 if (DECL_IS_MALLOC (exp))
724 flags |= ECF_MALLOC;
725
726 /* The function exp may have the `returns_twice' attribute. */
727 if (DECL_IS_RETURNS_TWICE (exp))
728 flags |= ECF_RETURNS_TWICE;
729
730 /* Process the pure and const attributes. */
731 if (TREE_READONLY (exp))
732 flags |= ECF_CONST;
733 if (DECL_PURE_P (exp))
734 flags |= ECF_PURE;
735 if (DECL_LOOPING_CONST_OR_PURE_P (exp))
736 flags |= ECF_LOOPING_CONST_OR_PURE;
737
738 if (DECL_IS_NOVOPS (exp))
739 flags |= ECF_NOVOPS;
740 if (lookup_attribute ("leaf", DECL_ATTRIBUTES (exp)))
741 flags |= ECF_LEAF;
742
743 if (TREE_NOTHROW (exp))
744 flags |= ECF_NOTHROW;
745
746 if (flag_tm)
747 {
748 if (is_tm_builtin (exp))
749 flags |= ECF_TM_BUILTIN;
750 else if ((flags & (ECF_CONST|ECF_NOVOPS)) != 0
751 || lookup_attribute ("transaction_pure",
752 TYPE_ATTRIBUTES (TREE_TYPE (exp))))
753 flags |= ECF_TM_PURE;
754 }
755
756 flags = special_function_p (exp, flags);
757 }
758 else if (TYPE_P (exp))
759 {
760 if (TYPE_READONLY (exp))
761 flags |= ECF_CONST;
762
763 if (flag_tm
764 && ((flags & ECF_CONST) != 0
765 || lookup_attribute ("transaction_pure", TYPE_ATTRIBUTES (exp))))
766 flags |= ECF_TM_PURE;
767 }
768 else
769 gcc_unreachable ();
770
771 if (TREE_THIS_VOLATILE (exp))
772 {
773 flags |= ECF_NORETURN;
774 if (flags & (ECF_CONST|ECF_PURE))
775 flags |= ECF_LOOPING_CONST_OR_PURE;
776 }
777
778 return flags;
779 }
780
781 /* Detect flags from a CALL_EXPR. */
782
783 int
call_expr_flags(const_tree t)784 call_expr_flags (const_tree t)
785 {
786 int flags;
787 tree decl = get_callee_fndecl (t);
788
789 if (decl)
790 flags = flags_from_decl_or_type (decl);
791 else if (CALL_EXPR_FN (t) == NULL_TREE)
792 flags = internal_fn_flags (CALL_EXPR_IFN (t));
793 else
794 {
795 t = TREE_TYPE (CALL_EXPR_FN (t));
796 if (t && TREE_CODE (t) == POINTER_TYPE)
797 flags = flags_from_decl_or_type (TREE_TYPE (t));
798 else
799 flags = 0;
800 }
801
802 return flags;
803 }
804
805 /* Return true if TYPE should be passed by invisible reference. */
806
807 bool
pass_by_reference(CUMULATIVE_ARGS * ca,machine_mode mode,tree type,bool named_arg)808 pass_by_reference (CUMULATIVE_ARGS *ca, machine_mode mode,
809 tree type, bool named_arg)
810 {
811 if (type)
812 {
813 /* If this type contains non-trivial constructors, then it is
814 forbidden for the middle-end to create any new copies. */
815 if (TREE_ADDRESSABLE (type))
816 return true;
817
818 /* GCC post 3.4 passes *all* variable sized types by reference. */
819 if (!TYPE_SIZE (type) || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
820 return true;
821
822 /* If a record type should be passed the same as its first (and only)
823 member, use the type and mode of that member. */
824 if (TREE_CODE (type) == RECORD_TYPE && TYPE_TRANSPARENT_AGGR (type))
825 {
826 type = TREE_TYPE (first_field (type));
827 mode = TYPE_MODE (type);
828 }
829 }
830
831 return targetm.calls.pass_by_reference (pack_cumulative_args (ca), mode,
832 type, named_arg);
833 }
834
835 /* Return true if TYPE, which is passed by reference, should be callee
836 copied instead of caller copied. */
837
838 bool
reference_callee_copied(CUMULATIVE_ARGS * ca,machine_mode mode,tree type,bool named_arg)839 reference_callee_copied (CUMULATIVE_ARGS *ca, machine_mode mode,
840 tree type, bool named_arg)
841 {
842 if (type && TREE_ADDRESSABLE (type))
843 return false;
844 return targetm.calls.callee_copies (pack_cumulative_args (ca), mode, type,
845 named_arg);
846 }
847
848
849 /* Precompute all register parameters as described by ARGS, storing values
850 into fields within the ARGS array.
851
852 NUM_ACTUALS indicates the total number elements in the ARGS array.
853
854 Set REG_PARM_SEEN if we encounter a register parameter. */
855
856 static void
precompute_register_parameters(int num_actuals,struct arg_data * args,int * reg_parm_seen)857 precompute_register_parameters (int num_actuals, struct arg_data *args,
858 int *reg_parm_seen)
859 {
860 int i;
861
862 *reg_parm_seen = 0;
863
864 for (i = 0; i < num_actuals; i++)
865 if (args[i].reg != 0 && ! args[i].pass_on_stack)
866 {
867 *reg_parm_seen = 1;
868
869 if (args[i].value == 0)
870 {
871 push_temp_slots ();
872 args[i].value = expand_normal (args[i].tree_value);
873 preserve_temp_slots (args[i].value);
874 pop_temp_slots ();
875 }
876
877 /* If we are to promote the function arg to a wider mode,
878 do it now. */
879
880 if (args[i].mode != TYPE_MODE (TREE_TYPE (args[i].tree_value)))
881 args[i].value
882 = convert_modes (args[i].mode,
883 TYPE_MODE (TREE_TYPE (args[i].tree_value)),
884 args[i].value, args[i].unsignedp);
885
886 /* If the value is a non-legitimate constant, force it into a
887 pseudo now. TLS symbols sometimes need a call to resolve. */
888 if (CONSTANT_P (args[i].value)
889 && !targetm.legitimate_constant_p (args[i].mode, args[i].value))
890 args[i].value = force_reg (args[i].mode, args[i].value);
891
892 /* If we're going to have to load the value by parts, pull the
893 parts into pseudos. The part extraction process can involve
894 non-trivial computation. */
895 if (GET_CODE (args[i].reg) == PARALLEL)
896 {
897 tree type = TREE_TYPE (args[i].tree_value);
898 args[i].parallel_value
899 = emit_group_load_into_temps (args[i].reg, args[i].value,
900 type, int_size_in_bytes (type));
901 }
902
903 /* If the value is expensive, and we are inside an appropriately
904 short loop, put the value into a pseudo and then put the pseudo
905 into the hard reg.
906
907 For small register classes, also do this if this call uses
908 register parameters. This is to avoid reload conflicts while
909 loading the parameters registers. */
910
911 else if ((! (REG_P (args[i].value)
912 || (GET_CODE (args[i].value) == SUBREG
913 && REG_P (SUBREG_REG (args[i].value)))))
914 && args[i].mode != BLKmode
915 && (set_src_cost (args[i].value, args[i].mode,
916 optimize_insn_for_speed_p ())
917 > COSTS_N_INSNS (1))
918 && ((*reg_parm_seen
919 && targetm.small_register_classes_for_mode_p (args[i].mode))
920 || optimize))
921 args[i].value = copy_to_mode_reg (args[i].mode, args[i].value);
922 }
923 }
924
925 #ifdef REG_PARM_STACK_SPACE
926
927 /* The argument list is the property of the called routine and it
928 may clobber it. If the fixed area has been used for previous
929 parameters, we must save and restore it. */
930
931 static rtx
save_fixed_argument_area(int reg_parm_stack_space,rtx argblock,int * low_to_save,int * high_to_save)932 save_fixed_argument_area (int reg_parm_stack_space, rtx argblock, int *low_to_save, int *high_to_save)
933 {
934 int low;
935 int high;
936
937 /* Compute the boundary of the area that needs to be saved, if any. */
938 high = reg_parm_stack_space;
939 if (ARGS_GROW_DOWNWARD)
940 high += 1;
941
942 if (high > highest_outgoing_arg_in_use)
943 high = highest_outgoing_arg_in_use;
944
945 for (low = 0; low < high; low++)
946 if (stack_usage_map[low] != 0)
947 {
948 int num_to_save;
949 machine_mode save_mode;
950 int delta;
951 rtx addr;
952 rtx stack_area;
953 rtx save_area;
954
955 while (stack_usage_map[--high] == 0)
956 ;
957
958 *low_to_save = low;
959 *high_to_save = high;
960
961 num_to_save = high - low + 1;
962 save_mode = mode_for_size (num_to_save * BITS_PER_UNIT, MODE_INT, 1);
963
964 /* If we don't have the required alignment, must do this
965 in BLKmode. */
966 if ((low & (MIN (GET_MODE_SIZE (save_mode),
967 BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1)))
968 save_mode = BLKmode;
969
970 if (ARGS_GROW_DOWNWARD)
971 delta = -high;
972 else
973 delta = low;
974
975 addr = plus_constant (Pmode, argblock, delta);
976 stack_area = gen_rtx_MEM (save_mode, memory_address (save_mode, addr));
977
978 set_mem_align (stack_area, PARM_BOUNDARY);
979 if (save_mode == BLKmode)
980 {
981 save_area = assign_stack_temp (BLKmode, num_to_save);
982 emit_block_move (validize_mem (save_area), stack_area,
983 GEN_INT (num_to_save), BLOCK_OP_CALL_PARM);
984 }
985 else
986 {
987 save_area = gen_reg_rtx (save_mode);
988 emit_move_insn (save_area, stack_area);
989 }
990
991 return save_area;
992 }
993
994 return NULL_RTX;
995 }
996
997 static void
restore_fixed_argument_area(rtx save_area,rtx argblock,int high_to_save,int low_to_save)998 restore_fixed_argument_area (rtx save_area, rtx argblock, int high_to_save, int low_to_save)
999 {
1000 machine_mode save_mode = GET_MODE (save_area);
1001 int delta;
1002 rtx addr, stack_area;
1003
1004 if (ARGS_GROW_DOWNWARD)
1005 delta = -high_to_save;
1006 else
1007 delta = low_to_save;
1008
1009 addr = plus_constant (Pmode, argblock, delta);
1010 stack_area = gen_rtx_MEM (save_mode, memory_address (save_mode, addr));
1011 set_mem_align (stack_area, PARM_BOUNDARY);
1012
1013 if (save_mode != BLKmode)
1014 emit_move_insn (stack_area, save_area);
1015 else
1016 emit_block_move (stack_area, validize_mem (save_area),
1017 GEN_INT (high_to_save - low_to_save + 1),
1018 BLOCK_OP_CALL_PARM);
1019 }
1020 #endif /* REG_PARM_STACK_SPACE */
1021
1022 /* If any elements in ARGS refer to parameters that are to be passed in
1023 registers, but not in memory, and whose alignment does not permit a
1024 direct copy into registers. Copy the values into a group of pseudos
1025 which we will later copy into the appropriate hard registers.
1026
1027 Pseudos for each unaligned argument will be stored into the array
1028 args[argnum].aligned_regs. The caller is responsible for deallocating
1029 the aligned_regs array if it is nonzero. */
1030
1031 static void
store_unaligned_arguments_into_pseudos(struct arg_data * args,int num_actuals)1032 store_unaligned_arguments_into_pseudos (struct arg_data *args, int num_actuals)
1033 {
1034 int i, j;
1035
1036 for (i = 0; i < num_actuals; i++)
1037 if (args[i].reg != 0 && ! args[i].pass_on_stack
1038 && GET_CODE (args[i].reg) != PARALLEL
1039 && args[i].mode == BLKmode
1040 && MEM_P (args[i].value)
1041 && (MEM_ALIGN (args[i].value)
1042 < (unsigned int) MIN (BIGGEST_ALIGNMENT, BITS_PER_WORD)))
1043 {
1044 int bytes = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
1045 int endian_correction = 0;
1046
1047 if (args[i].partial)
1048 {
1049 gcc_assert (args[i].partial % UNITS_PER_WORD == 0);
1050 args[i].n_aligned_regs = args[i].partial / UNITS_PER_WORD;
1051 }
1052 else
1053 {
1054 args[i].n_aligned_regs
1055 = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
1056 }
1057
1058 args[i].aligned_regs = XNEWVEC (rtx, args[i].n_aligned_regs);
1059
1060 /* Structures smaller than a word are normally aligned to the
1061 least significant byte. On a BYTES_BIG_ENDIAN machine,
1062 this means we must skip the empty high order bytes when
1063 calculating the bit offset. */
1064 if (bytes < UNITS_PER_WORD
1065 #ifdef BLOCK_REG_PADDING
1066 && (BLOCK_REG_PADDING (args[i].mode,
1067 TREE_TYPE (args[i].tree_value), 1)
1068 == downward)
1069 #else
1070 && BYTES_BIG_ENDIAN
1071 #endif
1072 )
1073 endian_correction = BITS_PER_WORD - bytes * BITS_PER_UNIT;
1074
1075 for (j = 0; j < args[i].n_aligned_regs; j++)
1076 {
1077 rtx reg = gen_reg_rtx (word_mode);
1078 rtx word = operand_subword_force (args[i].value, j, BLKmode);
1079 int bitsize = MIN (bytes * BITS_PER_UNIT, BITS_PER_WORD);
1080
1081 args[i].aligned_regs[j] = reg;
1082 word = extract_bit_field (word, bitsize, 0, 1, NULL_RTX,
1083 word_mode, word_mode, false);
1084
1085 /* There is no need to restrict this code to loading items
1086 in TYPE_ALIGN sized hunks. The bitfield instructions can
1087 load up entire word sized registers efficiently.
1088
1089 ??? This may not be needed anymore.
1090 We use to emit a clobber here but that doesn't let later
1091 passes optimize the instructions we emit. By storing 0 into
1092 the register later passes know the first AND to zero out the
1093 bitfield being set in the register is unnecessary. The store
1094 of 0 will be deleted as will at least the first AND. */
1095
1096 emit_move_insn (reg, const0_rtx);
1097
1098 bytes -= bitsize / BITS_PER_UNIT;
1099 store_bit_field (reg, bitsize, endian_correction, 0, 0,
1100 word_mode, word, false);
1101 }
1102 }
1103 }
1104
1105 /* Fill in ARGS_SIZE and ARGS array based on the parameters found in
1106 CALL_EXPR EXP.
1107
1108 NUM_ACTUALS is the total number of parameters.
1109
1110 N_NAMED_ARGS is the total number of named arguments.
1111
1112 STRUCT_VALUE_ADDR_VALUE is the implicit argument for a struct return
1113 value, or null.
1114
1115 FNDECL is the tree code for the target of this call (if known)
1116
1117 ARGS_SO_FAR holds state needed by the target to know where to place
1118 the next argument.
1119
1120 REG_PARM_STACK_SPACE is the number of bytes of stack space reserved
1121 for arguments which are passed in registers.
1122
1123 OLD_STACK_LEVEL is a pointer to an rtx which olds the old stack level
1124 and may be modified by this routine.
1125
1126 OLD_PENDING_ADJ, MUST_PREALLOCATE and FLAGS are pointers to integer
1127 flags which may be modified by this routine.
1128
1129 MAY_TAILCALL is cleared if we encounter an invisible pass-by-reference
1130 that requires allocation of stack space.
1131
1132 CALL_FROM_THUNK_P is true if this call is the jump from a thunk to
1133 the thunked-to function. */
1134
1135 static void
initialize_argument_information(int num_actuals ATTRIBUTE_UNUSED,struct arg_data * args,struct args_size * args_size,int n_named_args ATTRIBUTE_UNUSED,tree exp,tree struct_value_addr_value,tree fndecl,tree fntype,cumulative_args_t args_so_far,int reg_parm_stack_space,rtx * old_stack_level,int * old_pending_adj,int * must_preallocate,int * ecf_flags,bool * may_tailcall,bool call_from_thunk_p)1136 initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
1137 struct arg_data *args,
1138 struct args_size *args_size,
1139 int n_named_args ATTRIBUTE_UNUSED,
1140 tree exp, tree struct_value_addr_value,
1141 tree fndecl, tree fntype,
1142 cumulative_args_t args_so_far,
1143 int reg_parm_stack_space,
1144 rtx *old_stack_level, int *old_pending_adj,
1145 int *must_preallocate, int *ecf_flags,
1146 bool *may_tailcall, bool call_from_thunk_p)
1147 {
1148 CUMULATIVE_ARGS *args_so_far_pnt = get_cumulative_args (args_so_far);
1149 location_t loc = EXPR_LOCATION (exp);
1150
1151 /* Count arg position in order args appear. */
1152 int argpos;
1153
1154 int i;
1155
1156 args_size->constant = 0;
1157 args_size->var = 0;
1158
1159 bitmap_obstack_initialize (NULL);
1160
1161 /* In this loop, we consider args in the order they are written.
1162 We fill up ARGS from the back. */
1163
1164 i = num_actuals - 1;
1165 {
1166 int j = i, ptr_arg = -1;
1167 call_expr_arg_iterator iter;
1168 tree arg;
1169 bitmap slots = NULL;
1170
1171 if (struct_value_addr_value)
1172 {
1173 args[j].tree_value = struct_value_addr_value;
1174 j--;
1175
1176 /* If we pass structure address then we need to
1177 create bounds for it. Since created bounds is
1178 a call statement, we expand it right here to avoid
1179 fixing all other places where it may be expanded. */
1180 if (CALL_WITH_BOUNDS_P (exp))
1181 {
1182 args[j].value = gen_reg_rtx (targetm.chkp_bound_mode ());
1183 args[j].tree_value
1184 = chkp_make_bounds_for_struct_addr (struct_value_addr_value);
1185 expand_expr_real (args[j].tree_value, args[j].value, VOIDmode,
1186 EXPAND_NORMAL, 0, false);
1187 args[j].pointer_arg = j + 1;
1188 j--;
1189 }
1190 }
1191 argpos = 0;
1192 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
1193 {
1194 tree argtype = TREE_TYPE (arg);
1195
1196 /* Remember last param with pointer and associate it
1197 with following pointer bounds. */
1198 if (CALL_WITH_BOUNDS_P (exp)
1199 && chkp_type_has_pointer (argtype))
1200 {
1201 if (slots)
1202 BITMAP_FREE (slots);
1203 ptr_arg = j;
1204 if (!BOUNDED_TYPE_P (argtype))
1205 {
1206 slots = BITMAP_ALLOC (NULL);
1207 chkp_find_bound_slots (argtype, slots);
1208 }
1209 }
1210 else if (CALL_WITH_BOUNDS_P (exp)
1211 && pass_by_reference (NULL, TYPE_MODE (argtype), argtype,
1212 argpos < n_named_args))
1213 {
1214 if (slots)
1215 BITMAP_FREE (slots);
1216 ptr_arg = j;
1217 }
1218 else if (POINTER_BOUNDS_TYPE_P (argtype))
1219 {
1220 /* We expect bounds in instrumented calls only.
1221 Otherwise it is a sign we lost flag due to some optimization
1222 and may emit call args incorrectly. */
1223 gcc_assert (CALL_WITH_BOUNDS_P (exp));
1224
1225 /* For structures look for the next available pointer. */
1226 if (ptr_arg != -1 && slots)
1227 {
1228 unsigned bnd_no = bitmap_first_set_bit (slots);
1229 args[j].pointer_offset =
1230 bnd_no * POINTER_SIZE / BITS_PER_UNIT;
1231
1232 bitmap_clear_bit (slots, bnd_no);
1233
1234 /* Check we have no more pointers in the structure. */
1235 if (bitmap_empty_p (slots))
1236 BITMAP_FREE (slots);
1237 }
1238 args[j].pointer_arg = ptr_arg;
1239
1240 /* Check we covered all pointers in the previous
1241 non bounds arg. */
1242 if (!slots)
1243 ptr_arg = -1;
1244 }
1245 else
1246 ptr_arg = -1;
1247
1248 if (targetm.calls.split_complex_arg
1249 && argtype
1250 && TREE_CODE (argtype) == COMPLEX_TYPE
1251 && targetm.calls.split_complex_arg (argtype))
1252 {
1253 tree subtype = TREE_TYPE (argtype);
1254 args[j].tree_value = build1 (REALPART_EXPR, subtype, arg);
1255 j--;
1256 args[j].tree_value = build1 (IMAGPART_EXPR, subtype, arg);
1257 }
1258 else
1259 args[j].tree_value = arg;
1260 j--;
1261 argpos++;
1262 }
1263
1264 if (slots)
1265 BITMAP_FREE (slots);
1266 }
1267
1268 bitmap_obstack_release (NULL);
1269
1270 /* I counts args in order (to be) pushed; ARGPOS counts in order written. */
1271 for (argpos = 0; argpos < num_actuals; i--, argpos++)
1272 {
1273 tree type = TREE_TYPE (args[i].tree_value);
1274 int unsignedp;
1275 machine_mode mode;
1276
1277 /* Replace erroneous argument with constant zero. */
1278 if (type == error_mark_node || !COMPLETE_TYPE_P (type))
1279 args[i].tree_value = integer_zero_node, type = integer_type_node;
1280
1281 /* If TYPE is a transparent union or record, pass things the way
1282 we would pass the first field of the union or record. We have
1283 already verified that the modes are the same. */
1284 if ((TREE_CODE (type) == UNION_TYPE || TREE_CODE (type) == RECORD_TYPE)
1285 && TYPE_TRANSPARENT_AGGR (type))
1286 type = TREE_TYPE (first_field (type));
1287
1288 /* Decide where to pass this arg.
1289
1290 args[i].reg is nonzero if all or part is passed in registers.
1291
1292 args[i].partial is nonzero if part but not all is passed in registers,
1293 and the exact value says how many bytes are passed in registers.
1294
1295 args[i].pass_on_stack is nonzero if the argument must at least be
1296 computed on the stack. It may then be loaded back into registers
1297 if args[i].reg is nonzero.
1298
1299 These decisions are driven by the FUNCTION_... macros and must agree
1300 with those made by function.c. */
1301
1302 /* See if this argument should be passed by invisible reference. */
1303 if (pass_by_reference (args_so_far_pnt, TYPE_MODE (type),
1304 type, argpos < n_named_args))
1305 {
1306 bool callee_copies;
1307 tree base = NULL_TREE;
1308
1309 callee_copies
1310 = reference_callee_copied (args_so_far_pnt, TYPE_MODE (type),
1311 type, argpos < n_named_args);
1312
1313 /* If we're compiling a thunk, pass through invisible references
1314 instead of making a copy. */
1315 if (call_from_thunk_p
1316 || (callee_copies
1317 && !TREE_ADDRESSABLE (type)
1318 && (base = get_base_address (args[i].tree_value))
1319 && TREE_CODE (base) != SSA_NAME
1320 && (!DECL_P (base) || MEM_P (DECL_RTL (base)))))
1321 {
1322 /* We may have turned the parameter value into an SSA name.
1323 Go back to the original parameter so we can take the
1324 address. */
1325 if (TREE_CODE (args[i].tree_value) == SSA_NAME)
1326 {
1327 gcc_assert (SSA_NAME_IS_DEFAULT_DEF (args[i].tree_value));
1328 args[i].tree_value = SSA_NAME_VAR (args[i].tree_value);
1329 gcc_assert (TREE_CODE (args[i].tree_value) == PARM_DECL);
1330 }
1331 /* Argument setup code may have copied the value to register. We
1332 revert that optimization now because the tail call code must
1333 use the original location. */
1334 if (TREE_CODE (args[i].tree_value) == PARM_DECL
1335 && !MEM_P (DECL_RTL (args[i].tree_value))
1336 && DECL_INCOMING_RTL (args[i].tree_value)
1337 && MEM_P (DECL_INCOMING_RTL (args[i].tree_value)))
1338 set_decl_rtl (args[i].tree_value,
1339 DECL_INCOMING_RTL (args[i].tree_value));
1340
1341 mark_addressable (args[i].tree_value);
1342
1343 /* We can't use sibcalls if a callee-copied argument is
1344 stored in the current function's frame. */
1345 if (!call_from_thunk_p && DECL_P (base) && !TREE_STATIC (base))
1346 *may_tailcall = false;
1347
1348 args[i].tree_value = build_fold_addr_expr_loc (loc,
1349 args[i].tree_value);
1350 type = TREE_TYPE (args[i].tree_value);
1351
1352 if (*ecf_flags & ECF_CONST)
1353 *ecf_flags &= ~(ECF_CONST | ECF_LOOPING_CONST_OR_PURE);
1354 }
1355 else
1356 {
1357 /* We make a copy of the object and pass the address to the
1358 function being called. */
1359 rtx copy;
1360
1361 if (!COMPLETE_TYPE_P (type)
1362 || TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST
1363 || (flag_stack_check == GENERIC_STACK_CHECK
1364 && compare_tree_int (TYPE_SIZE_UNIT (type),
1365 STACK_CHECK_MAX_VAR_SIZE) > 0))
1366 {
1367 /* This is a variable-sized object. Make space on the stack
1368 for it. */
1369 rtx size_rtx = expr_size (args[i].tree_value);
1370
1371 if (*old_stack_level == 0)
1372 {
1373 emit_stack_save (SAVE_BLOCK, old_stack_level);
1374 *old_pending_adj = pending_stack_adjust;
1375 pending_stack_adjust = 0;
1376 }
1377
1378 /* We can pass TRUE as the 4th argument because we just
1379 saved the stack pointer and will restore it right after
1380 the call. */
1381 copy = allocate_dynamic_stack_space (size_rtx,
1382 TYPE_ALIGN (type),
1383 TYPE_ALIGN (type),
1384 true);
1385 copy = gen_rtx_MEM (BLKmode, copy);
1386 set_mem_attributes (copy, type, 1);
1387 }
1388 else
1389 copy = assign_temp (type, 1, 0);
1390
1391 store_expr (args[i].tree_value, copy, 0, false, false);
1392
1393 /* Just change the const function to pure and then let
1394 the next test clear the pure based on
1395 callee_copies. */
1396 if (*ecf_flags & ECF_CONST)
1397 {
1398 *ecf_flags &= ~ECF_CONST;
1399 *ecf_flags |= ECF_PURE;
1400 }
1401
1402 if (!callee_copies && *ecf_flags & ECF_PURE)
1403 *ecf_flags &= ~(ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
1404
1405 args[i].tree_value
1406 = build_fold_addr_expr_loc (loc, make_tree (type, copy));
1407 type = TREE_TYPE (args[i].tree_value);
1408 *may_tailcall = false;
1409 }
1410 }
1411
1412 unsignedp = TYPE_UNSIGNED (type);
1413 mode = promote_function_mode (type, TYPE_MODE (type), &unsignedp,
1414 fndecl ? TREE_TYPE (fndecl) : fntype, 0);
1415
1416 args[i].unsignedp = unsignedp;
1417 args[i].mode = mode;
1418
1419 args[i].reg = targetm.calls.function_arg (args_so_far, mode, type,
1420 argpos < n_named_args);
1421
1422 if (args[i].reg && CONST_INT_P (args[i].reg))
1423 {
1424 args[i].special_slot = args[i].reg;
1425 args[i].reg = NULL;
1426 }
1427
1428 /* If this is a sibling call and the machine has register windows, the
1429 register window has to be unwinded before calling the routine, so
1430 arguments have to go into the incoming registers. */
1431 if (targetm.calls.function_incoming_arg != targetm.calls.function_arg)
1432 args[i].tail_call_reg
1433 = targetm.calls.function_incoming_arg (args_so_far, mode, type,
1434 argpos < n_named_args);
1435 else
1436 args[i].tail_call_reg = args[i].reg;
1437
1438 if (args[i].reg)
1439 args[i].partial
1440 = targetm.calls.arg_partial_bytes (args_so_far, mode, type,
1441 argpos < n_named_args);
1442
1443 args[i].pass_on_stack = targetm.calls.must_pass_in_stack (mode, type);
1444
1445 /* If FUNCTION_ARG returned a (parallel [(expr_list (nil) ...) ...]),
1446 it means that we are to pass this arg in the register(s) designated
1447 by the PARALLEL, but also to pass it in the stack. */
1448 if (args[i].reg && GET_CODE (args[i].reg) == PARALLEL
1449 && XEXP (XVECEXP (args[i].reg, 0, 0), 0) == 0)
1450 args[i].pass_on_stack = 1;
1451
1452 /* If this is an addressable type, we must preallocate the stack
1453 since we must evaluate the object into its final location.
1454
1455 If this is to be passed in both registers and the stack, it is simpler
1456 to preallocate. */
1457 if (TREE_ADDRESSABLE (type)
1458 || (args[i].pass_on_stack && args[i].reg != 0))
1459 *must_preallocate = 1;
1460
1461 /* No stack allocation and padding for bounds. */
1462 if (POINTER_BOUNDS_P (args[i].tree_value))
1463 ;
1464 /* Compute the stack-size of this argument. */
1465 else if (args[i].reg == 0 || args[i].partial != 0
1466 || reg_parm_stack_space > 0
1467 || args[i].pass_on_stack)
1468 locate_and_pad_parm (mode, type,
1469 #ifdef STACK_PARMS_IN_REG_PARM_AREA
1470 1,
1471 #else
1472 args[i].reg != 0,
1473 #endif
1474 reg_parm_stack_space,
1475 args[i].pass_on_stack ? 0 : args[i].partial,
1476 fndecl, args_size, &args[i].locate);
1477 #ifdef BLOCK_REG_PADDING
1478 else
1479 /* The argument is passed entirely in registers. See at which
1480 end it should be padded. */
1481 args[i].locate.where_pad =
1482 BLOCK_REG_PADDING (mode, type,
1483 int_size_in_bytes (type) <= UNITS_PER_WORD);
1484 #endif
1485
1486 /* Update ARGS_SIZE, the total stack space for args so far. */
1487
1488 args_size->constant += args[i].locate.size.constant;
1489 if (args[i].locate.size.var)
1490 ADD_PARM_SIZE (*args_size, args[i].locate.size.var);
1491
1492 /* Increment ARGS_SO_FAR, which has info about which arg-registers
1493 have been used, etc. */
1494
1495 targetm.calls.function_arg_advance (args_so_far, TYPE_MODE (type),
1496 type, argpos < n_named_args);
1497 }
1498 }
1499
1500 /* Update ARGS_SIZE to contain the total size for the argument block.
1501 Return the original constant component of the argument block's size.
1502
1503 REG_PARM_STACK_SPACE holds the number of bytes of stack space reserved
1504 for arguments passed in registers. */
1505
1506 static int
compute_argument_block_size(int reg_parm_stack_space,struct args_size * args_size,tree fndecl ATTRIBUTE_UNUSED,tree fntype ATTRIBUTE_UNUSED,int preferred_stack_boundary ATTRIBUTE_UNUSED)1507 compute_argument_block_size (int reg_parm_stack_space,
1508 struct args_size *args_size,
1509 tree fndecl ATTRIBUTE_UNUSED,
1510 tree fntype ATTRIBUTE_UNUSED,
1511 int preferred_stack_boundary ATTRIBUTE_UNUSED)
1512 {
1513 int unadjusted_args_size = args_size->constant;
1514
1515 /* For accumulate outgoing args mode we don't need to align, since the frame
1516 will be already aligned. Align to STACK_BOUNDARY in order to prevent
1517 backends from generating misaligned frame sizes. */
1518 if (ACCUMULATE_OUTGOING_ARGS && preferred_stack_boundary > STACK_BOUNDARY)
1519 preferred_stack_boundary = STACK_BOUNDARY;
1520
1521 /* Compute the actual size of the argument block required. The variable
1522 and constant sizes must be combined, the size may have to be rounded,
1523 and there may be a minimum required size. */
1524
1525 if (args_size->var)
1526 {
1527 args_size->var = ARGS_SIZE_TREE (*args_size);
1528 args_size->constant = 0;
1529
1530 preferred_stack_boundary /= BITS_PER_UNIT;
1531 if (preferred_stack_boundary > 1)
1532 {
1533 /* We don't handle this case yet. To handle it correctly we have
1534 to add the delta, round and subtract the delta.
1535 Currently no machine description requires this support. */
1536 gcc_assert (!(stack_pointer_delta & (preferred_stack_boundary - 1)));
1537 args_size->var = round_up (args_size->var, preferred_stack_boundary);
1538 }
1539
1540 if (reg_parm_stack_space > 0)
1541 {
1542 args_size->var
1543 = size_binop (MAX_EXPR, args_size->var,
1544 ssize_int (reg_parm_stack_space));
1545
1546 /* The area corresponding to register parameters is not to count in
1547 the size of the block we need. So make the adjustment. */
1548 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
1549 args_size->var
1550 = size_binop (MINUS_EXPR, args_size->var,
1551 ssize_int (reg_parm_stack_space));
1552 }
1553 }
1554 else
1555 {
1556 preferred_stack_boundary /= BITS_PER_UNIT;
1557 if (preferred_stack_boundary < 1)
1558 preferred_stack_boundary = 1;
1559 args_size->constant = (((args_size->constant
1560 + stack_pointer_delta
1561 + preferred_stack_boundary - 1)
1562 / preferred_stack_boundary
1563 * preferred_stack_boundary)
1564 - stack_pointer_delta);
1565
1566 args_size->constant = MAX (args_size->constant,
1567 reg_parm_stack_space);
1568
1569 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
1570 args_size->constant -= reg_parm_stack_space;
1571 }
1572 return unadjusted_args_size;
1573 }
1574
1575 /* Precompute parameters as needed for a function call.
1576
1577 FLAGS is mask of ECF_* constants.
1578
1579 NUM_ACTUALS is the number of arguments.
1580
1581 ARGS is an array containing information for each argument; this
1582 routine fills in the INITIAL_VALUE and VALUE fields for each
1583 precomputed argument. */
1584
1585 static void
precompute_arguments(int num_actuals,struct arg_data * args)1586 precompute_arguments (int num_actuals, struct arg_data *args)
1587 {
1588 int i;
1589
1590 /* If this is a libcall, then precompute all arguments so that we do not
1591 get extraneous instructions emitted as part of the libcall sequence. */
1592
1593 /* If we preallocated the stack space, and some arguments must be passed
1594 on the stack, then we must precompute any parameter which contains a
1595 function call which will store arguments on the stack.
1596 Otherwise, evaluating the parameter may clobber previous parameters
1597 which have already been stored into the stack. (we have code to avoid
1598 such case by saving the outgoing stack arguments, but it results in
1599 worse code) */
1600 if (!ACCUMULATE_OUTGOING_ARGS)
1601 return;
1602
1603 for (i = 0; i < num_actuals; i++)
1604 {
1605 tree type;
1606 machine_mode mode;
1607
1608 if (TREE_CODE (args[i].tree_value) != CALL_EXPR)
1609 continue;
1610
1611 /* If this is an addressable type, we cannot pre-evaluate it. */
1612 type = TREE_TYPE (args[i].tree_value);
1613 gcc_assert (!TREE_ADDRESSABLE (type));
1614
1615 args[i].initial_value = args[i].value
1616 = expand_normal (args[i].tree_value);
1617
1618 mode = TYPE_MODE (type);
1619 if (mode != args[i].mode)
1620 {
1621 int unsignedp = args[i].unsignedp;
1622 args[i].value
1623 = convert_modes (args[i].mode, mode,
1624 args[i].value, args[i].unsignedp);
1625
1626 /* CSE will replace this only if it contains args[i].value
1627 pseudo, so convert it down to the declared mode using
1628 a SUBREG. */
1629 if (REG_P (args[i].value)
1630 && GET_MODE_CLASS (args[i].mode) == MODE_INT
1631 && promote_mode (type, mode, &unsignedp) != args[i].mode)
1632 {
1633 args[i].initial_value
1634 = gen_lowpart_SUBREG (mode, args[i].value);
1635 SUBREG_PROMOTED_VAR_P (args[i].initial_value) = 1;
1636 SUBREG_PROMOTED_SET (args[i].initial_value, args[i].unsignedp);
1637 }
1638 }
1639 }
1640 }
1641
1642 /* Given the current state of MUST_PREALLOCATE and information about
1643 arguments to a function call in NUM_ACTUALS, ARGS and ARGS_SIZE,
1644 compute and return the final value for MUST_PREALLOCATE. */
1645
1646 static int
finalize_must_preallocate(int must_preallocate,int num_actuals,struct arg_data * args,struct args_size * args_size)1647 finalize_must_preallocate (int must_preallocate, int num_actuals,
1648 struct arg_data *args, struct args_size *args_size)
1649 {
1650 /* See if we have or want to preallocate stack space.
1651
1652 If we would have to push a partially-in-regs parm
1653 before other stack parms, preallocate stack space instead.
1654
1655 If the size of some parm is not a multiple of the required stack
1656 alignment, we must preallocate.
1657
1658 If the total size of arguments that would otherwise create a copy in
1659 a temporary (such as a CALL) is more than half the total argument list
1660 size, preallocation is faster.
1661
1662 Another reason to preallocate is if we have a machine (like the m88k)
1663 where stack alignment is required to be maintained between every
1664 pair of insns, not just when the call is made. However, we assume here
1665 that such machines either do not have push insns (and hence preallocation
1666 would occur anyway) or the problem is taken care of with
1667 PUSH_ROUNDING. */
1668
1669 if (! must_preallocate)
1670 {
1671 int partial_seen = 0;
1672 int copy_to_evaluate_size = 0;
1673 int i;
1674
1675 for (i = 0; i < num_actuals && ! must_preallocate; i++)
1676 {
1677 if (args[i].partial > 0 && ! args[i].pass_on_stack)
1678 partial_seen = 1;
1679 else if (partial_seen && args[i].reg == 0)
1680 must_preallocate = 1;
1681 /* We preallocate in case there are bounds passed
1682 in the bounds table to have precomputed address
1683 for bounds association. */
1684 else if (POINTER_BOUNDS_P (args[i].tree_value)
1685 && !args[i].reg)
1686 must_preallocate = 1;
1687
1688 if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
1689 && (TREE_CODE (args[i].tree_value) == CALL_EXPR
1690 || TREE_CODE (args[i].tree_value) == TARGET_EXPR
1691 || TREE_CODE (args[i].tree_value) == COND_EXPR
1692 || TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value))))
1693 copy_to_evaluate_size
1694 += int_size_in_bytes (TREE_TYPE (args[i].tree_value));
1695 }
1696
1697 if (copy_to_evaluate_size * 2 >= args_size->constant
1698 && args_size->constant > 0)
1699 must_preallocate = 1;
1700 }
1701 return must_preallocate;
1702 }
1703
1704 /* If we preallocated stack space, compute the address of each argument
1705 and store it into the ARGS array.
1706
1707 We need not ensure it is a valid memory address here; it will be
1708 validized when it is used.
1709
1710 ARGBLOCK is an rtx for the address of the outgoing arguments. */
1711
1712 static void
compute_argument_addresses(struct arg_data * args,rtx argblock,int num_actuals)1713 compute_argument_addresses (struct arg_data *args, rtx argblock, int num_actuals)
1714 {
1715 if (argblock)
1716 {
1717 rtx arg_reg = argblock;
1718 int i, arg_offset = 0;
1719
1720 if (GET_CODE (argblock) == PLUS)
1721 arg_reg = XEXP (argblock, 0), arg_offset = INTVAL (XEXP (argblock, 1));
1722
1723 for (i = 0; i < num_actuals; i++)
1724 {
1725 rtx offset = ARGS_SIZE_RTX (args[i].locate.offset);
1726 rtx slot_offset = ARGS_SIZE_RTX (args[i].locate.slot_offset);
1727 rtx addr;
1728 unsigned int align, boundary;
1729 unsigned int units_on_stack = 0;
1730 machine_mode partial_mode = VOIDmode;
1731
1732 /* Skip this parm if it will not be passed on the stack. */
1733 if (! args[i].pass_on_stack
1734 && args[i].reg != 0
1735 && args[i].partial == 0)
1736 continue;
1737
1738 /* Pointer Bounds are never passed on the stack. */
1739 if (POINTER_BOUNDS_P (args[i].tree_value))
1740 continue;
1741
1742 if (CONST_INT_P (offset))
1743 addr = plus_constant (Pmode, arg_reg, INTVAL (offset));
1744 else
1745 addr = gen_rtx_PLUS (Pmode, arg_reg, offset);
1746
1747 addr = plus_constant (Pmode, addr, arg_offset);
1748
1749 if (args[i].partial != 0)
1750 {
1751 /* Only part of the parameter is being passed on the stack.
1752 Generate a simple memory reference of the correct size. */
1753 units_on_stack = args[i].locate.size.constant;
1754 partial_mode = mode_for_size (units_on_stack * BITS_PER_UNIT,
1755 MODE_INT, 1);
1756 args[i].stack = gen_rtx_MEM (partial_mode, addr);
1757 set_mem_size (args[i].stack, units_on_stack);
1758 }
1759 else
1760 {
1761 args[i].stack = gen_rtx_MEM (args[i].mode, addr);
1762 set_mem_attributes (args[i].stack,
1763 TREE_TYPE (args[i].tree_value), 1);
1764 }
1765 align = BITS_PER_UNIT;
1766 boundary = args[i].locate.boundary;
1767 if (args[i].locate.where_pad != downward)
1768 align = boundary;
1769 else if (CONST_INT_P (offset))
1770 {
1771 align = INTVAL (offset) * BITS_PER_UNIT | boundary;
1772 align = align & -align;
1773 }
1774 set_mem_align (args[i].stack, align);
1775
1776 if (CONST_INT_P (slot_offset))
1777 addr = plus_constant (Pmode, arg_reg, INTVAL (slot_offset));
1778 else
1779 addr = gen_rtx_PLUS (Pmode, arg_reg, slot_offset);
1780
1781 addr = plus_constant (Pmode, addr, arg_offset);
1782
1783 if (args[i].partial != 0)
1784 {
1785 /* Only part of the parameter is being passed on the stack.
1786 Generate a simple memory reference of the correct size.
1787 */
1788 args[i].stack_slot = gen_rtx_MEM (partial_mode, addr);
1789 set_mem_size (args[i].stack_slot, units_on_stack);
1790 }
1791 else
1792 {
1793 args[i].stack_slot = gen_rtx_MEM (args[i].mode, addr);
1794 set_mem_attributes (args[i].stack_slot,
1795 TREE_TYPE (args[i].tree_value), 1);
1796 }
1797 set_mem_align (args[i].stack_slot, args[i].locate.boundary);
1798
1799 /* Function incoming arguments may overlap with sibling call
1800 outgoing arguments and we cannot allow reordering of reads
1801 from function arguments with stores to outgoing arguments
1802 of sibling calls. */
1803 set_mem_alias_set (args[i].stack, 0);
1804 set_mem_alias_set (args[i].stack_slot, 0);
1805 }
1806 }
1807 }
1808
1809 /* Given a FNDECL and EXP, return an rtx suitable for use as a target address
1810 in a call instruction.
1811
1812 FNDECL is the tree node for the target function. For an indirect call
1813 FNDECL will be NULL_TREE.
1814
1815 ADDR is the operand 0 of CALL_EXPR for this call. */
1816
1817 static rtx
rtx_for_function_call(tree fndecl,tree addr)1818 rtx_for_function_call (tree fndecl, tree addr)
1819 {
1820 rtx funexp;
1821
1822 /* Get the function to call, in the form of RTL. */
1823 if (fndecl)
1824 {
1825 if (!TREE_USED (fndecl) && fndecl != current_function_decl)
1826 TREE_USED (fndecl) = 1;
1827
1828 /* Get a SYMBOL_REF rtx for the function address. */
1829 funexp = XEXP (DECL_RTL (fndecl), 0);
1830 }
1831 else
1832 /* Generate an rtx (probably a pseudo-register) for the address. */
1833 {
1834 push_temp_slots ();
1835 funexp = expand_normal (addr);
1836 pop_temp_slots (); /* FUNEXP can't be BLKmode. */
1837 }
1838 return funexp;
1839 }
1840
1841 /* Internal state for internal_arg_pointer_based_exp and its helpers. */
1842 static struct
1843 {
1844 /* Last insn that has been scanned by internal_arg_pointer_based_exp_scan,
1845 or NULL_RTX if none has been scanned yet. */
1846 rtx_insn *scan_start;
1847 /* Vector indexed by REGNO - FIRST_PSEUDO_REGISTER, recording if a pseudo is
1848 based on crtl->args.internal_arg_pointer. The element is NULL_RTX if the
1849 pseudo isn't based on it, a CONST_INT offset if the pseudo is based on it
1850 with fixed offset, or PC if this is with variable or unknown offset. */
1851 vec<rtx> cache;
1852 } internal_arg_pointer_exp_state;
1853
1854 static rtx internal_arg_pointer_based_exp (const_rtx, bool);
1855
1856 /* Helper function for internal_arg_pointer_based_exp. Scan insns in
1857 the tail call sequence, starting with first insn that hasn't been
1858 scanned yet, and note for each pseudo on the LHS whether it is based
1859 on crtl->args.internal_arg_pointer or not, and what offset from that
1860 that pointer it has. */
1861
1862 static void
internal_arg_pointer_based_exp_scan(void)1863 internal_arg_pointer_based_exp_scan (void)
1864 {
1865 rtx_insn *insn, *scan_start = internal_arg_pointer_exp_state.scan_start;
1866
1867 if (scan_start == NULL_RTX)
1868 insn = get_insns ();
1869 else
1870 insn = NEXT_INSN (scan_start);
1871
1872 while (insn)
1873 {
1874 rtx set = single_set (insn);
1875 if (set && REG_P (SET_DEST (set)) && !HARD_REGISTER_P (SET_DEST (set)))
1876 {
1877 rtx val = NULL_RTX;
1878 unsigned int idx = REGNO (SET_DEST (set)) - FIRST_PSEUDO_REGISTER;
1879 /* Punt on pseudos set multiple times. */
1880 if (idx < internal_arg_pointer_exp_state.cache.length ()
1881 && (internal_arg_pointer_exp_state.cache[idx]
1882 != NULL_RTX))
1883 val = pc_rtx;
1884 else
1885 val = internal_arg_pointer_based_exp (SET_SRC (set), false);
1886 if (val != NULL_RTX)
1887 {
1888 if (idx >= internal_arg_pointer_exp_state.cache.length ())
1889 internal_arg_pointer_exp_state.cache
1890 .safe_grow_cleared (idx + 1);
1891 internal_arg_pointer_exp_state.cache[idx] = val;
1892 }
1893 }
1894 if (NEXT_INSN (insn) == NULL_RTX)
1895 scan_start = insn;
1896 insn = NEXT_INSN (insn);
1897 }
1898
1899 internal_arg_pointer_exp_state.scan_start = scan_start;
1900 }
1901
1902 /* Compute whether RTL is based on crtl->args.internal_arg_pointer. Return
1903 NULL_RTX if RTL isn't based on it, a CONST_INT offset if RTL is based on
1904 it with fixed offset, or PC if this is with variable or unknown offset.
1905 TOPLEVEL is true if the function is invoked at the topmost level. */
1906
1907 static rtx
internal_arg_pointer_based_exp(const_rtx rtl,bool toplevel)1908 internal_arg_pointer_based_exp (const_rtx rtl, bool toplevel)
1909 {
1910 if (CONSTANT_P (rtl))
1911 return NULL_RTX;
1912
1913 if (rtl == crtl->args.internal_arg_pointer)
1914 return const0_rtx;
1915
1916 if (REG_P (rtl) && HARD_REGISTER_P (rtl))
1917 return NULL_RTX;
1918
1919 if (GET_CODE (rtl) == PLUS && CONST_INT_P (XEXP (rtl, 1)))
1920 {
1921 rtx val = internal_arg_pointer_based_exp (XEXP (rtl, 0), toplevel);
1922 if (val == NULL_RTX || val == pc_rtx)
1923 return val;
1924 return plus_constant (Pmode, val, INTVAL (XEXP (rtl, 1)));
1925 }
1926
1927 /* When called at the topmost level, scan pseudo assignments in between the
1928 last scanned instruction in the tail call sequence and the latest insn
1929 in that sequence. */
1930 if (toplevel)
1931 internal_arg_pointer_based_exp_scan ();
1932
1933 if (REG_P (rtl))
1934 {
1935 unsigned int idx = REGNO (rtl) - FIRST_PSEUDO_REGISTER;
1936 if (idx < internal_arg_pointer_exp_state.cache.length ())
1937 return internal_arg_pointer_exp_state.cache[idx];
1938
1939 return NULL_RTX;
1940 }
1941
1942 subrtx_iterator::array_type array;
1943 FOR_EACH_SUBRTX (iter, array, rtl, NONCONST)
1944 {
1945 const_rtx x = *iter;
1946 if (REG_P (x) && internal_arg_pointer_based_exp (x, false) != NULL_RTX)
1947 return pc_rtx;
1948 if (MEM_P (x))
1949 iter.skip_subrtxes ();
1950 }
1951
1952 return NULL_RTX;
1953 }
1954
1955 /* Return true if and only if SIZE storage units (usually bytes)
1956 starting from address ADDR overlap with already clobbered argument
1957 area. This function is used to determine if we should give up a
1958 sibcall. */
1959
1960 static bool
mem_overlaps_already_clobbered_arg_p(rtx addr,unsigned HOST_WIDE_INT size)1961 mem_overlaps_already_clobbered_arg_p (rtx addr, unsigned HOST_WIDE_INT size)
1962 {
1963 HOST_WIDE_INT i;
1964 rtx val;
1965
1966 if (bitmap_empty_p (stored_args_map))
1967 return false;
1968 val = internal_arg_pointer_based_exp (addr, true);
1969 if (val == NULL_RTX)
1970 return false;
1971 else if (val == pc_rtx)
1972 return true;
1973 else
1974 i = INTVAL (val);
1975
1976 if (STACK_GROWS_DOWNWARD)
1977 i -= crtl->args.pretend_args_size;
1978 else
1979 i += crtl->args.pretend_args_size;
1980
1981
1982 if (ARGS_GROW_DOWNWARD)
1983 i = -i - size;
1984
1985 if (size > 0)
1986 {
1987 unsigned HOST_WIDE_INT k;
1988
1989 for (k = 0; k < size; k++)
1990 if (i + k < SBITMAP_SIZE (stored_args_map)
1991 && bitmap_bit_p (stored_args_map, i + k))
1992 return true;
1993 }
1994
1995 return false;
1996 }
1997
1998 /* Do the register loads required for any wholly-register parms or any
1999 parms which are passed both on the stack and in a register. Their
2000 expressions were already evaluated.
2001
2002 Mark all register-parms as living through the call, putting these USE
2003 insns in the CALL_INSN_FUNCTION_USAGE field.
2004
2005 When IS_SIBCALL, perform the check_sibcall_argument_overlap
2006 checking, setting *SIBCALL_FAILURE if appropriate. */
2007
2008 static void
load_register_parameters(struct arg_data * args,int num_actuals,rtx * call_fusage,int flags,int is_sibcall,int * sibcall_failure)2009 load_register_parameters (struct arg_data *args, int num_actuals,
2010 rtx *call_fusage, int flags, int is_sibcall,
2011 int *sibcall_failure)
2012 {
2013 int i, j;
2014
2015 for (i = 0; i < num_actuals; i++)
2016 {
2017 rtx reg = ((flags & ECF_SIBCALL)
2018 ? args[i].tail_call_reg : args[i].reg);
2019 if (reg)
2020 {
2021 int partial = args[i].partial;
2022 int nregs;
2023 int size = 0;
2024 rtx_insn *before_arg = get_last_insn ();
2025 /* Set non-negative if we must move a word at a time, even if
2026 just one word (e.g, partial == 4 && mode == DFmode). Set
2027 to -1 if we just use a normal move insn. This value can be
2028 zero if the argument is a zero size structure. */
2029 nregs = -1;
2030 if (GET_CODE (reg) == PARALLEL)
2031 ;
2032 else if (partial)
2033 {
2034 gcc_assert (partial % UNITS_PER_WORD == 0);
2035 nregs = partial / UNITS_PER_WORD;
2036 }
2037 else if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode)
2038 {
2039 size = int_size_in_bytes (TREE_TYPE (args[i].tree_value));
2040 nregs = (size + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
2041 }
2042 else
2043 size = GET_MODE_SIZE (args[i].mode);
2044
2045 /* Handle calls that pass values in multiple non-contiguous
2046 locations. The Irix 6 ABI has examples of this. */
2047
2048 if (GET_CODE (reg) == PARALLEL)
2049 emit_group_move (reg, args[i].parallel_value);
2050
2051 /* If simple case, just do move. If normal partial, store_one_arg
2052 has already loaded the register for us. In all other cases,
2053 load the register(s) from memory. */
2054
2055 else if (nregs == -1)
2056 {
2057 emit_move_insn (reg, args[i].value);
2058 #ifdef BLOCK_REG_PADDING
2059 /* Handle case where we have a value that needs shifting
2060 up to the msb. eg. a QImode value and we're padding
2061 upward on a BYTES_BIG_ENDIAN machine. */
2062 if (size < UNITS_PER_WORD
2063 && (args[i].locate.where_pad
2064 == (BYTES_BIG_ENDIAN ? upward : downward)))
2065 {
2066 rtx x;
2067 int shift = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
2068
2069 /* Assigning REG here rather than a temp makes CALL_FUSAGE
2070 report the whole reg as used. Strictly speaking, the
2071 call only uses SIZE bytes at the msb end, but it doesn't
2072 seem worth generating rtl to say that. */
2073 reg = gen_rtx_REG (word_mode, REGNO (reg));
2074 x = expand_shift (LSHIFT_EXPR, word_mode, reg, shift, reg, 1);
2075 if (x != reg)
2076 emit_move_insn (reg, x);
2077 }
2078 #endif
2079 }
2080
2081 /* If we have pre-computed the values to put in the registers in
2082 the case of non-aligned structures, copy them in now. */
2083
2084 else if (args[i].n_aligned_regs != 0)
2085 for (j = 0; j < args[i].n_aligned_regs; j++)
2086 emit_move_insn (gen_rtx_REG (word_mode, REGNO (reg) + j),
2087 args[i].aligned_regs[j]);
2088
2089 else if (partial == 0 || args[i].pass_on_stack)
2090 {
2091 rtx mem = validize_mem (copy_rtx (args[i].value));
2092
2093 /* Check for overlap with already clobbered argument area,
2094 providing that this has non-zero size. */
2095 if (is_sibcall
2096 && size != 0
2097 && (mem_overlaps_already_clobbered_arg_p
2098 (XEXP (args[i].value, 0), size)))
2099 *sibcall_failure = 1;
2100
2101 if (size % UNITS_PER_WORD == 0
2102 || MEM_ALIGN (mem) % BITS_PER_WORD == 0)
2103 move_block_to_reg (REGNO (reg), mem, nregs, args[i].mode);
2104 else
2105 {
2106 if (nregs > 1)
2107 move_block_to_reg (REGNO (reg), mem, nregs - 1,
2108 args[i].mode);
2109 rtx dest = gen_rtx_REG (word_mode, REGNO (reg) + nregs - 1);
2110 unsigned int bitoff = (nregs - 1) * BITS_PER_WORD;
2111 unsigned int bitsize = size * BITS_PER_UNIT - bitoff;
2112 rtx x = extract_bit_field (mem, bitsize, bitoff, 1, dest,
2113 word_mode, word_mode, false);
2114 if (BYTES_BIG_ENDIAN)
2115 x = expand_shift (LSHIFT_EXPR, word_mode, x,
2116 BITS_PER_WORD - bitsize, dest, 1);
2117 if (x != dest)
2118 emit_move_insn (dest, x);
2119 }
2120
2121 /* Handle a BLKmode that needs shifting. */
2122 if (nregs == 1 && size < UNITS_PER_WORD
2123 #ifdef BLOCK_REG_PADDING
2124 && args[i].locate.where_pad == downward
2125 #else
2126 && BYTES_BIG_ENDIAN
2127 #endif
2128 )
2129 {
2130 rtx dest = gen_rtx_REG (word_mode, REGNO (reg));
2131 int shift = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
2132 enum tree_code dir = (BYTES_BIG_ENDIAN
2133 ? RSHIFT_EXPR : LSHIFT_EXPR);
2134 rtx x;
2135
2136 x = expand_shift (dir, word_mode, dest, shift, dest, 1);
2137 if (x != dest)
2138 emit_move_insn (dest, x);
2139 }
2140 }
2141
2142 /* When a parameter is a block, and perhaps in other cases, it is
2143 possible that it did a load from an argument slot that was
2144 already clobbered. */
2145 if (is_sibcall
2146 && check_sibcall_argument_overlap (before_arg, &args[i], 0))
2147 *sibcall_failure = 1;
2148
2149 /* Handle calls that pass values in multiple non-contiguous
2150 locations. The Irix 6 ABI has examples of this. */
2151 if (GET_CODE (reg) == PARALLEL)
2152 use_group_regs (call_fusage, reg);
2153 else if (nregs == -1)
2154 use_reg_mode (call_fusage, reg,
2155 TYPE_MODE (TREE_TYPE (args[i].tree_value)));
2156 else if (nregs > 0)
2157 use_regs (call_fusage, REGNO (reg), nregs);
2158 }
2159 }
2160 }
2161
2162 /* We need to pop PENDING_STACK_ADJUST bytes. But, if the arguments
2163 wouldn't fill up an even multiple of PREFERRED_UNIT_STACK_BOUNDARY
2164 bytes, then we would need to push some additional bytes to pad the
2165 arguments. So, we compute an adjust to the stack pointer for an
2166 amount that will leave the stack under-aligned by UNADJUSTED_ARGS_SIZE
2167 bytes. Then, when the arguments are pushed the stack will be perfectly
2168 aligned. ARGS_SIZE->CONSTANT is set to the number of bytes that should
2169 be popped after the call. Returns the adjustment. */
2170
2171 static int
combine_pending_stack_adjustment_and_call(int unadjusted_args_size,struct args_size * args_size,unsigned int preferred_unit_stack_boundary)2172 combine_pending_stack_adjustment_and_call (int unadjusted_args_size,
2173 struct args_size *args_size,
2174 unsigned int preferred_unit_stack_boundary)
2175 {
2176 /* The number of bytes to pop so that the stack will be
2177 under-aligned by UNADJUSTED_ARGS_SIZE bytes. */
2178 HOST_WIDE_INT adjustment;
2179 /* The alignment of the stack after the arguments are pushed, if we
2180 just pushed the arguments without adjust the stack here. */
2181 unsigned HOST_WIDE_INT unadjusted_alignment;
2182
2183 unadjusted_alignment
2184 = ((stack_pointer_delta + unadjusted_args_size)
2185 % preferred_unit_stack_boundary);
2186
2187 /* We want to get rid of as many of the PENDING_STACK_ADJUST bytes
2188 as possible -- leaving just enough left to cancel out the
2189 UNADJUSTED_ALIGNMENT. In other words, we want to ensure that the
2190 PENDING_STACK_ADJUST is non-negative, and congruent to
2191 -UNADJUSTED_ALIGNMENT modulo the PREFERRED_UNIT_STACK_BOUNDARY. */
2192
2193 /* Begin by trying to pop all the bytes. */
2194 unadjusted_alignment
2195 = (unadjusted_alignment
2196 - (pending_stack_adjust % preferred_unit_stack_boundary));
2197 adjustment = pending_stack_adjust;
2198 /* Push enough additional bytes that the stack will be aligned
2199 after the arguments are pushed. */
2200 if (preferred_unit_stack_boundary > 1)
2201 {
2202 if (unadjusted_alignment > 0)
2203 adjustment -= preferred_unit_stack_boundary - unadjusted_alignment;
2204 else
2205 adjustment += unadjusted_alignment;
2206 }
2207
2208 /* Now, sets ARGS_SIZE->CONSTANT so that we pop the right number of
2209 bytes after the call. The right number is the entire
2210 PENDING_STACK_ADJUST less our ADJUSTMENT plus the amount required
2211 by the arguments in the first place. */
2212 args_size->constant
2213 = pending_stack_adjust - adjustment + unadjusted_args_size;
2214
2215 return adjustment;
2216 }
2217
2218 /* Scan X expression if it does not dereference any argument slots
2219 we already clobbered by tail call arguments (as noted in stored_args_map
2220 bitmap).
2221 Return nonzero if X expression dereferences such argument slots,
2222 zero otherwise. */
2223
2224 static int
check_sibcall_argument_overlap_1(rtx x)2225 check_sibcall_argument_overlap_1 (rtx x)
2226 {
2227 RTX_CODE code;
2228 int i, j;
2229 const char *fmt;
2230
2231 if (x == NULL_RTX)
2232 return 0;
2233
2234 code = GET_CODE (x);
2235
2236 /* We need not check the operands of the CALL expression itself. */
2237 if (code == CALL)
2238 return 0;
2239
2240 if (code == MEM)
2241 return mem_overlaps_already_clobbered_arg_p (XEXP (x, 0),
2242 GET_MODE_SIZE (GET_MODE (x)));
2243
2244 /* Scan all subexpressions. */
2245 fmt = GET_RTX_FORMAT (code);
2246 for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
2247 {
2248 if (*fmt == 'e')
2249 {
2250 if (check_sibcall_argument_overlap_1 (XEXP (x, i)))
2251 return 1;
2252 }
2253 else if (*fmt == 'E')
2254 {
2255 for (j = 0; j < XVECLEN (x, i); j++)
2256 if (check_sibcall_argument_overlap_1 (XVECEXP (x, i, j)))
2257 return 1;
2258 }
2259 }
2260 return 0;
2261 }
2262
2263 /* Scan sequence after INSN if it does not dereference any argument slots
2264 we already clobbered by tail call arguments (as noted in stored_args_map
2265 bitmap). If MARK_STORED_ARGS_MAP, add stack slots for ARG to
2266 stored_args_map bitmap afterwards (when ARG is a register MARK_STORED_ARGS_MAP
2267 should be 0). Return nonzero if sequence after INSN dereferences such argument
2268 slots, zero otherwise. */
2269
2270 static int
check_sibcall_argument_overlap(rtx_insn * insn,struct arg_data * arg,int mark_stored_args_map)2271 check_sibcall_argument_overlap (rtx_insn *insn, struct arg_data *arg,
2272 int mark_stored_args_map)
2273 {
2274 int low, high;
2275
2276 if (insn == NULL_RTX)
2277 insn = get_insns ();
2278 else
2279 insn = NEXT_INSN (insn);
2280
2281 for (; insn; insn = NEXT_INSN (insn))
2282 if (INSN_P (insn)
2283 && check_sibcall_argument_overlap_1 (PATTERN (insn)))
2284 break;
2285
2286 if (mark_stored_args_map)
2287 {
2288 if (ARGS_GROW_DOWNWARD)
2289 low = -arg->locate.slot_offset.constant - arg->locate.size.constant;
2290 else
2291 low = arg->locate.slot_offset.constant;
2292
2293 for (high = low + arg->locate.size.constant; low < high; low++)
2294 bitmap_set_bit (stored_args_map, low);
2295 }
2296 return insn != NULL_RTX;
2297 }
2298
2299 /* Given that a function returns a value of mode MODE at the most
2300 significant end of hard register VALUE, shift VALUE left or right
2301 as specified by LEFT_P. Return true if some action was needed. */
2302
2303 bool
shift_return_value(machine_mode mode,bool left_p,rtx value)2304 shift_return_value (machine_mode mode, bool left_p, rtx value)
2305 {
2306 HOST_WIDE_INT shift;
2307
2308 gcc_assert (REG_P (value) && HARD_REGISTER_P (value));
2309 shift = GET_MODE_BITSIZE (GET_MODE (value)) - GET_MODE_BITSIZE (mode);
2310 if (shift == 0)
2311 return false;
2312
2313 /* Use ashr rather than lshr for right shifts. This is for the benefit
2314 of the MIPS port, which requires SImode values to be sign-extended
2315 when stored in 64-bit registers. */
2316 if (!force_expand_binop (GET_MODE (value), left_p ? ashl_optab : ashr_optab,
2317 value, GEN_INT (shift), value, 1, OPTAB_WIDEN))
2318 gcc_unreachable ();
2319 return true;
2320 }
2321
2322 /* If X is a likely-spilled register value, copy it to a pseudo
2323 register and return that register. Return X otherwise. */
2324
2325 static rtx
avoid_likely_spilled_reg(rtx x)2326 avoid_likely_spilled_reg (rtx x)
2327 {
2328 rtx new_rtx;
2329
2330 if (REG_P (x)
2331 && HARD_REGISTER_P (x)
2332 && targetm.class_likely_spilled_p (REGNO_REG_CLASS (REGNO (x))))
2333 {
2334 /* Make sure that we generate a REG rather than a CONCAT.
2335 Moves into CONCATs can need nontrivial instructions,
2336 and the whole point of this function is to avoid
2337 using the hard register directly in such a situation. */
2338 generating_concat_p = 0;
2339 new_rtx = gen_reg_rtx (GET_MODE (x));
2340 generating_concat_p = 1;
2341 emit_move_insn (new_rtx, x);
2342 return new_rtx;
2343 }
2344 return x;
2345 }
2346
2347 /* Generate all the code for a CALL_EXPR exp
2348 and return an rtx for its value.
2349 Store the value in TARGET (specified as an rtx) if convenient.
2350 If the value is stored in TARGET then TARGET is returned.
2351 If IGNORE is nonzero, then we ignore the value of the function call. */
2352
2353 rtx
expand_call(tree exp,rtx target,int ignore)2354 expand_call (tree exp, rtx target, int ignore)
2355 {
2356 /* Nonzero if we are currently expanding a call. */
2357 static int currently_expanding_call = 0;
2358
2359 /* RTX for the function to be called. */
2360 rtx funexp;
2361 /* Sequence of insns to perform a normal "call". */
2362 rtx_insn *normal_call_insns = NULL;
2363 /* Sequence of insns to perform a tail "call". */
2364 rtx_insn *tail_call_insns = NULL;
2365 /* Data type of the function. */
2366 tree funtype;
2367 tree type_arg_types;
2368 tree rettype;
2369 /* Declaration of the function being called,
2370 or 0 if the function is computed (not known by name). */
2371 tree fndecl = 0;
2372 /* The type of the function being called. */
2373 tree fntype;
2374 bool try_tail_call = CALL_EXPR_TAILCALL (exp);
2375 int pass;
2376
2377 /* Register in which non-BLKmode value will be returned,
2378 or 0 if no value or if value is BLKmode. */
2379 rtx valreg;
2380 /* Register(s) in which bounds are returned. */
2381 rtx valbnd = NULL;
2382 /* Address where we should return a BLKmode value;
2383 0 if value not BLKmode. */
2384 rtx structure_value_addr = 0;
2385 /* Nonzero if that address is being passed by treating it as
2386 an extra, implicit first parameter. Otherwise,
2387 it is passed by being copied directly into struct_value_rtx. */
2388 int structure_value_addr_parm = 0;
2389 /* Holds the value of implicit argument for the struct value. */
2390 tree structure_value_addr_value = NULL_TREE;
2391 /* Size of aggregate value wanted, or zero if none wanted
2392 or if we are using the non-reentrant PCC calling convention
2393 or expecting the value in registers. */
2394 HOST_WIDE_INT struct_value_size = 0;
2395 /* Nonzero if called function returns an aggregate in memory PCC style,
2396 by returning the address of where to find it. */
2397 int pcc_struct_value = 0;
2398 rtx struct_value = 0;
2399
2400 /* Number of actual parameters in this call, including struct value addr. */
2401 int num_actuals;
2402 /* Number of named args. Args after this are anonymous ones
2403 and they must all go on the stack. */
2404 int n_named_args;
2405 /* Number of complex actual arguments that need to be split. */
2406 int num_complex_actuals = 0;
2407
2408 /* Vector of information about each argument.
2409 Arguments are numbered in the order they will be pushed,
2410 not the order they are written. */
2411 struct arg_data *args;
2412
2413 /* Total size in bytes of all the stack-parms scanned so far. */
2414 struct args_size args_size;
2415 struct args_size adjusted_args_size;
2416 /* Size of arguments before any adjustments (such as rounding). */
2417 int unadjusted_args_size;
2418 /* Data on reg parms scanned so far. */
2419 CUMULATIVE_ARGS args_so_far_v;
2420 cumulative_args_t args_so_far;
2421 /* Nonzero if a reg parm has been scanned. */
2422 int reg_parm_seen;
2423 /* Nonzero if this is an indirect function call. */
2424
2425 /* Nonzero if we must avoid push-insns in the args for this call.
2426 If stack space is allocated for register parameters, but not by the
2427 caller, then it is preallocated in the fixed part of the stack frame.
2428 So the entire argument block must then be preallocated (i.e., we
2429 ignore PUSH_ROUNDING in that case). */
2430
2431 int must_preallocate = !PUSH_ARGS;
2432
2433 /* Size of the stack reserved for parameter registers. */
2434 int reg_parm_stack_space = 0;
2435
2436 /* Address of space preallocated for stack parms
2437 (on machines that lack push insns), or 0 if space not preallocated. */
2438 rtx argblock = 0;
2439
2440 /* Mask of ECF_ and ERF_ flags. */
2441 int flags = 0;
2442 int return_flags = 0;
2443 #ifdef REG_PARM_STACK_SPACE
2444 /* Define the boundary of the register parm stack space that needs to be
2445 saved, if any. */
2446 int low_to_save, high_to_save;
2447 rtx save_area = 0; /* Place that it is saved */
2448 #endif
2449
2450 int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
2451 char *initial_stack_usage_map = stack_usage_map;
2452 char *stack_usage_map_buf = NULL;
2453
2454 int old_stack_allocated;
2455
2456 /* State variables to track stack modifications. */
2457 rtx old_stack_level = 0;
2458 int old_stack_arg_under_construction = 0;
2459 int old_pending_adj = 0;
2460 int old_inhibit_defer_pop = inhibit_defer_pop;
2461
2462 /* Some stack pointer alterations we make are performed via
2463 allocate_dynamic_stack_space. This modifies the stack_pointer_delta,
2464 which we then also need to save/restore along the way. */
2465 int old_stack_pointer_delta = 0;
2466
2467 rtx call_fusage;
2468 tree addr = CALL_EXPR_FN (exp);
2469 int i;
2470 /* The alignment of the stack, in bits. */
2471 unsigned HOST_WIDE_INT preferred_stack_boundary;
2472 /* The alignment of the stack, in bytes. */
2473 unsigned HOST_WIDE_INT preferred_unit_stack_boundary;
2474 /* The static chain value to use for this call. */
2475 rtx static_chain_value;
2476 /* See if this is "nothrow" function call. */
2477 if (TREE_NOTHROW (exp))
2478 flags |= ECF_NOTHROW;
2479
2480 /* See if we can find a DECL-node for the actual function, and get the
2481 function attributes (flags) from the function decl or type node. */
2482 fndecl = get_callee_fndecl (exp);
2483 if (fndecl)
2484 {
2485 fntype = TREE_TYPE (fndecl);
2486 flags |= flags_from_decl_or_type (fndecl);
2487 return_flags |= decl_return_flags (fndecl);
2488 }
2489 else
2490 {
2491 fntype = TREE_TYPE (TREE_TYPE (addr));
2492 flags |= flags_from_decl_or_type (fntype);
2493 }
2494 rettype = TREE_TYPE (exp);
2495
2496 struct_value = targetm.calls.struct_value_rtx (fntype, 0);
2497
2498 /* Warn if this value is an aggregate type,
2499 regardless of which calling convention we are using for it. */
2500 if (AGGREGATE_TYPE_P (rettype))
2501 warning (OPT_Waggregate_return, "function call has aggregate value");
2502
2503 /* If the result of a non looping pure or const function call is
2504 ignored (or void), and none of its arguments are volatile, we can
2505 avoid expanding the call and just evaluate the arguments for
2506 side-effects. */
2507 if ((flags & (ECF_CONST | ECF_PURE))
2508 && (!(flags & ECF_LOOPING_CONST_OR_PURE))
2509 && (ignore || target == const0_rtx
2510 || TYPE_MODE (rettype) == VOIDmode))
2511 {
2512 bool volatilep = false;
2513 tree arg;
2514 call_expr_arg_iterator iter;
2515
2516 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
2517 if (TREE_THIS_VOLATILE (arg))
2518 {
2519 volatilep = true;
2520 break;
2521 }
2522
2523 if (! volatilep)
2524 {
2525 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
2526 expand_expr (arg, const0_rtx, VOIDmode, EXPAND_NORMAL);
2527 return const0_rtx;
2528 }
2529 }
2530
2531 #ifdef REG_PARM_STACK_SPACE
2532 reg_parm_stack_space = REG_PARM_STACK_SPACE (!fndecl ? fntype : fndecl);
2533 #endif
2534
2535 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))
2536 && reg_parm_stack_space > 0 && PUSH_ARGS)
2537 must_preallocate = 1;
2538
2539 /* Set up a place to return a structure. */
2540
2541 /* Cater to broken compilers. */
2542 if (aggregate_value_p (exp, fntype))
2543 {
2544 /* This call returns a big structure. */
2545 flags &= ~(ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
2546
2547 #ifdef PCC_STATIC_STRUCT_RETURN
2548 {
2549 pcc_struct_value = 1;
2550 }
2551 #else /* not PCC_STATIC_STRUCT_RETURN */
2552 {
2553 struct_value_size = int_size_in_bytes (rettype);
2554
2555 /* Even if it is semantically safe to use the target as the return
2556 slot, it may be not sufficiently aligned for the return type. */
2557 if (CALL_EXPR_RETURN_SLOT_OPT (exp)
2558 && target
2559 && MEM_P (target)
2560 && !(MEM_ALIGN (target) < TYPE_ALIGN (rettype)
2561 && SLOW_UNALIGNED_ACCESS (TYPE_MODE (rettype),
2562 MEM_ALIGN (target))))
2563 structure_value_addr = XEXP (target, 0);
2564 else
2565 {
2566 /* For variable-sized objects, we must be called with a target
2567 specified. If we were to allocate space on the stack here,
2568 we would have no way of knowing when to free it. */
2569 rtx d = assign_temp (rettype, 1, 1);
2570 structure_value_addr = XEXP (d, 0);
2571 target = 0;
2572 }
2573 }
2574 #endif /* not PCC_STATIC_STRUCT_RETURN */
2575 }
2576
2577 /* Figure out the amount to which the stack should be aligned. */
2578 preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
2579 if (fndecl)
2580 {
2581 struct cgraph_rtl_info *i = cgraph_node::rtl_info (fndecl);
2582 /* Without automatic stack alignment, we can't increase preferred
2583 stack boundary. With automatic stack alignment, it is
2584 unnecessary since unless we can guarantee that all callers will
2585 align the outgoing stack properly, callee has to align its
2586 stack anyway. */
2587 if (i
2588 && i->preferred_incoming_stack_boundary
2589 && i->preferred_incoming_stack_boundary < preferred_stack_boundary)
2590 preferred_stack_boundary = i->preferred_incoming_stack_boundary;
2591 }
2592
2593 /* Operand 0 is a pointer-to-function; get the type of the function. */
2594 funtype = TREE_TYPE (addr);
2595 gcc_assert (POINTER_TYPE_P (funtype));
2596 funtype = TREE_TYPE (funtype);
2597
2598 /* Count whether there are actual complex arguments that need to be split
2599 into their real and imaginary parts. Munge the type_arg_types
2600 appropriately here as well. */
2601 if (targetm.calls.split_complex_arg)
2602 {
2603 call_expr_arg_iterator iter;
2604 tree arg;
2605 FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
2606 {
2607 tree type = TREE_TYPE (arg);
2608 if (type && TREE_CODE (type) == COMPLEX_TYPE
2609 && targetm.calls.split_complex_arg (type))
2610 num_complex_actuals++;
2611 }
2612 type_arg_types = split_complex_types (TYPE_ARG_TYPES (funtype));
2613 }
2614 else
2615 type_arg_types = TYPE_ARG_TYPES (funtype);
2616
2617 if (flags & ECF_MAY_BE_ALLOCA)
2618 cfun->calls_alloca = 1;
2619
2620 /* If struct_value_rtx is 0, it means pass the address
2621 as if it were an extra parameter. Put the argument expression
2622 in structure_value_addr_value. */
2623 if (structure_value_addr && struct_value == 0)
2624 {
2625 /* If structure_value_addr is a REG other than
2626 virtual_outgoing_args_rtx, we can use always use it. If it
2627 is not a REG, we must always copy it into a register.
2628 If it is virtual_outgoing_args_rtx, we must copy it to another
2629 register in some cases. */
2630 rtx temp = (!REG_P (structure_value_addr)
2631 || (ACCUMULATE_OUTGOING_ARGS
2632 && stack_arg_under_construction
2633 && structure_value_addr == virtual_outgoing_args_rtx)
2634 ? copy_addr_to_reg (convert_memory_address
2635 (Pmode, structure_value_addr))
2636 : structure_value_addr);
2637
2638 structure_value_addr_value =
2639 make_tree (build_pointer_type (TREE_TYPE (funtype)), temp);
2640 structure_value_addr_parm = CALL_WITH_BOUNDS_P (exp) ? 2 : 1;
2641 }
2642
2643 /* Count the arguments and set NUM_ACTUALS. */
2644 num_actuals =
2645 call_expr_nargs (exp) + num_complex_actuals + structure_value_addr_parm;
2646
2647 /* Compute number of named args.
2648 First, do a raw count of the args for INIT_CUMULATIVE_ARGS. */
2649
2650 if (type_arg_types != 0)
2651 n_named_args
2652 = (list_length (type_arg_types)
2653 /* Count the struct value address, if it is passed as a parm. */
2654 + structure_value_addr_parm);
2655 else
2656 /* If we know nothing, treat all args as named. */
2657 n_named_args = num_actuals;
2658
2659 /* Start updating where the next arg would go.
2660
2661 On some machines (such as the PA) indirect calls have a different
2662 calling convention than normal calls. The fourth argument in
2663 INIT_CUMULATIVE_ARGS tells the backend if this is an indirect call
2664 or not. */
2665 INIT_CUMULATIVE_ARGS (args_so_far_v, funtype, NULL_RTX, fndecl, n_named_args);
2666 args_so_far = pack_cumulative_args (&args_so_far_v);
2667
2668 /* Now possibly adjust the number of named args.
2669 Normally, don't include the last named arg if anonymous args follow.
2670 We do include the last named arg if
2671 targetm.calls.strict_argument_naming() returns nonzero.
2672 (If no anonymous args follow, the result of list_length is actually
2673 one too large. This is harmless.)
2674
2675 If targetm.calls.pretend_outgoing_varargs_named() returns
2676 nonzero, and targetm.calls.strict_argument_naming() returns zero,
2677 this machine will be able to place unnamed args that were passed
2678 in registers into the stack. So treat all args as named. This
2679 allows the insns emitting for a specific argument list to be
2680 independent of the function declaration.
2681
2682 If targetm.calls.pretend_outgoing_varargs_named() returns zero,
2683 we do not have any reliable way to pass unnamed args in
2684 registers, so we must force them into memory. */
2685
2686 if (type_arg_types != 0
2687 && targetm.calls.strict_argument_naming (args_so_far))
2688 ;
2689 else if (type_arg_types != 0
2690 && ! targetm.calls.pretend_outgoing_varargs_named (args_so_far))
2691 /* Don't include the last named arg. */
2692 --n_named_args;
2693 else
2694 /* Treat all args as named. */
2695 n_named_args = num_actuals;
2696
2697 /* Make a vector to hold all the information about each arg. */
2698 args = XCNEWVEC (struct arg_data, num_actuals);
2699
2700 /* Build up entries in the ARGS array, compute the size of the
2701 arguments into ARGS_SIZE, etc. */
2702 initialize_argument_information (num_actuals, args, &args_size,
2703 n_named_args, exp,
2704 structure_value_addr_value, fndecl, fntype,
2705 args_so_far, reg_parm_stack_space,
2706 &old_stack_level, &old_pending_adj,
2707 &must_preallocate, &flags,
2708 &try_tail_call, CALL_FROM_THUNK_P (exp));
2709
2710 if (args_size.var)
2711 must_preallocate = 1;
2712
2713 /* Now make final decision about preallocating stack space. */
2714 must_preallocate = finalize_must_preallocate (must_preallocate,
2715 num_actuals, args,
2716 &args_size);
2717
2718 /* If the structure value address will reference the stack pointer, we
2719 must stabilize it. We don't need to do this if we know that we are
2720 not going to adjust the stack pointer in processing this call. */
2721
2722 if (structure_value_addr
2723 && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
2724 || reg_mentioned_p (virtual_outgoing_args_rtx,
2725 structure_value_addr))
2726 && (args_size.var
2727 || (!ACCUMULATE_OUTGOING_ARGS && args_size.constant)))
2728 structure_value_addr = copy_to_reg (structure_value_addr);
2729
2730 /* Tail calls can make things harder to debug, and we've traditionally
2731 pushed these optimizations into -O2. Don't try if we're already
2732 expanding a call, as that means we're an argument. Don't try if
2733 there's cleanups, as we know there's code to follow the call. */
2734
2735 if (currently_expanding_call++ != 0
2736 || !flag_optimize_sibling_calls
2737 || args_size.var
2738 || dbg_cnt (tail_call) == false)
2739 try_tail_call = 0;
2740
2741 /* Rest of purposes for tail call optimizations to fail. */
2742 if (!try_tail_call
2743 || !targetm.have_sibcall_epilogue ()
2744 /* Doing sibling call optimization needs some work, since
2745 structure_value_addr can be allocated on the stack.
2746 It does not seem worth the effort since few optimizable
2747 sibling calls will return a structure. */
2748 || structure_value_addr != NULL_RTX
2749 #ifdef REG_PARM_STACK_SPACE
2750 /* If outgoing reg parm stack space changes, we can not do sibcall. */
2751 || (OUTGOING_REG_PARM_STACK_SPACE (funtype)
2752 != OUTGOING_REG_PARM_STACK_SPACE (TREE_TYPE (current_function_decl)))
2753 || (reg_parm_stack_space != REG_PARM_STACK_SPACE (current_function_decl))
2754 #endif
2755 /* Check whether the target is able to optimize the call
2756 into a sibcall. */
2757 || !targetm.function_ok_for_sibcall (fndecl, exp)
2758 /* Functions that do not return exactly once may not be sibcall
2759 optimized. */
2760 || (flags & (ECF_RETURNS_TWICE | ECF_NORETURN))
2761 || TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (addr)))
2762 /* If the called function is nested in the current one, it might access
2763 some of the caller's arguments, but could clobber them beforehand if
2764 the argument areas are shared. */
2765 || (fndecl && decl_function_context (fndecl) == current_function_decl)
2766 /* If this function requires more stack slots than the current
2767 function, we cannot change it into a sibling call.
2768 crtl->args.pretend_args_size is not part of the
2769 stack allocated by our caller. */
2770 || args_size.constant > (crtl->args.size
2771 - crtl->args.pretend_args_size)
2772 /* If the callee pops its own arguments, then it must pop exactly
2773 the same number of arguments as the current function. */
2774 || (targetm.calls.return_pops_args (fndecl, funtype, args_size.constant)
2775 != targetm.calls.return_pops_args (current_function_decl,
2776 TREE_TYPE (current_function_decl),
2777 crtl->args.size))
2778 || !lang_hooks.decls.ok_for_sibcall (fndecl))
2779 try_tail_call = 0;
2780
2781 /* Check if caller and callee disagree in promotion of function
2782 return value. */
2783 if (try_tail_call)
2784 {
2785 machine_mode caller_mode, caller_promoted_mode;
2786 machine_mode callee_mode, callee_promoted_mode;
2787 int caller_unsignedp, callee_unsignedp;
2788 tree caller_res = DECL_RESULT (current_function_decl);
2789
2790 caller_unsignedp = TYPE_UNSIGNED (TREE_TYPE (caller_res));
2791 caller_mode = DECL_MODE (caller_res);
2792 callee_unsignedp = TYPE_UNSIGNED (TREE_TYPE (funtype));
2793 callee_mode = TYPE_MODE (TREE_TYPE (funtype));
2794 caller_promoted_mode
2795 = promote_function_mode (TREE_TYPE (caller_res), caller_mode,
2796 &caller_unsignedp,
2797 TREE_TYPE (current_function_decl), 1);
2798 callee_promoted_mode
2799 = promote_function_mode (TREE_TYPE (funtype), callee_mode,
2800 &callee_unsignedp,
2801 funtype, 1);
2802 if (caller_mode != VOIDmode
2803 && (caller_promoted_mode != callee_promoted_mode
2804 || ((caller_mode != caller_promoted_mode
2805 || callee_mode != callee_promoted_mode)
2806 && (caller_unsignedp != callee_unsignedp
2807 || GET_MODE_BITSIZE (caller_mode)
2808 < GET_MODE_BITSIZE (callee_mode)))))
2809 try_tail_call = 0;
2810 }
2811
2812 /* Ensure current function's preferred stack boundary is at least
2813 what we need. Stack alignment may also increase preferred stack
2814 boundary. */
2815 if (crtl->preferred_stack_boundary < preferred_stack_boundary)
2816 crtl->preferred_stack_boundary = preferred_stack_boundary;
2817 else
2818 preferred_stack_boundary = crtl->preferred_stack_boundary;
2819
2820 preferred_unit_stack_boundary = preferred_stack_boundary / BITS_PER_UNIT;
2821
2822 /* We want to make two insn chains; one for a sibling call, the other
2823 for a normal call. We will select one of the two chains after
2824 initial RTL generation is complete. */
2825 for (pass = try_tail_call ? 0 : 1; pass < 2; pass++)
2826 {
2827 int sibcall_failure = 0;
2828 /* We want to emit any pending stack adjustments before the tail
2829 recursion "call". That way we know any adjustment after the tail
2830 recursion call can be ignored if we indeed use the tail
2831 call expansion. */
2832 saved_pending_stack_adjust save;
2833 rtx_insn *insns, *before_call, *after_args;
2834 rtx next_arg_reg;
2835
2836 if (pass == 0)
2837 {
2838 /* State variables we need to save and restore between
2839 iterations. */
2840 save_pending_stack_adjust (&save);
2841 }
2842 if (pass)
2843 flags &= ~ECF_SIBCALL;
2844 else
2845 flags |= ECF_SIBCALL;
2846
2847 /* Other state variables that we must reinitialize each time
2848 through the loop (that are not initialized by the loop itself). */
2849 argblock = 0;
2850 call_fusage = 0;
2851
2852 /* Start a new sequence for the normal call case.
2853
2854 From this point on, if the sibling call fails, we want to set
2855 sibcall_failure instead of continuing the loop. */
2856 start_sequence ();
2857
2858 /* Don't let pending stack adjusts add up to too much.
2859 Also, do all pending adjustments now if there is any chance
2860 this might be a call to alloca or if we are expanding a sibling
2861 call sequence.
2862 Also do the adjustments before a throwing call, otherwise
2863 exception handling can fail; PR 19225. */
2864 if (pending_stack_adjust >= 32
2865 || (pending_stack_adjust > 0
2866 && (flags & ECF_MAY_BE_ALLOCA))
2867 || (pending_stack_adjust > 0
2868 && flag_exceptions && !(flags & ECF_NOTHROW))
2869 || pass == 0)
2870 do_pending_stack_adjust ();
2871
2872 /* Precompute any arguments as needed. */
2873 if (pass)
2874 precompute_arguments (num_actuals, args);
2875
2876 /* Now we are about to start emitting insns that can be deleted
2877 if a libcall is deleted. */
2878 if (pass && (flags & ECF_MALLOC))
2879 start_sequence ();
2880
2881 if (pass == 0 && crtl->stack_protect_guard)
2882 stack_protect_epilogue ();
2883
2884 adjusted_args_size = args_size;
2885 /* Compute the actual size of the argument block required. The variable
2886 and constant sizes must be combined, the size may have to be rounded,
2887 and there may be a minimum required size. When generating a sibcall
2888 pattern, do not round up, since we'll be re-using whatever space our
2889 caller provided. */
2890 unadjusted_args_size
2891 = compute_argument_block_size (reg_parm_stack_space,
2892 &adjusted_args_size,
2893 fndecl, fntype,
2894 (pass == 0 ? 0
2895 : preferred_stack_boundary));
2896
2897 old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
2898
2899 /* The argument block when performing a sibling call is the
2900 incoming argument block. */
2901 if (pass == 0)
2902 {
2903 argblock = crtl->args.internal_arg_pointer;
2904 if (STACK_GROWS_DOWNWARD)
2905 argblock
2906 = plus_constant (Pmode, argblock, crtl->args.pretend_args_size);
2907 else
2908 argblock
2909 = plus_constant (Pmode, argblock, -crtl->args.pretend_args_size);
2910
2911 stored_args_map = sbitmap_alloc (args_size.constant);
2912 bitmap_clear (stored_args_map);
2913 }
2914
2915 /* If we have no actual push instructions, or shouldn't use them,
2916 make space for all args right now. */
2917 else if (adjusted_args_size.var != 0)
2918 {
2919 if (old_stack_level == 0)
2920 {
2921 emit_stack_save (SAVE_BLOCK, &old_stack_level);
2922 old_stack_pointer_delta = stack_pointer_delta;
2923 old_pending_adj = pending_stack_adjust;
2924 pending_stack_adjust = 0;
2925 /* stack_arg_under_construction says whether a stack arg is
2926 being constructed at the old stack level. Pushing the stack
2927 gets a clean outgoing argument block. */
2928 old_stack_arg_under_construction = stack_arg_under_construction;
2929 stack_arg_under_construction = 0;
2930 }
2931 argblock = push_block (ARGS_SIZE_RTX (adjusted_args_size), 0, 0);
2932 if (flag_stack_usage_info)
2933 current_function_has_unbounded_dynamic_stack_size = 1;
2934 }
2935 else
2936 {
2937 /* Note that we must go through the motions of allocating an argument
2938 block even if the size is zero because we may be storing args
2939 in the area reserved for register arguments, which may be part of
2940 the stack frame. */
2941
2942 int needed = adjusted_args_size.constant;
2943
2944 /* Store the maximum argument space used. It will be pushed by
2945 the prologue (if ACCUMULATE_OUTGOING_ARGS, or stack overflow
2946 checking). */
2947
2948 if (needed > crtl->outgoing_args_size)
2949 crtl->outgoing_args_size = needed;
2950
2951 if (must_preallocate)
2952 {
2953 if (ACCUMULATE_OUTGOING_ARGS)
2954 {
2955 /* Since the stack pointer will never be pushed, it is
2956 possible for the evaluation of a parm to clobber
2957 something we have already written to the stack.
2958 Since most function calls on RISC machines do not use
2959 the stack, this is uncommon, but must work correctly.
2960
2961 Therefore, we save any area of the stack that was already
2962 written and that we are using. Here we set up to do this
2963 by making a new stack usage map from the old one. The
2964 actual save will be done by store_one_arg.
2965
2966 Another approach might be to try to reorder the argument
2967 evaluations to avoid this conflicting stack usage. */
2968
2969 /* Since we will be writing into the entire argument area,
2970 the map must be allocated for its entire size, not just
2971 the part that is the responsibility of the caller. */
2972 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
2973 needed += reg_parm_stack_space;
2974
2975 if (ARGS_GROW_DOWNWARD)
2976 highest_outgoing_arg_in_use
2977 = MAX (initial_highest_arg_in_use, needed + 1);
2978 else
2979 highest_outgoing_arg_in_use
2980 = MAX (initial_highest_arg_in_use, needed);
2981
2982 free (stack_usage_map_buf);
2983 stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
2984 stack_usage_map = stack_usage_map_buf;
2985
2986 if (initial_highest_arg_in_use)
2987 memcpy (stack_usage_map, initial_stack_usage_map,
2988 initial_highest_arg_in_use);
2989
2990 if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
2991 memset (&stack_usage_map[initial_highest_arg_in_use], 0,
2992 (highest_outgoing_arg_in_use
2993 - initial_highest_arg_in_use));
2994 needed = 0;
2995
2996 /* The address of the outgoing argument list must not be
2997 copied to a register here, because argblock would be left
2998 pointing to the wrong place after the call to
2999 allocate_dynamic_stack_space below. */
3000
3001 argblock = virtual_outgoing_args_rtx;
3002 }
3003 else
3004 {
3005 if (inhibit_defer_pop == 0)
3006 {
3007 /* Try to reuse some or all of the pending_stack_adjust
3008 to get this space. */
3009 needed
3010 = (combine_pending_stack_adjustment_and_call
3011 (unadjusted_args_size,
3012 &adjusted_args_size,
3013 preferred_unit_stack_boundary));
3014
3015 /* combine_pending_stack_adjustment_and_call computes
3016 an adjustment before the arguments are allocated.
3017 Account for them and see whether or not the stack
3018 needs to go up or down. */
3019 needed = unadjusted_args_size - needed;
3020
3021 if (needed < 0)
3022 {
3023 /* We're releasing stack space. */
3024 /* ??? We can avoid any adjustment at all if we're
3025 already aligned. FIXME. */
3026 pending_stack_adjust = -needed;
3027 do_pending_stack_adjust ();
3028 needed = 0;
3029 }
3030 else
3031 /* We need to allocate space. We'll do that in
3032 push_block below. */
3033 pending_stack_adjust = 0;
3034 }
3035
3036 /* Special case this because overhead of `push_block' in
3037 this case is non-trivial. */
3038 if (needed == 0)
3039 argblock = virtual_outgoing_args_rtx;
3040 else
3041 {
3042 argblock = push_block (GEN_INT (needed), 0, 0);
3043 if (ARGS_GROW_DOWNWARD)
3044 argblock = plus_constant (Pmode, argblock, needed);
3045 }
3046
3047 /* We only really need to call `copy_to_reg' in the case
3048 where push insns are going to be used to pass ARGBLOCK
3049 to a function call in ARGS. In that case, the stack
3050 pointer changes value from the allocation point to the
3051 call point, and hence the value of
3052 VIRTUAL_OUTGOING_ARGS_RTX changes as well. But might
3053 as well always do it. */
3054 argblock = copy_to_reg (argblock);
3055 }
3056 }
3057 }
3058
3059 if (ACCUMULATE_OUTGOING_ARGS)
3060 {
3061 /* The save/restore code in store_one_arg handles all
3062 cases except one: a constructor call (including a C
3063 function returning a BLKmode struct) to initialize
3064 an argument. */
3065 if (stack_arg_under_construction)
3066 {
3067 rtx push_size
3068 = GEN_INT (adjusted_args_size.constant
3069 + (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype
3070 : TREE_TYPE (fndecl))) ? 0
3071 : reg_parm_stack_space));
3072 if (old_stack_level == 0)
3073 {
3074 emit_stack_save (SAVE_BLOCK, &old_stack_level);
3075 old_stack_pointer_delta = stack_pointer_delta;
3076 old_pending_adj = pending_stack_adjust;
3077 pending_stack_adjust = 0;
3078 /* stack_arg_under_construction says whether a stack
3079 arg is being constructed at the old stack level.
3080 Pushing the stack gets a clean outgoing argument
3081 block. */
3082 old_stack_arg_under_construction
3083 = stack_arg_under_construction;
3084 stack_arg_under_construction = 0;
3085 /* Make a new map for the new argument list. */
3086 free (stack_usage_map_buf);
3087 stack_usage_map_buf = XCNEWVEC (char, highest_outgoing_arg_in_use);
3088 stack_usage_map = stack_usage_map_buf;
3089 highest_outgoing_arg_in_use = 0;
3090 }
3091 /* We can pass TRUE as the 4th argument because we just
3092 saved the stack pointer and will restore it right after
3093 the call. */
3094 allocate_dynamic_stack_space (push_size, 0,
3095 BIGGEST_ALIGNMENT, true);
3096 }
3097
3098 /* If argument evaluation might modify the stack pointer,
3099 copy the address of the argument list to a register. */
3100 for (i = 0; i < num_actuals; i++)
3101 if (args[i].pass_on_stack)
3102 {
3103 argblock = copy_addr_to_reg (argblock);
3104 break;
3105 }
3106 }
3107
3108 compute_argument_addresses (args, argblock, num_actuals);
3109
3110 /* Stack is properly aligned, pops can't safely be deferred during
3111 the evaluation of the arguments. */
3112 NO_DEFER_POP;
3113
3114 /* Precompute all register parameters. It isn't safe to compute
3115 anything once we have started filling any specific hard regs.
3116 TLS symbols sometimes need a call to resolve. Precompute
3117 register parameters before any stack pointer manipulation
3118 to avoid unaligned stack in the called function. */
3119 precompute_register_parameters (num_actuals, args, ®_parm_seen);
3120
3121 OK_DEFER_POP;
3122
3123 /* Perform stack alignment before the first push (the last arg). */
3124 if (argblock == 0
3125 && adjusted_args_size.constant > reg_parm_stack_space
3126 && adjusted_args_size.constant != unadjusted_args_size)
3127 {
3128 /* When the stack adjustment is pending, we get better code
3129 by combining the adjustments. */
3130 if (pending_stack_adjust
3131 && ! inhibit_defer_pop)
3132 {
3133 pending_stack_adjust
3134 = (combine_pending_stack_adjustment_and_call
3135 (unadjusted_args_size,
3136 &adjusted_args_size,
3137 preferred_unit_stack_boundary));
3138 do_pending_stack_adjust ();
3139 }
3140 else if (argblock == 0)
3141 anti_adjust_stack (GEN_INT (adjusted_args_size.constant
3142 - unadjusted_args_size));
3143 }
3144 /* Now that the stack is properly aligned, pops can't safely
3145 be deferred during the evaluation of the arguments. */
3146 NO_DEFER_POP;
3147
3148 /* Record the maximum pushed stack space size. We need to delay
3149 doing it this far to take into account the optimization done
3150 by combine_pending_stack_adjustment_and_call. */
3151 if (flag_stack_usage_info
3152 && !ACCUMULATE_OUTGOING_ARGS
3153 && pass
3154 && adjusted_args_size.var == 0)
3155 {
3156 int pushed = adjusted_args_size.constant + pending_stack_adjust;
3157 if (pushed > current_function_pushed_stack_size)
3158 current_function_pushed_stack_size = pushed;
3159 }
3160
3161 funexp = rtx_for_function_call (fndecl, addr);
3162
3163 if (CALL_EXPR_STATIC_CHAIN (exp))
3164 static_chain_value = expand_normal (CALL_EXPR_STATIC_CHAIN (exp));
3165 else
3166 static_chain_value = 0;
3167
3168 #ifdef REG_PARM_STACK_SPACE
3169 /* Save the fixed argument area if it's part of the caller's frame and
3170 is clobbered by argument setup for this call. */
3171 if (ACCUMULATE_OUTGOING_ARGS && pass)
3172 save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
3173 &low_to_save, &high_to_save);
3174 #endif
3175
3176 /* Now store (and compute if necessary) all non-register parms.
3177 These come before register parms, since they can require block-moves,
3178 which could clobber the registers used for register parms.
3179 Parms which have partial registers are not stored here,
3180 but we do preallocate space here if they want that. */
3181
3182 for (i = 0; i < num_actuals; i++)
3183 {
3184 /* Delay bounds until all other args are stored. */
3185 if (POINTER_BOUNDS_P (args[i].tree_value))
3186 continue;
3187 else if (args[i].reg == 0 || args[i].pass_on_stack)
3188 {
3189 rtx_insn *before_arg = get_last_insn ();
3190
3191 /* We don't allow passing huge (> 2^30 B) arguments
3192 by value. It would cause an overflow later on. */
3193 if (adjusted_args_size.constant
3194 >= (1 << (HOST_BITS_PER_INT - 2)))
3195 {
3196 sorry ("passing too large argument on stack");
3197 continue;
3198 }
3199
3200 if (store_one_arg (&args[i], argblock, flags,
3201 adjusted_args_size.var != 0,
3202 reg_parm_stack_space)
3203 || (pass == 0
3204 && check_sibcall_argument_overlap (before_arg,
3205 &args[i], 1)))
3206 sibcall_failure = 1;
3207 }
3208
3209 if (args[i].stack)
3210 call_fusage
3211 = gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args[i].tree_value)),
3212 gen_rtx_USE (VOIDmode, args[i].stack),
3213 call_fusage);
3214 }
3215
3216 /* If we have a parm that is passed in registers but not in memory
3217 and whose alignment does not permit a direct copy into registers,
3218 make a group of pseudos that correspond to each register that we
3219 will later fill. */
3220 if (STRICT_ALIGNMENT)
3221 store_unaligned_arguments_into_pseudos (args, num_actuals);
3222
3223 /* Now store any partially-in-registers parm.
3224 This is the last place a block-move can happen. */
3225 if (reg_parm_seen)
3226 for (i = 0; i < num_actuals; i++)
3227 if (args[i].partial != 0 && ! args[i].pass_on_stack)
3228 {
3229 rtx_insn *before_arg = get_last_insn ();
3230
3231 /* On targets with weird calling conventions (e.g. PA) it's
3232 hard to ensure that all cases of argument overlap between
3233 stack and registers work. Play it safe and bail out. */
3234 if (ARGS_GROW_DOWNWARD && !STACK_GROWS_DOWNWARD)
3235 {
3236 sibcall_failure = 1;
3237 break;
3238 }
3239
3240 if (store_one_arg (&args[i], argblock, flags,
3241 adjusted_args_size.var != 0,
3242 reg_parm_stack_space)
3243 || (pass == 0
3244 && check_sibcall_argument_overlap (before_arg,
3245 &args[i], 1)))
3246 sibcall_failure = 1;
3247 }
3248
3249 bool any_regs = false;
3250 for (i = 0; i < num_actuals; i++)
3251 if (args[i].reg != NULL_RTX)
3252 {
3253 any_regs = true;
3254 targetm.calls.call_args (args[i].reg, funtype);
3255 }
3256 if (!any_regs)
3257 targetm.calls.call_args (pc_rtx, funtype);
3258
3259 /* Figure out the register where the value, if any, will come back. */
3260 valreg = 0;
3261 valbnd = 0;
3262 if (TYPE_MODE (rettype) != VOIDmode
3263 && ! structure_value_addr)
3264 {
3265 if (pcc_struct_value)
3266 {
3267 valreg = hard_function_value (build_pointer_type (rettype),
3268 fndecl, NULL, (pass == 0));
3269 if (CALL_WITH_BOUNDS_P (exp))
3270 valbnd = targetm.calls.
3271 chkp_function_value_bounds (build_pointer_type (rettype),
3272 fndecl, (pass == 0));
3273 }
3274 else
3275 {
3276 valreg = hard_function_value (rettype, fndecl, fntype,
3277 (pass == 0));
3278 if (CALL_WITH_BOUNDS_P (exp))
3279 valbnd = targetm.calls.chkp_function_value_bounds (rettype,
3280 fndecl,
3281 (pass == 0));
3282 }
3283
3284 /* If VALREG is a PARALLEL whose first member has a zero
3285 offset, use that. This is for targets such as m68k that
3286 return the same value in multiple places. */
3287 if (GET_CODE (valreg) == PARALLEL)
3288 {
3289 rtx elem = XVECEXP (valreg, 0, 0);
3290 rtx where = XEXP (elem, 0);
3291 rtx offset = XEXP (elem, 1);
3292 if (offset == const0_rtx
3293 && GET_MODE (where) == GET_MODE (valreg))
3294 valreg = where;
3295 }
3296 }
3297
3298 /* Store all bounds not passed in registers. */
3299 for (i = 0; i < num_actuals; i++)
3300 {
3301 if (POINTER_BOUNDS_P (args[i].tree_value)
3302 && !args[i].reg)
3303 store_bounds (&args[i],
3304 args[i].pointer_arg == -1
3305 ? NULL
3306 : &args[args[i].pointer_arg]);
3307 }
3308
3309 /* If register arguments require space on the stack and stack space
3310 was not preallocated, allocate stack space here for arguments
3311 passed in registers. */
3312 if (OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl)))
3313 && !ACCUMULATE_OUTGOING_ARGS
3314 && must_preallocate == 0 && reg_parm_stack_space > 0)
3315 anti_adjust_stack (GEN_INT (reg_parm_stack_space));
3316
3317 /* Pass the function the address in which to return a
3318 structure value. */
3319 if (pass != 0 && structure_value_addr && ! structure_value_addr_parm)
3320 {
3321 structure_value_addr
3322 = convert_memory_address (Pmode, structure_value_addr);
3323 emit_move_insn (struct_value,
3324 force_reg (Pmode,
3325 force_operand (structure_value_addr,
3326 NULL_RTX)));
3327
3328 if (REG_P (struct_value))
3329 use_reg (&call_fusage, struct_value);
3330 }
3331
3332 after_args = get_last_insn ();
3333 funexp = prepare_call_address (fndecl ? fndecl : fntype, funexp,
3334 static_chain_value, &call_fusage,
3335 reg_parm_seen, pass == 0);
3336
3337 load_register_parameters (args, num_actuals, &call_fusage, flags,
3338 pass == 0, &sibcall_failure);
3339
3340 /* Save a pointer to the last insn before the call, so that we can
3341 later safely search backwards to find the CALL_INSN. */
3342 before_call = get_last_insn ();
3343
3344 /* Set up next argument register. For sibling calls on machines
3345 with register windows this should be the incoming register. */
3346 if (pass == 0)
3347 next_arg_reg = targetm.calls.function_incoming_arg (args_so_far,
3348 VOIDmode,
3349 void_type_node,
3350 true);
3351 else
3352 next_arg_reg = targetm.calls.function_arg (args_so_far,
3353 VOIDmode, void_type_node,
3354 true);
3355
3356 if (pass == 1 && (return_flags & ERF_RETURNS_ARG))
3357 {
3358 int arg_nr = return_flags & ERF_RETURN_ARG_MASK;
3359 arg_nr = num_actuals - arg_nr - 1;
3360 if (arg_nr >= 0
3361 && arg_nr < num_actuals
3362 && args[arg_nr].reg
3363 && valreg
3364 && REG_P (valreg)
3365 && GET_MODE (args[arg_nr].reg) == GET_MODE (valreg))
3366 call_fusage
3367 = gen_rtx_EXPR_LIST (TYPE_MODE (TREE_TYPE (args[arg_nr].tree_value)),
3368 gen_rtx_SET (valreg, args[arg_nr].reg),
3369 call_fusage);
3370 }
3371 /* All arguments and registers used for the call must be set up by
3372 now! */
3373
3374 /* Stack must be properly aligned now. */
3375 gcc_assert (!pass
3376 || !(stack_pointer_delta % preferred_unit_stack_boundary));
3377
3378 /* Generate the actual call instruction. */
3379 emit_call_1 (funexp, exp, fndecl, funtype, unadjusted_args_size,
3380 adjusted_args_size.constant, struct_value_size,
3381 next_arg_reg, valreg, old_inhibit_defer_pop, call_fusage,
3382 flags, args_so_far);
3383
3384 if (flag_ipa_ra)
3385 {
3386 rtx_call_insn *last;
3387 rtx datum = NULL_RTX;
3388 if (fndecl != NULL_TREE)
3389 {
3390 datum = XEXP (DECL_RTL (fndecl), 0);
3391 gcc_assert (datum != NULL_RTX
3392 && GET_CODE (datum) == SYMBOL_REF);
3393 }
3394 last = last_call_insn ();
3395 add_reg_note (last, REG_CALL_DECL, datum);
3396 }
3397
3398 /* If the call setup or the call itself overlaps with anything
3399 of the argument setup we probably clobbered our call address.
3400 In that case we can't do sibcalls. */
3401 if (pass == 0
3402 && check_sibcall_argument_overlap (after_args, 0, 0))
3403 sibcall_failure = 1;
3404
3405 /* If a non-BLKmode value is returned at the most significant end
3406 of a register, shift the register right by the appropriate amount
3407 and update VALREG accordingly. BLKmode values are handled by the
3408 group load/store machinery below. */
3409 if (!structure_value_addr
3410 && !pcc_struct_value
3411 && TYPE_MODE (rettype) != VOIDmode
3412 && TYPE_MODE (rettype) != BLKmode
3413 && REG_P (valreg)
3414 && targetm.calls.return_in_msb (rettype))
3415 {
3416 if (shift_return_value (TYPE_MODE (rettype), false, valreg))
3417 sibcall_failure = 1;
3418 valreg = gen_rtx_REG (TYPE_MODE (rettype), REGNO (valreg));
3419 }
3420
3421 if (pass && (flags & ECF_MALLOC))
3422 {
3423 rtx temp = gen_reg_rtx (GET_MODE (valreg));
3424 rtx_insn *last, *insns;
3425
3426 /* The return value from a malloc-like function is a pointer. */
3427 if (TREE_CODE (rettype) == POINTER_TYPE)
3428 mark_reg_pointer (temp, MALLOC_ABI_ALIGNMENT);
3429
3430 emit_move_insn (temp, valreg);
3431
3432 /* The return value from a malloc-like function can not alias
3433 anything else. */
3434 last = get_last_insn ();
3435 add_reg_note (last, REG_NOALIAS, temp);
3436
3437 /* Write out the sequence. */
3438 insns = get_insns ();
3439 end_sequence ();
3440 emit_insn (insns);
3441 valreg = temp;
3442 }
3443
3444 /* For calls to `setjmp', etc., inform
3445 function.c:setjmp_warnings that it should complain if
3446 nonvolatile values are live. For functions that cannot
3447 return, inform flow that control does not fall through. */
3448
3449 if ((flags & ECF_NORETURN) || pass == 0)
3450 {
3451 /* The barrier must be emitted
3452 immediately after the CALL_INSN. Some ports emit more
3453 than just a CALL_INSN above, so we must search for it here. */
3454
3455 rtx_insn *last = get_last_insn ();
3456 while (!CALL_P (last))
3457 {
3458 last = PREV_INSN (last);
3459 /* There was no CALL_INSN? */
3460 gcc_assert (last != before_call);
3461 }
3462
3463 emit_barrier_after (last);
3464
3465 /* Stack adjustments after a noreturn call are dead code.
3466 However when NO_DEFER_POP is in effect, we must preserve
3467 stack_pointer_delta. */
3468 if (inhibit_defer_pop == 0)
3469 {
3470 stack_pointer_delta = old_stack_allocated;
3471 pending_stack_adjust = 0;
3472 }
3473 }
3474
3475 /* If value type not void, return an rtx for the value. */
3476
3477 if (TYPE_MODE (rettype) == VOIDmode
3478 || ignore)
3479 target = const0_rtx;
3480 else if (structure_value_addr)
3481 {
3482 if (target == 0 || !MEM_P (target))
3483 {
3484 target
3485 = gen_rtx_MEM (TYPE_MODE (rettype),
3486 memory_address (TYPE_MODE (rettype),
3487 structure_value_addr));
3488 set_mem_attributes (target, rettype, 1);
3489 }
3490 }
3491 else if (pcc_struct_value)
3492 {
3493 /* This is the special C++ case where we need to
3494 know what the true target was. We take care to
3495 never use this value more than once in one expression. */
3496 target = gen_rtx_MEM (TYPE_MODE (rettype),
3497 copy_to_reg (valreg));
3498 set_mem_attributes (target, rettype, 1);
3499 }
3500 /* Handle calls that return values in multiple non-contiguous locations.
3501 The Irix 6 ABI has examples of this. */
3502 else if (GET_CODE (valreg) == PARALLEL)
3503 {
3504 if (target == 0)
3505 target = emit_group_move_into_temps (valreg);
3506 else if (rtx_equal_p (target, valreg))
3507 ;
3508 else if (GET_CODE (target) == PARALLEL)
3509 /* Handle the result of a emit_group_move_into_temps
3510 call in the previous pass. */
3511 emit_group_move (target, valreg);
3512 else
3513 emit_group_store (target, valreg, rettype,
3514 int_size_in_bytes (rettype));
3515 }
3516 else if (target
3517 && GET_MODE (target) == TYPE_MODE (rettype)
3518 && GET_MODE (target) == GET_MODE (valreg))
3519 {
3520 bool may_overlap = false;
3521
3522 /* We have to copy a return value in a CLASS_LIKELY_SPILLED hard
3523 reg to a plain register. */
3524 if (!REG_P (target) || HARD_REGISTER_P (target))
3525 valreg = avoid_likely_spilled_reg (valreg);
3526
3527 /* If TARGET is a MEM in the argument area, and we have
3528 saved part of the argument area, then we can't store
3529 directly into TARGET as it may get overwritten when we
3530 restore the argument save area below. Don't work too
3531 hard though and simply force TARGET to a register if it
3532 is a MEM; the optimizer is quite likely to sort it out. */
3533 if (ACCUMULATE_OUTGOING_ARGS && pass && MEM_P (target))
3534 for (i = 0; i < num_actuals; i++)
3535 if (args[i].save_area)
3536 {
3537 may_overlap = true;
3538 break;
3539 }
3540
3541 if (may_overlap)
3542 target = copy_to_reg (valreg);
3543 else
3544 {
3545 /* TARGET and VALREG cannot be equal at this point
3546 because the latter would not have
3547 REG_FUNCTION_VALUE_P true, while the former would if
3548 it were referring to the same register.
3549
3550 If they refer to the same register, this move will be
3551 a no-op, except when function inlining is being
3552 done. */
3553 emit_move_insn (target, valreg);
3554
3555 /* If we are setting a MEM, this code must be executed.
3556 Since it is emitted after the call insn, sibcall
3557 optimization cannot be performed in that case. */
3558 if (MEM_P (target))
3559 sibcall_failure = 1;
3560 }
3561 }
3562 else
3563 target = copy_to_reg (avoid_likely_spilled_reg (valreg));
3564
3565 /* If we promoted this return value, make the proper SUBREG.
3566 TARGET might be const0_rtx here, so be careful. */
3567 if (REG_P (target)
3568 && TYPE_MODE (rettype) != BLKmode
3569 && GET_MODE (target) != TYPE_MODE (rettype))
3570 {
3571 tree type = rettype;
3572 int unsignedp = TYPE_UNSIGNED (type);
3573 int offset = 0;
3574 machine_mode pmode;
3575
3576 /* Ensure we promote as expected, and get the new unsignedness. */
3577 pmode = promote_function_mode (type, TYPE_MODE (type), &unsignedp,
3578 funtype, 1);
3579 gcc_assert (GET_MODE (target) == pmode);
3580
3581 if ((WORDS_BIG_ENDIAN || BYTES_BIG_ENDIAN)
3582 && (GET_MODE_SIZE (GET_MODE (target))
3583 > GET_MODE_SIZE (TYPE_MODE (type))))
3584 {
3585 offset = GET_MODE_SIZE (GET_MODE (target))
3586 - GET_MODE_SIZE (TYPE_MODE (type));
3587 if (! BYTES_BIG_ENDIAN)
3588 offset = (offset / UNITS_PER_WORD) * UNITS_PER_WORD;
3589 else if (! WORDS_BIG_ENDIAN)
3590 offset %= UNITS_PER_WORD;
3591 }
3592
3593 target = gen_rtx_SUBREG (TYPE_MODE (type), target, offset);
3594 SUBREG_PROMOTED_VAR_P (target) = 1;
3595 SUBREG_PROMOTED_SET (target, unsignedp);
3596 }
3597
3598 /* If size of args is variable or this was a constructor call for a stack
3599 argument, restore saved stack-pointer value. */
3600
3601 if (old_stack_level)
3602 {
3603 rtx_insn *prev = get_last_insn ();
3604
3605 emit_stack_restore (SAVE_BLOCK, old_stack_level);
3606 stack_pointer_delta = old_stack_pointer_delta;
3607
3608 fixup_args_size_notes (prev, get_last_insn (), stack_pointer_delta);
3609
3610 pending_stack_adjust = old_pending_adj;
3611 old_stack_allocated = stack_pointer_delta - pending_stack_adjust;
3612 stack_arg_under_construction = old_stack_arg_under_construction;
3613 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3614 stack_usage_map = initial_stack_usage_map;
3615 sibcall_failure = 1;
3616 }
3617 else if (ACCUMULATE_OUTGOING_ARGS && pass)
3618 {
3619 #ifdef REG_PARM_STACK_SPACE
3620 if (save_area)
3621 restore_fixed_argument_area (save_area, argblock,
3622 high_to_save, low_to_save);
3623 #endif
3624
3625 /* If we saved any argument areas, restore them. */
3626 for (i = 0; i < num_actuals; i++)
3627 if (args[i].save_area)
3628 {
3629 machine_mode save_mode = GET_MODE (args[i].save_area);
3630 rtx stack_area
3631 = gen_rtx_MEM (save_mode,
3632 memory_address (save_mode,
3633 XEXP (args[i].stack_slot, 0)));
3634
3635 if (save_mode != BLKmode)
3636 emit_move_insn (stack_area, args[i].save_area);
3637 else
3638 emit_block_move (stack_area, args[i].save_area,
3639 GEN_INT (args[i].locate.size.constant),
3640 BLOCK_OP_CALL_PARM);
3641 }
3642
3643 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
3644 stack_usage_map = initial_stack_usage_map;
3645 }
3646
3647 /* If this was alloca, record the new stack level. */
3648 if (flags & ECF_MAY_BE_ALLOCA)
3649 record_new_stack_level ();
3650
3651 /* Free up storage we no longer need. */
3652 for (i = 0; i < num_actuals; ++i)
3653 free (args[i].aligned_regs);
3654
3655 targetm.calls.end_call_args ();
3656
3657 insns = get_insns ();
3658 end_sequence ();
3659
3660 if (pass == 0)
3661 {
3662 tail_call_insns = insns;
3663
3664 /* Restore the pending stack adjustment now that we have
3665 finished generating the sibling call sequence. */
3666
3667 restore_pending_stack_adjust (&save);
3668
3669 /* Prepare arg structure for next iteration. */
3670 for (i = 0; i < num_actuals; i++)
3671 {
3672 args[i].value = 0;
3673 args[i].aligned_regs = 0;
3674 args[i].stack = 0;
3675 }
3676
3677 sbitmap_free (stored_args_map);
3678 internal_arg_pointer_exp_state.scan_start = NULL;
3679 internal_arg_pointer_exp_state.cache.release ();
3680 }
3681 else
3682 {
3683 normal_call_insns = insns;
3684
3685 /* Verify that we've deallocated all the stack we used. */
3686 gcc_assert ((flags & ECF_NORETURN)
3687 || (old_stack_allocated
3688 == stack_pointer_delta - pending_stack_adjust));
3689 }
3690
3691 /* If something prevents making this a sibling call,
3692 zero out the sequence. */
3693 if (sibcall_failure)
3694 tail_call_insns = NULL;
3695 else
3696 break;
3697 }
3698
3699 /* If tail call production succeeded, we need to remove REG_EQUIV notes on
3700 arguments too, as argument area is now clobbered by the call. */
3701 if (tail_call_insns)
3702 {
3703 emit_insn (tail_call_insns);
3704 crtl->tail_call_emit = true;
3705 }
3706 else
3707 emit_insn (normal_call_insns);
3708
3709 currently_expanding_call--;
3710
3711 free (stack_usage_map_buf);
3712 free (args);
3713
3714 /* Join result with returned bounds so caller may use them if needed. */
3715 target = chkp_join_splitted_slot (target, valbnd);
3716
3717 return target;
3718 }
3719
3720 /* A sibling call sequence invalidates any REG_EQUIV notes made for
3721 this function's incoming arguments.
3722
3723 At the start of RTL generation we know the only REG_EQUIV notes
3724 in the rtl chain are those for incoming arguments, so we can look
3725 for REG_EQUIV notes between the start of the function and the
3726 NOTE_INSN_FUNCTION_BEG.
3727
3728 This is (slight) overkill. We could keep track of the highest
3729 argument we clobber and be more selective in removing notes, but it
3730 does not seem to be worth the effort. */
3731
3732 void
fixup_tail_calls(void)3733 fixup_tail_calls (void)
3734 {
3735 rtx_insn *insn;
3736
3737 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3738 {
3739 rtx note;
3740
3741 /* There are never REG_EQUIV notes for the incoming arguments
3742 after the NOTE_INSN_FUNCTION_BEG note, so stop if we see it. */
3743 if (NOTE_P (insn)
3744 && NOTE_KIND (insn) == NOTE_INSN_FUNCTION_BEG)
3745 break;
3746
3747 note = find_reg_note (insn, REG_EQUIV, 0);
3748 if (note)
3749 remove_note (insn, note);
3750 note = find_reg_note (insn, REG_EQUIV, 0);
3751 gcc_assert (!note);
3752 }
3753 }
3754
3755 /* Traverse a list of TYPES and expand all complex types into their
3756 components. */
3757 static tree
split_complex_types(tree types)3758 split_complex_types (tree types)
3759 {
3760 tree p;
3761
3762 /* Before allocating memory, check for the common case of no complex. */
3763 for (p = types; p; p = TREE_CHAIN (p))
3764 {
3765 tree type = TREE_VALUE (p);
3766 if (TREE_CODE (type) == COMPLEX_TYPE
3767 && targetm.calls.split_complex_arg (type))
3768 goto found;
3769 }
3770 return types;
3771
3772 found:
3773 types = copy_list (types);
3774
3775 for (p = types; p; p = TREE_CHAIN (p))
3776 {
3777 tree complex_type = TREE_VALUE (p);
3778
3779 if (TREE_CODE (complex_type) == COMPLEX_TYPE
3780 && targetm.calls.split_complex_arg (complex_type))
3781 {
3782 tree next, imag;
3783
3784 /* Rewrite complex type with component type. */
3785 TREE_VALUE (p) = TREE_TYPE (complex_type);
3786 next = TREE_CHAIN (p);
3787
3788 /* Add another component type for the imaginary part. */
3789 imag = build_tree_list (NULL_TREE, TREE_VALUE (p));
3790 TREE_CHAIN (p) = imag;
3791 TREE_CHAIN (imag) = next;
3792
3793 /* Skip the newly created node. */
3794 p = TREE_CHAIN (p);
3795 }
3796 }
3797
3798 return types;
3799 }
3800
3801 /* Output a library call to function FUN (a SYMBOL_REF rtx).
3802 The RETVAL parameter specifies whether return value needs to be saved, other
3803 parameters are documented in the emit_library_call function below. */
3804
3805 static rtx
emit_library_call_value_1(int retval,rtx orgfun,rtx value,enum libcall_type fn_type,machine_mode outmode,int nargs,va_list p)3806 emit_library_call_value_1 (int retval, rtx orgfun, rtx value,
3807 enum libcall_type fn_type,
3808 machine_mode outmode, int nargs, va_list p)
3809 {
3810 /* Total size in bytes of all the stack-parms scanned so far. */
3811 struct args_size args_size;
3812 /* Size of arguments before any adjustments (such as rounding). */
3813 struct args_size original_args_size;
3814 int argnum;
3815 rtx fun;
3816 /* Todo, choose the correct decl type of orgfun. Sadly this information
3817 isn't present here, so we default to native calling abi here. */
3818 tree fndecl ATTRIBUTE_UNUSED = NULL_TREE; /* library calls default to host calling abi ? */
3819 tree fntype ATTRIBUTE_UNUSED = NULL_TREE; /* library calls default to host calling abi ? */
3820 int count;
3821 rtx argblock = 0;
3822 CUMULATIVE_ARGS args_so_far_v;
3823 cumulative_args_t args_so_far;
3824 struct arg
3825 {
3826 rtx value;
3827 machine_mode mode;
3828 rtx reg;
3829 int partial;
3830 struct locate_and_pad_arg_data locate;
3831 rtx save_area;
3832 };
3833 struct arg *argvec;
3834 int old_inhibit_defer_pop = inhibit_defer_pop;
3835 rtx call_fusage = 0;
3836 rtx mem_value = 0;
3837 rtx valreg;
3838 int pcc_struct_value = 0;
3839 int struct_value_size = 0;
3840 int flags;
3841 int reg_parm_stack_space = 0;
3842 int needed;
3843 rtx_insn *before_call;
3844 bool have_push_fusage;
3845 tree tfom; /* type_for_mode (outmode, 0) */
3846
3847 #ifdef REG_PARM_STACK_SPACE
3848 /* Define the boundary of the register parm stack space that needs to be
3849 save, if any. */
3850 int low_to_save = 0, high_to_save = 0;
3851 rtx save_area = 0; /* Place that it is saved. */
3852 #endif
3853
3854 /* Size of the stack reserved for parameter registers. */
3855 int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
3856 char *initial_stack_usage_map = stack_usage_map;
3857 char *stack_usage_map_buf = NULL;
3858
3859 rtx struct_value = targetm.calls.struct_value_rtx (0, 0);
3860
3861 #ifdef REG_PARM_STACK_SPACE
3862 reg_parm_stack_space = REG_PARM_STACK_SPACE ((tree) 0);
3863 #endif
3864
3865 /* By default, library functions cannot throw. */
3866 flags = ECF_NOTHROW;
3867
3868 switch (fn_type)
3869 {
3870 case LCT_NORMAL:
3871 break;
3872 case LCT_CONST:
3873 flags |= ECF_CONST;
3874 break;
3875 case LCT_PURE:
3876 flags |= ECF_PURE;
3877 break;
3878 case LCT_NORETURN:
3879 flags |= ECF_NORETURN;
3880 break;
3881 case LCT_THROW:
3882 flags &= ~ECF_NOTHROW;
3883 break;
3884 case LCT_RETURNS_TWICE:
3885 flags = ECF_RETURNS_TWICE;
3886 break;
3887 }
3888 fun = orgfun;
3889
3890 /* Ensure current function's preferred stack boundary is at least
3891 what we need. */
3892 if (crtl->preferred_stack_boundary < PREFERRED_STACK_BOUNDARY)
3893 crtl->preferred_stack_boundary = PREFERRED_STACK_BOUNDARY;
3894
3895 /* If this kind of value comes back in memory,
3896 decide where in memory it should come back. */
3897 if (outmode != VOIDmode)
3898 {
3899 tfom = lang_hooks.types.type_for_mode (outmode, 0);
3900 if (aggregate_value_p (tfom, 0))
3901 {
3902 #ifdef PCC_STATIC_STRUCT_RETURN
3903 rtx pointer_reg
3904 = hard_function_value (build_pointer_type (tfom), 0, 0, 0);
3905 mem_value = gen_rtx_MEM (outmode, pointer_reg);
3906 pcc_struct_value = 1;
3907 if (value == 0)
3908 value = gen_reg_rtx (outmode);
3909 #else /* not PCC_STATIC_STRUCT_RETURN */
3910 struct_value_size = GET_MODE_SIZE (outmode);
3911 if (value != 0 && MEM_P (value))
3912 mem_value = value;
3913 else
3914 mem_value = assign_temp (tfom, 1, 1);
3915 #endif
3916 /* This call returns a big structure. */
3917 flags &= ~(ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
3918 }
3919 }
3920 else
3921 tfom = void_type_node;
3922
3923 /* ??? Unfinished: must pass the memory address as an argument. */
3924
3925 /* Copy all the libcall-arguments out of the varargs data
3926 and into a vector ARGVEC.
3927
3928 Compute how to pass each argument. We only support a very small subset
3929 of the full argument passing conventions to limit complexity here since
3930 library functions shouldn't have many args. */
3931
3932 argvec = XALLOCAVEC (struct arg, nargs + 1);
3933 memset (argvec, 0, (nargs + 1) * sizeof (struct arg));
3934
3935 #ifdef INIT_CUMULATIVE_LIBCALL_ARGS
3936 INIT_CUMULATIVE_LIBCALL_ARGS (args_so_far_v, outmode, fun);
3937 #else
3938 INIT_CUMULATIVE_ARGS (args_so_far_v, NULL_TREE, fun, 0, nargs);
3939 #endif
3940 args_so_far = pack_cumulative_args (&args_so_far_v);
3941
3942 args_size.constant = 0;
3943 args_size.var = 0;
3944
3945 count = 0;
3946
3947 push_temp_slots ();
3948
3949 /* If there's a structure value address to be passed,
3950 either pass it in the special place, or pass it as an extra argument. */
3951 if (mem_value && struct_value == 0 && ! pcc_struct_value)
3952 {
3953 rtx addr = XEXP (mem_value, 0);
3954
3955 nargs++;
3956
3957 /* Make sure it is a reasonable operand for a move or push insn. */
3958 if (!REG_P (addr) && !MEM_P (addr)
3959 && !(CONSTANT_P (addr)
3960 && targetm.legitimate_constant_p (Pmode, addr)))
3961 addr = force_operand (addr, NULL_RTX);
3962
3963 argvec[count].value = addr;
3964 argvec[count].mode = Pmode;
3965 argvec[count].partial = 0;
3966
3967 argvec[count].reg = targetm.calls.function_arg (args_so_far,
3968 Pmode, NULL_TREE, true);
3969 gcc_assert (targetm.calls.arg_partial_bytes (args_so_far, Pmode,
3970 NULL_TREE, 1) == 0);
3971
3972 locate_and_pad_parm (Pmode, NULL_TREE,
3973 #ifdef STACK_PARMS_IN_REG_PARM_AREA
3974 1,
3975 #else
3976 argvec[count].reg != 0,
3977 #endif
3978 reg_parm_stack_space, 0,
3979 NULL_TREE, &args_size, &argvec[count].locate);
3980
3981 if (argvec[count].reg == 0 || argvec[count].partial != 0
3982 || reg_parm_stack_space > 0)
3983 args_size.constant += argvec[count].locate.size.constant;
3984
3985 targetm.calls.function_arg_advance (args_so_far, Pmode, (tree) 0, true);
3986
3987 count++;
3988 }
3989
3990 for (; count < nargs; count++)
3991 {
3992 rtx val = va_arg (p, rtx);
3993 machine_mode mode = (machine_mode) va_arg (p, int);
3994 int unsigned_p = 0;
3995
3996 /* We cannot convert the arg value to the mode the library wants here;
3997 must do it earlier where we know the signedness of the arg. */
3998 gcc_assert (mode != BLKmode
3999 && (GET_MODE (val) == mode || GET_MODE (val) == VOIDmode));
4000
4001 /* Make sure it is a reasonable operand for a move or push insn. */
4002 if (!REG_P (val) && !MEM_P (val)
4003 && !(CONSTANT_P (val) && targetm.legitimate_constant_p (mode, val)))
4004 val = force_operand (val, NULL_RTX);
4005
4006 if (pass_by_reference (&args_so_far_v, mode, NULL_TREE, 1))
4007 {
4008 rtx slot;
4009 int must_copy
4010 = !reference_callee_copied (&args_so_far_v, mode, NULL_TREE, 1);
4011
4012 /* If this was a CONST function, it is now PURE since it now
4013 reads memory. */
4014 if (flags & ECF_CONST)
4015 {
4016 flags &= ~ECF_CONST;
4017 flags |= ECF_PURE;
4018 }
4019
4020 if (MEM_P (val) && !must_copy)
4021 {
4022 tree val_expr = MEM_EXPR (val);
4023 if (val_expr)
4024 mark_addressable (val_expr);
4025 slot = val;
4026 }
4027 else
4028 {
4029 slot = assign_temp (lang_hooks.types.type_for_mode (mode, 0),
4030 1, 1);
4031 emit_move_insn (slot, val);
4032 }
4033
4034 call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
4035 gen_rtx_USE (VOIDmode, slot),
4036 call_fusage);
4037 if (must_copy)
4038 call_fusage = gen_rtx_EXPR_LIST (VOIDmode,
4039 gen_rtx_CLOBBER (VOIDmode,
4040 slot),
4041 call_fusage);
4042
4043 mode = Pmode;
4044 val = force_operand (XEXP (slot, 0), NULL_RTX);
4045 }
4046
4047 mode = promote_function_mode (NULL_TREE, mode, &unsigned_p, NULL_TREE, 0);
4048 argvec[count].mode = mode;
4049 argvec[count].value = convert_modes (mode, GET_MODE (val), val, unsigned_p);
4050 argvec[count].reg = targetm.calls.function_arg (args_so_far, mode,
4051 NULL_TREE, true);
4052
4053 argvec[count].partial
4054 = targetm.calls.arg_partial_bytes (args_so_far, mode, NULL_TREE, 1);
4055
4056 if (argvec[count].reg == 0
4057 || argvec[count].partial != 0
4058 || reg_parm_stack_space > 0)
4059 {
4060 locate_and_pad_parm (mode, NULL_TREE,
4061 #ifdef STACK_PARMS_IN_REG_PARM_AREA
4062 1,
4063 #else
4064 argvec[count].reg != 0,
4065 #endif
4066 reg_parm_stack_space, argvec[count].partial,
4067 NULL_TREE, &args_size, &argvec[count].locate);
4068 args_size.constant += argvec[count].locate.size.constant;
4069 gcc_assert (!argvec[count].locate.size.var);
4070 }
4071 #ifdef BLOCK_REG_PADDING
4072 else
4073 /* The argument is passed entirely in registers. See at which
4074 end it should be padded. */
4075 argvec[count].locate.where_pad =
4076 BLOCK_REG_PADDING (mode, NULL_TREE,
4077 GET_MODE_SIZE (mode) <= UNITS_PER_WORD);
4078 #endif
4079
4080 targetm.calls.function_arg_advance (args_so_far, mode, (tree) 0, true);
4081 }
4082
4083 /* If this machine requires an external definition for library
4084 functions, write one out. */
4085 assemble_external_libcall (fun);
4086
4087 original_args_size = args_size;
4088 args_size.constant = (((args_size.constant
4089 + stack_pointer_delta
4090 + STACK_BYTES - 1)
4091 / STACK_BYTES
4092 * STACK_BYTES)
4093 - stack_pointer_delta);
4094
4095 args_size.constant = MAX (args_size.constant,
4096 reg_parm_stack_space);
4097
4098 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
4099 args_size.constant -= reg_parm_stack_space;
4100
4101 if (args_size.constant > crtl->outgoing_args_size)
4102 crtl->outgoing_args_size = args_size.constant;
4103
4104 if (flag_stack_usage_info && !ACCUMULATE_OUTGOING_ARGS)
4105 {
4106 int pushed = args_size.constant + pending_stack_adjust;
4107 if (pushed > current_function_pushed_stack_size)
4108 current_function_pushed_stack_size = pushed;
4109 }
4110
4111 if (ACCUMULATE_OUTGOING_ARGS)
4112 {
4113 /* Since the stack pointer will never be pushed, it is possible for
4114 the evaluation of a parm to clobber something we have already
4115 written to the stack. Since most function calls on RISC machines
4116 do not use the stack, this is uncommon, but must work correctly.
4117
4118 Therefore, we save any area of the stack that was already written
4119 and that we are using. Here we set up to do this by making a new
4120 stack usage map from the old one.
4121
4122 Another approach might be to try to reorder the argument
4123 evaluations to avoid this conflicting stack usage. */
4124
4125 needed = args_size.constant;
4126
4127 /* Since we will be writing into the entire argument area, the
4128 map must be allocated for its entire size, not just the part that
4129 is the responsibility of the caller. */
4130 if (! OUTGOING_REG_PARM_STACK_SPACE ((!fndecl ? fntype : TREE_TYPE (fndecl))))
4131 needed += reg_parm_stack_space;
4132
4133 if (ARGS_GROW_DOWNWARD)
4134 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
4135 needed + 1);
4136 else
4137 highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use, needed);
4138
4139 stack_usage_map_buf = XNEWVEC (char, highest_outgoing_arg_in_use);
4140 stack_usage_map = stack_usage_map_buf;
4141
4142 if (initial_highest_arg_in_use)
4143 memcpy (stack_usage_map, initial_stack_usage_map,
4144 initial_highest_arg_in_use);
4145
4146 if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
4147 memset (&stack_usage_map[initial_highest_arg_in_use], 0,
4148 highest_outgoing_arg_in_use - initial_highest_arg_in_use);
4149 needed = 0;
4150
4151 /* We must be careful to use virtual regs before they're instantiated,
4152 and real regs afterwards. Loop optimization, for example, can create
4153 new libcalls after we've instantiated the virtual regs, and if we
4154 use virtuals anyway, they won't match the rtl patterns. */
4155
4156 if (virtuals_instantiated)
4157 argblock = plus_constant (Pmode, stack_pointer_rtx,
4158 STACK_POINTER_OFFSET);
4159 else
4160 argblock = virtual_outgoing_args_rtx;
4161 }
4162 else
4163 {
4164 if (!PUSH_ARGS)
4165 argblock = push_block (GEN_INT (args_size.constant), 0, 0);
4166 }
4167
4168 /* We push args individually in reverse order, perform stack alignment
4169 before the first push (the last arg). */
4170 if (argblock == 0)
4171 anti_adjust_stack (GEN_INT (args_size.constant
4172 - original_args_size.constant));
4173
4174 argnum = nargs - 1;
4175
4176 #ifdef REG_PARM_STACK_SPACE
4177 if (ACCUMULATE_OUTGOING_ARGS)
4178 {
4179 /* The argument list is the property of the called routine and it
4180 may clobber it. If the fixed area has been used for previous
4181 parameters, we must save and restore it. */
4182 save_area = save_fixed_argument_area (reg_parm_stack_space, argblock,
4183 &low_to_save, &high_to_save);
4184 }
4185 #endif
4186
4187 /* When expanding a normal call, args are stored in push order,
4188 which is the reverse of what we have here. */
4189 bool any_regs = false;
4190 for (int i = nargs; i-- > 0; )
4191 if (argvec[i].reg != NULL_RTX)
4192 {
4193 targetm.calls.call_args (argvec[i].reg, NULL_TREE);
4194 any_regs = true;
4195 }
4196 if (!any_regs)
4197 targetm.calls.call_args (pc_rtx, NULL_TREE);
4198
4199 /* Push the args that need to be pushed. */
4200
4201 have_push_fusage = false;
4202
4203 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
4204 are to be pushed. */
4205 for (count = 0; count < nargs; count++, argnum--)
4206 {
4207 machine_mode mode = argvec[argnum].mode;
4208 rtx val = argvec[argnum].value;
4209 rtx reg = argvec[argnum].reg;
4210 int partial = argvec[argnum].partial;
4211 unsigned int parm_align = argvec[argnum].locate.boundary;
4212 int lower_bound = 0, upper_bound = 0, i;
4213
4214 if (! (reg != 0 && partial == 0))
4215 {
4216 rtx use;
4217
4218 if (ACCUMULATE_OUTGOING_ARGS)
4219 {
4220 /* If this is being stored into a pre-allocated, fixed-size,
4221 stack area, save any previous data at that location. */
4222
4223 if (ARGS_GROW_DOWNWARD)
4224 {
4225 /* stack_slot is negative, but we want to index stack_usage_map
4226 with positive values. */
4227 upper_bound = -argvec[argnum].locate.slot_offset.constant + 1;
4228 lower_bound = upper_bound - argvec[argnum].locate.size.constant;
4229 }
4230 else
4231 {
4232 lower_bound = argvec[argnum].locate.slot_offset.constant;
4233 upper_bound = lower_bound + argvec[argnum].locate.size.constant;
4234 }
4235
4236 i = lower_bound;
4237 /* Don't worry about things in the fixed argument area;
4238 it has already been saved. */
4239 if (i < reg_parm_stack_space)
4240 i = reg_parm_stack_space;
4241 while (i < upper_bound && stack_usage_map[i] == 0)
4242 i++;
4243
4244 if (i < upper_bound)
4245 {
4246 /* We need to make a save area. */
4247 unsigned int size
4248 = argvec[argnum].locate.size.constant * BITS_PER_UNIT;
4249 machine_mode save_mode
4250 = mode_for_size (size, MODE_INT, 1);
4251 rtx adr
4252 = plus_constant (Pmode, argblock,
4253 argvec[argnum].locate.offset.constant);
4254 rtx stack_area
4255 = gen_rtx_MEM (save_mode, memory_address (save_mode, adr));
4256
4257 if (save_mode == BLKmode)
4258 {
4259 argvec[argnum].save_area
4260 = assign_stack_temp (BLKmode,
4261 argvec[argnum].locate.size.constant
4262 );
4263
4264 emit_block_move (validize_mem
4265 (copy_rtx (argvec[argnum].save_area)),
4266 stack_area,
4267 GEN_INT (argvec[argnum].locate.size.constant),
4268 BLOCK_OP_CALL_PARM);
4269 }
4270 else
4271 {
4272 argvec[argnum].save_area = gen_reg_rtx (save_mode);
4273
4274 emit_move_insn (argvec[argnum].save_area, stack_area);
4275 }
4276 }
4277 }
4278
4279 emit_push_insn (val, mode, NULL_TREE, NULL_RTX, parm_align,
4280 partial, reg, 0, argblock,
4281 GEN_INT (argvec[argnum].locate.offset.constant),
4282 reg_parm_stack_space,
4283 ARGS_SIZE_RTX (argvec[argnum].locate.alignment_pad), false);
4284
4285 /* Now mark the segment we just used. */
4286 if (ACCUMULATE_OUTGOING_ARGS)
4287 for (i = lower_bound; i < upper_bound; i++)
4288 stack_usage_map[i] = 1;
4289
4290 NO_DEFER_POP;
4291
4292 /* Indicate argument access so that alias.c knows that these
4293 values are live. */
4294 if (argblock)
4295 use = plus_constant (Pmode, argblock,
4296 argvec[argnum].locate.offset.constant);
4297 else if (have_push_fusage)
4298 continue;
4299 else
4300 {
4301 /* When arguments are pushed, trying to tell alias.c where
4302 exactly this argument is won't work, because the
4303 auto-increment causes confusion. So we merely indicate
4304 that we access something with a known mode somewhere on
4305 the stack. */
4306 use = gen_rtx_PLUS (Pmode, stack_pointer_rtx,
4307 gen_rtx_SCRATCH (Pmode));
4308 have_push_fusage = true;
4309 }
4310 use = gen_rtx_MEM (argvec[argnum].mode, use);
4311 use = gen_rtx_USE (VOIDmode, use);
4312 call_fusage = gen_rtx_EXPR_LIST (VOIDmode, use, call_fusage);
4313 }
4314 }
4315
4316 argnum = nargs - 1;
4317
4318 fun = prepare_call_address (NULL, fun, NULL, &call_fusage, 0, 0);
4319
4320 /* Now load any reg parms into their regs. */
4321
4322 /* ARGNUM indexes the ARGVEC array in the order in which the arguments
4323 are to be pushed. */
4324 for (count = 0; count < nargs; count++, argnum--)
4325 {
4326 machine_mode mode = argvec[argnum].mode;
4327 rtx val = argvec[argnum].value;
4328 rtx reg = argvec[argnum].reg;
4329 int partial = argvec[argnum].partial;
4330 #ifdef BLOCK_REG_PADDING
4331 int size = 0;
4332 #endif
4333
4334 /* Handle calls that pass values in multiple non-contiguous
4335 locations. The PA64 has examples of this for library calls. */
4336 if (reg != 0 && GET_CODE (reg) == PARALLEL)
4337 emit_group_load (reg, val, NULL_TREE, GET_MODE_SIZE (mode));
4338 else if (reg != 0 && partial == 0)
4339 {
4340 emit_move_insn (reg, val);
4341 #ifdef BLOCK_REG_PADDING
4342 size = GET_MODE_SIZE (argvec[argnum].mode);
4343
4344 /* Copied from load_register_parameters. */
4345
4346 /* Handle case where we have a value that needs shifting
4347 up to the msb. eg. a QImode value and we're padding
4348 upward on a BYTES_BIG_ENDIAN machine. */
4349 if (size < UNITS_PER_WORD
4350 && (argvec[argnum].locate.where_pad
4351 == (BYTES_BIG_ENDIAN ? upward : downward)))
4352 {
4353 rtx x;
4354 int shift = (UNITS_PER_WORD - size) * BITS_PER_UNIT;
4355
4356 /* Assigning REG here rather than a temp makes CALL_FUSAGE
4357 report the whole reg as used. Strictly speaking, the
4358 call only uses SIZE bytes at the msb end, but it doesn't
4359 seem worth generating rtl to say that. */
4360 reg = gen_rtx_REG (word_mode, REGNO (reg));
4361 x = expand_shift (LSHIFT_EXPR, word_mode, reg, shift, reg, 1);
4362 if (x != reg)
4363 emit_move_insn (reg, x);
4364 }
4365 #endif
4366 }
4367
4368 NO_DEFER_POP;
4369 }
4370
4371 /* Any regs containing parms remain in use through the call. */
4372 for (count = 0; count < nargs; count++)
4373 {
4374 rtx reg = argvec[count].reg;
4375 if (reg != 0 && GET_CODE (reg) == PARALLEL)
4376 use_group_regs (&call_fusage, reg);
4377 else if (reg != 0)
4378 {
4379 int partial = argvec[count].partial;
4380 if (partial)
4381 {
4382 int nregs;
4383 gcc_assert (partial % UNITS_PER_WORD == 0);
4384 nregs = partial / UNITS_PER_WORD;
4385 use_regs (&call_fusage, REGNO (reg), nregs);
4386 }
4387 else
4388 use_reg (&call_fusage, reg);
4389 }
4390 }
4391
4392 /* Pass the function the address in which to return a structure value. */
4393 if (mem_value != 0 && struct_value != 0 && ! pcc_struct_value)
4394 {
4395 emit_move_insn (struct_value,
4396 force_reg (Pmode,
4397 force_operand (XEXP (mem_value, 0),
4398 NULL_RTX)));
4399 if (REG_P (struct_value))
4400 use_reg (&call_fusage, struct_value);
4401 }
4402
4403 /* Don't allow popping to be deferred, since then
4404 cse'ing of library calls could delete a call and leave the pop. */
4405 NO_DEFER_POP;
4406 valreg = (mem_value == 0 && outmode != VOIDmode
4407 ? hard_libcall_value (outmode, orgfun) : NULL_RTX);
4408
4409 /* Stack must be properly aligned now. */
4410 gcc_assert (!(stack_pointer_delta
4411 & (PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1)));
4412
4413 before_call = get_last_insn ();
4414
4415 /* We pass the old value of inhibit_defer_pop + 1 to emit_call_1, which
4416 will set inhibit_defer_pop to that value. */
4417 /* The return type is needed to decide how many bytes the function pops.
4418 Signedness plays no role in that, so for simplicity, we pretend it's
4419 always signed. We also assume that the list of arguments passed has
4420 no impact, so we pretend it is unknown. */
4421
4422 emit_call_1 (fun, NULL,
4423 get_identifier (XSTR (orgfun, 0)),
4424 build_function_type (tfom, NULL_TREE),
4425 original_args_size.constant, args_size.constant,
4426 struct_value_size,
4427 targetm.calls.function_arg (args_so_far,
4428 VOIDmode, void_type_node, true),
4429 valreg,
4430 old_inhibit_defer_pop + 1, call_fusage, flags, args_so_far);
4431
4432 if (flag_ipa_ra)
4433 {
4434 rtx datum = orgfun;
4435 gcc_assert (GET_CODE (datum) == SYMBOL_REF);
4436 rtx_call_insn *last = last_call_insn ();
4437 add_reg_note (last, REG_CALL_DECL, datum);
4438 }
4439
4440 /* Right-shift returned value if necessary. */
4441 if (!pcc_struct_value
4442 && TYPE_MODE (tfom) != BLKmode
4443 && targetm.calls.return_in_msb (tfom))
4444 {
4445 shift_return_value (TYPE_MODE (tfom), false, valreg);
4446 valreg = gen_rtx_REG (TYPE_MODE (tfom), REGNO (valreg));
4447 }
4448
4449 targetm.calls.end_call_args ();
4450
4451 /* For calls to `setjmp', etc., inform function.c:setjmp_warnings
4452 that it should complain if nonvolatile values are live. For
4453 functions that cannot return, inform flow that control does not
4454 fall through. */
4455 if (flags & ECF_NORETURN)
4456 {
4457 /* The barrier note must be emitted
4458 immediately after the CALL_INSN. Some ports emit more than
4459 just a CALL_INSN above, so we must search for it here. */
4460 rtx_insn *last = get_last_insn ();
4461 while (!CALL_P (last))
4462 {
4463 last = PREV_INSN (last);
4464 /* There was no CALL_INSN? */
4465 gcc_assert (last != before_call);
4466 }
4467
4468 emit_barrier_after (last);
4469 }
4470
4471 /* Consider that "regular" libcalls, i.e. all of them except for LCT_THROW
4472 and LCT_RETURNS_TWICE, cannot perform non-local gotos. */
4473 if (flags & ECF_NOTHROW)
4474 {
4475 rtx_insn *last = get_last_insn ();
4476 while (!CALL_P (last))
4477 {
4478 last = PREV_INSN (last);
4479 /* There was no CALL_INSN? */
4480 gcc_assert (last != before_call);
4481 }
4482
4483 make_reg_eh_region_note_nothrow_nononlocal (last);
4484 }
4485
4486 /* Now restore inhibit_defer_pop to its actual original value. */
4487 OK_DEFER_POP;
4488
4489 pop_temp_slots ();
4490
4491 /* Copy the value to the right place. */
4492 if (outmode != VOIDmode && retval)
4493 {
4494 if (mem_value)
4495 {
4496 if (value == 0)
4497 value = mem_value;
4498 if (value != mem_value)
4499 emit_move_insn (value, mem_value);
4500 }
4501 else if (GET_CODE (valreg) == PARALLEL)
4502 {
4503 if (value == 0)
4504 value = gen_reg_rtx (outmode);
4505 emit_group_store (value, valreg, NULL_TREE, GET_MODE_SIZE (outmode));
4506 }
4507 else
4508 {
4509 /* Convert to the proper mode if a promotion has been active. */
4510 if (GET_MODE (valreg) != outmode)
4511 {
4512 int unsignedp = TYPE_UNSIGNED (tfom);
4513
4514 gcc_assert (promote_function_mode (tfom, outmode, &unsignedp,
4515 fndecl ? TREE_TYPE (fndecl) : fntype, 1)
4516 == GET_MODE (valreg));
4517 valreg = convert_modes (outmode, GET_MODE (valreg), valreg, 0);
4518 }
4519
4520 if (value != 0)
4521 emit_move_insn (value, valreg);
4522 else
4523 value = valreg;
4524 }
4525 }
4526
4527 if (ACCUMULATE_OUTGOING_ARGS)
4528 {
4529 #ifdef REG_PARM_STACK_SPACE
4530 if (save_area)
4531 restore_fixed_argument_area (save_area, argblock,
4532 high_to_save, low_to_save);
4533 #endif
4534
4535 /* If we saved any argument areas, restore them. */
4536 for (count = 0; count < nargs; count++)
4537 if (argvec[count].save_area)
4538 {
4539 machine_mode save_mode = GET_MODE (argvec[count].save_area);
4540 rtx adr = plus_constant (Pmode, argblock,
4541 argvec[count].locate.offset.constant);
4542 rtx stack_area = gen_rtx_MEM (save_mode,
4543 memory_address (save_mode, adr));
4544
4545 if (save_mode == BLKmode)
4546 emit_block_move (stack_area,
4547 validize_mem
4548 (copy_rtx (argvec[count].save_area)),
4549 GEN_INT (argvec[count].locate.size.constant),
4550 BLOCK_OP_CALL_PARM);
4551 else
4552 emit_move_insn (stack_area, argvec[count].save_area);
4553 }
4554
4555 highest_outgoing_arg_in_use = initial_highest_arg_in_use;
4556 stack_usage_map = initial_stack_usage_map;
4557 }
4558
4559 free (stack_usage_map_buf);
4560
4561 return value;
4562
4563 }
4564
4565 /* Output a library call to function FUN (a SYMBOL_REF rtx)
4566 (emitting the queue unless NO_QUEUE is nonzero),
4567 for a value of mode OUTMODE,
4568 with NARGS different arguments, passed as alternating rtx values
4569 and machine_modes to convert them to.
4570
4571 FN_TYPE should be LCT_NORMAL for `normal' calls, LCT_CONST for
4572 `const' calls, LCT_PURE for `pure' calls, or other LCT_ value for
4573 other types of library calls. */
4574
4575 void
emit_library_call(rtx orgfun,enum libcall_type fn_type,machine_mode outmode,int nargs,...)4576 emit_library_call (rtx orgfun, enum libcall_type fn_type,
4577 machine_mode outmode, int nargs, ...)
4578 {
4579 va_list p;
4580
4581 va_start (p, nargs);
4582 emit_library_call_value_1 (0, orgfun, NULL_RTX, fn_type, outmode, nargs, p);
4583 va_end (p);
4584 }
4585
4586 /* Like emit_library_call except that an extra argument, VALUE,
4587 comes second and says where to store the result.
4588 (If VALUE is zero, this function chooses a convenient way
4589 to return the value.
4590
4591 This function returns an rtx for where the value is to be found.
4592 If VALUE is nonzero, VALUE is returned. */
4593
4594 rtx
emit_library_call_value(rtx orgfun,rtx value,enum libcall_type fn_type,machine_mode outmode,int nargs,...)4595 emit_library_call_value (rtx orgfun, rtx value,
4596 enum libcall_type fn_type,
4597 machine_mode outmode, int nargs, ...)
4598 {
4599 rtx result;
4600 va_list p;
4601
4602 va_start (p, nargs);
4603 result = emit_library_call_value_1 (1, orgfun, value, fn_type, outmode,
4604 nargs, p);
4605 va_end (p);
4606
4607 return result;
4608 }
4609
4610
4611 /* Store pointer bounds argument ARG into Bounds Table entry
4612 associated with PARM. */
4613 static void
store_bounds(struct arg_data * arg,struct arg_data * parm)4614 store_bounds (struct arg_data *arg, struct arg_data *parm)
4615 {
4616 rtx slot = NULL, ptr = NULL, addr = NULL;
4617
4618 /* We may pass bounds not associated with any pointer. */
4619 if (!parm)
4620 {
4621 gcc_assert (arg->special_slot);
4622 slot = arg->special_slot;
4623 ptr = const0_rtx;
4624 }
4625 /* Find pointer associated with bounds and where it is
4626 passed. */
4627 else
4628 {
4629 if (!parm->reg)
4630 {
4631 gcc_assert (!arg->special_slot);
4632
4633 addr = adjust_address (parm->stack, Pmode, arg->pointer_offset);
4634 }
4635 else if (REG_P (parm->reg))
4636 {
4637 gcc_assert (arg->special_slot);
4638 slot = arg->special_slot;
4639
4640 if (MEM_P (parm->value))
4641 addr = adjust_address (parm->value, Pmode, arg->pointer_offset);
4642 else if (REG_P (parm->value))
4643 ptr = gen_rtx_SUBREG (Pmode, parm->value, arg->pointer_offset);
4644 else
4645 {
4646 gcc_assert (!arg->pointer_offset);
4647 ptr = parm->value;
4648 }
4649 }
4650 else
4651 {
4652 gcc_assert (GET_CODE (parm->reg) == PARALLEL);
4653
4654 gcc_assert (arg->special_slot);
4655 slot = arg->special_slot;
4656
4657 if (parm->parallel_value)
4658 ptr = chkp_get_value_with_offs (parm->parallel_value,
4659 GEN_INT (arg->pointer_offset));
4660 else
4661 gcc_unreachable ();
4662 }
4663 }
4664
4665 /* Expand bounds. */
4666 if (!arg->value)
4667 arg->value = expand_normal (arg->tree_value);
4668
4669 targetm.calls.store_bounds_for_arg (ptr, addr, arg->value, slot);
4670 }
4671
4672 /* Store a single argument for a function call
4673 into the register or memory area where it must be passed.
4674 *ARG describes the argument value and where to pass it.
4675
4676 ARGBLOCK is the address of the stack-block for all the arguments,
4677 or 0 on a machine where arguments are pushed individually.
4678
4679 MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
4680 so must be careful about how the stack is used.
4681
4682 VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
4683 argument stack. This is used if ACCUMULATE_OUTGOING_ARGS to indicate
4684 that we need not worry about saving and restoring the stack.
4685
4686 FNDECL is the declaration of the function we are calling.
4687
4688 Return nonzero if this arg should cause sibcall failure,
4689 zero otherwise. */
4690
4691 static int
store_one_arg(struct arg_data * arg,rtx argblock,int flags,int variable_size ATTRIBUTE_UNUSED,int reg_parm_stack_space)4692 store_one_arg (struct arg_data *arg, rtx argblock, int flags,
4693 int variable_size ATTRIBUTE_UNUSED, int reg_parm_stack_space)
4694 {
4695 tree pval = arg->tree_value;
4696 rtx reg = 0;
4697 int partial = 0;
4698 int used = 0;
4699 int i, lower_bound = 0, upper_bound = 0;
4700 int sibcall_failure = 0;
4701
4702 if (TREE_CODE (pval) == ERROR_MARK)
4703 return 1;
4704
4705 /* Push a new temporary level for any temporaries we make for
4706 this argument. */
4707 push_temp_slots ();
4708
4709 if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL))
4710 {
4711 /* If this is being stored into a pre-allocated, fixed-size, stack area,
4712 save any previous data at that location. */
4713 if (argblock && ! variable_size && arg->stack)
4714 {
4715 if (ARGS_GROW_DOWNWARD)
4716 {
4717 /* stack_slot is negative, but we want to index stack_usage_map
4718 with positive values. */
4719 if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
4720 upper_bound = -INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1)) + 1;
4721 else
4722 upper_bound = 0;
4723
4724 lower_bound = upper_bound - arg->locate.size.constant;
4725 }
4726 else
4727 {
4728 if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
4729 lower_bound = INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1));
4730 else
4731 lower_bound = 0;
4732
4733 upper_bound = lower_bound + arg->locate.size.constant;
4734 }
4735
4736 i = lower_bound;
4737 /* Don't worry about things in the fixed argument area;
4738 it has already been saved. */
4739 if (i < reg_parm_stack_space)
4740 i = reg_parm_stack_space;
4741 while (i < upper_bound && stack_usage_map[i] == 0)
4742 i++;
4743
4744 if (i < upper_bound)
4745 {
4746 /* We need to make a save area. */
4747 unsigned int size = arg->locate.size.constant * BITS_PER_UNIT;
4748 machine_mode save_mode = mode_for_size (size, MODE_INT, 1);
4749 rtx adr = memory_address (save_mode, XEXP (arg->stack_slot, 0));
4750 rtx stack_area = gen_rtx_MEM (save_mode, adr);
4751
4752 if (save_mode == BLKmode)
4753 {
4754 arg->save_area
4755 = assign_temp (TREE_TYPE (arg->tree_value), 1, 1);
4756 preserve_temp_slots (arg->save_area);
4757 emit_block_move (validize_mem (copy_rtx (arg->save_area)),
4758 stack_area,
4759 GEN_INT (arg->locate.size.constant),
4760 BLOCK_OP_CALL_PARM);
4761 }
4762 else
4763 {
4764 arg->save_area = gen_reg_rtx (save_mode);
4765 emit_move_insn (arg->save_area, stack_area);
4766 }
4767 }
4768 }
4769 }
4770
4771 /* If this isn't going to be placed on both the stack and in registers,
4772 set up the register and number of words. */
4773 if (! arg->pass_on_stack)
4774 {
4775 if (flags & ECF_SIBCALL)
4776 reg = arg->tail_call_reg;
4777 else
4778 reg = arg->reg;
4779 partial = arg->partial;
4780 }
4781
4782 /* Being passed entirely in a register. We shouldn't be called in
4783 this case. */
4784 gcc_assert (reg == 0 || partial != 0);
4785
4786 /* If this arg needs special alignment, don't load the registers
4787 here. */
4788 if (arg->n_aligned_regs != 0)
4789 reg = 0;
4790
4791 /* If this is being passed partially in a register, we can't evaluate
4792 it directly into its stack slot. Otherwise, we can. */
4793 if (arg->value == 0)
4794 {
4795 /* stack_arg_under_construction is nonzero if a function argument is
4796 being evaluated directly into the outgoing argument list and
4797 expand_call must take special action to preserve the argument list
4798 if it is called recursively.
4799
4800 For scalar function arguments stack_usage_map is sufficient to
4801 determine which stack slots must be saved and restored. Scalar
4802 arguments in general have pass_on_stack == 0.
4803
4804 If this argument is initialized by a function which takes the
4805 address of the argument (a C++ constructor or a C function
4806 returning a BLKmode structure), then stack_usage_map is
4807 insufficient and expand_call must push the stack around the
4808 function call. Such arguments have pass_on_stack == 1.
4809
4810 Note that it is always safe to set stack_arg_under_construction,
4811 but this generates suboptimal code if set when not needed. */
4812
4813 if (arg->pass_on_stack)
4814 stack_arg_under_construction++;
4815
4816 arg->value = expand_expr (pval,
4817 (partial
4818 || TYPE_MODE (TREE_TYPE (pval)) != arg->mode)
4819 ? NULL_RTX : arg->stack,
4820 VOIDmode, EXPAND_STACK_PARM);
4821
4822 /* If we are promoting object (or for any other reason) the mode
4823 doesn't agree, convert the mode. */
4824
4825 if (arg->mode != TYPE_MODE (TREE_TYPE (pval)))
4826 arg->value = convert_modes (arg->mode, TYPE_MODE (TREE_TYPE (pval)),
4827 arg->value, arg->unsignedp);
4828
4829 if (arg->pass_on_stack)
4830 stack_arg_under_construction--;
4831 }
4832
4833 /* Check for overlap with already clobbered argument area. */
4834 if ((flags & ECF_SIBCALL)
4835 && MEM_P (arg->value)
4836 && mem_overlaps_already_clobbered_arg_p (XEXP (arg->value, 0),
4837 arg->locate.size.constant))
4838 sibcall_failure = 1;
4839
4840 /* Don't allow anything left on stack from computation
4841 of argument to alloca. */
4842 if (flags & ECF_MAY_BE_ALLOCA)
4843 do_pending_stack_adjust ();
4844
4845 if (arg->value == arg->stack)
4846 /* If the value is already in the stack slot, we are done. */
4847 ;
4848 else if (arg->mode != BLKmode)
4849 {
4850 int size;
4851 unsigned int parm_align;
4852
4853 /* Argument is a scalar, not entirely passed in registers.
4854 (If part is passed in registers, arg->partial says how much
4855 and emit_push_insn will take care of putting it there.)
4856
4857 Push it, and if its size is less than the
4858 amount of space allocated to it,
4859 also bump stack pointer by the additional space.
4860 Note that in C the default argument promotions
4861 will prevent such mismatches. */
4862
4863 size = GET_MODE_SIZE (arg->mode);
4864 /* Compute how much space the push instruction will push.
4865 On many machines, pushing a byte will advance the stack
4866 pointer by a halfword. */
4867 #ifdef PUSH_ROUNDING
4868 size = PUSH_ROUNDING (size);
4869 #endif
4870 used = size;
4871
4872 /* Compute how much space the argument should get:
4873 round up to a multiple of the alignment for arguments. */
4874 if (none != FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)))
4875 used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1)
4876 / (PARM_BOUNDARY / BITS_PER_UNIT))
4877 * (PARM_BOUNDARY / BITS_PER_UNIT));
4878
4879 /* Compute the alignment of the pushed argument. */
4880 parm_align = arg->locate.boundary;
4881 if (FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)) == downward)
4882 {
4883 int pad = used - size;
4884 if (pad)
4885 {
4886 unsigned int pad_align = (pad & -pad) * BITS_PER_UNIT;
4887 parm_align = MIN (parm_align, pad_align);
4888 }
4889 }
4890
4891 /* This isn't already where we want it on the stack, so put it there.
4892 This can either be done with push or copy insns. */
4893 if (!emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), NULL_RTX,
4894 parm_align, partial, reg, used - size, argblock,
4895 ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
4896 ARGS_SIZE_RTX (arg->locate.alignment_pad), true))
4897 sibcall_failure = 1;
4898
4899 /* Unless this is a partially-in-register argument, the argument is now
4900 in the stack. */
4901 if (partial == 0)
4902 arg->value = arg->stack;
4903 }
4904 else
4905 {
4906 /* BLKmode, at least partly to be pushed. */
4907
4908 unsigned int parm_align;
4909 int excess;
4910 rtx size_rtx;
4911
4912 /* Pushing a nonscalar.
4913 If part is passed in registers, PARTIAL says how much
4914 and emit_push_insn will take care of putting it there. */
4915
4916 /* Round its size up to a multiple
4917 of the allocation unit for arguments. */
4918
4919 if (arg->locate.size.var != 0)
4920 {
4921 excess = 0;
4922 size_rtx = ARGS_SIZE_RTX (arg->locate.size);
4923 }
4924 else
4925 {
4926 /* PUSH_ROUNDING has no effect on us, because emit_push_insn
4927 for BLKmode is careful to avoid it. */
4928 excess = (arg->locate.size.constant
4929 - int_size_in_bytes (TREE_TYPE (pval))
4930 + partial);
4931 size_rtx = expand_expr (size_in_bytes (TREE_TYPE (pval)),
4932 NULL_RTX, TYPE_MODE (sizetype),
4933 EXPAND_NORMAL);
4934 }
4935
4936 parm_align = arg->locate.boundary;
4937
4938 /* When an argument is padded down, the block is aligned to
4939 PARM_BOUNDARY, but the actual argument isn't. */
4940 if (FUNCTION_ARG_PADDING (arg->mode, TREE_TYPE (pval)) == downward)
4941 {
4942 if (arg->locate.size.var)
4943 parm_align = BITS_PER_UNIT;
4944 else if (excess)
4945 {
4946 unsigned int excess_align = (excess & -excess) * BITS_PER_UNIT;
4947 parm_align = MIN (parm_align, excess_align);
4948 }
4949 }
4950
4951 if ((flags & ECF_SIBCALL) && MEM_P (arg->value))
4952 {
4953 /* emit_push_insn might not work properly if arg->value and
4954 argblock + arg->locate.offset areas overlap. */
4955 rtx x = arg->value;
4956 int i = 0;
4957
4958 if (XEXP (x, 0) == crtl->args.internal_arg_pointer
4959 || (GET_CODE (XEXP (x, 0)) == PLUS
4960 && XEXP (XEXP (x, 0), 0) ==
4961 crtl->args.internal_arg_pointer
4962 && CONST_INT_P (XEXP (XEXP (x, 0), 1))))
4963 {
4964 if (XEXP (x, 0) != crtl->args.internal_arg_pointer)
4965 i = INTVAL (XEXP (XEXP (x, 0), 1));
4966
4967 /* arg.locate doesn't contain the pretend_args_size offset,
4968 it's part of argblock. Ensure we don't count it in I. */
4969 if (STACK_GROWS_DOWNWARD)
4970 i -= crtl->args.pretend_args_size;
4971 else
4972 i += crtl->args.pretend_args_size;
4973
4974 /* expand_call should ensure this. */
4975 gcc_assert (!arg->locate.offset.var
4976 && arg->locate.size.var == 0
4977 && CONST_INT_P (size_rtx));
4978
4979 if (arg->locate.offset.constant > i)
4980 {
4981 if (arg->locate.offset.constant < i + INTVAL (size_rtx))
4982 sibcall_failure = 1;
4983 }
4984 else if (arg->locate.offset.constant < i)
4985 {
4986 /* Use arg->locate.size.constant instead of size_rtx
4987 because we only care about the part of the argument
4988 on the stack. */
4989 if (i < (arg->locate.offset.constant
4990 + arg->locate.size.constant))
4991 sibcall_failure = 1;
4992 }
4993 else
4994 {
4995 /* Even though they appear to be at the same location,
4996 if part of the outgoing argument is in registers,
4997 they aren't really at the same location. Check for
4998 this by making sure that the incoming size is the
4999 same as the outgoing size. */
5000 if (arg->locate.size.constant != INTVAL (size_rtx))
5001 sibcall_failure = 1;
5002 }
5003 }
5004 }
5005
5006 emit_push_insn (arg->value, arg->mode, TREE_TYPE (pval), size_rtx,
5007 parm_align, partial, reg, excess, argblock,
5008 ARGS_SIZE_RTX (arg->locate.offset), reg_parm_stack_space,
5009 ARGS_SIZE_RTX (arg->locate.alignment_pad), false);
5010
5011 /* Unless this is a partially-in-register argument, the argument is now
5012 in the stack.
5013
5014 ??? Unlike the case above, in which we want the actual
5015 address of the data, so that we can load it directly into a
5016 register, here we want the address of the stack slot, so that
5017 it's properly aligned for word-by-word copying or something
5018 like that. It's not clear that this is always correct. */
5019 if (partial == 0)
5020 arg->value = arg->stack_slot;
5021 }
5022
5023 if (arg->reg && GET_CODE (arg->reg) == PARALLEL)
5024 {
5025 tree type = TREE_TYPE (arg->tree_value);
5026 arg->parallel_value
5027 = emit_group_load_into_temps (arg->reg, arg->value, type,
5028 int_size_in_bytes (type));
5029 }
5030
5031 /* Mark all slots this store used. */
5032 if (ACCUMULATE_OUTGOING_ARGS && !(flags & ECF_SIBCALL)
5033 && argblock && ! variable_size && arg->stack)
5034 for (i = lower_bound; i < upper_bound; i++)
5035 stack_usage_map[i] = 1;
5036
5037 /* Once we have pushed something, pops can't safely
5038 be deferred during the rest of the arguments. */
5039 NO_DEFER_POP;
5040
5041 /* Free any temporary slots made in processing this argument. */
5042 pop_temp_slots ();
5043
5044 return sibcall_failure;
5045 }
5046
5047 /* Nonzero if we do not know how to pass TYPE solely in registers. */
5048
5049 bool
must_pass_in_stack_var_size(machine_mode mode ATTRIBUTE_UNUSED,const_tree type)5050 must_pass_in_stack_var_size (machine_mode mode ATTRIBUTE_UNUSED,
5051 const_tree type)
5052 {
5053 if (!type)
5054 return false;
5055
5056 /* If the type has variable size... */
5057 if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
5058 return true;
5059
5060 /* If the type is marked as addressable (it is required
5061 to be constructed into the stack)... */
5062 if (TREE_ADDRESSABLE (type))
5063 return true;
5064
5065 return false;
5066 }
5067
5068 /* Another version of the TARGET_MUST_PASS_IN_STACK hook. This one
5069 takes trailing padding of a structure into account. */
5070 /* ??? Should be able to merge these two by examining BLOCK_REG_PADDING. */
5071
5072 bool
must_pass_in_stack_var_size_or_pad(machine_mode mode,const_tree type)5073 must_pass_in_stack_var_size_or_pad (machine_mode mode, const_tree type)
5074 {
5075 if (!type)
5076 return false;
5077
5078 /* If the type has variable size... */
5079 if (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
5080 return true;
5081
5082 /* If the type is marked as addressable (it is required
5083 to be constructed into the stack)... */
5084 if (TREE_ADDRESSABLE (type))
5085 return true;
5086
5087 /* If the padding and mode of the type is such that a copy into
5088 a register would put it into the wrong part of the register. */
5089 if (mode == BLKmode
5090 && int_size_in_bytes (type) % (PARM_BOUNDARY / BITS_PER_UNIT)
5091 && (FUNCTION_ARG_PADDING (mode, type)
5092 == (BYTES_BIG_ENDIAN ? upward : downward)))
5093 return true;
5094
5095 return false;
5096 }
5097