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