X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Flower%2Flower_dw.c;h=a0cd50f2a58b14cfbb4ceb1fe17ee3a7d8329b33;hb=9e32caf2e94f99e6d057b69e5b8384e26de2e785;hp=8cb855e4ad79db5ce1db6f8c8f3d7f4ecc90f297;hpb=b43cc85cacbf80acba5ef135f9a0a3d70ac8bd8a;p=libfirm

diff --git a/ir/lower/lower_dw.c b/ir/lower/lower_dw.c
index 8cb855e4a..a0cd50f2a 100644
--- a/ir/lower/lower_dw.c
+++ b/ir/lower/lower_dw.c
@@ -1,23 +1,33 @@
 /*
- * Project:     libFIRM
- * File name:   ir/lower/lower_dw.c
- * Purpose:     Lower Double word operations, ie Mode L -> I.
- * Author:      Michael Beck
- * Created:		8.10.2004
- * CVS-ID:      $Id$
- * Copyright:   (c) 1998-2006 Universität Karlsruhe
- * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
+ * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ *
+ * This file is part of libFirm.
+ *
+ * This file may be distributed and/or modified under the terms of the
+ * GNU General Public License version 2 as published by the Free Software
+ * Foundation and appearing in the file LICENSE.GPL included in the
+ * packaging of this file.
+ *
+ * Licensees holding valid libFirm Professional Edition licenses may use
+ * this file in accordance with the libFirm Commercial License.
+ * Agreement provided with the Software.
+ *
+ * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
+ * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE.
+ */
+
+/**
+ * @file
+ * @brief   Lower Double word operations, ie 64bit -> 32bit, 32bit -> 16bit etc.
+ * @date    8.10.2004
+ * @author  Michael Beck
+ * @version $Id$
  */
 #ifdef HAVE_CONFIG_H
 # include "config.h"
 #endif
 
-#ifdef HAVE_MALLOC_H
-# include <malloc.h>
-#endif
-#ifdef HAVE_ALLOCA_H
-# include <alloca.h>
-#endif
 #ifdef HAVE_STRING_H
 # include <string.h>
 #endif
@@ -27,6 +37,7 @@
 
 #include <assert.h>
 
+#include "lowering.h"
 #include "irnode_t.h"
 #include "irgraph_t.h"
 #include "irmode_t.h"
@@ -39,7 +50,6 @@
 #include "firmstat.h"
 #include "irgwalk.h"
 #include "ircons.h"
-#include "lower_dw.h"
 #include "irflag.h"
 #include "irtools.h"
 #include "debug.h"
@@ -47,6 +57,7 @@
 #include "pmap.h"
 #include "pdeq.h"
 #include "irdump.h"
+#include "xmalloc.h"
 
 /** A map from mode to a primitive type. */
 static pmap *prim_types;
@@ -73,7 +84,7 @@ typedef struct _op_mode_entry {
 	const ir_op   *op;    /**< the op */
 	const ir_mode *imode; /**< the input mode */
 	const ir_mode *omode; /**< the output mode */
-	entity        *ent;   /**< the associated entity of this (op, imode, omode) triple */
+	ir_entity     *ent;   /**< the associated entity of this (op, imode, omode) triple */
 } op_mode_entry_t;
 
 /**
@@ -90,13 +101,13 @@ typedef struct _conv_tp_entry {
  * we need some store to hold the replacement:
  */
 typedef struct _node_entry_t {
-	ir_node *low_word;        /**< the low word */
-	ir_node *high_word;       /**< the high word */
+	ir_node *low_word;    /**< the low word */
+	ir_node *high_word;   /**< the high word */
 } node_entry_t;
 
 enum lower_flags {
-	MUST_BE_LOWERED = 1,   /**< graph must be lowered */
-	CF_CHANGED      = 2,   /**< control flow was changed */
+	MUST_BE_LOWERED = 1,  /**< graph must be lowered */
+	CF_CHANGED      = 2,  /**< control flow was changed */
 };
 
 /**
@@ -160,7 +171,7 @@ static ir_type *get_conv_type(ir_mode *imode, ir_mode *omode, lower_env_t *env)
 		/* set param types and result types */
 		n_param = 0;
 		if (imode == env->params->high_signed) {
-			set_method_param_type(mtd, n_param++, tp_s);
+			set_method_param_type(mtd, n_param++, tp_u);
 			set_method_param_type(mtd, n_param++, tp_s);
 		} else if (imode == env->params->high_unsigned) {
 			set_method_param_type(mtd, n_param++, tp_u);
@@ -172,7 +183,7 @@ static ir_type *get_conv_type(ir_mode *imode, ir_mode *omode, lower_env_t *env)
 
 		n_res = 0;
 		if (omode == env->params->high_signed) {
-			set_method_res_type(mtd, n_res++, tp_s);
+			set_method_res_type(mtd, n_res++, tp_u);
 			set_method_res_type(mtd, n_res++, tp_s);
 		} else if (omode == env->params->high_unsigned) {
 			set_method_res_type(mtd, n_res++, tp_u);
@@ -277,7 +288,7 @@ static void prepare_links(ir_node *node, void *env)
 
 		lenv->entries[get_irn_idx(node)] = link;
 		lenv->flags |= MUST_BE_LOWERED;
-	} else if (get_irn_op(node) == op_Conv) {
+	} else if (is_Conv(node)) {
 		/* Conv nodes have two modes */
 		ir_node *pred = get_Conv_op(node);
 		mode = get_irn_mode(pred);
@@ -312,42 +323,6 @@ static void prepare_links(ir_node *node, void *env)
 				pmap_insert(lenv->proj_2_block, pred, node);
 		}  /* for */
 	}  /* if */
