X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fopt_ldst.c;h=d0770f318c86b74b1a4b4b77eae183c2a4516420;hb=b7b24e372a1338ecd5eb26bdd285a8cbe7b1fec9;hp=3102b6b6568eb6ffcf5f2eae10ec7da2498aad9c;hpb=cf946e20e9cac9f8e42e7a1fc93886a75db7a80c;p=libfirm

diff --git a/ir/opt/opt_ldst.c b/ir/opt/opt_ldst.c
index 3102b6b65..d0770f318 100644
--- a/ir/opt/opt_ldst.c
+++ b/ir/opt/opt_ldst.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -45,7 +45,7 @@
 #include "irpass.h"
 
 /* maximum number of output Proj's */
-#define MAX_PROJ (pn_Load_max > pn_Store_max ? pn_Load_max : pn_Store_max)
+#define MAX_PROJ ((long)pn_Load_max > (long)pn_Store_max ? (long)pn_Load_max : (long)pn_Store_max)
 
 /**
  * Mapping an address to an dense ID.
@@ -125,7 +125,7 @@ typedef struct ldst_env_t {
 	memop_t         **curr_id_2_memop; /**< current map of address ids to memops */
 	unsigned        curr_adr_id;       /**< number for address mapping */
 	unsigned        n_mem_ops;         /**< number of memory operations (Loads/Stores) */
-	unsigned        rbs_size;          /**< size of all bitsets in bytes */
+	size_t          rbs_size;          /**< size of all bitsets in bytes */
 	int             max_cfg_preds;     /**< maximum number of block cfg predecessors */
 	int             changed;           /**< Flags for changed graph state */
 #ifdef DEBUG_libfirm
@@ -145,7 +145,8 @@ static firm_dbg_module_t *dbg;
  *
  * @param ldst environment
  */
