1 /* Expands front end tree to back end RTL for GNU C-Compiler
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* This file handles the generation of rtl code from tree structure
23 above the level of expressions, using subroutines in exp*.c and emit-rtl.c.
24 It also creates the rtl expressions for parameters and auto variables
25 and has full responsibility for allocating stack slots.
27 The functions whose names start with `expand_' are called by the
28 parser to generate RTL instructions for various kinds of constructs.
30 Some control and binding constructs require calling several such
31 functions at different times. For example, a simple if-then
32 is expanded by calling `expand_start_cond' (with the condition-expression
33 as argument) before parsing the then-clause and calling `expand_end_cond'
34 after parsing the then-clause. */
45 #include "insn-config.h"
47 #include "hard-reg-set.h"
56 #define obstack_chunk_alloc xmalloc
57 #define obstack_chunk_free free
58 struct obstack stmt_obstack;
60 /* Assume that case vectors are not pc-relative. */
61 #ifndef CASE_VECTOR_PC_RELATIVE
62 #define CASE_VECTOR_PC_RELATIVE 0
65 /* Functions and data structures for expanding case statements. */
67 /* Case label structure, used to hold info on labels within case
68 statements. We handle "range" labels; for a single-value label
69 as in C, the high and low limits are the same.
71 An AVL tree of case nodes is initially created, and later transformed
72 to a list linked via the RIGHT fields in the nodes. Nodes with
73 higher case values are later in the list.
75 Switch statements can be output in one of two forms. A branch table
76 is used if there are more than a few labels and the labels are dense
77 within the range between the smallest and largest case value. If a
78 branch table is used, no further manipulations are done with the case
81 The alternative to the use of a branch table is to generate a series
82 of compare and jump insns. When that is done, we use the LEFT, RIGHT,
83 and PARENT fields to hold a binary tree. Initially the tree is
84 totally unbalanced, with everything on the right. We balance the tree
85 with nodes on the left having lower case values than the parent
86 and nodes on the right having higher values. We then output the tree
91 struct case_node *left; /* Left son in binary tree */
92 struct case_node *right; /* Right son in binary tree; also node chain */
93 struct case_node *parent; /* Parent of node in binary tree */
94 tree low; /* Lowest index value for this label */
95 tree high; /* Highest index value for this label */
96 tree code_label; /* Label to jump to when node matches */
100 typedef struct case_node case_node;
101 typedef struct case_node *case_node_ptr;
103 /* These are used by estimate_case_costs and balance_case_nodes. */
105 /* This must be a signed type, and non-ANSI compilers lack signed char. */
106 static short cost_table_[129];
107 static int use_cost_table;
108 static int cost_table_initialized;
110 /* Special care is needed because we allow -1, but TREE_INT_CST_LOW
112 #define COST_TABLE(I) cost_table_[(unsigned HOST_WIDE_INT)((I) + 1)]
114 /* Stack of control and binding constructs we are currently inside.
116 These constructs begin when you call `expand_start_WHATEVER'
117 and end when you call `expand_end_WHATEVER'. This stack records
118 info about how the construct began that tells the end-function
119 what to do. It also may provide information about the construct
120 to alter the behavior of other constructs within the body.
121 For example, they may affect the behavior of C `break' and `continue'.
123 Each construct gets one `struct nesting' object.
124 All of these objects are chained through the `all' field.
125 `nesting_stack' points to the first object (innermost construct).
126 The position of an entry on `nesting_stack' is in its `depth' field.
128 Each type of construct has its own individual stack.
129 For example, loops have `loop_stack'. Each object points to the
130 next object of the same type through the `next' field.
132 Some constructs are visible to `break' exit-statements and others
133 are not. Which constructs are visible depends on the language.
134 Therefore, the data structure allows each construct to be visible
135 or not, according to the args given when the construct is started.
136 The construct is visible if the `exit_label' field is non-null.
137 In that case, the value should be a CODE_LABEL rtx. */
142 struct nesting *next;
147 /* For conds (if-then and if-then-else statements). */
150 /* Label for the end of the if construct.
151 There is none if EXITFLAG was not set
152 and no `else' has been seen yet. */
154 /* Label for the end of this alternative.
155 This may be the end of the if or the next else/elseif. */
161 /* Label at the top of the loop; place to loop back to. */
163 /* Label at the end of the whole construct. */
165 /* Label before a jump that branches to the end of the whole
166 construct. This is where destructors go if any. */
168 /* Label for `continue' statement to jump to;
169 this is in front of the stepper of the loop. */
172 /* For variable binding contours. */
175 /* Sequence number of this binding contour within the function,
176 in order of entry. */
177 int block_start_count;
178 /* Nonzero => value to restore stack to on exit. */
180 /* The NOTE that starts this contour.
181 Used by expand_goto to check whether the destination
182 is within each contour or not. */
184 /* Innermost containing binding contour that has a stack level. */
185 struct nesting *innermost_stack_block;
186 /* List of cleanups to be run on exit from this contour.
187 This is a list of expressions to be evaluated.
188 The TREE_PURPOSE of each link is the ..._DECL node
189 which the cleanup pertains to. */
191 /* List of cleanup-lists of blocks containing this block,
192 as they were at the locus where this block appears.
193 There is an element for each containing block,
194 ordered innermost containing block first.
195 The tail of this list can be 0,
196 if all remaining elements would be empty lists.
197 The element's TREE_VALUE is the cleanup-list of that block,
198 which may be null. */
200 /* Chain of labels defined inside this binding contour.
201 For contours that have stack levels or cleanups. */
202 struct label_chain *label_chain;
203 /* Number of function calls seen, as of start of this block. */
204 int n_function_calls;
205 /* Nonzero if this is associated with a EH region. */
206 int exception_region;
207 /* The saved target_temp_slot_level from our outer block.
208 We may reset target_temp_slot_level to be the level of
209 this block, if that is done, target_temp_slot_level
210 reverts to the saved target_temp_slot_level at the very
212 int block_target_temp_slot_level;
213 /* True if we are currently emitting insns in an area of
214 output code that is controlled by a conditional
215 expression. This is used by the cleanup handling code to
216 generate conditional cleanup actions. */
217 int conditional_code;
218 /* A place to move the start of the exception region for any
219 of the conditional cleanups, must be at the end or after
220 the start of the last unconditional cleanup, and before any
221 conditional branch points. */
222 rtx last_unconditional_cleanup;
223 /* When in a conditional context, this is the specific
224 cleanup list associated with last_unconditional_cleanup,
225 where we place the conditionalized cleanups. */
228 /* For switch (C) or case (Pascal) statements,
229 and also for dummies (see `expand_start_case_dummy'). */
232 /* The insn after which the case dispatch should finally
233 be emitted. Zero for a dummy. */
235 /* A list of case labels; it is first built as an AVL tree.
236 During expand_end_case, this is converted to a list, and may be
237 rearranged into a nearly balanced binary tree. */
238 struct case_node *case_list;
239 /* Label to jump to if no case matches. */
241 /* The expression to be dispatched on. */
243 /* Type that INDEX_EXPR should be converted to. */
245 /* Name of this kind of statement, for warnings. */
246 const char *printname;
247 /* Used to save no_line_numbers till we see the first case label.
248 We set this to -1 when we see the first case label in this
250 int line_number_status;
255 /* Allocate and return a new `struct nesting'. */
257 #define ALLOC_NESTING() \
258 (struct nesting *) obstack_alloc (&stmt_obstack, sizeof (struct nesting))
260 /* Pop the nesting stack element by element until we pop off
261 the element which is at the top of STACK.
262 Update all the other stacks, popping off elements from them
263 as we pop them from nesting_stack. */
265 #define POPSTACK(STACK) \
266 do { struct nesting *target = STACK; \
267 struct nesting *this; \
268 do { this = nesting_stack; \
269 if (loop_stack == this) \
270 loop_stack = loop_stack->next; \
271 if (cond_stack == this) \
272 cond_stack = cond_stack->next; \
273 if (block_stack == this) \
274 block_stack = block_stack->next; \
275 if (stack_block_stack == this) \
276 stack_block_stack = stack_block_stack->next; \
277 if (case_stack == this) \
278 case_stack = case_stack->next; \
279 nesting_depth = nesting_stack->depth - 1; \
280 nesting_stack = this->all; \
281 obstack_free (&stmt_obstack, this); } \
282 while (this != target); } while (0)
284 /* In some cases it is impossible to generate code for a forward goto
285 until the label definition is seen. This happens when it may be necessary
286 for the goto to reset the stack pointer: we don't yet know how to do that.
287 So expand_goto puts an entry on this fixup list.
288 Each time a binding contour that resets the stack is exited,
290 If the target label has now been defined, we can insert the proper code. */
294 /* Points to following fixup. */
295 struct goto_fixup *next;
296 /* Points to the insn before the jump insn.
297 If more code must be inserted, it goes after this insn. */
299 /* The LABEL_DECL that this jump is jumping to, or 0
300 for break, continue or return. */
302 /* The BLOCK for the place where this goto was found. */
304 /* The CODE_LABEL rtx that this is jumping to. */
306 /* Number of binding contours started in current function
307 before the label reference. */
308 int block_start_count;
309 /* The outermost stack level that should be restored for this jump.
310 Each time a binding contour that resets the stack is exited,
311 if the target label is *not* yet defined, this slot is updated. */
313 /* List of lists of cleanup expressions to be run by this goto.
314 There is one element for each block that this goto is within.
315 The tail of this list can be 0,
316 if all remaining elements would be empty.
317 The TREE_VALUE contains the cleanup list of that block as of the
318 time this goto was seen.
319 The TREE_ADDRESSABLE flag is 1 for a block that has been exited. */
320 tree cleanup_list_list;
323 /* Within any binding contour that must restore a stack level,
324 all labels are recorded with a chain of these structures. */
328 /* Points to following fixup. */
329 struct label_chain *next;
335 /* Chain of all pending binding contours. */
336 struct nesting *x_block_stack;
338 /* If any new stacks are added here, add them to POPSTACKS too. */
340 /* Chain of all pending binding contours that restore stack levels
342 struct nesting *x_stack_block_stack;
344 /* Chain of all pending conditional statements. */
345 struct nesting *x_cond_stack;
347 /* Chain of all pending loops. */
348 struct nesting *x_loop_stack;
350 /* Chain of all pending case or switch statements. */
351 struct nesting *x_case_stack;
353 /* Separate chain including all of the above,
354 chained through the `all' field. */
355 struct nesting *x_nesting_stack;
357 /* Number of entries on nesting_stack now. */
360 /* Number of binding contours started so far in this function. */
361 int x_block_start_count;
363 /* Each time we expand an expression-statement,
364 record the expr's type and its RTL value here. */
365 tree x_last_expr_type;
366 rtx x_last_expr_value;
368 /* Nonzero if within a ({...}) grouping, in which case we must
369 always compute a value for each expr-stmt in case it is the last one. */
370 int x_expr_stmts_for_value;
372 /* Filename and line number of last line-number note,
373 whether we actually emitted it or not. */
374 const char *x_emit_filename;
377 struct goto_fixup *x_goto_fixup_chain;
380 #define block_stack (cfun->stmt->x_block_stack)
381 #define stack_block_stack (cfun->stmt->x_stack_block_stack)
382 #define cond_stack (cfun->stmt->x_cond_stack)
383 #define loop_stack (cfun->stmt->x_loop_stack)
384 #define case_stack (cfun->stmt->x_case_stack)
385 #define nesting_stack (cfun->stmt->x_nesting_stack)
386 #define nesting_depth (cfun->stmt->x_nesting_depth)
387 #define current_block_start_count (cfun->stmt->x_block_start_count)
388 #define last_expr_type (cfun->stmt->x_last_expr_type)
389 #define last_expr_value (cfun->stmt->x_last_expr_value)
390 #define expr_stmts_for_value (cfun->stmt->x_expr_stmts_for_value)
391 #define emit_filename (cfun->stmt->x_emit_filename)
392 #define emit_lineno (cfun->stmt->x_emit_lineno)
393 #define goto_fixup_chain (cfun->stmt->x_goto_fixup_chain)
395 /* Non-zero if we are using EH to handle cleanus. */
396 static int using_eh_for_cleanups_p = 0;
398 static int n_occurrences PARAMS ((int, const char *));
399 static void expand_goto_internal PARAMS ((tree, rtx, rtx));
400 static int expand_fixup PARAMS ((tree, rtx, rtx));
401 static rtx expand_nl_handler_label PARAMS ((rtx, rtx));
402 static void expand_nl_goto_receiver PARAMS ((void));
403 static void expand_nl_goto_receivers PARAMS ((struct nesting *));
404 static void fixup_gotos PARAMS ((struct nesting *, rtx, tree,
406 static void expand_null_return_1 PARAMS ((rtx, int));
407 static void expand_value_return PARAMS ((rtx));
408 static int tail_recursion_args PARAMS ((tree, tree));
409 static void expand_cleanups PARAMS ((tree, tree, int, int));
410 static void check_seenlabel PARAMS ((void));
411 static void do_jump_if_equal PARAMS ((rtx, rtx, rtx, int));
412 static int estimate_case_costs PARAMS ((case_node_ptr));
413 static void group_case_nodes PARAMS ((case_node_ptr));
414 static void balance_case_nodes PARAMS ((case_node_ptr *,
416 static int node_has_low_bound PARAMS ((case_node_ptr, tree));
417 static int node_has_high_bound PARAMS ((case_node_ptr, tree));
418 static int node_is_bounded PARAMS ((case_node_ptr, tree));
419 static void emit_jump_if_reachable PARAMS ((rtx));
420 static void emit_case_nodes PARAMS ((rtx, case_node_ptr, rtx, tree));
421 static struct case_node *case_tree2list PARAMS ((case_node *, case_node *));
422 static void mark_cond_nesting PARAMS ((struct nesting *));
423 static void mark_loop_nesting PARAMS ((struct nesting *));
424 static void mark_block_nesting PARAMS ((struct nesting *));
425 static void mark_case_nesting PARAMS ((struct nesting *));
426 static void mark_case_node PARAMS ((struct case_node *));
427 static void mark_goto_fixup PARAMS ((struct goto_fixup *));
428 static void free_case_nodes PARAMS ((case_node_ptr));
431 using_eh_for_cleanups ()
433 using_eh_for_cleanups_p = 1;
436 /* Mark N (known to be a cond-nesting) for GC. */
439 mark_cond_nesting (n)
444 ggc_mark_rtx (n->exit_label);
445 ggc_mark_rtx (n->data.cond.endif_label);
446 ggc_mark_rtx (n->data.cond.next_label);
452 /* Mark N (known to be a loop-nesting) for GC. */
455 mark_loop_nesting (n)
461 ggc_mark_rtx (n->exit_label);
462 ggc_mark_rtx (n->data.loop.start_label);
463 ggc_mark_rtx (n->data.loop.end_label);
464 ggc_mark_rtx (n->data.loop.alt_end_label);
465 ggc_mark_rtx (n->data.loop.continue_label);
471 /* Mark N (known to be a block-nesting) for GC. */
474 mark_block_nesting (n)
479 struct label_chain *l;
481 ggc_mark_rtx (n->exit_label);
482 ggc_mark_rtx (n->data.block.stack_level);
483 ggc_mark_rtx (n->data.block.first_insn);
484 ggc_mark_tree (n->data.block.cleanups);
485 ggc_mark_tree (n->data.block.outer_cleanups);
487 for (l = n->data.block.label_chain; l != NULL; l = l->next)
490 ggc_mark_tree (l->label);
493 ggc_mark_rtx (n->data.block.last_unconditional_cleanup);
495 /* ??? cleanup_ptr never points outside the stack, does it? */
501 /* Mark N (known to be a case-nesting) for GC. */
504 mark_case_nesting (n)
509 ggc_mark_rtx (n->exit_label);
510 ggc_mark_rtx (n->data.case_stmt.start);
512 ggc_mark_tree (n->data.case_stmt.default_label);
513 ggc_mark_tree (n->data.case_stmt.index_expr);
514 ggc_mark_tree (n->data.case_stmt.nominal_type);
516 mark_case_node (n->data.case_stmt.case_list);
529 ggc_mark_tree (c->low);
530 ggc_mark_tree (c->high);
531 ggc_mark_tree (c->code_label);
533 mark_case_node (c->right);
534 mark_case_node (c->left);
542 struct goto_fixup *g;
547 ggc_mark_rtx (g->before_jump);
548 ggc_mark_tree (g->target);
549 ggc_mark_tree (g->context);
550 ggc_mark_rtx (g->target_rtl);
551 ggc_mark_rtx (g->stack_level);
552 ggc_mark_tree (g->cleanup_list_list);
558 /* Clear out all parts of the state in F that can safely be discarded
559 after the function has been compiled, to let garbage collection
560 reclaim the memory. */
566 /* We're about to free the function obstack. If we hold pointers to
567 things allocated there, then we'll try to mark them when we do
568 GC. So, we clear them out here explicitly. */
578 struct stmt_status *p;
583 mark_block_nesting (p->x_block_stack);
584 mark_cond_nesting (p->x_cond_stack);
585 mark_loop_nesting (p->x_loop_stack);
586 mark_case_nesting (p->x_case_stack);
588 ggc_mark_tree (p->x_last_expr_type);
589 /* last_epxr_value is only valid if last_expr_type is nonzero. */
590 if (p->x_last_expr_type)
591 ggc_mark_rtx (p->x_last_expr_value);
593 mark_goto_fixup (p->x_goto_fixup_chain);
599 gcc_obstack_init (&stmt_obstack);
603 init_stmt_for_function ()
605 cfun->stmt = (struct stmt_status *) xmalloc (sizeof (struct stmt_status));
607 /* We are not currently within any block, conditional, loop or case. */
609 stack_block_stack = 0;
616 current_block_start_count = 0;
618 /* No gotos have been expanded yet. */
619 goto_fixup_chain = 0;
621 /* We are not processing a ({...}) grouping. */
622 expr_stmts_for_value = 0;
624 last_expr_value = NULL_RTX;
627 /* Return nonzero if anything is pushed on the loop, condition, or case
632 return cond_stack || loop_stack || case_stack;
635 /* Record the current file and line. Called from emit_line_note. */
637 set_file_and_line_for_stmt (file, line)
641 /* If we're outputting an inline function, and we add a line note,
642 there may be no CFUN->STMT information. So, there's no need to
646 emit_filename = file;
651 /* Emit a no-op instruction. */
658 last_insn = get_last_insn ();
660 && (GET_CODE (last_insn) == CODE_LABEL
661 || (GET_CODE (last_insn) == NOTE
662 && prev_real_insn (last_insn) == 0)))
663 emit_insn (gen_nop ());
666 /* Return the rtx-label that corresponds to a LABEL_DECL,
667 creating it if necessary. */
673 if (TREE_CODE (label) != LABEL_DECL)
676 if (!DECL_RTL_SET_P (label))
677 SET_DECL_RTL (label, gen_label_rtx ());
679 return DECL_RTL (label);
683 /* Add an unconditional jump to LABEL as the next sequential instruction. */
689 do_pending_stack_adjust ();
690 emit_jump_insn (gen_jump (label));
694 /* Emit code to jump to the address
695 specified by the pointer expression EXP. */
698 expand_computed_goto (exp)
701 rtx x = expand_expr (exp, NULL_RTX, VOIDmode, 0);
703 #ifdef POINTERS_EXTEND_UNSIGNED
704 x = convert_memory_address (Pmode, x);
708 /* Be sure the function is executable. */
709 if (current_function_check_memory_usage)
710 emit_library_call (chkr_check_exec_libfunc, LCT_CONST_MAKE_BLOCK,
711 VOIDmode, 1, x, ptr_mode);
713 do_pending_stack_adjust ();
714 emit_indirect_jump (x);
716 current_function_has_computed_jump = 1;
719 /* Handle goto statements and the labels that they can go to. */
721 /* Specify the location in the RTL code of a label LABEL,
722 which is a LABEL_DECL tree node.
724 This is used for the kind of label that the user can jump to with a
725 goto statement, and for alternatives of a switch or case statement.
726 RTL labels generated for loops and conditionals don't go through here;
727 they are generated directly at the RTL level, by other functions below.
729 Note that this has nothing to do with defining label *names*.
730 Languages vary in how they do that and what that even means. */
736 struct label_chain *p;
738 do_pending_stack_adjust ();
739 emit_label (label_rtx (label));
740 if (DECL_NAME (label))
741 LABEL_NAME (DECL_RTL (label)) = IDENTIFIER_POINTER (DECL_NAME (label));
743 if (stack_block_stack != 0)
745 p = (struct label_chain *) ggc_alloc (sizeof (struct label_chain));
746 p->next = stack_block_stack->data.block.label_chain;
747 stack_block_stack->data.block.label_chain = p;
752 /* Declare that LABEL (a LABEL_DECL) may be used for nonlocal gotos
753 from nested functions. */
756 declare_nonlocal_label (label)
759 rtx slot = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0);
761 nonlocal_labels = tree_cons (NULL_TREE, label, nonlocal_labels);
762 LABEL_PRESERVE_P (label_rtx (label)) = 1;
763 if (nonlocal_goto_handler_slots == 0)
765 emit_stack_save (SAVE_NONLOCAL,
766 &nonlocal_goto_stack_level,
767 PREV_INSN (tail_recursion_reentry));
769 nonlocal_goto_handler_slots
770 = gen_rtx_EXPR_LIST (VOIDmode, slot, nonlocal_goto_handler_slots);
773 /* Generate RTL code for a `goto' statement with target label LABEL.
774 LABEL should be a LABEL_DECL tree node that was or will later be
775 defined with `expand_label'. */
783 /* Check for a nonlocal goto to a containing function. */
784 context = decl_function_context (label);
785 if (context != 0 && context != current_function_decl)
787 struct function *p = find_function_data (context);
788 rtx label_ref = gen_rtx_LABEL_REF (Pmode, label_rtx (label));
789 rtx handler_slot, static_chain, save_area, insn;
792 /* Find the corresponding handler slot for this label. */
793 handler_slot = p->x_nonlocal_goto_handler_slots;
794 for (link = p->x_nonlocal_labels; TREE_VALUE (link) != label;
795 link = TREE_CHAIN (link))
796 handler_slot = XEXP (handler_slot, 1);
797 handler_slot = XEXP (handler_slot, 0);
799 p->has_nonlocal_label = 1;
800 current_function_has_nonlocal_goto = 1;
801 LABEL_REF_NONLOCAL_P (label_ref) = 1;
803 /* Copy the rtl for the slots so that they won't be shared in
804 case the virtual stack vars register gets instantiated differently
805 in the parent than in the child. */
807 static_chain = copy_to_reg (lookup_static_chain (label));
809 /* Get addr of containing function's current nonlocal goto handler,
810 which will do any cleanups and then jump to the label. */
811 handler_slot = copy_to_reg (replace_rtx (copy_rtx (handler_slot),
812 virtual_stack_vars_rtx,
815 /* Get addr of containing function's nonlocal save area. */
816 save_area = p->x_nonlocal_goto_stack_level;
818 save_area = replace_rtx (copy_rtx (save_area),
819 virtual_stack_vars_rtx, static_chain);
821 #if HAVE_nonlocal_goto
822 if (HAVE_nonlocal_goto)
823 emit_insn (gen_nonlocal_goto (static_chain, handler_slot,
824 save_area, label_ref));
828 /* Restore frame pointer for containing function.
829 This sets the actual hard register used for the frame pointer
830 to the location of the function's incoming static chain info.
831 The non-local goto handler will then adjust it to contain the
832 proper value and reload the argument pointer, if needed. */
833 emit_move_insn (hard_frame_pointer_rtx, static_chain);
834 emit_stack_restore (SAVE_NONLOCAL, save_area, NULL_RTX);
836 /* USE of hard_frame_pointer_rtx added for consistency;
837 not clear if really needed. */
838 emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
839 emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
840 emit_indirect_jump (handler_slot);
843 /* Search backwards to the jump insn and mark it as a
845 for (insn = get_last_insn ();
846 GET_CODE (insn) != JUMP_INSN;
847 insn = PREV_INSN (insn))
849 REG_NOTES (insn) = alloc_EXPR_LIST (REG_NON_LOCAL_GOTO, const0_rtx,
853 expand_goto_internal (label, label_rtx (label), NULL_RTX);
856 /* Generate RTL code for a `goto' statement with target label BODY.
857 LABEL should be a LABEL_REF.
858 LAST_INSN, if non-0, is the rtx we should consider as the last
859 insn emitted (for the purposes of cleaning up a return). */
862 expand_goto_internal (body, label, last_insn)
867 struct nesting *block;
870 if (GET_CODE (label) != CODE_LABEL)
873 /* If label has already been defined, we can tell now
874 whether and how we must alter the stack level. */
876 if (PREV_INSN (label) != 0)
878 /* Find the innermost pending block that contains the label.
879 (Check containment by comparing insn-uids.)
880 Then restore the outermost stack level within that block,
881 and do cleanups of all blocks contained in it. */
882 for (block = block_stack; block; block = block->next)
884 if (INSN_UID (block->data.block.first_insn) < INSN_UID (label))
886 if (block->data.block.stack_level != 0)
887 stack_level = block->data.block.stack_level;
888 /* Execute the cleanups for blocks we are exiting. */
889 if (block->data.block.cleanups != 0)
891 expand_cleanups (block->data.block.cleanups, NULL_TREE, 1, 1);
892 do_pending_stack_adjust ();
898 /* Ensure stack adjust isn't done by emit_jump, as this
899 would clobber the stack pointer. This one should be
900 deleted as dead by flow. */
901 clear_pending_stack_adjust ();
902 do_pending_stack_adjust ();
904 /* Don't do this adjust if it's to the end label and this function
905 is to return with a depressed stack pointer. */
906 if (label == return_label
907 && (((TREE_CODE (TREE_TYPE (current_function_decl))
909 && (TYPE_RETURNS_STACK_DEPRESSED
910 (TREE_TYPE (current_function_decl))))))
913 emit_stack_restore (SAVE_BLOCK, stack_level, NULL_RTX);
916 if (body != 0 && DECL_TOO_LATE (body))
917 error ("jump to `%s' invalidly jumps into binding contour",
918 IDENTIFIER_POINTER (DECL_NAME (body)));
920 /* Label not yet defined: may need to put this goto
921 on the fixup list. */
922 else if (! expand_fixup (body, label, last_insn))
924 /* No fixup needed. Record that the label is the target
925 of at least one goto that has no fixup. */
927 TREE_ADDRESSABLE (body) = 1;
933 /* Generate if necessary a fixup for a goto
934 whose target label in tree structure (if any) is TREE_LABEL
935 and whose target in rtl is RTL_LABEL.
937 If LAST_INSN is nonzero, we pretend that the jump appears
938 after insn LAST_INSN instead of at the current point in the insn stream.
940 The fixup will be used later to insert insns just before the goto.
941 Those insns will restore the stack level as appropriate for the
942 target label, and will (in the case of C++) also invoke any object
943 destructors which have to be invoked when we exit the scopes which
944 are exited by the goto.
946 Value is nonzero if a fixup is made. */
949 expand_fixup (tree_label, rtl_label, last_insn)
954 struct nesting *block, *end_block;
956 /* See if we can recognize which block the label will be output in.
957 This is possible in some very common cases.
958 If we succeed, set END_BLOCK to that block.
959 Otherwise, set it to 0. */
962 && (rtl_label == cond_stack->data.cond.endif_label
963 || rtl_label == cond_stack->data.cond.next_label))
964 end_block = cond_stack;
965 /* If we are in a loop, recognize certain labels which
966 are likely targets. This reduces the number of fixups
967 we need to create. */
969 && (rtl_label == loop_stack->data.loop.start_label
970 || rtl_label == loop_stack->data.loop.end_label
971 || rtl_label == loop_stack->data.loop.continue_label))
972 end_block = loop_stack;
976 /* Now set END_BLOCK to the binding level to which we will return. */
980 struct nesting *next_block = end_block->all;
983 /* First see if the END_BLOCK is inside the innermost binding level.
984 If so, then no cleanups or stack levels are relevant. */
985 while (next_block && next_block != block)
986 next_block = next_block->all;
991 /* Otherwise, set END_BLOCK to the innermost binding level
992 which is outside the relevant control-structure nesting. */
993 next_block = block_stack->next;
994 for (block = block_stack; block != end_block; block = block->all)
995 if (block == next_block)
996 next_block = next_block->next;
997 end_block = next_block;
1000 /* Does any containing block have a stack level or cleanups?
1001 If not, no fixup is needed, and that is the normal case
1002 (the only case, for standard C). */
1003 for (block = block_stack; block != end_block; block = block->next)
1004 if (block->data.block.stack_level != 0
1005 || block->data.block.cleanups != 0)
1008 if (block != end_block)
1010 /* Ok, a fixup is needed. Add a fixup to the list of such. */
1011 struct goto_fixup *fixup
1012 = (struct goto_fixup *) ggc_alloc (sizeof (struct goto_fixup));
1013 /* In case an old stack level is restored, make sure that comes
1014 after any pending stack adjust. */
1015 /* ?? If the fixup isn't to come at the present position,
1016 doing the stack adjust here isn't useful. Doing it with our
1017 settings at that location isn't useful either. Let's hope
1020 do_pending_stack_adjust ();
1021 fixup->target = tree_label;
1022 fixup->target_rtl = rtl_label;
1024 /* Create a BLOCK node and a corresponding matched set of
1025 NOTE_INSN_BLOCK_BEG and NOTE_INSN_BLOCK_END notes at
1026 this point. The notes will encapsulate any and all fixup
1027 code which we might later insert at this point in the insn
1028 stream. Also, the BLOCK node will be the parent (i.e. the
1029 `SUPERBLOCK') of any other BLOCK nodes which we might create
1030 later on when we are expanding the fixup code.
1032 Note that optimization passes (including expand_end_loop)
1033 might move the *_BLOCK notes away, so we use a NOTE_INSN_DELETED
1034 as a placeholder. */
1037 register rtx original_before_jump
1038 = last_insn ? last_insn : get_last_insn ();
1043 block = make_node (BLOCK);
1044 TREE_USED (block) = 1;
1046 if (!cfun->x_whole_function_mode_p)
1047 insert_block (block);
1051 = BLOCK_CHAIN (DECL_INITIAL (current_function_decl));
1052 BLOCK_CHAIN (DECL_INITIAL (current_function_decl))
1057 start = emit_note (NULL, NOTE_INSN_BLOCK_BEG);
1058 if (cfun->x_whole_function_mode_p)
1059 NOTE_BLOCK (start) = block;
1060 fixup->before_jump = emit_note (NULL, NOTE_INSN_DELETED);
1061 end = emit_note (NULL, NOTE_INSN_BLOCK_END);
1062 if (cfun->x_whole_function_mode_p)
1063 NOTE_BLOCK (end) = block;
1064 fixup->context = block;
1066 emit_insns_after (start, original_before_jump);
1069 fixup->block_start_count = current_block_start_count;
1070 fixup->stack_level = 0;
1071 fixup->cleanup_list_list
1072 = ((block->data.block.outer_cleanups
1073 || block->data.block.cleanups)
1074 ? tree_cons (NULL_TREE, block->data.block.cleanups,
1075 block->data.block.outer_cleanups)
1077 fixup->next = goto_fixup_chain;
1078 goto_fixup_chain = fixup;
1084 /* Expand any needed fixups in the outputmost binding level of the
1085 function. FIRST_INSN is the first insn in the function. */
1088 expand_fixups (first_insn)
1091 fixup_gotos (NULL, NULL_RTX, NULL_TREE, first_insn, 0);
1094 /* When exiting a binding contour, process all pending gotos requiring fixups.
1095 THISBLOCK is the structure that describes the block being exited.
1096 STACK_LEVEL is the rtx for the stack level to restore exiting this contour.
1097 CLEANUP_LIST is a list of expressions to evaluate on exiting this contour.
1098 FIRST_INSN is the insn that began this contour.
1100 Gotos that jump out of this contour must restore the
1101 stack level and do the cleanups before actually jumping.
1103 DONT_JUMP_IN nonzero means report error there is a jump into this
1104 contour from before the beginning of the contour.
1105 This is also done if STACK_LEVEL is nonzero. */
1108 fixup_gotos (thisblock, stack_level, cleanup_list, first_insn, dont_jump_in)
1109 struct nesting *thisblock;
1115 register struct goto_fixup *f, *prev;
1117 /* F is the fixup we are considering; PREV is the previous one. */
1118 /* We run this loop in two passes so that cleanups of exited blocks
1119 are run first, and blocks that are exited are marked so
1122 for (prev = 0, f = goto_fixup_chain; f; prev = f, f = f->next)
1124 /* Test for a fixup that is inactive because it is already handled. */
1125 if (f->before_jump == 0)
1127 /* Delete inactive fixup from the chain, if that is easy to do. */
1129 prev->next = f->next;
1131 /* Has this fixup's target label been defined?
1132 If so, we can finalize it. */
1133 else if (PREV_INSN (f->target_rtl) != 0)
1135 register rtx cleanup_insns;
1137 /* If this fixup jumped into this contour from before the beginning
1138 of this contour, report an error. This code used to use
1139 the first non-label insn after f->target_rtl, but that's
1140 wrong since such can be added, by things like put_var_into_stack
1141 and have INSN_UIDs that are out of the range of the block. */
1142 /* ??? Bug: this does not detect jumping in through intermediate
1143 blocks that have stack levels or cleanups.
1144 It detects only a problem with the innermost block
1145 around the label. */
1147 && (dont_jump_in || stack_level || cleanup_list)
1148 && INSN_UID (first_insn) < INSN_UID (f->target_rtl)
1149 && INSN_UID (first_insn) > INSN_UID (f->before_jump)
1150 && ! DECL_ERROR_ISSUED (f->target))
1152 error_with_decl (f->target,
1153 "label `%s' used before containing binding contour");
1154 /* Prevent multiple errors for one label. */
1155 DECL_ERROR_ISSUED (f->target) = 1;
1158 /* We will expand the cleanups into a sequence of their own and
1159 then later on we will attach this new sequence to the insn
1160 stream just ahead of the actual jump insn. */
1164 /* Temporarily restore the lexical context where we will
1165 logically be inserting the fixup code. We do this for the
1166 sake of getting the debugging information right. */
1169 set_block (f->context);
1171 /* Expand the cleanups for blocks this jump exits. */
1172 if (f->cleanup_list_list)
1175 for (lists = f->cleanup_list_list; lists; lists = TREE_CHAIN (lists))
1176 /* Marked elements correspond to blocks that have been closed.
1177 Do their cleanups. */
1178 if (TREE_ADDRESSABLE (lists)
1179 && TREE_VALUE (lists) != 0)
1181 expand_cleanups (TREE_VALUE (lists), NULL_TREE, 1, 1);
1182 /* Pop any pushes done in the cleanups,
1183 in case function is about to return. */
1184 do_pending_stack_adjust ();
1188 /* Restore stack level for the biggest contour that this
1189 jump jumps out of. */
1191 && ! (f->target_rtl == return_label
1192 && ((TREE_CODE (TREE_TYPE (current_function_decl))
1194 && (TYPE_RETURNS_STACK_DEPRESSED
1195 (TREE_TYPE (current_function_decl))))))
1196 emit_stack_restore (SAVE_BLOCK, f->stack_level, f->before_jump);
1198 /* Finish up the sequence containing the insns which implement the
1199 necessary cleanups, and then attach that whole sequence to the
1200 insn stream just ahead of the actual jump insn. Attaching it
1201 at that point insures that any cleanups which are in fact
1202 implicit C++ object destructions (which must be executed upon
1203 leaving the block) appear (to the debugger) to be taking place
1204 in an area of the generated code where the object(s) being
1205 destructed are still "in scope". */
1207 cleanup_insns = get_insns ();
1211 emit_insns_after (cleanup_insns, f->before_jump);
1217 /* For any still-undefined labels, do the cleanups for this block now.
1218 We must do this now since items in the cleanup list may go out
1219 of scope when the block ends. */
1220 for (prev = 0, f = goto_fixup_chain; f; prev = f, f = f->next)
1221 if (f->before_jump != 0
1222 && PREV_INSN (f->target_rtl) == 0
1223 /* Label has still not appeared. If we are exiting a block with
1224 a stack level to restore, that started before the fixup,
1225 mark this stack level as needing restoration
1226 when the fixup is later finalized. */
1228 /* Note: if THISBLOCK == 0 and we have a label that hasn't appeared, it
1229 means the label is undefined. That's erroneous, but possible. */
1230 && (thisblock->data.block.block_start_count
1231 <= f->block_start_count))
1233 tree lists = f->cleanup_list_list;
1236 for (; lists; lists = TREE_CHAIN (lists))
1237 /* If the following elt. corresponds to our containing block
1238 then the elt. must be for this block. */
1239 if (TREE_CHAIN (lists) == thisblock->data.block.outer_cleanups)
1243 set_block (f->context);
1244 expand_cleanups (TREE_VALUE (lists), NULL_TREE, 1, 1);
1245 do_pending_stack_adjust ();
1246 cleanup_insns = get_insns ();
1249 if (cleanup_insns != 0)
1251 = emit_insns_after (cleanup_insns, f->before_jump);
1253 f->cleanup_list_list = TREE_CHAIN (lists);
1257 f->stack_level = stack_level;
1261 /* Return the number of times character C occurs in string S. */
1263 n_occurrences (c, s)
1273 /* Generate RTL for an asm statement (explicit assembler code).
1274 BODY is a STRING_CST node containing the assembler code text,
1275 or an ADDR_EXPR containing a STRING_CST. */
1281 if (current_function_check_memory_usage)
1283 error ("`asm' cannot be used in function where memory usage is checked");
1287 if (TREE_CODE (body) == ADDR_EXPR)
1288 body = TREE_OPERAND (body, 0);
1290 emit_insn (gen_rtx_ASM_INPUT (VOIDmode,
1291 TREE_STRING_POINTER (body)));
1295 /* Generate RTL for an asm statement with arguments.
1296 STRING is the instruction template.
1297 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
1298 Each output or input has an expression in the TREE_VALUE and
1299 a constraint-string in the TREE_PURPOSE.
1300 CLOBBERS is a list of STRING_CST nodes each naming a hard register
1301 that is clobbered by this insn.
1303 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
1304 Some elements of OUTPUTS may be replaced with trees representing temporary
1305 values. The caller should copy those temporary values to the originally
1308 VOL nonzero means the insn is volatile; don't optimize it. */
1311 expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
1312 tree string, outputs, inputs, clobbers;
1314 const char *filename;
1317 rtvec argvec, constraints;
1319 int ninputs = list_length (inputs);
1320 int noutputs = list_length (outputs);
1325 /* Vector of RTX's of evaluated output operands. */
1326 rtx *output_rtx = (rtx *) alloca (noutputs * sizeof (rtx));
1327 int *inout_opnum = (int *) alloca (noutputs * sizeof (int));
1328 rtx *real_output_rtx = (rtx *) alloca (noutputs * sizeof (rtx));
1329 enum machine_mode *inout_mode
1330 = (enum machine_mode *) alloca (noutputs * sizeof (enum machine_mode));
1331 const char **output_constraints
1332 = alloca (noutputs * sizeof (const char *));
1333 /* The insn we have emitted. */
1335 int old_generating_concat_p = generating_concat_p;
1337 /* An ASM with no outputs needs to be treated as volatile, for now. */
1341 if (current_function_check_memory_usage)
1343 error ("`asm' cannot be used with `-fcheck-memory-usage'");
1347 #ifdef MD_ASM_CLOBBERS
1348 /* Sometimes we wish to automatically clobber registers across an asm.
1349 Case in point is when the i386 backend moved from cc0 to a hard reg --
1350 maintaining source-level compatability means automatically clobbering
1351 the flags register. */
1352 MD_ASM_CLOBBERS (clobbers);
1355 if (current_function_check_memory_usage)
1357 error ("`asm' cannot be used in function where memory usage is checked");
1361 /* Count the number of meaningful clobbered registers, ignoring what
1362 we would ignore later. */
1364 for (tail = clobbers; tail; tail = TREE_CHAIN (tail))
1366 const char *regname = TREE_STRING_POINTER (TREE_VALUE (tail));
1368 i = decode_reg_name (regname);
1369 if (i >= 0 || i == -4)
1372 error ("unknown register name `%s' in `asm'", regname);
1377 /* Check that the number of alternatives is constant across all
1379 if (outputs || inputs)
1381 tree tmp = TREE_PURPOSE (outputs ? outputs : inputs);
1382 int nalternatives = n_occurrences (',', TREE_STRING_POINTER (tmp));
1385 if (nalternatives + 1 > MAX_RECOG_ALTERNATIVES)
1387 error ("too many alternatives in `asm'");
1394 const char *constraint = TREE_STRING_POINTER (TREE_PURPOSE (tmp));
1396 if (n_occurrences (',', constraint) != nalternatives)
1398 error ("operand constraints for `asm' differ in number of alternatives");
1402 if (TREE_CHAIN (tmp))
1403 tmp = TREE_CHAIN (tmp);
1405 tmp = next, next = 0;
1409 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
1411 tree val = TREE_VALUE (tail);
1412 tree type = TREE_TYPE (val);
1413 const char *constraint;
1421 /* If there's an erroneous arg, emit no insn. */
1422 if (TREE_TYPE (val) == error_mark_node)
1425 /* Make sure constraint has `=' and does not have `+'. Also, see
1426 if it allows any register. Be liberal on the latter test, since
1427 the worst that happens if we get it wrong is we issue an error
1430 constraint = TREE_STRING_POINTER (TREE_PURPOSE (tail));
1431 output_constraints[i] = constraint;
1432 c_len = strlen (constraint);
1434 /* Allow the `=' or `+' to not be at the beginning of the string,
1435 since it wasn't explicitly documented that way, and there is a
1436 large body of code that puts it last. Swap the character to
1437 the front, so as not to uglify any place else. */
1441 if ((p = strchr (constraint, '=')) != NULL)
1443 if ((p = strchr (constraint, '+')) != NULL)
1446 error ("output operand constraint lacks `='");
1450 is_inout = *p == '+';
1454 /* Have to throw away this constraint string and get a new one. */
1455 char *buf = alloca (c_len + 1);
1458 memcpy (buf + 1, constraint, j);
1459 memcpy (buf + 1 + j, p + 1, c_len - j); /* not -j-1 - copy null */
1460 constraint = ggc_alloc_string (buf, c_len);
1461 output_constraints[i] = constraint;
1465 "output constraint `%c' for operand %d is not at the beginning",
1469 /* Make sure we can specify the matching operand. */
1470 if (is_inout && i > 9)
1472 error ("output operand constraint %d contains `+'", i);
1476 for (j = 1; j < c_len; j++)
1477 switch (constraint[j])
1481 error ("operand constraint contains '+' or '=' at illegal position.");
1485 if (i + 1 == ninputs + noutputs)
1487 error ("`%%' constraint used with last operand");
1492 case '?': case '!': case '*': case '&': case '#':
1493 case 'E': case 'F': case 'G': case 'H':
1494 case 's': case 'i': case 'n':
1495 case 'I': case 'J': case 'K': case 'L': case 'M':
1496 case 'N': case 'O': case 'P': case ',':
1499 case '0': case '1': case '2': case '3': case '4':
1500 case '5': case '6': case '7': case '8': case '9':
1501 error ("matching constraint not valid in output operand");
1504 case 'V': case 'm': case 'o':
1509 /* ??? Before flow, auto inc/dec insns are not supposed to exist,
1510 excepting those that expand_call created. So match memory
1525 if (! ISALPHA (constraint[j]))
1527 error ("invalid punctuation `%c' in constraint",
1531 if (REG_CLASS_FROM_LETTER (constraint[j]) != NO_REGS)
1533 #ifdef EXTRA_CONSTRAINT
1536 /* Otherwise we can't assume anything about the nature of
1537 the constraint except that it isn't purely registers.
1538 Treat it like "g" and hope for the best. */
1546 /* If an output operand is not a decl or indirect ref and our constraint
1547 allows a register, make a temporary to act as an intermediate.
1548 Make the asm insn write into that, then our caller will copy it to
1549 the real output operand. Likewise for promoted variables. */
1551 generating_concat_p = 0;
1553 real_output_rtx[i] = NULL_RTX;
1554 if ((TREE_CODE (val) == INDIRECT_REF
1557 && (allows_mem || GET_CODE (DECL_RTL (val)) == REG)
1558 && ! (GET_CODE (DECL_RTL (val)) == REG
1559 && GET_MODE (DECL_RTL (val)) != TYPE_MODE (type)))
1564 mark_addressable (TREE_VALUE (tail));
1567 = expand_expr (TREE_VALUE (tail), NULL_RTX, VOIDmode,
1568 EXPAND_MEMORY_USE_WO);
1570 if (! allows_reg && GET_CODE (output_rtx[i]) != MEM)
1571 error ("output number %d not directly addressable", i);
1572 if ((! allows_mem && GET_CODE (output_rtx[i]) == MEM)
1573 || GET_CODE (output_rtx[i]) == CONCAT)
1575 real_output_rtx[i] = protect_from_queue (output_rtx[i], 1);
1576 output_rtx[i] = gen_reg_rtx (GET_MODE (output_rtx[i]));
1578 emit_move_insn (output_rtx[i], real_output_rtx[i]);
1583 output_rtx[i] = assign_temp (type, 0, 0, 1);
1584 TREE_VALUE (tail) = make_tree (type, output_rtx[i]);
1587 generating_concat_p = old_generating_concat_p;
1591 inout_mode[ninout] = TYPE_MODE (TREE_TYPE (TREE_VALUE (tail)));
1592 inout_opnum[ninout++] = i;
1597 if (ninputs + noutputs > MAX_RECOG_OPERANDS)
1599 error ("more than %d operands in `asm'", MAX_RECOG_OPERANDS);
1603 /* Make vectors for the expression-rtx and constraint strings. */
1605 argvec = rtvec_alloc (ninputs);
1606 constraints = rtvec_alloc (ninputs);
1608 body = gen_rtx_ASM_OPERANDS ((noutputs == 0 ? VOIDmode
1609 : GET_MODE (output_rtx[0])),
1610 TREE_STRING_POINTER (string),
1611 empty_string, 0, argvec, constraints,
1614 MEM_VOLATILE_P (body) = vol;
1616 /* Eval the inputs and put them into ARGVEC.
1617 Put their constraints into ASM_INPUTs and store in CONSTRAINTS. */
1620 for (tail = inputs; tail; tail = TREE_CHAIN (tail))
1623 int allows_reg = 0, allows_mem = 0;
1624 const char *constraint, *orig_constraint;
1628 /* If there's an erroneous arg, emit no insn,
1629 because the ASM_INPUT would get VOIDmode
1630 and that could cause a crash in reload. */
1631 if (TREE_TYPE (TREE_VALUE (tail)) == error_mark_node)
1634 /* ??? Can this happen, and does the error message make any sense? */
1635 if (TREE_PURPOSE (tail) == NULL_TREE)
1637 error ("hard register `%s' listed as input operand to `asm'",
1638 TREE_STRING_POINTER (TREE_VALUE (tail)) );
1642 constraint = TREE_STRING_POINTER (TREE_PURPOSE (tail));
1643 c_len = strlen (constraint);
1644 orig_constraint = constraint;
1646 /* Make sure constraint has neither `=', `+', nor '&'. */
1648 for (j = 0; j < c_len; j++)
1649 switch (constraint[j])
1651 case '+': case '=': case '&':
1652 if (constraint == orig_constraint)
1654 error ("input operand constraint contains `%c'",
1661 if (constraint == orig_constraint
1662 && i + 1 == ninputs - ninout)
1664 error ("`%%' constraint used with last operand");
1669 case 'V': case 'm': case 'o':
1674 case '?': case '!': case '*': case '#':
1675 case 'E': case 'F': case 'G': case 'H':
1676 case 's': case 'i': case 'n':
1677 case 'I': case 'J': case 'K': case 'L': case 'M':
1678 case 'N': case 'O': case 'P': case ',':
1681 /* Whether or not a numeric constraint allows a register is
1682 decided by the matching constraint, and so there is no need
1683 to do anything special with them. We must handle them in
1684 the default case, so that we don't unnecessarily force
1685 operands to memory. */
1686 case '0': case '1': case '2': case '3': case '4':
1687 case '5': case '6': case '7': case '8': case '9':
1688 if (constraint[j] >= '0' + noutputs)
1691 ("matching constraint references invalid operand number");
1695 /* Try and find the real constraint for this dup. */
1696 if ((j == 0 && c_len == 1)
1697 || (j == 1 && c_len == 2 && constraint[0] == '%'))
1701 for (j = constraint[j] - '0'; j > 0; --j)
1704 constraint = TREE_STRING_POINTER (TREE_PURPOSE (o));
1705 c_len = strlen (constraint);
1722 if (! ISALPHA (constraint[j]))
1724 error ("invalid punctuation `%c' in constraint",
1728 if (REG_CLASS_FROM_LETTER (constraint[j]) != NO_REGS)
1730 #ifdef EXTRA_CONSTRAINT
1733 /* Otherwise we can't assume anything about the nature of
1734 the constraint except that it isn't purely registers.
1735 Treat it like "g" and hope for the best. */
1743 if (! allows_reg && allows_mem)
1744 mark_addressable (TREE_VALUE (tail));
1746 op = expand_expr (TREE_VALUE (tail), NULL_RTX, VOIDmode, 0);
1748 /* Never pass a CONCAT to an ASM. */
1749 generating_concat_p = 0;
1750 if (GET_CODE (op) == CONCAT)
1751 op = force_reg (GET_MODE (op), op);
1753 if (asm_operand_ok (op, constraint) <= 0)
1756 op = force_reg (TYPE_MODE (TREE_TYPE (TREE_VALUE (tail))), op);
1757 else if (!allows_mem)
1758 warning ("asm operand %d probably doesn't match constraints", i);
1759 else if (CONSTANT_P (op))
1760 op = force_const_mem (TYPE_MODE (TREE_TYPE (TREE_VALUE (tail))),
1762 else if (GET_CODE (op) == REG
1763 || GET_CODE (op) == SUBREG
1764 || GET_CODE (op) == ADDRESSOF
1765 || GET_CODE (op) == CONCAT)
1767 tree type = TREE_TYPE (TREE_VALUE (tail));
1768 tree qual_type = build_qualified_type (type,
1770 | TYPE_QUAL_CONST));
1771 rtx memloc = assign_temp (qual_type, 1, 1, 1);
1773 emit_move_insn (memloc, op);
1777 else if (GET_CODE (op) == MEM && MEM_VOLATILE_P (op))
1778 /* We won't recognize volatile memory as available a
1779 memory_operand at this point. Ignore it. */
1781 else if (queued_subexp_p (op))
1784 /* ??? Leave this only until we have experience with what
1785 happens in combine and elsewhere when constraints are
1787 warning ("asm operand %d probably doesn't match constraints", i);
1789 generating_concat_p = old_generating_concat_p;
1790 ASM_OPERANDS_INPUT (body, i) = op;
1792 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body, i)
1793 = gen_rtx_ASM_INPUT (TYPE_MODE (TREE_TYPE (TREE_VALUE (tail))),
1798 /* Protect all the operands from the queue now that they have all been
1801 generating_concat_p = 0;
1803 for (i = 0; i < ninputs - ninout; i++)
1804 ASM_OPERANDS_INPUT (body, i)
1805 = protect_from_queue (ASM_OPERANDS_INPUT (body, i), 0);
1807 for (i = 0; i < noutputs; i++)
1808 output_rtx[i] = protect_from_queue (output_rtx[i], 1);
1810 /* For in-out operands, copy output rtx to input rtx. */
1811 for (i = 0; i < ninout; i++)
1813 int j = inout_opnum[i];
1815 ASM_OPERANDS_INPUT (body, ninputs - ninout + i)
1817 ASM_OPERANDS_INPUT_CONSTRAINT_EXP (body, ninputs - ninout + i)
1818 = gen_rtx_ASM_INPUT (inout_mode[i], digit_string (j));
1821 generating_concat_p = old_generating_concat_p;
1823 /* Now, for each output, construct an rtx
1824 (set OUTPUT (asm_operands INSN OUTPUTNUMBER OUTPUTCONSTRAINT
1825 ARGVEC CONSTRAINTS))
1826 If there is more than one, put them inside a PARALLEL. */
1828 if (noutputs == 1 && nclobbers == 0)
1830 ASM_OPERANDS_OUTPUT_CONSTRAINT (body)
1831 = output_constraints[0];
1832 insn = emit_insn (gen_rtx_SET (VOIDmode, output_rtx[0], body));
1835 else if (noutputs == 0 && nclobbers == 0)
1837 /* No output operands: put in a raw ASM_OPERANDS rtx. */
1838 insn = emit_insn (body);
1849 body = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (num + nclobbers));
1851 /* For each output operand, store a SET. */
1852 for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
1854 XVECEXP (body, 0, i)
1855 = gen_rtx_SET (VOIDmode,
1857 gen_rtx_ASM_OPERANDS
1858 (GET_MODE (output_rtx[i]),
1859 TREE_STRING_POINTER (string),
1860 output_constraints[i],
1861 i, argvec, constraints,
1864 MEM_VOLATILE_P (SET_SRC (XVECEXP (body, 0, i))) = vol;
1867 /* If there are no outputs (but there are some clobbers)
1868 store the bare ASM_OPERANDS into the PARALLEL. */
1871 XVECEXP (body, 0, i++) = obody;
1873 /* Store (clobber REG) for each clobbered register specified. */
1875 for (tail = clobbers; tail; tail = TREE_CHAIN (tail))
1877 const char *regname = TREE_STRING_POINTER (TREE_VALUE (tail));
1878 int j = decode_reg_name (regname);
1882 if (j == -3) /* `cc', which is not a register */
1885 if (j == -4) /* `memory', don't cache memory across asm */
1887 XVECEXP (body, 0, i++)
1888 = gen_rtx_CLOBBER (VOIDmode,
1891 gen_rtx_SCRATCH (VOIDmode)));
1895 /* Ignore unknown register, error already signaled. */
1899 /* Use QImode since that's guaranteed to clobber just one reg. */
1900 XVECEXP (body, 0, i++)
1901 = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (QImode, j));
1904 insn = emit_insn (body);
1907 /* For any outputs that needed reloading into registers, spill them
1908 back to where they belong. */
1909 for (i = 0; i < noutputs; ++i)
1910 if (real_output_rtx[i])
1911 emit_move_insn (real_output_rtx[i], output_rtx[i]);
1916 /* Generate RTL to evaluate the expression EXP
1917 and remember it in case this is the VALUE in a ({... VALUE; }) constr. */
1920 expand_expr_stmt (exp)
1923 /* If -W, warn about statements with no side effects,
1924 except for an explicit cast to void (e.g. for assert()), and
1925 except inside a ({...}) where they may be useful. */
1926 if (expr_stmts_for_value == 0 && exp != error_mark_node)
1928 if (! TREE_SIDE_EFFECTS (exp))
1930 if ((extra_warnings || warn_unused_value)
1931 && !(TREE_CODE (exp) == CONVERT_EXPR
1932 && VOID_TYPE_P (TREE_TYPE (exp))))
1933 warning_with_file_and_line (emit_filename, emit_lineno,
1934 "statement with no effect");
1936 else if (warn_unused_value)
1937 warn_if_unused_value (exp);
1940 /* If EXP is of function type and we are expanding statements for
1941 value, convert it to pointer-to-function. */
1942 if (expr_stmts_for_value && TREE_CODE (TREE_TYPE (exp)) == FUNCTION_TYPE)
1943 exp = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (exp)), exp);
1945 /* The call to `expand_expr' could cause last_expr_type and
1946 last_expr_value to get reset. Therefore, we set last_expr_value
1947 and last_expr_type *after* calling expand_expr. */
1948 last_expr_value = expand_expr (exp,
1949 (expr_stmts_for_value
1950 ? NULL_RTX : const0_rtx),
1952 last_expr_type = TREE_TYPE (exp);
1954 /* If all we do is reference a volatile value in memory,
1955 copy it to a register to be sure it is actually touched. */
1956 if (last_expr_value != 0 && GET_CODE (last_expr_value) == MEM
1957 && TREE_THIS_VOLATILE (exp))
1959 if (TYPE_MODE (TREE_TYPE (exp)) == VOIDmode)
1961 else if (TYPE_MODE (TREE_TYPE (exp)) != BLKmode)
1962 copy_to_reg (last_expr_value);
1965 rtx lab = gen_label_rtx ();
1967 /* Compare the value with itself to reference it. */
1968 emit_cmp_and_jump_insns (last_expr_value, last_expr_value, EQ,
1969 expand_expr (TYPE_SIZE (last_expr_type),
1970 NULL_RTX, VOIDmode, 0),
1972 TYPE_ALIGN (last_expr_type) / BITS_PER_UNIT,
1978 /* If this expression is part of a ({...}) and is in memory, we may have
1979 to preserve temporaries. */
1980 preserve_temp_slots (last_expr_value);
1982 /* Free any temporaries used to evaluate this expression. Any temporary
1983 used as a result of this expression will already have been preserved
1990 /* Warn if EXP contains any computations whose results are not used.
1991 Return 1 if a warning is printed; 0 otherwise. */
1994 warn_if_unused_value (exp)
1997 if (TREE_USED (exp))
2000 /* Don't warn about void constructs. This includes casting to void,
2001 void function calls, and statement expressions with a final cast
2003 if (VOID_TYPE_P (TREE_TYPE (exp)))
2006 /* If this is an expression with side effects, don't warn. */
2007 if (TREE_SIDE_EFFECTS (exp))
2010 switch (TREE_CODE (exp))
2012 case PREINCREMENT_EXPR:
2013 case POSTINCREMENT_EXPR:
2014 case PREDECREMENT_EXPR:
2015 case POSTDECREMENT_EXPR:
2020 case METHOD_CALL_EXPR:
2022 case TRY_CATCH_EXPR:
2023 case WITH_CLEANUP_EXPR:
2028 /* For a binding, warn if no side effect within it. */
2029 return warn_if_unused_value (TREE_OPERAND (exp, 1));
2032 return warn_if_unused_value (TREE_OPERAND (exp, 1));
2034 case TRUTH_ORIF_EXPR:
2035 case TRUTH_ANDIF_EXPR:
2036 /* In && or ||, warn if 2nd operand has no side effect. */
2037 return warn_if_unused_value (TREE_OPERAND (exp, 1));
2040 if (TREE_NO_UNUSED_WARNING (exp))
2042 if (warn_if_unused_value (TREE_OPERAND (exp, 0)))
2044 /* Let people do `(foo (), 0)' without a warning. */
2045 if (TREE_CONSTANT (TREE_OPERAND (exp, 1)))
2047 return warn_if_unused_value (TREE_OPERAND (exp, 1));
2051 case NON_LVALUE_EXPR:
2052 /* Don't warn about conversions not explicit in the user's program. */
2053 if (TREE_NO_UNUSED_WARNING (exp))
2055 /* Assignment to a cast usually results in a cast of a modify.
2056 Don't complain about that. There can be an arbitrary number of
2057 casts before the modify, so we must loop until we find the first
2058 non-cast expression and then test to see if that is a modify. */
2060 tree tem = TREE_OPERAND (exp, 0);
2062 while (TREE_CODE (tem) == CONVERT_EXPR || TREE_CODE (tem) == NOP_EXPR)
2063 tem = TREE_OPERAND (tem, 0);
2065 if (TREE_CODE (tem) == MODIFY_EXPR || TREE_CODE (tem) == INIT_EXPR
2066 || TREE_CODE (tem) == CALL_EXPR)
2072 /* Don't warn about automatic dereferencing of references, since
2073 the user cannot control it. */
2074 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == REFERENCE_TYPE)
2075 return warn_if_unused_value (TREE_OPERAND (exp, 0));
2079 /* Referencing a volatile value is a side effect, so don't warn. */
2081 || TREE_CODE_CLASS (TREE_CODE (exp)) == 'r')
2082 && TREE_THIS_VOLATILE (exp))
2085 /* If this is an expression which has no operands, there is no value
2086 to be unused. There are no such language-independent codes,
2087 but front ends may define such. */
2088 if (TREE_CODE_CLASS (TREE_CODE (exp)) == 'e'
2089 && TREE_CODE_LENGTH (TREE_CODE (exp)) == 0)
2093 warning_with_file_and_line (emit_filename, emit_lineno,
2094 "value computed is not used");
2099 /* Clear out the memory of the last expression evaluated. */
2107 /* Begin a statement which will return a value.
2108 Return the RTL_EXPR for this statement expr.
2109 The caller must save that value and pass it to expand_end_stmt_expr. */
2112 expand_start_stmt_expr ()
2116 /* Make the RTL_EXPR node temporary, not momentary,
2117 so that rtl_expr_chain doesn't become garbage. */
2118 t = make_node (RTL_EXPR);
2119 do_pending_stack_adjust ();
2120 start_sequence_for_rtl_expr (t);
2122 expr_stmts_for_value++;
2126 /* Restore the previous state at the end of a statement that returns a value.
2127 Returns a tree node representing the statement's value and the
2128 insns to compute the value.
2130 The nodes of that expression have been freed by now, so we cannot use them.
2131 But we don't want to do that anyway; the expression has already been
2132 evaluated and now we just want to use the value. So generate a RTL_EXPR
2133 with the proper type and RTL value.
2135 If the last substatement was not an expression,
2136 return something with type `void'. */
2139 expand_end_stmt_expr (t)
2144 if (last_expr_type == 0)
2146 last_expr_type = void_type_node;
2147 last_expr_value = const0_rtx;
2149 else if (last_expr_value == 0)
2150 /* There are some cases where this can happen, such as when the
2151 statement is void type. */
2152 last_expr_value = const0_rtx;
2153 else if (GET_CODE (last_expr_value) != REG && ! CONSTANT_P (last_expr_value))
2154 /* Remove any possible QUEUED. */
2155 last_expr_value = protect_from_queue (last_expr_value, 0);
2159 TREE_TYPE (t) = last_expr_type;
2160 RTL_EXPR_RTL (t) = last_expr_value;
2161 RTL_EXPR_SEQUENCE (t) = get_insns ();
2163 rtl_expr_chain = tree_cons (NULL_TREE, t, rtl_expr_chain);
2167 /* Don't consider deleting this expr or containing exprs at tree level. */
2168 TREE_SIDE_EFFECTS (t) = 1;
2169 /* Propagate volatility of the actual RTL expr. */
2170 TREE_THIS_VOLATILE (t) = volatile_refs_p (last_expr_value);
2173 expr_stmts_for_value--;
2178 /* Generate RTL for the start of an if-then. COND is the expression
2179 whose truth should be tested.
2181 If EXITFLAG is nonzero, this conditional is visible to
2182 `exit_something'. */
2185 expand_start_cond (cond, exitflag)
2189 struct nesting *thiscond = ALLOC_NESTING ();
2191 /* Make an entry on cond_stack for the cond we are entering. */
2193 thiscond->next = cond_stack;
2194 thiscond->all = nesting_stack;
2195 thiscond->depth = ++nesting_depth;
2196 thiscond->data.cond.next_label = gen_label_rtx ();
2197 /* Before we encounter an `else', we don't need a separate exit label
2198 unless there are supposed to be exit statements
2199 to exit this conditional. */
2200 thiscond->exit_label = exitflag ? gen_label_rtx () : 0;
2201 thiscond->data.cond.endif_label = thiscond->exit_label;
2202 cond_stack = thiscond;
2203 nesting_stack = thiscond;
2205 do_jump (cond, thiscond->data.cond.next_label, NULL_RTX);
2208 /* Generate RTL between then-clause and the elseif-clause
2209 of an if-then-elseif-.... */
2212 expand_start_elseif (cond)
2215 if (cond_stack->data.cond.endif_label == 0)
2216 cond_stack->data.cond.endif_label = gen_label_rtx ();
2217 emit_jump (cond_stack->data.cond.endif_label);
2218 emit_label (cond_stack->data.cond.next_label);
2219 cond_stack->data.cond.next_label = gen_label_rtx ();
2220 do_jump (cond, cond_stack->data.cond.next_label, NULL_RTX);
2223 /* Generate RTL between the then-clause and the else-clause
2224 of an if-then-else. */
2227 expand_start_else ()
2229 if (cond_stack->data.cond.endif_label == 0)
2230 cond_stack->data.cond.endif_label = gen_label_rtx ();
2232 emit_jump (cond_stack->data.cond.endif_label);
2233 emit_label (cond_stack->data.cond.next_label);
2234 cond_stack->data.cond.next_label = 0; /* No more _else or _elseif calls. */
2237 /* After calling expand_start_else, turn this "else" into an "else if"
2238 by providing another condition. */
2241 expand_elseif (cond)
2244 cond_stack->data.cond.next_label = gen_label_rtx ();
2245 do_jump (cond, cond_stack->data.cond.next_label, NULL_RTX);
2248 /* Generate RTL for the end of an if-then.
2249 Pop the record for it off of cond_stack. */
2254 struct nesting *thiscond = cond_stack;
2256 do_pending_stack_adjust ();
2257 if (thiscond->data.cond.next_label)
2258 emit_label (thiscond->data.cond.next_label);
2259 if (thiscond->data.cond.endif_label)
2260 emit_label (thiscond->data.cond.endif_label);
2262 POPSTACK (cond_stack);
2266 /* Generate RTL for the start of a loop. EXIT_FLAG is nonzero if this
2267 loop should be exited by `exit_something'. This is a loop for which
2268 `expand_continue' will jump to the top of the loop.
2270 Make an entry on loop_stack to record the labels associated with
2274 expand_start_loop (exit_flag)
2277 register struct nesting *thisloop = ALLOC_NESTING ();
2279 /* Make an entry on loop_stack for the loop we are entering. */
2281 thisloop->next = loop_stack;
2282 thisloop->all = nesting_stack;
2283 thisloop->depth = ++nesting_depth;
2284 thisloop->data.loop.start_label = gen_label_rtx ();
2285 thisloop->data.loop.end_label = gen_label_rtx ();
2286 thisloop->data.loop.alt_end_label = 0;
2287 thisloop->data.loop.continue_label = thisloop->data.loop.start_label;
2288 thisloop->exit_label = exit_flag ? thisloop->data.loop.end_label : 0;
2289 loop_stack = thisloop;
2290 nesting_stack = thisloop;
2292 do_pending_stack_adjust ();
2294 emit_note (NULL, NOTE_INSN_LOOP_BEG);
2295 emit_label (thisloop->data.loop.start_label);
2300 /* Like expand_start_loop but for a loop where the continuation point
2301 (for expand_continue_loop) will be specified explicitly. */
2304 expand_start_loop_continue_elsewhere (exit_flag)
2307 struct nesting *thisloop = expand_start_loop (exit_flag);
2308 loop_stack->data.loop.continue_label = gen_label_rtx ();
2312 /* Begin a null, aka do { } while (0) "loop". But since the contents
2313 of said loop can still contain a break, we must frob the loop nest. */
2316 expand_start_null_loop ()
2318 register struct nesting *thisloop = ALLOC_NESTING ();
2320 /* Make an entry on loop_stack for the loop we are entering. */
2322 thisloop->next = loop_stack;
2323 thisloop->all = nesting_stack;
2324 thisloop->depth = ++nesting_depth;
2325 thisloop->data.loop.start_label = emit_note (NULL, NOTE_INSN_DELETED);
2326 thisloop->data.loop.end_label = gen_label_rtx ();
2327 thisloop->data.loop.alt_end_label = NULL_RTX;
2328 thisloop->data.loop.continue_label = thisloop->data.loop.end_label;
2329 thisloop->exit_label = thisloop->data.loop.end_label;
2330 loop_stack = thisloop;
2331 nesting_stack = thisloop;
2336 /* Specify the continuation point for a loop started with
2337 expand_start_loop_continue_elsewhere.
2338 Use this at the point in the code to which a continue statement
2342 expand_loop_continue_here ()
2344 do_pending_stack_adjust ();
2345 emit_note (NULL, NOTE_INSN_LOOP_CONT);
2346 emit_label (loop_stack->data.loop.continue_label);
2349 /* Finish a loop. Generate a jump back to the top and the loop-exit label.
2350 Pop the block off of loop_stack. */
2355 rtx start_label = loop_stack->data.loop.start_label;
2356 rtx insn = get_last_insn ();
2357 int needs_end_jump = 1;
2359 /* Mark the continue-point at the top of the loop if none elsewhere. */
2360 if (start_label == loop_stack->data.loop.continue_label)
2361 emit_note_before (NOTE_INSN_LOOP_CONT, start_label);
2363 do_pending_stack_adjust ();
2365 /* If optimizing, perhaps reorder the loop.
2366 First, try to use a condjump near the end.
2367 expand_exit_loop_if_false ends loops with unconditional jumps,
2370 if (test) goto label;
2372 goto loop_stack->data.loop.end_label
2376 If we find such a pattern, we can end the loop earlier. */
2379 && GET_CODE (insn) == CODE_LABEL
2380 && LABEL_NAME (insn) == NULL
2381 && GET_CODE (PREV_INSN (insn)) == BARRIER)
2384 rtx jump = PREV_INSN (PREV_INSN (label));
2386 if (GET_CODE (jump) == JUMP_INSN
2387 && GET_CODE (PATTERN (jump)) == SET
2388 && SET_DEST (PATTERN (jump)) == pc_rtx
2389 && GET_CODE (SET_SRC (PATTERN (jump))) == LABEL_REF
2390 && (XEXP (SET_SRC (PATTERN (jump)), 0)
2391 == loop_stack->data.loop.end_label))
2395 /* The test might be complex and reference LABEL multiple times,
2396 like the loop in loop_iterations to set vtop. To handle this,
2398 insn = PREV_INSN (label);
2399 reorder_insns (label, label, start_label);
2401 for (prev = PREV_INSN (jump);; prev = PREV_INSN (prev))
2403 /* We ignore line number notes, but if we see any other note,
2404 in particular NOTE_INSN_BLOCK_*, NOTE_INSN_EH_REGION_*,
2405 NOTE_INSN_LOOP_*, we disable this optimization. */
2406 if (GET_CODE (prev) == NOTE)
2408 if (NOTE_LINE_NUMBER (prev) < 0)
2412 if (GET_CODE (prev) == CODE_LABEL)
2414 if (GET_CODE (prev) == JUMP_INSN)
2416 if (GET_CODE (PATTERN (prev)) == SET
2417 && SET_DEST (PATTERN (prev)) == pc_rtx
2418 && GET_CODE (SET_SRC (PATTERN (prev))) == IF_THEN_ELSE
2419 && (GET_CODE (XEXP (SET_SRC (PATTERN (prev)), 1))
2421 && XEXP (XEXP (SET_SRC (PATTERN (prev)), 1), 0) == label)
2423 XEXP (XEXP (SET_SRC (PATTERN (prev)), 1), 0)
2425 emit_note_after (NOTE_INSN_LOOP_END, prev);
2434 /* If the loop starts with a loop exit, roll that to the end where
2435 it will optimize together with the jump back.
2437 We look for the conditional branch to the exit, except that once
2438 we find such a branch, we don't look past 30 instructions.
2440 In more detail, if the loop presently looks like this (in pseudo-C):
2443 if (test) goto end_label;
2448 transform it to look like:
2454 if (test) goto end_label;
2455 goto newstart_label;
2458 Here, the `test' may actually consist of some reasonably complex
2459 code, terminating in a test. */
2464 ! (GET_CODE (insn) == JUMP_INSN
2465 && GET_CODE (PATTERN (insn)) == SET
2466 && SET_DEST (PATTERN (insn)) == pc_rtx
2467 && GET_CODE (SET_SRC (PATTERN (insn))) == IF_THEN_ELSE))
2471 rtx last_test_insn = NULL_RTX;
2473 /* Scan insns from the top of the loop looking for a qualified
2474 conditional exit. */
2475 for (insn = NEXT_INSN (loop_stack->data.loop.start_label); insn;
2476 insn = NEXT_INSN (insn))
2478 if (GET_CODE (insn) == NOTE)
2481 && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG
2482 || NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END))
2483 /* The code that actually moves the exit test will
2484 carefully leave BLOCK notes in their original
2485 location. That means, however, that we can't debug
2486 the exit test itself. So, we refuse to move code
2487 containing BLOCK notes at low optimization levels. */
2490 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_BEG)
2492 else if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_EH_REGION_END)
2496 /* We've come to the end of an EH region, but
2497 never saw the beginning of that region. That
2498 means that an EH region begins before the top
2499 of the loop, and ends in the middle of it. The
2500 existence of such a situation violates a basic
2501 assumption in this code, since that would imply
2502 that even when EH_REGIONS is zero, we might
2503 move code out of an exception region. */
2507 /* We must not walk into a nested loop. */
2508 if (NOTE_LINE_NUMBER (insn) == NOTE_INSN_LOOP_BEG)
2511 /* We already know this INSN is a NOTE, so there's no
2512 point in looking at it to see if it's a JUMP. */
2516 if (GET_CODE (insn) == JUMP_INSN || GET_CODE (insn) == INSN)
2519 if (last_test_insn && num_insns > 30)
2523 /* We don't want to move a partial EH region. Consider:
2537 This isn't legal C++, but here's what it's supposed to
2538 mean: if cond() is true, stop looping. Otherwise,
2539 call bar, and keep looping. In addition, if cond
2540 throws an exception, catch it and keep looping. Such
2541 constructs are certainy legal in LISP.
2543 We should not move the `if (cond()) 0' test since then
2544 the EH-region for the try-block would be broken up.
2545 (In this case we would the EH_BEG note for the `try'
2546 and `if cond()' but not the call to bar() or the
2549 So we don't look for tests within an EH region. */
2552 if (GET_CODE (insn) == JUMP_INSN
2553 && GET_CODE (PATTERN (insn)) == SET
2554 && SET_DEST (PATTERN (insn)) == pc_rtx)
2556 /* This is indeed a jump. */
2557 rtx dest1 = NULL_RTX;
2558 rtx dest2 = NULL_RTX;
2559 rtx potential_last_test;
2560 if (GET_CODE (SET_SRC (PATTERN (insn))) == IF_THEN_ELSE)
2562 /* A conditional jump. */
2563 dest1 = XEXP (SET_SRC (PATTERN (insn)), 1);
2564 dest2 = XEXP (SET_SRC (PATTERN (insn)), 2);
2565 potential_last_test = insn;
2569 /* An unconditional jump. */
2570 dest1 = SET_SRC (PATTERN (insn));
2571 /* Include the BARRIER after the JUMP. */
2572 potential_last_test = NEXT_INSN (insn);
2576 if (dest1 && GET_CODE (dest1) == LABEL_REF
2577 && ((XEXP (dest1, 0)
2578 == loop_stack->data.loop.alt_end_label)
2580 == loop_stack->data.loop.end_label)))
2582 last_test_insn = potential_last_test;
2586 /* If this was a conditional jump, there may be
2587 another label at which we should look. */
2594 if (last_test_insn != 0 && last_test_insn != get_last_insn ())
2596 /* We found one. Move everything from there up
2597 to the end of the loop, and add a jump into the loop
2598 to jump to there. */
2599 register rtx newstart_label = gen_label_rtx ();
2600 register rtx start_move = start_label;
2603 /* If the start label is preceded by a NOTE_INSN_LOOP_CONT note,
2604 then we want to move this note also. */
2605 if (GET_CODE (PREV_INSN (start_move)) == NOTE
2606 && (NOTE_LINE_NUMBER (PREV_INSN (start_move))
2607 == NOTE_INSN_LOOP_CONT))
2608 start_move = PREV_INSN (start_move);
2610 emit_label_after (newstart_label, PREV_INSN (start_move));
2612 /* Actually move the insns. Start at the beginning, and
2613 keep copying insns until we've copied the
2615 for (insn = start_move; insn; insn = next_insn)
2617 /* Figure out which insn comes after this one. We have
2618 to do this before we move INSN. */
2619 if (insn == last_test_insn)
2620 /* We've moved all the insns. */
2621 next_insn = NULL_RTX;
2623 next_insn = NEXT_INSN (insn);
2625 if (GET_CODE (insn) == NOTE
2626 && (NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_BEG
2627 || NOTE_LINE_NUMBER (insn) == NOTE_INSN_BLOCK_END))
2628 /* We don't want to move NOTE_INSN_BLOCK_BEGs or
2629 NOTE_INSN_BLOCK_ENDs because the correct generation
2630 of debugging information depends on these appearing
2631 in the same order in the RTL and in the tree
2632 structure, where they are represented as BLOCKs.
2633 So, we don't move block notes. Of course, moving
2634 the code inside the block is likely to make it
2635 impossible to debug the instructions in the exit
2636 test, but such is the price of optimization. */
2639 /* Move the INSN. */
2640 reorder_insns (insn, insn, get_last_insn ());
2643 emit_jump_insn_after (gen_jump (start_label),
2644 PREV_INSN (newstart_label));
2645 emit_barrier_after (PREV_INSN (newstart_label));
2646 start_label = newstart_label;
2652 emit_jump (start_label);
2653 emit_note (NULL, NOTE_INSN_LOOP_END);
2655 emit_label (loop_stack->data.loop.end_label);
2657 POPSTACK (loop_stack);
2662 /* Finish a null loop, aka do { } while (0). */
2665 expand_end_null_loop ()
2667 do_pending_stack_adjust ();
2668 emit_label (loop_stack->data.loop.end_label);
2670 POPSTACK (loop_stack);
2675 /* Generate a jump to the current loop's continue-point.
2676 This is usually the top of the loop, but may be specified
2677 explicitly elsewhere. If not currently inside a loop,
2678 return 0 and do nothing; caller will print an error message. */
2681 expand_continue_loop (whichloop)
2682 struct nesting *whichloop;
2686 whichloop = loop_stack;
2689 expand_goto_internal (NULL_TREE, whichloop->data.loop.continue_label,
2694 /* Generate a jump to exit the current loop. If not currently inside a loop,
2695 return 0 and do nothing; caller will print an error message. */
2698 expand_exit_loop (whichloop)
2699 struct nesting *whichloop;
2703 whichloop = loop_stack;
2706 expand_goto_internal (NULL_TREE, whichloop->data.loop.end_label, NULL_RTX);
2710 /* Generate a conditional jump to exit the current loop if COND
2711 evaluates to zero. If not currently inside a loop,
2712 return 0 and do nothing; caller will print an error message. */
2715 expand_exit_loop_if_false (whichloop, cond)
2716 struct nesting *whichloop;
2719 rtx label = gen_label_rtx ();
2724 whichloop = loop_stack;
2727 /* In order to handle fixups, we actually create a conditional jump
2728 around a unconditional branch to exit the loop. If fixups are
2729 necessary, they go before the unconditional branch. */
2731 do_jump (cond, NULL_RTX, label);
2732 last_insn = get_last_insn ();
2733 if (GET_CODE (last_insn) == CODE_LABEL)
2734 whichloop->data.loop.alt_end_label = last_insn;
2735 expand_goto_internal (NULL_TREE, whichloop->data.loop.end_label,
2742 /* Return nonzero if the loop nest is empty. Else return zero. */
2745 stmt_loop_nest_empty ()
2747 /* cfun->stmt can be NULL if we are building a call to get the
2748 EH context for a setjmp/longjmp EH target and the current
2749 function was a deferred inline function. */
2750 return (cfun->stmt == NULL || loop_stack == NULL);
2753 /* Return non-zero if we should preserve sub-expressions as separate
2754 pseudos. We never do so if we aren't optimizing. We always do so
2755 if -fexpensive-optimizations.
2757 Otherwise, we only do so if we are in the "early" part of a loop. I.e.,
2758 the loop may still be a small one. */
2761 preserve_subexpressions_p ()
2765 if (flag_expensive_optimizations)
2768 if (optimize == 0 || cfun == 0 || cfun->stmt == 0 || loop_stack == 0)
2771 insn = get_last_insn_anywhere ();
2774 && (INSN_UID (insn) - INSN_UID (loop_stack->data.loop.start_label)
2775 < n_non_fixed_regs * 3));
2779 /* Generate a jump to exit the current loop, conditional, binding contour
2780 or case statement. Not all such constructs are visible to this function,
2781 only those started with EXIT_FLAG nonzero. Individual languages use
2782 the EXIT_FLAG parameter to control which kinds of constructs you can
2785 If not currently inside anything that can be exited,
2786 return 0 and do nothing; caller will print an error message. */
2789 expand_exit_something ()
2793 for (n = nesting_stack; n; n = n->all)
2794 if (n->exit_label != 0)
2796 expand_goto_internal (NULL_TREE, n->exit_label, NULL_RTX);
2803 /* Generate RTL to return from the current function, with no value.
2804 (That is, we do not do anything about returning any value.) */
2807 expand_null_return ()
2809 struct nesting *block = block_stack;
2810 rtx last_insn = get_last_insn ();
2812 /* If this function was declared to return a value, but we
2813 didn't, clobber the return registers so that they are not
2814 propogated live to the rest of the function. */
2815 clobber_return_register ();
2817 /* Does any pending block have cleanups? */
2818 while (block && block->data.block.cleanups == 0)
2819 block = block->next;
2821 /* If yes, use a goto to return, since that runs cleanups. */
2823 expand_null_return_1 (last_insn, block != 0);
2826 /* Generate RTL to return from the current function, with value VAL. */
2829 expand_value_return (val)
2832 struct nesting *block = block_stack;
2833 rtx last_insn = get_last_insn ();
2834 rtx return_reg = DECL_RTL (DECL_RESULT (current_function_decl));
2836 /* Copy the value to the return location
2837 unless it's already there. */
2839 if (return_reg != val)
2841 tree type = TREE_TYPE (DECL_RESULT (current_function_decl));
2842 #ifdef PROMOTE_FUNCTION_RETURN
2843 int unsignedp = TREE_UNSIGNED (type);
2844 enum machine_mode old_mode
2845 = DECL_MODE (DECL_RESULT (current_function_decl));
2846 enum machine_mode mode
2847 = promote_mode (type, old_mode, &unsignedp, 1);
2849 if (mode != old_mode)
2850 val = convert_modes (mode, old_mode, val, unsignedp);
2852 if (GET_CODE (return_reg) == PARALLEL)
2853 emit_group_load (return_reg, val, int_size_in_bytes (type),
2856 emit_move_insn (return_reg, val);
2859 /* Does any pending block have cleanups? */
2861 while (block && block->data.block.cleanups == 0)
2862 block = block->next;
2864 /* If yes, use a goto to return, since that runs cleanups.
2865 Use LAST_INSN to put cleanups *before* the move insn emitted above. */
2867 expand_null_return_1 (last_insn, block != 0);
2870 /* Output a return with no value. If LAST_INSN is nonzero,
2871 pretend that the return takes place after LAST_INSN.
2872 If USE_GOTO is nonzero then don't use a return instruction;
2873 go to the return label instead. This causes any cleanups
2874 of pending blocks to be executed normally. */
2877 expand_null_return_1 (last_insn, use_goto)
2881 rtx end_label = cleanup_label ? cleanup_label : return_label;
2883 clear_pending_stack_adjust ();
2884 do_pending_stack_adjust ();
2887 /* PCC-struct return always uses an epilogue. */
2888 if (current_function_returns_pcc_struct || use_goto)
2891 end_label = return_label = gen_label_rtx ();
2892 expand_goto_internal (NULL_TREE, end_label, last_insn);
2896 /* Otherwise output a simple return-insn if one is available,
2897 unless it won't do the job. */
2899 if (HAVE_return && use_goto == 0 && cleanup_label == 0)
2901 emit_jump_insn (gen_return ());
2907 /* Otherwise jump to the epilogue. */
2908 expand_goto_internal (NULL_TREE, end_label, last_insn);
2911 /* Generate RTL to evaluate the expression RETVAL and return it
2912 from the current function. */
2915 expand_return (retval)
2918 /* If there are any cleanups to be performed, then they will
2919 be inserted following LAST_INSN. It is desirable
2920 that the last_insn, for such purposes, should be the
2921 last insn before computing the return value. Otherwise, cleanups
2922 which call functions can clobber the return value. */
2923 /* ??? rms: I think that is erroneous, because in C++ it would
2924 run destructors on variables that might be used in the subsequent
2925 computation of the return value. */
2928 register rtx val = 0;
2931 /* If function wants no value, give it none. */
2932 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl))) == VOID_TYPE)
2934 expand_expr (retval, NULL_RTX, VOIDmode, 0);
2936 expand_null_return ();
2940 if (retval == error_mark_node)
2942 /* Treat this like a return of no value from a function that
2944 expand_null_return ();
2947 else if (TREE_CODE (retval) == RESULT_DECL)
2948 retval_rhs = retval;
2949 else if ((TREE_CODE (retval) == MODIFY_EXPR || TREE_CODE (retval) == INIT_EXPR)
2950 && TREE_CODE (TREE_OPERAND (retval, 0)) == RESULT_DECL)
2951 retval_rhs = TREE_OPERAND (retval, 1);
2952 else if (VOID_TYPE_P (TREE_TYPE (retval)))
2953 /* Recognize tail-recursive call to void function. */
2954 retval_rhs = retval;
2956 retval_rhs = NULL_TREE;
2958 last_insn = get_last_insn ();
2960 /* Distribute return down conditional expr if either of the sides
2961 may involve tail recursion (see test below). This enhances the number
2962 of tail recursions we see. Don't do this always since it can produce
2963 sub-optimal code in some cases and we distribute assignments into
2964 conditional expressions when it would help. */
2966 if (optimize && retval_rhs != 0
2967 && frame_offset == 0
2968 && TREE_CODE (retval_rhs) == COND_EXPR
2969 && (TREE_CODE (TREE_OPERAND (retval_rhs, 1)) == CALL_EXPR
2970 || TREE_CODE (TREE_OPERAND (retval_rhs, 2)) == CALL_EXPR))
2972 rtx label = gen_label_rtx ();
2975 do_jump (TREE_OPERAND (retval_rhs, 0), label, NULL_RTX);
2976 start_cleanup_deferral ();
2977 expr = build (MODIFY_EXPR, TREE_TYPE (TREE_TYPE (current_function_decl)),
2978 DECL_RESULT (current_function_decl),
2979 TREE_OPERAND (retval_rhs, 1));
2980 TREE_SIDE_EFFECTS (expr) = 1;
2981 expand_return (expr);
2984 expr = build (MODIFY_EXPR, TREE_TYPE (TREE_TYPE (current_function_decl)),
2985 DECL_RESULT (current_function_decl),
2986 TREE_OPERAND (retval_rhs, 2));
2987 TREE_SIDE_EFFECTS (expr) = 1;
2988 expand_return (expr);
2989 end_cleanup_deferral ();
2993 result_rtl = DECL_RTL (DECL_RESULT (current_function_decl));
2995 /* If the result is an aggregate that is being returned in one (or more)
2996 registers, load the registers here. The compiler currently can't handle
2997 copying a BLKmode value into registers. We could put this code in a
2998 more general area (for use by everyone instead of just function
2999 call/return), but until this feature is generally usable it is kept here
3000 (and in expand_call). The value must go into a pseudo in case there
3001 are cleanups that will clobber the real return register. */
3004 && TYPE_MODE (TREE_TYPE (retval_rhs)) == BLKmode
3005 && GET_CODE (result_rtl) == REG)
3008 unsigned HOST_WIDE_INT bitpos, xbitpos;
3009 unsigned HOST_WIDE_INT big_endian_correction = 0;
3010 unsigned HOST_WIDE_INT bytes
3011 = int_size_in_bytes (TREE_TYPE (retval_rhs));
3012 int n_regs = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
3013 unsigned int bitsize
3014 = MIN (TYPE_ALIGN (TREE_TYPE (retval_rhs)), BITS_PER_WORD);
3015 rtx *result_pseudos = (rtx *) alloca (sizeof (rtx) * n_regs);
3016 rtx result_reg, src = NULL_RTX, dst = NULL_RTX;
3017 rtx result_val = expand_expr (retval_rhs, NULL_RTX, VOIDmode, 0);
3018 enum machine_mode tmpmode, result_reg_mode;
3022 expand_null_return ();
3026 /* Structures whose size is not a multiple of a word are aligned
3027 to the least significant byte (to the right). On a BYTES_BIG_ENDIAN
3028 machine, this means we must skip the empty high order bytes when
3029 calculating the bit offset. */
3030 if (BYTES_BIG_ENDIAN && bytes % UNITS_PER_WORD)
3031 big_endian_correction = (BITS_PER_WORD - ((bytes % UNITS_PER_WORD)
3034 /* Copy the structure BITSIZE bits at a time. */
3035 for (bitpos = 0, xbitpos = big_endian_correction;
3036 bitpos < bytes * BITS_PER_UNIT;
3037 bitpos += bitsize, xbitpos += bitsize)
3039 /* We need a new destination pseudo each time xbitpos is
3040 on a word boundary and when xbitpos == big_endian_correction
3041 (the first time through). */
3042 if (xbitpos % BITS_PER_WORD == 0
3043 || xbitpos == big_endian_correction)
3045 /* Generate an appropriate register. */
3046 dst = gen_reg_rtx (word_mode);
3047 result_pseudos[xbitpos / BITS_PER_WORD] = dst;
3049 /* Clobber the destination before we move anything into it. */
3050 emit_insn (gen_rtx_CLOBBER (VOIDmode, dst));
3053 /* We need a new source operand each time bitpos is on a word
3055 if (bitpos % BITS_PER_WORD == 0)
3056 src = operand_subword_force (result_val,
3057 bitpos / BITS_PER_WORD,
3060 /* Use bitpos for the source extraction (left justified) and
3061 xbitpos for the destination store (right justified). */
3062 store_bit_field (dst, bitsize, xbitpos % BITS_PER_WORD, word_mode,
3063 extract_bit_field (src, bitsize,
3064 bitpos % BITS_PER_WORD, 1,
3065 NULL_RTX, word_mode, word_mode,
3066 bitsize, BITS_PER_WORD),
3067 bitsize, BITS_PER_WORD);
3070 /* Find the smallest integer mode large enough to hold the
3071 entire structure and use that mode instead of BLKmode
3072 on the USE insn for the return register. */
3073 for (tmpmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
3074 tmpmode != VOIDmode;
3075 tmpmode = GET_MODE_WIDER_MODE (tmpmode))
3076 /* Have we found a large enough mode? */
3077 if (GET_MODE_SIZE (tmpmode) >= bytes)
3080 /* No suitable mode found. */
3081 if (tmpmode == VOIDmode)
3084 PUT_MODE (result_rtl, tmpmode);
3086 if (GET_MODE_SIZE (tmpmode) < GET_MODE_SIZE (word_mode))
3087 result_reg_mode = word_mode;
3089 result_reg_mode = tmpmode;
3090 result_reg = gen_reg_rtx (result_reg_mode);
3093 for (i = 0; i < n_regs; i++)
3094 emit_move_insn (operand_subword (result_reg, i, 0, result_reg_mode),
3097 if (tmpmode != result_reg_mode)
3098 result_reg = gen_lowpart (tmpmode, result_reg);
3100 expand_value_return (result_reg);
3102 else if (retval_rhs != 0
3103 && !VOID_TYPE_P (TREE_TYPE (retval_rhs))
3104 && (GET_CODE (result_rtl) == REG
3105 || (GET_CODE (result_rtl) == PARALLEL)))
3107 /* Calculate the return value into a temporary (usually a pseudo
3109 tree ot = TREE_TYPE (DECL_RESULT (current_function_decl));
3110 tree nt = build_qualified_type (ot, TYPE_QUALS (ot) | TYPE_QUAL_CONST);
3112 val = assign_temp (nt, 0, 0, 1);
3113 val = expand_expr (retval_rhs, val, GET_MODE (val), 0);
3114 val = force_not_mem (val);
3116 /* Return the calculated value, doing cleanups first. */
3117 expand_value_return (val);
3121 /* No cleanups or no hard reg used;
3122 calculate value into hard return reg. */
3123 expand_expr (retval, const0_rtx, VOIDmode, 0);
3125 expand_value_return (result_rtl);
3129 /* Return 1 if the end of the generated RTX is not a barrier.
3130 This means code already compiled can drop through. */
3133 drop_through_at_end_p ()
3135 rtx insn = get_last_insn ();
3136 while (insn && GET_CODE (insn) == NOTE)
3137 insn = PREV_INSN (insn);
3138 return insn && GET_CODE (insn) != BARRIER;
3141 /* Attempt to optimize a potential tail recursion call into a goto.
3142 ARGUMENTS are the arguments to a CALL_EXPR; LAST_INSN indicates
3143 where to place the jump to the tail recursion label.
3145 Return TRUE if the call was optimized into a goto. */
3148 optimize_tail_recursion (arguments, last_insn)
3152 /* Finish checking validity, and if valid emit code to set the
3153 argument variables for the new call. */
3154 if (tail_recursion_args (arguments, DECL_ARGUMENTS (current_function_decl)))
3156 if (tail_recursion_label == 0)
3158 tail_recursion_label = gen_label_rtx ();
3159 emit_label_after (tail_recursion_label,
3160 tail_recursion_reentry);
3163 expand_goto_internal (NULL_TREE, tail_recursion_label, last_insn);
3170 /* Emit code to alter this function's formal parms for a tail-recursive call.
3171 ACTUALS is a list of actual parameter expressions (chain of TREE_LISTs).
3172 FORMALS is the chain of decls of formals.
3173 Return 1 if this can be done;
3174 otherwise return 0 and do not emit any code. */
3177 tail_recursion_args (actuals, formals)
3178 tree actuals, formals;
3180 register tree a = actuals, f = formals;
3182 register rtx *argvec;
3184 /* Check that number and types of actuals are compatible
3185 with the formals. This is not always true in valid C code.
3186 Also check that no formal needs to be addressable
3187 and that all formals are scalars. */
3189 /* Also count the args. */
3191 for (a = actuals, f = formals, i = 0; a && f; a = TREE_CHAIN (a), f = TREE_CHAIN (f), i++)
3193 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (a)))
3194 != TYPE_MAIN_VARIANT (TREE_TYPE (f)))
3196 if (GET_CODE (DECL_RTL (f)) != REG || DECL_MODE (f) == BLKmode)
3199 if (a != 0 || f != 0)
3202 /* Compute all the actuals. */
3204 argvec = (rtx *) alloca (i * sizeof (rtx));
3206 for (a = actuals, i = 0; a; a = TREE_CHAIN (a), i++)
3207 argvec[i] = expand_expr (TREE_VALUE (a), NULL_RTX, VOIDmode, 0);
3209 /* Find which actual values refer to current values of previous formals.
3210 Copy each of them now, before any formal is changed. */
3212 for (a = actuals, i = 0; a; a = TREE_CHAIN (a), i++)
3216 for (f = formals, j = 0; j < i; f = TREE_CHAIN (f), j++)
3217 if (reg_mentioned_p (DECL_RTL (f), argvec[i]))
3223 argvec[i] = copy_to_reg (argvec[i]);
3226 /* Store the values of the actuals into the formals. */
3228 for (f = formals, a = actuals, i = 0; f;
3229 f = TREE_CHAIN (f), a = TREE_CHAIN (a), i++)
3231 if (GET_MODE (DECL_RTL (f)) == GET_MODE (argvec[i]))
3232 emit_move_insn (DECL_RTL (f), argvec[i]);
3234 convert_move (DECL_RTL (f), argvec[i],
3235 TREE_UNSIGNED (TREE_TYPE (TREE_VALUE (a))));
3242 /* Generate the RTL code for entering a binding contour.
3243 The variables are declared one by one, by calls to `expand_decl'.
3245 FLAGS is a bitwise or of the following flags:
3247 1 - Nonzero if this construct should be visible to
3250 2 - Nonzero if this contour does not require a
3251 NOTE_INSN_BLOCK_BEG note. Virtually all calls from
3252 language-independent code should set this flag because they
3253 will not create corresponding BLOCK nodes. (There should be
3254 a one-to-one correspondence between NOTE_INSN_BLOCK_BEG notes
3255 and BLOCKs.) If this flag is set, MARK_ENDS should be zero
3256 when expand_end_bindings is called.
3258 If we are creating a NOTE_INSN_BLOCK_BEG note, a BLOCK may
3259 optionally be supplied. If so, it becomes the NOTE_BLOCK for the
3263 expand_start_bindings_and_block (flags, block)
3267 struct nesting *thisblock = ALLOC_NESTING ();
3269 int exit_flag = ((flags & 1) != 0);
3270 int block_flag = ((flags & 2) == 0);
3272 /* If a BLOCK is supplied, then the caller should be requesting a
3273 NOTE_INSN_BLOCK_BEG note. */
3274 if (!block_flag && block)
3277 /* Create a note to mark the beginning of the block. */
3280 note = emit_note (NULL, NOTE_INSN_BLOCK_BEG);
3281 NOTE_BLOCK (note) = block;
3284 note = emit_note (NULL, NOTE_INSN_DELETED);
3286 /* Make an entry on block_stack for the block we are entering. */
3288 thisblock->next = block_stack;
3289 thisblock->all = nesting_stack;
3290 thisblock->depth = ++nesting_depth;
3291 thisblock->data.block.stack_level = 0;
3292 thisblock->data.block.cleanups = 0;
3293 thisblock->data.block.n_function_calls = 0;
3294 thisblock->data.block.exception_region = 0;
3295 thisblock->data.block.block_target_temp_slot_level = target_temp_slot_level;
3297 thisblock->data.block.conditional_code = 0;
3298 thisblock->data.block.last_unconditional_cleanup = note;
3299 /* When we insert instructions after the last unconditional cleanup,
3300 we don't adjust last_insn. That means that a later add_insn will
3301 clobber the instructions we've just added. The easiest way to
3302 fix this is to just insert another instruction here, so that the
3303 instructions inserted after the last unconditional cleanup are
3304 never the last instruction. */
3305 emit_note (NULL, NOTE_INSN_DELETED);
3306 thisblock->data.block.cleanup_ptr = &thisblock->data.block.cleanups;
3309 && !(block_stack->data.block.cleanups == NULL_TREE
3310 && block_stack->data.block.outer_cleanups == NULL_TREE))
3311 thisblock->data.block.outer_cleanups
3312 = tree_cons (NULL_TREE, block_stack->data.block.cleanups,
3313 block_stack->data.block.outer_cleanups);
3315 thisblock->data.block.outer_cleanups = 0;
3316 thisblock->data.block.label_chain = 0;
3317 thisblock->data.block.innermost_stack_block = stack_block_stack;
3318 thisblock->data.block.first_insn = note;
3319 thisblock->data.block.block_start_count = ++current_block_start_count;
3320 thisblock->exit_label = exit_flag ? gen_label_rtx () : 0;
3321 block_stack = thisblock;
3322 nesting_stack = thisblock;
3324 /* Make a new level for allocating stack slots. */
3328 /* Specify the scope of temporaries created by TARGET_EXPRs. Similar
3329 to CLEANUP_POINT_EXPR, but handles cases when a series of calls to
3330 expand_expr are made. After we end the region, we know that all
3331 space for all temporaries that were created by TARGET_EXPRs will be
3332 destroyed and their space freed for reuse. */
3335 expand_start_target_temps ()
3337 /* This is so that even if the result is preserved, the space
3338 allocated will be freed, as we know that it is no longer in use. */
3341 /* Start a new binding layer that will keep track of all cleanup
3342 actions to be performed. */
3343 expand_start_bindings (2);
3345 target_temp_slot_level = temp_slot_level;
3349 expand_end_target_temps ()
3351 expand_end_bindings (NULL_TREE, 0, 0);
3353 /* This is so that even if the result is preserved, the space
3354 allocated will be freed, as we know that it is no longer in use. */
3358 /* Given a pointer to a BLOCK node return non-zero if (and only if) the node
3359 in question represents the outermost pair of curly braces (i.e. the "body
3360 block") of a function or method.
3362 For any BLOCK node representing a "body block" of a function or method, the
3363 BLOCK_SUPERCONTEXT of the node will point to another BLOCK node which
3364 represents the outermost (function) scope for the function or method (i.e.
3365 the one which includes the formal parameters). The BLOCK_SUPERCONTEXT of
3366 *that* node in turn will point to the relevant FUNCTION_DECL node. */
3369 is_body_block (stmt)
3372 if (TREE_CODE (stmt) == BLOCK)
3374 tree parent = BLOCK_SUPERCONTEXT (stmt);
3376 if (parent && TREE_CODE (parent) == BLOCK)
3378 tree grandparent = BLOCK_SUPERCONTEXT (parent);
3380 if (grandparent && TREE_CODE (grandparent) == FUNCTION_DECL)
3388 /* True if we are currently emitting insns in an area of output code
3389 that is controlled by a conditional expression. This is used by
3390 the cleanup handling code to generate conditional cleanup actions. */
3393 conditional_context ()
3395 return block_stack && block_stack->data.block.conditional_code;
3398 /* Emit a handler label for a nonlocal goto handler.
3399 Also emit code to store the handler label in SLOT before BEFORE_INSN. */
3402 expand_nl_handler_label (slot, before_insn)
3403 rtx slot, before_insn;
3406 rtx handler_label = gen_label_rtx ();
3408 /* Don't let jump_optimize delete the handler. */
3409 LABEL_PRESERVE_P (handler_label) = 1;
3412 emit_move_insn (slot, gen_rtx_LABEL_REF (Pmode, handler_label));
3413 insns = get_insns ();
3415 emit_insns_before (insns, before_insn);
3417 emit_label (handler_label);
3419 return handler_label;
3422 /* Emit code to restore vital registers at the beginning of a nonlocal goto
3425 expand_nl_goto_receiver ()
3427 #ifdef HAVE_nonlocal_goto
3428 if (! HAVE_nonlocal_goto)
3430 /* First adjust our frame pointer to its actual value. It was
3431 previously set to the start of the virtual area corresponding to
3432 the stacked variables when we branched here and now needs to be
3433 adjusted to the actual hardware fp value.
3435 Assignments are to virtual registers are converted by
3436 instantiate_virtual_regs into the corresponding assignment
3437 to the underlying register (fp in this case) that makes
3438 the original assignment true.
3439 So the following insn will actually be
3440 decrementing fp by STARTING_FRAME_OFFSET. */
3441 emit_move_insn (virtual_stack_vars_rtx, hard_frame_pointer_rtx);
3443 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
3444 if (fixed_regs[ARG_POINTER_REGNUM])
3446 #ifdef ELIMINABLE_REGS
3447 /* If the argument pointer can be eliminated in favor of the
3448 frame pointer, we don't need to restore it. We assume here
3449 that if such an elimination is present, it can always be used.
3450 This is the case on all known machines; if we don't make this
3451 assumption, we do unnecessary saving on many machines. */
3452 static struct elims {int from, to;} elim_regs[] = ELIMINABLE_REGS;
3455 for (i = 0; i < ARRAY_SIZE (elim_regs); i++)
3456 if (elim_regs[i].from == ARG_POINTER_REGNUM
3457 && elim_regs[i].to == HARD_FRAME_POINTER_REGNUM)
3460 if (i == ARRAY_SIZE (elim_regs))
3463 /* Now restore our arg pointer from the address at which it
3464 was saved in our stack frame.
3465 If there hasn't be space allocated for it yet, make
3467 if (arg_pointer_save_area == 0)
3468 arg_pointer_save_area
3469 = assign_stack_local (Pmode, GET_MODE_SIZE (Pmode), 0);
3470 emit_move_insn (virtual_incoming_args_rtx,
3471 /* We need a pseudo here, or else
3472 instantiate_virtual_regs_1 complains. */
3473 copy_to_reg (arg_pointer_save_area));
3478 #ifdef HAVE_nonlocal_goto_receiver
3479 if (HAVE_nonlocal_goto_receiver)
3480 emit_insn (gen_nonlocal_goto_receiver ());
3484 /* Make handlers for nonlocal gotos taking place in the function calls in
3488 expand_nl_goto_receivers (thisblock)
3489 struct nesting *thisblock;
3492 rtx afterward = gen_label_rtx ();
3497 /* Record the handler address in the stack slot for that purpose,
3498 during this block, saving and restoring the outer value. */
3499 if (thisblock->next != 0)
3500 for (slot = nonlocal_goto_handler_slots; slot; slot = XEXP (slot, 1))
3502 rtx save_receiver = gen_reg_rtx (Pmode);
3503 emit_move_insn (XEXP (slot, 0), save_receiver);
3506 emit_move_insn (save_receiver, XEXP (slot, 0));
3507 insns = get_insns ();
3509 emit_insns_before (insns, thisblock->data.block.first_insn);
3512 /* Jump around the handlers; they run only when specially invoked. */
3513 emit_jump (afterward);
3515 /* Make a separate handler for each label. */
3516 link = nonlocal_labels;
3517 slot = nonlocal_goto_handler_slots;
3518 label_list = NULL_RTX;
3519 for (; link; link = TREE_CHAIN (link), slot = XEXP (slot, 1))
3520 /* Skip any labels we shouldn't be able to jump to from here,
3521 we generate one special handler for all of them below which just calls
3523 if (! DECL_TOO_LATE (TREE_VALUE (link)))
3526 lab = expand_nl_handler_label (XEXP (slot, 0),
3527 thisblock->data.block.first_insn);
3528 label_list = gen_rtx_EXPR_LIST (VOIDmode, lab, label_list);
3530 expand_nl_goto_receiver ();
3532 /* Jump to the "real" nonlocal label. */
3533 expand_goto (TREE_VALUE (link));
3536 /* A second pass over all nonlocal labels; this time we handle those
3537 we should not be able to jump to at this point. */
3538 link = nonlocal_labels;
3539 slot = nonlocal_goto_handler_slots;
3541 for (; link; link = TREE_CHAIN (link), slot = XEXP (slot, 1))
3542 if (DECL_TOO_LATE (TREE_VALUE (link)))
3545 lab = expand_nl_handler_label (XEXP (slot, 0),
3546 thisblock->data.block.first_insn);
3547 label_list = gen_rtx_EXPR_LIST (VOIDmode, lab, label_list);
3553 expand_nl_goto_receiver ();
3554 emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "abort"), 0,
3559 nonlocal_goto_handler_labels = label_list;
3560 emit_label (afterward);
3563 /* Warn about any unused VARS (which may contain nodes other than
3564 VAR_DECLs, but such nodes are ignored). The nodes are connected
3565 via the TREE_CHAIN field. */
3568 warn_about_unused_variables (vars)
3573 if (warn_unused_variable)
3574 for (decl = vars; decl; decl = TREE_CHAIN (decl))
3575 if (TREE_CODE (decl) == VAR_DECL
3576 && ! TREE_USED (decl)
3577 && ! DECL_IN_SYSTEM_HEADER (decl)
3578 && DECL_NAME (decl) && ! DECL_ARTIFICIAL (decl))
3579 warning_with_decl (decl, "unused variable `%s'");
3582 /* Generate RTL code to terminate a binding contour.
3584 VARS is the chain of VAR_DECL nodes for the variables bound in this
3585 contour. There may actually be other nodes in this chain, but any
3586 nodes other than VAR_DECLS are ignored.
3588 MARK_ENDS is nonzero if we should put a note at the beginning
3589 and end of this binding contour.
3591 DONT_JUMP_IN is nonzero if it is not valid to jump into this contour.
3592 (That is true automatically if the contour has a saved stack level.) */
3595 expand_end_bindings (vars, mark_ends, dont_jump_in)
3600 register struct nesting *thisblock = block_stack;
3602 /* If any of the variables in this scope were not used, warn the
3604 warn_about_unused_variables (vars);
3606 if (thisblock->exit_label)
3608 do_pending_stack_adjust ();
3609 emit_label (thisblock->exit_label);
3612 /* If necessary, make handlers for nonlocal gotos taking
3613 place in the function calls in this block. */
3614 if (function_call_count != thisblock->data.block.n_function_calls
3616 /* Make handler for outermost block
3617 if there were any nonlocal gotos to this function. */
3618 && (thisblock->next == 0 ? current_function_has_nonlocal_label
3619 /* Make handler for inner block if it has something
3620 special to do when you jump out of it. */
3621 : (thisblock->data.block.cleanups != 0
3622 || thisblock->data.block.stack_level != 0)))
3623 expand_nl_goto_receivers (thisblock);
3625 /* Don't allow jumping into a block that has a stack level.
3626 Cleanups are allowed, though. */
3628 || thisblock->data.block.stack_level != 0)
3630 struct label_chain *chain;
3632 /* Any labels in this block are no longer valid to go to.
3633 Mark them to cause an error message. */
3634 for (chain = thisblock->data.block.label_chain; chain; chain = chain->next)
3636 DECL_TOO_LATE (chain->label) = 1;
3637 /* If any goto without a fixup came to this label,
3638 that must be an error, because gotos without fixups
3639 come from outside all saved stack-levels. */
3640 if (TREE_ADDRESSABLE (chain->label))
3641 error_with_decl (chain->label,
3642 "label `%s' used before containing binding contour");
3646 /* Restore stack level in effect before the block
3647 (only if variable-size objects allocated). */
3648 /* Perform any cleanups associated with the block. */
3650 if (thisblock->data.block.stack_level != 0
3651 || thisblock->data.block.cleanups != 0)
3656 /* Don't let cleanups affect ({...}) constructs. */
3657 int old_expr_stmts_for_value = expr_stmts_for_value;
3658 rtx old_last_expr_value = last_expr_value;
3659 tree old_last_expr_type = last_expr_type;
3660 expr_stmts_for_value = 0;
3662 /* Only clean up here if this point can actually be reached. */
3663 insn = get_last_insn ();
3664 if (GET_CODE (insn) == NOTE)
3665 insn = prev_nonnote_insn (insn);
3666 reachable = (! insn || GET_CODE (insn) != BARRIER);
3668 /* Do the cleanups. */
3669 expand_cleanups (thisblock->data.block.cleanups, NULL_TREE, 0, reachable);
3671 do_pending_stack_adjust ();
3673 expr_stmts_for_value = old_expr_stmts_for_value;
3674 last_expr_value = old_last_expr_value;
3675 last_expr_type = old_last_expr_type;
3677 /* Restore the stack level. */
3679 if (reachable && thisblock->data.block.stack_level != 0)
3681 emit_stack_restore (thisblock->next ? SAVE_BLOCK : SAVE_FUNCTION,
3682 thisblock->data.block.stack_level, NULL_RTX);
3683 if (nonlocal_goto_handler_slots != 0)
3684 emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level,
3688 /* Any gotos out of this block must also do these things.
3689 Also report any gotos with fixups that came to labels in this
3691 fixup_gotos (thisblock,
3692 thisblock->data.block.stack_level,
3693 thisblock->data.block.cleanups,
3694 thisblock->data.block.first_insn,
3698 /* Mark the beginning and end of the scope if requested.
3699 We do this now, after running cleanups on the variables
3700 just going out of scope, so they are in scope for their cleanups. */
3704 rtx note = emit_note (NULL, NOTE_INSN_BLOCK_END);
3705 NOTE_BLOCK (note) = NOTE_BLOCK (thisblock->data.block.first_insn);
3708 /* Get rid of the beginning-mark if we don't make an end-mark. */
3709 NOTE_LINE_NUMBER (thisblock->data.block.first_insn) = NOTE_INSN_DELETED;
3711 /* Restore the temporary level of TARGET_EXPRs. */
3712 target_temp_slot_level = thisblock->data.block.block_target_temp_slot_level;
3714 /* Restore block_stack level for containing block. */
3716 stack_block_stack = thisblock->data.block.innermost_stack_block;
3717 POPSTACK (block_stack);
3719 /* Pop the stack slot nesting and free any slots at this level. */
3723 /* Generate code to save the stack pointer at the start of the current block
3724 and set up to restore it on exit. */
3727 save_stack_pointer ()
3729 struct nesting *thisblock = block_stack;
3731 if (thisblock->data.block.stack_level == 0)
3733 emit_stack_save (thisblock->next ? SAVE_BLOCK : SAVE_FUNCTION,
3734 &thisblock->data.block.stack_level,
3735 thisblock->data.block.first_insn);
3736 stack_block_stack = thisblock;
3740 /* Generate RTL for the automatic variable declaration DECL.
3741 (Other kinds of declarations are simply ignored if seen here.) */
3747 struct nesting *thisblock;
3750 type = TREE_TYPE (decl);
3752 /* For a CONST_DECL, set mode, alignment, and sizes from those of the
3753 type in case this node is used in a reference. */
3754 if (TREE_CODE (decl) == CONST_DECL)
3756 DECL_MODE (decl) = TYPE_MODE (type);
3757 DECL_ALIGN (decl) = TYPE_ALIGN (type);
3758 DECL_SIZE (decl) = TYPE_SIZE (type);
3759 DECL_SIZE_UNIT (decl) = TYPE_SIZE_UNIT (type);
3763 /* Otherwise, only automatic variables need any expansion done. Static and
3764 external variables, and external functions, will be handled by
3765 `assemble_variable' (called from finish_decl). TYPE_DECL requires
3766 nothing. PARM_DECLs are handled in `assign_parms'. */
3767 if (TREE_CODE (decl) != VAR_DECL)
3770 if (TREE_STATIC (decl) || DECL_EXTERNAL (decl))
3773 thisblock = block_stack;
3775 /* Create the RTL representation for the variable. */
3777 if (type == error_mark_node)
3778 SET_DECL_RTL (decl, gen_rtx_MEM (BLKmode, const0_rtx));
3780 else if (DECL_SIZE (decl) == 0)
3781 /* Variable with incomplete type. */
3783 if (DECL_INITIAL (decl) == 0)
3784 /* Error message was already done; now avoid a crash. */
3785 SET_DECL_RTL (decl, gen_rtx_MEM (BLKmode, const0_rtx));
3787 /* An initializer is going to decide the size of this array.
3788 Until we know the size, represent its address with a reg. */
3789 SET_DECL_RTL (decl, gen_rtx_MEM (BLKmode, gen_reg_rtx (Pmode)));
3791 set_mem_attributes (DECL_RTL (decl), decl, 1);
3793 else if (DECL_MODE (decl) != BLKmode
3794 /* If -ffloat-store, don't put explicit float vars
3796 && !(flag_float_store
3797 && TREE_CODE (type) == REAL_TYPE)
3798 && ! TREE_THIS_VOLATILE (decl)
3799 && (DECL_REGISTER (decl) || optimize)
3800 /* if -fcheck-memory-usage, check all variables. */
3801 && ! current_function_check_memory_usage)
3803 /* Automatic variable that can go in a register. */
3804 int unsignedp = TREE_UNSIGNED (type);
3805 enum machine_mode reg_mode
3806 = promote_mode (type, DECL_MODE (decl), &unsignedp, 0);
3808 SET_DECL_RTL (decl, gen_reg_rtx (reg_mode));
3809 mark_user_reg (DECL_RTL (decl));
3811 if (POINTER_TYPE_P (type))
3812 mark_reg_pointer (DECL_RTL (decl),
3813 TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
3815 maybe_set_unchanging (DECL_RTL (decl), decl);
3817 /* If something wants our address, try to use ADDRESSOF. */
3818 if (TREE_ADDRESSABLE (decl))
3819 put_var_into_stack (decl);
3822 else if (TREE_CODE (DECL_SIZE_UNIT (decl)) == INTEGER_CST
3823 && ! (flag_stack_check && ! STACK_CHECK_BUILTIN
3824 && 0 < compare_tree_int (DECL_SIZE_UNIT (decl),
3825 STACK_CHECK_MAX_VAR_SIZE)))
3827 /* Variable of fixed size that goes on the stack. */
3831 /* If we previously made RTL for this decl, it must be an array
3832 whose size was determined by the initializer.
3833 The old address was a register; set that register now
3834 to the proper address. */
3835 if (DECL_RTL_SET_P (decl))
3837 if (GET_CODE (DECL_RTL (decl)) != MEM
3838 || GET_CODE (XEXP (DECL_RTL (decl), 0)) != REG)
3840 oldaddr = XEXP (DECL_RTL (decl), 0);
3844 assign_temp (TREE_TYPE (decl), 1, 1, 1));
3846 /* Set alignment we actually gave this decl. */
3847 DECL_ALIGN (decl) = (DECL_MODE (decl) == BLKmode ? BIGGEST_ALIGNMENT
3848 : GET_MODE_BITSIZE (DECL_MODE (decl)));
3849 DECL_USER_ALIGN (decl) = 0;
3853 addr = force_operand (XEXP (DECL_RTL (decl), 0), oldaddr);
3854 if (addr != oldaddr)
3855 emit_move_insn (oldaddr, addr);
3859 /* Dynamic-size object: must push space on the stack. */
3863 /* Record the stack pointer on entry to block, if have
3864 not already done so. */
3865 do_pending_stack_adjust ();
3866 save_stack_pointer ();
3868 /* In function-at-a-time mode, variable_size doesn't expand this,
3870 if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
3871 expand_expr (TYPE_MAX_VALUE (TYPE_DOMAIN (type)),
3872 const0_rtx, VOIDmode, 0);
3874 /* Compute the variable's size, in bytes. */
3875 size = expand_expr (DECL_SIZE_UNIT (decl), NULL_RTX, VOIDmode, 0);
3878 /* Allocate space on the stack for the variable. Note that
3879 DECL_ALIGN says how the variable is to be aligned and we
3880 cannot use it to conclude anything about the alignment of
3882 address = allocate_dynamic_stack_space (size, NULL_RTX,
3883 TYPE_ALIGN (TREE_TYPE (decl)));
3885 /* Reference the variable indirect through that rtx. */
3886 SET_DECL_RTL (decl, gen_rtx_MEM (DECL_MODE (decl), address));
3888 set_mem_attributes (DECL_RTL (decl), decl, 1);
3890 /* Indicate the alignment we actually gave this variable. */
3891 #ifdef STACK_BOUNDARY
3892 DECL_ALIGN (decl) = STACK_BOUNDARY;
3894 DECL_ALIGN (decl) = BIGGEST_ALIGNMENT;
3896 DECL_USER_ALIGN (decl) = 0;
3900 /* Emit code to perform the initialization of a declaration DECL. */
3903 expand_decl_init (decl)
3906 int was_used = TREE_USED (decl);
3908 /* If this is a CONST_DECL, we don't have to generate any code, but
3909 if DECL_INITIAL is a constant, call expand_expr to force TREE_CST_RTL
3910 to be set while in the obstack containing the constant. If we don't
3911 do this, we can lose if we have functions nested three deep and the middle
3912 function makes a CONST_DECL whose DECL_INITIAL is a STRING_CST while
3913 the innermost function is the first to expand that STRING_CST. */
3914 if (TREE_CODE (decl) == CONST_DECL)
3916 if (DECL_INITIAL (decl) && TREE_CONSTANT (DECL_INITIAL (decl)))
3917 expand_expr (DECL_INITIAL (decl), NULL_RTX, VOIDmode,
3918 EXPAND_INITIALIZER);
3922 if (TREE_STATIC (decl))
3925 /* Compute and store the initial value now. */
3927 if (DECL_INITIAL (decl) == error_mark_node)
3929 enum tree_code code = TREE_CODE (TREE_TYPE (decl));
3931 if (code == INTEGER_TYPE || code == REAL_TYPE || code == ENUMERAL_TYPE
3932 || code == POINTER_TYPE || code == REFERENCE_TYPE)
3933 expand_assignment (decl, convert (TREE_TYPE (decl), integer_zero_node),
3937 else if (DECL_INITIAL (decl) && TREE_CODE (DECL_INITIAL (decl)) != TREE_LIST)
3939 emit_line_note (DECL_SOURCE_FILE (decl), DECL_SOURCE_LINE (decl));
3940 expand_assignment (decl, DECL_INITIAL (decl), 0, 0);
3944 /* Don't let the initialization count as "using" the variable. */
3945 TREE_USED (decl) = was_used;
3947 /* Free any temporaries we made while initializing the decl. */
3948 preserve_temp_slots (NULL_RTX);
3952 /* CLEANUP is an expression to be executed at exit from this binding contour;
3953 for example, in C++, it might call the destructor for this variable.
3955 We wrap CLEANUP in an UNSAVE_EXPR node, so that we can expand the
3956 CLEANUP multiple times, and have the correct semantics. This
3957 happens in exception handling, for gotos, returns, breaks that
3958 leave the current scope.
3960 If CLEANUP is nonzero and DECL is zero, we record a cleanup
3961 that is not associated with any particular variable. */
3964 expand_decl_cleanup (decl, cleanup)
3967 struct nesting *thisblock;
3969 /* Error if we are not in any block. */
3970 if (cfun == 0 || block_stack == 0)
3973 thisblock = block_stack;
3975 /* Record the cleanup if there is one. */
3981 tree *cleanups = &thisblock->data.block.cleanups;
3982 int cond_context = conditional_context ();
3986 rtx flag = gen_reg_rtx (word_mode);
3991 emit_move_insn (flag, const0_rtx);
3992 set_flag_0 = get_insns ();
3995 thisblock->data.block.last_unconditional_cleanup
3996 = emit_insns_after (set_flag_0,
3997 thisblock->data.block.last_unconditional_cleanup);
3999 emit_move_insn (flag, const1_rtx);
4001 cond = build_decl (VAR_DECL, NULL_TREE, type_for_mode (word_mode, 1));
4002 SET_DECL_RTL (cond, flag);
4004 /* Conditionalize the cleanup. */
4005 cleanup = build (COND_EXPR, void_type_node,
4006 truthvalue_conversion (cond),
4007 cleanup, integer_zero_node);
4008 cleanup = fold (cleanup);
4010 cleanups = thisblock->data.block.cleanup_ptr;
4013 cleanup = unsave_expr (cleanup);
4015 t = *cleanups = tree_cons (decl, cleanup, *cleanups);
4018 /* If this block has a cleanup, it belongs in stack_block_stack. */
4019 stack_block_stack = thisblock;
4026 if (! using_eh_for_cleanups_p)
4027 TREE_ADDRESSABLE (t) = 1;
4029 expand_eh_region_start ();
4036 thisblock->data.block.last_unconditional_cleanup
4037 = emit_insns_after (seq,
4038 thisblock->data.block.last_unconditional_cleanup);
4042 thisblock->data.block.last_unconditional_cleanup
4044 /* When we insert instructions after the last unconditional cleanup,
4045 we don't adjust last_insn. That means that a later add_insn will
4046 clobber the instructions we've just added. The easiest way to
4047 fix this is to just insert another instruction here, so that the
4048 instructions inserted after the last unconditional cleanup are
4049 never the last instruction. */
4050 emit_note (NULL, NOTE_INSN_DELETED);
4051 thisblock->data.block.cleanup_ptr = &thisblock->data.block.cleanups;
4057 /* DECL is an anonymous union. CLEANUP is a cleanup for DECL.
4058 DECL_ELTS is the list of elements that belong to DECL's type.
4059 In each, the TREE_VALUE is a VAR_DECL, and the TREE_PURPOSE a cleanup. */
4062 expand_anon_union_decl (decl, cleanup, decl_elts)
4063 tree decl, cleanup, decl_elts;
4065 struct nesting *thisblock = cfun == 0 ? 0 : block_stack;
4069 /* If any of the elements are addressable, so is the entire union. */
4070 for (t = decl_elts; t; t = TREE_CHAIN (t))
4071 if (TREE_ADDRESSABLE (TREE_VALUE (t)))
4073 TREE_ADDRESSABLE (decl) = 1;
4078 expand_decl_cleanup (decl, cleanup);
4079 x = DECL_RTL (decl);
4081 /* Go through the elements, assigning RTL to each. */
4082 for (t = decl_elts; t; t = TREE_CHAIN (t))
4084 tree decl_elt = TREE_VALUE (t);
4085 tree cleanup_elt = TREE_PURPOSE (t);
4086 enum machine_mode mode = TYPE_MODE (TREE_TYPE (decl_elt));
4088 /* Propagate the union's alignment to the elements. */
4089 DECL_ALIGN (decl_elt) = DECL_ALIGN (decl);
4090 DECL_USER_ALIGN (decl_elt) = DECL_USER_ALIGN (decl);
4092 /* If the element has BLKmode and the union doesn't, the union is
4093 aligned such that the element doesn't need to have BLKmode, so
4094 change the element's mode to the appropriate one for its size. */
4095 if (mode == BLKmode && DECL_MODE (decl) != BLKmode)
4096 DECL_MODE (decl_elt) = mode
4097 = mode_for_size_tree (DECL_SIZE (decl_elt), MODE_INT, 1);
4099 /* (SUBREG (MEM ...)) at RTL generation time is invalid, so we
4100 instead create a new MEM rtx with the proper mode. */
4101 if (GET_CODE (x) == MEM)
4103 if (mode == GET_MODE (x))
4104 SET_DECL_RTL (decl_elt, x);
4107 SET_DECL_RTL (decl_elt,
4108 gen_rtx_MEM (mode, copy_rtx (XEXP (x, 0))));
4109 MEM_COPY_ATTRIBUTES (DECL_RTL (decl_elt), x);
4112 else if (GET_CODE (x) == REG)
4114 if (mode == GET_MODE (x))
4115 SET_DECL_RTL (decl_elt, x);
4117 SET_DECL_RTL (decl_elt, gen_lowpart_SUBREG (mode, x));
4122 /* Record the cleanup if there is one. */
4125 thisblock->data.block.cleanups
4126 = tree_cons (decl_elt, cleanup_elt,
4127 thisblock->data.block.cleanups);
4131 /* Expand a list of cleanups LIST.
4132 Elements may be expressions or may be nested lists.
4134 If DONT_DO is nonnull, then any list-element
4135 whose TREE_PURPOSE matches DONT_DO is omitted.
4136 This is sometimes used to avoid a cleanup associated with
4137 a value that is being returned out of the scope.
4139 If IN_FIXUP is non-zero, we are generating this cleanup for a fixup
4140 goto and handle protection regions specially in that case.
4142 If REACHABLE, we emit code, otherwise just inform the exception handling
4143 code about this finalization. */
4146 expand_cleanups (list, dont_do, in_fixup, reachable)
4153 for (tail = list; tail; tail = TREE_CHAIN (tail))
4154 if (dont_do == 0 || TREE_PURPOSE (tail) != dont_do)
4156 if (TREE_CODE (TREE_VALUE (tail)) == TREE_LIST)
4157 expand_cleanups (TREE_VALUE (tail), dont_do, in_fixup, reachable);
4160 if (! in_fixup && using_eh_for_cleanups_p)
4161 expand_eh_region_end_cleanup (TREE_VALUE (tail));
4165 /* Cleanups may be run multiple times. For example,
4166 when exiting a binding contour, we expand the
4167 cleanups associated with that contour. When a goto
4168 within that binding contour has a target outside that
4169 contour, it will expand all cleanups from its scope to
4170 the target. Though the cleanups are expanded multiple
4171 times, the control paths are non-overlapping so the
4172 cleanups will not be executed twice. */
4174 /* We may need to protect from outer cleanups. */
4175 if (in_fixup && using_eh_for_cleanups_p)
4177 expand_eh_region_start ();
4179 expand_expr (TREE_VALUE (tail), const0_rtx, VOIDmode, 0);
4181 expand_eh_region_end_fixup (TREE_VALUE (tail));
4184 expand_expr (TREE_VALUE (tail), const0_rtx, VOIDmode, 0);
4192 /* Mark when the context we are emitting RTL for as a conditional
4193 context, so that any cleanup actions we register with
4194 expand_decl_init will be properly conditionalized when those
4195 cleanup actions are later performed. Must be called before any
4196 expression (tree) is expanded that is within a conditional context. */
4199 start_cleanup_deferral ()
4201 /* block_stack can be NULL if we are inside the parameter list. It is
4202 OK to do nothing, because cleanups aren't possible here. */
4204 ++block_stack->data.block.conditional_code;
4207 /* Mark the end of a conditional region of code. Because cleanup
4208 deferrals may be nested, we may still be in a conditional region
4209 after we end the currently deferred cleanups, only after we end all
4210 deferred cleanups, are we back in unconditional code. */
4213 end_cleanup_deferral ()
4215 /* block_stack can be NULL if we are inside the parameter list. It is
4216 OK to do nothing, because cleanups aren't possible here. */
4218 --block_stack->data.block.conditional_code;
4221 /* Move all cleanups from the current block_stack
4222 to the containing block_stack, where they are assumed to
4223 have been created. If anything can cause a temporary to
4224 be created, but not expanded for more than one level of
4225 block_stacks, then this code will have to change. */
4230 struct nesting *block = block_stack;
4231 struct nesting *outer = block->next;
4233 outer->data.block.cleanups
4234 = chainon (block->data.block.cleanups,
4235 outer->data.block.cleanups);
4236 block->data.block.cleanups = 0;
4240 last_cleanup_this_contour ()
4242 if (block_stack == 0)
4245 return block_stack->data.block.cleanups;
4248 /* Return 1 if there are any pending cleanups at this point.
4249 If THIS_CONTOUR is nonzero, check the current contour as well.
4250 Otherwise, look only at the contours that enclose this one. */
4253 any_pending_cleanups (this_contour)
4256 struct nesting *block;
4258 if (cfun == NULL || cfun->stmt == NULL || block_stack == 0)
4261 if (this_contour && block_stack->data.block.cleanups != NULL)
4263 if (block_stack->data.block.cleanups == 0
4264 && block_stack->data.block.outer_cleanups == 0)
4267 for (block = block_stack->next; block; block = block->next)
4268 if (block->data.block.cleanups != 0)
4274 /* Enter a case (Pascal) or switch (C) statement.
4275 Push a block onto case_stack and nesting_stack
4276 to accumulate the case-labels that are seen
4277 and to record the labels generated for the statement.
4279 EXIT_FLAG is nonzero if `exit_something' should exit this case stmt.
4280 Otherwise, this construct is transparent for `exit_something'.
4282 EXPR is the index-expression to be dispatched on.
4283 TYPE is its nominal type. We could simply convert EXPR to this type,
4284 but instead we take short cuts. */
4287 expand_start_case (exit_flag, expr, type, printname)
4291 const char *printname;
4293 register struct nesting *thiscase = ALLOC_NESTING ();
4295 /* Make an entry on case_stack for the case we are entering. */
4297 thiscase->next = case_stack;
4298 thiscase->all = nesting_stack;
4299 thiscase->depth = ++nesting_depth;
4300 thiscase->exit_label = exit_flag ? gen_label_rtx () : 0;
4301 thiscase->data.case_stmt.case_list = 0;
4302 thiscase->data.case_stmt.index_expr = expr;
4303 thiscase->data.case_stmt.nominal_type = type;
4304 thiscase->data.case_stmt.default_label = 0;
4305 thiscase->data.case_stmt.printname = printname;
4306 thiscase->data.case_stmt.line_number_status = force_line_numbers ();
4307 case_stack = thiscase;
4308 nesting_stack = thiscase;
4310 do_pending_stack_adjust ();
4312 /* Make sure case_stmt.start points to something that won't
4313 need any transformation before expand_end_case. */
4314 if (GET_CODE (get_last_insn ()) != NOTE)
4315 emit_note (NULL, NOTE_INSN_DELETED);
4317 thiscase->data.case_stmt.start = get_last_insn ();
4319 start_cleanup_deferral ();
4322 /* Start a "dummy case statement" within which case labels are invalid
4323 and are not connected to any larger real case statement.
4324 This can be used if you don't want to let a case statement jump
4325 into the middle of certain kinds of constructs. */
4328 expand_start_case_dummy ()
4330 register struct nesting *thiscase = ALLOC_NESTING ();
4332 /* Make an entry on case_stack for the dummy. */
4334 thiscase->next = case_stack;
4335 thiscase->all = nesting_stack;
4336 thiscase->depth = ++nesting_depth;
4337 thiscase->exit_label = 0;
4338 thiscase->data.case_stmt.case_list = 0;
4339 thiscase->data.case_stmt.start = 0;
4340 thiscase->data.case_stmt.nominal_type = 0;
4341 thiscase->data.case_stmt.default_label = 0;
4342 case_stack = thiscase;
4343 nesting_stack = thiscase;
4344 start_cleanup_deferral ();
4347 /* End a dummy case statement. */
4350 expand_end_case_dummy ()
4352 end_cleanup_deferral ();
4353 POPSTACK (case_stack);
4356 /* Return the data type of the index-expression
4357 of the innermost case statement, or null if none. */
4360 case_index_expr_type ()
4363 return TREE_TYPE (case_stack->data.case_stmt.index_expr);
4370 /* If this is the first label, warn if any insns have been emitted. */
4371 if (case_stack->data.case_stmt.line_number_status >= 0)
4375 restore_line_number_status
4376 (case_stack->data.case_stmt.line_number_status);
4377 case_stack->data.case_stmt.line_number_status = -1;
4379 for (insn = case_stack->data.case_stmt.start;
4381 insn = NEXT_INSN (insn))
4383 if (GET_CODE (insn) == CODE_LABEL)
4385 if (GET_CODE (insn) != NOTE
4386 && (GET_CODE (insn) != INSN || GET_CODE (PATTERN (insn)) != USE))
4389 insn = PREV_INSN (insn);
4390 while (insn && (GET_CODE (insn) != NOTE || NOTE_LINE_NUMBER (insn) < 0));
4392 /* If insn is zero, then there must have been a syntax error. */
4394 warning_with_file_and_line (NOTE_SOURCE_FILE (insn),
4395 NOTE_LINE_NUMBER (insn),
4396 "unreachable code at beginning of %s",
4397 case_stack->data.case_stmt.printname);
4404 /* Accumulate one case or default label inside a case or switch statement.
4405 VALUE is the value of the case (a null pointer, for a default label).
4406 The function CONVERTER, when applied to arguments T and V,
4407 converts the value V to the type T.
4409 If not currently inside a case or switch statement, return 1 and do
4410 nothing. The caller will print a language-specific error message.
4411 If VALUE is a duplicate or overlaps, return 2 and do nothing
4412 except store the (first) duplicate node in *DUPLICATE.
4413 If VALUE is out of range, return 3 and do nothing.
4414 If we are jumping into the scope of a cleanup or var-sized array, return 5.
4415 Return 0 on success.
4417 Extended to handle range statements. */
4420 pushcase (value, converter, label, duplicate)
4421 register tree value;
4422 tree (*converter) PARAMS ((tree, tree));
4423 register tree label;
4429 /* Fail if not inside a real case statement. */
4430 if (! (case_stack && case_stack->data.case_stmt.start))
4433 if (stack_block_stack
4434 && stack_block_stack->depth > case_stack->depth)
4437 index_type = TREE_TYPE (case_stack->data.case_stmt.index_expr);
4438 nominal_type = case_stack->data.case_stmt.nominal_type;
4440 /* If the index is erroneous, avoid more problems: pretend to succeed. */
4441 if (index_type == error_mark_node)
4444 /* Convert VALUE to the type in which the comparisons are nominally done. */
4446 value = (*converter) (nominal_type, value);
4450 /* Fail if this value is out of range for the actual type of the index
4451 (which may be narrower than NOMINAL_TYPE). */
4453 && (TREE_CONSTANT_OVERFLOW (value)
4454 || ! int_fits_type_p (value, index_type)))
4457 return add_case_node (value, value, label, duplicate);
4460 /* Like pushcase but this case applies to all values between VALUE1 and
4461 VALUE2 (inclusive). If VALUE1 is NULL, the range starts at the lowest
4462 value of the index type and ends at VALUE2. If VALUE2 is NULL, the range
4463 starts at VALUE1 and ends at the highest value of the index type.
4464 If both are NULL, this case applies to all values.
4466 The return value is the same as that of pushcase but there is one
4467 additional error code: 4 means the specified range was empty. */
4470 pushcase_range (value1, value2, converter, label, duplicate)
4471 register tree value1, value2;
4472 tree (*converter) PARAMS ((tree, tree));
4473 register tree label;
4479 /* Fail if not inside a real case statement. */
4480 if (! (case_stack && case_stack->data.case_stmt.start))
4483 if (stack_block_stack
4484 && stack_block_stack->depth > case_stack->depth)
4487 index_type = TREE_TYPE (case_stack->data.case_stmt.index_expr);
4488 nominal_type = case_stack->data.case_stmt.nominal_type;
4490 /* If the index is erroneous, avoid more problems: pretend to succeed. */
4491 if (index_type == error_mark_node)
4496 /* Convert VALUEs to type in which the comparisons are nominally done
4497 and replace any unspecified value with the corresponding bound. */
4499 value1 = TYPE_MIN_VALUE (index_type);
4501 value2 = TYPE_MAX_VALUE (index_type);
4503 /* Fail if the range is empty. Do this before any conversion since
4504 we want to allow out-of-range empty ranges. */
4505 if (value2 != 0 && tree_int_cst_lt (value2, value1))
4508 /* If the max was unbounded, use the max of the nominal_type we are
4509 converting to. Do this after the < check above to suppress false
4512 value2 = TYPE_MAX_VALUE (nominal_type);
4514 value1 = (*converter) (nominal_type, value1);
4515 value2 = (*converter) (nominal_type, value2);
4517 /* Fail if these values are out of range. */
4518 if (TREE_CONSTANT_OVERFLOW (value1)
4519 || ! int_fits_type_p (value1, index_type))
4522 if (TREE_CONSTANT_OVERFLOW (value2)
4523 || ! int_fits_type_p (value2, index_type))
4526 return add_case_node (value1, value2, label, duplicate);
4529 /* Do the actual insertion of a case label for pushcase and pushcase_range
4530 into case_stack->data.case_stmt.case_list. Use an AVL tree to avoid
4531 slowdown for large switch statements. */
4534 add_case_node (low, high, label, duplicate)
4539 struct case_node *p, **q, *r;
4541 /* If there's no HIGH value, then this is not a case range; it's
4542 just a simple case label. But that's just a degenerate case
4547 /* Handle default labels specially. */
4550 if (case_stack->data.case_stmt.default_label != 0)
4552 *duplicate = case_stack->data.case_stmt.default_label;
4555 case_stack->data.case_stmt.default_label = label;
4556 expand_label (label);
4560 q = &case_stack->data.case_stmt.case_list;
4567 /* Keep going past elements distinctly greater than HIGH. */
4568 if (tree_int_cst_lt (high, p->low))
4571 /* or distinctly less than LOW. */
4572 else if (tree_int_cst_lt (p->high, low))
4577 /* We have an overlap; this is an error. */
4578 *duplicate = p->code_label;
4583 /* Add this label to the chain, and succeed. */
4585 r = (struct case_node *) xmalloc (sizeof (struct case_node));
4588 /* If the bounds are equal, turn this into the one-value case. */
4589 if (tree_int_cst_equal (low, high))
4594 r->code_label = label;
4595 expand_label (label);
4605 struct case_node *s;
4611 if (! (b = p->balance))
4612 /* Growth propagation from left side. */
4619 if ((p->left = s = r->right))
4628 if ((r->parent = s))
4636 case_stack->data.case_stmt.case_list = r;
4639 /* r->balance == +1 */
4644 struct case_node *t = r->right;
4646 if ((p->left = s = t->right))
4650 if ((r->right = s = t->left))
4664 if ((t->parent = s))
4672 case_stack->data.case_stmt.case_list = t;
4679 /* p->balance == +1; growth of left side balances the node. */
4689 if (! (b = p->balance))
4690 /* Growth propagation from right side. */
4698 if ((p->right = s = r->left))
4706 if ((r->parent = s))
4715 case_stack->data.case_stmt.case_list = r;
4719 /* r->balance == -1 */
4723 struct case_node *t = r->left;
4725 if ((p->right = s = t->left))
4730 if ((r->left = s = t->right))
4744 if ((t->parent = s))
4753 case_stack->data.case_stmt.case_list = t;
4759 /* p->balance == -1; growth of right side balances the node. */
4772 /* Returns the number of possible values of TYPE.
4773 Returns -1 if the number is unknown, variable, or if the number does not
4774 fit in a HOST_WIDE_INT.
4775 Sets *SPARENESS to 2 if TYPE is an ENUMERAL_TYPE whose values
4776 do not increase monotonically (there may be duplicates);
4777 to 1 if the values increase monotonically, but not always by 1;
4778 otherwise sets it to 0. */
4781 all_cases_count (type, spareness)
4786 HOST_WIDE_INT count, minval, lastval;
4790 switch (TREE_CODE (type))
4797 count = 1 << BITS_PER_UNIT;
4802 if (TYPE_MAX_VALUE (type) != 0
4803 && 0 != (t = fold (build (MINUS_EXPR, type, TYPE_MAX_VALUE (type),
4804 TYPE_MIN_VALUE (type))))
4805 && 0 != (t = fold (build (PLUS_EXPR, type, t,
4806 convert (type, integer_zero_node))))
4807 && host_integerp (t, 1))
4808 count = tree_low_cst (t, 1);
4814 /* Don't waste time with enumeral types with huge values. */
4815 if (! host_integerp (TYPE_MIN_VALUE (type), 0)
4816 || TYPE_MAX_VALUE (type) == 0
4817 || ! host_integerp (TYPE_MAX_VALUE (type), 0))
4820 lastval = minval = tree_low_cst (TYPE_MIN_VALUE (type), 0);
4823 for (t = TYPE_VALUES (type); t != NULL_TREE; t = TREE_CHAIN (t))
4825 HOST_WIDE_INT thisval = tree_low_cst (TREE_VALUE (t), 0);
4827 if (*spareness == 2 || thisval < lastval)
4829 else if (thisval != minval + count)
4839 #define BITARRAY_TEST(ARRAY, INDEX) \
4840 ((ARRAY)[(unsigned) (INDEX) / HOST_BITS_PER_CHAR]\
4841 & (1 << ((unsigned) (INDEX) % HOST_BITS_PER_CHAR)))
4842 #define BITARRAY_SET(ARRAY, INDEX) \
4843 ((ARRAY)[(unsigned) (INDEX) / HOST_BITS_PER_CHAR]\
4844 |= 1 << ((unsigned) (INDEX) % HOST_BITS_PER_CHAR))
4846 /* Set the elements of the bitstring CASES_SEEN (which has length COUNT),
4847 with the case values we have seen, assuming the case expression
4849 SPARSENESS is as determined by all_cases_count.
4851 The time needed is proportional to COUNT, unless
4852 SPARSENESS is 2, in which case quadratic time is needed. */
4855 mark_seen_cases (type, cases_seen, count, sparseness)
4857 unsigned char *cases_seen;
4858 HOST_WIDE_INT count;
4861 tree next_node_to_try = NULL_TREE;
4862 HOST_WIDE_INT next_node_offset = 0;
4864 register struct case_node *n, *root = case_stack->data.case_stmt.case_list;
4865 tree val = make_node (INTEGER_CST);
4867 TREE_TYPE (val) = type;
4871 else if (sparseness == 2)
4874 unsigned HOST_WIDE_INT xlo;
4876 /* This less efficient loop is only needed to handle
4877 duplicate case values (multiple enum constants
4878 with the same value). */
4879 TREE_TYPE (val) = TREE_TYPE (root->low);
4880 for (t = TYPE_VALUES (type), xlo = 0; t != NULL_TREE;
4881 t = TREE_CHAIN (t), xlo++)
4883 TREE_INT_CST_LOW (val) = TREE_INT_CST_LOW (TREE_VALUE (t));
4884 TREE_INT_CST_HIGH (val) = TREE_INT_CST_HIGH (TREE_VALUE (t));
4888 /* Keep going past elements distinctly greater than VAL. */
4889 if (tree_int_cst_lt (val, n->low))
4892 /* or distinctly less than VAL. */
4893 else if (tree_int_cst_lt (n->high, val))
4898 /* We have found a matching range. */
4899 BITARRAY_SET (cases_seen, xlo);
4909 case_stack->data.case_stmt.case_list = root = case_tree2list (root, 0);
4911 for (n = root; n; n = n->right)
4913 TREE_INT_CST_LOW (val) = TREE_INT_CST_LOW (n->low);
4914 TREE_INT_CST_HIGH (val) = TREE_INT_CST_HIGH (n->low);
4915 while (! tree_int_cst_lt (n->high, val))
4917 /* Calculate (into xlo) the "offset" of the integer (val).
4918 The element with lowest value has offset 0, the next smallest
4919 element has offset 1, etc. */
4921 unsigned HOST_WIDE_INT xlo;
4925 if (sparseness && TYPE_VALUES (type) != NULL_TREE)
4927 /* The TYPE_VALUES will be in increasing order, so
4928 starting searching where we last ended. */
4929 t = next_node_to_try;
4930 xlo = next_node_offset;
4936 t = TYPE_VALUES (type);
4939 if (tree_int_cst_equal (val, TREE_VALUE (t)))
4941 next_node_to_try = TREE_CHAIN (t);
4942 next_node_offset = xlo + 1;
4947 if (t == next_node_to_try)
4956 t = TYPE_MIN_VALUE (type);
4958 neg_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t),
4962 add_double (xlo, xhi,
4963 TREE_INT_CST_LOW (val), TREE_INT_CST_HIGH (val),
4967 if (xhi == 0 && xlo < (unsigned HOST_WIDE_INT) count)
4968 BITARRAY_SET (cases_seen, xlo);
4970 add_double (TREE_INT_CST_LOW (val), TREE_INT_CST_HIGH (val),
4972 &TREE_INT_CST_LOW (val), &TREE_INT_CST_HIGH (val));
4978 /* Called when the index of a switch statement is an enumerated type
4979 and there is no default label.
4981 Checks that all enumeration literals are covered by the case
4982 expressions of a switch. Also, warn if there are any extra
4983 switch cases that are *not* elements of the enumerated type.
4985 If all enumeration literals were covered by the case expressions,
4986 turn one of the expressions into the default expression since it should
4987 not be possible to fall through such a switch. */
4990 check_for_full_enumeration_handling (type)
4993 register struct case_node *n;
4994 register tree chain;
4995 #if 0 /* variable used by 'if 0'ed code below. */
4996 register struct case_node **l;
5000 /* True iff the selector type is a numbered set mode. */
5003 /* The number of possible selector values. */
5006 /* For each possible selector value. a one iff it has been matched
5007 by a case value alternative. */
5008 unsigned char *cases_seen;
5010 /* The allocated size of cases_seen, in chars. */
5011 HOST_WIDE_INT bytes_needed;
5016 size = all_cases_count (type, &sparseness);
5017 bytes_needed = (size + HOST_BITS_PER_CHAR) / HOST_BITS_PER_CHAR;
5019 if (size > 0 && size < 600000
5020 /* We deliberately use calloc here, not cmalloc, so that we can suppress
5021 this optimization if we don't have enough memory rather than
5022 aborting, as xmalloc would do. */
5024 (unsigned char *) really_call_calloc (bytes_needed, 1)) != NULL)
5027 tree v = TYPE_VALUES (type);
5029 /* The time complexity of this code is normally O(N), where
5030 N being the number of members in the enumerated type.
5031 However, if type is a ENUMERAL_TYPE whose values do not
5032 increase monotonically, O(N*log(N)) time may be needed. */
5034 mark_seen_cases (type, cases_seen, size, sparseness);
5036 for (i = 0; v != NULL_TREE && i < size; i++, v = TREE_CHAIN (v))
5037 if (BITARRAY_TEST (cases_seen, i) == 0)
5038 warning ("enumeration value `%s' not handled in switch",
5039 IDENTIFIER_POINTER (TREE_PURPOSE (v)));
5044 /* Now we go the other way around; we warn if there are case
5045 expressions that don't correspond to enumerators. This can
5046 occur since C and C++ don't enforce type-checking of
5047 assignments to enumeration variables. */
5049 if (case_stack->data.case_stmt.case_list
5050 && case_stack->data.case_stmt.case_list->left)
5051 case_stack->data.case_stmt.case_list
5052 = case_tree2list (case_stack->data.case_stmt.case_list, 0);
5054 for (n = case_stack->data.case_stmt.case_list; n; n = n->right)
5056 for (chain = TYPE_VALUES (type);
5057 chain && !tree_int_cst_equal (n->low, TREE_VALUE (chain));
5058 chain = TREE_CHAIN (chain))
5063 if (TYPE_NAME (type) == 0)
5064 warning ("case value `%ld' not in enumerated type",
5065 (long) TREE_INT_CST_LOW (n->low));
5067 warning ("case value `%ld' not in enumerated type `%s'",
5068 (long) TREE_INT_CST_LOW (n->low),
5069 IDENTIFIER_POINTER ((TREE_CODE (TYPE_NAME (type))
5072 : DECL_NAME (TYPE_NAME (type))));
5074 if (!tree_int_cst_equal (n->low, n->high))
5076 for (chain = TYPE_VALUES (type);
5077 chain && !tree_int_cst_equal (n->high, TREE_VALUE (chain));
5078 chain = TREE_CHAIN (chain))
5083 if (TYPE_NAME (type) == 0)
5084 warning ("case value `%ld' not in enumerated type",
5085 (long) TREE_INT_CST_LOW (n->high));
5087 warning ("case value `%ld' not in enumerated type `%s'",
5088 (long) TREE_INT_CST_LOW (n->high),
5089 IDENTIFIER_POINTER ((TREE_CODE (TYPE_NAME (type))
5092 : DECL_NAME (TYPE_NAME (type))));
5098 /* ??? This optimization is disabled because it causes valid programs to
5099 fail. ANSI C does not guarantee that an expression with enum type
5100 will have a value that is the same as one of the enumeration literals. */
5102 /* If all values were found as case labels, make one of them the default
5103 label. Thus, this switch will never fall through. We arbitrarily pick
5104 the last one to make the default since this is likely the most
5105 efficient choice. */
5109 for (l = &case_stack->data.case_stmt.case_list;
5114 case_stack->data.case_stmt.default_label = (*l)->code_label;
5120 /* Free CN, and its children. */
5123 free_case_nodes (cn)
5128 free_case_nodes (cn->left);
5129 free_case_nodes (cn->right);
5135 /* Terminate a case (Pascal) or switch (C) statement
5136 in which ORIG_INDEX is the expression to be tested.
5137 Generate the code to test it and jump to the right place. */
5140 expand_end_case (orig_index)
5143 tree minval = NULL_TREE, maxval = NULL_TREE, range = NULL_TREE, orig_minval;
5144 rtx default_label = 0;
5145 register struct case_node *n;
5153 register struct nesting *thiscase = case_stack;
5154 tree index_expr, index_type;
5157 /* Don't crash due to previous errors. */
5158 if (thiscase == NULL)
5161 table_label = gen_label_rtx ();
5162 index_expr = thiscase->data.case_stmt.index_expr;
5163 index_type = TREE_TYPE (index_expr);
5164 unsignedp = TREE_UNSIGNED (index_type);
5166 do_pending_stack_adjust ();
5168 /* This might get an spurious warning in the presence of a syntax error;
5169 it could be fixed by moving the call to check_seenlabel after the
5170 check for error_mark_node, and copying the code of check_seenlabel that
5171 deals with case_stack->data.case_stmt.line_number_status /
5172 restore_line_number_status in front of the call to end_cleanup_deferral;
5173 However, this might miss some useful warnings in the presence of
5174 non-syntax errors. */
5177 /* An ERROR_MARK occurs for various reasons including invalid data type. */
5178 if (index_type != error_mark_node)
5180 /* If switch expression was an enumerated type, check that all
5181 enumeration literals are covered by the cases.
5182 No sense trying this if there's a default case, however. */
5184 if (!thiscase->data.case_stmt.default_label
5185 && TREE_CODE (TREE_TYPE (orig_index)) == ENUMERAL_TYPE
5186 && TREE_CODE (index_expr) != INTEGER_CST)
5187 check_for_full_enumeration_handling (TREE_TYPE (orig_index));
5189 /* If we don't have a default-label, create one here,
5190 after the body of the switch. */
5191 if (thiscase->data.case_stmt.default_label == 0)
5193 thiscase->data.case_stmt.default_label
5194 = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
5195 expand_label (thiscase->data.case_stmt.default_label);
5197 default_label = label_rtx (thiscase->data.case_stmt.default_label);
5199 before_case = get_last_insn ();
5201 if (thiscase->data.case_stmt.case_list
5202 && thiscase->data.case_stmt.case_list->left)
5203 thiscase->data.case_stmt.case_list
5204 = case_tree2list (thiscase->data.case_stmt.case_list, 0);
5206 /* Simplify the case-list before we count it. */
5207 group_case_nodes (thiscase->data.case_stmt.case_list);
5209 /* Get upper and lower bounds of case values.
5210 Also convert all the case values to the index expr's data type. */
5213 for (n = thiscase->data.case_stmt.case_list; n; n = n->right)
5215 /* Check low and high label values are integers. */
5216 if (TREE_CODE (n->low) != INTEGER_CST)
5218 if (TREE_CODE (n->high) != INTEGER_CST)
5221 n->low = convert (index_type, n->low);
5222 n->high = convert (index_type, n->high);
5224 /* Count the elements and track the largest and smallest
5225 of them (treating them as signed even if they are not). */
5233 if (INT_CST_LT (n->low, minval))
5235 if (INT_CST_LT (maxval, n->high))
5238 /* A range counts double, since it requires two compares. */
5239 if (! tree_int_cst_equal (n->low, n->high))
5243 orig_minval = minval;
5245 /* Compute span of values. */
5247 range = fold (build (MINUS_EXPR, index_type, maxval, minval));
5249 end_cleanup_deferral ();
5253 expand_expr (index_expr, const0_rtx, VOIDmode, 0);
5255 emit_jump (default_label);
5258 /* If range of values is much bigger than number of values,
5259 make a sequence of conditional branches instead of a dispatch.
5260 If the switch-index is a constant, do it this way
5261 because we can optimize it. */
5263 #ifndef CASE_VALUES_THRESHOLD
5265 #define CASE_VALUES_THRESHOLD (HAVE_casesi ? 4 : 5)
5267 /* If machine does not have a case insn that compares the
5268 bounds, this means extra overhead for dispatch tables
5269 which raises the threshold for using them. */
5270 #define CASE_VALUES_THRESHOLD 5
5271 #endif /* HAVE_casesi */
5272 #endif /* CASE_VALUES_THRESHOLD */
5274 else if (count < CASE_VALUES_THRESHOLD
5275 || compare_tree_int (range, 10 * count) > 0
5276 /* RANGE may be signed, and really large ranges will show up
5277 as negative numbers. */
5278 || compare_tree_int (range, 0) < 0
5279 #ifndef ASM_OUTPUT_ADDR_DIFF_ELT
5282 || TREE_CODE (index_expr) == INTEGER_CST
5283 /* These will reduce to a constant. */
5284 || (TREE_CODE (index_expr) == CALL_EXPR
5285 && TREE_CODE (TREE_OPERAND (index_expr, 0)) == ADDR_EXPR
5286 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (index_expr, 0), 0)) == FUNCTION_DECL
5287 && DECL_BUILT_IN_CLASS (TREE_OPERAND (TREE_OPERAND (index_expr, 0), 0)) == BUILT_IN_NORMAL
5288 && DECL_FUNCTION_CODE (TREE_OPERAND (TREE_OPERAND (index_expr, 0), 0)) == BUILT_IN_CLASSIFY_TYPE)
5289 || (TREE_CODE (index_expr) == COMPOUND_EXPR
5290 && TREE_CODE (TREE_OPERAND (index_expr, 1)) == INTEGER_CST))
5292 index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
5294 /* If the index is a short or char that we do not have
5295 an insn to handle comparisons directly, convert it to
5296 a full integer now, rather than letting each comparison
5297 generate the conversion. */
5299 if (GET_MODE_CLASS (GET_MODE (index)) == MODE_INT
5300 && (cmp_optab->handlers[(int) GET_MODE (index)].insn_code
5301 == CODE_FOR_nothing))
5303 enum machine_mode wider_mode;
5304 for (wider_mode = GET_MODE (index); wider_mode != VOIDmode;
5305 wider_mode = GET_MODE_WIDER_MODE (wider_mode))
5306 if (cmp_optab->handlers[(int) wider_mode].insn_code
5307 != CODE_FOR_nothing)
5309 index = convert_to_mode (wider_mode, index, unsignedp);
5315 do_pending_stack_adjust ();
5317 index = protect_from_queue (index, 0);
5318 if (GET_CODE (index) == MEM)
5319 index = copy_to_reg (index);
5320 if (GET_CODE (index) == CONST_INT
5321 || TREE_CODE (index_expr) == INTEGER_CST)
5323 /* Make a tree node with the proper constant value
5324 if we don't already have one. */
5325 if (TREE_CODE (index_expr) != INTEGER_CST)
5328 = build_int_2 (INTVAL (index),
5329 unsignedp || INTVAL (index) >= 0 ? 0 : -1);
5330 index_expr = convert (index_type, index_expr);
5333 /* For constant index expressions we need only
5334 issue a unconditional branch to the appropriate
5335 target code. The job of removing any unreachable
5336 code is left to the optimisation phase if the
5337 "-O" option is specified. */
5338 for (n = thiscase->data.case_stmt.case_list; n; n = n->right)
5339 if (! tree_int_cst_lt (index_expr, n->low)
5340 && ! tree_int_cst_lt (n->high, index_expr))
5344 emit_jump (label_rtx (n->code_label));
5346 emit_jump (default_label);
5350 /* If the index expression is not constant we generate
5351 a binary decision tree to select the appropriate
5352 target code. This is done as follows:
5354 The list of cases is rearranged into a binary tree,
5355 nearly optimal assuming equal probability for each case.
5357 The tree is transformed into RTL, eliminating
5358 redundant test conditions at the same time.
5360 If program flow could reach the end of the
5361 decision tree an unconditional jump to the
5362 default code is emitted. */
5365 = (TREE_CODE (TREE_TYPE (orig_index)) != ENUMERAL_TYPE
5366 && estimate_case_costs (thiscase->data.case_stmt.case_list));
5367 balance_case_nodes (&thiscase->data.case_stmt.case_list, NULL);
5368 emit_case_nodes (index, thiscase->data.case_stmt.case_list,
5369 default_label, index_type);
5370 emit_jump_if_reachable (default_label);
5379 enum machine_mode index_mode = SImode;
5380 int index_bits = GET_MODE_BITSIZE (index_mode);
5382 enum machine_mode op_mode;
5384 /* Convert the index to SImode. */
5385 if (GET_MODE_BITSIZE (TYPE_MODE (index_type))
5386 > GET_MODE_BITSIZE (index_mode))
5388 enum machine_mode omode = TYPE_MODE (index_type);
5389 rtx rangertx = expand_expr (range, NULL_RTX, VOIDmode, 0);
5391 /* We must handle the endpoints in the original mode. */
5392 index_expr = build (MINUS_EXPR, index_type,
5393 index_expr, minval);
5394 minval = integer_zero_node;
5395 index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
5396 emit_cmp_and_jump_insns (rangertx, index, LTU, NULL_RTX,
5397 omode, 1, 0, default_label);
5398 /* Now we can safely truncate. */
5399 index = convert_to_mode (index_mode, index, 0);
5403 if (TYPE_MODE (index_type) != index_mode)
5405 index_expr = convert (type_for_size (index_bits, 0),
5407 index_type = TREE_TYPE (index_expr);
5410 index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
5413 index = protect_from_queue (index, 0);
5414 do_pending_stack_adjust ();
5416 op_mode = insn_data[(int) CODE_FOR_casesi].operand[0].mode;
5417 if (! (*insn_data[(int) CODE_FOR_casesi].operand[0].predicate)
5419 index = copy_to_mode_reg (op_mode, index);
5421 op1 = expand_expr (minval, NULL_RTX, VOIDmode, 0);
5423 op_mode = insn_data[(int) CODE_FOR_casesi].operand[1].mode;
5424 op1 = convert_modes (op_mode, TYPE_MODE (TREE_TYPE (minval)),
5425 op1, TREE_UNSIGNED (TREE_TYPE (minval)));
5426 if (! (*insn_data[(int) CODE_FOR_casesi].operand[1].predicate)
5428 op1 = copy_to_mode_reg (op_mode, op1);
5430 op2 = expand_expr (range, NULL_RTX, VOIDmode, 0);
5432 op_mode = insn_data[(int) CODE_FOR_casesi].operand[2].mode;
5433 op2 = convert_modes (op_mode, TYPE_MODE (TREE_TYPE (range)),
5434 op2, TREE_UNSIGNED (TREE_TYPE (range)));
5435 if (! (*insn_data[(int) CODE_FOR_casesi].operand[2].predicate)
5437 op2 = copy_to_mode_reg (op_mode, op2);
5439 emit_jump_insn (gen_casesi (index, op1, op2,
5440 table_label, default_label));
5444 #ifdef HAVE_tablejump
5445 if (! win && HAVE_tablejump)
5447 index_type = thiscase->data.case_stmt.nominal_type;
5448 index_expr = fold (build (MINUS_EXPR, index_type,
5449 convert (index_type, index_expr),
5450 convert (index_type, minval)));
5451 index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
5453 index = protect_from_queue (index, 0);
5454 do_pending_stack_adjust ();
5456 do_tablejump (index, TYPE_MODE (index_type),
5457 convert_modes (TYPE_MODE (index_type),
5458 TYPE_MODE (TREE_TYPE (range)),
5459 expand_expr (range, NULL_RTX,
5461 TREE_UNSIGNED (TREE_TYPE (range))),
5462 table_label, default_label);
5469 /* Get table of labels to jump to, in order of case index. */
5471 ncases = TREE_INT_CST_LOW (range) + 1;
5472 labelvec = (rtx *) alloca (ncases * sizeof (rtx));
5473 memset ((char *) labelvec, 0, ncases * sizeof (rtx));
5475 for (n = thiscase->data.case_stmt.case_list; n; n = n->right)
5477 register HOST_WIDE_INT i
5478 = TREE_INT_CST_LOW (n->low) - TREE_INT_CST_LOW (orig_minval);
5483 = gen_rtx_LABEL_REF (Pmode, label_rtx (n->code_label));
5484 if (i + TREE_INT_CST_LOW (orig_minval)
5485 == TREE_INT_CST_LOW (n->high))
5491 /* Fill in the gaps with the default. */
5492 for (i = 0; i < ncases; i++)
5493 if (labelvec[i] == 0)
5494 labelvec[i] = gen_rtx_LABEL_REF (Pmode, default_label);
5496 /* Output the table */
5497 emit_label (table_label);
5499 if (CASE_VECTOR_PC_RELATIVE || flag_pic)
5500 emit_jump_insn (gen_rtx_ADDR_DIFF_VEC (CASE_VECTOR_MODE,
5501 gen_rtx_LABEL_REF (Pmode, table_label),
5502 gen_rtvec_v (ncases, labelvec),
5503 const0_rtx, const0_rtx));
5505 emit_jump_insn (gen_rtx_ADDR_VEC (CASE_VECTOR_MODE,
5506 gen_rtvec_v (ncases, labelvec)));
5508 /* If the case insn drops through the table,
5509 after the table we must jump to the default-label.
5510 Otherwise record no drop-through after the table. */
5511 #ifdef CASE_DROPS_THROUGH
5512 emit_jump (default_label);
5518 before_case = squeeze_notes (NEXT_INSN (before_case), get_last_insn ());
5519 reorder_insns (before_case, get_last_insn (),
5520 thiscase->data.case_stmt.start);
5523 end_cleanup_deferral ();
5525 if (thiscase->exit_label)
5526 emit_label (thiscase->exit_label);
5528 free_case_nodes (case_stack->data.case_stmt.case_list);
5529 POPSTACK (case_stack);
5534 /* Convert the tree NODE into a list linked by the right field, with the left
5535 field zeroed. RIGHT is used for recursion; it is a list to be placed
5536 rightmost in the resulting list. */
5538 static struct case_node *
5539 case_tree2list (node, right)
5540 struct case_node *node, *right;
5542 struct case_node *left;
5545 right = case_tree2list (node->right, right);
5547 node->right = right;
5548 if ((left = node->left))
5551 return case_tree2list (left, node);
5557 /* Generate code to jump to LABEL if OP1 and OP2 are equal. */
5560 do_jump_if_equal (op1, op2, label, unsignedp)
5561 rtx op1, op2, label;
5564 if (GET_CODE (op1) == CONST_INT
5565 && GET_CODE (op2) == CONST_INT)
5567 if (INTVAL (op1) == INTVAL (op2))
5572 enum machine_mode mode = GET_MODE (op1);
5573 if (mode == VOIDmode)
5574 mode = GET_MODE (op2);
5575 emit_cmp_and_jump_insns (op1, op2, EQ, NULL_RTX, mode, unsignedp,
5580 /* Not all case values are encountered equally. This function
5581 uses a heuristic to weight case labels, in cases where that
5582 looks like a reasonable thing to do.
5584 Right now, all we try to guess is text, and we establish the
5587 chars above space: 16
5596 If we find any cases in the switch that are not either -1 or in the range
5597 of valid ASCII characters, or are control characters other than those
5598 commonly used with "\", don't treat this switch scanning text.
5600 Return 1 if these nodes are suitable for cost estimation, otherwise
5604 estimate_case_costs (node)
5607 tree min_ascii = integer_minus_one_node;
5608 tree max_ascii = convert (TREE_TYPE (node->high), build_int_2 (127, 0));
5612 /* If we haven't already made the cost table, make it now. Note that the
5613 lower bound of the table is -1, not zero. */
5615 if (! cost_table_initialized)
5617 cost_table_initialized = 1;
5619 for (i = 0; i < 128; i++)
5622 COST_TABLE (i) = 16;
5623 else if (ISPUNCT (i))
5625 else if (ISCNTRL (i))
5626 COST_TABLE (i) = -1;
5629 COST_TABLE (' ') = 8;
5630 COST_TABLE ('\t') = 4;
5631 COST_TABLE ('\0') = 4;
5632 COST_TABLE ('\n') = 2;
5633 COST_TABLE ('\f') = 1;
5634 COST_TABLE ('\v') = 1;
5635 COST_TABLE ('\b') = 1;
5638 /* See if all the case expressions look like text. It is text if the
5639 constant is >= -1 and the highest constant is <= 127. Do all comparisons
5640 as signed arithmetic since we don't want to ever access cost_table with a
5641 value less than -1. Also check that none of the constants in a range
5642 are strange control characters. */
5644 for (n = node; n; n = n->right)
5646 if ((INT_CST_LT (n->low, min_ascii)) || INT_CST_LT (max_ascii, n->high))
5649 for (i = (HOST_WIDE_INT) TREE_INT_CST_LOW (n->low);
5650 i <= (HOST_WIDE_INT) TREE_INT_CST_LOW (n->high); i++)
5651 if (COST_TABLE (i) < 0)
5655 /* All interesting values are within the range of interesting
5656 ASCII characters. */
5660 /* Scan an ordered list of case nodes
5661 combining those with consecutive values or ranges.
5663 Eg. three separate entries 1: 2: 3: become one entry 1..3: */
5666 group_case_nodes (head)
5669 case_node_ptr node = head;
5673 rtx lb = next_real_insn (label_rtx (node->code_label));
5675 case_node_ptr np = node;
5677 /* Try to group the successors of NODE with NODE. */
5678 while (((np = np->right) != 0)
5679 /* Do they jump to the same place? */
5680 && ((lb2 = next_real_insn (label_rtx (np->code_label))) == lb
5681 || (lb != 0 && lb2 != 0
5682 && simplejump_p (lb)
5683 && simplejump_p (lb2)
5684 && rtx_equal_p (SET_SRC (PATTERN (lb)),
5685 SET_SRC (PATTERN (lb2)))))
5686 /* Are their ranges consecutive? */
5687 && tree_int_cst_equal (np->low,
5688 fold (build (PLUS_EXPR,
5689 TREE_TYPE (node->high),
5692 /* An overflow is not consecutive. */
5693 && tree_int_cst_lt (node->high,
5694 fold (build (PLUS_EXPR,
5695 TREE_TYPE (node->high),
5697 integer_one_node))))
5699 node->high = np->high;
5701 /* NP is the first node after NODE which can't be grouped with it.
5702 Delete the nodes in between, and move on to that node. */
5708 /* Take an ordered list of case nodes
5709 and transform them into a near optimal binary tree,
5710 on the assumption that any target code selection value is as
5711 likely as any other.
5713 The transformation is performed by splitting the ordered
5714 list into two equal sections plus a pivot. The parts are
5715 then attached to the pivot as left and right branches. Each
5716 branch is then transformed recursively. */
5719 balance_case_nodes (head, parent)
5720 case_node_ptr *head;
5721 case_node_ptr parent;
5723 register case_node_ptr np;
5731 register case_node_ptr *npp;
5734 /* Count the number of entries on branch. Also count the ranges. */
5738 if (!tree_int_cst_equal (np->low, np->high))
5742 cost += COST_TABLE (TREE_INT_CST_LOW (np->high));
5746 cost += COST_TABLE (TREE_INT_CST_LOW (np->low));
5754 /* Split this list if it is long enough for that to help. */
5759 /* Find the place in the list that bisects the list's total cost,
5760 Here I gets half the total cost. */
5765 /* Skip nodes while their cost does not reach that amount. */
5766 if (!tree_int_cst_equal ((*npp)->low, (*npp)->high))
5767 i -= COST_TABLE (TREE_INT_CST_LOW ((*npp)->high));
5768 i -= COST_TABLE (TREE_INT_CST_LOW ((*npp)->low));
5771 npp = &(*npp)->right;
5776 /* Leave this branch lopsided, but optimize left-hand
5777 side and fill in `parent' fields for right-hand side. */
5779 np->parent = parent;
5780 balance_case_nodes (&np->left, np);
5781 for (; np->right; np = np->right)
5782 np->right->parent = np;
5786 /* If there are just three nodes, split at the middle one. */
5788 npp = &(*npp)->right;
5791 /* Find the place in the list that bisects the list's total cost,
5792 where ranges count as 2.
5793 Here I gets half the total cost. */
5794 i = (i + ranges + 1) / 2;
5797 /* Skip nodes while their cost does not reach that amount. */
5798 if (!tree_int_cst_equal ((*npp)->low, (*npp)->high))
5803 npp = &(*npp)->right;
5808 np->parent = parent;
5811 /* Optimize each of the two split parts. */
5812 balance_case_nodes (&np->left, np);
5813 balance_case_nodes (&np->right, np);
5817 /* Else leave this branch as one level,
5818 but fill in `parent' fields. */
5820 np->parent = parent;
5821 for (; np->right; np = np->right)
5822 np->right->parent = np;
5827 /* Search the parent sections of the case node tree
5828 to see if a test for the lower bound of NODE would be redundant.
5829 INDEX_TYPE is the type of the index expression.
5831 The instructions to generate the case decision tree are
5832 output in the same order as nodes are processed so it is
5833 known that if a parent node checks the range of the current
5834 node minus one that the current node is bounded at its lower
5835 span. Thus the test would be redundant. */
5838 node_has_low_bound (node, index_type)
5843 case_node_ptr pnode;
5845 /* If the lower bound of this node is the lowest value in the index type,
5846 we need not test it. */
5848 if (tree_int_cst_equal (node->low, TYPE_MIN_VALUE (index_type)))
5851 /* If this node has a left branch, the value at the left must be less
5852 than that at this node, so it cannot be bounded at the bottom and
5853 we need not bother testing any further. */
5858 low_minus_one = fold (build (MINUS_EXPR, TREE_TYPE (node->low),
5859 node->low, integer_one_node));
5861 /* If the subtraction above overflowed, we can't verify anything.
5862 Otherwise, look for a parent that tests our value - 1. */
5864 if (! tree_int_cst_lt (low_minus_one, node->low))
5867 for (pnode = node->parent; pnode; pnode = pnode->parent)
5868 if (tree_int_cst_equal (low_minus_one, pnode->high))
5874 /* Search the parent sections of the case node tree
5875 to see if a test for the upper bound of NODE would be redundant.
5876 INDEX_TYPE is the type of the index expression.
5878 The instructions to generate the case decision tree are
5879 output in the same order as nodes are processed so it is
5880 known that if a parent node checks the range of the current
5881 node plus one that the current node is bounded at its upper
5882 span. Thus the test would be redundant. */
5885 node_has_high_bound (node, index_type)
5890 case_node_ptr pnode;
5892 /* If there is no upper bound, obviously no test is needed. */
5894 if (TYPE_MAX_VALUE (index_type) == NULL)
5897 /* If the upper bound of this node is the highest value in the type
5898 of the index expression, we need not test against it. */
5900 if (tree_int_cst_equal (node->high, TYPE_MAX_VALUE (index_type)))
5903 /* If this node has a right branch, the value at the right must be greater
5904 than that at this node, so it cannot be bounded at the top and
5905 we need not bother testing any further. */
5910 high_plus_one = fold (build (PLUS_EXPR, TREE_TYPE (node->high),
5911 node->high, integer_one_node));
5913 /* If the addition above overflowed, we can't verify anything.
5914 Otherwise, look for a parent that tests our value + 1. */
5916 if (! tree_int_cst_lt (node->high, high_plus_one))
5919 for (pnode = node->parent; pnode; pnode = pnode->parent)
5920 if (tree_int_cst_equal (high_plus_one, pnode->low))
5926 /* Search the parent sections of the
5927 case node tree to see if both tests for the upper and lower
5928 bounds of NODE would be redundant. */
5931 node_is_bounded (node, index_type)
5935 return (node_has_low_bound (node, index_type)
5936 && node_has_high_bound (node, index_type));
5939 /* Emit an unconditional jump to LABEL unless it would be dead code. */
5942 emit_jump_if_reachable (label)
5945 if (GET_CODE (get_last_insn ()) != BARRIER)
5949 /* Emit step-by-step code to select a case for the value of INDEX.
5950 The thus generated decision tree follows the form of the
5951 case-node binary tree NODE, whose nodes represent test conditions.
5952 INDEX_TYPE is the type of the index of the switch.
5954 Care is taken to prune redundant tests from the decision tree
5955 by detecting any boundary conditions already checked by
5956 emitted rtx. (See node_has_high_bound, node_has_low_bound
5957 and node_is_bounded, above.)
5959 Where the test conditions can be shown to be redundant we emit
5960 an unconditional jump to the target code. As a further
5961 optimization, the subordinates of a tree node are examined to
5962 check for bounded nodes. In this case conditional and/or
5963 unconditional jumps as a result of the boundary check for the
5964 current node are arranged to target the subordinates associated
5965 code for out of bound conditions on the current node.
5967 We can assume that when control reaches the code generated here,
5968 the index value has already been compared with the parents
5969 of this node, and determined to be on the same side of each parent
5970 as this node is. Thus, if this node tests for the value 51,
5971 and a parent tested for 52, we don't need to consider
5972 the possibility of a value greater than 51. If another parent
5973 tests for the value 50, then this node need not test anything. */
5976 emit_case_nodes (index, node, default_label, index_type)
5982 /* If INDEX has an unsigned type, we must make unsigned branches. */
5983 int unsignedp = TREE_UNSIGNED (index_type);
5984 enum machine_mode mode = GET_MODE (index);
5985 enum machine_mode imode = TYPE_MODE (index_type);
5987 /* See if our parents have already tested everything for us.
5988 If they have, emit an unconditional jump for this node. */
5989 if (node_is_bounded (node, index_type))
5990 emit_jump (label_rtx (node->code_label));
5992 else if (tree_int_cst_equal (node->low, node->high))
5994 /* Node is single valued. First see if the index expression matches
5995 this node and then check our children, if any. */
5997 do_jump_if_equal (index,
5998 convert_modes (mode, imode,
5999 expand_expr (node->low, NULL_RTX,
6002 label_rtx (node->code_label), unsignedp);
6004 if (node->right != 0 && node->left != 0)
6006 /* This node has children on both sides.
6007 Dispatch to one side or the other
6008 by comparing the index value with this node's value.
6009 If one subtree is bounded, check that one first,
6010 so we can avoid real branches in the tree. */
6012 if (node_is_bounded (node->right, index_type))
6014 emit_cmp_and_jump_insns (index,
6017 expand_expr (node->high, NULL_RTX,
6020 GT, NULL_RTX, mode, unsignedp, 0,
6021 label_rtx (node->right->code_label));
6022 emit_case_nodes (index, node->left, default_label, index_type);
6025 else if (node_is_bounded (node->left, index_type))
6027 emit_cmp_and_jump_insns (index,
6030 expand_expr (node->high, NULL_RTX,
6033 LT, NULL_RTX, mode, unsignedp, 0,
6034 label_rtx (node->left->code_label));
6035 emit_case_nodes (index, node->right, default_label, index_type);
6040 /* Neither node is bounded. First distinguish the two sides;
6041 then emit the code for one side at a time. */
6043 tree test_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
6045 /* See if the value is on the right. */
6046 emit_cmp_and_jump_insns (index,
6049 expand_expr (node->high, NULL_RTX,
6052 GT, NULL_RTX, mode, unsignedp, 0,
6053 label_rtx (test_label));
6055 /* Value must be on the left.
6056 Handle the left-hand subtree. */
6057 emit_case_nodes (index, node->left, default_label, index_type);
6058 /* If left-hand subtree does nothing,
6060 emit_jump_if_reachable (default_label);
6062 /* Code branches here for the right-hand subtree. */
6063 expand_label (test_label);
6064 emit_case_nodes (index, node->right, default_label, index_type);
6068 else if (node->right != 0 && node->left == 0)
6070 /* Here we have a right child but no left so we issue conditional
6071 branch to default and process the right child.
6073 Omit the conditional branch to default if we it avoid only one
6074 right child; it costs too much space to save so little time. */
6076 if (node->right->right || node->right->left
6077 || !tree_int_cst_equal (node->right->low, node->right->high))
6079 if (!node_has_low_bound (node, index_type))
6081 emit_cmp_and_jump_insns (index,
6084 expand_expr (node->high, NULL_RTX,
6087 LT, NULL_RTX, mode, unsignedp, 0,
6091 emit_case_nodes (index, node->right, default_label, index_type);
6094 /* We cannot process node->right normally
6095 since we haven't ruled out the numbers less than
6096 this node's value. So handle node->right explicitly. */
6097 do_jump_if_equal (index,
6100 expand_expr (node->right->low, NULL_RTX,
6103 label_rtx (node->right->code_label), unsignedp);
6106 else if (node->right == 0 && node->left != 0)
6108 /* Just one subtree, on the left. */
6110 #if 0 /* The following code and comment were formerly part
6111 of the condition here, but they didn't work
6112 and I don't understand what the idea was. -- rms. */
6113 /* If our "most probable entry" is less probable
6114 than the default label, emit a jump to
6115 the default label using condition codes
6116 already lying around. With no right branch,
6117 a branch-greater-than will get us to the default
6120 && COST_TABLE (TREE_INT_CST_LOW (node->high)) < 12)
6123 if (node->left->left || node->left->right
6124 || !tree_int_cst_equal (node->left->low, node->left->high))
6126 if (!node_has_high_bound (node, index_type))
6128 emit_cmp_and_jump_insns (index,
6131 expand_expr (node->high, NULL_RTX,
6134 GT, NULL_RTX, mode, unsignedp, 0,
6138 emit_case_nodes (index, node->left, default_label, index_type);
6141 /* We cannot process node->left normally
6142 since we haven't ruled out the numbers less than
6143 this node's value. So handle node->left explicitly. */
6144 do_jump_if_equal (index,
6147 expand_expr (node->left->low, NULL_RTX,
6150 label_rtx (node->left->code_label), unsignedp);
6155 /* Node is a range. These cases are very similar to those for a single
6156 value, except that we do not start by testing whether this node
6157 is the one to branch to. */
6159 if (node->right != 0 && node->left != 0)
6161 /* Node has subtrees on both sides.
6162 If the right-hand subtree is bounded,
6163 test for it first, since we can go straight there.
6164 Otherwise, we need to make a branch in the control structure,
6165 then handle the two subtrees. */
6166 tree test_label = 0;
6168 if (node_is_bounded (node->right, index_type))
6169 /* Right hand node is fully bounded so we can eliminate any
6170 testing and branch directly to the target code. */
6171 emit_cmp_and_jump_insns (index,
6174 expand_expr (node->high, NULL_RTX,
6177 GT, NULL_RTX, mode, unsignedp, 0,
6178 label_rtx (node->right->code_label));
6181 /* Right hand node requires testing.
6182 Branch to a label where we will handle it later. */
6184 test_label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
6185 emit_cmp_and_jump_insns (index,
6188 expand_expr (node->high, NULL_RTX,
6191 GT, NULL_RTX, mode, unsignedp, 0,
6192 label_rtx (test_label));
6195 /* Value belongs to this node or to the left-hand subtree. */
6197 emit_cmp_and_jump_insns (index,
6200 expand_expr (node->low, NULL_RTX,
6203 GE, NULL_RTX, mode, unsignedp, 0,
6204 label_rtx (node->code_label));
6206 /* Handle the left-hand subtree. */
6207 emit_case_nodes (index, node->left, default_label, index_type);
6209 /* If right node had to be handled later, do that now. */
6213 /* If the left-hand subtree fell through,
6214 don't let it fall into the right-hand subtree. */
6215 emit_jump_if_reachable (default_label);
6217 expand_label (test_label);
6218 emit_case_nodes (index, node->right, default_label, index_type);
6222 else if (node->right != 0 && node->left == 0)
6224 /* Deal with values to the left of this node,
6225 if they are possible. */
6226 if (!node_has_low_bound (node, index_type))
6228 emit_cmp_and_jump_insns (index,
6231 expand_expr (node->low, NULL_RTX,
6234 LT, NULL_RTX, mode, unsignedp, 0,
6238 /* Value belongs to this node or to the right-hand subtree. */
6240 emit_cmp_and_jump_insns (index,
6243 expand_expr (node->high, NULL_RTX,
6246 LE, NULL_RTX, mode, unsignedp, 0,
6247 label_rtx (node->code_label));
6249 emit_case_nodes (index, node->right, default_label, index_type);
6252 else if (node->right == 0 && node->left != 0)
6254 /* Deal with values to the right of this node,
6255 if they are possible. */
6256 if (!node_has_high_bound (node, index_type))
6258 emit_cmp_and_jump_insns (index,
6261 expand_expr (node->high, NULL_RTX,
6264 GT, NULL_RTX, mode, unsignedp, 0,
6268 /* Value belongs to this node or to the left-hand subtree. */
6270 emit_cmp_and_jump_insns (index,
6273 expand_expr (node->low, NULL_RTX,
6276 GE, NULL_RTX, mode, unsignedp, 0,
6277 label_rtx (node->code_label));
6279 emit_case_nodes (index, node->left, default_label, index_type);
6284 /* Node has no children so we check low and high bounds to remove
6285 redundant tests. Only one of the bounds can exist,
6286 since otherwise this node is bounded--a case tested already. */
6288 if (!node_has_high_bound (node, index_type))
6290 emit_cmp_and_jump_insns (index,
6293 expand_expr (node->high, NULL_RTX,
6296 GT, NULL_RTX, mode, unsignedp, 0,
6300 if (!node_has_low_bound (node, index_type))
6302 emit_cmp_and_jump_insns (index,
6305 expand_expr (node->low, NULL_RTX,
6308 LT, NULL_RTX, mode, unsignedp, 0,
6312 emit_jump (label_rtx (node->code_label));