3 * File name: ir/st/exc.c
4 * Purpose: Helper functions for jack exceptions.
5 * Author: Florian Liekweg
9 * Copyright: (c) 2002-2003 Universität Karlsruhe
10 * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
17 Helper functions for exceptions
24 static char* exc_strings [] = {
25 "Invalid", /* invalid */
26 "Normal", /* normal */
27 "Entry", /* entry to region */
28 "Exit", /* exit of region */
29 "Handler", /* entry to handler */
35 Return true iff (block b is a handler entry AND a dominates b) OR
36 (b has a CFG successor that is both a handler entry AND is dominated
39 static bool has_handler (ir_graph *graph, ir_node *b, ir_node *a)
42 int n = get_irn_n_outs (b);
45 assert (0 && "Wrongly implemented");
46 /* must check for _immediate_ dominance !!! */
48 if (is_handler_entry (graph, b) && dominates (graph, a, b))
51 for (i = 0; i < n; i ++)
53 succ = get_irn_out (b, i);
55 if (has_handler (graph, succ, a))
63 Return true iff the given node represents an exception jump
65 static bool is_exc_jmp (ir_node *node)
67 ir_op *op = get_irn_op (node);
69 /* Proj_X (Load), Proj_X (Sto), Proj_X (Div_Int),
70 Proj_X (Raise), Proj_X (Call), Proj_X (Alloc) */
73 op = get_irn_op (get_Proj_pred (node));
75 assert ((is_fragile_op(get_Proj_pred(node))) &&
76 (op != op_Bad) /*&& (op != op_Unknown)*/ &&
77 (get_irn_mode(node) == mode_X));/* Check for proper Proj attr */
87 Return true iff the given node represents a normal cfg jump
90 static bool is_cfg_jmp (ir_node *node)
92 ir_op *op = get_irn_op (node);
96 op = get_irn_op (get_Proj_pred (node));
98 /* Proj_X (Proj_Cmp (Cond)) */
100 return (true); /* check for op == op_Cmp and op == op_Cond */
107 void set_Block_exc(ir_node *n, exc_t exc) {
110 exc_t get_Block_exc(ir_node *n) {
115 /* handler handling for Blocks */
117 set_Block_handler (ir_node *block, ir_node *handler) {
118 assert (is_Block(block));
119 assert (is_Block(handler));
123 get_Block_handler (ir_node *block) {
124 assert (is_Block(block));
128 /* handler handling for Nodes */
130 set_Node_handler (ir_node *node, ir_node *handler) {
135 get_Node_handler (ir_node *node) {
141 Return true iff a new exception region must be left upon entry of this block.
143 If all CFG preds of this block are exception jumps, then we must
146 bool is_handler_entry (ir_graph *graph, ir_node *block)
148 bool is_entry = true;
150 int n = get_irn_arity (block);
152 if (exc_invalid == get_Block_exc (block))
154 for (i = 0; (i < n) && (is_entry == true); i ++)
155 if (is_exc_jmp (get_irn_n (block, i)))
160 if (true == is_entry)
161 set_Block_exc (block, exc_handler);
164 return (exc_handler == get_Block_exc (block));
168 Return true iff a new exception region must be started upon entry of this block.
170 If this block immediately dominates a handler entry, we must return true.
172 bool is_region_entry (ir_graph *graph, ir_node *block)
174 assert (0 && "Not implemented");
176 if (exc_invalid == get_Block_exc (block))
179 int n = get_irn_n_outs (block);
182 bool no_handler = true;
184 for (i = 0; (i < n) && (no_handler == true); i ++)
186 succ = get_irn_out (block, i);
188 if (has_handler (graph, succ, block))
192 if (false == no_handler)
193 set_Block_exc (block, exc_region);
196 return (exc_region == get_Block_exc (block));
202 Return true iff this block is part of handler code.
204 If this block is dominated by a block for which {@link
205 is_handler_entry} is true, then this block is part of the handler.
207 bool is_handler_block (ir_graph *graph, ir_node *block)
209 assert (0 && "Not implemented");
211 if (exc_invalid == get_Block_exc (block))
213 bool no_handler = true;
214 dom_env_t *env = get_dom_env (graph, block);
215 int block_index = env->index_a;
216 bs_t block_mask = 0x00000001 << block_index;
217 int n_blocks = env->dt->n_blocks;
220 for (i = 0; (i < n_blocks) && (no_handler == true); i ++)
221 if (0 != (env->dt->masks [i] & block_mask)) /* if dominator */
222 if (is_handler_entry (graph, env->dt->blocks [i])) /* is handler entry */
225 delete_dom_env (env);
227 if (false == no_handler)
228 set_Block_exc (block, exc_handler);
231 return (exc_handler == get_Block_exc (block));
235 Convert a value of type exc_t to a descriptive string.
236 Returns a reference to a statically allocated, constant string.
239 const char *exc_to_string (exc_t exc)
241 int exc_val = (int) exc;
243 assert ((0 <= (int) exc_val) && (exc_val < (int) exc_max));
245 return (exc_strings [exc_val]);