-
-	/* handle support for Psi nodes */
-	if (mode == mode_b || get_irn_op(node) == op_Psi) {
-		for (i = get_irn_arity(node) - 1; i >= 0; --i) {
-			ir_node *proj = get_irn_n(node, i);
-
-			if (is_Proj(proj)) {
-				ir_node *cmp = get_Proj_pred(proj);
-
-				if (is_Cmp(cmp)) {
-					ir_node *l = get_Cmp_left(cmp);
-					mode = get_irn_mode(l);
-
-					if (mode == lenv->params->high_signed ||
-						mode == lenv->params->high_unsigned) {
-						/* ok, found a node that will be lowered */
-						ir_node *nproj;
-						int rem = get_optimize();
-
-						set_optimize(0);
-						nproj = new_rd_Proj(
-							get_irn_dbg_info(proj),
-							current_ir_graph,
-							get_nodes_block(proj),
-							cmp,
-							get_irn_mode(proj),
-							get_Proj_proj(proj));
-						set_optimize(rem);
-
-						set_irn_n(node, i, nproj);
-						lenv->flags |= MUST_BE_LOWERED;
-					}  /* if */
-				}  /* if */
-			}  /* if */
-		}  /* for */
-	}  /* if */
 }  /* prepare_links */
 
 /**
@@ -360,11 +335,12 @@ static void lower_Const(ir_node *node, ir_mode *mode, lower_env_t *env) {
 	ir_node  *block = get_nodes_block(node);
 	int      idx;
 	ir_graph *irg = current_ir_graph;
+	ir_mode  *low_mode = env->params->low_unsigned;
 
 	tv   = get_Const_tarval(node);
 
-	tv_l = tarval_convert_to(tv, mode);
-	low  = new_rd_Const(dbg, irg, block, mode, tv_l);
+	tv_l = tarval_convert_to(tv, low_mode);
+	low  = new_rd_Const(dbg, irg, block, low_mode, tv_l);
 
 	tv_h = tarval_convert_to(tarval_shrs(tv, env->tv_mode_bits), mode);
 	high = new_rd_Const(dbg, irg, block, mode, tv_h);
@@ -379,6 +355,7 @@ static void lower_Const(ir_node *node, ir_mode *mode, lower_env_t *env) {
  * Translate a Load: create two.
  */
 static void lower_Load(ir_node *node, ir_mode *mode, lower_env_t *env) {
+	ir_mode  *low_mode = env->params->low_unsigned;
 	ir_graph *irg = current_ir_graph;
 	ir_node  *adr = get_Load_ptr(node);
 	ir_node  *mem = get_Load_mem(node);
@@ -401,7 +378,7 @@ static void lower_Load(ir_node *node, ir_mode *mode, lower_env_t *env) {
 
 	/* create two loads */
 	dbg  = get_irn_dbg_info(node);
-	low  = new_rd_Load(dbg, irg, block, mem, low,  mode);
+	low  = new_rd_Load(dbg, irg, block, mem,  low,  low_mode);
 	proj = new_r_Proj(irg, block, low, mode_M, pn_Load_M);
 	high = new_rd_Load(dbg, irg, block, proj, high, mode);
 
@@ -427,8 +404,8 @@ static void lower_Load(ir_node *node, ir_mode *mode, lower_env_t *env) {
 			break;
 		case pn_Load_res:       /* Result of load operation. */
 			assert(idx < env->n_entries);
-			env->entries[idx]->low_word  = new_r_Proj(irg, block, low, mode, pn_Load_res);
-			env->entries[idx]->high_word = new_r_Proj(irg, block, high, mode, pn_Load_res);
+			env->entries[idx]->low_word  = new_r_Proj(irg, block, low,  low_mode, pn_Load_res);
+			env->entries[idx]->high_word = new_r_Proj(irg, block, high, mode,     pn_Load_res);
 			break;
 		default:
 			assert(0 && "unexpected Proj number");
@@ -449,6 +426,8 @@ static void lower_Store(ir_node *node, ir_mode *mode, lower_env_t *env) {
 	dbg_info *dbg;
 	int      idx;
 	node_entry_t *entry;
+	(void) node;
+	(void) mode;
 
 	irn = get_Store_value(node);
 	entry = env->entries[get_irn_idx(irn)];
@@ -526,7 +505,7 @@ static ir_node *get_intrinsic_address(ir_type *method, ir_op *op,
                                       ir_mode *imode, ir_mode *omode,
                                       ir_node *block, lower_env_t *env) {
 	symconst_symbol sym;
-	entity *ent;
+	ir_entity *ent;
 	op_mode_entry_t key, *entry;
 
 	key.op    = op;
@@ -546,7 +525,7 @@ static ir_node *get_intrinsic_address(ir_type *method, ir_op *op,
 		ent = entry->ent;
 	}  /* if */
 	sym.entity_p = ent;
-	return new_r_SymConst(current_ir_graph, block, sym, symconst_addr_ent);
+	return new_r_SymConst(current_ir_graph, block, mode_P_code, sym, symconst_addr_ent);
 }  /* get_intrinsic_address */
 
 /**
@@ -617,8 +596,8 @@ static void lower_Div(ir_node *node, ir_mode *mode, lower_env_t *env) {
 		case pn_Div_res:       /* Result of computation. */
 			idx = get_irn_idx(proj);
 			assert(idx < env->n_entries);
-			env->entries[idx]->low_word  = new_r_Proj(current_ir_graph, block, irn, mode, 0);
-			env->entries[idx]->high_word = new_r_Proj(current_ir_graph, block, irn, mode, 1);
+			env->entries[idx]->low_word  = new_r_Proj(current_ir_graph, block, irn, env->params->low_unsigned, 0);
+			env->entries[idx]->high_word = new_r_Proj(current_ir_graph, block, irn, mode,                      1);
 			break;
 		default:
 			assert(0 && "unexpected Proj number");
@@ -697,8 +676,8 @@ static void lower_Mod(ir_node *node, ir_mode *mode, lower_env_t *env) {
 		case pn_Mod_res:       /* Result of computation. */
 			idx = get_irn_idx(proj);
 			assert(idx < env->n_entries);
-			env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, mode, 0);
-			env->entries[idx]->high_word = new_r_Proj(irg, block, irn, mode, 1);
+			env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, env->params->low_unsigned, 0);
+			env->entries[idx]->high_word = new_r_Proj(irg, block, irn, mode,                      1);
 			break;
 		default:
 			assert(0 && "unexpected Proj number");
@@ -715,7 +694,9 @@ static void lower_Mod(ir_node *node, ir_mode *mode, lower_env_t *env) {
  * Create two intrinsic Calls.
  */
 static void lower_DivMod(ir_node *node, ir_mode *mode, lower_env_t *env) {
-	ir_node  *block, *proj, *irn, *mem, *callDiv, *callMod, *resDiv, *resMod;
+	ir_node  *block, *proj, *irn, *mem, *callDiv, *callMod;
+	ir_node  *resDiv = NULL;
+	ir_node  *resMod = NULL;
 	ir_node  *in[4];
 	ir_mode  *opmode;
 	dbg_info *dbg;
@@ -802,13 +783,13 @@ static void lower_DivMod(ir_node *node, ir_mode *mode, lower_env_t *env) {
 		case pn_DivMod_res_div:   /* Result of Div. */
 			idx = get_irn_idx(proj);
 			assert(idx < env->n_entries);
-			env->entries[idx]->low_word  = new_r_Proj(irg, block, resDiv, mode, 0);
-			env->entries[idx]->high_word = new_r_Proj(irg, block, resDiv, mode, 1);
+			env->entries[idx]->low_word  = new_r_Proj(irg, block, resDiv, env->params->low_unsigned, 0);
+			env->entries[idx]->high_word = new_r_Proj(irg, block, resDiv, mode,                      1);
 			break;
 		case pn_DivMod_res_mod:   /* Result of Mod. */
 			idx = get_irn_idx(proj);
-			env->entries[idx]->low_word  = new_r_Proj(irg, block, resMod, mode, 0);
-			env->entries[idx]->high_word = new_r_Proj(irg, block, resMod, mode, 1);
+			env->entries[idx]->low_word  = new_r_Proj(irg, block, resMod, env->params->low_unsigned, 0);
+			env->entries[idx]->high_word = new_r_Proj(irg, block, resMod, mode,                      1);
 			break;
 		default:
 			assert(0 && "unexpected Proj number");
@@ -872,8 +853,8 @@ static void lower_Binop(ir_node *node, ir_mode *mode, lower_env_t *env) {
 
 	idx = get_irn_idx(node);
 	assert(idx < env->n_entries);
-	env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, mode, 0);
-	env->entries[idx]->high_word = new_r_Proj(irg, block, irn, mode, 1);
+	env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, env->params->low_unsigned, 0);
+	env->entries[idx]->high_word = new_r_Proj(irg, block, irn, mode,                      1);
 }  /* lower_Binop */
 
 /**
@@ -919,8 +900,8 @@ static void lower_Shiftop(ir_node *node, ir_mode *mode, lower_env_t *env) {
 
 	idx = get_irn_idx(node);
 	assert(idx < env->n_entries);
-	env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, mode, 0);
-	env->entries[idx]->high_word = new_r_Proj(irg, block, irn, mode, 1);
+	env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, env->params->low_unsigned, 0);
+	env->entries[idx]->high_word = new_r_Proj(irg, block, irn, mode,                      1);
 }  /* lower_Shiftop */
 
 /**
@@ -934,7 +915,7 @@ static void lower_Shr(ir_node *node, ir_mode *mode, lower_env_t *env) {
 		tarval *tv = get_Const_tarval(right);
 
 		if (tarval_is_long(tv) &&
-			get_tarval_long(tv) >= get_mode_size_bits(mode)) {
+			get_tarval_long(tv) >= (int) get_mode_size_bits(mode)) {
 			ir_node *block = get_nodes_block(node);
 			ir_node *left = get_Shr_left(node);
 			ir_node *c;
@@ -969,14 +950,15 @@ static void lower_Shl(ir_node *node, ir_mode *mode, lower_env_t *env) {
 		tarval *tv = get_Const_tarval(right);
 
 		if (tarval_is_long(tv) &&
-			get_tarval_long(tv) >= get_mode_size_bits(mode)) {
+			get_tarval_long(tv) >= (int) get_mode_size_bits(mode)) {
+			ir_mode *mode_l;
 			ir_node *block = get_nodes_block(node);
 			ir_node *left = get_Shl_left(node);
 			ir_node *c;
 			long shf_cnt = get_tarval_long(tv) - get_mode_size_bits(mode);
 			int idx = get_irn_idx(left);
 
-			left = env->entries[idx]->low_word;
+			left = new_r_Conv(irg, block, env->entries[idx]->low_word, mode);
 			idx = get_irn_idx(node);
 
 			if (shf_cnt > 0) {
@@ -985,7 +967,8 @@ static void lower_Shl(ir_node *node, ir_mode *mode, lower_env_t *env) {
 			} else {
 				env->entries[idx]->high_word = left;
 			}  /* if */
-			env->entries[idx]->low_word  = new_r_Const(irg, block, mode, get_mode_null(mode));
+			mode_l = env->params->low_unsigned;
+			env->entries[idx]->low_word  = new_r_Const(irg, block, mode_l, get_mode_null(mode_l));
 
 			return;
 		}  /* if */
@@ -1004,7 +987,7 @@ static void lower_Shrs(ir_node *node, ir_mode *mode, lower_env_t *env) {
 		tarval *tv = get_Const_tarval(right);
 
 		if (tarval_is_long(tv) &&
-			get_tarval_long(tv) >= get_mode_size_bits(mode)) {
+			get_tarval_long(tv) >= (int) get_mode_size_bits(mode)) {
 			ir_node *block = get_nodes_block(node);
 			ir_node *left = get_Shrs_left(node);
 			long shf_cnt = get_tarval_long(tv) - get_mode_size_bits(mode);
@@ -1039,7 +1022,7 @@ static void lower_Rot(ir_node *node, ir_mode *mode, lower_env_t *env) {
 		tarval *tv = get_Const_tarval(right);
 
 		if (tarval_is_long(tv) &&
-			get_tarval_long(tv) == get_mode_size_bits(mode)) {
+			get_tarval_long(tv) == (int) get_mode_size_bits(mode)) {
 			ir_node *left = get_Rot_left(node);
 			ir_node *h, *l;
 			int idx = get_irn_idx(left);
@@ -1097,8 +1080,8 @@ static void lower_Unop(ir_node *node, ir_mode *mode, lower_env_t *env) {
 
 	idx = get_irn_idx(node);
 	assert(idx < env->n_entries);
-	env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, mode, 0);
-	env->entries[idx]->high_word = new_r_Proj(irg, block, irn, mode, 1);
+	env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, env->params->low_unsigned, 0);
+	env->entries[idx]->high_word = new_r_Proj(irg, block, irn, mode,                      1);
 }  /* lower_Unop */
 
 /**
@@ -1147,7 +1130,7 @@ static void lower_Binop_logical(ir_node *node, ir_mode *mode, lower_env_t *env,
 	idx = get_irn_idx(node);
 	assert(idx < env->n_entries);
 	irg = current_ir_graph;
-	env->entries[idx]->low_word  = constr_rd(dbg, irg, block, lop_l, rop_l, mode);
+	env->entries[idx]->low_word  = constr_rd(dbg, irg, block, lop_l, rop_l, env->params->low_unsigned);
 	env->entries[idx]->high_word = constr_rd(dbg, irg, block, lop_h, rop_h, mode);
 }  /* lower_Binop_logical */
 
@@ -1193,46 +1176,10 @@ static void lower_Not(ir_node *node, ir_mode *mode, lower_env_t *env) {
 
 	idx = get_irn_idx(node);
 	assert(idx < env->n_entries);
-	env->entries[idx]->low_word  = new_rd_Not(dbg, current_ir_graph, block, op_l, mode);
+	env->entries[idx]->low_word  = new_rd_Not(dbg, current_ir_graph, block, op_l, env->params->low_unsigned);
 	env->entries[idx]->high_word = new_rd_Not(dbg, current_ir_graph, block, op_h, mode);
 }  /* lower_Not */
 
-/**
- * Translate a Minus.
- *
- * Create two Minus'.
- */
-static void lower_Minus(ir_node *node, ir_mode *mode, lower_env_t *env) {
-	ir_node  *block, *irn;
-	ir_node  *op_l, *op_h;
-	dbg_info *dbg;
-	int      idx;
-	ir_graph *irg;
-	node_entry_t *entry;
-
-	irn   = get_Minus_op(node);
-	entry = env->entries[get_irn_idx(irn)];
-	assert(entry);
-
-	if (! entry->low_word) {
-		/* not ready yet, wait */
-		pdeq_putr(env->waitq, node);
-		return;
-	}  /* if */
-
-	op_l = entry->low_word;
-	op_h = entry->high_word;
-
-	dbg   = get_irn_dbg_info(node);
-	block = get_nodes_block(node);
-	irg   = current_ir_graph;
-
-	idx = get_irn_idx(node);
-	assert(idx < env->n_entries);
-	env->entries[idx]->low_word  = new_rd_Minus(dbg, current_ir_graph, block, op_l, mode);
-	env->entries[idx]->high_word = new_rd_Minus(dbg, current_ir_graph, block, op_h, mode);
-}  /* lower_Minus */
-
 /**
  * Translate a Cond.
  */
@@ -1241,6 +1188,7 @@ static void lower_Cond(ir_node *node, ir_mode *mode, lower_env_t *env) {
 	ir_node *sel = get_Cond_selector(node);
 	ir_mode *m = get_irn_mode(sel);
 	int     idx;
+	(void) mode;
 
 	if (m == mode_b) {
 		node_entry_t *lentry, *rentry;
@@ -1252,7 +1200,13 @@ static void lower_Cond(ir_node *node, ir_mode *mode, lower_env_t *env) {
 		pn_Cmp   pnc;
 		dbg_info *dbg;
 
+		if(!is_Proj(sel))
+			return;
+
 		cmp   = get_Proj_pred(sel);
+		if(!is_Cmp(cmp))
+			return;
+
 		left  = get_Cmp_left(cmp);
 		idx   = get_irn_idx(left);
 		lentry = env->entries[idx];
@@ -1290,13 +1244,28 @@ 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(cmp);
+		block = get_nodes_block(node);
 		dbg   = get_irn_dbg_info(cmp);
 		irg   = current_ir_graph;
+		pnc   = get_Proj_proj(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->params->low_unsigned;
+				ir_node *low  = new_r_Conv(irg, block, lentry->low_word, mode);
+				ir_node *high = new_r_Conv(irg, block, lentry->high_word, mode);
+				ir_node *or   = new_rd_Or(dbg, irg, block, low, high, mode);
+				ir_node *cmp  = new_rd_Cmp(dbg, irg, block, or, new_Const_long(mode, 0));
+
+				ir_node *proj = new_r_Proj(irg, block, cmp, mode_b, pnc);
+				set_Cond_selector(node, proj);
+				return;
+			}
+		}
 
 		cmpH = new_rd_Cmp(dbg, irg, block, lentry->high_word, rentry->high_word);
 
-		pnc = get_Proj_proj(sel);
 		if (pnc == pn_Cmp_Eq) {
 			/* simple case:a == b <==> a_h == b_h && a_l == b_l */
 			pmap_entry *entry = pmap_find(env->proj_2_block, projF);
@@ -1447,7 +1416,8 @@ static void lower_Cond(ir_node *node, ir_mode *mode, lower_env_t *env) {
 static void lower_Conv_to_Ls(ir_node *node, lower_env_t *env) {
 	ir_node  *op    = get_Conv_op(node);
 	ir_mode  *imode = get_irn_mode(op);
-	ir_mode  *dst_mode = env->params->low_signed;
+	ir_mode  *dst_mode_l = env->params->low_unsigned;
+	ir_mode  *dst_mode_h = env->params->low_signed;
 	int      idx = get_irn_idx(node);
 	ir_graph *irg = current_ir_graph;
 	ir_node  *block = get_nodes_block(node);
@@ -1465,16 +1435,22 @@ static void lower_Conv_to_Ls(ir_node *node, lower_env_t *env) {
 				pdeq_putr(env->waitq, node);
 				return;
 			}  /* if */
-			env->entries[idx]->low_word  = new_rd_Conv(dbg, irg, block, env->entries[op_idx]->low_word, dst_mode);
-			env->entries[idx]->high_word = new_rd_Conv(dbg, irg, block, env->entries[op_idx]->high_word, dst_mode);
+			env->entries[idx]->low_word  = new_rd_Conv(dbg, irg, block, env->entries[op_idx]->low_word,  dst_mode_l);
+			env->entries[idx]->high_word = new_rd_Conv(dbg, irg, block, env->entries[op_idx]->high_word, dst_mode_h);
 		} else {
 			/* simple case: create a high word */
-			if (imode != dst_mode)
-				op = new_rd_Conv(dbg, irg, block, op, dst_mode);
+			if (imode != dst_mode_l)
+				op = new_rd_Conv(dbg, irg, block, op, dst_mode_l);
 
 			env->entries[idx]->low_word  = op;
-			env->entries[idx]->high_word = new_rd_Shrs(dbg, irg, block, op,
-				new_Const_long(mode_Iu, get_mode_size_bits(dst_mode) - 1), dst_mode);
+
+			if (mode_is_signed(imode)) {
+				ir_node *op_conv = new_rd_Conv(dbg, irg, block, op, dst_mode_h);
+				env->entries[idx]->high_word = new_rd_Shrs(dbg, irg, block, op_conv,
+					new_Const_long(mode_Iu, get_mode_size_bits(dst_mode_h) - 1), dst_mode_h);
+			} else {
+				env->entries[idx]->high_word = new_Const(dst_mode_h, get_mode_null(dst_mode_h));
+			}  /* if */
 		}  /* if */
 	} else {
 		ir_node *irn, *call;
@@ -1486,8 +1462,8 @@ static void lower_Conv_to_Ls(ir_node *node, lower_env_t *env) {
 		set_irn_pinned(call, get_irn_pinned(node));
 		irn = new_r_Proj(irg, block, call, mode_T, pn_Call_T_result);
 
-		env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, dst_mode, 0);
-		env->entries[idx]->high_word = new_r_Proj(irg, block, irn, dst_mode, 1);
+		env->entries[idx]->low_word  = new_r_Proj(irg, block, irn, dst_mode_l, 0);
+		env->entries[idx]->high_word = new_r_Proj(irg, block, irn, dst_mode_h, 1);
 	}  /* if */
 }  /* lower_Conv_to_Ls */
 
@@ -1523,7 +1499,13 @@ static void lower_Conv_to_Lu(ir_node *node, lower_env_t *env) {
 				op = new_rd_Conv(dbg, irg, block, op, dst_mode);
 
 			env->entries[idx]->low_word  = op;
-			env->entries[idx]->high_word = new_Const(dst_mode, get_mode_null(dst_mode));
+
+			if (mode_is_signed(imode)) {
+				env->entries[idx]->high_word = new_rd_Shrs(dbg, irg, block, op,
+					new_Const_long(mode_Iu, get_mode_size_bits(dst_mode) - 1), dst_mode);
+			} else {
+				env->entries[idx]->high_word = new_Const(dst_mode, get_mode_null(dst_mode));
+			}  /* if */
 		}  /* if */
 	} else {
 		ir_node *irn, *call;
@@ -1554,6 +1536,12 @@ static void lower_Conv_from_Ls(ir_node *node, lower_env_t *env) {
 
 	assert(idx < env->n_entries);
 
+	if (! env->entries[idx]->low_word) {
+		/* not ready yet, wait */
+		pdeq_putr(env->waitq, node);
+		return;
+	}  /* if */
+
 	if (mode_is_int(omode) || mode_is_reference(omode)) {
 		op = env->entries[idx]->low_word;
 
@@ -1592,6 +1580,12 @@ static void lower_Conv_from_Lu(ir_node *node, lower_env_t *env) {
 
 	assert(idx < env->n_entries);
 
+	if (! env->entries[idx]->low_word) {
+		/* not ready yet, wait */
+		pdeq_putr(env->waitq, node);
+		return;
+	}  /* if */
+
 	if (mode_is_int(omode) || mode_is_reference(omode)) {
 		op = env->entries[idx]->low_word;
 
@@ -1632,7 +1626,7 @@ static void lower_Conv(ir_node *node, ir_mode *mode, lower_env_t *env) {
 
 		if (mode == env->params->high_signed) {
 			lower_Conv_from_Ls(node, env);
-        } else if (mode == env->params->high_unsigned) {
+		} else if (mode == env->params->high_unsigned) {
 			lower_Conv_from_Lu(node, env);
 		}  /* if */
 	}  /* if */
@@ -1692,7 +1686,7 @@ static ir_type *lower_mtp(ir_type *mtp, lower_env_t *env) {
 				ir_mode *mode = get_type_mode(tp);
 
 				if (mode == env->params->high_signed) {
-					set_method_param_type(res, n_param++, tp_s);
+					set_method_param_type(res, n_param++, tp_u);
 					set_method_param_type(res, n_param++, tp_s);
 				} else if (mode == env->params->high_unsigned) {
 					set_method_param_type(res, n_param++, tp_u);
@@ -1711,7 +1705,7 @@ static ir_type *lower_mtp(ir_type *mtp, lower_env_t *env) {
 				ir_mode *mode = get_type_mode(tp);
 
 				if (mode == env->params->high_signed) {
-					set_method_res_type(res, n_res++, tp_s);
+					set_method_res_type(res, n_res++, tp_u);
 					set_method_res_type(res, n_res++, tp_s);
 				} else if (mode == env->params->high_unsigned) {
 					set_method_res_type(res, n_res++, tp_u);
@@ -1735,12 +1729,13 @@ static ir_type *lower_mtp(ir_type *mtp, lower_env_t *env) {
  * Translate a Return.
  */
 static void lower_Return(ir_node *node, ir_mode *mode, lower_env_t *env) {
-	ir_graph *irg = current_ir_graph;
-	entity   *ent = get_irg_entity(irg);
-	ir_type  *mtp = get_entity_type(ent);
-	ir_node  **in;
-	int      i, j, n, idx;
-	int      need_conv = 0;
+	ir_graph  *irg = current_ir_graph;
+	ir_entity *ent = get_irg_entity(irg);
+	ir_type   *mtp = get_entity_type(ent);
+	ir_node   **in;
+	int       i, j, n, idx;
+	int       need_conv = 0;
+	(void) mode;
 
 	/* check if this return must be lowered */
 	for (i = 0, n = get_Return_n_ress(node); i < n; ++i) {
@@ -1792,13 +1787,14 @@ static void lower_Return(ir_node *node, ir_mode *mode, lower_env_t *env) {
  * Translate the parameters.
  */
 static void lower_Start(ir_node *node, ir_mode *mode, lower_env_t *env) {
-	ir_graph *irg = current_ir_graph;
-	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;
-	ir_node  *proj, *args;
+	ir_graph  *irg = current_ir_graph;
+	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;
+	ir_node   *proj, *args;
+	(void) mode;
 
 	if (is_lowered_type(tp)) {
 		mtp = get_associated_type(tp);
@@ -1857,6 +1853,8 @@ static void lower_Start(ir_node *node, ir_mode *mode, lower_env_t *env) {
 
 		idx = get_irn_idx(proj);
 		if (env->entries[idx]) {
+			ir_mode *low_mode = env->params->low_unsigned;
+
 			mode = get_irn_mode(proj);
 
 			if (mode == env->params->high_signed) {
@@ -1867,7 +1865,7 @@ static void lower_Start(ir_node *node, ir_mode *mode, lower_env_t *env) {
 
 			dbg = get_irn_dbg_info(proj);
 			env->entries[idx]->low_word  =
-				new_rd_Proj(dbg, irg, get_nodes_block(proj), args, mode, new_projs[proj_nr]);
+				new_rd_Proj(dbg, irg, get_nodes_block(proj), args, low_mode, new_projs[proj_nr]);
 			env->entries[idx]->high_word =
 				new_rd_Proj(dbg, irg, get_nodes_block(proj), args, mode, new_projs[proj_nr] + 1);
 		}  /* if */
@@ -1886,6 +1884,7 @@ static void lower_Call(ir_node *node, ir_mode *mode, lower_env_t *env) {
 	int      n_params, n_res, need_lower = 0;
 	int      i, j;
 	long     *res_numbers = NULL;
+	(void) mode;
 
 	if (is_lowered_type(tp)) {
 		call_tp = get_associated_type(tp);
@@ -1988,6 +1987,7 @@ static void lower_Call(ir_node *node, ir_mode *mode, lower_env_t *env) {
 				idx = get_irn_idx(proj);
 				if (env->entries[idx]) {
 					ir_mode *mode = get_irn_mode(proj);
+					ir_mode *low_mode = env->params->low_unsigned;
 					dbg_info *dbg;
 
 					if (mode == env->params->high_signed) {
@@ -1998,7 +1998,7 @@ static void lower_Call(ir_node *node, ir_mode *mode, lower_env_t *env) {
 
 					dbg = get_irn_dbg_info(proj);
 					env->entries[idx]->low_word  =
-						new_rd_Proj(dbg, irg, get_nodes_block(proj), results, mode, res_numbers[proj_nr]);
+						new_rd_Proj(dbg, irg, get_nodes_block(proj), results, low_mode, res_numbers[proj_nr]);
 					env->entries[idx]->high_word =
 						new_rd_Proj(dbg, irg, get_nodes_block(proj), results, mode, res_numbers[proj_nr] + 1);
 				}  /* if */
@@ -2013,10 +2013,11 @@ static void lower_Call(ir_node *node, ir_mode *mode, lower_env_t *env) {
  * Translate an Unknown into two.
  */
 static void lower_Unknown(ir_node *node, ir_mode *mode, lower_env_t *env) {
-	int idx = get_irn_idx(node);
+	int      idx = get_irn_idx(node);
 	ir_graph *irg = current_ir_graph;
+	ir_mode  *low_mode = env->params->low_unsigned;
 
-	env->entries[idx]->low_word  =
+	env->entries[idx]->low_word  = new_r_Unknown(irg, low_mode);
 	env->entries[idx]->high_word = new_r_Unknown(irg, mode);
 }  /* lower_Unknown */
 
@@ -2026,8 +2027,9 @@ static void lower_Unknown(ir_node *node, ir_mode *mode, lower_env_t *env) {
  * First step: just create two templates
  */
 static void lower_Phi(ir_node *phi, ir_mode *mode, lower_env_t *env) {
+	ir_mode  *mode_l = env->params->low_unsigned;
 	ir_graph *irg = current_ir_graph;
-	ir_node  *block, *unk;
+	ir_node  *block, *unk_l, *unk_h, *phi_l, *phi_h;
 	ir_node  **inl, **inh;
 	dbg_info *dbg;
 	int      idx, i, arity = get_Phi_n_preds(phi);
@@ -2057,7 +2059,8 @@ static void lower_Phi(ir_node *phi, ir_mode *mode, lower_env_t *env) {
 	/* first create a new in array */
 	NEW_ARR_A(ir_node *, inl, arity);
 	NEW_ARR_A(ir_node *, inh, arity);
-	unk = new_r_Unknown(irg, mode);
+	unk_l = new_r_Unknown(irg, mode_l);
+	unk_h = new_r_Unknown(irg, mode);
 
 	for (i = 0; i < arity; ++i) {
 		ir_node *pred = get_Phi_pred(phi, i);
@@ -2067,8 +2070,8 @@ static void lower_Phi(ir_node *phi, ir_mode *mode, lower_env_t *env) {
 			inl[i] = env->entries[idx]->low_word;
 			inh[i] = env->entries[idx]->high_word;
 		} else {
-			inl[i] = unk;
-			inh[i] = unk;
+			inl[i] = unk_l;
+			inh[i] = unk_h;
 			enq = 1;
 		}  /* if */
 	}  /* for */
@@ -2078,8 +2081,13 @@ static void lower_Phi(ir_node *phi, ir_mode *mode, lower_env_t *env) {
 
 	idx = get_irn_idx(phi);
 	assert(idx < env->n_entries);
-	env->entries[idx]->low_word  = new_rd_Phi(dbg, irg, block, arity, inl, mode);
-	env->entries[idx]->high_word = new_rd_Phi(dbg, irg, block, arity, inh, mode);
+	env->entries[idx]->low_word  = phi_l = new_rd_Phi(dbg, irg, block, arity, inl, mode_l);
+	env->entries[idx]->high_word = phi_h = new_rd_Phi(dbg, irg, block, arity, inh, mode);
+
+	/* Don't forget to link the new Phi nodes into the block! */
+	set_irn_link(phi_l, get_irn_link(block));
+	set_irn_link(phi_h, phi_l);
+	set_irn_link(block, phi_h);
 
 	if (enq) {
 		/* not yet finished */
@@ -2142,42 +2150,48 @@ static void lower_Psi(ir_node *psi, ir_mode *mode, lower_env_t *env) {
 }  /* lower_Psi */
 
 /**
- * lower all marked Proj(Cmp)
+ * check for opcodes that must always be lowered.
+ */
+static int always_lower(ir_opcode code) {
+	switch (code) {
+	case iro_Proj:
+	case iro_Start:
+	case iro_Call:
+	case iro_Return:
+	case iro_Cond:
+	case iro_Conv:
+		return 1;
+	default:
+		return 0;
+	}  /* switch */
+}  /* always_lower */
+
+/**
+ * lower boolean Proj(Cmp)
  */
-static void lower_Proj(ir_node *node, ir_mode *mode, lower_env_t *env) {
-	int      idx, lidx, ridx;
-	ir_node  *cmp, *l, *r, *low, *high, *t, *res;
+static ir_node *lower_boolean_Proj_Cmp(ir_node *proj, ir_node *cmp, lower_env_t *env) {
+	int      lidx, ridx;
+	ir_node  *l, *r, *low, *high, *t, *res;
 	pn_Cmp   pnc;
 	ir_node  *blk;
 	ir_graph *irg = current_ir_graph;
 	dbg_info *db;
 
-	idx = get_irn_idx(node);
-	if (env->entries[idx] == NULL)
-		return;
-
-	cmp  = get_Proj_pred(node);
-
-	if (! is_Cmp(cmp))
-		return;
-
 	l    = get_Cmp_left(cmp);
 	lidx = get_irn_idx(l);
 	if (! env->entries[lidx]->low_word) {
 		/* still not ready */
-		pdeq_putr(env->waitq, node);
-		return;
+		return NULL;
 	}  /* if */
 
 	r    = get_Cmp_right(cmp);
 	ridx = get_irn_idx(r);
 	if (! env->entries[ridx]->low_word) {
 		/* still not ready */
-		pdeq_putr(env->waitq, node);
-		return;
+		return NULL;
 	}  /* if */
 
-	pnc  = get_Proj_proj(node);
+	pnc  = get_Proj_proj(proj);
 	blk  = get_nodes_block(cmp);
 	db   = get_irn_dbg_info(cmp);
 	low  = new_rd_Cmp(db, irg, blk, env->entries[lidx]->low_word, env->entries[ridx]->low_word);
@@ -2206,25 +2220,8 @@ static void lower_Proj(ir_node *node, ir_mode *mode, lower_env_t *env) {
 			t,
 			mode_b);
 	}  /* if */
-	exchange(node, res);
-}  /* lower_Proj */
-
-/**
- * check for opcodes that must always be lowered.
- */
-static int always_lower(opcode code) {
-	switch (code) {
-	case iro_Proj:
-	case iro_Start:
-	case iro_Call:
-	case iro_Return:
-	case iro_Cond:
-    case iro_Conv:
-		return 1;
-	default:
-		return 0;
-	}  /* switch */
-}  /* always_lower */
+	return res;
+}  /* lower_boolean_Proj_Cmp */
 
 /**
  * The type of a lower function.
@@ -2243,6 +2240,36 @@ static void lower_ops(ir_node *node, void *env)
 	lower_env_t  *lenv = env;
 	node_entry_t *entry;
 	int          idx = get_irn_idx(node);
+	ir_mode      *mode = get_irn_mode(node);
+
+	if (mode == mode_b || is_Psi(node)) {
+		int i;
+
+		for (i = get_irn_arity(node) - 1; i >= 0; --i) {
+			ir_node *proj = get_irn_n(node, i);
+
+			if (is_Proj(proj)) {
+				ir_node *cmp = get_Proj_pred(proj);
+
+				if (is_Cmp(cmp)) {
+					ir_node *arg = get_Cmp_left(cmp);
+
+					mode = get_irn_mode(arg);
+					if (mode == lenv->params->high_signed ||
+						mode == lenv->params->high_unsigned) {
+						ir_node *res = lower_boolean_Proj_Cmp(proj, cmp, lenv);
+
+						if (res == NULL) {
+							/* could not lower because predecessors not ready */
+							waitq_put(lenv->waitq, node);
+							return;
+						}  /* if */
+						set_irn_n(node, i, res);
+					}  /* if */
+				}  /* if */
+			}  /* if */
+		}  /* for */
+	}  /* if */
 
 	entry = idx < lenv->n_entries ? lenv->entries[idx] : NULL;
 	if (entry || always_lower(get_irn_opcode(node))) {
@@ -2250,7 +2277,7 @@ static void lower_ops(ir_node *node, void *env)
 		lower_func func = (lower_func)op->ops.generic;
 
 		if (func) {
-			ir_mode *mode = get_irn_op_mode(node);
+			mode = get_irn_op_mode(node);
 
 			if (mode == lenv->params->high_signed)
 				mode = lenv->params->low_signed;
@@ -2271,6 +2298,7 @@ static void lower_ops(ir_node *node, void *env)
 static int cmp_op_mode(const void *elt, const void *key, size_t size) {
 	const op_mode_entry_t *e1 = elt;
 	const op_mode_entry_t *e2 = key;
+	(void) size;
 
 	return (e1->op - e2->op) | (e1->imode - e2->imode) | (e1->omode - e2->omode);
 }  /* cmp_op_mode */
@@ -2281,10 +2309,18 @@ static int cmp_op_mode(const void *elt, const void *key, size_t size) {
 static int cmp_conv_tp(const void *elt, const void *key, size_t size) {
 	const conv_tp_entry_t *e1 = elt;
 	const conv_tp_entry_t *e2 = key;
+	(void) size;
 
 	return (e1->imode - e2->imode) | (e1->omode - e2->omode);
 }  /* static int cmp_conv_tp */
 
+/**
+ * Enter a lowering function into an ir_op.
+ */
+static void enter_lower_func(ir_op *op, lower_func func) {
+	op->ops.generic = (op_func)func;
+}
+
 /*
  * Do the lowering.
  */
@@ -2306,7 +2342,7 @@ void lower_dw_ops(const lwrdw_param_t *param)
 	assert(2 * get_mode_size_bits(param->low_unsigned) == get_mode_size_bits(param->high_unsigned));
 	assert(get_mode_size_bits(param->low_signed) == get_mode_size_bits(param->low_unsigned));
 
-    /* create the necessary maps */
+	/* create the necessary maps */
 	if (! prim_types)
 		prim_types = pmap_create();
 	if (! intrinsic_fkt)
@@ -2316,13 +2352,13 @@ void lower_dw_ops(const lwrdw_param_t *param)
 	if (! lowered_type)
 		lowered_type = pmap_create();
 
-    /* create a primitive unsigned and signed type */
+	/* create a primitive unsigned and signed type */
 	if (! tp_u)
 		tp_u = get_primitive_type(param->low_unsigned);
 	if (! tp_s)
 		tp_s = get_primitive_type(param->low_signed);
 
-    /* create method types for the created binop calls */
+	/* create method types for the created binop calls */
 	if (! binop_tp_u) {
 		binop_tp_u = new_type_method(IDENT("binop_u_intrinsic"), 4, 2);
 		set_method_param_type(binop_tp_u, 0, tp_u);
@@ -2334,11 +2370,11 @@ void lower_dw_ops(const lwrdw_param_t *param)
 	}  /* if */
 	if (! binop_tp_s) {
 		binop_tp_s = new_type_method(IDENT("binop_s_intrinsic"), 4, 2);
-		set_method_param_type(binop_tp_s, 0, tp_s);
+		set_method_param_type(binop_tp_s, 0, tp_u);
 		set_method_param_type(binop_tp_s, 1, tp_s);
-		set_method_param_type(binop_tp_s, 2, tp_s);
+		set_method_param_type(binop_tp_s, 2, tp_u);
 		set_method_param_type(binop_tp_s, 3, tp_s);
-		set_method_res_type(binop_tp_s, 0, tp_s);
+		set_method_res_type(binop_tp_s, 0, tp_u);
 		set_method_res_type(binop_tp_s, 1, tp_s);
 	}  /* if */
 	if (! shiftop_tp_u) {
@@ -2351,11 +2387,11 @@ void lower_dw_ops(const lwrdw_param_t *param)
 	}  /* if */
 	if (! shiftop_tp_s) {
 		shiftop_tp_s = new_type_method(IDENT("shiftop_s_intrinsic"), 3, 2);
-		set_method_param_type(shiftop_tp_s, 0, tp_s);
+		set_method_param_type(shiftop_tp_s, 0, tp_u);
 		set_method_param_type(shiftop_tp_s, 1, tp_s);
 		/* beware: shift count is always mode_Iu */
 		set_method_param_type(shiftop_tp_s, 2, tp_u);
-		set_method_res_type(shiftop_tp_s, 0, tp_s);
+		set_method_res_type(shiftop_tp_s, 0, tp_u);
 		set_method_res_type(shiftop_tp_s, 1, tp_s);
 	}  /* if */
 	if (! unop_tp_u) {
@@ -2367,9 +2403,9 @@ void lower_dw_ops(const lwrdw_param_t *param)
 	}  /* if */
 	if (! unop_tp_s) {
 		unop_tp_s = new_type_method(IDENT("unop_s_intrinsic"), 2, 2);
-		set_method_param_type(unop_tp_s, 0, tp_s);
+		set_method_param_type(unop_tp_s, 0, tp_u);
 		set_method_param_type(unop_tp_s, 1, tp_s);
-		set_method_res_type(unop_tp_s, 0, tp_s);
+		set_method_res_type(unop_tp_s, 0, tp_u);
 		set_method_res_type(unop_tp_s, 1, tp_s);
 	}  /* if */
 
@@ -2381,7 +2417,7 @@ void lower_dw_ops(const lwrdw_param_t *param)
 	/* first clear the generic function pointer for all ops */
 	clear_irp_opcodes_generic_func();
 
-#define LOWER2(op, fkt)   op_##op->ops.generic = (op_func)fkt
+#define LOWER2(op, fkt)   enter_lower_func(op_##op, fkt)
 #define LOWER(op)         LOWER2(op, lower_##op)
 #define LOWER_BIN(op)     LOWER2(op, lower_Binop)
 #define LOWER_UN(op)      LOWER2(op, lower_Unop)
@@ -2409,12 +2445,11 @@ void lower_dw_ops(const lwrdw_param_t *param)
 	LOWER(Shr);
 	LOWER(Shrs);
 	LOWER(Rot);
-	LOWER2(Minus, lower_Minus);
 	LOWER(DivMod);
 	LOWER(Div);
 	LOWER(Mod);
 	LOWER_UN(Abs);
-	LOWER2(Proj, lower_Proj);
+	LOWER_UN(Minus);
 
 	LOWER(Conv);
 
@@ -2465,8 +2500,6 @@ void lower_dw_ops(const lwrdw_param_t *param)
 				set_irg_extblk_inconsistent(irg);
 				set_irg_loopinfo_inconsistent(irg);
 			}  /* if */
-
-			dump_ir_block_graph(irg, "-dw");
 		}  /* if */
 		pmap_destroy(lenv.proj_2_block);
 		free(lenv.entries);
@@ -2477,13 +2510,14 @@ void lower_dw_ops(const lwrdw_param_t *param)
 }  /* lower_dw_ops */
 
 /* Default implementation. */
-entity *def_create_intrinsic_fkt(ir_type *method, const ir_op *op,
-                                 const ir_mode *imode, const ir_mode *omode,
-                                 void *context)
+ir_entity *def_create_intrinsic_fkt(ir_type *method, const ir_op *op,
+                                    const ir_mode *imode, const ir_mode *omode,
+                                    void *context)
 {
 	char buf[64];
 	ident *id;
-	entity *ent;
+	ir_entity *ent;
+	(void) context;
 
 	if (imode == omode) {
 		snprintf(buf, sizeof(buf), "__l%s%s", get_op_name(op), get_mode_name(imode));