cleanup: Remove several uses of current_ir_graph.

diff --git a/ir/ana/ircfscc.c b/ir/ana/ircfscc.c
index a5a53b7..e7075c8 100644 (file)
--- a/ir/ana/ircfscc.c
+++ b/ir/ana/ircfscc.c
@@ -618,7 +618,6 @@ static void cfscc(ir_node *n)
 
 int construct_cf_backedges(ir_graph *irg)
 {
-       ir_graph *rem = current_ir_graph;
        ir_loop *head_rem;
        ir_node *end = get_irg_end(irg);
        struct obstack temp;
@@ -626,7 +625,6 @@ int construct_cf_backedges(ir_graph *irg)
 
        max_loop_depth = 0;
 
-       current_ir_graph   = irg;
        outermost_ir_graph = irg;
 
        obstack_init(&temp);
@@ -653,7 +651,6 @@ int construct_cf_backedges(ir_graph *irg)
        set_irg_loop(irg, current_loop);
        add_irg_properties(irg, IR_GRAPH_PROPERTY_CONSISTENT_LOOPINFO);
 
-       current_ir_graph = rem;
        return max_loop_depth;
 }
 

diff --git a/ir/be/amd64/amd64_transform.c b/ir/be/amd64/amd64_transform.c
index fbf32c9..97a16e7 100644 (file)
--- a/ir/be/amd64/amd64_transform.c
+++ b/ir/be/amd64/amd64_transform.c
@@ -470,12 +470,10 @@ static ir_node *gen_Proj_Load(ir_node *node)
  */
 static ir_node *gen_Proj(ir_node *node)
 {
-       ir_graph *irg  = current_ir_graph;
        dbg_info *dbgi = get_irn_dbg_info(node);
        ir_node  *pred = get_Proj_pred(node);
        long     proj  = get_Proj_proj(node);
 
-       (void) irg;
     (void) dbgi;
 
        if (is_Store(pred)) {
@@ -498,6 +496,7 @@ static ir_node *gen_Proj(ir_node *node)
 #endif
        } else if (is_Start(pred)) {
 #if 0
+               ir_graph *const irg = get_irn_irg(node);
                if (node == get_irg_anchor(irg, anchor_tls)) {
                        return gen_Proj_tls(node);
                }

diff --git a/ir/be/arm/arm_transform.c b/ir/be/arm/arm_transform.c
index 36f7c96..056de03 100644 (file)
--- a/ir/be/arm/arm_transform.c
+++ b/ir/be/arm/arm_transform.c
@@ -1158,7 +1158,7 @@ static ir_node *ints_to_double(dbg_info *dbgi, ir_node *block, ir_node *node0,
        /* the good way to do this would be to use the stm (store multiple)
         * instructions, since our input is nearly always 2 consecutive 32bit
         * registers... */
-       ir_graph *irg   = current_ir_graph;
+       ir_graph *irg   = get_Block_irg(block);
        ir_node  *stack = get_irg_frame(irg);
        ir_node  *nomem = get_irg_no_mem(irg);
        ir_node  *str0  = new_bd_arm_Str(dbgi, block, stack, node0, nomem, mode_gp,
@@ -1179,7 +1179,7 @@ static ir_node *ints_to_double(dbg_info *dbgi, ir_node *block, ir_node *node0,
 
 static ir_node *int_to_float(dbg_info *dbgi, ir_node *block, ir_node *node)
 {
-       ir_graph *irg   = current_ir_graph;
+       ir_graph *irg   = get_Block_irg(block);
        ir_node  *stack = get_irg_frame(irg);
        ir_node  *nomem = get_irg_no_mem(irg);
        ir_node  *str   = new_bd_arm_Str(dbgi, block, stack, node, nomem, mode_gp,
@@ -1195,7 +1195,7 @@ static ir_node *int_to_float(dbg_info *dbgi, ir_node *block, ir_node *node)
 
 static ir_node *float_to_int(dbg_info *dbgi, ir_node *block, ir_node *node)
 {
-       ir_graph *irg   = current_ir_graph;
+       ir_graph *irg   = get_Block_irg(block);
        ir_node  *stack = get_irg_frame(irg);
        ir_node  *nomem = get_irg_no_mem(irg);
        ir_node  *stf   = new_bd_arm_Stf(dbgi, block, stack, node, nomem, mode_F,
@@ -1212,7 +1212,7 @@ static ir_node *float_to_int(dbg_info *dbgi, ir_node *block, ir_node *node)
 static void double_to_ints(dbg_info *dbgi, ir_node *block, ir_node *node,
                            ir_node **out_value0, ir_node **out_value1)
 {
-       ir_graph *irg   = current_ir_graph;
+       ir_graph *irg   = get_Block_irg(block);
        ir_node  *stack = get_irg_frame(irg);
        ir_node  *nomem = get_irg_no_mem(irg);
        ir_node  *stf   = new_bd_arm_Stf(dbgi, block, stack, node, nomem, mode_D,
@@ -1426,7 +1426,8 @@ static ir_node *gen_Proj_Proj_Start(ir_node *node)
        long       pn          = get_Proj_proj(node);
        ir_node   *block       = get_nodes_block(node);
        ir_node   *new_block   = be_transform_node(block);
-       ir_entity *entity      = get_irg_entity(current_ir_graph);
+       ir_graph  *irg         = get_Block_irg(new_block);
+       ir_entity *entity      = get_irg_entity(irg);
        ir_type   *method_type = get_entity_type(entity);
        ir_type   *param_type  = get_method_param_type(method_type, pn);
        const reg_or_stackslot_t *param;
@@ -1447,12 +1448,9 @@ static ir_node *gen_Proj_Proj_Start(ir_node *node)
                        if (param->reg1 != NULL) {
                                value1 = be_prolog_get_reg_value(abihelper, param->reg1);
                        } else if (param->entity != NULL) {
-                               ir_graph *irg = get_irn_irg(node);
-                               ir_node  *fp  = get_irg_frame(irg);
-                               ir_node  *mem = be_prolog_get_memory(abihelper);
-                               ir_node  *ldr = new_bd_arm_Ldr(NULL, new_block, fp, mem,
-                                                              mode_gp, param->entity,
-                                                              0, 0, true);
+                               ir_node *const fp  = get_irg_frame(irg);
+                               ir_node *const mem = be_prolog_get_memory(abihelper);
+                               ir_node *const ldr = new_bd_arm_Ldr(NULL, new_block, fp, mem, mode_gp, param->entity, 0, 0, true);
                                value1 = new_r_Proj(ldr, mode_gp, pn_arm_Ldr_res);
                        }
 
@@ -1466,12 +1464,11 @@ static ir_node *gen_Proj_Proj_Start(ir_node *node)
                return value;
        } else {
                /* argument transmitted on stack */
-               ir_graph *irg  = get_irn_irg(node);
-               ir_node  *fp   = get_irg_frame(irg);
-               ir_node  *mem  = be_prolog_get_memory(abihelper);
-               ir_mode  *mode = get_type_mode(param->type);
-               ir_node  *load;
-               ir_node  *value;
+               ir_node *const fp   = get_irg_frame(irg);
+               ir_node *const mem  = be_prolog_get_memory(abihelper);
+               ir_mode *const mode = get_type_mode(param->type);
+               ir_node       *load;
+               ir_node       *value;
 
                if (mode_is_float(mode)) {
                        load  = new_bd_arm_Ldf(NULL, new_block, fp, mem, mode,

diff --git a/ir/be/bestack.c b/ir/be/bestack.c
index 5695517..07d4775 100644 (file)
--- a/ir/be/bestack.c
+++ b/ir/be/bestack.c
@@ -128,7 +128,7 @@ static void lower_outer_frame_sels(ir_node *sel, void *ctx)
                        dbg_info *dbgi = get_irn_dbg_info(sel);
                        ir_mode  *mode = get_irn_mode(sel);
                        ir_mode  *mode_UInt = get_reference_mode_unsigned_eq(mode);
-                       ir_node  *cnst = new_r_Const_long(current_ir_graph, mode_UInt, offset);
+                       ir_node  *cnst = new_r_Const_long(irg, mode_UInt, offset);
 
                        ptr = new_rd_Add(dbgi, bl, ptr, cnst, mode);
                }

diff --git a/ir/be/betranshlp.c b/ir/be/betranshlp.c
index dcf3ead..d4c102c 100644 (file)
--- a/ir/be/betranshlp.c
+++ b/ir/be/betranshlp.c
@@ -90,7 +90,7 @@ void be_duplicate_deps(ir_node *old_node, ir_node *new_node)
 ir_node *be_transform_phi(ir_node *node, const arch_register_req_t *req)
 {
        ir_node  *block = be_transform_node(get_nodes_block(node));
-       ir_graph *irg   = current_ir_graph;
+       ir_graph *irg   = get_Block_irg(block);
        dbg_info *dbgi  = get_irn_dbg_info(node);
 
        /* phi nodes allow loops, so we use the old arguments for now

diff --git a/ir/be/ia32/bearch_ia32.c b/ir/be/ia32/bearch_ia32.c
index d4a887d..72f0fc2 100644 (file)
--- a/ir/be/ia32/bearch_ia32.c
+++ b/ir/be/ia32/bearch_ia32.c
@@ -585,7 +585,7 @@ ir_node *ia32_turn_back_am(ir_node *node)
                default:
                        panic("Unknown AM type");
        }
-       noreg = ia32_new_NoReg_gp(current_ir_graph);
+       noreg = ia32_new_NoReg_gp(irg);
        set_irn_n(node, n_ia32_base,  noreg);
        set_irn_n(node, n_ia32_index, noreg);
        set_ia32_am_offs_int(node, 0);

diff --git a/ir/be/ia32/ia32_emitter.c b/ir/be/ia32/ia32_emitter.c
index 4624114..febbff4 100644 (file)
--- a/ir/be/ia32/ia32_emitter.c
+++ b/ir/be/ia32/ia32_emitter.c
@@ -1515,7 +1515,7 @@ static void ia32_emit_node(ir_node *node)
                (*func) (node);
        } else {
                emit_Nothing(node);
-               ir_fprintf(stderr, "Error: No emit handler for node %+F (%+G, graph %+F)\n", node, node, current_ir_graph);
+               ir_fprintf(stderr, "Error: No emit handler for node %+F (%+G, graph %+F)\n", node, node, get_irn_irg(node));
                abort();
        }
 
@@ -1597,9 +1597,7 @@ static int should_align_block(const ir_node *block)
  */
 static void ia32_emit_block_header(ir_node *block)
 {
-       ir_graph     *irg        = current_ir_graph;
-       int           need_label = block_needs_label(block);
-
+       ir_graph *const irg = get_Block_irg(block);
        if (block == get_irg_end_block(irg))
                return;
 
@@ -1629,6 +1627,7 @@ static void ia32_emit_block_header(ir_node *block)
                }
        }
 
+       int const need_label = block_needs_label(block);
        be_gas_begin_block(block, need_label);
 }
 

diff --git a/ir/be/ia32/ia32_optimize.c b/ir/be/ia32/ia32_optimize.c
index 613eee6..d86197c 100644 (file)
--- a/ir/be/ia32/ia32_optimize.c
+++ b/ir/be/ia32/ia32_optimize.c
@@ -166,10 +166,10 @@ static void peephole_ia32_Cmp(ir_node *const node)
                return;
 
        dbgi         = get_irn_dbg_info(node);
-       irg          = get_irn_irg(node);
        block        = get_nodes_block(node);
+       irg          = get_Block_irg(block);
        noreg        = ia32_new_NoReg_gp(irg);
-       nomem        = get_irg_no_mem(current_ir_graph);
+       nomem        = get_irg_no_mem(irg);
        op           = get_irn_n(node, n_ia32_Cmp_left);
        attr         = get_ia32_attr(node);
        ins_permuted = attr->data.ins_permuted;
@@ -647,7 +647,7 @@ static void peephole_store_incsp(ir_node *store)
 
        push  = new_bd_ia32_Push(dbgi, block, noreg, noreg, mem,
 
-       create_push(dbgi, current_ir_graph, block, am_base, store);
+       create_push(dbgi, block, am_base, store);
 }
 #endif
 

diff --git a/ir/be/ia32/ia32_transform.c b/ir/be/ia32/ia32_transform.c
index a314bd9..58f20b4 100644 (file)
--- a/ir/be/ia32/ia32_transform.c
+++ b/ir/be/ia32/ia32_transform.c
@@ -3967,15 +3967,15 @@ static ir_node *gen_be_FrameAddr(ir_node *node)
  */
 static ir_node *gen_be_Return(ir_node *node)
 {
-       ir_graph  *irg         = current_ir_graph;
        ir_node   *ret_val     = get_irn_n(node, n_be_Return_val);
        ir_node   *ret_mem     = get_irn_n(node, n_be_Return_mem);
        ir_node   *new_ret_val = be_transform_node(ret_val);
        ir_node   *new_ret_mem = be_transform_node(ret_mem);
-       ir_entity *ent         = get_irg_entity(irg);
-       ir_type   *tp          = get_entity_type(ent);
        dbg_info  *dbgi        = get_irn_dbg_info(node);
        ir_node   *block       = be_transform_node(get_nodes_block(node));
+       ir_graph  *irg         = get_Block_irg(block);
+       ir_entity *ent         = get_irg_entity(irg);
+       ir_type   *tp          = get_entity_type(ent);
        ir_type   *res_type;
        ir_mode   *mode;
        ir_node   *frame;
@@ -4223,7 +4223,7 @@ static ir_node *gen_ia32_l_LLtoFloat(ir_node *node)
 {
        ir_node  *src_block    = get_nodes_block(node);
        ir_node  *block        = be_transform_node(src_block);
-       ir_graph *irg          = current_ir_graph;
+       ir_graph *irg          = get_Block_irg(block);
        dbg_info *dbgi         = get_irn_dbg_info(node);
        ir_node  *frame        = get_irg_frame(irg);
        ir_node  *val_low      = get_irn_n(node, n_ia32_l_LLtoFloat_val_low);
@@ -4295,7 +4295,7 @@ static ir_node *gen_ia32_l_LLtoFloat(ir_node *node)
                am.mem_proj           = nomem;
                am.op_type            = ia32_AddrModeS;
                am.new_op1            = res;
-               am.new_op2            = ia32_new_NoReg_fp(current_ir_graph);
+               am.new_op2            = ia32_new_NoReg_fp(irg);
                am.pinned             = op_pin_state_floats;
                am.commutative        = 1;
                am.ins_permuted       = false;
@@ -4717,7 +4717,7 @@ static ir_node *gen_be_Call(ir_node *node)
                ir_mode *const res_mode = get_type_mode(res_type);
 
                if (res_mode != NULL && mode_is_float(res_mode)) {
-                       ir_graph        *irg      = current_ir_graph;
+                       ir_graph        *irg      = get_Block_irg(block);
                        ia32_irg_data_t *irg_data = ia32_get_irg_data(irg);
                        irg_data->do_x87_sim = 1;
                }
@@ -5703,7 +5703,7 @@ static void register_transformers(void)
 static void ia32_pretransform_node(void)
 {
        ir_graph        *irg      = current_ir_graph;
-       ia32_irg_data_t *irg_data = ia32_get_irg_data(current_ir_graph);
+       ia32_irg_data_t *irg_data = ia32_get_irg_data(irg);
 
        irg_data->noreg_gp       = be_pre_transform_node(irg_data->noreg_gp);
        irg_data->noreg_fp       = be_pre_transform_node(irg_data->noreg_fp);

diff --git a/ir/be/sparc/sparc_transform.c b/ir/be/sparc/sparc_transform.c
index e263aad..75fcf55 100644 (file)
--- a/ir/be/sparc/sparc_transform.c
+++ b/ir/be/sparc/sparc_transform.c
@@ -1014,9 +1014,9 @@ static ir_node *gen_Minus(ir_node *node)
 /**
  * Create an entity for a given (floating point) tarval
  */
-static ir_entity *create_float_const_entity(ir_tarval *tv)
+static ir_entity *create_float_const_entity(ir_graph *const irg, ir_tarval *const tv)
 {
-       const arch_env_t *arch_env = be_get_irg_arch_env(current_ir_graph);
+       const arch_env_t *arch_env = be_get_irg_arch_env(irg);
        sparc_isa_t      *isa      = (sparc_isa_t*) arch_env;
        ir_entity        *entity   = pmap_get(ir_entity, isa->constants, tv);
        ir_initializer_t *initializer;
@@ -1043,9 +1043,10 @@ static ir_entity *create_float_const_entity(ir_tarval *tv)
 
 static ir_node *gen_float_const(dbg_info *dbgi, ir_node *block, ir_tarval *tv)
 {
-       ir_entity *entity = create_float_const_entity(tv);
+       ir_graph  *irg    = get_Block_irg(block);
+       ir_entity *entity = create_float_const_entity(irg, tv);
        ir_node   *hi     = new_bd_sparc_SetHi(dbgi, block, entity, 0);
-       ir_node   *mem    = get_irg_no_mem(current_ir_graph);
+       ir_node   *mem    = get_irg_no_mem(irg);
        ir_mode   *mode   = get_tarval_mode(tv);
        ir_node   *new_op
                = create_ldf(dbgi, block, hi, mem, mode, entity, 0, false);
@@ -1121,7 +1122,7 @@ static ir_node *gen_Switch(ir_node *node)
        idx = new_bd_sparc_Sll_imm(dbgi, new_block, new_selector, NULL, 2);
        /* load from jumptable */
        load = new_bd_sparc_Ld_reg(dbgi, new_block, table_address, idx,
-                                  get_irg_no_mem(current_ir_graph),
+                                  get_irg_no_mem(irg),
                                   mode_gp);
        address = new_r_Proj(load, mode_gp, pn_sparc_Ld_res);
 
@@ -1602,7 +1603,7 @@ static ir_node *gen_Return(ir_node *node)
 static ir_node *bitcast_int_to_float(dbg_info *dbgi, ir_node *block,
                                      ir_node *value0, ir_node *value1)
 {
-       ir_graph *irg   = current_ir_graph;
+       ir_graph *irg   = get_Block_irg(block);
        ir_node  *sp    = get_irg_frame(irg);
        ir_node  *nomem = get_irg_no_mem(irg);
        ir_node  *st    = new_bd_sparc_St_imm(dbgi, block, value0, sp, nomem,
@@ -1657,7 +1658,7 @@ static void bitcast_float_to_int(dbg_info *dbgi, ir_node *block,
                        result[1] = NULL;
                }
        } else {
-               ir_graph *irg   = current_ir_graph;
+               ir_graph *irg   = get_Block_irg(block);
                ir_node  *stack = get_irg_frame(irg);
                ir_node  *nomem = get_irg_no_mem(irg);
                ir_node  *new_value = be_transform_node(value);

diff --git a/ir/ir/irssacons.c b/ir/ir/irssacons.c
index 794b0fc..ae98067 100644 (file)
--- a/ir/ir/irssacons.c
+++ b/ir/ir/irssacons.c
@@ -39,8 +39,9 @@ static void (*ssa_cons_walker)(ir_graph *, irg_walk_func *, irg_walk_func *, voi
  */
 static void prepare_blocks(ir_node *block, void *env)
 {
-       unsigned        n_loc = current_ir_graph->n_loc;
-       struct obstack *obst  = current_ir_graph->obst;
+       ir_graph       *const irg   = get_Block_irg(block);
+       unsigned        const n_loc = irg->n_loc;
+       struct obstack *const obst  = irg->obst;
        (void)env;
        /* reset mature flag */
        set_Block_matured(block, 0);

diff --git a/ir/lower/lower_hl.c b/ir/lower/lower_hl.c
index 88da2fd..39d0593 100644 (file)
--- a/ir/lower/lower_hl.c
+++ b/ir/lower/lower_hl.c
@@ -111,7 +111,6 @@ static void lower_sel(ir_node *sel)
                                lb = get_array_lower_bound(arr_ty, dim);
                                ub = get_array_upper_bound(arr_ty, dim);
 
-                               assert(irg == current_ir_graph);
                                if (! is_Unknown(lb))
                                        lb = new_rd_Conv(dbg, bl, copy_const_value(get_irn_dbg_info(sel), lb, bl), mode_Int);
                                else

diff --git a/ir/lower/lower_intrinsics.c b/ir/lower/lower_intrinsics.c
index b4c7b0a..66b6196 100644 (file)
--- a/ir/lower/lower_intrinsics.c
+++ b/ir/lower/lower_intrinsics.c
@@ -259,7 +259,8 @@ int i_mapper_bswap(ir_node *call, void *ctx)
        ir_node *irn;
        (void) ctx;
 
-       irn = new_rd_Builtin(dbg, block, get_irg_no_mem(current_ir_graph), 1, &op, ir_bk_bswap, tp);
+       ir_graph *const irg = get_Block_irg(block);
+       irn = new_rd_Builtin(dbg, block, get_irg_no_mem(irg), 1, &op, ir_bk_bswap, tp);
        set_irn_pinned(irn, op_pin_state_floats);
        irn = new_r_Proj(irn, get_irn_mode(op), pn_Builtin_max+1);
        replace_call(irn, call, mem, NULL, NULL);
@@ -1110,11 +1111,10 @@ int i_mapper_RuntimeCall(ir_node *node, runtime_rt *rt)
        int i, j, arity, first, n_param, n_res;
        long n_proj;
        ir_type *mtp;
-       ir_node *mem, *bl, *call, *addr, *res_proj;
+       ir_node *mem, *call, *addr, *res_proj;
        ir_node **in;
        bool     throws_exception;
        ir_op   *op;
-       ir_graph *irg;
        symconst_symbol sym;
        ir_mode *mode = get_irn_mode(node);
 
@@ -1133,7 +1133,8 @@ int i_mapper_RuntimeCall(ir_node *node, runtime_rt *rt)
 
        mtp     = get_entity_type(rt->ent);
        n_param = get_method_n_params(mtp);
-       irg     = current_ir_graph;
+       ir_node  *const bl  = get_nodes_block(node);
+       ir_graph *const irg = get_Block_irg(bl);
 
        mem = get_irn_n(node, 0);
        if (get_irn_mode(mem) != mode_M) {
@@ -1177,7 +1178,6 @@ int i_mapper_RuntimeCall(ir_node *node, runtime_rt *rt)
        }
 
        /* ok, when we are here, the number of predecessors match as well as the parameter modes */
-       bl = get_nodes_block(node);
        op = get_irn_op(node);
 
        in = NULL;

diff --git a/ir/opt/combo.c b/ir/opt/combo.c
index 9ea296b..530445e 100644 (file)
--- a/ir/opt/combo.c
+++ b/ir/opt/combo.c
@@ -1915,7 +1915,8 @@ static void compute_Block(node_t *node)
        int     i;
        ir_node *block = node->node;
 
-       if (block == get_irg_start_block(current_ir_graph) || get_Block_entity(block) != NULL) {
+       ir_graph *const irg = get_Block_irg(block);
+       if (block == get_irg_start_block(irg) || get_Block_entity(block) != NULL) {
                /* start block and labelled blocks are always reachable */
                node->type.tv = tarval_reachable;
                return;
@@ -3041,7 +3042,8 @@ static void apply_cf(ir_node *block, void *ctx)
                        }
                }
 
-               if (block == get_irg_end_block(current_ir_graph)) {
+               ir_graph *const irg = get_Block_irg(block);
+               if (block == get_irg_end_block(irg)) {
                        /* Analysis found out that the end block is unreachable,
                         * hence we remove all its control flow predecessors. */
                        set_irn_in(block, 0, NULL);

diff --git a/ir/opt/loop.c b/ir/opt/loop.c
index 4328ea8..389c44a 100644 (file)
--- a/ir/opt/loop.c
+++ b/ir/opt/loop.c
@@ -672,12 +672,11 @@ static void copy_walk(ir_node *node, walker_condition *walk_condition,
        int arity;
        ir_node *cp;
        ir_node **cpin;
-       ir_graph *irg = current_ir_graph;
 
        /**
         * break condition and cycle resolver, creating temporary node copies
         */
-       if (get_irn_visited(node) >= get_irg_visited(irg)) {
+       if (irn_visited(node)) {
                /* Here we rely on nodestate's copy being initialized with NULL */
                DB((dbg, LEVEL_5, "copy_walk: We have already visited %N\n", node));
                if (get_inversion_copy(node) == NULL) {

diff --git a/ir/opt/proc_cloning.c b/ir/opt/proc_cloning.c
index e8f6f1e..d61b233 100644 (file)
--- a/ir/opt/proc_cloning.c
+++ b/ir/opt/proc_cloning.c
@@ -267,10 +267,11 @@ static void set_preds(ir_node *irn, void *env)
        irn_copy = (ir_node*)get_irn_link(irn);
 
        if (is_Block(irn)) {
+               ir_graph *const irg = get_Block_irg(irn);
                for (i = get_Block_n_cfgpreds(irn) - 1; i >= 0; --i) {
                        pred = get_Block_cfgpred(irn, i);
                        /* "End" block must be handled extra, because it is not matured.*/
-                       if (get_irg_end_block(current_ir_graph) == irn)
+                       if (get_irg_end_block(irg) == irn)
                                add_immBlock_pred(get_irg_end_block(clone_irg), (ir_node*)get_irn_link(pred));
                        else
                                set_Block_cfgpred(irn_copy, i, (ir_node*)get_irn_link(pred));

diff --git a/ir/stat/dags.c b/ir/stat/dags.c
index 81cf08a..ff6f177 100644 (file)
--- a/ir/stat/dags.c
+++ b/ir/stat/dags.c
@@ -146,10 +146,9 @@ static void find_dag_roots(ir_node *node, void *env)
        block = get_nodes_block(node);
 
        /* ignore start end end blocks */
-       if (block == get_irg_start_block(current_ir_graph) ||
-               block == get_irg_end_block(current_ir_graph)) {
+       ir_graph *const irg = get_Block_irg(block);
+       if (block == get_irg_start_block(irg) || block == get_irg_end_block(irg))
                return;
-       }  /* if */
 
        /* Phi nodes always references nodes from "other" block */
        if (is_Phi(node)) {
@@ -222,10 +221,9 @@ static void connect_dags(ir_node *node, void *env)
        block = get_nodes_block(node);
 
        /* ignore start end end blocks */
-       if (block == get_irg_start_block(current_ir_graph) ||
-               block == get_irg_end_block(current_ir_graph)) {
+       ir_graph *const irg = get_Block_irg(block);
+       if (block == get_irg_start_block(irg) || block == get_irg_end_block(irg))
                return;
-       }  /* if */
 
        /* ignore Phi nodes */
        if (is_Phi(node))