forbid calls of new_XXX and new_d_XXX when not in phase_building (only new_r_XXX allowed)

[r28037]

include/libfirm/ircons.h

@@ -1150,7 +1150,7 @@ FIRM_API ir_node *new_rd_Block(dbg_info *db, ir_graph *irg, int arity, ir_node *
  * @param *irg   The IR graph the node belongs to.
  * @param *block The IR block the node belongs to.
  */
-FIRM_API ir_node *new_rd_Start(dbg_info *db, ir_graph *irg, ir_node *block);
+FIRM_API ir_node *new_rd_Start(dbg_info *db, ir_node *block);
 
 /** Constructor for a End node.
  *
@@ -1158,7 +1158,7 @@ FIRM_API ir_node *new_rd_Start(dbg_info *db, ir_graph *irg, ir_node *block);
  * @param *irg   The IR graph the node  belongs to.
  * @param *block The IR block the node belongs to.
  */
-FIRM_API ir_node *new_rd_End(dbg_info *db, ir_graph *irg, ir_node *block);
+FIRM_API ir_node *new_rd_End(dbg_info *db, ir_node *block);
 
 /** Constructor for a Jmp node.
  *
@@ -1977,17 +1977,15 @@ FIRM_API ir_node *new_r_Block(ir_graph *irg, int arity, ir_node *in[]);
 
 /** Constructor for a Start node.
  *
- * @param *irg   The IR graph the node belongs to.
  * @param *block The IR block the node belongs to.
  */
-FIRM_API ir_node *new_r_Start(ir_graph *irg, ir_node *block);
+FIRM_API ir_node *new_r_Start(ir_node *block);
 
 /** Constructor for a End node.
  *
- * @param *irg   The IR graph the node  belongs to.
  * @param *block The IR block the node belongs to.
  */
-FIRM_API ir_node *new_r_End(ir_graph *irg, ir_node *block);
+FIRM_API ir_node *new_r_End(ir_node *block);
 
 /** Constructor for a Jmp node.
  *

include/libfirm/typerep.h

@@ -429,7 +429,7 @@ FIRM_API int is_irn_const_expression(ir_node *n);
 
 /**
  * Copies a Firm subgraph that complies to the restrictions for
- * constant expressions to current_block in current_ir_graph.
+ * constant expressions to block.
  *
  * @param dbg  debug info for all newly created nodes
  * @param n    the node
@@ -437,7 +437,7 @@ FIRM_API int is_irn_const_expression(ir_node *n);
  * Set current_ir_graph to get_const_code_irg() to generate a constant
  * expression.
  */
-FIRM_API ir_node *copy_const_value(dbg_info *dbg, ir_node *n);
+FIRM_API ir_node *copy_const_value(dbg_info *dbg, ir_node *n, ir_node *to_block);
 
 /* Set has no effect for existent entities of type method. */
 FIRM_API ir_node *get_atomic_ent_value(ir_entity *ent);

ir/ana/cgana.c

@@ -206,9 +206,8 @@ static void sel_methods_walker(ir_node *node, void *env)
 			 * So we could replace the Sel node by a SymConst.
 			 * This method must exists.
 			 */
-			set_irg_current_block(current_ir_graph, get_nodes_block(node));
 			assert(get_entity_irg(arr[0]) != NULL);
-			new_node = copy_const_value(get_irn_dbg_info(node), get_atomic_ent_value(arr[0]));
+			new_node = copy_const_value(get_irn_dbg_info(node), get_atomic_ent_value(arr[0]), get_nodes_block(node));
 			DBG_OPT_POLY(node, new_node);
 			exchange(node, new_node);
 		}

ir/ana/irconsconfirm.c

