X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ir%2Flower%2Flower_dw.c;h=936e07c5f319c3e3fe6b56f4d9097834b4d89ffa;hb=bdc59608633f59b0541a04883c24d19b1bc0ffae;hp=0aa2a83b53ea6482dfc7b4ffbb787b8e7a2c4b86;hpb=376e7c78961ff5605f8b1241191c7ec9c22e352b;p=libfirm

diff --git a/ir/lower/lower_dw.c b/ir/lower/lower_dw.c
index 0aa2a83b5..936e07c5f 100644
--- a/ir/lower/lower_dw.c
+++ b/ir/lower/lower_dw.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2010 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -19,7 +19,7 @@
 
 /**
  * @file
- * @brief   Lower Double word operations, ie 64bit -> 32bit, 32bit -> 16bit etc.
+ * @brief   Lower double word operations, i.e. 64bit -> 32bit, 32bit -> 16bit etc.
  * @date    8.10.2004
  * @author  Michael Beck
  * @version $Id$
@@ -138,6 +138,9 @@ struct lower_env_t {
 	ir_type  *value_param_tp;     /**< the old value param type */
 };
 
+static void lower_node(lower_env_t *env, ir_node *node);
+static bool mtp_must_be_lowered(lower_env_t *env, ir_type *mtp);
+
 /**
  * Create a method type for a Conv emulation from imode to omode.
  */
@@ -250,8 +253,6 @@ static ir_mode *get_irn_op_mode(ir_node *node)
 		return get_Load_mode(node);
 	case iro_Store:
 		return get_irn_mode(get_Store_value(node));
-	case iro_DivMod:
-		return get_irn_mode(get_DivMod_left(node));
 	case iro_Div:
 		return get_irn_mode(get_Div_left(node));
 	case iro_Mod:
@@ -628,14 +629,6 @@ static void lower_Mod(ir_node *node, ir_mode *mode, lower_env_t *env)
 	}
 }
 
-static void lower_DivMod(ir_node *node, ir_mode *mode, lower_env_t *env)
-{
-	(void) node;
-	(void) mode;
-	(void) env;
-	panic("DivMod is deprecated, no doubleword lowering");
-}
-
 /**
  * Translate a binop.
  *
@@ -990,21 +983,42 @@ static void lower_Not(ir_node *node, ir_mode *mode, lower_env_t *env)
 	set_lowered(env, node, res_low, res_high);
 }
 
+static bool is_equality_cmp_0(const ir_node *node)
+{
+	ir_relation relation = get_Cmp_relation(node);
+	ir_node    *left     = get_Cmp_left(node);
+	ir_node    *right    = get_Cmp_right(node);
+	ir_mode    *mode     = get_irn_mode(left);
+
+	/* this probably makes no sense if unordered is involved */
+	assert(!mode_is_float(mode));
+
+	if (!is_Const(right) || !is_Const_null(right))
+		return false;
+	if (relation == ir_relation_equal)
+		return true;
+	if (mode_is_signed(mode)) {
+		return relation == ir_relation_less_greater;
+	} else {
+		return relation == ir_relation_greater;
+	}
+}
+
 /**
  * Translate a Cond.
  */
 static void lower_Cond(ir_node *node, ir_mode *mode, lower_env_t *env)
 {
-	ir_node *cmp, *left, *right, *block;
+	ir_node *left, *right, *block;
 	ir_node *sel = get_Cond_selector(node);
 	ir_mode *m = get_irn_mode(sel);
 	ir_mode *cmp_mode;
 	const node_entry_t *lentry, *rentry;
 	ir_node  *proj, *projT = NULL, *projF = NULL;
-	ir_node  *new_bl, *cmpH, *cmpL, *irn;
+	ir_node  *new_bl, *irn;
 	ir_node  *projHF, *projHT;
 	ir_node  *dst_blk;
-	pn_Cmp   pnc;
+	ir_relation relation;
 	ir_graph *irg;
 	dbg_info *dbg;
 
@@ -1015,22 +1029,25 @@ static void lower_Cond(ir_node *node, ir_mode *mode, lower_env_t *env)
 			/* bad we can't really handle Switch with 64bit offsets */
 			panic("Cond with 64bit jumptable not supported");
 		}
+		lower_node(env, sel);
 		return;
 	}
 
-	if (!is_Proj(sel))
-		return;
-
-	cmp = get_Proj_pred(sel);
-	if (!is_Cmp(cmp))
+	if (!is_Cmp(sel)) {
+		lower_node(env, sel);
 		return;
+	}
 
-	left     = get_Cmp_left(cmp);
+	left     = get_Cmp_left(sel);
 	cmp_mode = get_irn_mode(left);
-	if (cmp_mode != env->high_signed && cmp_mode != env->high_unsigned)
+	if (cmp_mode != env->high_signed && cmp_mode != env->high_unsigned) {
+		lower_node(env, sel);
 		return;
+	}
 
-	right  = get_Cmp_right(cmp);
+	right  = get_Cmp_right(sel);
+	lower_node(env, left);
+	lower_node(env, right);
 	lentry = get_node_entry(env, left);
 	rentry = get_node_entry(env, right);
 
