![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to calls.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to calls.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Convert function calls to rtl insns, for GNU C compiler.
2: Copyright (C) 1989, 1992 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20: #include "config.h"
21: #include "rtl.h"
22: #include "tree.h"
23: #include "flags.h"
24: #include "expr.h"
25: #include "insn-flags.h"
26:
27: /* Decide whether a function's arguments should be processed
28: from first to last or from last to first. */
29:
30: #ifdef STACK_GROWS_DOWNWARD
31: #ifdef PUSH_ROUNDING
32: #define PUSH_ARGS_REVERSED /* If it's last to first */
33: #endif
34: #endif
35:
36: /* Like STACK_BOUNDARY but in units of bytes, not bits. */
37: #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
38:
39: /* Data structure and subroutines used within expand_call. */
40:
41: struct arg_data
42: {
43: /* Tree node for this argument. */
44: tree tree_value;
45: /* Current RTL value for argument, or 0 if it isn't precomputed. */
46: rtx value;
47: /* Initially-compute RTL value for argument; only for const functions. */
48: rtx initial_value;
49: /* Register to pass this argument in, 0 if passed on stack, or an
50: EXPR_LIST if the arg is to be copied into multiple different
51: registers. */
52: rtx reg;
53: /* Number of registers to use. 0 means put the whole arg in registers.
54: Also 0 if not passed in registers. */
55: int partial;
1.1.1.3 ! root 56: /* Non-zero if argument must be passed on stack.
! 57: Note that some arguments may be passed on the stack
! 58: even though pass_on_stack is zero, just because FUNCTION_ARG says so.
! 59: pass_on_stack identifies arguments that *cannot* go in registers. */
1.1 root 60: int pass_on_stack;
61: /* Offset of this argument from beginning of stack-args. */
62: struct args_size offset;
63: /* Similar, but offset to the start of the stack slot. Different from
64: OFFSET if this arg pads downward. */
65: struct args_size slot_offset;
66: /* Size of this argument on the stack, rounded up for any padding it gets,
67: parts of the argument passed in registers do not count.
68: If REG_PARM_STACK_SPACE is defined, then register parms
69: are counted here as well. */
70: struct args_size size;
71: /* Location on the stack at which parameter should be stored. The store
72: has already been done if STACK == VALUE. */
73: rtx stack;
74: /* Location on the stack of the start of this argument slot. This can
75: differ from STACK if this arg pads downward. This location is known
76: to be aligned to FUNCTION_ARG_BOUNDARY. */
77: rtx stack_slot;
78: #ifdef ACCUMULATE_OUTGOING_ARGS
79: /* Place that this stack area has been saved, if needed. */
80: rtx save_area;
81: #endif
82: };
83:
84: #ifdef ACCUMULATE_OUTGOING_ARGS
85: /* A vector of one char per word of stack space. A byte if non-zero if
86: the corresponding stack location has been used.
87: This vector is used to prevent a function call within an argument from
88: clobbering any stack already set up. */
89: static char *stack_usage_map;
90:
91: /* Size of STACK_USAGE_MAP. */
92: static int highest_outgoing_arg_in_use;
1.1.1.3 ! root 93:
! 94: /* stack_arg_under_construction is nonzero when an argument may be
! 95: initialized with a constructor call (including a C function that
! 96: returns a BLKmode struct) and expand_call must take special action
! 97: to make sure the object being constructed does not overlap the
! 98: argument list for the constructor call. */
! 99: int stack_arg_under_construction;
1.1 root 100: #endif
101:
102: static void store_one_arg ();
103: extern enum machine_mode mode_for_size ();
104:
105: /* Return 1 if EXP contains a call to the built-in function `alloca'. */
106:
107: static int
108: calls_alloca (exp)
109: tree exp;
110: {
111: register int i;
112: int type = TREE_CODE_CLASS (TREE_CODE (exp));
113: int length = tree_code_length[(int) TREE_CODE (exp)];
114:
115: /* Only expressions and references can contain calls. */
116:
117: if (type != 'e' && type != '<' && type != '1' && type != '2' && type != 'r')
118: return 0;
119:
120: switch (TREE_CODE (exp))
121: {
122: case CALL_EXPR:
123: if (TREE_CODE (TREE_OPERAND (exp, 0)) == ADDR_EXPR
124: && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
125: == FUNCTION_DECL)
126: && DECL_BUILT_IN (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
127: && (DECL_FUNCTION_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0))
128: == BUILT_IN_ALLOCA))
129: return 1;
130:
131: /* Third operand is RTL. */
132: length = 2;
133: break;
134:
135: case SAVE_EXPR:
136: if (SAVE_EXPR_RTL (exp) != 0)
137: return 0;
138: break;
139:
140: case BLOCK:
141: /* Must not look at BLOCK_SUPERCONTEXT since it will point back to
142: us. */
143: length = 3;
144: break;
145:
146: case METHOD_CALL_EXPR:
147: length = 3;
148: break;
149:
150: case WITH_CLEANUP_EXPR:
151: length = 1;
152: break;
153:
154: case RTL_EXPR:
155: return 0;
156: }
157:
158: for (i = 0; i < length; i++)
159: if (TREE_OPERAND (exp, i) != 0
160: && calls_alloca (TREE_OPERAND (exp, i)))
161: return 1;
162:
163: return 0;
164: }
165:
166: /* Force FUNEXP into a form suitable for the address of a CALL,
167: and return that as an rtx. Also load the static chain register
168: if FNDECL is a nested function.
169:
170: USE_INSNS points to a variable holding a chain of USE insns
171: to which a USE of the static chain
172: register should be added, if required. */
173:
174: rtx
175: prepare_call_address (funexp, fndecl, use_insns)
176: rtx funexp;
177: tree fndecl;
178: rtx *use_insns;
179: {
180: rtx static_chain_value = 0;
181:
182: funexp = protect_from_queue (funexp, 0);
183:
184: if (fndecl != 0)
185: /* Get possible static chain value for nested function in C. */
186: static_chain_value = lookup_static_chain (fndecl);
187:
188: /* Make a valid memory address and copy constants thru pseudo-regs,
189: but not for a constant address if -fno-function-cse. */
190: if (GET_CODE (funexp) != SYMBOL_REF)
191: funexp = memory_address (FUNCTION_MODE, funexp);
192: else
193: {
194: #ifndef NO_FUNCTION_CSE
195: if (optimize && ! flag_no_function_cse)
196: #ifdef NO_RECURSIVE_FUNCTION_CSE
197: if (fndecl != current_function_decl)
198: #endif
199: funexp = force_reg (Pmode, funexp);
200: #endif
201: }
202:
203: if (static_chain_value != 0)
204: {
205: emit_move_insn (static_chain_rtx, static_chain_value);
206:
207: /* Put the USE insn in the chain we were passed. It will later be
208: output immediately in front of the CALL insn. */
209: push_to_sequence (*use_insns);
210: emit_insn (gen_rtx (USE, VOIDmode, static_chain_rtx));
211: *use_insns = get_insns ();
212: end_sequence ();
213: }
214:
215: return funexp;
216: }
217:
218: /* Generate instructions to call function FUNEXP,
219: and optionally pop the results.
220: The CALL_INSN is the first insn generated.
221:
222: FUNTYPE is the data type of the function, or, for a library call,
223: the identifier for the name of the call. This is given to the
224: macro RETURN_POPS_ARGS to determine whether this function pops its own args.
225:
226: STACK_SIZE is the number of bytes of arguments on the stack,
227: rounded up to STACK_BOUNDARY; zero if the size is variable.
228: This is both to put into the call insn and
229: to generate explicit popping code if necessary.
230:
231: STRUCT_VALUE_SIZE is the number of bytes wanted in a structure value.
232: It is zero if this call doesn't want a structure value.
233:
234: NEXT_ARG_REG is the rtx that results from executing
235: FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1)
236: just after all the args have had their registers assigned.
237: This could be whatever you like, but normally it is the first
238: arg-register beyond those used for args in this call,
239: or 0 if all the arg-registers are used in this call.
240: It is passed on to `gen_call' so you can put this info in the call insn.
241:
242: VALREG is a hard register in which a value is returned,
243: or 0 if the call does not return a value.
244:
245: OLD_INHIBIT_DEFER_POP is the value that `inhibit_defer_pop' had before
246: the args to this call were processed.
247: We restore `inhibit_defer_pop' to that value.
248:
249: USE_INSNS is a chain of USE insns to be emitted immediately before
250: the actual CALL insn.
251:
252: IS_CONST is true if this is a `const' call. */
253:
254: void
255: emit_call_1 (funexp, funtype, stack_size, struct_value_size, next_arg_reg,
256: valreg, old_inhibit_defer_pop, use_insns, is_const)
257: rtx funexp;
258: tree funtype;
259: int stack_size;
260: int struct_value_size;
261: rtx next_arg_reg;
262: rtx valreg;
263: int old_inhibit_defer_pop;
264: rtx use_insns;
265: int is_const;
266: {
267: rtx stack_size_rtx = gen_rtx (CONST_INT, VOIDmode, stack_size);
268: rtx struct_value_size_rtx = gen_rtx (CONST_INT, VOIDmode, struct_value_size);
269: rtx call_insn;
270: int already_popped = 0;
271:
272: /* Ensure address is valid. SYMBOL_REF is already valid, so no need,
273: and we don't want to load it into a register as an optimization,
274: because prepare_call_address already did it if it should be done. */
275: if (GET_CODE (funexp) != SYMBOL_REF)
276: funexp = memory_address (FUNCTION_MODE, funexp);
277:
278: #ifndef ACCUMULATE_OUTGOING_ARGS
279: #if defined (HAVE_call_pop) && defined (HAVE_call_value_pop)
280: if (HAVE_call_pop && HAVE_call_value_pop
281: && (RETURN_POPS_ARGS (funtype, stack_size) > 0 || stack_size == 0))
282: {
283: rtx n_pop = gen_rtx (CONST_INT, VOIDmode,
284: RETURN_POPS_ARGS (funtype, stack_size));
285: rtx pat;
286:
287: /* If this subroutine pops its own args, record that in the call insn
288: if possible, for the sake of frame pointer elimination. */
289: if (valreg)
290: pat = gen_call_value_pop (valreg,
291: gen_rtx (MEM, FUNCTION_MODE, funexp),
292: stack_size_rtx, next_arg_reg, n_pop);
293: else
294: pat = gen_call_pop (gen_rtx (MEM, FUNCTION_MODE, funexp),
295: stack_size_rtx, next_arg_reg, n_pop);
296:
297: emit_call_insn (pat);
298: already_popped = 1;
299: }
300: else
301: #endif
302: #endif
303:
304: #if defined (HAVE_call) && defined (HAVE_call_value)
305: if (HAVE_call && HAVE_call_value)
306: {
307: if (valreg)
308: emit_call_insn (gen_call_value (valreg,
309: gen_rtx (MEM, FUNCTION_MODE, funexp),
310: stack_size_rtx, next_arg_reg));
311: else
312: emit_call_insn (gen_call (gen_rtx (MEM, FUNCTION_MODE, funexp),
313: stack_size_rtx, next_arg_reg,
314: struct_value_size_rtx));
315: }
316: else
317: #endif
318: abort ();
319:
320: /* Find the CALL insn we just emitted and write the USE insns before it. */
321: for (call_insn = get_last_insn ();
322: call_insn && GET_CODE (call_insn) != CALL_INSN;
323: call_insn = PREV_INSN (call_insn))
324: ;
325:
326: if (! call_insn)
327: abort ();
328:
329: /* Put the USE insns before the CALL. */
330: emit_insns_before (use_insns, call_insn);
331:
332: /* If this is a const call, then set the insn's unchanging bit. */
333: if (is_const)
334: CONST_CALL_P (call_insn) = 1;
335:
336: #ifndef ACCUMULATE_OUTGOING_ARGS
337: /* If returning from the subroutine does not automatically pop the args,
338: we need an instruction to pop them sooner or later.
339: Perhaps do it now; perhaps just record how much space to pop later.
340:
341: If returning from the subroutine does pop the args, indicate that the
342: stack pointer will be changed. */
343:
344: if (stack_size != 0 && RETURN_POPS_ARGS (funtype, stack_size) > 0)
345: {
346: if (!already_popped)
347: emit_insn (gen_rtx (CLOBBER, VOIDmode, stack_pointer_rtx));
348: stack_size -= RETURN_POPS_ARGS (funtype, stack_size);
349: stack_size_rtx = gen_rtx (CONST_INT, VOIDmode, stack_size);
350: }
351:
352: if (stack_size != 0)
353: {
354: if (flag_defer_pop && inhibit_defer_pop == 0)
355: pending_stack_adjust += stack_size;
356: else
357: adjust_stack (stack_size_rtx);
358: }
359: #endif
1.1.1.3 ! root 360:
! 361: inhibit_defer_pop = old_inhibit_defer_pop;
1.1 root 362: }
363:
364: /* Generate all the code for a function call
365: and return an rtx for its value.
366: Store the value in TARGET (specified as an rtx) if convenient.
367: If the value is stored in TARGET then TARGET is returned.
368: If IGNORE is nonzero, then we ignore the value of the function call. */
369:
370: rtx
1.1.1.3 ! root 371: expand_call (exp, target, ignore)
1.1 root 372: tree exp;
373: rtx target;
374: int ignore;
375: {
376: /* List of actual parameters. */
377: tree actparms = TREE_OPERAND (exp, 1);
378: /* RTX for the function to be called. */
379: rtx funexp;
380: /* Tree node for the function to be called (not the address!). */
381: tree funtree;
382: /* Data type of the function. */
383: tree funtype;
384: /* Declaration of the function being called,
385: or 0 if the function is computed (not known by name). */
386: tree fndecl = 0;
387: char *name = 0;
388:
389: /* Register in which non-BLKmode value will be returned,
390: or 0 if no value or if value is BLKmode. */
391: rtx valreg;
392: /* Address where we should return a BLKmode value;
393: 0 if value not BLKmode. */
394: rtx structure_value_addr = 0;
395: /* Nonzero if that address is being passed by treating it as
396: an extra, implicit first parameter. Otherwise,
397: it is passed by being copied directly into struct_value_rtx. */
398: int structure_value_addr_parm = 0;
399: /* Size of aggregate value wanted, or zero if none wanted
400: or if we are using the non-reentrant PCC calling convention
401: or expecting the value in registers. */
402: int struct_value_size = 0;
403: /* Nonzero if called function returns an aggregate in memory PCC style,
404: by returning the address of where to find it. */
405: int pcc_struct_value = 0;
406:
407: /* Number of actual parameters in this call, including struct value addr. */
408: int num_actuals;
409: /* Number of named args. Args after this are anonymous ones
410: and they must all go on the stack. */
411: int n_named_args;
412: /* Count arg position in order args appear. */
413: int argpos;
414:
415: /* Vector of information about each argument.
416: Arguments are numbered in the order they will be pushed,
417: not the order they are written. */
418: struct arg_data *args;
419:
420: /* Total size in bytes of all the stack-parms scanned so far. */
421: struct args_size args_size;
422: /* Size of arguments before any adjustments (such as rounding). */
423: struct args_size original_args_size;
424: /* Data on reg parms scanned so far. */
425: CUMULATIVE_ARGS args_so_far;
426: /* Nonzero if a reg parm has been scanned. */
427: int reg_parm_seen;
428:
429: /* Nonzero if we must avoid push-insns in the args for this call.
430: If stack space is allocated for register parameters, but not by the
431: caller, then it is preallocated in the fixed part of the stack frame.
432: So the entire argument block must then be preallocated (i.e., we
433: ignore PUSH_ROUNDING in that case). */
434:
435: #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
436: int must_preallocate = 1;
437: #else
438: #ifdef PUSH_ROUNDING
439: int must_preallocate = 0;
440: #else
441: int must_preallocate = 1;
442: #endif
443: #endif
444:
1.1.1.3 ! root 445: /* Size of the stack reserved for paramter registers. */
! 446: int reg_parm_stack_space = 0;
! 447:
1.1 root 448: /* 1 if scanning parms front to back, -1 if scanning back to front. */
449: int inc;
450: /* Address of space preallocated for stack parms
451: (on machines that lack push insns), or 0 if space not preallocated. */
452: rtx argblock = 0;
453:
454: /* Nonzero if it is plausible that this is a call to alloca. */
455: int may_be_alloca;
456: /* Nonzero if this is a call to setjmp or a related function. */
457: int returns_twice;
458: /* Nonzero if this is a call to `longjmp'. */
459: int is_longjmp;
460: /* Nonzero if this is a call to an inline function. */
461: int is_integrable = 0;
462: /* Nonzero if this is a call to a `const' function.
463: Note that only explicitly named functions are handled as `const' here. */
464: int is_const = 0;
465: /* Nonzero if this is a call to a `volatile' function. */
466: int is_volatile = 0;
467: #if defined(ACCUMULATE_OUTGOING_ARGS) && defined(REG_PARM_STACK_SPACE)
468: /* Define the boundary of the register parm stack space that needs to be
469: save, if any. */
470: int low_to_save = -1, high_to_save;
471: rtx save_area = 0; /* Place that it is saved */
472: #endif
473:
474: #ifdef ACCUMULATE_OUTGOING_ARGS
475: int initial_highest_arg_in_use = highest_outgoing_arg_in_use;
476: char *initial_stack_usage_map = stack_usage_map;
477: #endif
478:
479: rtx old_stack_level = 0;
480: int old_pending_adj;
1.1.1.3 ! root 481: int old_stack_arg_under_construction;
1.1 root 482: int old_inhibit_defer_pop = inhibit_defer_pop;
483: tree old_cleanups = cleanups_this_call;
484:
485: rtx use_insns = 0;
486:
487: register tree p;
488: register int i;
489:
490: /* See if we can find a DECL-node for the actual function.
491: As a result, decide whether this is a call to an integrable function. */
492:
493: p = TREE_OPERAND (exp, 0);
494: if (TREE_CODE (p) == ADDR_EXPR)
495: {
496: fndecl = TREE_OPERAND (p, 0);
497: if (TREE_CODE (fndecl) != FUNCTION_DECL)
498: {
499: /* May still be a `const' function if it is
500: a call through a pointer-to-const.
501: But we don't handle that. */
502: fndecl = 0;
503: }
504: else
505: {
506: if (!flag_no_inline
507: && fndecl != current_function_decl
508: && DECL_SAVED_INSNS (fndecl))
509: is_integrable = 1;
510: else if (! TREE_ADDRESSABLE (fndecl))
511: {
512: /* In case this function later becomes inlineable,
513: record that there was already a non-inline call to it.
514:
515: Use abstraction instead of setting TREE_ADDRESSABLE
516: directly. */
517: if (TREE_INLINE (fndecl) && extra_warnings && !flag_no_inline)
518: warning_with_decl (fndecl, "can't inline call to `%s' which was declared inline");
519: mark_addressable (fndecl);
520: }
521:
522: if (TREE_READONLY (fndecl) && ! TREE_THIS_VOLATILE (fndecl)
523: && TYPE_MODE (TREE_TYPE (exp)) != VOIDmode)
524: is_const = 1;
525: }
526: }
527:
528: is_volatile = TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (p)));
529:
1.1.1.3 ! root 530: #ifdef REG_PARM_STACK_SPACE
! 531: #ifdef MAYBE_REG_PARM_STACK_SPACE
! 532: reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
! 533: #else
! 534: reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
! 535: #endif
! 536: #endif
! 537:
1.1 root 538: /* Warn if this value is an aggregate type,
539: regardless of which calling convention we are using for it. */
540: if (warn_aggregate_return
541: && (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
542: || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE
543: || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE))
544: warning ("function call has aggregate value");
545:
546: /* Set up a place to return a structure. */
547:
548: /* Cater to broken compilers. */
549: if (aggregate_value_p (exp))
550: {
551: /* This call returns a big structure. */
552: is_const = 0;
553:
554: #ifdef PCC_STATIC_STRUCT_RETURN
555: if (flag_pcc_struct_return)
556: {
557: pcc_struct_value = 1;
558: is_integrable = 0; /* Easier than making that case work right. */
559: }
560: else
561: #endif
562: {
563: struct_value_size = int_size_in_bytes (TREE_TYPE (exp));
564:
565: if (struct_value_size < 0)
566: abort ();
567:
568: if (target && GET_CODE (target) == MEM)
569: structure_value_addr = XEXP (target, 0);
570: else
571: {
572: /* Assign a temporary on the stack to hold the value. */
573:
574: /* For variable-sized objects, we must be called with a target
575: specified. If we were to allocate space on the stack here,
576: we would have no way of knowing when to free it. */
577:
578: structure_value_addr
579: = XEXP (assign_stack_temp (BLKmode, struct_value_size, 1), 0);
580: target = 0;
581: }
582: }
583: }
584:
585: /* If called function is inline, try to integrate it. */
586:
587: if (is_integrable)
588: {
589: rtx temp;
1.1.1.3 ! root 590: rtx before_call = get_last_insn ();
1.1 root 591:
592: temp = expand_inline_function (fndecl, actparms, target,
593: ignore, TREE_TYPE (exp),
594: structure_value_addr);
595:
596: /* If inlining succeeded, return. */
597: if ((int) temp != -1)
598: {
1.1.1.3 ! root 599: int i;
! 600:
1.1 root 601: /* Perform all cleanups needed for the arguments of this call
602: (i.e. destructors in C++). It is ok if these destructors
603: clobber RETURN_VALUE_REG, because the only time we care about
604: this is when TARGET is that register. But in C++, we take
605: care to never return that register directly. */
606: expand_cleanups_to (old_cleanups);
607:
1.1.1.3 ! root 608: #ifdef ACCUMULATE_OUTGOING_ARGS
! 609: /* If the outgoing argument list must be preserved, push
! 610: the stack before executing the inlined function if it
! 611: makes any calls. */
! 612:
! 613: for (i = reg_parm_stack_space - 1; i >= 0; i--)
! 614: if (i < highest_outgoing_arg_in_use && stack_usage_map[i] != 0)
! 615: break;
! 616:
! 617: if (stack_arg_under_construction || i >= 0)
! 618: {
! 619: rtx insn = NEXT_INSN (before_call), seq;
! 620:
! 621: /* Look for a call in the inline function code.
! 622: If OUTGOING_ARGS_SIZE (DECL_SAVED_INSNS (fndecl)) is
! 623: nonzero then there is a call and it is not necessary
! 624: to scan the insns. */
! 625:
! 626: if (OUTGOING_ARGS_SIZE (DECL_SAVED_INSNS (fndecl)) == 0)
! 627: for (; insn; insn = NEXT_INSN (insn))
! 628: if (GET_CODE (insn) == CALL_INSN)
! 629: break;
! 630:
! 631: if (insn)
! 632: {
! 633: /* Reserve enough stack space so that the largest
! 634: argument list of any function call in the inline
! 635: function does not overlap the argument list being
! 636: evaluated. This is usually an overestimate because
! 637: allocate_dynamic_stack_space reserves space for an
! 638: outgoing argument list in addition to the requested
! 639: space, but there is no way to ask for stack space such
! 640: that an argument list of a certain length can be
! 641: safely constructed. */
! 642:
! 643: int adjust = OUTGOING_ARGS_SIZE (DECL_SAVED_INSNS (fndecl));
! 644: #ifdef REG_PARM_STACK_SPACE
! 645: /* Add the stack space reserved for register arguments
! 646: in the inline function. What is really needed is the
! 647: largest value of reg_parm_stack_space in the inline
! 648: function, but that is not available. Using the current
! 649: value of reg_parm_stack_space is wrong, but gives
! 650: correct results on all supported machines. */
! 651: adjust += reg_parm_stack_space;
! 652: #endif
! 653: start_sequence ();
! 654: emit_stack_save (SAVE_BLOCK, &old_stack_level, 0);
! 655: allocate_dynamic_stack_space (gen_rtx (CONST_INT, VOIDmode,
! 656: adjust),
! 657: 0, BITS_PER_UNIT);
! 658: seq = get_insns ();
! 659: end_sequence ();
! 660: emit_insns_before (seq, NEXT_INSN (before_call));
! 661: emit_stack_restore (SAVE_BLOCK, old_stack_level, 0);
! 662: }
! 663: }
! 664: #endif
! 665:
1.1 root 666: /* If the result is equivalent to TARGET, return TARGET to simplify
667: checks in store_expr. They can be equivalent but not equal in the
668: case of a function that returns BLKmode. */
669: if (temp != target && rtx_equal_p (temp, target))
670: return target;
671: return temp;
672: }
673:
674: /* If inlining failed, mark FNDECL as needing to be compiled
675: separately after all. */
676: mark_addressable (fndecl);
677: }
678:
679: /* When calling a const function, we must pop the stack args right away,
680: so that the pop is deleted or moved with the call. */
681: if (is_const)
682: NO_DEFER_POP;
683:
684: function_call_count++;
685:
686: if (fndecl && DECL_NAME (fndecl))
687: name = IDENTIFIER_POINTER (DECL_NAME (fndecl));
688:
689: #if 0
690: /* Unless it's a call to a specific function that isn't alloca,
691: if it has one argument, we must assume it might be alloca. */
692:
693: may_be_alloca =
694: (!(fndecl != 0 && strcmp (name, "alloca"))
695: && actparms != 0
696: && TREE_CHAIN (actparms) == 0);
697: #else
698: /* We assume that alloca will always be called by name. It
699: makes no sense to pass it as a pointer-to-function to
700: anything that does not understand its behavior. */
701: may_be_alloca =
702: (name && ((IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 6
703: && name[0] == 'a'
704: && ! strcmp (name, "alloca"))
705: || (IDENTIFIER_LENGTH (DECL_NAME (fndecl)) == 16
706: && name[0] == '_'
707: && ! strcmp (name, "__builtin_alloca"))));
708: #endif
709:
710: /* See if this is a call to a function that can return more than once
711: or a call to longjmp. */
712:
713: returns_twice = 0;
714: is_longjmp = 0;
715:
716: if (name != 0 && IDENTIFIER_LENGTH (DECL_NAME (fndecl)) <= 15)
717: {
718: char *tname = name;
719:
720: if (name[0] == '_')
721: tname += ((name[1] == '_' && name[2] == 'x') ? 3 : 1);
722:
723: if (tname[0] == 's')
724: {
725: returns_twice
726: = ((tname[1] == 'e'
727: && (! strcmp (tname, "setjmp")
728: || ! strcmp (tname, "setjmp_syscall")))
729: || (tname[1] == 'i'
730: && ! strcmp (tname, "sigsetjmp"))
731: || (tname[1] == 'a'
732: && ! strcmp (tname, "savectx")));
733: if (tname[1] == 'i'
734: && ! strcmp (tname, "siglongjmp"))
735: is_longjmp = 1;
736: }
737: else if ((tname[0] == 'q' && tname[1] == 's'
738: && ! strcmp (tname, "qsetjmp"))
739: || (tname[0] == 'v' && tname[1] == 'f'
740: && ! strcmp (tname, "vfork")))
741: returns_twice = 1;
742:
743: else if (tname[0] == 'l' && tname[1] == 'o'
744: && ! strcmp (tname, "longjmp"))
745: is_longjmp = 1;
746: }
747:
748: if (may_be_alloca)
749: current_function_calls_alloca = 1;
750:
751: /* Don't let pending stack adjusts add up to too much.
752: Also, do all pending adjustments now
753: if there is any chance this might be a call to alloca. */
754:
755: if (pending_stack_adjust >= 32
756: || (pending_stack_adjust > 0 && may_be_alloca))
757: do_pending_stack_adjust ();
758:
759: /* Operand 0 is a pointer-to-function; get the type of the function. */
760: funtype = TREE_TYPE (TREE_OPERAND (exp, 0));
761: if (TREE_CODE (funtype) != POINTER_TYPE)
762: abort ();
763: funtype = TREE_TYPE (funtype);
764:
765: /* Push the temporary stack slot level so that we can free temporaries used
766: by each of the arguments separately. */
767: push_temp_slots ();
768:
769: /* Start updating where the next arg would go. */
770: INIT_CUMULATIVE_ARGS (args_so_far, funtype, 0);
771:
772: /* If struct_value_rtx is 0, it means pass the address
773: as if it were an extra parameter. */
774: if (structure_value_addr && struct_value_rtx == 0)
775: {
1.1.1.3 ! root 776: #ifdef ACCUMULATE_OUTGOING_ARGS
! 777: /* If the stack will be adjusted, make sure the structure address
! 778: does not refer to virtual_outgoing_args_rtx. */
! 779: rtx temp = (stack_arg_under_construction
! 780: ? copy_addr_to_reg (structure_value_addr)
! 781: : force_reg (Pmode, structure_value_addr));
! 782: #else
! 783: rtx temp = force_reg (Pmode, structure_value_addr);
! 784: #endif
! 785:
1.1 root 786: actparms
787: = tree_cons (error_mark_node,
788: make_tree (build_pointer_type (TREE_TYPE (funtype)),
1.1.1.3 ! root 789: temp),
1.1 root 790: actparms);
791: structure_value_addr_parm = 1;
792: }
793:
794: /* Count the arguments and set NUM_ACTUALS. */
795: for (p = actparms, i = 0; p; p = TREE_CHAIN (p)) i++;
796: num_actuals = i;
797:
798: /* Compute number of named args.
799: Normally, don't include the last named arg if anonymous args follow.
800: (If no anonymous args follow, the result of list_length
801: is actually one too large.)
802:
803: If SETUP_INCOMING_VARARGS is defined, this machine will be able to
804: place unnamed args that were passed in registers into the stack. So
805: treat all args as named. This allows the insns emitting for a specific
1.1.1.2 root 806: argument list to be independent of the function declaration.
1.1 root 807:
808: If SETUP_INCOMING_VARARGS is not defined, we do not have any reliable
809: way to pass unnamed args in registers, so we must force them into
810: memory. */
811: #ifndef SETUP_INCOMING_VARARGS
812: if (TYPE_ARG_TYPES (funtype) != 0)
813: n_named_args
814: = list_length (TYPE_ARG_TYPES (funtype)) - 1
815: /* Count the struct value address, if it is passed as a parm. */
816: + structure_value_addr_parm;
817: else
818: #endif
819: /* If we know nothing, treat all args as named. */
820: n_named_args = num_actuals;
821:
822: /* Make a vector to hold all the information about each arg. */
823: args = (struct arg_data *) alloca (num_actuals * sizeof (struct arg_data));
824: bzero (args, num_actuals * sizeof (struct arg_data));
825:
826: args_size.constant = 0;
827: args_size.var = 0;
828:
829: /* In this loop, we consider args in the order they are written.
830: We fill up ARGS from the front of from the back if necessary
831: so that in any case the first arg to be pushed ends up at the front. */
832:
833: #ifdef PUSH_ARGS_REVERSED
834: i = num_actuals - 1, inc = -1;
835: /* In this case, must reverse order of args
836: so that we compute and push the last arg first. */
837: #else
838: i = 0, inc = 1;
839: #endif
840:
841: /* I counts args in order (to be) pushed; ARGPOS counts in order written. */
842: for (p = actparms, argpos = 0; p; p = TREE_CHAIN (p), i += inc, argpos++)
843: {
844: tree type = TREE_TYPE (TREE_VALUE (p));
845:
846: args[i].tree_value = TREE_VALUE (p);
847:
848: /* Replace erroneous argument with constant zero. */
849: if (type == error_mark_node || TYPE_SIZE (type) == 0)
850: args[i].tree_value = integer_zero_node, type = integer_type_node;
851:
852: /* Decide where to pass this arg.
853:
854: args[i].reg is nonzero if all or part is passed in registers.
855:
856: args[i].partial is nonzero if part but not all is passed in registers,
857: and the exact value says how many words are passed in registers.
858:
859: args[i].pass_on_stack is nonzero if the argument must at least be
860: computed on the stack. It may then be loaded back into registers
861: if args[i].reg is nonzero.
862:
863: These decisions are driven by the FUNCTION_... macros and must agree
864: with those made by function.c. */
865:
866: #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
867: /* See if this argument should be passed by invisible reference. */
868: if (FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, TYPE_MODE (type), type,
869: argpos < n_named_args))
870: {
871: /* We make a copy of the object and pass the address to the function
872: being called. */
873: int size = int_size_in_bytes (type);
874: rtx copy;
875:
876: if (size < 0)
877: {
878: /* This is a variable-sized object. Make space on the stack
879: for it. */
880: rtx size_rtx = expand_expr (size_in_bytes (type), 0,
881: VOIDmode, 0);
882:
883: if (old_stack_level == 0)
884: {
1.1.1.3 ! root 885: emit_stack_save (SAVE_BLOCK, &old_stack_level, 0);
1.1 root 886: old_pending_adj = pending_stack_adjust;
887: pending_stack_adjust = 0;
888: }
889:
890: copy = gen_rtx (MEM, BLKmode,
1.1.1.3 ! root 891: allocate_dynamic_stack_space (size_rtx, 0,
! 892: TYPE_ALIGN (type)));
1.1 root 893: }
894: else
895: copy = assign_stack_temp (TYPE_MODE (type), size, 1);
896:
897: store_expr (args[i].tree_value, copy, 0);
898:
899: args[i].tree_value = build1 (ADDR_EXPR, build_pointer_type (type),
900: make_tree (type, copy));
901: type = build_pointer_type (type);
902: }
903: #endif
904:
905: args[i].reg = FUNCTION_ARG (args_so_far, TYPE_MODE (type), type,
906: argpos < n_named_args);
907: #ifdef FUNCTION_ARG_PARTIAL_NREGS
908: if (args[i].reg)
909: args[i].partial
910: = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, TYPE_MODE (type), type,
911: argpos < n_named_args);
912: #endif
913:
914: args[i].pass_on_stack = MUST_PASS_IN_STACK (TYPE_MODE (type), type);
915:
916: /* If FUNCTION_ARG returned an (expr_list (nil) FOO), it means that
917: we are to pass this arg in the register(s) designated by FOO, but
918: also to pass it in the stack. */
919: if (args[i].reg && GET_CODE (args[i].reg) == EXPR_LIST
920: && XEXP (args[i].reg, 0) == 0)
921: args[i].pass_on_stack = 1, args[i].reg = XEXP (args[i].reg, 1);
922:
923: /* If this is an addressable type, we must preallocate the stack
924: since we must evaluate the object into its final location.
925:
926: If this is to be passed in both registers and the stack, it is simpler
927: to preallocate. */
928: if (TREE_ADDRESSABLE (type)
929: || (args[i].pass_on_stack && args[i].reg != 0))
930: must_preallocate = 1;
931:
932: /* If this is an addressable type, we cannot pre-evaluate it. Thus,
933: we cannot consider this function call constant. */
934: if (TREE_ADDRESSABLE (type))
935: is_const = 0;
936:
937: /* Compute the stack-size of this argument. */
938: if (args[i].reg == 0 || args[i].partial != 0
939: #ifdef REG_PARM_STACK_SPACE
1.1.1.3 ! root 940: || reg_parm_stack_space > 0
1.1 root 941: #endif
942: || args[i].pass_on_stack)
943: locate_and_pad_parm (TYPE_MODE (type), type,
944: #ifdef STACK_PARMS_IN_REG_PARM_AREA
945: 1,
946: #else
947: args[i].reg != 0,
948: #endif
949: fndecl, &args_size, &args[i].offset,
950: &args[i].size);
951:
952: #ifndef ARGS_GROW_DOWNWARD
953: args[i].slot_offset = args_size;
954: #endif
955:
956: #ifndef REG_PARM_STACK_SPACE
957: /* If a part of the arg was put into registers,
958: don't include that part in the amount pushed. */
959: if (! args[i].pass_on_stack)
960: args[i].size.constant -= ((args[i].partial * UNITS_PER_WORD)
961: / (PARM_BOUNDARY / BITS_PER_UNIT)
962: * (PARM_BOUNDARY / BITS_PER_UNIT));
963: #endif
964:
965: /* Update ARGS_SIZE, the total stack space for args so far. */
966:
967: args_size.constant += args[i].size.constant;
968: if (args[i].size.var)
969: {
970: ADD_PARM_SIZE (args_size, args[i].size.var);
971: }
972:
973: /* Since the slot offset points to the bottom of the slot,
974: we must record it after incrementing if the args grow down. */
975: #ifdef ARGS_GROW_DOWNWARD
976: args[i].slot_offset = args_size;
977:
978: args[i].slot_offset.constant = -args_size.constant;
979: if (args_size.var)
980: {
981: SUB_PARM_SIZE (args[i].slot_offset, args_size.var);
982: }
983: #endif
984:
985: /* Increment ARGS_SO_FAR, which has info about which arg-registers
986: have been used, etc. */
987:
988: FUNCTION_ARG_ADVANCE (args_so_far, TYPE_MODE (type), type,
989: argpos < n_named_args);
990: }
991:
1.1.1.3 ! root 992: #ifdef FINAL_REG_PARM_STACK_SPACE
! 993: reg_parm_stack_space = FINAL_REG_PARM_STACK_SPACE (args_size.constant,
! 994: args_size.var);
! 995: #endif
! 996:
1.1 root 997: /* Compute the actual size of the argument block required. The variable
998: and constant sizes must be combined, the size may have to be rounded,
999: and there may be a minimum required size. */
1000:
1001: original_args_size = args_size;
1002: if (args_size.var)
1003: {
1004: /* If this function requires a variable-sized argument list, don't try to
1005: make a cse'able block for this call. We may be able to do this
1006: eventually, but it is too complicated to keep track of what insns go
1007: in the cse'able block and which don't. */
1008:
1009: is_const = 0;
1010: must_preallocate = 1;
1011:
1012: args_size.var = ARGS_SIZE_TREE (args_size);
1013: args_size.constant = 0;
1014:
1015: #ifdef STACK_BOUNDARY
1016: if (STACK_BOUNDARY != BITS_PER_UNIT)
1017: args_size.var = round_up (args_size.var, STACK_BYTES);
1018: #endif
1019:
1020: #ifdef REG_PARM_STACK_SPACE
1.1.1.3 ! root 1021: if (reg_parm_stack_space > 0)
1.1 root 1022: {
1023: args_size.var
1024: = size_binop (MAX_EXPR, args_size.var,
1025: size_int (REG_PARM_STACK_SPACE (fndecl)));
1026:
1027: #ifndef OUTGOING_REG_PARM_STACK_SPACE
1028: /* The area corresponding to register parameters is not to count in
1029: the size of the block we need. So make the adjustment. */
1030: args_size.var
1031: = size_binop (MINUS_EXPR, args_size.var,
1.1.1.3 ! root 1032: size_int (reg_parm_stack_space));
1.1 root 1033: #endif
1034: }
1035: #endif
1036: }
1037: else
1038: {
1039: #ifdef STACK_BOUNDARY
1040: args_size.constant = (((args_size.constant + (STACK_BYTES - 1))
1041: / STACK_BYTES) * STACK_BYTES);
1042: #endif
1043:
1044: #ifdef REG_PARM_STACK_SPACE
1045: args_size.constant = MAX (args_size.constant,
1.1.1.3 ! root 1046: reg_parm_stack_space);
1.1 root 1047: #ifndef OUTGOING_REG_PARM_STACK_SPACE
1.1.1.3 ! root 1048: args_size.constant -= reg_parm_stack_space;
1.1 root 1049: #endif
1050: #endif
1051: }
1052:
1053: /* See if we have or want to preallocate stack space.
1054:
1055: If we would have to push a partially-in-regs parm
1056: before other stack parms, preallocate stack space instead.
1057:
1058: If the size of some parm is not a multiple of the required stack
1059: alignment, we must preallocate.
1060:
1061: If the total size of arguments that would otherwise create a copy in
1062: a temporary (such as a CALL) is more than half the total argument list
1063: size, preallocation is faster.
1064:
1065: Another reason to preallocate is if we have a machine (like the m88k)
1066: where stack alignment is required to be maintained between every
1067: pair of insns, not just when the call is made. However, we assume here
1068: that such machines either do not have push insns (and hence preallocation
1069: would occur anyway) or the problem is taken care of with
1070: PUSH_ROUNDING. */
1071:
1072: if (! must_preallocate)
1073: {
1074: int partial_seen = 0;
1075: int copy_to_evaluate_size = 0;
1076:
1077: for (i = 0; i < num_actuals && ! must_preallocate; i++)
1078: {
1079: if (args[i].partial > 0 && ! args[i].pass_on_stack)
1080: partial_seen = 1;
1081: else if (partial_seen && args[i].reg == 0)
1082: must_preallocate = 1;
1083:
1084: if (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
1085: && (TREE_CODE (args[i].tree_value) == CALL_EXPR
1086: || TREE_CODE (args[i].tree_value) == TARGET_EXPR
1087: || TREE_CODE (args[i].tree_value) == COND_EXPR
1088: || TREE_ADDRESSABLE (TREE_TYPE (args[i].tree_value))))
1089: copy_to_evaluate_size
1090: += int_size_in_bytes (TREE_TYPE (args[i].tree_value));
1091: }
1092:
1.1.1.3 ! root 1093: if (copy_to_evaluate_size * 2 >= args_size.constant
! 1094: && args_size.constant > 0)
1.1 root 1095: must_preallocate = 1;
1096: }
1097:
1098: /* If the structure value address will reference the stack pointer, we must
1099: stabilize it. We don't need to do this if we know that we are not going
1100: to adjust the stack pointer in processing this call. */
1101:
1102: if (structure_value_addr
1103: && (reg_mentioned_p (virtual_stack_dynamic_rtx, structure_value_addr)
1104: || reg_mentioned_p (virtual_outgoing_args_rtx, structure_value_addr))
1105: && (args_size.var
1106: #ifndef ACCUMULATE_OUTGOING_ARGS
1107: || args_size.constant
1108: #endif
1109: ))
1110: structure_value_addr = copy_to_reg (structure_value_addr);
1111:
1112: /* If this function call is cse'able, precompute all the parameters.
1113: Note that if the parameter is constructed into a temporary, this will
1114: cause an additional copy because the parameter will be constructed
1115: into a temporary location and then copied into the outgoing arguments.
1116: If a parameter contains a call to alloca and this function uses the
1117: stack, precompute the parameter. */
1118:
1119: for (i = 0; i < num_actuals; i++)
1120: if (is_const
1121: || ((args_size.var != 0 || args_size.constant != 0)
1122: && calls_alloca (args[i].tree_value)))
1123: {
1124: args[i].initial_value = args[i].value
1125: = expand_expr (args[i].tree_value, 0, VOIDmode, 0);
1126: preserve_temp_slots (args[i].value);
1127: free_temp_slots ();
1128:
1129: /* ANSI doesn't require a sequence point here,
1130: but PCC has one, so this will avoid some problems. */
1131: emit_queue ();
1132: }
1133:
1134: /* Now we are about to start emitting insns that can be deleted
1135: if a libcall is deleted. */
1136: if (is_const)
1137: start_sequence ();
1138:
1139: /* If we have no actual push instructions, or shouldn't use them,
1140: make space for all args right now. */
1141:
1142: if (args_size.var != 0)
1143: {
1144: if (old_stack_level == 0)
1145: {
1.1.1.3 ! root 1146: emit_stack_save (SAVE_BLOCK, &old_stack_level, 0);
1.1 root 1147: old_pending_adj = pending_stack_adjust;
1148: pending_stack_adjust = 0;
1.1.1.3 ! root 1149: #ifdef ACCUMULATE_OUTGOING_ARGS
! 1150: /* stack_arg_under_construction says whether a stack arg is
! 1151: being constructed at the old stack level. Pushing the stack
! 1152: gets a clean outgoing argument block. */
! 1153: old_stack_arg_under_construction = stack_arg_under_construction;
! 1154: stack_arg_under_construction = 0;
! 1155: #endif
1.1 root 1156: }
1157: argblock = push_block (ARGS_SIZE_RTX (args_size), 0, 0);
1158: }
1159: else if (must_preallocate)
1160: {
1161: /* Note that we must go through the motions of allocating an argument
1162: block even if the size is zero because we may be storing args
1163: in the area reserved for register arguments, which may be part of
1164: the stack frame. */
1165: int needed = args_size.constant;
1166:
1167: #ifdef ACCUMULATE_OUTGOING_ARGS
1168: /* Store the maximum argument space used. It will be pushed by the
1169: prologue.
1170:
1171: Since the stack pointer will never be pushed, it is possible for
1172: the evaluation of a parm to clobber something we have already
1173: written to the stack. Since most function calls on RISC machines
1174: do not use the stack, this is uncommon, but must work correctly.
1175:
1176: Therefore, we save any area of the stack that was already written
1177: and that we are using. Here we set up to do this by making a new
1178: stack usage map from the old one. The actual save will be done
1179: by store_one_arg.
1180:
1181: Another approach might be to try to reorder the argument
1182: evaluations to avoid this conflicting stack usage. */
1183:
1184: if (needed > current_function_outgoing_args_size)
1185: current_function_outgoing_args_size = needed;
1186:
1187: #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
1188: /* Since we will be writing into the entire argument area, the
1189: map must be allocated for its entire size, not just the part that
1190: is the responsibility of the caller. */
1.1.1.3 ! root 1191: needed += reg_parm_stack_space;
1.1 root 1192: #endif
1193:
1194: #ifdef ARGS_GROW_DOWNWARD
1195: highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use,
1196: needed + 1);
1197: #else
1198: highest_outgoing_arg_in_use = MAX (initial_highest_arg_in_use, needed);
1199: #endif
1200: stack_usage_map = (char *) alloca (highest_outgoing_arg_in_use);
1201:
1202: if (initial_highest_arg_in_use)
1203: bcopy (initial_stack_usage_map, stack_usage_map,
1204: initial_highest_arg_in_use);
1205:
1206: if (initial_highest_arg_in_use != highest_outgoing_arg_in_use)
1207: bzero (&stack_usage_map[initial_highest_arg_in_use],
1208: highest_outgoing_arg_in_use - initial_highest_arg_in_use);
1209: needed = 0;
1.1.1.3 ! root 1210:
! 1211: /* The address of the outgoing argument list must not be copied to a
! 1212: register here, because argblock would be left pointing to the
! 1213: wrong place after the call to allocate_dynamic_stack_space below. */
! 1214:
1.1 root 1215: argblock = virtual_outgoing_args_rtx;
1.1.1.3 ! root 1216:
1.1 root 1217: #else /* not ACCUMULATE_OUTGOING_ARGS */
1218: if (inhibit_defer_pop == 0)
1219: {
1220: /* Try to reuse some or all of the pending_stack_adjust
1221: to get this space. Maybe we can avoid any pushing. */
1222: if (needed > pending_stack_adjust)
1223: {
1224: needed -= pending_stack_adjust;
1225: pending_stack_adjust = 0;
1226: }
1227: else
1228: {
1229: pending_stack_adjust -= needed;
1230: needed = 0;
1231: }
1232: }
1233: /* Special case this because overhead of `push_block' in this
1234: case is non-trivial. */
1235: if (needed == 0)
1236: argblock = virtual_outgoing_args_rtx;
1237: else
1238: argblock = push_block (gen_rtx (CONST_INT, VOIDmode, needed), 0, 0);
1239:
1240: /* We only really need to call `copy_to_reg' in the case where push
1241: insns are going to be used to pass ARGBLOCK to a function
1242: call in ARGS. In that case, the stack pointer changes value
1243: from the allocation point to the call point, and hence
1244: the value of VIRTUAL_OUTGOING_ARGS_RTX changes as well.
1245: But might as well always do it. */
1246: argblock = copy_to_reg (argblock);
1247: #endif /* not ACCUMULATE_OUTGOING_ARGS */
1248: }
1249:
1.1.1.3 ! root 1250:
! 1251: #ifdef ACCUMULATE_OUTGOING_ARGS
! 1252: /* The save/restore code in store_one_arg handles all cases except one:
! 1253: a constructor call (including a C function returning a BLKmode struct)
! 1254: to initialize an argument. */
! 1255: if (stack_arg_under_construction)
! 1256: {
! 1257: #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
! 1258: rtx push_size = gen_rtx (CONST_INT, VOIDmode,
! 1259: reg_parm_stack_space + args_size.constant);
! 1260: #else
! 1261: rtx push_size = gen_rtx (CONST_INT, VOIDmode, args_size.constant);
! 1262: #endif
! 1263: if (old_stack_level == 0)
! 1264: {
! 1265: emit_stack_save (SAVE_BLOCK, &old_stack_level, 0);
! 1266: old_pending_adj = pending_stack_adjust;
! 1267: pending_stack_adjust = 0;
! 1268: /* stack_arg_under_construction says whether a stack arg is
! 1269: being constructed at the old stack level. Pushing the stack
! 1270: gets a clean outgoing argument block. */
! 1271: old_stack_arg_under_construction = stack_arg_under_construction;
! 1272: stack_arg_under_construction = 0;
! 1273: /* Make a new map for the new argument list. */
! 1274: stack_usage_map = (char *)alloca (highest_outgoing_arg_in_use);
! 1275: bzero (stack_usage_map, highest_outgoing_arg_in_use);
! 1276: highest_outgoing_arg_in_use = 0;
! 1277: }
! 1278: allocate_dynamic_stack_space (push_size, 0, BITS_PER_UNIT);
! 1279: }
! 1280: /* If argument evaluation might modify the stack pointer, copy the
! 1281: address of the argument list to a register. */
! 1282: for (i = 0; i < num_actuals; i++)
! 1283: if (args[i].pass_on_stack)
! 1284: {
! 1285: argblock = copy_addr_to_reg (argblock);
! 1286: break;
! 1287: }
! 1288: #endif
! 1289:
! 1290:
1.1 root 1291: /* If we preallocated stack space, compute the address of each argument.
1292: We need not ensure it is a valid memory address here; it will be
1293: validized when it is used. */
1294: if (argblock)
1295: {
1296: rtx arg_reg = argblock;
1297: int arg_offset = 0;
1298:
1299: if (GET_CODE (argblock) == PLUS)
1300: arg_reg = XEXP (argblock, 0), arg_offset = INTVAL (XEXP (argblock, 1));
1301:
1302: for (i = 0; i < num_actuals; i++)
1303: {
1304: rtx offset = ARGS_SIZE_RTX (args[i].offset);
1305: rtx slot_offset = ARGS_SIZE_RTX (args[i].slot_offset);
1306: rtx addr;
1307:
1308: /* Skip this parm if it will not be passed on the stack. */
1309: if (! args[i].pass_on_stack && args[i].reg != 0)
1310: continue;
1311:
1312: if (GET_CODE (offset) == CONST_INT)
1313: addr = plus_constant (arg_reg, INTVAL (offset));
1314: else
1315: addr = gen_rtx (PLUS, Pmode, arg_reg, offset);
1316:
1317: addr = plus_constant (addr, arg_offset);
1318: args[i].stack
1319: = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (args[i].tree_value)), addr);
1320:
1321: if (GET_CODE (slot_offset) == CONST_INT)
1322: addr = plus_constant (arg_reg, INTVAL (slot_offset));
1323: else
1324: addr = gen_rtx (PLUS, Pmode, arg_reg, slot_offset);
1325:
1326: addr = plus_constant (addr, arg_offset);
1327: args[i].stack_slot
1328: = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (args[i].tree_value)), addr);
1329: }
1330: }
1331:
1332: #ifdef PUSH_ARGS_REVERSED
1333: #ifdef STACK_BOUNDARY
1334: /* If we push args individually in reverse order, perform stack alignment
1335: before the first push (the last arg). */
1336: if (argblock == 0)
1337: anti_adjust_stack (gen_rtx (CONST_INT, VOIDmode,
1338: (args_size.constant
1339: - original_args_size.constant)));
1340: #endif
1341: #endif
1342:
1343: /* Don't try to defer pops if preallocating, not even from the first arg,
1344: since ARGBLOCK probably refers to the SP. */
1345: if (argblock)
1346: NO_DEFER_POP;
1347:
1348: /* Get the function to call, in the form of RTL. */
1349: if (fndecl)
1350: /* Get a SYMBOL_REF rtx for the function address. */
1351: funexp = XEXP (DECL_RTL (fndecl), 0);
1352: else
1353: /* Generate an rtx (probably a pseudo-register) for the address. */
1354: {
1355: funexp = expand_expr (TREE_OPERAND (exp, 0), 0, VOIDmode, 0);
1356: free_temp_slots (); /* FUNEXP can't be BLKmode */
1357: emit_queue ();
1358: }
1359:
1360: /* Figure out the register where the value, if any, will come back. */
1361: valreg = 0;
1362: if (TYPE_MODE (TREE_TYPE (exp)) != VOIDmode
1363: && ! structure_value_addr)
1364: {
1365: if (pcc_struct_value)
1366: valreg = hard_function_value (build_pointer_type (TREE_TYPE (exp)),
1367: fndecl);
1368: else
1369: valreg = hard_function_value (TREE_TYPE (exp), fndecl);
1370: }
1371:
1372: /* Precompute all register parameters. It isn't safe to compute anything
1373: once we have started filling any specific hard regs. */
1374: reg_parm_seen = 0;
1375: for (i = 0; i < num_actuals; i++)
1376: if (args[i].reg != 0 && ! args[i].pass_on_stack)
1377: {
1378: reg_parm_seen = 1;
1379:
1380: if (args[i].value == 0)
1381: {
1382: args[i].value = expand_expr (args[i].tree_value, 0, VOIDmode, 0);
1383: preserve_temp_slots (args[i].value);
1384: free_temp_slots ();
1385:
1386: /* ANSI doesn't require a sequence point here,
1387: but PCC has one, so this will avoid some problems. */
1388: emit_queue ();
1389: }
1390: }
1391:
1392: #if defined(ACCUMULATE_OUTGOING_ARGS) && defined(REG_PARM_STACK_SPACE)
1393: /* The argument list is the property of the called routine and it
1394: may clobber it. If the fixed area has been used for previous
1395: parameters, we must save and restore it.
1396:
1397: Here we compute the boundary of the that needs to be saved, if any. */
1398:
1.1.1.3 ! root 1399: for (i = 0; i < reg_parm_stack_space; i++)
1.1 root 1400: {
1401: if (i >= highest_outgoing_arg_in_use
1402: || stack_usage_map[i] == 0)
1403: continue;
1404:
1405: if (low_to_save == -1)
1406: low_to_save = i;
1407:
1408: high_to_save = i;
1409: }
1410:
1411: if (low_to_save >= 0)
1412: {
1413: int num_to_save = high_to_save - low_to_save + 1;
1414: enum machine_mode save_mode
1415: = mode_for_size (num_to_save * BITS_PER_UNIT, MODE_INT, 1);
1416: rtx stack_area;
1417:
1418: /* If we don't have the required alignment, must do this in BLKmode. */
1419: if ((low_to_save & (MIN (GET_MODE_SIZE (save_mode),
1420: BIGGEST_ALIGNMENT / UNITS_PER_WORD) - 1)))
1421: save_mode = BLKmode;
1422:
1423: stack_area = gen_rtx (MEM, save_mode,
1424: memory_address (save_mode,
1425: plus_constant (argblock,
1426: low_to_save)));
1427: if (save_mode == BLKmode)
1428: {
1429: save_area = assign_stack_temp (BLKmode, num_to_save, 1);
1430: emit_block_move (validize_mem (save_area), stack_area,
1431: gen_rtx (CONST_INT, VOIDmode, num_to_save),
1432: PARM_BOUNDARY / BITS_PER_UNIT);
1433: }
1434: else
1435: {
1436: save_area = gen_reg_rtx (save_mode);
1437: emit_move_insn (save_area, stack_area);
1438: }
1439: }
1440: #endif
1441:
1442:
1443: /* Now store (and compute if necessary) all non-register parms.
1444: These come before register parms, since they can require block-moves,
1445: which could clobber the registers used for register parms.
1446: Parms which have partial registers are not stored here,
1447: but we do preallocate space here if they want that. */
1448:
1449: for (i = 0; i < num_actuals; i++)
1450: if (args[i].reg == 0 || args[i].pass_on_stack)
1451: store_one_arg (&args[i], argblock, may_be_alloca,
1.1.1.3 ! root 1452: args_size.var != 0, fndecl, reg_parm_stack_space);
1.1 root 1453:
1454: /* Now store any partially-in-registers parm.
1455: This is the last place a block-move can happen. */
1456: if (reg_parm_seen)
1457: for (i = 0; i < num_actuals; i++)
1458: if (args[i].partial != 0 && ! args[i].pass_on_stack)
1459: store_one_arg (&args[i], argblock, may_be_alloca,
1.1.1.3 ! root 1460: args_size.var != 0, fndecl, reg_parm_stack_space);
1.1 root 1461:
1462: #ifndef PUSH_ARGS_REVERSED
1463: #ifdef STACK_BOUNDARY
1464: /* If we pushed args in forward order, perform stack alignment
1465: after pushing the last arg. */
1466: if (argblock == 0)
1467: anti_adjust_stack (gen_rtx (CONST_INT, VOIDmode,
1468: (args_size.constant
1469: - original_args_size.constant)));
1470: #endif
1471: #endif
1472:
1.1.1.3 ! root 1473: /* If register arguments require space on the stack and stack space
! 1474: was not preallocated, allocate stack space here for arguments
! 1475: passed in registers. */
! 1476: #if ! defined(ALLOCATE_OUTGOING_ARGS) && defined(OUTGOING_REG_PARM_STACK_SPACE)
! 1477: if (must_preallocate == 0 && reg_parm_stack_space > 0)
! 1478: anti_adjust_stack (gen_rtx (CONST_INT, VOIDmode, reg_parm_stack_space));
! 1479: #endif
! 1480:
1.1 root 1481: /* Pass the function the address in which to return a structure value. */
1482: if (structure_value_addr && ! structure_value_addr_parm)
1483: {
1484: emit_move_insn (struct_value_rtx,
1485: force_reg (Pmode,
1486: force_operand (structure_value_addr, 0)));
1487: if (GET_CODE (struct_value_rtx) == REG)
1488: {
1489: push_to_sequence (use_insns);
1490: emit_insn (gen_rtx (USE, VOIDmode, struct_value_rtx));
1491: use_insns = get_insns ();
1492: end_sequence ();
1493: }
1494: }
1495:
1496: /* Now do the register loads required for any wholly-register parms or any
1497: parms which are passed both on the stack and in a register. Their
1498: expressions were already evaluated.
1499:
1500: Mark all register-parms as living through the call, putting these USE
1501: insns in a list headed by USE_INSNS. */
1502:
1503: for (i = 0; i < num_actuals; i++)
1504: {
1505: rtx list = args[i].reg;
1506: int partial = args[i].partial;
1507:
1508: while (list)
1509: {
1510: rtx reg;
1511: int nregs;
1512:
1513: /* Process each register that needs to get this arg. */
1514: if (GET_CODE (list) == EXPR_LIST)
1515: reg = XEXP (list, 0), list = XEXP (list, 1);
1516: else
1517: reg = list, list = 0;
1518:
1519: /* Set to non-zero if must move a word at a time, even if just one
1520: word (e.g, partial == 1 && mode == DFmode). Set to zero if
1521: we just use a normal move insn. */
1522: nregs = (partial ? partial
1523: : (TYPE_MODE (TREE_TYPE (args[i].tree_value)) == BLKmode
1524: ? ((int_size_in_bytes (TREE_TYPE (args[i].tree_value))
1525: + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)
1526: : 0));
1527:
1528: /* If simple case, just do move. If normal partial, store_one_arg
1529: has already loaded the register for us. In all other cases,
1530: load the register(s) from memory. */
1531:
1532: if (nregs == 0)
1533: emit_move_insn (reg, args[i].value);
1534: else if (args[i].partial == 0 || args[i].pass_on_stack)
1535: move_block_to_reg (REGNO (reg),
1536: validize_mem (args[i].value), nregs,
1537: TYPE_MODE (TREE_TYPE (args[i].tree_value)));
1538:
1539: push_to_sequence (use_insns);
1540: if (nregs == 0)
1541: emit_insn (gen_rtx (USE, VOIDmode, reg));
1542: else
1543: use_regs (REGNO (reg), nregs);
1544: use_insns = get_insns ();
1545: end_sequence ();
1546:
1547: /* PARTIAL referred only to the first register, so clear it for the
1548: next time. */
1549: partial = 0;
1550: }
1551: }
1552:
1553: /* Perform postincrements before actually calling the function. */
1554: emit_queue ();
1555:
1556: /* All arguments and registers used for the call must be set up by now! */
1557:
1558: funexp = prepare_call_address (funexp, fndecl, &use_insns);
1559:
1560: /* Generate the actual call instruction. */
1561: emit_call_1 (funexp, funtype, args_size.constant, struct_value_size,
1562: FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1),
1563: valreg, old_inhibit_defer_pop, use_insns, is_const);
1564:
1565: /* If call is cse'able, make appropriate pair of reg-notes around it.
1566: Test valreg so we don't crash; may safely ignore `const'
1567: if return type is void. */
1568: if (is_const && valreg != 0)
1569: {
1570: rtx note = 0;
1571: rtx temp = gen_reg_rtx (GET_MODE (valreg));
1572: rtx insns;
1573:
1574: /* Construct an "equal form" for the value which mentions all the
1575: arguments in order as well as the function name. */
1576: #ifdef PUSH_ARGS_REVERSED
1577: for (i = 0; i < num_actuals; i++)
1578: note = gen_rtx (EXPR_LIST, VOIDmode, args[i].initial_value, note);
1579: #else
1580: for (i = num_actuals - 1; i >= 0; i--)
1581: note = gen_rtx (EXPR_LIST, VOIDmode, args[i].initial_value, note);
1582: #endif
1583: note = gen_rtx (EXPR_LIST, VOIDmode, funexp, note);
1584:
1585: insns = get_insns ();
1586: end_sequence ();
1587:
1588: emit_libcall_block (insns, temp, valreg, note);
1589:
1590: valreg = temp;
1591: }
1592:
1593: /* For calls to `setjmp', etc., inform flow.c it should complain
1594: if nonvolatile values are live. */
1595:
1596: if (returns_twice)
1597: {
1598: emit_note (name, NOTE_INSN_SETJMP);
1599: current_function_calls_setjmp = 1;
1600: }
1601:
1602: if (is_longjmp)
1603: current_function_calls_longjmp = 1;
1604:
1605: /* Notice functions that cannot return.
1606: If optimizing, insns emitted below will be dead.
1607: If not optimizing, they will exist, which is useful
1608: if the user uses the `return' command in the debugger. */
1609:
1610: if (is_volatile || is_longjmp)
1611: emit_barrier ();
1612:
1613: /* If value type not void, return an rtx for the value. */
1614:
1615: /* If there are cleanups to be called, don't use a hard reg as target. */
1616: if (cleanups_this_call != old_cleanups
1617: && target && REG_P (target)
1618: && REGNO (target) < FIRST_PSEUDO_REGISTER)
1619: target = 0;
1620:
1621: if (TYPE_MODE (TREE_TYPE (exp)) == VOIDmode
1622: || ignore)
1623: {
1624: target = const0_rtx;
1625: }
1626: else if (structure_value_addr)
1627: {
1628: if (target == 0 || GET_CODE (target) != MEM)
1.1.1.3 ! root 1629: {
! 1630: target = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)),
! 1631: memory_address (TYPE_MODE (TREE_TYPE (exp)),
! 1632: structure_value_addr));
! 1633: MEM_IN_STRUCT_P (target)
! 1634: = (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
! 1635: || TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
! 1636: || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE);
! 1637: }
1.1 root 1638: }
1639: else if (pcc_struct_value)
1640: {
1641: if (target == 0)
1.1.1.3 ! root 1642: {
! 1643: target = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)),
! 1644: copy_to_reg (valreg));
! 1645: MEM_IN_STRUCT_P (target)
! 1646: = (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
! 1647: || TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
! 1648: || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE);
! 1649: }
1.1 root 1650: else if (TYPE_MODE (TREE_TYPE (exp)) != BLKmode)
1651: emit_move_insn (target, gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)),
1652: copy_to_reg (valreg)));
1653: else
1654: emit_block_move (target, gen_rtx (MEM, BLKmode, copy_to_reg (valreg)),
1655: expr_size (exp),
1656: TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT);
1657: }
1658: else if (target && GET_MODE (target) == TYPE_MODE (TREE_TYPE (exp)))
1659: /* TARGET and VALREG cannot be equal at this point because the latter
1660: would not have REG_FUNCTION_VALUE_P true, while the former would if
1661: it were referring to the same register.
1662:
1663: If they refer to the same register, this move will be a no-op, except
1664: when function inlining is being done. */
1665: emit_move_insn (target, valreg);
1666: else
1667: target = copy_to_reg (valreg);
1668:
1669: /* Perform all cleanups needed for the arguments of this call
1670: (i.e. destructors in C++). */
1671: expand_cleanups_to (old_cleanups);
1672:
1.1.1.3 ! root 1673: /* If size of args is variable or this was a constructor call for a stack
! 1674: argument, restore saved stack-pointer value. */
1.1 root 1675:
1676: if (old_stack_level)
1677: {
1.1.1.3 ! root 1678: emit_stack_restore (SAVE_BLOCK, old_stack_level, 0);
1.1 root 1679: pending_stack_adjust = old_pending_adj;
1.1.1.3 ! root 1680: #ifdef ACCUMULATE_OUTGOING_ARGS
! 1681: stack_arg_under_construction = old_stack_arg_under_construction;
! 1682: highest_outgoing_arg_in_use = initial_highest_arg_in_use;
! 1683: stack_usage_map = initial_stack_usage_map;
! 1684: #endif
1.1 root 1685: }
1686: #ifdef ACCUMULATE_OUTGOING_ARGS
1687: else
1688: {
1689: #ifdef REG_PARM_STACK_SPACE
1690: if (save_area)
1691: {
1692: enum machine_mode save_mode = GET_MODE (save_area);
1693: rtx stack_area
1694: = gen_rtx (MEM, save_mode,
1695: memory_address (save_mode,
1696: plus_constant (argblock, low_to_save)));
1697:
1698: if (save_mode != BLKmode)
1699: emit_move_insn (stack_area, save_area);
1700: else
1701: emit_block_move (stack_area, validize_mem (save_area),
1702: gen_rtx (CONST_INT, VOIDmode,
1703: high_to_save - low_to_save + 1,
1704: PARM_BOUNDARY / BITS_PER_UNIT));
1705: }
1706: #endif
1707:
1708: /* If we saved any argument areas, restore them. */
1709: for (i = 0; i < num_actuals; i++)
1710: if (args[i].save_area)
1711: {
1712: enum machine_mode save_mode = GET_MODE (args[i].save_area);
1713: rtx stack_area
1714: = gen_rtx (MEM, save_mode,
1715: memory_address (save_mode,
1716: XEXP (args[i].stack_slot, 0)));
1717:
1718: if (save_mode != BLKmode)
1719: emit_move_insn (stack_area, args[i].save_area);
1720: else
1721: emit_block_move (stack_area, validize_mem (args[i].save_area),
1722: gen_rtx (CONST_INT, VOIDmode,
1723: args[i].size.constant),
1724: PARM_BOUNDARY / BITS_PER_UNIT);
1725: }
1726:
1727: highest_outgoing_arg_in_use = initial_highest_arg_in_use;
1728: stack_usage_map = initial_stack_usage_map;
1729: }
1730: #endif
1731:
1.1.1.3 ! root 1732: /* If this was alloca, record the new stack level for nonlocal gotos.
! 1733: Check for the handler slots since we might not have a save area
! 1734: for non-local gotos. */
! 1735:
! 1736: if (may_be_alloca && nonlocal_goto_handler_slot != 0)
! 1737: emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, 0);
1.1 root 1738:
1739: pop_temp_slots ();
1740:
1741: return target;
1742: }
1743:
1744: #if 0
1745: /* Return an rtx which represents a suitable home on the stack
1746: given TYPE, the type of the argument looking for a home.
1747: This is called only for BLKmode arguments.
1748:
1749: SIZE is the size needed for this target.
1750: ARGS_ADDR is the address of the bottom of the argument block for this call.
1751: OFFSET describes this parameter's offset into ARGS_ADDR. It is meaningless
1752: if this machine uses push insns. */
1753:
1754: static rtx
1755: target_for_arg (type, size, args_addr, offset)
1756: tree type;
1757: rtx size;
1758: rtx args_addr;
1759: struct args_size offset;
1760: {
1761: rtx target;
1762: rtx offset_rtx = ARGS_SIZE_RTX (offset);
1763:
1764: /* We do not call memory_address if possible,
1765: because we want to address as close to the stack
1766: as possible. For non-variable sized arguments,
1767: this will be stack-pointer relative addressing. */
1768: if (GET_CODE (offset_rtx) == CONST_INT)
1769: target = plus_constant (args_addr, INTVAL (offset_rtx));
1770: else
1771: {
1772: /* I have no idea how to guarantee that this
1773: will work in the presence of register parameters. */
1774: target = gen_rtx (PLUS, Pmode, args_addr, offset_rtx);
1775: target = memory_address (QImode, target);
1776: }
1777:
1778: return gen_rtx (MEM, BLKmode, target);
1779: }
1780: #endif
1781:
1782: /* Store a single argument for a function call
1783: into the register or memory area where it must be passed.
1784: *ARG describes the argument value and where to pass it.
1785:
1786: ARGBLOCK is the address of the stack-block for all the arguments,
1.1.1.2 root 1787: or 0 on a machine where arguments are pushed individually.
1.1 root 1788:
1789: MAY_BE_ALLOCA nonzero says this could be a call to `alloca'
1790: so must be careful about how the stack is used.
1791:
1792: VARIABLE_SIZE nonzero says that this was a variable-sized outgoing
1793: argument stack. This is used if ACCUMULATE_OUTGOING_ARGS to indicate
1794: that we need not worry about saving and restoring the stack.
1795:
1796: FNDECL is the declaration of the function we are calling. */
1797:
1798: static void
1.1.1.3 ! root 1799: store_one_arg (arg, argblock, may_be_alloca, variable_size, fndecl,
! 1800: reg_parm_stack_space)
1.1 root 1801: struct arg_data *arg;
1802: rtx argblock;
1803: int may_be_alloca;
1804: int variable_size;
1805: tree fndecl;
1.1.1.3 ! root 1806: int reg_parm_stack_space;
1.1 root 1807: {
1808: register tree pval = arg->tree_value;
1809: rtx reg = 0;
1810: int partial = 0;
1811: int used = 0;
1812: int i, lower_bound, upper_bound;
1813:
1814: if (TREE_CODE (pval) == ERROR_MARK)
1815: return;
1816:
1817: #ifdef ACCUMULATE_OUTGOING_ARGS
1818: /* If this is being stored into a pre-allocated, fixed-size, stack area,
1819: save any previous data at that location. */
1820: if (argblock && ! variable_size && arg->stack)
1821: {
1822: #ifdef ARGS_GROW_DOWNWARD
1823: /* stack_slot is negative, but we want to index stack_usage_map */
1824: /* with positive values. */
1825: if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
1826: upper_bound = -INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1)) + 1;
1827: else
1828: abort ();
1829:
1830: lower_bound = upper_bound - arg->size.constant;
1831: #else
1832: if (GET_CODE (XEXP (arg->stack_slot, 0)) == PLUS)
1833: lower_bound = INTVAL (XEXP (XEXP (arg->stack_slot, 0), 1));
1834: else
1835: lower_bound = 0;
1836:
1837: upper_bound = lower_bound + arg->size.constant;
1838: #endif
1839:
1840: for (i = lower_bound; i < upper_bound; i++)
1841: if (stack_usage_map[i]
1842: #ifdef REG_PARM_STACK_SPACE
1843: /* Don't store things in the fixed argument area at this point;
1844: it has already been saved. */
1.1.1.3 ! root 1845: && i > reg_parm_stack_space
1.1 root 1846: #endif
1847: )
1848: break;
1849:
1850: if (i != upper_bound)
1851: {
1852: /* We need to make a save area. See what mode we can make it. */
1853: enum machine_mode save_mode
1854: = mode_for_size (arg->size.constant * BITS_PER_UNIT, MODE_INT, 1);
1855: rtx stack_area
1856: = gen_rtx (MEM, save_mode,
1857: memory_address (save_mode, XEXP (arg->stack_slot, 0)));
1858:
1859: if (save_mode == BLKmode)
1860: {
1861: arg->save_area = assign_stack_temp (BLKmode,
1862: arg->size.constant, 1);
1863: emit_block_move (validize_mem (arg->save_area), stack_area,
1864: gen_rtx (CONST_INT, VOIDmode,
1865: arg->size.constant),
1866: PARM_BOUNDARY / BITS_PER_UNIT);
1867: }
1868: else
1869: {
1870: arg->save_area = gen_reg_rtx (save_mode);
1871: emit_move_insn (arg->save_area, stack_area);
1872: }
1873: }
1874: }
1875: #endif
1876:
1877: /* If this isn't going to be placed on both the stack and in registers,
1878: set up the register and number of words. */
1879: if (! arg->pass_on_stack)
1880: reg = arg->reg, partial = arg->partial;
1881:
1882: if (reg != 0 && partial == 0)
1883: /* Being passed entirely in a register. We shouldn't be called in
1884: this case. */
1885: abort ();
1886:
1887: /* If this is being partially passed in a register, but multiple locations
1888: are specified, we assume that the one partially used is the one that is
1889: listed first. */
1890: if (reg && GET_CODE (reg) == EXPR_LIST)
1891: reg = XEXP (reg, 0);
1892:
1893: /* If this is being passes partially in a register, we can't evaluate
1894: it directly into its stack slot. Otherwise, we can. */
1895: if (arg->value == 0)
1.1.1.3 ! root 1896: {
! 1897: #ifdef ACCUMULATE_OUTGOING_ARGS
! 1898: /* stack_arg_under_construction is nonzero if a function argument is
! 1899: being evaluated directly into the outgoing argument list and
! 1900: expand_call must take special action to preserve the argument list
! 1901: if it is called recursively.
! 1902:
! 1903: For scalar function arguments stack_usage_map is sufficient to
! 1904: determine which stack slots must be saved and restored. Scalar
! 1905: arguments in general have pass_on_stack == 0.
! 1906:
! 1907: If this argument is initialized by a function which takes the
! 1908: address of the argument (a C++ constructor or a C function
! 1909: returning a BLKmode structure), then stack_usage_map is
! 1910: insufficient and expand_call must push the stack around the
! 1911: function call. Such arguments have pass_on_stack == 1.
! 1912:
! 1913: Note that it is always safe to set stack_arg_under_construction,
! 1914: but this generates suboptimal code if set when not needed. */
! 1915:
! 1916: if (arg->pass_on_stack)
! 1917: stack_arg_under_construction++;
! 1918: #endif
! 1919: arg->value = expand_expr (pval, partial ? 0 : arg->stack, VOIDmode, 0);
! 1920: #ifdef ACCUMULATE_OUTGOING_ARGS
! 1921: if (arg->pass_on_stack)
! 1922: stack_arg_under_construction--;
! 1923: #endif
! 1924: }
1.1 root 1925:
1926: /* Don't allow anything left on stack from computation
1927: of argument to alloca. */
1928: if (may_be_alloca)
1929: do_pending_stack_adjust ();
1930:
1931: if (arg->value == arg->stack)
1932: /* If the value is already in the stack slot, we are done. */
1933: ;
1934: else if (TYPE_MODE (TREE_TYPE (pval)) != BLKmode)
1935: {
1936: register int size;
1937:
1938: /* Argument is a scalar, not entirely passed in registers.
1939: (If part is passed in registers, arg->partial says how much
1940: and emit_push_insn will take care of putting it there.)
1941:
1942: Push it, and if its size is less than the
1943: amount of space allocated to it,
1944: also bump stack pointer by the additional space.
1945: Note that in C the default argument promotions
1946: will prevent such mismatches. */
1947:
1948: size = GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (pval)));
1949: /* Compute how much space the push instruction will push.
1950: On many machines, pushing a byte will advance the stack
1951: pointer by a halfword. */
1952: #ifdef PUSH_ROUNDING
1953: size = PUSH_ROUNDING (size);
1954: #endif
1955: used = size;
1956:
1957: /* Compute how much space the argument should get:
1958: round up to a multiple of the alignment for arguments. */
1959: if (none != FUNCTION_ARG_PADDING (TYPE_MODE (TREE_TYPE (pval)),
1960: TREE_TYPE (pval)))
1961: used = (((size + PARM_BOUNDARY / BITS_PER_UNIT - 1)
1962: / (PARM_BOUNDARY / BITS_PER_UNIT))
1963: * (PARM_BOUNDARY / BITS_PER_UNIT));
1964:
1965: /* This isn't already where we want it on the stack, so put it there.
1966: This can either be done with push or copy insns. */
1967: emit_push_insn (arg->value, TYPE_MODE (TREE_TYPE (pval)),
1968: TREE_TYPE (pval), 0, 0, partial, reg,
1969: used - size, argblock, ARGS_SIZE_RTX (arg->offset));
1970: }
1971: else
1972: {
1973: /* BLKmode, at least partly to be pushed. */
1974:
1975: register int excess;
1976: rtx size_rtx;
1977:
1978: /* Pushing a nonscalar.
1979: If part is passed in registers, PARTIAL says how much
1980: and emit_push_insn will take care of putting it there. */
1981:
1982: /* Round its size up to a multiple
1983: of the allocation unit for arguments. */
1984:
1985: if (arg->size.var != 0)
1986: {
1987: excess = 0;
1988: size_rtx = ARGS_SIZE_RTX (arg->size);
1989: }
1990: else
1991: {
1992: register tree size = size_in_bytes (TREE_TYPE (pval));
1993: /* PUSH_ROUNDING has no effect on us, because
1994: emit_push_insn for BLKmode is careful to avoid it. */
1995: excess = (arg->size.constant - TREE_INT_CST_LOW (size)
1996: + partial * UNITS_PER_WORD);
1997: size_rtx = expand_expr (size, 0, VOIDmode, 0);
1998: }
1999:
2000: emit_push_insn (arg->value, TYPE_MODE (TREE_TYPE (pval)),
2001: TREE_TYPE (pval), size_rtx,
2002: TYPE_ALIGN (TREE_TYPE (pval)) / BITS_PER_UNIT, partial,
2003: reg, excess, argblock, ARGS_SIZE_RTX (arg->offset));
2004: }
2005:
2006:
2007: /* Unless this is a partially-in-register argument, the argument is now
2008: in the stack.
2009:
2010: ??? Note that this can change arg->value from arg->stack to
2011: arg->stack_slot and it matters when they are not the same.
2012: It isn't totally clear that this is correct in all cases. */
2013: if (partial == 0)
2014: arg->value = arg->stack_slot;
2015:
2016: /* Once we have pushed something, pops can't safely
2017: be deferred during the rest of the arguments. */
2018: NO_DEFER_POP;
2019:
2020: /* ANSI doesn't require a sequence point here,
2021: but PCC has one, so this will avoid some problems. */
2022: emit_queue ();
2023:
2024: /* Free any temporary slots made in processing this argument. */
2025: free_temp_slots ();
2026:
2027: #ifdef ACCUMULATE_OUTGOING_ARGS
2028: /* Now mark the segment we just used. */
2029: if (argblock && ! variable_size && arg->stack)
2030: for (i = lower_bound; i < upper_bound; i++)
2031: stack_usage_map[i] = 1;
2032: #endif
2033: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.