![[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 [GCC 2.x] / gcc|
Return to stmt.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Expands front end tree to back end RTL for GNU C-Compiler
2: Copyright (C) 1987, 1988, 1989, 1992 Free Software Foundation, Inc.
3:
4: This file is part of GNU CC.
5:
6: GNU CC is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 2, or (at your option)
9: any later version.
10:
11: GNU CC is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GNU CC; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20:
21: /* This file handles the generation of rtl code from tree structure
22: above the level of expressions, using subroutines in exp*.c and emit-rtl.c.
23: It also creates the rtl expressions for parameters and auto variables
24: and has full responsibility for allocating stack slots.
25:
26: The functions whose names start with `expand_' are called by the
27: parser to generate RTL instructions for various kinds of constructs.
28:
29: Some control and binding constructs require calling several such
30: functions at different times. For example, a simple if-then
31: is expanded by calling `expand_start_cond' (with the condition-expression
32: as argument) before parsing the then-clause and calling `expand_end_cond'
33: after parsing the then-clause. */
34:
35: #include "config.h"
36:
37: #include <stdio.h>
38: #include <ctype.h>
39:
40: #include "rtl.h"
41: #include "tree.h"
42: #include "flags.h"
43: #include "function.h"
44: #include "insn-flags.h"
45: #include "insn-config.h"
46: #include "insn-codes.h"
47: #include "expr.h"
48: #include "hard-reg-set.h"
49: #include "obstack.h"
50: #include "loop.h"
51: #include "recog.h"
52:
53: #define obstack_chunk_alloc xmalloc
54: #define obstack_chunk_free free
55: struct obstack stmt_obstack;
56:
57: extern int xmalloc ();
58: extern void free ();
59:
60: /* Filename and line number of last line-number note,
61: whether we actually emitted it or not. */
62: char *emit_filename;
63: int emit_lineno;
64:
65: /* Nonzero if within a ({...}) grouping, in which case we must
66: always compute a value for each expr-stmt in case it is the last one. */
67:
68: int expr_stmts_for_value;
69:
70: /* Each time we expand an expression-statement,
71: record the expr's type and its RTL value here. */
72:
73: static tree last_expr_type;
74: static rtx last_expr_value;
75:
76: /* Number of binding contours started so far in this function. */
77:
78: int block_start_count;
79:
80: /* Nonzero if function being compiled needs to
81: return the address of where it has put a structure value. */
82:
83: extern int current_function_returns_pcc_struct;
84:
85: /* Label that will go on parm cleanup code, if any.
86: Jumping to this label runs cleanup code for parameters, if
87: such code must be run. Following this code is the logical return label. */
88:
89: extern rtx cleanup_label;
90:
91: /* Label that will go on function epilogue.
92: Jumping to this label serves as a "return" instruction
93: on machines which require execution of the epilogue on all returns. */
94:
95: extern rtx return_label;
96:
97: /* List (chain of EXPR_LISTs) of pseudo-regs of SAVE_EXPRs.
98: So we can mark them all live at the end of the function, if nonopt. */
99: extern rtx save_expr_regs;
100:
101: /* Offset to end of allocated area of stack frame.
102: If stack grows down, this is the address of the last stack slot allocated.
103: If stack grows up, this is the address for the next slot. */
104: extern int frame_offset;
105:
106: /* Label to jump back to for tail recursion, or 0 if we have
107: not yet needed one for this function. */
108: extern rtx tail_recursion_label;
109:
110: /* Place after which to insert the tail_recursion_label if we need one. */
111: extern rtx tail_recursion_reentry;
112:
113: /* Location at which to save the argument pointer if it will need to be
114: referenced. There are two cases where this is done: if nonlocal gotos
115: exist, or if vars whose is an offset from the argument pointer will be
116: needed by inner routines. */
117:
118: extern rtx arg_pointer_save_area;
119:
120: /* Chain of all RTL_EXPRs that have insns in them. */
121: extern tree rtl_expr_chain;
122:
123: #if 0 /* Turned off because 0 seems to work just as well. */
124: /* Cleanup lists are required for binding levels regardless of whether
125: that binding level has cleanups or not. This node serves as the
126: cleanup list whenever an empty list is required. */
127: static tree empty_cleanup_list;
128: #endif
129:
130: /* Functions and data structures for expanding case statements. */
131:
132: /* Case label structure, used to hold info on labels within case
133: statements. We handle "range" labels; for a single-value label
134: as in C, the high and low limits are the same.
135:
136: A chain of case nodes is initially maintained via the RIGHT fields
137: in the nodes. Nodes with higher case values are later in the list.
138:
139: Switch statements can be output in one of two forms. A branch table
140: is used if there are more than a few labels and the labels are dense
141: within the range between the smallest and largest case value. If a
142: branch table is used, no further manipulations are done with the case
143: node chain.
144:
145: The alternative to the use of a branch table is to generate a series
146: of compare and jump insns. When that is done, we use the LEFT, RIGHT,
147: and PARENT fields to hold a binary tree. Initially the tree is
148: totally unbalanced, with everything on the right. We balance the tree
149: with nodes on the left having lower case values than the parent
150: and nodes on the right having higher values. We then output the tree
151: in order. */
152:
153: struct case_node
154: {
155: struct case_node *left; /* Left son in binary tree */
156: struct case_node *right; /* Right son in binary tree; also node chain */
157: struct case_node *parent; /* Parent of node in binary tree */
158: tree low; /* Lowest index value for this label */
159: tree high; /* Highest index value for this label */
160: tree code_label; /* Label to jump to when node matches */
161: };
162:
163: typedef struct case_node case_node;
164: typedef struct case_node *case_node_ptr;
165:
166: /* These are used by estimate_case_costs and balance_case_nodes. */
167:
168: /* This must be a signed type, and non-ANSI compilers lack signed char. */
169: static short *cost_table;
170: static int use_cost_table;
171:
172: static int estimate_case_costs ();
173: static void balance_case_nodes ();
174: static void emit_case_nodes ();
175: static void group_case_nodes ();
176: static void emit_jump_if_reachable ();
177:
178: static int warn_if_unused_value ();
179: static void expand_goto_internal ();
180: static int expand_fixup ();
181: void fixup_gotos ();
182: void free_temp_slots ();
183: static void expand_cleanups ();
184: static void fixup_cleanups ();
185: static void expand_null_return_1 ();
186: static int tail_recursion_args ();
187: static void do_jump_if_equal ();
188:
189: /* Stack of control and binding constructs we are currently inside.
190:
191: These constructs begin when you call `expand_start_WHATEVER'
192: and end when you call `expand_end_WHATEVER'. This stack records
193: info about how the construct began that tells the end-function
194: what to do. It also may provide information about the construct
195: to alter the behavior of other constructs within the body.
196: For example, they may affect the behavior of C `break' and `continue'.
197:
198: Each construct gets one `struct nesting' object.
199: All of these objects are chained through the `all' field.
200: `nesting_stack' points to the first object (innermost construct).
201: The position of an entry on `nesting_stack' is in its `depth' field.
202:
203: Each type of construct has its own individual stack.
204: For example, loops have `loop_stack'. Each object points to the
205: next object of the same type through the `next' field.
206:
207: Some constructs are visible to `break' exit-statements and others
208: are not. Which constructs are visible depends on the language.
209: Therefore, the data structure allows each construct to be visible
210: or not, according to the args given when the construct is started.
211: The construct is visible if the `exit_label' field is non-null.
212: In that case, the value should be a CODE_LABEL rtx. */
213:
214: struct nesting
215: {
216: struct nesting *all;
217: struct nesting *next;
218: int depth;
219: rtx exit_label;
220: union
221: {
222: /* For conds (if-then and if-then-else statements). */
223: struct
224: {
225: /* Label for the end of the if construct.
226: There is none if EXITFLAG was not set
227: and no `else' has been seen yet. */
228: rtx endif_label;
229: /* Label for the end of this alternative.
230: This may be the end of the if or the next else/elseif. */
231: rtx next_label;
232: } cond;
233: /* For loops. */
234: struct
235: {
236: /* Label at the top of the loop; place to loop back to. */
237: rtx start_label;
238: /* Label at the end of the whole construct. */
239: rtx end_label;
240: /* Label for `continue' statement to jump to;
241: this is in front of the stepper of the loop. */
242: rtx continue_label;
243: } loop;
244: /* For variable binding contours. */
245: struct
246: {
247: /* Sequence number of this binding contour within the function,
248: in order of entry. */
249: int block_start_count;
250: /* Nonzero => value to restore stack to on exit. */
251: rtx stack_level;
252: /* The NOTE that starts this contour.
253: Used by expand_goto to check whether the destination
254: is within each contour or not. */
255: rtx first_insn;
256: /* Innermost containing binding contour that has a stack level. */
257: struct nesting *innermost_stack_block;
258: /* List of cleanups to be run on exit from this contour.
259: This is a list of expressions to be evaluated.
260: The TREE_PURPOSE of each link is the ..._DECL node
261: which the cleanup pertains to. */
262: tree cleanups;
263: /* List of cleanup-lists of blocks containing this block,
264: as they were at the locus where this block appears.
265: There is an element for each containing block,
266: ordered innermost containing block first.
267: The tail of this list can be 0 (was empty_cleanup_list),
268: if all remaining elements would be empty lists.
269: The element's TREE_VALUE is the cleanup-list of that block,
270: which may be null. */
271: tree outer_cleanups;
272: /* Chain of labels defined inside this binding contour.
273: For contours that have stack levels or cleanups. */
274: struct label_chain *label_chain;
275: /* Number of function calls seen, as of start of this block. */
276: int function_call_count;
277: } block;
278: /* For switch (C) or case (Pascal) statements,
279: and also for dummies (see `expand_start_case_dummy'). */
280: struct
281: {
282: /* The insn after which the case dispatch should finally
283: be emitted. Zero for a dummy. */
284: rtx start;
285: /* A list of case labels, kept in ascending order by value
286: as the list is built.
287: During expand_end_case, this list may be rearranged into a
288: nearly balanced binary tree. */
289: struct case_node *case_list;
290: /* Label to jump to if no case matches. */
291: tree default_label;
292: /* The expression to be dispatched on. */
293: tree index_expr;
294: /* Type that INDEX_EXPR should be converted to. */
295: tree nominal_type;
296: /* Number of range exprs in case statement. */
297: int num_ranges;
298: /* Name of this kind of statement, for warnings. */
299: char *printname;
300: /* Nonzero if a case label has been seen in this case stmt. */
301: char seenlabel;
302: } case_stmt;
303: /* For exception contours. */
304: struct
305: {
306: /* List of exceptions raised. This is a TREE_LIST
307: of whatever you want. */
308: tree raised;
309: /* List of exceptions caught. This is also a TREE_LIST
310: of whatever you want. As a special case, it has the
311: value `void_type_node' if it handles default exceptions. */
312: tree handled;
313:
314: /* First insn of TRY block, in case resumptive model is needed. */
315: rtx first_insn;
316: /* Label for the catch clauses. */
317: rtx except_label;
318: /* Label for unhandled exceptions. */
319: rtx unhandled_label;
320: /* Label at the end of whole construct. */
321: rtx after_label;
322: /* Label which "escapes" the exception construct.
323: Like EXIT_LABEL for BREAK construct, but for exceptions. */
324: rtx escape_label;
325: } except_stmt;
326: } data;
327: };
328:
329: /* Chain of all pending binding contours. */
330: struct nesting *block_stack;
331:
332: /* Chain of all pending binding contours that restore stack levels
333: or have cleanups. */
334: struct nesting *stack_block_stack;
335:
336: /* Chain of all pending conditional statements. */
337: struct nesting *cond_stack;
338:
339: /* Chain of all pending loops. */
340: struct nesting *loop_stack;
341:
342: /* Chain of all pending case or switch statements. */
343: struct nesting *case_stack;
344:
345: /* Chain of all pending exception contours. */
346: struct nesting *except_stack;
347:
348: /* Separate chain including all of the above,
349: chained through the `all' field. */
350: struct nesting *nesting_stack;
351:
352: /* Number of entries on nesting_stack now. */
353: int nesting_depth;
354:
355: /* Allocate and return a new `struct nesting'. */
356:
357: #define ALLOC_NESTING() \
358: (struct nesting *) obstack_alloc (&stmt_obstack, sizeof (struct nesting))
359:
360: /* Pop one of the sub-stacks, such as `loop_stack' or `cond_stack';
361: and pop off `nesting_stack' down to the same level. */
362:
363: #define POPSTACK(STACK) \
364: do { int initial_depth = nesting_stack->depth; \
365: do { struct nesting *this = STACK; \
366: STACK = this->next; \
367: nesting_stack = this->all; \
368: nesting_depth = this->depth; \
369: obstack_free (&stmt_obstack, this); } \
370: while (nesting_depth > initial_depth); } while (0)
371:
372: /* In some cases it is impossible to generate code for a forward goto
373: until the label definition is seen. This happens when it may be necessary
374: for the goto to reset the stack pointer: we don't yet know how to do that.
375: So expand_goto puts an entry on this fixup list.
376: Each time a binding contour that resets the stack is exited,
377: we check each fixup.
378: If the target label has now been defined, we can insert the proper code. */
379:
380: struct goto_fixup
381: {
382: /* Points to following fixup. */
383: struct goto_fixup *next;
384: /* Points to the insn before the jump insn.
385: If more code must be inserted, it goes after this insn. */
386: rtx before_jump;
387: /* The LABEL_DECL that this jump is jumping to, or 0
388: for break, continue or return. */
389: tree target;
390: /* The CODE_LABEL rtx that this is jumping to. */
391: rtx target_rtl;
392: /* Number of binding contours started in current function
393: before the label reference. */
394: int block_start_count;
395: /* The outermost stack level that should be restored for this jump.
396: Each time a binding contour that resets the stack is exited,
397: if the target label is *not* yet defined, this slot is updated. */
398: rtx stack_level;
399: /* List of lists of cleanup expressions to be run by this goto.
400: There is one element for each block that this goto is within.
401: The tail of this list can be 0 (was empty_cleanup_list),
402: if all remaining elements would be empty.
403: The TREE_VALUE contains the cleanup list of that block as of the
404: time this goto was seen.
405: The TREE_ADDRESSABLE flag is 1 for a block that has been exited. */
406: tree cleanup_list_list;
407: };
408:
409: static struct goto_fixup *goto_fixup_chain;
410:
411: /* Within any binding contour that must restore a stack level,
412: all labels are recorded with a chain of these structures. */
413:
414: struct label_chain
415: {
416: /* Points to following fixup. */
417: struct label_chain *next;
418: tree label;
419: };
420:
421: void
422: init_stmt ()
423: {
424: gcc_obstack_init (&stmt_obstack);
425: #if 0
426: empty_cleanup_list = build_tree_list (NULL_TREE, NULL_TREE);
427: #endif
428: }
429:
430: void
431: init_stmt_for_function ()
432: {
433: /* We are not currently within any block, conditional, loop or case. */
434: block_stack = 0;
435: loop_stack = 0;
436: case_stack = 0;
437: cond_stack = 0;
438: nesting_stack = 0;
439: nesting_depth = 0;
440:
441: block_start_count = 0;
442:
443: /* No gotos have been expanded yet. */
444: goto_fixup_chain = 0;
445:
446: /* We are not processing a ({...}) grouping. */
447: expr_stmts_for_value = 0;
448: last_expr_type = 0;
449: }
450:
451: void
452: save_stmt_status (p)
453: struct function *p;
454: {
455: p->block_stack = block_stack;
456: p->stack_block_stack = stack_block_stack;
457: p->cond_stack = cond_stack;
458: p->loop_stack = loop_stack;
459: p->case_stack = case_stack;
460: p->nesting_stack = nesting_stack;
461: p->nesting_depth = nesting_depth;
462: p->block_start_count = block_start_count;
463: p->last_expr_type = last_expr_type;
464: p->last_expr_value = last_expr_value;
465: p->expr_stmts_for_value = expr_stmts_for_value;
466: p->emit_filename = emit_filename;
467: p->emit_lineno = emit_lineno;
468: p->goto_fixup_chain = goto_fixup_chain;
469: }
470:
471: void
472: restore_stmt_status (p)
473: struct function *p;
474: {
475: block_stack = p->block_stack;
476: stack_block_stack = p->stack_block_stack;
477: cond_stack = p->cond_stack;
478: loop_stack = p->loop_stack;
479: case_stack = p->case_stack;
480: nesting_stack = p->nesting_stack;
481: nesting_depth = p->nesting_depth;
482: block_start_count = p->block_start_count;
483: last_expr_type = p->last_expr_type;
484: last_expr_value = p->last_expr_value;
485: expr_stmts_for_value = p->expr_stmts_for_value;
486: emit_filename = p->emit_filename;
487: emit_lineno = p->emit_lineno;
488: goto_fixup_chain = p->goto_fixup_chain;
489: }
490:
491: /* Emit a no-op instruction. */
492:
493: void
494: emit_nop ()
495: {
496: rtx last_insn = get_last_insn ();
497: if (!optimize
498: && (GET_CODE (last_insn) == CODE_LABEL
499: || prev_real_insn (last_insn) == 0))
500: emit_insn (gen_nop ());
501: }
502:
503: /* Return the rtx-label that corresponds to a LABEL_DECL,
504: creating it if necessary. */
505:
506: rtx
507: label_rtx (label)
508: tree label;
509: {
510: if (TREE_CODE (label) != LABEL_DECL)
511: abort ();
512:
513: if (DECL_RTL (label))
514: return DECL_RTL (label);
515:
516: return DECL_RTL (label) = gen_label_rtx ();
517: }
518:
519: /* Add an unconditional jump to LABEL as the next sequential instruction. */
520:
521: void
522: emit_jump (label)
523: rtx label;
524: {
525: do_pending_stack_adjust ();
526: emit_jump_insn (gen_jump (label));
527: emit_barrier ();
528: }
529:
530: /* Emit code to jump to the address
531: specified by the pointer expression EXP. */
532:
533: void
534: expand_computed_goto (exp)
535: tree exp;
536: {
537: rtx x = expand_expr (exp, 0, VOIDmode, 0);
538: emit_indirect_jump (x);
539: emit_barrier ();
540: }
541:
542: /* Handle goto statements and the labels that they can go to. */
543:
544: /* Specify the location in the RTL code of a label LABEL,
545: which is a LABEL_DECL tree node.
546:
547: This is used for the kind of label that the user can jump to with a
548: goto statement, and for alternatives of a switch or case statement.
549: RTL labels generated for loops and conditionals don't go through here;
550: they are generated directly at the RTL level, by other functions below.
551:
552: Note that this has nothing to do with defining label *names*.
553: Languages vary in how they do that and what that even means. */
554:
555: void
556: expand_label (label)
557: tree label;
558: {
559: struct label_chain *p;
560:
561: do_pending_stack_adjust ();
562: emit_label (label_rtx (label));
563: if (DECL_NAME (label))
564: LABEL_NAME (DECL_RTL (label)) = IDENTIFIER_POINTER (DECL_NAME (label));
565:
566: if (stack_block_stack != 0)
567: {
568: p = (struct label_chain *) oballoc (sizeof (struct label_chain));
569: p->next = stack_block_stack->data.block.label_chain;
570: stack_block_stack->data.block.label_chain = p;
571: p->label = label;
572: }
573: }
574:
575: /* Declare that LABEL (a LABEL_DECL) may be used for nonlocal gotos
576: from nested functions. */
577:
578: void
579: declare_nonlocal_label (label)
580: tree label;
581: {
582: nonlocal_labels = tree_cons (NULL_TREE, label, nonlocal_labels);
583: LABEL_PRESERVE_P (label_rtx (label)) = 1;
584: if (nonlocal_goto_handler_slot == 0)
585: {
586: nonlocal_goto_handler_slot
587: = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0);
588: nonlocal_goto_stack_level
589: = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0);
590: emit_insn_before (gen_move_insn (nonlocal_goto_stack_level,
591: stack_pointer_rtx),
592: tail_recursion_reentry);
593: }
594: }
595:
596: /* Generate RTL code for a `goto' statement with target label LABEL.
597: LABEL should be a LABEL_DECL tree node that was or will later be
598: defined with `expand_label'. */
599:
600: void
601: expand_goto (label)
602: tree label;
603: {
604: /* Check for a nonlocal goto to a containing function. */
605: tree context = decl_function_context (label);
606: if (context != 0 && context != current_function_decl)
607: {
608: struct function *p = find_function_data (context);
609: rtx temp;
610: p->has_nonlocal_label = 1;
611: #if HAVE_nonlocal_goto
612: if (HAVE_nonlocal_goto)
613: emit_insn (gen_nonlocal_goto (lookup_static_chain (label),
614: p->nonlocal_goto_handler_slot,
615: p->nonlocal_goto_stack_level,
616: gen_rtx (LABEL_REF, Pmode,
617: label_rtx (label))));
618: else
619: #endif
620: {
621: /* Restore frame pointer for containing function.
622: This sets the actual hard register used for the frame pointer
623: to the location of the function's incoming static chain info.
624: The non-local goto handler will then adjust it to contain the
625: proper value and reload the argument pointer, if needed. */
626: emit_move_insn (frame_pointer_rtx, lookup_static_chain (label));
627: /* Get addr of containing function's current nonlocal goto handler,
628: which will do any cleanups and then jump to the label. */
629: temp = copy_to_reg (p->nonlocal_goto_handler_slot);
630: /* Restore the stack pointer. Note this uses fp just restored. */
631: emit_move_insn (stack_pointer_rtx, p->nonlocal_goto_stack_level);
632: /* Put in the static chain register the nonlocal label address. */
633: emit_move_insn (static_chain_rtx,
634: gen_rtx (LABEL_REF, Pmode, label_rtx (label)));
635: /* USE of frame_pointer_rtx added for consistency; not clear if
636: really needed. */
637: emit_insn (gen_rtx (USE, VOIDmode, frame_pointer_rtx));
638: emit_insn (gen_rtx (USE, VOIDmode, stack_pointer_rtx));
639: emit_insn (gen_rtx (USE, VOIDmode, static_chain_rtx));
640: emit_indirect_jump (temp);
641: }
642: }
643: else
644: expand_goto_internal (label, label_rtx (label), 0);
645: }
646:
647: /* Generate RTL code for a `goto' statement with target label BODY.
648: LABEL should be a LABEL_REF.
649: LAST_INSN, if non-0, is the rtx we should consider as the last
650: insn emitted (for the purposes of cleaning up a return). */
651:
652: static void
653: expand_goto_internal (body, label, last_insn)
654: tree body;
655: rtx label;
656: rtx last_insn;
657: {
658: struct nesting *block;
659: rtx stack_level = 0;
660:
661: if (GET_CODE (label) != CODE_LABEL)
662: abort ();
663:
664: /* If label has already been defined, we can tell now
665: whether and how we must alter the stack level. */
666:
667: if (PREV_INSN (label) != 0)
668: {
669: /* Find the innermost pending block that contains the label.
670: (Check containment by comparing insn-uids.)
671: Then restore the outermost stack level within that block,
672: and do cleanups of all blocks contained in it. */
673: for (block = block_stack; block; block = block->next)
674: {
675: if (INSN_UID (block->data.block.first_insn) < INSN_UID (label))
676: break;
677: if (block->data.block.stack_level != 0)
678: stack_level = block->data.block.stack_level;
679: /* Execute the cleanups for blocks we are exiting. */
680: if (block->data.block.cleanups != 0)
681: {
682: expand_cleanups (block->data.block.cleanups, 0);
683: do_pending_stack_adjust ();
684: }
685: }
686:
687: if (stack_level)
688: {
689: /* Ensure stack adjust isn't done by emit_jump, as this would clobber
690: the stack pointer. This one should be deleted as dead by flow. */
691: clear_pending_stack_adjust ();
692: do_pending_stack_adjust ();
693: emit_move_insn (stack_pointer_rtx, stack_level);
694: }
695:
696: if (body != 0 && DECL_TOO_LATE (body))
697: error ("jump to `%s' invalidly jumps into binding contour",
698: IDENTIFIER_POINTER (DECL_NAME (body)));
699: }
700: /* Label not yet defined: may need to put this goto
701: on the fixup list. */
702: else if (! expand_fixup (body, label, last_insn))
703: {
704: /* No fixup needed. Record that the label is the target
705: of at least one goto that has no fixup. */
706: if (body != 0)
707: TREE_ADDRESSABLE (body) = 1;
708: }
709:
710: emit_jump (label);
711: }
712:
713: /* Generate if necessary a fixup for a goto
714: whose target label in tree structure (if any) is TREE_LABEL
715: and whose target in rtl is RTL_LABEL.
716:
717: If LAST_INSN is nonzero, we pretend that the jump appears
718: after insn LAST_INSN instead of at the current point in the insn stream.
719:
720: The fixup will be used later to insert insns at this point
721: to restore the stack level as appropriate for the target label.
722:
723: Value is nonzero if a fixup is made. */
724:
725: static int
726: expand_fixup (tree_label, rtl_label, last_insn)
727: tree tree_label;
728: rtx rtl_label;
729: rtx last_insn;
730: {
731: struct nesting *block, *end_block;
732:
733: /* See if we can recognize which block the label will be output in.
734: This is possible in some very common cases.
735: If we succeed, set END_BLOCK to that block.
736: Otherwise, set it to 0. */
737:
738: if (cond_stack
739: && (rtl_label == cond_stack->data.cond.endif_label
740: || rtl_label == cond_stack->data.cond.next_label))
741: end_block = cond_stack;
742: /* If we are in a loop, recognize certain labels which
743: are likely targets. This reduces the number of fixups
744: we need to create. */
745: else if (loop_stack
746: && (rtl_label == loop_stack->data.loop.start_label
747: || rtl_label == loop_stack->data.loop.end_label
748: || rtl_label == loop_stack->data.loop.continue_label))
749: end_block = loop_stack;
750: else
751: end_block = 0;
752:
753: /* Now set END_BLOCK to the binding level to which we will return. */
754:
755: if (end_block)
756: {
757: struct nesting *next_block = end_block->all;
758: block = block_stack;
759:
760: /* First see if the END_BLOCK is inside the innermost binding level.
761: If so, then no cleanups or stack levels are relevant. */
762: while (next_block && next_block != block)
763: next_block = next_block->all;
764:
765: if (next_block)
766: return 0;
767:
768: /* Otherwise, set END_BLOCK to the innermost binding level
769: which is outside the relevant control-structure nesting. */
770: next_block = block_stack->next;
771: for (block = block_stack; block != end_block; block = block->all)
772: if (block == next_block)
773: next_block = next_block->next;
774: end_block = next_block;
775: }
776:
777: /* Does any containing block have a stack level or cleanups?
778: If not, no fixup is needed, and that is the normal case
779: (the only case, for standard C). */
780: for (block = block_stack; block != end_block; block = block->next)
781: if (block->data.block.stack_level != 0
782: || block->data.block.cleanups != 0)
783: break;
784:
785: if (block != end_block)
786: {
787: /* Ok, a fixup is needed. Add a fixup to the list of such. */
788: struct goto_fixup *fixup
789: = (struct goto_fixup *) oballoc (sizeof (struct goto_fixup));
790: /* In case an old stack level is restored, make sure that comes
791: after any pending stack adjust. */
792: /* ?? If the fixup isn't to come at the present position,
793: doing the stack adjust here isn't useful. Doing it with our
794: settings at that location isn't useful either. Let's hope
795: someone does it! */
796: if (last_insn == 0)
797: do_pending_stack_adjust ();
798: fixup->before_jump = last_insn ? last_insn : get_last_insn ();
799: fixup->target = tree_label;
800: fixup->target_rtl = rtl_label;
801: fixup->block_start_count = block_start_count;
802: fixup->stack_level = 0;
803: fixup->cleanup_list_list
804: = (((block->data.block.outer_cleanups
805: #if 0
806: && block->data.block.outer_cleanups != empty_cleanup_list
807: #endif
808: )
809: || block->data.block.cleanups)
810: ? tree_cons (0, block->data.block.cleanups,
811: block->data.block.outer_cleanups)
812: : 0);
813: fixup->next = goto_fixup_chain;
814: goto_fixup_chain = fixup;
815: }
816:
817: return block != 0;
818: }
819:
820: /* When exiting a binding contour, process all pending gotos requiring fixups.
821: THISBLOCK is the structure that describes the block being exited.
822: STACK_LEVEL is the rtx for the stack level to restore exiting this contour.
823: CLEANUP_LIST is a list of expressions to evaluate on exiting this contour.
824: FIRST_INSN is the insn that began this contour.
825:
826: Gotos that jump out of this contour must restore the
827: stack level and do the cleanups before actually jumping.
828:
829: DONT_JUMP_IN nonzero means report error there is a jump into this
830: contour from before the beginning of the contour.
831: This is also done if STACK_LEVEL is nonzero. */
832:
833: void
834: fixup_gotos (thisblock, stack_level, cleanup_list, first_insn, dont_jump_in)
835: struct nesting *thisblock;
836: rtx stack_level;
837: tree cleanup_list;
838: rtx first_insn;
839: int dont_jump_in;
840: {
841: register struct goto_fixup *f, *prev;
842:
843: /* F is the fixup we are considering; PREV is the previous one. */
844: /* We run this loop in two passes so that cleanups of exited blocks
845: are run first, and blocks that are exited are marked so
846: afterwards. */
847:
848: for (prev = 0, f = goto_fixup_chain; f; prev = f, f = f->next)
849: {
850: /* Test for a fixup that is inactive because it is already handled. */
851: if (f->before_jump == 0)
852: {
853: /* Delete inactive fixup from the chain, if that is easy to do. */
854: if (prev != 0)
855: prev->next = f->next;
856: }
857: /* Has this fixup's target label been defined?
858: If so, we can finalize it. */
859: else if (PREV_INSN (f->target_rtl) != 0)
860: {
861: /* Get the first non-label after the label
862: this goto jumps to. If that's before this scope begins,
863: we don't have a jump into the scope. */
864: rtx after_label = f->target_rtl;
865: while (after_label != 0 && GET_CODE (after_label) == CODE_LABEL)
866: after_label = NEXT_INSN (after_label);
867:
868: /* If this fixup jumped into this contour from before the beginning
869: of this contour, report an error. */
870: /* ??? Bug: this does not detect jumping in through intermediate
871: blocks that have stack levels or cleanups.
872: It detects only a problem with the innermost block
873: around the label. */
874: if (f->target != 0
875: && (dont_jump_in || stack_level || cleanup_list)
876: /* If AFTER_LABEL is 0, it means the jump goes to the end
877: of the rtl, which means it jumps into this scope. */
878: && (after_label == 0
879: || INSN_UID (first_insn) < INSN_UID (after_label))
880: && INSN_UID (first_insn) > INSN_UID (f->before_jump)
881: && ! TREE_REGDECL (f->target))
882: {
883: error_with_decl (f->target,
884: "label `%s' used before containing binding contour");
885: /* Prevent multiple errors for one label. */
886: TREE_REGDECL (f->target) = 1;
887: }
888:
889: /* Execute cleanups for blocks this jump exits. */
890: if (f->cleanup_list_list)
891: {
892: tree lists;
893: for (lists = f->cleanup_list_list; lists; lists = TREE_CHAIN (lists))
894: /* Marked elements correspond to blocks that have been closed.
895: Do their cleanups. */
896: if (TREE_ADDRESSABLE (lists)
897: && TREE_VALUE (lists) != 0)
898: fixup_cleanups (TREE_VALUE (lists), &f->before_jump);
899: }
900:
901: /* Restore stack level for the biggest contour that this
902: jump jumps out of. */
903: if (f->stack_level)
904: emit_insn_after (gen_move_insn (stack_pointer_rtx, f->stack_level),
905: f->before_jump);
906: f->before_jump = 0;
907: }
908: }
909:
910: /* Mark the cleanups of exited blocks so that they are executed
911: by the code above. */
912: for (prev = 0, f = goto_fixup_chain; f; prev = f, f = f->next)
913: if (f->before_jump != 0
914: && PREV_INSN (f->target_rtl) == 0
915: /* Label has still not appeared. If we are exiting a block with
916: a stack level to restore, that started before the fixup,
917: mark this stack level as needing restoration
918: when the fixup is later finalized.
919: Also mark the cleanup_list_list element for F
920: that corresponds to this block, so that ultimately
921: this block's cleanups will be executed by the code above. */
922: && thisblock != 0
923: /* Note: if THISBLOCK == 0 and we have a label that hasn't appeared,
924: it means the label is undefined. That's erroneous, but possible. */
925: && (thisblock->data.block.block_start_count
926: <= f->block_start_count))
927: {
928: tree lists = f->cleanup_list_list;
929: for (; lists; lists = TREE_CHAIN (lists))
930: /* If the following elt. corresponds to our containing block
931: then the elt. must be for this block. */
932: if (TREE_CHAIN (lists) == thisblock->data.block.outer_cleanups)
933: TREE_ADDRESSABLE (lists) = 1;
934:
935: if (stack_level)
936: f->stack_level = stack_level;
937: }
938: }
939:
940: /* Generate RTL for an asm statement (explicit assembler code).
941: BODY is a STRING_CST node containing the assembler code text,
942: or an ADDR_EXPR containing a STRING_CST. */
943:
944: void
945: expand_asm (body)
946: tree body;
947: {
948: if (TREE_CODE (body) == ADDR_EXPR)
949: body = TREE_OPERAND (body, 0);
950:
951: emit_insn (gen_rtx (ASM_INPUT, VOIDmode,
952: TREE_STRING_POINTER (body)));
953: last_expr_type = 0;
954: }
955:
956: /* Generate RTL for an asm statement with arguments.
957: STRING is the instruction template.
958: OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
959: Each output or input has an expression in the TREE_VALUE and
960: a constraint-string in the TREE_PURPOSE.
961: CLOBBERS is a list of STRING_CST nodes each naming a hard register
962: that is clobbered by this insn.
963:
964: Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
965: Some elements of OUTPUTS may be replaced with trees representing temporary
966: values. The caller should copy those temporary values to the originally
967: specified lvalues.
968:
969: VOL nonzero means the insn is volatile; don't optimize it. */
970:
971: void
972: expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
973: tree string, outputs, inputs, clobbers;
974: int vol;
975: char *filename;
976: int line;
977: {
978: rtvec argvec, constraints;
979: rtx body;
980: int ninputs = list_length (inputs);
981: int noutputs = list_length (outputs);
982: int nclobbers = list_length (clobbers);
983: tree tail;
984: register int i;
985: /* Vector of RTX's of evaluated output operands. */
986: rtx *output_rtx = (rtx *) alloca (noutputs * sizeof (rtx));
987: /* The insn we have emitted. */
988: rtx insn;
989:
990: last_expr_type = 0;
991:
992: for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
993: {
994: tree val = TREE_VALUE (tail);
995: tree val1;
996: int j;
997: int found_equal;
998:
999: /* If there's an erroneous arg, emit no insn. */
1000: if (TREE_TYPE (val) == error_mark_node)
1001: return;
1002:
1003: /* Make sure constraint has `=' and does not have `+'. */
1004:
1005: found_equal = 0;
1006: for (j = 0; j < TREE_STRING_LENGTH (TREE_PURPOSE (tail)); j++)
1007: {
1008: if (TREE_STRING_POINTER (TREE_PURPOSE (tail))[j] == '+')
1009: {
1010: error ("output operand constraint contains `+'");
1011: return;
1012: }
1013: if (TREE_STRING_POINTER (TREE_PURPOSE (tail))[j] == '=')
1014: found_equal = 1;
1015: }
1016: if (! found_equal)
1017: {
1018: error ("output operand constraint lacks `='");
1019: return;
1020: }
1021:
1022: /* If an output operand is not a variable or indirect ref,
1023: or a part of one,
1024: create a SAVE_EXPR which is a pseudo-reg
1025: to act as an intermediate temporary.
1026: Make the asm insn write into that, then copy it to
1027: the real output operand. */
1028:
1029: while (TREE_CODE (val) == COMPONENT_REF
1030: || TREE_CODE (val) == ARRAY_REF)
1031: val = TREE_OPERAND (val, 0);
1032:
1033: if (TREE_CODE (val) != VAR_DECL
1034: && TREE_CODE (val) != PARM_DECL
1035: && TREE_CODE (val) != INDIRECT_REF)
1036: TREE_VALUE (tail) = save_expr (TREE_VALUE (tail));
1037:
1038: output_rtx[i] = expand_expr (TREE_VALUE (tail), 0, VOIDmode, 0);
1039: }
1040:
1041: if (ninputs + noutputs > MAX_RECOG_OPERANDS)
1042: {
1043: error ("more than %d operands in `asm'", MAX_RECOG_OPERANDS);
1044: return;
1045: }
1046:
1047: /* Make vectors for the expression-rtx and constraint strings. */
1048:
1049: argvec = rtvec_alloc (ninputs);
1050: constraints = rtvec_alloc (ninputs);
1051:
1052: body = gen_rtx (ASM_OPERANDS, VOIDmode,
1053: TREE_STRING_POINTER (string), "", 0, argvec, constraints,
1054: filename, line);
1055: MEM_VOLATILE_P (body) = vol;
1056:
1057: /* Eval the inputs and put them into ARGVEC.
1058: Put their constraints into ASM_INPUTs and store in CONSTRAINTS. */
1059:
1060: i = 0;
1061: for (tail = inputs; tail; tail = TREE_CHAIN (tail))
1062: {
1063: int j;
1064:
1065: /* If there's an erroneous arg, emit no insn,
1066: because the ASM_INPUT would get VOIDmode
1067: and that could cause a crash in reload. */
1068: if (TREE_TYPE (TREE_VALUE (tail)) == error_mark_node)
1069: return;
1070: if (TREE_PURPOSE (tail) == NULL_TREE)
1071: {
1072: error ("hard register `%s' listed as input operand to `asm'",
1073: TREE_STRING_POINTER (TREE_VALUE (tail)) );
1074: return;
1075: }
1076:
1077: /* Make sure constraint has neither `=' nor `+'. */
1078:
1079: for (j = 0; j < TREE_STRING_LENGTH (TREE_PURPOSE (tail)); j++)
1080: if (TREE_STRING_POINTER (TREE_PURPOSE (tail))[j] == '='
1081: || TREE_STRING_POINTER (TREE_PURPOSE (tail))[j] == '+')
1082: {
1083: error ("input operand constraint contains `%c'",
1084: TREE_STRING_POINTER (TREE_PURPOSE (tail))[j]);
1085: return;
1086: }
1087:
1088: XVECEXP (body, 3, i) /* argvec */
1089: = expand_expr (TREE_VALUE (tail), 0, VOIDmode, 0);
1090: XVECEXP (body, 4, i) /* constraints */
1091: = gen_rtx (ASM_INPUT, TYPE_MODE (TREE_TYPE (TREE_VALUE (tail))),
1092: TREE_STRING_POINTER (TREE_PURPOSE (tail)));
1093: i++;
1094: }
1095:
1096: /* Protect all the operands from the queue,
1097: now that they have all been evaluated. */
1098:
1099: for (i = 0; i < ninputs; i++)
1100: XVECEXP (body, 3, i) = protect_from_queue (XVECEXP (body, 3, i), 0);
1101:
1102: for (i = 0; i < noutputs; i++)
1103: output_rtx[i] = protect_from_queue (output_rtx[i], 1);
1104:
1105: /* Now, for each output, construct an rtx
1106: (set OUTPUT (asm_operands INSN OUTPUTNUMBER OUTPUTCONSTRAINT
1107: ARGVEC CONSTRAINTS))
1108: If there is more than one, put them inside a PARALLEL. */
1109:
1110: if (noutputs == 1 && nclobbers == 0)
1111: {
1112: XSTR (body, 1) = TREE_STRING_POINTER (TREE_PURPOSE (outputs));
1113: insn = emit_insn (gen_rtx (SET, VOIDmode, output_rtx[0], body));
1114: }
1115: else if (noutputs == 0 && nclobbers == 0)
1116: {
1117: /* No output operands: put in a raw ASM_OPERANDS rtx. */
1118: insn = emit_insn (body);
1119: }
1120: else
1121: {
1122: rtx obody = body;
1123: int num = noutputs;
1124: if (num == 0) num = 1;
1125: body = gen_rtx (PARALLEL, VOIDmode, rtvec_alloc (num + nclobbers));
1126:
1127: /* For each output operand, store a SET. */
1128:
1129: for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
1130: {
1131: XVECEXP (body, 0, i)
1132: = gen_rtx (SET, VOIDmode,
1133: output_rtx[i],
1134: gen_rtx (ASM_OPERANDS, VOIDmode,
1135: TREE_STRING_POINTER (string),
1136: TREE_STRING_POINTER (TREE_PURPOSE (tail)),
1137: i, argvec, constraints,
1138: filename, line));
1139: MEM_VOLATILE_P (SET_SRC (XVECEXP (body, 0, i))) = vol;
1140: }
1141:
1142: /* If there are no outputs (but there are some clobbers)
1143: store the bare ASM_OPERANDS into the PARALLEL. */
1144:
1145: if (i == 0)
1146: XVECEXP (body, 0, i++) = obody;
1147:
1148: /* Store (clobber REG) for each clobbered register specified. */
1149:
1150: for (tail = clobbers; tail; tail = TREE_CHAIN (tail), i++)
1151: {
1152: int j;
1153: char *regname = TREE_STRING_POINTER (TREE_VALUE (tail));
1154:
1155: for (j = 0; j < FIRST_PSEUDO_REGISTER; j++)
1156: if (!strcmp (regname, reg_names[j]))
1157: break;
1158:
1159: if (j == FIRST_PSEUDO_REGISTER)
1160: {
1161: error ("unknown register name `%s' in `asm'", regname);
1162: return;
1163: }
1164:
1165: /* Use QImode since that's guaranteed to clobber just one reg. */
1166: XVECEXP (body, 0, i)
1167: = gen_rtx (CLOBBER, VOIDmode, gen_rtx (REG, QImode, j));
1168: }
1169:
1170: insn = emit_insn (body);
1171: }
1172:
1173: free_temp_slots ();
1174: }
1175:
1176: /* Generate RTL to evaluate the expression EXP
1177: and remember it in case this is the VALUE in a ({... VALUE; }) constr. */
1178:
1179: void
1180: expand_expr_stmt (exp)
1181: tree exp;
1182: {
1183: /* If -W, warn about statements with no side effects,
1184: except for an explicit cast to void (e.g. for assert()), and
1185: except inside a ({...}) where they may be useful. */
1186: if (expr_stmts_for_value == 0 && exp != error_mark_node)
1187: {
1188: if (! TREE_SIDE_EFFECTS (exp) && (extra_warnings || warn_unused)
1189: && !(TREE_CODE (exp) == CONVERT_EXPR
1190: && TREE_TYPE (exp) == void_type_node))
1191: warning_with_file_and_line (emit_filename, emit_lineno,
1192: "statement with no effect");
1193: else if (warn_unused)
1194: warn_if_unused_value (exp);
1195: }
1196: last_expr_type = TREE_TYPE (exp);
1197: if (! flag_syntax_only)
1198: last_expr_value = expand_expr (exp, expr_stmts_for_value ? 0 : const0_rtx,
1199: VOIDmode, 0);
1200:
1201: /* If all we do is reference a volatile value in memory,
1202: copy it to a register to be sure it is actually touched. */
1203: if (last_expr_value != 0 && GET_CODE (last_expr_value) == MEM
1204: && TREE_THIS_VOLATILE (exp))
1205: {
1206: if (TYPE_MODE (TREE_TYPE (exp)) != BLKmode)
1207: copy_to_reg (last_expr_value);
1208: else
1209: /* This case needs to be written. */
1210: abort ();
1211: }
1212:
1213: /* If this expression is part of a ({...}) and is in memory, we may have
1214: to preserve temporaries. */
1215: preserve_temp_slots (last_expr_value);
1216:
1217: /* Free any temporaries used to evaluate this expression. Any temporary
1218: used as a result of this expression will already have been preserved
1219: above. */
1220: free_temp_slots ();
1221:
1222: emit_queue ();
1223: }
1224:
1225: /* Warn if EXP contains any computations whose results are not used.
1226: Return 1 if a warning is printed; 0 otherwise. */
1227:
1228: static int
1229: warn_if_unused_value (exp)
1230: tree exp;
1231: {
1232: if (TREE_USED (exp))
1233: return 0;
1234:
1235: switch (TREE_CODE (exp))
1236: {
1237: case PREINCREMENT_EXPR:
1238: case POSTINCREMENT_EXPR:
1239: case PREDECREMENT_EXPR:
1240: case POSTDECREMENT_EXPR:
1241: case MODIFY_EXPR:
1242: case INIT_EXPR:
1243: case TARGET_EXPR:
1244: case CALL_EXPR:
1245: case METHOD_CALL_EXPR:
1246: case RTL_EXPR:
1247: case WRAPPER_EXPR:
1248: case ANTI_WRAPPER_EXPR:
1249: case WITH_CLEANUP_EXPR:
1250: case EXIT_EXPR:
1251: /* We don't warn about COND_EXPR because it may be a useful
1252: construct if either arm contains a side effect. */
1253: case COND_EXPR:
1254: return 0;
1255:
1256: case BIND_EXPR:
1257: /* For a binding, warn if no side effect within it. */
1258: return warn_if_unused_value (TREE_OPERAND (exp, 1));
1259:
1260: case TRUTH_ORIF_EXPR:
1261: case TRUTH_ANDIF_EXPR:
1262: /* In && or ||, warn if 2nd operand has no side effect. */
1263: return warn_if_unused_value (TREE_OPERAND (exp, 1));
1264:
1265: case COMPOUND_EXPR:
1266: if (warn_if_unused_value (TREE_OPERAND (exp, 0)))
1267: return 1;
1268: return warn_if_unused_value (TREE_OPERAND (exp, 1));
1269:
1270: case NOP_EXPR:
1271: case CONVERT_EXPR:
1272: /* Don't warn about values cast to void. */
1273: if (TREE_TYPE (exp) == void_type_node)
1274: return 0;
1275: /* Don't warn about conversions not explicit in the user's program. */
1276: if (TREE_NO_UNUSED_WARNING (exp))
1277: return 0;
1278: /* Assignment to a cast usually results in a cast of a modify.
1279: Don't complain about that. */
1280: if (TREE_CODE (TREE_OPERAND (exp, 0)) == MODIFY_EXPR)
1281: return 0;
1282: /* Sometimes it results in a cast of a cast of a modify.
1283: Don't complain about that. */
1284: if ((TREE_CODE (TREE_OPERAND (exp, 0)) == CONVERT_EXPR
1285: || TREE_CODE (TREE_OPERAND (exp, 0)) == NOP_EXPR)
1286: && TREE_CODE (TREE_OPERAND (TREE_OPERAND (exp, 0), 0)) == MODIFY_EXPR)
1287: return 0;
1288:
1289: default:
1290: warning_with_file_and_line (emit_filename, emit_lineno,
1291: "value computed is not used");
1292: return 1;
1293: }
1294: }
1295:
1296: /* Clear out the memory of the last expression evaluated. */
1297:
1298: void
1299: clear_last_expr ()
1300: {
1301: last_expr_type = 0;
1302: }
1303:
1304: /* Begin a statement which will return a value.
1305: Return the RTL_EXPR for this statement expr.
1306: The caller must save that value and pass it to expand_end_stmt_expr. */
1307:
1308: tree
1309: expand_start_stmt_expr ()
1310: {
1311: /* Make the RTL_EXPR node temporary, not momentary,
1312: so that rtl_expr_chain doesn't become garbage. */
1313: int momentary = suspend_momentary ();
1314: tree t = make_node (RTL_EXPR);
1315: resume_momentary (momentary);
1316: start_sequence ();
1317: NO_DEFER_POP;
1318: expr_stmts_for_value++;
1319: return t;
1320: }
1321:
1322: /* Restore the previous state at the end of a statement that returns a value.
1323: Returns a tree node representing the statement's value and the
1324: insns to compute the value.
1325:
1326: The nodes of that expression have been freed by now, so we cannot use them.
1327: But we don't want to do that anyway; the expression has already been
1328: evaluated and now we just want to use the value. So generate a RTL_EXPR
1329: with the proper type and RTL value.
1330:
1331: If the last substatement was not an expression,
1332: return something with type `void'. */
1333:
1334: tree
1335: expand_end_stmt_expr (t)
1336: tree t;
1337: {
1338: OK_DEFER_POP;
1339:
1340: if (last_expr_type == 0)
1341: {
1342: last_expr_type = void_type_node;
1343: last_expr_value = const0_rtx;
1344: }
1345: else if (last_expr_value == 0)
1346: /* There are some cases where this can happen, such as when the
1347: statement is void type. */
1348: last_expr_value = const0_rtx;
1349: else if (GET_CODE (last_expr_value) != REG && ! CONSTANT_P (last_expr_value))
1350: /* Remove any possible QUEUED. */
1351: last_expr_value = protect_from_queue (last_expr_value, 0);
1352:
1353: emit_queue ();
1354:
1355: TREE_TYPE (t) = last_expr_type;
1356: RTL_EXPR_RTL (t) = last_expr_value;
1357: RTL_EXPR_SEQUENCE (t) = get_insns ();
1358:
1359: rtl_expr_chain = tree_cons (NULL_TREE, t, rtl_expr_chain);
1360:
1361: end_sequence ();
1362:
1363: /* Don't consider deleting this expr or containing exprs at tree level. */
1364: TREE_SIDE_EFFECTS (t) = 1;
1365: /* Propagate volatility of the actual RTL expr. */
1366: TREE_THIS_VOLATILE (t) = volatile_refs_p (last_expr_value);
1367:
1368: last_expr_type = 0;
1369: expr_stmts_for_value--;
1370:
1371: return t;
1372: }
1373:
1374: /* The exception handling nesting looks like this:
1375:
1376: <-- Level N-1
1377: { <-- exception handler block
1378: <-- Level N
1379: <-- in an exception handler
1380: { <-- try block
1381: : <-- in a TRY block
1382: : <-- in an exception handler
1383: :
1384: }
1385:
1386: { <-- except block
1387: : <-- in an except block
1388: : <-- in an exception handler
1389: :
1390: }
1391:
1392: }
1393:
1394: /* Return nonzero iff in a try block at level LEVEL. */
1395:
1396: int
1397: in_try_block (level)
1398: int level;
1399: {
1400: struct nesting *n = except_stack;
1401: while (1)
1402: {
1403: while (n && n->data.except_stmt.after_label != 0)
1404: n = n->next;
1405: if (n == 0)
1406: return 0;
1407: if (level == 0)
1408: return n != 0;
1409: level--;
1410: n = n->next;
1411: }
1412: }
1413:
1414: /* Return nonzero iff in an except block at level LEVEL. */
1415:
1416: int
1417: in_except_block (level)
1418: int level;
1419: {
1420: struct nesting *n = except_stack;
1421: while (1)
1422: {
1423: while (n && n->data.except_stmt.after_label == 0)
1424: n = n->next;
1425: if (n == 0)
1426: return 0;
1427: if (level == 0)
1428: return n != 0;
1429: level--;
1430: n = n->next;
1431: }
1432: }
1433:
1434: /* Return nonzero iff in an exception handler at level LEVEL. */
1435:
1436: int
1437: in_exception_handler (level)
1438: int level;
1439: {
1440: struct nesting *n = except_stack;
1441: while (n && level--)
1442: n = n->next;
1443: return n != 0;
1444: }
1445:
1446: /* Record the fact that the current exception nesting raises
1447: exception EX. If not in an exception handler, return 0. */
1448: int
1449: expand_raise (ex)
1450: tree ex;
1451: {
1452: tree *raises_ptr;
1453:
1454: if (except_stack == 0)
1455: return 0;
1456: raises_ptr = &except_stack->data.except_stmt.raised;
1457: if (! value_member (ex, *raises_ptr))
1458: *raises_ptr = tree_cons (NULL_TREE, ex, *raises_ptr);
1459: return 1;
1460: }
1461:
1462: /* Generate RTL for the start of a try block.
1463:
1464: TRY_CLAUSE is the condition to test to enter the try block. */
1465:
1466: void
1467: expand_start_try (try_clause, exitflag, escapeflag)
1468: tree try_clause;
1469: int exitflag;
1470: int escapeflag;
1471: {
1472: struct nesting *thishandler = ALLOC_NESTING ();
1473:
1474: /* Make an entry on cond_stack for the cond we are entering. */
1475:
1476: thishandler->next = except_stack;
1477: thishandler->all = nesting_stack;
1478: thishandler->depth = ++nesting_depth;
1479: thishandler->data.except_stmt.raised = 0;
1480: thishandler->data.except_stmt.handled = 0;
1481: thishandler->data.except_stmt.first_insn = get_insns ();
1482: thishandler->data.except_stmt.except_label = gen_label_rtx ();
1483: thishandler->data.except_stmt.unhandled_label = 0;
1484: thishandler->data.except_stmt.after_label = 0;
1485: thishandler->data.except_stmt.escape_label
1486: = escapeflag ? thishandler->data.except_stmt.except_label : 0;
1487: thishandler->exit_label = exitflag ? gen_label_rtx () : 0;
1488: except_stack = thishandler;
1489: nesting_stack = thishandler;
1490:
1491: do_jump (try_clause, thishandler->data.except_stmt.except_label, NULL);
1492: }
1493:
1494: /* End of a TRY block. Nothing to do for now. */
1495:
1496: void
1497: expand_end_try ()
1498: {
1499: except_stack->data.except_stmt.after_label = gen_label_rtx ();
1500: expand_goto_internal (NULL, except_stack->data.except_stmt.after_label, 0);
1501: }
1502:
1503: /* Start an `except' nesting contour.
1504: EXITFLAG says whether this contour should be able to `exit' something.
1505: ESCAPEFLAG says whether this contour should be escapable. */
1506:
1507: void
1508: expand_start_except (exitflag, escapeflag)
1509: int exitflag;
1510: int escapeflag;
1511: {
1512: if (exitflag)
1513: {
1514: struct nesting *n;
1515: /* An `exit' from catch clauses goes out to next exit level,
1516: if there is one. Otherwise, it just goes to the end
1517: of the construct. */
1518: for (n = except_stack->next; n; n = n->next)
1519: if (n->exit_label != 0)
1520: {
1521: except_stack->exit_label = n->exit_label;
1522: break;
1523: }
1524: if (n == 0)
1525: except_stack->exit_label = except_stack->data.except_stmt.after_label;
1526: }
1527: if (escapeflag)
1528: {
1529: struct nesting *n;
1530: /* An `escape' from catch clauses goes out to next escape level,
1531: if there is one. Otherwise, it just goes to the end
1532: of the construct. */
1533: for (n = except_stack->next; n; n = n->next)
1534: if (n->data.except_stmt.escape_label != 0)
1535: {
1536: except_stack->data.except_stmt.escape_label
1537: = n->data.except_stmt.escape_label;
1538: break;
1539: }
1540: if (n == 0)
1541: except_stack->data.except_stmt.escape_label
1542: = except_stack->data.except_stmt.after_label;
1543: }
1544: do_pending_stack_adjust ();
1545: emit_label (except_stack->data.except_stmt.except_label);
1546: }
1547:
1548: /* Generate code to `escape' from an exception contour. This
1549: is like `exiting', but does not conflict with constructs which
1550: use `exit_label'.
1551:
1552: Return nonzero if this contour is escapable, otherwise
1553: return zero, and language-specific code will emit the
1554: appropriate error message. */
1555: int
1556: expand_escape_except ()
1557: {
1558: struct nesting *n;
1559: last_expr_type = 0;
1560: for (n = except_stack; n; n = n->next)
1561: if (n->data.except_stmt.escape_label != 0)
1562: {
1563: expand_goto_internal (0, n->data.except_stmt.escape_label, 0);
1564: return 1;
1565: }
1566:
1567: return 0;
1568: }
1569:
1570: /* Finish processing and `except' contour.
1571: Culls out all exceptions which might be raise but not
1572: handled, and returns the list to the caller.
1573: Language-specific code is responsible for dealing with these
1574: exceptions. */
1575:
1576: tree
1577: expand_end_except ()
1578: {
1579: struct nesting *n;
1580: tree raised = NULL_TREE;
1581:
1582: do_pending_stack_adjust ();
1583: emit_label (except_stack->data.except_stmt.after_label);
1584:
1585: n = except_stack->next;
1586: if (n)
1587: {
1588: /* Propagate exceptions raised but not handled to next
1589: highest level. */
1590: tree handled = except_stack->data.except_stmt.raised;
1591: if (handled != void_type_node)
1592: {
1593: tree prev = NULL_TREE;
1594: raised = except_stack->data.except_stmt.raised;
1595: while (handled)
1596: {
1597: tree this_raise;
1598: for (this_raise = raised, prev = 0; this_raise;
1599: this_raise = TREE_CHAIN (this_raise))
1600: {
1601: if (value_member (TREE_VALUE (this_raise), handled))
1602: {
1603: if (prev)
1604: TREE_CHAIN (prev) = TREE_CHAIN (this_raise);
1605: else
1606: {
1607: raised = TREE_CHAIN (raised);
1608: if (raised == NULL_TREE)
1609: goto nada;
1610: }
1611: }
1612: else
1613: prev = this_raise;
1614: }
1615: handled = TREE_CHAIN (handled);
1616: }
1617: if (prev == NULL_TREE)
1618: prev = raised;
1619: if (prev)
1620: TREE_CHAIN (prev) = n->data.except_stmt.raised;
1621: nada:
1622: n->data.except_stmt.raised = raised;
1623: }
1624: }
1625:
1626: POPSTACK (except_stack);
1627: last_expr_type = 0;
1628: return raised;
1629: }
1630:
1631: /* Record that exception EX is caught by this exception handler.
1632: Return nonzero if in exception handling construct, otherwise return 0. */
1633: int
1634: expand_catch (ex)
1635: tree ex;
1636: {
1637: tree *raises_ptr;
1638:
1639: if (except_stack == 0)
1640: return 0;
1641: raises_ptr = &except_stack->data.except_stmt.handled;
1642: if (*raises_ptr != void_type_node
1643: && ex != NULL_TREE
1644: && ! value_member (ex, *raises_ptr))
1645: *raises_ptr = tree_cons (NULL_TREE, ex, *raises_ptr);
1646: return 1;
1647: }
1648:
1649: /* Record that this exception handler catches all exceptions.
1650: Return nonzero if in exception handling construct, otherwise return 0. */
1651:
1652: int
1653: expand_catch_default ()
1654: {
1655: if (except_stack == 0)
1656: return 0;
1657: except_stack->data.except_stmt.handled = void_type_node;
1658: return 1;
1659: }
1660:
1661: int
1662: expand_end_catch ()
1663: {
1664: if (except_stack == 0 || except_stack->data.except_stmt.after_label == 0)
1665: return 0;
1666: expand_goto_internal (0, except_stack->data.except_stmt.after_label, 0);
1667: return 1;
1668: }
1669:
1670: /* Generate RTL for the start of an if-then. COND is the expression
1671: whose truth should be tested.
1672:
1673: If EXITFLAG is nonzero, this conditional is visible to
1674: `exit_something'. */
1675:
1676: void
1677: expand_start_cond (cond, exitflag)
1678: tree cond;
1679: int exitflag;
1680: {
1681: struct nesting *thiscond = ALLOC_NESTING ();
1682:
1683: /* Make an entry on cond_stack for the cond we are entering. */
1684:
1685: thiscond->next = cond_stack;
1686: thiscond->all = nesting_stack;
1687: thiscond->depth = ++nesting_depth;
1688: thiscond->data.cond.next_label = gen_label_rtx ();
1689: /* Before we encounter an `else', we don't need a separate exit label
1690: unless there are supposed to be exit statements
1691: to exit this conditional. */
1692: thiscond->exit_label = exitflag ? gen_label_rtx () : 0;
1693: thiscond->data.cond.endif_label = thiscond->exit_label;
1694: cond_stack = thiscond;
1695: nesting_stack = thiscond;
1696:
1697: do_jump (cond, thiscond->data.cond.next_label, NULL);
1698: }
1699:
1700: /* Generate RTL between then-clause and the elseif-clause
1701: of an if-then-elseif-.... */
1702:
1703: void
1704: expand_start_elseif (cond)
1705: tree cond;
1706: {
1707: if (cond_stack->data.cond.endif_label == 0)
1708: cond_stack->data.cond.endif_label = gen_label_rtx ();
1709: emit_jump (cond_stack->data.cond.endif_label);
1710: emit_label (cond_stack->data.cond.next_label);
1711: cond_stack->data.cond.next_label = gen_label_rtx ();
1712: do_jump (cond, cond_stack->data.cond.next_label, NULL);
1713: }
1714:
1715: /* Generate RTL between the then-clause and the else-clause
1716: of an if-then-else. */
1717:
1718: void
1719: expand_start_else ()
1720: {
1721: if (cond_stack->data.cond.endif_label == 0)
1722: cond_stack->data.cond.endif_label = gen_label_rtx ();
1723: emit_jump (cond_stack->data.cond.endif_label);
1724: emit_label (cond_stack->data.cond.next_label);
1725: cond_stack->data.cond.next_label = 0; /* No more _else or _elseif calls. */
1726: }
1727:
1728: /* Generate RTL for the end of an if-then.
1729: Pop the record for it off of cond_stack. */
1730:
1731: void
1732: expand_end_cond ()
1733: {
1734: struct nesting *thiscond = cond_stack;
1735:
1736: do_pending_stack_adjust ();
1737: if (thiscond->data.cond.next_label)
1738: emit_label (thiscond->data.cond.next_label);
1739: if (thiscond->data.cond.endif_label)
1740: emit_label (thiscond->data.cond.endif_label);
1741:
1742: POPSTACK (cond_stack);
1743: last_expr_type = 0;
1744: }
1745:
1746: /* Generate RTL for the start of a loop. EXIT_FLAG is nonzero if this
1747: loop should be exited by `exit_something'. This is a loop for which
1748: `expand_continue' will jump to the top of the loop.
1749:
1750: Make an entry on loop_stack to record the labels associated with
1751: this loop. */
1752:
1753: struct nesting *
1754: expand_start_loop (exit_flag)
1755: int exit_flag;
1756: {
1757: register struct nesting *thisloop = ALLOC_NESTING ();
1758:
1759: /* Make an entry on loop_stack for the loop we are entering. */
1760:
1761: thisloop->next = loop_stack;
1762: thisloop->all = nesting_stack;
1763: thisloop->depth = ++nesting_depth;
1764: thisloop->data.loop.start_label = gen_label_rtx ();
1765: thisloop->data.loop.end_label = gen_label_rtx ();
1766: thisloop->data.loop.continue_label = thisloop->data.loop.start_label;
1767: thisloop->exit_label = exit_flag ? thisloop->data.loop.end_label : 0;
1768: loop_stack = thisloop;
1769: nesting_stack = thisloop;
1770:
1771: do_pending_stack_adjust ();
1772: emit_queue ();
1773: emit_note (0, NOTE_INSN_LOOP_BEG);
1774: emit_label (thisloop->data.loop.start_label);
1775:
1776: return thisloop;
1777: }
1778:
1779: /* Like expand_start_loop but for a loop where the continuation point
1780: (for expand_continue_loop) will be specified explicitly. */
1781:
1782: struct nesting *
1783: expand_start_loop_continue_elsewhere (exit_flag)
1784: int exit_flag;
1785: {
1786: struct nesting *thisloop = expand_start_loop (exit_flag);
1787: loop_stack->data.loop.continue_label = gen_label_rtx ();
1788: return thisloop;
1789: }
1790:
1791: /* Specify the continuation point for a loop started with
1792: expand_start_loop_continue_elsewhere.
1793: Use this at the point in the code to which a continue statement
1794: should jump. */
1795:
1796: void
1797: expand_loop_continue_here ()
1798: {
1799: do_pending_stack_adjust ();
1800: emit_note (0, NOTE_INSN_LOOP_CONT);
1801: emit_label (loop_stack->data.loop.continue_label);
1802: }
1803:
1804: /* Finish a loop. Generate a jump back to the top and the loop-exit label.
1805: Pop the block off of loop_stack. */
1806:
1807: void
1808: expand_end_loop ()
1809: {
1810: register rtx insn = get_last_insn ();
1811: register rtx start_label = loop_stack->data.loop.start_label;
1812: rtx last_test_insn = 0;
1813: int num_insns = 0;
1814:
1815: /* Mark the continue-point at the top of the loop if none elsewhere. */
1816: if (start_label == loop_stack->data.loop.continue_label)
1817: emit_note_before (NOTE_INSN_LOOP_CONT, start_label);
1818:
1819: do_pending_stack_adjust ();
1820:
1821: /* If optimizing, perhaps reorder the loop. If the loop
1822: starts with a conditional exit, roll that to the end
1823: where it will optimize together with the jump back.
1824:
1825: We look for the last conditional branch to the exit that we encounter
1826: before hitting 30 insns or a CALL_INSN. If we see an unconditional
1827: branch to the exit first, use it.
1828:
1829: We must also stop at NOTE_INSN_BLOCK_BEG and NOTE_INSN_BLOCK_END notes
1830: because moving them is not valid. */
1831:
1832: if (optimize
1833: &&
1834: ! (GET_CODE (insn) == JUMP_INSN
1835: && GET_CODE (PATTERN (insn)) == SET
1836: && SET_DEST (PATTERN (insn)) == pc_rtx
1837: && GET_CODE (SET_SRC (PATTERN (insn))) == IF_THEN_ELSE))
1838: {
1839: /* Scan insns from the top of the loop looking for a qualified
1840: conditional exit. */
1841: for (insn = NEXT_INSN (loop_stack->data.loop.start_label); insn;
1842: insn = NEXT_INSN (insn))
1843: {
1844: if (GET_CODE (insn) == CALL_INSN || GET_CODE (insn) == CODE_LABEL)
1845: break;
1846:
1847: if (GET_CODE (insn) == NOTE
1848: && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG
1849: || NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END))
1850: break;
1851:
1852: if (GET_CODE (insn) == JUMP_INSN || GET_CODE (insn) == INSN)
1853: num_insns++;
1854:
1855: if (last_test_insn && num_insns > 30)
1856: break;
1857:
1858: if (GET_CODE (insn) == JUMP_INSN && GET_CODE (PATTERN (insn)) == SET
1859: && SET_DEST (PATTERN (insn)) == pc_rtx
1860: && GET_CODE (SET_SRC (PATTERN (insn))) == IF_THEN_ELSE
1861: && ((GET_CODE (XEXP (SET_SRC (PATTERN (insn)), 1)) == LABEL_REF
1862: && (XEXP (XEXP (SET_SRC (PATTERN (insn)), 1), 0)
1863: == loop_stack->data.loop.end_label))
1864: || (GET_CODE (XEXP (SET_SRC (PATTERN (insn)), 2)) == LABEL_REF
1865: && (XEXP (XEXP (SET_SRC (PATTERN (insn)), 2), 0)
1866: == loop_stack->data.loop.end_label))))
1867: last_test_insn = insn;
1868:
1869: if (last_test_insn == 0 && GET_CODE (insn) == JUMP_INSN
1870: && GET_CODE (PATTERN (insn)) == SET
1871: && SET_DEST (PATTERN (insn)) == pc_rtx
1872: && GET_CODE (SET_SRC (PATTERN (insn))) == LABEL_REF
1873: && (XEXP (SET_SRC (PATTERN (insn)), 0)
1874: == loop_stack->data.loop.end_label))
1875: /* Include BARRIER. */
1876: last_test_insn = NEXT_INSN (insn);
1877: }
1878:
1879: if (last_test_insn != 0 && last_test_insn != get_last_insn ())
1880: {
1881: /* We found one. Move everything from there up
1882: to the end of the loop, and add a jump into the loop
1883: to jump to there. */
1884: register rtx newstart_label = gen_label_rtx ();
1885: register rtx start_move = start_label;
1886:
1887: /* If the start label is preceeded by a NOTE_INSN_LOOP_CONT note,
1888: then we want to move this note also. */
1889: if (GET_CODE (PREV_INSN (start_move)) == NOTE
1890: && (NOTE_LINE_NUMBER (PREV_INSN (start_move))
1891: == NOTE_INSN_LOOP_CONT))
1892: start_move = PREV_INSN (start_move);
1893:
1894: emit_label_after (newstart_label, PREV_INSN (start_move));
1895: reorder_insns (start_move, last_test_insn, get_last_insn ());
1896: emit_jump_insn_after (gen_jump (start_label),
1897: PREV_INSN (newstart_label));
1898: emit_barrier_after (PREV_INSN (newstart_label));
1899: start_label = newstart_label;
1900: }
1901: }
1902:
1903: emit_jump (start_label);
1904: emit_note (0, NOTE_INSN_LOOP_END);
1905: emit_label (loop_stack->data.loop.end_label);
1906:
1907: POPSTACK (loop_stack);
1908:
1909: last_expr_type = 0;
1910: }
1911:
1912: /* Generate a jump to the current loop's continue-point.
1913: This is usually the top of the loop, but may be specified
1914: explicitly elsewhere. If not currently inside a loop,
1915: return 0 and do nothing; caller will print an error message. */
1916:
1917: int
1918: expand_continue_loop (whichloop)
1919: struct nesting *whichloop;
1920: {
1921: last_expr_type = 0;
1922: if (whichloop == 0)
1923: whichloop = loop_stack;
1924: if (whichloop == 0)
1925: return 0;
1926: expand_goto_internal (0, whichloop->data.loop.continue_label, 0);
1927: return 1;
1928: }
1929:
1930: /* Generate a jump to exit the current loop. If not currently inside a loop,
1931: return 0 and do nothing; caller will print an error message. */
1932:
1933: int
1934: expand_exit_loop (whichloop)
1935: struct nesting *whichloop;
1936: {
1937: last_expr_type = 0;
1938: if (whichloop == 0)
1939: whichloop = loop_stack;
1940: if (whichloop == 0)
1941: return 0;
1942: expand_goto_internal (0, whichloop->data.loop.end_label, 0);
1943: return 1;
1944: }
1945:
1946: /* Generate a conditional jump to exit the current loop if COND
1947: evaluates to zero. If not currently inside a loop,
1948: return 0 and do nothing; caller will print an error message. */
1949:
1950: int
1951: expand_exit_loop_if_false (whichloop, cond)
1952: struct nesting *whichloop;
1953: tree cond;
1954: {
1955: last_expr_type = 0;
1956: if (whichloop == 0)
1957: whichloop = loop_stack;
1958: if (whichloop == 0)
1959: return 0;
1960: do_jump (cond, whichloop->data.loop.end_label, NULL);
1961: return 1;
1962: }
1963:
1964: /* Return non-zero if we should preserve sub-expressions as separate
1965: pseudos. We never do so if we aren't optimizing. We always do so
1966: if -fexpensive-optimizations.
1967:
1968: Otherwise, we only do so if we are in the "early" part of a loop. I.e.,
1969: the loop may still be a small one. */
1970:
1971: int
1972: preserve_subexpressions_p ()
1973: {
1974: rtx insn;
1975:
1976: if (flag_expensive_optimizations)
1977: return 1;
1978:
1979: if (optimize == 0 || loop_stack == 0)
1980: return 0;
1981:
1982: insn = get_last_insn_anywhere ();
1983:
1984: return (insn
1985: && (INSN_UID (insn) - INSN_UID (loop_stack->data.loop.start_label)
1986: < n_non_fixed_regs * 3));
1987:
1988: }
1989:
1990: /* Generate a jump to exit the current loop, conditional, binding contour
1991: or case statement. Not all such constructs are visible to this function,
1992: only those started with EXIT_FLAG nonzero. Individual languages use
1993: the EXIT_FLAG parameter to control which kinds of constructs you can
1994: exit this way.
1995:
1996: If not currently inside anything that can be exited,
1997: return 0 and do nothing; caller will print an error message. */
1998:
1999: int
2000: expand_exit_something ()
2001: {
2002: struct nesting *n;
2003: last_expr_type = 0;
2004: for (n = nesting_stack; n; n = n->all)
2005: if (n->exit_label != 0)
2006: {
2007: expand_goto_internal (0, n->exit_label, 0);
2008: return 1;
2009: }
2010:
2011: return 0;
2012: }
2013:
2014: /* Generate RTL to return from the current function, with no value.
2015: (That is, we do not do anything about returning any value.) */
2016:
2017: void
2018: expand_null_return ()
2019: {
2020: struct nesting *block = block_stack;
2021: rtx last_insn = 0;
2022:
2023: /* Does any pending block have cleanups? */
2024:
2025: while (block && block->data.block.cleanups == 0)
2026: block = block->next;
2027:
2028: /* If yes, use a goto to return, since that runs cleanups. */
2029:
2030: expand_null_return_1 (last_insn, block != 0);
2031: }
2032:
2033: /* Generate RTL to return from the current function, with value VAL. */
2034:
2035: void
2036: expand_value_return (val)
2037: rtx val;
2038: {
2039: struct nesting *block = block_stack;
2040: rtx last_insn = get_last_insn ();
2041: rtx return_reg = DECL_RTL (DECL_RESULT (current_function_decl));
2042:
2043: /* Copy the value to the return location
2044: unless it's already there. */
2045:
2046: if (return_reg != val)
2047: emit_move_insn (return_reg, val);
2048: if (GET_CODE (return_reg) == REG
2049: && REGNO (return_reg) < FIRST_PSEUDO_REGISTER)
2050: emit_insn (gen_rtx (USE, VOIDmode, return_reg));
2051:
2052: /* Does any pending block have cleanups? */
2053:
2054: while (block && block->data.block.cleanups == 0)
2055: block = block->next;
2056:
2057: /* If yes, use a goto to return, since that runs cleanups.
2058: Use LAST_INSN to put cleanups *before* the move insn emitted above. */
2059:
2060: expand_null_return_1 (last_insn, block != 0);
2061: }
2062:
2063: /* Output a return with no value. If LAST_INSN is nonzero,
2064: pretend that the return takes place after LAST_INSN.
2065: If USE_GOTO is nonzero then don't use a return instruction;
2066: go to the return label instead. This causes any cleanups
2067: of pending blocks to be executed normally. */
2068:
2069: static void
2070: expand_null_return_1 (last_insn, use_goto)
2071: rtx last_insn;
2072: int use_goto;
2073: {
2074: rtx end_label = cleanup_label ? cleanup_label : return_label;
2075:
2076: clear_pending_stack_adjust ();
2077: do_pending_stack_adjust ();
2078: last_expr_type = 0;
2079:
2080: /* PCC-struct return always uses an epilogue. */
2081: if (current_function_returns_pcc_struct || use_goto)
2082: {
2083: if (end_label == 0)
2084: end_label = return_label = gen_label_rtx ();
2085: expand_goto_internal (0, end_label, last_insn);
2086: return;
2087: }
2088:
2089: /* Otherwise output a simple return-insn if one is available,
2090: unless it won't do the job. */
2091: #ifdef HAVE_return
2092: if (HAVE_return && use_goto == 0 && cleanup_label == 0)
2093: {
2094: emit_jump_insn (gen_return ());
2095: emit_barrier ();
2096: return;
2097: }
2098: #endif
2099:
2100: /* Otherwise jump to the epilogue. */
2101: expand_goto_internal (0, end_label, last_insn);
2102: }
2103:
2104: /* Generate RTL to evaluate the expression RETVAL and return it
2105: from the current function. */
2106:
2107: void
2108: expand_return (retval)
2109: tree retval;
2110: {
2111: /* If there are any cleanups to be performed, then they will
2112: be inserted following LAST_INSN. It is desirable
2113: that the last_insn, for such purposes, should be the
2114: last insn before computing the return value. Otherwise, cleanups
2115: which call functions can clobber the return value. */
2116: /* ??? rms: I think that is erroneous, because in C++ it would
2117: run destructors on variables that might be used in the subsequent
2118: computation of the return value. */
2119: rtx last_insn = 0;
2120: register rtx val = 0;
2121: register rtx op0;
2122: tree retval_rhs;
2123: int cleanups;
2124: struct nesting *block;
2125:
2126: /* If function wants no value, give it none. */
2127: if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl))) == VOID_TYPE)
2128: {
2129: expand_expr (retval, 0, VOIDmode, 0);
2130: expand_null_return ();
2131: return;
2132: }
2133:
2134: /* Are any cleanups needed? E.g. C++ destructors to be run? */
2135: cleanups = any_pending_cleanups (1);
2136:
2137: if (TREE_CODE (retval) == RESULT_DECL)
2138: retval_rhs = retval;
2139: else if ((TREE_CODE (retval) == MODIFY_EXPR || TREE_CODE (retval) == INIT_EXPR)
2140: && TREE_CODE (TREE_OPERAND (retval, 0)) == RESULT_DECL)
2141: retval_rhs = TREE_OPERAND (retval, 1);
2142: else if (TREE_TYPE (retval) == void_type_node)
2143: /* Recognize tail-recursive call to void function. */
2144: retval_rhs = retval;
2145: else
2146: retval_rhs = NULL_TREE;
2147:
2148: /* Only use `last_insn' if there are cleanups which must be run. */
2149: if (cleanups || cleanup_label != 0)
2150: last_insn = get_last_insn ();
2151:
2152: /* Distribute return down conditional expr if either of the sides
2153: may involve tail recursion (see test below). This enhances the number
2154: of tail recursions we see. Don't do this always since it can produce
2155: sub-optimal code in some cases and we distribute assignments into
2156: conditional expressions when it would help. */
2157:
2158: if (optimize && retval_rhs != 0
2159: && frame_offset == 0
2160: && TREE_CODE (retval_rhs) == COND_EXPR
2161: && (TREE_CODE (TREE_OPERAND (retval_rhs, 1)) == CALL_EXPR
2162: || TREE_CODE (TREE_OPERAND (retval_rhs, 2)) == CALL_EXPR))
2163: {
2164: rtx label = gen_label_rtx ();
2165: do_jump (TREE_OPERAND (retval_rhs, 0), label, 0);
2166: expand_return (build (MODIFY_EXPR, TREE_TYPE (current_function_decl),
2167: DECL_RESULT (current_function_decl),
2168: TREE_OPERAND (retval_rhs, 1)));
2169: emit_label (label);
2170: expand_return (build (MODIFY_EXPR, TREE_TYPE (current_function_decl),
2171: DECL_RESULT (current_function_decl),
2172: TREE_OPERAND (retval_rhs, 2)));
2173: return;
2174: }
2175:
2176: /* For tail-recursive call to current function,
2177: just jump back to the beginning.
2178: It's unsafe if any auto variable in this function
2179: has its address taken; for simplicity,
2180: require stack frame to be empty. */
2181: if (optimize && retval_rhs != 0
2182: && frame_offset == 0
2183: && TREE_CODE (retval_rhs) == CALL_EXPR
2184: && TREE_CODE (TREE_OPERAND (retval_rhs, 0)) == ADDR_EXPR
2185: && TREE_OPERAND (TREE_OPERAND (retval_rhs, 0), 0) == current_function_decl
2186: /* Finish checking validity, and if valid emit code
2187: to set the argument variables for the new call. */
2188: && tail_recursion_args (TREE_OPERAND (retval_rhs, 1),
2189: DECL_ARGUMENTS (current_function_decl)))
2190: {
2191: if (tail_recursion_label == 0)
2192: {
2193: tail_recursion_label = gen_label_rtx ();
2194: emit_label_after (tail_recursion_label,
2195: tail_recursion_reentry);
2196: }
2197: expand_goto_internal (0, tail_recursion_label, last_insn);
2198: emit_barrier ();
2199: return;
2200: }
2201: #ifdef HAVE_return
2202: /* This optimization is safe if there are local cleanups
2203: because expand_null_return takes care of them.
2204: ??? I think it should also be safe when there is a cleanup label,
2205: because expand_null_return takes care of them, too.
2206: Any reason why not? */
2207: if (HAVE_return && cleanup_label == 0
2208: && ! current_function_returns_pcc_struct)
2209: {
2210: /* If this is return x == y; then generate
2211: if (x == y) return 1; else return 0;
2212: if we can do it with explicit return insns. */
2213: if (retval_rhs)
2214: switch (TREE_CODE (retval_rhs))
2215: {
2216: case EQ_EXPR:
2217: case NE_EXPR:
2218: case GT_EXPR:
2219: case GE_EXPR:
2220: case LT_EXPR:
2221: case LE_EXPR:
2222: case TRUTH_ANDIF_EXPR:
2223: case TRUTH_ORIF_EXPR:
2224: case TRUTH_AND_EXPR:
2225: case TRUTH_OR_EXPR:
2226: case TRUTH_NOT_EXPR:
2227: op0 = gen_label_rtx ();
2228: jumpifnot (retval_rhs, op0);
2229: expand_value_return (const1_rtx);
2230: emit_label (op0);
2231: expand_value_return (const0_rtx);
2232: return;
2233: }
2234: }
2235: #endif /* HAVE_return */
2236:
2237: if (cleanups
2238: && retval_rhs != 0
2239: && TREE_TYPE (retval_rhs) != void_type_node
2240: && GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl))) == REG)
2241: {
2242: /* Calculate the return value into a pseudo reg. */
2243: val = expand_expr (retval_rhs, 0, VOIDmode, 0);
2244: emit_queue ();
2245: /* All temporaries have now been used. */
2246: free_temp_slots ();
2247: /* Return the calculated value, doing cleanups first. */
2248: expand_value_return (val);
2249: }
2250: else
2251: {
2252: /* No cleanups or no hard reg used;
2253: calculate value into hard return reg. */
2254: expand_expr (retval, 0, VOIDmode, 0);
2255: emit_queue ();
2256: free_temp_slots ();
2257: expand_value_return (DECL_RTL (DECL_RESULT (current_function_decl)));
2258: }
2259: }
2260:
2261: /* Return 1 if the end of the generated RTX is not a barrier.
2262: This means code already compiled can drop through. */
2263:
2264: int
2265: drop_through_at_end_p ()
2266: {
2267: rtx insn = get_last_insn ();
2268: while (insn && GET_CODE (insn) == NOTE)
2269: insn = PREV_INSN (insn);
2270: return insn && GET_CODE (insn) != BARRIER;
2271: }
2272:
2273: /* Emit code to alter this function's formal parms for a tail-recursive call.
2274: ACTUALS is a list of actual parameter expressions (chain of TREE_LISTs).
2275: FORMALS is the chain of decls of formals.
2276: Return 1 if this can be done;
2277: otherwise return 0 and do not emit any code. */
2278:
2279: static int
2280: tail_recursion_args (actuals, formals)
2281: tree actuals, formals;
2282: {
2283: register tree a = actuals, f = formals;
2284: register int i;
2285: register rtx *argvec;
2286:
2287: /* Check that number and types of actuals are compatible
2288: with the formals. This is not always true in valid C code.
2289: Also check that no formal needs to be addressable
2290: and that all formals are scalars. */
2291:
2292: /* Also count the args. */
2293:
2294: for (a = actuals, f = formals, i = 0; a && f; a = TREE_CHAIN (a), f = TREE_CHAIN (f), i++)
2295: {
2296: if (TREE_TYPE (TREE_VALUE (a)) != TREE_TYPE (f))
2297: return 0;
2298: if (GET_CODE (DECL_RTL (f)) != REG || DECL_MODE (f) == BLKmode)
2299: return 0;
2300: }
2301: if (a != 0 || f != 0)
2302: return 0;
2303:
2304: /* Compute all the actuals. */
2305:
2306: argvec = (rtx *) alloca (i * sizeof (rtx));
2307:
2308: for (a = actuals, i = 0; a; a = TREE_CHAIN (a), i++)
2309: argvec[i] = expand_expr (TREE_VALUE (a), 0, VOIDmode, 0);
2310:
2311: /* Find which actual values refer to current values of previous formals.
2312: Copy each of them now, before any formal is changed. */
2313:
2314: for (a = actuals, i = 0; a; a = TREE_CHAIN (a), i++)
2315: {
2316: int copy = 0;
2317: register int j;
2318: for (f = formals, j = 0; j < i; f = TREE_CHAIN (f), j++)
2319: if (reg_mentioned_p (DECL_RTL (f), argvec[i]))
2320: { copy = 1; break; }
2321: if (copy)
2322: argvec[i] = copy_to_reg (argvec[i]);
2323: }
2324:
2325: /* Store the values of the actuals into the formals. */
2326:
2327: for (f = formals, a = actuals, i = 0; f;
2328: f = TREE_CHAIN (f), a = TREE_CHAIN (a), i++)
2329: {
2330: if (DECL_MODE (f) == GET_MODE (argvec[i]))
2331: emit_move_insn (DECL_RTL (f), argvec[i]);
2332: else
2333: convert_move (DECL_RTL (f), argvec[i],
2334: TREE_UNSIGNED (TREE_TYPE (TREE_VALUE (a))));
2335: }
2336:
2337: free_temp_slots ();
2338: return 1;
2339: }
2340:
2341: /* Generate the RTL code for entering a binding contour.
2342: The variables are declared one by one, by calls to `expand_decl'.
2343:
2344: EXIT_FLAG is nonzero if this construct should be visible to
2345: `exit_something'. */
2346:
2347: void
2348: expand_start_bindings (exit_flag)
2349: int exit_flag;
2350: {
2351: struct nesting *thisblock = ALLOC_NESTING ();
2352:
2353: rtx note = emit_note (0, NOTE_INSN_BLOCK_BEG);
2354:
2355: /* Make an entry on block_stack for the block we are entering. */
2356:
2357: thisblock->next = block_stack;
2358: thisblock->all = nesting_stack;
2359: thisblock->depth = ++nesting_depth;
2360: thisblock->data.block.stack_level = 0;
2361: thisblock->data.block.cleanups = 0;
2362: thisblock->data.block.function_call_count = 0;
2363: #if 0
2364: if (block_stack)
2365: {
2366: if (block_stack->data.block.cleanups == NULL_TREE
2367: && (block_stack->data.block.outer_cleanups == NULL_TREE
2368: || block_stack->data.block.outer_cleanups == empty_cleanup_list))
2369: thisblock->data.block.outer_cleanups = empty_cleanup_list;
2370: else
2371: thisblock->data.block.outer_cleanups
2372: = tree_cons (NULL_TREE, block_stack->data.block.cleanups,
2373: block_stack->data.block.outer_cleanups);
2374: }
2375: else
2376: thisblock->data.block.outer_cleanups = 0;
2377: #endif
2378: #if 1
2379: if (block_stack
2380: && !(block_stack->data.block.cleanups == NULL_TREE
2381: && block_stack->data.block.outer_cleanups == NULL_TREE))
2382: thisblock->data.block.outer_cleanups
2383: = tree_cons (NULL_TREE, block_stack->data.block.cleanups,
2384: block_stack->data.block.outer_cleanups);
2385: else
2386: thisblock->data.block.outer_cleanups = 0;
2387: #endif
2388: thisblock->data.block.label_chain = 0;
2389: thisblock->data.block.innermost_stack_block = stack_block_stack;
2390: thisblock->data.block.first_insn = note;
2391: thisblock->data.block.block_start_count = ++block_start_count;
2392: thisblock->exit_label = exit_flag ? gen_label_rtx () : 0;
2393: block_stack = thisblock;
2394: nesting_stack = thisblock;
2395:
2396: /* Make a new level for allocating stack slots. */
2397: push_temp_slots ();
2398: }
2399:
2400: /* Generate RTL code to terminate a binding contour.
2401: VARS is the chain of VAR_DECL nodes
2402: for the variables bound in this contour.
2403: MARK_ENDS is nonzero if we should put a note at the beginning
2404: and end of this binding contour.
2405:
2406: DONT_JUMP_IN is nonzero if it is not valid to jump into this contour.
2407: (That is true automatically if the contour has a saved stack level.) */
2408:
2409: void
2410: expand_end_bindings (vars, mark_ends, dont_jump_in)
2411: tree vars;
2412: int mark_ends;
2413: int dont_jump_in;
2414: {
2415: register struct nesting *thisblock = block_stack;
2416: register tree decl;
2417:
2418: if (warn_unused)
2419: for (decl = vars; decl; decl = TREE_CHAIN (decl))
2420: if (! TREE_USED (decl) && TREE_CODE (decl) == VAR_DECL)
2421: warning_with_decl (decl, "unused variable `%s'");
2422:
2423: /* Mark the beginning and end of the scope if requested. */
2424:
2425: if (mark_ends)
2426: emit_note (0, NOTE_INSN_BLOCK_END);
2427: else
2428: /* Get rid of the beginning-mark if we don't make an end-mark. */
2429: NOTE_LINE_NUMBER (thisblock->data.block.first_insn) = NOTE_INSN_DELETED;
2430:
2431: if (thisblock->exit_label)
2432: {
2433: do_pending_stack_adjust ();
2434: emit_label (thisblock->exit_label);
2435: }
2436:
2437: /* If necessary, make a handler for nonlocal gotos taking
2438: place in the function calls in this block. */
2439: if (function_call_count != thisblock->data.block.function_call_count
2440: && nonlocal_labels
2441: /* Make handler for outermost block
2442: if there were any nonlocal gotos to this function. */
2443: && (thisblock->next == 0 ? current_function_has_nonlocal_label
2444: /* Make handler for inner block if it has something
2445: special to do when you jump out of it. */
2446: : (thisblock->data.block.cleanups != 0
2447: || thisblock->data.block.stack_level != 0)))
2448: {
2449: tree link;
2450: rtx afterward = gen_label_rtx ();
2451: rtx handler_label = gen_label_rtx ();
2452: rtx save_receiver = gen_reg_rtx (Pmode);
2453:
2454: /* Don't let jump_optimize delete the handler. */
2455: LABEL_PRESERVE_P (handler_label) = 1;
2456:
2457: /* Record the handler address in the stack slot for that purpose,
2458: during this block, saving and restoring the outer value. */
2459: if (thisblock->next != 0)
2460: {
2461: emit_move_insn (nonlocal_goto_handler_slot, save_receiver);
2462: emit_insn_before (gen_move_insn (save_receiver,
2463: nonlocal_goto_handler_slot),
2464: thisblock->data.block.first_insn);
2465: }
2466: emit_insn_before (gen_move_insn (nonlocal_goto_handler_slot,
2467: gen_rtx (LABEL_REF, Pmode,
2468: handler_label)),
2469: thisblock->data.block.first_insn);
2470:
2471: /* Jump around the handler; it runs only when specially invoked. */
2472: emit_jump (afterward);
2473: emit_label (handler_label);
2474:
2475: #ifdef HAVE_nonlocal_goto
2476: if (! HAVE_nonlocal_goto)
2477: #endif
2478: /* First adjust our frame pointer to its actual value. It was
2479: previously set to the start of the virtual area corresponding to
2480: the stacked variables when we branched here and now needs to be
2481: adjusted to the actual hardware fp value.
2482:
2483: Assignments are to virtual registers are converted by
2484: instantiate_virtual_regs into the corresponding assignment
2485: to the underlying register (fp in this case) that makes
2486: the original assignment true.
2487: So the following insn will actually be
2488: decrementing fp by STARTING_FRAME_OFFSET. */
2489: emit_move_insn (virtual_stack_vars_rtx, frame_pointer_rtx);
2490:
2491: #if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
2492: if (fixed_regs[ARG_POINTER_REGNUM])
2493: {
2494: /* Now restore our arg pointer from the address at which it was saved
2495: in our stack frame.
2496: If there hasn't be space allocated for it yet, make some now. */
2497: if (arg_pointer_save_area == 0)
2498: arg_pointer_save_area
2499: = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0);
2500: emit_move_insn (virtual_incoming_args_rtx, arg_pointer_save_area);
2501: }
2502: #endif
2503:
2504: /* The handler expects the desired label address in the static chain
2505: register. It tests the address and does an appropriate jump
2506: to whatever label is desired. */
2507: for (link = nonlocal_labels; link; link = TREE_CHAIN (link))
2508: /* Skip any labels we shouldn't be able to jump to from here. */
2509: if (! DECL_TOO_LATE (TREE_VALUE (link)))
2510: {
2511: rtx not_this = gen_label_rtx ();
2512: rtx this = gen_label_rtx ();
2513: do_jump_if_equal (static_chain_rtx,
2514: gen_rtx (LABEL_REF, Pmode, DECL_RTL (TREE_VALUE (link))),
2515: this, 0);
2516: emit_jump (not_this);
2517: emit_label (this);
2518: expand_goto (TREE_VALUE (link));
2519: emit_label (not_this);
2520: }
2521: /* If label is not recognized, abort. */
2522: emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "abort"), 0,
2523: VOIDmode, 0);
2524: emit_label (afterward);
2525: }
2526:
2527: /* Don't allow jumping into a block that has cleanups or a stack level. */
2528: if (dont_jump_in
2529: || thisblock->data.block.stack_level != 0
2530: || thisblock->data.block.cleanups != 0)
2531: {
2532: struct label_chain *chain;
2533:
2534: /* Any labels in this block are no longer valid to go to.
2535: Mark them to cause an error message. */
2536: for (chain = thisblock->data.block.label_chain; chain; chain = chain->next)
2537: {
2538: DECL_TOO_LATE (chain->label) = 1;
2539: /* If any goto without a fixup came to this label,
2540: that must be an error, because gotos without fixups
2541: come from outside all saved stack-levels and all cleanups. */
2542: if (TREE_ADDRESSABLE (chain->label))
2543: error_with_decl (chain->label,
2544: "label `%s' used before containing binding contour");
2545: }
2546: }
2547:
2548: /* Restore stack level in effect before the block
2549: (only if variable-size objects allocated). */
2550: /* Perform any cleanups associated with the block. */
2551:
2552: if (thisblock->data.block.stack_level != 0
2553: || thisblock->data.block.cleanups != 0)
2554: {
2555: /* Don't let cleanups affect ({...}) constructs. */
2556: int old_expr_stmts_for_value = expr_stmts_for_value;
2557: rtx old_last_expr_value = last_expr_value;
2558: tree old_last_expr_type = last_expr_type;
2559: expr_stmts_for_value = 0;
2560:
2561: /* Do the cleanups. */
2562: expand_cleanups (thisblock->data.block.cleanups, 0);
2563: do_pending_stack_adjust ();
2564:
2565: expr_stmts_for_value = old_expr_stmts_for_value;
2566: last_expr_value = old_last_expr_value;
2567: last_expr_type = old_last_expr_type;
2568:
2569: /* Restore the stack level. */
2570:
2571: if (thisblock->data.block.stack_level != 0)
2572: {
2573: emit_move_insn (stack_pointer_rtx,
2574: thisblock->data.block.stack_level);
2575: if (nonlocal_goto_stack_level != 0)
2576: emit_move_insn (nonlocal_goto_stack_level, stack_pointer_rtx);
2577: }
2578:
2579: /* Any gotos out of this block must also do these things.
2580: Also report any gotos with fixups that came to labels in this level. */
2581: fixup_gotos (thisblock,
2582: thisblock->data.block.stack_level,
2583: thisblock->data.block.cleanups,
2584: thisblock->data.block.first_insn,
2585: dont_jump_in);
2586: }
2587:
2588: /* If doing stupid register allocation, make sure lives of all
2589: register variables declared here extend thru end of scope. */
2590:
2591: if (obey_regdecls)
2592: for (decl = vars; decl; decl = TREE_CHAIN (decl))
2593: {
2594: rtx rtl = DECL_RTL (decl);
2595: if (TREE_CODE (decl) == VAR_DECL && rtl != 0)
2596: use_variable (rtl);
2597: }
2598:
2599: /* Restore block_stack level for containing block. */
2600:
2601: stack_block_stack = thisblock->data.block.innermost_stack_block;
2602: POPSTACK (block_stack);
2603:
2604: /* Pop the stack slot nesting and free any slots at this level. */
2605: pop_temp_slots ();
2606: }
2607:
2608: /* Generate RTL for the automatic variable declaration DECL.
2609: (Other kinds of declarations are simply ignored if seen here.)
2610: CLEANUP is an expression to be executed at exit from this binding contour;
2611: for example, in C++, it might call the destructor for this variable.
2612:
2613: If CLEANUP contains any SAVE_EXPRs, then you must preevaluate them
2614: either before or after calling `expand_decl' but before compiling
2615: any subsequent expressions. This is because CLEANUP may be expanded
2616: more than once, on different branches of execution.
2617: For the same reason, CLEANUP may not contain a CALL_EXPR
2618: except as its topmost node--else `preexpand_calls' would get confused.
2619:
2620: If CLEANUP is nonzero and DECL is zero, we record a cleanup
2621: that is not associated with any particular variable.
2622:
2623: There is no special support here for C++ constructors.
2624: They should be handled by the proper code in DECL_INITIAL. */
2625:
2626: void
2627: expand_decl (decl)
2628: register tree decl;
2629: {
2630: struct nesting *thisblock = block_stack;
2631: tree type = TREE_TYPE (decl);
2632:
2633: /* Only automatic variables need any expansion done.
2634: Static and external variables, and external functions,
2635: will be handled by `assemble_variable' (called from finish_decl).
2636: TYPE_DECL and CONST_DECL require nothing.
2637: PARM_DECLs are handled in `assign_parms'. */
2638:
2639: if (TREE_CODE (decl) != VAR_DECL)
2640: return;
2641: if (TREE_STATIC (decl) || TREE_EXTERNAL (decl))
2642: return;
2643:
2644: /* Create the RTL representation for the variable. */
2645:
2646: if (type == error_mark_node)
2647: DECL_RTL (decl) = gen_rtx (MEM, BLKmode, const0_rtx);
2648: else if (DECL_SIZE (decl) == 0)
2649: /* Variable with incomplete type. */
2650: {
2651: if (DECL_INITIAL (decl) == 0)
2652: /* Error message was already done; now avoid a crash. */
2653: DECL_RTL (decl) = assign_stack_temp (DECL_MODE (decl), 0, 1);
2654: else
2655: /* An initializer is going to decide the size of this array.
2656: Until we know the size, represent its address with a reg. */
2657: DECL_RTL (decl) = gen_rtx (MEM, BLKmode, gen_reg_rtx (Pmode));
2658: }
2659: else if (DECL_MODE (decl) != BLKmode
2660: /* If -ffloat-store, don't put explicit float vars
2661: into regs. */
2662: && !(flag_float_store
2663: && TREE_CODE (type) == REAL_TYPE)
2664: && ! TREE_THIS_VOLATILE (decl)
2665: && ! TREE_ADDRESSABLE (decl)
2666: && (TREE_REGDECL (decl) || ! obey_regdecls))
2667: {
2668: /* Automatic variable that can go in a register. */
2669: DECL_RTL (decl) = gen_reg_rtx (DECL_MODE (decl));
2670: if (TREE_CODE (type) == POINTER_TYPE)
2671: mark_reg_pointer (DECL_RTL (decl));
2672: REG_USERVAR_P (DECL_RTL (decl)) = 1;
2673: }
2674: else if (TREE_CODE (DECL_SIZE (decl)) == INTEGER_CST)
2675: {
2676: /* Variable of fixed size that goes on the stack. */
2677: rtx oldaddr = 0;
2678: rtx addr;
2679:
2680: /* If we previously made RTL for this decl, it must be an array
2681: whose size was determined by the initializer.
2682: The old address was a register; set that register now
2683: to the proper address. */
2684: if (DECL_RTL (decl) != 0)
2685: {
2686: if (GET_CODE (DECL_RTL (decl)) != MEM
2687: || GET_CODE (XEXP (DECL_RTL (decl), 0)) != REG)
2688: abort ();
2689: oldaddr = XEXP (DECL_RTL (decl), 0);
2690: }
2691:
2692: DECL_RTL (decl)
2693: = assign_stack_temp (DECL_MODE (decl),
2694: ((TREE_INT_CST_LOW (DECL_SIZE (decl))
2695: + BITS_PER_UNIT - 1)
2696: / BITS_PER_UNIT),
2697: 1);
2698:
2699: /* Set alignment we actually gave this decl. */
2700: DECL_ALIGN (decl) = (DECL_MODE (decl) == BLKmode ? BIGGEST_ALIGNMENT
2701: : GET_MODE_BITSIZE (DECL_MODE (decl)));
2702:
2703: if (oldaddr)
2704: {
2705: addr = force_operand (XEXP (DECL_RTL (decl), 0), oldaddr);
2706: if (addr != oldaddr)
2707: emit_move_insn (oldaddr, addr);
2708: }
2709:
2710: /* If this is a memory ref that contains aggregate components,
2711: mark it as such for cse and loop optimize. */
2712: MEM_IN_STRUCT_P (DECL_RTL (decl))
2713: = (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
2714: || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
2715: || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE);
2716: #if 0
2717: /* If this is in memory because of -ffloat-store,
2718: set the volatile bit, to prevent optimizations from
2719: undoing the effects. */
2720: if (flag_float_store && TREE_CODE (type) == REAL_TYPE)
2721: MEM_VOLATILE_P (DECL_RTL (decl)) = 1;
2722: #endif
2723: }
2724: else
2725: /* Dynamic-size object: must push space on the stack. */
2726: {
2727: rtx address, size;
2728:
2729: /* Record the stack pointer on entry to block, if have
2730: not already done so. */
2731: if (thisblock->data.block.stack_level == 0)
2732: {
2733: do_pending_stack_adjust ();
2734: thisblock->data.block.stack_level
2735: = copy_to_reg (stack_pointer_rtx);
2736: stack_block_stack = thisblock;
2737: }
2738:
2739: /* Compute the variable's size, in bytes. */
2740: size = expand_expr (size_binop (CEIL_DIV_EXPR,
2741: DECL_SIZE (decl),
2742: size_int (BITS_PER_UNIT)),
2743: 0, VOIDmode, 0);
2744: free_temp_slots ();
2745:
2746: /* Allocate space on the stack for the variable. */
2747: address = allocate_dynamic_stack_space (size, 0);
2748:
2749: if (nonlocal_goto_stack_level != 0)
2750: emit_move_insn (nonlocal_goto_stack_level, stack_pointer_rtx);
2751:
2752: /* Reference the variable indirect through that rtx. */
2753: DECL_RTL (decl) = gen_rtx (MEM, DECL_MODE (decl), address);
2754:
2755: /* Indicate the alignment we actually gave this variable. */
2756: #ifdef STACK_BOUNDARY
2757: DECL_ALIGN (decl) = STACK_BOUNDARY;
2758: #else
2759: DECL_ALIGN (decl) = BIGGEST_ALIGNMENT;
2760: #endif
2761: }
2762:
2763: if (TREE_THIS_VOLATILE (decl))
2764: MEM_VOLATILE_P (DECL_RTL (decl)) = 1;
2765: if (TREE_READONLY (decl))
2766: RTX_UNCHANGING_P (DECL_RTL (decl)) = 1;
2767:
2768: /* If doing stupid register allocation, make sure life of any
2769: register variable starts here, at the start of its scope. */
2770:
2771: if (obey_regdecls)
2772: use_variable (DECL_RTL (decl));
2773: }
2774:
2775: /* Emit code to perform the initialization of a declaration DECL. */
2776:
2777: void
2778: expand_decl_init (decl)
2779: tree decl;
2780: {
2781: if (TREE_STATIC (decl))
2782: return;
2783:
2784: /* Compute and store the initial value now. */
2785:
2786: if (DECL_INITIAL (decl) == error_mark_node)
2787: {
2788: enum tree_code code = TREE_CODE (TREE_TYPE (decl));
2789: if (code == INTEGER_TYPE || code == REAL_TYPE || code == ENUMERAL_TYPE
2790: || code == POINTER_TYPE)
2791: expand_assignment (decl, convert (TREE_TYPE (decl), integer_zero_node),
2792: 0, 0);
2793: emit_queue ();
2794: }
2795: else if (DECL_INITIAL (decl) && TREE_CODE (DECL_INITIAL (decl)) != TREE_LIST)
2796: {
2797: emit_line_note (DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
2798: expand_assignment (decl, DECL_INITIAL (decl), 0, 0);
2799: emit_queue ();
2800: }
2801:
2802: /* Free any temporaries we made while initializing the decl. */
2803: free_temp_slots ();
2804: }
2805:
2806: /* CLEANUP is an expression to be executed at exit from this binding contour;
2807: for example, in C++, it might call the destructor for this variable.
2808:
2809: If CLEANUP contains any SAVE_EXPRs, then you must preevaluate them
2810: either before or after calling `expand_decl' but before compiling
2811: any subsequent expressions. This is because CLEANUP may be expanded
2812: more than once, on different branches of execution.
2813: For the same reason, CLEANUP may not contain a CALL_EXPR
2814: except as its topmost node--else `preexpand_calls' would get confused.
2815:
2816: If CLEANUP is nonzero and DECL is zero, we record a cleanup
2817: that is not associated with any particular variable. */
2818:
2819: int
2820: expand_decl_cleanup (decl, cleanup)
2821: tree decl, cleanup;
2822: {
2823: struct nesting *thisblock = block_stack;
2824:
2825: /* Error if we are not in any block. */
2826: if (thisblock == 0)
2827: return 0;
2828:
2829: /* Record the cleanup if there is one. */
2830:
2831: if (cleanup != 0)
2832: {
2833: thisblock->data.block.cleanups
2834: = temp_tree_cons (decl, cleanup, thisblock->data.block.cleanups);
2835: /* If this block has a cleanup, it belongs in stack_block_stack. */
2836: stack_block_stack = thisblock;
2837: }
2838: return 1;
2839: }
2840:
2841: /* DECL is an anonymous union. CLEANUP is a cleanup for DECL.
2842: DECL_ELTS is the list of elements that belong to DECL's type.
2843: In each, the TREE_VALUE is a VAR_DECL, and the TREE_PURPOSE a cleanup. */
2844:
2845: void
2846: expand_anon_union_decl (decl, cleanup, decl_elts)
2847: tree decl, cleanup, decl_elts;
2848: {
2849: struct nesting *thisblock = block_stack;
2850: rtx x;
2851:
2852: expand_decl (decl, cleanup);
2853: x = DECL_RTL (decl);
2854:
2855: while (decl_elts)
2856: {
2857: tree decl_elt = TREE_VALUE (decl_elts);
2858: tree cleanup_elt = TREE_PURPOSE (decl_elts);
2859: enum machine_mode mode = TYPE_MODE (TREE_TYPE (decl_elt));
2860:
2861: /* (SUBREG (MEM ...)) at RTL generation time is invalid, so we
2862: instead create a new MEM rtx with the proper mode. */
2863: if (GET_CODE (x) == MEM)
2864: {
2865: if (mode == GET_MODE (x))
2866: DECL_RTL (decl_elt) = x;
2867: else
2868: {
2869: DECL_RTL (decl_elt) = gen_rtx (MEM, mode, copy_rtx (XEXP (x, 0)));
2870: MEM_IN_STRUCT_P (DECL_RTL (decl_elt)) = MEM_IN_STRUCT_P (x);
2871: RTX_UNCHANGING_P (DECL_RTL (decl_elt)) = RTX_UNCHANGING_P (x);
2872: }
2873: }
2874: else if (GET_CODE (x) == REG)
2875: {
2876: if (mode == GET_MODE (x))
2877: DECL_RTL (decl_elt) = x;
2878: else
2879: DECL_RTL (decl_elt) = gen_rtx (SUBREG, mode, x, 0);
2880: }
2881: else
2882: abort ();
2883:
2884: /* Record the cleanup if there is one. */
2885:
2886: if (cleanup != 0)
2887: thisblock->data.block.cleanups
2888: = temp_tree_cons (decl_elt, cleanup_elt,
2889: thisblock->data.block.cleanups);
2890:
2891: decl_elts = TREE_CHAIN (decl_elts);
2892: }
2893: }
2894:
2895: /* Expand a list of cleanups LIST.
2896: Elements may be expressions or may be nested lists.
2897:
2898: If DONT_DO is nonnull, then any list-element
2899: whose TREE_PURPOSE matches DONT_DO is omitted.
2900: This is sometimes used to avoid a cleanup associated with
2901: a value that is being returned out of the scope. */
2902:
2903: static void
2904: expand_cleanups (list, dont_do)
2905: tree list;
2906: tree dont_do;
2907: {
2908: tree tail;
2909: for (tail = list; tail; tail = TREE_CHAIN (tail))
2910: if (dont_do == 0 || TREE_PURPOSE (tail) != dont_do)
2911: {
2912: if (TREE_CODE (TREE_VALUE (tail)) == TREE_LIST)
2913: expand_cleanups (TREE_VALUE (tail), dont_do);
2914: else
2915: {
2916: /* Cleanups may be run multiple times. For example,
2917: when exiting a binding contour, we expand the
2918: cleanups associated with that contour. When a goto
2919: within that binding contour has a target outside that
2920: contour, it will expand all cleanups from its scope to
2921: the target. Though the cleanups are expanded multiple
2922: times, the control paths are non-overlapping so the
2923: cleanups will not be executed twice. */
2924: expand_expr (TREE_VALUE (tail), const0_rtx, VOIDmode, 0);
2925: free_temp_slots ();
2926: }
2927: }
2928: }
2929:
2930: /* Expand a list of cleanups for a goto fixup.
2931: The expansion is put into the insn chain after the insn *BEFORE_JUMP
2932: and *BEFORE_JUMP is set to the insn that now comes before the jump. */
2933:
2934: static void
2935: fixup_cleanups (list, before_jump)
2936: tree list;
2937: rtx *before_jump;
2938: {
2939: rtx beyond_jump = get_last_insn ();
2940: rtx new_before_jump;
2941:
2942: expand_cleanups (list, 0);
2943: /* Pop any pushes done in the cleanups,
2944: in case function is about to return. */
2945: do_pending_stack_adjust ();
2946:
2947: new_before_jump = get_last_insn ();
2948:
2949: if (beyond_jump != new_before_jump)
2950: {
2951: /* If cleanups expand to nothing, don't reorder. */
2952: reorder_insns (NEXT_INSN (beyond_jump), new_before_jump, *before_jump);
2953: *before_jump = new_before_jump;
2954: }
2955: }
2956:
2957: /* Move all cleanups from the current block_stack
2958: to the containing block_stack, where they are assumed to
2959: have been created. If anything can cause a temporary to
2960: be created, but not expanded for more than one level of
2961: block_stacks, then this code will have to change. */
2962:
2963: void
2964: move_cleanups_up ()
2965: {
2966: struct nesting *block = block_stack;
2967: struct nesting *outer = block->next;
2968:
2969: outer->data.block.cleanups
2970: = chainon (block->data.block.cleanups,
2971: outer->data.block.cleanups);
2972: block->data.block.cleanups = 0;
2973: }
2974:
2975: tree
2976: last_cleanup_this_contour ()
2977: {
2978: if (block_stack == 0)
2979: return 0;
2980:
2981: return block_stack->data.block.cleanups;
2982: }
2983:
2984: /* Return 1 if there are any pending cleanups at this point.
2985: If THIS_CONTOUR is nonzero, check the current contour as well.
2986: Otherwise, look only at the contours that enclose this one. */
2987:
2988: int
2989: any_pending_cleanups (this_contour)
2990: int this_contour;
2991: {
2992: struct nesting *block;
2993:
2994: if (block_stack == 0)
2995: return 0;
2996:
2997: if (this_contour && block_stack->data.block.cleanups != NULL)
2998: return 1;
2999: if (block_stack->data.block.cleanups == 0
3000: && (block_stack->data.block.outer_cleanups == 0
3001: #if 0
3002: || block_stack->data.block.outer_cleanups == empty_cleanup_list
3003: #endif
3004: ))
3005: return 0;
3006:
3007: for (block = block_stack->next; block; block = block->next)
3008: if (block->data.block.cleanups != 0)
3009: return 1;
3010:
3011: return 0;
3012: }
3013:
3014: /* Enter a case (Pascal) or switch (C) statement.
3015: Push a block onto case_stack and nesting_stack
3016: to accumulate the case-labels that are seen
3017: and to record the labels generated for the statement.
3018:
3019: EXIT_FLAG is nonzero if `exit_something' should exit this case stmt.
3020: Otherwise, this construct is transparent for `exit_something'.
3021:
3022: EXPR is the index-expression to be dispatched on.
3023: TYPE is its nominal type. We could simply convert EXPR to this type,
3024: but instead we take short cuts. */
3025:
3026: void
3027: expand_start_case (exit_flag, expr, type, printname)
3028: int exit_flag;
3029: tree expr;
3030: tree type;
3031: char *printname;
3032: {
3033: register struct nesting *thiscase = ALLOC_NESTING ();
3034:
3035: /* Make an entry on case_stack for the case we are entering. */
3036:
3037: thiscase->next = case_stack;
3038: thiscase->all = nesting_stack;
3039: thiscase->depth = ++nesting_depth;
3040: thiscase->exit_label = exit_flag ? gen_label_rtx () : 0;
3041: thiscase->data.case_stmt.case_list = 0;
3042: thiscase->data.case_stmt.index_expr = expr;
3043: thiscase->data.case_stmt.nominal_type = type;
3044: thiscase->data.case_stmt.default_label = 0;
3045: thiscase->data.case_stmt.num_ranges = 0;
3046: thiscase->data.case_stmt.printname = printname;
3047: thiscase->data.case_stmt.seenlabel = 0;
3048: case_stack = thiscase;
3049: nesting_stack = thiscase;
3050:
3051: do_pending_stack_adjust ();
3052:
3053: /* Make sure case_stmt.start points to something that won't
3054: need any transformation before expand_end_case. */
3055: if (GET_CODE (get_last_insn ()) != NOTE)
3056: emit_note (0, NOTE_INSN_DELETED);
3057:
3058: thiscase->data.case_stmt.start = get_last_insn ();
3059: }
3060:
3061: /* Start a "dummy case statement" within which case labels are invalid
3062: and are not connected to any larger real case statement.
3063: This can be used if you don't want to let a case statement jump
3064: into the middle of certain kinds of constructs. */
3065:
3066: void
3067: expand_start_case_dummy ()
3068: {
3069: register struct nesting *thiscase = ALLOC_NESTING ();
3070:
3071: /* Make an entry on case_stack for the dummy. */
3072:
3073: thiscase->next = case_stack;
3074: thiscase->all = nesting_stack;
3075: thiscase->depth = ++nesting_depth;
3076: thiscase->exit_label = 0;
3077: thiscase->data.case_stmt.case_list = 0;
3078: thiscase->data.case_stmt.start = 0;
3079: thiscase->data.case_stmt.nominal_type = 0;
3080: thiscase->data.case_stmt.default_label = 0;
3081: thiscase->data.case_stmt.num_ranges = 0;
3082: case_stack = thiscase;
3083: nesting_stack = thiscase;
3084: }
3085:
3086: /* End a dummy case statement. */
3087:
3088: void
3089: expand_end_case_dummy ()
3090: {
3091: POPSTACK (case_stack);
3092: }
3093:
3094: /* Return the data type of the index-expression
3095: of the innermost case statement, or null if none. */
3096:
3097: tree
3098: case_index_expr_type ()
3099: {
3100: if (case_stack)
3101: return TREE_TYPE (case_stack->data.case_stmt.index_expr);
3102: return 0;
3103: }
3104:
3105: /* Accumulate one case or default label inside a case or switch statement.
3106: VALUE is the value of the case (a null pointer, for a default label).
3107:
3108: If not currently inside a case or switch statement, return 1 and do
3109: nothing. The caller will print a language-specific error message.
3110: If VALUE is a duplicate or overlaps, return 2 and do nothing
3111: except store the (first) duplicate node in *DUPLICATE.
3112: If VALUE is out of range, return 3 and do nothing.
3113: If we are jumping into the scope of a cleaup or var-sized array, return 5.
3114: Return 0 on success.
3115:
3116: Extended to handle range statements. */
3117:
3118: int
3119: pushcase (value, label, duplicate)
3120: register tree value;
3121: register tree label;
3122: tree *duplicate;
3123: {
3124: register struct case_node **l;
3125: register struct case_node *n;
3126: tree index_type;
3127: tree nominal_type;
3128:
3129: /* Fail if not inside a real case statement. */
3130: if (! (case_stack && case_stack->data.case_stmt.start))
3131: return 1;
3132:
3133: if (stack_block_stack
3134: && stack_block_stack->depth > case_stack->depth)
3135: return 5;
3136:
3137: index_type = TREE_TYPE (case_stack->data.case_stmt.index_expr);
3138: nominal_type = case_stack->data.case_stmt.nominal_type;
3139:
3140: /* If the index is erroneous, avoid more problems: pretend to succeed. */
3141: if (index_type == error_mark_node)
3142: return 0;
3143:
3144: /* Convert VALUE to the type in which the comparisons are nominally done. */
3145: if (value != 0)
3146: value = convert (nominal_type, value);
3147:
3148: /* If this is the first label, warn if any insns have been emitted. */
3149: if (case_stack->data.case_stmt.seenlabel == 0)
3150: {
3151: rtx insn;
3152: for (insn = case_stack->data.case_stmt.start;
3153: insn;
3154: insn = NEXT_INSN (insn))
3155: {
3156: if (GET_CODE (insn) == CODE_LABEL)
3157: break;
3158: if (GET_CODE (insn) != NOTE
3159: && (GET_CODE (insn) != INSN || GET_CODE (PATTERN (insn)) != USE))
3160: {
3161: warning ("unreachable code at beginning of %s",
3162: case_stack->data.case_stmt.printname);
3163: break;
3164: }
3165: }
3166: }
3167: case_stack->data.case_stmt.seenlabel = 1;
3168:
3169: /* Fail if this value is out of range for the actual type of the index
3170: (which may be narrower than NOMINAL_TYPE). */
3171: if (value != 0 && ! int_fits_type_p (value, index_type))
3172: return 3;
3173:
3174: /* Fail if this is a duplicate or overlaps another entry. */
3175: if (value == 0)
3176: {
3177: if (case_stack->data.case_stmt.default_label != 0)
3178: {
3179: *duplicate = case_stack->data.case_stmt.default_label;
3180: return 2;
3181: }
3182: case_stack->data.case_stmt.default_label = label;
3183: }
3184: else
3185: {
3186: /* Find the elt in the chain before which to insert the new value,
3187: to keep the chain sorted in increasing order.
3188: But report an error if this element is a duplicate. */
3189: for (l = &case_stack->data.case_stmt.case_list;
3190: /* Keep going past elements distinctly less than VALUE. */
3191: *l != 0 && tree_int_cst_lt ((*l)->high, value);
3192: l = &(*l)->right)
3193: ;
3194: if (*l)
3195: {
3196: /* Element we will insert before must be distinctly greater;
3197: overlap means error. */
3198: if (! tree_int_cst_lt (value, (*l)->low))
3199: {
3200: *duplicate = (*l)->code_label;
3201: return 2;
3202: }
3203: }
3204:
3205: /* Add this label to the chain, and succeed.
3206: Copy VALUE so it is on temporary rather than momentary
3207: obstack and will thus survive till the end of the case statement. */
3208: n = (struct case_node *) oballoc (sizeof (struct case_node));
3209: n->left = 0;
3210: n->right = *l;
3211: n->high = n->low = copy_node (value);
3212: n->code_label = label;
3213: *l = n;
3214: }
3215:
3216: expand_label (label);
3217: return 0;
3218: }
3219:
3220: /* Like pushcase but this case applies to all values
3221: between VALUE1 and VALUE2 (inclusive).
3222: The return value is the same as that of pushcase
3223: but there is one additional error code:
3224: 4 means the specified range was empty. */
3225:
3226: int
3227: pushcase_range (value1, value2, label, duplicate)
3228: register tree value1, value2;
3229: register tree label;
3230: tree *duplicate;
3231: {
3232: register struct case_node **l;
3233: register struct case_node *n;
3234: tree index_type;
3235: tree nominal_type;
3236:
3237: /* Fail if not inside a real case statement. */
3238: if (! (case_stack && case_stack->data.case_stmt.start))
3239: return 1;
3240:
3241: if (stack_block_stack
3242: && stack_block_stack->depth > case_stack->depth)
3243: return 5;
3244:
3245: index_type = TREE_TYPE (case_stack->data.case_stmt.index_expr);
3246: nominal_type = case_stack->data.case_stmt.nominal_type;
3247:
3248: /* If the index is erroneous, avoid more problems: pretend to succeed. */
3249: if (index_type == error_mark_node)
3250: return 0;
3251:
3252: /* If this is the first label, warn if any insns have been emitted. */
3253: if (case_stack->data.case_stmt.seenlabel == 0)
3254: {
3255: rtx insn;
3256: for (insn = case_stack->data.case_stmt.start;
3257: insn;
3258: insn = NEXT_INSN (insn))
3259: {
3260: if (GET_CODE (insn) == CODE_LABEL)
3261: break;
3262: if (GET_CODE (insn) != NOTE
3263: && (GET_CODE (insn) != INSN || GET_CODE (PATTERN (insn)) != USE))
3264: {
3265: warning ("unreachable code at beginning of %s",
3266: case_stack->data.case_stmt.printname);
3267: break;
3268: }
3269: }
3270: }
3271: case_stack->data.case_stmt.seenlabel = 1;
3272:
3273: /* Convert VALUEs to type in which the comparisons are nominally done. */
3274: if (value1 == 0) /* Negative infinity. */
3275: value1 = TYPE_MIN_VALUE(index_type);
3276: value1 = convert (nominal_type, value1);
3277:
3278: if (value2 == 0) /* Positive infinity. */
3279: value2 = TYPE_MAX_VALUE(index_type);
3280: value2 = convert (nominal_type, value2);
3281:
3282: /* Fail if these values are out of range. */
3283: if (! int_fits_type_p (value1, index_type))
3284: return 3;
3285:
3286: if (! int_fits_type_p (value2, index_type))
3287: return 3;
3288:
3289: /* Fail if the range is empty. */
3290: if (tree_int_cst_lt (value2, value1))
3291: return 4;
3292:
3293: /* If the bounds are equal, turn this into the one-value case. */
3294: if (tree_int_cst_equal (value1, value2))
3295: return pushcase (value1, label, duplicate);
3296:
3297: /* Find the elt in the chain before which to insert the new value,
3298: to keep the chain sorted in increasing order.
3299: But report an error if this element is a duplicate. */
3300: for (l = &case_stack->data.case_stmt.case_list;
3301: /* Keep going past elements distinctly less than this range. */
3302: *l != 0 && tree_int_cst_lt ((*l)->high, value1);
3303: l = &(*l)->right)
3304: ;
3305: if (*l)
3306: {
3307: /* Element we will insert before must be distinctly greater;
3308: overlap means error. */
3309: if (! tree_int_cst_lt (value2, (*l)->low))
3310: {
3311: *duplicate = (*l)->code_label;
3312: return 2;
3313: }
3314: }
3315:
3316: /* Add this label to the chain, and succeed.
3317: Copy VALUE1, VALUE2 so they are on temporary rather than momentary
3318: obstack and will thus survive till the end of the case statement. */
3319:
3320: n = (struct case_node *) oballoc (sizeof (struct case_node));
3321: n->left = 0;
3322: n->right = *l;
3323: n->low = copy_node (value1);
3324: n->high = copy_node (value2);
3325: n->code_label = label;
3326: *l = n;
3327:
3328: expand_label (label);
3329:
3330: case_stack->data.case_stmt.num_ranges++;
3331:
3332: return 0;
3333: }
3334:
3335: /* Called when the index of a switch statement is an enumerated type
3336: and there is no default label.
3337:
3338: Checks that all enumeration literals are covered by the case
3339: expressions of a switch. Also, warn if there are any extra
3340: switch cases that are *not* elements of the enumerated type.
3341:
3342: If all enumeration literals were covered by the case expressions,
3343: turn one of the expressions into the default expression since it should
3344: not be possible to fall through such a switch. */
3345:
3346: void
3347: check_for_full_enumeration_handling (type)
3348: tree type;
3349: {
3350: register struct case_node *n;
3351: register struct case_node **l;
3352: register tree chain;
3353: int all_values = 1;
3354:
3355: /* The time complexity of this loop is currently O(N * M), with
3356: N being the number of enumerals in the enumerated type, and
3357: M being the number of case expressions in the switch. */
3358:
3359: for (chain = TYPE_VALUES (type);
3360: chain;
3361: chain = TREE_CHAIN (chain))
3362: {
3363: /* Find a match between enumeral and case expression, if possible.
3364: Quit looking when we've gone too far (since case expressions
3365: are kept sorted in ascending order). Warn about enumerals not
3366: handled in the switch statement case expression list. */
3367:
3368: for (n = case_stack->data.case_stmt.case_list;
3369: n && tree_int_cst_lt (n->high, TREE_VALUE (chain));
3370: n = n->right)
3371: ;
3372:
3373: if (!(n && tree_int_cst_equal (n->low, TREE_VALUE (chain))))
3374: {
3375: if (warn_switch)
3376: warning ("enumerated value `%s' not handled in switch",
3377: IDENTIFIER_POINTER (TREE_PURPOSE (chain)));
3378: all_values = 0;
3379: }
3380: }
3381:
3382: /* Now we go the other way around; we warn if there are case
3383: expressions that don't correspond to enumerals. This can
3384: occur since C and C++ don't enforce type-checking of
3385: assignments to enumeration variables. */
3386:
3387: if (warn_switch)
3388: for (n = case_stack->data.case_stmt.case_list; n; n = n->right)
3389: {
3390: for (chain = TYPE_VALUES (type);
3391: chain && !tree_int_cst_equal (n->low, TREE_VALUE (chain));
3392: chain = TREE_CHAIN (chain))
3393: ;
3394:
3395: if (!chain)
3396: warning ("case value `%d' not in enumerated type `%s'",
3397: TREE_INT_CST_LOW (n->low),
3398: IDENTIFIER_POINTER ((TREE_CODE (TYPE_NAME (type))
3399: == IDENTIFIER_NODE)
3400: ? TYPE_NAME (type)
3401: : DECL_NAME (TYPE_NAME (type))));
3402: }
3403:
3404: /* If all values were found as case labels, make one of them the default
3405: label. Thus, this switch will never fall through. We arbitrarily pick
3406: the last one to make the default since this is likely the most
3407: efficient choice. */
3408:
3409: if (all_values)
3410: {
3411: for (l = &case_stack->data.case_stmt.case_list;
3412: (*l)->right != 0;
3413: l = &(*l)->right)
3414: ;
3415:
3416: case_stack->data.case_stmt.default_label = (*l)->code_label;
3417: *l = 0;
3418: }
3419: }
3420:
3421: /* Terminate a case (Pascal) or switch (C) statement
3422: in which CASE_INDEX is the expression to be tested.
3423: Generate the code to test it and jump to the right place. */
3424:
3425: void
3426: expand_end_case (orig_index)
3427: tree orig_index;
3428: {
3429: tree minval, maxval, range;
3430: rtx default_label = 0;
3431: register struct case_node *n;
3432: int count;
3433: rtx index;
3434: rtx table_label = gen_label_rtx ();
3435: int ncases;
3436: rtx *labelvec;
3437: register int i;
3438: rtx before_case;
3439: register struct nesting *thiscase = case_stack;
3440: tree index_expr = thiscase->data.case_stmt.index_expr;
3441: int unsignedp = TREE_UNSIGNED (TREE_TYPE (index_expr));
3442:
3443: do_pending_stack_adjust ();
3444:
3445: /* An ERROR_MARK occurs for various reasons including invalid data type. */
3446: if (TREE_TYPE (index_expr) != error_mark_node)
3447: {
3448: /* If switch expression was an enumerated type, check that all
3449: enumeration literals are covered by the cases.
3450: No sense trying this if there's a default case, however. */
3451:
3452: if (!thiscase->data.case_stmt.default_label
3453: && TREE_CODE (TREE_TYPE (orig_index)) == ENUMERAL_TYPE
3454: && TREE_CODE (index_expr) != INTEGER_CST)
3455: check_for_full_enumeration_handling (TREE_TYPE (orig_index));
3456:
3457: /* If this is the first label, warn if any insns have been emitted. */
3458: if (thiscase->data.case_stmt.seenlabel == 0)
3459: {
3460: rtx insn;
3461: for (insn = get_last_insn ();
3462: insn != case_stack->data.case_stmt.start;
3463: insn = PREV_INSN (insn))
3464: if (GET_CODE (insn) != NOTE
3465: && (GET_CODE (insn) != INSN || GET_CODE (PATTERN (insn))!= USE))
3466: {
3467: warning ("unreachable code at beginning of %s",
3468: case_stack->data.case_stmt.printname);
3469: break;
3470: }
3471: }
3472:
3473: /* If we don't have a default-label, create one here,
3474: after the body of the switch. */
3475: if (thiscase->data.case_stmt.default_label == 0)
3476: {
3477: thiscase->data.case_stmt.default_label
3478: = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3479: expand_label (thiscase->data.case_stmt.default_label);
3480: }
3481: default_label = label_rtx (thiscase->data.case_stmt.default_label);
3482:
3483: before_case = get_last_insn ();
3484:
3485: /* Simplify the case-list before we count it. */
3486: group_case_nodes (thiscase->data.case_stmt.case_list);
3487:
3488: /* Get upper and lower bounds of case values.
3489: Also convert all the case values to the index expr's data type. */
3490:
3491: count = 0;
3492: for (n = thiscase->data.case_stmt.case_list; n; n = n->right)
3493: {
3494: /* Check low and high label values are integers. */
3495: if (TREE_CODE (n->low) != INTEGER_CST)
3496: abort ();
3497: if (TREE_CODE (n->high) != INTEGER_CST)
3498: abort ();
3499:
3500: n->low = convert (TREE_TYPE (index_expr), n->low);
3501: n->high = convert (TREE_TYPE (index_expr), n->high);
3502:
3503: /* Count the elements and track the largest and smallest
3504: of them (treating them as signed even if they are not). */
3505: if (count++ == 0)
3506: {
3507: minval = n->low;
3508: maxval = n->high;
3509: }
3510: else
3511: {
3512: if (INT_CST_LT (n->low, minval))
3513: minval = n->low;
3514: if (INT_CST_LT (maxval, n->high))
3515: maxval = n->high;
3516: }
3517: /* A range counts double, since it requires two compares. */
3518: if (! tree_int_cst_equal (n->low, n->high))
3519: count++;
3520: }
3521:
3522: /* Compute span of values. */
3523: if (count != 0)
3524: range = fold (build (MINUS_EXPR, TREE_TYPE (index_expr),
3525: maxval, minval));
3526:
3527: if (count == 0 || TREE_CODE (TREE_TYPE (index_expr)) == ERROR_MARK)
3528: {
3529: expand_expr (index_expr, const0_rtx, VOIDmode, 0);
3530: emit_queue ();
3531: emit_jump (default_label);
3532: }
3533: /* If range of values is much bigger than number of values,
3534: make a sequence of conditional branches instead of a dispatch.
3535: If the switch-index is a constant, do it this way
3536: because we can optimize it. */
3537: else if (TREE_INT_CST_HIGH (range) != 0
3538: #ifdef HAVE_casesi
3539: || (HAVE_casesi ? count < 4 : count < 5)
3540: #else
3541: /* If machine does not have a case insn that compares the
3542: bounds, this means extra overhead for dispatch tables
3543: which raises the threshold for using them. */
3544: || count < 5
3545: #endif
3546: || (unsigned) (TREE_INT_CST_LOW (range)) > 10 * count
3547: || TREE_CODE (index_expr) == INTEGER_CST
3548: /* This will reduce to a constant. */
3549: || (TREE_CODE (index_expr) == CALL_EXPR
3550: && TREE_CODE (TREE_OPERAND (index_expr, 0)) == ADDR_EXPR
3551: && TREE_CODE (TREE_OPERAND (TREE_OPERAND (index_expr, 0), 0)) == FUNCTION_DECL
3552: && DECL_FUNCTION_CODE (TREE_OPERAND (TREE_OPERAND (index_expr, 0), 0)) == BUILT_IN_CLASSIFY_TYPE))
3553: {
3554: index = expand_expr (index_expr, 0, VOIDmode, 0);
3555:
3556: /* If the index is a short or char that we do not have
3557: an insn to handle comparisons directly, convert it to
3558: a full integer now, rather than letting each comparison
3559: generate the conversion. */
3560:
3561: if (GET_MODE_CLASS (GET_MODE (index)) == MODE_INT
3562: && (cmp_optab->handlers[(int) GET_MODE(index)].insn_code
3563: == CODE_FOR_nothing))
3564: {
3565: enum machine_mode wider_mode;
3566: for (wider_mode = GET_MODE (index); wider_mode != VOIDmode;
3567: wider_mode = GET_MODE_WIDER_MODE (wider_mode))
3568: if (cmp_optab->handlers[(int) wider_mode].insn_code
3569: != CODE_FOR_nothing)
3570: {
3571: index = convert_to_mode (wider_mode, index, unsignedp);
3572: break;
3573: }
3574: }
3575:
3576: emit_queue ();
3577: do_pending_stack_adjust ();
3578:
3579: index = protect_from_queue (index, 0);
3580: if (GET_CODE (index) == MEM)
3581: index = copy_to_reg (index);
3582: if (GET_CODE (index) == CONST_INT
3583: || TREE_CODE (index_expr) == INTEGER_CST)
3584: {
3585: /* Make a tree node with the proper constant value
3586: if we don't already have one. */
3587: if (TREE_CODE (index_expr) != INTEGER_CST)
3588: {
3589: index_expr
3590: = build_int_2 (INTVAL (index),
3591: !unsignedp && INTVAL (index) >= 0 ? 0 : -1);
3592: index_expr = convert (TREE_TYPE (index_expr), index_expr);
3593: }
3594:
3595: /* For constant index expressions we need only
3596: issue a unconditional branch to the appropriate
3597: target code. The job of removing any unreachable
3598: code is left to the optimisation phase if the
3599: "-O" option is specified. */
3600: for (n = thiscase->data.case_stmt.case_list;
3601: n;
3602: n = n->right)
3603: {
3604: if (! tree_int_cst_lt (index_expr, n->low)
3605: && ! tree_int_cst_lt (n->high, index_expr))
3606: break;
3607: }
3608: if (n)
3609: emit_jump (label_rtx (n->code_label));
3610: else
3611: emit_jump (default_label);
3612: }
3613: else
3614: {
3615: /* If the index expression is not constant we generate
3616: a binary decision tree to select the appropriate
3617: target code. This is done as follows:
3618:
3619: The list of cases is rearranged into a binary tree,
3620: nearly optimal assuming equal probability for each case.
3621:
3622: The tree is transformed into RTL, eliminating
3623: redundant test conditions at the same time.
3624:
3625: If program flow could reach the end of the
3626: decision tree an unconditional jump to the
3627: default code is emitted. */
3628:
3629: use_cost_table
3630: = (TREE_CODE (TREE_TYPE (orig_index)) != ENUMERAL_TYPE
3631: && default_label != 0
3632: && estimate_case_costs (thiscase->data.case_stmt.case_list));
3633: balance_case_nodes (&thiscase->data.case_stmt.case_list, 0);
3634: emit_case_nodes (index, thiscase->data.case_stmt.case_list,
3635: default_label, TREE_TYPE (index_expr));
3636: emit_jump_if_reachable (default_label);
3637: }
3638: }
3639: else
3640: {
3641: int win = 0;
3642: #ifdef HAVE_casesi
3643: if (HAVE_casesi)
3644: {
3645: /* Convert the index to SImode. */
3646: if (TYPE_MODE (TREE_TYPE (index_expr)) == DImode)
3647: {
3648: index_expr = build (MINUS_EXPR, TREE_TYPE (index_expr),
3649: index_expr, minval);
3650: minval = integer_zero_node;
3651: }
3652: if (TYPE_MODE (TREE_TYPE (index_expr)) != SImode)
3653: index_expr = convert (type_for_size (GET_MODE_BITSIZE (SImode), 0),
3654: index_expr);
3655: index = expand_expr (index_expr, 0, VOIDmode, 0);
3656: emit_queue ();
3657: index = protect_from_queue (index, 0);
3658: do_pending_stack_adjust ();
3659:
3660: emit_jump_insn (gen_casesi (index, expand_expr (minval, 0, VOIDmode, 0),
3661: expand_expr (range, 0, VOIDmode, 0),
3662: table_label, default_label));
3663: win = 1;
3664: }
3665: #endif
3666: #ifdef HAVE_tablejump
3667: if (! win && HAVE_tablejump)
3668: {
3669: index_expr = convert (thiscase->data.case_stmt.nominal_type,
3670: build (MINUS_EXPR, TREE_TYPE (index_expr),
3671: index_expr, minval));
3672: index = expand_expr (index_expr, 0, VOIDmode, 0);
3673: emit_queue ();
3674: index = protect_from_queue (index, 0);
3675: do_pending_stack_adjust ();
3676:
3677: do_tablejump (index,
3678: gen_rtx (CONST_INT, VOIDmode,
3679: TREE_INT_CST_LOW (range)),
3680: table_label, default_label);
3681: win = 1;
3682: }
3683: #endif
3684: if (! win)
3685: abort ();
3686:
3687: /* Get table of labels to jump to, in order of case index. */
3688:
3689: ncases = TREE_INT_CST_LOW (range) + 1;
3690: labelvec = (rtx *) alloca (ncases * sizeof (rtx));
3691: bzero (labelvec, ncases * sizeof (rtx));
3692:
3693: for (n = thiscase->data.case_stmt.case_list; n; n = n->right)
3694: {
3695: register int i
3696: = TREE_INT_CST_LOW (n->low) - TREE_INT_CST_LOW (minval);
3697:
3698: while (1)
3699: {
3700: labelvec[i]
3701: = gen_rtx (LABEL_REF, Pmode, label_rtx (n->code_label));
3702: if (i + TREE_INT_CST_LOW (minval)
3703: == TREE_INT_CST_LOW (n->high))
3704: break;
3705: i++;
3706: }
3707: }
3708:
3709: /* Fill in the gaps with the default. */
3710: for (i = 0; i < ncases; i++)
3711: if (labelvec[i] == 0)
3712: labelvec[i] = gen_rtx (LABEL_REF, Pmode, default_label);
3713:
3714: /* Output the table */
3715: emit_label (table_label);
3716:
3717: /* This would be a lot nicer if CASE_VECTOR_PC_RELATIVE
3718: were an expression, instead of a an #ifdef/#ifndef. */
3719: if (
3720: #ifdef CASE_VECTOR_PC_RELATIVE
3721: 1 ||
3722: #endif
3723: flag_pic)
3724: emit_jump_insn (gen_rtx (ADDR_DIFF_VEC, CASE_VECTOR_MODE,
3725: gen_rtx (LABEL_REF, Pmode, table_label),
3726: gen_rtvec_v (ncases, labelvec)));
3727: else
3728: emit_jump_insn (gen_rtx (ADDR_VEC, CASE_VECTOR_MODE,
3729: gen_rtvec_v (ncases, labelvec)));
3730:
3731: /* If the case insn drops through the table,
3732: after the table we must jump to the default-label.
3733: Otherwise record no drop-through after the table. */
3734: #ifdef CASE_DROPS_THROUGH
3735: emit_jump (default_label);
3736: #else
3737: emit_barrier ();
3738: #endif
3739: }
3740:
3741: reorder_insns (NEXT_INSN (before_case), get_last_insn (),
3742: thiscase->data.case_stmt.start);
3743: }
3744: if (thiscase->exit_label)
3745: emit_label (thiscase->exit_label);
3746:
3747: POPSTACK (case_stack);
3748:
3749: free_temp_slots ();
3750: }
3751:
3752: /* Generate code to jump to LABEL if OP1 and OP2 are equal. */
3753:
3754: static void
3755: do_jump_if_equal (op1, op2, label, unsignedp)
3756: rtx op1, op2, label;
3757: int unsignedp;
3758: {
3759: if (GET_CODE (op1) == CONST_INT
3760: && GET_CODE (op2) == CONST_INT)
3761: {
3762: if (INTVAL (op1) == INTVAL (op2))
3763: emit_jump (label);
3764: }
3765: else
3766: {
3767: enum machine_mode mode = GET_MODE (op1);
3768: if (mode == VOIDmode)
3769: mode = GET_MODE (op2);
3770: emit_cmp_insn (op1, op2, EQ, 0, mode, unsignedp, 0);
3771: emit_jump_insn (gen_beq (label));
3772: }
3773: }
3774:
3775: /* Not all case values are encountered equally. This function
3776: uses a heuristic to weight case labels, in cases where that
3777: looks like a reasonable thing to do.
3778:
3779: Right now, all we try to guess is text, and we establish the
3780: following weights:
3781:
3782: chars above space: 16
3783: digits: 16
3784: default: 12
3785: space, punct: 8
3786: tab: 4
3787: newline: 2
3788: other "\" chars: 1
3789: remaining chars: 0
3790:
3791: If we find any cases in the switch that are not either -1 or in the range
3792: of valid ASCII characters, or are control characters other than those
3793: commonly used with "\", don't treat this switch scanning text.
3794:
3795: Return 1 if these nodes are suitable for cost estimation, otherwise
3796: return 0. */
3797:
3798: static int
3799: estimate_case_costs (node)
3800: case_node_ptr node;
3801: {
3802: tree min_ascii = build_int_2 (-1, -1);
3803: tree max_ascii = convert (TREE_TYPE (node->high), build_int_2 (127, 0));
3804: case_node_ptr n;
3805: int i;
3806:
3807: /* If we haven't already made the cost table, make it now. Note that the
3808: lower bound of the table is -1, not zero. */
3809:
3810: if (cost_table == NULL)
3811: {
3812: cost_table = ((short *) xmalloc (129 * sizeof (short))) + 1;
3813: bzero (cost_table - 1, 129 * sizeof (short));
3814:
3815: for (i = 0; i < 128; i++)
3816: {
3817: if (isalnum (i))
3818: cost_table[i] = 16;
3819: else if (ispunct (i))
3820: cost_table[i] = 8;
3821: else if (iscntrl (i))
3822: cost_table[i] = -1;
3823: }
3824:
3825: cost_table[' '] = 8;
3826: cost_table['\t'] = 4;
3827: cost_table['\0'] = 4;
3828: cost_table['\n'] = 2;
3829: cost_table['\f'] = 1;
3830: cost_table['\v'] = 1;
3831: cost_table['\b'] = 1;
3832: }
3833:
3834: /* See if all the case expressions look like text. It is text if the
3835: constant is >= -1 and the highest constant is <= 127. Do all comparisons
3836: as signed arithmetic since we don't want to ever access cost_table with a
3837: value less than -1. Also check that none of the constants in a range
3838: are strange control characters. */
3839:
3840: for (n = node; n; n = n->right)
3841: {
3842: if ((INT_CST_LT (n->low, min_ascii)) || INT_CST_LT (max_ascii, n->high))
3843: return 0;
3844:
3845: for (i = TREE_INT_CST_LOW (n->low); i <= TREE_INT_CST_LOW (n->high); i++)
3846: if (cost_table[i] < 0)
3847: return 0;
3848: }
3849:
3850: /* All interesting values are within the range of interesting
3851: ASCII characters. */
3852: return 1;
3853: }
3854:
3855: /* Scan an ordered list of case nodes
3856: combining those with consecutive values or ranges.
3857:
3858: Eg. three separate entries 1: 2: 3: become one entry 1..3: */
3859:
3860: static void
3861: group_case_nodes (head)
3862: case_node_ptr head;
3863: {
3864: case_node_ptr node = head;
3865:
3866: while (node)
3867: {
3868: rtx lb = next_real_insn (label_rtx (node->code_label));
3869: case_node_ptr np = node;
3870:
3871: /* Try to group the successors of NODE with NODE. */
3872: while (((np = np->right) != 0)
3873: /* Do they jump to the same place? */
3874: && next_real_insn (label_rtx (np->code_label)) == lb
3875: /* Are their ranges consecutive? */
3876: && tree_int_cst_equal (np->low,
3877: fold (build (PLUS_EXPR,
3878: TREE_TYPE (node->high),
3879: node->high,
3880: integer_one_node)))
3881: /* An overflow is not consecutive. */
3882: && tree_int_cst_lt (node->high,
3883: fold (build (PLUS_EXPR,
3884: TREE_TYPE (node->high),
3885: node->high,
3886: integer_one_node))))
3887: {
3888: node->high = np->high;
3889: }
3890: /* NP is the first node after NODE which can't be grouped with it.
3891: Delete the nodes in between, and move on to that node. */
3892: node->right = np;
3893: node = np;
3894: }
3895: }
3896:
3897: /* Take an ordered list of case nodes
3898: and transform them into a near optimal binary tree,
3899: on the assumtion that any target code selection value is as
3900: likely as any other.
3901:
3902: The transformation is performed by splitting the ordered
3903: list into two equal sections plus a pivot. The parts are
3904: then attached to the pivot as left and right branches. Each
3905: branch is is then transformed recursively. */
3906:
3907: static void
3908: balance_case_nodes (head, parent)
3909: case_node_ptr *head;
3910: case_node_ptr parent;
3911: {
3912: register case_node_ptr np;
3913:
3914: np = *head;
3915: if (np)
3916: {
3917: int cost = 0;
3918: int i = 0;
3919: int ranges = 0;
3920: register case_node_ptr *npp;
3921: case_node_ptr left;
3922:
3923: /* Count the number of entries on branch. Also count the ranges. */
3924:
3925: while (np)
3926: {
3927: if (!tree_int_cst_equal (np->low, np->high))
3928: {
3929: ranges++;
3930: if (use_cost_table)
3931: cost += cost_table[TREE_INT_CST_LOW (np->high)];
3932: }
3933:
3934: if (use_cost_table)
3935: cost += cost_table[TREE_INT_CST_LOW (np->low)];
3936:
3937: i++;
3938: np = np->right;
3939: }
3940:
3941: if (i > 2)
3942: {
3943: /* Split this list if it is long enough for that to help. */
3944: npp = head;
3945: left = *npp;
3946: if (use_cost_table)
3947: {
3948: /* Find the place in the list that bisects the list's total cost,
3949: Here I gets half the total cost. */
3950: int n_moved = 0;
3951: i = (cost + 1) / 2;
3952: while (1)
3953: {
3954: /* Skip nodes while their cost does not reach that amount. */
3955: if (!tree_int_cst_equal ((*npp)->low, (*npp)->high))
3956: i -= cost_table[TREE_INT_CST_LOW ((*npp)->high)];
3957: i -= cost_table[TREE_INT_CST_LOW ((*npp)->low)];
3958: if (i <= 0)
3959: break;
3960: npp = &(*npp)->right;
3961: n_moved += 1;
3962: }
3963: if (n_moved == 0)
3964: {
3965: /* Leave this branch lopsided, but optimize left-hand
3966: side and fill in `parent' fields for right-hand side. */
3967: np = *head;
3968: np->parent = parent;
3969: balance_case_nodes (&np->left, np);
3970: for (; np->right; np = np->right)
3971: np->right->parent = np;
3972: return;
3973: }
3974: }
3975: /* If there are just three nodes, split at the middle one. */
3976: else if (i == 3)
3977: npp = &(*npp)->right;
3978: else
3979: {
3980: /* Find the place in the list that bisects the list's total cost,
3981: where ranges count as 2.
3982: Here I gets half the total cost. */
3983: i = (i + ranges + 1) / 2;
3984: while (1)
3985: {
3986: /* Skip nodes while their cost does not reach that amount. */
3987: if (!tree_int_cst_equal ((*npp)->low, (*npp)->high))
3988: i--;
3989: i--;
3990: if (i <= 0)
3991: break;
3992: npp = &(*npp)->right;
3993: }
3994: }
3995: *head = np = *npp;
3996: *npp = 0;
3997: np->parent = parent;
3998: np->left = left;
3999:
4000: /* Optimize each of the two split parts. */
4001: balance_case_nodes (&np->left, np);
4002: balance_case_nodes (&np->right, np);
4003: }
4004: else
4005: {
4006: /* Else leave this branch as one level,
4007: but fill in `parent' fields. */
4008: np = *head;
4009: np->parent = parent;
4010: for (; np->right; np = np->right)
4011: np->right->parent = np;
4012: }
4013: }
4014: }
4015:
4016: /* Search the parent sections of the case node tree
4017: to see if a test for the lower bound of NODE would be redundant.
4018: INDEX_TYPE is the type of the index expression.
4019:
4020: The instructions to generate the case decision tree are
4021: output in the same order as nodes are processed so it is
4022: known that if a parent node checks the range of the current
4023: node minus one that the current node is bounded at its lower
4024: span. Thus the test would be redundant. */
4025:
4026: static int
4027: node_has_low_bound (node, index_type)
4028: case_node_ptr node;
4029: tree index_type;
4030: {
4031: tree low_minus_one;
4032: case_node_ptr pnode;
4033:
4034: /* If the lower bound of this node is the lowest value in the index type,
4035: we need not test it. */
4036:
4037: if (tree_int_cst_equal (node->low, TYPE_MIN_VALUE (index_type)))
4038: return 1;
4039:
4040: /* If this node has a left branch, the value at the left must be less
4041: than that at this node, so it cannot be bounded at the bottom and
4042: we need not bother testing any further. */
4043:
4044: if (node->left)
4045: return 0;
4046:
4047: low_minus_one = fold (build (MINUS_EXPR, TREE_TYPE (node->low),
4048: node->low, integer_one_node));
4049:
4050: /* If the subtraction above overflowed, we can't verify anything.
4051: Otherwise, look for a parent that tests our value - 1. */
4052:
4053: if (! tree_int_cst_lt (low_minus_one, node->low))
4054: return 0;
4055:
4056: for (pnode = node->parent; pnode; pnode = pnode->parent)
4057: if (tree_int_cst_equal (low_minus_one, pnode->high))
4058: return 1;
4059:
4060: return 0;
4061: }
4062:
4063: /* Search the parent sections of the case node tree
4064: to see if a test for the upper bound of NODE would be redundant.
4065: INDEX_TYPE is the type of the index expression.
4066:
4067: The instructions to generate the case decision tree are
4068: output in the same order as nodes are processed so it is
4069: known that if a parent node checks the range of the current
4070: node plus one that the current node is bounded at its upper
4071: span. Thus the test would be redundant. */
4072:
4073: static int
4074: node_has_high_bound (node, index_type)
4075: case_node_ptr node;
4076: tree index_type;
4077: {
4078: tree high_plus_one;
4079: case_node_ptr pnode;
4080:
4081: /* If the upper bound of this node is the highest value in the type
4082: of the index expression, we need not test against it. */
4083:
4084: if (tree_int_cst_equal (node->high, TYPE_MAX_VALUE (index_type)))
4085: return 1;
4086:
4087: /* If this node has a right branch, the value at the right must be greater
4088: than that at this node, so it cannot be bounded at the top and
4089: we need not bother testing any further. */
4090:
4091: if (node->right)
4092: return 0;
4093:
4094: high_plus_one = fold (build (PLUS_EXPR, TREE_TYPE (node->high),
4095: node->high, integer_one_node));
4096:
4097: /* If the addition above overflowed, we can't verify anything.
4098: Otherwise, look for a parent that tests our value + 1. */
4099:
4100: if (! tree_int_cst_lt (node->high, high_plus_one))
4101: return 0;
4102:
4103: for (pnode = node->parent; pnode; pnode = pnode->parent)
4104: if (tree_int_cst_equal (high_plus_one, pnode->low))
4105: return 1;
4106:
4107: return 0;
4108: }
4109:
4110: /* Search the parent sections of the
4111: case node tree to see if both tests for the upper and lower
4112: bounds of NODE would be redundant. */
4113:
4114: static int
4115: node_is_bounded (node, index_type)
4116: case_node_ptr node;
4117: tree index_type;
4118: {
4119: return (node_has_low_bound (node, index_type)
4120: && node_has_high_bound (node, index_type));
4121: }
4122:
4123: /* Emit an unconditional jump to LABEL unless it would be dead code. */
4124:
4125: static void
4126: emit_jump_if_reachable (label)
4127: rtx label;
4128: {
4129: if (GET_CODE (get_last_insn ()) != BARRIER)
4130: emit_jump (label);
4131: }
4132:
4133: /* Emit step-by-step code to select a case for the value of INDEX.
4134: The thus generated decision tree follows the form of the
4135: case-node binary tree NODE, whose nodes represent test conditions.
4136: INDEX_TYPE is the type of the index of the switch.
4137:
4138: Care is taken to prune redundant tests from the decision tree
4139: by detecting any boundary conditions already checked by
4140: emitted rtx. (See node_has_high_bound, node_has_low_bound
4141: and node_is_bounded, above.)
4142:
4143: Where the test conditions can be shown to be redundant we emit
4144: an unconditional jump to the target code. As a further
4145: optimization, the subordinates of a tree node are examined to
4146: check for bounded nodes. In this case conditional and/or
4147: unconditional jumps as a result of the boundary check for the
4148: current node are arranged to target the subordinates associated
4149: code for out of bound conditions on the current node node.
4150:
4151: We can asume that when control reaches the code generated here,
4152: the index value has already been compared with the parents
4153: of this node, and determined to be on the same side of each parent
4154: as this node is. Thus, if this node tests for the value 51,
4155: and a parent tested for 52, we don't need to consider
4156: the possibility of a value greater than 51. If another parent
4157: tests for the value 50, then this node need not test anything. */
4158:
4159: static void
4160: emit_case_nodes (index, node, default_label, index_type)
4161: rtx index;
4162: case_node_ptr node;
4163: rtx default_label;
4164: tree index_type;
4165: {
4166: /* If INDEX has an unsigned type, we must make unsigned branches. */
4167: int unsignedp = TREE_UNSIGNED (index_type);
4168: typedef rtx rtx_function ();
4169: rtx_function *gen_bgt_pat = unsignedp ? gen_bgtu : gen_bgt;
4170: rtx_function *gen_bge_pat = unsignedp ? gen_bgeu : gen_bge;
4171: rtx_function *gen_blt_pat = unsignedp ? gen_bltu : gen_blt;
4172: rtx_function *gen_ble_pat = unsignedp ? gen_bleu : gen_ble;
4173: enum machine_mode mode = GET_MODE (index);
4174:
4175: /* See if our parents have already tested everything for us.
4176: If they have, emit an unconditional jump for this node. */
4177: if (node_is_bounded (node, index_type))
4178: emit_jump (label_rtx (node->code_label));
4179:
4180: else if (tree_int_cst_equal (node->low, node->high))
4181: {
4182: /* Node is single valued. First see if the index expression matches
4183: this node and then check our children, if any. */
4184:
4185: do_jump_if_equal (index, expand_expr (node->low, 0, VOIDmode, 0),
4186: label_rtx (node->code_label), unsignedp);
4187:
4188: if (node->right != 0 && node->left != 0)
4189: {
4190: /* This node has children on both sides.
4191: Dispatch to one side or the other
4192: by comparing the index value with this node's value.
4193: If one subtree is bounded, check that one first,
4194: so we can avoid real branches in the tree. */
4195:
4196: if (node_is_bounded (node->right, index_type))
4197: {
4198: emit_cmp_insn (index, expand_expr (node->high, 0, VOIDmode, 0),
4199: GT, 0, mode, unsignedp, 0);
4200:
4201: emit_jump_insn ((*gen_bgt_pat) (label_rtx (node->right->code_label)));
4202: emit_case_nodes (index, node->left, default_label, index_type);
4203: }
4204:
4205: else if (node_is_bounded (node->left, index_type))
4206: {
4207: emit_cmp_insn (index, expand_expr (node->high, 0,
4208: VOIDmode, 0),
4209: LT, 0, mode, unsignedp, 0);
4210: emit_jump_insn ((*gen_blt_pat) (label_rtx (node->left->code_label)));
4211: emit_case_nodes (index, node->right, default_label, index_type);
4212: }
4213:
4214: else
4215: {
4216: /* Neither node is bounded. First distinguish the two sides;
4217: then emit the code for one side at a time. */
4218:
4219: tree test_label
4220: = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
4221:
4222: /* See if the value is on the right. */
4223: emit_cmp_insn (index, expand_expr (node->high, 0,
4224: VOIDmode, 0),
4225: GT, 0, mode, unsignedp, 0);
4226: emit_jump_insn ((*gen_bgt_pat) (label_rtx (test_label)));
4227:
4228: /* Value must be on the left.
4229: Handle the left-hand subtree. */
4230: emit_case_nodes (index, node->left, default_label, index_type);
4231: /* If left-hand subtree does nothing,
4232: go to default. */
4233: emit_jump_if_reachable (default_label);
4234:
4235: /* Code branches here for the right-hand subtree. */
4236: expand_label (test_label);
4237: emit_case_nodes (index, node->right, default_label, index_type);
4238: }
4239: }
4240:
4241: else if (node->right != 0 && node->left == 0)
4242: {
4243: /* Here we have a right child but no left so we issue conditional
4244: branch to default and process the right child.
4245:
4246: Omit the conditional branch to default if we it avoid only one
4247: right child; it costs too much space to save so little time. */
4248:
4249: if (node->right->right || node->right->left
4250: || !tree_int_cst_equal (node->right->low, node->right->high))
4251: {
4252: if (!node_has_low_bound (node, index_type))
4253: {
4254: emit_cmp_insn (index, expand_expr (node->high, 0, VOIDmode, 0),
4255: LT, 0, mode, unsignedp, 0);
4256: emit_jump_insn ((*gen_blt_pat) (default_label));
4257: }
4258:
4259: emit_case_nodes (index, node->right, default_label, index_type);
4260: }
4261: else
4262: /* We cannot process node->right normally
4263: since we haven't ruled out the numbers less than
4264: this node's value. So handle node->right explicitly. */
4265: do_jump_if_equal (index,
4266: expand_expr (node->right->low, 0, VOIDmode, 0),
4267: label_rtx (node->right->code_label), unsignedp);
4268: }
4269:
4270: else if (node->right == 0 && node->left != 0)
4271: {
4272: /* Just one subtree, on the left. */
4273:
4274: #if 0 /* The following code and comment were formerly part
4275: of the condition here, but they didn't work
4276: and I don't understand what the idea was. -- rms. */
4277: /* If our "most probable entry" is less probable
4278: than the default label, emit a jump to
4279: the default label using condition codes
4280: already lying around. With no right branch,
4281: a branch-greater-than will get us to the default
4282: label correctly. */
4283: if (use_cost_table
4284: && cost_table[TREE_INT_CST_LOW (node->high)] < 12)
4285: ;
4286: #endif /* 0 */
4287: if (node->left->left || node->left->right
4288: || !tree_int_cst_equal (node->left->low, node->left->high))
4289: {
4290: if (!node_has_high_bound (node, index_type))
4291: {
4292: emit_cmp_insn (index, expand_expr (node->high, 0, VOIDmode, 0),
4293: GT, 0, mode, unsignedp, 0);
4294: emit_jump_insn ((*gen_bgt_pat) (default_label));
4295: }
4296:
4297: emit_case_nodes (index, node->left, default_label, index_type);
4298: }
4299: else
4300: /* We cannot process node->left normally
4301: since we haven't ruled out the numbers less than
4302: this node's value. So handle node->left explicitly. */
4303: do_jump_if_equal (index,
4304: expand_expr (node->left->low, 0, VOIDmode, 0),
4305: label_rtx (node->left->code_label), unsignedp);
4306: }
4307: }
4308: else
4309: {
4310: /* Node is a range. These cases are very similar to those for a single
4311: value, except that we do not start by testing whether this node
4312: is the one to branch to. */
4313:
4314: if (node->right != 0 && node->left != 0)
4315: {
4316: /* Node has subtrees on both sides.
4317: If the right-hand subtree is bounded,
4318: test for it first, since we can go straight there.
4319: Otherwise, we need to make a branch in the control structure,
4320: then handle the two subtrees. */
4321: tree test_label = 0;
4322:
4323: emit_cmp_insn (index, expand_expr (node->high, 0, VOIDmode, 0),
4324: GT, 0, mode, unsignedp, 0);
4325:
4326: if (node_is_bounded (node->right, index_type))
4327: /* Right hand node is fully bounded so we can eliminate any
4328: testing and branch directly to the target code. */
4329: emit_jump_insn ((*gen_bgt_pat) (label_rtx (node->right->code_label)));
4330: else
4331: {
4332: /* Right hand node requires testing.
4333: Branch to a label where we will handle it later. */
4334:
4335: test_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
4336: emit_jump_insn ((*gen_bgt_pat) (label_rtx (test_label)));
4337: }
4338:
4339: /* Value belongs to this node or to the left-hand subtree. */
4340:
4341: emit_cmp_insn (index, expand_expr (node->low, 0, VOIDmode, 0),
4342: GE, 0, mode, unsignedp, 0);
4343: emit_jump_insn ((*gen_bge_pat) (label_rtx (node->code_label)));
4344:
4345: /* Handle the left-hand subtree. */
4346: emit_case_nodes (index, node->left, default_label, index_type);
4347:
4348: /* If right node had to be handled later, do that now. */
4349:
4350: if (test_label)
4351: {
4352: /* If the left-hand subtree fell through,
4353: don't let it fall into the right-hand subtree. */
4354: emit_jump_if_reachable (default_label);
4355:
4356: expand_label (test_label);
4357: emit_case_nodes (index, node->right, default_label, index_type);
4358: }
4359: }
4360:
4361: else if (node->right != 0 && node->left == 0)
4362: {
4363: /* Deal with values to the left of this node,
4364: if they are possible. */
4365: if (!node_has_low_bound (node, index_type))
4366: {
4367: emit_cmp_insn (index, expand_expr (node->low, 0, VOIDmode, 0),
4368: LT, 0, mode, unsignedp, 0);
4369: emit_jump_insn ((*gen_blt_pat) (default_label));
4370: }
4371:
4372: /* Value belongs to this node or to the right-hand subtree. */
4373:
4374: emit_cmp_insn (index, expand_expr (node->high, 0, VOIDmode, 0),
4375: LE, 0, mode, unsignedp, 0);
4376: emit_jump_insn ((*gen_ble_pat) (label_rtx (node->code_label)));
4377:
4378: emit_case_nodes (index, node->right, default_label, index_type);
4379: }
4380:
4381: else if (node->right == 0 && node->left != 0)
4382: {
4383: /* Deal with values to the right of this node,
4384: if they are possible. */
4385: if (!node_has_high_bound (node, index_type))
4386: {
4387: emit_cmp_insn (index, expand_expr (node->high, 0, VOIDmode, 0),
4388: GT, 0, mode, unsignedp, 0);
4389: emit_jump_insn ((*gen_bgt_pat) (default_label));
4390: }
4391:
4392: /* Value belongs to this node or to the left-hand subtree. */
4393:
4394: emit_cmp_insn (index, expand_expr (node->low, 0, VOIDmode, 0),
4395: GE, 0, mode, unsignedp, 0);
4396: emit_jump_insn ((*gen_bge_pat) (label_rtx (node->code_label)));
4397:
4398: emit_case_nodes (index, node->left, default_label, index_type);
4399: }
4400:
4401: else
4402: {
4403: /* Node has no children so we check low and high bounds to remove
4404: redundant tests. Only one of the bounds can exist,
4405: since otherwise this node is bounded--a case tested already. */
4406:
4407: if (!node_has_high_bound (node, index_type))
4408: {
4409: emit_cmp_insn (index, expand_expr (node->high, 0, VOIDmode, 0),
4410: GT, 0, mode, unsignedp, 0);
4411: emit_jump_insn ((*gen_bgt_pat) (default_label));
4412: }
4413:
4414: if (!node_has_low_bound (node, index_type))
4415: {
4416: emit_cmp_insn (index, expand_expr (node->low, 0, VOIDmode, 0),
4417: LT, 0, mode, unsignedp, 0);
4418: emit_jump_insn ((*gen_blt_pat) (default_label));
4419: }
4420:
4421: emit_jump (label_rtx (node->code_label));
4422: }
4423: }
4424: }
4425:
4426: /* These routines are used by the loop unrolling code. They copy BLOCK trees
4427: so that the debugging info will be correct for the unrolled loop. */
4428:
4429: /* Indexed by loop number, contains pointer to the first block in the loop,
4430: or zero if none. Only valid if doing loop unrolling and outputting debugger
4431: info. */
4432:
4433: tree *loop_number_first_block;
4434:
4435: /* Indexed by loop number, contains pointer to the last block in the loop,
4436: only valid if loop_number_first_block is nonzero. */
4437:
4438: tree *loop_number_last_block;
4439:
4440: /* Indexed by loop number, contains nesting level of first block in the
4441: loop, if any. Only valid if doing loop unrolling and outputting debugger
4442: info. */
4443:
4444: int *loop_number_block_level;
4445:
4446: /* Scan the function looking for loops, and walk the BLOCK tree at the
4447: same time. Record the first and last BLOCK tree corresponding to each
4448: loop. This function is similar to find_and_verify_loops in loop.c. */
4449:
4450: void
4451: find_loop_tree_blocks (f)
4452: rtx f;
4453: {
4454: rtx insn;
4455: int current_loop = -1;
4456: int next_loop = -1;
4457: int loop;
4458: int block_level, tree_level;
4459: tree tree_block, parent_tree_block;
4460:
4461: tree_block = DECL_INITIAL (current_function_decl);
4462: parent_tree_block = 0;
4463: block_level = 0;
4464: tree_level = -1;
4465:
4466: /* Find boundaries of loops, and save the first and last BLOCK tree
4467: corresponding to each loop. */
4468:
4469: for (insn = f; insn; insn = NEXT_INSN (insn))
4470: {
4471: if (GET_CODE (insn) == NOTE)
4472: switch (NOTE_LINE_NUMBER (insn))
4473: {
4474: case NOTE_INSN_LOOP_BEG:
4475: loop_number_block_level[++next_loop] = block_level;
4476: loop_number_first_block[next_loop] = 0;
4477: current_loop = next_loop;
4478: break;
4479:
4480: case NOTE_INSN_LOOP_END:
4481: if (current_loop == -1)
4482: abort ();
4483:
4484: current_loop = loop_outer_loop[current_loop];
4485: break;
4486:
4487: case NOTE_INSN_BLOCK_BEG:
4488: if (tree_level < block_level)
4489: {
4490: /* We have seen two NOTE_INSN_BLOCK_BEG notes in a row, so
4491: we must now visit the subtree of the current block. */
4492: parent_tree_block = tree_block;
4493: tree_block = BLOCK_SUBBLOCKS (tree_block);
4494: tree_level++;
4495: }
4496: else if (tree_level > block_level)
4497: abort ();
4498:
4499: /* Save this block tree here for all nested loops for which
4500: this is the topmost block. */
4501: for (loop = current_loop;
4502: loop != -1 && block_level == loop_number_block_level[loop];
4503: loop = loop_outer_loop[loop])
4504: {
4505: if (loop_number_first_block[loop] == 0)
4506: loop_number_first_block[loop] = tree_block;
4507: loop_number_last_block[loop] = tree_block;
4508: }
4509:
4510: block_level++;
4511: break;
4512:
4513: case NOTE_INSN_BLOCK_END:
4514: block_level--;
4515: if (tree_level > block_level)
4516: {
4517: /* We have seen two NOTE_INSN_BLOCK_END notes in a row, so
4518: we must now visit the parent of the current tree. */
4519: if (tree_block != 0 || parent_tree_block == 0)
4520: abort ();
4521: tree_block = parent_tree_block;
4522: parent_tree_block = BLOCK_SUPERCONTEXT (parent_tree_block);
4523: tree_level--;
4524: }
4525: tree_block = BLOCK_CHAIN (tree_block);
4526: break;
4527: }
4528: }
4529: }
4530:
4531: /* This routine will make COPIES-1 copies of all BLOCK trees that correspond
4532: to BLOCK_BEG notes inside the loop LOOP_NUMBER.
4533:
4534: Note that we only copy the topmost level of tree nodes; they will share
4535: pointers to the same subblocks. */
4536:
4537: void
4538: unroll_block_trees (loop_number, copies)
4539: int loop_number;
4540: int copies;
4541: {
4542: int i;
4543:
4544: /* First check whether there are any blocks that need to be copied. */
4545: if (loop_number_first_block[loop_number])
4546: {
4547: tree first_block = loop_number_first_block[loop_number];
4548: tree last_block = loop_number_last_block[loop_number];
4549: tree last_block_created = 0;
4550:
4551: for (i = 0; i < copies - 1; i++)
4552: {
4553: tree block = first_block;
4554: tree insert_after = last_block;
4555: tree copied_block;
4556:
4557: /* Copy every block between first_block and last_block inclusive,
4558: inserting the new blocks after last_block. */
4559: do
4560: {
4561: tree new_block = make_node (BLOCK);
4562: BLOCK_VARS (new_block) = BLOCK_VARS (block);
4563: BLOCK_TYPE_TAGS (new_block) = BLOCK_TYPE_TAGS (block);
4564: BLOCK_SUBBLOCKS (new_block) = BLOCK_SUBBLOCKS (block);
4565: BLOCK_SUPERCONTEXT (new_block) = BLOCK_SUPERCONTEXT (block);
4566: TREE_USED (new_block) = TREE_USED (block);
4567:
4568: /* Insert the new block after the insertion point, and move
4569: the insertion point to the new block. This ensures that
4570: the copies are inserted in the right order. */
4571: BLOCK_CHAIN (new_block) = BLOCK_CHAIN (insert_after);
4572: BLOCK_CHAIN (insert_after) = new_block;
4573: insert_after = new_block;
4574:
4575: copied_block = block;
4576: block = BLOCK_CHAIN (block);
4577: }
4578: while (copied_block != last_block);
4579:
4580: /* Remember the last block created, so that we can update the
4581: info in the tables. */
4582: if (last_block_created == 0)
4583: last_block_created = insert_after;
4584: }
4585:
4586: /* For all nested loops for which LAST_BLOCK was originally the last
4587: block, update the tables to indicate that LAST_BLOCK_CREATED is
4588: now the last block in the loop. */
4589: for (i = loop_number; last_block == loop_number_last_block[i];
4590: i = loop_outer_loop[i])
4591: loop_number_last_block[i] = last_block_created;
4592: }
4593: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.