![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to stmt.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / gcc|
Return to stmt.c CVS log | Up to [Research Unix] / researchv10dc / cmd / gcc |
1.1 root 1: /* Expands front end tree to back end RTL for GNU C-Compiler
2: Copyright (C) 1987,1988 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is distributed in the hope that it will be useful,
7: but WITHOUT ANY WARRANTY. No author or distributor
8: accepts responsibility to anyone for the consequences of using it
9: or for whether it serves any particular purpose or works at all,
10: unless he says so in writing. Refer to the GNU CC General Public
11: License for full details.
12:
13: Everyone is granted permission to copy, modify and redistribute
14: GNU CC, but only under the conditions described in the
15: GNU CC General Public License. A copy of this license is
16: supposed to have been given to you along with GNU CC so you
17: can know your rights and responsibilities. It should be in a
18: file named COPYING. Among other things, the copyright notice
19: and this notice must be preserved on all copies. */
20:
21:
22: /* This file handles the generation of rtl code from tree structure
23: above the level of expressions, using subroutines in exp*.c and emit-rtl.c.
24: It also creates the rtl expressions for parameters and auto variables
25: and has full responsibility for allocating stack slots.
26:
27: The functions whose names start with `expand_' are called by the
28: parser to generate RTL instructions for various kinds of constructs.
29:
30: Some control and binding constructs require calling several such
31: functions at different times. For example, a simple if-then
32: is expanded by calling `expand_start_cond' (with the condition-expression
33: as argument) before parsing the then-clause and calling `expand_end_cond'
34: after parsing the then-clause.
35:
36: `expand_start_function' is called at the beginning of a function,
37: before the function body is parsed, and `expand_end_function' is
38: called after parsing the body.
39:
40: Call `assign_stack_local' to allocate a stack slot for a local variable.
41: This is usually done during the RTL generation for the function body,
42: but it can also be done in the reload pass when a pseudo-register does
43: not get a hard register.
44:
45: Call `put_var_into_stack' when you learn, belatedly, that a variable
46: previously given a pseudo-register must in fact go in the stack.
47: This function changes the DECL_RTL to be a stack slot instead of a reg
48: then scans all the RTL instructions so far generated to correct them. */
49:
50: #include "config.h"
51:
52: #include <stdio.h>
53:
54: #include "rtl.h"
55: #include "tree.h"
56: #include "flags.h"
57: #include "insn-flags.h"
58: #include "insn-config.h"
59: #include "expr.h"
60: #include "regs.h"
61:
62: #define MAX(x,y) (((x) > (y)) ? (x) : (y))
63: #define MIN(x,y) (((x) < (y)) ? (x) : (y))
64:
65: /* Nonzero if function being compiled pops its args on return.
66: May affect compilation of return insn or of function epilogue. */
67:
68: int current_function_pops_args;
69:
70: /* If function's args have a fixed size, this is that size, in bytes.
71: Otherwise, it is -1.
72: May affect compilation of return insn or of function epilogue. */
73:
74: int current_function_args_size;
75:
76: /* # bytes the prologue should push and pretend that the caller pushed them.
77: The prologue must do this, but only if parms can be passed in registers. */
78:
79: int current_function_pretend_args_size;
80:
81: /* Name of function now being compiled. */
82:
83: char *current_function_name;
84:
85: /* Label that will go on function epilogue.
86: Jumping to this label serves as a "return" instruction
87: on machines which require execution of the epilogue on all returns. */
88:
89: rtx return_label;
90:
91: /* The FUNCTION_DECL node for the function being compiled. */
92:
93: static tree this_function;
94:
95: /* Offset to end of allocated area of stack frame.
96: If stack grows down, this is the address of the last stack slot allocated.
97: If stack grows up, this is the address for the next slot. */
98: static int frame_offset;
99:
100: /* Nonzero if a stack slot has been generated whose address is not
101: actually valid. It means that the generated rtl must all be scanned
102: to detect and correct the invalid addresses where they occur. */
103: static int invalid_stack_slot;
104:
105: /* Label to jump back to for tail recursion, or 0 if we have
106: not yet needed one for this function. */
107: static rtx tail_recursion_label;
108:
109: /* Place after which to insert the tail_recursion_label if we need one. */
110: static rtx tail_recursion_reentry;
111:
112: /* Each time we expand an expression-statement,
113: record the expr's type and its RTL value here. */
114:
115: static tree last_expr_type;
116: static rtx last_expr_value;
117:
118: static void fixup_gotos ();
119: static int tail_recursion_args ();
120: void fixup_stack_slots ();
121: static rtx fixup_stack_1 ();
122: static rtx fixup_memory_subreg ();
123: static void fixup_var_refs ();
124: static rtx fixup_var_refs_1 ();
125: static rtx parm_stack_loc ();
126: static void optimize_bit_field ();
127: void do_jump_if_equal ();
128:
129: /* Stack of control and binding constructs we are currently inside.
130:
131: These constructs begin when you call `expand_start_WHATEVER'
132: and end when you call `expand_end_WHATEVER'. This stack records
133: info about how the construct began that tells the end-function
134: what to do. It also may provide information about the construct
135: to alter the behavior of other constructs within the body.
136: For example, they may affect the behavior of C `break' and `continue'.
137:
138: Each construct gets one `struct nesting' object.
139: All of these objects are chained through the `all' field.
140: `nesting_stack' points to the first object (innermost construct).
141: The position of an entry on `nesting_stack' is in its `depth' field.
142:
143: Each type of construct has its own individual stack.
144: For example, loops have `loop_stack'. Each object points to the
145: next object of the same type through the `next' field.
146:
147: Some constructs are visible to `break' exit-statements and others
148: are not. Which constructs are visible depends on the language.
149: Therefore, the data structure allows each construct to be visible
150: or not, according to the args given when the construct is started.
151: The construct is visible if the `exit_label' field is non-null.
152: In that case, the value should be a CODE_LABEL rtx. */
153:
154: struct nesting
155: {
156: struct nesting *all;
157: struct nesting *next;
158: int depth;
159: rtx exit_label;
160: union
161: {
162: /* For conds (if-then and if-then-else statements). */
163: struct
164: {
165: /* Label on the else-part, if any, else 0. */
166: rtx else_label;
167: /* Label at the end of the whole construct. */
168: rtx after_label;
169: } cond;
170: /* For loops. */
171: struct
172: {
173: /* Label at the top of the loop; place to loop back to. */
174: rtx start_label;
175: /* Label at the end of the whole construct. */
176: rtx end_label;
177: /* Label for `continue' statement to jump to;
178: this is in front of the stepper of the loop. */
179: rtx continue_label;
180: } loop;
181: /* For variable binding contours. */
182: struct
183: {
184: /* Nonzero => value to restore stack to on exit. */
185: rtx stack_level;
186: /* The NOTE that starts this contour.
187: Used by expand_goto to check whether the destination
188: is within each contour or not. */
189: rtx first_insn;
190: /* Innermost containing binding contour that has a stack level. */
191: struct nesting *innermost_stack_block;
192: /* Chain of labels defined inside this binding contour.
193: Only for contours that have stack levels. */
194: struct label_chain *label_chain;
195: } block;
196: /* For switch (C) or case (Pascal) statements,
197: and also for dummies (see `expand_start_case_dummy'). */
198: struct
199: {
200: /* The insn after which the case dispatch should finally
201: be emitted. Zero for a dummy. */
202: rtx start;
203: /* A list of the case-values and their labels.
204: A chain of TREE_LIST nodes with the value to test for
205: (a constant node) in the TREE_PURPOSE and the
206: label (a LABEL_DECL) in the TREE_VALUE. */
207: tree case_list;
208: /* The expression to be dispatched on. */
209: tree index_expr;
210: /* Type that INDEX_EXPR should be converted to. */
211: tree nominal_type;
212: } case_stmt;
213: } data;
214: };
215:
216: /* Chain of all pending binding contours. */
217: struct nesting *block_stack;
218:
219: /* Chain of all pending binding contours that restore stack levels. */
220: struct nesting *stack_block_stack;
221:
222: /* Chain of all pending conditional statements. */
223: struct nesting *cond_stack;
224:
225: /* Chain of all pending loops. */
226: struct nesting *loop_stack;
227:
228: /* Chain of all pending case or switch statements. */
229: struct nesting *case_stack;
230:
231: /* Separate chain including all of the above,
232: chained through the `all' field. */
233: struct nesting *nesting_stack;
234:
235: /* Number of entries on nesting_stack now. */
236: int nesting_depth;
237:
238: /* Pop one of the sub-stacks, such as `loop_stack' or `cond_stack';
239: and pop off `nesting_stack' down to the same level. */
240:
241: #define POPSTACK(STACK) \
242: do { int initial_depth = nesting_stack->depth; \
243: do { struct nesting *this = STACK; \
244: STACK = this->next; \
245: nesting_stack = this->all; \
246: nesting_depth = this->depth; \
247: free (this); } \
248: while (nesting_depth > initial_depth); } while (0)
249:
250: /* Return the rtx-label that corresponds to a LABEL_DECL,
251: creating it if necessary. */
252:
253: static rtx
254: label_rtx (label)
255: tree label;
256: {
257: if (TREE_CODE (label) != LABEL_DECL)
258: abort ();
259:
260: if (DECL_RTL (label))
261: return DECL_RTL (label);
262:
263: return DECL_RTL (label) = gen_label_rtx ();
264: }
265:
266: /* Add an unconditional jump to LABEL as the next sequential instruction. */
267:
268: void
269: emit_jump (label)
270: rtx label;
271: {
272: do_pending_stack_adjust ();
273: emit_jump_insn (gen_jump (label));
274: emit_barrier ();
275: }
276:
277: /* Handle goto statements and the labels that they can go to. */
278:
279: /* In some cases it is impossible to generate code for a forward goto
280: until the label definition is seen. This happens when it may be necessary
281: for the goto to reset the stack pointer: we don't yet know how to do that.
282: So expand_goto puts an entry on this fixup list.
283: Each time a binding contour that resets the stack is exited,
284: we check each fixup.
285: If the target label has now been defined, we can insert the proper code. */
286:
287: struct goto_fixup
288: {
289: /* Points to following fixup. */
290: struct goto_fixup *next;
291: /* Points to the insn before the jump insn.
292: If more code must be inserted, it goes after this insn. */
293: rtx before_jump;
294: /* The LABEL_DECL that this jump is jumping to. */
295: tree target;
296: /* The outermost stack level that should be restored for this jump.
297: Each time a binding contour that resets the stack is exited,
298: if the target label is *not* yet defined, this slot is updated. */
299: rtx stack_level;
300: };
301:
302: static struct goto_fixup *goto_fixup_chain;
303:
304: /* Within any binding contour that must restore a stack level,
305: all labels are recorded with a chain of these structures. */
306:
307: struct label_chain
308: {
309: /* Points to following fixup. */
310: struct label_chain *next;
311: tree label;
312: };
313:
314: /* Specify the location in the RTL code of a label BODY,
315: which is a LABEL_DECL tree node.
316:
317: This is used for the kind of label that the user can jump to with a
318: goto statement, and for alternatives of a switch or case statement.
319: RTL labels generated for loops and conditionals don't go through here;
320: they are generated directly at the RTL level, by other functions below.
321:
322: Note that this has nothing to do with defining label *names*.
323: Languages vary in how they do that and what that even means. */
324:
325: void
326: expand_label (body)
327: tree body;
328: {
329: struct label_chain *p;
330:
331: do_pending_stack_adjust ();
332: emit_label (label_rtx (body));
333:
334: if (stack_block_stack)
335: {
336: p = (struct label_chain *) oballoc (sizeof (struct label_chain));
337: p->next = stack_block_stack->data.block.label_chain;
338: stack_block_stack->data.block.label_chain = p;
339: p->label = body;
340: }
341: }
342:
343: /* Generate RTL code for a `goto' statement with target label BODY.
344: BODY should be a LABEL_DECL tree node that was or will later be
345: defined with `expand_label'. */
346:
347: void
348: expand_goto (body)
349: tree body;
350: {
351: struct nesting *block;
352: rtx stack_level = 0;
353: rtx label = label_rtx (body);
354:
355: if (GET_CODE (label) != CODE_LABEL)
356: abort ();
357:
358: /* If label has already been defined, we can tell now
359: whether and how we must alter the stack level. */
360:
361: if (DECL_SOURCE_LINE (body) != 0)
362: {
363: /* Find the outermost pending block that contains the label.
364: (Check containment by comparing insn-uids.)
365: Then restore the outermost stack level within that block. */
366: for (block = block_stack; block; block = block->next)
367: {
368: if (INSN_UID (block->data.block.first_insn) < INSN_UID (label))
369: break;
370: if (block->data.block.stack_level != 0)
371: stack_level = block->data.block.stack_level;
372: }
373:
374: if (stack_level)
375: emit_move_insn (stack_pointer_rtx, stack_level);
376:
377: if (TREE_PACKED (body))
378: error ("goto \"%s\" invalidly jumps into binding contour",
379: IDENTIFIER_POINTER (DECL_NAME (body)));
380: }
381: /* Label not yet defined: may need to put this goto
382: on the fixup list. */
383: else
384: {
385: /* Does any containing block have a stack level?
386: If not, no fixup is needed, and that is the normal case
387: (the only case, for standard C). */
388: for (block = block_stack; block; block = block->next)
389: if (block->data.block.stack_level != 0)
390: break;
391:
392: if (block)
393: {
394: /* Ok, a fixup is needed. Add a fixup to the list of such. */
395: struct goto_fixup *fixup
396: = (struct goto_fixup *) oballoc (sizeof (struct goto_fixup));
397: /* In case an old stack level is restored, make sure that comes
398: after any pending stack adjust. */
399: do_pending_stack_adjust ();
400: fixup->before_jump = get_last_insn ();
401: fixup->target = body;
402: fixup->stack_level = 0;
403: fixup->next = goto_fixup_chain;
404: goto_fixup_chain = fixup;
405: }
406: else
407: /* No fixup needed. Record that the label is the target
408: of at least one goto that has no fixup. */
409: TREE_ADDRESSABLE (body) = 1;
410: }
411:
412: emit_jump (label);
413: }
414:
415: /* When exiting a binding contour, process all pending gotos requiring fixups.
416: STACK_LEVEL is the rtx for the stack level to restore on exit from
417: this contour. FIRST_INSN is the insn that begain this contour.
418: Gotos that jump out of this contour must restore the
419: stack level before actually jumping.
420:
421: Also print an error message if any fixup describes a jump into this
422: contour from before the beginning of the contour. */
423:
424: static void
425: fixup_gotos (stack_level, first_insn)
426: rtx stack_level;
427: rtx first_insn;
428: {
429: register struct goto_fixup *f;
430:
431: for (f = goto_fixup_chain; f; f = f->next)
432: {
433: /* Test for a fixup that is inactive because it is already handled. */
434: if (f->before_jump == 0)
435: ;
436: /* Has this fixup's target label been defined?
437: If so, we can finalize it. */
438: else if (DECL_SOURCE_LINE (f->target) != 0)
439: {
440: /* If this fixup jumped into this contour from before the beginning
441: of this contour, report an error. */
442: if (INSN_UID (first_insn) > INSN_UID (f->before_jump)
443: && ! TREE_ADDRESSABLE (f->target))
444: {
445: error_with_file_and_line (DECL_SOURCE_FILE (f->target),
446: DECL_SOURCE_LINE (f->target),
447: "label \"%s\" was used \
448: before containing binding contour",
449: IDENTIFIER_POINTER (DECL_NAME (f->target)));
450: /* Prevent multiple errors for one label. */
451: TREE_ADDRESSABLE (f->target) = 1;
452: }
453:
454: /* Restore stack level for the biggest contour that this
455: jump jumps out of. */
456: if (f->stack_level)
457: emit_insn_after (gen_move_insn (stack_pointer_rtx, f->stack_level),
458: f->before_jump);
459: f->before_jump = 0;
460: }
461: /* Label has still not appeared. If we are exiting a block with
462: a stack level to restore, mark this stack level as needing
463: restoration when the fixup is later finalized. */
464: else if (stack_level)
465: f->stack_level = stack_level;
466: }
467: }
468:
469: /* Generate RTL for an asm statement (explicit assembler code).
470: BODY is a STRING_CST node containing the assembler code text. */
471:
472: void
473: expand_asm (body)
474: tree body;
475: {
476: emit_insn (gen_rtx (ASM_INPUT, VOIDmode,
477: TREE_STRING_POINTER (body)));
478: last_expr_type = 0;
479: }
480:
481: /* Generate RTL for an asm statement with arguments.
482: STRING is the instruction template.
483: OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
484: Each output or input has an expression in the TREE_VALUE and
485: a constraint-string in the TREE_PURPOSE.
486:
487: Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
488: Some elements of OUTPUTS may be replaced with trees representing temporary
489: values. The caller should copy those temporary values to the originally
490: specified lvalues.
491:
492: VOL nonzero means the insn is volatile; don't optimize it. */
493:
494: void
495: expand_asm_operands (string, outputs, inputs, vol)
496: tree string, outputs, inputs;
497: int vol;
498: {
499: rtvec argvec, constraints;
500: rtx body;
501: int ninputs = list_length (inputs);
502: int noutputs = list_length (outputs);
503: int numargs = 0;
504: tree tail;
505: int i;
506:
507: if (ninputs + noutputs > MAX_RECOG_OPERANDS)
508: {
509: error ("more than %d operands in `asm'", MAX_RECOG_OPERANDS);
510: return;
511: }
512:
513: for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
514: {
515: tree val = TREE_VALUE (tail);
516:
517: /* If an output operand is not a variable or indirect ref,
518: create a SAVE_EXPR which is a pseudo-reg
519: to act as an intermediate temporary.
520: Make the asm insn write into that, then copy it to
521: the real output operand. */
522:
523: if (TREE_CODE (val) != VAR_DECL
524: && TREE_CODE (val) != PARM_DECL
525: && TREE_CODE (val) != INDIRECT_REF)
526: TREE_VALUE (tail) = build (SAVE_EXPR, TREE_TYPE (val), val,
527: gen_reg_rtx (TYPE_MODE (TREE_TYPE (val))));
528: }
529:
530: /* Make vectors for the expression-rtx and constraint strings. */
531:
532: if (ninputs > 0)
533: {
534: argvec = rtvec_alloc (ninputs);
535: constraints = rtvec_alloc (ninputs);
536: }
537: else
538: argvec = constraints = 0;
539:
540: body = gen_rtx (ASM_OPERANDS, VOIDmode,
541: TREE_STRING_POINTER (string), "", 0, argvec, constraints);
542: body->volatil = vol;
543:
544: /* Eval the inputs and put them into ARGVEC.
545: Put their constraints into ASM_INPUTs and store in CONSTRAINTS. */
546:
547: i = 0;
548: for (tail = inputs; tail; tail = TREE_CHAIN (tail))
549: {
550: XVECEXP (body, 3, i) /* argvec */
551: = expand_expr (TREE_VALUE (tail), 0, VOIDmode, 0);
552: XVECEXP (body, 4, i) /* constraints */
553: = gen_rtx (ASM_INPUT, TYPE_MODE (TREE_TYPE (TREE_VALUE (tail))),
554: TREE_STRING_POINTER (TREE_PURPOSE (tail)));
555: i++;
556: }
557:
558: /* Now, for each output, construct an rtx
559: (set OUTPUT (asm_operands INSN OUTPUTNUMBER OUTPUTCONSTRAINT
560: ARGVEC CONSTRAINTS))
561: If there is more than one, put them inside a PARALLEL. */
562:
563: if (noutputs == 1)
564: {
565: tree val = TREE_VALUE (outputs);
566:
567: XSTR (body, 1) = TREE_STRING_POINTER (TREE_PURPOSE (outputs));
568: emit_insn (gen_rtx (SET, VOIDmode,
569: expand_expr (val, 0, VOIDmode, 0),
570: body));
571: }
572: else
573: {
574: body = gen_rtx (PARALLEL, VOIDmode, rtvec_alloc (noutputs));
575:
576: for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
577: {
578: tree val = TREE_VALUE (tail);
579:
580: XVECEXP (body, 0, i)
581: = gen_rtx (SET, VOIDmode,
582: expand_expr (val, 0, VOIDmode, 0),
583: gen_rtx (ASM_OPERANDS, VOIDmode,
584: TREE_STRING_POINTER (string),
585: TREE_STRING_POINTER (TREE_PURPOSE (tail)),
586: i, argvec, constraints));
587: SET_SRC (XVECEXP (body, 0, i))->volatil = vol;
588: }
589:
590: emit_insn (body);
591: }
592: last_expr_type = 0;
593: }
594:
595: /* Nonzero if within a ({...}) grouping, in which case we must
596: always compute a value for each expr-stmt in case it is the last one. */
597:
598: int expr_stmts_for_value;
599:
600: /* Generate RTL to evaluate the expression EXP
601: and remember it in case this is the VALUE in a ({... VALUE; }) constr. */
602:
603: void
604: expand_expr_stmt (exp)
605: tree exp;
606: {
607: last_expr_type = TREE_TYPE (exp);
608: last_expr_value = expand_expr (exp, expr_stmts_for_value ? 0 : const0_rtx,
609: VOIDmode, 0);
610: emit_queue ();
611: }
612:
613: /* Clear out the memory of the last expression evaluated. */
614:
615: void
616: clear_last_expr ()
617: {
618: last_expr_type = 0;
619: }
620:
621: /* Return a tree node that refers to the last expression evaluated.
622: The nodes of that expression have been freed by now, so we cannot use them.
623: But we don't want to do that anyway; the expression has already been
624: evaluated and now we just want to use the value. So generate a SAVE_EXPR
625: with the proper type and RTL value.
626:
627: If the last statement was not an expression,
628: return something with type `void'. */
629:
630: tree
631: get_last_expr ()
632: {
633: tree t;
634:
635: if (last_expr_type == 0)
636: {
637: last_expr_type = void_type_node;
638: last_expr_value = const0_rtx;
639: }
640: t = build (RTL_EXPR, last_expr_type, NULL, NULL);
641: RTL_EXPR_RTL (t) = last_expr_value;
642: RTL_EXPR_SEQUENCE (t) = gen_sequence ();
643: return t;
644: }
645:
646: void
647: expand_start_stmt_expr ()
648: {
649: extern int emit_to_sequence;
650: expr_stmts_for_value++;
651: emit_to_sequence++;
652: }
653:
654: void
655: expand_end_stmt_expr ()
656: {
657: extern int emit_to_sequence;
658: expr_stmts_for_value--;
659: emit_to_sequence--;
660: }
661:
662: /* Generate RTL for the start of an if-then. COND is the expression
663: whose truth should be tested.
664:
665: If EXITFLAG is nonzero, this conditional is visible to
666: `exit_something'. */
667:
668: void
669: expand_start_cond (cond, exitflag)
670: tree cond;
671: int exitflag;
672: {
673: struct nesting *thiscond
674: = (struct nesting *) xmalloc (sizeof (struct nesting));
675:
676: /* Make an entry on cond_stack for the cond we are entering. */
677:
678: thiscond->next = cond_stack;
679: thiscond->all = nesting_stack;
680: thiscond->depth = ++nesting_depth;
681: thiscond->data.cond.after_label = 0;
682: thiscond->data.cond.else_label = gen_label_rtx ();
683: thiscond->exit_label = exitflag ? thiscond->data.cond.else_label : 0;
684: cond_stack = thiscond;
685: nesting_stack = thiscond;
686:
687: do_jump (cond, thiscond->data.cond.else_label, NULL);
688: }
689:
690: /* Generate RTL for the end of an if-then with no else-clause.
691: Pop the record for it off of cond_stack. */
692:
693: void
694: expand_end_cond ()
695: {
696: struct nesting *thiscond = cond_stack;
697:
698: do_pending_stack_adjust ();
699: emit_label (thiscond->data.cond.else_label);
700:
701: POPSTACK (cond_stack);
702: last_expr_type = 0;
703: }
704:
705: /* Generate RTL between the then-clause and the else-clause
706: of an if-then-else. */
707:
708: void
709: expand_start_else ()
710: {
711: cond_stack->data.cond.after_label = gen_label_rtx ();
712: if (cond_stack->exit_label != 0)
713: cond_stack->exit_label = cond_stack->data.cond.after_label;
714: emit_jump (cond_stack->data.cond.after_label);
715: if (cond_stack->data.cond.else_label)
716: emit_label (cond_stack->data.cond.else_label);
717: }
718:
719: /* Generate RTL for the end of an if-then-else.
720: Pop the record for it off of cond_stack. */
721:
722: void
723: expand_end_else ()
724: {
725: struct nesting *thiscond = cond_stack;
726:
727: do_pending_stack_adjust ();
728: /* Note: a syntax error can cause this to be called
729: without first calling `expand_start_else'. */
730: if (thiscond->data.cond.after_label)
731: emit_label (thiscond->data.cond.after_label);
732:
733: POPSTACK (cond_stack);
734: last_expr_type = 0;
735: }
736:
737: /* Generate RTL for the start of a loop. EXIT_FLAG is nonzero if this
738: loop should be exited by `exit_something'. This is a loop for which
739: `expand_continue' will jump to the top of the loop.
740:
741: Make an entry on loop_stack to record the labels associated with
742: this loop. */
743:
744: void
745: expand_start_loop (exit_flag)
746: int exit_flag;
747: {
748: register struct nesting *thisloop
749: = (struct nesting *) xmalloc (sizeof (struct nesting));
750:
751: /* Make an entry on loop_stack for the loop we are entering. */
752:
753: thisloop->next = loop_stack;
754: thisloop->all = nesting_stack;
755: thisloop->depth = ++nesting_depth;
756: thisloop->data.loop.start_label = gen_label_rtx ();
757: thisloop->data.loop.end_label = gen_label_rtx ();
758: thisloop->data.loop.continue_label = thisloop->data.loop.start_label;
759: thisloop->exit_label = exit_flag ? thisloop->data.loop.end_label : 0;
760: loop_stack = thisloop;
761: nesting_stack = thisloop;
762:
763: do_pending_stack_adjust ();
764: emit_queue ();
765: emit_note (0, NOTE_INSN_LOOP_BEG);
766: emit_label (thisloop->data.loop.start_label);
767: }
768:
769: /* Like expand_start_loop but for a loop where the continuation point
770: (for expand_continue_loop) will be specified explicitly. */
771:
772: void
773: expand_start_loop_continue_elsewhere (exit_flag)
774: int exit_flag;
775: {
776: expand_start_loop (exit_flag);
777: loop_stack->data.loop.continue_label = gen_label_rtx ();
778: }
779:
780: /* Specify the continuation point for a loop started with
781: expand_start_loop_continue_elsewhere.
782: Use this at the point in the code to which a continue statement
783: should jump. */
784:
785: void
786: expand_loop_continue_here ()
787: {
788: do_pending_stack_adjust ();
789: emit_label (loop_stack->data.loop.continue_label);
790: }
791:
792: /* Finish a loop. Generate a jump back to the top and the loop-exit label.
793: Pop the block off of loop_stack. */
794:
795: void
796: expand_end_loop ()
797: {
798: register struct nesting *thisloop = loop_stack;
799: register rtx insn = get_last_insn ();
800: register rtx start_label = loop_stack->data.loop.start_label;
801:
802: do_pending_stack_adjust ();
803:
804: /* If optimizing, perhaps reorder the loop. If the loop
805: starts with a conditional exit, roll that to the end
806: where it will optimize together with the jump back. */
807: if (optimize
808: &&
809: ! (GET_CODE (insn) == JUMP_INSN
810: && GET_CODE (PATTERN (insn)) == SET
811: && SET_DEST (PATTERN (insn)) == pc_rtx
812: && GET_CODE (SET_SRC (PATTERN (insn))) == IF_THEN_ELSE))
813: {
814: /* Scan insns from the top of the loop looking for a qualified
815: conditional exit. */
816: for (insn = loop_stack->data.loop.start_label; insn; insn= NEXT_INSN (insn))
817: if (GET_CODE (insn) == JUMP_INSN && GET_CODE (PATTERN (insn)) == SET
818: && SET_DEST (PATTERN (insn)) == pc_rtx
819: && GET_CODE (SET_SRC (PATTERN (insn))) == IF_THEN_ELSE
820: &&
821: ((GET_CODE (XEXP (SET_SRC (PATTERN (insn)), 1)) == LABEL_REF
822: && (XEXP (XEXP (SET_SRC (PATTERN (insn)), 1), 0)
823: == loop_stack->data.loop.end_label))
824: ||
825: (GET_CODE (XEXP (SET_SRC (PATTERN (insn)), 2)) == LABEL_REF
826: && (XEXP (XEXP (SET_SRC (PATTERN (insn)), 2), 0)
827: == loop_stack->data.loop.end_label))))
828: break;
829: if (insn != 0)
830: {
831: /* We found one. Move everything from there up
832: to the end of the loop, and add a jump into the loop
833: to jump to there. */
834: register rtx newstart_label = gen_label_rtx ();
835:
836: emit_label_after (newstart_label, PREV_INSN (start_label));
837: reorder_insns (start_label, insn, get_last_insn ());
838: emit_jump_insn_after (gen_jump (start_label), PREV_INSN (newstart_label));
839: emit_barrier_after (PREV_INSN (newstart_label));
840: start_label = newstart_label;
841: }
842: }
843:
844: emit_jump (start_label);
845: emit_note (0, NOTE_INSN_LOOP_END);
846: emit_label (loop_stack->data.loop.end_label);
847:
848: POPSTACK (loop_stack);
849:
850: last_expr_type = 0;
851: }
852:
853: /* Generate a jump to the current loop's continue-point.
854: This is usually the top of the loop, but may be specified
855: explicitly elsewhere. If not currently inside a loop,
856: return 0 and do nothing; caller will print an error message. */
857:
858: int
859: expand_continue_loop ()
860: {
861: last_expr_type = 0;
862: if (loop_stack == 0)
863: return 0;
864: emit_jump (loop_stack->data.loop.continue_label);
865: return 1;
866: }
867:
868: /* Generate a jump to exit the current loop. If not currently inside a loop,
869: return 0 and do nothing; caller will print an error message. */
870:
871: int
872: expand_exit_loop ()
873: {
874: last_expr_type = 0;
875: if (loop_stack == 0)
876: return 0;
877: emit_jump (loop_stack->data.loop.end_label);
878: return 1;
879: }
880:
881: /* Generate a conditional jump to exit the current loop if COND
882: evaluates to zero. If not currently inside a loop,
883: return 0 and do nothing; caller will print an error message. */
884:
885: int
886: expand_exit_loop_if_false (cond)
887: tree cond;
888: {
889: last_expr_type = 0;
890: if (loop_stack == 0)
891: return 0;
892: do_jump (cond, loop_stack->data.loop.end_label, NULL);
893: return 1;
894: }
895:
896: /* Generate a jump to exit the current loop, conditional, binding contour
897: or case statement. Not all such constructs are visible to this function,
898: only those started with EXIT_FLAG nonzero. Individual languages use
899: the EXIT_FLAG parameter to control which kinds of constructs you can
900: exit this way.
901:
902: If not currently inside anything that can be exited,
903: return 0 and do nothing; caller will print an error message. */
904:
905: int
906: expand_exit_something ()
907: {
908: struct nesting *n;
909: last_expr_type = 0;
910: for (n = nesting_stack; n; n = n->all)
911: {
912: if (n->exit_label != 0)
913: {
914: emit_jump (n->exit_label);
915: return 1;
916: }
917: }
918: return 0;
919: }
920:
921: /* Generate RTL to return from the current function, with no value.
922: (That is, we do not do anything about returning any value.) */
923:
924: void
925: expand_null_return ()
926: {
927: clear_pending_stack_adjust ();
928: #ifdef FUNCTION_EPILOGUE
929: emit_jump (return_label);
930: #else
931: emit_jump_insn (gen_return ());
932: emit_barrier ();
933: #endif
934: last_expr_type = 0;
935: }
936:
937: /* Generate RTL to evaluate the expression RETVAL and return it
938: from the current function. */
939:
940: void
941: expand_return (retval)
942: tree retval;
943: {
944: register rtx val = 0;
945: register rtx op0;
946: int really_for_value =
947: (TREE_CODE (retval) == MODIFY_EXPR
948: && TREE_CODE (TREE_OPERAND (retval, 0)) == RESULT_DECL);
949:
950: /* For tail-recursive call to current function,
951: just jump back to the beginning.
952: It's unsafe if any auto variable in this function
953: has its address taken; for simplicity,
954: require stack frame to be empty. */
955: if (optimize && really_for_value
956: && frame_offset == STARTING_FRAME_OFFSET
957: && TREE_CODE (TREE_OPERAND (retval, 1)) == CALL_EXPR
958: && TREE_CODE (TREE_OPERAND (TREE_OPERAND (retval, 1), 0)) == ADDR_EXPR
959: && TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (retval, 1), 0), 0) == this_function
960: /* Finish checking validity, and if valid emit code
961: to set the argument variables for the new call. */
962: && tail_recursion_args (TREE_OPERAND (TREE_OPERAND (retval, 1), 1),
963: DECL_ARGUMENTS (this_function)))
964: {
965: ;
966: if (tail_recursion_label == 0)
967: {
968: tail_recursion_label = gen_label_rtx ();
969: emit_label_after (tail_recursion_label,
970: tail_recursion_reentry);
971: }
972: emit_jump (tail_recursion_label);
973: emit_barrier ();
974: return;
975: }
976: #ifndef FUNCTION_EPILOGUE
977: /* If this is return x == y; then generate
978: if (x == y) return 1; else return 0;
979: if we can do it with explicit return insns. */
980: if (really_for_value)
981: switch (TREE_CODE (TREE_OPERAND (retval, 1)))
982: {
983: case EQ_EXPR:
984: case NE_EXPR:
985: case GT_EXPR:
986: case GE_EXPR:
987: case LT_EXPR:
988: case LE_EXPR:
989: case TRUTH_ANDIF_EXPR:
990: case TRUTH_ORIF_EXPR:
991: case TRUTH_NOT_EXPR:
992: op0 = gen_label_rtx ();
993: val = DECL_RTL (DECL_RESULT (this_function));
994: jumpifnot (TREE_OPERAND (retval, 1), op0);
995: emit_move_insn (val, const1_rtx);
996: emit_insn (gen_rtx (USE, VOIDmode, val));
997: expand_null_return ();
998: emit_label (op0);
999: emit_move_insn (val, const0_rtx);
1000: emit_insn (gen_rtx (USE, VOIDmode, val));
1001: expand_null_return ();
1002: return;
1003: }
1004: #endif
1005: val = expand_expr (retval, 0, VOIDmode, 0);
1006: emit_queue ();
1007:
1008: if (really_for_value && GET_CODE (val) == REG)
1009: emit_insn (gen_rtx (USE, VOIDmode, val));
1010:
1011: expand_null_return ();
1012: }
1013:
1014: /* Return 1 if the end of the generated RTX is not a barrier.
1015: This means code already compiled can drop through. */
1016:
1017: int
1018: drop_through_at_end_p ()
1019: {
1020: rtx insn = get_last_insn ();
1021: while (insn && GET_CODE (insn) == NOTE)
1022: insn = PREV_INSN (insn);
1023: return insn && GET_CODE (insn) != BARRIER;
1024: }
1025:
1026: /* Emit code to alter this function's formal parms for a tail-recursive call.
1027: ACTUALS is a list of actual parameter expressions (chain of TREE_LISTs).
1028: FORMALS is the chain of decls of formals.
1029: Return 1 if this can be done;
1030: otherwise return 0 and do not emit any code. */
1031:
1032: static int
1033: tail_recursion_args (actuals, formals)
1034: tree actuals, formals;
1035: {
1036: register tree a = actuals, f = formals;
1037: register int i;
1038: register rtx *argvec;
1039:
1040: /* Check that number and types of actuals are compatible
1041: with the formals. This is not always true in valid C code.
1042: Also check that no formal needs to be addressable
1043: and that all formals are scalars. */
1044:
1045: /* Also count the args. */
1046:
1047: for (a = actuals, f = formals, i = 0; a && f; a = TREE_CHAIN (a), f = TREE_CHAIN (f), i++)
1048: {
1049: if (TREE_TYPE (TREE_VALUE (a)) != TREE_TYPE (f))
1050: return 0;
1051: if (GET_CODE (DECL_RTL (f)) != REG || DECL_MODE (f) == BLKmode)
1052: return 0;
1053: }
1054: if (a != 0 || f != 0)
1055: return 0;
1056:
1057: /* Compute all the actuals. */
1058:
1059: argvec = (rtx *) alloca (i * sizeof (rtx));
1060:
1061: for (a = actuals, i = 0; a; a = TREE_CHAIN (a), i++)
1062: argvec[i] = expand_expr (TREE_VALUE (a), 0, VOIDmode, 0);
1063:
1064: /* Find which actual values refer to current values of previous formals.
1065: Copy each of them now, before any formal is changed. */
1066:
1067: for (a = actuals, i = 0; a; a = TREE_CHAIN (a), i++)
1068: {
1069: int copy = 0;
1070: register int j;
1071: for (f = formals, j = 0; j < i; f = TREE_CHAIN (f), j++)
1072: if (reg_mentioned_p (DECL_RTL (f), argvec[i]))
1073: { copy = 1; break; }
1074: if (copy)
1075: argvec[i] = copy_to_reg (argvec[i]);
1076: }
1077:
1078: /* Store the values of the actuals into the formals. */
1079:
1080: for (f = formals, a = actuals, i = 0; f;
1081: f = TREE_CHAIN (f), a = TREE_CHAIN (a), i++)
1082: {
1083: if (DECL_MODE (f) == GET_MODE (argvec[i]))
1084: emit_move_insn (DECL_RTL (f), argvec[i]);
1085: else
1086: convert_move (DECL_RTL (f), argvec[i],
1087: TREE_UNSIGNED (TREE_TYPE (TREE_VALUE (a))));
1088: }
1089:
1090: return 1;
1091: }
1092:
1093: /* Generate the RTL code for entering a binding contour.
1094: The variables are declared one by one, by calls to `expand_decl'.
1095:
1096: EXIT_FLAG is nonzero if this construct should be visible to
1097: `exit_something'. */
1098:
1099: void
1100: expand_start_bindings (exit_flag)
1101: int exit_flag;
1102: {
1103: struct nesting *thisblock
1104: = (struct nesting *) xmalloc (sizeof (struct nesting));
1105:
1106: rtx note = emit_note (0, NOTE_INSN_BLOCK_BEG);
1107:
1108: /* Make an entry on block_stack for the block we are entering. */
1109:
1110: thisblock->next = block_stack;
1111: thisblock->all = nesting_stack;
1112: thisblock->depth = ++nesting_depth;
1113: thisblock->data.block.stack_level = 0;
1114: thisblock->data.block.label_chain = 0;
1115: thisblock->data.block.innermost_stack_block = stack_block_stack;
1116: thisblock->data.block.first_insn = note;
1117: thisblock->exit_label = exit_flag ? gen_label_rtx () : 0;
1118: block_stack = thisblock;
1119: nesting_stack = thisblock;
1120: }
1121:
1122: /* Output a USE for any register use in RTL.
1123: This is used with -noreg to mark the extent of lifespan
1124: of any registers used in a user-visible variable's DECL_RTL. */
1125:
1126: static void
1127: use_variable (rtl)
1128: rtx rtl;
1129: {
1130: if (GET_CODE (rtl) == REG)
1131: /* This is a register variable. */
1132: emit_insn (gen_rtx (USE, VOIDmode, rtl));
1133: else if (GET_CODE (rtl) == MEM
1134: && GET_CODE (XEXP (rtl, 0)) == REG
1135: && XEXP (rtl, 0) != frame_pointer_rtx
1136: && XEXP (rtl, 0) != arg_pointer_rtx)
1137: /* This is a variable-sized structure. */
1138: emit_insn (gen_rtx (USE, VOIDmode, XEXP (rtl, 0)));
1139: }
1140:
1141: /* Generate RTL code to terminate a binding contour.
1142: VARS is the chain of VAR_DECL nodes
1143: for the variables bound in this contour.
1144: MARK_ENDs is nonzero if we should put a note at the beginning
1145: and end of this binding contour. */
1146:
1147: void
1148: expand_end_bindings (vars, mark_ends)
1149: tree vars;
1150: int mark_ends;
1151: {
1152: register struct nesting *thisblock = block_stack;
1153: register tree decl;
1154:
1155: /* Mark the beginning and end of the scope if requested. */
1156:
1157: if (mark_ends)
1158: emit_note (0, NOTE_INSN_BLOCK_END);
1159: else
1160: /* Get rid of the beginning-mark if we don't make an end-mark. */
1161: NOTE_LINE_NUMBER (thisblock->data.block.first_insn) = NOTE_INSN_DELETED;
1162:
1163: if (thisblock->exit_label)
1164: {
1165: do_pending_stack_adjust ();
1166: emit_label (thisblock->exit_label);
1167: }
1168:
1169: /* Restore stack level in effect before the block
1170: (only if variable-size objects allocated). */
1171:
1172: if (thisblock->data.block.stack_level != 0)
1173: {
1174: struct label_chain *chain;
1175:
1176: do_pending_stack_adjust ();
1177: emit_move_insn (stack_pointer_rtx,
1178: thisblock->data.block.stack_level);
1179:
1180: /* Any labels in this block are no longer valid to go to.
1181: Mark them to cause an error message. */
1182: for (chain = thisblock->data.block.label_chain; chain; chain = chain->next)
1183: {
1184: TREE_PACKED (chain->label) = 1;
1185: /* If any goto without a fixup came to this label,
1186: that must be an error, because gotos without fixups
1187: come from outside all saved stack-levels. */
1188: if (TREE_ADDRESSABLE (chain->label))
1189: error_with_file_and_line (DECL_SOURCE_FILE (chain->label),
1190: DECL_SOURCE_LINE (chain->label),
1191: "label \"%s\" was used \
1192: before containing binding contour",
1193: IDENTIFIER_POINTER (DECL_NAME (chain->label)));
1194: }
1195:
1196: /* Any gotos out of this block must also restore the stack level.
1197: Also report any gotos with fixups that came to labels in this level. */
1198: fixup_gotos (thisblock->data.block.stack_level,
1199: thisblock->data.block.first_insn);
1200: }
1201:
1202: /* If doing stupid register allocation, make sure lives of all
1203: register variables declared here extend thru end of scope. */
1204:
1205: if (obey_regdecls)
1206: for (decl = vars; decl; decl = TREE_CHAIN (decl))
1207: {
1208: rtx rtl = DECL_RTL (decl);
1209: if (TREE_CODE (decl) == VAR_DECL && rtl != 0)
1210: use_variable (rtl);
1211: }
1212:
1213: /* Restore block_stack level for containing block. */
1214:
1215: stack_block_stack = thisblock->data.block.innermost_stack_block;
1216: POPSTACK (block_stack);
1217: }
1218:
1219: /* Generate RTL for the automatic variable declaration DECL.
1220: (Other kinds of declarations are simply ignored.) */
1221:
1222: void
1223: expand_decl (decl)
1224: register tree decl;
1225: {
1226: struct nesting *thisblock = block_stack;
1227: tree type = TREE_TYPE (decl);
1228:
1229: /* External function declarations are supposed to have been
1230: handled in assemble_variable. Verify this. */
1231: if (TREE_CODE (decl) == FUNCTION_DECL)
1232: {
1233: if (DECL_RTL (decl) == 0)
1234: abort ();
1235: return;
1236: }
1237:
1238: /* Aside from that, only automatic variables need any expansion done.
1239: Static and external variables were handled by `assemble_variable'
1240: (called from finish_decl). TYPE_DECL and CONST_DECL require nothing;
1241: PARM_DECLs are handled in `assign_parms'. */
1242:
1243: if (TREE_CODE (decl) != VAR_DECL)
1244: return;
1245: if (TREE_STATIC (decl) || TREE_EXTERNAL (decl))
1246: return;
1247:
1248: /* Create the RTL representation for the variable. */
1249:
1250: if (type == error_mark_node)
1251: DECL_RTL (decl) = gen_rtx (MEM, BLKmode, const0_rtx);
1252: else if (DECL_MODE (decl) != BLKmode
1253: /* If -ffloat-store, don't put explicit float vars
1254: into regs. */
1255: && !(flag_float_store
1256: && TREE_CODE (type) == REAL_TYPE)
1257: && ! TREE_VOLATILE (decl)
1258: && ! TREE_ADDRESSABLE (decl)
1259: && (TREE_REGDECL (decl) || ! obey_regdecls))
1260: {
1261: /* Automatic variable that can go in a register. */
1262: DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl));
1263: if (TREE_CODE (type) == POINTER_TYPE)
1264: mark_reg_pointer (DECL_RTL (decl));
1265: DECL_RTL (decl)->volatil = 1;
1266: }
1267: else if (DECL_SIZE (decl) == 0)
1268: /* Variable with incomplete type. */
1269: /* Error message was already done; now avoid a crash. */
1270: DECL_RTL (decl) = assign_stack_local (DECL_MODE (decl), 0);
1271: else if (TREE_LITERAL (DECL_SIZE (decl)))
1272: {
1273: /* Variable of fixed size that goes on the stack. */
1274: DECL_RTL (decl)
1275: = assign_stack_local (DECL_MODE (decl),
1276: (TREE_INT_CST_LOW (DECL_SIZE (decl))
1277: * DECL_SIZE_UNIT (decl)
1278: + BITS_PER_UNIT - 1)
1279: / BITS_PER_UNIT);
1280: /* If this is a memory ref that contains aggregate components,
1281: mark it as such for cse and loop optimize. */
1282: DECL_RTL (decl)->in_struct
1283: = (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
1284: || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
1285: || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE);
1286: }
1287: else
1288: /* Dynamic-size object: must push space on the stack. */
1289: {
1290: rtx address, size;
1291:
1292: frame_pointer_needed = 1;
1293:
1294: /* Record the stack pointer on entry to block, if have
1295: not already done so. */
1296: if (thisblock->data.block.stack_level == 0)
1297: {
1298: do_pending_stack_adjust ();
1299: thisblock->data.block.stack_level
1300: = copy_to_reg (stack_pointer_rtx);
1301: stack_block_stack = thisblock;
1302: }
1303:
1304: /* Compute the variable's size, in bytes. */
1305: size = expand_expr (convert_units (DECL_SIZE (decl),
1306: DECL_SIZE_UNIT (decl),
1307: BITS_PER_UNIT),
1308: 0, VOIDmode, 0);
1309:
1310: /* Round it up to this machine's required stack boundary. */
1311: #ifdef STACK_BOUNDARY
1312: /* Avoid extra code if we can prove it's a multiple already. */
1313: if (DECL_SIZE_UNIT (decl) % STACK_BOUNDARY)
1314: size = round_push (size);
1315: #endif
1316:
1317: /* Make space on the stack, and get an rtx for the address of it. */
1318: #ifdef STACK_GROWS_DOWNWARD
1319: anti_adjust_stack (size);
1320: #endif
1321: address = copy_to_reg (stack_pointer_rtx);
1322: #ifndef STACK_GROWS_DOWNWARD
1323: anti_adjust_stack (size);
1324: #endif
1325:
1326: /* Reference the variable indirect through that rtx. */
1327: DECL_RTL (decl) = gen_rtx (MEM, DECL_MODE (decl), address);
1328: }
1329:
1330: if (TREE_VOLATILE (decl))
1331: DECL_RTL (decl)->volatil = 1;
1332: if (TREE_READONLY (decl))
1333: DECL_RTL (decl)->unchanging = 1;
1334:
1335: /* If doing stupid register allocation, make sure life of any
1336: register variable starts here, at the start of its scope. */
1337:
1338: if (obey_regdecls
1339: && TREE_CODE (decl) == VAR_DECL
1340: && DECL_RTL (decl) != 0)
1341: use_variable (DECL_RTL (decl));
1342:
1343: /* Compute and store the initial value now. */
1344:
1345: if (DECL_INITIAL (decl) == error_mark_node)
1346: {
1347: enum tree_code code = TREE_CODE (TREE_TYPE (decl));
1348: if (code == INTEGER_TYPE || code == REAL_TYPE || code == ENUMERAL_TYPE
1349: || code == POINTER_TYPE)
1350: expand_assignment (decl, convert (TREE_TYPE (decl), integer_zero_node),
1351: 0, 0);
1352: emit_queue ();
1353: }
1354: else if (DECL_INITIAL (decl))
1355: {
1356: emit_note (DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
1357: expand_assignment (decl, DECL_INITIAL (decl), 0, 0);
1358: emit_queue ();
1359: }
1360: }
1361:
1362: /* Enter a case (Pascal) or switch (C) statement.
1363: Push a block onto case_stack and nesting_stack
1364: to accumulate the case-labels that are seen
1365: and to record the labels generated for the statement.
1366:
1367: EXIT_FLAG is nonzero if `exit_something' should exit this case stmt.
1368: Otherwise, this construct is transparent for `exit_something'.
1369:
1370: EXPR is the index-expression to be dispatched on.
1371: TYPE is its nominal type. We could simply convert EXPR to this type,
1372: but instead we take short cuts. */
1373:
1374: void
1375: expand_start_case (exit_flag, expr, type)
1376: int exit_flag;
1377: tree expr;
1378: tree type;
1379: {
1380: register struct nesting *thiscase
1381: = (struct nesting *) xmalloc (sizeof (struct nesting));
1382:
1383: /* Make an entry on case_stack for the case we are entering. */
1384:
1385: thiscase->next = case_stack;
1386: thiscase->all = nesting_stack;
1387: thiscase->depth = ++nesting_depth;
1388: thiscase->exit_label = exit_flag ? gen_label_rtx () : 0;
1389: thiscase->data.case_stmt.case_list = 0;
1390: thiscase->data.case_stmt.index_expr = expr;
1391: thiscase->data.case_stmt.nominal_type = type;
1392: case_stack = thiscase;
1393: nesting_stack = thiscase;
1394:
1395: do_pending_stack_adjust ();
1396:
1397: thiscase->data.case_stmt.start = get_last_insn ();
1398: }
1399:
1400: /* Start a "dummy case statement" within which case labels are invalid
1401: and are not connected to any larger real case statement.
1402: This can be used if you don't want to let a case statement jump
1403: into the middle of certain kinds of constructs. */
1404:
1405: void
1406: expand_start_case_dummy ()
1407: {
1408: register struct nesting *thiscase
1409: = (struct nesting *) xmalloc (sizeof (struct nesting));
1410:
1411: /* Make an entry on case_stack for the dummy. */
1412:
1413: thiscase->next = case_stack;
1414: thiscase->all = nesting_stack;
1415: thiscase->depth = ++nesting_depth;
1416: thiscase->exit_label = 0;
1417: thiscase->data.case_stmt.case_list = 0;
1418: thiscase->data.case_stmt.start = 0;
1419: thiscase->data.case_stmt.nominal_type = 0;
1420: case_stack = thiscase;
1421: nesting_stack = thiscase;
1422: }
1423:
1424: /* End a dummy case statement. */
1425:
1426: void
1427: expand_end_case_dummy ()
1428: {
1429: POPSTACK (case_stack);
1430: }
1431:
1432: /* Accumulate one case or default label inside a case or switch statement.
1433: VALUE is the value of the case (a null pointer, for a default label).
1434:
1435: If not currently inside a case or switch statement, return 1 and do
1436: nothing. The caller will print a language-specific error message.
1437: If VALUE is a duplicate, return 2 and do nothing.
1438: If VALUE is out of range, return 3 and do nothing.
1439: Return 0 on success. */
1440:
1441: int
1442: pushcase (value, label)
1443: register tree value;
1444: register tree label;
1445: {
1446: register tree l;
1447: tree index_type;
1448: tree nominal_type;
1449:
1450: /* Fail if not inside a real case statement. */
1451: if (! (case_stack && case_stack->data.case_stmt.start))
1452: return 1;
1453:
1454: index_type = TREE_TYPE (case_stack->data.case_stmt.index_expr);
1455: nominal_type = case_stack->data.case_stmt.nominal_type;
1456:
1457: /* If the index is erroneous, avoid more problems: pretend to succeed. */
1458: if (index_type == error_mark_node)
1459: return 0;
1460:
1461: /* Convert VALUE to the type in which the comparisons are nominally done. */
1462: if (value != 0)
1463: value = convert (nominal_type, value);
1464:
1465: /* Fail if this is a duplicate entry. */
1466: for (l = case_stack->data.case_stmt.case_list; l; l = TREE_CHAIN (l))
1467: {
1468: if (value == 0 && TREE_PURPOSE (l) == 0)
1469: return 2;
1470: if (value != 0 && TREE_PURPOSE (l)
1471: && (TREE_INT_CST_LOW (value)
1472: == TREE_INT_CST_LOW (TREE_PURPOSE (l)))
1473: && (TREE_INT_CST_HIGH (value)
1474: == TREE_INT_CST_HIGH (TREE_PURPOSE (l))))
1475: return 2;
1476: }
1477:
1478: /* Fail if this value is out of range for the actual type of the index
1479: (which may be narrower than NOMINAL_TYPE). */
1480: if (value != 0 && ! int_fits_type_p (value, index_type))
1481: return 3;
1482:
1483: /* Add this label to the list, and succeed.
1484: Copy VALUE so it is temporary rather than momentary. */
1485: case_stack->data.case_stmt.case_list
1486: = tree_cons (value ? copy_node (value) : 0, label,
1487: case_stack->data.case_stmt.case_list);
1488: expand_label (label);
1489: return 0;
1490: }
1491:
1492: /* Terminate a case (Pascal) or switch (C) statement
1493: in which CASE_INDEX is the expression to be tested.
1494: Generate the code to test it and jump to the right place. */
1495:
1496: void
1497: expand_end_case ()
1498: {
1499: tree minval, maxval, range;
1500: rtx default_label = 0;
1501: register tree elt;
1502: register tree c;
1503: int count;
1504: rtx index;
1505: rtx table_label = gen_label_rtx ();
1506: int ncases;
1507: rtx *labelvec;
1508: register int i;
1509: rtx before_case;
1510: register struct nesting *thiscase = case_stack;
1511: tree index_expr = thiscase->data.case_stmt.index_expr;
1512:
1513: do_pending_stack_adjust ();
1514:
1515: /* This happens for various reasons including invalid data type. */
1516: if (index_expr != error_mark_node)
1517: {
1518: /* If we don't have a default-label, create one here,
1519: after the body of the switch. */
1520: for (c = thiscase->data.case_stmt.case_list; c; c = TREE_CHAIN (c))
1521: if (TREE_PURPOSE (c) == 0)
1522: break;
1523: if (c == 0)
1524: pushcase (0, build_decl (LABEL_DECL, NULL_TREE, NULL_TREE));
1525:
1526: before_case = get_last_insn ();
1527:
1528: /* Get upper and lower bounds of case values.
1529: Also convert all the case values to the index expr's data type. */
1530: count = 0;
1531: for (c = thiscase->data.case_stmt.case_list; c; c = TREE_CHAIN (c))
1532: if (elt = TREE_PURPOSE (c))
1533: {
1534: /* Note that in Pascal it will be possible
1535: to have a RANGE_EXPR here as long as both
1536: ends of the range are constant.
1537: It will be necessary to extend this function
1538: to handle them. */
1539: if (TREE_CODE (elt) != INTEGER_CST)
1540: abort ();
1541:
1542: TREE_PURPOSE (c) = elt = convert (TREE_TYPE (index_expr), elt);
1543:
1544: /* Count the elements and track the largest and
1545: smallest of them
1546: (treating them as signed even if they are not). */
1547: if (count++ == 0)
1548: {
1549: minval = maxval = elt;
1550: }
1551: else
1552: {
1553: if (INT_CST_LT (elt, minval))
1554: minval = elt;
1555: if (INT_CST_LT (maxval, elt))
1556: maxval = elt;
1557: }
1558: }
1559: else
1560: default_label = label_rtx (TREE_VALUE (c));
1561:
1562: if (default_label == 0)
1563: abort ();
1564:
1565: /* Compute span of values. */
1566: if (count != 0)
1567: range = combine (MINUS_EXPR, maxval, minval);
1568:
1569: if (count == 0 || TREE_CODE (TREE_TYPE (index_expr)) == ERROR_MARK)
1570: {
1571: expand_expr (index_expr, const0_rtx, VOIDmode, 0);
1572: emit_queue ();
1573: emit_jump (default_label);
1574: }
1575: /* If range of values is much bigger than number of values,
1576: make a sequence of conditional branches instead of a dispatch.
1577: If the switch-index is a constant, do it this way
1578: because we can optimize it. */
1579: else if (TREE_INT_CST_HIGH (range) != 0
1580: #ifdef HAVE_casesi
1581: || count < 4
1582: #else
1583: /* If machine does not have a case insn that compares the
1584: bounds, this means extra overhead for dispatch tables
1585: which raises the threshold for using them. */
1586: || count < 5
1587: #endif
1588: || (unsigned) (TREE_INT_CST_LOW (range)) > 10 * count
1589: || TREE_CODE (index_expr) == INTEGER_CST)
1590: {
1591: index = expand_expr (index_expr, 0, VOIDmode, 0);
1592: emit_queue ();
1593:
1594: index = protect_from_queue (index, 0);
1595: if (GET_CODE (index) == MEM)
1596: index = copy_to_reg (index);
1597: do_pending_stack_adjust ();
1598:
1599: for (c = thiscase->data.case_stmt.case_list; c; c = TREE_CHAIN (c))
1600: {
1601: elt = TREE_PURPOSE (c);
1602: if (elt && TREE_VALUE (c))
1603: do_jump_if_equal (expand_expr (elt, 0, VOIDmode, 0), index,
1604: label_rtx (TREE_VALUE (c)));
1605: }
1606:
1607: emit_jump (default_label);
1608: }
1609: else
1610: {
1611: #ifdef HAVE_casesi
1612: /* Convert the index to SImode. */
1613: if (TYPE_MODE (TREE_TYPE (index_expr)) == DImode)
1614: {
1615: index_expr = build (MINUS_EXPR, TREE_TYPE (index_expr),
1616: index_expr, minval);
1617: minval = integer_zero_node;
1618: }
1619: if (TYPE_MODE (TREE_TYPE (index_expr)) != SImode)
1620: index_expr = convert (type_for_size (GET_MODE_BITSIZE (SImode), 0),
1621: index_expr);
1622: index = expand_expr (index_expr, 0, VOIDmode, 0);
1623: emit_queue ();
1624: index = protect_from_queue (index, 0);
1625: do_pending_stack_adjust ();
1626:
1627: emit_jump_insn (gen_casesi (index, expand_expr (minval, 0, VOIDmode, 0),
1628: expand_expr (range, 0, VOIDmode, 0),
1629: table_label, default_label));
1630: #else
1631: #ifdef HAVE_tablejump
1632: index_expr = convert (type_for_size (GET_MODE_BITSIZE (SImode), 0),
1633: build (MINUS_EXPR, TREE_TYPE (index_expr),
1634: index_expr, minval));
1635: index = expand_expr (index_expr, 0, VOIDmode, 0);
1636: emit_queue ();
1637: index = protect_from_queue (index, 0);
1638: do_pending_stack_adjust ();
1639:
1640: do_tablejump (index,
1641: gen_rtx (CONST_INT, VOIDmode, TREE_INT_CST_LOW (range)),
1642: table_label, default_label);
1643: #else
1644: lossage;
1645: #endif /* not HAVE_tablejump */
1646: #endif /* not HAVE_casesi */
1647:
1648: /* Get table of labels to jump to, in order of case index. */
1649:
1650: ncases = TREE_INT_CST_LOW (range) + 1;
1651: labelvec = (rtx *) alloca (ncases * sizeof (rtx));
1652: bzero (labelvec, ncases * sizeof (rtx));
1653:
1654: for (c = thiscase->data.case_stmt.case_list; c; c = TREE_CHAIN (c))
1655: if (TREE_VALUE (c) && (elt = TREE_PURPOSE (c)))
1656: {
1657: register int i
1658: = TREE_INT_CST_LOW (elt) - TREE_INT_CST_LOW (minval);
1659: labelvec[i]
1660: = gen_rtx (LABEL_REF, Pmode, label_rtx (TREE_VALUE (c)));
1661: }
1662:
1663: /* Fill in the gaps with the default. */
1664: for (i = 0; i < ncases; i++)
1665: if (labelvec[i] == 0)
1666: labelvec[i] = gen_rtx (LABEL_REF, Pmode, default_label);
1667:
1668: /* Output the table */
1669: emit_label (table_label);
1670:
1671: #ifdef CASE_VECTOR_PC_RELATIVE
1672: emit_jump_insn (gen_rtx (ADDR_DIFF_VEC, CASE_VECTOR_MODE,
1673: gen_rtx (LABEL_REF, Pmode, table_label),
1674: gen_rtvec_v (ncases, labelvec)));
1675: #else
1676: emit_jump_insn (gen_rtx (ADDR_VEC, CASE_VECTOR_MODE,
1677: gen_rtvec_v (ncases, labelvec)));
1678: #endif
1679: /* If the case insn drops through the table,
1680: after the table we must jump to the default-label.
1681: Otherwise record no drop-through after the table. */
1682: #ifdef CASE_DROPS_THROUGH
1683: emit_jump (default_label);
1684: #else
1685: emit_barrier ();
1686: #endif
1687: }
1688:
1689: reorder_insns (NEXT_INSN (before_case), get_last_insn (),
1690: thiscase->data.case_stmt.start);
1691: }
1692: if (thiscase->exit_label)
1693: emit_label (thiscase->exit_label);
1694:
1695: POPSTACK (case_stack);
1696: }
1697:
1698: /* Generate code to jump to LABEL if OP1 and OP2 are equal. */
1699: /* ??? This may need an UNSIGNEDP argument to work properly ??? */
1700:
1701: void
1702: do_jump_if_equal (op1, op2, label)
1703: rtx op1, op2, label;
1704: {
1705: if (GET_CODE (op1) == CONST_INT
1706: && GET_CODE (op2) == CONST_INT)
1707: {
1708: if (INTVAL (op1) == INTVAL (op2))
1709: emit_jump (label);
1710: }
1711: else
1712: {
1713: emit_cmp_insn (op1, op2, 0, 0);
1714: emit_jump_insn (gen_beq (label));
1715: }
1716: }
1717:
1718: /* Allocate fixed slots in the stack frame of the current function. */
1719:
1720: /* Return size needed for stack frame based on slots so far allocated. */
1721:
1722: int
1723: get_frame_size ()
1724: {
1725: #ifdef FRAME_GROWS_DOWNWARD
1726: return -frame_offset;
1727: #else
1728: return frame_offset;
1729: #endif
1730: }
1731:
1732: /* Allocate a stack slot of SIZE bytes and return a MEM rtx for it
1733: with machine mode MODE. */
1734:
1735: rtx
1736: assign_stack_local (mode, size)
1737: enum machine_mode mode;
1738: int size;
1739: {
1740: register rtx x, addr;
1741:
1742: frame_pointer_needed = 1;
1743:
1744: /* Make each stack slot a multiple of the main allocation unit. */
1745: size = (((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
1746: / (BIGGEST_ALIGNMENT / BITS_PER_UNIT))
1747: * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1748:
1749: #ifdef FRAME_GROWS_DOWNWARD
1750: frame_offset -= size;
1751: #endif
1752: addr = gen_rtx (PLUS, Pmode, frame_pointer_rtx,
1753: gen_rtx (CONST_INT, VOIDmode, frame_offset));
1754: #ifndef FRAME_GROWS_DOWNWARD
1755: frame_offset += size;
1756: #endif
1757:
1758: if (! memory_address_p (mode, addr))
1759: invalid_stack_slot = 1;
1760:
1761: x = gen_rtx (MEM, mode, addr);
1762:
1763: return x;
1764: }
1765:
1766: /* Retroactively move an auto variable from a register to a stack slot.
1767: This is done when an address-reference to the variable is seen. */
1768:
1769: void
1770: put_var_into_stack (decl)
1771: tree decl;
1772: {
1773: register rtx reg = DECL_RTL (decl);
1774: register rtx new;
1775:
1776: /* No need to do anything if decl has no rtx yet
1777: since in that case caller is setting TREE_ADDRESSABLE
1778: and a stack slot will be assigned when the rtl is made. */
1779: if (reg == 0)
1780: return;
1781: if (GET_CODE (reg) != REG)
1782: return;
1783:
1784: new = parm_stack_loc (reg);
1785: if (new == 0)
1786: new = assign_stack_local (GET_MODE (reg), GET_MODE_SIZE (GET_MODE (reg)));
1787:
1788: /* If this is a memory ref that contains aggregate components,
1789: mark it as such for cse and loop optimize. */
1790: reg->in_struct
1791: = (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
1792: || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
1793: || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE);
1794:
1795: XEXP (reg, 0) = XEXP (new, 0);
1796: PUT_CODE (reg, MEM);
1797: /* `volatil' bit means one thing for MEMs, another entirely for REGs. */
1798: reg->volatil = 0;
1799:
1800: fixup_var_refs (reg);
1801: }
1802:
1803: static void
1804: fixup_var_refs (var)
1805: rtx var;
1806: {
1807: register rtx insn;
1808:
1809: /* Yes. Must scan all insns for stack-refs that exceed the limit. */
1810: for (insn = get_insns (); insn; )
1811: {
1812: rtx next = NEXT_INSN (insn);
1813: if (GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN
1814: || GET_CODE (insn) == JUMP_INSN)
1815: {
1816: /* The insn to load VAR from a home in the arglist
1817: is now a no-op. When we see it, just delete it. */
1818: if (GET_CODE (PATTERN (insn)) == SET
1819: && SET_DEST (PATTERN (insn)) == var
1820: && rtx_equal_p (SET_SRC (PATTERN (insn)), var))
1821: next = delete_insn (insn);
1822: else
1823: fixup_var_refs_1 (var, PATTERN (insn), insn);
1824: }
1825: insn = next;
1826: }
1827: }
1828:
1829: static rtx
1830: fixup_var_refs_1 (var, x, insn)
1831: register rtx var;
1832: register rtx x;
1833: rtx insn;
1834: {
1835: register int i;
1836: RTX_CODE code = GET_CODE (x);
1837: register char *fmt;
1838: register rtx tem;
1839:
1840: switch (code)
1841: {
1842: case MEM:
1843: if (var == x)
1844: {
1845: x = fixup_stack_1 (x, insn);
1846: tem = gen_reg_rtx (GET_MODE (x));
1847: emit_insn_before (gen_move_insn (tem, x), insn);
1848: return tem;
1849: }
1850: break;
1851:
1852: case REG:
1853: case CC0:
1854: case PC:
1855: case CONST_INT:
1856: case CONST:
1857: case SYMBOL_REF:
1858: case LABEL_REF:
1859: case CONST_DOUBLE:
1860: return x;
1861:
1862: case SIGN_EXTRACT:
1863: case ZERO_EXTRACT:
1864: /* Note that in some cases those types of expressions are altered
1865: by optimize_bit_field, and do not survive to get here. */
1866: case SUBREG:
1867: tem = x;
1868: while (GET_CODE (tem) == SUBREG || GET_CODE (tem) == SIGN_EXTRACT
1869: || GET_CODE (tem) == ZERO_EXTRACT)
1870: tem = XEXP (tem, 0);
1871: if (tem == var)
1872: {
1873: x = fixup_stack_1 (x, insn);
1874: tem = gen_reg_rtx (GET_MODE (x));
1875: emit_insn_before (gen_move_insn (tem, x), insn);
1876: return tem;
1877: }
1878: break;
1879:
1880: case SET:
1881: /* First do special simplification of bit-field references. */
1882: if (GET_CODE (SET_DEST (x)) == SIGN_EXTRACT
1883: || GET_CODE (SET_DEST (x)) == ZERO_EXTRACT)
1884: optimize_bit_field (x, insn, 0);
1885: if (GET_CODE (SET_SRC (x)) == SIGN_EXTRACT
1886: || GET_CODE (SET_SRC (x)) == ZERO_EXTRACT)
1887: optimize_bit_field (x, insn, 0);
1888:
1889: {
1890: rtx dest = SET_DEST (x);
1891: rtx src = SET_SRC (x);
1892: rtx outerdest = dest;
1893: rtx outersrc = src;
1894: int strictflag = GET_CODE (dest) == STRICT_LOW_PART;
1895:
1896: while (GET_CODE (dest) == SUBREG || GET_CODE (dest) == STRICT_LOW_PART
1897: || GET_CODE (dest) == SIGN_EXTRACT
1898: || GET_CODE (dest) == ZERO_EXTRACT)
1899: dest = XEXP (dest, 0);
1900: while (GET_CODE (src) == SUBREG
1901: || GET_CODE (src) == SIGN_EXTRACT
1902: || GET_CODE (src) == ZERO_EXTRACT)
1903: src = XEXP (src, 0);
1904:
1905: /* If VAR does not appear at the top level of the SET
1906: just scan the lower levels of the tree. */
1907:
1908: if (src != var && dest != var)
1909: break;
1910:
1911: /* Clean up (SUBREG:SI (MEM:mode ...) 0)
1912: that may appear inside a SIGN_EXTRACT or ZERO_EXTRACT.
1913: This was legitimate when the MEM was a REG. */
1914:
1915: if ((GET_CODE (outerdest) == SIGN_EXTRACT
1916: || GET_CODE (outerdest) == ZERO_EXTRACT)
1917: && GET_CODE (XEXP (outerdest, 0)) == SUBREG
1918: && SUBREG_REG (XEXP (outerdest, 0)) == var)
1919: XEXP (outerdest, 0) = fixup_memory_subreg (XEXP (outerdest, 0));
1920:
1921: if ((GET_CODE (outersrc) == SIGN_EXTRACT
1922: || GET_CODE (outersrc) == ZERO_EXTRACT)
1923: && GET_CODE (XEXP (outersrc, 0)) == SUBREG
1924: && SUBREG_REG (XEXP (outersrc, 0)) == var)
1925: XEXP (outersrc, 0) = fixup_memory_subreg (XEXP (outersrc, 0));
1926:
1927: /* Make sure a MEM inside a SIGN_EXTRACT has QImode
1928: since that's what bit-field insns want. */
1929:
1930: if ((GET_CODE (outerdest) == SIGN_EXTRACT
1931: || GET_CODE (outerdest) == ZERO_EXTRACT)
1932: && GET_CODE (XEXP (outerdest, 0)) == MEM
1933: && GET_MODE (XEXP (outerdest, 0)) != QImode)
1934: {
1935: XEXP (outerdest, 0) = copy_rtx (XEXP (outerdest, 0));
1936: PUT_MODE (XEXP (outerdest, 0), QImode);
1937: }
1938:
1939: if ((GET_CODE (outersrc) == SIGN_EXTRACT
1940: || GET_CODE (outersrc) == ZERO_EXTRACT)
1941: && GET_CODE (XEXP (outersrc, 0)) == MEM
1942: && GET_MODE (XEXP (outersrc, 0)) != QImode)
1943: {
1944: XEXP (outersrc, 0) = copy_rtx (XEXP (outersrc, 0));
1945: PUT_MODE (XEXP (outersrc, 0), QImode);
1946: }
1947:
1948: /* STRICT_LOW_PART is a no-op on memory references
1949: and it can cause combinations to be unrecognizable,
1950: so eliminate it. */
1951:
1952: if (dest == var && GET_CODE (SET_DEST (x)) == STRICT_LOW_PART)
1953: SET_DEST (x) = XEXP (SET_DEST (x), 0);
1954:
1955: /* An insn to copy VAR into or out of a register
1956: must be left alone, to avoid an infinite loop here.
1957: But do fix up the address of VAR's stack slot if nec. */
1958:
1959: if (GET_CODE (SET_SRC (x)) == REG || GET_CODE (SET_DEST (x)) == REG)
1960: return fixup_stack_1 (x, insn);
1961:
1962: if ((GET_CODE (SET_SRC (x)) == SUBREG
1963: && GET_CODE (SUBREG_REG (SET_SRC (x))) == REG)
1964: || (GET_CODE (SET_DEST (x)) == SUBREG
1965: && GET_CODE (SUBREG_REG (SET_DEST (x))) == REG))
1966: return fixup_stack_1 (x, insn);
1967:
1968: /* Otherwise, storing into VAR must be handled specially
1969: by storing into a temporary and copying that into VAR
1970: with a new insn after this one. */
1971:
1972: if (dest == var)
1973: {
1974: rtx temp;
1975: rtx fixeddest;
1976: tem = SET_DEST (x);
1977: if (GET_CODE (tem) == STRICT_LOW_PART)
1978: tem = XEXP (tem, 0);
1979: temp = gen_reg_rtx (GET_MODE (tem));
1980: fixeddest = fixup_stack_1 (SET_DEST (x), insn);
1981: emit_insn_after (gen_move_insn (fixeddest, temp), insn);
1982: SET_DEST (x) = temp;
1983: }
1984: }
1985: }
1986:
1987: /* Nothing special about this RTX; fix its operands. */
1988:
1989: fmt = GET_RTX_FORMAT (code);
1990: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1991: {
1992: if (fmt[i] == 'e')
1993: XEXP (x, i) = fixup_var_refs_1 (var, XEXP (x, i), insn);
1994: if (fmt[i] == 'E')
1995: {
1996: register int j;
1997: for (j = 0; j < XVECLEN (x, i); j++)
1998: XVECEXP (x, i, j)
1999: = fixup_var_refs_1 (var, XVECEXP (x, i, j), insn);
2000: }
2001: }
2002: return x;
2003: }
2004:
2005: /* Given X, an rtx of the form (SUBREG:m1 (MEM:m2 addr)),
2006: return an rtx (MEM:m1 newaddr) which is equivalent. */
2007:
2008: static rtx
2009: fixup_memory_subreg (x)
2010: rtx x;
2011: {
2012: int offset = SUBREG_WORD (x) * UNITS_PER_WORD;
2013: rtx addr = XEXP (SUBREG_REG (x), 0);
2014: enum machine_mode mode = GET_MODE (SUBREG_REG (x));
2015:
2016: #ifdef BYTES_BIG_ENDIAN
2017: offset += (MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode))
2018: - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (x))));
2019: #endif
2020: return change_address (SUBREG_REG (x), mode,
2021: plus_constant (addr, offset));
2022: }
2023:
2024: #if 0
2025: /* Fix up any references to stack slots that are invalid memory addresses
2026: because they exceed the maximum range of a displacement. */
2027:
2028: void
2029: fixup_stack_slots ()
2030: {
2031: register rtx insn;
2032:
2033: /* Did we generate a stack slot that is out of range
2034: or otherwise has an invalid address? */
2035: if (invalid_stack_slot)
2036: {
2037: /* Yes. Must scan all insns for stack-refs that exceed the limit. */
2038: for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
2039: if (GET_CODE (insn) == INSN || GET_CODE (insn) == CALL_INSN
2040: || GET_CODE (insn) == JUMP_INSN)
2041: fixup_stack_1 (PATTERN (insn), insn);
2042: }
2043: }
2044: #endif
2045:
2046: /* For each memory ref within X, if it refers to a stack slot
2047: with an out of range displacement, put the address in a temp register
2048: (emitting new insns before INSN to load these registers)
2049: and alter the memory ref to use that register.
2050: Replace each such MEM rtx with a copy, to avoid clobberage. */
2051:
2052: static rtx
2053: fixup_stack_1 (x, insn)
2054: rtx x;
2055: rtx insn;
2056: {
2057: register int i;
2058: register RTX_CODE code = GET_CODE (x);
2059: register char *fmt;
2060:
2061: if (code == MEM)
2062: {
2063: register rtx ad = XEXP (x, 0);
2064: /* If we have address of a stack slot but it's not valid
2065: (displacement is too large), compute the sum in a register. */
2066: if (GET_CODE (ad) == PLUS
2067: && XEXP (ad, 0) == frame_pointer_rtx
2068: && GET_CODE (XEXP (ad, 1)) == CONST_INT)
2069: {
2070: rtx temp;
2071: if (memory_address_p (GET_MODE (x), ad))
2072: return x;
2073: temp = gen_reg_rtx (GET_MODE (ad));
2074: emit_insn_before (gen_move_insn (temp, ad), insn);
2075: return change_address (x, VOIDmode, temp);
2076: }
2077: return x;
2078: }
2079:
2080: fmt = GET_RTX_FORMAT (code);
2081: for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
2082: {
2083: if (fmt[i] == 'e')
2084: XEXP (x, i) = fixup_stack_1 (XEXP (x, i), insn);
2085: if (fmt[i] == 'E')
2086: {
2087: register int j;
2088: for (j = 0; j < XVECLEN (x, i); j++)
2089: XVECEXP (x, i, j) = fixup_stack_1 (XVECEXP (x, i, j), insn);
2090: }
2091: }
2092: return x;
2093: }
2094:
2095: /* Optimization: a bit-field instruction whose field
2096: happens to be a byte or halfword in memory
2097: can be changed to a move instruction.
2098:
2099: We call here when INSN is an insn to examine or store into a bit-field.
2100: BODY is the SET-rtx to be altered.
2101:
2102: EQUIV_MEM is the table `reg_equiv_mem' if that is available; else 0.
2103: (Currently this is called only from stmt.c, and EQUIV_MEM is always 0.) */
2104:
2105: static void
2106: optimize_bit_field (body, insn, equiv_mem)
2107: rtx body;
2108: rtx insn;
2109: rtx *equiv_mem;
2110: {
2111: register rtx bitfield;
2112: int destflag;
2113:
2114: if (GET_CODE (SET_DEST (body)) == SIGN_EXTRACT
2115: || GET_CODE (SET_DEST (body)) == ZERO_EXTRACT)
2116: bitfield = SET_DEST (body), destflag = 1;
2117: else
2118: bitfield = SET_SRC (body), destflag = 0;
2119:
2120: /* First check that the field being stored has constant size and position
2121: and is in fact a byte or halfword suitably aligned. */
2122:
2123: if (GET_CODE (XEXP (bitfield, 1)) == CONST_INT
2124: && GET_CODE (XEXP (bitfield, 2)) == CONST_INT
2125: && (INTVAL (XEXP (bitfield, 1)) == GET_MODE_BITSIZE (QImode)
2126: || INTVAL (XEXP (bitfield, 1)) == GET_MODE_BITSIZE (HImode))
2127: && INTVAL (XEXP (bitfield, 2)) % INTVAL (XEXP (bitfield, 1)) == 0)
2128: {
2129: register rtx memref = 0;
2130:
2131: /* Now check that the contanting word is memory, not a register,
2132: and that it is safe to change the machine mode and to
2133: add something to the address. */
2134:
2135: if (GET_CODE (XEXP (bitfield, 0)) == MEM)
2136: memref = XEXP (bitfield, 0);
2137: else if (GET_CODE (XEXP (bitfield, 0)) == REG
2138: && equiv_mem != 0
2139: && (memref = equiv_mem[REGNO (XEXP (bitfield, 0))]) != 0)
2140: ;
2141: else if (GET_CODE (XEXP (bitfield, 0)) == SUBREG
2142: && GET_CODE (SUBREG_REG (XEXP (bitfield, 0))) == MEM)
2143: memref = SUBREG_REG (XEXP (bitfield, 0));
2144: else if (GET_CODE (XEXP (bitfield, 0)) == SUBREG
2145: && equiv_mem != 0
2146: && GET_CODE (SUBREG_REG (XEXP (bitfield, 0))) == REG
2147: && (memref = equiv_mem[REGNO (SUBREG_REG (XEXP (bitfield, 0)))]) != 0)
2148: ;
2149:
2150: if (memref
2151: && ! mode_dependent_address_p (XEXP (memref, 0))
2152: && offsetable_address_p (GET_MODE (bitfield), XEXP (memref, 0)))
2153: {
2154: /* Now adjust the address, first for any subreg'ing
2155: that we are now getting rid of,
2156: and then for which byte of the word is wanted. */
2157:
2158: register int offset
2159: = INTVAL (XEXP (bitfield, 2)) / GET_MODE_BITSIZE (QImode);
2160: if (GET_CODE (XEXP (bitfield, 0)) == SUBREG)
2161: {
2162: offset += SUBREG_WORD (XEXP (bitfield, 0)) * UNITS_PER_WORD;
2163: #ifdef BYTES_BIG_ENDIAN
2164: offset -= (MIN (UNITS_PER_WORD,
2165: GET_MODE_SIZE (GET_MODE (XEXP (bitfield, 0))))
2166: - MIN (UNITS_PER_WORD,
2167: GET_MODE_SIZE (GET_MODE (memref))));
2168: #endif
2169: }
2170: memref = gen_rtx (MEM,
2171: (INTVAL (XEXP (bitfield, 1)) == GET_MODE_BITSIZE (QImode)
2172: ? QImode : HImode),
2173: XEXP (memref, 0));
2174:
2175: /* Store this memory reference where
2176: we found the bit field reference. */
2177:
2178: if (destflag)
2179: {
2180: SET_DEST (body)
2181: = adj_offsetable_operand (memref, offset);
2182: if (! CONSTANT_ADDRESS_P (SET_SRC (body)))
2183: {
2184: rtx src = SET_SRC (body);
2185: while (GET_CODE (src) == SUBREG
2186: && SUBREG_WORD (src) == 0)
2187: src = SUBREG_REG (src);
2188: if (GET_MODE (src) != GET_MODE (memref))
2189: src = gen_rtx (SUBREG, GET_MODE (memref),
2190: SET_SRC (body), 0);
2191: SET_SRC (body) = src;
2192: }
2193: else if (GET_MODE (SET_SRC (body)) != VOIDmode
2194: && GET_MODE (SET_SRC (body)) != GET_MODE (memref))
2195: /* This shouldn't happen because anything that didn't have
2196: one of these modes should have got converted explicitly
2197: and then referenced through a subreg.
2198: This is so because the original bit-field was
2199: handled by agg_mode and so its tree structure had
2200: the same mode that memref now has. */
2201: abort ();
2202: }
2203: else
2204: {
2205: rtx newreg = gen_reg_rtx (GET_MODE (SET_DEST (body)));
2206: emit_insn_before (gen_extend_insn (newreg, adj_offsetable_operand (memref, offset),
2207: GET_MODE (SET_DEST (body)),
2208: GET_MODE (memref),
2209: GET_CODE (SET_SRC (body)) == ZERO_EXTRACT),
2210: insn);
2211: SET_SRC (body) = newreg;
2212: }
2213:
2214: /* Cause the insn to be re-recognized. */
2215:
2216: INSN_CODE (insn) = -1;
2217: }
2218: }
2219: }
2220:
2221: /* 1 + last pseudo register number used for loading a copy
2222: of a parameter of this function. */
2223:
2224: static int max_parm_reg;
2225:
2226: /* Vector indexed by REGNO, containing location on stack in which
2227: to put the parm which is nominally in pseudo register REGNO,
2228: if we discover that that parm must go in the stack. */
2229: static rtx *parm_reg_stack_loc;
2230:
2231: /* Last insn of those whose job was to put parms into their nominal homes. */
2232: static rtx last_parm_insn;
2233:
2234: int
2235: max_parm_reg_num ()
2236: {
2237: return max_parm_reg;
2238: }
2239:
2240: /* Return the first insn following those generated by `assign_parms'. */
2241:
2242: rtx
2243: get_first_nonparm_insn ()
2244: {
2245: if (last_parm_insn)
2246: return NEXT_INSN (last_parm_insn);
2247: return get_insns ();
2248: }
2249:
2250: /* Get the stack home of a REG rtx that is one of this function's parameters.
2251: This is called rather than assign a new stack slot as a local.
2252: Return 0 if there is no existing stack home suitable for such use. */
2253:
2254: static rtx
2255: parm_stack_loc (reg)
2256: rtx reg;
2257: {
2258: if (REGNO (reg) < max_parm_reg)
2259: return parm_reg_stack_loc[REGNO (reg)];
2260: return 0;
2261: }
2262:
2263: /* Assign RTL expressions to the function's parameters.
2264: This may involve copying them into registers and using
2265: those registers as the RTL for them. */
2266:
2267: static void
2268: assign_parms (fndecl)
2269: tree fndecl;
2270: {
2271: register tree parm;
2272: register rtx entry_parm;
2273: register rtx stack_parm;
2274: register CUMULATIVE_ARGS args_so_far;
2275: enum machine_mode passed_mode, nominal_mode;
2276: /* Total space needed so far for args on the stack,
2277: given as a constant and a tree-expression. */
2278: struct args_size stack_args_size;
2279:
2280: int nparmregs
2281: = list_length (DECL_ARGUMENTS (fndecl)) + FIRST_PSEUDO_REGISTER;
2282:
2283: /* Nonzero if function takes extra anonymous args.
2284: This means the last named arg must be on the stack
2285: right before the anonymous ones. */
2286: int vararg
2287: = (TYPE_ARG_TYPES (TREE_TYPE (fndecl)) != 0
2288: && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (TREE_TYPE (fndecl))))
2289: != void_type_node));
2290:
2291: stack_args_size.constant = 0;
2292: stack_args_size.var = 0;
2293:
2294: parm_reg_stack_loc = (rtx *) oballoc (nparmregs * sizeof (rtx));
2295: bzero (parm_reg_stack_loc, nparmregs * sizeof (rtx));
2296:
2297: INIT_CUMULATIVE_ARGS (args_so_far, TREE_TYPE (fndecl));
2298:
2299: for (parm = DECL_ARGUMENTS (fndecl); parm; parm = TREE_CHAIN (parm))
2300: {
2301: int aggregate
2302: = (TREE_CODE (TREE_TYPE (parm)) == ARRAY_TYPE
2303: || TREE_CODE (TREE_TYPE (parm)) == RECORD_TYPE
2304: || TREE_CODE (TREE_TYPE (parm)) == UNION_TYPE);
2305: struct args_size stack_offset;
2306: rtx stack_offset_rtx;
2307:
2308: /* Get this parm's offset as an rtx. */
2309: stack_offset = stack_args_size;
2310: stack_offset.constant += FIRST_PARM_OFFSET;
2311: stack_offset_rtx = ARGS_SIZE_RTX (stack_offset);
2312:
2313: DECL_OFFSET (parm) = -1;
2314:
2315: if (TREE_TYPE (parm) == error_mark_node)
2316: {
2317: DECL_RTL (parm) = gen_rtx (MEM, BLKmode, const0_rtx);
2318: continue;
2319: }
2320:
2321: /* Find mode of arg as it is passed, and mode of arg
2322: as it should be during execution of this function. */
2323: passed_mode = TYPE_MODE (DECL_ARG_TYPE (parm));
2324: nominal_mode = TYPE_MODE (TREE_TYPE (parm));
2325:
2326: /* Determine parm's home in the stack,
2327: in case it arrives in the stack or we should pretend it did. */
2328: stack_parm
2329: = gen_rtx (MEM, passed_mode,
2330: memory_address (passed_mode,
2331: gen_rtx (PLUS, Pmode,
2332: arg_pointer_rtx, stack_offset_rtx)));
2333:
2334: /* If this is a memory ref that contains aggregate components,
2335: mark it as such for cse and loop optimize. */
2336: stack_parm->in_struct = aggregate;
2337:
2338: /* Let machine desc say which reg (if any) the parm arrives in.
2339: 0 means it arrives on the stack. */
2340: entry_parm = 0;
2341: /* Variable-size args, and args following such, are never in regs. */
2342: if (TREE_CODE (TYPE_SIZE (TREE_TYPE (parm))) == INTEGER_CST
2343: || stack_offset.var != 0)
2344: {
2345: #ifdef FUNCTION_INCOMING_ARG
2346: entry_parm
2347: = FUNCTION_INCOMING_ARG (args_so_far, passed_mode,
2348: DECL_ARG_TYPE (parm), 1);
2349: #else
2350: entry_parm
2351: = FUNCTION_ARG (args_so_far, passed_mode, DECL_ARG_TYPE (parm), 1);
2352: #endif
2353: }
2354: /* If this parm was passed part in regs and part in memory,
2355: pretend it arrived entirely in memory
2356: by pushing the register-part onto the stack.
2357:
2358: In the special case of a DImode or DFmode that is split,
2359: we could put it together in a pseudoreg directly,
2360: but for now that's not worth bothering with. */
2361:
2362: /* If this is the last named arg and anonymous args follow,
2363: likewise pretend this arg arrived on the stack
2364: so varargs can find the anonymous args following it. */
2365: {
2366: int nregs = 0;
2367: int i;
2368: #ifdef FUNCTION_ARG_PARTIAL_NREGS
2369: nregs = FUNCTION_ARG_PARTIAL_NREGS (args_so_far, passed_mode,
2370: DECL_ARG_TYPE (parm), 1);
2371: #endif
2372: if (TREE_CHAIN (parm) == 0 && vararg && entry_parm != 0)
2373: nregs = GET_MODE_SIZE (GET_MODE (entry_parm)) / UNITS_PER_WORD;
2374:
2375: if (nregs > 0)
2376: current_function_pretend_args_size
2377: = (((nregs * UNITS_PER_WORD) + (PARM_BOUNDARY / BITS_PER_UNIT) - 1)
2378: / (PARM_BOUNDARY / BITS_PER_UNIT)
2379: * (PARM_BOUNDARY / BITS_PER_UNIT));
2380:
2381: i = nregs;
2382: while (--i >= 0)
2383: emit_move_insn (gen_rtx (MEM, SImode,
2384: plus_constant (XEXP (stack_parm, 0),
2385: i * GET_MODE_SIZE (SImode))),
2386: gen_rtx (REG, SImode, REGNO (entry_parm) + i));
2387: if (nregs > 0)
2388: entry_parm = stack_parm;
2389: }
2390:
2391: if (entry_parm == 0)
2392: entry_parm = stack_parm;
2393:
2394: /* Now ENTRY_PARM refers to the stack iff this parm uses stack space.
2395: In that case, count its size in STACK_ARGS_SIZE. */
2396:
2397: if (entry_parm == stack_parm)
2398: {
2399: tree sizetree = size_in_bytes (DECL_ARG_TYPE (parm));
2400: /* Round the size up to multiple of PARM_BOUNDARY bits. */
2401: tree s1 = convert_units (sizetree, BITS_PER_UNIT, PARM_BOUNDARY);
2402: tree s2 = convert_units (s1, PARM_BOUNDARY, BITS_PER_UNIT);
2403: /* Add it in. */
2404: ADD_PARM_SIZE (stack_args_size, s2);
2405: }
2406:
2407: /* For a memory parm, record in DECL_OFFSET the arglist offset
2408: of the parm at the time it is passed (before conversion). */
2409: if (GET_CODE (entry_parm) != REG)
2410: DECL_OFFSET (parm) = stack_offset.constant * BITS_PER_UNIT;
2411:
2412: /* Now set STACK_PARM to the place in the stack
2413: where this parameter should live during execution,
2414: if we discover that it must live in the stack during execution.
2415: To make debuggers happier on big-endian machines, we store
2416: the value in the last bytes of the space available. */
2417:
2418: if (nominal_mode != BLKmode && nominal_mode != passed_mode)
2419: {
2420: #ifdef BYTES_BIG_ENDIAN
2421: stack_offset.constant
2422: += GET_MODE_SIZE (passed_mode)
2423: - GET_MODE_SIZE (nominal_mode);
2424: stack_offset_rtx = ARGS_SIZE_RTX (stack_offset);
2425: #endif
2426:
2427: stack_parm
2428: = gen_rtx (MEM, nominal_mode,
2429: memory_address (nominal_mode,
2430: gen_rtx (PLUS, Pmode,
2431: arg_pointer_rtx,
2432: stack_offset_rtx)));
2433:
2434: /* If this is a memory ref that contains aggregate components,
2435: mark it as such for cse and loop optimize. */
2436: stack_parm->in_struct = aggregate;
2437: }
2438:
2439: /* If the parm arrived in a reg, we don't have an argument
2440: stack slot for it, so don't think that we do.
2441: If it needs to be addressable, it will get put into the stack
2442: like an ordinary automatic variable. */
2443:
2444: if (GET_CODE (entry_parm) == REG)
2445: stack_parm = 0;
2446:
2447: #if 0 /* Not needed now that `memory_address' is used above. */
2448: /* If either STACK_PARM or ENTRY_PARM is a MEM whose address
2449: is not really valid, arrange to correct all references later. */
2450:
2451: if ((GET_CODE (entry_parm) == MEM
2452: && ! memory_address_p (passed_mode, XEXP (entry_parm, 0)))
2453: || (stack_parm != entry_parm && stack_parm != 0
2454: && GET_CODE (stack_parm) == MEM
2455: && ! memory_address_p (nominal_mode, XEXP (stack_parm, 0))))
2456: invalid_stack_slot = 1;
2457: #endif /* 0 */
2458:
2459: /* ENTRY_PARM is an RTX for the parameter as it arrives,
2460: in the mode in which it arrives.
2461:
2462: Now output code if necessary to convert it to
2463: the type in which this function declares it,
2464: and store a reference to that value in DECL_RTL.
2465: This reference may be the same as STACK_PARM,
2466: or a similar stack reference in a different mode,
2467: or may be a pseudo register. */
2468:
2469: if (nominal_mode == BLKmode)
2470: {
2471: /* If a BLKmode arrives in registers, copy it to a stack slot. */
2472: if (stack_parm == 0)
2473: {
2474: stack_parm
2475: = assign_stack_local (GET_MODE (entry_parm),
2476: int_size_in_bytes (TREE_TYPE (parm)));
2477:
2478: move_block_from_reg (REGNO (entry_parm), stack_parm,
2479: int_size_in_bytes (TREE_TYPE (parm))
2480: / UNITS_PER_WORD);
2481: }
2482: DECL_RTL (parm) = stack_parm;
2483:
2484: }
2485: else if (! ((obey_regdecls && ! TREE_REGDECL (parm))
2486: /* If -ffloat-store specified, don't put explicit
2487: float variables into registers. */
2488: || (flag_float_store
2489: && TREE_CODE (TREE_TYPE (parm)) == REAL_TYPE)))
2490: {
2491: /* Store the parm in a pseudoregister during the function. */
2492: register rtx parmreg = gen_reg_rtx (nominal_mode);
2493:
2494: parmreg->volatil = 1;
2495: DECL_RTL (parm) = parmreg;
2496:
2497: /* Copy the value into the register. */
2498: if (GET_MODE (parmreg) != GET_MODE (entry_parm))
2499: convert_move (parmreg, entry_parm, 0);
2500: else
2501: emit_move_insn (parmreg, entry_parm);
2502:
2503: /* In any case, record the parm's desired stack location
2504: in case we later discover it must live in the stack. */
2505: if (REGNO (parmreg) >= nparmregs)
2506: {
2507: rtx *new;
2508: nparmregs = REGNO (parmreg) + 5;
2509: new = (rtx *) oballoc (nparmregs * sizeof (rtx));
2510: bcopy (parm_reg_stack_loc, new, nparmregs * sizeof (rtx));
2511: parm_reg_stack_loc = new;
2512: }
2513: parm_reg_stack_loc[REGNO (parmreg)] = stack_parm;
2514:
2515: /* Mark the register as eliminable if we did no conversion
2516: and it was copied from memory at a fixed offset. */
2517: if (nominal_mode == passed_mode
2518: && GET_CODE (entry_parm) == MEM
2519: && stack_offset.var == 0)
2520: REG_NOTES (get_last_insn ()) = gen_rtx (EXPR_LIST, REG_EQUIV,
2521: entry_parm, 0);
2522:
2523: /* For pointer data type, suggest pointer register. */
2524: if (TREE_CODE (TREE_TYPE (parm)) == POINTER_TYPE)
2525: mark_reg_pointer (parmreg);
2526: }
2527: else
2528: {
2529: /* Value must be stored in the stack slot STACK_PARM
2530: during function execution. */
2531:
2532: if (passed_mode != nominal_mode)
2533: /* Conversion is required. */
2534: entry_parm = convert_to_mode (nominal_mode, entry_parm, 0);
2535:
2536: if (entry_parm != stack_parm)
2537: {
2538: if (stack_parm == 0)
2539: stack_parm = assign_stack_local (GET_MODE (entry_parm),
2540: GET_MODE_SIZE (GET_MODE (entry_parm)));
2541: emit_move_insn (stack_parm, entry_parm);
2542: }
2543:
2544: DECL_RTL (parm) = stack_parm;
2545: frame_pointer_needed = 1;
2546: }
2547:
2548: if (TREE_VOLATILE (parm))
2549: DECL_RTL (parm)->volatil = 1;
2550: if (TREE_READONLY (parm))
2551: DECL_RTL (parm)->unchanging = 1;
2552:
2553: /* Update info on where next arg arrives in registers. */
2554:
2555: FUNCTION_ARG_ADVANCE (args_so_far, passed_mode, DECL_ARG_TYPE (parm), 1);
2556: }
2557: max_parm_reg = max_reg_num ();
2558: last_parm_insn = get_last_insn ();
2559:
2560: current_function_args_size = stack_args_size.constant;
2561: }
2562:
2563: /* Allocation of space for returned structure values.
2564: During the rtl generation pass, `get_structure_value_addr'
2565: is called from time to time to request the address of a block in our
2566: stack frame in which called functions will store the structures
2567: they are returning. The same space is used for all of these blocks.
2568:
2569: We allocate these blocks like stack locals. We keep reusing
2570: the same block until a bigger one is needed. */
2571:
2572: /* Length in bytes of largest structure value returned by
2573: any function called so far in this function. */
2574: static int max_structure_value_size;
2575:
2576: /* An rtx for the addr we are currently using for structure values.
2577: This is typically (PLUS (REG:SI stackptr) (CONST_INT...)). */
2578: static rtx structure_value;
2579:
2580: rtx
2581: get_structure_value_addr (sizex)
2582: rtx sizex;
2583: {
2584: register int size;
2585: if (GET_CODE (sizex) != CONST_INT)
2586: abort ();
2587: size = INTVAL (sizex);
2588:
2589: /* Round up to a multiple of the main allocation unit. */
2590: size = (((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
2591: / (BIGGEST_ALIGNMENT / BITS_PER_UNIT))
2592: * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
2593:
2594: /* If this size is bigger than space we know to use,
2595: get a bigger piece of space. */
2596: if (size > max_structure_value_size)
2597: {
2598: max_structure_value_size = size;
2599: structure_value = assign_stack_local (BLKmode, size);
2600: if (GET_CODE (structure_value) == MEM)
2601: structure_value = XEXP (structure_value, 0);
2602: }
2603:
2604: return structure_value;
2605: }
2606:
2607: /* Walk the tree of LET_STMTs describing the binding levels within a function
2608: and warn about uninitialized variables.
2609: This is done after calling flow_analysis and before global_alloc
2610: clobbers the pseudo-regs to hard regs. */
2611:
2612: void
2613: uninitialized_vars_warning (block)
2614: tree block;
2615: {
2616: register tree decl, sub;
2617: for (decl = STMT_VARS (block); decl; decl = TREE_CHAIN (decl))
2618: {
2619: if (TREE_CODE (decl) == VAR_DECL
2620: /* These warnings are unreliable for and aggregates
2621: because assigning the fields one by one can fail to convince
2622: flow.c that the entire aggregate was initialized.
2623: Unions are troublesome because members may be shorter. */
2624: && TREE_CODE (TREE_TYPE (decl)) != RECORD_TYPE
2625: && TREE_CODE (TREE_TYPE (decl)) != UNION_TYPE
2626: && TREE_CODE (TREE_TYPE (decl)) != ARRAY_TYPE
2627: && GET_CODE (DECL_RTL (decl)) == REG
2628: && regno_uninitialized (REGNO (DECL_RTL (decl))))
2629: warning_with_decl (decl,
2630: "variable `%s' used uninitialized in this function");
2631: if (TREE_CODE (decl) == VAR_DECL
2632: && GET_CODE (DECL_RTL (decl)) == REG
2633: && regno_clobbered_at_setjmp (REGNO (DECL_RTL (decl))))
2634: warning_with_decl (decl,
2635: "variable `%s' may be clobbered by `longjmp'");
2636: }
2637: for (sub = STMT_BODY (block); sub; sub = TREE_CHAIN (sub))
2638: uninitialized_vars_warning (sub);
2639: }
2640:
2641: /* Generate RTL for the start of the function FUNC (a FUNCTION_DECL tree node)
2642: and initialize static variables for generating RTL for the statements
2643: of the function. */
2644:
2645: void
2646: expand_function_start (subr)
2647: tree subr;
2648: {
2649: register int i;
2650: tree tem;
2651:
2652: this_function = subr;
2653: cse_not_expected = ! optimize;
2654:
2655: /* We have not yet found a reason why a frame pointer cannot
2656: be omitted for this function in particular, but maybe we know
2657: a priori that it is required.
2658: `flag_omit_frame_pointer' has its main effect here. */
2659: frame_pointer_needed = FRAME_POINTER_REQUIRED || ! flag_omit_frame_pointer;
2660:
2661: /* No gotos have been expanded yet. */
2662: goto_fixup_chain = 0;
2663:
2664: /* No invalid stack slots have been made yet. */
2665: invalid_stack_slot = 0;
2666:
2667: /* Initialize the RTL mechanism. */
2668: init_emit (write_symbols);
2669:
2670: /* Initialize the queue of pending postincrement and postdecrements,
2671: and some other info in expr.c. */
2672: init_expr ();
2673:
2674: init_const_rtx_hash_table ();
2675:
2676: /* Decide whether function should try to pop its args on return. */
2677:
2678: current_function_pops_args = RETURN_POPS_ARGS (TREE_TYPE (subr));
2679:
2680: current_function_name = IDENTIFIER_POINTER (DECL_NAME (subr));
2681:
2682: /* Make the label for return statements to jump to, if this machine
2683: does not have a one-instruction return. */
2684: #ifdef FUNCTION_EPILOGUE
2685: return_label = gen_label_rtx ();
2686: #else
2687: return_label = 0;
2688: #endif
2689:
2690: /* No space assigned yet for structure values. */
2691: max_structure_value_size = 0;
2692: structure_value = 0;
2693:
2694: /* We are not currently within any block, conditional, loop or case. */
2695: block_stack = 0;
2696: loop_stack = 0;
2697: case_stack = 0;
2698: cond_stack = 0;
2699: nesting_stack = 0;
2700: nesting_depth = 0;
2701:
2702: /* We have not yet needed to make a label to jump to for tail-recursion. */
2703: tail_recursion_label = 0;
2704:
2705: /* No stack slots allocated yet. */
2706: frame_offset = STARTING_FRAME_OFFSET;
2707:
2708: init_pending_stack_adjust ();
2709: clear_current_args_size ();
2710:
2711: /* Prevent ever trying to delete the first instruction of a function.
2712: Also tell final how to output a linenum before the function prologue. */
2713: emit_note (DECL_SOURCE_FILE (subr), DECL_SOURCE_LINE (subr));
2714: /* Make sure first insn is a note even if we don't want linenums.
2715: This makes sure the first insn will never be deleted.
2716: Also, final expects a note to appear there. */
2717: emit_note (0, NOTE_INSN_DELETED);
2718:
2719: /* Initialize rtx for parameters and local variables.
2720: In some cases this requires emitting insns. */
2721:
2722: assign_parms (subr);
2723:
2724: /* If doing stupid allocation, mark parms as born here. */
2725:
2726: if (obey_regdecls)
2727: for (i = FIRST_PSEUDO_REGISTER; i < max_parm_reg; i++)
2728: use_variable (regno_reg_rtx[i]);
2729:
2730: /* After the parm initializations is where the tail-recursion label
2731: should go, if we end up needing one. */
2732: tail_recursion_reentry = get_last_insn ();
2733:
2734: /* Initialize rtx used to return the value. */
2735:
2736: if (DECL_MODE (DECL_RESULT (subr)) == BLKmode)
2737: {
2738: /* Returning something that won't go in a register. */
2739: register rtx value_address;
2740:
2741: /* Expect to be passed the address of a place to store the value. */
2742: value_address = gen_reg_rtx (Pmode);
2743: emit_move_insn (value_address, struct_value_incoming_rtx);
2744: DECL_RTL (DECL_RESULT (subr))
2745: = gen_rtx (MEM, DECL_MODE (DECL_RESULT (subr)),
2746: value_address);
2747: }
2748: else
2749: #ifdef FUNCTION_OUTGOING_VALUE
2750: DECL_RTL (DECL_RESULT (subr))
2751: = FUNCTION_OUTGOING_VALUE (TREE_TYPE (DECL_RESULT (subr)), subr);
2752: #else
2753: DECL_RTL (DECL_RESULT (subr))
2754: = FUNCTION_VALUE (TREE_TYPE (DECL_RESULT (subr)), subr);
2755: #endif
2756: }
2757:
2758: /* Generate RTL for the end of the current function. */
2759:
2760: void
2761: expand_function_end ()
2762: {
2763: register int i;
2764:
2765: /* Fix up any gotos that jumped out to the outermost
2766: binding level of the function. */
2767: fixup_gotos (0, get_insns ());
2768:
2769: /* If doing stupid register allocation,
2770: mark register parms as dying here. */
2771:
2772: if (obey_regdecls)
2773: for (i = FIRST_PSEUDO_REGISTER; i < max_parm_reg; i++)
2774: use_variable (regno_reg_rtx[i]);
2775:
2776: clear_pending_stack_adjust ();
2777: do_pending_stack_adjust ();
2778:
2779: /* Mark the end of the function body.
2780: If control reaches this insn, the function can drop through
2781: without returning a value. */
2782: emit_note (0, NOTE_INSN_FUNCTION_END);
2783:
2784: /* If we require a true epilogue,
2785: put here the label that return statements jump to.
2786: If there will be no epilogue, write a return instruction. */
2787: #ifdef FUNCTION_EPILOGUE
2788: emit_label (return_label);
2789: #else
2790: emit_jump_insn (gen_return ());
2791: #endif
2792: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.