1 /* Expands front end tree to back end RTL for GNU C-Compiler
2 Copyright (C) 1987, 88, 89, 92-98, 1999 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 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. */
44 #include "insn-flags.h"
45 #include "insn-config.h"
46 #include "insn-codes.h"
48 #include "hard-reg-set.h"
57 #define obstack_chunk_alloc xmalloc
58 #define obstack_chunk_free free
59 struct obstack stmt_obstack
;
61 /* Assume that case vectors are not pc-relative. */
62 #ifndef CASE_VECTOR_PC_RELATIVE
63 #define CASE_VECTOR_PC_RELATIVE 0
66 /* Each time we expand the end of a binding contour (in `expand_end_bindings')
67 and we emit a new NOTE_INSN_BLOCK_END note, we save a pointer to it here.
68 This is used by the `remember_end_note' function to record the endpoint
69 of each generated block in its associated BLOCK node. */
71 static rtx last_block_end_note
;
73 /* Functions and data structures for expanding case statements. */
75 /* Case label structure, used to hold info on labels within case
76 statements. We handle "range" labels; for a single-value label
77 as in C, the high and low limits are the same.
79 An AVL tree of case nodes is initially created, and later transformed
80 to a list linked via the RIGHT fields in the nodes. Nodes with
81 higher case values are later in the list.
83 Switch statements can be output in one of two forms. A branch table
84 is used if there are more than a few labels and the labels are dense
85 within the range between the smallest and largest case value. If a
86 branch table is used, no further manipulations are done with the case
89 The alternative to the use of a branch table is to generate a series
90 of compare and jump insns. When that is done, we use the LEFT, RIGHT,
91 and PARENT fields to hold a binary tree. Initially the tree is
92 totally unbalanced, with everything on the right. We balance the tree
93 with nodes on the left having lower case values than the parent
94 and nodes on the right having higher values. We then output the tree
99 struct case_node
*left
; /* Left son in binary tree */
100 struct case_node
*right
; /* Right son in binary tree; also node chain */
101 struct case_node
*parent
; /* Parent of node in binary tree */
102 tree low
; /* Lowest index value for this label */
103 tree high
; /* Highest index value for this label */
104 tree code_label
; /* Label to jump to when node matches */
108 typedef struct case_node case_node
;
109 typedef struct case_node
*case_node_ptr
;
111 /* These are used by estimate_case_costs and balance_case_nodes. */
113 /* This must be a signed type, and non-ANSI compilers lack signed char. */
114 static short *cost_table
;
115 static int use_cost_table
;
117 /* Stack of control and binding constructs we are currently inside.
119 These constructs begin when you call `expand_start_WHATEVER'
120 and end when you call `expand_end_WHATEVER'. This stack records
121 info about how the construct began that tells the end-function
122 what to do. It also may provide information about the construct
123 to alter the behavior of other constructs within the body.
124 For example, they may affect the behavior of C `break' and `continue'.
126 Each construct gets one `struct nesting' object.
127 All of these objects are chained through the `all' field.
128 `nesting_stack' points to the first object (innermost construct).
129 The position of an entry on `nesting_stack' is in its `depth' field.
131 Each type of construct has its own individual stack.
132 For example, loops have `loop_stack'. Each object points to the
133 next object of the same type through the `next' field.
135 Some constructs are visible to `break' exit-statements and others
136 are not. Which constructs are visible depends on the language.
137 Therefore, the data structure allows each construct to be visible
138 or not, according to the args given when the construct is started.
139 The construct is visible if the `exit_label' field is non-null.
140 In that case, the value should be a CODE_LABEL rtx. */
145 struct nesting
*next
;
150 /* For conds (if-then and if-then-else statements). */
153 /* Label for the end of the if construct.
154 There is none if EXITFLAG was not set
155 and no `else' has been seen yet. */
157 /* Label for the end of this alternative.
158 This may be the end of the if or the next else/elseif. */
164 /* Label at the top of the loop; place to loop back to. */
166 /* Label at the end of the whole construct. */
168 /* Label before a jump that branches to the end of the whole
169 construct. This is where destructors go if any. */
171 /* Label for `continue' statement to jump to;
172 this is in front of the stepper of the loop. */
175 /* For variable binding contours. */
178 /* Sequence number of this binding contour within the function,
179 in order of entry. */
180 int block_start_count
;
181 /* Nonzero => value to restore stack to on exit. */
183 /* The NOTE that starts this contour.
184 Used by expand_goto to check whether the destination
185 is within each contour or not. */
187 /* Innermost containing binding contour that has a stack level. */
188 struct nesting
*innermost_stack_block
;
189 /* List of cleanups to be run on exit from this contour.
190 This is a list of expressions to be evaluated.
191 The TREE_PURPOSE of each link is the ..._DECL node
192 which the cleanup pertains to. */
194 /* List of cleanup-lists of blocks containing this block,
195 as they were at the locus where this block appears.
196 There is an element for each containing block,
197 ordered innermost containing block first.
198 The tail of this list can be 0,
199 if all remaining elements would be empty lists.
200 The element's TREE_VALUE is the cleanup-list of that block,
201 which may be null. */
203 /* Chain of labels defined inside this binding contour.
204 For contours that have stack levels or cleanups. */
205 struct label_chain
*label_chain
;
206 /* Number of function calls seen, as of start of this block. */
207 int n_function_calls
;
208 /* Nonzero if this is associated with a EH region. */
209 int exception_region
;
210 /* The saved target_temp_slot_level from our outer block.
211 We may reset target_temp_slot_level to be the level of
212 this block, if that is done, target_temp_slot_level
213 reverts to the saved target_temp_slot_level at the very
215 int block_target_temp_slot_level
;
216 /* True if we are currently emitting insns in an area of
217 output code that is controlled by a conditional
218 expression. This is used by the cleanup handling code to
219 generate conditional cleanup actions. */
220 int conditional_code
;
221 /* A place to move the start of the exception region for any
222 of the conditional cleanups, must be at the end or after
223 the start of the last unconditional cleanup, and before any
224 conditional branch points. */
225 rtx last_unconditional_cleanup
;
226 /* When in a conditional context, this is the specific
227 cleanup list associated with last_unconditional_cleanup,
228 where we place the conditionalized cleanups. */
231 /* For switch (C) or case (Pascal) statements,
232 and also for dummies (see `expand_start_case_dummy'). */
235 /* The insn after which the case dispatch should finally
236 be emitted. Zero for a dummy. */
238 /* A list of case labels; it is first built as an AVL tree.
239 During expand_end_case, this is converted to a list, and may be
240 rearranged into a nearly balanced binary tree. */
241 struct case_node
*case_list
;
242 /* Label to jump to if no case matches. */
244 /* The expression to be dispatched on. */
246 /* Type that INDEX_EXPR should be converted to. */
248 /* Number of range exprs in case statement. */
250 /* Name of this kind of statement, for warnings. */
251 const char *printname
;
252 /* Used to save no_line_numbers till we see the first case label.
253 We set this to -1 when we see the first case label in this
255 int line_number_status
;
260 /* Allocate and return a new `struct nesting'. */
262 #define ALLOC_NESTING() \
263 (struct nesting *) obstack_alloc (&stmt_obstack, sizeof (struct nesting))
265 /* Pop the nesting stack element by element until we pop off
266 the element which is at the top of STACK.
267 Update all the other stacks, popping off elements from them
268 as we pop them from nesting_stack. */
270 #define POPSTACK(STACK) \
271 do { struct nesting *target = STACK; \
272 struct nesting *this; \
273 do { this = nesting_stack; \
274 if (loop_stack == this) \
275 loop_stack = loop_stack->next; \
276 if (cond_stack == this) \
277 cond_stack = cond_stack->next; \
278 if (block_stack == this) \
279 block_stack = block_stack->next; \
280 if (stack_block_stack == this) \
281 stack_block_stack = stack_block_stack->next; \
282 if (case_stack == this) \
283 case_stack = case_stack->next; \
284 nesting_depth = nesting_stack->depth - 1; \
285 nesting_stack = this->all; \
286 obstack_free (&stmt_obstack, this); } \
287 while (this != target); } while (0)
289 /* In some cases it is impossible to generate code for a forward goto
290 until the label definition is seen. This happens when it may be necessary
291 for the goto to reset the stack pointer: we don't yet know how to do that.
292 So expand_goto puts an entry on this fixup list.
293 Each time a binding contour that resets the stack is exited,
295 If the target label has now been defined, we can insert the proper code. */
299 /* Points to following fixup. */
300 struct goto_fixup
*next
;
301 /* Points to the insn before the jump insn.
302 If more code must be inserted, it goes after this insn. */
304 /* The LABEL_DECL that this jump is jumping to, or 0
305 for break, continue or return. */
307 /* The BLOCK for the place where this goto was found. */
309 /* The CODE_LABEL rtx that this is jumping to. */
311 /* Number of binding contours started in current function
312 before the label reference. */
313 int block_start_count
;
314 /* The outermost stack level that should be restored for this jump.
315 Each time a binding contour that resets the stack is exited,
316 if the target label is *not* yet defined, this slot is updated. */
318 /* List of lists of cleanup expressions to be run by this goto.
319 There is one element for each block that this goto is within.
320 The tail of this list can be 0,
321 if all remaining elements would be empty.
322 The TREE_VALUE contains the cleanup list of that block as of the
323 time this goto was seen.
324 The TREE_ADDRESSABLE flag is 1 for a block that has been exited. */
325 tree cleanup_list_list
;
328 /* Within any binding contour that must restore a stack level,
329 all labels are recorded with a chain of these structures. */
333 /* Points to following fixup. */
334 struct label_chain
*next
;
340 /* Chain of all pending binding contours. */
341 struct nesting
*x_block_stack
;
343 /* If any new stacks are added here, add them to POPSTACKS too. */
345 /* Chain of all pending binding contours that restore stack levels
347 struct nesting
*x_stack_block_stack
;
349 /* Chain of all pending conditional statements. */
350 struct nesting
*x_cond_stack
;
352 /* Chain of all pending loops. */
353 struct nesting
*x_loop_stack
;
355 /* Chain of all pending case or switch statements. */
356 struct nesting
*x_case_stack
;
358 /* Separate chain including all of the above,
359 chained through the `all' field. */
360 struct nesting
*x_nesting_stack
;
362 /* Number of entries on nesting_stack now. */
365 /* Number of binding contours started so far in this function. */
366 int x_block_start_count
;
368 /* Each time we expand an expression-statement,
369 record the expr's type and its RTL value here. */
370 tree x_last_expr_type
;
371 rtx x_last_expr_value
;
373 /* Nonzero if within a ({...}) grouping, in which case we must
374 always compute a value for each expr-stmt in case it is the last one. */
375 int x_expr_stmts_for_value
;
377 /* Filename and line number of last line-number note,
378 whether we actually emitted it or not. */
379 char *x_emit_filename
;
382 struct goto_fixup
*x_goto_fixup_chain
;
385 #define block_stack (current_function->stmt->x_block_stack)
386 #define stack_block_stack (current_function->stmt->x_stack_block_stack)
387 #define cond_stack (current_function->stmt->x_cond_stack)
388 #define loop_stack (current_function->stmt->x_loop_stack)
389 #define case_stack (current_function->stmt->x_case_stack)
390 #define nesting_stack (current_function->stmt->x_nesting_stack)
391 #define nesting_depth (current_function->stmt->x_nesting_depth)
392 #define current_block_start_count (current_function->stmt->x_block_start_count)
393 #define last_expr_type (current_function->stmt->x_last_expr_type)
394 #define last_expr_value (current_function->stmt->x_last_expr_value)
395 #define expr_stmts_for_value (current_function->stmt->x_expr_stmts_for_value)
396 #define emit_filename (current_function->stmt->x_emit_filename)
397 #define emit_lineno (current_function->stmt->x_emit_lineno)
398 #define goto_fixup_chain (current_function->stmt->x_goto_fixup_chain)
400 /* Non-zero if we are using EH to handle cleanus. */
401 static int using_eh_for_cleanups_p
= 0;
404 static int n_occurrences
PROTO((int, const char *));
405 static void expand_goto_internal
PROTO((tree
, rtx
, rtx
));
406 static int expand_fixup
PROTO((tree
, rtx
, rtx
));
407 static rtx expand_nl_handler_label
PROTO((rtx
, rtx
));
408 static void expand_nl_goto_receiver
PROTO((void));
409 static void expand_nl_goto_receivers
PROTO((struct nesting
*));
410 static void fixup_gotos
PROTO((struct nesting
*, rtx
, tree
,
412 static void expand_null_return_1
PROTO((rtx
, int));
413 static void expand_value_return
PROTO((rtx
));
414 static int tail_recursion_args
PROTO((tree
, tree
));
415 static void expand_cleanups
PROTO((tree
, tree
, int, int));
416 static void check_seenlabel
PROTO((void));
417 static void do_jump_if_equal
PROTO((rtx
, rtx
, rtx
, int));
418 static int estimate_case_costs
PROTO((case_node_ptr
));
419 static void group_case_nodes
PROTO((case_node_ptr
));
420 static void balance_case_nodes
PROTO((case_node_ptr
*,
422 static int node_has_low_bound
PROTO((case_node_ptr
, tree
));
423 static int node_has_high_bound
PROTO((case_node_ptr
, tree
));
424 static int node_is_bounded
PROTO((case_node_ptr
, tree
));
425 static void emit_jump_if_reachable
PROTO((rtx
));
426 static void emit_case_nodes
PROTO((rtx
, case_node_ptr
, rtx
, tree
));
427 static int add_case_node
PROTO((tree
, tree
, tree
, tree
*));
428 static struct case_node
*case_tree2list
PROTO((case_node
*, case_node
*));
429 static void mark_cond_nesting
PROTO((struct nesting
*));
430 static void mark_loop_nesting
PROTO((struct nesting
*));
431 static void mark_block_nesting
PROTO((struct nesting
*));
432 static void mark_case_nesting
PROTO((struct nesting
*));
433 static void mark_goto_fixup
PROTO((struct goto_fixup
*));
437 using_eh_for_cleanups ()
439 using_eh_for_cleanups_p
= 1;
442 /* Mark N (known to be a cond-nesting) for GC. */
445 mark_cond_nesting (n
)
450 ggc_mark_rtx (n
->exit_label
);
451 ggc_mark_rtx (n
->data
.cond
.endif_label
);
452 ggc_mark_rtx (n
->data
.cond
.next_label
);
458 /* Mark N (known to be a loop-nesting) for GC. */
461 mark_loop_nesting (n
)
467 ggc_mark_rtx (n
->exit_label
);
468 ggc_mark_rtx (n
->data
.loop
.start_label
);
469 ggc_mark_rtx (n
->data
.loop
.end_label
);
470 ggc_mark_rtx (n
->data
.loop
.alt_end_label
);
471 ggc_mark_rtx (n
->data
.loop
.continue_label
);
477 /* Mark N (known to be a block-nesting) for GC. */
480 mark_block_nesting (n
)
485 struct label_chain
*l
;
487 ggc_mark_rtx (n
->exit_label
);
488 ggc_mark_rtx (n
->data
.block
.stack_level
);
489 ggc_mark_rtx (n
->data
.block
.first_insn
);
490 ggc_mark_tree (n
->data
.block
.cleanups
);
491 ggc_mark_tree (n
->data
.block
.outer_cleanups
);
493 for (l
= n
->data
.block
.label_chain
; l
!= NULL
; l
= l
->next
)
494 ggc_mark_tree (l
->label
);
496 ggc_mark_rtx (n
->data
.block
.last_unconditional_cleanup
);
498 /* ??? cleanup_ptr never points outside the stack, does it? */
504 /* Mark N (known to be a case-nesting) for GC. */
507 mark_case_nesting (n
)
512 struct case_node
*node
;
514 ggc_mark_rtx (n
->exit_label
);
515 ggc_mark_rtx (n
->data
.case_stmt
.start
);
517 node
= n
->data
.case_stmt
.case_list
;
520 ggc_mark_tree (node
->low
);
521 ggc_mark_tree (node
->high
);
522 ggc_mark_tree (node
->code_label
);
526 ggc_mark_tree (n
->data
.case_stmt
.default_label
);
527 ggc_mark_tree (n
->data
.case_stmt
.index_expr
);
528 ggc_mark_tree (n
->data
.case_stmt
.nominal_type
);
538 struct goto_fixup
*g
;
542 ggc_mark_rtx (g
->before_jump
);
543 ggc_mark_tree (g
->target
);
544 ggc_mark_tree (g
->context
);
545 ggc_mark_rtx (g
->target_rtl
);
546 ggc_mark_rtx (g
->stack_level
);
547 ggc_mark_tree (g
->cleanup_list_list
);
557 struct stmt_status
*p
;
562 mark_block_nesting (p
->x_block_stack
);
563 mark_cond_nesting (p
->x_cond_stack
);
564 mark_loop_nesting (p
->x_loop_stack
);
565 mark_case_nesting (p
->x_case_stack
);
567 ggc_mark_tree (p
->x_last_expr_type
);
568 /* last_epxr_value is only valid if last_expr_type is nonzero. */
569 if (p
->x_last_expr_type
)
570 ggc_mark_rtx (p
->x_last_expr_value
);
572 mark_goto_fixup (p
->x_goto_fixup_chain
);
578 gcc_obstack_init (&stmt_obstack
);
583 init_stmt_for_function ()
585 current_function
->stmt
586 = (struct stmt_status
*) xmalloc (sizeof (struct stmt_status
));
588 /* We are not currently within any block, conditional, loop or case. */
590 stack_block_stack
= 0;
597 current_block_start_count
= 0;
599 /* No gotos have been expanded yet. */
600 goto_fixup_chain
= 0;
602 /* We are not processing a ({...}) grouping. */
603 expr_stmts_for_value
= 0;
606 init_eh_for_function ();
609 /* Return nonzero if anything is pushed on the loop, condition, or case
614 return cond_stack
|| loop_stack
|| case_stack
;
617 /* Record the current file and line. Called from emit_line_note. */
619 set_file_and_line_for_stmt (file
, line
)
623 emit_filename
= file
;
627 /* Emit a no-op instruction. */
634 last_insn
= get_last_insn ();
636 && (GET_CODE (last_insn
) == CODE_LABEL
637 || (GET_CODE (last_insn
) == NOTE
638 && prev_real_insn (last_insn
) == 0)))
639 emit_insn (gen_nop ());
642 /* Return the rtx-label that corresponds to a LABEL_DECL,
643 creating it if necessary. */
649 if (TREE_CODE (label
) != LABEL_DECL
)
652 if (DECL_RTL (label
))
653 return DECL_RTL (label
);
655 return DECL_RTL (label
) = gen_label_rtx ();
658 /* Add an unconditional jump to LABEL as the next sequential instruction. */
664 do_pending_stack_adjust ();
665 emit_jump_insn (gen_jump (label
));
669 /* Emit code to jump to the address
670 specified by the pointer expression EXP. */
673 expand_computed_goto (exp
)
676 rtx x
= expand_expr (exp
, NULL_RTX
, VOIDmode
, 0);
678 #ifdef POINTERS_EXTEND_UNSIGNED
679 x
= convert_memory_address (Pmode
, x
);
683 /* Be sure the function is executable. */
684 if (current_function_check_memory_usage
)
685 emit_library_call (chkr_check_exec_libfunc
, 1,
686 VOIDmode
, 1, x
, ptr_mode
);
688 do_pending_stack_adjust ();
689 emit_indirect_jump (x
);
691 current_function_has_computed_jump
= 1;
694 /* Handle goto statements and the labels that they can go to. */
696 /* Specify the location in the RTL code of a label LABEL,
697 which is a LABEL_DECL tree node.
699 This is used for the kind of label that the user can jump to with a
700 goto statement, and for alternatives of a switch or case statement.
701 RTL labels generated for loops and conditionals don't go through here;
702 they are generated directly at the RTL level, by other functions below.
704 Note that this has nothing to do with defining label *names*.
705 Languages vary in how they do that and what that even means. */
711 struct label_chain
*p
;
713 do_pending_stack_adjust ();
714 emit_label (label_rtx (label
));
715 if (DECL_NAME (label
))
716 LABEL_NAME (DECL_RTL (label
)) = IDENTIFIER_POINTER (DECL_NAME (label
));
718 if (stack_block_stack
!= 0)
720 p
= (struct label_chain
*) oballoc (sizeof (struct label_chain
));
721 p
->next
= stack_block_stack
->data
.block
.label_chain
;
722 stack_block_stack
->data
.block
.label_chain
= p
;
727 /* Declare that LABEL (a LABEL_DECL) may be used for nonlocal gotos
728 from nested functions. */
731 declare_nonlocal_label (label
)
734 rtx slot
= assign_stack_local (Pmode
, GET_MODE_SIZE (Pmode
), 0);
736 nonlocal_labels
= tree_cons (NULL_TREE
, label
, nonlocal_labels
);
737 LABEL_PRESERVE_P (label_rtx (label
)) = 1;
738 if (nonlocal_goto_handler_slots
== 0)
740 emit_stack_save (SAVE_NONLOCAL
,
741 &nonlocal_goto_stack_level
,
742 PREV_INSN (tail_recursion_reentry
));
744 nonlocal_goto_handler_slots
745 = gen_rtx_EXPR_LIST (VOIDmode
, slot
, nonlocal_goto_handler_slots
);
748 /* Generate RTL code for a `goto' statement with target label LABEL.
749 LABEL should be a LABEL_DECL tree node that was or will later be
750 defined with `expand_label'. */
758 /* Check for a nonlocal goto to a containing function. */
759 context
= decl_function_context (label
);
760 if (context
!= 0 && context
!= current_function_decl
)
762 struct function
*p
= find_function_data (context
);
763 rtx label_ref
= gen_rtx_LABEL_REF (Pmode
, label_rtx (label
));
764 rtx temp
, handler_slot
;
767 /* Find the corresponding handler slot for this label. */
768 handler_slot
= p
->x_nonlocal_goto_handler_slots
;
769 for (link
= p
->x_nonlocal_labels
; TREE_VALUE (link
) != label
;
770 link
= TREE_CHAIN (link
))
771 handler_slot
= XEXP (handler_slot
, 1);
772 handler_slot
= XEXP (handler_slot
, 0);
774 p
->has_nonlocal_label
= 1;
775 current_function_has_nonlocal_goto
= 1;
776 LABEL_REF_NONLOCAL_P (label_ref
) = 1;
778 /* Copy the rtl for the slots so that they won't be shared in
779 case the virtual stack vars register gets instantiated differently
780 in the parent than in the child. */
782 #if HAVE_nonlocal_goto
783 if (HAVE_nonlocal_goto
)
784 emit_insn (gen_nonlocal_goto (lookup_static_chain (label
),
785 copy_rtx (handler_slot
),
786 copy_rtx (p
->x_nonlocal_goto_stack_level
),
793 /* Restore frame pointer for containing function.
794 This sets the actual hard register used for the frame pointer
795 to the location of the function's incoming static chain info.
796 The non-local goto handler will then adjust it to contain the
797 proper value and reload the argument pointer, if needed. */
798 emit_move_insn (hard_frame_pointer_rtx
, lookup_static_chain (label
));
800 /* We have now loaded the frame pointer hardware register with
801 the address of that corresponds to the start of the virtual
802 stack vars. So replace virtual_stack_vars_rtx in all
803 addresses we use with stack_pointer_rtx. */
805 /* Get addr of containing function's current nonlocal goto handler,
806 which will do any cleanups and then jump to the label. */
807 addr
= copy_rtx (handler_slot
);
808 temp
= copy_to_reg (replace_rtx (addr
, virtual_stack_vars_rtx
,
809 hard_frame_pointer_rtx
));
811 /* Restore the stack pointer. Note this uses fp just restored. */
812 addr
= p
->x_nonlocal_goto_stack_level
;
814 addr
= replace_rtx (copy_rtx (addr
),
815 virtual_stack_vars_rtx
,
816 hard_frame_pointer_rtx
);
818 emit_stack_restore (SAVE_NONLOCAL
, addr
, NULL_RTX
);
820 /* USE of hard_frame_pointer_rtx added for consistency; not clear if
822 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
823 emit_insn (gen_rtx_USE (VOIDmode
, stack_pointer_rtx
));
824 emit_indirect_jump (temp
);
828 expand_goto_internal (label
, label_rtx (label
), NULL_RTX
);
831 /* Generate RTL code for a `goto' statement with target label BODY.
832 LABEL should be a LABEL_REF.
833 LAST_INSN, if non-0, is the rtx we should consider as the last
834 insn emitted (for the purposes of cleaning up a return). */
837 expand_goto_internal (body
, label
, last_insn
)
842 struct nesting
*block
;
845 if (GET_CODE (label
) != CODE_LABEL
)
848 /* If label has already been defined, we can tell now
849 whether and how we must alter the stack level. */
851 if (PREV_INSN (label
) != 0)
853 /* Find the innermost pending block that contains the label.
854 (Check containment by comparing insn-uids.)
855 Then restore the outermost stack level within that block,
856 and do cleanups of all blocks contained in it. */
857 for (block
= block_stack
; block
; block
= block
->next
)
859 if (INSN_UID (block
->data
.block
.first_insn
) < INSN_UID (label
))
861 if (block
->data
.block
.stack_level
!= 0)
862 stack_level
= block
->data
.block
.stack_level
;
863 /* Execute the cleanups for blocks we are exiting. */
864 if (block
->data
.block
.cleanups
!= 0)
866 expand_cleanups (block
->data
.block
.cleanups
, NULL_TREE
, 1, 1);
867 do_pending_stack_adjust ();
873 /* Ensure stack adjust isn't done by emit_jump, as this
874 would clobber the stack pointer. This one should be
875 deleted as dead by flow. */
876 clear_pending_stack_adjust ();
877 do_pending_stack_adjust ();
878 emit_stack_restore (SAVE_BLOCK
, stack_level
, NULL_RTX
);
881 if (body
!= 0 && DECL_TOO_LATE (body
))
882 error ("jump to `%s' invalidly jumps into binding contour",
883 IDENTIFIER_POINTER (DECL_NAME (body
)));
885 /* Label not yet defined: may need to put this goto
886 on the fixup list. */
887 else if (! expand_fixup (body
, label
, last_insn
))
889 /* No fixup needed. Record that the label is the target
890 of at least one goto that has no fixup. */
892 TREE_ADDRESSABLE (body
) = 1;
898 /* Generate if necessary a fixup for a goto
899 whose target label in tree structure (if any) is TREE_LABEL
900 and whose target in rtl is RTL_LABEL.
902 If LAST_INSN is nonzero, we pretend that the jump appears
903 after insn LAST_INSN instead of at the current point in the insn stream.
905 The fixup will be used later to insert insns just before the goto.
906 Those insns will restore the stack level as appropriate for the
907 target label, and will (in the case of C++) also invoke any object
908 destructors which have to be invoked when we exit the scopes which
909 are exited by the goto.
911 Value is nonzero if a fixup is made. */
914 expand_fixup (tree_label
, rtl_label
, last_insn
)
919 struct nesting
*block
, *end_block
;
921 /* See if we can recognize which block the label will be output in.
922 This is possible in some very common cases.
923 If we succeed, set END_BLOCK to that block.
924 Otherwise, set it to 0. */
927 && (rtl_label
== cond_stack
->data
.cond
.endif_label
928 || rtl_label
== cond_stack
->data
.cond
.next_label
))
929 end_block
= cond_stack
;
930 /* If we are in a loop, recognize certain labels which
931 are likely targets. This reduces the number of fixups
932 we need to create. */
934 && (rtl_label
== loop_stack
->data
.loop
.start_label
935 || rtl_label
== loop_stack
->data
.loop
.end_label
936 || rtl_label
== loop_stack
->data
.loop
.continue_label
))
937 end_block
= loop_stack
;
941 /* Now set END_BLOCK to the binding level to which we will return. */
945 struct nesting
*next_block
= end_block
->all
;
948 /* First see if the END_BLOCK is inside the innermost binding level.
949 If so, then no cleanups or stack levels are relevant. */
950 while (next_block
&& next_block
!= block
)
951 next_block
= next_block
->all
;
956 /* Otherwise, set END_BLOCK to the innermost binding level
957 which is outside the relevant control-structure nesting. */
958 next_block
= block_stack
->next
;
959 for (block
= block_stack
; block
!= end_block
; block
= block
->all
)
960 if (block
== next_block
)
961 next_block
= next_block
->next
;
962 end_block
= next_block
;
965 /* Does any containing block have a stack level or cleanups?
966 If not, no fixup is needed, and that is the normal case
967 (the only case, for standard C). */
968 for (block
= block_stack
; block
!= end_block
; block
= block
->next
)
969 if (block
->data
.block
.stack_level
!= 0
970 || block
->data
.block
.cleanups
!= 0)
973 if (block
!= end_block
)
975 /* Ok, a fixup is needed. Add a fixup to the list of such. */
976 struct goto_fixup
*fixup
977 = (struct goto_fixup
*) oballoc (sizeof (struct goto_fixup
));
978 /* In case an old stack level is restored, make sure that comes
979 after any pending stack adjust. */
980 /* ?? If the fixup isn't to come at the present position,
981 doing the stack adjust here isn't useful. Doing it with our
982 settings at that location isn't useful either. Let's hope
985 do_pending_stack_adjust ();
986 fixup
->target
= tree_label
;
987 fixup
->target_rtl
= rtl_label
;
989 /* Create a BLOCK node and a corresponding matched set of
990 NOTE_INSN_BEGIN_BLOCK and NOTE_INSN_END_BLOCK notes at
991 this point. The notes will encapsulate any and all fixup
992 code which we might later insert at this point in the insn
993 stream. Also, the BLOCK node will be the parent (i.e. the
994 `SUPERBLOCK') of any other BLOCK nodes which we might create
995 later on when we are expanding the fixup code.
997 Note that optimization passes (including expand_end_loop)
998 might move the *_BLOCK notes away, so we use a NOTE_INSN_DELETED
1002 register rtx original_before_jump
1003 = last_insn
? last_insn
: get_last_insn ();
1008 start
= emit_note (NULL_PTR
, NOTE_INSN_BLOCK_BEG
);
1009 fixup
->before_jump
= emit_note (NULL_PTR
, NOTE_INSN_DELETED
);
1010 last_block_end_note
= emit_note (NULL_PTR
, NOTE_INSN_BLOCK_END
);
1011 fixup
->context
= poplevel (1, 0, 0); /* Create the BLOCK node now! */
1013 emit_insns_after (start
, original_before_jump
);
1016 fixup
->block_start_count
= current_block_start_count
;
1017 fixup
->stack_level
= 0;
1018 fixup
->cleanup_list_list
1019 = ((block
->data
.block
.outer_cleanups
1020 || block
->data
.block
.cleanups
)
1021 ? tree_cons (NULL_TREE
, block
->data
.block
.cleanups
,
1022 block
->data
.block
.outer_cleanups
)
1024 fixup
->next
= goto_fixup_chain
;
1025 goto_fixup_chain
= fixup
;
1033 /* Expand any needed fixups in the outputmost binding level of the
1034 function. FIRST_INSN is the first insn in the function. */
1037 expand_fixups (first_insn
)
1040 fixup_gotos (NULL_PTR
, NULL_RTX
, NULL_TREE
, first_insn
, 0);
1043 /* When exiting a binding contour, process all pending gotos requiring fixups.
1044 THISBLOCK is the structure that describes the block being exited.
1045 STACK_LEVEL is the rtx for the stack level to restore exiting this contour.
1046 CLEANUP_LIST is a list of expressions to evaluate on exiting this contour.
1047 FIRST_INSN is the insn that began this contour.
1049 Gotos that jump out of this contour must restore the
1050 stack level and do the cleanups before actually jumping.
1052 DONT_JUMP_IN nonzero means report error there is a jump into this
1053 contour from before the beginning of the contour.
1054 This is also done if STACK_LEVEL is nonzero. */
1057 fixup_gotos (thisblock
, stack_level
, cleanup_list
, first_insn
, dont_jump_in
)
1058 struct nesting
*thisblock
;
1064 register struct goto_fixup
*f
, *prev
;
1066 /* F is the fixup we are considering; PREV is the previous one. */
1067 /* We run this loop in two passes so that cleanups of exited blocks
1068 are run first, and blocks that are exited are marked so
1071 for (prev
= 0, f
= goto_fixup_chain
; f
; prev
= f
, f
= f
->next
)
1073 /* Test for a fixup that is inactive because it is already handled. */
1074 if (f
->before_jump
== 0)
1076 /* Delete inactive fixup from the chain, if that is easy to do. */
1078 prev
->next
= f
->next
;
1080 /* Has this fixup's target label been defined?
1081 If so, we can finalize it. */
1082 else if (PREV_INSN (f
->target_rtl
) != 0)
1084 register rtx cleanup_insns
;
1086 /* Get the first non-label after the label
1087 this goto jumps to. If that's before this scope begins,
1088 we don't have a jump into the scope. */
1089 rtx after_label
= f
->target_rtl
;
1090 while (after_label
!= 0 && GET_CODE (after_label
) == CODE_LABEL
)
1091 after_label
= NEXT_INSN (after_label
);
1093 /* If this fixup jumped into this contour from before the beginning
1094 of this contour, report an error. */
1095 /* ??? Bug: this does not detect jumping in through intermediate
1096 blocks that have stack levels or cleanups.
1097 It detects only a problem with the innermost block
1098 around the label. */
1100 && (dont_jump_in
|| stack_level
|| cleanup_list
)
1101 /* If AFTER_LABEL is 0, it means the jump goes to the end
1102 of the rtl, which means it jumps into this scope. */
1103 && (after_label
== 0
1104 || INSN_UID (first_insn
) < INSN_UID (after_label
))
1105 && INSN_UID (first_insn
) > INSN_UID (f
->before_jump
)
1106 && ! DECL_ERROR_ISSUED (f
->target
))
1108 error_with_decl (f
->target
,
1109 "label `%s' used before containing binding contour");
1110 /* Prevent multiple errors for one label. */
1111 DECL_ERROR_ISSUED (f
->target
) = 1;
1114 /* We will expand the cleanups into a sequence of their own and
1115 then later on we will attach this new sequence to the insn
1116 stream just ahead of the actual jump insn. */
1120 /* Temporarily restore the lexical context where we will
1121 logically be inserting the fixup code. We do this for the
1122 sake of getting the debugging information right. */
1125 set_block (f
->context
);
1127 /* Expand the cleanups for blocks this jump exits. */
1128 if (f
->cleanup_list_list
)
1131 for (lists
= f
->cleanup_list_list
; lists
; lists
= TREE_CHAIN (lists
))
1132 /* Marked elements correspond to blocks that have been closed.
1133 Do their cleanups. */
1134 if (TREE_ADDRESSABLE (lists
)
1135 && TREE_VALUE (lists
) != 0)
1137 expand_cleanups (TREE_VALUE (lists
), NULL_TREE
, 1, 1);
1138 /* Pop any pushes done in the cleanups,
1139 in case function is about to return. */
1140 do_pending_stack_adjust ();
1144 /* Restore stack level for the biggest contour that this
1145 jump jumps out of. */
1147 emit_stack_restore (SAVE_BLOCK
, f
->stack_level
, f
->before_jump
);
1149 /* Finish up the sequence containing the insns which implement the
1150 necessary cleanups, and then attach that whole sequence to the
1151 insn stream just ahead of the actual jump insn. Attaching it
1152 at that point insures that any cleanups which are in fact
1153 implicit C++ object destructions (which must be executed upon
1154 leaving the block) appear (to the debugger) to be taking place
1155 in an area of the generated code where the object(s) being
1156 destructed are still "in scope". */
1158 cleanup_insns
= get_insns ();
1162 emit_insns_after (cleanup_insns
, f
->before_jump
);
1169 /* For any still-undefined labels, do the cleanups for this block now.
1170 We must do this now since items in the cleanup list may go out
1171 of scope when the block ends. */
1172 for (prev
= 0, f
= goto_fixup_chain
; f
; prev
= f
, f
= f
->next
)
1173 if (f
->before_jump
!= 0
1174 && PREV_INSN (f
->target_rtl
) == 0
1175 /* Label has still not appeared. If we are exiting a block with
1176 a stack level to restore, that started before the fixup,
1177 mark this stack level as needing restoration
1178 when the fixup is later finalized. */
1180 /* Note: if THISBLOCK == 0 and we have a label that hasn't appeared, it
1181 means the label is undefined. That's erroneous, but possible. */
1182 && (thisblock
->data
.block
.block_start_count
1183 <= f
->block_start_count
))
1185 tree lists
= f
->cleanup_list_list
;
1188 for (; lists
; lists
= TREE_CHAIN (lists
))
1189 /* If the following elt. corresponds to our containing block
1190 then the elt. must be for this block. */
1191 if (TREE_CHAIN (lists
) == thisblock
->data
.block
.outer_cleanups
)
1195 set_block (f
->context
);
1196 expand_cleanups (TREE_VALUE (lists
), NULL_TREE
, 1, 1);
1197 do_pending_stack_adjust ();
1198 cleanup_insns
= get_insns ();
1201 if (cleanup_insns
!= 0)
1203 = emit_insns_after (cleanup_insns
, f
->before_jump
);
1205 f
->cleanup_list_list
= TREE_CHAIN (lists
);
1209 f
->stack_level
= stack_level
;
1213 /* Return the number of times character C occurs in string S. */
1215 n_occurrences (c
, s
)
1225 /* Generate RTL for an asm statement (explicit assembler code).
1226 BODY is a STRING_CST node containing the assembler code text,
1227 or an ADDR_EXPR containing a STRING_CST. */
1233 if (current_function_check_memory_usage
)
1235 error ("`asm' cannot be used in function where memory usage is checked");
1239 if (TREE_CODE (body
) == ADDR_EXPR
)
1240 body
= TREE_OPERAND (body
, 0);
1242 emit_insn (gen_rtx_ASM_INPUT (VOIDmode
,
1243 TREE_STRING_POINTER (body
)));
1247 /* Generate RTL for an asm statement with arguments.
1248 STRING is the instruction template.
1249 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
1250 Each output or input has an expression in the TREE_VALUE and
1251 a constraint-string in the TREE_PURPOSE.
1252 CLOBBERS is a list of STRING_CST nodes each naming a hard register
1253 that is clobbered by this insn.
1255 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
1256 Some elements of OUTPUTS may be replaced with trees representing temporary
1257 values. The caller should copy those temporary values to the originally
1260 VOL nonzero means the insn is volatile; don't optimize it. */
1263 expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
)
1264 tree string
, outputs
, inputs
, clobbers
;
1269 rtvec argvec
, constraints
;
1271 int ninputs
= list_length (inputs
);
1272 int noutputs
= list_length (outputs
);
1277 /* Vector of RTX's of evaluated output operands. */
1278 rtx
*output_rtx
= (rtx
*) alloca (noutputs
* sizeof (rtx
));
1279 int *inout_opnum
= (int *) alloca (noutputs
* sizeof (int));
1280 rtx
*real_output_rtx
= (rtx
*) alloca (noutputs
* sizeof (rtx
));
1281 enum machine_mode
*inout_mode
1282 = (enum machine_mode
*) alloca (noutputs
* sizeof (enum machine_mode
));
1283 /* The insn we have emitted. */
1286 /* An ASM with no outputs needs to be treated as volatile, for now. */
1290 if (current_function_check_memory_usage
)
1292 error ("`asm' cannot be used with `-fcheck-memory-usage'");
1296 #ifdef MD_ASM_CLOBBERS
1297 /* Sometimes we wish to automatically clobber registers across an asm.
1298 Case in point is when the i386 backend moved from cc0 to a hard reg --
1299 maintaining source-level compatability means automatically clobbering
1300 the flags register. */
1301 MD_ASM_CLOBBERS (clobbers
);
1304 if (current_function_check_memory_usage
)
1306 error ("`asm' cannot be used in function where memory usage is checked");
1310 /* Count the number of meaningful clobbered registers, ignoring what
1311 we would ignore later. */
1313 for (tail
= clobbers
; tail
; tail
= TREE_CHAIN (tail
))
1315 char *regname
= TREE_STRING_POINTER (TREE_VALUE (tail
));
1316 i
= decode_reg_name (regname
);
1317 if (i
>= 0 || i
== -4)
1320 error ("unknown register name `%s' in `asm'", regname
);
1325 /* Check that the number of alternatives is constant across all
1327 if (outputs
|| inputs
)
1329 tree tmp
= TREE_PURPOSE (outputs
? outputs
: inputs
);
1330 int nalternatives
= n_occurrences (',', TREE_STRING_POINTER (tmp
));
1333 if (nalternatives
+ 1 > MAX_RECOG_ALTERNATIVES
)
1335 error ("too many alternatives in `asm'");
1342 char *constraint
= TREE_STRING_POINTER (TREE_PURPOSE (tmp
));
1343 if (n_occurrences (',', constraint
) != nalternatives
)
1345 error ("operand constraints for `asm' differ in number of alternatives");
1348 if (TREE_CHAIN (tmp
))
1349 tmp
= TREE_CHAIN (tmp
);
1351 tmp
= next
, next
= 0;
1355 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
1357 tree val
= TREE_VALUE (tail
);
1358 tree type
= TREE_TYPE (val
);
1367 /* If there's an erroneous arg, emit no insn. */
1368 if (TREE_TYPE (val
) == error_mark_node
)
1371 /* Make sure constraint has `=' and does not have `+'. Also, see
1372 if it allows any register. Be liberal on the latter test, since
1373 the worst that happens if we get it wrong is we issue an error
1376 c_len
= TREE_STRING_LENGTH (TREE_PURPOSE (tail
)) - 1;
1377 constraint
= TREE_STRING_POINTER (TREE_PURPOSE (tail
));
1379 /* Allow the `=' or `+' to not be at the beginning of the string,
1380 since it wasn't explicitly documented that way, and there is a
1381 large body of code that puts it last. Swap the character to
1382 the front, so as not to uglify any place else. */
1386 if ((p
= strchr (constraint
, '=')) != NULL
)
1388 if ((p
= strchr (constraint
, '+')) != NULL
)
1391 error ("output operand constraint lacks `='");
1395 if (p
!= constraint
)
1398 bcopy (constraint
, constraint
+1, p
-constraint
);
1401 warning ("output constraint `%c' for operand %d is not at the beginning", j
, i
);
1404 is_inout
= constraint
[0] == '+';
1405 /* Replace '+' with '='. */
1406 constraint
[0] = '=';
1407 /* Make sure we can specify the matching operand. */
1408 if (is_inout
&& i
> 9)
1410 error ("output operand constraint %d contains `+'", i
);
1414 for (j
= 1; j
< c_len
; j
++)
1415 switch (constraint
[j
])
1419 error ("operand constraint contains '+' or '=' at illegal position.");
1423 if (i
+ 1 == ninputs
+ noutputs
)
1425 error ("`%%' constraint used with last operand");
1430 case '?': case '!': case '*': case '&':
1431 case 'E': case 'F': case 'G': case 'H':
1432 case 's': case 'i': case 'n':
1433 case 'I': case 'J': case 'K': case 'L': case 'M':
1434 case 'N': case 'O': case 'P': case ',':
1435 #ifdef EXTRA_CONSTRAINT
1436 case 'Q': case 'R': case 'S': case 'T': case 'U':
1440 case '0': case '1': case '2': case '3': case '4':
1441 case '5': case '6': case '7': case '8': case '9':
1442 error ("matching constraint not valid in output operand");
1445 case 'V': case 'm': case 'o':
1450 /* ??? Before flow, auto inc/dec insns are not supposed to exist,
1451 excepting those that expand_call created. So match memory
1467 /* If an output operand is not a decl or indirect ref and our constraint
1468 allows a register, make a temporary to act as an intermediate.
1469 Make the asm insn write into that, then our caller will copy it to
1470 the real output operand. Likewise for promoted variables. */
1472 real_output_rtx
[i
] = NULL_RTX
;
1473 if ((TREE_CODE (val
) == INDIRECT_REF
1475 || (TREE_CODE_CLASS (TREE_CODE (val
)) == 'd'
1476 && (allows_mem
|| GET_CODE (DECL_RTL (val
)) == REG
)
1477 && ! (GET_CODE (DECL_RTL (val
)) == REG
1478 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
)))
1483 mark_addressable (TREE_VALUE (tail
));
1486 = expand_expr (TREE_VALUE (tail
), NULL_RTX
, VOIDmode
,
1487 EXPAND_MEMORY_USE_WO
);
1489 if (! allows_reg
&& GET_CODE (output_rtx
[i
]) != MEM
)
1490 error ("output number %d not directly addressable", i
);
1491 if (! allows_mem
&& GET_CODE (output_rtx
[i
]) == MEM
)
1493 real_output_rtx
[i
] = protect_from_queue (output_rtx
[i
], 1);
1494 output_rtx
[i
] = gen_reg_rtx (GET_MODE (output_rtx
[i
]));
1496 emit_move_insn (output_rtx
[i
], real_output_rtx
[i
]);
1501 output_rtx
[i
] = assign_temp (type
, 0, 0, 0);
1502 TREE_VALUE (tail
) = make_tree (type
, output_rtx
[i
]);
1507 inout_mode
[ninout
] = TYPE_MODE (TREE_TYPE (TREE_VALUE (tail
)));
1508 inout_opnum
[ninout
++] = i
;
1513 if (ninputs
+ noutputs
> MAX_RECOG_OPERANDS
)
1515 error ("more than %d operands in `asm'", MAX_RECOG_OPERANDS
);
1519 /* Make vectors for the expression-rtx and constraint strings. */
1521 argvec
= rtvec_alloc (ninputs
);
1522 constraints
= rtvec_alloc (ninputs
);
1524 body
= gen_rtx_ASM_OPERANDS (VOIDmode
,
1525 TREE_STRING_POINTER (string
), "", 0, argvec
,
1526 constraints
, filename
, line
);
1528 MEM_VOLATILE_P (body
) = vol
;
1530 /* Eval the inputs and put them into ARGVEC.
1531 Put their constraints into ASM_INPUTs and store in CONSTRAINTS. */
1534 for (tail
= inputs
; tail
; tail
= TREE_CHAIN (tail
))
1537 int allows_reg
= 0, allows_mem
= 0;
1538 char *constraint
, *orig_constraint
;
1542 /* If there's an erroneous arg, emit no insn,
1543 because the ASM_INPUT would get VOIDmode
1544 and that could cause a crash in reload. */
1545 if (TREE_TYPE (TREE_VALUE (tail
)) == error_mark_node
)
1548 /* ??? Can this happen, and does the error message make any sense? */
1549 if (TREE_PURPOSE (tail
) == NULL_TREE
)
1551 error ("hard register `%s' listed as input operand to `asm'",
1552 TREE_STRING_POINTER (TREE_VALUE (tail
)) );
1556 c_len
= TREE_STRING_LENGTH (TREE_PURPOSE (tail
)) - 1;
1557 constraint
= TREE_STRING_POINTER (TREE_PURPOSE (tail
));
1558 orig_constraint
= constraint
;
1560 /* Make sure constraint has neither `=', `+', nor '&'. */
1562 for (j
= 0; j
< c_len
; j
++)
1563 switch (constraint
[j
])
1565 case '+': case '=': case '&':
1566 if (constraint
== orig_constraint
)
1568 error ("input operand constraint contains `%c'", constraint
[j
]);
1574 if (constraint
== orig_constraint
1575 && i
+ 1 == ninputs
- ninout
)
1577 error ("`%%' constraint used with last operand");
1582 case 'V': case 'm': case 'o':
1587 case '?': case '!': case '*':
1588 case 'E': case 'F': case 'G': case 'H': case 'X':
1589 case 's': case 'i': case 'n':
1590 case 'I': case 'J': case 'K': case 'L': case 'M':
1591 case 'N': case 'O': case 'P': case ',':
1592 #ifdef EXTRA_CONSTRAINT
1593 case 'Q': case 'R': case 'S': case 'T': case 'U':
1597 /* Whether or not a numeric constraint allows a register is
1598 decided by the matching constraint, and so there is no need
1599 to do anything special with them. We must handle them in
1600 the default case, so that we don't unnecessarily force
1601 operands to memory. */
1602 case '0': case '1': case '2': case '3': case '4':
1603 case '5': case '6': case '7': case '8': case '9':
1604 if (constraint
[j
] >= '0' + noutputs
)
1607 ("matching constraint references invalid operand number");
1611 /* Try and find the real constraint for this dup. */
1612 if ((j
== 0 && c_len
== 1)
1613 || (j
== 1 && c_len
== 2 && constraint
[0] == '%'))
1616 for (j
= constraint
[j
] - '0'; j
> 0; --j
)
1619 c_len
= TREE_STRING_LENGTH (TREE_PURPOSE (o
)) - 1;
1620 constraint
= TREE_STRING_POINTER (TREE_PURPOSE (o
));
1625 /* ... fall through ... */
1638 if (! allows_reg
&& allows_mem
)
1639 mark_addressable (TREE_VALUE (tail
));
1641 op
= expand_expr (TREE_VALUE (tail
), NULL_RTX
, VOIDmode
, 0);
1643 if (asm_operand_ok (op
, constraint
) <= 0)
1646 op
= force_reg (TYPE_MODE (TREE_TYPE (TREE_VALUE (tail
))), op
);
1647 else if (!allows_mem
)
1648 warning ("asm operand %d probably doesn't match constraints", i
);
1649 else if (CONSTANT_P (op
))
1650 op
= force_const_mem (TYPE_MODE (TREE_TYPE (TREE_VALUE (tail
))),
1652 else if (GET_CODE (op
) == REG
1653 || GET_CODE (op
) == SUBREG
1654 || GET_CODE (op
) == CONCAT
)
1656 tree type
= TREE_TYPE (TREE_VALUE (tail
));
1657 rtx memloc
= assign_temp (type
, 1, 1, 1);
1659 emit_move_insn (memloc
, op
);
1662 else if (GET_CODE (op
) == MEM
&& MEM_VOLATILE_P (op
))
1663 /* We won't recognize volatile memory as available a
1664 memory_operand at this point. Ignore it. */
1666 else if (queued_subexp_p (op
))
1669 /* ??? Leave this only until we have experience with what
1670 happens in combine and elsewhere when constraints are
1672 warning ("asm operand %d probably doesn't match constraints", i
);
1674 XVECEXP (body
, 3, i
) = op
;
1676 XVECEXP (body
, 4, i
) /* constraints */
1677 = gen_rtx_ASM_INPUT (TYPE_MODE (TREE_TYPE (TREE_VALUE (tail
))),
1682 /* Protect all the operands from the queue,
1683 now that they have all been evaluated. */
1685 for (i
= 0; i
< ninputs
- ninout
; i
++)
1686 XVECEXP (body
, 3, i
) = protect_from_queue (XVECEXP (body
, 3, i
), 0);
1688 for (i
= 0; i
< noutputs
; i
++)
1689 output_rtx
[i
] = protect_from_queue (output_rtx
[i
], 1);
1691 /* For in-out operands, copy output rtx to input rtx. */
1692 for (i
= 0; i
< ninout
; i
++)
1694 static char match
[9+1][2]
1695 = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"};
1696 int j
= inout_opnum
[i
];
1698 XVECEXP (body
, 3, ninputs
- ninout
+ i
) /* argvec */
1700 XVECEXP (body
, 4, ninputs
- ninout
+ i
) /* constraints */
1701 = gen_rtx_ASM_INPUT (inout_mode
[i
], match
[j
]);
1704 /* Now, for each output, construct an rtx
1705 (set OUTPUT (asm_operands INSN OUTPUTNUMBER OUTPUTCONSTRAINT
1706 ARGVEC CONSTRAINTS))
1707 If there is more than one, put them inside a PARALLEL. */
1709 if (noutputs
== 1 && nclobbers
== 0)
1711 XSTR (body
, 1) = TREE_STRING_POINTER (TREE_PURPOSE (outputs
));
1712 insn
= emit_insn (gen_rtx_SET (VOIDmode
, output_rtx
[0], body
));
1714 else if (noutputs
== 0 && nclobbers
== 0)
1716 /* No output operands: put in a raw ASM_OPERANDS rtx. */
1717 insn
= emit_insn (body
);
1723 if (num
== 0) num
= 1;
1724 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (num
+ nclobbers
));
1726 /* For each output operand, store a SET. */
1728 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
1730 XVECEXP (body
, 0, i
)
1731 = gen_rtx_SET (VOIDmode
,
1733 gen_rtx_ASM_OPERANDS
1735 TREE_STRING_POINTER (string
),
1736 TREE_STRING_POINTER (TREE_PURPOSE (tail
)),
1737 i
, argvec
, constraints
,
1740 MEM_VOLATILE_P (SET_SRC (XVECEXP (body
, 0, i
))) = vol
;
1743 /* If there are no outputs (but there are some clobbers)
1744 store the bare ASM_OPERANDS into the PARALLEL. */
1747 XVECEXP (body
, 0, i
++) = obody
;
1749 /* Store (clobber REG) for each clobbered register specified. */
1751 for (tail
= clobbers
; tail
; tail
= TREE_CHAIN (tail
))
1753 char *regname
= TREE_STRING_POINTER (TREE_VALUE (tail
));
1754 int j
= decode_reg_name (regname
);
1758 if (j
== -3) /* `cc', which is not a register */
1761 if (j
== -4) /* `memory', don't cache memory across asm */
1763 XVECEXP (body
, 0, i
++)
1764 = gen_rtx_CLOBBER (VOIDmode
,
1767 gen_rtx_SCRATCH (VOIDmode
)));
1771 /* Ignore unknown register, error already signaled. */
1775 /* Use QImode since that's guaranteed to clobber just one reg. */
1776 XVECEXP (body
, 0, i
++)
1777 = gen_rtx_CLOBBER (VOIDmode
, gen_rtx_REG (QImode
, j
));
1780 insn
= emit_insn (body
);
1783 /* For any outputs that needed reloading into registers, spill them
1784 back to where they belong. */
1785 for (i
= 0; i
< noutputs
; ++i
)
1786 if (real_output_rtx
[i
])
1787 emit_move_insn (real_output_rtx
[i
], output_rtx
[i
]);
1792 /* Generate RTL to evaluate the expression EXP
1793 and remember it in case this is the VALUE in a ({... VALUE; }) constr. */
1796 expand_expr_stmt (exp
)
1799 /* If -W, warn about statements with no side effects,
1800 except for an explicit cast to void (e.g. for assert()), and
1801 except inside a ({...}) where they may be useful. */
1802 if (expr_stmts_for_value
== 0 && exp
!= error_mark_node
)
1804 if (! TREE_SIDE_EFFECTS (exp
) && (extra_warnings
|| warn_unused
)
1805 && !(TREE_CODE (exp
) == CONVERT_EXPR
1806 && TREE_TYPE (exp
) == void_type_node
))
1807 warning_with_file_and_line (emit_filename
, emit_lineno
,
1808 "statement with no effect");
1809 else if (warn_unused
)
1810 warn_if_unused_value (exp
);
1813 /* If EXP is of function type and we are expanding statements for
1814 value, convert it to pointer-to-function. */
1815 if (expr_stmts_for_value
&& TREE_CODE (TREE_TYPE (exp
)) == FUNCTION_TYPE
)
1816 exp
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (exp
)), exp
);
1818 last_expr_type
= TREE_TYPE (exp
);
1819 last_expr_value
= expand_expr (exp
,
1820 (expr_stmts_for_value
1821 ? NULL_RTX
: const0_rtx
),
1824 /* If all we do is reference a volatile value in memory,
1825 copy it to a register to be sure it is actually touched. */
1826 if (last_expr_value
!= 0 && GET_CODE (last_expr_value
) == MEM
1827 && TREE_THIS_VOLATILE (exp
))
1829 if (TYPE_MODE (TREE_TYPE (exp
)) == VOIDmode
)
1831 else if (TYPE_MODE (TREE_TYPE (exp
)) != BLKmode
)
1832 copy_to_reg (last_expr_value
);
1835 rtx lab
= gen_label_rtx ();
1837 /* Compare the value with itself to reference it. */
1838 emit_cmp_and_jump_insns (last_expr_value
, last_expr_value
, EQ
,
1839 expand_expr (TYPE_SIZE (last_expr_type
),
1840 NULL_RTX
, VOIDmode
, 0),
1842 TYPE_ALIGN (last_expr_type
) / BITS_PER_UNIT
,
1848 /* If this expression is part of a ({...}) and is in memory, we may have
1849 to preserve temporaries. */
1850 preserve_temp_slots (last_expr_value
);
1852 /* Free any temporaries used to evaluate this expression. Any temporary
1853 used as a result of this expression will already have been preserved
1860 /* Warn if EXP contains any computations whose results are not used.
1861 Return 1 if a warning is printed; 0 otherwise. */
1864 warn_if_unused_value (exp
)
1867 if (TREE_USED (exp
))
1870 switch (TREE_CODE (exp
))
1872 case PREINCREMENT_EXPR
:
1873 case POSTINCREMENT_EXPR
:
1874 case PREDECREMENT_EXPR
:
1875 case POSTDECREMENT_EXPR
:
1880 case METHOD_CALL_EXPR
:
1882 case TRY_CATCH_EXPR
:
1883 case WITH_CLEANUP_EXPR
:
1885 /* We don't warn about COND_EXPR because it may be a useful
1886 construct if either arm contains a side effect. */
1891 /* For a binding, warn if no side effect within it. */
1892 return warn_if_unused_value (TREE_OPERAND (exp
, 1));
1895 return warn_if_unused_value (TREE_OPERAND (exp
, 1));
1897 case TRUTH_ORIF_EXPR
:
1898 case TRUTH_ANDIF_EXPR
:
1899 /* In && or ||, warn if 2nd operand has no side effect. */
1900 return warn_if_unused_value (TREE_OPERAND (exp
, 1));
1903 if (TREE_NO_UNUSED_WARNING (exp
))
1905 if (warn_if_unused_value (TREE_OPERAND (exp
, 0)))
1907 /* Let people do `(foo (), 0)' without a warning. */
1908 if (TREE_CONSTANT (TREE_OPERAND (exp
, 1)))
1910 return warn_if_unused_value (TREE_OPERAND (exp
, 1));
1914 case NON_LVALUE_EXPR
:
1915 /* Don't warn about values cast to void. */
1916 if (TREE_TYPE (exp
) == void_type_node
)
1918 /* Don't warn about conversions not explicit in the user's program. */
1919 if (TREE_NO_UNUSED_WARNING (exp
))
1921 /* Assignment to a cast usually results in a cast of a modify.
1922 Don't complain about that. There can be an arbitrary number of
1923 casts before the modify, so we must loop until we find the first
1924 non-cast expression and then test to see if that is a modify. */
1926 tree tem
= TREE_OPERAND (exp
, 0);
1928 while (TREE_CODE (tem
) == CONVERT_EXPR
|| TREE_CODE (tem
) == NOP_EXPR
)
1929 tem
= TREE_OPERAND (tem
, 0);
1931 if (TREE_CODE (tem
) == MODIFY_EXPR
|| TREE_CODE (tem
) == INIT_EXPR
1932 || TREE_CODE (tem
) == CALL_EXPR
)
1938 /* Don't warn about automatic dereferencing of references, since
1939 the user cannot control it. */
1940 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == REFERENCE_TYPE
)
1941 return warn_if_unused_value (TREE_OPERAND (exp
, 0));
1942 /* ... fall through ... */
1945 /* Referencing a volatile value is a side effect, so don't warn. */
1946 if ((TREE_CODE_CLASS (TREE_CODE (exp
)) == 'd'
1947 || TREE_CODE_CLASS (TREE_CODE (exp
)) == 'r')
1948 && TREE_THIS_VOLATILE (exp
))
1951 warning_with_file_and_line (emit_filename
, emit_lineno
,
1952 "value computed is not used");
1957 /* Clear out the memory of the last expression evaluated. */
1965 /* Begin a statement which will return a value.
1966 Return the RTL_EXPR for this statement expr.
1967 The caller must save that value and pass it to expand_end_stmt_expr. */
1970 expand_start_stmt_expr ()
1975 /* Make the RTL_EXPR node temporary, not momentary,
1976 so that rtl_expr_chain doesn't become garbage. */
1977 momentary
= suspend_momentary ();
1978 t
= make_node (RTL_EXPR
);
1979 resume_momentary (momentary
);
1980 do_pending_stack_adjust ();
1981 start_sequence_for_rtl_expr (t
);
1983 expr_stmts_for_value
++;
1987 /* Restore the previous state at the end of a statement that returns a value.
1988 Returns a tree node representing the statement's value and the
1989 insns to compute the value.
1991 The nodes of that expression have been freed by now, so we cannot use them.
1992 But we don't want to do that anyway; the expression has already been
1993 evaluated and now we just want to use the value. So generate a RTL_EXPR
1994 with the proper type and RTL value.
1996 If the last substatement was not an expression,
1997 return something with type `void'. */
2000 expand_end_stmt_expr (t
)
2005 if (last_expr_type
== 0)
2007 last_expr_type
= void_type_node
;
2008 last_expr_value
= const0_rtx
;
2010 else if (last_expr_value
== 0)
2011 /* There are some cases where this can happen, such as when the
2012 statement is void type. */
2013 last_expr_value
= const0_rtx
;
2014 else if (GET_CODE (last_expr_value
) != REG
&& ! CONSTANT_P (last_expr_value
))
2015 /* Remove any possible QUEUED. */
2016 last_expr_value
= protect_from_queue (last_expr_value
, 0);
2020 TREE_TYPE (t
) = last_expr_type
;
2021 RTL_EXPR_RTL (t
) = last_expr_value
;
2022 RTL_EXPR_SEQUENCE (t
) = get_insns ();
2024 rtl_expr_chain
= tree_cons (NULL_TREE
, t
, rtl_expr_chain
);
2028 /* Don't consider deleting this expr or containing exprs at tree level. */
2029 TREE_SIDE_EFFECTS (t
) = 1;
2030 /* Propagate volatility of the actual RTL expr. */
2031 TREE_THIS_VOLATILE (t
) = volatile_refs_p (last_expr_value
);
2034 expr_stmts_for_value
--;
2039 /* Generate RTL for the start of an if-then. COND is the expression
2040 whose truth should be tested.
2042 If EXITFLAG is nonzero, this conditional is visible to
2043 `exit_something'. */
2046 expand_start_cond (cond
, exitflag
)
2050 struct nesting
*thiscond
= ALLOC_NESTING ();
2052 /* Make an entry on cond_stack for the cond we are entering. */
2054 thiscond
->next
= cond_stack
;
2055 thiscond
->all
= nesting_stack
;
2056 thiscond
->depth
= ++nesting_depth
;
2057 thiscond
->data
.cond
.next_label
= gen_label_rtx ();
2058 /* Before we encounter an `else', we don't need a separate exit label
2059 unless there are supposed to be exit statements
2060 to exit this conditional. */
2061 thiscond
->exit_label
= exitflag
? gen_label_rtx () : 0;
2062 thiscond
->data
.cond
.endif_label
= thiscond
->exit_label
;
2063 cond_stack
= thiscond
;
2064 nesting_stack
= thiscond
;
2066 do_jump (cond
, thiscond
->data
.cond
.next_label
, NULL_RTX
);
2069 /* Generate RTL between then-clause and the elseif-clause
2070 of an if-then-elseif-.... */
2073 expand_start_elseif (cond
)
2076 if (cond_stack
->data
.cond
.endif_label
== 0)
2077 cond_stack
->data
.cond
.endif_label
= gen_label_rtx ();
2078 emit_jump (cond_stack
->data
.cond
.endif_label
);
2079 emit_label (cond_stack
->data
.cond
.next_label
);
2080 cond_stack
->data
.cond
.next_label
= gen_label_rtx ();
2081 do_jump (cond
, cond_stack
->data
.cond
.next_label
, NULL_RTX
);
2084 /* Generate RTL between the then-clause and the else-clause
2085 of an if-then-else. */
2088 expand_start_else ()
2090 if (cond_stack
->data
.cond
.endif_label
== 0)
2091 cond_stack
->data
.cond
.endif_label
= gen_label_rtx ();
2093 emit_jump (cond_stack
->data
.cond
.endif_label
);
2094 emit_label (cond_stack
->data
.cond
.next_label
);
2095 cond_stack
->data
.cond
.next_label
= 0; /* No more _else or _elseif calls. */
2098 /* After calling expand_start_else, turn this "else" into an "else if"
2099 by providing another condition. */
2102 expand_elseif (cond
)
2105 cond_stack
->data
.cond
.next_label
= gen_label_rtx ();
2106 do_jump (cond
, cond_stack
->data
.cond
.next_label
, NULL_RTX
);
2109 /* Generate RTL for the end of an if-then.
2110 Pop the record for it off of cond_stack. */
2115 struct nesting
*thiscond
= cond_stack
;
2117 do_pending_stack_adjust ();
2118 if (thiscond
->data
.cond
.next_label
)
2119 emit_label (thiscond
->data
.cond
.next_label
);
2120 if (thiscond
->data
.cond
.endif_label
)
2121 emit_label (thiscond
->data
.cond
.endif_label
);
2123 POPSTACK (cond_stack
);
2129 /* Generate RTL for the start of a loop. EXIT_FLAG is nonzero if this
2130 loop should be exited by `exit_something'. This is a loop for which
2131 `expand_continue' will jump to the top of the loop.
2133 Make an entry on loop_stack to record the labels associated with
2137 expand_start_loop (exit_flag
)
2140 register struct nesting
*thisloop
= ALLOC_NESTING ();
2142 /* Make an entry on loop_stack for the loop we are entering. */
2144 thisloop
->next
= loop_stack
;
2145 thisloop
->all
= nesting_stack
;
2146 thisloop
->depth
= ++nesting_depth
;
2147 thisloop
->data
.loop
.start_label
= gen_label_rtx ();
2148 thisloop
->data
.loop
.end_label
= gen_label_rtx ();
2149 thisloop
->data
.loop
.alt_end_label
= 0;
2150 thisloop
->data
.loop
.continue_label
= thisloop
->data
.loop
.start_label
;
2151 thisloop
->exit_label
= exit_flag
? thisloop
->data
.loop
.end_label
: 0;
2152 loop_stack
= thisloop
;
2153 nesting_stack
= thisloop
;
2155 do_pending_stack_adjust ();
2157 emit_note (NULL_PTR
, NOTE_INSN_LOOP_BEG
);
2158 emit_label (thisloop
->data
.loop
.start_label
);
2163 /* Like expand_start_loop but for a loop where the continuation point
2164 (for expand_continue_loop) will be specified explicitly. */
2167 expand_start_loop_continue_elsewhere (exit_flag
)
2170 struct nesting
*thisloop
= expand_start_loop (exit_flag
);
2171 loop_stack
->data
.loop
.continue_label
= gen_label_rtx ();
2175 /* Specify the continuation point for a loop started with
2176 expand_start_loop_continue_elsewhere.
2177 Use this at the point in the code to which a continue statement
2181 expand_loop_continue_here ()
2183 do_pending_stack_adjust ();
2184 emit_note (NULL_PTR
, NOTE_INSN_LOOP_CONT
);
2185 emit_label (loop_stack
->data
.loop
.continue_label
);
2188 /* Finish a loop. Generate a jump back to the top and the loop-exit label.
2189 Pop the block off of loop_stack. */
2194 rtx start_label
= loop_stack
->data
.loop
.start_label
;
2195 rtx insn
= get_last_insn ();
2196 int needs_end_jump
= 1;
2198 /* Mark the continue-point at the top of the loop if none elsewhere. */
2199 if (start_label
== loop_stack
->data
.loop
.continue_label
)
2200 emit_note_before (NOTE_INSN_LOOP_CONT
, start_label
);
2202 do_pending_stack_adjust ();
2204 /* If optimizing, perhaps reorder the loop.
2205 First, try to use a condjump near the end.
2206 expand_exit_loop_if_false ends loops with unconditional jumps,
2209 if (test) goto label;
2211 goto loop_stack->data.loop.end_label
2215 If we find such a pattern, we can end the loop earlier. */
2218 && GET_CODE (insn
) == CODE_LABEL
2219 && LABEL_NAME (insn
) == NULL
2220 && GET_CODE (PREV_INSN (insn
)) == BARRIER
)
2223 rtx jump
= PREV_INSN (PREV_INSN (label
));
2225 if (GET_CODE (jump
) == JUMP_INSN
2226 && GET_CODE (PATTERN (jump
)) == SET
2227 && SET_DEST (PATTERN (jump
)) == pc_rtx
2228 && GET_CODE (SET_SRC (PATTERN (jump
))) == LABEL_REF
2229 && (XEXP (SET_SRC (PATTERN (jump
)), 0)
2230 == loop_stack
->data
.loop
.end_label
))
2234 /* The test might be complex and reference LABEL multiple times,
2235 like the loop in loop_iterations to set vtop. To handle this,
2237 insn
= PREV_INSN (label
);
2238 reorder_insns (label
, label
, start_label
);
2240 for (prev
= PREV_INSN (jump
); ; prev
= PREV_INSN (prev
))
2242 /* We ignore line number notes, but if we see any other note,
2243 in particular NOTE_INSN_BLOCK_*, NOTE_INSN_EH_REGION_*,
2244 NOTE_INSN_LOOP_*, we disable this optimization. */
2245 if (GET_CODE (prev
) == NOTE
)
2247 if (NOTE_LINE_NUMBER (prev
) < 0)
2251 if (GET_CODE (prev
) == CODE_LABEL
)
2253 if (GET_CODE (prev
) == JUMP_INSN
)
2255 if (GET_CODE (PATTERN (prev
)) == SET
2256 && SET_DEST (PATTERN (prev
)) == pc_rtx
2257 && GET_CODE (SET_SRC (PATTERN (prev
))) == IF_THEN_ELSE
2258 && (GET_CODE (XEXP (SET_SRC (PATTERN (prev
)), 1))
2260 && XEXP (XEXP (SET_SRC (PATTERN (prev
)), 1), 0) == label
)
2262 XEXP (XEXP (SET_SRC (PATTERN (prev
)), 1), 0)
2264 emit_note_after (NOTE_INSN_LOOP_END
, prev
);
2273 /* If the loop starts with a loop exit, roll that to the end where
2274 it will optimize together with the jump back.
2276 We look for the conditional branch to the exit, except that once
2277 we find such a branch, we don't look past 30 instructions.
2279 In more detail, if the loop presently looks like this (in pseudo-C):
2282 if (test) goto end_label;
2287 transform it to look like:
2293 if (test) goto end_label;
2294 goto newstart_label;
2297 Here, the `test' may actually consist of some reasonably complex
2298 code, terminating in a test. */
2303 ! (GET_CODE (insn
) == JUMP_INSN
2304 && GET_CODE (PATTERN (insn
)) == SET
2305 && SET_DEST (PATTERN (insn
)) == pc_rtx
2306 && GET_CODE (SET_SRC (PATTERN (insn
))) == IF_THEN_ELSE
))
2310 rtx last_test_insn
= NULL_RTX
;
2312 /* Scan insns from the top of the loop looking for a qualified
2313 conditional exit. */
2314 for (insn
= NEXT_INSN (loop_stack
->data
.loop
.start_label
); insn
;
2315 insn
= NEXT_INSN (insn
))
2317 if (GET_CODE (insn
) == NOTE
)
2320 && (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_BEG
2321 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_END
))
2322 /* The code that actually moves the exit test will
2323 carefully leave BLOCK notes in their original
2324 location. That means, however, that we can't debug
2325 the exit test itself. So, we refuse to move code
2326 containing BLOCK notes at low optimization levels. */
2329 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_EH_REGION_BEG
)
2331 else if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_EH_REGION_END
)
2335 /* We've come to the end of an EH region, but
2336 never saw the beginning of that region. That
2337 means that an EH region begins before the top
2338 of the loop, and ends in the middle of it. The
2339 existence of such a situation violates a basic
2340 assumption in this code, since that would imply
2341 that even when EH_REGIONS is zero, we might
2342 move code out of an exception region. */
2346 /* We must not walk into a nested loop. */
2347 if (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_LOOP_BEG
)
2350 /* We already know this INSN is a NOTE, so there's no
2351 point in looking at it to see if it's a JUMP. */
2355 if (GET_CODE (insn
) == JUMP_INSN
|| GET_CODE (insn
) == INSN
)
2358 if (last_test_insn
&& num_insns
> 30)
2362 /* We don't want to move a partial EH region. Consider:
2376 This isn't legal C++, but here's what it's supposed to
2377 mean: if cond() is true, stop looping. Otherwise,
2378 call bar, and keep looping. In addition, if cond
2379 throws an exception, catch it and keep looping. Such
2380 constructs are certainy legal in LISP.
2382 We should not move the `if (cond()) 0' test since then
2383 the EH-region for the try-block would be broken up.
2384 (In this case we would the EH_BEG note for the `try'
2385 and `if cond()' but not the call to bar() or the
2388 So we don't look for tests within an EH region. */
2391 if (GET_CODE (insn
) == JUMP_INSN
2392 && GET_CODE (PATTERN (insn
)) == SET
2393 && SET_DEST (PATTERN (insn
)) == pc_rtx
)
2395 /* This is indeed a jump. */
2396 rtx dest1
= NULL_RTX
;
2397 rtx dest2
= NULL_RTX
;
2398 rtx potential_last_test
;
2399 if (GET_CODE (SET_SRC (PATTERN (insn
))) == IF_THEN_ELSE
)
2401 /* A conditional jump. */
2402 dest1
= XEXP (SET_SRC (PATTERN (insn
)), 1);
2403 dest2
= XEXP (SET_SRC (PATTERN (insn
)), 2);
2404 potential_last_test
= insn
;
2408 /* An unconditional jump. */
2409 dest1
= SET_SRC (PATTERN (insn
));
2410 /* Include the BARRIER after the JUMP. */
2411 potential_last_test
= NEXT_INSN (insn
);
2415 if (dest1
&& GET_CODE (dest1
) == LABEL_REF
2416 && ((XEXP (dest1
, 0)
2417 == loop_stack
->data
.loop
.alt_end_label
)
2419 == loop_stack
->data
.loop
.end_label
)))
2421 last_test_insn
= potential_last_test
;
2425 /* If this was a conditional jump, there may be
2426 another label at which we should look. */
2433 if (last_test_insn
!= 0 && last_test_insn
!= get_last_insn ())
2435 /* We found one. Move everything from there up
2436 to the end of the loop, and add a jump into the loop
2437 to jump to there. */
2438 register rtx newstart_label
= gen_label_rtx ();
2439 register rtx start_move
= start_label
;
2442 /* If the start label is preceded by a NOTE_INSN_LOOP_CONT note,
2443 then we want to move this note also. */
2444 if (GET_CODE (PREV_INSN (start_move
)) == NOTE
2445 && (NOTE_LINE_NUMBER (PREV_INSN (start_move
))
2446 == NOTE_INSN_LOOP_CONT
))
2447 start_move
= PREV_INSN (start_move
);
2449 emit_label_after (newstart_label
, PREV_INSN (start_move
));
2451 /* Actually move the insns. Start at the beginning, and
2452 keep copying insns until we've copied the
2454 for (insn
= start_move
; insn
; insn
= next_insn
)
2456 /* Figure out which insn comes after this one. We have
2457 to do this before we move INSN. */
2458 if (insn
== last_test_insn
)
2459 /* We've moved all the insns. */
2460 next_insn
= NULL_RTX
;
2462 next_insn
= NEXT_INSN (insn
);
2464 if (GET_CODE (insn
) == NOTE
2465 && (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_BEG
2466 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_END
))
2467 /* We don't want to move NOTE_INSN_BLOCK_BEGs or
2468 NOTE_INSN_BLOCK_ENDs because the correct generation
2469 of debugging information depends on these appearing
2470 in the same order in the RTL and in the tree
2471 structure, where they are represented as BLOCKs.
2472 So, we don't move block notes. Of course, moving
2473 the code inside the block is likely to make it
2474 impossible to debug the instructions in the exit
2475 test, but such is the price of optimization. */
2478 /* Move the INSN. */
2479 reorder_insns (insn
, insn
, get_last_insn ());
2482 emit_jump_insn_after (gen_jump (start_label
),
2483 PREV_INSN (newstart_label
));
2484 emit_barrier_after (PREV_INSN (newstart_label
));
2485 start_label
= newstart_label
;
2491 emit_jump (start_label
);
2492 emit_note (NULL_PTR
, NOTE_INSN_LOOP_END
);
2494 emit_label (loop_stack
->data
.loop
.end_label
);
2496 POPSTACK (loop_stack
);
2501 /* Generate a jump to the current loop's continue-point.
2502 This is usually the top of the loop, but may be specified
2503 explicitly elsewhere. If not currently inside a loop,
2504 return 0 and do nothing; caller will print an error message. */
2507 expand_continue_loop (whichloop
)
2508 struct nesting
*whichloop
;
2512 whichloop
= loop_stack
;
2515 expand_goto_internal (NULL_TREE
, whichloop
->data
.loop
.continue_label
,
2520 /* Generate a jump to exit the current loop. If not currently inside a loop,
2521 return 0 and do nothing; caller will print an error message. */
2524 expand_exit_loop (whichloop
)
2525 struct nesting
*whichloop
;
2529 whichloop
= loop_stack
;
2532 expand_goto_internal (NULL_TREE
, whichloop
->data
.loop
.end_label
, NULL_RTX
);
2536 /* Generate a conditional jump to exit the current loop if COND
2537 evaluates to zero. If not currently inside a loop,
2538 return 0 and do nothing; caller will print an error message. */
2541 expand_exit_loop_if_false (whichloop
, cond
)
2542 struct nesting
*whichloop
;
2545 rtx label
= gen_label_rtx ();
2550 whichloop
= loop_stack
;
2553 /* In order to handle fixups, we actually create a conditional jump
2554 around a unconditional branch to exit the loop. If fixups are
2555 necessary, they go before the unconditional branch. */
2558 do_jump (cond
, NULL_RTX
, label
);
2559 last_insn
= get_last_insn ();
2560 if (GET_CODE (last_insn
) == CODE_LABEL
)
2561 whichloop
->data
.loop
.alt_end_label
= last_insn
;
2562 expand_goto_internal (NULL_TREE
, whichloop
->data
.loop
.end_label
,
2569 /* Return nonzero if the loop nest is empty. Else return zero. */
2572 stmt_loop_nest_empty ()
2574 return (loop_stack
== NULL
);
2577 /* Return non-zero if we should preserve sub-expressions as separate
2578 pseudos. We never do so if we aren't optimizing. We always do so
2579 if -fexpensive-optimizations.
2581 Otherwise, we only do so if we are in the "early" part of a loop. I.e.,
2582 the loop may still be a small one. */
2585 preserve_subexpressions_p ()
2589 if (flag_expensive_optimizations
)
2592 if (optimize
== 0 || current_function
== 0 || loop_stack
== 0)
2595 insn
= get_last_insn_anywhere ();
2598 && (INSN_UID (insn
) - INSN_UID (loop_stack
->data
.loop
.start_label
)
2599 < n_non_fixed_regs
* 3));
2603 /* Generate a jump to exit the current loop, conditional, binding contour
2604 or case statement. Not all such constructs are visible to this function,
2605 only those started with EXIT_FLAG nonzero. Individual languages use
2606 the EXIT_FLAG parameter to control which kinds of constructs you can
2609 If not currently inside anything that can be exited,
2610 return 0 and do nothing; caller will print an error message. */
2613 expand_exit_something ()
2617 for (n
= nesting_stack
; n
; n
= n
->all
)
2618 if (n
->exit_label
!= 0)
2620 expand_goto_internal (NULL_TREE
, n
->exit_label
, NULL_RTX
);
2627 /* Generate RTL to return from the current function, with no value.
2628 (That is, we do not do anything about returning any value.) */
2631 expand_null_return ()
2633 struct nesting
*block
= block_stack
;
2636 /* Does any pending block have cleanups? */
2638 while (block
&& block
->data
.block
.cleanups
== 0)
2639 block
= block
->next
;
2641 /* If yes, use a goto to return, since that runs cleanups. */
2643 expand_null_return_1 (last_insn
, block
!= 0);
2646 /* Generate RTL to return from the current function, with value VAL. */
2649 expand_value_return (val
)
2652 struct nesting
*block
= block_stack
;
2653 rtx last_insn
= get_last_insn ();
2654 rtx return_reg
= DECL_RTL (DECL_RESULT (current_function_decl
));
2656 /* Copy the value to the return location
2657 unless it's already there. */
2659 if (return_reg
!= val
)
2661 #ifdef PROMOTE_FUNCTION_RETURN
2662 tree type
= TREE_TYPE (DECL_RESULT (current_function_decl
));
2663 int unsignedp
= TREE_UNSIGNED (type
);
2664 enum machine_mode mode
2665 = promote_mode (type
, DECL_MODE (DECL_RESULT (current_function_decl
)),
2668 if (GET_MODE (val
) != VOIDmode
&& GET_MODE (val
) != mode
)
2669 convert_move (return_reg
, val
, unsignedp
);
2672 emit_move_insn (return_reg
, val
);
2674 if (GET_CODE (return_reg
) == REG
2675 && REGNO (return_reg
) < FIRST_PSEUDO_REGISTER
)
2676 emit_insn (gen_rtx_USE (VOIDmode
, return_reg
));
2677 /* Handle calls that return values in multiple non-contiguous locations.
2678 The Irix 6 ABI has examples of this. */
2679 else if (GET_CODE (return_reg
) == PARALLEL
)
2683 for (i
= 0; i
< XVECLEN (return_reg
, 0); i
++)
2685 rtx x
= XEXP (XVECEXP (return_reg
, 0, i
), 0);
2687 if (GET_CODE (x
) == REG
2688 && REGNO (x
) < FIRST_PSEUDO_REGISTER
)
2689 emit_insn (gen_rtx_USE (VOIDmode
, x
));
2693 /* Does any pending block have cleanups? */
2695 while (block
&& block
->data
.block
.cleanups
== 0)
2696 block
= block
->next
;
2698 /* If yes, use a goto to return, since that runs cleanups.
2699 Use LAST_INSN to put cleanups *before* the move insn emitted above. */
2701 expand_null_return_1 (last_insn
, block
!= 0);
2704 /* Output a return with no value. If LAST_INSN is nonzero,
2705 pretend that the return takes place after LAST_INSN.
2706 If USE_GOTO is nonzero then don't use a return instruction;
2707 go to the return label instead. This causes any cleanups
2708 of pending blocks to be executed normally. */
2711 expand_null_return_1 (last_insn
, use_goto
)
2715 rtx end_label
= cleanup_label
? cleanup_label
: return_label
;
2717 clear_pending_stack_adjust ();
2718 do_pending_stack_adjust ();
2721 /* PCC-struct return always uses an epilogue. */
2722 if (current_function_returns_pcc_struct
|| use_goto
)
2725 end_label
= return_label
= gen_label_rtx ();
2726 expand_goto_internal (NULL_TREE
, end_label
, last_insn
);
2730 /* Otherwise output a simple return-insn if one is available,
2731 unless it won't do the job. */
2733 if (HAVE_return
&& use_goto
== 0 && cleanup_label
== 0)
2735 emit_jump_insn (gen_return ());
2741 /* Otherwise jump to the epilogue. */
2742 expand_goto_internal (NULL_TREE
, end_label
, last_insn
);
2745 /* Generate RTL to evaluate the expression RETVAL and return it
2746 from the current function. */
2749 expand_return (retval
)
2752 /* If there are any cleanups to be performed, then they will
2753 be inserted following LAST_INSN. It is desirable
2754 that the last_insn, for such purposes, should be the
2755 last insn before computing the return value. Otherwise, cleanups
2756 which call functions can clobber the return value. */
2757 /* ??? rms: I think that is erroneous, because in C++ it would
2758 run destructors on variables that might be used in the subsequent
2759 computation of the return value. */
2761 register rtx val
= 0;
2766 /* If function wants no value, give it none. */
2767 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl
))) == VOID_TYPE
)
2769 expand_expr (retval
, NULL_RTX
, VOIDmode
, 0);
2771 expand_null_return ();
2775 /* Are any cleanups needed? E.g. C++ destructors to be run? */
2776 /* This is not sufficient. We also need to watch for cleanups of the
2777 expression we are about to expand. Unfortunately, we cannot know
2778 if it has cleanups until we expand it, and we want to change how we
2779 expand it depending upon if we need cleanups. We can't win. */
2781 cleanups
= any_pending_cleanups (1);
2786 if (TREE_CODE (retval
) == RESULT_DECL
)
2787 retval_rhs
= retval
;
2788 else if ((TREE_CODE (retval
) == MODIFY_EXPR
|| TREE_CODE (retval
) == INIT_EXPR
)
2789 && TREE_CODE (TREE_OPERAND (retval
, 0)) == RESULT_DECL
)
2790 retval_rhs
= TREE_OPERAND (retval
, 1);
2791 else if (TREE_TYPE (retval
) == void_type_node
)
2792 /* Recognize tail-recursive call to void function. */
2793 retval_rhs
= retval
;
2795 retval_rhs
= NULL_TREE
;
2797 /* Only use `last_insn' if there are cleanups which must be run. */
2798 if (cleanups
|| cleanup_label
!= 0)
2799 last_insn
= get_last_insn ();
2801 /* Distribute return down conditional expr if either of the sides
2802 may involve tail recursion (see test below). This enhances the number
2803 of tail recursions we see. Don't do this always since it can produce
2804 sub-optimal code in some cases and we distribute assignments into
2805 conditional expressions when it would help. */
2807 if (optimize
&& retval_rhs
!= 0
2808 && frame_offset
== 0
2809 && TREE_CODE (retval_rhs
) == COND_EXPR
2810 && (TREE_CODE (TREE_OPERAND (retval_rhs
, 1)) == CALL_EXPR
2811 || TREE_CODE (TREE_OPERAND (retval_rhs
, 2)) == CALL_EXPR
))
2813 rtx label
= gen_label_rtx ();
2816 do_jump (TREE_OPERAND (retval_rhs
, 0), label
, NULL_RTX
);
2817 start_cleanup_deferral ();
2818 expr
= build (MODIFY_EXPR
, TREE_TYPE (TREE_TYPE (current_function_decl
)),
2819 DECL_RESULT (current_function_decl
),
2820 TREE_OPERAND (retval_rhs
, 1));
2821 TREE_SIDE_EFFECTS (expr
) = 1;
2822 expand_return (expr
);
2825 expr
= build (MODIFY_EXPR
, TREE_TYPE (TREE_TYPE (current_function_decl
)),
2826 DECL_RESULT (current_function_decl
),
2827 TREE_OPERAND (retval_rhs
, 2));
2828 TREE_SIDE_EFFECTS (expr
) = 1;
2829 expand_return (expr
);
2830 end_cleanup_deferral ();
2834 /* Attempt to optimize the call if it is tail recursive. */
2835 if (optimize_tail_recursion (retval_rhs
, last_insn
))
2839 /* This optimization is safe if there are local cleanups
2840 because expand_null_return takes care of them.
2841 ??? I think it should also be safe when there is a cleanup label,
2842 because expand_null_return takes care of them, too.
2843 Any reason why not? */
2844 if (HAVE_return
&& cleanup_label
== 0
2845 && ! current_function_returns_pcc_struct
2846 && BRANCH_COST
<= 1)
2848 /* If this is return x == y; then generate
2849 if (x == y) return 1; else return 0;
2850 if we can do it with explicit return insns and branches are cheap,
2851 but not if we have the corresponding scc insn. */
2854 switch (TREE_CODE (retval_rhs
))
2880 case TRUTH_ANDIF_EXPR
:
2881 case TRUTH_ORIF_EXPR
:
2882 case TRUTH_AND_EXPR
:
2884 case TRUTH_NOT_EXPR
:
2885 case TRUTH_XOR_EXPR
:
2888 op0
= gen_label_rtx ();
2889 jumpifnot (retval_rhs
, op0
);
2890 expand_value_return (const1_rtx
);
2892 expand_value_return (const0_rtx
);
2901 #endif /* HAVE_return */
2903 /* If the result is an aggregate that is being returned in one (or more)
2904 registers, load the registers here. The compiler currently can't handle
2905 copying a BLKmode value into registers. We could put this code in a
2906 more general area (for use by everyone instead of just function
2907 call/return), but until this feature is generally usable it is kept here
2908 (and in expand_call). The value must go into a pseudo in case there
2909 are cleanups that will clobber the real return register. */
2912 && TYPE_MODE (TREE_TYPE (retval_rhs
)) == BLKmode
2913 && GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl
))) == REG
)
2915 int i
, bitpos
, xbitpos
;
2916 int big_endian_correction
= 0;
2917 int bytes
= int_size_in_bytes (TREE_TYPE (retval_rhs
));
2918 int n_regs
= (bytes
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
2919 int bitsize
= MIN (TYPE_ALIGN (TREE_TYPE (retval_rhs
)),
2920 (unsigned int)BITS_PER_WORD
);
2921 rtx
*result_pseudos
= (rtx
*) alloca (sizeof (rtx
) * n_regs
);
2922 rtx result_reg
, src
= NULL_RTX
, dst
= NULL_RTX
;
2923 rtx result_val
= expand_expr (retval_rhs
, NULL_RTX
, VOIDmode
, 0);
2924 enum machine_mode tmpmode
, result_reg_mode
;
2926 /* Structures whose size is not a multiple of a word are aligned
2927 to the least significant byte (to the right). On a BYTES_BIG_ENDIAN
2928 machine, this means we must skip the empty high order bytes when
2929 calculating the bit offset. */
2930 if (BYTES_BIG_ENDIAN
&& bytes
% UNITS_PER_WORD
)
2931 big_endian_correction
= (BITS_PER_WORD
- ((bytes
% UNITS_PER_WORD
)
2934 /* Copy the structure BITSIZE bits at a time. */
2935 for (bitpos
= 0, xbitpos
= big_endian_correction
;
2936 bitpos
< bytes
* BITS_PER_UNIT
;
2937 bitpos
+= bitsize
, xbitpos
+= bitsize
)
2939 /* We need a new destination pseudo each time xbitpos is
2940 on a word boundary and when xbitpos == big_endian_correction
2941 (the first time through). */
2942 if (xbitpos
% BITS_PER_WORD
== 0
2943 || xbitpos
== big_endian_correction
)
2945 /* Generate an appropriate register. */
2946 dst
= gen_reg_rtx (word_mode
);
2947 result_pseudos
[xbitpos
/ BITS_PER_WORD
] = dst
;
2949 /* Clobber the destination before we move anything into it. */
2950 emit_insn (gen_rtx_CLOBBER (VOIDmode
, dst
));
2953 /* We need a new source operand each time bitpos is on a word
2955 if (bitpos
% BITS_PER_WORD
== 0)
2956 src
= operand_subword_force (result_val
,
2957 bitpos
/ BITS_PER_WORD
,
2960 /* Use bitpos for the source extraction (left justified) and
2961 xbitpos for the destination store (right justified). */
2962 store_bit_field (dst
, bitsize
, xbitpos
% BITS_PER_WORD
, word_mode
,
2963 extract_bit_field (src
, bitsize
,
2964 bitpos
% BITS_PER_WORD
, 1,
2965 NULL_RTX
, word_mode
,
2967 bitsize
/ BITS_PER_UNIT
,
2969 bitsize
/ BITS_PER_UNIT
, BITS_PER_WORD
);
2972 /* Find the smallest integer mode large enough to hold the
2973 entire structure and use that mode instead of BLKmode
2974 on the USE insn for the return register. */
2975 bytes
= int_size_in_bytes (TREE_TYPE (retval_rhs
));
2976 for (tmpmode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
2977 tmpmode
!= VOIDmode
;
2978 tmpmode
= GET_MODE_WIDER_MODE (tmpmode
))
2980 /* Have we found a large enough mode? */
2981 if (GET_MODE_SIZE (tmpmode
) >= bytes
)
2985 /* No suitable mode found. */
2986 if (tmpmode
== VOIDmode
)
2989 PUT_MODE (DECL_RTL (DECL_RESULT (current_function_decl
)), tmpmode
);
2991 if (GET_MODE_SIZE (tmpmode
) < GET_MODE_SIZE (word_mode
))
2992 result_reg_mode
= word_mode
;
2994 result_reg_mode
= tmpmode
;
2995 result_reg
= gen_reg_rtx (result_reg_mode
);
2998 for (i
= 0; i
< n_regs
; i
++)
2999 emit_move_insn (operand_subword (result_reg
, i
, 0, result_reg_mode
),
3002 if (tmpmode
!= result_reg_mode
)
3003 result_reg
= gen_lowpart (tmpmode
, result_reg
);
3005 expand_value_return (result_reg
);
3009 && TREE_TYPE (retval_rhs
) != void_type_node
3010 && GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl
))) == REG
)
3012 /* Calculate the return value into a pseudo reg. */
3013 val
= gen_reg_rtx (DECL_MODE (DECL_RESULT (current_function_decl
)));
3014 val
= expand_expr (retval_rhs
, val
, GET_MODE (val
), 0);
3015 val
= force_not_mem (val
);
3017 /* Return the calculated value, doing cleanups first. */
3018 expand_value_return (val
);
3022 /* No cleanups or no hard reg used;
3023 calculate value into hard return reg. */
3024 expand_expr (retval
, const0_rtx
, VOIDmode
, 0);
3026 expand_value_return (DECL_RTL (DECL_RESULT (current_function_decl
)));
3030 /* Return 1 if the end of the generated RTX is not a barrier.
3031 This means code already compiled can drop through. */
3034 drop_through_at_end_p ()
3036 rtx insn
= get_last_insn ();
3037 while (insn
&& GET_CODE (insn
) == NOTE
)
3038 insn
= PREV_INSN (insn
);
3039 return insn
&& GET_CODE (insn
) != BARRIER
;
3042 /* Test CALL_EXPR to determine if it is a potential tail recursion call
3043 and emit code to optimize the tail recursion. LAST_INSN indicates where
3044 to place the jump to the tail recursion label. Return TRUE if the
3045 call was optimized into a goto.
3047 This is only used by expand_return, but expand_call is expected to
3051 optimize_tail_recursion (call_expr
, last_insn
)
3055 /* For tail-recursive call to current function,
3056 just jump back to the beginning.
3057 It's unsafe if any auto variable in this function
3058 has its address taken; for simplicity,
3059 require stack frame to be empty. */
3060 if (optimize
&& call_expr
!= 0
3061 && frame_offset
== 0
3062 && TREE_CODE (call_expr
) == CALL_EXPR
3063 && TREE_CODE (TREE_OPERAND (call_expr
, 0)) == ADDR_EXPR
3064 && TREE_OPERAND (TREE_OPERAND (call_expr
, 0), 0) == current_function_decl
3065 /* Finish checking validity, and if valid emit code
3066 to set the argument variables for the new call. */
3067 && tail_recursion_args (TREE_OPERAND (call_expr
, 1),
3068 DECL_ARGUMENTS (current_function_decl
)))
3070 if (tail_recursion_label
== 0)
3072 tail_recursion_label
= gen_label_rtx ();
3073 emit_label_after (tail_recursion_label
,
3074 tail_recursion_reentry
);
3077 expand_goto_internal (NULL_TREE
, tail_recursion_label
, last_insn
);
3085 /* Emit code to alter this function's formal parms for a tail-recursive call.
3086 ACTUALS is a list of actual parameter expressions (chain of TREE_LISTs).
3087 FORMALS is the chain of decls of formals.
3088 Return 1 if this can be done;
3089 otherwise return 0 and do not emit any code. */
3092 tail_recursion_args (actuals
, formals
)
3093 tree actuals
, formals
;
3095 register tree a
= actuals
, f
= formals
;
3097 register rtx
*argvec
;
3099 /* Check that number and types of actuals are compatible
3100 with the formals. This is not always true in valid C code.
3101 Also check that no formal needs to be addressable
3102 and that all formals are scalars. */
3104 /* Also count the args. */
3106 for (a
= actuals
, f
= formals
, i
= 0; a
&& f
; a
= TREE_CHAIN (a
), f
= TREE_CHAIN (f
), i
++)
3108 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (a
)))
3109 != TYPE_MAIN_VARIANT (TREE_TYPE (f
)))
3111 if (GET_CODE (DECL_RTL (f
)) != REG
|| DECL_MODE (f
) == BLKmode
)
3114 if (a
!= 0 || f
!= 0)
3117 /* Compute all the actuals. */
3119 argvec
= (rtx
*) alloca (i
* sizeof (rtx
));
3121 for (a
= actuals
, i
= 0; a
; a
= TREE_CHAIN (a
), i
++)
3122 argvec
[i
] = expand_expr (TREE_VALUE (a
), NULL_RTX
, VOIDmode
, 0);
3124 /* Find which actual values refer to current values of previous formals.
3125 Copy each of them now, before any formal is changed. */
3127 for (a
= actuals
, i
= 0; a
; a
= TREE_CHAIN (a
), i
++)
3131 for (f
= formals
, j
= 0; j
< i
; f
= TREE_CHAIN (f
), j
++)
3132 if (reg_mentioned_p (DECL_RTL (f
), argvec
[i
]))
3133 { copy
= 1; break; }
3135 argvec
[i
] = copy_to_reg (argvec
[i
]);
3138 /* Store the values of the actuals into the formals. */
3140 for (f
= formals
, a
= actuals
, i
= 0; f
;
3141 f
= TREE_CHAIN (f
), a
= TREE_CHAIN (a
), i
++)
3143 if (GET_MODE (DECL_RTL (f
)) == GET_MODE (argvec
[i
]))
3144 emit_move_insn (DECL_RTL (f
), argvec
[i
]);
3146 convert_move (DECL_RTL (f
), argvec
[i
],
3147 TREE_UNSIGNED (TREE_TYPE (TREE_VALUE (a
))));
3154 /* Generate the RTL code for entering a binding contour.
3155 The variables are declared one by one, by calls to `expand_decl'.
3157 EXIT_FLAG is nonzero if this construct should be visible to
3158 `exit_something'. */
3161 expand_start_bindings (exit_flag
)
3164 struct nesting
*thisblock
= ALLOC_NESTING ();
3165 rtx note
= emit_note (NULL_PTR
, NOTE_INSN_BLOCK_BEG
);
3167 /* Make an entry on block_stack for the block we are entering. */
3169 thisblock
->next
= block_stack
;
3170 thisblock
->all
= nesting_stack
;
3171 thisblock
->depth
= ++nesting_depth
;
3172 thisblock
->data
.block
.stack_level
= 0;
3173 thisblock
->data
.block
.cleanups
= 0;
3174 thisblock
->data
.block
.n_function_calls
= 0;
3175 thisblock
->data
.block
.exception_region
= 0;
3176 thisblock
->data
.block
.block_target_temp_slot_level
= target_temp_slot_level
;
3178 thisblock
->data
.block
.conditional_code
= 0;
3179 thisblock
->data
.block
.last_unconditional_cleanup
= note
;
3180 thisblock
->data
.block
.cleanup_ptr
= &thisblock
->data
.block
.cleanups
;
3183 && !(block_stack
->data
.block
.cleanups
== NULL_TREE
3184 && block_stack
->data
.block
.outer_cleanups
== NULL_TREE
))
3185 thisblock
->data
.block
.outer_cleanups
3186 = tree_cons (NULL_TREE
, block_stack
->data
.block
.cleanups
,
3187 block_stack
->data
.block
.outer_cleanups
);
3189 thisblock
->data
.block
.outer_cleanups
= 0;
3190 thisblock
->data
.block
.label_chain
= 0;
3191 thisblock
->data
.block
.innermost_stack_block
= stack_block_stack
;
3192 thisblock
->data
.block
.first_insn
= note
;
3193 thisblock
->data
.block
.block_start_count
= ++current_block_start_count
;
3194 thisblock
->exit_label
= exit_flag
? gen_label_rtx () : 0;
3195 block_stack
= thisblock
;
3196 nesting_stack
= thisblock
;
3198 /* Make a new level for allocating stack slots. */
3202 /* Specify the scope of temporaries created by TARGET_EXPRs. Similar
3203 to CLEANUP_POINT_EXPR, but handles cases when a series of calls to
3204 expand_expr are made. After we end the region, we know that all
3205 space for all temporaries that were created by TARGET_EXPRs will be
3206 destroyed and their space freed for reuse. */
3209 expand_start_target_temps ()
3211 /* This is so that even if the result is preserved, the space
3212 allocated will be freed, as we know that it is no longer in use. */
3215 /* Start a new binding layer that will keep track of all cleanup
3216 actions to be performed. */
3217 expand_start_bindings (0);
3219 target_temp_slot_level
= temp_slot_level
;
3223 expand_end_target_temps ()
3225 expand_end_bindings (NULL_TREE
, 0, 0);
3227 /* This is so that even if the result is preserved, the space
3228 allocated will be freed, as we know that it is no longer in use. */
3232 /* Mark top block of block_stack as an implicit binding for an
3233 exception region. This is used to prevent infinite recursion when
3234 ending a binding with expand_end_bindings. It is only ever called
3235 by expand_eh_region_start, as that it the only way to create a
3236 block stack for a exception region. */
3239 mark_block_as_eh_region ()
3241 block_stack
->data
.block
.exception_region
= 1;
3242 if (block_stack
->next
3243 && block_stack
->next
->data
.block
.conditional_code
)
3245 block_stack
->data
.block
.conditional_code
3246 = block_stack
->next
->data
.block
.conditional_code
;
3247 block_stack
->data
.block
.last_unconditional_cleanup
3248 = block_stack
->next
->data
.block
.last_unconditional_cleanup
;
3249 block_stack
->data
.block
.cleanup_ptr
3250 = block_stack
->next
->data
.block
.cleanup_ptr
;
3254 /* True if we are currently emitting insns in an area of output code
3255 that is controlled by a conditional expression. This is used by
3256 the cleanup handling code to generate conditional cleanup actions. */
3259 conditional_context ()
3261 return block_stack
&& block_stack
->data
.block
.conditional_code
;
3264 /* Mark top block of block_stack as not for an implicit binding for an
3265 exception region. This is only ever done by expand_eh_region_end
3266 to let expand_end_bindings know that it is being called explicitly
3267 to end the binding layer for just the binding layer associated with
3268 the exception region, otherwise expand_end_bindings would try and
3269 end all implicit binding layers for exceptions regions, and then
3270 one normal binding layer. */
3273 mark_block_as_not_eh_region ()
3275 block_stack
->data
.block
.exception_region
= 0;
3278 /* True if the top block of block_stack was marked as for an exception
3279 region by mark_block_as_eh_region. */
3284 return (current_function
&& block_stack
3285 && block_stack
->data
.block
.exception_region
);
3288 /* Given a pointer to a BLOCK node, save a pointer to the most recently
3289 generated NOTE_INSN_BLOCK_END in the BLOCK_END_NOTE field of the given
3293 remember_end_note (block
)
3294 register tree block
;
3296 BLOCK_END_NOTE (block
) = last_block_end_note
;
3297 last_block_end_note
= NULL_RTX
;
3300 /* Emit a handler label for a nonlocal goto handler.
3301 Also emit code to store the handler label in SLOT before BEFORE_INSN. */
3304 expand_nl_handler_label (slot
, before_insn
)
3305 rtx slot
, before_insn
;
3308 rtx handler_label
= gen_label_rtx ();
3310 /* Don't let jump_optimize delete the handler. */
3311 LABEL_PRESERVE_P (handler_label
) = 1;
3314 emit_move_insn (slot
, gen_rtx_LABEL_REF (Pmode
, handler_label
));
3315 insns
= get_insns ();
3317 emit_insns_before (insns
, before_insn
);
3319 emit_label (handler_label
);
3321 return handler_label
;
3324 /* Emit code to restore vital registers at the beginning of a nonlocal goto
3327 expand_nl_goto_receiver ()
3329 #ifdef HAVE_nonlocal_goto
3330 if (! HAVE_nonlocal_goto
)
3332 /* First adjust our frame pointer to its actual value. It was
3333 previously set to the start of the virtual area corresponding to
3334 the stacked variables when we branched here and now needs to be
3335 adjusted to the actual hardware fp value.
3337 Assignments are to virtual registers are converted by
3338 instantiate_virtual_regs into the corresponding assignment
3339 to the underlying register (fp in this case) that makes
3340 the original assignment true.
3341 So the following insn will actually be
3342 decrementing fp by STARTING_FRAME_OFFSET. */
3343 emit_move_insn (virtual_stack_vars_rtx
, hard_frame_pointer_rtx
);
3345 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
3346 if (fixed_regs
[ARG_POINTER_REGNUM
])
3348 #ifdef ELIMINABLE_REGS
3349 /* If the argument pointer can be eliminated in favor of the
3350 frame pointer, we don't need to restore it. We assume here
3351 that if such an elimination is present, it can always be used.
3352 This is the case on all known machines; if we don't make this
3353 assumption, we do unnecessary saving on many machines. */
3354 static struct elims
{int from
, to
;} elim_regs
[] = ELIMINABLE_REGS
;
3357 for (i
= 0; i
< sizeof elim_regs
/ sizeof elim_regs
[0]; i
++)
3358 if (elim_regs
[i
].from
== ARG_POINTER_REGNUM
3359 && elim_regs
[i
].to
== HARD_FRAME_POINTER_REGNUM
)
3362 if (i
== sizeof elim_regs
/ sizeof elim_regs
[0])
3365 /* Now restore our arg pointer from the address at which it
3366 was saved in our stack frame.
3367 If there hasn't be space allocated for it yet, make
3369 if (arg_pointer_save_area
== 0)
3370 arg_pointer_save_area
3371 = assign_stack_local (Pmode
, GET_MODE_SIZE (Pmode
), 0);
3372 emit_move_insn (virtual_incoming_args_rtx
,
3373 /* We need a pseudo here, or else
3374 instantiate_virtual_regs_1 complains. */
3375 copy_to_reg (arg_pointer_save_area
));
3380 #ifdef HAVE_nonlocal_goto_receiver
3381 if (HAVE_nonlocal_goto_receiver
)
3382 emit_insn (gen_nonlocal_goto_receiver ());
3386 /* Make handlers for nonlocal gotos taking place in the function calls in
3390 expand_nl_goto_receivers (thisblock
)
3391 struct nesting
*thisblock
;
3394 rtx afterward
= gen_label_rtx ();
3399 /* Record the handler address in the stack slot for that purpose,
3400 during this block, saving and restoring the outer value. */
3401 if (thisblock
->next
!= 0)
3402 for (slot
= nonlocal_goto_handler_slots
; slot
; slot
= XEXP (slot
, 1))
3404 rtx save_receiver
= gen_reg_rtx (Pmode
);
3405 emit_move_insn (XEXP (slot
, 0), save_receiver
);
3408 emit_move_insn (save_receiver
, XEXP (slot
, 0));
3409 insns
= get_insns ();
3411 emit_insns_before (insns
, thisblock
->data
.block
.first_insn
);
3414 /* Jump around the handlers; they run only when specially invoked. */
3415 emit_jump (afterward
);
3417 /* Make a separate handler for each label. */
3418 link
= nonlocal_labels
;
3419 slot
= nonlocal_goto_handler_slots
;
3420 label_list
= NULL_RTX
;
3421 for (; link
; link
= TREE_CHAIN (link
), slot
= XEXP (slot
, 1))
3422 /* Skip any labels we shouldn't be able to jump to from here,
3423 we generate one special handler for all of them below which just calls
3425 if (! DECL_TOO_LATE (TREE_VALUE (link
)))
3428 lab
= expand_nl_handler_label (XEXP (slot
, 0),
3429 thisblock
->data
.block
.first_insn
);
3430 label_list
= gen_rtx_EXPR_LIST (VOIDmode
, lab
, label_list
);
3432 expand_nl_goto_receiver ();
3434 /* Jump to the "real" nonlocal label. */
3435 expand_goto (TREE_VALUE (link
));
3438 /* A second pass over all nonlocal labels; this time we handle those
3439 we should not be able to jump to at this point. */
3440 link
= nonlocal_labels
;
3441 slot
= nonlocal_goto_handler_slots
;
3443 for (; link
; link
= TREE_CHAIN (link
), slot
= XEXP (slot
, 1))
3444 if (DECL_TOO_LATE (TREE_VALUE (link
)))
3447 lab
= expand_nl_handler_label (XEXP (slot
, 0),
3448 thisblock
->data
.block
.first_insn
);
3449 label_list
= gen_rtx_EXPR_LIST (VOIDmode
, lab
, label_list
);
3455 expand_nl_goto_receiver ();
3456 emit_library_call (gen_rtx_SYMBOL_REF (Pmode
, "abort"), 0,
3461 nonlocal_goto_handler_labels
= label_list
;
3462 emit_label (afterward
);
3465 /* Generate RTL code to terminate a binding contour.
3467 VARS is the chain of VAR_DECL nodes for the variables bound in this
3468 contour. There may actually be other nodes in this chain, but any
3469 nodes other than VAR_DECLS are ignored.
3471 MARK_ENDS is nonzero if we should put a note at the beginning
3472 and end of this binding contour.
3474 DONT_JUMP_IN is nonzero if it is not valid to jump into this contour.
3475 (That is true automatically if the contour has a saved stack level.) */
3478 expand_end_bindings (vars
, mark_ends
, dont_jump_in
)
3483 register struct nesting
*thisblock
;
3486 while (block_stack
->data
.block
.exception_region
)
3488 /* Because we don't need or want a new temporary level and
3489 because we didn't create one in expand_eh_region_start,
3490 create a fake one now to avoid removing one in
3491 expand_end_bindings. */
3494 block_stack
->data
.block
.exception_region
= 0;
3496 expand_end_bindings (NULL_TREE
, 0, 0);
3499 /* Since expand_eh_region_start does an expand_start_bindings, we
3500 have to first end all the bindings that were created by
3501 expand_eh_region_start. */
3503 thisblock
= block_stack
;
3506 for (decl
= vars
; decl
; decl
= TREE_CHAIN (decl
))
3507 if (TREE_CODE (decl
) == VAR_DECL
3508 && ! TREE_USED (decl
)
3509 && ! DECL_IN_SYSTEM_HEADER (decl
)
3510 && DECL_NAME (decl
) && ! DECL_ARTIFICIAL (decl
))
3511 warning_with_decl (decl
, "unused variable `%s'");
3513 if (thisblock
->exit_label
)
3515 do_pending_stack_adjust ();
3516 emit_label (thisblock
->exit_label
);
3519 /* If necessary, make handlers for nonlocal gotos taking
3520 place in the function calls in this block. */
3521 if (function_call_count
!= thisblock
->data
.block
.n_function_calls
3523 /* Make handler for outermost block
3524 if there were any nonlocal gotos to this function. */
3525 && (thisblock
->next
== 0 ? current_function_has_nonlocal_label
3526 /* Make handler for inner block if it has something
3527 special to do when you jump out of it. */
3528 : (thisblock
->data
.block
.cleanups
!= 0
3529 || thisblock
->data
.block
.stack_level
!= 0)))
3530 expand_nl_goto_receivers (thisblock
);
3532 /* Don't allow jumping into a block that has a stack level.
3533 Cleanups are allowed, though. */
3535 || thisblock
->data
.block
.stack_level
!= 0)
3537 struct label_chain
*chain
;
3539 /* Any labels in this block are no longer valid to go to.
3540 Mark them to cause an error message. */
3541 for (chain
= thisblock
->data
.block
.label_chain
; chain
; chain
= chain
->next
)
3543 DECL_TOO_LATE (chain
->label
) = 1;
3544 /* If any goto without a fixup came to this label,
3545 that must be an error, because gotos without fixups
3546 come from outside all saved stack-levels. */
3547 if (TREE_ADDRESSABLE (chain
->label
))
3548 error_with_decl (chain
->label
,
3549 "label `%s' used before containing binding contour");
3553 /* Restore stack level in effect before the block
3554 (only if variable-size objects allocated). */
3555 /* Perform any cleanups associated with the block. */
3557 if (thisblock
->data
.block
.stack_level
!= 0
3558 || thisblock
->data
.block
.cleanups
!= 0)
3560 /* Only clean up here if this point can actually be reached. */
3561 int reachable
= GET_CODE (get_last_insn ()) != BARRIER
;
3563 /* Don't let cleanups affect ({...}) constructs. */
3564 int old_expr_stmts_for_value
= expr_stmts_for_value
;
3565 rtx old_last_expr_value
= last_expr_value
;
3566 tree old_last_expr_type
= last_expr_type
;
3567 expr_stmts_for_value
= 0;
3569 /* Do the cleanups. */
3570 expand_cleanups (thisblock
->data
.block
.cleanups
, NULL_TREE
, 0, reachable
);
3572 do_pending_stack_adjust ();
3574 expr_stmts_for_value
= old_expr_stmts_for_value
;
3575 last_expr_value
= old_last_expr_value
;
3576 last_expr_type
= old_last_expr_type
;
3578 /* Restore the stack level. */
3580 if (reachable
&& thisblock
->data
.block
.stack_level
!= 0)
3582 emit_stack_restore (thisblock
->next
? SAVE_BLOCK
: SAVE_FUNCTION
,
3583 thisblock
->data
.block
.stack_level
, NULL_RTX
);
3584 if (nonlocal_goto_handler_slots
!= 0)
3585 emit_stack_save (SAVE_NONLOCAL
, &nonlocal_goto_stack_level
,
3589 /* Any gotos out of this block must also do these things.
3590 Also report any gotos with fixups that came to labels in this
3592 fixup_gotos (thisblock
,
3593 thisblock
->data
.block
.stack_level
,
3594 thisblock
->data
.block
.cleanups
,
3595 thisblock
->data
.block
.first_insn
,
3599 /* Mark the beginning and end of the scope if requested.
3600 We do this now, after running cleanups on the variables
3601 just going out of scope, so they are in scope for their cleanups. */
3604 last_block_end_note
= emit_note (NULL_PTR
, NOTE_INSN_BLOCK_END
);
3606 /* Get rid of the beginning-mark if we don't make an end-mark. */
3607 NOTE_LINE_NUMBER (thisblock
->data
.block
.first_insn
) = NOTE_INSN_DELETED
;
3609 /* If doing stupid register allocation, make sure lives of all
3610 register variables declared here extend thru end of scope. */
3613 for (decl
= vars
; decl
; decl
= TREE_CHAIN (decl
))
3614 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_RTL (decl
))
3615 use_variable (DECL_RTL (decl
));
3617 /* Restore the temporary level of TARGET_EXPRs. */
3618 target_temp_slot_level
= thisblock
->data
.block
.block_target_temp_slot_level
;
3620 /* Restore block_stack level for containing block. */
3622 stack_block_stack
= thisblock
->data
.block
.innermost_stack_block
;
3623 POPSTACK (block_stack
);
3625 /* Pop the stack slot nesting and free any slots at this level. */
3629 /* Generate RTL for the automatic variable declaration DECL.
3630 (Other kinds of declarations are simply ignored if seen here.) */
3636 struct nesting
*thisblock
;
3639 type
= TREE_TYPE (decl
);
3641 /* Only automatic variables need any expansion done.
3642 Static and external variables, and external functions,
3643 will be handled by `assemble_variable' (called from finish_decl).
3644 TYPE_DECL and CONST_DECL require nothing.
3645 PARM_DECLs are handled in `assign_parms'. */
3647 if (TREE_CODE (decl
) != VAR_DECL
)
3649 if (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
))
3652 thisblock
= block_stack
;
3654 /* Create the RTL representation for the variable. */
3656 if (type
== error_mark_node
)
3657 DECL_RTL (decl
) = gen_rtx_MEM (BLKmode
, const0_rtx
);
3658 else if (DECL_SIZE (decl
) == 0)
3659 /* Variable with incomplete type. */
3661 if (DECL_INITIAL (decl
) == 0)
3662 /* Error message was already done; now avoid a crash. */
3663 DECL_RTL (decl
) = assign_stack_temp (DECL_MODE (decl
), 0, 1);
3665 /* An initializer is going to decide the size of this array.
3666 Until we know the size, represent its address with a reg. */
3667 DECL_RTL (decl
) = gen_rtx_MEM (BLKmode
, gen_reg_rtx (Pmode
));
3668 MEM_SET_IN_STRUCT_P (DECL_RTL (decl
), AGGREGATE_TYPE_P (type
));
3670 else if (DECL_MODE (decl
) != BLKmode
3671 /* If -ffloat-store, don't put explicit float vars
3673 && !(flag_float_store
3674 && TREE_CODE (type
) == REAL_TYPE
)
3675 && ! TREE_THIS_VOLATILE (decl
)
3676 && ! TREE_ADDRESSABLE (decl
)
3677 && (DECL_REGISTER (decl
) || ! obey_regdecls
)
3678 /* if -fcheck-memory-usage, check all variables. */
3679 && ! current_function_check_memory_usage
)
3681 /* Automatic variable that can go in a register. */
3682 int unsignedp
= TREE_UNSIGNED (type
);
3683 enum machine_mode reg_mode
3684 = promote_mode (type
, DECL_MODE (decl
), &unsignedp
, 0);
3686 DECL_RTL (decl
) = gen_reg_rtx (reg_mode
);
3687 mark_user_reg (DECL_RTL (decl
));
3689 if (POINTER_TYPE_P (type
))
3690 mark_reg_pointer (DECL_RTL (decl
),
3691 (TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl
)))
3695 else if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
3696 && ! (flag_stack_check
&& ! STACK_CHECK_BUILTIN
3697 && (TREE_INT_CST_HIGH (DECL_SIZE (decl
)) != 0
3698 || (TREE_INT_CST_LOW (DECL_SIZE (decl
))
3699 > STACK_CHECK_MAX_VAR_SIZE
* BITS_PER_UNIT
))))
3701 /* Variable of fixed size that goes on the stack. */
3705 /* If we previously made RTL for this decl, it must be an array
3706 whose size was determined by the initializer.
3707 The old address was a register; set that register now
3708 to the proper address. */
3709 if (DECL_RTL (decl
) != 0)
3711 if (GET_CODE (DECL_RTL (decl
)) != MEM
3712 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != REG
)
3714 oldaddr
= XEXP (DECL_RTL (decl
), 0);
3717 DECL_RTL (decl
) = assign_temp (TREE_TYPE (decl
), 1, 1, 1);
3718 MEM_SET_IN_STRUCT_P (DECL_RTL (decl
),
3719 AGGREGATE_TYPE_P (TREE_TYPE (decl
)));
3721 /* Set alignment we actually gave this decl. */
3722 DECL_ALIGN (decl
) = (DECL_MODE (decl
) == BLKmode
? BIGGEST_ALIGNMENT
3723 : GET_MODE_BITSIZE (DECL_MODE (decl
)));
3727 addr
= force_operand (XEXP (DECL_RTL (decl
), 0), oldaddr
);
3728 if (addr
!= oldaddr
)
3729 emit_move_insn (oldaddr
, addr
);
3732 /* If this is a memory ref that contains aggregate components,
3733 mark it as such for cse and loop optimize. */
3734 MEM_SET_IN_STRUCT_P (DECL_RTL (decl
),
3735 AGGREGATE_TYPE_P (TREE_TYPE (decl
)));
3737 /* If this is in memory because of -ffloat-store,
3738 set the volatile bit, to prevent optimizations from
3739 undoing the effects. */
3740 if (flag_float_store
&& TREE_CODE (type
) == REAL_TYPE
)
3741 MEM_VOLATILE_P (DECL_RTL (decl
)) = 1;
3744 MEM_ALIAS_SET (DECL_RTL (decl
)) = get_alias_set (decl
);
3747 /* Dynamic-size object: must push space on the stack. */
3751 /* Record the stack pointer on entry to block, if have
3752 not already done so. */
3753 if (thisblock
->data
.block
.stack_level
== 0)
3755 do_pending_stack_adjust ();
3756 emit_stack_save (thisblock
->next
? SAVE_BLOCK
: SAVE_FUNCTION
,
3757 &thisblock
->data
.block
.stack_level
,
3758 thisblock
->data
.block
.first_insn
);
3759 stack_block_stack
= thisblock
;
3762 /* Compute the variable's size, in bytes. */
3763 size
= expand_expr (size_binop (CEIL_DIV_EXPR
,
3765 size_int (BITS_PER_UNIT
)),
3766 NULL_RTX
, VOIDmode
, 0);
3769 /* Allocate space on the stack for the variable. Note that
3770 DECL_ALIGN says how the variable is to be aligned and we
3771 cannot use it to conclude anything about the alignment of
3773 address
= allocate_dynamic_stack_space (size
, NULL_RTX
,
3774 TYPE_ALIGN (TREE_TYPE (decl
)));
3776 /* Reference the variable indirect through that rtx. */
3777 DECL_RTL (decl
) = gen_rtx_MEM (DECL_MODE (decl
), address
);
3779 /* If this is a memory ref that contains aggregate components,
3780 mark it as such for cse and loop optimize. */
3781 MEM_SET_IN_STRUCT_P (DECL_RTL (decl
),
3782 AGGREGATE_TYPE_P (TREE_TYPE (decl
)));
3784 /* Indicate the alignment we actually gave this variable. */
3785 #ifdef STACK_BOUNDARY
3786 DECL_ALIGN (decl
) = STACK_BOUNDARY
;
3788 DECL_ALIGN (decl
) = BIGGEST_ALIGNMENT
;
3792 if (TREE_THIS_VOLATILE (decl
))
3793 MEM_VOLATILE_P (DECL_RTL (decl
)) = 1;
3794 #if 0 /* A variable is not necessarily unchanging
3795 just because it is const. RTX_UNCHANGING_P
3796 means no change in the function,
3797 not merely no change in the variable's scope.
3798 It is correct to set RTX_UNCHANGING_P if the variable's scope
3799 is the whole function. There's no convenient way to test that. */
3800 if (TREE_READONLY (decl
))
3801 RTX_UNCHANGING_P (DECL_RTL (decl
)) = 1;
3804 /* If doing stupid register allocation, make sure life of any
3805 register variable starts here, at the start of its scope. */
3808 use_variable (DECL_RTL (decl
));
3813 /* Emit code to perform the initialization of a declaration DECL. */
3816 expand_decl_init (decl
)
3819 int was_used
= TREE_USED (decl
);
3821 /* If this is a CONST_DECL, we don't have to generate any code, but
3822 if DECL_INITIAL is a constant, call expand_expr to force TREE_CST_RTL
3823 to be set while in the obstack containing the constant. If we don't
3824 do this, we can lose if we have functions nested three deep and the middle
3825 function makes a CONST_DECL whose DECL_INITIAL is a STRING_CST while
3826 the innermost function is the first to expand that STRING_CST. */
3827 if (TREE_CODE (decl
) == CONST_DECL
)
3829 if (DECL_INITIAL (decl
) && TREE_CONSTANT (DECL_INITIAL (decl
)))
3830 expand_expr (DECL_INITIAL (decl
), NULL_RTX
, VOIDmode
,
3831 EXPAND_INITIALIZER
);
3835 if (TREE_STATIC (decl
))
3838 /* Compute and store the initial value now. */
3840 if (DECL_INITIAL (decl
) == error_mark_node
)
3842 enum tree_code code
= TREE_CODE (TREE_TYPE (decl
));
3844 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== ENUMERAL_TYPE
3845 || code
== POINTER_TYPE
|| code
== REFERENCE_TYPE
)
3846 expand_assignment (decl
, convert (TREE_TYPE (decl
), integer_zero_node
),
3850 else if (DECL_INITIAL (decl
) && TREE_CODE (DECL_INITIAL (decl
)) != TREE_LIST
)
3852 emit_line_note (DECL_SOURCE_FILE (decl
), DECL_SOURCE_LINE (decl
));
3853 expand_assignment (decl
, DECL_INITIAL (decl
), 0, 0);
3857 /* Don't let the initialization count as "using" the variable. */
3858 TREE_USED (decl
) = was_used
;
3860 /* Free any temporaries we made while initializing the decl. */
3861 preserve_temp_slots (NULL_RTX
);
3865 /* CLEANUP is an expression to be executed at exit from this binding contour;
3866 for example, in C++, it might call the destructor for this variable.
3868 We wrap CLEANUP in an UNSAVE_EXPR node, so that we can expand the
3869 CLEANUP multiple times, and have the correct semantics. This
3870 happens in exception handling, for gotos, returns, breaks that
3871 leave the current scope.
3873 If CLEANUP is nonzero and DECL is zero, we record a cleanup
3874 that is not associated with any particular variable. */
3877 expand_decl_cleanup (decl
, cleanup
)
3880 struct nesting
*thisblock
;
3882 /* Error if we are not in any block. */
3883 if (current_function
== 0 || block_stack
== 0)
3886 thisblock
= block_stack
;
3888 /* Record the cleanup if there is one. */
3894 tree
*cleanups
= &thisblock
->data
.block
.cleanups
;
3895 int cond_context
= conditional_context ();
3899 rtx flag
= gen_reg_rtx (word_mode
);
3904 emit_move_insn (flag
, const0_rtx
);
3905 set_flag_0
= get_insns ();
3908 thisblock
->data
.block
.last_unconditional_cleanup
3909 = emit_insns_after (set_flag_0
,
3910 thisblock
->data
.block
.last_unconditional_cleanup
);
3912 emit_move_insn (flag
, const1_rtx
);
3914 /* All cleanups must be on the function_obstack. */
3915 push_obstacks_nochange ();
3916 resume_temporary_allocation ();
3918 cond
= build_decl (VAR_DECL
, NULL_TREE
, type_for_mode (word_mode
, 1));
3919 DECL_RTL (cond
) = flag
;
3921 /* Conditionalize the cleanup. */
3922 cleanup
= build (COND_EXPR
, void_type_node
,
3923 truthvalue_conversion (cond
),
3924 cleanup
, integer_zero_node
);
3925 cleanup
= fold (cleanup
);
3929 cleanups
= thisblock
->data
.block
.cleanup_ptr
;
3932 /* All cleanups must be on the function_obstack. */
3933 push_obstacks_nochange ();
3934 resume_temporary_allocation ();
3935 cleanup
= unsave_expr (cleanup
);
3938 t
= *cleanups
= temp_tree_cons (decl
, cleanup
, *cleanups
);
3941 /* If this block has a cleanup, it belongs in stack_block_stack. */
3942 stack_block_stack
= thisblock
;
3949 /* If this was optimized so that there is no exception region for the
3950 cleanup, then mark the TREE_LIST node, so that we can later tell
3951 if we need to call expand_eh_region_end. */
3952 if (! using_eh_for_cleanups_p
3953 || expand_eh_region_start_tree (decl
, cleanup
))
3954 TREE_ADDRESSABLE (t
) = 1;
3955 /* If that started a new EH region, we're in a new block. */
3956 thisblock
= block_stack
;
3963 thisblock
->data
.block
.last_unconditional_cleanup
3964 = emit_insns_after (seq
,
3965 thisblock
->data
.block
.last_unconditional_cleanup
);
3969 thisblock
->data
.block
.last_unconditional_cleanup
3971 thisblock
->data
.block
.cleanup_ptr
= &thisblock
->data
.block
.cleanups
;
3977 /* Like expand_decl_cleanup, but suppress generating an exception handler
3978 to perform the cleanup. */
3981 expand_decl_cleanup_no_eh (decl
, cleanup
)
3984 int save_eh
= using_eh_for_cleanups_p
;
3987 using_eh_for_cleanups_p
= 0;
3988 result
= expand_decl_cleanup (decl
, cleanup
);
3989 using_eh_for_cleanups_p
= save_eh
;
3994 /* Arrange for the top element of the dynamic cleanup chain to be
3995 popped if we exit the current binding contour. DECL is the
3996 associated declaration, if any, otherwise NULL_TREE. If the
3997 current contour is left via an exception, then __sjthrow will pop
3998 the top element off the dynamic cleanup chain. The code that
3999 avoids doing the action we push into the cleanup chain in the
4000 exceptional case is contained in expand_cleanups.
4002 This routine is only used by expand_eh_region_start, and that is
4003 the only way in which an exception region should be started. This
4004 routine is only used when using the setjmp/longjmp codegen method
4005 for exception handling. */
4008 expand_dcc_cleanup (decl
)
4011 struct nesting
*thisblock
;
4014 /* Error if we are not in any block. */
4015 if (current_function
== 0 || block_stack
== 0)
4017 thisblock
= block_stack
;
4019 /* Record the cleanup for the dynamic handler chain. */
4021 /* All cleanups must be on the function_obstack. */
4022 push_obstacks_nochange ();
4023 resume_temporary_allocation ();
4024 cleanup
= make_node (POPDCC_EXPR
);
4027 /* Add the cleanup in a manner similar to expand_decl_cleanup. */
4028 thisblock
->data
.block
.cleanups
4029 = temp_tree_cons (decl
, cleanup
, thisblock
->data
.block
.cleanups
);
4031 /* If this block has a cleanup, it belongs in stack_block_stack. */
4032 stack_block_stack
= thisblock
;
4036 /* Arrange for the top element of the dynamic handler chain to be
4037 popped if we exit the current binding contour. DECL is the
4038 associated declaration, if any, otherwise NULL_TREE. If the current
4039 contour is left via an exception, then __sjthrow will pop the top
4040 element off the dynamic handler chain. The code that avoids doing
4041 the action we push into the handler chain in the exceptional case
4042 is contained in expand_cleanups.
4044 This routine is only used by expand_eh_region_start, and that is
4045 the only way in which an exception region should be started. This
4046 routine is only used when using the setjmp/longjmp codegen method
4047 for exception handling. */
4050 expand_dhc_cleanup (decl
)
4053 struct nesting
*thisblock
;
4056 /* Error if we are not in any block. */
4057 if (current_function
== 0 || block_stack
== 0)
4059 thisblock
= block_stack
;
4061 /* Record the cleanup for the dynamic handler chain. */
4063 /* All cleanups must be on the function_obstack. */
4064 push_obstacks_nochange ();
4065 resume_temporary_allocation ();
4066 cleanup
= make_node (POPDHC_EXPR
);
4069 /* Add the cleanup in a manner similar to expand_decl_cleanup. */
4070 thisblock
->data
.block
.cleanups
4071 = temp_tree_cons (decl
, cleanup
, thisblock
->data
.block
.cleanups
);
4073 /* If this block has a cleanup, it belongs in stack_block_stack. */
4074 stack_block_stack
= thisblock
;
4078 /* DECL is an anonymous union. CLEANUP is a cleanup for DECL.
4079 DECL_ELTS is the list of elements that belong to DECL's type.
4080 In each, the TREE_VALUE is a VAR_DECL, and the TREE_PURPOSE a cleanup. */
4083 expand_anon_union_decl (decl
, cleanup
, decl_elts
)
4084 tree decl
, cleanup
, decl_elts
;
4086 struct nesting
*thisblock
= current_function
== 0 ? 0 : block_stack
;
4090 expand_decl_cleanup (decl
, cleanup
);
4091 x
= DECL_RTL (decl
);
4095 tree decl_elt
= TREE_VALUE (decl_elts
);
4096 tree cleanup_elt
= TREE_PURPOSE (decl_elts
);
4097 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (decl_elt
));
4099 /* Propagate the union's alignment to the elements. */
4100 DECL_ALIGN (decl_elt
) = DECL_ALIGN (decl
);
4102 /* If the element has BLKmode and the union doesn't, the union is
4103 aligned such that the element doesn't need to have BLKmode, so
4104 change the element's mode to the appropriate one for its size. */
4105 if (mode
== BLKmode
&& DECL_MODE (decl
) != BLKmode
)
4106 DECL_MODE (decl_elt
) = mode
4107 = mode_for_size (TREE_INT_CST_LOW (DECL_SIZE (decl_elt
)),
4110 /* (SUBREG (MEM ...)) at RTL generation time is invalid, so we
4111 instead create a new MEM rtx with the proper mode. */
4112 if (GET_CODE (x
) == MEM
)
4114 if (mode
== GET_MODE (x
))
4115 DECL_RTL (decl_elt
) = x
;
4118 DECL_RTL (decl_elt
) = gen_rtx_MEM (mode
, copy_rtx (XEXP (x
, 0)));
4119 MEM_COPY_ATTRIBUTES (DECL_RTL (decl_elt
), x
);
4120 RTX_UNCHANGING_P (DECL_RTL (decl_elt
)) = RTX_UNCHANGING_P (x
);
4123 else if (GET_CODE (x
) == REG
)
4125 if (mode
== GET_MODE (x
))
4126 DECL_RTL (decl_elt
) = x
;
4128 DECL_RTL (decl_elt
) = gen_rtx_SUBREG (mode
, x
, 0);
4133 /* Record the cleanup if there is one. */
4136 thisblock
->data
.block
.cleanups
4137 = temp_tree_cons (decl_elt
, cleanup_elt
,
4138 thisblock
->data
.block
.cleanups
);
4140 decl_elts
= TREE_CHAIN (decl_elts
);
4144 /* Expand a list of cleanups LIST.
4145 Elements may be expressions or may be nested lists.
4147 If DONT_DO is nonnull, then any list-element
4148 whose TREE_PURPOSE matches DONT_DO is omitted.
4149 This is sometimes used to avoid a cleanup associated with
4150 a value that is being returned out of the scope.
4152 If IN_FIXUP is non-zero, we are generating this cleanup for a fixup
4153 goto and handle protection regions specially in that case.
4155 If REACHABLE, we emit code, otherwise just inform the exception handling
4156 code about this finalization. */
4159 expand_cleanups (list
, dont_do
, in_fixup
, reachable
)
4166 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
4167 if (dont_do
== 0 || TREE_PURPOSE (tail
) != dont_do
)
4169 if (TREE_CODE (TREE_VALUE (tail
)) == TREE_LIST
)
4170 expand_cleanups (TREE_VALUE (tail
), dont_do
, in_fixup
, reachable
);
4175 tree cleanup
= TREE_VALUE (tail
);
4177 /* See expand_d{h,c}c_cleanup for why we avoid this. */
4178 if (TREE_CODE (cleanup
) != POPDHC_EXPR
4179 && TREE_CODE (cleanup
) != POPDCC_EXPR
4180 /* See expand_eh_region_start_tree for this case. */
4181 && ! TREE_ADDRESSABLE (tail
))
4183 cleanup
= protect_with_terminate (cleanup
);
4184 expand_eh_region_end (cleanup
);
4190 /* Cleanups may be run multiple times. For example,
4191 when exiting a binding contour, we expand the
4192 cleanups associated with that contour. When a goto
4193 within that binding contour has a target outside that
4194 contour, it will expand all cleanups from its scope to
4195 the target. Though the cleanups are expanded multiple
4196 times, the control paths are non-overlapping so the
4197 cleanups will not be executed twice. */
4199 /* We may need to protect fixups with rethrow regions. */
4200 int protect
= (in_fixup
&& ! TREE_ADDRESSABLE (tail
));
4203 expand_fixup_region_start ();
4205 expand_expr (TREE_VALUE (tail
), const0_rtx
, VOIDmode
, 0);
4207 expand_fixup_region_end (TREE_VALUE (tail
));
4214 /* Mark when the context we are emitting RTL for as a conditional
4215 context, so that any cleanup actions we register with
4216 expand_decl_init will be properly conditionalized when those
4217 cleanup actions are later performed. Must be called before any
4218 expression (tree) is expanded that is within a conditional context. */
4221 start_cleanup_deferral ()
4223 /* block_stack can be NULL if we are inside the parameter list. It is
4224 OK to do nothing, because cleanups aren't possible here. */
4226 ++block_stack
->data
.block
.conditional_code
;
4229 /* Mark the end of a conditional region of code. Because cleanup
4230 deferrals may be nested, we may still be in a conditional region
4231 after we end the currently deferred cleanups, only after we end all
4232 deferred cleanups, are we back in unconditional code. */
4235 end_cleanup_deferral ()
4237 /* block_stack can be NULL if we are inside the parameter list. It is
4238 OK to do nothing, because cleanups aren't possible here. */
4240 --block_stack
->data
.block
.conditional_code
;
4243 /* Move all cleanups from the current block_stack
4244 to the containing block_stack, where they are assumed to
4245 have been created. If anything can cause a temporary to
4246 be created, but not expanded for more than one level of
4247 block_stacks, then this code will have to change. */
4252 struct nesting
*block
= block_stack
;
4253 struct nesting
*outer
= block
->next
;
4255 outer
->data
.block
.cleanups
4256 = chainon (block
->data
.block
.cleanups
,
4257 outer
->data
.block
.cleanups
);
4258 block
->data
.block
.cleanups
= 0;
4262 last_cleanup_this_contour ()
4264 if (block_stack
== 0)
4267 return block_stack
->data
.block
.cleanups
;
4270 /* Return 1 if there are any pending cleanups at this point.
4271 If THIS_CONTOUR is nonzero, check the current contour as well.
4272 Otherwise, look only at the contours that enclose this one. */
4275 any_pending_cleanups (this_contour
)
4278 struct nesting
*block
;
4280 if (block_stack
== 0)
4283 if (this_contour
&& block_stack
->data
.block
.cleanups
!= NULL
)
4285 if (block_stack
->data
.block
.cleanups
== 0
4286 && block_stack
->data
.block
.outer_cleanups
== 0)
4289 for (block
= block_stack
->next
; block
; block
= block
->next
)
4290 if (block
->data
.block
.cleanups
!= 0)
4296 /* Enter a case (Pascal) or switch (C) statement.
4297 Push a block onto case_stack and nesting_stack
4298 to accumulate the case-labels that are seen
4299 and to record the labels generated for the statement.
4301 EXIT_FLAG is nonzero if `exit_something' should exit this case stmt.
4302 Otherwise, this construct is transparent for `exit_something'.
4304 EXPR is the index-expression to be dispatched on.
4305 TYPE is its nominal type. We could simply convert EXPR to this type,
4306 but instead we take short cuts. */
4309 expand_start_case (exit_flag
, expr
, type
, printname
)
4313 const char *printname
;
4315 register struct nesting
*thiscase
= ALLOC_NESTING ();
4317 /* Make an entry on case_stack for the case we are entering. */
4319 thiscase
->next
= case_stack
;
4320 thiscase
->all
= nesting_stack
;
4321 thiscase
->depth
= ++nesting_depth
;
4322 thiscase
->exit_label
= exit_flag
? gen_label_rtx () : 0;
4323 thiscase
->data
.case_stmt
.case_list
= 0;
4324 thiscase
->data
.case_stmt
.index_expr
= expr
;
4325 thiscase
->data
.case_stmt
.nominal_type
= type
;
4326 thiscase
->data
.case_stmt
.default_label
= 0;
4327 thiscase
->data
.case_stmt
.num_ranges
= 0;
4328 thiscase
->data
.case_stmt
.printname
= printname
;
4329 thiscase
->data
.case_stmt
.line_number_status
= force_line_numbers ();
4330 case_stack
= thiscase
;
4331 nesting_stack
= thiscase
;
4333 do_pending_stack_adjust ();
4335 /* Make sure case_stmt.start points to something that won't
4336 need any transformation before expand_end_case. */
4337 if (GET_CODE (get_last_insn ()) != NOTE
)
4338 emit_note (NULL_PTR
, NOTE_INSN_DELETED
);
4340 thiscase
->data
.case_stmt
.start
= get_last_insn ();
4342 start_cleanup_deferral ();
4346 /* Start a "dummy case statement" within which case labels are invalid
4347 and are not connected to any larger real case statement.
4348 This can be used if you don't want to let a case statement jump
4349 into the middle of certain kinds of constructs. */
4352 expand_start_case_dummy ()
4354 register struct nesting
*thiscase
= ALLOC_NESTING ();
4356 /* Make an entry on case_stack for the dummy. */
4358 thiscase
->next
= case_stack
;
4359 thiscase
->all
= nesting_stack
;
4360 thiscase
->depth
= ++nesting_depth
;
4361 thiscase
->exit_label
= 0;
4362 thiscase
->data
.case_stmt
.case_list
= 0;
4363 thiscase
->data
.case_stmt
.start
= 0;
4364 thiscase
->data
.case_stmt
.nominal_type
= 0;
4365 thiscase
->data
.case_stmt
.default_label
= 0;
4366 thiscase
->data
.case_stmt
.num_ranges
= 0;
4367 case_stack
= thiscase
;
4368 nesting_stack
= thiscase
;
4369 start_cleanup_deferral ();
4372 /* End a dummy case statement. */
4375 expand_end_case_dummy ()
4377 end_cleanup_deferral ();
4378 POPSTACK (case_stack
);
4381 /* Return the data type of the index-expression
4382 of the innermost case statement, or null if none. */
4385 case_index_expr_type ()
4388 return TREE_TYPE (case_stack
->data
.case_stmt
.index_expr
);
4395 /* If this is the first label, warn if any insns have been emitted. */
4396 if (case_stack
->data
.case_stmt
.line_number_status
>= 0)
4400 restore_line_number_status
4401 (case_stack
->data
.case_stmt
.line_number_status
);
4402 case_stack
->data
.case_stmt
.line_number_status
= -1;
4404 for (insn
= case_stack
->data
.case_stmt
.start
;
4406 insn
= NEXT_INSN (insn
))
4408 if (GET_CODE (insn
) == CODE_LABEL
)
4410 if (GET_CODE (insn
) != NOTE
4411 && (GET_CODE (insn
) != INSN
|| GET_CODE (PATTERN (insn
)) != USE
))
4414 insn
= PREV_INSN (insn
);
4415 while (insn
&& (GET_CODE (insn
) != NOTE
|| NOTE_LINE_NUMBER (insn
) < 0));
4417 /* If insn is zero, then there must have been a syntax error. */
4419 warning_with_file_and_line (NOTE_SOURCE_FILE(insn
),
4420 NOTE_LINE_NUMBER(insn
),
4421 "unreachable code at beginning of %s",
4422 case_stack
->data
.case_stmt
.printname
);
4429 /* Accumulate one case or default label inside a case or switch statement.
4430 VALUE is the value of the case (a null pointer, for a default label).
4431 The function CONVERTER, when applied to arguments T and V,
4432 converts the value V to the type T.
4434 If not currently inside a case or switch statement, return 1 and do
4435 nothing. The caller will print a language-specific error message.
4436 If VALUE is a duplicate or overlaps, return 2 and do nothing
4437 except store the (first) duplicate node in *DUPLICATE.
4438 If VALUE is out of range, return 3 and do nothing.
4439 If we are jumping into the scope of a cleanup or var-sized array, return 5.
4440 Return 0 on success.
4442 Extended to handle range statements. */
4445 pushcase (value
, converter
, label
, duplicate
)
4446 register tree value
;
4447 tree (*converter
) PROTO((tree
, tree
));
4448 register tree label
;
4454 /* Fail if not inside a real case statement. */
4455 if (! (case_stack
&& case_stack
->data
.case_stmt
.start
))
4458 if (stack_block_stack
4459 && stack_block_stack
->depth
> case_stack
->depth
)
4462 index_type
= TREE_TYPE (case_stack
->data
.case_stmt
.index_expr
);
4463 nominal_type
= case_stack
->data
.case_stmt
.nominal_type
;
4465 /* If the index is erroneous, avoid more problems: pretend to succeed. */
4466 if (index_type
== error_mark_node
)
4469 /* Convert VALUE to the type in which the comparisons are nominally done. */
4471 value
= (*converter
) (nominal_type
, value
);
4475 /* Fail if this value is out of range for the actual type of the index
4476 (which may be narrower than NOMINAL_TYPE). */
4477 if (value
!= 0 && ! int_fits_type_p (value
, index_type
))
4480 /* Fail if this is a duplicate or overlaps another entry. */
4483 if (case_stack
->data
.case_stmt
.default_label
!= 0)
4485 *duplicate
= case_stack
->data
.case_stmt
.default_label
;
4488 case_stack
->data
.case_stmt
.default_label
= label
;
4491 return add_case_node (value
, value
, label
, duplicate
);
4493 expand_label (label
);
4497 /* Like pushcase but this case applies to all values between VALUE1 and
4498 VALUE2 (inclusive). If VALUE1 is NULL, the range starts at the lowest
4499 value of the index type and ends at VALUE2. If VALUE2 is NULL, the range
4500 starts at VALUE1 and ends at the highest value of the index type.
4501 If both are NULL, this case applies to all values.
4503 The return value is the same as that of pushcase but there is one
4504 additional error code: 4 means the specified range was empty. */
4507 pushcase_range (value1
, value2
, converter
, label
, duplicate
)
4508 register tree value1
, value2
;
4509 tree (*converter
) PROTO((tree
, tree
));
4510 register tree label
;
4516 /* Fail if not inside a real case statement. */
4517 if (! (case_stack
&& case_stack
->data
.case_stmt
.start
))
4520 if (stack_block_stack
4521 && stack_block_stack
->depth
> case_stack
->depth
)
4524 index_type
= TREE_TYPE (case_stack
->data
.case_stmt
.index_expr
);
4525 nominal_type
= case_stack
->data
.case_stmt
.nominal_type
;
4527 /* If the index is erroneous, avoid more problems: pretend to succeed. */
4528 if (index_type
== error_mark_node
)
4533 /* Convert VALUEs to type in which the comparisons are nominally done
4534 and replace any unspecified value with the corresponding bound. */
4536 value1
= TYPE_MIN_VALUE (index_type
);
4538 value2
= TYPE_MAX_VALUE (index_type
);
4540 /* Fail if the range is empty. Do this before any conversion since
4541 we want to allow out-of-range empty ranges. */
4542 if (value2
&& tree_int_cst_lt (value2
, value1
))
4545 value1
= (*converter
) (nominal_type
, value1
);
4547 /* If the max was unbounded, use the max of the nominal_type we are
4548 converting to. Do this after the < check above to suppress false
4551 value2
= TYPE_MAX_VALUE (nominal_type
);
4552 value2
= (*converter
) (nominal_type
, value2
);
4554 /* Fail if these values are out of range. */
4555 if (TREE_CONSTANT_OVERFLOW (value1
)
4556 || ! int_fits_type_p (value1
, index_type
))
4559 if (TREE_CONSTANT_OVERFLOW (value2
)
4560 || ! int_fits_type_p (value2
, index_type
))
4563 return add_case_node (value1
, value2
, label
, duplicate
);
4566 /* Do the actual insertion of a case label for pushcase and pushcase_range
4567 into case_stack->data.case_stmt.case_list. Use an AVL tree to avoid
4568 slowdown for large switch statements. */
4571 add_case_node (low
, high
, label
, duplicate
)
4576 struct case_node
*p
, **q
, *r
;
4578 q
= &case_stack
->data
.case_stmt
.case_list
;
4585 /* Keep going past elements distinctly greater than HIGH. */
4586 if (tree_int_cst_lt (high
, p
->low
))
4589 /* or distinctly less than LOW. */
4590 else if (tree_int_cst_lt (p
->high
, low
))
4595 /* We have an overlap; this is an error. */
4596 *duplicate
= p
->code_label
;
4601 /* Add this label to the chain, and succeed.
4602 Copy LOW, HIGH so they are on temporary rather than momentary
4603 obstack and will thus survive till the end of the case statement. */
4605 r
= (struct case_node
*) oballoc (sizeof (struct case_node
));
4606 r
->low
= copy_node (low
);
4608 /* If the bounds are equal, turn this into the one-value case. */
4610 if (tree_int_cst_equal (low
, high
))
4614 r
->high
= copy_node (high
);
4615 case_stack
->data
.case_stmt
.num_ranges
++;
4618 r
->code_label
= label
;
4619 expand_label (label
);
4629 struct case_node
*s
;
4635 if (! (b
= p
->balance
))
4636 /* Growth propagation from left side. */
4643 if ((p
->left
= s
= r
->right
))
4652 if ((r
->parent
= s
))
4660 case_stack
->data
.case_stmt
.case_list
= r
;
4663 /* r->balance == +1 */
4668 struct case_node
*t
= r
->right
;
4670 if ((p
->left
= s
= t
->right
))
4674 if ((r
->right
= s
= t
->left
))
4688 if ((t
->parent
= s
))
4696 case_stack
->data
.case_stmt
.case_list
= t
;
4703 /* p->balance == +1; growth of left side balances the node. */
4713 if (! (b
= p
->balance
))
4714 /* Growth propagation from right side. */
4722 if ((p
->right
= s
= r
->left
))
4730 if ((r
->parent
= s
))
4739 case_stack
->data
.case_stmt
.case_list
= r
;
4743 /* r->balance == -1 */
4747 struct case_node
*t
= r
->left
;
4749 if ((p
->right
= s
= t
->left
))
4754 if ((r
->left
= s
= t
->right
))
4768 if ((t
->parent
= s
))
4777 case_stack
->data
.case_stmt
.case_list
= t
;
4783 /* p->balance == -1; growth of right side balances the node. */
4797 /* Returns the number of possible values of TYPE.
4798 Returns -1 if the number is unknown or variable.
4799 Returns -2 if the number does not fit in a HOST_WIDE_INT.
4800 Sets *SPARENESS to 2 if TYPE is an ENUMERAL_TYPE whose values
4801 do not increase monotonically (there may be duplicates);
4802 to 1 if the values increase monotonically, but not always by 1;
4803 otherwise sets it to 0. */
4806 all_cases_count (type
, spareness
)
4810 HOST_WIDE_INT count
;
4813 switch (TREE_CODE (type
))
4820 count
= 1 << BITS_PER_UNIT
;
4824 if (TREE_CODE (TYPE_MIN_VALUE (type
)) != INTEGER_CST
4825 || TYPE_MAX_VALUE (type
) == NULL
4826 || TREE_CODE (TYPE_MAX_VALUE (type
)) != INTEGER_CST
)
4831 = TREE_INT_CST_LOW (TYPE_MAX_VALUE (type))
4832 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)) + 1
4833 but with overflow checking. */
4834 tree mint
= TYPE_MIN_VALUE (type
);
4835 tree maxt
= TYPE_MAX_VALUE (type
);
4836 HOST_WIDE_INT lo
, hi
;
4837 neg_double(TREE_INT_CST_LOW (mint
), TREE_INT_CST_HIGH (mint
),
4839 add_double(TREE_INT_CST_LOW (maxt
), TREE_INT_CST_HIGH (maxt
),
4841 add_double (lo
, hi
, 1, 0, &lo
, &hi
);
4842 if (hi
!= 0 || lo
< 0)
4849 for (t
= TYPE_VALUES (type
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
4851 if (TREE_CODE (TYPE_MIN_VALUE (type
)) != INTEGER_CST
4852 || TREE_CODE (TREE_VALUE (t
)) != INTEGER_CST
4853 || TREE_INT_CST_LOW (TYPE_MIN_VALUE (type
)) + count
4854 != TREE_INT_CST_LOW (TREE_VALUE (t
)))
4858 if (*spareness
== 1)
4860 tree prev
= TREE_VALUE (TYPE_VALUES (type
));
4861 for (t
= TYPE_VALUES (type
); t
= TREE_CHAIN (t
), t
!= NULL_TREE
; )
4863 if (! tree_int_cst_lt (prev
, TREE_VALUE (t
)))
4868 prev
= TREE_VALUE (t
);
4877 #define BITARRAY_TEST(ARRAY, INDEX) \
4878 ((ARRAY)[(unsigned) (INDEX) / HOST_BITS_PER_CHAR]\
4879 & (1 << ((unsigned) (INDEX) % HOST_BITS_PER_CHAR)))
4880 #define BITARRAY_SET(ARRAY, INDEX) \
4881 ((ARRAY)[(unsigned) (INDEX) / HOST_BITS_PER_CHAR]\
4882 |= 1 << ((unsigned) (INDEX) % HOST_BITS_PER_CHAR))
4884 /* Set the elements of the bitstring CASES_SEEN (which has length COUNT),
4885 with the case values we have seen, assuming the case expression
4887 SPARSENESS is as determined by all_cases_count.
4889 The time needed is proportional to COUNT, unless
4890 SPARSENESS is 2, in which case quadratic time is needed. */
4893 mark_seen_cases (type
, cases_seen
, count
, sparseness
)
4895 unsigned char *cases_seen
;
4899 tree next_node_to_try
= NULL_TREE
;
4900 long next_node_offset
= 0;
4902 register struct case_node
*n
, *root
= case_stack
->data
.case_stmt
.case_list
;
4903 tree val
= make_node (INTEGER_CST
);
4904 TREE_TYPE (val
) = type
;
4907 else if (sparseness
== 2)
4912 /* This less efficient loop is only needed to handle
4913 duplicate case values (multiple enum constants
4914 with the same value). */
4915 TREE_TYPE (val
) = TREE_TYPE (root
->low
);
4916 for (t
= TYPE_VALUES (type
), xlo
= 0; t
!= NULL_TREE
;
4917 t
= TREE_CHAIN (t
), xlo
++)
4919 TREE_INT_CST_LOW (val
) = TREE_INT_CST_LOW (TREE_VALUE (t
));
4920 TREE_INT_CST_HIGH (val
) = TREE_INT_CST_HIGH (TREE_VALUE (t
));
4924 /* Keep going past elements distinctly greater than VAL. */
4925 if (tree_int_cst_lt (val
, n
->low
))
4928 /* or distinctly less than VAL. */
4929 else if (tree_int_cst_lt (n
->high
, val
))
4934 /* We have found a matching range. */
4935 BITARRAY_SET (cases_seen
, xlo
);
4945 case_stack
->data
.case_stmt
.case_list
= root
= case_tree2list (root
, 0);
4946 for (n
= root
; n
; n
= n
->right
)
4948 TREE_INT_CST_LOW (val
) = TREE_INT_CST_LOW (n
->low
);
4949 TREE_INT_CST_HIGH (val
) = TREE_INT_CST_HIGH (n
->low
);
4950 while ( ! tree_int_cst_lt (n
->high
, val
))
4952 /* Calculate (into xlo) the "offset" of the integer (val).
4953 The element with lowest value has offset 0, the next smallest
4954 element has offset 1, etc. */
4956 HOST_WIDE_INT xlo
, xhi
;
4958 if (sparseness
&& TYPE_VALUES (type
) != NULL_TREE
)
4960 /* The TYPE_VALUES will be in increasing order, so
4961 starting searching where we last ended. */
4962 t
= next_node_to_try
;
4963 xlo
= next_node_offset
;
4969 t
= TYPE_VALUES (type
);
4972 if (tree_int_cst_equal (val
, TREE_VALUE (t
)))
4974 next_node_to_try
= TREE_CHAIN (t
);
4975 next_node_offset
= xlo
+ 1;
4980 if (t
== next_node_to_try
)
4989 t
= TYPE_MIN_VALUE (type
);
4991 neg_double (TREE_INT_CST_LOW (t
), TREE_INT_CST_HIGH (t
),
4995 add_double (xlo
, xhi
,
4996 TREE_INT_CST_LOW (val
), TREE_INT_CST_HIGH (val
),
5000 if (xhi
== 0 && xlo
>= 0 && xlo
< count
)
5001 BITARRAY_SET (cases_seen
, xlo
);
5002 add_double (TREE_INT_CST_LOW (val
), TREE_INT_CST_HIGH (val
),
5004 &TREE_INT_CST_LOW (val
), &TREE_INT_CST_HIGH (val
));
5010 /* Called when the index of a switch statement is an enumerated type
5011 and there is no default label.
5013 Checks that all enumeration literals are covered by the case
5014 expressions of a switch. Also, warn if there are any extra
5015 switch cases that are *not* elements of the enumerated type.
5017 If all enumeration literals were covered by the case expressions,
5018 turn one of the expressions into the default expression since it should
5019 not be possible to fall through such a switch. */
5022 check_for_full_enumeration_handling (type
)
5025 register struct case_node
*n
;
5026 register tree chain
;
5027 #if 0 /* variable used by 'if 0'ed code below. */
5028 register struct case_node
**l
;
5032 /* True iff the selector type is a numbered set mode. */
5035 /* The number of possible selector values. */
5038 /* For each possible selector value. a one iff it has been matched
5039 by a case value alternative. */
5040 unsigned char *cases_seen
;
5042 /* The allocated size of cases_seen, in chars. */
5048 size
= all_cases_count (type
, &sparseness
);
5049 bytes_needed
= (size
+ HOST_BITS_PER_CHAR
) / HOST_BITS_PER_CHAR
;
5051 if (size
> 0 && size
< 600000
5052 /* We deliberately use calloc here, not cmalloc, so that we can suppress
5053 this optimization if we don't have enough memory rather than
5054 aborting, as xmalloc would do. */
5055 && (cases_seen
= (unsigned char *) calloc (bytes_needed
, 1)) != NULL
)
5058 tree v
= TYPE_VALUES (type
);
5060 /* The time complexity of this code is normally O(N), where
5061 N being the number of members in the enumerated type.
5062 However, if type is a ENUMERAL_TYPE whose values do not
5063 increase monotonically, O(N*log(N)) time may be needed. */
5065 mark_seen_cases (type
, cases_seen
, size
, sparseness
);
5067 for (i
= 0; v
!= NULL_TREE
&& i
< size
; i
++, v
= TREE_CHAIN (v
))
5069 if (BITARRAY_TEST(cases_seen
, i
) == 0)
5070 warning ("enumeration value `%s' not handled in switch",
5071 IDENTIFIER_POINTER (TREE_PURPOSE (v
)));
5077 /* Now we go the other way around; we warn if there are case
5078 expressions that don't correspond to enumerators. This can
5079 occur since C and C++ don't enforce type-checking of
5080 assignments to enumeration variables. */
5082 if (case_stack
->data
.case_stmt
.case_list
5083 && case_stack
->data
.case_stmt
.case_list
->left
)
5084 case_stack
->data
.case_stmt
.case_list
5085 = case_tree2list (case_stack
->data
.case_stmt
.case_list
, 0);
5087 for (n
= case_stack
->data
.case_stmt
.case_list
; n
; n
= n
->right
)
5089 for (chain
= TYPE_VALUES (type
);
5090 chain
&& !tree_int_cst_equal (n
->low
, TREE_VALUE (chain
));
5091 chain
= TREE_CHAIN (chain
))
5096 if (TYPE_NAME (type
) == 0)
5097 warning ("case value `%ld' not in enumerated type",
5098 (long) TREE_INT_CST_LOW (n
->low
));
5100 warning ("case value `%ld' not in enumerated type `%s'",
5101 (long) TREE_INT_CST_LOW (n
->low
),
5102 IDENTIFIER_POINTER ((TREE_CODE (TYPE_NAME (type
))
5105 : DECL_NAME (TYPE_NAME (type
))));
5107 if (!tree_int_cst_equal (n
->low
, n
->high
))
5109 for (chain
= TYPE_VALUES (type
);
5110 chain
&& !tree_int_cst_equal (n
->high
, TREE_VALUE (chain
));
5111 chain
= TREE_CHAIN (chain
))
5116 if (TYPE_NAME (type
) == 0)
5117 warning ("case value `%ld' not in enumerated type",
5118 (long) TREE_INT_CST_LOW (n
->high
));
5120 warning ("case value `%ld' not in enumerated type `%s'",
5121 (long) TREE_INT_CST_LOW (n
->high
),
5122 IDENTIFIER_POINTER ((TREE_CODE (TYPE_NAME (type
))
5125 : DECL_NAME (TYPE_NAME (type
))));
5131 /* ??? This optimization is disabled because it causes valid programs to
5132 fail. ANSI C does not guarantee that an expression with enum type
5133 will have a value that is the same as one of the enumeration literals. */
5135 /* If all values were found as case labels, make one of them the default
5136 label. Thus, this switch will never fall through. We arbitrarily pick
5137 the last one to make the default since this is likely the most
5138 efficient choice. */
5142 for (l
= &case_stack
->data
.case_stmt
.case_list
;
5147 case_stack
->data
.case_stmt
.default_label
= (*l
)->code_label
;
5154 /* Terminate a case (Pascal) or switch (C) statement
5155 in which ORIG_INDEX is the expression to be tested.
5156 Generate the code to test it and jump to the right place. */
5159 expand_end_case (orig_index
)
5162 tree minval
= NULL_TREE
, maxval
= NULL_TREE
, range
, orig_minval
;
5163 rtx default_label
= 0;
5164 register struct case_node
*n
;
5172 register struct nesting
*thiscase
= case_stack
;
5173 tree index_expr
, index_type
;
5176 table_label
= gen_label_rtx ();
5177 index_expr
= thiscase
->data
.case_stmt
.index_expr
;
5178 index_type
= TREE_TYPE (index_expr
);
5179 unsignedp
= TREE_UNSIGNED (index_type
);
5181 do_pending_stack_adjust ();
5183 /* This might get an spurious warning in the presence of a syntax error;
5184 it could be fixed by moving the call to check_seenlabel after the
5185 check for error_mark_node, and copying the code of check_seenlabel that
5186 deals with case_stack->data.case_stmt.line_number_status /
5187 restore_line_number_status in front of the call to end_cleanup_deferral;
5188 However, this might miss some useful warnings in the presence of
5189 non-syntax errors. */
5192 /* An ERROR_MARK occurs for various reasons including invalid data type. */
5193 if (index_type
!= error_mark_node
)
5195 /* If switch expression was an enumerated type, check that all
5196 enumeration literals are covered by the cases.
5197 No sense trying this if there's a default case, however. */
5199 if (!thiscase
->data
.case_stmt
.default_label
5200 && TREE_CODE (TREE_TYPE (orig_index
)) == ENUMERAL_TYPE
5201 && TREE_CODE (index_expr
) != INTEGER_CST
)
5202 check_for_full_enumeration_handling (TREE_TYPE (orig_index
));
5204 /* If we don't have a default-label, create one here,
5205 after the body of the switch. */
5206 if (thiscase
->data
.case_stmt
.default_label
== 0)
5208 thiscase
->data
.case_stmt
.default_label
5209 = build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
5210 expand_label (thiscase
->data
.case_stmt
.default_label
);
5212 default_label
= label_rtx (thiscase
->data
.case_stmt
.default_label
);
5214 before_case
= get_last_insn ();
5216 if (thiscase
->data
.case_stmt
.case_list
5217 && thiscase
->data
.case_stmt
.case_list
->left
)
5218 thiscase
->data
.case_stmt
.case_list
5219 = case_tree2list(thiscase
->data
.case_stmt
.case_list
, 0);
5221 /* Simplify the case-list before we count it. */
5222 group_case_nodes (thiscase
->data
.case_stmt
.case_list
);
5224 /* Get upper and lower bounds of case values.
5225 Also convert all the case values to the index expr's data type. */
5228 for (n
= thiscase
->data
.case_stmt
.case_list
; n
; n
= n
->right
)
5230 /* Check low and high label values are integers. */
5231 if (TREE_CODE (n
->low
) != INTEGER_CST
)
5233 if (TREE_CODE (n
->high
) != INTEGER_CST
)
5236 n
->low
= convert (index_type
, n
->low
);
5237 n
->high
= convert (index_type
, n
->high
);
5239 /* Count the elements and track the largest and smallest
5240 of them (treating them as signed even if they are not). */
5248 if (INT_CST_LT (n
->low
, minval
))
5250 if (INT_CST_LT (maxval
, n
->high
))
5253 /* A range counts double, since it requires two compares. */
5254 if (! tree_int_cst_equal (n
->low
, n
->high
))
5258 orig_minval
= minval
;
5260 /* Compute span of values. */
5262 range
= fold (build (MINUS_EXPR
, index_type
, maxval
, minval
));
5264 end_cleanup_deferral ();
5268 expand_expr (index_expr
, const0_rtx
, VOIDmode
, 0);
5270 emit_jump (default_label
);
5273 /* If range of values is much bigger than number of values,
5274 make a sequence of conditional branches instead of a dispatch.
5275 If the switch-index is a constant, do it this way
5276 because we can optimize it. */
5278 #ifndef CASE_VALUES_THRESHOLD
5280 #define CASE_VALUES_THRESHOLD (HAVE_casesi ? 4 : 5)
5282 /* If machine does not have a case insn that compares the
5283 bounds, this means extra overhead for dispatch tables
5284 which raises the threshold for using them. */
5285 #define CASE_VALUES_THRESHOLD 5
5286 #endif /* HAVE_casesi */
5287 #endif /* CASE_VALUES_THRESHOLD */
5289 else if (TREE_INT_CST_HIGH (range
) != 0
5290 || count
< (unsigned int) CASE_VALUES_THRESHOLD
5291 || ((unsigned HOST_WIDE_INT
) (TREE_INT_CST_LOW (range
))
5293 #ifndef ASM_OUTPUT_ADDR_DIFF_ELT
5296 || TREE_CODE (index_expr
) == INTEGER_CST
5297 /* These will reduce to a constant. */
5298 || (TREE_CODE (index_expr
) == CALL_EXPR
5299 && TREE_CODE (TREE_OPERAND (index_expr
, 0)) == ADDR_EXPR
5300 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (index_expr
, 0), 0)) == FUNCTION_DECL
5301 && DECL_FUNCTION_CODE (TREE_OPERAND (TREE_OPERAND (index_expr
, 0), 0)) == BUILT_IN_CLASSIFY_TYPE
)
5302 || (TREE_CODE (index_expr
) == COMPOUND_EXPR
5303 && TREE_CODE (TREE_OPERAND (index_expr
, 1)) == INTEGER_CST
))
5305 index
= expand_expr (index_expr
, NULL_RTX
, VOIDmode
, 0);
5307 /* If the index is a short or char that we do not have
5308 an insn to handle comparisons directly, convert it to
5309 a full integer now, rather than letting each comparison
5310 generate the conversion. */
5312 if (GET_MODE_CLASS (GET_MODE (index
)) == MODE_INT
5313 && (cmp_optab
->handlers
[(int) GET_MODE(index
)].insn_code
5314 == CODE_FOR_nothing
))
5316 enum machine_mode wider_mode
;
5317 for (wider_mode
= GET_MODE (index
); wider_mode
!= VOIDmode
;
5318 wider_mode
= GET_MODE_WIDER_MODE (wider_mode
))
5319 if (cmp_optab
->handlers
[(int) wider_mode
].insn_code
5320 != CODE_FOR_nothing
)
5322 index
= convert_to_mode (wider_mode
, index
, unsignedp
);
5328 do_pending_stack_adjust ();
5330 index
= protect_from_queue (index
, 0);
5331 if (GET_CODE (index
) == MEM
)
5332 index
= copy_to_reg (index
);
5333 if (GET_CODE (index
) == CONST_INT
5334 || TREE_CODE (index_expr
) == INTEGER_CST
)
5336 /* Make a tree node with the proper constant value
5337 if we don't already have one. */
5338 if (TREE_CODE (index_expr
) != INTEGER_CST
)
5341 = build_int_2 (INTVAL (index
),
5342 unsignedp
|| INTVAL (index
) >= 0 ? 0 : -1);
5343 index_expr
= convert (index_type
, index_expr
);
5346 /* For constant index expressions we need only
5347 issue a unconditional branch to the appropriate
5348 target code. The job of removing any unreachable
5349 code is left to the optimisation phase if the
5350 "-O" option is specified. */
5351 for (n
= thiscase
->data
.case_stmt
.case_list
; n
; n
= n
->right
)
5352 if (! tree_int_cst_lt (index_expr
, n
->low
)
5353 && ! tree_int_cst_lt (n
->high
, index_expr
))
5357 emit_jump (label_rtx (n
->code_label
));
5359 emit_jump (default_label
);
5363 /* If the index expression is not constant we generate
5364 a binary decision tree to select the appropriate
5365 target code. This is done as follows:
5367 The list of cases is rearranged into a binary tree,
5368 nearly optimal assuming equal probability for each case.
5370 The tree is transformed into RTL, eliminating
5371 redundant test conditions at the same time.
5373 If program flow could reach the end of the
5374 decision tree an unconditional jump to the
5375 default code is emitted. */
5378 = (TREE_CODE (TREE_TYPE (orig_index
)) != ENUMERAL_TYPE
5379 && estimate_case_costs (thiscase
->data
.case_stmt
.case_list
));
5380 balance_case_nodes (&thiscase
->data
.case_stmt
.case_list
,
5382 emit_case_nodes (index
, thiscase
->data
.case_stmt
.case_list
,
5383 default_label
, index_type
);
5384 emit_jump_if_reachable (default_label
);
5393 enum machine_mode index_mode
= SImode
;
5394 int index_bits
= GET_MODE_BITSIZE (index_mode
);
5396 enum machine_mode op_mode
;
5398 /* Convert the index to SImode. */
5399 if (GET_MODE_BITSIZE (TYPE_MODE (index_type
))
5400 > GET_MODE_BITSIZE (index_mode
))
5402 enum machine_mode omode
= TYPE_MODE (index_type
);
5403 rtx rangertx
= expand_expr (range
, NULL_RTX
, VOIDmode
, 0);
5405 /* We must handle the endpoints in the original mode. */
5406 index_expr
= build (MINUS_EXPR
, index_type
,
5407 index_expr
, minval
);
5408 minval
= integer_zero_node
;
5409 index
= expand_expr (index_expr
, NULL_RTX
, VOIDmode
, 0);
5410 emit_cmp_and_jump_insns (rangertx
, index
, LTU
, NULL_RTX
,
5411 omode
, 1, 0, default_label
);
5412 /* Now we can safely truncate. */
5413 index
= convert_to_mode (index_mode
, index
, 0);
5417 if (TYPE_MODE (index_type
) != index_mode
)
5419 index_expr
= convert (type_for_size (index_bits
, 0),
5421 index_type
= TREE_TYPE (index_expr
);
5424 index
= expand_expr (index_expr
, NULL_RTX
, VOIDmode
, 0);
5427 index
= protect_from_queue (index
, 0);
5428 do_pending_stack_adjust ();
5430 op_mode
= insn_operand_mode
[(int)CODE_FOR_casesi
][0];
5431 if (! (*insn_operand_predicate
[(int)CODE_FOR_casesi
][0])
5433 index
= copy_to_mode_reg (op_mode
, index
);
5435 op1
= expand_expr (minval
, NULL_RTX
, VOIDmode
, 0);
5437 op_mode
= insn_operand_mode
[(int)CODE_FOR_casesi
][1];
5438 if (! (*insn_operand_predicate
[(int)CODE_FOR_casesi
][1])
5440 op1
= copy_to_mode_reg (op_mode
, op1
);
5442 op2
= expand_expr (range
, NULL_RTX
, VOIDmode
, 0);
5444 op_mode
= insn_operand_mode
[(int)CODE_FOR_casesi
][2];
5445 if (! (*insn_operand_predicate
[(int)CODE_FOR_casesi
][2])
5447 op2
= copy_to_mode_reg (op_mode
, op2
);
5449 emit_jump_insn (gen_casesi (index
, op1
, op2
,
5450 table_label
, default_label
));
5454 #ifdef HAVE_tablejump
5455 if (! win
&& HAVE_tablejump
)
5457 index_expr
= convert (thiscase
->data
.case_stmt
.nominal_type
,
5458 fold (build (MINUS_EXPR
, index_type
,
5459 index_expr
, minval
)));
5460 index_type
= TREE_TYPE (index_expr
);
5461 index
= expand_expr (index_expr
, NULL_RTX
, VOIDmode
, 0);
5463 index
= protect_from_queue (index
, 0);
5464 do_pending_stack_adjust ();
5466 do_tablejump (index
, TYPE_MODE (index_type
),
5467 expand_expr (range
, NULL_RTX
, VOIDmode
, 0),
5468 table_label
, default_label
);
5475 /* Get table of labels to jump to, in order of case index. */
5477 ncases
= TREE_INT_CST_LOW (range
) + 1;
5478 labelvec
= (rtx
*) alloca (ncases
* sizeof (rtx
));
5479 bzero ((char *) labelvec
, ncases
* sizeof (rtx
));
5481 for (n
= thiscase
->data
.case_stmt
.case_list
; n
; n
= n
->right
)
5483 register HOST_WIDE_INT i
5484 = TREE_INT_CST_LOW (n
->low
) - TREE_INT_CST_LOW (orig_minval
);
5489 = gen_rtx_LABEL_REF (Pmode
, label_rtx (n
->code_label
));
5490 if (i
+ TREE_INT_CST_LOW (orig_minval
)
5491 == TREE_INT_CST_LOW (n
->high
))
5497 /* Fill in the gaps with the default. */
5498 for (i
= 0; i
< ncases
; i
++)
5499 if (labelvec
[i
] == 0)
5500 labelvec
[i
] = gen_rtx_LABEL_REF (Pmode
, default_label
);
5502 /* Output the table */
5503 emit_label (table_label
);
5505 if (CASE_VECTOR_PC_RELATIVE
|| flag_pic
)
5506 emit_jump_insn (gen_rtx_ADDR_DIFF_VEC (CASE_VECTOR_MODE
,
5507 gen_rtx_LABEL_REF (Pmode
, table_label
),
5508 gen_rtvec_v (ncases
, labelvec
),
5509 const0_rtx
, const0_rtx
));
5511 emit_jump_insn (gen_rtx_ADDR_VEC (CASE_VECTOR_MODE
,
5512 gen_rtvec_v (ncases
, labelvec
)));
5514 /* If the case insn drops through the table,
5515 after the table we must jump to the default-label.
5516 Otherwise record no drop-through after the table. */
5517 #ifdef CASE_DROPS_THROUGH
5518 emit_jump (default_label
);
5524 before_case
= squeeze_notes (NEXT_INSN (before_case
), get_last_insn ());
5525 reorder_insns (before_case
, get_last_insn (),
5526 thiscase
->data
.case_stmt
.start
);
5529 end_cleanup_deferral ();
5531 if (thiscase
->exit_label
)
5532 emit_label (thiscase
->exit_label
);
5534 POPSTACK (case_stack
);
5539 /* Convert the tree NODE into a list linked by the right field, with the left
5540 field zeroed. RIGHT is used for recursion; it is a list to be placed
5541 rightmost in the resulting list. */
5543 static struct case_node
*
5544 case_tree2list (node
, right
)
5545 struct case_node
*node
, *right
;
5547 struct case_node
*left
;
5550 right
= case_tree2list (node
->right
, right
);
5552 node
->right
= right
;
5553 if ((left
= node
->left
))
5556 return case_tree2list (left
, node
);
5562 /* Generate code to jump to LABEL if OP1 and OP2 are equal. */
5565 do_jump_if_equal (op1
, op2
, label
, unsignedp
)
5566 rtx op1
, op2
, label
;
5569 if (GET_CODE (op1
) == CONST_INT
5570 && GET_CODE (op2
) == CONST_INT
)
5572 if (INTVAL (op1
) == INTVAL (op2
))
5577 enum machine_mode mode
= GET_MODE (op1
);
5578 if (mode
== VOIDmode
)
5579 mode
= GET_MODE (op2
);
5580 emit_cmp_and_jump_insns (op1
, op2
, EQ
, NULL_RTX
, mode
, unsignedp
,
5585 /* Not all case values are encountered equally. This function
5586 uses a heuristic to weight case labels, in cases where that
5587 looks like a reasonable thing to do.
5589 Right now, all we try to guess is text, and we establish the
5592 chars above space: 16
5601 If we find any cases in the switch that are not either -1 or in the range
5602 of valid ASCII characters, or are control characters other than those
5603 commonly used with "\", don't treat this switch scanning text.
5605 Return 1 if these nodes are suitable for cost estimation, otherwise
5609 estimate_case_costs (node
)
5612 tree min_ascii
= build_int_2 (-1, -1);
5613 tree max_ascii
= convert (TREE_TYPE (node
->high
), build_int_2 (127, 0));
5617 /* If we haven't already made the cost table, make it now. Note that the
5618 lower bound of the table is -1, not zero. */
5620 if (cost_table
== NULL
)
5622 cost_table
= ((short *) xcalloc (129, sizeof (short))) + 1;
5624 for (i
= 0; i
< 128; i
++)
5628 else if (ISPUNCT (i
))
5630 else if (ISCNTRL (i
))
5634 cost_table
[' '] = 8;
5635 cost_table
['\t'] = 4;
5636 cost_table
['\0'] = 4;
5637 cost_table
['\n'] = 2;
5638 cost_table
['\f'] = 1;
5639 cost_table
['\v'] = 1;
5640 cost_table
['\b'] = 1;
5643 /* See if all the case expressions look like text. It is text if the
5644 constant is >= -1 and the highest constant is <= 127. Do all comparisons
5645 as signed arithmetic since we don't want to ever access cost_table with a
5646 value less than -1. Also check that none of the constants in a range
5647 are strange control characters. */
5649 for (n
= node
; n
; n
= n
->right
)
5651 if ((INT_CST_LT (n
->low
, min_ascii
)) || INT_CST_LT (max_ascii
, n
->high
))
5654 for (i
= TREE_INT_CST_LOW (n
->low
); i
<= TREE_INT_CST_LOW (n
->high
); i
++)
5655 if (cost_table
[i
] < 0)
5659 /* All interesting values are within the range of interesting
5660 ASCII characters. */
5664 /* Scan an ordered list of case nodes
5665 combining those with consecutive values or ranges.
5667 Eg. three separate entries 1: 2: 3: become one entry 1..3: */
5670 group_case_nodes (head
)
5673 case_node_ptr node
= head
;
5677 rtx lb
= next_real_insn (label_rtx (node
->code_label
));
5679 case_node_ptr np
= node
;
5681 /* Try to group the successors of NODE with NODE. */
5682 while (((np
= np
->right
) != 0)
5683 /* Do they jump to the same place? */
5684 && ((lb2
= next_real_insn (label_rtx (np
->code_label
))) == lb
5685 || (lb
!= 0 && lb2
!= 0
5686 && simplejump_p (lb
)
5687 && simplejump_p (lb2
)
5688 && rtx_equal_p (SET_SRC (PATTERN (lb
)),
5689 SET_SRC (PATTERN (lb2
)))))
5690 /* Are their ranges consecutive? */
5691 && tree_int_cst_equal (np
->low
,
5692 fold (build (PLUS_EXPR
,
5693 TREE_TYPE (node
->high
),
5696 /* An overflow is not consecutive. */
5697 && tree_int_cst_lt (node
->high
,
5698 fold (build (PLUS_EXPR
,
5699 TREE_TYPE (node
->high
),
5701 integer_one_node
))))
5703 node
->high
= np
->high
;
5705 /* NP is the first node after NODE which can't be grouped with it.
5706 Delete the nodes in between, and move on to that node. */
5712 /* Take an ordered list of case nodes
5713 and transform them into a near optimal binary tree,
5714 on the assumption that any target code selection value is as
5715 likely as any other.
5717 The transformation is performed by splitting the ordered
5718 list into two equal sections plus a pivot. The parts are
5719 then attached to the pivot as left and right branches. Each
5720 branch is then transformed recursively. */
5723 balance_case_nodes (head
, parent
)
5724 case_node_ptr
*head
;
5725 case_node_ptr parent
;
5727 register case_node_ptr np
;
5735 register case_node_ptr
*npp
;
5738 /* Count the number of entries on branch. Also count the ranges. */
5742 if (!tree_int_cst_equal (np
->low
, np
->high
))
5746 cost
+= cost_table
[TREE_INT_CST_LOW (np
->high
)];
5750 cost
+= cost_table
[TREE_INT_CST_LOW (np
->low
)];
5758 /* Split this list if it is long enough for that to help. */
5763 /* Find the place in the list that bisects the list's total cost,
5764 Here I gets half the total cost. */
5769 /* Skip nodes while their cost does not reach that amount. */
5770 if (!tree_int_cst_equal ((*npp
)->low
, (*npp
)->high
))
5771 i
-= cost_table
[TREE_INT_CST_LOW ((*npp
)->high
)];
5772 i
-= cost_table
[TREE_INT_CST_LOW ((*npp
)->low
)];
5775 npp
= &(*npp
)->right
;
5780 /* Leave this branch lopsided, but optimize left-hand
5781 side and fill in `parent' fields for right-hand side. */
5783 np
->parent
= parent
;
5784 balance_case_nodes (&np
->left
, np
);
5785 for (; np
->right
; np
= np
->right
)
5786 np
->right
->parent
= np
;
5790 /* If there are just three nodes, split at the middle one. */
5792 npp
= &(*npp
)->right
;
5795 /* Find the place in the list that bisects the list's total cost,
5796 where ranges count as 2.
5797 Here I gets half the total cost. */
5798 i
= (i
+ ranges
+ 1) / 2;
5801 /* Skip nodes while their cost does not reach that amount. */
5802 if (!tree_int_cst_equal ((*npp
)->low
, (*npp
)->high
))
5807 npp
= &(*npp
)->right
;
5812 np
->parent
= parent
;
5815 /* Optimize each of the two split parts. */
5816 balance_case_nodes (&np
->left
, np
);
5817 balance_case_nodes (&np
->right
, np
);
5821 /* Else leave this branch as one level,
5822 but fill in `parent' fields. */
5824 np
->parent
= parent
;
5825 for (; np
->right
; np
= np
->right
)
5826 np
->right
->parent
= np
;
5831 /* Search the parent sections of the case node tree
5832 to see if a test for the lower bound of NODE would be redundant.
5833 INDEX_TYPE is the type of the index expression.
5835 The instructions to generate the case decision tree are
5836 output in the same order as nodes are processed so it is
5837 known that if a parent node checks the range of the current
5838 node minus one that the current node is bounded at its lower
5839 span. Thus the test would be redundant. */
5842 node_has_low_bound (node
, index_type
)
5847 case_node_ptr pnode
;
5849 /* If the lower bound of this node is the lowest value in the index type,
5850 we need not test it. */
5852 if (tree_int_cst_equal (node
->low
, TYPE_MIN_VALUE (index_type
)))
5855 /* If this node has a left branch, the value at the left must be less
5856 than that at this node, so it cannot be bounded at the bottom and
5857 we need not bother testing any further. */
5862 low_minus_one
= fold (build (MINUS_EXPR
, TREE_TYPE (node
->low
),
5863 node
->low
, integer_one_node
));
5865 /* If the subtraction above overflowed, we can't verify anything.
5866 Otherwise, look for a parent that tests our value - 1. */
5868 if (! tree_int_cst_lt (low_minus_one
, node
->low
))
5871 for (pnode
= node
->parent
; pnode
; pnode
= pnode
->parent
)
5872 if (tree_int_cst_equal (low_minus_one
, pnode
->high
))
5878 /* Search the parent sections of the case node tree
5879 to see if a test for the upper bound of NODE would be redundant.
5880 INDEX_TYPE is the type of the index expression.
5882 The instructions to generate the case decision tree are
5883 output in the same order as nodes are processed so it is
5884 known that if a parent node checks the range of the current
5885 node plus one that the current node is bounded at its upper
5886 span. Thus the test would be redundant. */
5889 node_has_high_bound (node
, index_type
)
5894 case_node_ptr pnode
;
5896 /* If there is no upper bound, obviously no test is needed. */
5898 if (TYPE_MAX_VALUE (index_type
) == NULL
)
5901 /* If the upper bound of this node is the highest value in the type
5902 of the index expression, we need not test against it. */
5904 if (tree_int_cst_equal (node
->high
, TYPE_MAX_VALUE (index_type
)))
5907 /* If this node has a right branch, the value at the right must be greater
5908 than that at this node, so it cannot be bounded at the top and
5909 we need not bother testing any further. */
5914 high_plus_one
= fold (build (PLUS_EXPR
, TREE_TYPE (node
->high
),
5915 node
->high
, integer_one_node
));
5917 /* If the addition above overflowed, we can't verify anything.
5918 Otherwise, look for a parent that tests our value + 1. */
5920 if (! tree_int_cst_lt (node
->high
, high_plus_one
))
5923 for (pnode
= node
->parent
; pnode
; pnode
= pnode
->parent
)
5924 if (tree_int_cst_equal (high_plus_one
, pnode
->low
))
5930 /* Search the parent sections of the
5931 case node tree to see if both tests for the upper and lower
5932 bounds of NODE would be redundant. */
5935 node_is_bounded (node
, index_type
)
5939 return (node_has_low_bound (node
, index_type
)
5940 && node_has_high_bound (node
, index_type
));
5943 /* Emit an unconditional jump to LABEL unless it would be dead code. */
5946 emit_jump_if_reachable (label
)
5949 if (GET_CODE (get_last_insn ()) != BARRIER
)
5953 /* Emit step-by-step code to select a case for the value of INDEX.
5954 The thus generated decision tree follows the form of the
5955 case-node binary tree NODE, whose nodes represent test conditions.
5956 INDEX_TYPE is the type of the index of the switch.
5958 Care is taken to prune redundant tests from the decision tree
5959 by detecting any boundary conditions already checked by
5960 emitted rtx. (See node_has_high_bound, node_has_low_bound
5961 and node_is_bounded, above.)
5963 Where the test conditions can be shown to be redundant we emit
5964 an unconditional jump to the target code. As a further
5965 optimization, the subordinates of a tree node are examined to
5966 check for bounded nodes. In this case conditional and/or
5967 unconditional jumps as a result of the boundary check for the
5968 current node are arranged to target the subordinates associated
5969 code for out of bound conditions on the current node.
5971 We can assume that when control reaches the code generated here,
5972 the index value has already been compared with the parents
5973 of this node, and determined to be on the same side of each parent
5974 as this node is. Thus, if this node tests for the value 51,
5975 and a parent tested for 52, we don't need to consider
5976 the possibility of a value greater than 51. If another parent
5977 tests for the value 50, then this node need not test anything. */
5980 emit_case_nodes (index
, node
, default_label
, index_type
)
5986 /* If INDEX has an unsigned type, we must make unsigned branches. */
5987 int unsignedp
= TREE_UNSIGNED (index_type
);
5988 typedef rtx
rtx_fn ();
5989 enum machine_mode mode
= GET_MODE (index
);
5991 /* See if our parents have already tested everything for us.
5992 If they have, emit an unconditional jump for this node. */
5993 if (node_is_bounded (node
, index_type
))
5994 emit_jump (label_rtx (node
->code_label
));
5996 else if (tree_int_cst_equal (node
->low
, node
->high
))
5998 /* Node is single valued. First see if the index expression matches
5999 this node and then check our children, if any. */
6001 do_jump_if_equal (index
, expand_expr (node
->low
, NULL_RTX
, VOIDmode
, 0),
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
, expand_expr (node
->high
, NULL_RTX
,
6016 GT
, NULL_RTX
, mode
, unsignedp
, 0,
6017 label_rtx (node
->right
->code_label
));
6018 emit_case_nodes (index
, node
->left
, default_label
, index_type
);
6021 else if (node_is_bounded (node
->left
, index_type
))
6023 emit_cmp_and_jump_insns (index
, expand_expr (node
->high
, NULL_RTX
,
6025 LT
, NULL_RTX
, mode
, unsignedp
, 0,
6026 label_rtx (node
->left
->code_label
));
6027 emit_case_nodes (index
, node
->right
, default_label
, index_type
);
6032 /* Neither node is bounded. First distinguish the two sides;
6033 then emit the code for one side at a time. */
6036 = build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
6038 /* See if the value is on the right. */
6039 emit_cmp_and_jump_insns (index
, expand_expr (node
->high
, NULL_RTX
,
6041 GT
, NULL_RTX
, mode
, unsignedp
, 0,
6042 label_rtx (test_label
));
6044 /* Value must be on the left.
6045 Handle the left-hand subtree. */
6046 emit_case_nodes (index
, node
->left
, default_label
, index_type
);
6047 /* If left-hand subtree does nothing,
6049 emit_jump_if_reachable (default_label
);
6051 /* Code branches here for the right-hand subtree. */
6052 expand_label (test_label
);
6053 emit_case_nodes (index
, node
->right
, default_label
, index_type
);
6057 else if (node
->right
!= 0 && node
->left
== 0)
6059 /* Here we have a right child but no left so we issue conditional
6060 branch to default and process the right child.
6062 Omit the conditional branch to default if we it avoid only one
6063 right child; it costs too much space to save so little time. */
6065 if (node
->right
->right
|| node
->right
->left
6066 || !tree_int_cst_equal (node
->right
->low
, node
->right
->high
))
6068 if (!node_has_low_bound (node
, index_type
))
6070 emit_cmp_and_jump_insns (index
, expand_expr (node
->high
,
6073 LT
, NULL_RTX
, mode
, unsignedp
, 0,
6077 emit_case_nodes (index
, node
->right
, default_label
, index_type
);
6080 /* We cannot process node->right normally
6081 since we haven't ruled out the numbers less than
6082 this node's value. So handle node->right explicitly. */
6083 do_jump_if_equal (index
,
6084 expand_expr (node
->right
->low
, NULL_RTX
,
6086 label_rtx (node
->right
->code_label
), unsignedp
);
6089 else if (node
->right
== 0 && node
->left
!= 0)
6091 /* Just one subtree, on the left. */
6093 #if 0 /* The following code and comment were formerly part
6094 of the condition here, but they didn't work
6095 and I don't understand what the idea was. -- rms. */
6096 /* If our "most probable entry" is less probable
6097 than the default label, emit a jump to
6098 the default label using condition codes
6099 already lying around. With no right branch,
6100 a branch-greater-than will get us to the default
6103 && cost_table
[TREE_INT_CST_LOW (node
->high
)] < 12)
6106 if (node
->left
->left
|| node
->left
->right
6107 || !tree_int_cst_equal (node
->left
->low
, node
->left
->high
))
6109 if (!node_has_high_bound (node
, index_type
))
6111 emit_cmp_and_jump_insns (index
, expand_expr (node
->high
,
6114 GT
, NULL_RTX
, mode
, unsignedp
, 0,
6118 emit_case_nodes (index
, node
->left
, default_label
, index_type
);
6121 /* We cannot process node->left normally
6122 since we haven't ruled out the numbers less than
6123 this node's value. So handle node->left explicitly. */
6124 do_jump_if_equal (index
,
6125 expand_expr (node
->left
->low
, NULL_RTX
,
6127 label_rtx (node
->left
->code_label
), unsignedp
);
6132 /* Node is a range. These cases are very similar to those for a single
6133 value, except that we do not start by testing whether this node
6134 is the one to branch to. */
6136 if (node
->right
!= 0 && node
->left
!= 0)
6138 /* Node has subtrees on both sides.
6139 If the right-hand subtree is bounded,
6140 test for it first, since we can go straight there.
6141 Otherwise, we need to make a branch in the control structure,
6142 then handle the two subtrees. */
6143 tree test_label
= 0;
6146 if (node_is_bounded (node
->right
, index_type
))
6147 /* Right hand node is fully bounded so we can eliminate any
6148 testing and branch directly to the target code. */
6149 emit_cmp_and_jump_insns (index
, expand_expr (node
->high
, NULL_RTX
,
6151 GT
, NULL_RTX
, mode
, unsignedp
, 0,
6152 label_rtx (node
->right
->code_label
));
6155 /* Right hand node requires testing.
6156 Branch to a label where we will handle it later. */
6158 test_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
6159 emit_cmp_and_jump_insns (index
, expand_expr (node
->high
, NULL_RTX
,
6161 GT
, NULL_RTX
, mode
, unsignedp
, 0,
6162 label_rtx (test_label
));
6165 /* Value belongs to this node or to the left-hand subtree. */
6167 emit_cmp_and_jump_insns (index
, expand_expr (node
->low
, NULL_RTX
,
6169 GE
, NULL_RTX
, mode
, unsignedp
, 0,
6170 label_rtx (node
->code_label
));
6172 /* Handle the left-hand subtree. */
6173 emit_case_nodes (index
, node
->left
, default_label
, index_type
);
6175 /* If right node had to be handled later, do that now. */
6179 /* If the left-hand subtree fell through,
6180 don't let it fall into the right-hand subtree. */
6181 emit_jump_if_reachable (default_label
);
6183 expand_label (test_label
);
6184 emit_case_nodes (index
, node
->right
, default_label
, index_type
);
6188 else if (node
->right
!= 0 && node
->left
== 0)
6190 /* Deal with values to the left of this node,
6191 if they are possible. */
6192 if (!node_has_low_bound (node
, index_type
))
6194 emit_cmp_and_jump_insns (index
, expand_expr (node
->low
, NULL_RTX
,
6196 LT
, NULL_RTX
, mode
, unsignedp
, 0,
6200 /* Value belongs to this node or to the right-hand subtree. */
6202 emit_cmp_and_jump_insns (index
, expand_expr (node
->high
, NULL_RTX
,
6204 LE
, NULL_RTX
, mode
, unsignedp
, 0,
6205 label_rtx (node
->code_label
));
6207 emit_case_nodes (index
, node
->right
, default_label
, index_type
);
6210 else if (node
->right
== 0 && node
->left
!= 0)
6212 /* Deal with values to the right of this node,
6213 if they are possible. */
6214 if (!node_has_high_bound (node
, index_type
))
6216 emit_cmp_and_jump_insns (index
, expand_expr (node
->high
, NULL_RTX
,
6218 GT
, NULL_RTX
, mode
, unsignedp
, 0,
6222 /* Value belongs to this node or to the left-hand subtree. */
6224 emit_cmp_and_jump_insns (index
, expand_expr (node
->low
, NULL_RTX
,
6226 GE
, NULL_RTX
, mode
, unsignedp
, 0,
6227 label_rtx (node
->code_label
));
6229 emit_case_nodes (index
, node
->left
, default_label
, index_type
);
6234 /* Node has no children so we check low and high bounds to remove
6235 redundant tests. Only one of the bounds can exist,
6236 since otherwise this node is bounded--a case tested already. */
6238 if (!node_has_high_bound (node
, index_type
))
6240 emit_cmp_and_jump_insns (index
, expand_expr (node
->high
, NULL_RTX
,
6242 GT
, NULL_RTX
, mode
, unsignedp
, 0,
6246 if (!node_has_low_bound (node
, index_type
))
6248 emit_cmp_and_jump_insns (index
, expand_expr (node
->low
, NULL_RTX
,
6250 LT
, NULL_RTX
, mode
, unsignedp
, 0,
6254 emit_jump (label_rtx (node
->code_label
));
6259 /* These routines are used by the loop unrolling code. They copy BLOCK trees
6260 so that the debugging info will be correct for the unrolled loop. */
6262 /* Indexed by block number, contains a pointer to the N'th block node.
6264 Allocated by the call to identify_blocks, then released after the call
6265 to reorder_blocks in the function unroll_block_trees. */
6267 static tree
*block_vector
;
6270 find_loop_tree_blocks ()
6272 tree block
= DECL_INITIAL (current_function_decl
);
6274 block_vector
= identify_blocks (block
, get_insns ());
6278 unroll_block_trees ()
6280 tree block
= DECL_INITIAL (current_function_decl
);
6282 reorder_blocks (block_vector
, block
, get_insns ());
6284 /* Release any memory allocated by identify_blocks. */
6286 free (block_vector
);