@@ -1052,36 +1069,31 @@ static void lower_Cond(ir_node *node, ir_mode *mode, lower_env_t *env)
 	assert(projT && projF);
 
 	/* create a new high compare */
-	block = get_nodes_block(node);
-	irg   = get_Block_irg(block);
-	dbg   = get_irn_dbg_info(cmp);
-	pnc   = get_Proj_pn_cmp(sel);
-
-	if (is_Const(right) && is_Const_null(right)) {
-		if (pnc == pn_Cmp_Eq || pnc == pn_Cmp_Lg) {
-			/* x ==/!= 0 ==> or(low,high) ==/!= 0 */
-			ir_mode *mode   = env->low_unsigned;
-			ir_node *low    = new_r_Conv(block, lentry->low_word, mode);
-			ir_node *high   = new_r_Conv(block, lentry->high_word, mode);
-			ir_node *ornode = new_rd_Or(dbg, block, low, high, mode);
-			ir_node *cmp    = new_rd_Cmp(dbg, block, ornode, new_r_Const_long(irg, mode, 0));
-
-			ir_node *proj = new_r_Proj(cmp, mode_b, pnc);
-			set_Cond_selector(node, proj);
-			return;
-		}
-	}
+	block    = get_nodes_block(node);
+	irg      = get_Block_irg(block);
+	dbg      = get_irn_dbg_info(sel);
+	relation = get_Cmp_relation(sel);
 
-	cmpH = new_rd_Cmp(dbg, block, lentry->high_word, rentry->high_word);
+	if (is_equality_cmp_0(sel)) {
+		/* x ==/!= 0 ==> or(low,high) ==/!= 0 */
+		ir_mode *mode   = env->low_unsigned;
+		ir_node *low    = new_r_Conv(block, lentry->low_word, mode);
+		ir_node *high   = new_r_Conv(block, lentry->high_word, mode);
+		ir_node *ornode = new_rd_Or(dbg, block, low, high, mode);
+		ir_node *cmp    = new_rd_Cmp(dbg, block, ornode, new_r_Const_long(irg, mode, 0), relation);
+		set_Cond_selector(node, cmp);
+		return;
+	}
 