-static void dump_block_list(ldst_env *env) {
+static void dump_block_list(ldst_env *env)
+{
 	block_t *entry;
 	memop_t *op;
 	int     i;
@@ -157,7 +158,8 @@ static void dump_block_list(ldst_env *env) {
 		for (op = entry->memop_forward; op != NULL; op = op->next) {
 			if (i == 0) {
 				DB((dbg, LEVEL_2, "\n\t"));
-			}			DB((dbg, LEVEL_2, "%+F", op->node));
+			}
+			DB((dbg, LEVEL_2, "%+F", op->node));
 			if ((op->flags & FLAG_KILL_ALL) == FLAG_KILL_ALL)
 				DB((dbg, LEVEL_2, "X"));
 			else if (op->flags & FLAG_KILL_ALL)
@@ -176,10 +178,11 @@ static void dump_block_list(ldst_env *env) {
  * @param bl   current block
  * @param s    name of the set
  */
-static void dump_curr(block_t *bl, const char *s) {
-	unsigned end = env.rbs_size - 1;
-	unsigned pos;
-	int      i;
+static void dump_curr(block_t *bl, const char *s)
+{
+	size_t end = env.rbs_size - 1;
+	size_t pos;
+	int    i;
 
 	DB((dbg, LEVEL_2, "%s[%+F] = {", s, bl->block));
 	i = 0;
@@ -197,26 +200,30 @@ static void dump_curr(block_t *bl, const char *s) {
 }  /* dump_curr */
 
 #else
-static void dump_block_list(ldst_env *env) {
+static void dump_block_list(ldst_env *env)
+{
 	(void) env;
 }
-static void dump_curr(block_t *bl, const char *s) {
+static void dump_curr(block_t *bl, const char *s)
+{
 	(void) bl;
 	(void) s;
 }
 #endif /* DEBUG_libfirm */
 
 /** Get the block entry for a block node */
-static block_t *get_block_entry(const ir_node *block) {
+static block_t *get_block_entry(const ir_node *block)
+{
 	assert(is_Block(block));
 
-	return get_irn_link(block);
+	return (block_t*)get_irn_link(block);
 }  /* get_block_entry */
 
 /** Get the memop entry for a memory operation node */
-static memop_t *get_irn_memop(const ir_node *irn) {
+static memop_t *get_irn_memop(const ir_node *irn)
+{
 	assert(! is_Block(irn));
-	return get_irn_link(irn);
+	return (memop_t*)get_irn_link(irn);
 }  /* get_irn_memop */
 
 /**
@@ -228,7 +235,8 @@ static memop_t *get_irn_memop(const ir_node *irn) {
  * @param post  post walker function
  * @param ctx   context parameter for the walker functions
  */
-static void walk_memory(ir_node *irn, irg_walk_func *pre, irg_walk_func *post, void *ctx) {
+static void walk_memory(ir_node *irn, irg_walk_func *pre, irg_walk_func *post, void *ctx)
+{
 	int     i;
 	ir_mode *mode;
 
@@ -267,7 +275,8 @@ static void walk_memory(ir_node *irn, irg_walk_func *pre, irg_walk_func *post, v
  * @param post  post walker function
  * @param ctx   context parameter for the walker functions
  */
-static void walk_memory_irg(ir_graph *irg, irg_walk_func pre, irg_walk_func post, void *ctx) {
+static void walk_memory_irg(ir_graph *irg, irg_walk_func pre, irg_walk_func post, void *ctx)
+{
 	inc_irg_visited(irg);
 
 	ir_reserve_resources(irg, IR_RESOURCE_IRN_VISITED);
@@ -288,7 +297,8 @@ static void walk_memory_irg(ir_graph *irg, irg_walk_func pre, irg_walk_func post
  *
  * @return the allocated id
  */
-static unsigned register_address(ir_node *adr) {
+static unsigned register_address(ir_node *adr)
+{
 	address_entry *entry;
 
 	/* skip Confirms and Casts */
@@ -302,7 +312,7 @@ restart:
 		goto restart;
 	}
 
-	entry = ir_nodemap_get(&env.adr_map, adr);
+	entry = (address_entry*)ir_nodemap_get(&env.adr_map, adr);
 
 	if (entry == NULL) {
 		/* new address */
@@ -328,7 +338,8 @@ restart:
  * @param block    the block
  * @param pos      the position of the predecessor in block
  */
-static ir_node *phi_translate(ir_node *address, const ir_node *block, int pos) {
+static ir_node *phi_translate(ir_node *address, const ir_node *block, int pos)
+{
 	if (is_Phi(address) && get_nodes_block(address) == block)
 		address = get_Phi_pred(address, pos);
 	return address;
@@ -338,7 +349,8 @@ static ir_node *phi_translate(ir_node *address, const ir_node *block, int pos) {
  * Walker: allocate an block entry for every block
  * and register all potential addresses.
  */
-static void prepare_blocks(ir_node *irn, void *ctx) {
+static void prepare_blocks(ir_node *irn, void *ctx)
+{
 	(void)ctx;
 
 	if (is_Block(irn)) {
@@ -383,7 +395,8 @@ static void prepare_blocks(ir_node *irn, void *ctx) {
 /**
  * Post-Walker, link in all Phi's
  */
-static void link_phis(ir_node *irn, void *ctx) {
+static void link_phis(ir_node *irn, void *ctx)
+{
 	(void)ctx;
 
 	if (is_Phi(irn)) {
@@ -395,7 +408,8 @@ static void link_phis(ir_node *irn, void *ctx) {
 /**
  * Block walker: creates the inverse post-order list for the CFG.
  */
-static void inverse_post_order(ir_node *block, void *ctx) {
+static void inverse_post_order(ir_node *block, void *ctx)
+{
 	block_t *entry = get_block_entry(block);
 
 	(void)ctx;
@@ -415,7 +429,8 @@ static void inverse_post_order(ir_node *block, void *ctx) {
 /**
  * Block walker: create backward links for the memops of a block.
  */
-static void collect_backward(ir_node *block, void *ctx) {
+static void collect_backward(ir_node *block, void *ctx)
+{
 	block_t *entry = get_block_entry(block);
 	memop_t *last, *op;
 
@@ -450,7 +465,8 @@ static void collect_backward(ir_node *block, void *ctx) {
  *
  * @return the allocated memop
  */
-static memop_t *alloc_memop(ir_node *irn) {
+static memop_t *alloc_memop(ir_node *irn)
+{
 	memop_t *m = OALLOC(&env.obst, memop_t);
 
 	m->value.address = NULL;
@@ -476,7 +492,8 @@ static memop_t *alloc_memop(ir_node *irn) {
  * @param op   the memop to clone
  * @param phi  the Phi-node representing the new value
  */
-static memop_t *clone_memop_phi(memop_t *op, ir_node *phi) {
+static memop_t *clone_memop_phi(memop_t *op, ir_node *phi)
+{
 	memop_t *m = OALLOC(&env.obst, memop_t);
 
 	m->value         = op->value;
@@ -498,7 +515,8 @@ static memop_t *clone_memop_phi(memop_t *op, ir_node *phi) {
  *
  * return a bitset of mtp_property_const and mtp_property_pure
  */
-static unsigned get_Call_memory_properties(ir_node *call) {
+static unsigned get_Call_memory_properties(ir_node *call)
+{
 	ir_type *call_tp = get_Call_type(call);
 	unsigned prop = get_method_additional_properties(call_tp);
 
@@ -523,7 +541,8 @@ static unsigned get_Call_memory_properties(ir_node *call) {
  *
  * @return an entity or NULL
  */
-static ir_entity *find_constant_entity(ir_node *ptr) {
+static ir_entity *find_constant_entity(ir_node *ptr)
+{
 	for (;;) {
 		if (is_SymConst(ptr) && get_SymConst_kind(ptr) == symconst_addr_ent) {
 			return get_SymConst_entity(ptr);
@@ -542,10 +561,10 @@ static ir_entity *find_constant_entity(ir_node *ptr) {
 				int i, n;
 
 				for (i = 0, n = get_Sel_n_indexs(ptr); i < n; ++i) {
-					ir_node *bound;
-					tarval *tlower, *tupper;
-					ir_node *index = get_Sel_index(ptr, i);
-					tarval *tv     = computed_value(index);
+					ir_node   *bound;
+					ir_tarval *tlower, *tupper;
+					ir_node   *index = get_Sel_index(ptr, i);
+					ir_tarval *tv     = computed_value(index);
 
 					/* check if the index is constant */
 					if (tv == tarval_bad)
@@ -559,9 +578,9 @@ static ir_entity *find_constant_entity(ir_node *ptr) {
 					if (tlower == tarval_bad || tupper == tarval_bad)
 						return NULL;
 
-					if (tarval_cmp(tv, tlower) & pn_Cmp_Lt)
+					if (tarval_cmp(tv, tlower) == ir_relation_less)
 						return NULL;
-					if (tarval_cmp(tupper, tv) & pn_Cmp_Lt)
+					if (tarval_cmp(tupper, tv) == ir_relation_less)
 						return NULL;
 
 					/* ok, bounds check finished */
@@ -591,7 +610,7 @@ static ir_entity *find_constant_entity(ir_node *ptr) {
 			ir_node *l = get_Sub_left(ptr);
 			ir_node *r = get_Sub_right(ptr);
 
-			if (get_irn_mode(l) == get_irn_mode(ptr) &&	is_Const(r))
+			if (get_irn_mode(l) == get_irn_mode(ptr) && is_Const(r))
 				ptr = l;
 			else
 				return NULL;
@@ -606,7 +625,8 @@ static ir_entity *find_constant_entity(ir_node *ptr) {
 /**
  * Return the Selection index of a Sel node from dimension n
  */
-static long get_Sel_array_index_long(ir_node *n, int dim) {
+static long get_Sel_array_index_long(ir_node *n, int dim)
+{
 	ir_node *index = get_Sel_index(n, dim);
 	assert(is_Const(index));
 	return get_tarval_long(get_Const_tarval(index));
@@ -620,11 +640,12 @@ static long get_Sel_array_index_long(ir_node *n, int dim) {
  * @param depth  current depth in steps upward from the root
  *               of the address
  */
-static compound_graph_path *rec_get_accessed_path(ir_node *ptr, int depth) {
+static compound_graph_path *rec_get_accessed_path(ir_node *ptr, int depth)
+{
 	compound_graph_path *res = NULL;
 	ir_entity           *root, *field, *ent;
 	int                 path_len, pos, idx;
-	tarval              *tv;
+	ir_tarval           *tv;
 	ir_type             *tp;
 
 	if (is_SymConst(ptr)) {
@@ -652,17 +673,19 @@ static compound_graph_path *rec_get_accessed_path(ir_node *ptr, int depth) {
 			set_compound_graph_path_array_index(res, pos, get_Sel_array_index_long(ptr, 0));
 		}
 	} else if (is_Add(ptr)) {
-		ir_node *l    = get_Add_left(ptr);
-		ir_node *r    = get_Add_right(ptr);
-		ir_mode *mode = get_irn_mode(ptr);
-		tarval  *tmp;
-
-		if (is_Const(r) && get_irn_mode(l) == mode) {
-			ptr = l;
-			tv  = get_Const_tarval(r);
-		} else {
-			ptr = r;
-			tv  = get_Const_tarval(l);
+		ir_mode   *mode;
+		ir_tarval *tmp;
+
+		{
+			ir_node *l = get_Add_left(ptr);
+			ir_node *r = get_Add_right(ptr);
+			if (is_Const(r) && get_irn_mode(l) == get_irn_mode(ptr)) {
+				ptr = l;
+				tv  = get_Const_tarval(r);
+			} else {
+				ptr = r;
+				tv  = get_Const_tarval(l);
+			}
 		}
 ptr_arith:
 		mode = get_tarval_mode(tv);
@@ -676,9 +699,9 @@ ptr_arith:
 		}
 		idx = 0;
 		for (ent = field;;) {
-			unsigned size;
-			tarval   *sz, *tv_index, *tlower, *tupper;
-			ir_node  *bound;
+			unsigned  size;
+			ir_tarval *sz, *tv_index, *tlower, *tupper;
+			ir_node   *bound;
 
 			tp = get_entity_type(ent);
 			if (! is_Array_type(tp))
@@ -702,9 +725,9 @@ ptr_arith:
 			if (tlower == tarval_bad || tupper == tarval_bad)
 				return NULL;
 
-			if (tarval_cmp(tv_index, tlower) & pn_Cmp_Lt)
+			if (tarval_cmp(tv_index, tlower) == ir_relation_less)
 				return NULL;
-			if (tarval_cmp(tupper, tv_index) & pn_Cmp_Lt)
+			if (tarval_cmp(tupper, tv_index) == ir_relation_less)
 				return NULL;
 
 			/* ok, bounds check finished */
@@ -727,9 +750,9 @@ ptr_arith:
 		pos      = path_len - depth - idx;
 
 		for (ent = field;;) {
-			unsigned size;
-			tarval   *sz, *tv_index;
-			long     index;
+			unsigned   size;
+			ir_tarval *sz, *tv_index;
+			long       index;
 
 			tp = get_entity_type(ent);
 			if (! is_Array_type(tp))
@@ -767,7 +790,8 @@ ptr_arith:
  * Returns an access path or NULL.  The access path is only
  * valid, if the graph is in phase_high and _no_ address computation is used.
  */
-static compound_graph_path *get_accessed_path(ir_node *ptr) {
+static compound_graph_path *get_accessed_path(ir_node *ptr)
+{
 	compound_graph_path *gr = rec_get_accessed_path(ptr, 0);
 	return gr;
 }  /* get_accessed_path */
@@ -778,11 +802,12 @@ typedef struct path_entry {
 	long              index;
 } path_entry;
 
-static ir_node *rec_find_compound_ent_value(ir_node *ptr, path_entry *next) {
+static ir_node *rec_find_compound_ent_value(ir_node *ptr, path_entry *next)
+{
 	path_entry       entry, *p;
 	ir_entity        *ent, *field;
 	ir_initializer_t *initializer;
-	tarval           *tv;
+	ir_tarval        *tv;
 	ir_type          *tp;
 	unsigned         n;
 
@@ -853,17 +878,19 @@ static ir_node *rec_find_compound_ent_value(ir_node *ptr, path_entry *next) {
 		}
 		return rec_find_compound_ent_value(get_Sel_ptr(ptr), &entry);
 	}  else if (is_Add(ptr)) {
-		ir_node  *l = get_Add_left(ptr);
-		ir_node  *r = get_Add_right(ptr);
-		ir_mode  *mode;
+		ir_mode *mode;
 		unsigned pos;
 
-		if (is_Const(r)) {
-			ptr = l;
-			tv  = get_Const_tarval(r);
-		} else {
-			ptr = r;
-			tv  = get_Const_tarval(l);
+		{
+			ir_node *l = get_Add_left(ptr);
+			ir_node *r = get_Add_right(ptr);
+			if (is_Const(r)) {
+				ptr = l;
+				tv  = get_Const_tarval(r);
+			} else {
+				ptr = r;
+				tv  = get_Const_tarval(l);
+			}
 		}
 ptr_arith:
 		mode = get_tarval_mode(tv);
@@ -894,10 +921,10 @@ ptr_arith:
 		/* fill them up */
 		pos = 0;
 		for (ent = field;;) {
-			unsigned size;
-			tarval   *sz, *tv_index, *tlower, *tupper;
-			long     index;
-			ir_node  *bound;
+			unsigned  size;
+			ir_tarval *sz, *tv_index, *tlower, *tupper;
+			long      index;
+			ir_node   *bound;
 
 			tp = get_entity_type(ent);
 			if (! is_Array_type(tp))
@@ -924,9 +951,9 @@ ptr_arith:
 			if (tlower == tarval_bad || tupper == tarval_bad)
 				return NULL;
 
-			if (tarval_cmp(tv_index, tlower) & pn_Cmp_Lt)
+			if (tarval_cmp(tv_index, tlower) == ir_relation_less)
 				return NULL;
-			if (tarval_cmp(tupper, tv_index) & pn_Cmp_Lt)
+			if (tarval_cmp(tupper, tv_index) == ir_relation_less)
 				return NULL;
 
 			/* ok, bounds check finished */
@@ -952,7 +979,8 @@ ptr_arith:
 	return NULL;
 }  /* rec_find_compound_ent_value */
 
-static ir_node *find_compound_ent_value(ir_node *ptr) {
+static ir_node *find_compound_ent_value(ir_node *ptr)
+{
 	return rec_find_compound_ent_value(ptr, NULL);
 }  /* find_compound_ent_value */
 
@@ -961,7 +989,8 @@ static ir_node *find_compound_ent_value(ir_node *ptr) {
  *
  * @param op  the Load memop
  */
-static void mark_replace_load(memop_t *op, ir_node *def) {
+static void mark_replace_load(memop_t *op, ir_node *def)
+{
 	op->replace = def;
 	op->flags |= FLAG_KILLED_NODE;
 	env.changed = 1;
@@ -972,7 +1001,8 @@ static void mark_replace_load(memop_t *op, ir_node *def) {
  *
  * @param op  the Store memop
  */
-static void mark_remove_store(memop_t *op) {
+static void mark_remove_store(memop_t *op)
+{
 	op->flags |= FLAG_KILLED_NODE;
 	env.changed = 1;
 }  /* mark_remove_store */
@@ -982,7 +1012,8 @@ static void mark_remove_store(memop_t *op) {
  *
  * @param m  the memop
  */
-static void update_Load_memop(memop_t *m) {
+static void update_Load_memop(memop_t *m)
+{
 	int       i;
 	ir_node   *load = m->node;
 	ir_node   *ptr;
@@ -1033,7 +1064,8 @@ static void update_Load_memop(memop_t *m) {
 
 		/* no exception, clear the m fields as it might be checked later again */
 		if (m->projs[pn_Load_X_except]) {
-			exchange(m->projs[pn_Load_X_except], new_Bad());
+			ir_graph *irg = get_irn_irg(ptr);
+			exchange(m->projs[pn_Load_X_except], new_r_Bad(irg));
 			m->projs[pn_Load_X_except] = NULL;
 			m->flags &= ~FLAG_EXCEPTION;
 			env.changed = 1;
@@ -1087,7 +1119,8 @@ static void update_Load_memop(memop_t *m) {
  *
  * @param m  the memop
  */
-static void update_Store_memop(memop_t *m) {
+static void update_Store_memop(memop_t *m)
+{
 	int     i;
 	ir_node *store = m->node;
 	ir_node *adr   = get_Store_ptr(store);
@@ -1134,7 +1167,8 @@ static void update_Store_memop(memop_t *m) {
  *
  * @param m  the memop
  */
-static void update_Call_memop(memop_t *m) {
+static void update_Call_memop(memop_t *m)
+{
 	ir_node  *call = m->node;
 	unsigned prop  = get_Call_memory_properties(call);
 	int      i;
@@ -1167,11 +1201,12 @@ static void update_Call_memop(memop_t *m) {
 }  /* update_Call_memop */
 
 /**
- * Update a memop for a Div/Mod/Quot/DivMod.
+ * Update a memop for a Div/Mod.
  *
  * @param m  the memop
  */
-static void update_DivOp_memop(memop_t *m) {
+static void update_DivOp_memop(memop_t *m)
+{
 	ir_node *div = m->node;
 	int     i;
 
@@ -1198,15 +1233,17 @@ static void update_DivOp_memop(memop_t *m) {
  *
  * @param m  the memop
  */
-static void update_Phi_memop(memop_t *m) {
-	/* the Phi is it's own mem */
+static void update_Phi_memop(memop_t *m)
+{
+	/* the Phi is its own mem */
 	m->mem = m->node;
 }  /* update_Phi_memop */
 
 /**
  * Memory walker: collect all memory ops and build topological lists.
  */
-static void collect_memops(ir_node *irn, void *ctx) {
+static void collect_memops(ir_node *irn, void *ctx)
+{
 	memop_t  *op;
 	ir_node  *block;
 	block_t  *entry;
@@ -1214,7 +1251,8 @@ static void collect_memops(ir_node *irn, void *ctx) {
 	(void) ctx;
 	if (is_Proj(irn)) {
 		/* we can safely ignore ProjM's except the initial memory */
-		if (irn != get_irg_initial_mem(current_ir_graph))
+		ir_graph *irg = get_irn_irg(irn);
+		if (irn != get_irg_initial_mem(irg))
 			return;
 	}
 
@@ -1253,8 +1291,6 @@ static void collect_memops(ir_node *irn, void *ctx) {
 			/* we can those to find the memory edge */
 			break;
 		case iro_Div:
-		case iro_DivMod:
-		case iro_Quot:
 		case iro_Mod:
 			update_DivOp_memop(op);
 			break;
@@ -1286,7 +1322,8 @@ static void collect_memops(ir_node *irn, void *ctx) {
  *         not exists in the set or cannot be converted into
  *         the requested mode
  */
-static memop_t *find_address(const value_t *value) {
+static memop_t *find_address(const value_t *value)
+{
 	if (rbitset_is_set(env.curr_set, value->id)) {
 		memop_t *res = env.curr_id_2_memop[value->id];
 
@@ -1306,7 +1343,8 @@ static memop_t *find_address(const value_t *value) {
  *
  * @param bl     the block
  */
-static memop_t *find_address_avail(const block_t *bl, unsigned id, const ir_mode *mode) {
+static memop_t *find_address_avail(const block_t *bl, unsigned id, const ir_mode *mode)
+{
 	if (rbitset_is_set(bl->avail_out, id)) {
 		memop_t *res = bl->id_2_memop_avail[id];
 
@@ -1324,7 +1362,8 @@ static memop_t *find_address_avail(const block_t *bl, unsigned id, const ir_mode
 /**
  * Kill all addresses from the current set.
  */
-static void kill_all(void) {
+static void kill_all(void)
+{
 	rbitset_clear_all(env.curr_set, env.rbs_size);
 
 	/* set sentinel */
@@ -1336,14 +1375,15 @@ static void kill_all(void) {
  *
  * @param value  the Store value
  */
-static void kill_memops(const value_t *value) {
-	unsigned end = env.rbs_size - 1;
-	unsigned pos;
+static void kill_memops(const value_t *value)
+{
+	size_t end = env.rbs_size - 1;
+	size_t pos;
 
 	for (pos = rbitset_next(env.curr_set, 0, 1); pos < end; pos = rbitset_next(env.curr_set, pos + 1, 1)) {
 		memop_t *op = env.curr_id_2_memop[pos];
 
-		if (ir_no_alias != get_alias_relation(current_ir_graph, value->address, value->mode,
+		if (ir_no_alias != get_alias_relation(value->address, value->mode,
 			                                  op->value.address, op->value.mode)) {
 			rbitset_clear(env.curr_set, pos);
 			env.curr_id_2_memop[pos] = NULL;
@@ -1357,7 +1397,8 @@ static void kill_memops(const value_t *value) {
  *
  * @param op  the memory op
  */
-static void add_memop(memop_t *op) {
+static void add_memop(memop_t *op)
+{
 	rbitset_set(env.curr_set, op->value.id);
 	env.curr_id_2_memop[op->value.id] = op;
 }  /* add_memop */
@@ -1368,7 +1409,8 @@ static void add_memop(memop_t *op) {
  * @param bl  the block
  * @param op  the memory op
  */
-static void add_memop_avail(block_t *bl, memop_t *op) {
+static void add_memop_avail(block_t *bl, memop_t *op)
+{
 	rbitset_set(bl->avail_out, op->value.id);
 	bl->id_2_memop_avail[op->value.id] = op;
 }  /* add_memop_avail */
@@ -1380,7 +1422,8 @@ static void add_memop_avail(block_t *bl, memop_t *op) {
  * @param from  the original mode
  * @param to    the destination mode
  */
-static int can_convert_to(const ir_mode *from, const ir_mode *to) {
+static int can_convert_to(const ir_mode *from, const ir_mode *to)
+{
 	if (get_mode_arithmetic(from) == irma_twos_complement &&
 	    get_mode_arithmetic(to) == irma_twos_complement &&
 	    get_mode_size_bits(from) == get_mode_size_bits(to))
@@ -1397,7 +1440,8 @@ static int can_convert_to(const ir_mode *from, const ir_mode *to) {
  * @return the possible converted node or NULL
  *         if the conversion is not possible
  */
-static ir_node *conv_to(ir_node *irn, ir_mode *mode) {
+static ir_node *conv_to(ir_node *irn, ir_mode *mode)
+{
 	ir_mode *other = get_irn_mode(irn);
 	if (other != mode) {
 		/* different modes: check if conversion is possible without changing the bits */
@@ -1417,7 +1461,8 @@ static ir_node *conv_to(ir_node *irn, ir_mode *mode) {
  *
  * @param value  the value whose address is updated
  */
-static void update_address(value_t *value) {
+static void update_address(value_t *value)
+{
 	if (is_Proj(value->address)) {
 		ir_node *load = get_Proj_pred(value->address);
 
@@ -1436,7 +1481,8 @@ static void update_address(value_t *value) {
  *
  * @param bl  the block
  */
-static void calc_gen_kill_avail(block_t *bl) {
+static void calc_gen_kill_avail(block_t *bl)
+{
 	memop_t *op;
 	ir_node *def;
 
@@ -1525,7 +1571,8 @@ static void calc_gen_kill_avail(block_t *bl) {
  *
  * @param block  the block
  */
-static void forward_avail(block_t *bl) {
+static void forward_avail(block_t *bl)
+{
 	/* fill the data from the current block */
 	env.curr_id_2_memop = bl->id_2_memop_avail;
 	env.curr_set        = bl->avail_out;
@@ -1542,7 +1589,8 @@ static void forward_avail(block_t *bl) {
  *
  * @return non-zero if the set has changed since last iteration
  */
-static int backward_antic(block_t *bl) {
+static int backward_antic(block_t *bl)
+{
 	memop_t *op;
 	ir_node *block = bl->block;
 	int     n = get_Block_n_cfg_outs(block);
@@ -1551,8 +1599,8 @@ static int backward_antic(block_t *bl) {
 		ir_node  *succ    = get_Block_cfg_out(block, 0);
 		block_t  *succ_bl = get_block_entry(succ);
 		int      pred_pos = get_Block_cfgpred_pos(succ, block);
-		unsigned end      = env.rbs_size - 1;
-		unsigned pos;
+		size_t   end      = env.rbs_size - 1;
+		size_t   pos;
 
 		kill_all();
 
@@ -1647,7 +1695,7 @@ static int backward_antic(block_t *bl) {
 	}
 
 	memcpy(bl->id_2_memop_antic, env.curr_id_2_memop, env.rbs_size * sizeof(env.curr_id_2_memop[0]));
-	if (! rbitset_equal(bl->anticL_in, env.curr_set, env.rbs_size)) {
+	if (! rbitsets_equal(bl->anticL_in, env.curr_set, env.rbs_size)) {
 		/* changed */
 		rbitset_copy(bl->anticL_in, env.curr_set, env.rbs_size);
 		dump_curr(bl, "AnticL_in*");
@@ -1662,7 +1710,8 @@ static int backward_antic(block_t *bl) {
  *
  * @param op  the Load memop
  */
-static void replace_load(memop_t *op) {
+static void replace_load(memop_t *op)
+{
 	ir_node *load = op->node;
 	ir_node *def  = skip_Id(op->replace);
 	ir_node *proj;
@@ -1696,7 +1745,8 @@ static void replace_load(memop_t *op) {
 	}
 	proj = op->projs[pn_Load_X_except];
 	if (proj != NULL) {
-		exchange(proj, new_Bad());
+		ir_graph *irg = get_irn_irg(load);
+		exchange(proj, new_r_Bad(irg));
 	}
 	proj = op->projs[pn_Load_X_regular];
 	if (proj != NULL) {
@@ -1709,7 +1759,8 @@ static void replace_load(memop_t *op) {
  *
  * @param op  the Store memop
  */
-static void remove_store(memop_t *op) {
+static void remove_store(memop_t *op)
+{
 	ir_node *store = op->node;
 	ir_node *proj;
 
@@ -1721,7 +1772,8 @@ static void remove_store(memop_t *op) {
 	}
 	proj = op->projs[pn_Store_X_except];
 	if (proj != NULL) {
-		exchange(proj, new_Bad());
+		ir_graph *irg = get_irn_irg(store);
+		exchange(proj, new_r_Bad(irg));
 	}
 	proj = op->projs[pn_Store_X_regular];
 	if (proj != NULL) {
@@ -1735,7 +1787,8 @@ static void remove_store(memop_t *op) {
  *
  * @param bl  the block
  */
-static void do_replacements(block_t *bl) {
+static void do_replacements(block_t *bl)
+{
 	memop_t *op;
 
 	for (op = bl->memop_forward; op != NULL; op = op->next) {
@@ -1755,7 +1808,8 @@ static void do_replacements(block_t *bl) {
 /**
  * Calculate the Avail_out sets for all basic blocks.
  */
-static void calcAvail(void) {
+static void calcAvail(void)
+{
 	memop_t  **tmp_memop = env.curr_id_2_memop;
 	unsigned *tmp_set    = env.curr_set;
 	block_t  *bl;
@@ -1776,7 +1830,8 @@ static void calcAvail(void) {
 /**
  * Calculate the Antic_in sets for all basic blocks.
  */
-static void calcAntic(void) {
+static void calcAntic(void)
+{
 	int i, need_iter;
 
 	/* calculate antic_out */
@@ -1803,7 +1858,8 @@ static void calcAntic(void) {
  *
  * @param bl  the block
  */
-static ir_node *find_last_memory(block_t *bl) {
+static ir_node *find_last_memory(block_t *bl)
+{
 	for (;;) {
 		if (bl->memop_backward != NULL) {
 			return bl->memop_backward->mem;
@@ -1820,7 +1876,8 @@ static ir_node *find_last_memory(block_t *bl) {
  * @param omem  the old memory IR-node
  * @param nmem  the new memory IR-node
  */
-static void reroute_all_mem_users(ir_node *omem, ir_node *nmem) {
+static void reroute_all_mem_users(ir_node *omem, ir_node *nmem)
+{
 	int i;
 
 	for (i = get_irn_n_outs(omem) - 1; i >= 0; --i) {
@@ -1842,7 +1899,8 @@ static void reroute_all_mem_users(ir_node *omem, ir_node *nmem) {
  * @param nmem     the new memory IR-node
  * @param pass_bl  the block the memory must pass
  */
-static void reroute_mem_through(ir_node *omem, ir_node *nmem, ir_node *pass_bl) {
+static void reroute_mem_through(ir_node *omem, ir_node *nmem, ir_node *pass_bl)
+{
 	int             i, j, n = get_irn_n_outs(omem);
 	ir_def_use_edge *edges = NEW_ARR_D(ir_def_use_edge, &env.obst, n + 1);
 
@@ -1876,11 +1934,11 @@ static void reroute_mem_through(ir_node *omem, ir_node *nmem, ir_node *pass_bl)
 /**
  * insert Loads, making partly redundant Loads fully redundant
  */
-static int insert_Load(block_t *bl) {
+static int insert_Load(block_t *bl)
+{
 	ir_node  *block = bl->block;
 	int      i, n = get_Block_n_cfgpreds(block);
-	unsigned end = env.rbs_size - 1;
-	unsigned pos;
+	size_t   end = env.rbs_size - 1;
 
 	DB((dbg, LEVEL_3, "processing %+F\n", block));
 
@@ -1891,7 +1949,7 @@ static int insert_Load(block_t *bl) {
 
 	if (n > 1) {
 		ir_node **ins;
-		int     pos;
+		size_t    pos;
 
 		NEW_ARR_A(ir_node *, ins, n);
 
@@ -1918,9 +1976,9 @@ static int insert_Load(block_t *bl) {
 		}
 		/*
 		 * Ensure that all values are in the map: build Phi's if necessary:
-		 * Note: the last bit is the sentinel and ALWAYS set, so start with -2.
+		 * Note: the last bit is the sentinel and ALWAYS set, so end with -2.
 		 */
-		for (pos = env.rbs_size - 2; pos >= 0; --pos) {
+		for (pos = 0; pos < env.rbs_size - 1; ++pos) {
 			if (! rbitset_is_set(env.curr_set, pos))
 				env.curr_id_2_memop[pos] = NULL;
 			else {
@@ -1984,6 +2042,8 @@ static int insert_Load(block_t *bl) {
 	}
 
 	if (n > 1) {
+		size_t pos;
+
 		/* check for partly redundant values */
 		for (pos = rbitset_next(bl->anticL_in, 0, 1);
 		     pos < end;
@@ -2061,11 +2121,11 @@ static int insert_Load(block_t *bl) {
 						assert(last_mem != NULL);
 						adr  = phi_translate(op->value.address, block, i);
 						load = new_rd_Load(db, pred, last_mem, adr, mode, cons_none);
-						def  = new_r_Proj(pred, load, mode, pn_Load_res);
+						def  = new_r_Proj(load, mode, pn_Load_res);
 						DB((dbg, LEVEL_1, "Created new %+F in %+F for party redundant %+F\n", load, pred, op->node));
 
 						new_op                = alloc_memop(load);
-						new_op->mem           = new_r_Proj(pred, load, mode_M, pn_Load_M);
+						new_op->mem           = new_r_Proj(load, mode_M, pn_Load_M);
 						new_op->value.address = adr;
 						new_op->value.id      = op->value.id;
 						new_op->value.mode    = mode;
@@ -2114,7 +2174,7 @@ static int insert_Load(block_t *bl) {
 	/* always update the map after gen/kill, as values might have been changed due to RAR/WAR/WAW */
 	memcpy(bl->id_2_memop_avail, env.curr_id_2_memop, env.rbs_size * sizeof(env.curr_id_2_memop[0]));
 
-	if (!rbitset_equal(bl->avail_out, env.curr_set, env.rbs_size)) {
+	if (!rbitsets_equal(bl->avail_out, env.curr_set, env.rbs_size)) {
 		/* the avail set has changed */
 		rbitset_copy(bl->avail_out, env.curr_set, env.rbs_size);
 		dump_curr(bl, "Avail_out*");
@@ -2127,7 +2187,8 @@ static int insert_Load(block_t *bl) {
 /**
  * Insert Loads upwards.
  */
-static void insert_Loads_upwards(void) {
+static void insert_Loads_upwards(void)
+{
 	int i, need_iter;
 	block_t *bl;
 
@@ -2155,7 +2216,8 @@ static void insert_Loads_upwards(void) {
  *
  * @param irg  the graph to operate on
  */
-static void kill_unreachable_blocks(ir_graph *irg) {
+static void kill_unreachable_blocks(ir_graph *irg)
+{
 	block_t *bl;
 	ir_node **ins;
 	int     changed = 0;
@@ -2246,22 +2308,17 @@ static void kill_unreachable_blocks(ir_graph *irg) {
 	}
 }  /* kill_unreachable_blocks */
 
-int opt_ldst(ir_graph *irg) {
-	block_t  *bl;
-	ir_graph *rem = current_ir_graph;
-
-	current_ir_graph = irg;
+int opt_ldst(ir_graph *irg)
+{
+	block_t *bl;
 
 	FIRM_DBG_REGISTER(dbg, "firm.opt.ldst");
-//	firm_dbg_set_mask(dbg, -1);
 
 	DB((dbg, LEVEL_1, "\nDoing Load/Store optimization on %+F\n", irg));
 
 	/* we need landing pads */
 	remove_critical_cf_edges(irg);
 
-//	dump_ir_block_graph(irg, "-XXX");
-
 	if (get_opt_alias_analysis()) {
 		assure_irg_entity_usage_computed(irg);
 		assure_irp_globals_entity_usage_computed();
@@ -2362,7 +2419,6 @@ int opt_ldst(ir_graph *irg) {
 		memset(bl->id_2_memop_antic, 0, env.rbs_size * sizeof(bl->id_2_memop_antic[0]));
 	}
 
-//	dump_block_list(&env);
 	(void) dump_block_list;
 
 	calcAvail();
@@ -2387,13 +2443,10 @@ end:
 	ir_nodemap_destroy(&env.adr_map);
 	obstack_free(&env.obst, NULL);
 
-//	dump_ir_block_graph(irg, "-YYY");
-
 #ifdef DEBUG_libfirm
 	DEL_ARR_F(env.id_2_address);
 #endif
 
-	current_ir_graph = rem;
 	return env.changed != 0;
 }  /* opt_ldst */