/*
- * 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.
*
/**
* @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$
node_entry_t **entries; /**< entries per node */
ir_graph *irg;
struct obstack obst; /**< an obstack holding the temporary data */
- ir_type *l_mtp; /**< lowered method type of the current method */
- tarval *tv_mode_bytes; /**< a tarval containing the number of bytes in the lowered modes */
- tarval *tv_mode_bits; /**< a tarval containing the number of bits in the lowered modes */
- pdeq *waitq; /**< a wait queue of all nodes that must be handled later */
- ir_node **lowered_phis; /**< list of lowered phis */
- pmap *proj_2_block; /**< a map from ProjX to its destination blocks */
- ir_mode *high_signed; /**< doubleword signed type */
- ir_mode *high_unsigned; /**< doubleword unsigned type */
- ir_mode *low_signed; /**< word signed type */
- ir_mode *low_unsigned; /**< word unsigned type */
- ident *first_id; /**< .l for little and .h for big endian */
- ident *next_id; /**< .h for little and .l for big endian */
+ ir_type *l_mtp; /**< lowered method type of the current method */
+ ir_tarval *tv_mode_bytes; /**< a tarval containing the number of bytes in the lowered modes */
+ ir_tarval *tv_mode_bits; /**< a tarval containing the number of bits in the lowered modes */
+ pdeq *waitq; /**< a wait queue of all nodes that must be handled later */
+ ir_node **lowered_phis; /**< list of lowered phis */
+ pmap *proj_2_block; /**< a map from ProjX to its destination blocks */
+ ir_mode *high_signed; /**< doubleword signed type */
+ ir_mode *high_unsigned; /**< doubleword unsigned type */
+ ir_mode *low_signed; /**< word signed type */
+ ir_mode *low_unsigned; /**< word unsigned type */
+ ident *first_id; /**< .l for little and .h for big endian */
+ ident *next_id; /**< .h for little and .l for big endian */
const lwrdw_param_t *params; /**< transformation parameter */
unsigned flags; /**< some flags */
unsigned n_entries; /**< number of entries */
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.
*/
key.omode = omode;
key.mtd = NULL;
- entry = set_insert(conv_types, &key, sizeof(key), HASH_PTR(imode) ^ HASH_PTR(omode));
+ entry = (conv_tp_entry_t*)set_insert(conv_types, &key, sizeof(key), HASH_PTR(imode) ^ HASH_PTR(omode));
if (! entry->mtd) {
int n_param = 1, n_res = 1;
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:
*/
static void lower_Const(ir_node *node, ir_mode *mode, lower_env_t *env)
{
- ir_graph *irg = get_irn_irg(node);
- dbg_info *dbg = get_irn_dbg_info(node);
- ir_mode *low_mode = env->low_unsigned;
- tarval *tv = get_Const_tarval(node);
- tarval *tv_l = tarval_convert_to(tv, low_mode);
- ir_node *res_low = new_rd_Const(dbg, irg, tv_l);
- tarval *tv_shrs = tarval_shrs(tv, env->tv_mode_bits);
- tarval *tv_h = tarval_convert_to(tv_shrs, mode);
- ir_node *res_high = new_rd_Const(dbg, irg, tv_h);
+ ir_graph *irg = get_irn_irg(node);
+ dbg_info *dbg = get_irn_dbg_info(node);
+ ir_mode *low_mode = env->low_unsigned;
+ ir_tarval *tv = get_Const_tarval(node);
+ ir_tarval *tv_l = tarval_convert_to(tv, low_mode);
+ ir_node *res_low = new_rd_Const(dbg, irg, tv_l);
+ ir_tarval *tv_shrs = tarval_shrs(tv, env->tv_mode_bits);
+ ir_tarval *tv_h = tarval_convert_to(tv_shrs, mode);
+ ir_node *res_high = new_rd_Const(dbg, irg, tv_h);
set_lowered(env, node, res_low, res_high);
}
dbg_info *dbg;
ir_node *block = get_nodes_block(node);
ir_cons_flags volatility = get_Load_volatility(node) == volatility_is_volatile
- ? cons_volatile : 0;
+ ? cons_volatile : cons_none;
if (env->params->little_endian) {
low = adr;
set_lowered(env, node, low, high);
- for (proj = get_irn_link(node); proj; proj = get_irn_link(proj)) {
+ for (proj = (ir_node*)get_irn_link(node); proj;
+ proj = (ir_node*)get_irn_link(proj)) {
switch (get_Proj_proj(proj)) {
case pn_Load_M: /* Memory result. */
/* put it to the second one */
ir_node *value = get_Store_value(node);
const node_entry_t *entry = get_node_entry(env, value);
ir_cons_flags volatility = get_Store_volatility(node) == volatility_is_volatile
- ? cons_volatile : 0;
+ ? cons_volatile : cons_none;
(void) mode;
assert(entry);
set_lowered(env, node, low, high);
- for (proj = get_irn_link(node); proj; proj = get_irn_link(proj)) {
+ for (proj = (ir_node*)get_irn_link(node); proj;
+ proj = (ir_node*)get_irn_link(proj)) {
switch (get_Proj_proj(proj)) {
case pn_Store_M: /* Memory result. */
/* put it to the second one */
key.omode = omode;
key.ent = NULL;
- entry = set_insert(intrinsic_fkt, &key, sizeof(key),
+ entry = (op_mode_entry_t*)set_insert(intrinsic_fkt, &key, sizeof(key),
HASH_PTR(op) ^ HASH_PTR(imode) ^ (HASH_PTR(omode) << 8));
if (! entry->ent) {
/* create a new one */
set_irn_pinned(call, get_irn_pinned(node));
- for (proj = get_irn_link(node); proj; proj = get_irn_link(proj)) {
+ for (proj = (ir_node*)get_irn_link(node); proj;
+ proj = (ir_node*)get_irn_link(proj)) {
switch (get_Proj_proj(proj)) {
case pn_Div_M: /* Memory result. */
/* reroute to the call */
ir_node *proj;
set_irn_pinned(call, get_irn_pinned(node));
- for (proj = get_irn_link(node); proj; proj = get_irn_link(proj)) {
+ for (proj = (ir_node*)get_irn_link(node); proj;
+ proj = (ir_node*)get_irn_link(proj)) {
switch (get_Proj_proj(proj)) {
case pn_Mod_M: /* Memory result. */
/* reroute to the call */
}
}
-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.
*
*/
static void lower_Shiftop(ir_node *node, ir_mode *mode, lower_env_t *env)
{
+ ir_node *block = get_nodes_block(node);
ir_node *left = get_binop_left(node);
const node_entry_t *left_entry = get_node_entry(env, left);
ir_node *right = get_binop_right(node);
ir_node *in[3] = {
- left_entry->low_word, left_entry->high_word, right
+ left_entry->low_word, left_entry->high_word,
+ /* it should be safe to conv to low_unsigned */
+ new_r_Conv(block, right, env->low_unsigned)
};
dbg_info *dbgi = get_irn_dbg_info(node);
- ir_node *block = get_nodes_block(node);
ir_graph *irg = get_irn_irg(block);
ir_type *mtp
= mode_is_signed(mode) ? shiftop_tp_s : shiftop_tp_u;
set_irn_pinned(call, get_irn_pinned(node));
set_lowered(env, node, res_low, res_high);
-
- /* The shift count is always mode_Iu, no need for lowering */
- assert(get_irn_mode(right) != env->high_signed
- && get_irn_mode(right) != env->high_unsigned);
}
/**
ir_node *right = get_Shr_right(node);
if (get_mode_arithmetic(mode) == irma_twos_complement && is_Const(right)) {
- tarval *tv = get_Const_tarval(right);
+ ir_tarval *tv = get_Const_tarval(right);
if (tarval_is_long(tv) &&
get_tarval_long(tv) >= (long)get_mode_size_bits(mode)) {
ir_node *right = get_Shl_right(node);
if (get_mode_arithmetic(mode) == irma_twos_complement && is_Const(right)) {
- tarval *tv = get_Const_tarval(right);
+ ir_tarval *tv = get_Const_tarval(right);
+
+ if (tarval_is_long(tv)) {
+ long value = get_tarval_long(tv);
+ if (value >= (long)get_mode_size_bits(mode)) {
+ /* simple case: shift above the lower word */
+ 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);
+ const node_entry_t *left_entry = get_node_entry(env, left);
+ ir_node *res_low;
+ ir_node *res_high;
- if (tarval_is_long(tv) &&
- get_tarval_long(tv) >= (long)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);
- const node_entry_t *left_entry = get_node_entry(env, left);
- ir_node *res_low;
- ir_node *res_high;
+ left = left_entry->low_word;
+ left = new_r_Conv(block, left, mode);
- left = left_entry->low_word;
- left = new_r_Conv(block, left, mode);
+ mode_l = env->low_unsigned;
+ if (shf_cnt > 0) {
+ c = new_r_Const_long(irg, mode_l, shf_cnt);
+ res_high = new_r_Shl(block, left, c, mode);
+ } else {
+ res_high = left;
+ }
+ res_low = new_r_Const(irg, get_mode_null(mode_l));
+ set_lowered(env, node, res_low, res_high);
- mode_l = env->low_unsigned;
- if (shf_cnt > 0) {
- c = new_r_Const_long(irg, mode_l, shf_cnt);
- res_high = new_r_Shl(block, left, c, mode);
- } else {
- res_high = left;
+ return;
+ }
+ if (value == 1) {
+ /* left << 1 == left + left */
+ ir_node *left = get_binop_left(node);
+ const node_entry_t *left_entry = get_node_entry(env, left);
+ ir_node *in[4] = {
+ left_entry->low_word, left_entry->high_word,
+ left_entry->low_word, left_entry->high_word,
+ };
+ dbg_info *dbgi = get_irn_dbg_info(node);
+ ir_node *block = get_nodes_block(node);
+ ir_graph *irg = get_irn_irg(block);
+ ir_type *mtp
+ = mode_is_signed(mode) ? binop_tp_s : binop_tp_u;
+ ir_node *addr
+ = get_intrinsic_address(mtp, op_Add, mode, mode, env);
+ ir_node *call
+ = new_rd_Call(dbgi, block, get_irg_no_mem(irg), addr, 4, in, mtp);
+ ir_node *resproj = new_r_Proj(call, mode_T, pn_Call_T_result);
+ ir_node *res_low = new_r_Proj(resproj, env->low_unsigned, 0);
+ ir_node *res_high = new_r_Proj(resproj, mode, 1);
+ set_irn_pinned(call, get_irn_pinned(node));
+ set_lowered(env, node, res_low, res_high);
+
+ return;
}
- res_low = new_r_Const(irg, get_mode_null(mode_l));
- set_lowered(env, node, res_low, res_high);
-
- return;
}
}
lower_Shiftop(node, mode, env);
ir_node *right = get_Shrs_right(node);
if (get_mode_arithmetic(mode) == irma_twos_complement && is_Const(right)) {
- tarval *tv = get_Const_tarval(right);
+ ir_tarval *tv = get_Const_tarval(right);
if (tarval_is_long(tv) &&
get_tarval_long(tv) >= (long)get_mode_size_bits(mode)) {
*/
static void prepare_links_and_handle_rotl(ir_node *node, void *env)
{
- lower_env_t *lenv = env;
+ lower_env_t *lenv = (lower_env_t*)env;
if (is_Rotl(node)) {
ir_mode *mode = get_irn_op_mode(node);
ir_node *right;
- ir_node *left, *shl, *shr, *or, *block, *sub, *c;
+ ir_node *left, *shl, *shr, *ornode, *block, *sub, *c;
ir_mode *omode, *rmode;
ir_graph *irg;
dbg_info *dbg;
/* switch optimization off here, or we will get the Rotl back */
save_optimization_state(&state);
set_opt_algebraic_simplification(0);
- or = new_rd_Or(dbg, block, shl, shr, omode);
+ ornode = new_rd_Or(dbg, block, shl, shr, omode);
restore_optimization_state(&state);
- exchange(node, or);
+ exchange(node, ornode);
/* do lowering on the new nodes */
prepare_links(lenv, shl);
prepare_links(lenv, c);
prepare_links(lenv, sub);
prepare_links(lenv, shr);
- prepare_links(lenv, or);
+ prepare_links(lenv, ornode);
return;
}
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;
/* 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);
/* all right, build the code */
- for (proj = get_irn_link(node); proj; proj = get_irn_link(proj)) {
+ for (proj = (ir_node*)get_irn_link(node); proj;
+ proj = (ir_node*)get_irn_link(proj)) {
long proj_nr = get_Proj_proj(proj);
if (proj_nr == pn_Cond_true) {
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_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->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 *or = new_rd_Or(dbg, block, low, high, mode);
- ir_node *cmp = new_rd_Cmp(dbg, block, or, 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);
+
+ 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;
}
- cmpH = new_rd_Cmp(dbg, block, lentry->high_word, rentry->high_word);
-
- 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 = entry->value;
+ 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);
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);
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 = entry->value;
+ 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);
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);
entry = pmap_find(env->proj_2_block, projT);
assert(entry);
- dstT = entry->value;
+ dstT = (ir_node*)entry->value;
entry = pmap_find(env->proj_2_block, projF);
assert(entry);
- dstF = entry->value;
+ 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);
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);
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);
set_Conv_op(node, op);
} else if (omode == mode_b) {
/* llu ? true : false <=> (low|high) ? true : false */
- ir_mode *mode = env->low_unsigned;
- ir_node *or = new_rd_Or(dbg, block, entry->low_word, entry->high_word,
- mode);
- set_Conv_op(node, or);
+ ir_mode *mode = env->low_unsigned;
+ ir_node *ornode = new_rd_Or(dbg, block, entry->low_word,
+ entry->high_word, mode);
+ set_Conv_op(node, ornode);
} else {
ir_node *irn, *call, *in[2];
ir_mode *imode = get_irn_mode(op);
}
/**
- * 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_proj(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)
-{
- (void) mode;
- ir_node *pred = get_Proj_pred(node);
- 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);
}
/**
}
}
+/**
+ * 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.
*
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);
}
/* 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);
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)) {
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)) {
/* 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;
}
set_lowered_type(value_type, get_method_value_param_type(res));
}
} else {
- res = entry->value;
+ res = (ir_type*)entry->value;
}
return res;
}
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;
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 = get_irn_link(node); proj; proj = get_irn_link(proj)) {
+ for (proj = (ir_node*)get_irn_link(node); proj;
+ proj = (ir_node*)get_irn_link(proj)) {
ir_node *pred = get_Proj_pred(proj);
long proj_nr;
ir_mode *mode;
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;
}
}
}
- 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;
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);
/* fix the results */
results = NULL;
- for (proj = get_irn_link(node); proj; proj = get_irn_link(proj)) {
+ for (proj = (ir_node*)get_irn_link(node); proj;
+ proj = (ir_node*)get_irn_link(proj)) {
long proj_nr = get_Proj_proj(proj);
if (proj_nr == pn_Call_T_result && get_Proj_pred(proj) == node) {
/* 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 = get_irn_link(results); proj; proj = 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);
*/
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 = get_irn_link(n);
- if (n == NULL)
- break;
+ if (n_64bit_outs == 0)
+ return;
- proj_mode = get_irn_mode(n);
- if (proj_mode == his || proj_mode == hiu) {
- panic("lowering ASM unimplemented");
+ {
+ 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);
+
+ 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);
+ }
}
}
}
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);
/**
* check for opcodes that must always be lowered.
*/
-static bool always_lower(ir_opcode code)
+static bool always_lower(unsigned code)
{
switch (code) {
case iro_ASM:
*/
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;
+ const op_mode_entry_t *e1 = (const op_mode_entry_t*)elt;
+ const op_mode_entry_t *e2 = (const op_mode_entry_t*)key;
(void) size;
- return (e1->op - e2->op) | (e1->imode - e2->imode) | (e1->omode - e2->omode);
+ return (e1->op != e2->op) | (e1->imode != e2->imode) | (e1->omode != e2->omode);
}
/**
*/
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;
+ const conv_tp_entry_t *e1 = (const conv_tp_entry_t*)elt;
+ const conv_tp_entry_t *e2 = (const conv_tp_entry_t*)key;
(void) size;
- return (e1->imode - e2->imode) | (e1->omode - e2->omode);
+ return (e1->imode != e2->imode) | (e1->omode != e2->omode);
}
/**
*/
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) {
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) {
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 */
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);
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);
}
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);
env->lowered_phis = NEW_ARR_F(ir_node*, 0);
while (!pdeq_empty(env->waitq)) {
- ir_node *node = pdeq_getl(env->waitq);
+ ir_node *node = (ir_node*)pdeq_getl(env->waitq);
lower_node(env, node);
}
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");
}
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);
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);
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);
}
projects / libfirm / blobdiff