1 /* Expands front end tree to back end RTL for GNU C-Compiler
2 Copyright (C) 1987, 88, 89, 92-7, 1998 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"
54 #define obstack_chunk_alloc xmalloc
55 #define obstack_chunk_free free
56 struct obstack stmt_obstack
;
58 /* Assume that case vectors are not pc-relative. */
59 #ifndef CASE_VECTOR_PC_RELATIVE
60 #define CASE_VECTOR_PC_RELATIVE 0
63 /* Filename and line number of last line-number note,
64 whether we actually emitted it or not. */
68 /* Nonzero if within a ({...}) grouping, in which case we must
69 always compute a value for each expr-stmt in case it is the last one. */
71 int expr_stmts_for_value
;
73 /* Each time we expand an expression-statement,
74 record the expr's type and its RTL value here. */
76 static tree last_expr_type
;
77 static rtx last_expr_value
;
79 /* Each time we expand the end of a binding contour (in `expand_end_bindings')
80 and we emit a new NOTE_INSN_BLOCK_END note, we save a pointer to it here.
81 This is used by the `remember_end_note' function to record the endpoint
82 of each generated block in its associated BLOCK node. */
84 static rtx last_block_end_note
;
86 /* Number of binding contours started so far in this function. */
88 int block_start_count
;
90 /* Nonzero if function being compiled needs to
91 return the address of where it has put a structure value. */
93 extern int current_function_returns_pcc_struct
;
95 /* Label that will go on parm cleanup code, if any.
96 Jumping to this label runs cleanup code for parameters, if
97 such code must be run. Following this code is the logical return label. */
99 extern rtx cleanup_label
;
101 /* Label that will go on function epilogue.
102 Jumping to this label serves as a "return" instruction
103 on machines which require execution of the epilogue on all returns. */
105 extern rtx return_label
;
107 /* Offset to end of allocated area of stack frame.
108 If stack grows down, this is the address of the last stack slot allocated.
109 If stack grows up, this is the address for the next slot. */
110 extern int frame_offset
;
112 /* Label to jump back to for tail recursion, or 0 if we have
113 not yet needed one for this function. */
114 extern rtx tail_recursion_label
;
116 /* Place after which to insert the tail_recursion_label if we need one. */
117 extern rtx tail_recursion_reentry
;
119 /* Location at which to save the argument pointer if it will need to be
120 referenced. There are two cases where this is done: if nonlocal gotos
121 exist, or if vars whose is an offset from the argument pointer will be
122 needed by inner routines. */
124 extern rtx arg_pointer_save_area
;
126 /* Chain of all RTL_EXPRs that have insns in them. */
127 extern tree rtl_expr_chain
;
129 /* Stack allocation level in which temporaries for TARGET_EXPRs live. */
130 extern int target_temp_slot_level
;
132 extern int temp_slot_level
;
134 /* Functions and data structures for expanding case statements. */
136 /* Case label structure, used to hold info on labels within case
137 statements. We handle "range" labels; for a single-value label
138 as in C, the high and low limits are the same.
140 An AVL tree of case nodes is initially created, and later transformed
141 to a list linked via the RIGHT fields in the nodes. Nodes with
142 higher case values are later in the list.
144 Switch statements can be output in one of two forms. A branch table
145 is used if there are more than a few labels and the labels are dense
146 within the range between the smallest and largest case value. If a
147 branch table is used, no further manipulations are done with the case
150 The alternative to the use of a branch table is to generate a series
151 of compare and jump insns. When that is done, we use the LEFT, RIGHT,
152 and PARENT fields to hold a binary tree. Initially the tree is
153 totally unbalanced, with everything on the right. We balance the tree
154 with nodes on the left having lower case values than the parent
155 and nodes on the right having higher values. We then output the tree
160 struct case_node
*left
; /* Left son in binary tree */
161 struct case_node
*right
; /* Right son in binary tree; also node chain */
162 struct case_node
*parent
; /* Parent of node in binary tree */
163 tree low
; /* Lowest index value for this label */
164 tree high
; /* Highest index value for this label */
165 tree code_label
; /* Label to jump to when node matches */
169 typedef struct case_node case_node
;
170 typedef struct case_node
*case_node_ptr
;
172 /* These are used by estimate_case_costs and balance_case_nodes. */
174 /* This must be a signed type, and non-ANSI compilers lack signed char. */
175 static short *cost_table
;
176 static int use_cost_table
;
178 /* Stack of control and binding constructs we are currently inside.
180 These constructs begin when you call `expand_start_WHATEVER'
181 and end when you call `expand_end_WHATEVER'. This stack records
182 info about how the construct began that tells the end-function
183 what to do. It also may provide information about the construct
184 to alter the behavior of other constructs within the body.
185 For example, they may affect the behavior of C `break' and `continue'.
187 Each construct gets one `struct nesting' object.
188 All of these objects are chained through the `all' field.
189 `nesting_stack' points to the first object (innermost construct).
190 The position of an entry on `nesting_stack' is in its `depth' field.
192 Each type of construct has its own individual stack.
193 For example, loops have `loop_stack'. Each object points to the
194 next object of the same type through the `next' field.
196 Some constructs are visible to `break' exit-statements and others
197 are not. Which constructs are visible depends on the language.
198 Therefore, the data structure allows each construct to be visible
199 or not, according to the args given when the construct is started.
200 The construct is visible if the `exit_label' field is non-null.
201 In that case, the value should be a CODE_LABEL rtx. */
206 struct nesting
*next
;
211 /* For conds (if-then and if-then-else statements). */
214 /* Label for the end of the if construct.
215 There is none if EXITFLAG was not set
216 and no `else' has been seen yet. */
218 /* Label for the end of this alternative.
219 This may be the end of the if or the next else/elseif. */
225 /* Label at the top of the loop; place to loop back to. */
227 /* Label at the end of the whole construct. */
229 /* Label before a jump that branches to the end of the whole
230 construct. This is where destructors go if any. */
232 /* Label for `continue' statement to jump to;
233 this is in front of the stepper of the loop. */
236 /* For variable binding contours. */
239 /* Sequence number of this binding contour within the function,
240 in order of entry. */
241 int block_start_count
;
242 /* Nonzero => value to restore stack to on exit. */
244 /* The NOTE that starts this contour.
245 Used by expand_goto to check whether the destination
246 is within each contour or not. */
248 /* Innermost containing binding contour that has a stack level. */
249 struct nesting
*innermost_stack_block
;
250 /* List of cleanups to be run on exit from this contour.
251 This is a list of expressions to be evaluated.
252 The TREE_PURPOSE of each link is the ..._DECL node
253 which the cleanup pertains to. */
255 /* List of cleanup-lists of blocks containing this block,
256 as they were at the locus where this block appears.
257 There is an element for each containing block,
258 ordered innermost containing block first.
259 The tail of this list can be 0,
260 if all remaining elements would be empty lists.
261 The element's TREE_VALUE is the cleanup-list of that block,
262 which may be null. */
264 /* Chain of labels defined inside this binding contour.
265 For contours that have stack levels or cleanups. */
266 struct label_chain
*label_chain
;
267 /* Number of function calls seen, as of start of this block. */
268 int function_call_count
;
269 /* Nonzero if this is associated with a EH region. */
270 int exception_region
;
271 /* The saved target_temp_slot_level from our outer block.
272 We may reset target_temp_slot_level to be the level of
273 this block, if that is done, target_temp_slot_level
274 reverts to the saved target_temp_slot_level at the very
276 int target_temp_slot_level
;
277 /* True if we are currently emitting insns in an area of
278 output code that is controlled by a conditional
279 expression. This is used by the cleanup handling code to
280 generate conditional cleanup actions. */
281 int conditional_code
;
282 /* A place to move the start of the exception region for any
283 of the conditional cleanups, must be at the end or after
284 the start of the last unconditional cleanup, and before any
285 conditional branch points. */
286 rtx last_unconditional_cleanup
;
287 /* When in a conditional context, this is the specific
288 cleanup list associated with last_unconditional_cleanup,
289 where we place the conditionalized cleanups. */
292 /* For switch (C) or case (Pascal) statements,
293 and also for dummies (see `expand_start_case_dummy'). */
296 /* The insn after which the case dispatch should finally
297 be emitted. Zero for a dummy. */
299 /* A list of case labels; it is first built as an AVL tree.
300 During expand_end_case, this is converted to a list, and may be
301 rearranged into a nearly balanced binary tree. */
302 struct case_node
*case_list
;
303 /* Label to jump to if no case matches. */
305 /* The expression to be dispatched on. */
307 /* Type that INDEX_EXPR should be converted to. */
309 /* Number of range exprs in case statement. */
311 /* Name of this kind of statement, for warnings. */
313 /* Used to save no_line_numbers till we see the first case label.
314 We set this to -1 when we see the first case label in this
316 int line_number_status
;
321 /* Chain of all pending binding contours. */
322 struct nesting
*block_stack
;
324 /* If any new stacks are added here, add them to POPSTACKS too. */
326 /* Chain of all pending binding contours that restore stack levels
328 struct nesting
*stack_block_stack
;
330 /* Chain of all pending conditional statements. */
331 struct nesting
*cond_stack
;
333 /* Chain of all pending loops. */
334 struct nesting
*loop_stack
;
336 /* Chain of all pending case or switch statements. */
337 struct nesting
*case_stack
;
339 /* Separate chain including all of the above,
340 chained through the `all' field. */
341 struct nesting
*nesting_stack
;
343 /* Number of entries on nesting_stack now. */
346 /* Allocate and return a new `struct nesting'. */
348 #define ALLOC_NESTING() \
349 (struct nesting *) obstack_alloc (&stmt_obstack, sizeof (struct nesting))
351 /* Pop the nesting stack element by element until we pop off
352 the element which is at the top of STACK.
353 Update all the other stacks, popping off elements from them
354 as we pop them from nesting_stack. */
356 #define POPSTACK(STACK) \
357 do { struct nesting *target = STACK; \
358 struct nesting *this; \
359 do { this = nesting_stack; \
360 if (loop_stack == this) \
361 loop_stack = loop_stack->next; \
362 if (cond_stack == this) \
363 cond_stack = cond_stack->next; \
364 if (block_stack == this) \
365 block_stack = block_stack->next; \
366 if (stack_block_stack == this) \
367 stack_block_stack = stack_block_stack->next; \
368 if (case_stack == this) \
369 case_stack = case_stack->next; \
370 nesting_depth = nesting_stack->depth - 1; \
371 nesting_stack = this->all; \
372 obstack_free (&stmt_obstack, this); } \
373 while (this != target); } while (0)
375 /* In some cases it is impossible to generate code for a forward goto
376 until the label definition is seen. This happens when it may be necessary
377 for the goto to reset the stack pointer: we don't yet know how to do that.
378 So expand_goto puts an entry on this fixup list.
379 Each time a binding contour that resets the stack is exited,
381 If the target label has now been defined, we can insert the proper code. */
385 /* Points to following fixup. */
386 struct goto_fixup
*next
;
387 /* Points to the insn before the jump insn.
388 If more code must be inserted, it goes after this insn. */
390 /* The LABEL_DECL that this jump is jumping to, or 0
391 for break, continue or return. */
393 /* The BLOCK for the place where this goto was found. */
395 /* The CODE_LABEL rtx that this is jumping to. */
397 /* Number of binding contours started in current function
398 before the label reference. */
399 int block_start_count
;
400 /* The outermost stack level that should be restored for this jump.
401 Each time a binding contour that resets the stack is exited,
402 if the target label is *not* yet defined, this slot is updated. */
404 /* List of lists of cleanup expressions to be run by this goto.
405 There is one element for each block that this goto is within.
406 The tail of this list can be 0,
407 if all remaining elements would be empty.
408 The TREE_VALUE contains the cleanup list of that block as of the
409 time this goto was seen.
410 The TREE_ADDRESSABLE flag is 1 for a block that has been exited. */
411 tree cleanup_list_list
;
414 static struct goto_fixup
*goto_fixup_chain
;
416 /* Within any binding contour that must restore a stack level,
417 all labels are recorded with a chain of these structures. */
421 /* Points to following fixup. */
422 struct label_chain
*next
;
427 /* Non-zero if we are using EH to handle cleanus. */
428 static int using_eh_for_cleanups_p
= 0;
431 static void expand_goto_internal
PROTO((tree
, rtx
, rtx
));
432 static int expand_fixup
PROTO((tree
, rtx
, rtx
));
433 static void fixup_gotos
PROTO((struct nesting
*, rtx
, tree
,
435 static void expand_null_return_1
PROTO((rtx
, int));
436 static void expand_value_return
PROTO((rtx
));
437 static int tail_recursion_args
PROTO((tree
, tree
));
438 static void expand_cleanups
PROTO((tree
, tree
, int, int));
439 static void do_jump_if_equal
PROTO((rtx
, rtx
, rtx
, int));
440 static int estimate_case_costs
PROTO((case_node_ptr
));
441 static void group_case_nodes
PROTO((case_node_ptr
));
442 static void balance_case_nodes
PROTO((case_node_ptr
*,
444 static int node_has_low_bound
PROTO((case_node_ptr
, tree
));
445 static int node_has_high_bound
PROTO((case_node_ptr
, tree
));
446 static int node_is_bounded
PROTO((case_node_ptr
, tree
));
447 static void emit_jump_if_reachable
PROTO((rtx
));
448 static void emit_case_nodes
PROTO((rtx
, case_node_ptr
, rtx
, tree
));
449 static int add_case_node
PROTO((tree
, tree
, tree
, tree
*));
450 static struct case_node
*case_tree2list
PROTO((case_node
*, case_node
*));
454 using_eh_for_cleanups ()
456 using_eh_for_cleanups_p
= 1;
462 gcc_obstack_init (&stmt_obstack
);
467 init_stmt_for_function ()
469 /* We are not currently within any block, conditional, loop or case. */
471 stack_block_stack
= 0;
478 block_start_count
= 0;
480 /* No gotos have been expanded yet. */
481 goto_fixup_chain
= 0;
483 /* We are not processing a ({...}) grouping. */
484 expr_stmts_for_value
= 0;
487 init_eh_for_function ();
494 p
->block_stack
= block_stack
;
495 p
->stack_block_stack
= stack_block_stack
;
496 p
->cond_stack
= cond_stack
;
497 p
->loop_stack
= loop_stack
;
498 p
->case_stack
= case_stack
;
499 p
->nesting_stack
= nesting_stack
;
500 p
->nesting_depth
= nesting_depth
;
501 p
->block_start_count
= block_start_count
;
502 p
->last_expr_type
= last_expr_type
;
503 p
->last_expr_value
= last_expr_value
;
504 p
->expr_stmts_for_value
= expr_stmts_for_value
;
505 p
->emit_filename
= emit_filename
;
506 p
->emit_lineno
= emit_lineno
;
507 p
->goto_fixup_chain
= goto_fixup_chain
;
512 restore_stmt_status (p
)
515 block_stack
= p
->block_stack
;
516 stack_block_stack
= p
->stack_block_stack
;
517 cond_stack
= p
->cond_stack
;
518 loop_stack
= p
->loop_stack
;
519 case_stack
= p
->case_stack
;
520 nesting_stack
= p
->nesting_stack
;
521 nesting_depth
= p
->nesting_depth
;
522 block_start_count
= p
->block_start_count
;
523 last_expr_type
= p
->last_expr_type
;
524 last_expr_value
= p
->last_expr_value
;
525 expr_stmts_for_value
= p
->expr_stmts_for_value
;
526 emit_filename
= p
->emit_filename
;
527 emit_lineno
= p
->emit_lineno
;
528 goto_fixup_chain
= p
->goto_fixup_chain
;
529 restore_eh_status (p
);
532 /* Emit a no-op instruction. */
539 last_insn
= get_last_insn ();
541 && (GET_CODE (last_insn
) == CODE_LABEL
542 || (GET_CODE (last_insn
) == NOTE
543 && prev_real_insn (last_insn
) == 0)))
544 emit_insn (gen_nop ());
547 /* Return the rtx-label that corresponds to a LABEL_DECL,
548 creating it if necessary. */
554 if (TREE_CODE (label
) != LABEL_DECL
)
557 if (DECL_RTL (label
))
558 return DECL_RTL (label
);
560 return DECL_RTL (label
) = gen_label_rtx ();
563 /* Add an unconditional jump to LABEL as the next sequential instruction. */
569 do_pending_stack_adjust ();
570 emit_jump_insn (gen_jump (label
));
574 /* Emit code to jump to the address
575 specified by the pointer expression EXP. */
578 expand_computed_goto (exp
)
581 rtx x
= expand_expr (exp
, NULL_RTX
, VOIDmode
, 0);
583 #ifdef POINTERS_EXTEND_UNSIGNED
584 x
= convert_memory_address (Pmode
, x
);
588 /* Be sure the function is executable. */
589 if (flag_check_memory_usage
)
590 emit_library_call (chkr_check_exec_libfunc
, 1,
591 VOIDmode
, 1, x
, ptr_mode
);
593 do_pending_stack_adjust ();
594 emit_indirect_jump (x
);
597 /* Handle goto statements and the labels that they can go to. */
599 /* Specify the location in the RTL code of a label LABEL,
600 which is a LABEL_DECL tree node.
602 This is used for the kind of label that the user can jump to with a
603 goto statement, and for alternatives of a switch or case statement.
604 RTL labels generated for loops and conditionals don't go through here;
605 they are generated directly at the RTL level, by other functions below.
607 Note that this has nothing to do with defining label *names*.
608 Languages vary in how they do that and what that even means. */
614 struct label_chain
*p
;
616 do_pending_stack_adjust ();
617 emit_label (label_rtx (label
));
618 if (DECL_NAME (label
))
619 LABEL_NAME (DECL_RTL (label
)) = IDENTIFIER_POINTER (DECL_NAME (label
));
621 if (stack_block_stack
!= 0)
623 p
= (struct label_chain
*) oballoc (sizeof (struct label_chain
));
624 p
->next
= stack_block_stack
->data
.block
.label_chain
;
625 stack_block_stack
->data
.block
.label_chain
= p
;
630 /* Declare that LABEL (a LABEL_DECL) may be used for nonlocal gotos
631 from nested functions. */
634 declare_nonlocal_label (label
)
637 nonlocal_labels
= tree_cons (NULL_TREE
, label
, nonlocal_labels
);
638 LABEL_PRESERVE_P (label_rtx (label
)) = 1;
639 if (nonlocal_goto_handler_slot
== 0)
641 nonlocal_goto_handler_slot
642 = assign_stack_local (Pmode
, GET_MODE_SIZE (Pmode
), 0);
643 emit_stack_save (SAVE_NONLOCAL
,
644 &nonlocal_goto_stack_level
,
645 PREV_INSN (tail_recursion_reentry
));
649 /* Generate RTL code for a `goto' statement with target label LABEL.
650 LABEL should be a LABEL_DECL tree node that was or will later be
651 defined with `expand_label'. */
659 /* Check for a nonlocal goto to a containing function. */
660 context
= decl_function_context (label
);
661 if (context
!= 0 && context
!= current_function_decl
)
663 struct function
*p
= find_function_data (context
);
664 rtx label_ref
= gen_rtx_LABEL_REF (Pmode
, label_rtx (label
));
667 p
->has_nonlocal_label
= 1;
668 current_function_has_nonlocal_goto
= 1;
669 LABEL_REF_NONLOCAL_P (label_ref
) = 1;
671 /* Copy the rtl for the slots so that they won't be shared in
672 case the virtual stack vars register gets instantiated differently
673 in the parent than in the child. */
675 #if HAVE_nonlocal_goto
676 if (HAVE_nonlocal_goto
)
677 emit_insn (gen_nonlocal_goto (lookup_static_chain (label
),
678 copy_rtx (p
->nonlocal_goto_handler_slot
),
679 copy_rtx (p
->nonlocal_goto_stack_level
),
686 /* Restore frame pointer for containing function.
687 This sets the actual hard register used for the frame pointer
688 to the location of the function's incoming static chain info.
689 The non-local goto handler will then adjust it to contain the
690 proper value and reload the argument pointer, if needed. */
691 emit_move_insn (hard_frame_pointer_rtx
, lookup_static_chain (label
));
693 /* We have now loaded the frame pointer hardware register with
694 the address of that corresponds to the start of the virtual
695 stack vars. So replace virtual_stack_vars_rtx in all
696 addresses we use with stack_pointer_rtx. */
698 /* Get addr of containing function's current nonlocal goto handler,
699 which will do any cleanups and then jump to the label. */
700 addr
= copy_rtx (p
->nonlocal_goto_handler_slot
);
701 temp
= copy_to_reg (replace_rtx (addr
, virtual_stack_vars_rtx
,
702 hard_frame_pointer_rtx
));
704 /* Restore the stack pointer. Note this uses fp just restored. */
705 addr
= p
->nonlocal_goto_stack_level
;
707 addr
= replace_rtx (copy_rtx (addr
),
708 virtual_stack_vars_rtx
,
709 hard_frame_pointer_rtx
);
711 emit_stack_restore (SAVE_NONLOCAL
, addr
, NULL_RTX
);
713 /* Put in the static chain register the nonlocal label address. */
714 emit_move_insn (static_chain_rtx
, label_ref
);
715 /* USE of hard_frame_pointer_rtx added for consistency; not clear if
717 emit_insn (gen_rtx_USE (VOIDmode
, hard_frame_pointer_rtx
));
718 emit_insn (gen_rtx_USE (VOIDmode
, stack_pointer_rtx
));
719 emit_insn (gen_rtx_USE (VOIDmode
, static_chain_rtx
));
720 emit_indirect_jump (temp
);
724 expand_goto_internal (label
, label_rtx (label
), NULL_RTX
);
727 /* Generate RTL code for a `goto' statement with target label BODY.
728 LABEL should be a LABEL_REF.
729 LAST_INSN, if non-0, is the rtx we should consider as the last
730 insn emitted (for the purposes of cleaning up a return). */
733 expand_goto_internal (body
, label
, last_insn
)
738 struct nesting
*block
;
741 if (GET_CODE (label
) != CODE_LABEL
)
744 /* If label has already been defined, we can tell now
745 whether and how we must alter the stack level. */
747 if (PREV_INSN (label
) != 0)
749 /* Find the innermost pending block that contains the label.
750 (Check containment by comparing insn-uids.)
751 Then restore the outermost stack level within that block,
752 and do cleanups of all blocks contained in it. */
753 for (block
= block_stack
; block
; block
= block
->next
)
755 if (INSN_UID (block
->data
.block
.first_insn
) < INSN_UID (label
))
757 if (block
->data
.block
.stack_level
!= 0)
758 stack_level
= block
->data
.block
.stack_level
;
759 /* Execute the cleanups for blocks we are exiting. */
760 if (block
->data
.block
.cleanups
!= 0)
762 expand_cleanups (block
->data
.block
.cleanups
, NULL_TREE
, 1, 1);
763 do_pending_stack_adjust ();
769 /* Ensure stack adjust isn't done by emit_jump, as this
770 would clobber the stack pointer. This one should be
771 deleted as dead by flow. */
772 clear_pending_stack_adjust ();
773 do_pending_stack_adjust ();
774 emit_stack_restore (SAVE_BLOCK
, stack_level
, NULL_RTX
);
777 if (body
!= 0 && DECL_TOO_LATE (body
))
778 error ("jump to `%s' invalidly jumps into binding contour",
779 IDENTIFIER_POINTER (DECL_NAME (body
)));
781 /* Label not yet defined: may need to put this goto
782 on the fixup list. */
783 else if (! expand_fixup (body
, label
, last_insn
))
785 /* No fixup needed. Record that the label is the target
786 of at least one goto that has no fixup. */
788 TREE_ADDRESSABLE (body
) = 1;
794 /* Generate if necessary a fixup for a goto
795 whose target label in tree structure (if any) is TREE_LABEL
796 and whose target in rtl is RTL_LABEL.
798 If LAST_INSN is nonzero, we pretend that the jump appears
799 after insn LAST_INSN instead of at the current point in the insn stream.
801 The fixup will be used later to insert insns just before the goto.
802 Those insns will restore the stack level as appropriate for the
803 target label, and will (in the case of C++) also invoke any object
804 destructors which have to be invoked when we exit the scopes which
805 are exited by the goto.
807 Value is nonzero if a fixup is made. */
810 expand_fixup (tree_label
, rtl_label
, last_insn
)
815 struct nesting
*block
, *end_block
;
817 /* See if we can recognize which block the label will be output in.
818 This is possible in some very common cases.
819 If we succeed, set END_BLOCK to that block.
820 Otherwise, set it to 0. */
823 && (rtl_label
== cond_stack
->data
.cond
.endif_label
824 || rtl_label
== cond_stack
->data
.cond
.next_label
))
825 end_block
= cond_stack
;
826 /* If we are in a loop, recognize certain labels which
827 are likely targets. This reduces the number of fixups
828 we need to create. */
830 && (rtl_label
== loop_stack
->data
.loop
.start_label
831 || rtl_label
== loop_stack
->data
.loop
.end_label
832 || rtl_label
== loop_stack
->data
.loop
.continue_label
))
833 end_block
= loop_stack
;
837 /* Now set END_BLOCK to the binding level to which we will return. */
841 struct nesting
*next_block
= end_block
->all
;
844 /* First see if the END_BLOCK is inside the innermost binding level.
845 If so, then no cleanups or stack levels are relevant. */
846 while (next_block
&& next_block
!= block
)
847 next_block
= next_block
->all
;
852 /* Otherwise, set END_BLOCK to the innermost binding level
853 which is outside the relevant control-structure nesting. */
854 next_block
= block_stack
->next
;
855 for (block
= block_stack
; block
!= end_block
; block
= block
->all
)
856 if (block
== next_block
)
857 next_block
= next_block
->next
;
858 end_block
= next_block
;
861 /* Does any containing block have a stack level or cleanups?
862 If not, no fixup is needed, and that is the normal case
863 (the only case, for standard C). */
864 for (block
= block_stack
; block
!= end_block
; block
= block
->next
)
865 if (block
->data
.block
.stack_level
!= 0
866 || block
->data
.block
.cleanups
!= 0)
869 if (block
!= end_block
)
871 /* Ok, a fixup is needed. Add a fixup to the list of such. */
872 struct goto_fixup
*fixup
873 = (struct goto_fixup
*) oballoc (sizeof (struct goto_fixup
));
874 /* In case an old stack level is restored, make sure that comes
875 after any pending stack adjust. */
876 /* ?? If the fixup isn't to come at the present position,
877 doing the stack adjust here isn't useful. Doing it with our
878 settings at that location isn't useful either. Let's hope
881 do_pending_stack_adjust ();
882 fixup
->target
= tree_label
;
883 fixup
->target_rtl
= rtl_label
;
885 /* Create a BLOCK node and a corresponding matched set of
886 NOTE_INSN_BEGIN_BLOCK and NOTE_INSN_END_BLOCK notes at
887 this point. The notes will encapsulate any and all fixup
888 code which we might later insert at this point in the insn
889 stream. Also, the BLOCK node will be the parent (i.e. the
890 `SUPERBLOCK') of any other BLOCK nodes which we might create
891 later on when we are expanding the fixup code. */
894 register rtx original_before_jump
895 = last_insn
? last_insn
: get_last_insn ();
899 fixup
->before_jump
= emit_note (NULL_PTR
, NOTE_INSN_BLOCK_BEG
);
900 last_block_end_note
= emit_note (NULL_PTR
, NOTE_INSN_BLOCK_END
);
901 fixup
->context
= poplevel (1, 0, 0); /* Create the BLOCK node now! */
903 emit_insns_after (fixup
->before_jump
, original_before_jump
);
906 fixup
->block_start_count
= block_start_count
;
907 fixup
->stack_level
= 0;
908 fixup
->cleanup_list_list
909 = ((block
->data
.block
.outer_cleanups
910 || block
->data
.block
.cleanups
)
911 ? tree_cons (NULL_TREE
, block
->data
.block
.cleanups
,
912 block
->data
.block
.outer_cleanups
)
914 fixup
->next
= goto_fixup_chain
;
915 goto_fixup_chain
= fixup
;
923 /* Expand any needed fixups in the outputmost binding level of the
924 function. FIRST_INSN is the first insn in the function. */
927 expand_fixups (first_insn
)
930 fixup_gotos (NULL_PTR
, NULL_RTX
, NULL_TREE
, first_insn
, 0);
933 /* When exiting a binding contour, process all pending gotos requiring fixups.
934 THISBLOCK is the structure that describes the block being exited.
935 STACK_LEVEL is the rtx for the stack level to restore exiting this contour.
936 CLEANUP_LIST is a list of expressions to evaluate on exiting this contour.
937 FIRST_INSN is the insn that began this contour.
939 Gotos that jump out of this contour must restore the
940 stack level and do the cleanups before actually jumping.
942 DONT_JUMP_IN nonzero means report error there is a jump into this
943 contour from before the beginning of the contour.
944 This is also done if STACK_LEVEL is nonzero. */
947 fixup_gotos (thisblock
, stack_level
, cleanup_list
, first_insn
, dont_jump_in
)
948 struct nesting
*thisblock
;
954 register struct goto_fixup
*f
, *prev
;
956 /* F is the fixup we are considering; PREV is the previous one. */
957 /* We run this loop in two passes so that cleanups of exited blocks
958 are run first, and blocks that are exited are marked so
961 for (prev
= 0, f
= goto_fixup_chain
; f
; prev
= f
, f
= f
->next
)
963 /* Test for a fixup that is inactive because it is already handled. */
964 if (f
->before_jump
== 0)
966 /* Delete inactive fixup from the chain, if that is easy to do. */
968 prev
->next
= f
->next
;
970 /* Has this fixup's target label been defined?
971 If so, we can finalize it. */
972 else if (PREV_INSN (f
->target_rtl
) != 0)
974 register rtx cleanup_insns
;
976 /* Get the first non-label after the label
977 this goto jumps to. If that's before this scope begins,
978 we don't have a jump into the scope. */
979 rtx after_label
= f
->target_rtl
;
980 while (after_label
!= 0 && GET_CODE (after_label
) == CODE_LABEL
)
981 after_label
= NEXT_INSN (after_label
);
983 /* If this fixup jumped into this contour from before the beginning
984 of this contour, report an error. */
985 /* ??? Bug: this does not detect jumping in through intermediate
986 blocks that have stack levels or cleanups.
987 It detects only a problem with the innermost block
990 && (dont_jump_in
|| stack_level
|| cleanup_list
)
991 /* If AFTER_LABEL is 0, it means the jump goes to the end
992 of the rtl, which means it jumps into this scope. */
994 || INSN_UID (first_insn
) < INSN_UID (after_label
))
995 && INSN_UID (first_insn
) > INSN_UID (f
->before_jump
)
996 && ! DECL_ERROR_ISSUED (f
->target
))
998 error_with_decl (f
->target
,
999 "label `%s' used before containing binding contour");
1000 /* Prevent multiple errors for one label. */
1001 DECL_ERROR_ISSUED (f
->target
) = 1;
1004 /* We will expand the cleanups into a sequence of their own and
1005 then later on we will attach this new sequence to the insn
1006 stream just ahead of the actual jump insn. */
1010 /* Temporarily restore the lexical context where we will
1011 logically be inserting the fixup code. We do this for the
1012 sake of getting the debugging information right. */
1015 set_block (f
->context
);
1017 /* Expand the cleanups for blocks this jump exits. */
1018 if (f
->cleanup_list_list
)
1021 for (lists
= f
->cleanup_list_list
; lists
; lists
= TREE_CHAIN (lists
))
1022 /* Marked elements correspond to blocks that have been closed.
1023 Do their cleanups. */
1024 if (TREE_ADDRESSABLE (lists
)
1025 && TREE_VALUE (lists
) != 0)
1027 expand_cleanups (TREE_VALUE (lists
), NULL_TREE
, 1, 1);
1028 /* Pop any pushes done in the cleanups,
1029 in case function is about to return. */
1030 do_pending_stack_adjust ();
1034 /* Restore stack level for the biggest contour that this
1035 jump jumps out of. */
1037 emit_stack_restore (SAVE_BLOCK
, f
->stack_level
, f
->before_jump
);
1039 /* Finish up the sequence containing the insns which implement the
1040 necessary cleanups, and then attach that whole sequence to the
1041 insn stream just ahead of the actual jump insn. Attaching it
1042 at that point insures that any cleanups which are in fact
1043 implicit C++ object destructions (which must be executed upon
1044 leaving the block) appear (to the debugger) to be taking place
1045 in an area of the generated code where the object(s) being
1046 destructed are still "in scope". */
1048 cleanup_insns
= get_insns ();
1052 emit_insns_after (cleanup_insns
, f
->before_jump
);
1059 /* For any still-undefined labels, do the cleanups for this block now.
1060 We must do this now since items in the cleanup list may go out
1061 of scope when the block ends. */
1062 for (prev
= 0, f
= goto_fixup_chain
; f
; prev
= f
, f
= f
->next
)
1063 if (f
->before_jump
!= 0
1064 && PREV_INSN (f
->target_rtl
) == 0
1065 /* Label has still not appeared. If we are exiting a block with
1066 a stack level to restore, that started before the fixup,
1067 mark this stack level as needing restoration
1068 when the fixup is later finalized. */
1070 /* Note: if THISBLOCK == 0 and we have a label that hasn't appeared, it
1071 means the label is undefined. That's erroneous, but possible. */
1072 && (thisblock
->data
.block
.block_start_count
1073 <= f
->block_start_count
))
1075 tree lists
= f
->cleanup_list_list
;
1078 for (; lists
; lists
= TREE_CHAIN (lists
))
1079 /* If the following elt. corresponds to our containing block
1080 then the elt. must be for this block. */
1081 if (TREE_CHAIN (lists
) == thisblock
->data
.block
.outer_cleanups
)
1085 set_block (f
->context
);
1086 expand_cleanups (TREE_VALUE (lists
), NULL_TREE
, 1, 1);
1087 do_pending_stack_adjust ();
1088 cleanup_insns
= get_insns ();
1091 if (cleanup_insns
!= 0)
1093 = emit_insns_after (cleanup_insns
, f
->before_jump
);
1095 f
->cleanup_list_list
= TREE_CHAIN (lists
);
1099 f
->stack_level
= stack_level
;
1105 /* Generate RTL for an asm statement (explicit assembler code).
1106 BODY is a STRING_CST node containing the assembler code text,
1107 or an ADDR_EXPR containing a STRING_CST. */
1113 if (flag_check_memory_usage
)
1115 error ("`asm' cannot be used with `-fcheck-memory-usage'");
1119 if (TREE_CODE (body
) == ADDR_EXPR
)
1120 body
= TREE_OPERAND (body
, 0);
1122 emit_insn (gen_rtx_ASM_INPUT (VOIDmode
,
1123 TREE_STRING_POINTER (body
)));
1127 /* Generate RTL for an asm statement with arguments.
1128 STRING is the instruction template.
1129 OUTPUTS is a list of output arguments (lvalues); INPUTS a list of inputs.
1130 Each output or input has an expression in the TREE_VALUE and
1131 a constraint-string in the TREE_PURPOSE.
1132 CLOBBERS is a list of STRING_CST nodes each naming a hard register
1133 that is clobbered by this insn.
1135 Not all kinds of lvalue that may appear in OUTPUTS can be stored directly.
1136 Some elements of OUTPUTS may be replaced with trees representing temporary
1137 values. The caller should copy those temporary values to the originally
1140 VOL nonzero means the insn is volatile; don't optimize it. */
1143 expand_asm_operands (string
, outputs
, inputs
, clobbers
, vol
, filename
, line
)
1144 tree string
, outputs
, inputs
, clobbers
;
1149 rtvec argvec
, constraints
;
1151 int ninputs
= list_length (inputs
);
1152 int noutputs
= list_length (outputs
);
1157 /* Vector of RTX's of evaluated output operands. */
1158 rtx
*output_rtx
= (rtx
*) alloca (noutputs
* sizeof (rtx
));
1159 int *inout_opnum
= (int *) alloca (noutputs
* sizeof (int));
1160 enum machine_mode
*inout_mode
1161 = (enum machine_mode
*) alloca (noutputs
* sizeof (enum machine_mode
));
1162 /* The insn we have emitted. */
1165 /* An ASM with no outputs needs to be treated as volatile. */
1169 if (flag_check_memory_usage
)
1171 error ("`asm' cannot be used with `-fcheck-memory-usage'");
1175 /* Count the number of meaningful clobbered registers, ignoring what
1176 we would ignore later. */
1178 for (tail
= clobbers
; tail
; tail
= TREE_CHAIN (tail
))
1180 char *regname
= TREE_STRING_POINTER (TREE_VALUE (tail
));
1181 i
= decode_reg_name (regname
);
1182 if (i
>= 0 || i
== -4)
1185 error ("unknown register name `%s' in `asm'", regname
);
1190 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
1192 tree val
= TREE_VALUE (tail
);
1193 tree type
= TREE_TYPE (val
);
1195 int found_equal
= 0;
1199 /* If there's an erroneous arg, emit no insn. */
1200 if (TREE_TYPE (val
) == error_mark_node
)
1203 /* Make sure constraint has `=' and does not have `+'. Also, see
1204 if it allows any register. Be liberal on the latter test, since
1205 the worst that happens if we get it wrong is we issue an error
1208 for (j
= 0; j
< TREE_STRING_LENGTH (TREE_PURPOSE (tail
)) - 1; j
++)
1209 switch (TREE_STRING_POINTER (TREE_PURPOSE (tail
))[j
])
1212 /* Make sure we can specify the matching operand. */
1215 error ("output operand constraint %d contains `+'", i
);
1219 /* Replace '+' with '='. */
1220 TREE_STRING_POINTER (TREE_PURPOSE (tail
))[j
] = '=';
1228 case '?': case '!': case '*': case '%': case '&':
1229 case 'V': case 'm': case 'o': case '<': case '>':
1230 case 'E': case 'F': case 'G': case 'H': case 'X':
1231 case 's': case 'i': case 'n':
1232 case 'I': case 'J': case 'K': case 'L': case 'M':
1233 case 'N': case 'O': case 'P': case ',':
1234 #ifdef EXTRA_CONSTRAINT
1235 case 'Q': case 'R': case 'S': case 'T': case 'U':
1239 case '0': case '1': case '2': case '3': case '4':
1240 case '5': case '6': case '7': case '8': case '9':
1241 error ("matching constraint not valid in output operand");
1244 case 'p': case 'g': case 'r':
1250 if (! found_equal
&& ! found_plus
)
1252 error ("output operand constraint lacks `='");
1256 /* If an output operand is not a decl or indirect ref and our constraint
1257 allows a register, make a temporary to act as an intermediate.
1258 Make the asm insn write into that, then our caller will copy it to
1259 the real output operand. Likewise for promoted variables. */
1261 if (TREE_CODE (val
) == INDIRECT_REF
1262 || (TREE_CODE_CLASS (TREE_CODE (val
)) == 'd'
1263 && ! (GET_CODE (DECL_RTL (val
)) == REG
1264 && GET_MODE (DECL_RTL (val
)) != TYPE_MODE (type
)))
1269 mark_addressable (TREE_VALUE (tail
));
1272 = expand_expr (TREE_VALUE (tail
), NULL_RTX
, VOIDmode
,
1273 EXPAND_MEMORY_USE_WO
);
1275 if (! allows_reg
&& GET_CODE (output_rtx
[i
]) != MEM
)
1276 error ("output number %d not directly addressable", i
);
1280 output_rtx
[i
] = assign_temp (type
, 0, 0, 0);
1281 TREE_VALUE (tail
) = make_tree (type
, output_rtx
[i
]);
1286 inout_mode
[ninout
] = TYPE_MODE (TREE_TYPE (TREE_VALUE (tail
)));
1287 inout_opnum
[ninout
++] = i
;
1292 if (ninputs
+ noutputs
> MAX_RECOG_OPERANDS
)
1294 error ("more than %d operands in `asm'", MAX_RECOG_OPERANDS
);
1298 /* Make vectors for the expression-rtx and constraint strings. */
1300 argvec
= rtvec_alloc (ninputs
);
1301 constraints
= rtvec_alloc (ninputs
);
1303 body
= gen_rtx_ASM_OPERANDS (VOIDmode
,
1304 TREE_STRING_POINTER (string
), "", 0, argvec
,
1305 constraints
, filename
, line
);
1307 MEM_VOLATILE_P (body
) = vol
;
1309 /* Eval the inputs and put them into ARGVEC.
1310 Put their constraints into ASM_INPUTs and store in CONSTRAINTS. */
1313 for (tail
= inputs
; tail
; tail
= TREE_CHAIN (tail
))
1318 /* If there's an erroneous arg, emit no insn,
1319 because the ASM_INPUT would get VOIDmode
1320 and that could cause a crash in reload. */
1321 if (TREE_TYPE (TREE_VALUE (tail
)) == error_mark_node
)
1323 if (TREE_PURPOSE (tail
) == NULL_TREE
)
1325 error ("hard register `%s' listed as input operand to `asm'",
1326 TREE_STRING_POINTER (TREE_VALUE (tail
)) );
1330 /* Make sure constraint has neither `=' nor `+'. */
1332 for (j
= 0; j
< TREE_STRING_LENGTH (TREE_PURPOSE (tail
)) - 1; j
++)
1333 switch (TREE_STRING_POINTER (TREE_PURPOSE (tail
))[j
])
1336 error ("input operand constraint contains `%c'",
1337 TREE_STRING_POINTER (TREE_PURPOSE (tail
))[j
]);
1340 case '?': case '!': case '*': case '%': case '&':
1341 case 'V': case 'm': case 'o': case '<': case '>':
1342 case 'E': case 'F': case 'G': case 'H': case 'X':
1343 case 's': case 'i': case 'n':
1344 case 'I': case 'J': case 'K': case 'L': case 'M':
1345 case 'N': case 'O': case 'P': case ',':
1346 #ifdef EXTRA_CONSTRAINT
1347 case 'Q': case 'R': case 'S': case 'T': case 'U':
1351 /* Whether or not a numeric constraint allows a register is
1352 decided by the matching constraint, and so there is no need
1353 to do anything special with them. We must handle them in
1354 the default case, so that we don't unnecessarily force
1355 operands to memory. */
1356 case '0': case '1': case '2': case '3': case '4':
1357 case '5': case '6': case '7': case '8': case '9':
1358 if (TREE_STRING_POINTER (TREE_PURPOSE (tail
))[j
]
1362 ("matching constraint references invalid operand number");
1366 /* ... fall through ... */
1368 case 'p': case 'g': case 'r':
1375 mark_addressable (TREE_VALUE (tail
));
1377 XVECEXP (body
, 3, i
) /* argvec */
1378 = expand_expr (TREE_VALUE (tail
), NULL_RTX
, VOIDmode
, 0);
1379 if (CONSTANT_P (XVECEXP (body
, 3, i
))
1380 && ! general_operand (XVECEXP (body
, 3, i
),
1381 TYPE_MODE (TREE_TYPE (TREE_VALUE (tail
)))))
1384 XVECEXP (body
, 3, i
)
1385 = force_reg (TYPE_MODE (TREE_TYPE (TREE_VALUE (tail
))),
1386 XVECEXP (body
, 3, i
));
1388 XVECEXP (body
, 3, i
)
1389 = force_const_mem (TYPE_MODE (TREE_TYPE (TREE_VALUE (tail
))),
1390 XVECEXP (body
, 3, i
));
1394 && (GET_CODE (XVECEXP (body
, 3, i
)) == REG
1395 || GET_CODE (XVECEXP (body
, 3, i
)) == SUBREG
1396 || GET_CODE (XVECEXP (body
, 3, i
)) == CONCAT
))
1398 tree type
= TREE_TYPE (TREE_VALUE (tail
));
1399 rtx memloc
= assign_temp (type
, 1, 1, 1);
1401 emit_move_insn (memloc
, XVECEXP (body
, 3, i
));
1402 XVECEXP (body
, 3, i
) = memloc
;
1405 XVECEXP (body
, 4, i
) /* constraints */
1406 = gen_rtx_ASM_INPUT (TYPE_MODE (TREE_TYPE (TREE_VALUE (tail
))),
1407 TREE_STRING_POINTER (TREE_PURPOSE (tail
)));
1411 /* Protect all the operands from the queue,
1412 now that they have all been evaluated. */
1414 for (i
= 0; i
< ninputs
- ninout
; i
++)
1415 XVECEXP (body
, 3, i
) = protect_from_queue (XVECEXP (body
, 3, i
), 0);
1417 for (i
= 0; i
< noutputs
; i
++)
1418 output_rtx
[i
] = protect_from_queue (output_rtx
[i
], 1);
1420 /* For in-out operands, copy output rtx to input rtx. */
1421 for (i
= 0; i
< ninout
; i
++)
1423 static char match
[9+1][2]
1424 = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"};
1425 int j
= inout_opnum
[i
];
1427 XVECEXP (body
, 3, ninputs
- ninout
+ i
) /* argvec */
1429 XVECEXP (body
, 4, ninputs
- ninout
+ i
) /* constraints */
1430 = gen_rtx_ASM_INPUT (inout_mode
[j
], match
[j
]);
1433 /* Now, for each output, construct an rtx
1434 (set OUTPUT (asm_operands INSN OUTPUTNUMBER OUTPUTCONSTRAINT
1435 ARGVEC CONSTRAINTS))
1436 If there is more than one, put them inside a PARALLEL. */
1438 if (noutputs
== 1 && nclobbers
== 0)
1440 XSTR (body
, 1) = TREE_STRING_POINTER (TREE_PURPOSE (outputs
));
1441 insn
= emit_insn (gen_rtx_SET (VOIDmode
, output_rtx
[0], body
));
1443 else if (noutputs
== 0 && nclobbers
== 0)
1445 /* No output operands: put in a raw ASM_OPERANDS rtx. */
1446 insn
= emit_insn (body
);
1452 if (num
== 0) num
= 1;
1453 body
= gen_rtx_PARALLEL (VOIDmode
, rtvec_alloc (num
+ nclobbers
));
1455 /* For each output operand, store a SET. */
1457 for (i
= 0, tail
= outputs
; tail
; tail
= TREE_CHAIN (tail
), i
++)
1459 XVECEXP (body
, 0, i
)
1460 = gen_rtx_SET (VOIDmode
,
1462 gen_rtx_ASM_OPERANDS (VOIDmode
,
1463 TREE_STRING_POINTER (string
),
1464 TREE_STRING_POINTER (TREE_PURPOSE (tail
)),
1465 i
, argvec
, constraints
,
1467 MEM_VOLATILE_P (SET_SRC (XVECEXP (body
, 0, i
))) = vol
;
1470 /* If there are no outputs (but there are some clobbers)
1471 store the bare ASM_OPERANDS into the PARALLEL. */
1474 XVECEXP (body
, 0, i
++) = obody
;
1476 /* Store (clobber REG) for each clobbered register specified. */
1478 for (tail
= clobbers
; tail
; tail
= TREE_CHAIN (tail
))
1480 char *regname
= TREE_STRING_POINTER (TREE_VALUE (tail
));
1481 int j
= decode_reg_name (regname
);
1485 if (j
== -3) /* `cc', which is not a register */
1488 if (j
== -4) /* `memory', don't cache memory across asm */
1490 XVECEXP (body
, 0, i
++)
1491 = gen_rtx_CLOBBER (VOIDmode
,
1492 gen_rtx_MEM (BLKmode
,
1493 gen_rtx_SCRATCH (VOIDmode
)));
1497 /* Ignore unknown register, error already signaled. */
1501 /* Use QImode since that's guaranteed to clobber just one reg. */
1502 XVECEXP (body
, 0, i
++)
1503 = gen_rtx_CLOBBER (VOIDmode
, gen_rtx_REG (QImode
, j
));
1506 insn
= emit_insn (body
);
1512 /* Generate RTL to evaluate the expression EXP
1513 and remember it in case this is the VALUE in a ({... VALUE; }) constr. */
1516 expand_expr_stmt (exp
)
1519 /* If -W, warn about statements with no side effects,
1520 except for an explicit cast to void (e.g. for assert()), and
1521 except inside a ({...}) where they may be useful. */
1522 if (expr_stmts_for_value
== 0 && exp
!= error_mark_node
)
1524 if (! TREE_SIDE_EFFECTS (exp
) && (extra_warnings
|| warn_unused
)
1525 && !(TREE_CODE (exp
) == CONVERT_EXPR
1526 && TREE_TYPE (exp
) == void_type_node
))
1527 warning_with_file_and_line (emit_filename
, emit_lineno
,
1528 "statement with no effect");
1529 else if (warn_unused
)
1530 warn_if_unused_value (exp
);
1533 /* If EXP is of function type and we are expanding statements for
1534 value, convert it to pointer-to-function. */
1535 if (expr_stmts_for_value
&& TREE_CODE (TREE_TYPE (exp
)) == FUNCTION_TYPE
)
1536 exp
= build1 (ADDR_EXPR
, build_pointer_type (TREE_TYPE (exp
)), exp
);
1538 last_expr_type
= TREE_TYPE (exp
);
1539 if (! flag_syntax_only
)
1540 last_expr_value
= expand_expr (exp
,
1541 (expr_stmts_for_value
1542 ? NULL_RTX
: const0_rtx
),
1545 /* If all we do is reference a volatile value in memory,
1546 copy it to a register to be sure it is actually touched. */
1547 if (last_expr_value
!= 0 && GET_CODE (last_expr_value
) == MEM
1548 && TREE_THIS_VOLATILE (exp
))
1550 if (TYPE_MODE (TREE_TYPE (exp
)) == VOIDmode
)
1552 else if (TYPE_MODE (TREE_TYPE (exp
)) != BLKmode
)
1553 copy_to_reg (last_expr_value
);
1556 rtx lab
= gen_label_rtx ();
1558 /* Compare the value with itself to reference it. */
1559 emit_cmp_insn (last_expr_value
, last_expr_value
, EQ
,
1560 expand_expr (TYPE_SIZE (last_expr_type
),
1561 NULL_RTX
, VOIDmode
, 0),
1563 TYPE_ALIGN (last_expr_type
) / BITS_PER_UNIT
);
1564 emit_jump_insn ((*bcc_gen_fctn
[(int) EQ
]) (lab
));
1569 /* If this expression is part of a ({...}) and is in memory, we may have
1570 to preserve temporaries. */
1571 preserve_temp_slots (last_expr_value
);
1573 /* Free any temporaries used to evaluate this expression. Any temporary
1574 used as a result of this expression will already have been preserved
1581 /* Warn if EXP contains any computations whose results are not used.
1582 Return 1 if a warning is printed; 0 otherwise. */
1585 warn_if_unused_value (exp
)
1588 if (TREE_USED (exp
))
1591 switch (TREE_CODE (exp
))
1593 case PREINCREMENT_EXPR
:
1594 case POSTINCREMENT_EXPR
:
1595 case PREDECREMENT_EXPR
:
1596 case POSTDECREMENT_EXPR
:
1601 case METHOD_CALL_EXPR
:
1603 case TRY_CATCH_EXPR
:
1604 case WITH_CLEANUP_EXPR
:
1606 /* We don't warn about COND_EXPR because it may be a useful
1607 construct if either arm contains a side effect. */
1612 /* For a binding, warn if no side effect within it. */
1613 return warn_if_unused_value (TREE_OPERAND (exp
, 1));
1616 return warn_if_unused_value (TREE_OPERAND (exp
, 1));
1618 case TRUTH_ORIF_EXPR
:
1619 case TRUTH_ANDIF_EXPR
:
1620 /* In && or ||, warn if 2nd operand has no side effect. */
1621 return warn_if_unused_value (TREE_OPERAND (exp
, 1));
1624 if (TREE_NO_UNUSED_WARNING (exp
))
1626 if (warn_if_unused_value (TREE_OPERAND (exp
, 0)))
1628 /* Let people do `(foo (), 0)' without a warning. */
1629 if (TREE_CONSTANT (TREE_OPERAND (exp
, 1)))
1631 return warn_if_unused_value (TREE_OPERAND (exp
, 1));
1635 case NON_LVALUE_EXPR
:
1636 /* Don't warn about values cast to void. */
1637 if (TREE_TYPE (exp
) == void_type_node
)
1639 /* Don't warn about conversions not explicit in the user's program. */
1640 if (TREE_NO_UNUSED_WARNING (exp
))
1642 /* Assignment to a cast usually results in a cast of a modify.
1643 Don't complain about that. There can be an arbitrary number of
1644 casts before the modify, so we must loop until we find the first
1645 non-cast expression and then test to see if that is a modify. */
1647 tree tem
= TREE_OPERAND (exp
, 0);
1649 while (TREE_CODE (tem
) == CONVERT_EXPR
|| TREE_CODE (tem
) == NOP_EXPR
)
1650 tem
= TREE_OPERAND (tem
, 0);
1652 if (TREE_CODE (tem
) == MODIFY_EXPR
|| TREE_CODE (tem
) == INIT_EXPR
1653 || TREE_CODE (tem
) == CALL_EXPR
)
1659 /* Don't warn about automatic dereferencing of references, since
1660 the user cannot control it. */
1661 if (TREE_CODE (TREE_TYPE (TREE_OPERAND (exp
, 0))) == REFERENCE_TYPE
)
1662 return warn_if_unused_value (TREE_OPERAND (exp
, 0));
1663 /* ... fall through ... */
1666 /* Referencing a volatile value is a side effect, so don't warn. */
1667 if ((TREE_CODE_CLASS (TREE_CODE (exp
)) == 'd'
1668 || TREE_CODE_CLASS (TREE_CODE (exp
)) == 'r')
1669 && TREE_THIS_VOLATILE (exp
))
1672 warning_with_file_and_line (emit_filename
, emit_lineno
,
1673 "value computed is not used");
1678 /* Clear out the memory of the last expression evaluated. */
1686 /* Begin a statement which will return a value.
1687 Return the RTL_EXPR for this statement expr.
1688 The caller must save that value and pass it to expand_end_stmt_expr. */
1691 expand_start_stmt_expr ()
1696 /* Make the RTL_EXPR node temporary, not momentary,
1697 so that rtl_expr_chain doesn't become garbage. */
1698 momentary
= suspend_momentary ();
1699 t
= make_node (RTL_EXPR
);
1700 resume_momentary (momentary
);
1701 do_pending_stack_adjust ();
1702 start_sequence_for_rtl_expr (t
);
1704 expr_stmts_for_value
++;
1708 /* Restore the previous state at the end of a statement that returns a value.
1709 Returns a tree node representing the statement's value and the
1710 insns to compute the value.
1712 The nodes of that expression have been freed by now, so we cannot use them.
1713 But we don't want to do that anyway; the expression has already been
1714 evaluated and now we just want to use the value. So generate a RTL_EXPR
1715 with the proper type and RTL value.
1717 If the last substatement was not an expression,
1718 return something with type `void'. */
1721 expand_end_stmt_expr (t
)
1726 if (last_expr_type
== 0)
1728 last_expr_type
= void_type_node
;
1729 last_expr_value
= const0_rtx
;
1731 else if (last_expr_value
== 0)
1732 /* There are some cases where this can happen, such as when the
1733 statement is void type. */
1734 last_expr_value
= const0_rtx
;
1735 else if (GET_CODE (last_expr_value
) != REG
&& ! CONSTANT_P (last_expr_value
))
1736 /* Remove any possible QUEUED. */
1737 last_expr_value
= protect_from_queue (last_expr_value
, 0);
1741 TREE_TYPE (t
) = last_expr_type
;
1742 RTL_EXPR_RTL (t
) = last_expr_value
;
1743 RTL_EXPR_SEQUENCE (t
) = get_insns ();
1745 rtl_expr_chain
= tree_cons (NULL_TREE
, t
, rtl_expr_chain
);
1749 /* Don't consider deleting this expr or containing exprs at tree level. */
1750 TREE_SIDE_EFFECTS (t
) = 1;
1751 /* Propagate volatility of the actual RTL expr. */
1752 TREE_THIS_VOLATILE (t
) = volatile_refs_p (last_expr_value
);
1755 expr_stmts_for_value
--;
1760 /* Generate RTL for the start of an if-then. COND is the expression
1761 whose truth should be tested.
1763 If EXITFLAG is nonzero, this conditional is visible to
1764 `exit_something'. */
1767 expand_start_cond (cond
, exitflag
)
1771 struct nesting
*thiscond
= ALLOC_NESTING ();
1773 /* Make an entry on cond_stack for the cond we are entering. */
1775 thiscond
->next
= cond_stack
;
1776 thiscond
->all
= nesting_stack
;
1777 thiscond
->depth
= ++nesting_depth
;
1778 thiscond
->data
.cond
.next_label
= gen_label_rtx ();
1779 /* Before we encounter an `else', we don't need a separate exit label
1780 unless there are supposed to be exit statements
1781 to exit this conditional. */
1782 thiscond
->exit_label
= exitflag
? gen_label_rtx () : 0;
1783 thiscond
->data
.cond
.endif_label
= thiscond
->exit_label
;
1784 cond_stack
= thiscond
;
1785 nesting_stack
= thiscond
;
1787 do_jump (cond
, thiscond
->data
.cond
.next_label
, NULL_RTX
);
1790 /* Generate RTL between then-clause and the elseif-clause
1791 of an if-then-elseif-.... */
1794 expand_start_elseif (cond
)
1797 if (cond_stack
->data
.cond
.endif_label
== 0)
1798 cond_stack
->data
.cond
.endif_label
= gen_label_rtx ();
1799 emit_jump (cond_stack
->data
.cond
.endif_label
);
1800 emit_label (cond_stack
->data
.cond
.next_label
);
1801 cond_stack
->data
.cond
.next_label
= gen_label_rtx ();
1802 do_jump (cond
, cond_stack
->data
.cond
.next_label
, NULL_RTX
);
1805 /* Generate RTL between the then-clause and the else-clause
1806 of an if-then-else. */
1809 expand_start_else ()
1811 if (cond_stack
->data
.cond
.endif_label
== 0)
1812 cond_stack
->data
.cond
.endif_label
= gen_label_rtx ();
1814 emit_jump (cond_stack
->data
.cond
.endif_label
);
1815 emit_label (cond_stack
->data
.cond
.next_label
);
1816 cond_stack
->data
.cond
.next_label
= 0; /* No more _else or _elseif calls. */
1819 /* After calling expand_start_else, turn this "else" into an "else if"
1820 by providing another condition. */
1823 expand_elseif (cond
)
1826 cond_stack
->data
.cond
.next_label
= gen_label_rtx ();
1827 do_jump (cond
, cond_stack
->data
.cond
.next_label
, NULL_RTX
);
1830 /* Generate RTL for the end of an if-then.
1831 Pop the record for it off of cond_stack. */
1836 struct nesting
*thiscond
= cond_stack
;
1838 do_pending_stack_adjust ();
1839 if (thiscond
->data
.cond
.next_label
)
1840 emit_label (thiscond
->data
.cond
.next_label
);
1841 if (thiscond
->data
.cond
.endif_label
)
1842 emit_label (thiscond
->data
.cond
.endif_label
);
1844 POPSTACK (cond_stack
);
1850 /* Generate RTL for the start of a loop. EXIT_FLAG is nonzero if this
1851 loop should be exited by `exit_something'. This is a loop for which
1852 `expand_continue' will jump to the top of the loop.
1854 Make an entry on loop_stack to record the labels associated with
1858 expand_start_loop (exit_flag
)
1861 register struct nesting
*thisloop
= ALLOC_NESTING ();
1863 /* Make an entry on loop_stack for the loop we are entering. */
1865 thisloop
->next
= loop_stack
;
1866 thisloop
->all
= nesting_stack
;
1867 thisloop
->depth
= ++nesting_depth
;
1868 thisloop
->data
.loop
.start_label
= gen_label_rtx ();
1869 thisloop
->data
.loop
.end_label
= gen_label_rtx ();
1870 thisloop
->data
.loop
.alt_end_label
= 0;
1871 thisloop
->data
.loop
.continue_label
= thisloop
->data
.loop
.start_label
;
1872 thisloop
->exit_label
= exit_flag
? thisloop
->data
.loop
.end_label
: 0;
1873 loop_stack
= thisloop
;
1874 nesting_stack
= thisloop
;
1876 do_pending_stack_adjust ();
1878 emit_note (NULL_PTR
, NOTE_INSN_LOOP_BEG
);
1879 emit_label (thisloop
->data
.loop
.start_label
);
1884 /* Like expand_start_loop but for a loop where the continuation point
1885 (for expand_continue_loop) will be specified explicitly. */
1888 expand_start_loop_continue_elsewhere (exit_flag
)
1891 struct nesting
*thisloop
= expand_start_loop (exit_flag
);
1892 loop_stack
->data
.loop
.continue_label
= gen_label_rtx ();
1896 /* Specify the continuation point for a loop started with
1897 expand_start_loop_continue_elsewhere.
1898 Use this at the point in the code to which a continue statement
1902 expand_loop_continue_here ()
1904 do_pending_stack_adjust ();
1905 emit_note (NULL_PTR
, NOTE_INSN_LOOP_CONT
);
1906 emit_label (loop_stack
->data
.loop
.continue_label
);
1909 /* Finish a loop. Generate a jump back to the top and the loop-exit label.
1910 Pop the block off of loop_stack. */
1916 register rtx start_label
;
1917 rtx last_test_insn
= 0;
1920 insn
= get_last_insn ();
1921 start_label
= loop_stack
->data
.loop
.start_label
;
1923 /* Mark the continue-point at the top of the loop if none elsewhere. */
1924 if (start_label
== loop_stack
->data
.loop
.continue_label
)
1925 emit_note_before (NOTE_INSN_LOOP_CONT
, start_label
);
1927 do_pending_stack_adjust ();
1929 /* If optimizing, perhaps reorder the loop. If the loop
1930 starts with a conditional exit, roll that to the end
1931 where it will optimize together with the jump back.
1933 We look for the last conditional branch to the exit that we encounter
1934 before hitting 30 insns or a CALL_INSN. If we see an unconditional
1935 branch to the exit first, use it.
1937 We must also stop at NOTE_INSN_BLOCK_BEG and NOTE_INSN_BLOCK_END notes
1938 because moving them is not valid. */
1942 ! (GET_CODE (insn
) == JUMP_INSN
1943 && GET_CODE (PATTERN (insn
)) == SET
1944 && SET_DEST (PATTERN (insn
)) == pc_rtx
1945 && GET_CODE (SET_SRC (PATTERN (insn
))) == IF_THEN_ELSE
))
1947 /* Scan insns from the top of the loop looking for a qualified
1948 conditional exit. */
1949 for (insn
= NEXT_INSN (loop_stack
->data
.loop
.start_label
); insn
;
1950 insn
= NEXT_INSN (insn
))
1952 if (GET_CODE (insn
) == CALL_INSN
|| GET_CODE (insn
) == CODE_LABEL
)
1955 if (GET_CODE (insn
) == NOTE
1956 && (NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_BEG
1957 || NOTE_LINE_NUMBER (insn
) == NOTE_INSN_BLOCK_END
))
1960 if (GET_CODE (insn
) == JUMP_INSN
|| GET_CODE (insn
) == INSN
)
1963 if (last_test_insn
&& num_insns
> 30)
1966 if (GET_CODE (insn
) == JUMP_INSN
&& GET_CODE (PATTERN (insn
)) == SET
1967 && SET_DEST (PATTERN (insn
)) == pc_rtx
1968 && GET_CODE (SET_SRC (PATTERN (insn
))) == IF_THEN_ELSE
1969 && ((GET_CODE (XEXP (SET_SRC (PATTERN (insn
)), 1)) == LABEL_REF
1970 && ((XEXP (XEXP (SET_SRC (PATTERN (insn
)), 1), 0)
1971 == loop_stack
->data
.loop
.end_label
)
1972 || (XEXP (XEXP (SET_SRC (PATTERN (insn
)), 1), 0)
1973 == loop_stack
->data
.loop
.alt_end_label
)))
1974 || (GET_CODE (XEXP (SET_SRC (PATTERN (insn
)), 2)) == LABEL_REF
1975 && ((XEXP (XEXP (SET_SRC (PATTERN (insn
)), 2), 0)
1976 == loop_stack
->data
.loop
.end_label
)
1977 || (XEXP (XEXP (SET_SRC (PATTERN (insn
)), 2), 0)
1978 == loop_stack
->data
.loop
.alt_end_label
)))))
1979 last_test_insn
= insn
;
1981 if (last_test_insn
== 0 && GET_CODE (insn
) == JUMP_INSN
1982 && GET_CODE (PATTERN (insn
)) == SET
1983 && SET_DEST (PATTERN (insn
)) == pc_rtx
1984 && GET_CODE (SET_SRC (PATTERN (insn
))) == LABEL_REF
1985 && ((XEXP (SET_SRC (PATTERN (insn
)), 0)
1986 == loop_stack
->data
.loop
.end_label
)
1987 || (XEXP (SET_SRC (PATTERN (insn
)), 0)
1988 == loop_stack
->data
.loop
.alt_end_label
)))
1989 /* Include BARRIER. */
1990 last_test_insn
= NEXT_INSN (insn
);
1993 if (last_test_insn
!= 0 && last_test_insn
!= get_last_insn ())
1995 /* We found one. Move everything from there up
1996 to the end of the loop, and add a jump into the loop
1997 to jump to there. */
1998 register rtx newstart_label
= gen_label_rtx ();
1999 register rtx start_move
= start_label
;
2001 /* If the start label is preceded by a NOTE_INSN_LOOP_CONT note,
2002 then we want to move this note also. */
2003 if (GET_CODE (PREV_INSN (start_move
)) == NOTE
2004 && (NOTE_LINE_NUMBER (PREV_INSN (start_move
))
2005 == NOTE_INSN_LOOP_CONT
))
2006 start_move
= PREV_INSN (start_move
);
2008 emit_label_after (newstart_label
, PREV_INSN (start_move
));
2009 reorder_insns (start_move
, last_test_insn
, get_last_insn ());
2010 emit_jump_insn_after (gen_jump (start_label
),
2011 PREV_INSN (newstart_label
));
2012 emit_barrier_after (PREV_INSN (newstart_label
));
2013 start_label
= newstart_label
;
2017 emit_jump (start_label
);
2018 emit_note (NULL_PTR
, NOTE_INSN_LOOP_END
);
2019 emit_label (loop_stack
->data
.loop
.end_label
);
2021 POPSTACK (loop_stack
);
2026 /* Generate a jump to the current loop's continue-point.
2027 This is usually the top of the loop, but may be specified
2028 explicitly elsewhere. If not currently inside a loop,
2029 return 0 and do nothing; caller will print an error message. */
2032 expand_continue_loop (whichloop
)
2033 struct nesting
*whichloop
;
2037 whichloop
= loop_stack
;
2040 expand_goto_internal (NULL_TREE
, whichloop
->data
.loop
.continue_label
,
2045 /* Generate a jump to exit the current loop. If not currently inside a loop,
2046 return 0 and do nothing; caller will print an error message. */
2049 expand_exit_loop (whichloop
)
2050 struct nesting
*whichloop
;
2054 whichloop
= loop_stack
;
2057 expand_goto_internal (NULL_TREE
, whichloop
->data
.loop
.end_label
, NULL_RTX
);
2061 /* Generate a conditional jump to exit the current loop if COND
2062 evaluates to zero. If not currently inside a loop,
2063 return 0 and do nothing; caller will print an error message. */
2066 expand_exit_loop_if_false (whichloop
, cond
)
2067 struct nesting
*whichloop
;
2070 rtx label
= gen_label_rtx ();
2075 whichloop
= loop_stack
;
2078 /* In order to handle fixups, we actually create a conditional jump
2079 around a unconditional branch to exit the loop. If fixups are
2080 necessary, they go before the unconditional branch. */
2083 do_jump (cond
, NULL_RTX
, label
);
2084 last_insn
= get_last_insn ();
2085 if (GET_CODE (last_insn
) == CODE_LABEL
)
2086 whichloop
->data
.loop
.alt_end_label
= last_insn
;
2087 expand_goto_internal (NULL_TREE
, whichloop
->data
.loop
.end_label
,
2094 /* Return non-zero if we should preserve sub-expressions as separate
2095 pseudos. We never do so if we aren't optimizing. We always do so
2096 if -fexpensive-optimizations.
2098 Otherwise, we only do so if we are in the "early" part of a loop. I.e.,
2099 the loop may still be a small one. */
2102 preserve_subexpressions_p ()
2106 if (flag_expensive_optimizations
)
2109 if (optimize
== 0 || loop_stack
== 0)
2112 insn
= get_last_insn_anywhere ();
2115 && (INSN_UID (insn
) - INSN_UID (loop_stack
->data
.loop
.start_label
)
2116 < n_non_fixed_regs
* 3));
2120 /* Generate a jump to exit the current loop, conditional, binding contour
2121 or case statement. Not all such constructs are visible to this function,
2122 only those started with EXIT_FLAG nonzero. Individual languages use
2123 the EXIT_FLAG parameter to control which kinds of constructs you can
2126 If not currently inside anything that can be exited,
2127 return 0 and do nothing; caller will print an error message. */
2130 expand_exit_something ()
2134 for (n
= nesting_stack
; n
; n
= n
->all
)
2135 if (n
->exit_label
!= 0)
2137 expand_goto_internal (NULL_TREE
, n
->exit_label
, NULL_RTX
);
2144 /* Generate RTL to return from the current function, with no value.
2145 (That is, we do not do anything about returning any value.) */
2148 expand_null_return ()
2150 struct nesting
*block
= block_stack
;
2153 /* Does any pending block have cleanups? */
2155 while (block
&& block
->data
.block
.cleanups
== 0)
2156 block
= block
->next
;
2158 /* If yes, use a goto to return, since that runs cleanups. */
2160 expand_null_return_1 (last_insn
, block
!= 0);
2163 /* Generate RTL to return from the current function, with value VAL. */
2166 expand_value_return (val
)
2169 struct nesting
*block
= block_stack
;
2170 rtx last_insn
= get_last_insn ();
2171 rtx return_reg
= DECL_RTL (DECL_RESULT (current_function_decl
));
2173 /* Copy the value to the return location
2174 unless it's already there. */
2176 if (return_reg
!= val
)
2178 #ifdef PROMOTE_FUNCTION_RETURN
2179 tree type
= TREE_TYPE (DECL_RESULT (current_function_decl
));
2180 int unsignedp
= TREE_UNSIGNED (type
);
2181 enum machine_mode mode
2182 = promote_mode (type
, DECL_MODE (DECL_RESULT (current_function_decl
)),
2185 if (GET_MODE (val
) != VOIDmode
&& GET_MODE (val
) != mode
)
2186 convert_move (return_reg
, val
, unsignedp
);
2189 emit_move_insn (return_reg
, val
);
2191 if (GET_CODE (return_reg
) == REG
2192 && REGNO (return_reg
) < FIRST_PSEUDO_REGISTER
)
2193 emit_insn (gen_rtx_USE (VOIDmode
, return_reg
));
2194 /* Handle calls that return values in multiple non-contiguous locations.
2195 The Irix 6 ABI has examples of this. */
2196 else if (GET_CODE (return_reg
) == PARALLEL
)
2200 for (i
= 0; i
< XVECLEN (return_reg
, 0); i
++)
2202 rtx x
= XEXP (XVECEXP (return_reg
, 0, i
), 0);
2204 if (GET_CODE (x
) == REG
2205 && REGNO (x
) < FIRST_PSEUDO_REGISTER
)
2206 emit_insn (gen_rtx_USE (VOIDmode
, x
));
2210 /* Does any pending block have cleanups? */
2212 while (block
&& block
->data
.block
.cleanups
== 0)
2213 block
= block
->next
;
2215 /* If yes, use a goto to return, since that runs cleanups.
2216 Use LAST_INSN to put cleanups *before* the move insn emitted above. */
2218 expand_null_return_1 (last_insn
, block
!= 0);
2221 /* Output a return with no value. If LAST_INSN is nonzero,
2222 pretend that the return takes place after LAST_INSN.
2223 If USE_GOTO is nonzero then don't use a return instruction;
2224 go to the return label instead. This causes any cleanups
2225 of pending blocks to be executed normally. */
2228 expand_null_return_1 (last_insn
, use_goto
)
2232 rtx end_label
= cleanup_label
? cleanup_label
: return_label
;
2234 clear_pending_stack_adjust ();
2235 do_pending_stack_adjust ();
2238 /* PCC-struct return always uses an epilogue. */
2239 if (current_function_returns_pcc_struct
|| use_goto
)
2242 end_label
= return_label
= gen_label_rtx ();
2243 expand_goto_internal (NULL_TREE
, end_label
, last_insn
);
2247 /* Otherwise output a simple return-insn if one is available,
2248 unless it won't do the job. */
2250 if (HAVE_return
&& use_goto
== 0 && cleanup_label
== 0)
2252 emit_jump_insn (gen_return ());
2258 /* Otherwise jump to the epilogue. */
2259 expand_goto_internal (NULL_TREE
, end_label
, last_insn
);
2262 /* Generate RTL to evaluate the expression RETVAL and return it
2263 from the current function. */
2266 expand_return (retval
)
2269 /* If there are any cleanups to be performed, then they will
2270 be inserted following LAST_INSN. It is desirable
2271 that the last_insn, for such purposes, should be the
2272 last insn before computing the return value. Otherwise, cleanups
2273 which call functions can clobber the return value. */
2274 /* ??? rms: I think that is erroneous, because in C++ it would
2275 run destructors on variables that might be used in the subsequent
2276 computation of the return value. */
2278 register rtx val
= 0;
2283 /* If function wants no value, give it none. */
2284 if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl
))) == VOID_TYPE
)
2286 expand_expr (retval
, NULL_RTX
, VOIDmode
, 0);
2288 expand_null_return ();
2292 /* Are any cleanups needed? E.g. C++ destructors to be run? */
2293 /* This is not sufficient. We also need to watch for cleanups of the
2294 expression we are about to expand. Unfortunately, we cannot know
2295 if it has cleanups until we expand it, and we want to change how we
2296 expand it depending upon if we need cleanups. We can't win. */
2298 cleanups
= any_pending_cleanups (1);
2303 if (TREE_CODE (retval
) == RESULT_DECL
)
2304 retval_rhs
= retval
;
2305 else if ((TREE_CODE (retval
) == MODIFY_EXPR
|| TREE_CODE (retval
) == INIT_EXPR
)
2306 && TREE_CODE (TREE_OPERAND (retval
, 0)) == RESULT_DECL
)
2307 retval_rhs
= TREE_OPERAND (retval
, 1);
2308 else if (TREE_TYPE (retval
) == void_type_node
)
2309 /* Recognize tail-recursive call to void function. */
2310 retval_rhs
= retval
;
2312 retval_rhs
= NULL_TREE
;
2314 /* Only use `last_insn' if there are cleanups which must be run. */
2315 if (cleanups
|| cleanup_label
!= 0)
2316 last_insn
= get_last_insn ();
2318 /* Distribute return down conditional expr if either of the sides
2319 may involve tail recursion (see test below). This enhances the number
2320 of tail recursions we see. Don't do this always since it can produce
2321 sub-optimal code in some cases and we distribute assignments into
2322 conditional expressions when it would help. */
2324 if (optimize
&& retval_rhs
!= 0
2325 && frame_offset
== 0
2326 && TREE_CODE (retval_rhs
) == COND_EXPR
2327 && (TREE_CODE (TREE_OPERAND (retval_rhs
, 1)) == CALL_EXPR
2328 || TREE_CODE (TREE_OPERAND (retval_rhs
, 2)) == CALL_EXPR
))
2330 rtx label
= gen_label_rtx ();
2333 do_jump (TREE_OPERAND (retval_rhs
, 0), label
, NULL_RTX
);
2334 expr
= build (MODIFY_EXPR
, TREE_TYPE (TREE_TYPE (current_function_decl
)),
2335 DECL_RESULT (current_function_decl
),
2336 TREE_OPERAND (retval_rhs
, 1));
2337 TREE_SIDE_EFFECTS (expr
) = 1;
2338 expand_return (expr
);
2341 expr
= build (MODIFY_EXPR
, TREE_TYPE (TREE_TYPE (current_function_decl
)),
2342 DECL_RESULT (current_function_decl
),
2343 TREE_OPERAND (retval_rhs
, 2));
2344 TREE_SIDE_EFFECTS (expr
) = 1;
2345 expand_return (expr
);
2349 /* For tail-recursive call to current function,
2350 just jump back to the beginning.
2351 It's unsafe if any auto variable in this function
2352 has its address taken; for simplicity,
2353 require stack frame to be empty. */
2354 if (optimize
&& retval_rhs
!= 0
2355 && frame_offset
== 0
2356 && TREE_CODE (retval_rhs
) == CALL_EXPR
2357 && TREE_CODE (TREE_OPERAND (retval_rhs
, 0)) == ADDR_EXPR
2358 && TREE_OPERAND (TREE_OPERAND (retval_rhs
, 0), 0) == current_function_decl
2359 /* Finish checking validity, and if valid emit code
2360 to set the argument variables for the new call. */
2361 && tail_recursion_args (TREE_OPERAND (retval_rhs
, 1),
2362 DECL_ARGUMENTS (current_function_decl
)))
2364 if (tail_recursion_label
== 0)
2366 tail_recursion_label
= gen_label_rtx ();
2367 emit_label_after (tail_recursion_label
,
2368 tail_recursion_reentry
);
2371 expand_goto_internal (NULL_TREE
, tail_recursion_label
, last_insn
);
2376 /* This optimization is safe if there are local cleanups
2377 because expand_null_return takes care of them.
2378 ??? I think it should also be safe when there is a cleanup label,
2379 because expand_null_return takes care of them, too.
2380 Any reason why not? */
2381 if (HAVE_return
&& cleanup_label
== 0
2382 && ! current_function_returns_pcc_struct
2383 && BRANCH_COST
<= 1)
2385 /* If this is return x == y; then generate
2386 if (x == y) return 1; else return 0;
2387 if we can do it with explicit return insns and branches are cheap,
2388 but not if we have the corresponding scc insn. */
2391 switch (TREE_CODE (retval_rhs
))
2417 case TRUTH_ANDIF_EXPR
:
2418 case TRUTH_ORIF_EXPR
:
2419 case TRUTH_AND_EXPR
:
2421 case TRUTH_NOT_EXPR
:
2422 case TRUTH_XOR_EXPR
:
2425 op0
= gen_label_rtx ();
2426 jumpifnot (retval_rhs
, op0
);
2427 expand_value_return (const1_rtx
);
2429 expand_value_return (const0_rtx
);
2438 #endif /* HAVE_return */
2440 /* If the result is an aggregate that is being returned in one (or more)
2441 registers, load the registers here. The compiler currently can't handle
2442 copying a BLKmode value into registers. We could put this code in a
2443 more general area (for use by everyone instead of just function
2444 call/return), but until this feature is generally usable it is kept here
2445 (and in expand_call). The value must go into a pseudo in case there
2446 are cleanups that will clobber the real return register. */
2449 && TYPE_MODE (TREE_TYPE (retval_rhs
)) == BLKmode
2450 && GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl
))) == REG
)
2452 int i
, bitpos
, xbitpos
;
2453 int big_endian_correction
= 0;
2454 int bytes
= int_size_in_bytes (TREE_TYPE (retval_rhs
));
2455 int n_regs
= (bytes
+ UNITS_PER_WORD
- 1) / UNITS_PER_WORD
;
2456 int bitsize
= MIN (TYPE_ALIGN (TREE_TYPE (retval_rhs
)),BITS_PER_WORD
);
2457 rtx
*result_pseudos
= (rtx
*) alloca (sizeof (rtx
) * n_regs
);
2458 rtx result_reg
, src
, dst
;
2459 rtx result_val
= expand_expr (retval_rhs
, NULL_RTX
, VOIDmode
, 0);
2460 enum machine_mode tmpmode
, result_reg_mode
;
2462 /* Structures whose size is not a multiple of a word are aligned
2463 to the least significant byte (to the right). On a BYTES_BIG_ENDIAN
2464 machine, this means we must skip the empty high order bytes when
2465 calculating the bit offset. */
2466 if (BYTES_BIG_ENDIAN
&& bytes
% UNITS_PER_WORD
)
2467 big_endian_correction
= (BITS_PER_WORD
- ((bytes
% UNITS_PER_WORD
)
2470 /* Copy the structure BITSIZE bits at a time. */
2471 for (bitpos
= 0, xbitpos
= big_endian_correction
;
2472 bitpos
< bytes
* BITS_PER_UNIT
;
2473 bitpos
+= bitsize
, xbitpos
+= bitsize
)
2475 /* We need a new destination pseudo each time xbitpos is
2476 on a word boundary and when xbitpos == big_endian_correction
2477 (the first time through). */
2478 if (xbitpos
% BITS_PER_WORD
== 0
2479 || xbitpos
== big_endian_correction
)
2481 /* Generate an appropriate register. */
2482 dst
= gen_reg_rtx (word_mode
);
2483 result_pseudos
[xbitpos
/ BITS_PER_WORD
] = dst
;
2485 /* Clobber the destination before we move anything into it. */
2486 emit_insn (gen_rtx_CLOBBER (VOIDmode
, dst
));
2489 /* We need a new source operand each time bitpos is on a word
2491 if (bitpos
% BITS_PER_WORD
== 0)
2492 src
= operand_subword_force (result_val
,
2493 bitpos
/ BITS_PER_WORD
,
2496 /* Use bitpos for the source extraction (left justified) and
2497 xbitpos for the destination store (right justified). */
2498 store_bit_field (dst
, bitsize
, xbitpos
% BITS_PER_WORD
, word_mode
,
2499 extract_bit_field (src
, bitsize
,
2500 bitpos
% BITS_PER_WORD
, 1,
2501 NULL_RTX
, word_mode
,
2503 bitsize
/ BITS_PER_UNIT
,
2505 bitsize
/ BITS_PER_UNIT
, BITS_PER_WORD
);
2508 /* Find the smallest integer mode large enough to hold the
2509 entire structure and use that mode instead of BLKmode
2510 on the USE insn for the return register. */
2511 bytes
= int_size_in_bytes (TREE_TYPE (retval_rhs
));
2512 for (tmpmode
= GET_CLASS_NARROWEST_MODE (MODE_INT
);
2513 tmpmode
!= MAX_MACHINE_MODE
;
2514 tmpmode
= GET_MODE_WIDER_MODE (tmpmode
))
2516 /* Have we found a large enough mode? */
2517 if (GET_MODE_SIZE (tmpmode
) >= bytes
)
2521 /* No suitable mode found. */
2522 if (tmpmode
== MAX_MACHINE_MODE
)
2525 PUT_MODE (DECL_RTL (DECL_RESULT (current_function_decl
)), tmpmode
);
2527 if (GET_MODE_SIZE (tmpmode
) < GET_MODE_SIZE (word_mode
))
2528 result_reg_mode
= word_mode
;
2530 result_reg_mode
= tmpmode
;
2531 result_reg
= gen_reg_rtx (result_reg_mode
);
2534 for (i
= 0; i
< n_regs
; i
++)
2535 emit_move_insn (operand_subword (result_reg
, i
, 0, result_reg_mode
),
2538 if (tmpmode
!= result_reg_mode
)
2539 result_reg
= gen_lowpart (tmpmode
, result_reg
);
2541 expand_value_return (result_reg
);
2545 && TREE_TYPE (retval_rhs
) != void_type_node
2546 && GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl
))) == REG
)
2548 /* Calculate the return value into a pseudo reg. */
2549 val
= gen_reg_rtx (DECL_MODE (DECL_RESULT (current_function_decl
)));
2550 val
= expand_expr (retval_rhs
, val
, GET_MODE (val
), 0);
2551 val
= force_not_mem (val
);
2553 /* Return the calculated value, doing cleanups first. */
2554 expand_value_return (val
);
2558 /* No cleanups or no hard reg used;
2559 calculate value into hard return reg. */
2560 expand_expr (retval
, const0_rtx
, VOIDmode
, 0);
2562 expand_value_return (DECL_RTL (DECL_RESULT (current_function_decl
)));
2566 /* Return 1 if the end of the generated RTX is not a barrier.
2567 This means code already compiled can drop through. */
2570 drop_through_at_end_p ()
2572 rtx insn
= get_last_insn ();
2573 while (insn
&& GET_CODE (insn
) == NOTE
)
2574 insn
= PREV_INSN (insn
);
2575 return insn
&& GET_CODE (insn
) != BARRIER
;
2578 /* Emit code to alter this function's formal parms for a tail-recursive call.
2579 ACTUALS is a list of actual parameter expressions (chain of TREE_LISTs).
2580 FORMALS is the chain of decls of formals.
2581 Return 1 if this can be done;
2582 otherwise return 0 and do not emit any code. */
2585 tail_recursion_args (actuals
, formals
)
2586 tree actuals
, formals
;
2588 register tree a
= actuals
, f
= formals
;
2590 register rtx
*argvec
;
2592 /* Check that number and types of actuals are compatible
2593 with the formals. This is not always true in valid C code.
2594 Also check that no formal needs to be addressable
2595 and that all formals are scalars. */
2597 /* Also count the args. */
2599 for (a
= actuals
, f
= formals
, i
= 0; a
&& f
; a
= TREE_CHAIN (a
), f
= TREE_CHAIN (f
), i
++)
2601 if (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (a
)))
2602 != TYPE_MAIN_VARIANT (TREE_TYPE (f
)))
2604 if (GET_CODE (DECL_RTL (f
)) != REG
|| DECL_MODE (f
) == BLKmode
)
2607 if (a
!= 0 || f
!= 0)
2610 /* Compute all the actuals. */
2612 argvec
= (rtx
*) alloca (i
* sizeof (rtx
));
2614 for (a
= actuals
, i
= 0; a
; a
= TREE_CHAIN (a
), i
++)
2615 argvec
[i
] = expand_expr (TREE_VALUE (a
), NULL_RTX
, VOIDmode
, 0);
2617 /* Find which actual values refer to current values of previous formals.
2618 Copy each of them now, before any formal is changed. */
2620 for (a
= actuals
, i
= 0; a
; a
= TREE_CHAIN (a
), i
++)
2624 for (f
= formals
, j
= 0; j
< i
; f
= TREE_CHAIN (f
), j
++)
2625 if (reg_mentioned_p (DECL_RTL (f
), argvec
[i
]))
2626 { copy
= 1; break; }
2628 argvec
[i
] = copy_to_reg (argvec
[i
]);
2631 /* Store the values of the actuals into the formals. */
2633 for (f
= formals
, a
= actuals
, i
= 0; f
;
2634 f
= TREE_CHAIN (f
), a
= TREE_CHAIN (a
), i
++)
2636 if (GET_MODE (DECL_RTL (f
)) == GET_MODE (argvec
[i
]))
2637 emit_move_insn (DECL_RTL (f
), argvec
[i
]);
2639 convert_move (DECL_RTL (f
), argvec
[i
],
2640 TREE_UNSIGNED (TREE_TYPE (TREE_VALUE (a
))));
2647 /* Generate the RTL code for entering a binding contour.
2648 The variables are declared one by one, by calls to `expand_decl'.
2650 EXIT_FLAG is nonzero if this construct should be visible to
2651 `exit_something'. */
2654 expand_start_bindings (exit_flag
)
2657 struct nesting
*thisblock
= ALLOC_NESTING ();
2658 rtx note
= emit_note (NULL_PTR
, NOTE_INSN_BLOCK_BEG
);
2660 /* Make an entry on block_stack for the block we are entering. */
2662 thisblock
->next
= block_stack
;
2663 thisblock
->all
= nesting_stack
;
2664 thisblock
->depth
= ++nesting_depth
;
2665 thisblock
->data
.block
.stack_level
= 0;
2666 thisblock
->data
.block
.cleanups
= 0;
2667 thisblock
->data
.block
.function_call_count
= 0;
2668 thisblock
->data
.block
.exception_region
= 0;
2669 thisblock
->data
.block
.target_temp_slot_level
= target_temp_slot_level
;
2671 thisblock
->data
.block
.conditional_code
= 0;
2672 thisblock
->data
.block
.last_unconditional_cleanup
= note
;
2673 thisblock
->data
.block
.cleanup_ptr
= &thisblock
->data
.block
.cleanups
;
2676 && !(block_stack
->data
.block
.cleanups
== NULL_TREE
2677 && block_stack
->data
.block
.outer_cleanups
== NULL_TREE
))
2678 thisblock
->data
.block
.outer_cleanups
2679 = tree_cons (NULL_TREE
, block_stack
->data
.block
.cleanups
,
2680 block_stack
->data
.block
.outer_cleanups
);
2682 thisblock
->data
.block
.outer_cleanups
= 0;
2683 thisblock
->data
.block
.label_chain
= 0;
2684 thisblock
->data
.block
.innermost_stack_block
= stack_block_stack
;
2685 thisblock
->data
.block
.first_insn
= note
;
2686 thisblock
->data
.block
.block_start_count
= ++block_start_count
;
2687 thisblock
->exit_label
= exit_flag
? gen_label_rtx () : 0;
2688 block_stack
= thisblock
;
2689 nesting_stack
= thisblock
;
2691 /* Make a new level for allocating stack slots. */
2695 /* Specify the scope of temporaries created by TARGET_EXPRs. Similar
2696 to CLEANUP_POINT_EXPR, but handles cases when a series of calls to
2697 expand_expr are made. After we end the region, we know that all
2698 space for all temporaries that were created by TARGET_EXPRs will be
2699 destroyed and their space freed for reuse. */
2702 expand_start_target_temps ()
2704 /* This is so that even if the result is preserved, the space
2705 allocated will be freed, as we know that it is no longer in use. */
2708 /* Start a new binding layer that will keep track of all cleanup
2709 actions to be performed. */
2710 expand_start_bindings (0);
2712 target_temp_slot_level
= temp_slot_level
;
2716 expand_end_target_temps ()
2718 expand_end_bindings (NULL_TREE
, 0, 0);
2720 /* This is so that even if the result is preserved, the space
2721 allocated will be freed, as we know that it is no longer in use. */
2725 /* Mark top block of block_stack as an implicit binding for an
2726 exception region. This is used to prevent infinite recursion when
2727 ending a binding with expand_end_bindings. It is only ever called
2728 by expand_eh_region_start, as that it the only way to create a
2729 block stack for a exception region. */
2732 mark_block_as_eh_region ()
2734 block_stack
->data
.block
.exception_region
= 1;
2735 if (block_stack
->next
2736 && block_stack
->next
->data
.block
.conditional_code
)
2738 block_stack
->data
.block
.conditional_code
2739 = block_stack
->next
->data
.block
.conditional_code
;
2740 block_stack
->data
.block
.last_unconditional_cleanup
2741 = block_stack
->next
->data
.block
.last_unconditional_cleanup
;
2742 block_stack
->data
.block
.cleanup_ptr
2743 = block_stack
->next
->data
.block
.cleanup_ptr
;
2747 /* True if we are currently emitting insns in an area of output code
2748 that is controlled by a conditional expression. This is used by
2749 the cleanup handling code to generate conditional cleanup actions. */
2752 conditional_context ()
2754 return block_stack
&& block_stack
->data
.block
.conditional_code
;
2757 /* Mark top block of block_stack as not for an implicit binding for an
2758 exception region. This is only ever done by expand_eh_region_end
2759 to let expand_end_bindings know that it is being called explicitly
2760 to end the binding layer for just the binding layer associated with
2761 the exception region, otherwise expand_end_bindings would try and
2762 end all implicit binding layers for exceptions regions, and then
2763 one normal binding layer. */
2766 mark_block_as_not_eh_region ()
2768 block_stack
->data
.block
.exception_region
= 0;
2771 /* True if the top block of block_stack was marked as for an exception
2772 region by mark_block_as_eh_region. */
2777 return block_stack
&& block_stack
->data
.block
.exception_region
;
2780 /* Given a pointer to a BLOCK node, save a pointer to the most recently
2781 generated NOTE_INSN_BLOCK_END in the BLOCK_END_NOTE field of the given
2785 remember_end_note (block
)
2786 register tree block
;
2788 BLOCK_END_NOTE (block
) = last_block_end_note
;
2789 last_block_end_note
= NULL_RTX
;
2792 /* Generate RTL code to terminate a binding contour.
2793 VARS is the chain of VAR_DECL nodes
2794 for the variables bound in this contour.
2795 MARK_ENDS is nonzero if we should put a note at the beginning
2796 and end of this binding contour.
2798 DONT_JUMP_IN is nonzero if it is not valid to jump into this contour.
2799 (That is true automatically if the contour has a saved stack level.) */
2802 expand_end_bindings (vars
, mark_ends
, dont_jump_in
)
2807 register struct nesting
*thisblock
;
2810 while (block_stack
->data
.block
.exception_region
)
2812 /* Because we don't need or want a new temporary level and
2813 because we didn't create one in expand_eh_region_start,
2814 create a fake one now to avoid removing one in
2815 expand_end_bindings. */
2818 block_stack
->data
.block
.exception_region
= 0;
2820 expand_end_bindings (NULL_TREE
, 0, 0);
2823 /* Since expand_eh_region_start does an expand_start_bindings, we
2824 have to first end all the bindings that were created by
2825 expand_eh_region_start. */
2827 thisblock
= block_stack
;
2830 for (decl
= vars
; decl
; decl
= TREE_CHAIN (decl
))
2831 if (! TREE_USED (decl
) && TREE_CODE (decl
) == VAR_DECL
2832 && ! DECL_IN_SYSTEM_HEADER (decl
)
2833 && DECL_NAME (decl
) && ! DECL_ARTIFICIAL (decl
))
2834 warning_with_decl (decl
, "unused variable `%s'");
2836 if (thisblock
->exit_label
)
2838 do_pending_stack_adjust ();
2839 emit_label (thisblock
->exit_label
);
2842 /* If necessary, make a handler for nonlocal gotos taking
2843 place in the function calls in this block. */
2844 if (function_call_count
!= thisblock
->data
.block
.function_call_count
2846 /* Make handler for outermost block
2847 if there were any nonlocal gotos to this function. */
2848 && (thisblock
->next
== 0 ? current_function_has_nonlocal_label
2849 /* Make handler for inner block if it has something
2850 special to do when you jump out of it. */
2851 : (thisblock
->data
.block
.cleanups
!= 0
2852 || thisblock
->data
.block
.stack_level
!= 0)))
2855 rtx afterward
= gen_label_rtx ();
2856 rtx handler_label
= gen_label_rtx ();
2857 rtx save_receiver
= gen_reg_rtx (Pmode
);
2860 /* Don't let jump_optimize delete the handler. */
2861 LABEL_PRESERVE_P (handler_label
) = 1;
2863 /* Record the handler address in the stack slot for that purpose,
2864 during this block, saving and restoring the outer value. */
2865 if (thisblock
->next
!= 0)
2867 emit_move_insn (nonlocal_goto_handler_slot
, save_receiver
);
2870 emit_move_insn (save_receiver
, nonlocal_goto_handler_slot
);
2871 insns
= get_insns ();
2873 emit_insns_before (insns
, thisblock
->data
.block
.first_insn
);
2877 emit_move_insn (nonlocal_goto_handler_slot
,
2878 gen_rtx_LABEL_REF (Pmode
, handler_label
));
2879 insns
= get_insns ();
2881 emit_insns_before (insns
, thisblock
->data
.block
.first_insn
);
2883 /* Jump around the handler; it runs only when specially invoked. */
2884 emit_jump (afterward
);
2885 emit_label (handler_label
);
2887 #ifdef HAVE_nonlocal_goto
2888 if (! HAVE_nonlocal_goto
)
2890 /* First adjust our frame pointer to its actual value. It was
2891 previously set to the start of the virtual area corresponding to
2892 the stacked variables when we branched here and now needs to be
2893 adjusted to the actual hardware fp value.
2895 Assignments are to virtual registers are converted by
2896 instantiate_virtual_regs into the corresponding assignment
2897 to the underlying register (fp in this case) that makes
2898 the original assignment true.
2899 So the following insn will actually be
2900 decrementing fp by STARTING_FRAME_OFFSET. */
2901 emit_move_insn (virtual_stack_vars_rtx
, hard_frame_pointer_rtx
);
2903 #if ARG_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
2904 if (fixed_regs
[ARG_POINTER_REGNUM
])
2906 #ifdef ELIMINABLE_REGS
2907 /* If the argument pointer can be eliminated in favor of the
2908 frame pointer, we don't need to restore it. We assume here
2909 that if such an elimination is present, it can always be used.
2910 This is the case on all known machines; if we don't make this
2911 assumption, we do unnecessary saving on many machines. */
2912 static struct elims
{int from
, to
;} elim_regs
[] = ELIMINABLE_REGS
;
2915 for (i
= 0; i
< sizeof elim_regs
/ sizeof elim_regs
[0]; i
++)
2916 if (elim_regs
[i
].from
== ARG_POINTER_REGNUM
2917 && elim_regs
[i
].to
== HARD_FRAME_POINTER_REGNUM
)
2920 if (i
== sizeof elim_regs
/ sizeof elim_regs
[0])
2923 /* Now restore our arg pointer from the address at which it
2924 was saved in our stack frame.
2925 If there hasn't be space allocated for it yet, make
2927 if (arg_pointer_save_area
== 0)
2928 arg_pointer_save_area
2929 = assign_stack_local (Pmode
, GET_MODE_SIZE (Pmode
), 0);
2930 emit_move_insn (virtual_incoming_args_rtx
,
2931 /* We need a pseudo here, or else
2932 instantiate_virtual_regs_1 complains. */
2933 copy_to_reg (arg_pointer_save_area
));
2938 #ifdef HAVE_nonlocal_goto_receiver
2939 if (HAVE_nonlocal_goto_receiver
)
2940 emit_insn (gen_nonlocal_goto_receiver ());
2943 /* The handler expects the desired label address in the static chain
2944 register. It tests the address and does an appropriate jump
2945 to whatever label is desired. */
2946 for (link
= nonlocal_labels
; link
; link
= TREE_CHAIN (link
))
2947 /* Skip any labels we shouldn't be able to jump to from here. */
2948 if (! DECL_TOO_LATE (TREE_VALUE (link
)))
2950 rtx not_this
= gen_label_rtx ();
2951 rtx
this = gen_label_rtx ();
2952 do_jump_if_equal (static_chain_rtx
,
2953 gen_rtx_LABEL_REF (Pmode
, DECL_RTL (TREE_VALUE (link
))),
2955 emit_jump (not_this
);
2957 expand_goto (TREE_VALUE (link
));
2958 emit_label (not_this
);
2960 /* If label is not recognized, abort. */
2961 emit_library_call (gen_rtx_SYMBOL_REF (Pmode
, "abort"), 0,
2964 emit_label (afterward
);
2967 /* Don't allow jumping into a block that has a stack level.
2968 Cleanups are allowed, though. */
2970 || thisblock
->data
.block
.stack_level
!= 0)
2972 struct label_chain
*chain
;
2974 /* Any labels in this block are no longer valid to go to.
2975 Mark them to cause an error message. */
2976 for (chain
= thisblock
->data
.block
.label_chain
; chain
; chain
= chain
->next
)
2978 DECL_TOO_LATE (chain
->label
) = 1;
2979 /* If any goto without a fixup came to this label,
2980 that must be an error, because gotos without fixups
2981 come from outside all saved stack-levels. */
2982 if (TREE_ADDRESSABLE (chain
->label
))
2983 error_with_decl (chain
->label
,
2984 "label `%s' used before containing binding contour");
2988 /* Restore stack level in effect before the block
2989 (only if variable-size objects allocated). */
2990 /* Perform any cleanups associated with the block. */
2992 if (thisblock
->data
.block
.stack_level
!= 0
2993 || thisblock
->data
.block
.cleanups
!= 0)
2995 /* Only clean up here if this point can actually be reached. */
2996 int reachable
= GET_CODE (get_last_insn ()) != BARRIER
;
2998 /* Don't let cleanups affect ({...}) constructs. */
2999 int old_expr_stmts_for_value
= expr_stmts_for_value
;
3000 rtx old_last_expr_value
= last_expr_value
;
3001 tree old_last_expr_type
= last_expr_type
;
3002 expr_stmts_for_value
= 0;
3004 /* Do the cleanups. */
3005 expand_cleanups (thisblock
->data
.block
.cleanups
, NULL_TREE
, 0, reachable
);
3007 do_pending_stack_adjust ();
3009 expr_stmts_for_value
= old_expr_stmts_for_value
;
3010 last_expr_value
= old_last_expr_value
;
3011 last_expr_type
= old_last_expr_type
;
3013 /* Restore the stack level. */
3015 if (reachable
&& thisblock
->data
.block
.stack_level
!= 0)
3017 emit_stack_restore (thisblock
->next
? SAVE_BLOCK
: SAVE_FUNCTION
,
3018 thisblock
->data
.block
.stack_level
, NULL_RTX
);
3019 if (nonlocal_goto_handler_slot
!= 0)
3020 emit_stack_save (SAVE_NONLOCAL
, &nonlocal_goto_stack_level
,
3024 /* Any gotos out of this block must also do these things.
3025 Also report any gotos with fixups that came to labels in this
3027 fixup_gotos (thisblock
,
3028 thisblock
->data
.block
.stack_level
,
3029 thisblock
->data
.block
.cleanups
,
3030 thisblock
->data
.block
.first_insn
,
3034 /* Mark the beginning and end of the scope if requested.
3035 We do this now, after running cleanups on the variables
3036 just going out of scope, so they are in scope for their cleanups. */
3039 last_block_end_note
= emit_note (NULL_PTR
, NOTE_INSN_BLOCK_END
);
3041 /* Get rid of the beginning-mark if we don't make an end-mark. */
3042 NOTE_LINE_NUMBER (thisblock
->data
.block
.first_insn
) = NOTE_INSN_DELETED
;
3044 /* If doing stupid register allocation, make sure lives of all
3045 register variables declared here extend thru end of scope. */
3048 for (decl
= vars
; decl
; decl
= TREE_CHAIN (decl
))
3050 rtx rtl
= DECL_RTL (decl
);
3051 if (TREE_CODE (decl
) == VAR_DECL
&& rtl
!= 0)
3055 /* Restore the temporary level of TARGET_EXPRs. */
3056 target_temp_slot_level
= thisblock
->data
.block
.target_temp_slot_level
;
3058 /* Restore block_stack level for containing block. */
3060 stack_block_stack
= thisblock
->data
.block
.innermost_stack_block
;
3061 POPSTACK (block_stack
);
3063 /* Pop the stack slot nesting and free any slots at this level. */
3069 /* Generate RTL for the automatic variable declaration DECL.
3070 (Other kinds of declarations are simply ignored if seen here.) */
3076 struct nesting
*thisblock
= block_stack
;
3079 type
= TREE_TYPE (decl
);
3081 /* Only automatic variables need any expansion done.
3082 Static and external variables, and external functions,
3083 will be handled by `assemble_variable' (called from finish_decl).
3084 TYPE_DECL and CONST_DECL require nothing.
3085 PARM_DECLs are handled in `assign_parms'. */
3087 if (TREE_CODE (decl
) != VAR_DECL
)
3089 if (TREE_STATIC (decl
) || DECL_EXTERNAL (decl
))
3092 /* Create the RTL representation for the variable. */
3094 if (type
== error_mark_node
)
3095 DECL_RTL (decl
) = gen_rtx_MEM (BLKmode
, const0_rtx
);
3096 else if (DECL_SIZE (decl
) == 0)
3097 /* Variable with incomplete type. */
3099 if (DECL_INITIAL (decl
) == 0)
3100 /* Error message was already done; now avoid a crash. */
3101 DECL_RTL (decl
) = assign_stack_temp (DECL_MODE (decl
), 0, 1);
3103 /* An initializer is going to decide the size of this array.
3104 Until we know the size, represent its address with a reg. */
3105 DECL_RTL (decl
) = gen_rtx_MEM (BLKmode
, gen_reg_rtx (Pmode
));
3106 MEM_IN_STRUCT_P (DECL_RTL (decl
)) = AGGREGATE_TYPE_P (type
);
3108 else if (DECL_MODE (decl
) != BLKmode
3109 /* If -ffloat-store, don't put explicit float vars
3111 && !(flag_float_store
3112 && TREE_CODE (type
) == REAL_TYPE
)
3113 && ! TREE_THIS_VOLATILE (decl
)
3114 && ! TREE_ADDRESSABLE (decl
)
3115 && (DECL_REGISTER (decl
) || ! obey_regdecls
))
3117 /* Automatic variable that can go in a register. */
3118 int unsignedp
= TREE_UNSIGNED (type
);
3119 enum machine_mode reg_mode
3120 = promote_mode (type
, DECL_MODE (decl
), &unsignedp
, 0);
3122 DECL_RTL (decl
) = gen_reg_rtx (reg_mode
);
3123 mark_user_reg (DECL_RTL (decl
));
3125 if (TREE_CODE (type
) == POINTER_TYPE
)
3126 mark_reg_pointer (DECL_RTL (decl
),
3127 (TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl
)))
3131 else if (TREE_CODE (DECL_SIZE (decl
)) == INTEGER_CST
3132 && ! (flag_stack_check
&& ! STACK_CHECK_BUILTIN
3133 && (TREE_INT_CST_HIGH (DECL_SIZE (decl
)) != 0
3134 || (TREE_INT_CST_LOW (DECL_SIZE (decl
))
3135 > STACK_CHECK_MAX_VAR_SIZE
* BITS_PER_UNIT
))))
3137 /* Variable of fixed size that goes on the stack. */
3141 /* If we previously made RTL for this decl, it must be an array
3142 whose size was determined by the initializer.
3143 The old address was a register; set that register now
3144 to the proper address. */
3145 if (DECL_RTL (decl
) != 0)
3147 if (GET_CODE (DECL_RTL (decl
)) != MEM
3148 || GET_CODE (XEXP (DECL_RTL (decl
), 0)) != REG
)
3150 oldaddr
= XEXP (DECL_RTL (decl
), 0);
3154 = assign_stack_temp (DECL_MODE (decl
),
3155 ((TREE_INT_CST_LOW (DECL_SIZE (decl
))
3156 + BITS_PER_UNIT
- 1)
3159 MEM_IN_STRUCT_P (DECL_RTL (decl
)) = AGGREGATE_TYPE_P (TREE_TYPE (decl
));
3161 /* Set alignment we actually gave this decl. */
3162 DECL_ALIGN (decl
) = (DECL_MODE (decl
) == BLKmode
? BIGGEST_ALIGNMENT
3163 : GET_MODE_BITSIZE (DECL_MODE (decl
)));
3167 addr
= force_operand (XEXP (DECL_RTL (decl
), 0), oldaddr
);
3168 if (addr
!= oldaddr
)
3169 emit_move_insn (oldaddr
, addr
);
3172 /* If this is a memory ref that contains aggregate components,
3173 mark it as such for cse and loop optimize. */
3174 MEM_IN_STRUCT_P (DECL_RTL (decl
)) = AGGREGATE_TYPE_P (TREE_TYPE (decl
));
3176 /* If this is in memory because of -ffloat-store,
3177 set the volatile bit, to prevent optimizations from
3178 undoing the effects. */
3179 if (flag_float_store
&& TREE_CODE (type
) == REAL_TYPE
)
3180 MEM_VOLATILE_P (DECL_RTL (decl
)) = 1;
3184 /* Dynamic-size object: must push space on the stack. */
3188 /* Record the stack pointer on entry to block, if have
3189 not already done so. */
3190 if (thisblock
->data
.block
.stack_level
== 0)
3192 do_pending_stack_adjust ();
3193 emit_stack_save (thisblock
->next
? SAVE_BLOCK
: SAVE_FUNCTION
,
3194 &thisblock
->data
.block
.stack_level
,
3195 thisblock
->data
.block
.first_insn
);
3196 stack_block_stack
= thisblock
;
3199 /* Compute the variable's size, in bytes. */
3200 size
= expand_expr (size_binop (CEIL_DIV_EXPR
,
3202 size_int (BITS_PER_UNIT
)),
3203 NULL_RTX
, VOIDmode
, 0);
3206 /* Allocate space on the stack for the variable. Note that
3207 DECL_ALIGN says how the variable is to be aligned and we
3208 cannot use it to conclude anything about the alignment of
3210 address
= allocate_dynamic_stack_space (size
, NULL_RTX
,
3211 TYPE_ALIGN (TREE_TYPE (decl
)));
3213 /* Reference the variable indirect through that rtx. */
3214 DECL_RTL (decl
) = gen_rtx_MEM (DECL_MODE (decl
), address
);
3216 /* If this is a memory ref that contains aggregate components,
3217 mark it as such for cse and loop optimize. */
3218 MEM_IN_STRUCT_P (DECL_RTL (decl
)) = AGGREGATE_TYPE_P (TREE_TYPE (decl
));
3220 /* Indicate the alignment we actually gave this variable. */
3221 #ifdef STACK_BOUNDARY
3222 DECL_ALIGN (decl
) = STACK_BOUNDARY
;
3224 DECL_ALIGN (decl
) = BIGGEST_ALIGNMENT
;
3228 if (TREE_THIS_VOLATILE (decl
))
3229 MEM_VOLATILE_P (DECL_RTL (decl
)) = 1;
3230 #if 0 /* A variable is not necessarily unchanging
3231 just because it is const. RTX_UNCHANGING_P
3232 means no change in the function,
3233 not merely no change in the variable's scope.
3234 It is correct to set RTX_UNCHANGING_P if the variable's scope
3235 is the whole function. There's no convenient way to test that. */
3236 if (TREE_READONLY (decl
))
3237 RTX_UNCHANGING_P (DECL_RTL (decl
)) = 1;
3240 /* If doing stupid register allocation, make sure life of any
3241 register variable starts here, at the start of its scope. */
3244 use_variable (DECL_RTL (decl
));
3249 /* Emit code to perform the initialization of a declaration DECL. */
3252 expand_decl_init (decl
)
3255 int was_used
= TREE_USED (decl
);
3257 /* If this is a CONST_DECL, we don't have to generate any code, but
3258 if DECL_INITIAL is a constant, call expand_expr to force TREE_CST_RTL
3259 to be set while in the obstack containing the constant. If we don't
3260 do this, we can lose if we have functions nested three deep and the middle
3261 function makes a CONST_DECL whose DECL_INITIAL is a STRING_CST while
3262 the innermost function is the first to expand that STRING_CST. */
3263 if (TREE_CODE (decl
) == CONST_DECL
)
3265 if (DECL_INITIAL (decl
) && TREE_CONSTANT (DECL_INITIAL (decl
)))
3266 expand_expr (DECL_INITIAL (decl
), NULL_RTX
, VOIDmode
,
3267 EXPAND_INITIALIZER
);
3271 if (TREE_STATIC (decl
))
3274 /* Compute and store the initial value now. */
3276 if (DECL_INITIAL (decl
) == error_mark_node
)
3278 enum tree_code code
= TREE_CODE (TREE_TYPE (decl
));
3279 if (code
== INTEGER_TYPE
|| code
== REAL_TYPE
|| code
== ENUMERAL_TYPE
3280 || code
== POINTER_TYPE
)
3281 expand_assignment (decl
, convert (TREE_TYPE (decl
), integer_zero_node
),
3285 else if (DECL_INITIAL (decl
) && TREE_CODE (DECL_INITIAL (decl
)) != TREE_LIST
)
3287 emit_line_note (DECL_SOURCE_FILE (decl
), DECL_SOURCE_LINE (decl
));
3288 expand_assignment (decl
, DECL_INITIAL (decl
), 0, 0);
3292 /* Don't let the initialization count as "using" the variable. */
3293 TREE_USED (decl
) = was_used
;
3295 /* Free any temporaries we made while initializing the decl. */
3296 preserve_temp_slots (NULL_RTX
);
3300 /* CLEANUP is an expression to be executed at exit from this binding contour;
3301 for example, in C++, it might call the destructor for this variable.
3303 We wrap CLEANUP in an UNSAVE_EXPR node, so that we can expand the
3304 CLEANUP multiple times, and have the correct semantics. This
3305 happens in exception handling, for gotos, returns, breaks that
3306 leave the current scope.
3308 If CLEANUP is nonzero and DECL is zero, we record a cleanup
3309 that is not associated with any particular variable. */
3312 expand_decl_cleanup (decl
, cleanup
)
3315 struct nesting
*thisblock
= block_stack
;
3317 /* Error if we are not in any block. */
3321 /* Record the cleanup if there is one. */
3327 tree
*cleanups
= &thisblock
->data
.block
.cleanups
;
3328 int cond_context
= conditional_context ();
3332 rtx flag
= gen_reg_rtx (word_mode
);
3337 emit_move_insn (flag
, const0_rtx
);
3338 set_flag_0
= get_insns ();
3341 thisblock
->data
.block
.last_unconditional_cleanup
3342 = emit_insns_after (set_flag_0
,
3343 thisblock
->data
.block
.last_unconditional_cleanup
);
3345 emit_move_insn (flag
, const1_rtx
);
3347 /* All cleanups must be on the function_obstack. */
3348 push_obstacks_nochange ();
3349 resume_temporary_allocation ();
3351 cond
= build_decl (VAR_DECL
, NULL_TREE
, type_for_mode (word_mode
, 1));
3352 DECL_RTL (cond
) = flag
;
3354 /* Conditionalize the cleanup. */
3355 cleanup
= build (COND_EXPR
, void_type_node
,
3356 truthvalue_conversion (cond
),
3357 cleanup
, integer_zero_node
);
3358 cleanup
= fold (cleanup
);
3362 cleanups
= thisblock
->data
.block
.cleanup_ptr
;
3365 /* All cleanups must be on the function_obstack. */
3366 push_obstacks_nochange ();
3367 resume_temporary_allocation ();
3368 cleanup
= unsave_expr (cleanup
);
3371 t
= *cleanups
= temp_tree_cons (decl
, cleanup
, *cleanups
);
3374 /* If this block has a cleanup, it belongs in stack_block_stack. */
3375 stack_block_stack
= thisblock
;
3382 /* If this was optimized so that there is no exception region for the
3383 cleanup, then mark the TREE_LIST node, so that we can later tell
3384 if we need to call expand_eh_region_end. */
3385 if (! using_eh_for_cleanups_p
3386 || expand_eh_region_start_tree (decl
, cleanup
))
3387 TREE_ADDRESSABLE (t
) = 1;
3388 /* If that started a new EH region, we're in a new block. */
3389 thisblock
= block_stack
;
3396 thisblock
->data
.block
.last_unconditional_cleanup
3397 = emit_insns_after (seq
,
3398 thisblock
->data
.block
.last_unconditional_cleanup
);
3402 thisblock
->data
.block
.last_unconditional_cleanup
3404 thisblock
->data
.block
.cleanup_ptr
= &thisblock
->data
.block
.cleanups
;
3410 /* Like expand_decl_cleanup, but suppress generating an exception handler
3411 to perform the cleanup. */
3414 expand_decl_cleanup_no_eh (decl
, cleanup
)
3417 int save_eh
= using_eh_for_cleanups_p
;
3420 using_eh_for_cleanups_p
= 0;
3421 result
= expand_decl_cleanup (decl
, cleanup
);
3422 using_eh_for_cleanups_p
= save_eh
;
3427 /* Arrange for the top element of the dynamic cleanup chain to be
3428 popped if we exit the current binding contour. DECL is the
3429 associated declaration, if any, otherwise NULL_TREE. If the
3430 current contour is left via an exception, then __sjthrow will pop
3431 the top element off the dynamic cleanup chain. The code that
3432 avoids doing the action we push into the cleanup chain in the
3433 exceptional case is contained in expand_cleanups.
3435 This routine is only used by expand_eh_region_start, and that is
3436 the only way in which an exception region should be started. This
3437 routine is only used when using the setjmp/longjmp codegen method
3438 for exception handling. */
3441 expand_dcc_cleanup (decl
)
3444 struct nesting
*thisblock
= block_stack
;
3447 /* Error if we are not in any block. */
3451 /* Record the cleanup for the dynamic handler chain. */
3453 /* All cleanups must be on the function_obstack. */
3454 push_obstacks_nochange ();
3455 resume_temporary_allocation ();
3456 cleanup
= make_node (POPDCC_EXPR
);
3459 /* Add the cleanup in a manner similar to expand_decl_cleanup. */
3460 thisblock
->data
.block
.cleanups
3461 = temp_tree_cons (decl
, cleanup
, thisblock
->data
.block
.cleanups
);
3463 /* If this block has a cleanup, it belongs in stack_block_stack. */
3464 stack_block_stack
= thisblock
;
3468 /* Arrange for the top element of the dynamic handler chain to be
3469 popped if we exit the current binding contour. DECL is the
3470 associated declaration, if any, otherwise NULL_TREE. If the current
3471 contour is left via an exception, then __sjthrow will pop the top
3472 element off the dynamic handler chain. The code that avoids doing
3473 the action we push into the handler chain in the exceptional case
3474 is contained in expand_cleanups.
3476 This routine is only used by expand_eh_region_start, and that is
3477 the only way in which an exception region should be started. This
3478 routine is only used when using the setjmp/longjmp codegen method
3479 for exception handling. */
3482 expand_dhc_cleanup (decl
)
3485 struct nesting
*thisblock
= block_stack
;
3488 /* Error if we are not in any block. */
3492 /* Record the cleanup for the dynamic handler chain. */
3494 /* All cleanups must be on the function_obstack. */
3495 push_obstacks_nochange ();
3496 resume_temporary_allocation ();
3497 cleanup
= make_node (POPDHC_EXPR
);
3500 /* Add the cleanup in a manner similar to expand_decl_cleanup. */
3501 thisblock
->data
.block
.cleanups
3502 = temp_tree_cons (decl
, cleanup
, thisblock
->data
.block
.cleanups
);
3504 /* If this block has a cleanup, it belongs in stack_block_stack. */
3505 stack_block_stack
= thisblock
;
3509 /* DECL is an anonymous union. CLEANUP is a cleanup for DECL.
3510 DECL_ELTS is the list of elements that belong to DECL's type.
3511 In each, the TREE_VALUE is a VAR_DECL, and the TREE_PURPOSE a cleanup. */
3514 expand_anon_union_decl (decl
, cleanup
, decl_elts
)
3515 tree decl
, cleanup
, decl_elts
;
3517 struct nesting
*thisblock
= block_stack
;
3521 expand_decl_cleanup (decl
, cleanup
);
3522 x
= DECL_RTL (decl
);
3526 tree decl_elt
= TREE_VALUE (decl_elts
);
3527 tree cleanup_elt
= TREE_PURPOSE (decl_elts
);
3528 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (decl_elt
));
3530 /* Propagate the union's alignment to the elements. */
3531 DECL_ALIGN (decl_elt
) = DECL_ALIGN (decl
);
3533 /* If the element has BLKmode and the union doesn't, the union is
3534 aligned such that the element doesn't need to have BLKmode, so
3535 change the element's mode to the appropriate one for its size. */
3536 if (mode
== BLKmode
&& DECL_MODE (decl
) != BLKmode
)
3537 DECL_MODE (decl_elt
) = mode
3538 = mode_for_size (TREE_INT_CST_LOW (DECL_SIZE (decl_elt
)),
3541 /* (SUBREG (MEM ...)) at RTL generation time is invalid, so we
3542 instead create a new MEM rtx with the proper mode. */
3543 if (GET_CODE (x
) == MEM
)
3545 if (mode
== GET_MODE (x
))
3546 DECL_RTL (decl_elt
) = x
;
3549 DECL_RTL (decl_elt
) = gen_rtx_MEM (mode
, copy_rtx (XEXP (x
, 0)));
3550 MEM_IN_STRUCT_P (DECL_RTL (decl_elt
)) = MEM_IN_STRUCT_P (x
);
3551 RTX_UNCHANGING_P (DECL_RTL (decl_elt
)) = RTX_UNCHANGING_P (x
);
3554 else if (GET_CODE (x
) == REG
)
3556 if (mode
== GET_MODE (x
))
3557 DECL_RTL (decl_elt
) = x
;
3559 DECL_RTL (decl_elt
) = gen_rtx_SUBREG (mode
, x
, 0);
3564 /* Record the cleanup if there is one. */
3567 thisblock
->data
.block
.cleanups
3568 = temp_tree_cons (decl_elt
, cleanup_elt
,
3569 thisblock
->data
.block
.cleanups
);
3571 decl_elts
= TREE_CHAIN (decl_elts
);
3575 /* Expand a list of cleanups LIST.
3576 Elements may be expressions or may be nested lists.
3578 If DONT_DO is nonnull, then any list-element
3579 whose TREE_PURPOSE matches DONT_DO is omitted.
3580 This is sometimes used to avoid a cleanup associated with
3581 a value that is being returned out of the scope.
3583 If IN_FIXUP is non-zero, we are generating this cleanup for a fixup
3584 goto and handle protection regions specially in that case.
3586 If REACHABLE, we emit code, otherwise just inform the exception handling
3587 code about this finalization. */
3590 expand_cleanups (list
, dont_do
, in_fixup
, reachable
)
3597 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
3598 if (dont_do
== 0 || TREE_PURPOSE (tail
) != dont_do
)
3600 if (TREE_CODE (TREE_VALUE (tail
)) == TREE_LIST
)
3601 expand_cleanups (TREE_VALUE (tail
), dont_do
, in_fixup
, reachable
);
3606 tree cleanup
= TREE_VALUE (tail
);
3608 /* See expand_d{h,c}c_cleanup for why we avoid this. */
3609 if (TREE_CODE (cleanup
) != POPDHC_EXPR
3610 && TREE_CODE (cleanup
) != POPDCC_EXPR
3611 /* See expand_eh_region_start_tree for this case. */
3612 && ! TREE_ADDRESSABLE (tail
))
3614 cleanup
= protect_with_terminate (cleanup
);
3615 expand_eh_region_end (cleanup
);
3621 /* Cleanups may be run multiple times. For example,
3622 when exiting a binding contour, we expand the
3623 cleanups associated with that contour. When a goto
3624 within that binding contour has a target outside that
3625 contour, it will expand all cleanups from its scope to
3626 the target. Though the cleanups are expanded multiple
3627 times, the control paths are non-overlapping so the
3628 cleanups will not be executed twice. */
3630 /* We may need to protect fixups with rethrow regions. */
3631 int protect
= (in_fixup
&& ! TREE_ADDRESSABLE (tail
));
3633 expand_fixup_region_start ();
3634 expand_expr (TREE_VALUE (tail
), const0_rtx
, VOIDmode
, 0);
3636 expand_fixup_region_end (TREE_VALUE (tail
));
3643 /* Mark when the context we are emitting RTL for as a conditional
3644 context, so that any cleanup actions we register with
3645 expand_decl_init will be properly conditionalized when those
3646 cleanup actions are later performed. Must be called before any
3647 expression (tree) is expanded that is within a conditional context. */
3650 start_cleanup_deferral ()
3652 /* block_stack can be NULL if we are inside the parameter list. It is
3653 OK to do nothing, because cleanups aren't possible here. */
3655 ++block_stack
->data
.block
.conditional_code
;
3658 /* Mark the end of a conditional region of code. Because cleanup
3659 deferrals may be nested, we may still be in a conditional region
3660 after we end the currently deferred cleanups, only after we end all
3661 deferred cleanups, are we back in unconditional code. */
3664 end_cleanup_deferral ()
3666 /* block_stack can be NULL if we are inside the parameter list. It is
3667 OK to do nothing, because cleanups aren't possible here. */
3669 --block_stack
->data
.block
.conditional_code
;
3672 /* Move all cleanups from the current block_stack
3673 to the containing block_stack, where they are assumed to
3674 have been created. If anything can cause a temporary to
3675 be created, but not expanded for more than one level of
3676 block_stacks, then this code will have to change. */
3681 struct nesting
*block
= block_stack
;
3682 struct nesting
*outer
= block
->next
;
3684 outer
->data
.block
.cleanups
3685 = chainon (block
->data
.block
.cleanups
,
3686 outer
->data
.block
.cleanups
);
3687 block
->data
.block
.cleanups
= 0;
3691 last_cleanup_this_contour ()
3693 if (block_stack
== 0)
3696 return block_stack
->data
.block
.cleanups
;
3699 /* Return 1 if there are any pending cleanups at this point.
3700 If THIS_CONTOUR is nonzero, check the current contour as well.
3701 Otherwise, look only at the contours that enclose this one. */
3704 any_pending_cleanups (this_contour
)
3707 struct nesting
*block
;
3709 if (block_stack
== 0)
3712 if (this_contour
&& block_stack
->data
.block
.cleanups
!= NULL
)
3714 if (block_stack
->data
.block
.cleanups
== 0
3715 && block_stack
->data
.block
.outer_cleanups
== 0)
3718 for (block
= block_stack
->next
; block
; block
= block
->next
)
3719 if (block
->data
.block
.cleanups
!= 0)
3725 /* Enter a case (Pascal) or switch (C) statement.
3726 Push a block onto case_stack and nesting_stack
3727 to accumulate the case-labels that are seen
3728 and to record the labels generated for the statement.
3730 EXIT_FLAG is nonzero if `exit_something' should exit this case stmt.
3731 Otherwise, this construct is transparent for `exit_something'.
3733 EXPR is the index-expression to be dispatched on.
3734 TYPE is its nominal type. We could simply convert EXPR to this type,
3735 but instead we take short cuts. */
3738 expand_start_case (exit_flag
, expr
, type
, printname
)
3744 register struct nesting
*thiscase
= ALLOC_NESTING ();
3746 /* Make an entry on case_stack for the case we are entering. */
3748 thiscase
->next
= case_stack
;
3749 thiscase
->all
= nesting_stack
;
3750 thiscase
->depth
= ++nesting_depth
;
3751 thiscase
->exit_label
= exit_flag
? gen_label_rtx () : 0;
3752 thiscase
->data
.case_stmt
.case_list
= 0;
3753 thiscase
->data
.case_stmt
.index_expr
= expr
;
3754 thiscase
->data
.case_stmt
.nominal_type
= type
;
3755 thiscase
->data
.case_stmt
.default_label
= 0;
3756 thiscase
->data
.case_stmt
.num_ranges
= 0;
3757 thiscase
->data
.case_stmt
.printname
= printname
;
3758 thiscase
->data
.case_stmt
.line_number_status
= force_line_numbers ();
3759 case_stack
= thiscase
;
3760 nesting_stack
= thiscase
;
3762 do_pending_stack_adjust ();
3764 /* Make sure case_stmt.start points to something that won't
3765 need any transformation before expand_end_case. */
3766 if (GET_CODE (get_last_insn ()) != NOTE
)
3767 emit_note (NULL_PTR
, NOTE_INSN_DELETED
);
3769 thiscase
->data
.case_stmt
.start
= get_last_insn ();
3771 start_cleanup_deferral ();
3775 /* Start a "dummy case statement" within which case labels are invalid
3776 and are not connected to any larger real case statement.
3777 This can be used if you don't want to let a case statement jump
3778 into the middle of certain kinds of constructs. */
3781 expand_start_case_dummy ()
3783 register struct nesting
*thiscase
= ALLOC_NESTING ();
3785 /* Make an entry on case_stack for the dummy. */
3787 thiscase
->next
= case_stack
;
3788 thiscase
->all
= nesting_stack
;
3789 thiscase
->depth
= ++nesting_depth
;
3790 thiscase
->exit_label
= 0;
3791 thiscase
->data
.case_stmt
.case_list
= 0;
3792 thiscase
->data
.case_stmt
.start
= 0;
3793 thiscase
->data
.case_stmt
.nominal_type
= 0;
3794 thiscase
->data
.case_stmt
.default_label
= 0;
3795 thiscase
->data
.case_stmt
.num_ranges
= 0;
3796 case_stack
= thiscase
;
3797 nesting_stack
= thiscase
;
3798 start_cleanup_deferral ();
3801 /* End a dummy case statement. */
3804 expand_end_case_dummy ()
3806 end_cleanup_deferral ();
3807 POPSTACK (case_stack
);
3810 /* Return the data type of the index-expression
3811 of the innermost case statement, or null if none. */
3814 case_index_expr_type ()
3817 return TREE_TYPE (case_stack
->data
.case_stmt
.index_expr
);
3824 /* If this is the first label, warn if any insns have been emitted. */
3825 if (case_stack
->data
.case_stmt
.line_number_status
>= 0)
3829 restore_line_number_status
3830 (case_stack
->data
.case_stmt
.line_number_status
);
3831 case_stack
->data
.case_stmt
.line_number_status
= -1;
3833 for (insn
= case_stack
->data
.case_stmt
.start
;
3835 insn
= NEXT_INSN (insn
))
3837 if (GET_CODE (insn
) == CODE_LABEL
)
3839 if (GET_CODE (insn
) != NOTE
3840 && (GET_CODE (insn
) != INSN
|| GET_CODE (PATTERN (insn
)) != USE
))
3843 insn
= PREV_INSN (insn
);
3844 while (GET_CODE (insn
) != NOTE
|| NOTE_LINE_NUMBER (insn
) < 0);
3846 warning_with_file_and_line (NOTE_SOURCE_FILE(insn
),
3847 NOTE_LINE_NUMBER(insn
),
3848 "unreachable code at beginning of %s",
3849 case_stack
->data
.case_stmt
.printname
);
3856 /* Accumulate one case or default label inside a case or switch statement.
3857 VALUE is the value of the case (a null pointer, for a default label).
3858 The function CONVERTER, when applied to arguments T and V,
3859 converts the value V to the type T.
3861 If not currently inside a case or switch statement, return 1 and do
3862 nothing. The caller will print a language-specific error message.
3863 If VALUE is a duplicate or overlaps, return 2 and do nothing
3864 except store the (first) duplicate node in *DUPLICATE.
3865 If VALUE is out of range, return 3 and do nothing.
3866 If we are jumping into the scope of a cleanup or var-sized array, return 5.
3867 Return 0 on success.
3869 Extended to handle range statements. */
3872 pushcase (value
, converter
, label
, duplicate
)
3873 register tree value
;
3874 tree (*converter
) PROTO((tree
, tree
));
3875 register tree label
;
3881 /* Fail if not inside a real case statement. */
3882 if (! (case_stack
&& case_stack
->data
.case_stmt
.start
))
3885 if (stack_block_stack
3886 && stack_block_stack
->depth
> case_stack
->depth
)
3889 index_type
= TREE_TYPE (case_stack
->data
.case_stmt
.index_expr
);
3890 nominal_type
= case_stack
->data
.case_stmt
.nominal_type
;
3892 /* If the index is erroneous, avoid more problems: pretend to succeed. */
3893 if (index_type
== error_mark_node
)
3896 /* Convert VALUE to the type in which the comparisons are nominally done. */
3898 value
= (*converter
) (nominal_type
, value
);
3902 /* Fail if this value is out of range for the actual type of the index
3903 (which may be narrower than NOMINAL_TYPE). */
3904 if (value
!= 0 && ! int_fits_type_p (value
, index_type
))
3907 /* Fail if this is a duplicate or overlaps another entry. */
3910 if (case_stack
->data
.case_stmt
.default_label
!= 0)
3912 *duplicate
= case_stack
->data
.case_stmt
.default_label
;
3915 case_stack
->data
.case_stmt
.default_label
= label
;
3918 return add_case_node (value
, value
, label
, duplicate
);
3920 expand_label (label
);
3924 /* Like pushcase but this case applies to all values between VALUE1 and
3925 VALUE2 (inclusive). If VALUE1 is NULL, the range starts at the lowest
3926 value of the index type and ends at VALUE2. If VALUE2 is NULL, the range
3927 starts at VALUE1 and ends at the highest value of the index type.
3928 If both are NULL, this case applies to all values.
3930 The return value is the same as that of pushcase but there is one
3931 additional error code: 4 means the specified range was empty. */
3934 pushcase_range (value1
, value2
, converter
, label
, duplicate
)
3935 register tree value1
, value2
;
3936 tree (*converter
) PROTO((tree
, tree
));
3937 register tree label
;
3943 /* Fail if not inside a real case statement. */
3944 if (! (case_stack
&& case_stack
->data
.case_stmt
.start
))
3947 if (stack_block_stack
3948 && stack_block_stack
->depth
> case_stack
->depth
)
3951 index_type
= TREE_TYPE (case_stack
->data
.case_stmt
.index_expr
);
3952 nominal_type
= case_stack
->data
.case_stmt
.nominal_type
;
3954 /* If the index is erroneous, avoid more problems: pretend to succeed. */
3955 if (index_type
== error_mark_node
)
3960 /* Convert VALUEs to type in which the comparisons are nominally done
3961 and replace any unspecified value with the corresponding bound. */
3963 value1
= TYPE_MIN_VALUE (index_type
);
3965 value2
= TYPE_MAX_VALUE (index_type
);
3967 /* Fail if the range is empty. Do this before any conversion since
3968 we want to allow out-of-range empty ranges. */
3969 if (value2
&& tree_int_cst_lt (value2
, value1
))
3972 value1
= (*converter
) (nominal_type
, value1
);
3974 /* If the max was unbounded, use the max of the nominal_type we are
3975 converting to. Do this after the < check above to suppress false
3978 value2
= TYPE_MAX_VALUE (nominal_type
);
3979 value2
= (*converter
) (nominal_type
, value2
);
3981 /* Fail if these values are out of range. */
3982 if (TREE_CONSTANT_OVERFLOW (value1
)
3983 || ! int_fits_type_p (value1
, index_type
))
3986 if (TREE_CONSTANT_OVERFLOW (value2
)
3987 || ! int_fits_type_p (value2
, index_type
))
3990 return add_case_node (value1
, value2
, label
, duplicate
);
3993 /* Do the actual insertion of a case label for pushcase and pushcase_range
3994 into case_stack->data.case_stmt.case_list. Use an AVL tree to avoid
3995 slowdown for large switch statements. */
3998 add_case_node (low
, high
, label
, duplicate
)
4003 struct case_node
*p
, **q
, *r
;
4005 q
= &case_stack
->data
.case_stmt
.case_list
;
4012 /* Keep going past elements distinctly greater than HIGH. */
4013 if (tree_int_cst_lt (high
, p
->low
))
4016 /* or distinctly less than LOW. */
4017 else if (tree_int_cst_lt (p
->high
, low
))
4022 /* We have an overlap; this is an error. */
4023 *duplicate
= p
->code_label
;
4028 /* Add this label to the chain, and succeed.
4029 Copy LOW, HIGH so they are on temporary rather than momentary
4030 obstack and will thus survive till the end of the case statement. */
4032 r
= (struct case_node
*) oballoc (sizeof (struct case_node
));
4033 r
->low
= copy_node (low
);
4035 /* If the bounds are equal, turn this into the one-value case. */
4037 if (tree_int_cst_equal (low
, high
))
4041 r
->high
= copy_node (high
);
4042 case_stack
->data
.case_stmt
.num_ranges
++;
4045 r
->code_label
= label
;
4046 expand_label (label
);
4056 struct case_node
*s
;
4062 if (! (b
= p
->balance
))
4063 /* Growth propagation from left side. */
4070 if ((p
->left
= s
= r
->right
))
4079 if ((r
->parent
= s
))
4087 case_stack
->data
.case_stmt
.case_list
= r
;
4090 /* r->balance == +1 */
4095 struct case_node
*t
= r
->right
;
4097 if ((p
->left
= s
= t
->right
))
4101 if ((r
->right
= s
= t
->left
))
4115 if ((t
->parent
= s
))
4123 case_stack
->data
.case_stmt
.case_list
= t
;
4130 /* p->balance == +1; growth of left side balances the node. */
4140 if (! (b
= p
->balance
))
4141 /* Growth propagation from right side. */
4149 if ((p
->right
= s
= r
->left
))
4157 if ((r
->parent
= s
))
4166 case_stack
->data
.case_stmt
.case_list
= r
;
4170 /* r->balance == -1 */
4174 struct case_node
*t
= r
->left
;
4176 if ((p
->right
= s
= t
->left
))
4181 if ((r
->left
= s
= t
->right
))
4195 if ((t
->parent
= s
))
4204 case_stack
->data
.case_stmt
.case_list
= t
;
4210 /* p->balance == -1; growth of right side balances the node. */
4224 /* Returns the number of possible values of TYPE.
4225 Returns -1 if the number is unknown or variable.
4226 Returns -2 if the number does not fit in a HOST_WIDE_INT.
4227 Sets *SPARENESS to 2 if TYPE is an ENUMERAL_TYPE whose values
4228 do not increase monotonically (there may be duplicates);
4229 to 1 if the values increase monotonically, but not always by 1;
4230 otherwise sets it to 0. */
4233 all_cases_count (type
, spareness
)
4237 HOST_WIDE_INT count
;
4240 switch (TREE_CODE (type
))
4247 count
= 1 << BITS_PER_UNIT
;
4251 if (TREE_CODE (TYPE_MIN_VALUE (type
)) != INTEGER_CST
4252 || TYPE_MAX_VALUE (type
) == NULL
4253 || TREE_CODE (TYPE_MAX_VALUE (type
)) != INTEGER_CST
)
4258 = TREE_INT_CST_LOW (TYPE_MAX_VALUE (type))
4259 - TREE_INT_CST_LOW (TYPE_MIN_VALUE (type)) + 1
4260 but with overflow checking. */
4261 tree mint
= TYPE_MIN_VALUE (type
);
4262 tree maxt
= TYPE_MAX_VALUE (type
);
4263 HOST_WIDE_INT lo
, hi
;
4264 neg_double(TREE_INT_CST_LOW (mint
), TREE_INT_CST_HIGH (mint
),
4266 add_double(TREE_INT_CST_LOW (maxt
), TREE_INT_CST_HIGH (maxt
),
4268 add_double (lo
, hi
, 1, 0, &lo
, &hi
);
4269 if (hi
!= 0 || lo
< 0)
4276 for (t
= TYPE_VALUES (type
); t
!= NULL_TREE
; t
= TREE_CHAIN (t
))
4278 if (TREE_CODE (TYPE_MIN_VALUE (type
)) != INTEGER_CST
4279 || TREE_CODE (TREE_VALUE (t
)) != INTEGER_CST
4280 || TREE_INT_CST_LOW (TYPE_MIN_VALUE (type
)) + count
4281 != TREE_INT_CST_LOW (TREE_VALUE (t
)))
4285 if (*spareness
== 1)
4287 tree prev
= TREE_VALUE (TYPE_VALUES (type
));
4288 for (t
= TYPE_VALUES (type
); t
= TREE_CHAIN (t
), t
!= NULL_TREE
; )
4290 if (! tree_int_cst_lt (prev
, TREE_VALUE (t
)))
4295 prev
= TREE_VALUE (t
);
4304 #define BITARRAY_TEST(ARRAY, INDEX) \
4305 ((ARRAY)[(unsigned) (INDEX) / HOST_BITS_PER_CHAR]\
4306 & (1 << ((unsigned) (INDEX) % HOST_BITS_PER_CHAR)))
4307 #define BITARRAY_SET(ARRAY, INDEX) \
4308 ((ARRAY)[(unsigned) (INDEX) / HOST_BITS_PER_CHAR]\
4309 |= 1 << ((unsigned) (INDEX) % HOST_BITS_PER_CHAR))
4311 /* Set the elements of the bitstring CASES_SEEN (which has length COUNT),
4312 with the case values we have seen, assuming the case expression
4314 SPARSENESS is as determined by all_cases_count.
4316 The time needed is proportional to COUNT, unless
4317 SPARSENESS is 2, in which case quadratic time is needed. */
4320 mark_seen_cases (type
, cases_seen
, count
, sparseness
)
4322 unsigned char *cases_seen
;
4326 tree next_node_to_try
= NULL_TREE
;
4327 long next_node_offset
= 0;
4329 register struct case_node
*n
, *root
= case_stack
->data
.case_stmt
.case_list
;
4330 tree val
= make_node (INTEGER_CST
);
4331 TREE_TYPE (val
) = type
;
4334 else if (sparseness
== 2)
4339 /* This less efficient loop is only needed to handle
4340 duplicate case values (multiple enum constants
4341 with the same value). */
4342 TREE_TYPE (val
) = TREE_TYPE (root
->low
);
4343 for (t
= TYPE_VALUES (type
), xlo
= 0; t
!= NULL_TREE
;
4344 t
= TREE_CHAIN (t
), xlo
++)
4346 TREE_INT_CST_LOW (val
) = TREE_INT_CST_LOW (TREE_VALUE (t
));
4347 TREE_INT_CST_HIGH (val
) = TREE_INT_CST_HIGH (TREE_VALUE (t
));
4351 /* Keep going past elements distinctly greater than VAL. */
4352 if (tree_int_cst_lt (val
, n
->low
))
4355 /* or distinctly less than VAL. */
4356 else if (tree_int_cst_lt (n
->high
, val
))
4361 /* We have found a matching range. */
4362 BITARRAY_SET (cases_seen
, xlo
);
4372 case_stack
->data
.case_stmt
.case_list
= root
= case_tree2list (root
, 0);
4373 for (n
= root
; n
; n
= n
->right
)
4375 TREE_INT_CST_LOW (val
) = TREE_INT_CST_LOW (n
->low
);
4376 TREE_INT_CST_HIGH (val
) = TREE_INT_CST_HIGH (n
->low
);
4377 while ( ! tree_int_cst_lt (n
->high
, val
))
4379 /* Calculate (into xlo) the "offset" of the integer (val).
4380 The element with lowest value has offset 0, the next smallest
4381 element has offset 1, etc. */
4383 HOST_WIDE_INT xlo
, xhi
;
4385 if (sparseness
&& TYPE_VALUES (type
) != NULL_TREE
)
4387 /* The TYPE_VALUES will be in increasing order, so
4388 starting searching where we last ended. */
4389 t
= next_node_to_try
;
4390 xlo
= next_node_offset
;
4396 t
= TYPE_VALUES (type
);
4399 if (tree_int_cst_equal (val
, TREE_VALUE (t
)))
4401 next_node_to_try
= TREE_CHAIN (t
);
4402 next_node_offset
= xlo
+ 1;
4407 if (t
== next_node_to_try
)
4416 t
= TYPE_MIN_VALUE (type
);
4418 neg_double (TREE_INT_CST_LOW (t
), TREE_INT_CST_HIGH (t
),
4422 add_double (xlo
, xhi
,
4423 TREE_INT_CST_LOW (val
), TREE_INT_CST_HIGH (val
),
4427 if (xhi
== 0 && xlo
>= 0 && xlo
< count
)
4428 BITARRAY_SET (cases_seen
, xlo
);
4429 add_double (TREE_INT_CST_LOW (val
), TREE_INT_CST_HIGH (val
),
4431 &TREE_INT_CST_LOW (val
), &TREE_INT_CST_HIGH (val
));
4437 /* Called when the index of a switch statement is an enumerated type
4438 and there is no default label.
4440 Checks that all enumeration literals are covered by the case
4441 expressions of a switch. Also, warn if there are any extra
4442 switch cases that are *not* elements of the enumerated type.
4444 If all enumeration literals were covered by the case expressions,
4445 turn one of the expressions into the default expression since it should
4446 not be possible to fall through such a switch. */
4449 check_for_full_enumeration_handling (type
)
4452 register struct case_node
*n
;
4453 register tree chain
;
4454 #if 0 /* variable used by 'if 0'ed code below. */
4455 register struct case_node
**l
;
4459 /* True iff the selector type is a numbered set mode. */
4462 /* The number of possible selector values. */
4465 /* For each possible selector value. a one iff it has been matched
4466 by a case value alternative. */
4467 unsigned char *cases_seen
;
4469 /* The allocated size of cases_seen, in chars. */
4475 size
= all_cases_count (type
, &sparseness
);
4476 bytes_needed
= (size
+ HOST_BITS_PER_CHAR
) / HOST_BITS_PER_CHAR
;
4478 if (size
> 0 && size
< 600000
4479 /* We deliberately use malloc here - not xmalloc. */
4480 && (cases_seen
= (unsigned char *) malloc (bytes_needed
)) != NULL
)
4483 tree v
= TYPE_VALUES (type
);
4484 bzero (cases_seen
, bytes_needed
);
4486 /* The time complexity of this code is normally O(N), where
4487 N being the number of members in the enumerated type.
4488 However, if type is a ENUMERAL_TYPE whose values do not
4489 increase monotonically, O(N*log(N)) time may be needed. */
4491 mark_seen_cases (type
, cases_seen
, size
, sparseness
);
4493 for (i
= 0; v
!= NULL_TREE
&& i
< size
; i
++, v
= TREE_CHAIN (v
))
4495 if (BITARRAY_TEST(cases_seen
, i
) == 0)
4496 warning ("enumeration value `%s' not handled in switch",
4497 IDENTIFIER_POINTER (TREE_PURPOSE (v
)));
4503 /* Now we go the other way around; we warn if there are case
4504 expressions that don't correspond to enumerators. This can
4505 occur since C and C++ don't enforce type-checking of
4506 assignments to enumeration variables. */
4508 if (case_stack
->data
.case_stmt
.case_list
4509 && case_stack
->data
.case_stmt
.case_list
->left
)
4510 case_stack
->data
.case_stmt
.case_list
4511 = case_tree2list (case_stack
->data
.case_stmt
.case_list
, 0);
4513 for (n
= case_stack
->data
.case_stmt
.case_list
; n
; n
= n
->right
)
4515 for (chain
= TYPE_VALUES (type
);
4516 chain
&& !tree_int_cst_equal (n
->low
, TREE_VALUE (chain
));
4517 chain
= TREE_CHAIN (chain
))
4522 if (TYPE_NAME (type
) == 0)
4523 warning ("case value `%d' not in enumerated type",
4524 TREE_INT_CST_LOW (n
->low
));
4526 warning ("case value `%d' not in enumerated type `%s'",
4527 TREE_INT_CST_LOW (n
->low
),
4528 IDENTIFIER_POINTER ((TREE_CODE (TYPE_NAME (type
))
4531 : DECL_NAME (TYPE_NAME (type
))));
4533 if (!tree_int_cst_equal (n
->low
, n
->high
))
4535 for (chain
= TYPE_VALUES (type
);
4536 chain
&& !tree_int_cst_equal (n
->high
, TREE_VALUE (chain
));
4537 chain
= TREE_CHAIN (chain
))
4542 if (TYPE_NAME (type
) == 0)
4543 warning ("case value `%d' not in enumerated type",
4544 TREE_INT_CST_LOW (n
->high
));
4546 warning ("case value `%d' not in enumerated type `%s'",
4547 TREE_INT_CST_LOW (n
->high
),
4548 IDENTIFIER_POINTER ((TREE_CODE (TYPE_NAME (type
))
4551 : DECL_NAME (TYPE_NAME (type
))));
4557 /* ??? This optimization is disabled because it causes valid programs to
4558 fail. ANSI C does not guarantee that an expression with enum type
4559 will have a value that is the same as one of the enumeration literals. */
4561 /* If all values were found as case labels, make one of them the default
4562 label. Thus, this switch will never fall through. We arbitrarily pick
4563 the last one to make the default since this is likely the most
4564 efficient choice. */
4568 for (l
= &case_stack
->data
.case_stmt
.case_list
;
4573 case_stack
->data
.case_stmt
.default_label
= (*l
)->code_label
;
4580 /* Terminate a case (Pascal) or switch (C) statement
4581 in which ORIG_INDEX is the expression to be tested.
4582 Generate the code to test it and jump to the right place. */
4585 expand_end_case (orig_index
)
4588 tree minval
, maxval
, range
, orig_minval
;
4589 rtx default_label
= 0;
4590 register struct case_node
*n
;
4598 register struct nesting
*thiscase
= case_stack
;
4599 tree index_expr
, index_type
;
4602 table_label
= gen_label_rtx ();
4603 index_expr
= thiscase
->data
.case_stmt
.index_expr
;
4604 index_type
= TREE_TYPE (index_expr
);
4605 unsignedp
= TREE_UNSIGNED (index_type
);
4607 do_pending_stack_adjust ();
4609 /* This might get an spurious warning in the presence of a syntax error;
4610 it could be fixed by moving the call to check_seenlabel after the
4611 check for error_mark_node, and copying the code of check_seenlabel that
4612 deals with case_stack->data.case_stmt.line_number_status /
4613 restore_line_number_status in front of the call to end_cleanup_deferral;
4614 However, this might miss some useful warnings in the presence of
4615 non-syntax errors. */
4618 /* An ERROR_MARK occurs for various reasons including invalid data type. */
4619 if (index_type
!= error_mark_node
)
4621 /* If switch expression was an enumerated type, check that all
4622 enumeration literals are covered by the cases.
4623 No sense trying this if there's a default case, however. */
4625 if (!thiscase
->data
.case_stmt
.default_label
4626 && TREE_CODE (TREE_TYPE (orig_index
)) == ENUMERAL_TYPE
4627 && TREE_CODE (index_expr
) != INTEGER_CST
)
4628 check_for_full_enumeration_handling (TREE_TYPE (orig_index
));
4630 /* If we don't have a default-label, create one here,
4631 after the body of the switch. */
4632 if (thiscase
->data
.case_stmt
.default_label
== 0)
4634 thiscase
->data
.case_stmt
.default_label
4635 = build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
4636 expand_label (thiscase
->data
.case_stmt
.default_label
);
4638 default_label
= label_rtx (thiscase
->data
.case_stmt
.default_label
);
4640 before_case
= get_last_insn ();
4642 if (thiscase
->data
.case_stmt
.case_list
4643 && thiscase
->data
.case_stmt
.case_list
->left
)
4644 thiscase
->data
.case_stmt
.case_list
4645 = case_tree2list(thiscase
->data
.case_stmt
.case_list
, 0);
4647 /* Simplify the case-list before we count it. */
4648 group_case_nodes (thiscase
->data
.case_stmt
.case_list
);
4650 /* Get upper and lower bounds of case values.
4651 Also convert all the case values to the index expr's data type. */
4654 for (n
= thiscase
->data
.case_stmt
.case_list
; n
; n
= n
->right
)
4656 /* Check low and high label values are integers. */
4657 if (TREE_CODE (n
->low
) != INTEGER_CST
)
4659 if (TREE_CODE (n
->high
) != INTEGER_CST
)
4662 n
->low
= convert (index_type
, n
->low
);
4663 n
->high
= convert (index_type
, n
->high
);
4665 /* Count the elements and track the largest and smallest
4666 of them (treating them as signed even if they are not). */
4674 if (INT_CST_LT (n
->low
, minval
))
4676 if (INT_CST_LT (maxval
, n
->high
))
4679 /* A range counts double, since it requires two compares. */
4680 if (! tree_int_cst_equal (n
->low
, n
->high
))
4684 orig_minval
= minval
;
4686 /* Compute span of values. */
4688 range
= fold (build (MINUS_EXPR
, index_type
, maxval
, minval
));
4690 end_cleanup_deferral ();
4694 expand_expr (index_expr
, const0_rtx
, VOIDmode
, 0);
4696 emit_jump (default_label
);
4699 /* If range of values is much bigger than number of values,
4700 make a sequence of conditional branches instead of a dispatch.
4701 If the switch-index is a constant, do it this way
4702 because we can optimize it. */
4704 #ifndef CASE_VALUES_THRESHOLD
4706 #define CASE_VALUES_THRESHOLD (HAVE_casesi ? 4 : 5)
4708 /* If machine does not have a case insn that compares the
4709 bounds, this means extra overhead for dispatch tables
4710 which raises the threshold for using them. */
4711 #define CASE_VALUES_THRESHOLD 5
4712 #endif /* HAVE_casesi */
4713 #endif /* CASE_VALUES_THRESHOLD */
4715 else if (TREE_INT_CST_HIGH (range
) != 0
4716 || count
< CASE_VALUES_THRESHOLD
4717 || ((unsigned HOST_WIDE_INT
) (TREE_INT_CST_LOW (range
))
4719 #ifndef ASM_OUTPUT_ADDR_DIFF_ELT
4722 || TREE_CODE (index_expr
) == INTEGER_CST
4723 /* These will reduce to a constant. */
4724 || (TREE_CODE (index_expr
) == CALL_EXPR
4725 && TREE_CODE (TREE_OPERAND (index_expr
, 0)) == ADDR_EXPR
4726 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (index_expr
, 0), 0)) == FUNCTION_DECL
4727 && DECL_FUNCTION_CODE (TREE_OPERAND (TREE_OPERAND (index_expr
, 0), 0)) == BUILT_IN_CLASSIFY_TYPE
)
4728 || (TREE_CODE (index_expr
) == COMPOUND_EXPR
4729 && TREE_CODE (TREE_OPERAND (index_expr
, 1)) == INTEGER_CST
))
4731 index
= expand_expr (index_expr
, NULL_RTX
, VOIDmode
, 0);
4733 /* If the index is a short or char that we do not have
4734 an insn to handle comparisons directly, convert it to
4735 a full integer now, rather than letting each comparison
4736 generate the conversion. */
4738 if (GET_MODE_CLASS (GET_MODE (index
)) == MODE_INT
4739 && (cmp_optab
->handlers
[(int) GET_MODE(index
)].insn_code
4740 == CODE_FOR_nothing
))
4742 enum machine_mode wider_mode
;
4743 for (wider_mode
= GET_MODE (index
); wider_mode
!= VOIDmode
;
4744 wider_mode
= GET_MODE_WIDER_MODE (wider_mode
))
4745 if (cmp_optab
->handlers
[(int) wider_mode
].insn_code
4746 != CODE_FOR_nothing
)
4748 index
= convert_to_mode (wider_mode
, index
, unsignedp
);
4754 do_pending_stack_adjust ();
4756 index
= protect_from_queue (index
, 0);
4757 if (GET_CODE (index
) == MEM
)
4758 index
= copy_to_reg (index
);
4759 if (GET_CODE (index
) == CONST_INT
4760 || TREE_CODE (index_expr
) == INTEGER_CST
)
4762 /* Make a tree node with the proper constant value
4763 if we don't already have one. */
4764 if (TREE_CODE (index_expr
) != INTEGER_CST
)
4767 = build_int_2 (INTVAL (index
),
4768 unsignedp
|| INTVAL (index
) >= 0 ? 0 : -1);
4769 index_expr
= convert (index_type
, index_expr
);
4772 /* For constant index expressions we need only
4773 issue a unconditional branch to the appropriate
4774 target code. The job of removing any unreachable
4775 code is left to the optimisation phase if the
4776 "-O" option is specified. */
4777 for (n
= thiscase
->data
.case_stmt
.case_list
; n
; n
= n
->right
)
4778 if (! tree_int_cst_lt (index_expr
, n
->low
)
4779 && ! tree_int_cst_lt (n
->high
, index_expr
))
4783 emit_jump (label_rtx (n
->code_label
));
4785 emit_jump (default_label
);
4789 /* If the index expression is not constant we generate
4790 a binary decision tree to select the appropriate
4791 target code. This is done as follows:
4793 The list of cases is rearranged into a binary tree,
4794 nearly optimal assuming equal probability for each case.
4796 The tree is transformed into RTL, eliminating
4797 redundant test conditions at the same time.
4799 If program flow could reach the end of the
4800 decision tree an unconditional jump to the
4801 default code is emitted. */
4804 = (TREE_CODE (TREE_TYPE (orig_index
)) != ENUMERAL_TYPE
4805 && estimate_case_costs (thiscase
->data
.case_stmt
.case_list
));
4806 balance_case_nodes (&thiscase
->data
.case_stmt
.case_list
,
4808 emit_case_nodes (index
, thiscase
->data
.case_stmt
.case_list
,
4809 default_label
, index_type
);
4810 emit_jump_if_reachable (default_label
);
4819 enum machine_mode index_mode
= SImode
;
4820 int index_bits
= GET_MODE_BITSIZE (index_mode
);
4822 enum machine_mode op_mode
;
4824 /* Convert the index to SImode. */
4825 if (GET_MODE_BITSIZE (TYPE_MODE (index_type
))
4826 > GET_MODE_BITSIZE (index_mode
))
4828 enum machine_mode omode
= TYPE_MODE (index_type
);
4829 rtx rangertx
= expand_expr (range
, NULL_RTX
, VOIDmode
, 0);
4831 /* We must handle the endpoints in the original mode. */
4832 index_expr
= build (MINUS_EXPR
, index_type
,
4833 index_expr
, minval
);
4834 minval
= integer_zero_node
;
4835 index
= expand_expr (index_expr
, NULL_RTX
, VOIDmode
, 0);
4836 emit_cmp_insn (rangertx
, index
, LTU
, NULL_RTX
, omode
, 1, 0);
4837 emit_jump_insn (gen_bltu (default_label
));
4838 /* Now we can safely truncate. */
4839 index
= convert_to_mode (index_mode
, index
, 0);
4843 if (TYPE_MODE (index_type
) != index_mode
)
4845 index_expr
= convert (type_for_size (index_bits
, 0),
4847 index_type
= TREE_TYPE (index_expr
);
4850 index
= expand_expr (index_expr
, NULL_RTX
, VOIDmode
, 0);
4853 index
= protect_from_queue (index
, 0);
4854 do_pending_stack_adjust ();
4856 op_mode
= insn_operand_mode
[(int)CODE_FOR_casesi
][0];
4857 if (! (*insn_operand_predicate
[(int)CODE_FOR_casesi
][0])
4859 index
= copy_to_mode_reg (op_mode
, index
);
4861 op1
= expand_expr (minval
, NULL_RTX
, VOIDmode
, 0);
4863 op_mode
= insn_operand_mode
[(int)CODE_FOR_casesi
][1];
4864 if (! (*insn_operand_predicate
[(int)CODE_FOR_casesi
][1])
4866 op1
= copy_to_mode_reg (op_mode
, op1
);
4868 op2
= expand_expr (range
, NULL_RTX
, VOIDmode
, 0);
4870 op_mode
= insn_operand_mode
[(int)CODE_FOR_casesi
][2];
4871 if (! (*insn_operand_predicate
[(int)CODE_FOR_casesi
][2])
4873 op2
= copy_to_mode_reg (op_mode
, op2
);
4875 emit_jump_insn (gen_casesi (index
, op1
, op2
,
4876 table_label
, default_label
));
4880 #ifdef HAVE_tablejump
4881 if (! win
&& HAVE_tablejump
)
4883 index_expr
= convert (thiscase
->data
.case_stmt
.nominal_type
,
4884 fold (build (MINUS_EXPR
, index_type
,
4885 index_expr
, minval
)));
4886 index_type
= TREE_TYPE (index_expr
);
4887 index
= expand_expr (index_expr
, NULL_RTX
, VOIDmode
, 0);
4889 index
= protect_from_queue (index
, 0);
4890 do_pending_stack_adjust ();
4892 do_tablejump (index
, TYPE_MODE (index_type
),
4893 expand_expr (range
, NULL_RTX
, VOIDmode
, 0),
4894 table_label
, default_label
);
4901 /* Get table of labels to jump to, in order of case index. */
4903 ncases
= TREE_INT_CST_LOW (range
) + 1;
4904 labelvec
= (rtx
*) alloca (ncases
* sizeof (rtx
));
4905 bzero ((char *) labelvec
, ncases
* sizeof (rtx
));
4907 for (n
= thiscase
->data
.case_stmt
.case_list
; n
; n
= n
->right
)
4909 register HOST_WIDE_INT i
4910 = TREE_INT_CST_LOW (n
->low
) - TREE_INT_CST_LOW (orig_minval
);
4915 = gen_rtx_LABEL_REF (Pmode
, label_rtx (n
->code_label
));
4916 if (i
+ TREE_INT_CST_LOW (orig_minval
)
4917 == TREE_INT_CST_LOW (n
->high
))
4923 /* Fill in the gaps with the default. */
4924 for (i
= 0; i
< ncases
; i
++)
4925 if (labelvec
[i
] == 0)
4926 labelvec
[i
] = gen_rtx_LABEL_REF (Pmode
, default_label
);
4928 /* Output the table */
4929 emit_label (table_label
);
4931 if (CASE_VECTOR_PC_RELATIVE
|| flag_pic
)
4932 emit_jump_insn (gen_rtx_ADDR_DIFF_VEC (CASE_VECTOR_MODE
,
4933 gen_rtx_LABEL_REF (Pmode
, table_label
),
4934 gen_rtvec_v (ncases
, labelvec
),
4935 const0_rtx
, const0_rtx
, 0));
4937 emit_jump_insn (gen_rtx_ADDR_VEC (CASE_VECTOR_MODE
,
4938 gen_rtvec_v (ncases
, labelvec
)));
4940 /* If the case insn drops through the table,
4941 after the table we must jump to the default-label.
4942 Otherwise record no drop-through after the table. */
4943 #ifdef CASE_DROPS_THROUGH
4944 emit_jump (default_label
);
4950 before_case
= squeeze_notes (NEXT_INSN (before_case
), get_last_insn ());
4951 reorder_insns (before_case
, get_last_insn (),
4952 thiscase
->data
.case_stmt
.start
);
4955 end_cleanup_deferral ();
4957 if (thiscase
->exit_label
)
4958 emit_label (thiscase
->exit_label
);
4960 POPSTACK (case_stack
);
4965 /* Convert the tree NODE into a list linked by the right field, with the left
4966 field zeroed. RIGHT is used for recursion; it is a list to be placed
4967 rightmost in the resulting list. */
4969 static struct case_node
*
4970 case_tree2list (node
, right
)
4971 struct case_node
*node
, *right
;
4973 struct case_node
*left
;
4976 right
= case_tree2list (node
->right
, right
);
4978 node
->right
= right
;
4979 if ((left
= node
->left
))
4982 return case_tree2list (left
, node
);
4988 /* Generate code to jump to LABEL if OP1 and OP2 are equal. */
4991 do_jump_if_equal (op1
, op2
, label
, unsignedp
)
4992 rtx op1
, op2
, label
;
4995 if (GET_CODE (op1
) == CONST_INT
4996 && GET_CODE (op2
) == CONST_INT
)
4998 if (INTVAL (op1
) == INTVAL (op2
))
5003 enum machine_mode mode
= GET_MODE (op1
);
5004 if (mode
== VOIDmode
)
5005 mode
= GET_MODE (op2
);
5006 emit_cmp_insn (op1
, op2
, EQ
, NULL_RTX
, mode
, unsignedp
, 0);
5007 emit_jump_insn (gen_beq (label
));
5011 /* Not all case values are encountered equally. This function
5012 uses a heuristic to weight case labels, in cases where that
5013 looks like a reasonable thing to do.
5015 Right now, all we try to guess is text, and we establish the
5018 chars above space: 16
5027 If we find any cases in the switch that are not either -1 or in the range
5028 of valid ASCII characters, or are control characters other than those
5029 commonly used with "\", don't treat this switch scanning text.
5031 Return 1 if these nodes are suitable for cost estimation, otherwise
5035 estimate_case_costs (node
)
5038 tree min_ascii
= build_int_2 (-1, -1);
5039 tree max_ascii
= convert (TREE_TYPE (node
->high
), build_int_2 (127, 0));
5043 /* If we haven't already made the cost table, make it now. Note that the
5044 lower bound of the table is -1, not zero. */
5046 if (cost_table
== NULL
)
5048 cost_table
= ((short *) xmalloc (129 * sizeof (short))) + 1;
5049 bzero ((char *) (cost_table
- 1), 129 * sizeof (short));
5051 for (i
= 0; i
< 128; i
++)
5055 else if (ispunct (i
))
5057 else if (iscntrl (i
))
5061 cost_table
[' '] = 8;
5062 cost_table
['\t'] = 4;
5063 cost_table
['\0'] = 4;
5064 cost_table
['\n'] = 2;
5065 cost_table
['\f'] = 1;
5066 cost_table
['\v'] = 1;
5067 cost_table
['\b'] = 1;
5070 /* See if all the case expressions look like text. It is text if the
5071 constant is >= -1 and the highest constant is <= 127. Do all comparisons
5072 as signed arithmetic since we don't want to ever access cost_table with a
5073 value less than -1. Also check that none of the constants in a range
5074 are strange control characters. */
5076 for (n
= node
; n
; n
= n
->right
)
5078 if ((INT_CST_LT (n
->low
, min_ascii
)) || INT_CST_LT (max_ascii
, n
->high
))
5081 for (i
= TREE_INT_CST_LOW (n
->low
); i
<= TREE_INT_CST_LOW (n
->high
); i
++)
5082 if (cost_table
[i
] < 0)
5086 /* All interesting values are within the range of interesting
5087 ASCII characters. */
5091 /* Scan an ordered list of case nodes
5092 combining those with consecutive values or ranges.
5094 Eg. three separate entries 1: 2: 3: become one entry 1..3: */
5097 group_case_nodes (head
)
5100 case_node_ptr node
= head
;
5104 rtx lb
= next_real_insn (label_rtx (node
->code_label
));
5106 case_node_ptr np
= node
;
5108 /* Try to group the successors of NODE with NODE. */
5109 while (((np
= np
->right
) != 0)
5110 /* Do they jump to the same place? */
5111 && ((lb2
= next_real_insn (label_rtx (np
->code_label
))) == lb
5112 || (lb
!= 0 && lb2
!= 0
5113 && simplejump_p (lb
)
5114 && simplejump_p (lb2
)
5115 && rtx_equal_p (SET_SRC (PATTERN (lb
)),
5116 SET_SRC (PATTERN (lb2
)))))
5117 /* Are their ranges consecutive? */
5118 && tree_int_cst_equal (np
->low
,
5119 fold (build (PLUS_EXPR
,
5120 TREE_TYPE (node
->high
),
5123 /* An overflow is not consecutive. */
5124 && tree_int_cst_lt (node
->high
,
5125 fold (build (PLUS_EXPR
,
5126 TREE_TYPE (node
->high
),
5128 integer_one_node
))))
5130 node
->high
= np
->high
;
5132 /* NP is the first node after NODE which can't be grouped with it.
5133 Delete the nodes in between, and move on to that node. */
5139 /* Take an ordered list of case nodes
5140 and transform them into a near optimal binary tree,
5141 on the assumption that any target code selection value is as
5142 likely as any other.
5144 The transformation is performed by splitting the ordered
5145 list into two equal sections plus a pivot. The parts are
5146 then attached to the pivot as left and right branches. Each
5147 branch is is then transformed recursively. */
5150 balance_case_nodes (head
, parent
)
5151 case_node_ptr
*head
;
5152 case_node_ptr parent
;
5154 register case_node_ptr np
;
5162 register case_node_ptr
*npp
;
5165 /* Count the number of entries on branch. Also count the ranges. */
5169 if (!tree_int_cst_equal (np
->low
, np
->high
))
5173 cost
+= cost_table
[TREE_INT_CST_LOW (np
->high
)];
5177 cost
+= cost_table
[TREE_INT_CST_LOW (np
->low
)];
5185 /* Split this list if it is long enough for that to help. */
5190 /* Find the place in the list that bisects the list's total cost,
5191 Here I gets half the total cost. */
5196 /* Skip nodes while their cost does not reach that amount. */
5197 if (!tree_int_cst_equal ((*npp
)->low
, (*npp
)->high
))
5198 i
-= cost_table
[TREE_INT_CST_LOW ((*npp
)->high
)];
5199 i
-= cost_table
[TREE_INT_CST_LOW ((*npp
)->low
)];
5202 npp
= &(*npp
)->right
;
5207 /* Leave this branch lopsided, but optimize left-hand
5208 side and fill in `parent' fields for right-hand side. */
5210 np
->parent
= parent
;
5211 balance_case_nodes (&np
->left
, np
);
5212 for (; np
->right
; np
= np
->right
)
5213 np
->right
->parent
= np
;
5217 /* If there are just three nodes, split at the middle one. */
5219 npp
= &(*npp
)->right
;
5222 /* Find the place in the list that bisects the list's total cost,
5223 where ranges count as 2.
5224 Here I gets half the total cost. */
5225 i
= (i
+ ranges
+ 1) / 2;
5228 /* Skip nodes while their cost does not reach that amount. */
5229 if (!tree_int_cst_equal ((*npp
)->low
, (*npp
)->high
))
5234 npp
= &(*npp
)->right
;
5239 np
->parent
= parent
;
5242 /* Optimize each of the two split parts. */
5243 balance_case_nodes (&np
->left
, np
);
5244 balance_case_nodes (&np
->right
, np
);
5248 /* Else leave this branch as one level,
5249 but fill in `parent' fields. */
5251 np
->parent
= parent
;
5252 for (; np
->right
; np
= np
->right
)
5253 np
->right
->parent
= np
;
5258 /* Search the parent sections of the case node tree
5259 to see if a test for the lower bound of NODE would be redundant.
5260 INDEX_TYPE is the type of the index expression.
5262 The instructions to generate the case decision tree are
5263 output in the same order as nodes are processed so it is
5264 known that if a parent node checks the range of the current
5265 node minus one that the current node is bounded at its lower
5266 span. Thus the test would be redundant. */
5269 node_has_low_bound (node
, index_type
)
5274 case_node_ptr pnode
;
5276 /* If the lower bound of this node is the lowest value in the index type,
5277 we need not test it. */
5279 if (tree_int_cst_equal (node
->low
, TYPE_MIN_VALUE (index_type
)))
5282 /* If this node has a left branch, the value at the left must be less
5283 than that at this node, so it cannot be bounded at the bottom and
5284 we need not bother testing any further. */
5289 low_minus_one
= fold (build (MINUS_EXPR
, TREE_TYPE (node
->low
),
5290 node
->low
, integer_one_node
));
5292 /* If the subtraction above overflowed, we can't verify anything.
5293 Otherwise, look for a parent that tests our value - 1. */
5295 if (! tree_int_cst_lt (low_minus_one
, node
->low
))
5298 for (pnode
= node
->parent
; pnode
; pnode
= pnode
->parent
)
5299 if (tree_int_cst_equal (low_minus_one
, pnode
->high
))
5305 /* Search the parent sections of the case node tree
5306 to see if a test for the upper bound of NODE would be redundant.
5307 INDEX_TYPE is the type of the index expression.
5309 The instructions to generate the case decision tree are
5310 output in the same order as nodes are processed so it is
5311 known that if a parent node checks the range of the current
5312 node plus one that the current node is bounded at its upper
5313 span. Thus the test would be redundant. */
5316 node_has_high_bound (node
, index_type
)
5321 case_node_ptr pnode
;
5323 /* If there is no upper bound, obviously no test is needed. */
5325 if (TYPE_MAX_VALUE (index_type
) == NULL
)
5328 /* If the upper bound of this node is the highest value in the type
5329 of the index expression, we need not test against it. */
5331 if (tree_int_cst_equal (node
->high
, TYPE_MAX_VALUE (index_type
)))
5334 /* If this node has a right branch, the value at the right must be greater
5335 than that at this node, so it cannot be bounded at the top and
5336 we need not bother testing any further. */
5341 high_plus_one
= fold (build (PLUS_EXPR
, TREE_TYPE (node
->high
),
5342 node
->high
, integer_one_node
));
5344 /* If the addition above overflowed, we can't verify anything.
5345 Otherwise, look for a parent that tests our value + 1. */
5347 if (! tree_int_cst_lt (node
->high
, high_plus_one
))
5350 for (pnode
= node
->parent
; pnode
; pnode
= pnode
->parent
)
5351 if (tree_int_cst_equal (high_plus_one
, pnode
->low
))
5357 /* Search the parent sections of the
5358 case node tree to see if both tests for the upper and lower
5359 bounds of NODE would be redundant. */
5362 node_is_bounded (node
, index_type
)
5366 return (node_has_low_bound (node
, index_type
)
5367 && node_has_high_bound (node
, index_type
));
5370 /* Emit an unconditional jump to LABEL unless it would be dead code. */
5373 emit_jump_if_reachable (label
)
5376 if (GET_CODE (get_last_insn ()) != BARRIER
)
5380 /* Emit step-by-step code to select a case for the value of INDEX.
5381 The thus generated decision tree follows the form of the
5382 case-node binary tree NODE, whose nodes represent test conditions.
5383 INDEX_TYPE is the type of the index of the switch.
5385 Care is taken to prune redundant tests from the decision tree
5386 by detecting any boundary conditions already checked by
5387 emitted rtx. (See node_has_high_bound, node_has_low_bound
5388 and node_is_bounded, above.)
5390 Where the test conditions can be shown to be redundant we emit
5391 an unconditional jump to the target code. As a further
5392 optimization, the subordinates of a tree node are examined to
5393 check for bounded nodes. In this case conditional and/or
5394 unconditional jumps as a result of the boundary check for the
5395 current node are arranged to target the subordinates associated
5396 code for out of bound conditions on the current node node.
5398 We can assume that when control reaches the code generated here,
5399 the index value has already been compared with the parents
5400 of this node, and determined to be on the same side of each parent
5401 as this node is. Thus, if this node tests for the value 51,
5402 and a parent tested for 52, we don't need to consider
5403 the possibility of a value greater than 51. If another parent
5404 tests for the value 50, then this node need not test anything. */
5407 emit_case_nodes (index
, node
, default_label
, index_type
)
5413 /* If INDEX has an unsigned type, we must make unsigned branches. */
5414 int unsignedp
= TREE_UNSIGNED (index_type
);
5415 typedef rtx
rtx_function ();
5416 rtx_function
*gen_bgt_pat
= unsignedp
? gen_bgtu
: gen_bgt
;
5417 rtx_function
*gen_bge_pat
= unsignedp
? gen_bgeu
: gen_bge
;
5418 rtx_function
*gen_blt_pat
= unsignedp
? gen_bltu
: gen_blt
;
5419 rtx_function
*gen_ble_pat
= unsignedp
? gen_bleu
: gen_ble
;
5420 enum machine_mode mode
= GET_MODE (index
);
5422 /* See if our parents have already tested everything for us.
5423 If they have, emit an unconditional jump for this node. */
5424 if (node_is_bounded (node
, index_type
))
5425 emit_jump (label_rtx (node
->code_label
));
5427 else if (tree_int_cst_equal (node
->low
, node
->high
))
5429 /* Node is single valued. First see if the index expression matches
5430 this node and then check our children, if any. */
5432 do_jump_if_equal (index
, expand_expr (node
->low
, NULL_RTX
, VOIDmode
, 0),
5433 label_rtx (node
->code_label
), unsignedp
);
5435 if (node
->right
!= 0 && node
->left
!= 0)
5437 /* This node has children on both sides.
5438 Dispatch to one side or the other
5439 by comparing the index value with this node's value.
5440 If one subtree is bounded, check that one first,
5441 so we can avoid real branches in the tree. */
5443 if (node_is_bounded (node
->right
, index_type
))
5445 emit_cmp_insn (index
, expand_expr (node
->high
, NULL_RTX
,
5447 GT
, NULL_RTX
, mode
, unsignedp
, 0);
5449 emit_jump_insn ((*gen_bgt_pat
) (label_rtx (node
->right
->code_label
)));
5450 emit_case_nodes (index
, node
->left
, default_label
, index_type
);
5453 else if (node_is_bounded (node
->left
, index_type
))
5455 emit_cmp_insn (index
, expand_expr (node
->high
, NULL_RTX
,
5457 LT
, NULL_RTX
, mode
, unsignedp
, 0);
5458 emit_jump_insn ((*gen_blt_pat
) (label_rtx (node
->left
->code_label
)));
5459 emit_case_nodes (index
, node
->right
, default_label
, index_type
);
5464 /* Neither node is bounded. First distinguish the two sides;
5465 then emit the code for one side at a time. */
5468 = build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
5470 /* See if the value is on the right. */
5471 emit_cmp_insn (index
, expand_expr (node
->high
, NULL_RTX
,
5473 GT
, NULL_RTX
, mode
, unsignedp
, 0);
5474 emit_jump_insn ((*gen_bgt_pat
) (label_rtx (test_label
)));
5476 /* Value must be on the left.
5477 Handle the left-hand subtree. */
5478 emit_case_nodes (index
, node
->left
, default_label
, index_type
);
5479 /* If left-hand subtree does nothing,
5481 emit_jump_if_reachable (default_label
);
5483 /* Code branches here for the right-hand subtree. */
5484 expand_label (test_label
);
5485 emit_case_nodes (index
, node
->right
, default_label
, index_type
);
5489 else if (node
->right
!= 0 && node
->left
== 0)
5491 /* Here we have a right child but no left so we issue conditional
5492 branch to default and process the right child.
5494 Omit the conditional branch to default if we it avoid only one
5495 right child; it costs too much space to save so little time. */
5497 if (node
->right
->right
|| node
->right
->left
5498 || !tree_int_cst_equal (node
->right
->low
, node
->right
->high
))
5500 if (!node_has_low_bound (node
, index_type
))
5502 emit_cmp_insn (index
, expand_expr (node
->high
, NULL_RTX
,
5504 LT
, NULL_RTX
, mode
, unsignedp
, 0);
5505 emit_jump_insn ((*gen_blt_pat
) (default_label
));
5508 emit_case_nodes (index
, node
->right
, default_label
, index_type
);
5511 /* We cannot process node->right normally
5512 since we haven't ruled out the numbers less than
5513 this node's value. So handle node->right explicitly. */
5514 do_jump_if_equal (index
,
5515 expand_expr (node
->right
->low
, NULL_RTX
,
5517 label_rtx (node
->right
->code_label
), unsignedp
);
5520 else if (node
->right
== 0 && node
->left
!= 0)
5522 /* Just one subtree, on the left. */
5524 #if 0 /* The following code and comment were formerly part
5525 of the condition here, but they didn't work
5526 and I don't understand what the idea was. -- rms. */
5527 /* If our "most probable entry" is less probable
5528 than the default label, emit a jump to
5529 the default label using condition codes
5530 already lying around. With no right branch,
5531 a branch-greater-than will get us to the default
5534 && cost_table
[TREE_INT_CST_LOW (node
->high
)] < 12)
5537 if (node
->left
->left
|| node
->left
->right
5538 || !tree_int_cst_equal (node
->left
->low
, node
->left
->high
))
5540 if (!node_has_high_bound (node
, index_type
))
5542 emit_cmp_insn (index
, expand_expr (node
->high
, NULL_RTX
,
5544 GT
, NULL_RTX
, mode
, unsignedp
, 0);
5545 emit_jump_insn ((*gen_bgt_pat
) (default_label
));
5548 emit_case_nodes (index
, node
->left
, default_label
, index_type
);
5551 /* We cannot process node->left normally
5552 since we haven't ruled out the numbers less than
5553 this node's value. So handle node->left explicitly. */
5554 do_jump_if_equal (index
,
5555 expand_expr (node
->left
->low
, NULL_RTX
,
5557 label_rtx (node
->left
->code_label
), unsignedp
);
5562 /* Node is a range. These cases are very similar to those for a single
5563 value, except that we do not start by testing whether this node
5564 is the one to branch to. */
5566 if (node
->right
!= 0 && node
->left
!= 0)
5568 /* Node has subtrees on both sides.
5569 If the right-hand subtree is bounded,
5570 test for it first, since we can go straight there.
5571 Otherwise, we need to make a branch in the control structure,
5572 then handle the two subtrees. */
5573 tree test_label
= 0;
5575 emit_cmp_insn (index
, expand_expr (node
->high
, NULL_RTX
,
5577 GT
, NULL_RTX
, mode
, unsignedp
, 0);
5579 if (node_is_bounded (node
->right
, index_type
))
5580 /* Right hand node is fully bounded so we can eliminate any
5581 testing and branch directly to the target code. */
5582 emit_jump_insn ((*gen_bgt_pat
) (label_rtx (node
->right
->code_label
)));
5585 /* Right hand node requires testing.
5586 Branch to a label where we will handle it later. */
5588 test_label
= build_decl (LABEL_DECL
, NULL_TREE
, NULL_TREE
);
5589 emit_jump_insn ((*gen_bgt_pat
) (label_rtx (test_label
)));
5592 /* Value belongs to this node or to the left-hand subtree. */
5594 emit_cmp_insn (index
, expand_expr (node
->low
, NULL_RTX
, VOIDmode
, 0),
5595 GE
, NULL_RTX
, mode
, unsignedp
, 0);
5596 emit_jump_insn ((*gen_bge_pat
) (label_rtx (node
->code_label
)));
5598 /* Handle the left-hand subtree. */
5599 emit_case_nodes (index
, node
->left
, default_label
, index_type
);
5601 /* If right node had to be handled later, do that now. */
5605 /* If the left-hand subtree fell through,
5606 don't let it fall into the right-hand subtree. */
5607 emit_jump_if_reachable (default_label
);
5609 expand_label (test_label
);
5610 emit_case_nodes (index
, node
->right
, default_label
, index_type
);
5614 else if (node
->right
!= 0 && node
->left
== 0)
5616 /* Deal with values to the left of this node,
5617 if they are possible. */
5618 if (!node_has_low_bound (node
, index_type
))
5620 emit_cmp_insn (index
, expand_expr (node
->low
, NULL_RTX
,
5622 LT
, NULL_RTX
, mode
, unsignedp
, 0);
5623 emit_jump_insn ((*gen_blt_pat
) (default_label
));
5626 /* Value belongs to this node or to the right-hand subtree. */
5628 emit_cmp_insn (index
, expand_expr (node
->high
, NULL_RTX
,
5630 LE
, NULL_RTX
, mode
, unsignedp
, 0);
5631 emit_jump_insn ((*gen_ble_pat
) (label_rtx (node
->code_label
)));
5633 emit_case_nodes (index
, node
->right
, default_label
, index_type
);
5636 else if (node
->right
== 0 && node
->left
!= 0)
5638 /* Deal with values to the right of this node,
5639 if they are possible. */
5640 if (!node_has_high_bound (node
, index_type
))
5642 emit_cmp_insn (index
, expand_expr (node
->high
, NULL_RTX
,
5644 GT
, NULL_RTX
, mode
, unsignedp
, 0);
5645 emit_jump_insn ((*gen_bgt_pat
) (default_label
));
5648 /* Value belongs to this node or to the left-hand subtree. */
5650 emit_cmp_insn (index
, expand_expr (node
->low
, NULL_RTX
, VOIDmode
, 0),
5651 GE
, NULL_RTX
, mode
, unsignedp
, 0);
5652 emit_jump_insn ((*gen_bge_pat
) (label_rtx (node
->code_label
)));
5654 emit_case_nodes (index
, node
->left
, default_label
, index_type
);
5659 /* Node has no children so we check low and high bounds to remove
5660 redundant tests. Only one of the bounds can exist,
5661 since otherwise this node is bounded--a case tested already. */
5663 if (!node_has_high_bound (node
, index_type
))
5665 emit_cmp_insn (index
, expand_expr (node
->high
, NULL_RTX
,
5667 GT
, NULL_RTX
, mode
, unsignedp
, 0);
5668 emit_jump_insn ((*gen_bgt_pat
) (default_label
));
5671 if (!node_has_low_bound (node
, index_type
))
5673 emit_cmp_insn (index
, expand_expr (node
->low
, NULL_RTX
,
5675 LT
, NULL_RTX
, mode
, unsignedp
, 0);
5676 emit_jump_insn ((*gen_blt_pat
) (default_label
));
5679 emit_jump (label_rtx (node
->code_label
));
5684 /* These routines are used by the loop unrolling code. They copy BLOCK trees
5685 so that the debugging info will be correct for the unrolled loop. */
5687 /* Indexed by block number, contains a pointer to the N'th block node. */
5689 static tree
*block_vector
;
5692 find_loop_tree_blocks ()
5694 tree block
= DECL_INITIAL (current_function_decl
);
5696 block_vector
= identify_blocks (block
, get_insns ());
5700 unroll_block_trees ()
5702 tree block
= DECL_INITIAL (current_function_decl
);
5704 reorder_blocks (block_vector
, block
, get_insns ());