![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to function.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cc|
Return to function.c CVS log | Up to [Apple XNU] / GNUtools / cc |
1.1 root 1: /* Expands front end tree to back end RTL for GNU C-Compiler
2: Copyright (C) 1987, 88, 89, 91, 92, 1993 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:
21: /* This file handles the generation of rtl code from tree structure
22: at the level of the function as a whole.
23: It creates the rtl expressions for parameters and auto variables
24: and has full responsibility for allocating stack slots.
25:
26: `expand_function_start' is called at the beginning of a function,
27: before the function body is parsed, and `expand_function_end' is
28: called after parsing the body.
29:
30: Call `assign_stack_local' to allocate a stack slot for a local variable.
31: This is usually done during the RTL generation for the function body,
32: but it can also be done in the reload pass when a pseudo-register does
33: not get a hard register.
34:
35: Call `put_var_into_stack' when you learn, belatedly, that a variable
36: previously given a pseudo-register must in fact go in the stack.
37: This function changes the DECL_RTL to be a stack slot instead of a reg
38: then scans all the RTL instructions so far generated to correct them. */
39:
40: #include "config.h"
41:
42: #include <stdio.h>
43:
44: #include "rtl.h"
45: #include "tree.h"
46: #include "flags.h"
47: #include "function.h"
48: #include "insn-flags.h"
49: #include "expr.h"
50: #include "insn-codes.h"
51: #include "regs.h"
52: #include "hard-reg-set.h"
53: #include "insn-config.h"
54: #include "recog.h"
55: #include "output.h"
56: #include "basic-block.h"
57: #include "obstack.h"
58: #include "bytecode.h"
59:
60: /* Some systems use __main in a way incompatible with its use in gcc, in these
61: cases use the macros NAME__MAIN to give a quoted symbol and SYMBOL__MAIN to
62: give the same symbol without quotes for an alternative entry point. You
63: must define both, or niether. */
64: #ifndef NAME__MAIN
65: #define NAME__MAIN "__main"
66: #define SYMBOL__MAIN __main
67: #endif
68:
69: /* Round a value to the lowest integer less than it that is a multiple of
70: the required alignment. Avoid using division in case the value is
71: negative. Assume the alignment is a power of two. */
72: #define FLOOR_ROUND(VALUE,ALIGN) ((VALUE) & ~((ALIGN) - 1))
73:
74: /* Similar, but round to the next highest integer that meets the
75: alignment. */
76: #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
77:
78: /* NEED_SEPARATE_AP means that we cannot derive ap from the value of fp
79: during rtl generation. If they are different register numbers, this is
80: always true. It may also be true if
81: FIRST_PARM_OFFSET - STARTING_FRAME_OFFSET is not a constant during rtl
82: generation. See fix_lexical_addr for details. */
83:
84: #if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
85: #define NEED_SEPARATE_AP
86: #endif
87:
88: /* Number of bytes of args popped by function being compiled on its return.
89: Zero if no bytes are to be popped.
90: May affect compilation of return insn or of function epilogue. */
91:
92: int current_function_pops_args;
93:
94: /* Nonzero if function being compiled needs to be given an address
95: where the value should be stored. */
96:
97: int current_function_returns_struct;
98:
99: /* Nonzero if function being compiled needs to
100: return the address of where it has put a structure value. */
101:
102: int current_function_returns_pcc_struct;
103:
104: /* Nonzero if function being compiled needs to be passed a static chain. */
105:
106: int current_function_needs_context;
107:
108: /* Nonzero if function being compiled can call setjmp. */
109:
110: int current_function_calls_setjmp;
111:
112: /* Nonzero if function being compiled can call longjmp. */
113:
114: int current_function_calls_longjmp;
115:
116: /* Nonzero if function being compiled receives nonlocal gotos
117: from nested functions. */
118:
119: int current_function_has_nonlocal_label;
120:
121: /* Nonzero if function being compiled has nonlocal gotos to parent
122: function. */
123:
124: int current_function_has_nonlocal_goto;
125:
126: /* Nonzero if function being compiled contains nested functions. */
127:
128: int current_function_contains_functions;
129:
130: /* Nonzero if function being compiled can call alloca,
131: either as a subroutine or builtin. */
132:
133: int current_function_calls_alloca;
134:
135: /* Nonzero if the current function returns a pointer type */
136:
137: int current_function_returns_pointer;
138:
139: /* If some insns can be deferred to the delay slots of the epilogue, the
140: delay list for them is recorded here. */
141:
142: rtx current_function_epilogue_delay_list;
143:
144: /* If function's args have a fixed size, this is that size, in bytes.
145: Otherwise, it is -1.
146: May affect compilation of return insn or of function epilogue. */
147:
148: int current_function_args_size;
149:
150: /* # bytes the prologue should push and pretend that the caller pushed them.
151: The prologue must do this, but only if parms can be passed in registers. */
152:
153: int current_function_pretend_args_size;
154:
155: /* # of bytes of outgoing arguments required to be pushed by the prologue.
156: If this is non-zero, it means that ACCUMULATE_OUTGOING_ARGS was defined
157: and no stack adjusts will be done on function calls. */
158:
159: int current_function_outgoing_args_size;
160:
161: /* This is the offset from the arg pointer to the place where the first
162: anonymous arg can be found, if there is one. */
163:
164: rtx current_function_arg_offset_rtx;
165:
166: /* Nonzero if current function uses varargs.h or equivalent.
167: Zero for functions that use stdarg.h. */
168:
169: int current_function_varargs;
170:
171: /* Quantities of various kinds of registers
172: used for the current function's args. */
173:
174: CUMULATIVE_ARGS current_function_args_info;
175:
176: /* Name of function now being compiled. */
177:
178: char *current_function_name;
179:
180: /* If non-zero, an RTL expression for that location at which the current
181: function returns its result. Always equal to
182: DECL_RTL (DECL_RESULT (current_function_decl)), but provided
183: independently of the tree structures. */
184:
185: rtx current_function_return_rtx;
186:
187: /* Nonzero if the current function uses the constant pool. */
188:
189: int current_function_uses_const_pool;
190:
191: /* Nonzero if the current function uses pic_offset_table_rtx. */
192: int current_function_uses_pic_offset_table;
193:
194: /* The arg pointer hard register, or the pseudo into which it was copied. */
195: rtx current_function_internal_arg_pointer;
196:
197: /* The FUNCTION_DECL for an inline function currently being expanded. */
198: tree inline_function_decl;
199:
200: /* Number of function calls seen so far in current function. */
201:
202: int function_call_count;
203:
204: /* List (chain of TREE_LIST) of LABEL_DECLs for all nonlocal labels
205: (labels to which there can be nonlocal gotos from nested functions)
206: in this function. */
207:
208: tree nonlocal_labels;
209:
210: /* RTX for stack slot that holds the current handler for nonlocal gotos.
211: Zero when function does not have nonlocal labels. */
212:
213: rtx nonlocal_goto_handler_slot;
214:
215: /* RTX for stack slot that holds the stack pointer value to restore
216: for a nonlocal goto.
217: Zero when function does not have nonlocal labels. */
218:
219: rtx nonlocal_goto_stack_level;
220:
221: /* Label that will go on parm cleanup code, if any.
222: Jumping to this label runs cleanup code for parameters, if
223: such code must be run. Following this code is the logical return label. */
224:
225: rtx cleanup_label;
226:
227: /* Label that will go on function epilogue.
228: Jumping to this label serves as a "return" instruction
229: on machines which require execution of the epilogue on all returns. */
230:
231: rtx return_label;
232:
233: /* List (chain of EXPR_LISTs) of pseudo-regs of SAVE_EXPRs.
234: So we can mark them all live at the end of the function, if nonopt. */
235: rtx save_expr_regs;
236:
237: /* List (chain of EXPR_LISTs) of all stack slots in this function.
238: Made for the sake of unshare_all_rtl. */
239: rtx stack_slot_list;
240:
241: /* Chain of all RTL_EXPRs that have insns in them. */
242: tree rtl_expr_chain;
243:
244: /* Label to jump back to for tail recursion, or 0 if we have
245: not yet needed one for this function. */
246: rtx tail_recursion_label;
247:
248: /* Place after which to insert the tail_recursion_label if we need one. */
249: rtx tail_recursion_reentry;
250:
251: /* Location at which to save the argument pointer if it will need to be
252: referenced. There are two cases where this is done: if nonlocal gotos
253: exist, or if vars stored at an offset from the argument pointer will be
254: needed by inner routines. */
255:
256: rtx arg_pointer_save_area;
257:
258: /* Offset to end of allocated area of stack frame.
259: If stack grows down, this is the address of the last stack slot allocated.
260: If stack grows up, this is the address for the next slot. */
261: int frame_offset;
262:
263: /* List (chain of TREE_LISTs) of static chains for containing functions.
264: Each link has a FUNCTION_DECL in the TREE_PURPOSE and a reg rtx
265: in an RTL_EXPR in the TREE_VALUE. */
266: static tree context_display;
267:
268: /* List (chain of TREE_LISTs) of trampolines for nested functions.
269: The trampoline sets up the static chain and jumps to the function.
270: We supply the trampoline's address when the function's address is requested.
271:
272: Each link has a FUNCTION_DECL in the TREE_PURPOSE and a reg rtx
273: in an RTL_EXPR in the TREE_VALUE. */
274: static tree trampoline_list;
275:
276: /* Insn after which register parms and SAVE_EXPRs are born, if nonopt. */
277: static rtx parm_birth_insn;
278:
279: #if 0
280: /* Nonzero if a stack slot has been generated whose address is not
281: actually valid. It means that the generated rtl must all be scanned
282: to detect and correct the invalid addresses where they occur. */
283: static int invalid_stack_slot;
284: #endif
285:
286: /* Last insn of those whose job was to put parms into their nominal homes. */
287: static rtx last_parm_insn;
288:
289: /* 1 + last pseudo register number used for loading a copy
290: of a parameter of this function. */
291: static int max_parm_reg;
292:
293: /* Vector indexed by REGNO, containing location on stack in which
294: to put the parm which is nominally in pseudo register REGNO,
295: if we discover that that parm must go in the stack. */
296: static rtx *parm_reg_stack_loc;
297:
298: #if 0 /* Turned off because 0 seems to work just as well. */
299: /* Cleanup lists are required for binding levels regardless of whether
300: that binding level has cleanups or not. This node serves as the
301: cleanup list whenever an empty list is required. */
302: static tree empty_cleanup_list;
303: #endif
304:
305: /* Nonzero once virtual register instantiation has been done.
306: assign_stack_local uses frame_pointer_rtx when this is nonzero. */
307: static int virtuals_instantiated;
308:
309: /* These variables hold pointers to functions to
310: save and restore machine-specific data,
311: in push_function_context and pop_function_context. */
312: void (*save_machine_status) ();
313: void (*restore_machine_status) ();
314:
315: /* Nonzero if we need to distinguish between the return value of this function
316: and the return value of a function called by this function. This helps
317: integrate.c */
318:
319: extern int rtx_equal_function_value_matters;
320: extern tree sequence_rtl_expr;
321: extern tree bc_runtime_type_code ();
322: extern rtx bc_build_calldesc ();
323: extern char *bc_emit_trampoline ();
324: extern char *bc_end_function ();
325:
326: void fixup_gotos ();
327:
328: static tree round_down ();
329: static rtx round_trampoline_addr ();
330: static rtx fixup_stack_1 ();
331: static void put_reg_into_stack ();
332: static void fixup_var_refs ();
333: static void fixup_var_refs_insns ();
334: static void fixup_var_refs_1 ();
335: static void optimize_bit_field ();
336: static void instantiate_decls ();
337: static void instantiate_decls_1 ();
338: static void instantiate_decl ();
339: static int instantiate_virtual_regs_1 ();
340: static rtx fixup_memory_subreg ();
341: static rtx walk_fixup_memory_subreg ();
342:
343: /* In order to evaluate some expressions, such as function calls returning
344: structures in memory, we need to temporarily allocate stack locations.
345: We record each allocated temporary in the following structure.
346:
347: Associated with each temporary slot is a nesting level. When we pop up
348: one level, all temporaries associated with the previous level are freed.
349: Normally, all temporaries are freed after the execution of the statement
350: in which they were created. However, if we are inside a ({...}) grouping,
351: the result may be in a temporary and hence must be preserved. If the
352: result could be in a temporary, we preserve it if we can determine which
353: one it is in. If we cannot determine which temporary may contain the
354: result, all temporaries are preserved. A temporary is preserved by
355: pretending it was allocated at the previous nesting level.
356:
357: Automatic variables are also assigned temporary slots, at the nesting
358: level where they are defined. They are marked a "kept" so that
359: free_temp_slots will not free them. */
360:
361: struct temp_slot
362: {
363: /* Points to next temporary slot. */
364: struct temp_slot *next;
365: /* The rtx to used to reference the slot. */
366: rtx slot;
367: /* The size, in units, of the slot. */
368: int size;
369: /* The value of `sequence_rtl_expr' when this temporary is allocated. */
370: tree rtl_expr;
371: /* Non-zero if this temporary is currently in use. */
372: char in_use;
373: /* Nesting level at which this slot is being used. */
374: int level;
375: /* Non-zero if this should survive a call to free_temp_slots. */
376: int keep;
377: };
378:
379: /* List of all temporaries allocated, both available and in use. */
380:
381: struct temp_slot *temp_slots;
382:
383: /* Current nesting level for temporaries. */
384:
385: int temp_slot_level;
386:
387: /* The FUNCTION_DECL node for the current function. */
388: static tree this_function_decl;
389:
390: /* Callinfo pointer for the current function. */
391: static rtx this_function_callinfo;
392:
393: /* The label in the bytecode file of this function's actual bytecode.
394: Not an rtx. */
395: static char *this_function_bytecode;
396:
397: /* The call description vector for the current function. */
398: static rtx this_function_calldesc;
399:
400: /* Size of the local variables allocated for the current function. */
401: int local_vars_size;
402:
403: /* Current depth of the bytecode evaluation stack. */
404: int stack_depth;
405:
406: /* Maximum depth of the evaluation stack in this function. */
407: int max_stack_depth;
408:
409: /* Current depth in statement expressions. */
410: static int stmt_expr_depth;
411:
412: /* Pointer to chain of `struct function' for containing functions. */
413: struct function *outer_function_chain;
414:
415: /* Given a function decl for a containing function,
416: return the `struct function' for it. */
417:
418: struct function *
419: find_function_data (decl)
420: tree decl;
421: {
422: struct function *p;
423: for (p = outer_function_chain; p; p = p->next)
424: if (p->decl == decl)
425: return p;
426: abort ();
427: }
428:
429: /* Save the current context for compilation of a nested function.
430: This is called from language-specific code.
431: The caller is responsible for saving any language-specific status,
432: since this function knows only about language-independent variables. */
433:
434: void
435: push_function_context ()
436: {
437: struct function *p = (struct function *) xmalloc (sizeof (struct function));
438:
439: p->next = outer_function_chain;
440: outer_function_chain = p;
441:
442: p->name = current_function_name;
443: p->decl = current_function_decl;
444: p->pops_args = current_function_pops_args;
445: p->returns_struct = current_function_returns_struct;
446: p->returns_pcc_struct = current_function_returns_pcc_struct;
447: p->needs_context = current_function_needs_context;
448: p->calls_setjmp = current_function_calls_setjmp;
449: p->calls_longjmp = current_function_calls_longjmp;
450: p->calls_alloca = current_function_calls_alloca;
451: p->has_nonlocal_label = current_function_has_nonlocal_label;
452: p->has_nonlocal_goto = current_function_has_nonlocal_goto;
453: p->args_size = current_function_args_size;
454: p->pretend_args_size = current_function_pretend_args_size;
455: p->arg_offset_rtx = current_function_arg_offset_rtx;
456: p->uses_const_pool = current_function_uses_const_pool;
457: p->uses_pic_offset_table = current_function_uses_pic_offset_table;
458: p->internal_arg_pointer = current_function_internal_arg_pointer;
459: p->max_parm_reg = max_parm_reg;
460: p->parm_reg_stack_loc = parm_reg_stack_loc;
461: p->outgoing_args_size = current_function_outgoing_args_size;
462: p->return_rtx = current_function_return_rtx;
463: p->nonlocal_goto_handler_slot = nonlocal_goto_handler_slot;
464: p->nonlocal_goto_stack_level = nonlocal_goto_stack_level;
465: p->nonlocal_labels = nonlocal_labels;
466: p->cleanup_label = cleanup_label;
467: p->return_label = return_label;
468: p->save_expr_regs = save_expr_regs;
469: p->stack_slot_list = stack_slot_list;
470: p->parm_birth_insn = parm_birth_insn;
471: p->frame_offset = frame_offset;
472: p->tail_recursion_label = tail_recursion_label;
473: p->tail_recursion_reentry = tail_recursion_reentry;
474: p->arg_pointer_save_area = arg_pointer_save_area;
475: p->rtl_expr_chain = rtl_expr_chain;
476: p->last_parm_insn = last_parm_insn;
477: p->context_display = context_display;
478: p->trampoline_list = trampoline_list;
479: p->function_call_count = function_call_count;
480: p->temp_slots = temp_slots;
481: p->temp_slot_level = temp_slot_level;
482: p->fixup_var_refs_queue = 0;
483: p->epilogue_delay_list = current_function_epilogue_delay_list;
484:
485: save_tree_status (p);
486: save_storage_status (p);
487: save_emit_status (p);
488: init_emit ();
489: save_expr_status (p);
490: save_stmt_status (p);
491: save_varasm_status (p);
492:
493: if (save_machine_status)
494: (*save_machine_status) (p);
495: }
496:
497: /* Restore the last saved context, at the end of a nested function.
498: This function is called from language-specific code. */
499:
500: void
501: pop_function_context ()
502: {
503: struct function *p = outer_function_chain;
504:
505: outer_function_chain = p->next;
506:
507: current_function_name = p->name;
508: current_function_decl = p->decl;
509: current_function_pops_args = p->pops_args;
510: current_function_returns_struct = p->returns_struct;
511: current_function_returns_pcc_struct = p->returns_pcc_struct;
512: current_function_needs_context = p->needs_context;
513: current_function_calls_setjmp = p->calls_setjmp;
514: current_function_calls_longjmp = p->calls_longjmp;
515: current_function_calls_alloca = p->calls_alloca;
516: current_function_has_nonlocal_label = p->has_nonlocal_label;
517: current_function_has_nonlocal_goto = p->has_nonlocal_goto;
518: current_function_contains_functions = 1;
519: current_function_args_size = p->args_size;
520: current_function_pretend_args_size = p->pretend_args_size;
521: current_function_arg_offset_rtx = p->arg_offset_rtx;
522: current_function_uses_const_pool = p->uses_const_pool;
523: current_function_uses_pic_offset_table = p->uses_pic_offset_table;
524: current_function_internal_arg_pointer = p->internal_arg_pointer;
525: max_parm_reg = p->max_parm_reg;
526: parm_reg_stack_loc = p->parm_reg_stack_loc;
527: current_function_outgoing_args_size = p->outgoing_args_size;
528: current_function_return_rtx = p->return_rtx;
529: nonlocal_goto_handler_slot = p->nonlocal_goto_handler_slot;
530: nonlocal_goto_stack_level = p->nonlocal_goto_stack_level;
531: nonlocal_labels = p->nonlocal_labels;
532: cleanup_label = p->cleanup_label;
533: return_label = p->return_label;
534: save_expr_regs = p->save_expr_regs;
535: stack_slot_list = p->stack_slot_list;
536: parm_birth_insn = p->parm_birth_insn;
537: frame_offset = p->frame_offset;
538: tail_recursion_label = p->tail_recursion_label;
539: tail_recursion_reentry = p->tail_recursion_reentry;
540: arg_pointer_save_area = p->arg_pointer_save_area;
541: rtl_expr_chain = p->rtl_expr_chain;
542: last_parm_insn = p->last_parm_insn;
543: context_display = p->context_display;
544: trampoline_list = p->trampoline_list;
545: function_call_count = p->function_call_count;
546: temp_slots = p->temp_slots;
547: temp_slot_level = p->temp_slot_level;
548: current_function_epilogue_delay_list = p->epilogue_delay_list;
549:
550: restore_tree_status (p);
551: restore_storage_status (p);
552: restore_expr_status (p);
553: restore_emit_status (p);
554: restore_stmt_status (p);
555: restore_varasm_status (p);
556:
557: if (restore_machine_status)
558: (*restore_machine_status) (p);
559:
560: /* Finish doing put_var_into_stack for any of our variables
561: which became addressable during the nested function. */
562: {
563: struct var_refs_queue *queue = p->fixup_var_refs_queue;
564: for (; queue; queue = queue->next)
565: fixup_var_refs (queue->modified, queue->promoted_mode, queue->unsignedp);
566: }
567:
568: free (p);
569:
570: /* Reset variables that have known state during rtx generation. */
571: rtx_equal_function_value_matters = 1;
572: virtuals_instantiated = 0;
573: }
574:
575: /* Allocate fixed slots in the stack frame of the current function. */
576:
577: /* Return size needed for stack frame based on slots so far allocated.
578: This size counts from zero. It is not rounded to STACK_BOUNDARY;
579: the caller may have to do that. */
580:
581: int
582: get_frame_size ()
583: {
584: #ifdef FRAME_GROWS_DOWNWARD
585: return -frame_offset;
586: #else
587: return frame_offset;
588: #endif
589: }
590:
591: /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it
592: with machine mode MODE.
593:
594: ALIGN controls the amount of alignment for the address of the slot:
595: 0 means according to MODE,
596: -1 means use BIGGEST_ALIGNMENT and round size to multiple of that,
597: positive specifies alignment boundary in bits.
598:
599: We do not round to stack_boundary here. */
600:
601: rtx
602: assign_stack_local (mode, size, align)
603: enum machine_mode mode;
604: int size;
605: int align;
606: {
607: register rtx x, addr;
608: int bigend_correction = 0;
609: int alignment;
610:
611: if (align == 0)
612: {
613: alignment = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
614: if (mode == BLKmode)
615: alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
616: }
617: else if (align == -1)
618: {
619: alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
620: size = CEIL_ROUND (size, alignment);
621: }
622: else
623: alignment = align / BITS_PER_UNIT;
624:
625: /* Round frame offset to that alignment.
626: We must be careful here, since FRAME_OFFSET might be negative and
627: division with a negative dividend isn't as well defined as we might
628: like. So we instead assume that ALIGNMENT is a power of two and
629: use logical operations which are unambiguous. */
630: #ifdef FRAME_GROWS_DOWNWARD
631: frame_offset = FLOOR_ROUND (frame_offset, alignment);
632: #else
633: frame_offset = CEIL_ROUND (frame_offset, alignment);
634: #endif
635:
636: /* On a big-endian machine, if we are allocating more space than we will use,
637: use the least significant bytes of those that are allocated. */
638: #if BYTES_BIG_ENDIAN
639: if (mode != BLKmode)
640: bigend_correction = size - GET_MODE_SIZE (mode);
641: #endif
642:
643: #ifdef FRAME_GROWS_DOWNWARD
644: frame_offset -= size;
645: #endif
646:
647: /* If we have already instantiated virtual registers, return the actual
648: address relative to the frame pointer. */
649: if (virtuals_instantiated)
650: addr = plus_constant (frame_pointer_rtx,
651: (frame_offset + bigend_correction
652: + STARTING_FRAME_OFFSET));
653: else
654: addr = plus_constant (virtual_stack_vars_rtx,
655: frame_offset + bigend_correction);
656:
657: #ifndef FRAME_GROWS_DOWNWARD
658: frame_offset += size;
659: #endif
660:
661: x = gen_rtx (MEM, mode, addr);
662:
663: stack_slot_list = gen_rtx (EXPR_LIST, VOIDmode, x, stack_slot_list);
664:
665: return x;
666: }
667:
668: /* Assign a stack slot in a containing function.
669: First three arguments are same as in preceding function.
670: The last argument specifies the function to allocate in. */
671:
672: rtx
673: assign_outer_stack_local (mode, size, align, function)
674: enum machine_mode mode;
675: int size;
676: int align;
677: struct function *function;
678: {
679: register rtx x, addr;
680: int bigend_correction = 0;
681: int alignment;
682:
683: /* Allocate in the memory associated with the function in whose frame
684: we are assigning. */
685: push_obstacks (function->function_obstack,
686: function->function_maybepermanent_obstack);
687:
688: if (align == 0)
689: {
690: alignment = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
691: if (mode == BLKmode)
692: alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
693: }
694: else if (align == -1)
695: {
696: alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
697: size = CEIL_ROUND (size, alignment);
698: }
699: else
700: alignment = align / BITS_PER_UNIT;
701:
702: /* Round frame offset to that alignment. */
703: #ifdef FRAME_GROWS_DOWNWARD
704: function->frame_offset = FLOOR_ROUND (function->frame_offset, alignment);
705: #else
706: function->frame_offset = CEIL_ROUND (function->frame_offset, alignment);
707: #endif
708:
709: /* On a big-endian machine, if we are allocating more space than we will use,
710: use the least significant bytes of those that are allocated. */
711: #if BYTES_BIG_ENDIAN
712: if (mode != BLKmode)
713: bigend_correction = size - GET_MODE_SIZE (mode);
714: #endif
715:
716: #ifdef FRAME_GROWS_DOWNWARD
717: function->frame_offset -= size;
718: #endif
719: addr = plus_constant (virtual_stack_vars_rtx,
720: function->frame_offset + bigend_correction);
721: #ifndef FRAME_GROWS_DOWNWARD
722: function->frame_offset += size;
723: #endif
724:
725: x = gen_rtx (MEM, mode, addr);
726:
727: function->stack_slot_list
728: = gen_rtx (EXPR_LIST, VOIDmode, x, function->stack_slot_list);
729:
730: pop_obstacks ();
731:
732: return x;
733: }
734:
735: /* Allocate a temporary stack slot and record it for possible later
736: reuse.
737:
738: MODE is the machine mode to be given to the returned rtx.
739:
740: SIZE is the size in units of the space required. We do no rounding here
741: since assign_stack_local will do any required rounding.
742:
743: KEEP is non-zero if this slot is to be retained after a call to
744: free_temp_slots. Automatic variables for a block are allocated with this
745: flag. */
746:
747: rtx
748: assign_stack_temp (mode, size, keep)
749: enum machine_mode mode;
750: int size;
751: int keep;
752: {
753: struct temp_slot *p, *best_p = 0;
754:
755: /* First try to find an available, already-allocated temporary that is the
756: exact size we require. */
757: for (p = temp_slots; p; p = p->next)
758: if (p->size == size && GET_MODE (p->slot) == mode && ! p->in_use)
759: break;
760:
761: /* If we didn't find, one, try one that is larger than what we want. We
762: find the smallest such. */
763: if (p == 0)
764: for (p = temp_slots; p; p = p->next)
765: if (p->size > size && GET_MODE (p->slot) == mode && ! p->in_use
766: && (best_p == 0 || best_p->size > p->size))
767: best_p = p;
768:
769: /* Make our best, if any, the one to use. */
770: if (best_p)
771: {
772: /* If there are enough aligned bytes left over, make them into a new
773: temp_slot so that the extra bytes don't get wasted. Do this only
774: for BLKmode slots, so that we can be sure of the alignment. */
775: if (GET_MODE (best_p->slot) == BLKmode)
776: {
777: int alignment = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
778: int rounded_size = CEIL_ROUND (size, alignment);
779:
780: if (best_p->size - rounded_size >= alignment)
781: {
782: p = (struct temp_slot *) oballoc (sizeof (struct temp_slot));
783: p->in_use = 0;
784: p->size = best_p->size - rounded_size;
785: p->slot = gen_rtx (MEM, BLKmode,
786: plus_constant (XEXP (best_p->slot, 0),
787: rounded_size));
788: p->next = temp_slots;
789: temp_slots = p;
790:
791: stack_slot_list = gen_rtx (EXPR_LIST, VOIDmode, p->slot,
792: stack_slot_list);
793:
794: best_p->size = rounded_size;
795: }
796: }
797:
798: p = best_p;
799: }
800:
801:
802: /* If we still didn't find one, make a new temporary. */
803: if (p == 0)
804: {
805: p = (struct temp_slot *) oballoc (sizeof (struct temp_slot));
806: p->size = size;
807: /* If the temp slot mode doesn't indicate the alignment,
808: use the largest possible, so no one will be disappointed. */
809: p->slot = assign_stack_local (mode, size, mode == BLKmode ? -1 : 0);
810: p->next = temp_slots;
811: temp_slots = p;
812: }
813:
814: p->in_use = 1;
815: p->rtl_expr = sequence_rtl_expr;
816: p->level = temp_slot_level;
817: p->keep = keep;
818: return p->slot;
819: }
820:
821: /* Combine temporary stack slots which are adjacent on the stack.
822:
823: This allows for better use of already allocated stack space. This is only
824: done for BLKmode slots because we can be sure that we won't have alignment
825: problems in this case. */
826:
827: void
828: combine_temp_slots ()
829: {
830: struct temp_slot *p, *q;
831: struct temp_slot *prev_p, *prev_q;
832: /* Determine where to free back to after this function. */
833: rtx free_pointer = rtx_alloc (CONST_INT);
834:
835: for (p = temp_slots, prev_p = 0; p; p = prev_p ? prev_p->next : temp_slots)
836: {
837: int delete_p = 0;
838: if (! p->in_use && GET_MODE (p->slot) == BLKmode)
839: for (q = p->next, prev_q = p; q; q = prev_q->next)
840: {
841: int delete_q = 0;
842: if (! q->in_use && GET_MODE (q->slot) == BLKmode)
843: {
844: if (rtx_equal_p (plus_constant (XEXP (p->slot, 0), p->size),
845: XEXP (q->slot, 0)))
846: {
847: /* Q comes after P; combine Q into P. */
848: p->size += q->size;
849: delete_q = 1;
850: }
851: else if (rtx_equal_p (plus_constant (XEXP (q->slot, 0), q->size),
852: XEXP (p->slot, 0)))
853: {
854: /* P comes after Q; combine P into Q. */
855: q->size += p->size;
856: delete_p = 1;
857: break;
858: }
859: }
860: /* Either delete Q or advance past it. */
861: if (delete_q)
862: prev_q->next = q->next;
863: else
864: prev_q = q;
865: }
866: /* Either delete P or advance past it. */
867: if (delete_p)
868: {
869: if (prev_p)
870: prev_p->next = p->next;
871: else
872: temp_slots = p->next;
873: }
874: else
875: prev_p = p;
876: }
877:
878: /* Free all the RTL made by plus_constant. */
879: rtx_free (free_pointer);
880: }
881:
882: /* If X could be a reference to a temporary slot, mark that slot as belonging
883: to the to one level higher. If X matched one of our slots, just mark that
884: one. Otherwise, we can't easily predict which it is, so upgrade all of
885: them. Kept slots need not be touched.
886:
887: This is called when an ({...}) construct occurs and a statement
888: returns a value in memory. */
889:
890: void
891: preserve_temp_slots (x)
892: rtx x;
893: {
894: struct temp_slot *p;
895:
896: /* If X is not in memory or is at a constant address, it cannot be in
897: a temporary slot. */
898: if (x == 0 || GET_CODE (x) != MEM || CONSTANT_P (XEXP (x, 0)))
899: return;
900:
901: /* First see if we can find a match. */
902: for (p = temp_slots; p; p = p->next)
903: if (p->in_use && x == p->slot)
904: {
905: p->level--;
906: return;
907: }
908:
909: /* Otherwise, preserve all non-kept slots at this level. */
910: for (p = temp_slots; p; p = p->next)
911: if (p->in_use && p->level == temp_slot_level && ! p->keep)
912: p->level--;
913: }
914:
915: /* Free all temporaries used so far. This is normally called at the end
916: of generating code for a statement. Don't free any temporaries
917: currently in use for an RTL_EXPR that hasn't yet been emitted.
918: We could eventually do better than this since it can be reused while
919: generating the same RTL_EXPR, but this is complex and probably not
920: worthwhile. */
921:
922: void
923: free_temp_slots ()
924: {
925: struct temp_slot *p;
926:
927: for (p = temp_slots; p; p = p->next)
928: if (p->in_use && p->level == temp_slot_level && ! p->keep
929: && p->rtl_expr == 0)
930: p->in_use = 0;
931:
932: combine_temp_slots ();
933: }
934:
935: /* Free all temporary slots used in T, an RTL_EXPR node. */
936:
937: void
938: free_temps_for_rtl_expr (t)
939: tree t;
940: {
941: struct temp_slot *p;
942:
943: for (p = temp_slots; p; p = p->next)
944: if (p->rtl_expr == t)
945: p->in_use = 0;
946:
947: combine_temp_slots ();
948: }
949:
950: /* Push deeper into the nesting level for stack temporaries. */
951:
952: void
953: push_temp_slots ()
954: {
955: temp_slot_level++;
956: }
957:
958: /* Pop a temporary nesting level. All slots in use in the current level
959: are freed. */
960:
961: void
962: pop_temp_slots ()
963: {
964: struct temp_slot *p;
965:
966: for (p = temp_slots; p; p = p->next)
967: if (p->in_use && p->level == temp_slot_level && p->rtl_expr == 0)
968: p->in_use = 0;
969:
970: combine_temp_slots ();
971:
972: temp_slot_level--;
973: }
974:
975: /* Retroactively move an auto variable from a register to a stack slot.
976: This is done when an address-reference to the variable is seen. */
977:
978: void
979: put_var_into_stack (decl)
980: tree decl;
981: {
982: register rtx reg;
983: enum machine_mode promoted_mode, decl_mode;
984: struct function *function = 0;
985: tree context;
986:
987: if (output_bytecode)
988: return;
989:
990: context = decl_function_context (decl);
991:
992: /* Get the current rtl used for this object and it's original mode. */
993: reg = TREE_CODE (decl) == SAVE_EXPR ? SAVE_EXPR_RTL (decl) : DECL_RTL (decl);
994:
995: /* No need to do anything if decl has no rtx yet
996: since in that case caller is setting TREE_ADDRESSABLE
997: and a stack slot will be assigned when the rtl is made. */
998: if (reg == 0)
999: return;
1000:
1001: /* Get the declared mode for this object. */
1002: decl_mode = (TREE_CODE (decl) == SAVE_EXPR ? TYPE_MODE (TREE_TYPE (decl))
1003: : DECL_MODE (decl));
1004: /* Get the mode it's actually stored in. */
1005: promoted_mode = GET_MODE (reg);
1006:
1007: /* If this variable comes from an outer function,
1008: find that function's saved context. */
1009: if (context != current_function_decl)
1010: for (function = outer_function_chain; function; function = function->next)
1011: if (function->decl == context)
1012: break;
1013:
1014: /* If this is a variable-size object with a pseudo to address it,
1015: put that pseudo into the stack, if the var is nonlocal. */
1016: if (DECL_NONLOCAL (decl)
1017: && GET_CODE (reg) == MEM
1018: && GET_CODE (XEXP (reg, 0)) == REG
1019: && REGNO (XEXP (reg, 0)) > LAST_VIRTUAL_REGISTER)
1020: {
1021: reg = XEXP (reg, 0);
1022: decl_mode = promoted_mode = GET_MODE (reg);
1023: }
1024:
1025: /* Now we should have a value that resides in one or more pseudo regs. */
1026:
1027: if (GET_CODE (reg) == REG)
1028: put_reg_into_stack (function, reg, TREE_TYPE (decl),
1029: promoted_mode, decl_mode);
1030: else if (GET_CODE (reg) == CONCAT)
1031: {
1032: /* A CONCAT contains two pseudos; put them both in the stack.
1033: We do it so they end up consecutive. */
1034: enum machine_mode part_mode = GET_MODE (XEXP (reg, 0));
1035: tree part_type = TREE_TYPE (TREE_TYPE (decl));
1036: #ifdef STACK_GROWS_DOWNWARD
1037: /* Since part 0 should have a lower address, do it second. */
1038: put_reg_into_stack (function, XEXP (reg, 1),
1039: part_type, part_mode, part_mode);
1040: put_reg_into_stack (function, XEXP (reg, 0),
1041: part_type, part_mode, part_mode);
1042: #else
1043: put_reg_into_stack (function, XEXP (reg, 0),
1044: part_type, part_mode, part_mode);
1045: put_reg_into_stack (function, XEXP (reg, 1),
1046: part_type, part_mode, part_mode);
1047: #endif
1048:
1049: /* Change the CONCAT into a combined MEM for both parts. */
1050: PUT_CODE (reg, MEM);
1051: /* The two parts are in memory order already.
1052: Use the lower parts address as ours. */
1053: XEXP (reg, 0) = XEXP (XEXP (reg, 0), 0);
1054: /* Prevent sharing of rtl that might lose. */
1055: if (GET_CODE (XEXP (reg, 0)) == PLUS)
1056: XEXP (reg, 0) = copy_rtx (XEXP (reg, 0));
1057: }
1058: }
1059:
1060: /* Subroutine of put_var_into_stack. This puts a single pseudo reg REG
1061: into the stack frame of FUNCTION (0 means the current function).
1062: DECL_MODE is the machine mode of the user-level data type.
1063: PROMOTED_MODE is the machine mode of the register. */
1064:
1065: static void
1066: put_reg_into_stack (function, reg, type, promoted_mode, decl_mode)
1067: struct function *function;
1068: rtx reg;
1069: tree type;
1070: enum machine_mode promoted_mode, decl_mode;
1071: {
1072: rtx new = 0;
1073:
1074: if (function)
1075: {
1076: if (REGNO (reg) < function->max_parm_reg)
1077: new = function->parm_reg_stack_loc[REGNO (reg)];
1078: if (new == 0)
1079: new = assign_outer_stack_local (decl_mode, GET_MODE_SIZE (decl_mode),
1080: 0, function);
1081: }
1082: else
1083: {
1084: if (REGNO (reg) < max_parm_reg)
1085: new = parm_reg_stack_loc[REGNO (reg)];
1086: if (new == 0)
1087: new = assign_stack_local (decl_mode, GET_MODE_SIZE (decl_mode), 0);
1088: }
1089:
1090: XEXP (reg, 0) = XEXP (new, 0);
1091: /* `volatil' bit means one thing for MEMs, another entirely for REGs. */
1092: REG_USERVAR_P (reg) = 0;
1093: PUT_CODE (reg, MEM);
1094: PUT_MODE (reg, decl_mode);
1095:
1096: /* If this is a memory ref that contains aggregate components,
1097: mark it as such for cse and loop optimize. */
1098: MEM_IN_STRUCT_P (reg)
1099: = (TREE_CODE (type) == ARRAY_TYPE
1100: || TREE_CODE (type) == RECORD_TYPE
1101: || TREE_CODE (type) == UNION_TYPE
1102: || TREE_CODE (type) == QUAL_UNION_TYPE);
1103:
1104: /* Now make sure that all refs to the variable, previously made
1105: when it was a register, are fixed up to be valid again. */
1106: if (function)
1107: {
1108: struct var_refs_queue *temp;
1109:
1110: /* Variable is inherited; fix it up when we get back to its function. */
1111: push_obstacks (function->function_obstack,
1112: function->function_maybepermanent_obstack);
1113:
1114: /* See comment in restore_tree_status in tree.c for why this needs to be
1115: on saveable obstack. */
1116: temp
1117: = (struct var_refs_queue *) savealloc (sizeof (struct var_refs_queue));
1118: temp->modified = reg;
1119: temp->promoted_mode = promoted_mode;
1120: temp->unsignedp = TREE_UNSIGNED (type);
1121: temp->next = function->fixup_var_refs_queue;
1122: function->fixup_var_refs_queue = temp;
1123: pop_obstacks ();
1124: }
1125: else
1126: /* Variable is local; fix it up now. */
1127: fixup_var_refs (reg, promoted_mode, TREE_UNSIGNED (type));
1128: }
1129:
1130: static void
1131: fixup_var_refs (var, promoted_mode, unsignedp)
1132: rtx var;
1133: enum machine_mode promoted_mode;
1134: int unsignedp;
1135: {
1136: tree pending;
1137: rtx first_insn = get_insns ();
1138: struct sequence_stack *stack = sequence_stack;
1139: tree rtl_exps = rtl_expr_chain;
1140:
1141: /* Must scan all insns for stack-refs that exceed the limit. */
1142: fixup_var_refs_insns (var, promoted_mode, unsignedp, first_insn, stack == 0);
1143:
1144: /* Scan all pending sequences too. */
1145: for (; stack; stack = stack->next)
1146: {
1147: push_to_sequence (stack->first);
1148: fixup_var_refs_insns (var, promoted_mode, unsignedp,
1149: stack->first, stack->next != 0);
1150: /* Update remembered end of sequence
1151: in case we added an insn at the end. */
1152: stack->last = get_last_insn ();
1153: end_sequence ();
1154: }
1155:
1156: /* Scan all waiting RTL_EXPRs too. */
1157: for (pending = rtl_exps; pending; pending = TREE_CHAIN (pending))
1158: {
1159: rtx seq = RTL_EXPR_SEQUENCE (TREE_VALUE (pending));
1160: if (seq != const0_rtx && seq != 0)
1161: {
1162: push_to_sequence (seq);
1163: fixup_var_refs_insns (var, promoted_mode, unsignedp, seq, 0);
1164: end_sequence ();
1165: }
1166: }
1167: }
1168:
1169: /* This structure is used by the following two functions to record MEMs or
1170: pseudos used to replace VAR, any SUBREGs of VAR, and any MEMs containing
1171: VAR as an address. We need to maintain this list in case two operands of
1172: an insn were required to match; in that case we must ensure we use the
1173: same replacement. */
1174:
1175: struct fixup_replacement
1176: {
1177: rtx old;
1178: rtx new;
1179: struct fixup_replacement *next;
1180: };
1181:
1182: /* REPLACEMENTS is a pointer to a list of the above structures and X is
1183: some part of an insn. Return a struct fixup_replacement whose OLD
1184: value is equal to X. Allocate a new structure if no such entry exists. */
1185:
1186: static struct fixup_replacement *
1187: find_fixup_replacement (replacements, x)
1188: struct fixup_replacement **replacements;
1189: rtx x;
1190: {
1191: struct fixup_replacement *p;
1192:
1193: /* See if we have already replaced this. */
1194: for (p = *replacements; p && p->old != x; p = p->next)
1195: ;
1196:
1197: if (p == 0)
1198: {
1199: p = (struct fixup_replacement *) oballoc (sizeof (struct fixup_replacement));
1200: p->old = x;
1201: p->new = 0;
1202: p->next = *replacements;
1203: *replacements = p;
1204: }
1205:
1206: return p;
1207: }
1208:
1209: /* Scan the insn-chain starting with INSN for refs to VAR
1210: and fix them up. TOPLEVEL is nonzero if this chain is the
1211: main chain of insns for the current function. */
1212:
1213: static void
1214: fixup_var_refs_insns (var, promoted_mode, unsignedp, insn, toplevel)
1215: rtx var;
1216: enum machine_mode promoted_mode;
1217: int unsignedp;
1218: rtx insn;
1219: int toplevel;
1220: {
1221: rtx call_dest = 0;
1222:
1223: while (insn)
1224: {
1225: rtx next = NEXT_INSN (insn);
1226: rtx note;
1227: if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
1228: {
1229: /* The insn to load VAR from a home in the arglist
1230: is now a no-op. When we see it, just delete it. */
1231: if (toplevel
1232: && GET_CODE (PATTERN (insn)) == SET
1233: && SET_DEST (PATTERN (insn)) == var
1234: /* If this represents the result of an insn group,
1235: don't delete the insn. */
1236: && find_reg_note (insn, REG_RETVAL, NULL_RTX) == 0
1237: && rtx_equal_p (SET_SRC (PATTERN (insn)), var))
1238: {
1239: /* In unoptimized compilation, we shouldn't call delete_insn
1240: except in jump.c doing warnings. */
1241: PUT_CODE (insn, NOTE);
1242: NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
1243: NOTE_SOURCE_FILE (insn) = 0;
1244: if (insn == last_parm_insn)
1245: last_parm_insn = PREV_INSN (next);
1246: }
1247: else
1248: {
1249: struct fixup_replacement *replacements = 0;
1250: rtx next_insn = NEXT_INSN (insn);
1251:
1252: #ifdef SMALL_REGISTER_CLASSES
1253: /* If the insn that copies the results of a CALL_INSN
1254: into a pseudo now references VAR, we have to use an
1255: intermediate pseudo since we want the life of the
1256: return value register to be only a single insn.
1257:
1258: If we don't use an intermediate pseudo, such things as
1259: address computations to make the address of VAR valid
1260: if it is not can be placed beween the CALL_INSN and INSN.
1261:
1262: To make sure this doesn't happen, we record the destination
1263: of the CALL_INSN and see if the next insn uses both that
1264: and VAR. */
1265:
1266: if (call_dest != 0 && GET_CODE (insn) == INSN
1267: && reg_mentioned_p (var, PATTERN (insn))
1268: && reg_mentioned_p (call_dest, PATTERN (insn)))
1269: {
1270: rtx temp = gen_reg_rtx (GET_MODE (call_dest));
1271:
1272: emit_insn_before (gen_move_insn (temp, call_dest), insn);
1273:
1274: PATTERN (insn) = replace_rtx (PATTERN (insn),
1275: call_dest, temp);
1276: }
1277:
1278: if (GET_CODE (insn) == CALL_INSN
1279: && GET_CODE (PATTERN (insn)) == SET)
1280: call_dest = SET_DEST (PATTERN (insn));
1281: else if (GET_CODE (insn) == CALL_INSN
1282: && GET_CODE (PATTERN (insn)) == PARALLEL
1283: && GET_CODE (XVECEXP (PATTERN (insn), 0, 0)) == SET)
1284: call_dest = SET_DEST (XVECEXP (PATTERN (insn), 0, 0));
1285: else
1286: call_dest = 0;
1287: #endif
1288:
1289: /* See if we have to do anything to INSN now that VAR is in
1290: memory. If it needs to be loaded into a pseudo, use a single
1291: pseudo for the entire insn in case there is a MATCH_DUP
1292: between two operands. We pass a pointer to the head of
1293: a list of struct fixup_replacements. If fixup_var_refs_1
1294: needs to allocate pseudos or replacement MEMs (for SUBREGs),
1295: it will record them in this list.
1296:
1297: If it allocated a pseudo for any replacement, we copy into
1298: it here. */
1299:
1300: fixup_var_refs_1 (var, promoted_mode, &PATTERN (insn), insn,
1301: &replacements);
1302:
1303: /* If this is last_parm_insn, and any instructions were output
1304: after it to fix it up, then we must set last_parm_insn to
1305: the last such instruction emitted. */
1306: if (insn == last_parm_insn)
1307: last_parm_insn = PREV_INSN (next_insn);
1308:
1309: while (replacements)
1310: {
1311: if (GET_CODE (replacements->new) == REG)
1312: {
1313: rtx insert_before;
1314: rtx seq;
1315:
1316: /* OLD might be a (subreg (mem)). */
1317: if (GET_CODE (replacements->old) == SUBREG)
1318: replacements->old
1319: = fixup_memory_subreg (replacements->old, insn, 0);
1320: else
1321: replacements->old
1322: = fixup_stack_1 (replacements->old, insn);
1323:
1324: /* We can not separate USE insns from the CALL_INSN
1325: that they belong to. If this is a CALL_INSN, insert
1326: the move insn before the USE insns preceding it
1327: instead of immediately before the insn. */
1328: if (GET_CODE (insn) == CALL_INSN)
1329: {
1330: insert_before = insn;
1331: while (GET_CODE (PREV_INSN (insert_before)) == INSN
1332: && GET_CODE (PATTERN (PREV_INSN (insert_before))) == USE)
1333: insert_before = PREV_INSN (insert_before);
1334: }
1335: else
1336: insert_before = insn;
1337:
1338: /* If we are changing the mode, do a conversion.
1339: This might be wasteful, but combine.c will
1340: eliminate much of the waste. */
1341:
1342: if (GET_MODE (replacements->new)
1343: != GET_MODE (replacements->old))
1344: {
1345: start_sequence ();
1346: convert_move (replacements->new,
1347: replacements->old, unsignedp);
1348: seq = gen_sequence ();
1349: end_sequence ();
1350: }
1351: else
1352: seq = gen_move_insn (replacements->new,
1353: replacements->old);
1354:
1355: emit_insn_before (seq, insert_before);
1356: }
1357:
1358: replacements = replacements->next;
1359: }
1360: }
1361:
1362: /* Also fix up any invalid exprs in the REG_NOTES of this insn.
1363: But don't touch other insns referred to by reg-notes;
1364: we will get them elsewhere. */
1365: for (note = REG_NOTES (insn); note; note = XEXP (note, 1))
1366: if (GET_CODE (note) != INSN_LIST)
1367: XEXP (note, 0)
1368: = walk_fixup_memory_subreg (XEXP (note, 0), insn, 1);
1369: }
1370: insn = next;
1371: }
1372: }
1373:
1374: /* VAR is a MEM that used to be a pseudo register with mode PROMOTED_MODE.
1375: See if the rtx expression at *LOC in INSN needs to be changed.
1376:
1377: REPLACEMENTS is a pointer to a list head that starts out zero, but may
1378: contain a list of original rtx's and replacements. If we find that we need
1379: to modify this insn by replacing a memory reference with a pseudo or by
1380: making a new MEM to implement a SUBREG, we consult that list to see if
1381: we have already chosen a replacement. If none has already been allocated,
1382: we allocate it and update the list. fixup_var_refs_insns will copy VAR
1383: or the SUBREG, as appropriate, to the pseudo. */
1384:
1385: static void
1386: fixup_var_refs_1 (var, promoted_mode, loc, insn, replacements)
1387: register rtx var;
1388: enum machine_mode promoted_mode;
1389: register rtx *loc;
1390: rtx insn;
1391: struct fixup_replacement **replacements;
1392: {
1393: register int i;
1394: register rtx x = *loc;
1395: RTX_CODE code = GET_CODE (x);
1396: register char *fmt;
1397: register rtx tem, tem1;
1398: struct fixup_replacement *replacement;
1399:
1400: switch (code)
1401: {
1402: case MEM:
1403: if (var == x)
1404: {
1405: /* If we already have a replacement, use it. Otherwise,
1406: try to fix up this address in case it is invalid. */
1407:
1408: replacement = find_fixup_replacement (replacements, var);
1409: if (replacement->new)
1410: {
1411: *loc = replacement->new;
1412: return;
1413: }
1414:
1415: *loc = replacement->new = x = fixup_stack_1 (x, insn);
1416:
1417: /* Unless we are forcing memory to register or we changed the mode,
1418: we can leave things the way they are if the insn is valid. */
1419:
1420: INSN_CODE (insn) = -1;
1421: if (! flag_force_mem && GET_MODE (x) == promoted_mode
1422: && recog_memoized (insn) >= 0)
1423: return;
1424:
1425: *loc = replacement->new = gen_reg_rtx (promoted_mode);
1426: return;
1427: }
1428:
1429: /* If X contains VAR, we need to unshare it here so that we update
1430: each occurrence separately. But all identical MEMs in one insn
1431: must be replaced with the same rtx because of the possibility of
1432: MATCH_DUPs. */
1433:
1434: if (reg_mentioned_p (var, x))
1435: {
1436: replacement = find_fixup_replacement (replacements, x);
1437: if (replacement->new == 0)
1438: replacement->new = copy_most_rtx (x, var);
1439:
1440: *loc = x = replacement->new;
1441: }
1442: break;
1443:
1444: case REG:
1445: case CC0:
1446: case PC:
1447: case CONST_INT:
1448: case CONST:
1449: case SYMBOL_REF:
1450: case LABEL_REF:
1451: case CONST_DOUBLE:
1452: return;
1453:
1454: case SIGN_EXTRACT:
1455: case ZERO_EXTRACT:
1456: /* Note that in some cases those types of expressions are altered
1457: by optimize_bit_field, and do not survive to get here. */
1458: if (XEXP (x, 0) == var
1459: || (GET_CODE (XEXP (x, 0)) == SUBREG
1460: && SUBREG_REG (XEXP (x, 0)) == var))
1461: {
1462: /* Get TEM as a valid MEM in the mode presently in the insn.
1463:
1464: We don't worry about the possibility of MATCH_DUP here; it
1465: is highly unlikely and would be tricky to handle. */
1466:
1467: tem = XEXP (x, 0);
1468: if (GET_CODE (tem) == SUBREG)
1469: tem = fixup_memory_subreg (tem, insn, 1);
1470: tem = fixup_stack_1 (tem, insn);
1471:
1472: /* Unless we want to load from memory, get TEM into the proper mode
1473: for an extract from memory. This can only be done if the
1474: extract is at a constant position and length. */
1475:
1476: if (! flag_force_mem && GET_CODE (XEXP (x, 1)) == CONST_INT
1477: && GET_CODE (XEXP (x, 2)) == CONST_INT
1478: && ! mode_dependent_address_p (XEXP (tem, 0))
1479: && ! MEM_VOLATILE_P (tem))
1480: {
1481: enum machine_mode wanted_mode = VOIDmode;
1482: enum machine_mode is_mode = GET_MODE (tem);
1483: int width = INTVAL (XEXP (x, 1));
1484: int pos = INTVAL (XEXP (x, 2));
1485:
1486: #ifdef HAVE_extzv
1487: if (GET_CODE (x) == ZERO_EXTRACT)
1488: wanted_mode = insn_operand_mode[(int) CODE_FOR_extzv][1];
1489: #endif
1490: #ifdef HAVE_extv
1491: if (GET_CODE (x) == SIGN_EXTRACT)
1492: wanted_mode = insn_operand_mode[(int) CODE_FOR_extv][1];
1493: #endif
1494: /* If we have a narrower mode, we can do something. */
1495: if (wanted_mode != VOIDmode
1496: && GET_MODE_SIZE (wanted_mode) < GET_MODE_SIZE (is_mode))
1497: {
1498: int offset = pos / BITS_PER_UNIT;
1499: rtx old_pos = XEXP (x, 2);
1500: rtx newmem;
1501:
1502: /* If the bytes and bits are counted differently, we
1503: must adjust the offset. */
1504: #if BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN
1505: offset = (GET_MODE_SIZE (is_mode)
1506: - GET_MODE_SIZE (wanted_mode) - offset);
1507: #endif
1508:
1509: pos %= GET_MODE_BITSIZE (wanted_mode);
1510:
1511: newmem = gen_rtx (MEM, wanted_mode,
1512: plus_constant (XEXP (tem, 0), offset));
1513: RTX_UNCHANGING_P (newmem) = RTX_UNCHANGING_P (tem);
1514: MEM_VOLATILE_P (newmem) = MEM_VOLATILE_P (tem);
1515: MEM_IN_STRUCT_P (newmem) = MEM_IN_STRUCT_P (tem);
1516:
1517: /* Make the change and see if the insn remains valid. */
1518: INSN_CODE (insn) = -1;
1519: XEXP (x, 0) = newmem;
1520: XEXP (x, 2) = GEN_INT (pos);
1521:
1522: if (recog_memoized (insn) >= 0)
1523: return;
1524:
1525: /* Otherwise, restore old position. XEXP (x, 0) will be
1526: restored later. */
1527: XEXP (x, 2) = old_pos;
1528: }
1529: }
1530:
1531: /* If we get here, the bitfield extract insn can't accept a memory
1532: reference. Copy the input into a register. */
1533:
1534: tem1 = gen_reg_rtx (GET_MODE (tem));
1535: emit_insn_before (gen_move_insn (tem1, tem), insn);
1536: XEXP (x, 0) = tem1;
1537: return;
1538: }
1539: break;
1540:
1541: case SUBREG:
1542: if (SUBREG_REG (x) == var)
1543: {
1544: /* If this is a special SUBREG made because VAR was promoted
1545: from a wider mode, replace it with VAR and call ourself
1546: recursively, this time saying that the object previously
1547: had its current mode (by virtue of the SUBREG). */
1548:
1549: if (SUBREG_PROMOTED_VAR_P (x))
1550: {
1551: *loc = var;
1552: fixup_var_refs_1 (var, GET_MODE (var), loc, insn, replacements);
1553: return;
1554: }
1555:
1556: /* If this SUBREG makes VAR wider, it has become a paradoxical
1557: SUBREG with VAR in memory, but these aren't allowed at this
1558: stage of the compilation. So load VAR into a pseudo and take
1559: a SUBREG of that pseudo. */
1560: if (GET_MODE_SIZE (GET_MODE (x)) > GET_MODE_SIZE (GET_MODE (var)))
1561: {
1562: replacement = find_fixup_replacement (replacements, var);
1563: if (replacement->new == 0)
1564: replacement->new = gen_reg_rtx (GET_MODE (var));
1565: SUBREG_REG (x) = replacement->new;
1566: return;
1567: }
1568:
1569: /* See if we have already found a replacement for this SUBREG.
1570: If so, use it. Otherwise, make a MEM and see if the insn
1571: is recognized. If not, or if we should force MEM into a register,
1572: make a pseudo for this SUBREG. */
1573: replacement = find_fixup_replacement (replacements, x);
1574: if (replacement->new)
1575: {
1576: *loc = replacement->new;
1577: return;
1578: }
1579:
1580: replacement->new = *loc = fixup_memory_subreg (x, insn, 0);
1581:
1582: INSN_CODE (insn) = -1;
1583: if (! flag_force_mem && recog_memoized (insn) >= 0)
1584: return;
1585:
1586: *loc = replacement->new = gen_reg_rtx (GET_MODE (x));
1587: return;
1588: }
1589: break;
1590:
1591: case SET:
1592: /* First do special simplification of bit-field references. */
1593: if (GET_CODE (SET_DEST (x)) == SIGN_EXTRACT
1594: || GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
1595: optimize_bit_field (x, insn, 0);
1596: if (GET_CODE (SET_SRC (x)) == SIGN_EXTRACT
1597: || GET_CODE (SET_SRC (x)) == ZERO_EXTRACT)
1598: optimize_bit_field (x, insn, NULL_PTR);
1599:
1600: /* If SET_DEST is now a paradoxical SUBREG, put the result of this
1601: insn into a pseudo and store the low part of the pseudo into VAR. */
1602: if (GET_CODE (SET_DEST (x)) == SUBREG
1603: && SUBREG_REG (SET_DEST (x)) == var
1604: && (GET_MODE_SIZE (GET_MODE (SET_DEST (x)))
1605: > GET_MODE_SIZE (GET_MODE (var))))
1606: {
1607: SET_DEST (x) = tem = gen_reg_rtx (GET_MODE (SET_DEST (x)));
1608: emit_insn_after (gen_move_insn (var, gen_lowpart (GET_MODE (var),
1609: tem)),
1610: insn);
1611: break;
1612: }
1613:
1614: {
1615: rtx dest = SET_DEST (x);
1616: rtx src = SET_SRC (x);
1617: rtx outerdest = dest;
1618:
1619: while (GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART
1620: || GET_CODE (dest) == SIGN_EXTRACT
1621: || GET_CODE (dest) == ZERO_EXTRACT)
1622: dest = XEXP (dest, 0);
1623:
1624: if (GET_CODE (src) == SUBREG)
1625: src = XEXP (src, 0);
1626:
1627: /* If VAR does not appear at the top level of the SET
1628: just scan the lower levels of the tree. */
1629:
1630: if (src != var && dest != var)
1631: break;
1632:
1633: /* We will need to rerecognize this insn. */
1634: INSN_CODE (insn) = -1;
1635:
1636: #ifdef HAVE_insv
1637: if (GET_CODE (outerdest) == ZERO_EXTRACT && dest == var)
1638: {
1639: /* Since this case will return, ensure we fixup all the
1640: operands here. */
1641: fixup_var_refs_1 (var, promoted_mode, &XEXP (outerdest, 1),
1642: insn, replacements);
1643: fixup_var_refs_1 (var, promoted_mode, &XEXP (outerdest, 2),
1644: insn, replacements);
1645: fixup_var_refs_1 (var, promoted_mode, &SET_SRC (x),
1646: insn, replacements);
1647:
1648: tem = XEXP (outerdest, 0);
1649:
1650: /* Clean up (SUBREG:SI (MEM:mode ...) 0)
1651: that may appear inside a ZERO_EXTRACT.
1652: This was legitimate when the MEM was a REG. */
1653: if (GET_CODE (tem) == SUBREG
1654: && SUBREG_REG (tem) == var)
1655: tem = fixup_memory_subreg (tem, insn, 1);
1656: else
1657: tem = fixup_stack_1 (tem, insn);
1658:
1659: if (GET_CODE (XEXP (outerdest, 1)) == CONST_INT
1660: && GET_CODE (XEXP (outerdest, 2)) == CONST_INT
1661: && ! mode_dependent_address_p (XEXP (tem, 0))
1662: && ! MEM_VOLATILE_P (tem))
1663: {
1664: enum machine_mode wanted_mode
1665: = insn_operand_mode[(int) CODE_FOR_insv][0];
1666: enum machine_mode is_mode = GET_MODE (tem);
1667: int width = INTVAL (XEXP (outerdest, 1));
1668: int pos = INTVAL (XEXP (outerdest, 2));
1669:
1670: /* If we have a narrower mode, we can do something. */
1671: if (GET_MODE_SIZE (wanted_mode) < GET_MODE_SIZE (is_mode))
1672: {
1673: int offset = pos / BITS_PER_UNIT;
1674: rtx old_pos = XEXP (outerdest, 2);
1675: rtx newmem;
1676:
1677: #if BYTES_BIG_ENDIAN != BITS_BIG_ENDIAN
1678: offset = (GET_MODE_SIZE (is_mode)
1679: - GET_MODE_SIZE (wanted_mode) - offset);
1680: #endif
1681:
1682: pos %= GET_MODE_BITSIZE (wanted_mode);
1683:
1684: newmem = gen_rtx (MEM, wanted_mode,
1685: plus_constant (XEXP (tem, 0), offset));
1686: RTX_UNCHANGING_P (newmem) = RTX_UNCHANGING_P (tem);
1687: MEM_VOLATILE_P (newmem) = MEM_VOLATILE_P (tem);
1688: MEM_IN_STRUCT_P (newmem) = MEM_IN_STRUCT_P (tem);
1689:
1690: /* Make the change and see if the insn remains valid. */
1691: INSN_CODE (insn) = -1;
1692: XEXP (outerdest, 0) = newmem;
1693: XEXP (outerdest, 2) = GEN_INT (pos);
1694:
1695: if (recog_memoized (insn) >= 0)
1696: return;
1697:
1698: /* Otherwise, restore old position. XEXP (x, 0) will be
1699: restored later. */
1700: XEXP (outerdest, 2) = old_pos;
1701: }
1702: }
1703:
1704: /* If we get here, the bit-field store doesn't allow memory
1705: or isn't located at a constant position. Load the value into
1706: a register, do the store, and put it back into memory. */
1707:
1708: tem1 = gen_reg_rtx (GET_MODE (tem));
1709: emit_insn_before (gen_move_insn (tem1, tem), insn);
1710: emit_insn_after (gen_move_insn (tem, tem1), insn);
1711: XEXP (outerdest, 0) = tem1;
1712: return;
1713: }
1714: #endif
1715:
1716: /* STRICT_LOW_PART is a no-op on memory references
1717: and it can cause combinations to be unrecognizable,
1718: so eliminate it. */
1719:
1720: if (dest == var && GET_CODE (SET_DEST (x)) == STRICT_LOW_PART)
1721: SET_DEST (x) = XEXP (SET_DEST (x), 0);
1722:
1723: /* A valid insn to copy VAR into or out of a register
1724: must be left alone, to avoid an infinite loop here.
1725: If the reference to VAR is by a subreg, fix that up,
1726: since SUBREG is not valid for a memref.
1727: Also fix up the address of the stack slot.
1728:
1729: Note that we must not try to recognize the insn until
1730: after we know that we have valid addresses and no
1731: (subreg (mem ...) ...) constructs, since these interfere
1732: with determining the validity of the insn. */
1733:
1734: if ((SET_SRC (x) == var
1735: || (GET_CODE (SET_SRC (x)) == SUBREG
1736: && SUBREG_REG (SET_SRC (x)) == var))
1737: && (GET_CODE (SET_DEST (x)) == REG
1738: || (GET_CODE (SET_DEST (x)) == SUBREG
1739: && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG))
1740: && x == single_set (PATTERN (insn)))
1741: {
1742: rtx pat;
1743:
1744: replacement = find_fixup_replacement (replacements, SET_SRC (x));
1745: if (replacement->new)
1746: SET_SRC (x) = replacement->new;
1747: else if (GET_CODE (SET_SRC (x)) == SUBREG)
1748: SET_SRC (x) = replacement->new
1749: = fixup_memory_subreg (SET_SRC (x), insn, 0);
1750: else
1751: SET_SRC (x) = replacement->new
1752: = fixup_stack_1 (SET_SRC (x), insn);
1753:
1754: if (recog_memoized (insn) >= 0)
1755: return;
1756:
1757: /* INSN is not valid, but we know that we want to
1758: copy SET_SRC (x) to SET_DEST (x) in some way. So
1759: we generate the move and see whether it requires more
1760: than one insn. If it does, we emit those insns and
1761: delete INSN. Otherwise, we an just replace the pattern
1762: of INSN; we have already verified above that INSN has
1763: no other function that to do X. */
1764:
1765: pat = gen_move_insn (SET_DEST (x), SET_SRC (x));
1766: if (GET_CODE (pat) == SEQUENCE)
1767: {
1768: emit_insn_after (pat, insn);
1769: PUT_CODE (insn, NOTE);
1770: NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
1771: NOTE_SOURCE_FILE (insn) = 0;
1772: }
1773: else
1774: PATTERN (insn) = pat;
1775:
1776: return;
1777: }
1778:
1779: if ((SET_DEST (x) == var
1780: || (GET_CODE (SET_DEST (x)) == SUBREG
1781: && SUBREG_REG (SET_DEST (x)) == var))
1782: && (GET_CODE (SET_SRC (x)) == REG
1783: || (GET_CODE (SET_SRC (x)) == SUBREG
1784: && GET_CODE (SUBREG_REG (SET_SRC (x))) == REG))
1785: && x == single_set (PATTERN (insn)))
1786: {
1787: rtx pat;
1788:
1789: if (GET_CODE (SET_DEST (x)) == SUBREG)
1790: SET_DEST (x) = fixup_memory_subreg (SET_DEST (x), insn, 0);
1791: else
1792: SET_DEST (x) = fixup_stack_1 (SET_DEST (x), insn);
1793:
1794: if (recog_memoized (insn) >= 0)
1795: return;
1796:
1797: pat = gen_move_insn (SET_DEST (x), SET_SRC (x));
1798: if (GET_CODE (pat) == SEQUENCE)
1799: {
1800: emit_insn_after (pat, insn);
1801: PUT_CODE (insn, NOTE);
1802: NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
1803: NOTE_SOURCE_FILE (insn) = 0;
1804: }
1805: else
1806: PATTERN (insn) = pat;
1807:
1808: return;
1809: }
1810:
1811: /* Otherwise, storing into VAR must be handled specially
1812: by storing into a temporary and copying that into VAR
1813: with a new insn after this one. Note that this case
1814: will be used when storing into a promoted scalar since
1815: the insn will now have different modes on the input
1816: and output and hence will be invalid (except for the case
1817: of setting it to a constant, which does not need any
1818: change if it is valid). We generate extra code in that case,
1819: but combine.c will eliminate it. */
1820:
1821: if (dest == var)
1822: {
1823: rtx temp;
1824: rtx fixeddest = SET_DEST (x);
1825:
1826: /* STRICT_LOW_PART can be discarded, around a MEM. */
1827: if (GET_CODE (fixeddest) == STRICT_LOW_PART)
1828: fixeddest = XEXP (fixeddest, 0);
1829: /* Convert (SUBREG (MEM)) to a MEM in a changed mode. */
1830: if (GET_CODE (fixeddest) == SUBREG)
1831: fixeddest = fixup_memory_subreg (fixeddest, insn, 0);
1832: else
1833: fixeddest = fixup_stack_1 (fixeddest, insn);
1834:
1835: temp = gen_reg_rtx (GET_MODE (SET_SRC (x)) == VOIDmode
1836: ? GET_MODE (fixeddest)
1837: : GET_MODE (SET_SRC (x)));
1838:
1839: emit_insn_after (gen_move_insn (fixeddest,
1840: gen_lowpart (GET_MODE (fixeddest),
1841: temp)),
1842: insn);
1843:
1844: SET_DEST (x) = temp;
1845: }
1846: }
1847: }
1848:
1849: /* Nothing special about this RTX; fix its operands. */
1850:
1851: fmt = GET_RTX_FORMAT (code);
1852: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1853: {
1854: if (fmt[i] == 'e')
1855: fixup_var_refs_1 (var, promoted_mode, &XEXP (x, i), insn, replacements);
1856: if (fmt[i] == 'E')
1857: {
1858: register int j;
1859: for (j = 0; j < XVECLEN (x, i); j++)
1860: fixup_var_refs_1 (var, promoted_mode, &XVECEXP (x, i, j),
1861: insn, replacements);
1862: }
1863: }
1864: }
1865:
1866: /* Given X, an rtx of the form (SUBREG:m1 (MEM:m2 addr)),
1867: return an rtx (MEM:m1 newaddr) which is equivalent.
1868: If any insns must be emitted to compute NEWADDR, put them before INSN.
1869:
1870: UNCRITICAL nonzero means accept paradoxical subregs.
1871: This is used for subregs found inside of ZERO_EXTRACTs and in REG_NOTES. */
1872:
1873: static rtx
1874: fixup_memory_subreg (x, insn, uncritical)
1875: rtx x;
1876: rtx insn;
1877: int uncritical;
1878: {
1879: int offset = SUBREG_WORD (x) * UNITS_PER_WORD;
1880: rtx addr = XEXP (SUBREG_REG (x), 0);
1881: enum machine_mode mode = GET_MODE (x);
1882: rtx saved, result;
1883:
1884: /* Paradoxical SUBREGs are usually invalid during RTL generation. */
1885: if (GET_MODE_SIZE (mode) > GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))
1886: && ! uncritical)
1887: abort ();
1888:
1889: #if BYTES_BIG_ENDIAN
1890: offset += (MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
1891: - MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode)));
1892: #endif
1893: addr = plus_constant (addr, offset);
1894: if (!flag_force_addr && memory_address_p (mode, addr))
1895: /* Shortcut if no insns need be emitted. */
1896: return change_address (SUBREG_REG (x), mode, addr);
1897: start_sequence ();
1898: result = change_address (SUBREG_REG (x), mode, addr);
1899: emit_insn_before (gen_sequence (), insn);
1900: end_sequence ();
1901: return result;
1902: }
1903:
1904: /* Do fixup_memory_subreg on all (SUBREG (MEM ...) ...) contained in X.
1905: Replace subexpressions of X in place.
1906: If X itself is a (SUBREG (MEM ...) ...), return the replacement expression.
1907: Otherwise return X, with its contents possibly altered.
1908:
1909: If any insns must be emitted to compute NEWADDR, put them before INSN.
1910:
1911: UNCRITICAL is as in fixup_memory_subreg. */
1912:
1913: static rtx
1914: walk_fixup_memory_subreg (x, insn, uncritical)
1915: register rtx x;
1916: rtx insn;
1917: int uncritical;
1918: {
1919: register enum rtx_code code;
1920: register char *fmt;
1921: register int i;
1922:
1923: if (x == 0)
1924: return 0;
1925:
1926: code = GET_CODE (x);
1927:
1928: if (code == SUBREG && GET_CODE (SUBREG_REG (x)) == MEM)
1929: return fixup_memory_subreg (x, insn, uncritical);
1930:
1931: /* Nothing special about this RTX; fix its operands. */
1932:
1933: fmt = GET_RTX_FORMAT (code);
1934: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1935: {
1936: if (fmt[i] == 'e')
1937: XEXP (x, i) = walk_fixup_memory_subreg (XEXP (x, i), insn, uncritical);
1938: if (fmt[i] == 'E')
1939: {
1940: register int j;
1941: for (j = 0; j < XVECLEN (x, i); j++)
1942: XVECEXP (x, i, j)
1943: = walk_fixup_memory_subreg (XVECEXP (x, i, j), insn, uncritical);
1944: }
1945: }
1946: return x;
1947: }
1948:
1949: #if 0
1950: /* Fix up any references to stack slots that are invalid memory addresses
1951: because they exceed the maximum range of a displacement. */
1952:
1953: void
1954: fixup_stack_slots ()
1955: {
1956: register rtx insn;
1957:
1958: /* Did we generate a stack slot that is out of range
1959: or otherwise has an invalid address? */
1960: if (invalid_stack_slot)
1961: {
1962: /* Yes. Must scan all insns for stack-refs that exceed the limit. */
1963: for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
1964: if (GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN
1965: || GET_CODE (insn) == JUMP_INSN)
1966: fixup_stack_1 (PATTERN (insn), insn);
1967: }
1968: }
1969: #endif
1970:
1971: /* For each memory ref within X, if it refers to a stack slot
1972: with an out of range displacement, put the address in a temp register
1973: (emitting new insns before INSN to load these registers)
1974: and alter the memory ref to use that register.
1975: Replace each such MEM rtx with a copy, to avoid clobberage. */
1976:
1977: static rtx
1978: fixup_stack_1 (x, insn)
1979: rtx x;
1980: rtx insn;
1981: {
1982: register int i;
1983: register RTX_CODE code = GET_CODE (x);
1984: register char *fmt;
1985:
1986: if (code == MEM)
1987: {
1988: register rtx ad = XEXP (x, 0);
1989: /* If we have address of a stack slot but it's not valid
1990: (displacement is too large), compute the sum in a register. */
1991: if (GET_CODE (ad) == PLUS
1992: && GET_CODE (XEXP (ad, 0)) == REG
1993: && ((REGNO (XEXP (ad, 0)) >= FIRST_VIRTUAL_REGISTER
1994: && REGNO (XEXP (ad, 0)) <= LAST_VIRTUAL_REGISTER)
1995: || XEXP (ad, 0) == current_function_internal_arg_pointer)
1996: && GET_CODE (XEXP (ad, 1)) == CONST_INT)
1997: {
1998: rtx temp, seq;
1999: if (memory_address_p (GET_MODE (x), ad))
2000: return x;
2001:
2002: start_sequence ();
2003: temp = copy_to_reg (ad);
2004: seq = gen_sequence ();
2005: end_sequence ();
2006: emit_insn_before (seq, insn);
2007: return change_address (x, VOIDmode, temp);
2008: }
2009: return x;
2010: }
2011:
2012: fmt = GET_RTX_FORMAT (code);
2013: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2014: {
2015: if (fmt[i] == 'e')
2016: XEXP (x, i) = fixup_stack_1 (XEXP (x, i), insn);
2017: if (fmt[i] == 'E')
2018: {
2019: register int j;
2020: for (j = 0; j < XVECLEN (x, i); j++)
2021: XVECEXP (x, i, j) = fixup_stack_1 (XVECEXP (x, i, j), insn);
2022: }
2023: }
2024: return x;
2025: }
2026:
2027: /* Optimization: a bit-field instruction whose field
2028: happens to be a byte or halfword in memory
2029: can be changed to a move instruction.
2030:
2031: We call here when INSN is an insn to examine or store into a bit-field.
2032: BODY is the SET-rtx to be altered.
2033:
2034: EQUIV_MEM is the table `reg_equiv_mem' if that is available; else 0.
2035: (Currently this is called only from function.c, and EQUIV_MEM
2036: is always 0.) */
2037:
2038: static void
2039: optimize_bit_field (body, insn, equiv_mem)
2040: rtx body;
2041: rtx insn;
2042: rtx *equiv_mem;
2043: {
2044: register rtx bitfield;
2045: int destflag;
2046: rtx seq = 0;
2047: enum machine_mode mode;
2048:
2049: if (GET_CODE (SET_DEST (body)) == SIGN_EXTRACT
2050: || GET_CODE (SET_DEST (body)) == ZERO_EXTRACT)
2051: bitfield = SET_DEST (body), destflag = 1;
2052: else
2053: bitfield = SET_SRC (body), destflag = 0;
2054:
2055: /* First check that the field being stored has constant size and position
2056: and is in fact a byte or halfword suitably aligned. */
2057:
2058: if (GET_CODE (XEXP (bitfield, 1)) == CONST_INT
2059: && GET_CODE (XEXP (bitfield, 2)) == CONST_INT
2060: && ((mode = mode_for_size (INTVAL (XEXP (bitfield, 1)), MODE_INT, 1))
2061: != BLKmode)
2062: && INTVAL (XEXP (bitfield, 2)) % INTVAL (XEXP (bitfield, 1)) == 0)
2063: {
2064: register rtx memref = 0;
2065:
2066: /* Now check that the containing word is memory, not a register,
2067: and that it is safe to change the machine mode. */
2068:
2069: if (GET_CODE (XEXP (bitfield, 0)) == MEM)
2070: memref = XEXP (bitfield, 0);
2071: else if (GET_CODE (XEXP (bitfield, 0)) == REG
2072: && equiv_mem != 0)
2073: memref = equiv_mem[REGNO (XEXP (bitfield, 0))];
2074: else if (GET_CODE (XEXP (bitfield, 0)) == SUBREG
2075: && GET_CODE (SUBREG_REG (XEXP (bitfield, 0))) == MEM)
2076: memref = SUBREG_REG (XEXP (bitfield, 0));
2077: else if (GET_CODE (XEXP (bitfield, 0)) == SUBREG
2078: && equiv_mem != 0
2079: && GET_CODE (SUBREG_REG (XEXP (bitfield, 0))) == REG)
2080: memref = equiv_mem[REGNO (SUBREG_REG (XEXP (bitfield, 0)))];
2081:
2082: if (memref
2083: && ! mode_dependent_address_p (XEXP (memref, 0))
2084: && ! MEM_VOLATILE_P (memref))
2085: {
2086: /* Now adjust the address, first for any subreg'ing
2087: that we are now getting rid of,
2088: and then for which byte of the word is wanted. */
2089:
2090: register int offset = INTVAL (XEXP (bitfield, 2));
2091: /* Adjust OFFSET to count bits from low-address byte. */
2092: #if BITS_BIG_ENDIAN != BYTES_BIG_ENDIAN
2093: offset = (GET_MODE_BITSIZE (GET_MODE (XEXP (bitfield, 0)))
2094: - offset - INTVAL (XEXP (bitfield, 1)));
2095: #endif
2096: /* Adjust OFFSET to count bytes from low-address byte. */
2097: offset /= BITS_PER_UNIT;
2098: if (GET_CODE (XEXP (bitfield, 0)) == SUBREG)
2099: {
2100: offset += SUBREG_WORD (XEXP (bitfield, 0)) * UNITS_PER_WORD;
2101: #if BYTES_BIG_ENDIAN
2102: offset -= (MIN (UNITS_PER_WORD,
2103: GET_MODE_SIZE (GET_MODE (XEXP (bitfield, 0))))
2104: - MIN (UNITS_PER_WORD,
2105: GET_MODE_SIZE (GET_MODE (memref))));
2106: #endif
2107: }
2108:
2109: memref = change_address (memref, mode,
2110: plus_constant (XEXP (memref, 0), offset));
2111:
2112: /* Store this memory reference where
2113: we found the bit field reference. */
2114:
2115: if (destflag)
2116: {
2117: validate_change (insn, &SET_DEST (body), memref, 1);
2118: if (! CONSTANT_ADDRESS_P (SET_SRC (body)))
2119: {
2120: rtx src = SET_SRC (body);
2121: while (GET_CODE (src) == SUBREG
2122: && SUBREG_WORD (src) == 0)
2123: src = SUBREG_REG (src);
2124: if (GET_MODE (src) != GET_MODE (memref))
2125: src = gen_lowpart (GET_MODE (memref), SET_SRC (body));
2126: validate_change (insn, &SET_SRC (body), src, 1);
2127: }
2128: else if (GET_MODE (SET_SRC (body)) != VOIDmode
2129: && GET_MODE (SET_SRC (body)) != GET_MODE (memref))
2130: /* This shouldn't happen because anything that didn't have
2131: one of these modes should have got converted explicitly
2132: and then referenced through a subreg.
2133: This is so because the original bit-field was
2134: handled by agg_mode and so its tree structure had
2135: the same mode that memref now has. */
2136: abort ();
2137: }
2138: else
2139: {
2140: rtx dest = SET_DEST (body);
2141:
2142: while (GET_CODE (dest) == SUBREG
2143: && SUBREG_WORD (dest) == 0)
2144: dest = SUBREG_REG (dest);
2145:
2146: validate_change (insn, &SET_DEST (body), dest, 1);
2147:
2148: if (GET_MODE (dest) == GET_MODE (memref))
2149: validate_change (insn, &SET_SRC (body), memref, 1);
2150: else
2151: {
2152: /* Convert the mem ref to the destination mode. */
2153: rtx newreg = gen_reg_rtx (GET_MODE (dest));
2154:
2155: start_sequence ();
2156: convert_move (newreg, memref,
2157: GET_CODE (SET_SRC (body)) == ZERO_EXTRACT);
2158: seq = get_insns ();
2159: end_sequence ();
2160:
2161: validate_change (insn, &SET_SRC (body), newreg, 1);
2162: }
2163: }
2164:
2165: /* See if we can convert this extraction or insertion into
2166: a simple move insn. We might not be able to do so if this
2167: was, for example, part of a PARALLEL.
2168:
2169: If we succeed, write out any needed conversions. If we fail,
2170: it is hard to guess why we failed, so don't do anything
2171: special; just let the optimization be suppressed. */
2172:
2173: if (apply_change_group () && seq)
2174: emit_insns_before (seq, insn);
2175: }
2176: }
2177: }
2178:
2179: /* These routines are responsible for converting virtual register references
2180: to the actual hard register references once RTL generation is complete.
2181:
2182: The following four variables are used for communication between the
2183: routines. They contain the offsets of the virtual registers from their
2184: respective hard registers. */
2185:
2186: static int in_arg_offset;
2187: static int var_offset;
2188: static int dynamic_offset;
2189: static int out_arg_offset;
2190:
2191: /* In most machines, the stack pointer register is equivalent to the bottom
2192: of the stack. */
2193:
2194: #ifndef STACK_POINTER_OFFSET
2195: #define STACK_POINTER_OFFSET 0
2196: #endif
2197:
2198: /* If not defined, pick an appropriate default for the offset of dynamically
2199: allocated memory depending on the value of ACCUMULATE_OUTGOING_ARGS,
2200: REG_PARM_STACK_SPACE, and OUTGOING_REG_PARM_STACK_SPACE. */
2201:
2202: #ifndef STACK_DYNAMIC_OFFSET
2203:
2204: #ifdef ACCUMULATE_OUTGOING_ARGS
2205: /* The bottom of the stack points to the actual arguments. If
2206: REG_PARM_STACK_SPACE is defined, this includes the space for the register
2207: parameters. However, if OUTGOING_REG_PARM_STACK space is not defined,
2208: stack space for register parameters is not pushed by the caller, but
2209: rather part of the fixed stack areas and hence not included in
2210: `current_function_outgoing_args_size'. Nevertheless, we must allow
2211: for it when allocating stack dynamic objects. */
2212:
2213: #if defined(REG_PARM_STACK_SPACE) && ! defined(OUTGOING_REG_PARM_STACK_SPACE)
2214: #define STACK_DYNAMIC_OFFSET(FNDECL) \
2215: (current_function_outgoing_args_size \
2216: + REG_PARM_STACK_SPACE (FNDECL) + (STACK_POINTER_OFFSET))
2217:
2218: #else
2219: #define STACK_DYNAMIC_OFFSET(FNDECL) \
2220: (current_function_outgoing_args_size + (STACK_POINTER_OFFSET))
2221: #endif
2222:
2223: #else
2224: #define STACK_DYNAMIC_OFFSET(FNDECL) STACK_POINTER_OFFSET
2225: #endif
2226: #endif
2227:
2228: /* Pass through the INSNS of function FNDECL and convert virtual register
2229: references to hard register references. */
2230:
2231: void
2232: instantiate_virtual_regs (fndecl, insns)
2233: tree fndecl;
2234: rtx insns;
2235: {
2236: rtx insn;
2237:
2238: /* Compute the offsets to use for this function. */
2239: in_arg_offset = FIRST_PARM_OFFSET (fndecl);
2240: var_offset = STARTING_FRAME_OFFSET;
2241: dynamic_offset = STACK_DYNAMIC_OFFSET (fndecl);
2242: out_arg_offset = STACK_POINTER_OFFSET;
2243:
2244: /* Scan all variables and parameters of this function. For each that is
2245: in memory, instantiate all virtual registers if the result is a valid
2246: address. If not, we do it later. That will handle most uses of virtual
2247: regs on many machines. */
2248: instantiate_decls (fndecl, 1);
2249:
2250: /* Initialize recognition, indicating that volatile is OK. */
2251: init_recog ();
2252:
2253: /* Scan through all the insns, instantiating every virtual register still
2254: present. */
2255: for (insn = insns; insn; insn = NEXT_INSN (insn))
2256: if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN
2257: || GET_CODE (insn) == CALL_INSN)
2258: {
2259: instantiate_virtual_regs_1 (&PATTERN (insn), insn, 1);
2260: instantiate_virtual_regs_1 (®_NOTES (insn), NULL_RTX, 0);
2261: }
2262:
2263: /* Now instantiate the remaining register equivalences for debugging info.
2264: These will not be valid addresses. */
2265: instantiate_decls (fndecl, 0);
2266:
2267: /* Indicate that, from now on, assign_stack_local should use
2268: frame_pointer_rtx. */
2269: virtuals_instantiated = 1;
2270: }
2271:
2272: /* Scan all decls in FNDECL (both variables and parameters) and instantiate
2273: all virtual registers in their DECL_RTL's.
2274:
2275: If VALID_ONLY, do this only if the resulting address is still valid.
2276: Otherwise, always do it. */
2277:
2278: static void
2279: instantiate_decls (fndecl, valid_only)
2280: tree fndecl;
2281: int valid_only;
2282: {
2283: tree decl;
2284:
2285: if (DECL_INLINE (fndecl))
2286: /* When compiling an inline function, the obstack used for
2287: rtl allocation is the maybepermanent_obstack. Calling
2288: `resume_temporary_allocation' switches us back to that
2289: obstack while we process this function's parameters. */
2290: resume_temporary_allocation ();
2291:
2292: /* Process all parameters of the function. */
2293: for (decl = DECL_ARGUMENTS (fndecl); decl; decl = TREE_CHAIN (decl))
2294: {
2295: instantiate_decl (DECL_RTL (decl), int_size_in_bytes (TREE_TYPE (decl)),
2296: valid_only);
2297: instantiate_decl (DECL_INCOMING_RTL (decl),
2298: int_size_in_bytes (TREE_TYPE (decl)), valid_only);
2299: }
2300:
2301: /* Now process all variables defined in the function or its subblocks. */
2302: instantiate_decls_1 (DECL_INITIAL (fndecl), valid_only);
2303:
2304: if (DECL_INLINE (fndecl))
2305: {
2306: /* Save all rtl allocated for this function by raising the
2307: high-water mark on the maybepermanent_obstack. */
2308: preserve_data ();
2309: /* All further rtl allocation is now done in the current_obstack. */
2310: rtl_in_current_obstack ();
2311: }
2312: }
2313:
2314: /* Subroutine of instantiate_decls: Process all decls in the given
2315: BLOCK node and all its subblocks. */
2316:
2317: static void
2318: instantiate_decls_1 (let, valid_only)
2319: tree let;
2320: int valid_only;
2321: {
2322: tree t;
2323:
2324: for (t = BLOCK_VARS (let); t; t = TREE_CHAIN (t))
2325: instantiate_decl (DECL_RTL (t), int_size_in_bytes (TREE_TYPE (t)),
2326: valid_only);
2327:
2328: /* Process all subblocks. */
2329: for (t = BLOCK_SUBBLOCKS (let); t; t = TREE_CHAIN (t))
2330: instantiate_decls_1 (t, valid_only);
2331: }
2332:
2333: /* Subroutine of the preceding procedures: Given RTL representing a
2334: decl and the size of the object, do any instantiation required.
2335:
2336: If VALID_ONLY is non-zero, it means that the RTL should only be
2337: changed if the new address is valid. */
2338:
2339: static void
2340: instantiate_decl (x, size, valid_only)
2341: rtx x;
2342: int size;
2343: int valid_only;
2344: {
2345: enum machine_mode mode;
2346: rtx addr;
2347:
2348: /* If this is not a MEM, no need to do anything. Similarly if the
2349: address is a constant or a register that is not a virtual register. */
2350:
2351: if (x == 0 || GET_CODE (x) != MEM)
2352: return;
2353:
2354: addr = XEXP (x, 0);
2355: if (CONSTANT_P (addr)
2356: || (GET_CODE (addr) == REG
2357: && (REGNO (addr) < FIRST_VIRTUAL_REGISTER
2358: || REGNO (addr) > LAST_VIRTUAL_REGISTER)))
2359: return;
2360:
2361: /* If we should only do this if the address is valid, copy the address.
2362: We need to do this so we can undo any changes that might make the
2363: address invalid. This copy is unfortunate, but probably can't be
2364: avoided. */
2365:
2366: if (valid_only)
2367: addr = copy_rtx (addr);
2368:
2369: instantiate_virtual_regs_1 (&addr, NULL_RTX, 0);
2370:
2371: if (! valid_only)
2372: return;
2373:
2374: /* Now verify that the resulting address is valid for every integer or
2375: floating-point mode up to and including SIZE bytes long. We do this
2376: since the object might be accessed in any mode and frame addresses
2377: are shared. */
2378:
2379: for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
2380: mode != VOIDmode && GET_MODE_SIZE (mode) <= size;
2381: mode = GET_MODE_WIDER_MODE (mode))
2382: if (! memory_address_p (mode, addr))
2383: return;
2384:
2385: for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT);
2386: mode != VOIDmode && GET_MODE_SIZE (mode) <= size;
2387: mode = GET_MODE_WIDER_MODE (mode))
2388: if (! memory_address_p (mode, addr))
2389: return;
2390:
2391: /* Otherwise, put back the address, now that we have updated it and we
2392: know it is valid. */
2393:
2394: XEXP (x, 0) = addr;
2395: }
2396:
2397: /* Given a pointer to a piece of rtx and an optional pointer to the
2398: containing object, instantiate any virtual registers present in it.
2399:
2400: If EXTRA_INSNS, we always do the replacement and generate
2401: any extra insns before OBJECT. If it zero, we do nothing if replacement
2402: is not valid.
2403:
2404: Return 1 if we either had nothing to do or if we were able to do the
2405: needed replacement. Return 0 otherwise; we only return zero if
2406: EXTRA_INSNS is zero.
2407:
2408: We first try some simple transformations to avoid the creation of extra
2409: pseudos. */
2410:
2411: static int
2412: instantiate_virtual_regs_1 (loc, object, extra_insns)
2413: rtx *loc;
2414: rtx object;
2415: int extra_insns;
2416: {
2417: rtx x;
2418: RTX_CODE code;
2419: rtx new = 0;
2420: int offset;
2421: rtx temp;
2422: rtx seq;
2423: int i, j;
2424: char *fmt;
2425:
2426: /* Re-start here to avoid recursion in common cases. */
2427: restart:
2428:
2429: x = *loc;
2430: if (x == 0)
2431: return 1;
2432:
2433: code = GET_CODE (x);
2434:
2435: /* Check for some special cases. */
2436: switch (code)
2437: {
2438: case CONST_INT:
2439: case CONST_DOUBLE:
2440: case CONST:
2441: case SYMBOL_REF:
2442: case CODE_LABEL:
2443: case PC:
2444: case CC0:
2445: case ASM_INPUT:
2446: case ADDR_VEC:
2447: case ADDR_DIFF_VEC:
2448: case RETURN:
2449: return 1;
2450:
2451: case SET:
2452: /* We are allowed to set the virtual registers. This means that
2453: that the actual register should receive the source minus the
2454: appropriate offset. This is used, for example, in the handling
2455: of non-local gotos. */
2456: if (SET_DEST (x) == virtual_incoming_args_rtx)
2457: new = arg_pointer_rtx, offset = - in_arg_offset;
2458: else if (SET_DEST (x) == virtual_stack_vars_rtx)
2459: new = frame_pointer_rtx, offset = - var_offset;
2460: else if (SET_DEST (x) == virtual_stack_dynamic_rtx)
2461: new = stack_pointer_rtx, offset = - dynamic_offset;
2462: else if (SET_DEST (x) == virtual_outgoing_args_rtx)
2463: new = stack_pointer_rtx, offset = - out_arg_offset;
2464:
2465: if (new)
2466: {
2467: /* The only valid sources here are PLUS or REG. Just do
2468: the simplest possible thing to handle them. */
2469: if (GET_CODE (SET_SRC (x)) != REG
2470: && GET_CODE (SET_SRC (x)) != PLUS)
2471: abort ();
2472:
2473: start_sequence ();
2474: if (GET_CODE (SET_SRC (x)) != REG)
2475: temp = force_operand (SET_SRC (x), NULL_RTX);
2476: else
2477: temp = SET_SRC (x);
2478: temp = force_operand (plus_constant (temp, offset), NULL_RTX);
2479: seq = get_insns ();
2480: end_sequence ();
2481:
2482: emit_insns_before (seq, object);
2483: SET_DEST (x) = new;
2484:
2485: if (!validate_change (object, &SET_SRC (x), temp, 0)
2486: || ! extra_insns)
2487: abort ();
2488:
2489: return 1;
2490: }
2491:
2492: instantiate_virtual_regs_1 (&SET_DEST (x), object, extra_insns);
2493: loc = &SET_SRC (x);
2494: goto restart;
2495:
2496: case PLUS:
2497: /* Handle special case of virtual register plus constant. */
2498: if (CONSTANT_P (XEXP (x, 1)))
2499: {
2500: rtx old;
2501:
2502: /* Check for (plus (plus VIRT foo) (const_int)) first. */
2503: if (GET_CODE (XEXP (x, 0)) == PLUS)
2504: {
2505: rtx inner = XEXP (XEXP (x, 0), 0);
2506:
2507: if (inner == virtual_incoming_args_rtx)
2508: new = arg_pointer_rtx, offset = in_arg_offset;
2509: else if (inner == virtual_stack_vars_rtx)
2510: new = frame_pointer_rtx, offset = var_offset;
2511: else if (inner == virtual_stack_dynamic_rtx)
2512: new = stack_pointer_rtx, offset = dynamic_offset;
2513: else if (inner == virtual_outgoing_args_rtx)
2514: new = stack_pointer_rtx, offset = out_arg_offset;
2515: else
2516: {
2517: loc = &XEXP (x, 0);
2518: goto restart;
2519: }
2520:
2521: instantiate_virtual_regs_1 (&XEXP (XEXP (x, 0), 1), object,
2522: extra_insns);
2523: new = gen_rtx (PLUS, Pmode, new, XEXP (XEXP (x, 0), 1));
2524: }
2525:
2526: else if (XEXP (x, 0) == virtual_incoming_args_rtx)
2527: new = arg_pointer_rtx, offset = in_arg_offset;
2528: else if (XEXP (x, 0) == virtual_stack_vars_rtx)
2529: new = frame_pointer_rtx, offset = var_offset;
2530: else if (XEXP (x, 0) == virtual_stack_dynamic_rtx)
2531: new = stack_pointer_rtx, offset = dynamic_offset;
2532: else if (XEXP (x, 0) == virtual_outgoing_args_rtx)
2533: new = stack_pointer_rtx, offset = out_arg_offset;
2534: else
2535: {
2536: /* We know the second operand is a constant. Unless the
2537: first operand is a REG (which has been already checked),
2538: it needs to be checked. */
2539: if (GET_CODE (XEXP (x, 0)) != REG)
2540: {
2541: loc = &XEXP (x, 0);
2542: goto restart;
2543: }
2544: return 1;
2545: }
2546:
2547: old = XEXP (x, 0);
2548: XEXP (x, 0) = new;
2549: new = plus_constant (XEXP (x, 1), offset);
2550:
2551: /* If the new constant is zero, try to replace the sum with its
2552: first operand. */
2553: if (new == const0_rtx
2554: && validate_change (object, loc, XEXP (x, 0), 0))
2555: return 1;
2556:
2557: /* Next try to replace constant with new one. */
2558: if (!validate_change (object, &XEXP (x, 1), new, 0))
2559: {
2560: if (! extra_insns)
2561: {
2562: XEXP (x, 0) = old;
2563: return 0;
2564: }
2565:
2566: /* Otherwise copy the new constant into a register and replace
2567: constant with that register. */
2568: temp = gen_reg_rtx (Pmode);
2569: if (validate_change (object, &XEXP (x, 1), temp, 0))
2570: emit_insn_before (gen_move_insn (temp, new), object);
2571: else
2572: {
2573: /* If that didn't work, replace this expression with a
2574: register containing the sum. */
2575:
2576: new = gen_rtx (PLUS, Pmode, XEXP (x, 0), new);
2577: XEXP (x, 0) = old;
2578:
2579: start_sequence ();
2580: temp = force_operand (new, NULL_RTX);
2581: seq = get_insns ();
2582: end_sequence ();
2583:
2584: emit_insns_before (seq, object);
2585: if (! validate_change (object, loc, temp, 0)
2586: && ! validate_replace_rtx (x, temp, object))
2587: abort ();
2588: }
2589: }
2590:
2591: return 1;
2592: }
2593:
2594: /* Fall through to generic two-operand expression case. */
2595: case EXPR_LIST:
2596: case CALL:
2597: case COMPARE:
2598: case MINUS:
2599: case MULT:
2600: case DIV: case UDIV:
2601: case MOD: case UMOD:
2602: case AND: case IOR: case XOR:
2603: case LSHIFT: case ASHIFT: case ROTATE:
2604: case ASHIFTRT: case LSHIFTRT: case ROTATERT:
2605: case NE: case EQ:
2606: case GE: case GT: case GEU: case GTU:
2607: case LE: case LT: case LEU: case LTU:
2608: if (XEXP (x, 1) && ! CONSTANT_P (XEXP (x, 1)))
2609: instantiate_virtual_regs_1 (&XEXP (x, 1), object, extra_insns);
2610: loc = &XEXP (x, 0);
2611: goto restart;
2612:
2613: case MEM:
2614: /* Most cases of MEM that convert to valid addresses have already been
2615: handled by our scan of regno_reg_rtx. The only special handling we
2616: need here is to make a copy of the rtx to ensure it isn't being
2617: shared if we have to change it to a pseudo.
2618:
2619: If the rtx is a simple reference to an address via a virtual register,
2620: it can potentially be shared. In such cases, first try to make it
2621: a valid address, which can also be shared. Otherwise, copy it and
2622: proceed normally.
2623:
2624: First check for common cases that need no processing. These are
2625: usually due to instantiation already being done on a previous instance
2626: of a shared rtx. */
2627:
2628: temp = XEXP (x, 0);
2629: if (CONSTANT_ADDRESS_P (temp)
2630: #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
2631: || temp == arg_pointer_rtx
2632: #endif
2633: #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
2634: || temp == hard_frame_pointer_rtx
2635: #endif
2636: || temp == frame_pointer_rtx)
2637: return 1;
2638:
2639: if (GET_CODE (temp) == PLUS
2640: && CONSTANT_ADDRESS_P (XEXP (temp, 1))
2641: && (XEXP (temp, 0) == frame_pointer_rtx
2642: #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
2643: || XEXP (temp, 0) == hard_frame_pointer_rtx
2644: #endif
2645: #if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
2646: || XEXP (temp, 0) == arg_pointer_rtx
2647: #endif
2648: ))
2649: return 1;
2650:
2651: if (temp == virtual_stack_vars_rtx
2652: || temp == virtual_incoming_args_rtx
2653: || (GET_CODE (temp) == PLUS
2654: && CONSTANT_ADDRESS_P (XEXP (temp, 1))
2655: && (XEXP (temp, 0) == virtual_stack_vars_rtx
2656: || XEXP (temp, 0) == virtual_incoming_args_rtx)))
2657: {
2658: /* This MEM may be shared. If the substitution can be done without
2659: the need to generate new pseudos, we want to do it in place
2660: so all copies of the shared rtx benefit. The call below will
2661: only make substitutions if the resulting address is still
2662: valid.
2663:
2664: Note that we cannot pass X as the object in the recursive call
2665: since the insn being processed may not allow all valid
2666: addresses. However, if we were not passed on object, we can
2667: only modify X without copying it if X will have a valid
2668: address.
2669:
2670: ??? Also note that this can still lose if OBJECT is an insn that
2671: has less restrictions on an address that some other insn.
2672: In that case, we will modify the shared address. This case
2673: doesn't seem very likely, though. */
2674:
2675: if (instantiate_virtual_regs_1 (&XEXP (x, 0),
2676: object ? object : x, 0))
2677: return 1;
2678:
2679: /* Otherwise make a copy and process that copy. We copy the entire
2680: RTL expression since it might be a PLUS which could also be
2681: shared. */
2682: *loc = x = copy_rtx (x);
2683: }
2684:
2685: /* Fall through to generic unary operation case. */
2686: case USE:
2687: case CLOBBER:
2688: case SUBREG:
2689: case STRICT_LOW_PART:
2690: case NEG: case NOT:
2691: case PRE_DEC: case PRE_INC: case POST_DEC: case POST_INC:
2692: case SIGN_EXTEND: case ZERO_EXTEND:
2693: case TRUNCATE: case FLOAT_EXTEND: case FLOAT_TRUNCATE:
2694: case FLOAT: case FIX:
2695: case UNSIGNED_FIX: case UNSIGNED_FLOAT:
2696: case ABS:
2697: case SQRT:
2698: case FFS:
2699: /* These case either have just one operand or we know that we need not
2700: check the rest of the operands. */
2701: loc = &XEXP (x, 0);
2702: goto restart;
2703:
2704: case REG:
2705: /* Try to replace with a PLUS. If that doesn't work, compute the sum
2706: in front of this insn and substitute the temporary. */
2707: if (x == virtual_incoming_args_rtx)
2708: new = arg_pointer_rtx, offset = in_arg_offset;
2709: else if (x == virtual_stack_vars_rtx)
2710: new = frame_pointer_rtx, offset = var_offset;
2711: else if (x == virtual_stack_dynamic_rtx)
2712: new = stack_pointer_rtx, offset = dynamic_offset;
2713: else if (x == virtual_outgoing_args_rtx)
2714: new = stack_pointer_rtx, offset = out_arg_offset;
2715:
2716: if (new)
2717: {
2718: temp = plus_constant (new, offset);
2719: if (!validate_change (object, loc, temp, 0))
2720: {
2721: if (! extra_insns)
2722: return 0;
2723:
2724: start_sequence ();
2725: temp = force_operand (temp, NULL_RTX);
2726: seq = get_insns ();
2727: end_sequence ();
2728:
2729: emit_insns_before (seq, object);
2730: if (! validate_change (object, loc, temp, 0)
2731: && ! validate_replace_rtx (x, temp, object))
2732: abort ();
2733: }
2734: }
2735:
2736: return 1;
2737: }
2738:
2739: /* Scan all subexpressions. */
2740: fmt = GET_RTX_FORMAT (code);
2741: for (i = 0; i < GET_RTX_LENGTH (code); i++, fmt++)
2742: if (*fmt == 'e')
2743: {
2744: if (!instantiate_virtual_regs_1 (&XEXP (x, i), object, extra_insns))
2745: return 0;
2746: }
2747: else if (*fmt == 'E')
2748: for (j = 0; j < XVECLEN (x, i); j++)
2749: if (! instantiate_virtual_regs_1 (&XVECEXP (x, i, j), object,
2750: extra_insns))
2751: return 0;
2752:
2753: return 1;
2754: }
2755:
2756: /* Optimization: assuming this function does not receive nonlocal gotos,
2757: delete the handlers for such, as well as the insns to establish
2758: and disestablish them. */
2759:
2760: static void
2761: delete_handlers ()
2762: {
2763: rtx insn;
2764: for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2765: {
2766: /* Delete the handler by turning off the flag that would
2767: prevent jump_optimize from deleting it.
2768: Also permit deletion of the nonlocal labels themselves
2769: if nothing local refers to them. */
2770: if (GET_CODE (insn) == CODE_LABEL)
2771: LABEL_PRESERVE_P (insn) = 0;
2772: if (GET_CODE (insn) == INSN
2773: && ((nonlocal_goto_handler_slot != 0
2774: && reg_mentioned_p (nonlocal_goto_handler_slot, PATTERN (insn)))
2775: || (nonlocal_goto_stack_level != 0
2776: && reg_mentioned_p (nonlocal_goto_stack_level,
2777: PATTERN (insn)))))
2778: delete_insn (insn);
2779: }
2780: }
2781:
2782: /* Return a list (chain of EXPR_LIST nodes) for the nonlocal labels
2783: of the current function. */
2784:
2785: rtx
2786: nonlocal_label_rtx_list ()
2787: {
2788: tree t;
2789: rtx x = 0;
2790:
2791: for (t = nonlocal_labels; t; t = TREE_CHAIN (t))
2792: x = gen_rtx (EXPR_LIST, VOIDmode, label_rtx (TREE_VALUE (t)), x);
2793:
2794: return x;
2795: }
2796:
2797: /* Output a USE for any register use in RTL.
2798: This is used with -noreg to mark the extent of lifespan
2799: of any registers used in a user-visible variable's DECL_RTL. */
2800:
2801: void
2802: use_variable (rtl)
2803: rtx rtl;
2804: {
2805: if (GET_CODE (rtl) == REG)
2806: /* This is a register variable. */
2807: emit_insn (gen_rtx (USE, VOIDmode, rtl));
2808: else if (GET_CODE (rtl) == MEM
2809: && GET_CODE (XEXP (rtl, 0)) == REG
2810: && (REGNO (XEXP (rtl, 0)) < FIRST_VIRTUAL_REGISTER
2811: || REGNO (XEXP (rtl, 0)) > LAST_VIRTUAL_REGISTER)
2812: && XEXP (rtl, 0) != current_function_internal_arg_pointer)
2813: /* This is a variable-sized structure. */
2814: emit_insn (gen_rtx (USE, VOIDmode, XEXP (rtl, 0)));
2815: }
2816:
2817: /* Like use_variable except that it outputs the USEs after INSN
2818: instead of at the end of the insn-chain. */
2819:
2820: void
2821: use_variable_after (rtl, insn)
2822: rtx rtl, insn;
2823: {
2824: if (GET_CODE (rtl) == REG)
2825: /* This is a register variable. */
2826: emit_insn_after (gen_rtx (USE, VOIDmode, rtl), insn);
2827: else if (GET_CODE (rtl) == MEM
2828: && GET_CODE (XEXP (rtl, 0)) == REG
2829: && (REGNO (XEXP (rtl, 0)) < FIRST_VIRTUAL_REGISTER
2830: || REGNO (XEXP (rtl, 0)) > LAST_VIRTUAL_REGISTER)
2831: && XEXP (rtl, 0) != current_function_internal_arg_pointer)
2832: /* This is a variable-sized structure. */
2833: emit_insn_after (gen_rtx (USE, VOIDmode, XEXP (rtl, 0)), insn);
2834: }
2835:
2836: int
2837: max_parm_reg_num ()
2838: {
2839: return max_parm_reg;
2840: }
2841:
2842: /* Return the first insn following those generated by `assign_parms'. */
2843:
2844: rtx
2845: get_first_nonparm_insn ()
2846: {
2847: if (last_parm_insn)
2848: return NEXT_INSN (last_parm_insn);
2849: return get_insns ();
2850: }
2851:
2852: /* Return the first NOTE_INSN_BLOCK_BEG note in the function.
2853: Crash if there is none. */
2854:
2855: rtx
2856: get_first_block_beg ()
2857: {
2858: register rtx searcher;
2859: register rtx insn = get_first_nonparm_insn ();
2860:
2861: for (searcher = insn; searcher; searcher = NEXT_INSN (searcher))
2862: if (GET_CODE (searcher) == NOTE
2863: && NOTE_LINE_NUMBER (searcher) == NOTE_INSN_BLOCK_BEG)
2864: return searcher;
2865:
2866: abort (); /* Invalid call to this function. (See comments above.) */
2867: return NULL_RTX;
2868: }
2869:
2870: /* Return 1 if EXP is an aggregate type (or a value with aggregate type).
2871: This means a type for which function calls must pass an address to the
2872: function or get an address back from the function.
2873: EXP may be a type node or an expression (whose type is tested). */
2874:
2875: int
2876: aggregate_value_p (exp)
2877: tree exp;
2878: {
2879: int i, regno, nregs;
2880: rtx reg;
2881: tree type;
2882: if (TREE_CODE_CLASS (TREE_CODE (exp)) == 't')
2883: type = exp;
2884: else
2885: type = TREE_TYPE (exp);
2886:
2887: if (RETURN_IN_MEMORY (type))
2888: return 1;
2889: if (flag_pcc_struct_return
2890: && (TREE_CODE (type) == RECORD_TYPE
2891: || TREE_CODE (type) == UNION_TYPE
2892: || TREE_CODE (type) == QUAL_UNION_TYPE
2893: || TREE_CODE (type) == ARRAY_TYPE))
2894: return 1;
2895: /* Make sure we have suitable call-clobbered regs to return
2896: the value in; if not, we must return it in memory. */
2897: reg = hard_function_value (type, 0);
2898: regno = REGNO (reg);
2899: nregs = HARD_REGNO_NREGS (regno, TYPE_MODE (type));
2900: for (i = 0; i < nregs; i++)
2901: if (! call_used_regs[regno + i])
2902: return 1;
2903: return 0;
2904: }
2905:
2906: /* Assign RTL expressions to the function's parameters.
2907: This may involve copying them into registers and using
2908: those registers as the RTL for them.
2909:
2910: If SECOND_TIME is non-zero it means that this function is being
2911: called a second time. This is done by integrate.c when a function's
2912: compilation is deferred. We need to come back here in case the
2913: FUNCTION_ARG macro computes items needed for the rest of the compilation
2914: (such as changing which registers are fixed or caller-saved). But suppress
2915: writing any insns or setting DECL_RTL of anything in this case. */
2916:
2917: void
2918: assign_parms (fndecl, second_time)
2919: tree fndecl;
2920: int second_time;
2921: {
2922: register tree parm;
2923: register rtx entry_parm = 0;
2924: register rtx stack_parm = 0;
2925: CUMULATIVE_ARGS args_so_far;
2926: enum machine_mode promoted_mode, passed_mode, nominal_mode;
2927: int unsignedp;
2928: /* Total space needed so far for args on the stack,
2929: given as a constant and a tree-expression. */
2930: struct args_size stack_args_size;
2931: tree fntype = TREE_TYPE (fndecl);
2932: tree fnargs = DECL_ARGUMENTS (fndecl);
2933: /* This is used for the arg pointer when referring to stack args. */
2934: rtx internal_arg_pointer;
2935: /* This is a dummy PARM_DECL that we used for the function result if
2936: the function returns a structure. */
2937: tree function_result_decl = 0;
2938: int nparmregs = list_length (fnargs) + LAST_VIRTUAL_REGISTER + 1;
2939: int varargs_setup = 0;
2940: rtx conversion_insns = 0;
2941: /* FUNCTION_ARG may look at this variable. Since this is not
2942: expanding a call it will always be zero in this function. */
2943: int current_call_is_indirect = 0;
2944:
2945: /* Nonzero if the last arg is named `__builtin_va_alist',
2946: which is used on some machines for old-fashioned non-ANSI varargs.h;
2947: this should be stuck onto the stack as if it had arrived there. */
2948: int vararg
2949: = (fnargs
2950: && (parm = tree_last (fnargs)) != 0
2951: && DECL_NAME (parm)
2952: && (! strcmp (IDENTIFIER_POINTER (DECL_NAME (parm)),
2953: "__builtin_va_alist")));
2954:
2955: /* Nonzero if function takes extra anonymous args.
2956: This means the last named arg must be on the stack
2957: right before the anonymous ones. */
2958: int stdarg
2959: = (TYPE_ARG_TYPES (fntype) != 0
2960: && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
2961: != void_type_node));
2962:
2963: /* If the reg that the virtual arg pointer will be translated into is
2964: not a fixed reg or is the stack pointer, make a copy of the virtual
2965: arg pointer, and address parms via the copy. The frame pointer is
2966: considered fixed even though it is not marked as such.
2967:
2968: The second time through, simply use ap to avoid generating rtx. */
2969:
2970: if ((ARG_POINTER_REGNUM == STACK_POINTER_REGNUM
2971: || ! (fixed_regs[ARG_POINTER_REGNUM]
2972: || ARG_POINTER_REGNUM == FRAME_POINTER_REGNUM))
2973: && ! second_time)
2974: internal_arg_pointer = copy_to_reg (virtual_incoming_args_rtx);
2975: else
2976: internal_arg_pointer = virtual_incoming_args_rtx;
2977: current_function_internal_arg_pointer = internal_arg_pointer;
2978:
2979: stack_args_size.constant = 0;
2980: stack_args_size.var = 0;
2981:
2982: /* If struct value address is treated as the first argument, make it so. */
2983: if (aggregate_value_p (DECL_RESULT (fndecl))
2984: && ! current_function_returns_pcc_struct
2985: && struct_value_incoming_rtx == 0)
2986: {
2987: tree type = build_pointer_type (fntype);
2988:
2989: function_result_decl = build_decl (PARM_DECL, NULL_TREE, type);
2990:
2991: DECL_ARG_TYPE (function_result_decl) = type;
2992: TREE_CHAIN (function_result_decl) = fnargs;
2993: fnargs = function_result_decl;
2994: }
2995:
2996: parm_reg_stack_loc = (rtx *) oballoc (nparmregs * sizeof (rtx));
2997: bzero (parm_reg_stack_loc, nparmregs * sizeof (rtx));
2998:
2999: #ifdef INIT_CUMULATIVE_INCOMING_ARGS
3000: INIT_CUMULATIVE_INCOMING_ARGS (args_so_far, fntype, NULL_RTX);
3001: #else
3002: INIT_CUMULATIVE_ARGS (args_so_far, fntype, NULL_RTX);
3003: #endif
3004:
3005: /* We haven't yet found an argument that we must push and pretend the
3006: caller did. */
3007: current_function_pretend_args_size = 0;
3008:
3009: for (parm = fnargs; parm; parm = TREE_CHAIN (parm))
3010: {
3011: int aggregate
3012: = (TREE_CODE (TREE_TYPE (parm)) == ARRAY_TYPE
3013: || TREE_CODE (TREE_TYPE (parm)) == RECORD_TYPE
3014: || TREE_CODE (TREE_TYPE (parm)) == UNION_TYPE
3015: || TREE_CODE (TREE_TYPE (parm)) == QUAL_UNION_TYPE);
3016: struct args_size stack_offset;
3017: struct args_size arg_size;
3018: int passed_pointer = 0;
3019: tree passed_type = DECL_ARG_TYPE (parm);
3020:
3021: /* Set LAST_NAMED if this is last named arg before some
3022: anonymous args. We treat it as if it were anonymous too. */
3023: int last_named = ((TREE_CHAIN (parm) == 0
3024: || DECL_NAME (TREE_CHAIN (parm)) == 0)
3025: && (vararg || stdarg));
3026:
3027: if (TREE_TYPE (parm) == error_mark_node
3028: /* This can happen after weird syntax errors
3029: or if an enum type is defined among the parms. */
3030: || TREE_CODE (parm) != PARM_DECL
3031: || passed_type == NULL)
3032: {
3033: DECL_INCOMING_RTL (parm) = DECL_RTL (parm) = gen_rtx (MEM, BLKmode,
3034: const0_rtx);
3035: TREE_USED (parm) = 1;
3036: continue;
3037: }
3038:
3039: /* For varargs.h function, save info about regs and stack space
3040: used by the individual args, not including the va_alist arg. */
3041: if (vararg && last_named)
3042: current_function_args_info = args_so_far;
3043:
3044: /* Find mode of arg as it is passed, and mode of arg
3045: as it should be during execution of this function. */
3046: passed_mode = TYPE_MODE (passed_type);
3047: nominal_mode = TYPE_MODE (TREE_TYPE (parm));
3048:
3049: /* If the parm's mode is VOID, its value doesn't matter,
3050: and avoid the usual things like emit_move_insn that could crash. */
3051: if (nominal_mode == VOIDmode)
3052: {
3053: DECL_INCOMING_RTL (parm) = DECL_RTL (parm) = const0_rtx;
3054: continue;
3055: }
3056:
3057: /* See if this arg was passed by invisible reference. It is if
3058: it is an object whose size depends on the contents of the
3059: object itself or if the machine requires these objects be passed
3060: that way. */
3061:
3062: if ((TREE_CODE (TYPE_SIZE (passed_type)) != INTEGER_CST
3063: && contains_placeholder_p (TYPE_SIZE (passed_type)))
3064: #ifdef FUNCTION_ARG_PASS_BY_REFERENCE
3065: || FUNCTION_ARG_PASS_BY_REFERENCE (args_so_far, passed_mode,
3066: passed_type, ! last_named)
3067: #endif
3068: )
3069: {
3070: passed_type = build_pointer_type (passed_type);
3071: passed_pointer = 1;
3072: passed_mode = nominal_mode = Pmode;
3073: }
3074:
3075: promoted_mode = passed_mode;
3076:
3077: #ifdef PROMOTE_FUNCTION_ARGS
3078: /* Compute the mode in which the arg is actually extended to. */
3079: if (TREE_CODE (passed_type) == INTEGER_TYPE
3080: || TREE_CODE (passed_type) == ENUMERAL_TYPE
3081: || TREE_CODE (passed_type) == BOOLEAN_TYPE
3082: || TREE_CODE (passed_type) == CHAR_TYPE
3083: || TREE_CODE (passed_type) == REAL_TYPE
3084: || TREE_CODE (passed_type) == POINTER_TYPE
3085: || TREE_CODE (passed_type) == OFFSET_TYPE)
3086: {
3087: unsignedp = TREE_UNSIGNED (passed_type);
3088: PROMOTE_MODE (promoted_mode, unsignedp, passed_type);
3089: }
3090: #endif
3091:
3092: /* Let machine desc say which reg (if any) the parm arrives in.
3093: 0 means it arrives on the stack. */
3094: #ifdef FUNCTION_INCOMING_ARG
3095: entry_parm = FUNCTION_INCOMING_ARG (args_so_far, promoted_mode,
3096: passed_type, ! last_named);
3097: #else
3098: entry_parm = FUNCTION_ARG (args_so_far, promoted_mode,
3099: passed_type, ! last_named);
3100: #endif
3101:
3102: if (entry_parm)
3103: passed_mode = promoted_mode;
3104:
3105: #ifdef SETUP_INCOMING_VARARGS
3106: /* If this is the last named parameter, do any required setup for
3107: varargs or stdargs. We need to know about the case of this being an
3108: addressable type, in which case we skip the registers it
3109: would have arrived in.
3110:
3111: For stdargs, LAST_NAMED will be set for two parameters, the one that
3112: is actually the last named, and the dummy parameter. We only
3113: want to do this action once.
3114:
3115: Also, indicate when RTL generation is to be suppressed. */
3116: if (last_named && !varargs_setup)
3117: {
3118: SETUP_INCOMING_VARARGS (args_so_far, passed_mode, passed_type,
3119: current_function_pretend_args_size,
3120: second_time);
3121: varargs_setup = 1;
3122: }
3123: #endif
3124:
3125: /* Determine parm's home in the stack,
3126: in case it arrives in the stack or we should pretend it did.
3127:
3128: Compute the stack position and rtx where the argument arrives
3129: and its size.
3130:
3131: There is one complexity here: If this was a parameter that would
3132: have been passed in registers, but wasn't only because it is
3133: __builtin_va_alist, we want locate_and_pad_parm to treat it as if
3134: it came in a register so that REG_PARM_STACK_SPACE isn't skipped.
3135: In this case, we call FUNCTION_ARG with NAMED set to 1 instead of
3136: 0 as it was the previous time. */
3137:
3138: locate_and_pad_parm (passed_mode, passed_type,
3139: #ifdef STACK_PARMS_IN_REG_PARM_AREA
3140: 1,
3141: #else
3142: #ifdef FUNCTION_INCOMING_ARG
3143: FUNCTION_INCOMING_ARG (args_so_far, passed_mode,
3144: passed_type,
3145: (! last_named
3146: || varargs_setup)) != 0,
3147: #else
3148: FUNCTION_ARG (args_so_far, passed_mode,
3149: passed_type,
3150: ! last_named || varargs_setup) != 0,
3151: #endif
3152: #endif
3153: fndecl, &stack_args_size, &stack_offset, &arg_size);
3154:
3155: if (! second_time)
3156: {
3157: rtx offset_rtx = ARGS_SIZE_RTX (stack_offset);
3158:
3159: if (offset_rtx == const0_rtx)
3160: stack_parm = gen_rtx (MEM, passed_mode, internal_arg_pointer);
3161: else
3162: stack_parm = gen_rtx (MEM, passed_mode,
3163: gen_rtx (PLUS, Pmode,
3164: internal_arg_pointer, offset_rtx));
3165:
3166: /* If this is a memory ref that contains aggregate components,
3167: mark it as such for cse and loop optimize. */
3168: MEM_IN_STRUCT_P (stack_parm) = aggregate;
3169: }
3170:
3171: /* If this parameter was passed both in registers and in the stack,
3172: use the copy on the stack. */
3173: if (MUST_PASS_IN_STACK (passed_mode, passed_type))
3174: entry_parm = 0;
3175:
3176: #ifdef FUNCTION_ARG_PARTIAL_NREGS
3177: /* If this parm was passed part in regs and part in memory,
3178: pretend it arrived entirely in memory
3179: by pushing the register-part onto the stack.
3180:
3181: In the special case of a DImode or DFmode that is split,
3182: we could put it together in a pseudoreg directly,
3183: but for now that's not worth bothering with. */
3184:
3185: if (entry_parm)
3186: {
3187: int nregs = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, passed_mode,
3188: passed_type, ! last_named);
3189:
3190: if (nregs > 0)
3191: {
3192: current_function_pretend_args_size
3193: = (((nregs * UNITS_PER_WORD) + (PARM_BOUNDARY / BITS_PER_UNIT) - 1)
3194: / (PARM_BOUNDARY / BITS_PER_UNIT)
3195: * (PARM_BOUNDARY / BITS_PER_UNIT));
3196:
3197: if (! second_time)
3198: move_block_from_reg (REGNO (entry_parm),
3199: validize_mem (stack_parm), nregs,
3200: int_size_in_bytes (TREE_TYPE (parm)));
3201: entry_parm = stack_parm;
3202: }
3203: }
3204: #endif
3205:
3206: /* If we didn't decide this parm came in a register,
3207: by default it came on the stack. */
3208: if (entry_parm == 0)
3209: entry_parm = stack_parm;
3210:
3211: /* Record permanently how this parm was passed. */
3212: if (! second_time)
3213: DECL_INCOMING_RTL (parm) = entry_parm;
3214:
3215: /* If there is actually space on the stack for this parm,
3216: count it in stack_args_size; otherwise set stack_parm to 0
3217: to indicate there is no preallocated stack slot for the parm. */
3218:
3219: if (entry_parm == stack_parm
3220: #if defined (REG_PARM_STACK_SPACE) && ! defined (MAYBE_REG_PARM_STACK_SPACE)
3221: /* On some machines, even if a parm value arrives in a register
3222: there is still an (uninitialized) stack slot allocated for it.
3223:
3224: ??? When MAYBE_REG_PARM_STACK_SPACE is defined, we can't tell
3225: whether this parameter already has a stack slot allocated,
3226: because an arg block exists only if current_function_args_size
3227: is larger than some threshhold, and we haven't calculated that
3228: yet. So, for now, we just assume that stack slots never exist
3229: in this case. */
3230: || REG_PARM_STACK_SPACE (fndecl) > 0
3231: #endif
3232: )
3233: {
3234: stack_args_size.constant += arg_size.constant;
3235: if (arg_size.var)
3236: ADD_PARM_SIZE (stack_args_size, arg_size.var);
3237: }
3238: else
3239: /* No stack slot was pushed for this parm. */
3240: stack_parm = 0;
3241:
3242: /* Update info on where next arg arrives in registers. */
3243:
3244: FUNCTION_ARG_ADVANCE (args_so_far, passed_mode,
3245: passed_type, ! last_named);
3246:
3247: /* If this is our second time through, we are done with this parm. */
3248: if (second_time)
3249: continue;
3250:
3251: /* If we can't trust the parm stack slot to be aligned enough
3252: for its ultimate type, don't use that slot after entry.
3253: We'll make another stack slot, if we need one. */
3254: {
3255: int thisparm_boundary
3256: = FUNCTION_ARG_BOUNDARY (passed_mode, passed_type);
3257:
3258: if (GET_MODE_ALIGNMENT (nominal_mode) > thisparm_boundary)
3259: stack_parm = 0;
3260: }
3261:
3262: /* If parm was passed in memory, and we need to convert it on entry,
3263: don't store it back in that same slot. */
3264: if (entry_parm != 0
3265: && nominal_mode != BLKmode && nominal_mode != passed_mode)
3266: stack_parm = 0;
3267:
3268: #if 0
3269: /* Now adjust STACK_PARM to the mode and precise location
3270: where this parameter should live during execution,
3271: if we discover that it must live in the stack during execution.
3272: To make debuggers happier on big-endian machines, we store
3273: the value in the last bytes of the space available. */
3274:
3275: if (nominal_mode != BLKmode && nominal_mode != passed_mode
3276: && stack_parm != 0)
3277: {
3278: rtx offset_rtx;
3279:
3280: #if BYTES_BIG_ENDIAN
3281: if (GET_MODE_SIZE (nominal_mode) < UNITS_PER_WORD)
3282: stack_offset.constant += (GET_MODE_SIZE (passed_mode)
3283: - GET_MODE_SIZE (nominal_mode));
3284: #endif
3285:
3286: offset_rtx = ARGS_SIZE_RTX (stack_offset);
3287: if (offset_rtx == const0_rtx)
3288: stack_parm = gen_rtx (MEM, nominal_mode, internal_arg_pointer);
3289: else
3290: stack_parm = gen_rtx (MEM, nominal_mode,
3291: gen_rtx (PLUS, Pmode,
3292: internal_arg_pointer, offset_rtx));
3293:
3294: /* If this is a memory ref that contains aggregate components,
3295: mark it as such for cse and loop optimize. */
3296: MEM_IN_STRUCT_P (stack_parm) = aggregate;
3297: }
3298: #endif /* 0 */
3299:
3300: /* ENTRY_PARM is an RTX for the parameter as it arrives,
3301: in the mode in which it arrives.
3302: STACK_PARM is an RTX for a stack slot where the parameter can live
3303: during the function (in case we want to put it there).
3304: STACK_PARM is 0 if no stack slot was pushed for it.
3305:
3306: Now output code if necessary to convert ENTRY_PARM to
3307: the type in which this function declares it,
3308: and store that result in an appropriate place,
3309: which may be a pseudo reg, may be STACK_PARM,
3310: or may be a local stack slot if STACK_PARM is 0.
3311:
3312: Set DECL_RTL to that place. */
3313:
3314: if (nominal_mode == BLKmode)
3315: {
3316: /* If a BLKmode arrives in registers, copy it to a stack slot. */
3317: if (GET_CODE (entry_parm) == REG)
3318: {
3319: int size_stored = CEIL_ROUND (int_size_in_bytes (TREE_TYPE (parm)),
3320: UNITS_PER_WORD);
3321:
3322: /* Note that we will be storing an integral number of words.
3323: So we have to be careful to ensure that we allocate an
3324: integral number of words. We do this below in the
3325: assign_stack_local if space was not allocated in the argument
3326: list. If it was, this will not work if PARM_BOUNDARY is not
3327: a multiple of BITS_PER_WORD. It isn't clear how to fix this
3328: if it becomes a problem. */
3329:
3330: if (stack_parm == 0)
3331: {
3332: stack_parm
3333: = assign_stack_local (GET_MODE (entry_parm), size_stored, 0);
3334: /* If this is a memory ref that contains aggregate components,
3335: mark it as such for cse and loop optimize. */
3336: MEM_IN_STRUCT_P (stack_parm) = aggregate;
3337: }
3338:
3339: else if (PARM_BOUNDARY % BITS_PER_WORD != 0)
3340: abort ();
3341:
3342: move_block_from_reg (REGNO (entry_parm),
3343: validize_mem (stack_parm),
3344: size_stored / UNITS_PER_WORD,
3345: int_size_in_bytes (TREE_TYPE (parm)));
3346: }
3347: DECL_RTL (parm) = stack_parm;
3348: }
3349: else if (! ((obey_regdecls && ! DECL_REGISTER (parm)
3350: && ! DECL_INLINE (fndecl))
3351: /* layout_decl may set this. */
3352: || TREE_ADDRESSABLE (parm)
3353: || TREE_SIDE_EFFECTS (parm)
3354: /* If -ffloat-store specified, don't put explicit
3355: float variables into registers. */
3356: || (flag_float_store
3357: && TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE))
3358: /* Always assign pseudo to structure return or item passed
3359: by invisible reference. */
3360: || passed_pointer || parm == function_result_decl)
3361: {
3362: /* Store the parm in a pseudoregister during the function, but we
3363: may need to do it in a wider mode. */
3364:
3365: register rtx parmreg;
3366: int regno;
3367:
3368: unsignedp = TREE_UNSIGNED (TREE_TYPE (parm));
3369: if (TREE_CODE (TREE_TYPE (parm)) == INTEGER_TYPE
3370: || TREE_CODE (TREE_TYPE (parm)) == ENUMERAL_TYPE
3371: || TREE_CODE (TREE_TYPE (parm)) == BOOLEAN_TYPE
3372: || TREE_CODE (TREE_TYPE (parm)) == CHAR_TYPE
3373: || TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE
3374: || TREE_CODE (TREE_TYPE (parm)) == POINTER_TYPE
3375: || TREE_CODE (TREE_TYPE (parm)) == OFFSET_TYPE)
3376: {
3377: PROMOTE_MODE (nominal_mode, unsignedp, TREE_TYPE (parm));
3378: }
3379:
3380: parmreg = gen_reg_rtx (nominal_mode);
3381: REG_USERVAR_P (parmreg) = 1;
3382:
3383: /* If this was an item that we received a pointer to, set DECL_RTL
3384: appropriately. */
3385: if (passed_pointer)
3386: {
3387: DECL_RTL (parm) = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (passed_type)), parmreg);
3388: MEM_IN_STRUCT_P (DECL_RTL (parm)) = aggregate;
3389: }
3390: else
3391: DECL_RTL (parm) = parmreg;
3392:
3393: /* Copy the value into the register. */
3394: if (GET_MODE (parmreg) != GET_MODE (entry_parm))
3395: {
3396: /* If ENTRY_PARM is a hard register, it might be in a register
3397: not valid for operating in its mode (e.g., an odd-numbered
3398: register for a DFmode). In that case, moves are the only
3399: thing valid, so we can't do a convert from there. This
3400: occurs when the calling sequence allow such misaligned
3401: usages.
3402:
3403: In addition, the conversion may involve a call, which could
3404: clobber parameters which haven't been copied to pseudo
3405: registers yet. Therefore, we must first copy the parm to
3406: a pseudo reg here, and save the conversion until after all
3407: parameters have been moved. */
3408:
3409: rtx tempreg = gen_reg_rtx (GET_MODE (entry_parm));
3410:
3411: emit_move_insn (tempreg, validize_mem (entry_parm));
3412:
3413: push_to_sequence (conversion_insns);
3414: convert_move (parmreg, tempreg, unsignedp);
3415: conversion_insns = get_insns ();
3416: end_sequence ();
3417: }
3418: else
3419: emit_move_insn (parmreg, validize_mem (entry_parm));
3420:
3421: /* If we were passed a pointer but the actual value
3422: can safely live in a register, put it in one. */
3423: if (passed_pointer && TYPE_MODE (TREE_TYPE (parm)) != BLKmode
3424: && ! ((obey_regdecls && ! DECL_REGISTER (parm)
3425: && ! DECL_INLINE (fndecl))
3426: /* layout_decl may set this. */
3427: || TREE_ADDRESSABLE (parm)
3428: || TREE_SIDE_EFFECTS (parm)
3429: /* If -ffloat-store specified, don't put explicit
3430: float variables into registers. */
3431: || (flag_float_store
3432: && TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE)))
3433: {
3434: /* We can't use nominal_mode, because it will have been set to
3435: Pmode above. We must use the actual mode of the parm. */
3436: parmreg = gen_reg_rtx (TYPE_MODE (TREE_TYPE (parm)));
3437: emit_move_insn (parmreg, DECL_RTL (parm));
3438: DECL_RTL (parm) = parmreg;
3439: /* STACK_PARM is the pointer, not the parm, and PARMREG is
3440: now the parm. */
3441: stack_parm = 0;
3442: }
3443: #ifdef FUNCTION_ARG_CALLEE_COPIES
3444: /* If we are passed an arg by reference and it is our responsibility
3445: to make a copy, do it now.
3446: PASSED_TYPE and PASSED mode now refer to the pointer, not the
3447: original argument, so we must recreate them in the call to
3448: FUNCTION_ARG_CALLEE_COPIES. */
3449: /* ??? Later add code to handle the case that if the argument isn't
3450: modified, don't do the copy. */
3451:
3452: else if (passed_pointer
3453: && FUNCTION_ARG_CALLEE_COPIES (args_so_far,
3454: TYPE_MODE (DECL_ARG_TYPE (parm)),
3455: DECL_ARG_TYPE (parm),
3456: ! last_named))
3457: {
3458: rtx copy;
3459: tree type = DECL_ARG_TYPE (parm);
3460:
3461: /* This sequence may involve a library call perhaps clobbering
3462: registers that haven't been copied to pseudos yet. */
3463:
3464: push_to_sequence (conversion_insns);
3465:
3466: if (TYPE_SIZE (type) == 0
3467: || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
3468: {
3469: /* This is a variable sized object. */
3470: /* ??? Can we use expr_size here? */
3471: rtx size_rtx = expand_expr (size_in_bytes (type), NULL_RTX,
3472: TYPE_MODE (sizetype), 0);
3473:
3474: copy = gen_rtx (MEM, BLKmode,
3475: allocate_dynamic_stack_space (size_rtx, NULL_RTX,
3476: TYPE_ALIGN (type)));
3477: }
3478: else
3479: {
3480: int size = int_size_in_bytes (type);
3481: copy = assign_stack_temp (TYPE_MODE (type), size, 1);
3482: }
3483:
3484: store_expr (parm, copy, 0);
3485: emit_move_insn (parmreg, XEXP (copy, 0));
3486: conversion_insns = get_insns ();
3487: end_sequence ();
3488: }
3489: #endif /* FUNCTION_ARG_CALLEE_COPIES */
3490:
3491: /* In any case, record the parm's desired stack location
3492: in case we later discover it must live in the stack.
3493:
3494: If it is a COMPLEX value, store the stack location for both
3495: halves. */
3496:
3497: if (GET_CODE (parmreg) == CONCAT)
3498: regno = MAX (REGNO (XEXP (parmreg, 0)), REGNO (XEXP (parmreg, 1)));
3499: else
3500: regno = REGNO (parmreg);
3501:
3502: if (regno >= nparmregs)
3503: {
3504: rtx *new;
3505: int old_nparmregs = nparmregs;
3506:
3507: nparmregs = regno + 5;
3508: new = (rtx *) oballoc (nparmregs * sizeof (rtx));
3509: bcopy (parm_reg_stack_loc, new, old_nparmregs * sizeof (rtx));
3510: bzero (new + old_nparmregs,
3511: (nparmregs - old_nparmregs) * sizeof (rtx));
3512: parm_reg_stack_loc = new;
3513: }
3514:
3515: if (GET_CODE (parmreg) == CONCAT)
3516: {
3517: enum machine_mode submode = GET_MODE (XEXP (parmreg, 0));
3518:
3519: if (stack_parm != 0)
3520: {
3521: parm_reg_stack_loc[REGNO (gen_lowpart (submode, parmreg))]
3522: = gen_lowpart (submode, stack_parm);
3523: parm_reg_stack_loc[REGNO (gen_highpart (submode, parmreg))]
3524: = gen_highpart (submode, stack_parm);
3525: }
3526: else
3527: {
3528: parm_reg_stack_loc[REGNO (gen_lowpart (submode, parmreg))]
3529: = 0;
3530: parm_reg_stack_loc[REGNO (gen_highpart (submode, parmreg))]
3531: = 0;
3532: }
3533: }
3534: else
3535: parm_reg_stack_loc[REGNO (parmreg)] = stack_parm;
3536:
3537: /* Mark the register as eliminable if we did no conversion
3538: and it was copied from memory at a fixed offset,
3539: and the arg pointer was not copied to a pseudo-reg.
3540: If the arg pointer is a pseudo reg or the offset formed
3541: an invalid address, such memory-equivalences
3542: as we make here would screw up life analysis for it. */
3543: if (nominal_mode == passed_mode
3544: && GET_CODE (entry_parm) == MEM
3545: && entry_parm == stack_parm
3546: && stack_offset.var == 0
3547: && reg_mentioned_p (virtual_incoming_args_rtx,
3548: XEXP (entry_parm, 0)))
3549: REG_NOTES (get_last_insn ())
3550: = gen_rtx (EXPR_LIST, REG_EQUIV,
3551: entry_parm, REG_NOTES (get_last_insn ()));
3552:
3553: /* For pointer data type, suggest pointer register. */
3554: if (TREE_CODE (TREE_TYPE (parm)) == POINTER_TYPE)
3555: mark_reg_pointer (parmreg);
3556: }
3557: else
3558: {
3559: /* Value must be stored in the stack slot STACK_PARM
3560: during function execution. */
3561:
3562: if (passed_mode != nominal_mode)
3563: {
3564: /* Conversion is required. */
3565: rtx tempreg = gen_reg_rtx (GET_MODE (entry_parm));
3566:
3567: emit_move_insn (tempreg, validize_mem (entry_parm));
3568:
3569: push_to_sequence (conversion_insns);
3570: entry_parm = convert_to_mode (nominal_mode, tempreg,
3571: TREE_UNSIGNED (TREE_TYPE (parm)));
3572: conversion_insns = get_insns ();
3573: end_sequence ();
3574: }
3575:
3576: if (entry_parm != stack_parm)
3577: {
3578: if (stack_parm == 0)
3579: {
3580: stack_parm
3581: = assign_stack_local (GET_MODE (entry_parm),
3582: GET_MODE_SIZE (GET_MODE (entry_parm)), 0);
3583: /* If this is a memory ref that contains aggregate components,
3584: mark it as such for cse and loop optimize. */
3585: MEM_IN_STRUCT_P (stack_parm) = aggregate;
3586: }
3587:
3588: if (passed_mode != nominal_mode)
3589: {
3590: push_to_sequence (conversion_insns);
3591: emit_move_insn (validize_mem (stack_parm),
3592: validize_mem (entry_parm));
3593: conversion_insns = get_insns ();
3594: end_sequence ();
3595: }
3596: else
3597: emit_move_insn (validize_mem (stack_parm),
3598: validize_mem (entry_parm));
3599: }
3600:
3601: DECL_RTL (parm) = stack_parm;
3602: }
3603:
3604: /* If this "parameter" was the place where we are receiving the
3605: function's incoming structure pointer, set up the result. */
3606: if (parm == function_result_decl)
3607: DECL_RTL (DECL_RESULT (fndecl))
3608: = gen_rtx (MEM, DECL_MODE (DECL_RESULT (fndecl)), DECL_RTL (parm));
3609:
3610: if (TREE_THIS_VOLATILE (parm))
3611: MEM_VOLATILE_P (DECL_RTL (parm)) = 1;
3612: if (TREE_READONLY (parm))
3613: RTX_UNCHANGING_P (DECL_RTL (parm)) = 1;
3614: }
3615:
3616: /* Output all parameter conversion instructions (possibly including calls)
3617: now that all parameters have been copied out of hard registers. */
3618: emit_insns (conversion_insns);
3619:
3620: max_parm_reg = max_reg_num ();
3621: last_parm_insn = get_last_insn ();
3622:
3623: current_function_args_size = stack_args_size.constant;
3624:
3625: /* Adjust function incoming argument size for alignment and
3626: minimum length. */
3627:
3628: #ifdef REG_PARM_STACK_SPACE
3629: #ifndef MAYBE_REG_PARM_STACK_SPACE
3630: current_function_args_size = MAX (current_function_args_size,
3631: REG_PARM_STACK_SPACE (fndecl));
3632: #endif
3633: #endif
3634:
3635: #ifdef STACK_BOUNDARY
3636: #define STACK_BYTES (STACK_BOUNDARY / BITS_PER_UNIT)
3637:
3638: current_function_args_size
3639: = ((current_function_args_size + STACK_BYTES - 1)
3640: / STACK_BYTES) * STACK_BYTES;
3641: #endif
3642:
3643: #ifdef ARGS_GROW_DOWNWARD
3644: current_function_arg_offset_rtx
3645: = (stack_args_size.var == 0 ? GEN_INT (-stack_args_size.constant)
3646: : expand_expr (size_binop (MINUS_EXPR, stack_args_size.var,
3647: size_int (-stack_args_size.constant)),
3648: NULL_RTX, VOIDmode, 0));
3649: #else
3650: current_function_arg_offset_rtx = ARGS_SIZE_RTX (stack_args_size);
3651: #endif
3652:
3653: /* See how many bytes, if any, of its args a function should try to pop
3654: on return. */
3655:
3656: current_function_pops_args = RETURN_POPS_ARGS (TREE_TYPE (fndecl),
3657: current_function_args_size);
3658:
3659: /* For stdarg.h function, save info about regs and stack space
3660: used by the named args. */
3661:
3662: if (stdarg)
3663: current_function_args_info = args_so_far;
3664:
3665: /* Set the rtx used for the function return value. Put this in its
3666: own variable so any optimizers that need this information don't have
3667: to include tree.h. Do this here so it gets done when an inlined
3668: function gets output. */
3669:
3670: current_function_return_rtx = DECL_RTL (DECL_RESULT (fndecl));
3671: }
3672:
3673: /* Indicate whether REGNO is an incoming argument to the current function
3674: that was promoted to a wider mode. If so, return the RTX for the
3675: register (to get its mode). PMODE and PUNSIGNEDP are set to the mode
3676: that REGNO is promoted from and whether the promotion was signed or
3677: unsigned. */
3678:
3679: #ifdef PROMOTE_FUNCTION_ARGS
3680:
3681: rtx
3682: promoted_input_arg (regno, pmode, punsignedp)
3683: int regno;
3684: enum machine_mode *pmode;
3685: int *punsignedp;
3686: {
3687: tree arg;
3688:
3689: for (arg = DECL_ARGUMENTS (current_function_decl); arg;
3690: arg = TREE_CHAIN (arg))
3691: if (GET_CODE (DECL_INCOMING_RTL (arg)) == REG
3692: && REGNO (DECL_INCOMING_RTL (arg)) == regno
3693: && (TREE_CODE (TREE_TYPE (arg)) == INTEGER_TYPE
3694: || TREE_CODE (TREE_TYPE (arg)) == ENUMERAL_TYPE
3695: || TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE
3696: || TREE_CODE (TREE_TYPE (arg)) == CHAR_TYPE
3697: || TREE_CODE (TREE_TYPE (arg)) == REAL_TYPE
3698: || TREE_CODE (TREE_TYPE (arg)) == POINTER_TYPE
3699: || TREE_CODE (TREE_TYPE (arg)) == OFFSET_TYPE))
3700: {
3701: enum machine_mode mode = TYPE_MODE (TREE_TYPE (arg));
3702: int unsignedp = TREE_UNSIGNED (TREE_TYPE (arg));
3703:
3704: PROMOTE_MODE (mode, unsignedp, TREE_TYPE (arg));
3705: if (mode == GET_MODE (DECL_INCOMING_RTL (arg))
3706: && mode != DECL_MODE (arg))
3707: {
3708: *pmode = DECL_MODE (arg);
3709: *punsignedp = unsignedp;
3710: return DECL_INCOMING_RTL (arg);
3711: }
3712: }
3713:
3714: return 0;
3715: }
3716:
3717: #endif
3718:
3719: /* Compute the size and offset from the start of the stacked arguments for a
3720: parm passed in mode PASSED_MODE and with type TYPE.
3721:
3722: INITIAL_OFFSET_PTR points to the current offset into the stacked
3723: arguments.
3724:
3725: The starting offset and size for this parm are returned in *OFFSET_PTR
3726: and *ARG_SIZE_PTR, respectively.
3727:
3728: IN_REGS is non-zero if the argument will be passed in registers. It will
3729: never be set if REG_PARM_STACK_SPACE is not defined.
3730:
3731: FNDECL is the function in which the argument was defined.
3732:
3733: There are two types of rounding that are done. The first, controlled by
3734: FUNCTION_ARG_BOUNDARY, forces the offset from the start of the argument
3735: list to be aligned to the specific boundary (in bits). This rounding
3736: affects the initial and starting offsets, but not the argument size.
3737:
3738: The second, controlled by FUNCTION_ARG_PADDING and PARM_BOUNDARY,
3739: optionally rounds the size of the parm to PARM_BOUNDARY. The
3740: initial offset is not affected by this rounding, while the size always
3741: is and the starting offset may be. */
3742:
3743: /* offset_ptr will be negative for ARGS_GROW_DOWNWARD case;
3744: initial_offset_ptr is positive because locate_and_pad_parm's
3745: callers pass in the total size of args so far as
3746: initial_offset_ptr. arg_size_ptr is always positive.*/
3747:
3748: static void pad_to_arg_alignment (), pad_below ();
3749:
3750: void
3751: locate_and_pad_parm (passed_mode, type, in_regs, fndecl,
3752: initial_offset_ptr, offset_ptr, arg_size_ptr)
3753: enum machine_mode passed_mode;
3754: tree type;
3755: int in_regs;
3756: tree fndecl;
3757: struct args_size *initial_offset_ptr;
3758: struct args_size *offset_ptr;
3759: struct args_size *arg_size_ptr;
3760: {
3761: tree sizetree
3762: = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode));
3763: enum direction where_pad = FUNCTION_ARG_PADDING (passed_mode, type);
3764: int boundary = FUNCTION_ARG_BOUNDARY (passed_mode, type);
3765: int boundary_in_bytes = boundary / BITS_PER_UNIT;
3766: int reg_parm_stack_space = 0;
3767:
3768: #ifdef REG_PARM_STACK_SPACE
3769: /* If we have found a stack parm before we reach the end of the
3770: area reserved for registers, skip that area. */
3771: if (! in_regs)
3772: {
3773: #ifdef MAYBE_REG_PARM_STACK_SPACE
3774: reg_parm_stack_space = MAYBE_REG_PARM_STACK_SPACE;
3775: #else
3776: reg_parm_stack_space = REG_PARM_STACK_SPACE (fndecl);
3777: #endif
3778: if (reg_parm_stack_space > 0)
3779: {
3780: if (initial_offset_ptr->var)
3781: {
3782: initial_offset_ptr->var
3783: = size_binop (MAX_EXPR, ARGS_SIZE_TREE (*initial_offset_ptr),
3784: size_int (reg_parm_stack_space));
3785: initial_offset_ptr->constant = 0;
3786: }
3787: else if (initial_offset_ptr->constant < reg_parm_stack_space)
3788: initial_offset_ptr->constant = reg_parm_stack_space;
3789: }
3790: }
3791: #endif /* REG_PARM_STACK_SPACE */
3792:
3793: arg_size_ptr->var = 0;
3794: arg_size_ptr->constant = 0;
3795:
3796: #ifdef ARGS_GROW_DOWNWARD
3797: if (initial_offset_ptr->var)
3798: {
3799: offset_ptr->constant = 0;
3800: offset_ptr->var = size_binop (MINUS_EXPR, integer_zero_node,
3801: initial_offset_ptr->var);
3802: }
3803: else
3804: {
3805: offset_ptr->constant = - initial_offset_ptr->constant;
3806: offset_ptr->var = 0;
3807: }
3808: if (where_pad == upward
3809: && (TREE_CODE (sizetree) != INTEGER_CST
3810: || ((TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY)))
3811: sizetree = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
3812: SUB_PARM_SIZE (*offset_ptr, sizetree);
3813: if (where_pad != downward)
3814: pad_to_arg_alignment (offset_ptr, boundary);
3815: if (initial_offset_ptr->var)
3816: {
3817: arg_size_ptr->var = size_binop (MINUS_EXPR,
3818: size_binop (MINUS_EXPR,
3819: integer_zero_node,
3820: initial_offset_ptr->var),
3821: offset_ptr->var);
3822: }
3823: else
3824: {
3825: arg_size_ptr->constant = (- initial_offset_ptr->constant -
3826: offset_ptr->constant);
3827: }
3828: /* ADD_PARM_SIZE (*arg_size_ptr, sizetree); */
3829: if (where_pad == downward)
3830: pad_below (arg_size_ptr, passed_mode, sizetree);
3831: #else /* !ARGS_GROW_DOWNWARD */
3832: pad_to_arg_alignment (initial_offset_ptr, boundary);
3833: *offset_ptr = *initial_offset_ptr;
3834:
3835: #ifdef PUSH_ROUNDING
3836: if (passed_mode != BLKmode)
3837: sizetree = size_int (PUSH_ROUNDING (TREE_INT_CST_LOW (sizetree)));
3838: #endif
3839:
3840: if (where_pad != none
3841: && (TREE_CODE (sizetree) != INTEGER_CST
3842: || ((TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY)))
3843: sizetree = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
3844:
3845: /* This must be done after rounding sizetree, so that it will subtract
3846: the same value that we explicitly add below. */
3847: if (where_pad == downward)
3848: pad_below (offset_ptr, passed_mode, sizetree);
3849: ADD_PARM_SIZE (*arg_size_ptr, sizetree);
3850: #endif /* ARGS_GROW_DOWNWARD */
3851: }
3852:
3853: /* Round the stack offset in *OFFSET_PTR up to a multiple of BOUNDARY.
3854: BOUNDARY is measured in bits, but must be a multiple of a storage unit. */
3855:
3856: static void
3857: pad_to_arg_alignment (offset_ptr, boundary)
3858: struct args_size *offset_ptr;
3859: int boundary;
3860: {
3861: int boundary_in_bytes = boundary / BITS_PER_UNIT;
3862:
3863: if (boundary > BITS_PER_UNIT)
3864: {
3865: if (offset_ptr->var)
3866: {
3867: offset_ptr->var =
3868: #ifdef ARGS_GROW_DOWNWARD
3869: round_down
3870: #else
3871: round_up
3872: #endif
3873: (ARGS_SIZE_TREE (*offset_ptr),
3874: boundary / BITS_PER_UNIT);
3875: offset_ptr->constant = 0; /*?*/
3876: }
3877: else
3878: offset_ptr->constant =
3879: #ifdef ARGS_GROW_DOWNWARD
3880: FLOOR_ROUND (offset_ptr->constant, boundary_in_bytes);
3881: #else
3882: CEIL_ROUND (offset_ptr->constant, boundary_in_bytes);
3883: #endif
3884: }
3885: }
3886:
3887: static void
3888: pad_below (offset_ptr, passed_mode, sizetree)
3889: struct args_size *offset_ptr;
3890: enum machine_mode passed_mode;
3891: tree sizetree;
3892: {
3893: if (passed_mode != BLKmode)
3894: {
3895: if (GET_MODE_BITSIZE (passed_mode) % PARM_BOUNDARY)
3896: offset_ptr->constant
3897: += (((GET_MODE_BITSIZE (passed_mode) + PARM_BOUNDARY - 1)
3898: / PARM_BOUNDARY * PARM_BOUNDARY / BITS_PER_UNIT)
3899: - GET_MODE_SIZE (passed_mode));
3900: }
3901: else
3902: {
3903: if (TREE_CODE (sizetree) != INTEGER_CST
3904: || (TREE_INT_CST_LOW (sizetree) * BITS_PER_UNIT) % PARM_BOUNDARY)
3905: {
3906: /* Round the size up to multiple of PARM_BOUNDARY bits. */
3907: tree s2 = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
3908: /* Add it in. */
3909: ADD_PARM_SIZE (*offset_ptr, s2);
3910: SUB_PARM_SIZE (*offset_ptr, sizetree);
3911: }
3912: }
3913: }
3914:
3915: static tree
3916: round_down (value, divisor)
3917: tree value;
3918: int divisor;
3919: {
3920: return size_binop (MULT_EXPR,
3921: size_binop (FLOOR_DIV_EXPR, value, size_int (divisor)),
3922: size_int (divisor));
3923: }
3924:
3925: /* Walk the tree of blocks describing the binding levels within a function
3926: and warn about uninitialized variables.
3927: This is done after calling flow_analysis and before global_alloc
3928: clobbers the pseudo-regs to hard regs. */
3929:
3930: void
3931: uninitialized_vars_warning (block)
3932: tree block;
3933: {
3934: register tree decl, sub;
3935: for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
3936: {
3937: if (TREE_CODE (decl) == VAR_DECL
3938: /* These warnings are unreliable for and aggregates
3939: because assigning the fields one by one can fail to convince
3940: flow.c that the entire aggregate was initialized.
3941: Unions are troublesome because members may be shorter. */
3942: && TREE_CODE (TREE_TYPE (decl)) != RECORD_TYPE
3943: && TREE_CODE (TREE_TYPE (decl)) != UNION_TYPE
3944: && TREE_CODE (TREE_TYPE (decl)) != QUAL_UNION_TYPE
3945: && TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE
3946: && DECL_RTL (decl) != 0
3947: && GET_CODE (DECL_RTL (decl)) == REG
3948: && regno_uninitialized (REGNO (DECL_RTL (decl))))
3949: warning_with_decl (decl,
3950: "`%s' may be used uninitialized in this function");
3951: if (TREE_CODE (decl) == VAR_DECL
3952: && DECL_RTL (decl) != 0
3953: && GET_CODE (DECL_RTL (decl)) == REG
3954: && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
3955: warning_with_decl (decl,
3956: "variable `%s' may be clobbered by `longjmp' or `vfork'");
3957: }
3958: for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub))
3959: uninitialized_vars_warning (sub);
3960: }
3961:
3962: /* Do the appropriate part of uninitialized_vars_warning
3963: but for arguments instead of local variables. */
3964:
3965: void
3966: setjmp_args_warning (block)
3967: tree block;
3968: {
3969: register tree decl;
3970: for (decl = DECL_ARGUMENTS (current_function_decl);
3971: decl; decl = TREE_CHAIN (decl))
3972: if (DECL_RTL (decl) != 0
3973: && GET_CODE (DECL_RTL (decl)) == REG
3974: && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
3975: warning_with_decl (decl, "argument `%s' may be clobbered by `longjmp' or `vfork'");
3976: }
3977:
3978: /* If this function call setjmp, put all vars into the stack
3979: unless they were declared `register'. */
3980:
3981: void
3982: setjmp_protect (block)
3983: tree block;
3984: {
3985: register tree decl, sub;
3986: for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl))
3987: if ((TREE_CODE (decl) == VAR_DECL
3988: || TREE_CODE (decl) == PARM_DECL)
3989: && DECL_RTL (decl) != 0
3990: && GET_CODE (DECL_RTL (decl)) == REG
3991: /* If this variable came from an inline function, it must be
3992: that it's life doesn't overlap the setjmp. If there was a
3993: setjmp in the function, it would already be in memory. We
3994: must exclude such variable because their DECL_RTL might be
3995: set to strange things such as virtual_stack_vars_rtx. */
3996: && ! DECL_FROM_INLINE (decl)
3997: && (
3998: #ifdef NON_SAVING_SETJMP
3999: /* If longjmp doesn't restore the registers,
4000: don't put anything in them. */
4001: NON_SAVING_SETJMP
4002: ||
4003: #endif
4004: ! DECL_REGISTER (decl)))
4005: put_var_into_stack (decl);
4006: for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub))
4007: setjmp_protect (sub);
4008: }
4009:
4010: /* Like the previous function, but for args instead of local variables. */
4011:
4012: void
4013: setjmp_protect_args ()
4014: {
4015: register tree decl, sub;
4016: for (decl = DECL_ARGUMENTS (current_function_decl);
4017: decl; decl = TREE_CHAIN (decl))
4018: if ((TREE_CODE (decl) == VAR_DECL
4019: || TREE_CODE (decl) == PARM_DECL)
4020: && DECL_RTL (decl) != 0
4021: && GET_CODE (DECL_RTL (decl)) == REG
4022: && (
4023: /* If longjmp doesn't restore the registers,
4024: don't put anything in them. */
4025: #ifdef NON_SAVING_SETJMP
4026: NON_SAVING_SETJMP
4027: ||
4028: #endif
4029: ! DECL_REGISTER (decl)))
4030: put_var_into_stack (decl);
4031: }
4032:
4033: /* Return the context-pointer register corresponding to DECL,
4034: or 0 if it does not need one. */
4035:
4036: rtx
4037: lookup_static_chain (decl)
4038: tree decl;
4039: {
4040: tree context = decl_function_context (decl);
4041: tree link;
4042:
4043: if (context == 0)
4044: return 0;
4045:
4046: /* We treat inline_function_decl as an alias for the current function
4047: because that is the inline function whose vars, types, etc.
4048: are being merged into the current function.
4049: See expand_inline_function. */
4050: if (context == current_function_decl || context == inline_function_decl)
4051: return virtual_stack_vars_rtx;
4052:
4053: for (link = context_display; link; link = TREE_CHAIN (link))
4054: if (TREE_PURPOSE (link) == context)
4055: return RTL_EXPR_RTL (TREE_VALUE (link));
4056:
4057: abort ();
4058: }
4059:
4060: /* Convert a stack slot address ADDR for variable VAR
4061: (from a containing function)
4062: into an address valid in this function (using a static chain). */
4063:
4064: rtx
4065: fix_lexical_addr (addr, var)
4066: rtx addr;
4067: tree var;
4068: {
4069: rtx basereg;
4070: int displacement;
4071: tree context = decl_function_context (var);
4072: struct function *fp;
4073: rtx base = 0;
4074:
4075: /* If this is the present function, we need not do anything. */
4076: if (context == current_function_decl || context == inline_function_decl)
4077: return addr;
4078:
4079: for (fp = outer_function_chain; fp; fp = fp->next)
4080: if (fp->decl == context)
4081: break;
4082:
4083: if (fp == 0)
4084: abort ();
4085:
4086: /* Decode given address as base reg plus displacement. */
4087: if (GET_CODE (addr) == REG)
4088: basereg = addr, displacement = 0;
4089: else if (GET_CODE (addr) == PLUS && GET_CODE (XEXP (addr, 1)) == CONST_INT)
4090: basereg = XEXP (addr, 0), displacement = INTVAL (XEXP (addr, 1));
4091: else
4092: abort ();
4093:
4094: /* We accept vars reached via the containing function's
4095: incoming arg pointer and via its stack variables pointer. */
4096: if (basereg == fp->internal_arg_pointer)
4097: {
4098: /* If reached via arg pointer, get the arg pointer value
4099: out of that function's stack frame.
4100:
4101: There are two cases: If a separate ap is needed, allocate a
4102: slot in the outer function for it and dereference it that way.
4103: This is correct even if the real ap is actually a pseudo.
4104: Otherwise, just adjust the offset from the frame pointer to
4105: compensate. */
4106:
4107: #ifdef NEED_SEPARATE_AP
4108: rtx addr;
4109:
4110: if (fp->arg_pointer_save_area == 0)
4111: fp->arg_pointer_save_area
4112: = assign_outer_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0, fp);
4113:
4114: addr = fix_lexical_addr (XEXP (fp->arg_pointer_save_area, 0), var);
4115: addr = memory_address (Pmode, addr);
4116:
4117: base = copy_to_reg (gen_rtx (MEM, Pmode, addr));
4118: #else
4119: displacement += (FIRST_PARM_OFFSET (context) - STARTING_FRAME_OFFSET);
4120: base = lookup_static_chain (var);
4121: #endif
4122: }
4123:
4124: else if (basereg == virtual_stack_vars_rtx)
4125: {
4126: /* This is the same code as lookup_static_chain, duplicated here to
4127: avoid an extra call to decl_function_context. */
4128: tree link;
4129:
4130: for (link = context_display; link; link = TREE_CHAIN (link))
4131: if (TREE_PURPOSE (link) == context)
4132: {
4133: base = RTL_EXPR_RTL (TREE_VALUE (link));
4134: break;
4135: }
4136: }
4137:
4138: if (base == 0)
4139: abort ();
4140:
4141: /* Use same offset, relative to appropriate static chain or argument
4142: pointer. */
4143: return plus_constant (base, displacement);
4144: }
4145:
4146: /* Return the address of the trampoline for entering nested fn FUNCTION.
4147: If necessary, allocate a trampoline (in the stack frame)
4148: and emit rtl to initialize its contents (at entry to this function). */
4149:
4150: rtx
4151: trampoline_address (function)
4152: tree function;
4153: {
4154: tree link;
4155: tree rtlexp;
4156: rtx tramp;
4157: struct function *fp;
4158: tree fn_context;
4159:
4160: /* Find an existing trampoline and return it. */
4161: for (link = trampoline_list; link; link = TREE_CHAIN (link))
4162: if (TREE_PURPOSE (link) == function)
4163: return XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0);
4164: for (fp = outer_function_chain; fp; fp = fp->next)
4165: for (link = fp->trampoline_list; link; link = TREE_CHAIN (link))
4166: if (TREE_PURPOSE (link) == function)
4167: {
4168: tramp = fix_lexical_addr (XEXP (RTL_EXPR_RTL (TREE_VALUE (link)), 0),
4169: function);
4170: return round_trampoline_addr (tramp);
4171: }
4172:
4173: /* None exists; we must make one. */
4174:
4175: /* Find the `struct function' for the function containing FUNCTION. */
4176: fp = 0;
4177: fn_context = decl_function_context (function);
4178: if (fn_context != current_function_decl)
4179: for (fp = outer_function_chain; fp; fp = fp->next)
4180: if (fp->decl == fn_context)
4181: break;
4182:
4183: /* Allocate run-time space for this trampoline
4184: (usually in the defining function's stack frame). */
4185: #ifdef ALLOCATE_TRAMPOLINE
4186: tramp = ALLOCATE_TRAMPOLINE (fp);
4187: #else
4188: /* If rounding needed, allocate extra space
4189: to ensure we have TRAMPOLINE_SIZE bytes left after rounding up. */
4190: #ifdef TRAMPOLINE_ALIGNMENT
4191: #define TRAMPOLINE_REAL_SIZE (TRAMPOLINE_SIZE + TRAMPOLINE_ALIGNMENT - 1)
4192: #else
4193: #define TRAMPOLINE_REAL_SIZE (TRAMPOLINE_SIZE)
4194: #endif
4195: if (fp != 0)
4196: tramp = assign_outer_stack_local (BLKmode, TRAMPOLINE_REAL_SIZE, 0, fp);
4197: else
4198: tramp = assign_stack_local (BLKmode, TRAMPOLINE_REAL_SIZE, 0);
4199: #endif
4200:
4201: /* Record the trampoline for reuse and note it for later initialization
4202: by expand_function_end. */
4203: if (fp != 0)
4204: {
4205: push_obstacks (fp->function_maybepermanent_obstack,
4206: fp->function_maybepermanent_obstack);
4207: rtlexp = make_node (RTL_EXPR);
4208: RTL_EXPR_RTL (rtlexp) = tramp;
4209: fp->trampoline_list = tree_cons (function, rtlexp, fp->trampoline_list);
4210: pop_obstacks ();
4211: }
4212: else
4213: {
4214: /* Make the RTL_EXPR node temporary, not momentary, so that the
4215: trampoline_list doesn't become garbage. */
4216: int momentary = suspend_momentary ();
4217: rtlexp = make_node (RTL_EXPR);
4218: resume_momentary (momentary);
4219:
4220: RTL_EXPR_RTL (rtlexp) = tramp;
4221: trampoline_list = tree_cons (function, rtlexp, trampoline_list);
4222: }
4223:
4224: tramp = fix_lexical_addr (XEXP (tramp, 0), function);
4225: return round_trampoline_addr (tramp);
4226: }
4227:
4228: /* Given a trampoline address,
4229: round it to multiple of TRAMPOLINE_ALIGNMENT. */
4230:
4231: static rtx
4232: round_trampoline_addr (tramp)
4233: rtx tramp;
4234: {
4235: #ifdef TRAMPOLINE_ALIGNMENT
4236: /* Round address up to desired boundary. */
4237: rtx temp = gen_reg_rtx (Pmode);
4238: temp = expand_binop (Pmode, add_optab, tramp,
4239: GEN_INT (TRAMPOLINE_ALIGNMENT - 1),
4240: temp, 0, OPTAB_LIB_WIDEN);
4241: tramp = expand_binop (Pmode, and_optab, temp,
4242: GEN_INT (- TRAMPOLINE_ALIGNMENT),
4243: temp, 0, OPTAB_LIB_WIDEN);
4244: #endif
4245: return tramp;
4246: }
4247:
4248: /* The functions identify_blocks and reorder_blocks provide a way to
4249: reorder the tree of BLOCK nodes, for optimizers that reshuffle or
4250: duplicate portions of the RTL code. Call identify_blocks before
4251: changing the RTL, and call reorder_blocks after. */
4252:
4253: static int all_blocks ();
4254: static tree blocks_nreverse ();
4255:
4256: /* Put all this function's BLOCK nodes into a vector, and return it.
4257: Also store in each NOTE for the beginning or end of a block
4258: the index of that block in the vector.
4259: The arguments are TOP_BLOCK, the top-level block of the function,
4260: and INSNS, the insn chain of the function. */
4261:
4262: tree *
4263: identify_blocks (top_block, insns)
4264: tree top_block;
4265: rtx insns;
4266: {
4267: int n_blocks;
4268: tree *block_vector;
4269: int *block_stack;
4270: int depth = 0;
4271: int next_block_number = 0;
4272: int current_block_number = 0;
4273: rtx insn;
4274:
4275: if (top_block == 0)
4276: return 0;
4277:
4278: n_blocks = all_blocks (top_block, 0);
4279: block_vector = (tree *) xmalloc (n_blocks * sizeof (tree));
4280: block_stack = (int *) alloca (n_blocks * sizeof (int));
4281:
4282: all_blocks (top_block, block_vector);
4283:
4284: for (insn = insns; insn; insn = NEXT_INSN (insn))
4285: if (GET_CODE (insn) == NOTE)
4286: {
4287: if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
4288: {
4289: block_stack[depth++] = current_block_number;
4290: current_block_number = next_block_number;
4291: NOTE_BLOCK_NUMBER (insn) = next_block_number++;
4292: }
4293: if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
4294: {
4295: current_block_number = block_stack[--depth];
4296: NOTE_BLOCK_NUMBER (insn) = current_block_number;
4297: }
4298: }
4299:
4300: return block_vector;
4301: }
4302:
4303: /* Given BLOCK_VECTOR which was returned by identify_blocks,
4304: and a revised instruction chain, rebuild the tree structure
4305: of BLOCK nodes to correspond to the new order of RTL.
4306: The new block tree is inserted below TOP_BLOCK.
4307: Returns the current top-level block. */
4308:
4309: tree
4310: reorder_blocks (block_vector, top_block, insns)
4311: tree *block_vector;
4312: tree top_block;
4313: rtx insns;
4314: {
4315: tree current_block = top_block;
4316: rtx insn;
4317:
4318: if (block_vector == 0)
4319: return top_block;
4320:
4321: /* Prune the old tree away, so that it doesn't get in the way. */
4322: BLOCK_SUBBLOCKS (current_block) = 0;
4323:
4324: for (insn = insns; insn; insn = NEXT_INSN (insn))
4325: if (GET_CODE (insn) == NOTE)
4326: {
4327: if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG)
4328: {
4329: tree block = block_vector[NOTE_BLOCK_NUMBER (insn)];
4330: /* If we have seen this block before, copy it. */
4331: if (TREE_ASM_WRITTEN (block))
4332: block = copy_node (block);
4333: BLOCK_SUBBLOCKS (block) = 0;
4334: TREE_ASM_WRITTEN (block) = 1;
4335: BLOCK_SUPERCONTEXT (block) = current_block;
4336: BLOCK_CHAIN (block) = BLOCK_SUBBLOCKS (current_block);
4337: BLOCK_SUBBLOCKS (current_block) = block;
4338: current_block = block;
4339: NOTE_SOURCE_FILE (insn) = 0;
4340: }
4341: if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END)
4342: {
4343: BLOCK_SUBBLOCKS (current_block)
4344: = blocks_nreverse (BLOCK_SUBBLOCKS (current_block));
4345: current_block = BLOCK_SUPERCONTEXT (current_block);
4346: NOTE_SOURCE_FILE (insn) = 0;
4347: }
4348: }
4349:
4350: return current_block;
4351: }
4352:
4353: /* Reverse the order of elements in the chain T of blocks,
4354: and return the new head of the chain (old last element). */
4355:
4356: static tree
4357: blocks_nreverse (t)
4358: tree t;
4359: {
4360: register tree prev = 0, decl, next;
4361: for (decl = t; decl; decl = next)
4362: {
4363: next = BLOCK_CHAIN (decl);
4364: BLOCK_CHAIN (decl) = prev;
4365: prev = decl;
4366: }
4367: return prev;
4368: }
4369:
4370: /* Count the subblocks of BLOCK, and list them all into the vector VECTOR.
4371: Also clear TREE_ASM_WRITTEN in all blocks. */
4372:
4373: static int
4374: all_blocks (block, vector)
4375: tree block;
4376: tree *vector;
4377: {
4378: int n_blocks = 1;
4379: tree subblocks;
4380:
4381: TREE_ASM_WRITTEN (block) = 0;
4382: /* Record this block. */
4383: if (vector)
4384: vector[0] = block;
4385:
4386: /* Record the subblocks, and their subblocks. */
4387: for (subblocks = BLOCK_SUBBLOCKS (block);
4388: subblocks; subblocks = BLOCK_CHAIN (subblocks))
4389: n_blocks += all_blocks (subblocks, vector ? vector + n_blocks : 0);
4390:
4391: return n_blocks;
4392: }
4393:
4394: /* Build bytecode call descriptor for function SUBR. */
4395: rtx
4396: bc_build_calldesc (subr)
4397: tree subr;
4398: {
4399: tree calldesc = 0, arg;
4400: int nargs = 0;
4401:
4402: /* Build the argument description vector in reverse order. */
4403: DECL_ARGUMENTS (subr) = nreverse (DECL_ARGUMENTS (subr));
4404: nargs = 0;
4405:
4406: for (arg = DECL_ARGUMENTS (subr); arg; arg = TREE_CHAIN (arg))
4407: {
4408: ++nargs;
4409:
4410: calldesc = tree_cons ((tree) 0, size_in_bytes (TREE_TYPE (arg)), calldesc);
4411: calldesc = tree_cons ((tree) 0, bc_runtime_type_code (TREE_TYPE (arg)), calldesc);
4412: }
4413:
4414: DECL_ARGUMENTS (subr) = nreverse (DECL_ARGUMENTS (subr));
4415:
4416: /* Prepend the function's return type. */
4417: calldesc = tree_cons ((tree) 0,
4418: size_in_bytes (TREE_TYPE (TREE_TYPE (subr))),
4419: calldesc);
4420:
4421: calldesc = tree_cons ((tree) 0,
4422: bc_runtime_type_code (TREE_TYPE (TREE_TYPE (subr))),
4423: calldesc);
4424:
4425: /* Prepend the arg count. */
4426: calldesc = tree_cons ((tree) 0, build_int_2 (nargs, 0), calldesc);
4427:
4428: /* Output the call description vector and get its address. */
4429: calldesc = build_nt (CONSTRUCTOR, (tree) 0, calldesc);
4430: TREE_TYPE (calldesc) = build_array_type (integer_type_node,
4431: build_index_type (build_int_2 (nargs * 2, 0)));
4432:
4433: return output_constant_def (calldesc);
4434: }
4435:
4436:
4437: /* Generate RTL for the start of the function SUBR (a FUNCTION_DECL tree node)
4438: and initialize static variables for generating RTL for the statements
4439: of the function. */
4440:
4441: void
4442: init_function_start (subr, filename, line)
4443: tree subr;
4444: char *filename;
4445: int line;
4446: {
4447: char *junk;
4448:
4449: if (output_bytecode)
4450: {
4451: this_function_decl = subr;
4452: this_function_calldesc = bc_build_calldesc (subr);
4453: local_vars_size = 0;
4454: stack_depth = 0;
4455: max_stack_depth = 0;
4456: stmt_expr_depth = 0;
4457: return;
4458: }
4459:
4460: init_stmt_for_function ();
4461:
4462: cse_not_expected = ! optimize;
4463:
4464: /* Caller save not needed yet. */
4465: caller_save_needed = 0;
4466:
4467: /* No stack slots have been made yet. */
4468: stack_slot_list = 0;
4469:
4470: /* There is no stack slot for handling nonlocal gotos. */
4471: nonlocal_goto_handler_slot = 0;
4472: nonlocal_goto_stack_level = 0;
4473:
4474: /* No labels have been declared for nonlocal use. */
4475: nonlocal_labels = 0;
4476:
4477: /* No function calls so far in this function. */
4478: function_call_count = 0;
4479:
4480: /* No parm regs have been allocated.
4481: (This is important for output_inline_function.) */
4482: max_parm_reg = LAST_VIRTUAL_REGISTER + 1;
4483:
4484: /* Initialize the RTL mechanism. */
4485: init_emit ();
4486:
4487: /* Initialize the queue of pending postincrement and postdecrements,
4488: and some other info in expr.c. */
4489: init_expr ();
4490:
4491: /* We haven't done register allocation yet. */
4492: reg_renumber = 0;
4493:
4494: init_const_rtx_hash_table ();
4495:
4496: current_function_name = (*decl_printable_name) (subr, &junk);
4497:
4498: /* Nonzero if this is a nested function that uses a static chain. */
4499:
4500: current_function_needs_context
4501: = (decl_function_context (current_function_decl) != 0);
4502:
4503: /* Set if a call to setjmp is seen. */
4504: current_function_calls_setjmp = 0;
4505:
4506: /* Set if a call to longjmp is seen. */
4507: current_function_calls_longjmp = 0;
4508:
4509: current_function_calls_alloca = 0;
4510: current_function_has_nonlocal_label = 0;
4511: current_function_has_nonlocal_goto = 0;
4512: current_function_contains_functions = 0;
4513:
4514: current_function_returns_pcc_struct = 0;
4515: current_function_returns_struct = 0;
4516: current_function_epilogue_delay_list = 0;
4517: current_function_uses_const_pool = 0;
4518: current_function_uses_pic_offset_table = 0;
4519:
4520: /* We have not yet needed to make a label to jump to for tail-recursion. */
4521: tail_recursion_label = 0;
4522:
4523: /* We haven't had a need to make a save area for ap yet. */
4524:
4525: arg_pointer_save_area = 0;
4526:
4527: /* No stack slots allocated yet. */
4528: frame_offset = 0;
4529:
4530: /* No SAVE_EXPRs in this function yet. */
4531: save_expr_regs = 0;
4532:
4533: /* No RTL_EXPRs in this function yet. */
4534: rtl_expr_chain = 0;
4535:
4536: /* We have not allocated any temporaries yet. */
4537: temp_slots = 0;
4538: temp_slot_level = 0;
4539:
4540: /* Within function body, compute a type's size as soon it is laid out. */
4541: immediate_size_expand++;
4542:
4543: /* We haven't made any trampolines for this function yet. */
4544: trampoline_list = 0;
4545:
4546: init_pending_stack_adjust ();
4547: inhibit_defer_pop = 0;
4548:
4549: current_function_outgoing_args_size = 0;
4550:
4551: /* Initialize the insn lengths. */
4552: init_insn_lengths ();
4553:
4554: /* Prevent ever trying to delete the first instruction of a function.
4555: Also tell final how to output a linenum before the function prologue. */
4556: emit_line_note (filename, line);
4557:
4558: /* Make sure first insn is a note even if we don't want linenums.
4559: This makes sure the first insn will never be deleted.
4560: Also, final expects a note to appear there. */
4561: emit_note (NULL_PTR, NOTE_INSN_DELETED);
4562:
4563: /* Set flags used by final.c. */
4564: if (aggregate_value_p (DECL_RESULT (subr)))
4565: {
4566: #ifdef PCC_STATIC_STRUCT_RETURN
4567: current_function_returns_pcc_struct = 1;
4568: #endif
4569: current_function_returns_struct = 1;
4570: }
4571:
4572: /* Warn if this value is an aggregate type,
4573: regardless of which calling convention we are using for it. */
4574: if (warn_aggregate_return
4575: && (TREE_CODE (TREE_TYPE (DECL_RESULT (subr))) == RECORD_TYPE
4576: || TREE_CODE (TREE_TYPE (DECL_RESULT (subr))) == UNION_TYPE
4577: || TREE_CODE (TREE_TYPE (DECL_RESULT (subr))) == QUAL_UNION_TYPE
4578: || TREE_CODE (TREE_TYPE (DECL_RESULT (subr))) == ARRAY_TYPE))
4579: warning ("function returns an aggregate");
4580:
4581: current_function_returns_pointer
4582: = (TREE_CODE (TREE_TYPE (DECL_RESULT (subr))) == POINTER_TYPE);
4583:
4584: /* Indicate that we need to distinguish between the return value of the
4585: present function and the return value of a function being called. */
4586: rtx_equal_function_value_matters = 1;
4587:
4588: /* Indicate that we have not instantiated virtual registers yet. */
4589: virtuals_instantiated = 0;
4590:
4591: /* Indicate we have no need of a frame pointer yet. */
4592: frame_pointer_needed = 0;
4593:
4594: /* By default assume not varargs. */
4595: current_function_varargs = 0;
4596: }
4597:
4598: /* Indicate that the current function uses extra args
4599: not explicitly mentioned in the argument list in any fashion. */
4600:
4601: void
4602: mark_varargs ()
4603: {
4604: current_function_varargs = 1;
4605: }
4606:
4607: /* Expand a call to __main at the beginning of a possible main function. */
4608:
4609: void
4610: expand_main_function ()
4611: {
4612: if (!output_bytecode)
4613: {
4614: /* The zero below avoids a possible parse error */
4615: 0;
4616: #if !defined (INIT_SECTION_ASM_OP) || defined (INVOKE__main)
4617: #ifdef NEXT_EXTENSION
4618: {
4619: rtx _argv, _argc;
4620: tree __main_type
4621: = build_function_type (void_type,
4622: tree_cons (0, int_type,
4623: tree_cons (0, pointer_type, 0)));
4624:
4625: emit_library_call (gen_rtx (SYMBOL_REF, Pmode, NAME__MAIN), 0,
4626: VOIDmode, 0);
4627: }
4628: #else
4629: emit_library_call (gen_rtx (SYMBOL_REF, Pmode, NAME__MAIN), 0,
4630: VOIDmode, 0);
4631: #endif
4632: #endif /* not INIT_SECTION_ASM_OP or INVOKE__main */
4633: }
4634: }
4635:
4636: extern struct obstack permanent_obstack;
4637:
4638: /* Expand start of bytecode function. See comment at
4639: expand_function_start below for details. */
4640:
4641: void
4642: bc_expand_function_start (subr, parms_have_cleanups)
4643: tree subr;
4644: int parms_have_cleanups;
4645: {
4646: char label[20], *name;
4647: static int nlab;
4648: tree thisarg;
4649: int argsz;
4650:
4651: if (TREE_PUBLIC (subr))
4652: bc_globalize_label (IDENTIFIER_POINTER (DECL_NAME (subr)));
4653:
4654: #ifdef DEBUG_PRINT_CODE
4655: fprintf (stderr, "\n<func %s>\n", IDENTIFIER_POINTER (DECL_NAME (subr)));
4656: #endif
4657:
4658: for (argsz = 0, thisarg = DECL_ARGUMENTS (subr); thisarg; thisarg = TREE_CHAIN (thisarg))
4659: {
4660: if (DECL_RTL (thisarg))
4661: abort (); /* Should be NULL here I think. */
4662: else if (TREE_CONSTANT (DECL_SIZE (thisarg)))
4663: {
4664: DECL_RTL (thisarg) = bc_gen_rtx ((char *) 0, argsz, (struct bc_label *) 0);
4665: argsz += TREE_INT_CST_LOW (DECL_SIZE (thisarg));
4666: }
4667: else
4668: {
4669: /* Variable-sized objects are pointers to their storage. */
4670: DECL_RTL (thisarg) = bc_gen_rtx ((char *) 0, argsz, (struct bc_label *) 0);
4671: argsz += POINTER_SIZE;
4672: }
4673: }
4674:
4675: bc_begin_function (bc_xstrdup (IDENTIFIER_POINTER (DECL_NAME (subr))));
4676:
4677: ASM_GENERATE_INTERNAL_LABEL (label, "LX", nlab);
4678:
4679: ++nlab;
4680: name = (char *) obstack_copy0 (&permanent_obstack, label, strlen (label));
4681: this_function_callinfo = bc_gen_rtx (name, 0, (struct bc_label *) 0);
4682: this_function_bytecode =
4683: bc_emit_trampoline (BYTECODE_LABEL (this_function_callinfo));
4684: }
4685:
4686:
4687: /* Expand end of bytecode function. See details the comment of
4688: expand_function_end(), below. */
4689:
4690: void
4691: bc_expand_function_end ()
4692: {
4693: char *ptrconsts;
4694:
4695: expand_null_return ();
4696:
4697: /* Emit any fixup code. This must be done before the call to
4698: to BC_END_FUNCTION (), since that will cause the bytecode
4699: segment to be finished off and closed. */
4700:
4701: fixup_gotos (0, 0, 0, 0, 0);
4702:
4703: ptrconsts = bc_end_function ();
4704:
4705: bc_align_const (2 /* INT_ALIGN */);
4706:
4707: /* If this changes also make sure to change bc-interp.h! */
4708:
4709: bc_emit_const_labeldef (BYTECODE_LABEL (this_function_callinfo));
4710: bc_emit_const ((char *) &max_stack_depth, sizeof max_stack_depth);
4711: bc_emit_const ((char *) &local_vars_size, sizeof local_vars_size);
4712: bc_emit_const_labelref (this_function_bytecode, 0);
4713: bc_emit_const_labelref (ptrconsts, 0);
4714: bc_emit_const_labelref (BYTECODE_LABEL (this_function_calldesc), 0);
4715: }
4716:
4717:
4718: /* Start the RTL for a new function, and set variables used for
4719: emitting RTL.
4720: SUBR is the FUNCTION_DECL node.
4721: PARMS_HAVE_CLEANUPS is nonzero if there are cleanups associated with
4722: the function's parameters, which must be run at any return statement. */
4723:
4724: void
4725: expand_function_start (subr, parms_have_cleanups)
4726: tree subr;
4727: int parms_have_cleanups;
4728: {
4729: register int i;
4730: tree tem;
4731: rtx last_ptr;
4732:
4733: if (output_bytecode)
4734: {
4735: bc_expand_function_start (subr, parms_have_cleanups);
4736: return;
4737: }
4738:
4739: /* Make sure volatile mem refs aren't considered
4740: valid operands of arithmetic insns. */
4741: init_recog_no_volatile ();
4742:
4743: /* If function gets a static chain arg, store it in the stack frame.
4744: Do this first, so it gets the first stack slot offset. */
4745: if (current_function_needs_context)
4746: {
4747: last_ptr = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0);
4748: emit_move_insn (last_ptr, static_chain_incoming_rtx);
4749: }
4750:
4751: /* If the parameters of this function need cleaning up, get a label
4752: for the beginning of the code which executes those cleanups. This must
4753: be done before doing anything with return_label. */
4754: if (parms_have_cleanups)
4755: cleanup_label = gen_label_rtx ();
4756: else
4757: cleanup_label = 0;
4758:
4759: /* Make the label for return statements to jump to, if this machine
4760: does not have a one-instruction return and uses an epilogue,
4761: or if it returns a structure, or if it has parm cleanups. */
4762: #ifdef HAVE_return
4763: if (cleanup_label == 0 && HAVE_return
4764: && ! current_function_returns_pcc_struct
4765: && ! (current_function_returns_struct && ! optimize))
4766: return_label = 0;
4767: else
4768: return_label = gen_label_rtx ();
4769: #else
4770: return_label = gen_label_rtx ();
4771: #endif
4772:
4773: /* Initialize rtx used to return the value. */
4774: /* Do this before assign_parms so that we copy the struct value address
4775: before any library calls that assign parms might generate. */
4776:
4777: /* Decide whether to return the value in memory or in a register. */
4778: if (aggregate_value_p (DECL_RESULT (subr)))
4779: {
4780: /* Returning something that won't go in a register. */
4781: register rtx value_address;
4782:
4783: #ifdef PCC_STATIC_STRUCT_RETURN
4784: if (current_function_returns_pcc_struct)
4785: {
4786: int size = int_size_in_bytes (TREE_TYPE (DECL_RESULT (subr)));
4787: value_address = assemble_static_space (size);
4788: }
4789: else
4790: #endif
4791: {
4792: /* Expect to be passed the address of a place to store the value.
4793: If it is passed as an argument, assign_parms will take care of
4794: it. */
4795: if (struct_value_incoming_rtx)
4796: {
4797: value_address = gen_reg_rtx (Pmode);
4798: emit_move_insn (value_address, struct_value_incoming_rtx);
4799: }
4800: }
4801: if (value_address)
4802: DECL_RTL (DECL_RESULT (subr))
4803: = gen_rtx (MEM, DECL_MODE (DECL_RESULT (subr)),
4804: value_address);
4805: }
4806: else if (DECL_MODE (DECL_RESULT (subr)) == VOIDmode)
4807: /* If return mode is void, this decl rtl should not be used. */
4808: DECL_RTL (DECL_RESULT (subr)) = 0;
4809: else if (parms_have_cleanups)
4810: {
4811: /* If function will end with cleanup code for parms,
4812: compute the return values into a pseudo reg,
4813: which we will copy into the true return register
4814: after the cleanups are done. */
4815:
4816: enum machine_mode mode = DECL_MODE (DECL_RESULT (subr));
4817: #ifdef PROMOTE_FUNCTION_RETURN
4818: tree type = TREE_TYPE (DECL_RESULT (subr));
4819: int unsignedp = TREE_UNSIGNED (type);
4820:
4821: if (TREE_CODE (type) == INTEGER_TYPE || TREE_CODE (type) == ENUMERAL_TYPE
4822: || TREE_CODE (type) == BOOLEAN_TYPE || TREE_CODE (type) == CHAR_TYPE
4823: || TREE_CODE (type) == REAL_TYPE || TREE_CODE (type) == POINTER_TYPE
4824: || TREE_CODE (type) == OFFSET_TYPE)
4825: {
4826: PROMOTE_MODE (mode, unsignedp, type);
4827: }
4828: #endif
4829:
4830: DECL_RTL (DECL_RESULT (subr)) = gen_reg_rtx (mode);
4831: }
4832: else
4833: /* Scalar, returned in a register. */
4834: {
4835: #ifdef FUNCTION_OUTGOING_VALUE
4836: DECL_RTL (DECL_RESULT (subr))
4837: = FUNCTION_OUTGOING_VALUE (TREE_TYPE (DECL_RESULT (subr)), subr);
4838: #else
4839: DECL_RTL (DECL_RESULT (subr))
4840: = FUNCTION_VALUE (TREE_TYPE (DECL_RESULT (subr)), subr);
4841: #endif
4842:
4843: /* Mark this reg as the function's return value. */
4844: if (GET_CODE (DECL_RTL (DECL_RESULT (subr))) == REG)
4845: {
4846: REG_FUNCTION_VALUE_P (DECL_RTL (DECL_RESULT (subr))) = 1;
4847: /* Needed because we may need to move this to memory
4848: in case it's a named return value whose address is taken. */
4849: DECL_REGISTER (DECL_RESULT (subr)) = 1;
4850: }
4851: }
4852:
4853: /* Initialize rtx for parameters and local variables.
4854: In some cases this requires emitting insns. */
4855:
4856: assign_parms (subr, 0);
4857:
4858: /* The following was moved from init_function_start.
4859: The move is supposed to make sdb output more accurate. */
4860: /* Indicate the beginning of the function body,
4861: as opposed to parm setup. */
4862: emit_note (NULL_PTR, NOTE_INSN_FUNCTION_BEG);
4863:
4864: /* If doing stupid allocation, mark parms as born here. */
4865:
4866: if (GET_CODE (get_last_insn ()) != NOTE)
4867: emit_note (NULL_PTR, NOTE_INSN_DELETED);
4868: parm_birth_insn = get_last_insn ();
4869:
4870: if (obey_regdecls)
4871: {
4872: for (i = LAST_VIRTUAL_REGISTER + 1; i < max_parm_reg; i++)
4873: use_variable (regno_reg_rtx[i]);
4874:
4875: if (current_function_internal_arg_pointer != virtual_incoming_args_rtx)
4876: use_variable (current_function_internal_arg_pointer);
4877: }
4878:
4879: /* Fetch static chain values for containing functions. */
4880: tem = decl_function_context (current_function_decl);
4881: /* If not doing stupid register allocation, then start off with the static
4882: chain pointer in a pseudo register. Otherwise, we use the stack
4883: address that was generated above. */
4884: if (tem && ! obey_regdecls)
4885: last_ptr = copy_to_reg (static_chain_incoming_rtx);
4886: context_display = 0;
4887: while (tem)
4888: {
4889: tree rtlexp = make_node (RTL_EXPR);
4890:
4891: RTL_EXPR_RTL (rtlexp) = last_ptr;
4892: context_display = tree_cons (tem, rtlexp, context_display);
4893: tem = decl_function_context (tem);
4894: if (tem == 0)
4895: break;
4896: /* Chain thru stack frames, assuming pointer to next lexical frame
4897: is found at the place we always store it. */
4898: #ifdef FRAME_GROWS_DOWNWARD
4899: last_ptr = plus_constant (last_ptr, - GET_MODE_SIZE (Pmode));
4900: #endif
4901: last_ptr = copy_to_reg (gen_rtx (MEM, Pmode,
4902: memory_address (Pmode, last_ptr)));
4903:
4904: /* If we are not optimizing, ensure that we know that this
4905: piece of context is live over the entire function. */
4906: if (! optimize)
4907: save_expr_regs = gen_rtx (EXPR_LIST, VOIDmode, last_ptr,
4908: save_expr_regs);
4909: }
4910:
4911: /* After the display initializations is where the tail-recursion label
4912: should go, if we end up needing one. Ensure we have a NOTE here
4913: since some things (like trampolines) get placed before this. */
4914: tail_recursion_reentry = emit_note (NULL_PTR, NOTE_INSN_DELETED);
4915:
4916: /* Evaluate now the sizes of any types declared among the arguments. */
4917: for (tem = nreverse (get_pending_sizes ()); tem; tem = TREE_CHAIN (tem))
4918: expand_expr (TREE_VALUE (tem), const0_rtx, VOIDmode, 0);
4919:
4920: /* Make sure there is a line number after the function entry setup code. */
4921: force_next_line_note ();
4922: }
4923:
4924: /* Generate RTL for the end of the current function.
4925: FILENAME and LINE are the current position in the source file.
4926:
4927: It is up to language-specific callers to do cleanups for parameters--
4928: or else, supply 1 for END_BINDINGS and we will call expand_end_bindings. */
4929:
4930: void
4931: expand_function_end (filename, line, end_bindings)
4932: char *filename;
4933: int line;
4934: int end_bindings;
4935: {
4936: register int i;
4937: tree link;
4938:
4939: static rtx initial_trampoline;
4940:
4941: if (output_bytecode)
4942: {
4943: bc_expand_function_end ();
4944: return;
4945: }
4946:
4947: #ifdef NON_SAVING_SETJMP
4948: /* Don't put any variables in registers if we call setjmp
4949: on a machine that fails to restore the registers. */
4950: if (NON_SAVING_SETJMP && current_function_calls_setjmp)
4951: {
4952: setjmp_protect (DECL_INITIAL (current_function_decl));
4953: setjmp_protect_args ();
4954: }
4955: #endif
4956:
4957: /* Save the argument pointer if a save area was made for it. */
4958: if (arg_pointer_save_area)
4959: {
4960: rtx x = gen_move_insn (arg_pointer_save_area, virtual_incoming_args_rtx);
4961: emit_insn_before (x, tail_recursion_reentry);
4962: }
4963:
4964: /* Initialize any trampolines required by this function. */
4965: for (link = trampoline_list; link; link = TREE_CHAIN (link))
4966: {
4967: tree function = TREE_PURPOSE (link);
4968: rtx context = lookup_static_chain (function);
4969: rtx tramp = RTL_EXPR_RTL (TREE_VALUE (link));
4970: rtx seq;
4971:
4972: /* First make sure this compilation has a template for
4973: initializing trampolines. */
4974: if (initial_trampoline == 0)
4975: {
4976: end_temporary_allocation ();
4977: initial_trampoline
4978: = gen_rtx (MEM, BLKmode, assemble_trampoline_template ());
4979: resume_temporary_allocation ();
4980: }
4981:
4982: /* Generate insns to initialize the trampoline. */
4983: start_sequence ();
4984: tramp = change_address (initial_trampoline, BLKmode,
4985: round_trampoline_addr (XEXP (tramp, 0)));
4986: emit_block_move (tramp, initial_trampoline, GEN_INT (TRAMPOLINE_SIZE),
4987: FUNCTION_BOUNDARY / BITS_PER_UNIT);
4988: INITIALIZE_TRAMPOLINE (XEXP (tramp, 0),
4989: XEXP (DECL_RTL (function), 0), context);
4990: seq = get_insns ();
4991: end_sequence ();
4992:
4993: /* Put those insns at entry to the containing function (this one). */
4994: emit_insns_before (seq, tail_recursion_reentry);
4995: }
4996:
4997: #if 0 /* I think unused parms are legitimate enough. */
4998: /* Warn about unused parms. */
4999: if (warn_unused)
5000: {
5001: rtx decl;
5002:
5003: for (decl = DECL_ARGUMENTS (current_function_decl);
5004: decl; decl = TREE_CHAIN (decl))
5005: if (! TREE_USED (decl) && TREE_CODE (decl) == VAR_DECL)
5006: warning_with_decl (decl, "unused parameter `%s'");
5007: }
5008: #endif
5009:
5010: /* Delete handlers for nonlocal gotos if nothing uses them. */
5011: if (nonlocal_goto_handler_slot != 0 && !current_function_has_nonlocal_label)
5012: delete_handlers ();
5013:
5014: /* End any sequences that failed to be closed due to syntax errors. */
5015: while (in_sequence_p ())
5016: end_sequence ();
5017:
5018: /* Outside function body, can't compute type's actual size
5019: until next function's body starts. */
5020: immediate_size_expand--;
5021:
5022: /* If doing stupid register allocation,
5023: mark register parms as dying here. */
5024:
5025: if (obey_regdecls)
5026: {
5027: rtx tem;
5028: for (i = LAST_VIRTUAL_REGISTER + 1; i < max_parm_reg; i++)
5029: use_variable (regno_reg_rtx[i]);
5030:
5031: /* Likewise for the regs of all the SAVE_EXPRs in the function. */
5032:
5033: for (tem = save_expr_regs; tem; tem = XEXP (tem, 1))
5034: {
5035: use_variable (XEXP (tem, 0));
5036: use_variable_after (XEXP (tem, 0), parm_birth_insn);
5037: }
5038:
5039: if (current_function_internal_arg_pointer != virtual_incoming_args_rtx)
5040: use_variable (current_function_internal_arg_pointer);
5041: }
5042:
5043: clear_pending_stack_adjust ();
5044: do_pending_stack_adjust ();
5045:
5046: /* Mark the end of the function body.
5047: If control reaches this insn, the function can drop through
5048: without returning a value. */
5049: emit_note (NULL_PTR, NOTE_INSN_FUNCTION_END);
5050:
5051: /* Output a linenumber for the end of the function.
5052: SDB depends on this. */
5053: emit_line_note_force (filename, line);
5054:
5055: /* Output the label for the actual return from the function,
5056: if one is expected. This happens either because a function epilogue
5057: is used instead of a return instruction, or because a return was done
5058: with a goto in order to run local cleanups, or because of pcc-style
5059: structure returning. */
5060:
5061: if (return_label)
5062: emit_label (return_label);
5063:
5064: /* C++ uses this. */
5065: if (end_bindings)
5066: expand_end_bindings (0, 0, 0);
5067:
5068: /* If we had calls to alloca, and this machine needs
5069: an accurate stack pointer to exit the function,
5070: insert some code to save and restore the stack pointer. */
5071: #ifdef EXIT_IGNORE_STACK
5072: if (! EXIT_IGNORE_STACK)
5073: #endif
5074: if (current_function_calls_alloca)
5075: {
5076: rtx tem = 0;
5077:
5078: emit_stack_save (SAVE_FUNCTION, &tem, parm_birth_insn);
5079: emit_stack_restore (SAVE_FUNCTION, tem, NULL_RTX);
5080: }
5081:
5082: /* If scalar return value was computed in a pseudo-reg,
5083: copy that to the hard return register. */
5084: if (DECL_RTL (DECL_RESULT (current_function_decl)) != 0
5085: && GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl))) == REG
5086: && (REGNO (DECL_RTL (DECL_RESULT (current_function_decl)))
5087: >= FIRST_PSEUDO_REGISTER))
5088: {
5089: rtx real_decl_result;
5090:
5091: #ifdef FUNCTION_OUTGOING_VALUE
5092: real_decl_result
5093: = FUNCTION_OUTGOING_VALUE (TREE_TYPE (DECL_RESULT (current_function_decl)),
5094: current_function_decl);
5095: #else
5096: real_decl_result
5097: = FUNCTION_VALUE (TREE_TYPE (DECL_RESULT (current_function_decl)),
5098: current_function_decl);
5099: #endif
5100: REG_FUNCTION_VALUE_P (real_decl_result) = 1;
5101: emit_move_insn (real_decl_result,
5102: DECL_RTL (DECL_RESULT (current_function_decl)));
5103: emit_insn (gen_rtx (USE, VOIDmode, real_decl_result));
5104: }
5105:
5106: /* If returning a structure, arrange to return the address of the value
5107: in a place where debuggers expect to find it.
5108:
5109: If returning a structure PCC style,
5110: the caller also depends on this value.
5111: And current_function_returns_pcc_struct is not necessarily set. */
5112: if (current_function_returns_struct
5113: || current_function_returns_pcc_struct)
5114: {
5115: rtx value_address = XEXP (DECL_RTL (DECL_RESULT (current_function_decl)), 0);
5116: tree type = TREE_TYPE (DECL_RESULT (current_function_decl));
5117: #ifdef FUNCTION_OUTGOING_VALUE
5118: rtx outgoing
5119: = FUNCTION_OUTGOING_VALUE (build_pointer_type (type),
5120: current_function_decl);
5121: #else
5122: rtx outgoing
5123: = FUNCTION_VALUE (build_pointer_type (type),
5124: current_function_decl);
5125: #endif
5126:
5127: /* Mark this as a function return value so integrate will delete the
5128: assignment and USE below when inlining this function. */
5129: REG_FUNCTION_VALUE_P (outgoing) = 1;
5130:
5131: emit_move_insn (outgoing, value_address);
5132: use_variable (outgoing);
5133: }
5134:
5135: /* Output a return insn if we are using one.
5136: Otherwise, let the rtl chain end here, to drop through
5137: into the epilogue. */
5138:
5139: #ifdef HAVE_return
5140: if (HAVE_return)
5141: {
5142: emit_jump_insn (gen_return ());
5143: emit_barrier ();
5144: }
5145: #endif
5146:
5147: /* Fix up any gotos that jumped out to the outermost
5148: binding level of the function.
5149: Must follow emitting RETURN_LABEL. */
5150:
5151: /* If you have any cleanups to do at this point,
5152: and they need to create temporary variables,
5153: then you will lose. */
5154: fixup_gotos (NULL_PTR, NULL_RTX, NULL_TREE, get_insns (), 0);
5155: }
5156:
5157: /* These arrays record the INSN_UIDs of the prologue and epilogue insns. */
5158:
5159: static int *prologue;
5160: static int *epilogue;
5161:
5162: /* Create an array that records the INSN_UIDs of INSNS (either a sequence
5163: or a single insn). */
5164:
5165: static int *
5166: record_insns (insns)
5167: rtx insns;
5168: {
5169: int *vec;
5170:
5171: if (GET_CODE (insns) == SEQUENCE)
5172: {
5173: int len = XVECLEN (insns, 0);
5174: vec = (int *) oballoc ((len + 1) * sizeof (int));
5175: vec[len] = 0;
5176: while (--len >= 0)
5177: vec[len] = INSN_UID (XVECEXP (insns, 0, len));
5178: }
5179: else
5180: {
5181: vec = (int *) oballoc (2 * sizeof (int));
5182: vec[0] = INSN_UID (insns);
5183: vec[1] = 0;
5184: }
5185: return vec;
5186: }
5187:
5188: /* Determine how many INSN_UIDs in VEC are part of INSN. */
5189:
5190: static int
5191: contains (insn, vec)
5192: rtx insn;
5193: int *vec;
5194: {
5195: register int i, j;
5196:
5197: if (GET_CODE (insn) == INSN
5198: && GET_CODE (PATTERN (insn)) == SEQUENCE)
5199: {
5200: int count = 0;
5201: for (i = XVECLEN (PATTERN (insn), 0) - 1; i >= 0; i--)
5202: for (j = 0; vec[j]; j++)
5203: if (INSN_UID (XVECEXP (PATTERN (insn), 0, i)) == vec[j])
5204: count++;
5205: return count;
5206: }
5207: else
5208: {
5209: for (j = 0; vec[j]; j++)
5210: if (INSN_UID (insn) == vec[j])
5211: return 1;
5212: }
5213: return 0;
5214: }
5215:
5216: /* Generate the prologe and epilogue RTL if the machine supports it. Thread
5217: this into place with notes indicating where the prologue ends and where
5218: the epilogue begins. Update the basic block information when possible. */
5219:
5220: void
5221: thread_prologue_and_epilogue_insns (f)
5222: rtx f;
5223: {
5224: #ifdef HAVE_prologue
5225: if (HAVE_prologue)
5226: {
5227: rtx head, seq, insn;
5228:
5229: /* The first insn (a NOTE_INSN_DELETED) is followed by zero or more
5230: prologue insns and a NOTE_INSN_PROLOGUE_END. */
5231: emit_note_after (NOTE_INSN_PROLOGUE_END, f);
5232: seq = gen_prologue ();
5233: head = emit_insn_after (seq, f);
5234:
5235: /* Include the new prologue insns in the first block. Ignore them
5236: if they form a basic block unto themselves. */
5237: if (basic_block_head && n_basic_blocks
5238: #ifdef NEXT_SEMANTICS
5239: && !obey_regdecls
5240: #endif
5241: && GET_CODE (basic_block_head[0]) != CODE_LABEL)
5242: basic_block_head[0] = NEXT_INSN (f);
5243:
5244: /* Retain a map of the prologue insns. */
5245: prologue = record_insns (GET_CODE (seq) == SEQUENCE ? seq : head);
5246: }
5247: else
5248: #endif
5249: prologue = 0;
5250:
5251: #ifdef HAVE_epilogue
5252: if (HAVE_epilogue)
5253: {
5254: rtx insn = get_last_insn ();
5255: rtx prev = prev_nonnote_insn (insn);
5256:
5257: /* If we end with a BARRIER, we don't need an epilogue. */
5258: if (! (prev && GET_CODE (prev) == BARRIER))
5259: {
5260: rtx tail, seq, tem;
5261: rtx first_use = 0;
5262: rtx last_use = 0;
5263:
5264: /* The last basic block ends with a NOTE_INSN_EPILOGUE_BEG, the
5265: epilogue insns, the USE insns at the end of a function,
5266: the jump insn that returns, and then a BARRIER. */
5267:
5268: /* Move the USE insns at the end of a function onto a list. */
5269: while (prev
5270: && GET_CODE (prev) == INSN
5271: && GET_CODE (PATTERN (prev)) == USE)
5272: {
5273: tem = prev;
5274: prev = prev_nonnote_insn (prev);
5275:
5276: NEXT_INSN (PREV_INSN (tem)) = NEXT_INSN (tem);
5277: PREV_INSN (NEXT_INSN (tem)) = PREV_INSN (tem);
5278: if (first_use)
5279: {
5280: NEXT_INSN (tem) = first_use;
5281: PREV_INSN (first_use) = tem;
5282: }
5283: first_use = tem;
5284: if (!last_use)
5285: last_use = tem;
5286: }
5287:
5288: emit_barrier_after (insn);
5289:
5290: seq = gen_epilogue ();
5291: tail = emit_jump_insn_after (seq, insn);
5292:
5293: /* Insert the USE insns immediately before the return insn, which
5294: must be the first instruction before the final barrier. */
5295: if (first_use)
5296: {
5297: tem = prev_nonnote_insn (get_last_insn ());
5298: NEXT_INSN (PREV_INSN (tem)) = first_use;
5299: PREV_INSN (first_use) = PREV_INSN (tem);
5300: PREV_INSN (tem) = last_use;
5301: NEXT_INSN (last_use) = tem;
5302: }
5303:
5304: emit_note_after (NOTE_INSN_EPILOGUE_BEG, insn);
5305:
5306: /* Include the new epilogue insns in the last block. Ignore
5307: them if they form a basic block unto themselves. */
5308: if (basic_block_end && n_basic_blocks
5309: #ifdef NEXT_SEMANTICS
5310: && !obey_regdecls
5311: #endif
5312: && GET_CODE (basic_block_end[n_basic_blocks - 1]) != JUMP_INSN)
5313: basic_block_end[n_basic_blocks - 1] = tail;
5314:
5315: /* Retain a map of the epilogue insns. */
5316: epilogue = record_insns (GET_CODE (seq) == SEQUENCE ? seq : tail);
5317: return;
5318: }
5319: }
5320: #endif
5321: epilogue = 0;
5322: }
5323:
5324: /* Reposition the prologue-end and epilogue-begin notes after instruction
5325: scheduling and delayed branch scheduling. */
5326:
5327: void
5328: reposition_prologue_and_epilogue_notes (f)
5329: rtx f;
5330: {
5331: #if defined (HAVE_prologue) || defined (HAVE_epilogue)
5332: /* Reposition the prologue and epilogue notes. */
5333: if (n_basic_blocks)
5334: {
5335: rtx next, prev;
5336: int len;
5337:
5338: if (prologue)
5339: {
5340: register rtx insn, note = 0;
5341:
5342: /* Scan from the beginning until we reach the last prologue insn.
5343: We apparently can't depend on basic_block_{head,end} after
5344: reorg has run. */
5345: for (len = 0; prologue[len]; len++)
5346: ;
5347: for (insn = f; len && insn; insn = NEXT_INSN (insn))
5348: {
5349: if (GET_CODE (insn) == NOTE)
5350: {
5351: if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_PROLOGUE_END)
5352: note = insn;
5353: }
5354: else if ((len -= contains (insn, prologue)) == 0)
5355: {
5356: /* Find the prologue-end note if we haven't already, and
5357: move it to just after the last prologue insn. */
5358: if (note == 0)
5359: {
5360: for (note = insn; note = NEXT_INSN (note);)
5361: if (GET_CODE (note) == NOTE
5362: && NOTE_LINE_NUMBER (note) == NOTE_INSN_PROLOGUE_END)
5363: break;
5364: }
5365: next = NEXT_INSN (note);
5366: prev = PREV_INSN (note);
5367: if (prev)
5368: NEXT_INSN (prev) = next;
5369: if (next)
5370: PREV_INSN (next) = prev;
5371: add_insn_after (note, insn);
5372: }
5373: }
5374: }
5375:
5376: if (epilogue)
5377: {
5378: register rtx insn, note = 0;
5379:
5380: /* Scan from the end until we reach the first epilogue insn.
5381: We apparently can't depend on basic_block_{head,end} after
5382: reorg has run. */
5383: for (len = 0; epilogue[len]; len++)
5384: ;
5385: for (insn = get_last_insn (); len && insn; insn = PREV_INSN (insn))
5386: {
5387: if (GET_CODE (insn) == NOTE)
5388: {
5389: if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EPILOGUE_BEG)
5390: note = insn;
5391: }
5392: else if ((len -= contains (insn, epilogue)) == 0)
5393: {
5394: /* Find the epilogue-begin note if we haven't already, and
5395: move it to just before the first epilogue insn. */
5396: if (note == 0)
5397: {
5398: for (note = insn; note = PREV_INSN (note);)
5399: if (GET_CODE (note) == NOTE
5400: && NOTE_LINE_NUMBER (note) == NOTE_INSN_EPILOGUE_BEG)
5401: break;
5402: }
5403: next = NEXT_INSN (note);
5404: prev = PREV_INSN (note);
5405: if (prev)
5406: NEXT_INSN (prev) = next;
5407: if (next)
5408: PREV_INSN (next) = prev;
5409: add_insn_after (note, PREV_INSN (insn));
5410: }
5411: }
5412: }
5413: }
5414: #endif /* HAVE_prologue or HAVE_epilogue */
5415: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.