/*
- * 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.
*
/**
* @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$
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.
*/
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_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.
*
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);
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);
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 = (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);
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);
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);
}
/**
- * 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);
}
/**
}
}
+/**
+ * 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;
}
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 = (ir_node*)get_irn_link(node); proj;
proj = (ir_node*)get_irn_link(proj)) {
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);
/* 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);
*/
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);
+ }
}
}
}
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);
*/
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);
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