ir_node *eh_new_Call(ir_node * irn_ptr, int arity, ir_node *const * in, ir_type* type)
{
ir_node *jmp = new_Jmp();
ir_node *call_block = new_immBlock();
add_immBlock_pred(call_block, jmp);
mature_immBlock(call_block);
set_cur_block(call_block);
ir_node *cur_mem = get_store();
ir_node *call = new_Call(cur_mem, irn_ptr, arity, in, type);
ir_set_throws_exception(call, 1);
ir_node *proj_except = new_Proj(call, mode_X, pn_Call_X_except);
cur_mem = new_Proj(call, mode_M, pn_Call_M);
set_store(cur_mem);
add_immBlock_pred(top->handler_header_block, proj_except);
ir_node *proj_regular = new_Proj(call, mode_X, pn_Call_X_regular);
ir_node *new_block = new_immBlock();
add_immBlock_pred(new_block, proj_regular);
mature_immBlock(new_block);
set_cur_block(new_block);
top->used = true;
return call;
}
void eh_add_handler(ir_type *catch_type, ir_node *catch_block)
{
assert (top->prev); //e.g., not the default handler
assert (top->cur_block && "Cannot add handler after an catch all was registered");
ir_node *saved_block = get_cur_block();
set_cur_block(top->cur_block);
if (catch_type) {
ir_node *cur_mem = get_store();
ir_node *instanceof = new_InstanceOf(cur_mem, top->exception_object, catch_type);
cur_mem = new_Proj(instanceof, mode_M, pn_InstanceOf_M);
ir_node *result = new_Proj(instanceof, mode_b, pn_InstanceOf_res);
ir_node *cond = new_Cond(result);
ir_node *proj_match = new_Proj(cond, mode_X, pn_Cond_true);
add_immBlock_pred(catch_block, proj_match);
// will be matured elsewhere
ir_node *proj_go_on = new_Proj(cond, mode_X, pn_Cond_false);
ir_node *new_block = new_immBlock();
add_immBlock_pred(new_block, proj_go_on);
mature_immBlock(new_block);
top->cur_block = new_block;
set_store(cur_mem);
} else {
ir_node *jmp = new_Jmp();
add_immBlock_pred(catch_block, jmp);
top->cur_block = NULL;
}
set_cur_block(saved_block);
}
void eh_end_method(void)
{
assert (! top->prev); // the explicit stuff is gone, we have the default handler
if (top->used) {
mature_immBlock(top->handler_header_block);
assert (top->cur_block); // would fail if front end adds an catch all handler to the default handler
ir_node *saved_block = get_cur_block();
set_cur_block(top->cur_block);
ir_node *cur_mem = get_store();
ir_node *raise = new_Raise(cur_mem, top->exception_object);
ir_node *proj = new_Proj(raise, mode_X, pn_Raise_X);
cur_mem = new_Proj(raise, mode_M, pn_Raise_M);
set_store(cur_mem);
ir_node *end_block = get_irg_end_block(get_current_ir_graph());
add_immBlock_pred(end_block, proj);
set_cur_block(saved_block);
}
obstack_free(&lpads, top);
top = NULL;
}
/**
* mature all immature Blocks.
*/
static void finish_block(ir_node *block, void *env)
{
(void)env;
ir_graph *irg = get_irn_irg(block);
if (block != get_irg_start_block(irg))
mature_immBlock(block);
}
void eh_pop_lpad(void)
{
mature_immBlock(top->handler_header_block);
//assert (top->used && "No exception is ever thrown");
lpad_t *prev = top->prev;
assert (prev);
if (top->cur_block) {
// the popped lpad didn't have a catch all handler and therefore is still "open".
ir_node *saved_block = get_cur_block();
set_cur_block(top->cur_block);
ir_node *jmp = new_Jmp();
add_immBlock_pred(prev->handler_header_block, jmp);
set_cur_block(saved_block);
}
obstack_free(&lpads, top);
top = prev;
}
ir_graph *new_const_code_irg(void)
{
ir_graph *const res = new_r_ir_graph(NULL, 0);
mature_immBlock(get_irg_end_block(res));
/* There is no Start node in the const_code_irg */
set_irg_start(res, new_r_Bad(res, mode_T));
set_irg_frame(res, new_r_Bad(res, mode_BAD));
set_irg_args(res, new_r_Bad(res, mode_T));
set_irg_initial_mem(res, new_r_Bad(res, mode_M));
set_r_store(res, get_irg_no_mem(res));
/* Set the visited flag high enough that the blocks will never be
* visited. */
ir_node *const body_block = get_r_cur_block(res);
set_irn_visited(body_block, -1);
set_Block_block_visited(body_block, -1);
ir_node *const start_block = get_irg_start_block(res);
set_Block_block_visited(start_block, -1);
set_irn_visited(start_block, -1);
return res;
}