-	if (pnc == pn_Cmp_Eq) {
+	if (relation == ir_relation_equal) {
 		/* simple case:a == b <==> a_h == b_h && a_l == b_l */
 		pmap_entry *entry = pmap_find(env->proj_2_block, projF);
 
 		assert(entry);
 		dst_blk = (ir_node*)entry->value;
 
-		irn = new_r_Proj(cmpH, mode_b, pn_Cmp_Eq);
+		irn = new_rd_Cmp(dbg, block, lentry->high_word, rentry->high_word,
+		                 ir_relation_equal);
 		dbg = get_irn_dbg_info(node);
 		irn = new_rd_Cond(dbg, block, irn);
 
@@ -1094,9 +1106,9 @@ static void lower_Cond(ir_node *node, ir_mode *mode, lower_env_t *env)
 
 		new_bl = new_r_Block(irg, 1, &projHT);
 
-		dbg   = get_irn_dbg_info(cmp);
-		cmpL = new_rd_Cmp(dbg, new_bl, lentry->low_word, rentry->low_word);
-		irn = new_r_Proj(cmpL, mode_b, pn_Cmp_Eq);
+		dbg = get_irn_dbg_info(sel);
+		irn = new_rd_Cmp(dbg, new_bl, lentry->low_word, rentry->low_word,
+		                  ir_relation_equal);
 		dbg = get_irn_dbg_info(node);
 		irn = new_rd_Cond(dbg, new_bl, irn);
 
@@ -1107,14 +1119,15 @@ static void lower_Cond(ir_node *node, ir_mode *mode, lower_env_t *env)
 		proj = new_r_Proj(irn, mode_X, pn_Cond_true);
 		mark_irn_visited(proj);
 		exchange(projT, proj);
-	} else if (pnc == pn_Cmp_Lg) {
+	} else if (relation == ir_relation_less_greater) {
 		/* simple case:a != b <==> a_h != b_h || a_l != b_l */
 		pmap_entry *entry = pmap_find(env->proj_2_block, projT);
 
 		assert(entry);
 		dst_blk = (ir_node*)entry->value;
 
-		irn = new_r_Proj(cmpH, mode_b, pn_Cmp_Lg);
+		irn = new_rd_Cmp(dbg, block, lentry->high_word, rentry->high_word,
+		                 ir_relation_less_greater);
 		dbg = get_irn_dbg_info(node);
 		irn = new_rd_Cond(dbg, block, irn);
 
@@ -1127,9 +1140,9 @@ static void lower_Cond(ir_node *node, ir_mode *mode, lower_env_t *env)
 
 		new_bl = new_r_Block(irg, 1, &projHF);
 
-		dbg   = get_irn_dbg_info(cmp);
-		cmpL = new_rd_Cmp(dbg, new_bl, lentry->low_word, rentry->low_word);
-		irn = new_r_Proj(cmpL, mode_b, pn_Cmp_Lg);
+		dbg = get_irn_dbg_info(sel);
+		irn = new_rd_Cmp(dbg, new_bl, lentry->low_word, rentry->low_word,
+		                 ir_relation_less_greater);
 		dbg = get_irn_dbg_info(node);
 		irn = new_rd_Cond(dbg, new_bl, irn);
 
@@ -1153,7 +1166,8 @@ static void lower_Cond(ir_node *node, ir_mode *mode, lower_env_t *env)
 		assert(entry);
 		dstF = (ir_node*)entry->value;
 
-		irn = new_r_Proj(cmpH, mode_b, pnc & ~pn_Cmp_Eq);
+		irn = new_rd_Cmp(dbg, block, lentry->high_word, rentry->high_word,
+		                 relation & ~ir_relation_equal);
 		dbg = get_irn_dbg_info(node);
 		irn = new_rd_Cond(dbg, block, irn);
 
@@ -1167,7 +1181,8 @@ static void lower_Cond(ir_node *node, ir_mode *mode, lower_env_t *env)
 
 		newbl_eq = new_r_Block(irg, 1, &projHF);
 
-		irn = new_r_Proj(cmpH, mode_b, pn_Cmp_Eq);
+		irn = new_rd_Cmp(dbg, block, lentry->high_word, rentry->high_word,
+		                 ir_relation_equal);
 		irn = new_rd_Cond(dbg, newbl_eq, irn);
 
 		proj = new_r_Proj(irn, mode_X, pn_Cond_false);
@@ -1180,9 +1195,9 @@ static void lower_Cond(ir_node *node, ir_mode *mode, lower_env_t *env)
 
 		newbl_l = new_r_Block(irg, 1, &proj);
 
-		dbg   = get_irn_dbg_info(cmp);
-		cmpL = new_rd_Cmp(dbg, newbl_l, lentry->low_word, rentry->low_word);
-		irn = new_r_Proj(cmpL, mode_b, pnc);
+		dbg = get_irn_dbg_info(sel);
+		irn = new_rd_Cmp(dbg, newbl_l, lentry->low_word, rentry->low_word,
+		                 relation);
 		dbg = get_irn_dbg_info(node);
 		irn = new_rd_Cond(dbg, newbl_l, irn);
 
@@ -1302,66 +1317,68 @@ static void lower_Conv_from_Ll(ir_node *node, lower_env_t *env)
 }
 
 /**
- * lower boolean Proj(Cmp)
+ * lower Cmp
  */
-static void lower_Proj_Cmp(lower_env_t *env, ir_node *proj)
+static void lower_Cmp(ir_node *cmp, ir_mode *m, lower_env_t *env)
 {
-	ir_node  *cmp  = get_Proj_pred(proj);
 	ir_node  *l    = get_Cmp_left(cmp);
 	ir_mode  *mode = get_irn_mode(l);
 	ir_node  *r, *low, *high, *t, *res;
-	pn_Cmp    pnc;
-	ir_node  *blk;
-	dbg_info *db;
+	ir_relation relation;
+	ir_node  *block;
+	dbg_info *dbg;
 	const node_entry_t *lentry;
 	const node_entry_t *rentry;
+	(void) m;
 
-	if (mode != env->high_signed && mode != env->high_unsigned) {
+	if (mode != env->high_signed && mode != env->high_unsigned)
 		return;
-	}
 
-	r      = get_Cmp_right(cmp);
-	lentry = get_node_entry(env, l);
-	rentry = get_node_entry(env, r);
-	pnc    = get_Proj_pn_cmp(proj);
-	blk    = get_nodes_block(cmp);
-	db     = get_irn_dbg_info(cmp);
-	low    = new_rd_Cmp(db, blk, lentry->low_word, rentry->low_word);
-	high   = new_rd_Cmp(db, blk, lentry->high_word, rentry->high_word);
+	r        = get_Cmp_right(cmp);
+	lentry   = get_node_entry(env, l);
+	rentry   = get_node_entry(env, r);
+	relation = get_Cmp_relation(cmp);
+	block    = get_nodes_block(cmp);
+	dbg      = get_irn_dbg_info(cmp);
+
+	/* easy case for x ==/!= 0 (see lower_Cond for details) */
+	if (is_equality_cmp_0(cmp)) {
+		ir_graph *irg     = get_irn_irg(cmp);
+		ir_mode  *mode    = env->low_unsigned;
+		ir_node  *low     = new_r_Conv(block, lentry->low_word, mode);
+		ir_node  *high    = new_r_Conv(block, lentry->high_word, mode);
+		ir_node  *ornode  = new_rd_Or(dbg, block, low, high, mode);
+		ir_node  *new_cmp = new_rd_Cmp(dbg, block, ornode, new_r_Const_long(irg, mode, 0), relation);
+		exchange(cmp, new_cmp);
+		return;
+	}
 
-	if (pnc == pn_Cmp_Eq) {
+	if (relation == ir_relation_equal) {
 		/* simple case:a == b <==> a_h == b_h && a_l == b_l */
-		res = new_rd_And(db, blk,
-			new_r_Proj(low, mode_b, pnc),
-			new_r_Proj(high, mode_b, pnc),
-			mode_b);
-	} else if (pnc == pn_Cmp_Lg) {
+		low  = new_rd_Cmp(dbg, block, lentry->low_word, rentry->low_word,
+		                  relation);
+		high = new_rd_Cmp(dbg, block, lentry->high_word, rentry->high_word,
+		                  relation);
+		res  = new_rd_And(dbg, block, low, high, mode_b);
+	} else if (relation == ir_relation_less_greater) {
 		/* simple case:a != b <==> a_h != b_h || a_l != b_l */
-		res = new_rd_Or(db, blk,
-			new_r_Proj(low, mode_b, pnc),
-			new_r_Proj(high, mode_b, pnc),
-			mode_b);
+		low  = new_rd_Cmp(dbg, block, lentry->low_word, rentry->low_word,
+		                  relation);
+		high = new_rd_Cmp(dbg, block, lentry->high_word, rentry->high_word,
+		                  relation);
+		res = new_rd_Or(dbg, block, low, high, mode_b);
 	} else {
 		/* a rel b <==> a_h REL b_h || (a_h == b_h && a_l rel b_l) */
-		t = new_rd_And(db, blk,
-			new_r_Proj(low, mode_b, pnc),
-			new_r_Proj(high, mode_b, pn_Cmp_Eq),
-			mode_b);
-		res = new_rd_Or(db, blk,
-			new_r_Proj(high, mode_b, pnc & ~pn_Cmp_Eq),
-			t,
-			mode_b);
-	}
-	exchange(proj, res);
-}
-
-static void lower_Proj(ir_node *node, ir_mode *mode, lower_env_t *env)
-{
-	ir_node *pred = get_Proj_pred(node);
-	(void) mode;
-	if (is_Cmp(pred)) {
-		lower_Proj_Cmp(env, node);
-	}
+		ir_node *high1 = new_rd_Cmp(dbg, block, lentry->high_word,
+			rentry->high_word, relation & ~ir_relation_equal);
+		low  = new_rd_Cmp(dbg, block, lentry->low_word, rentry->low_word,
+		                  relation);
+		high = new_rd_Cmp(dbg, block, lentry->high_word, rentry->high_word,
+		                  ir_relation_equal);
+		t = new_rd_And(dbg, block, low, high, mode_b);
+		res = new_rd_Or(dbg, block, high1, t, mode_b);
+	}
+	exchange(cmp, res);
 }
 
 /**
@@ -1382,6 +1399,27 @@ static void lower_Conv(ir_node *node, ir_mode *mode, lower_env_t *env)
 	}
 }
 
+/**
+ * Remember the new argument index of this value type entity in the lowered
+ * method type.
+ *
+ * @param ent  the entity
+ * @param pos  the argument index of this entity
+ */
+static inline void set_entity_arg_idx(ir_entity *ent, size_t pos)
+{
+	set_entity_link(ent, INT_TO_PTR(pos));
+}
+
+/**
+ * Retrieve the argument index of a value type entity.
+ *
+ * @param ent  the entity
+ */
+static size_t get_entity_arg_idx(const ir_entity *ent) {
+	return PTR_TO_INT(get_entity_link(ent));
+}
+
 /**
  * Lower the method type.
  *
@@ -1393,20 +1431,16 @@ static void lower_Conv(ir_node *node, ir_mode *mode, lower_env_t *env)
 static ir_type *lower_mtp(lower_env_t *env, ir_type *mtp)
 {
 	pmap_entry *entry;
-	ident      *lid;
 	ir_type    *res, *value_type;
 
-	if (is_lowered_type(mtp))
-		return mtp;
-
 	entry = pmap_find(lowered_type, mtp);
 	if (! entry) {
-		int i, n, r, n_param, n_res;
+		size_t i, orig_n_params, orig_n_res, n_param, n_res;
 
 		/* count new number of params */
-		n_param = n = get_method_n_params(mtp);
-		for (i = n_param - 1; i >= 0; --i) {
-			ir_type *tp = get_method_param_type(mtp, i);
+		n_param = orig_n_params = get_method_n_params(mtp);
+		for (i = orig_n_params; i > 0;) {
+			ir_type *tp = get_method_param_type(mtp, --i);
 
 			if (is_Primitive_type(tp)) {
 				ir_mode *mode = get_type_mode(tp);
@@ -1418,9 +1452,9 @@ static ir_type *lower_mtp(lower_env_t *env, ir_type *mtp)
 		}
 
 		/* count new number of results */
-		n_res = r = get_method_n_ress(mtp);
-		for (i = n_res - 1; i >= 0; --i) {
-			ir_type *tp = get_method_res_type(mtp, i);
+		n_res = orig_n_res = get_method_n_ress(mtp);
+		for (i = orig_n_res; i > 0;) {
+			ir_type *tp = get_method_res_type(mtp, --i);
 
 			if (is_Primitive_type(tp)) {
 				ir_mode *mode = get_type_mode(tp);
@@ -1434,7 +1468,7 @@ static ir_type *lower_mtp(lower_env_t *env, ir_type *mtp)
 		res = new_type_method(n_param, n_res);
 
 		/* set param types and result types */
-		for (i = n_param = 0; i < n; ++i) {
+		for (i = n_param = 0; i < orig_n_params; ++i) {
 			ir_type *tp = get_method_param_type(mtp, i);
 
 			if (is_Primitive_type(tp)) {
@@ -1453,7 +1487,7 @@ static ir_type *lower_mtp(lower_env_t *env, ir_type *mtp)
 				set_method_param_type(res, n_param++, tp);
 			}
 		}
-		for (i = n_res = 0; i < r; ++i) {
+		for (i = n_res = 0; i < orig_n_res; ++i) {
 			ir_type *tp = get_method_res_type(mtp, i);
 
 			if (is_Primitive_type(tp)) {
@@ -1480,33 +1514,20 @@ static ir_type *lower_mtp(lower_env_t *env, ir_type *mtp)
 			/* this creates a new value parameter type */
 			(void)get_method_value_param_ent(res, 0);
 
-			/* set new param positions */
-			for (i = n_param = 0; i < n; ++i) {
+			/* set new param positions for all entities of the value type */
+			for (i = n_param = 0; i < orig_n_params; ++i) {
 				ir_type   *tp  = get_method_param_type(mtp, i);
-				ident     *id  = get_method_param_ident(mtp, i);
 				ir_entity *ent = get_method_value_param_ent(mtp, i);
 
-				set_entity_link(ent, INT_TO_PTR(n_param));
+				set_entity_arg_idx(ent, n_param);
 				if (is_Primitive_type(tp)) {
 					ir_mode *mode = get_type_mode(tp);
 
 					if (mode == env->high_signed || mode == env->high_unsigned) {
-						if (id != NULL) {
-							lid = id_mangle(id, env->first_id);
-							set_method_param_ident(res, n_param, lid);
-							set_entity_ident(get_method_value_param_ent(res, n_param), lid);
-							lid = id_mangle(id, env->next_id);
-							set_method_param_ident(res, n_param + 1, lid);
-							set_entity_ident(get_method_value_param_ent(res, n_param + 1), lid);
-						}
 						n_param += 2;
 						continue;
 					}
 				}
-				if (id != NULL) {
-					set_method_param_ident(res, n_param, id);
-					set_entity_ident(get_method_value_param_ent(res, n_param), id);
-				}
 				++n_param;
 			}
 
@@ -1527,7 +1548,7 @@ static void lower_Return(ir_node *node, ir_mode *mode, lower_env_t *env)
 	ir_entity *ent = get_irg_entity(irg);
 	ir_type   *mtp = get_entity_type(ent);
 	ir_node  **in;
-	int        i, j, n;
+	size_t     i, j, n;
 	int        need_conv = 0;
 	(void) mode;
 
@@ -1576,50 +1597,42 @@ static void lower_Start(ir_node *node, ir_mode *mode, lower_env_t *env)
 	ir_graph  *irg = get_irn_irg(node);
 	ir_entity *ent = get_irg_entity(irg);
 	ir_type   *tp  = get_entity_type(ent);
-	ir_type   *mtp;
 	long      *new_projs;
-	int       i, j, n_params, rem;
+	size_t    i, j, n_params;
+	int       rem;
 	ir_node   *proj, *args;
 	(void) mode;
 
-	if (is_lowered_type(tp)) {
-		mtp = get_associated_type(tp);
-	} else {
-		mtp = tp;
-	}
-	assert(! is_lowered_type(mtp));
+	if (!mtp_must_be_lowered(env, tp)) return;
 
-	n_params = get_method_n_params(mtp);
-	if (n_params <= 0)
-		return;
+	n_params = get_method_n_params(tp);
 
 	NEW_ARR_A(long, new_projs, n_params);
 
-	/* first check if we have parameters that must be fixed */
+	/* Calculate mapping of proj numbers in new_projs */
 	for (i = j = 0; i < n_params; ++i, ++j) {
-		ir_type *tp = get_method_param_type(mtp, i);
+		ir_type *ptp = get_method_param_type(tp, i);
 
 		new_projs[i] = j;
-		if (is_Primitive_type(tp)) {
-			ir_mode *mode = get_type_mode(tp);
+		if (is_Primitive_type(ptp)) {
+			ir_mode *mode = get_type_mode(ptp);
 
 			if (mode == env->high_signed ||
 				mode == env->high_unsigned)
 				++j;
 		}
 	}
-	if (i == j)
-		return;
 
-	mtp = lower_mtp(env, mtp);
-	set_entity_type(ent, mtp);
+	/* lower method type */
+	tp = lower_mtp(env, tp);
+	set_entity_type(ent, tp);
 
 	/* switch off optimization for new Proj nodes or they might be CSE'ed
 	   with not patched one's */
 	rem = get_optimize();
 	set_optimize(0);
 
-	/* ok, fix all Proj's and create new ones */
+	/* fix all Proj's and create new ones */
 	args = get_irg_args(irg);
 	for (proj = (ir_node*)get_irn_link(node); proj;
 	     proj = (ir_node*)get_irn_link(proj)) {
@@ -1665,28 +1678,20 @@ static void lower_Start(ir_node *node, ir_mode *mode, lower_env_t *env)
 static void lower_Call(ir_node *node, ir_mode *mode, lower_env_t *env)
 {
 	ir_type  *tp = get_Call_type(node);
-	ir_type  *call_tp;
 	ir_node  **in, *proj, *results;
-	int      n_params, n_res;
+	size_t   n_params, n_res;
 	bool     need_lower = false;
-	int      i, j;
+	size_t   i, j;
+	size_t   p;
 	long     *res_numbers = NULL;
 	(void) mode;
 
-	if (is_lowered_type(tp)) {
-		call_tp = get_associated_type(tp);
-	} else {
-		call_tp = tp;
-	}
-
-	assert(! is_lowered_type(call_tp));
+	n_params = get_method_n_params(tp);
+	for (p = 0; p < n_params; ++p) {
+		ir_type *ptp = get_method_param_type(tp, p);
 
-	n_params = get_method_n_params(call_tp);
-	for (i = 0; i < n_params; ++i) {
-		ir_type *tp = get_method_param_type(call_tp, i);
-
-		if (is_Primitive_type(tp)) {
-			ir_mode *mode = get_type_mode(tp);
+		if (is_Primitive_type(ptp)) {
+			ir_mode *mode = get_type_mode(ptp);
 
 			if (mode == env->high_signed || mode == env->high_unsigned) {
 				need_lower = true;
@@ -1694,16 +1699,16 @@ static void lower_Call(ir_node *node, ir_mode *mode, lower_env_t *env)
 			}
 		}
 	}
-	n_res = get_method_n_ress(call_tp);
+	n_res = get_method_n_ress(tp);
 	if (n_res > 0) {
 		NEW_ARR_A(long, res_numbers, n_res);
 
 		for (i = j = 0; i < n_res; ++i, ++j) {
-			ir_type *tp = get_method_res_type(call_tp, i);
+			ir_type *ptp = get_method_res_type(tp, i);
 
 			res_numbers[i] = j;
-			if (is_Primitive_type(tp)) {
-				ir_mode *mode = get_type_mode(tp);
+			if (is_Primitive_type(ptp)) {
+				ir_mode *mode = get_type_mode(ptp);
 
 				if (mode == env->high_signed || mode == env->high_unsigned) {
 					need_lower = true;
@@ -1717,10 +1722,10 @@ static void lower_Call(ir_node *node, ir_mode *mode, lower_env_t *env)
 		return;
 
 	/* let's lower it */
-	call_tp = lower_mtp(env, call_tp);
-	set_Call_type(node, call_tp);
+	tp = lower_mtp(env, tp);
+	set_Call_type(node, tp);
 
-	NEW_ARR_A(ir_node *, in, get_method_n_params(call_tp) + 2);
+	NEW_ARR_A(ir_node *, in, get_method_n_params(tp) + 2);
 
 	in[0] = get_Call_mem(node);
 	in[1] = get_Call_ptr(node);
@@ -1759,8 +1764,7 @@ static void lower_Call(ir_node *node, ir_mode *mode, lower_env_t *env)
 		/* switch off optimization for new Proj nodes or they might be CSE'ed
 		   with not patched one's */
 		set_optimize(0);
-		for (i = j = 0, proj = (ir_node*)get_irn_link(results); proj;
-		     proj = (ir_node*)get_irn_link(proj), ++i, ++j) {
+		for (proj = (ir_node*)get_irn_link(results); proj; proj = (ir_node*)get_irn_link(proj)) {
 			if (get_Proj_pred(proj) == results) {
 				long      proj_nr   = get_Proj_proj(proj);
 				ir_mode  *proj_mode = get_irn_mode(proj);
@@ -1915,30 +1919,106 @@ static void lower_Mux(ir_node *mux, ir_mode *mode, lower_env_t *env)
  */
 static void lower_ASM(ir_node *asmn, ir_mode *mode, lower_env_t *env)
 {
-	ir_mode *his = env->high_signed;
-	ir_mode *hiu = env->high_unsigned;
+	ir_mode           *high_signed        = env->high_signed;
+	ir_mode           *high_unsigned      = env->high_unsigned;
+	int                n_outs             = get_ASM_n_output_constraints(asmn);
+	ir_asm_constraint *output_constraints = get_ASM_output_constraints(asmn);
+	ir_asm_constraint *input_constraints  = get_ASM_input_constraints(asmn);
+	unsigned           n_64bit_outs       = 0;
 	int      i;
 	ir_node *n;
 
 	(void)mode;
 
 	for (i = get_irn_arity(asmn) - 1; i >= 0; --i) {
-		ir_mode *op_mode = get_irn_mode(get_irn_n(asmn, i));
-		if (op_mode == his || op_mode == hiu) {
-			panic("lowering ASM unimplemented");
+		ir_node *op      = get_irn_n(asmn, i);
+		ir_mode *op_mode = get_irn_mode(op);
+		if (op_mode == high_signed || op_mode == high_unsigned) {
+			panic("lowering ASM 64bit input unimplemented");
 		}
 	}
 
-	for (n = asmn;;) {
-		ir_mode *proj_mode;
+	for (i = 0; i < n_outs; ++i) {
+		const ir_asm_constraint *constraint = &output_constraints[i];
+		if (constraint->mode == high_signed || constraint->mode == high_unsigned) {
+			const char *constr = get_id_str(constraint->constraint);
+			++n_64bit_outs;
+			/* TODO: How to do this architecture neutral? This is very
+			 * i386 specific... */
+			if (constr[0] != '=' || constr[1] != 'A') {
+				panic("lowering ASM 64bit output only supports '=A' currently");
+			}
+		}
+	}
 
-		n = (ir_node*)get_irn_link(n);
-		if (n == NULL)
-			break;
+	if (n_64bit_outs == 0)
+		return;
+
+	{
+		dbg_info          *dbgi       = get_irn_dbg_info(asmn);
+		ir_node           *block      = get_nodes_block(asmn);
+		int                arity      = get_irn_arity(asmn);
+		ir_node          **in         = get_irn_in(asmn) + 1;
+		int                n_outs     = get_ASM_n_output_constraints(asmn);
+		int                new_n_outs = 0;
+		int                n_clobber  = get_ASM_n_clobbers(asmn);
+		long              *proj_map   = ALLOCAN(long, n_outs);
+		ident            **clobbers   = get_ASM_clobbers(asmn);
+		ident             *asm_text   = get_ASM_text(asmn);
+		ir_asm_constraint *new_outputs
+			= ALLOCAN(ir_asm_constraint, n_outs+n_64bit_outs);
+		ir_node           *new_asm;
+
+		for (i = 0; i < n_outs; ++i) {
+			const ir_asm_constraint *constraint = &output_constraints[i];
+			if (constraint->mode == high_signed || constraint->mode == high_unsigned) {
+				new_outputs[new_n_outs].pos        = constraint->pos;
+				new_outputs[new_n_outs].constraint = new_id_from_str("=a");
+				new_outputs[new_n_outs].mode       = env->low_unsigned;
+				proj_map[i] = new_n_outs;
+				++new_n_outs;
+				new_outputs[new_n_outs].pos        = constraint->pos;
+				new_outputs[new_n_outs].constraint = new_id_from_str("=d");
+				if (constraint->mode == high_signed)
+					new_outputs[new_n_outs].mode = env->low_signed;
+				else
+					new_outputs[new_n_outs].mode = env->low_unsigned;
+				++new_n_outs;
+			} else {
+				new_outputs[new_n_outs] = *constraint;
+				proj_map[i] = new_n_outs;
+				++new_n_outs;
+			}
+		}
+		assert(new_n_outs == n_outs+(int)n_64bit_outs);
+
+		new_asm = new_rd_ASM(dbgi, block, arity, in, input_constraints,
+		                     new_n_outs, new_outputs, n_clobber, clobbers,
+		                     asm_text);
 
-		proj_mode = get_irn_mode(n);
-		if (proj_mode == his || proj_mode == hiu) {
-			panic("lowering ASM unimplemented");
+		for (n = asmn;;) {
+			long pn;
+			ir_mode *proj_mode;
+			n = (ir_node*)get_irn_link(n);
+			if (n == NULL)
+				break;
+			proj_mode = get_irn_mode(n);
+			pn = get_Proj_proj(n);
+			if (pn < n_outs)
+				pn = proj_map[pn];
+			else
+				pn = new_n_outs + pn - n_outs;
+
+			if (proj_mode == high_signed || proj_mode == high_unsigned) {
+				ir_mode *high_mode
+					= proj_mode == high_signed ? env->low_signed : env->low_unsigned;
+				ir_node *np_low  = new_r_Proj(new_asm, env->low_unsigned, pn);
+				ir_node *np_high = new_r_Proj(new_asm, high_mode, pn+1);
+				set_lowered(env, n, np_low, np_high);
+			} else {
+				ir_node *np = new_r_Proj(new_asm, proj_mode, pn);
+				exchange(n, np);
+			}
 		}
 	}
 }
@@ -1955,7 +2035,7 @@ static void lower_Sel(ir_node *sel, ir_mode *mode, lower_env_t *env)
 	if (env->value_param_tp != NULL) {
 		ir_entity *ent = get_Sel_entity(sel);
 	    if (get_entity_owner(ent) == env->value_param_tp) {
-			int pos = PTR_TO_INT(get_entity_link(ent));
+			size_t pos = get_entity_arg_idx(ent);
 
 			ent = get_method_value_param_ent(env->l_mtp, pos);
 			set_Sel_entity(sel, ent);
@@ -2022,8 +2102,7 @@ static void enter_lower_func(ir_op *op, lower_func func)
  */
 static bool mtp_must_be_lowered(lower_env_t *env, ir_type *mtp)
 {
-	int n_params = get_method_n_params(mtp);
-	int i;
+	size_t i, n_params = get_method_n_params(mtp);
 
 	/* first check if we have parameters that must be fixed */
 	for (i = 0; i < n_params; ++i) {
@@ -2046,10 +2125,10 @@ static void setup_modes(lower_env_t *env)
 	unsigned           size_bits           = env->params->doubleword_size;
 	ir_mode           *doubleword_signed   = NULL;
 	ir_mode           *doubleword_unsigned = NULL;
-	int                n_modes             = get_irp_n_modes();
+	size_t             n_modes             = get_irp_n_modes();
 	ir_mode_arithmetic arithmetic;
 	unsigned           modulo_shift;
-	int                i;
+	size_t             i;
 
 	/* search for doubleword modes... */
 	for (i = 0; i < n_modes; ++i) {
@@ -2134,9 +2213,8 @@ static void lower_node(lower_env_t *env, ir_node *node)
 	unsigned      idx;
 	node_entry_t *entry;
 
-	if (irn_visited(node))
+	if (irn_visited_else_mark(node))
 		return;
-	mark_irn_visited(node);
 
 	/* cycles are always broken at Phi and Block nodes. So we don't need special
 	 * magic in all the other lower functions */
@@ -2154,10 +2232,12 @@ static void lower_node(lower_env_t *env, ir_node *node)
 		lower_node(env, block);
 	}
 
-	arity = get_irn_arity(node);
-	for (i = 0; i < arity; ++i) {
-		ir_node *pred = get_irn_n(node, i);
-		lower_node(env, pred);
+	if (!is_Cond(node)) {
+		arity = get_irn_arity(node);
+		for (i = 0; i < arity; ++i) {
+			ir_node *pred = get_irn_n(node, i);
+			lower_node(env, pred);
+		}
 	}
 
 	op   = get_irn_op(node);
@@ -2204,8 +2284,8 @@ static void lower_irg(lower_env_t *env, ir_graph *irg)
 
 	if (mtp_must_be_lowered(env, mtp)) {
 		ir_type *ltp = lower_mtp(env, mtp);
+		/* Do not update the entity type yet, this will be done by lower_Start! */
 		env->flags |= MUST_BE_LOWERED;
-		set_entity_type(ent, ltp);
 		env->l_mtp = ltp;
 		env->value_param_tp = get_method_value_param_type(mtp);
 	}
@@ -2216,7 +2296,7 @@ static void lower_irg(lower_env_t *env, ir_graph *irg)
 	               prepare_links_and_handle_rotl, env);
 
 	if (env->flags & MUST_BE_LOWERED) {
-		int i;
+		size_t i;
 		ir_reserve_resources(irg, IR_RESOURCE_IRN_VISITED);
 		inc_irg_visited(irg);
 
@@ -2263,7 +2343,7 @@ static void lower_irg(lower_env_t *env, ir_graph *irg)
 void lower_dw_ops(const lwrdw_param_t *param)
 {
 	lower_env_t lenv;
-	int         i;
+	size_t      i, n;
 
 	assert(param != NULL);
 	FIRM_DBG_REGISTER(dbg, "firm.lower.dw");
@@ -2337,15 +2417,15 @@ void lower_dw_ops(const lwrdw_param_t *param)
 	}
 
 	clear_irp_opcodes_generic_func();
+	enter_lower_func(op_ASM,     lower_ASM);
 	enter_lower_func(op_Add,     lower_binop);
 	enter_lower_func(op_And,     lower_And);
-	enter_lower_func(op_ASM,     lower_ASM);
 	enter_lower_func(op_Call,    lower_Call);
+	enter_lower_func(op_Cmp,     lower_Cmp);
 	enter_lower_func(op_Cond,    lower_Cond);
 	enter_lower_func(op_Const,   lower_Const);
 	enter_lower_func(op_Conv,    lower_Conv);
 	enter_lower_func(op_Div,     lower_Div);
-	enter_lower_func(op_DivMod,  lower_DivMod);
 	enter_lower_func(op_Eor,     lower_Eor);
 	enter_lower_func(op_Load,    lower_Load);
 	enter_lower_func(op_Minus,   lower_Unop);
@@ -2354,7 +2434,6 @@ void lower_dw_ops(const lwrdw_param_t *param)
 	enter_lower_func(op_Mux,     lower_Mux);
 	enter_lower_func(op_Not,     lower_Not);
 	enter_lower_func(op_Or,      lower_Or);
-	enter_lower_func(op_Proj,    lower_Proj);
 	enter_lower_func(op_Return,  lower_Return);
 	enter_lower_func(op_Sel,     lower_Sel);
 	enter_lower_func(op_Shl,     lower_Shl);
@@ -2372,7 +2451,7 @@ void lower_dw_ops(const lwrdw_param_t *param)
 	lenv.next_id       = new_id_from_chars(param->little_endian ? ".h" : ".l", 2);
 
 	/* transform all graphs */
-	for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+	for (i = 0, n = get_irp_n_irgs(); i < n; ++i) {
 		ir_graph *irg = get_irp_irg(i);
 		lower_irg(&lenv, irg);
 	}