@@ -152,7 +152,8 @@ static void handle_modeb(ir_node *block, ir_node *selector, pn_Cond pnc, env_t *
 			 * We can replace the input with true/false.
 			 */
 			if (con == NULL) {
-				con = new_Const(pnc == pn_Cond_true ? tarval_b_true : tarval_b_false);
+				ir_graph *irg = get_irn_irg(block);
+				con = new_r_Const(irg, pnc == pn_Cond_true ? tarval_b_true : tarval_b_false);
 			}
 			old = get_irn_n(user, pos);
 			set_irn_n(user, pos, con);
@@ -212,8 +213,9 @@ static void handle_modeb(ir_node *block, ir_node *selector, pn_Cond pnc, env_t *
 				NEW_ARR_A(ir_node *, in, n);
 				/* ok, ALL predecessors are either dominated by block OR other block */
 				if (c_b == NULL) {
-					ir_node *c_true  = new_Const(tarval_b_true);
-					ir_node *c_false = new_Const(tarval_b_false);
+					ir_graph *irg    = get_irn_irg(block);
+					ir_node *c_true  = new_r_Const(irg, tarval_b_true);
+					ir_node *c_false = new_r_Const(irg, tarval_b_false);
 					env->num_consts += 2;
 					if (pnc == pn_Cond_true) {
 						c_b = c_true;
@@ -518,9 +520,9 @@ static void insert_non_null(ir_node *ptr, ir_node *block, env_t *env)
 			 * We can replace the input with a Confirm(ptr, !=, NULL).
 			 */
 			if (c == NULL) {
-				ir_mode *mode = get_irn_mode(ptr);
-				c = new_Const(get_mode_null(mode));
-
+				ir_mode  *mode = get_irn_mode(ptr);
+				ir_graph *irg  = get_irn_irg(block);
+				c = new_r_Const(irg, get_mode_null(mode));
 				c = new_r_Confirm(block, ptr, c, pn_Cmp_Lg);
 			}
 

ir/ana/irdom.c

@@ -52,7 +52,8 @@ ir_node *get_Block_idom(const ir_node *bl)
 	assert(is_Block(bl));
 	if (get_Block_dom_depth(bl) == -1) {
 		/* This block is not reachable from Start */
-		return new_Bad();
+		ir_graph *irg = get_irn_irg(bl);
+		return new_r_Bad(irg);
 	}
 	return get_dom_info(bl)->idom;
 }
@@ -83,7 +84,8 @@ ir_node *get_Block_ipostdom(const ir_node *bl)
 	assert(is_Block(bl));
 	if (get_Block_postdom_depth(bl) == -1) {
 		/* This block is not reachable from Start */
-		return new_Bad();
+		ir_graph *irg = get_irn_irg(bl);
+		return new_r_Bad(irg);
 	}
 	return get_pdom_info(bl)->idom;
 }

ir/be/amd64/bearch_amd64.c

@@ -184,7 +184,7 @@ static void transform_Spill(ir_node *node)
 	ir_node   *block  = get_nodes_block(node);
 	dbg_info  *dbgi   = get_irn_dbg_info(node);
 	ir_node   *ptr    = get_irg_frame(irg);
-	ir_node   *mem    = new_NoMem();
+	ir_node   *mem    = new_r_NoMem(irg);
 	ir_node   *val    = get_irn_n(node, be_pos_Spill_val);
 	//ir_mode   *mode   = get_irn_mode(val);
 	ir_entity *entity = be_get_frame_entity(node);

ir/be/arm/arm_transform.c

@@ -1151,7 +1151,7 @@ static ir_node *ints_to_double(dbg_info *dbgi, ir_node *block, ir_node *node0,
 	 * registers... */
 	ir_graph *irg   = current_ir_graph;
 	ir_node  *stack = get_irg_frame(irg);
-	ir_node  *nomem = new_NoMem();
+	ir_node  *nomem = new_r_NoMem(irg);
 	ir_node  *str0  = new_bd_arm_Str(dbgi, block, stack, node0, nomem, mode_gp,
 	                                 NULL, 0, 0, true);
 	ir_node  *str1  = new_bd_arm_Str(dbgi, block, stack, node1, nomem, mode_gp,
@@ -1165,14 +1165,14 @@ static ir_node *ints_to_double(dbg_info *dbgi, ir_node *block, ir_node *node0,
 	ldf = new_bd_arm_Ldf(dbgi, block, stack, sync, mode_D, NULL, 0, 0, true);
 	set_irn_pinned(ldf, op_pin_state_floats);
 
-	return new_Proj(ldf, mode_fp, pn_arm_Ldf_res);
+	return new_r_Proj(ldf, mode_fp, pn_arm_Ldf_res);
 }
 
 static ir_node *int_to_float(dbg_info *dbgi, ir_node *block, ir_node *node)
 {
 	ir_graph *irg   = current_ir_graph;
 	ir_node  *stack = get_irg_frame(irg);
-	ir_node  *nomem = new_NoMem();
+	ir_node  *nomem = new_r_NoMem(irg);
 	ir_node  *str   = new_bd_arm_Str(dbgi, block, stack, node, nomem, mode_gp,
 	                                 NULL, 0, 0, true);
 	ir_node  *ldf;
@@ -1181,14 +1181,14 @@ static ir_node *int_to_float(dbg_info *dbgi, ir_node *block, ir_node *node)
 	ldf = new_bd_arm_Ldf(dbgi, block, stack, str, mode_F, NULL, 0, 0, true);
 	set_irn_pinned(ldf, op_pin_state_floats);
 
-	return new_Proj(ldf, mode_fp, pn_arm_Ldf_res);
+	return new_r_Proj(ldf, mode_fp, pn_arm_Ldf_res);
 }
 
 static ir_node *float_to_int(dbg_info *dbgi, ir_node *block, ir_node *node)
 {
 	ir_graph *irg   = current_ir_graph;
 	ir_node  *stack = get_irg_frame(irg);
-	ir_node  *nomem = new_NoMem();
+	ir_node  *nomem = new_r_NoMem(irg);
 	ir_node  *stf   = new_bd_arm_Stf(dbgi, block, stack, node, nomem, mode_F,
 	                                 NULL, 0, 0, true);
 	ir_node  *ldr;
@@ -1197,7 +1197,7 @@ static ir_node *float_to_int(dbg_info *dbgi, ir_node *block, ir_node *node)
 	ldr = new_bd_arm_Ldr(dbgi, block, stack, stf, mode_gp, NULL, 0, 0, true);
 	set_irn_pinned(ldr, op_pin_state_floats);
 
-	return new_Proj(ldr, mode_gp, pn_arm_Ldr_res);
+	return new_r_Proj(ldr, mode_gp, pn_arm_Ldr_res);
 }
 
 static void double_to_ints(dbg_info *dbgi, ir_node *block, ir_node *node,
@@ -1205,7 +1205,7 @@ static void double_to_ints(dbg_info *dbgi, ir_node *block, ir_node *node,
 {
 	ir_graph *irg   = current_ir_graph;
 	ir_node  *stack = get_irg_frame(irg);
-	ir_node  *nomem = new_NoMem();
+	ir_node  *nomem = new_r_NoMem(irg);
 	ir_node  *stf   = new_bd_arm_Stf(dbgi, block, stack, node, nomem, mode_D,
 	                                 NULL, 0, 0, true);
 	ir_node  *ldr0, *ldr1;
@@ -1216,8 +1216,8 @@ static void double_to_ints(dbg_info *dbgi, ir_node *block, ir_node *node,
 	ldr1 = new_bd_arm_Ldr(dbgi, block, stack, stf, mode_gp, NULL, 0, 4, true);
 	set_irn_pinned(ldr1, op_pin_state_floats);
 
-	*out_value0 = new_Proj(ldr0, mode_gp, pn_arm_Ldr_res);
-	*out_value1 = new_Proj(ldr1, mode_gp, pn_arm_Ldr_res);
+	*out_value0 = new_r_Proj(ldr0, mode_gp, pn_arm_Ldr_res);
+	*out_value1 = new_r_Proj(ldr1, mode_gp, pn_arm_Ldr_res);
 }
 
 static ir_node *gen_CopyB(ir_node *node)
@@ -1427,7 +1427,7 @@ static ir_node *gen_Proj_Start(ir_node *node)
 		return be_prolog_get_reg_value(abihelper, sp_reg);
 
 	case pn_Start_P_tls:
-		return new_Bad();
+		return new_r_Bad(get_irn_irg(node));
 
 	case pn_Start_max:
 		break;
@@ -1467,7 +1467,7 @@ static ir_node *gen_Proj_Proj_Start(ir_node *node)
 				ir_node  *ldr = new_bd_arm_Ldr(NULL, new_block, fp, mem,
 				                               mode_gp, param->entity,
 				                               0, 0, true);
-				value1 = new_Proj(ldr, mode_gp, pn_arm_Ldr_res);
+				value1 = new_r_Proj(ldr, mode_gp, pn_arm_Ldr_res);
 			}
 
 			/* convert integer value to float */

ir/be/arm/bearch_arm.c

@@ -189,7 +189,8 @@ static void transform_Spill(ir_node *node)
 	ir_node   *block  = get_nodes_block(node);
 	dbg_info  *dbgi   = get_irn_dbg_info(node);
 	ir_node   *ptr    = get_irn_n(node, be_pos_Spill_frame);
-	ir_node   *mem    = new_NoMem();
+	ir_graph  *irg    = get_irn_irg(node);
+	ir_node   *mem    = new_r_NoMem(irg);
 	ir_node   *val    = get_irn_n(node, be_pos_Spill_val);
 	ir_mode   *mode   = get_irn_mode(val);
 	ir_entity *entity = be_get_frame_entity(node);

ir/be/beabi.c

@@ -470,7 +470,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp)
 			/* Insert a store for primitive arguments. */
 			if (is_atomic_type(param_type)) {
 				ir_node *store;
-				ir_node *mem_input = do_seq ? curr_mem : new_NoMem();
+				ir_node *mem_input = do_seq ? curr_mem : new_r_NoMem(irg);
 				store = new_rd_Store(dbgi, bl, mem_input, addr, param, 0);
 				mem   = new_r_Proj(store, mode_M, pn_Store_M);
 			} else {
@@ -1936,7 +1936,7 @@ static void modify_irg(ir_graph *irg)
 					ir_mode *mode      = get_type_mode(param_type);
 					ir_mode *load_mode = arg->load_mode;
 
-					ir_node *load = new_r_Load(start_bl, new_NoMem(), addr, load_mode, cons_floats);
+					ir_node *load = new_r_Load(start_bl, new_r_NoMem(irg), addr, load_mode, cons_floats);
 					repl = new_r_Proj(load, load_mode, pn_Load_res);
 
 					if (mode != load_mode) {
@@ -2170,7 +2170,7 @@ static void fix_pic_symconsts(ir_node *node, void *data)
 		/* we need an extra indirection for global data outside our current
 		   module. The loads are always safe and can therefore float
 		   and need no memory input */
-		load     = new_r_Load(block, new_NoMem(), add, mode, cons_floats);
+		load     = new_r_Load(block, new_r_NoMem(irg), add, mode, cons_floats);
 		load_res = new_r_Proj(load, mode, pn_Load_res);
 
 		set_irn_n(node, i, load_res);

ir/be/bechordal_main.c

@@ -223,9 +223,10 @@ static void memory_operand_walker(ir_node *irn, void *env)
 
 	/* kill the Reload */
 	if (get_irn_n_edges(irn) == 0) {
+		ir_graph *irg = get_irn_irg(irn);
 		sched_remove(irn);
-		set_irn_n(irn, be_pos_Reload_mem, new_Bad());
-		set_irn_n(irn, be_pos_Reload_frame, new_Bad());
+		set_irn_n(irn, be_pos_Reload_mem, new_r_Bad(irg));
+		set_irn_n(irn, be_pos_Reload_frame, new_r_Bad(irg));
 	}
 }
 

ir/be/beinfo.c

@@ -64,7 +64,7 @@ void be_info_new_node(ir_node *node)
 	}
 }
 
-static void new_Phi_copy_attr(ir_graph *irg, const ir_node *old_node,
+static void new_phi_copy_attr(ir_graph *irg, const ir_node *old_node,
                               ir_node *new_node)
 {
 	backend_info_t *old_info = be_get_info(old_node);
@@ -119,7 +119,7 @@ void be_info_init(void)
 		panic("double initialization of be_info");
 
 	old_phi_copy_attr = op_Phi->ops.copy_attr;
-	op_Phi->ops.copy_attr = new_Phi_copy_attr;
+	op_Phi->ops.copy_attr = new_phi_copy_attr;
 	initialized = true;
 
 	/* phis have register and register requirements now which we want to dump */
@@ -159,7 +159,7 @@ void be_info_free(void)
 	if (!initialized)
 		panic("be_info_free called without prior init");
 
-	assert(op_Phi->ops.copy_attr == new_Phi_copy_attr);
+	assert(op_Phi->ops.copy_attr == new_phi_copy_attr);
 	op_Phi->ops.copy_attr = old_phi_copy_attr;
 	initialized = false;
 

ir/be/beirgmod.c

@@ -155,6 +155,7 @@ static void remove_empty_block(ir_node *block)
 	ir_node *pred;
 	ir_node *succ_block;
 	ir_node *jump = NULL;
+	ir_graph *irg = get_irn_irg(block);
 
 	if (irn_visited_else_mark(block))
 		return;
@@ -226,7 +227,7 @@ static void remove_empty_block(ir_node *block)
 		panic("Unexpected node %+F in block %+F with empty schedule", node, block);
 	}
 
-	set_Block_cfgpred(block, 0, new_Bad());
+	set_Block_cfgpred(block, 0, new_r_Bad(irg));
 	kill_node(jump);
 	blocks_removed = 1;
 

ir/be/benode.c

@@ -1077,7 +1077,8 @@ ir_node *be_new_Phi(ir_node *block, int n_ins, ir_node **ins, ir_mode *mode,
                     const arch_register_class_t *cls)
 {
 	const arch_register_req_t *req;
-	struct obstack *obst = be_get_be_obst(get_irn_irg(block));
+	ir_graph       *irg  = get_irn_irg(block);
+	struct obstack *obst = be_get_be_obst(irg);
 	backend_info_t *info;
 	int             i;
 

ir/be/bepeephole.c

@@ -235,13 +235,14 @@ static void process_block(ir_node *block, void *data)
 
 static void kill_node_and_preds(ir_node *node)
 {
+	ir_graph *irg = get_irn_irg(node);
 	int arity, i;
 
 	arity = get_irn_arity(node);
 	for (i = 0; i < arity; ++i) {
 		ir_node *pred = get_irn_n(node, i);
 
-		set_irn_n(node, i, new_Bad());
+		set_irn_n(node, i, new_r_Bad(irg));
 		if (get_irn_n_edges(pred) != 0)
 			continue;
 

ir/be/bespillslots.c

@@ -734,7 +734,7 @@ static void create_memperms(be_fec_env_t *env)
 			be_set_MemPerm_in_entity(mempermnode, i, entry->in);
 			be_set_MemPerm_out_entity(mempermnode, i, entry->out);
 			set_irg_current_block(irg, memperm->block);
-			proj = new_Proj(mempermnode, get_irn_mode(arg), i);
+			proj = new_r_Proj(mempermnode, get_irn_mode(arg), i);
 
 			set_irn_n(entry->node, entry->pos, proj);
 		}

ir/be/bespillutil.c

@@ -427,7 +427,8 @@ static void spill_irn(spill_env_t *env, spill_info_t *spillinfo)
 	 * and simply always available. */
 	if (!sched_is_scheduled(insn)) {
 		/* override spillinfos or create a new one */
-		spillinfo->spills->spill = new_NoMem();
+		ir_graph *irg = get_irn_irg(to_spill);
+		spillinfo->spills->spill = new_r_NoMem(irg);
 		DB((dbg, LEVEL_1, "don't spill %+F use NoMem\n", to_spill));
 		return;
 	}
@@ -549,7 +550,7 @@ static void spill_node(spill_env_t *env, spill_info_t *spillinfo)
 static int is_value_available(spill_env_t *env, const ir_node *arg,
                               const ir_node *reloader)
 {
-	if (is_Unknown(arg) || arg == new_NoMem())
+	if (is_Unknown(arg) || is_NoMem(arg))
 		return 1;
 
 	if (be_is_Spill(skip_Proj_const(arg)))
@@ -773,11 +774,12 @@ static void determine_spill_costs(spill_env_t *env, spill_info_t *spillinfo)
 	 * predecessor (of a PhiM) but this test might match other things too...
 	 */
 	if (!sched_is_scheduled(insn)) {
+		ir_graph *irg = get_irn_irg(to_spill);
 		/* override spillinfos or create a new one */
 		spill_t *spill = OALLOC(&env->obst, spill_t);
 		spill->after = NULL;
 		spill->next  = NULL;
-		spill->spill = new_NoMem();
+		spill->spill = new_r_NoMem(irg);
 
 		spillinfo->spills      = spill;
 		spillinfo->spill_costs = 0;

ir/be/betranshlp.c

@@ -292,7 +292,7 @@ static ir_node *new_be_Anchor(ir_graph *irg)
 
 	/* Hack: some places in the code ask the Anchor for its register
 	   requirements */
-	new_anchor = new_Anchor(irg);
+	new_anchor = new_r_Anchor(irg);
 	info = be_get_info(new_anchor);
 	info->out_infos = NEW_ARR_D(reg_out_info_t, obst, 1);
 	memset(info->out_infos, 0, 1 * sizeof(info->out_infos[0]));

ir/be/ia32/bearch_ia32.c

@@ -558,7 +558,7 @@ static arch_inverse_t *ia32_get_inverse(const ir_node *irn, int i, arch_inverse_
 	mode     = get_irn_mode(irn);
 	irn_mode = get_irn_mode(irn);
 	noreg    = get_irn_n(irn, 0);
-	nomem    = new_NoMem();
+	nomem    = new_r_NoMem(irg);
 	dbg      = get_irn_dbg_info(irn);
 
 	/* initialize structure */
@@ -854,6 +854,7 @@ static void ia32_prepare_graph(ir_graph *irg)
 ir_node *turn_back_am(ir_node *node)
 {
 	dbg_info *dbgi  = get_irn_dbg_info(node);
+	ir_graph *irg   = get_irn_irg(node);
 	ir_node  *block = get_nodes_block(node);
 	ir_node  *base  = get_irn_n(node, n_ia32_base);
 	ir_node  *index = get_irn_n(node, n_ia32_index);
@@ -866,7 +867,7 @@ ir_node *turn_back_am(ir_node *node)
 	ia32_copy_am_attrs(load, node);
 	if (is_ia32_is_reload(node))
 		set_ia32_is_reload(load);
-	set_irn_n(node, n_ia32_mem, new_NoMem());
+	set_irn_n(node, n_ia32_mem, new_r_NoMem(irg));
 
 	switch (get_ia32_am_support(node)) {
 		case ia32_am_unary:
@@ -1033,7 +1034,7 @@ static void transform_to_Store(ir_node *node)
 	const ir_node *spillval = get_irn_n(node, be_pos_Spill_val);
 	ir_mode *mode  = get_spill_mode(spillval);
 	ir_node *noreg = ia32_new_NoReg_gp(irg);
-	ir_node *nomem = new_NoMem();
+	ir_node *nomem = new_r_NoMem(irg);
 	ir_node *ptr   = get_irg_frame(irg);
 	ir_node *val   = get_irn_n(node, be_pos_Spill_val);
 	ir_node *store;
@@ -1101,7 +1102,7 @@ static ir_node *create_pop(ir_node *node, ir_node *schedpoint, ir_node *sp, ir_e
 	ir_node  *noreg = ia32_new_NoReg_gp(irg);
 	ir_node  *frame = get_irg_frame(irg);
 
-	ir_node *pop = new_bd_ia32_PopMem(dbg, block, frame, noreg, new_NoMem(), sp);
+	ir_node *pop = new_bd_ia32_PopMem(dbg, block, frame, noreg, new_r_NoMem(irg), sp);
 
 	set_ia32_frame_ent(pop, ent);
 	set_ia32_use_frame(pop);
@@ -1169,7 +1170,7 @@ static void transform_MemPerm(ir_node *node)
 			sp = create_spproj(node, push, pn_ia32_Push_stack);
 		}
 
-		set_irn_n(node, i, new_Bad());
+		set_irn_n(node, i, new_r_Bad(irg));
 	}
 
 	/* create pops */
@@ -1217,7 +1218,7 @@ static void transform_MemPerm(ir_node *node)
 	/* remove memperm */
 	arity = get_irn_arity(node);
 	for (i = 0; i < arity; ++i) {
-		set_irn_n(node, i, new_Bad());
+		set_irn_n(node, i, new_r_Bad(irg));
 	}
 	sched_remove(node);
 }
@@ -2109,23 +2110,25 @@ static void ia32_lower_for_target(void)
  */
 static ir_node *ia32_create_trampoline_fkt(ir_node *block, ir_node *mem, ir_node *trampoline, ir_node *env, ir_node *callee)
 {
-	ir_node  *st, *p = trampoline;
-	ir_mode *mode    = get_irn_mode(p);
+	ir_graph *irg  = get_irn_irg(block);
+	ir_node  *p    = trampoline;
+	ir_mode  *mode = get_irn_mode(p);
+	ir_node  *st;
 
 	/* mov  ecx,<env> */
-	st  = new_r_Store(block, mem, p, new_Const_long(mode_Bu, 0xb9), 0);
+	st  = new_r_Store(block, mem, p, new_r_Const_long(irg, mode_Bu, 0xb9), 0);
 	mem = new_r_Proj(st, mode_M, pn_Store_M);
-	p   = new_r_Add(block, p, new_Const_long(mode_Iu, 1), mode);
+	p   = new_r_Add(block, p, new_r_Const_long(irg, mode_Iu, 1), mode);
 	st  = new_r_Store(block, mem, p, env, 0);
 	mem = new_r_Proj(st, mode_M, pn_Store_M);
-	p   = new_r_Add(block, p, new_Const_long(mode_Iu, 4), mode);
+	p   = new_r_Add(block, p, new_r_Const_long(irg, mode_Iu, 4), mode);
 	/* jmp  <callee> */
-	st  = new_r_Store(block, mem, p, new_Const_long(mode_Bu, 0xe9), 0);
+	st  = new_r_Store(block, mem, p, new_r_Const_long(irg, mode_Bu, 0xe9), 0);
 	mem = new_r_Proj(st, mode_M, pn_Store_M);
-	p   = new_r_Add(block, p, new_Const_long(mode_Iu, 1), mode);
+	p   = new_r_Add(block, p, new_r_Const_long(irg, mode_Iu, 1), mode);
 	st  = new_r_Store(block, mem, p, callee, 0);
 	mem = new_r_Proj(st, mode_M, pn_Store_M);
-	p   = new_r_Add(block, p, new_Const_long(mode_Iu, 4), mode);
+	p   = new_r_Add(block, p, new_r_Const_long(irg, mode_Iu, 4), mode);
 
 	return mem;
 }

ir/be/ia32/ia32_finish.c

@@ -69,7 +69,7 @@ static void ia32_transform_sub_to_neg_add(ir_node *irn)
 	irg      = get_irn_irg(irn);
 	noreg    = ia32_new_NoReg_gp(irg);
 	noreg_fp = ia32_new_NoReg_xmm(irg);
-	nomem    = new_NoMem();
+	nomem    = new_r_NoMem(irg);
 	in1      = get_irn_n(irn, n_ia32_binary_left);
 	in2      = get_irn_n(irn, n_ia32_binary_right);
 	in1_reg  = arch_get_irn_register(in1);

ir/be/ia32/ia32_fpu.c

@@ -105,7 +105,7 @@ static ir_node *create_fpu_mode_spill(void *env, ir_node *state, int force,
 		ir_graph *irg = get_irn_irg(state);
 		ir_node *block = get_nodes_block(state);
 		ir_node *noreg = ia32_new_NoReg_gp(irg);
-		ir_node *nomem = new_NoMem();
+		ir_node *nomem = new_r_NoMem(irg);
 		ir_node *frame = get_irg_frame(irg);
 
 		spill = new_bd_ia32_FnstCW(NULL, block, frame, noreg, nomem, state);
@@ -123,7 +123,7 @@ static ir_node *create_fpu_mode_spill(void *env, ir_node *state, int force,
 static ir_node *create_fldcw_ent(ir_node *block, ir_entity *entity)
 {
 	ir_graph *irg   = get_irn_irg(block);
-	ir_node  *nomem = new_NoMem();
+	ir_node  *nomem = new_r_NoMem(irg);
 	ir_node  *noreg = ia32_new_NoReg_gp(irg);
 	ir_node  *reload;
 
@@ -171,7 +171,7 @@ static ir_node *create_fpu_mode_reload(void *env, ir_node *state,
 		sched_add_before(before, reload);
 	} else {
 		ir_mode *lsmode = ia32_reg_classes[CLASS_ia32_fp_cw].mode;
-		ir_node *nomem = new_NoMem();
+		ir_node *nomem  = new_r_NoMem(irg);
 		ir_node *cwstore, *load, *load_res, *or, *store, *fldcw;
 		ir_node *or_const;