/*
- * 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.
*
#include "ircons_t.h"
#include "irgmod.h"
#include "irverify.h"
+#include "iroptimize.h"
#include "tv_t.h"
#include "dbginfo_t.h"
#include "iropt_dbg.h"
#include "irhooks.h"
#include "irarch.h"
#include "hashptr.h"
-#include "opt_confirms.h"
#include "opt_polymorphy.h"
#include "irtools.h"
#include "irhooks.h"
#include "array_t.h"
#include "vrp.h"
#include "firm_types.h"
+#include "bitfiddle.h"
#include "be.h"
/* Make types visible to allow most efficient access */
/**
* Returns the tarval of a Const node or tarval_bad for all other nodes.
*/
-static tarval *default_value_of(const ir_node *n)
+static ir_tarval *default_value_of(const ir_node *n)
{
if (is_Const(n))
return get_Const_tarval(n); /* might return tarval_bad */
/**
* Return the value of a Constant.
*/
-static tarval *computed_value_Const(const ir_node *n)
+static ir_tarval *computed_value_Const(const ir_node *n)
{
return get_Const_tarval(n);
} /* computed_value_Const */
/**
* Return the value of a 'sizeof', 'alignof' or 'offsetof' SymConst.
*/
-static tarval *computed_value_SymConst(const ir_node *n)
+static ir_tarval *computed_value_SymConst(const ir_node *n)
{
ir_type *type;
ir_entity *ent;
/**
* Return the value of an Add.
*/
-static tarval *computed_value_Add(const ir_node *n)
+static ir_tarval *computed_value_Add(const ir_node *n)
{
ir_node *a = get_Add_left(n);
ir_node *b = get_Add_right(n);
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
if ((ta != tarval_bad) && (tb != tarval_bad))
return tarval_add(ta, tb);
* Return the value of a Sub.
* Special case: a - a
*/
-static tarval *computed_value_Sub(const ir_node *n)
+static ir_tarval *computed_value_Sub(const ir_node *n)
{
- ir_mode *mode = get_irn_mode(n);
- ir_node *a = get_Sub_left(n);
- ir_node *b = get_Sub_right(n);
- tarval *ta;
- tarval *tb;
+ ir_mode *mode = get_irn_mode(n);
+ ir_node *a = get_Sub_left(n);
+ ir_node *b = get_Sub_right(n);
+ ir_tarval *ta;
+ ir_tarval *tb;
/* NaN - NaN != 0 */
if (! mode_is_float(mode)) {
* Return the value of a Carry.
* Special : a op 0, 0 op b
*/
-static tarval *computed_value_Carry(const ir_node *n)
+static ir_tarval *computed_value_Carry(const ir_node *n)
{
- ir_node *a = get_binop_left(n);
- ir_node *b = get_binop_right(n);
- ir_mode *m = get_irn_mode(n);
-
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+ ir_node *a = get_binop_left(n);
+ ir_node *b = get_binop_right(n);
+ ir_mode *m = get_irn_mode(n);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
if ((ta != tarval_bad) && (tb != tarval_bad)) {
tarval_add(ta, tb);
* Return the value of a Borrow.
* Special : a op 0
*/
-static tarval *computed_value_Borrow(const ir_node *n)
+static ir_tarval *computed_value_Borrow(const ir_node *n)
{
- ir_node *a = get_binop_left(n);
- ir_node *b = get_binop_right(n);
- ir_mode *m = get_irn_mode(n);
-
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+ ir_node *a = get_binop_left(n);
+ ir_node *b = get_binop_right(n);
+ ir_mode *m = get_irn_mode(n);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
if ((ta != tarval_bad) && (tb != tarval_bad)) {
return tarval_cmp(ta, tb) == pn_Cmp_Lt ? get_mode_one(m) : get_mode_null(m);
/**
* Return the value of an unary Minus.
*/
-static tarval *computed_value_Minus(const ir_node *n)
+static ir_tarval *computed_value_Minus(const ir_node *n)
{
- ir_node *a = get_Minus_op(n);
- tarval *ta = value_of(a);
+ ir_node *a = get_Minus_op(n);
+ ir_tarval *ta = value_of(a);
if (ta != tarval_bad)
return tarval_neg(ta);
/**
* Return the value of a Mul.
*/
-static tarval *computed_value_Mul(const ir_node *n)
+static ir_tarval *computed_value_Mul(const ir_node *n)
{
- ir_node *a = get_Mul_left(n);
- ir_node *b = get_Mul_right(n);
- ir_mode *mode;
-
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+ ir_node *a = get_Mul_left(n);
+ ir_node *b = get_Mul_right(n);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
+ ir_mode *mode;
mode = get_irn_mode(n);
if (mode != get_irn_mode(a)) {
return tarval_bad;
} /* computed_value_Mul */
-/**
- * Return the value of an Abs.
- */
-static tarval *computed_value_Abs(const ir_node *n)
-{
- ir_node *a = get_Abs_op(n);
- tarval *ta = value_of(a);
-
- if (ta != tarval_bad)
- return tarval_abs(ta);
-
- return tarval_bad;
-} /* computed_value_Abs */
-
/**
* Return the value of an And.
* Special case: a & 0, 0 & b
*/
-static tarval *computed_value_And(const ir_node *n)
+static ir_tarval *computed_value_And(const ir_node *n)
{
- ir_node *a = get_And_left(n);
- ir_node *b = get_And_right(n);
-
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+ ir_node *a = get_And_left(n);
+ ir_node *b = get_And_right(n);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
if ((ta != tarval_bad) && (tb != tarval_bad)) {
return tarval_and (ta, tb);
* Return the value of an Or.
* Special case: a | 1...1, 1...1 | b
*/
-static tarval *computed_value_Or(const ir_node *n)
+static ir_tarval *computed_value_Or(const ir_node *n)
{
- ir_node *a = get_Or_left(n);
- ir_node *b = get_Or_right(n);
-
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+ ir_node *a = get_Or_left(n);
+ ir_node *b = get_Or_right(n);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
if ((ta != tarval_bad) && (tb != tarval_bad)) {
return tarval_or (ta, tb);
/**
* Return the value of an Eor.
*/
-static tarval *computed_value_Eor(const ir_node *n)
+static ir_tarval *computed_value_Eor(const ir_node *n)
{
ir_node *a = get_Eor_left(n);
ir_node *b = get_Eor_right(n);
- tarval *ta, *tb;
+ ir_tarval *ta, *tb;
if (a == b)
return get_mode_null(get_irn_mode(n));
/**
* Return the value of a Not.
*/
-static tarval *computed_value_Not(const ir_node *n)
+static ir_tarval *computed_value_Not(const ir_node *n)
{
- ir_node *a = get_Not_op(n);
- tarval *ta = value_of(a);
+ ir_node *a = get_Not_op(n);
+ ir_tarval *ta = value_of(a);
if (ta != tarval_bad)
return tarval_not(ta);
/**
* Return the value of a Shl.
*/
-static tarval *computed_value_Shl(const ir_node *n)
+static ir_tarval *computed_value_Shl(const ir_node *n)
{
ir_node *a = get_Shl_left(n);
ir_node *b = get_Shl_right(n);
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
if ((ta != tarval_bad) && (tb != tarval_bad)) {
return tarval_shl(ta, tb);
/**
* Return the value of a Shr.
*/
-static tarval *computed_value_Shr(const ir_node *n)
+static ir_tarval *computed_value_Shr(const ir_node *n)
{
ir_node *a = get_Shr_left(n);
ir_node *b = get_Shr_right(n);
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
if ((ta != tarval_bad) && (tb != tarval_bad)) {
return tarval_shr(ta, tb);
/**
* Return the value of a Shrs.
*/
-static tarval *computed_value_Shrs(const ir_node *n)
+static ir_tarval *computed_value_Shrs(const ir_node *n)
{
ir_node *a = get_Shrs_left(n);
ir_node *b = get_Shrs_right(n);
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
if ((ta != tarval_bad) && (tb != tarval_bad)) {
return tarval_shrs(ta, tb);
/**
* Return the value of a Rotl.
*/
-static tarval *computed_value_Rotl(const ir_node *n)
+static ir_tarval *computed_value_Rotl(const ir_node *n)
{
ir_node *a = get_Rotl_left(n);
ir_node *b = get_Rotl_right(n);
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
if ((ta != tarval_bad) && (tb != tarval_bad)) {
return tarval_rotl(ta, tb);
/**
* Return the value of a Conv.
*/
-static tarval *computed_value_Conv(const ir_node *n)
+static ir_tarval *computed_value_Conv(const ir_node *n)
{
ir_node *a = get_Conv_op(n);
- tarval *ta = value_of(a);
+ ir_tarval *ta = value_of(a);
if (ta != tarval_bad)
return tarval_convert_to(ta, get_irn_mode(n));
* Calculate the value of a Mux: can be evaluated, if the
* sel and the right input are known.
*/
-static tarval *computed_value_Mux(const ir_node *n)
+static ir_tarval *computed_value_Mux(const ir_node *n)
{
ir_node *sel = get_Mux_sel(n);
- tarval *ts = value_of(sel);
+ ir_tarval *ts = value_of(sel);
if (ts == get_tarval_b_true()) {
ir_node *v = get_Mux_true(n);
* Calculate the value of a Confirm: can be evaluated,
* if it has the form Confirm(x, '=', Const).
*/
-static tarval *computed_value_Confirm(const ir_node *n)
+static ir_tarval *computed_value_Confirm(const ir_node *n)
{
- /*
- * Beware: we might produce Phi(Confirm(x == true), Confirm(x == false)).
- * Do NOT optimize them away (jump threading wants them), so wait until
- * remove_confirm is activated.
- */
- if (get_opt_remove_confirm()) {
- if (get_Confirm_cmp(n) == pn_Cmp_Eq) {
- tarval *tv = value_of(get_Confirm_bound(n));
- if (tv != tarval_bad)
- return tv;
- }
+ if (get_Confirm_cmp(n) == pn_Cmp_Eq) {
+ ir_tarval *tv = value_of(get_Confirm_bound(n));
+ if (tv != tarval_bad)
+ return tv;
}
return value_of(get_Confirm_value(n));
} /* computed_value_Confirm */
* only 1 is used.
* There are several case where we can evaluate a Cmp node, see later.
*/
-static tarval *computed_value_Proj_Cmp(const ir_node *n)
+static ir_tarval *computed_value_Proj_Cmp(const ir_node *n)
{
- ir_node *cmp = get_Proj_pred(n);
- ir_node *left = get_Cmp_left(cmp);
- ir_node *right = get_Cmp_right(cmp);
- long pn_cmp = get_Proj_proj(n);
- ir_mode *mode = get_irn_mode(left);
- tarval *tv_l, *tv_r;
+ ir_node *cmp = get_Proj_pred(n);
+ ir_node *left = get_Cmp_left(cmp);
+ ir_node *right = get_Cmp_right(cmp);
+ pn_Cmp pn_cmp = get_Proj_pn_cmp(n);
+ ir_mode *mode = get_irn_mode(left);
+ ir_tarval *tv_l, *tv_r;
/*
* BEWARE: a == a is NOT always True for floating Point values, as
/**
* Return the value of a floating point Quot.
*/
-static tarval *do_computed_value_Quot(const ir_node *a, const ir_node *b)
+static ir_tarval *do_computed_value_Quot(const ir_node *a, const ir_node *b)
{
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
/* cannot optimize 0 / b = 0 because of NaN */
if (ta != tarval_bad && tb != tarval_bad)
* Calculate the value of an integer Div of two nodes.
* Special case: 0 / b
*/
-static tarval *do_computed_value_Div(const ir_node *a, const ir_node *b)
+static ir_tarval *do_computed_value_Div(const ir_node *a, const ir_node *b)
{
- tarval *ta = value_of(a);
- tarval *tb;
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb;
const ir_node *dummy;
/* Compute c1 / c2 or 0 / a, a != 0 */
* Calculate the value of an integer Mod of two nodes.
* Special case: a % 1
*/
-static tarval *do_computed_value_Mod(const ir_node *a, const ir_node *b)
+static ir_tarval *do_computed_value_Mod(const ir_node *a, const ir_node *b)
{
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
/* Compute a % 1 or c1 % c2 */
if (tarval_is_one(tb))
/**
* Return the value of a Proj(DivMod).
*/
-static tarval *computed_value_Proj_DivMod(const ir_node *n)
+static ir_tarval *computed_value_Proj_DivMod(const ir_node *n)
{
long proj_nr = get_Proj_proj(n);
/**
* Return the value of a Proj(Div).
*/
-static tarval *computed_value_Proj_Div(const ir_node *n)
+static ir_tarval *computed_value_Proj_Div(const ir_node *n)
{
long proj_nr = get_Proj_proj(n);
/**
* Return the value of a Proj(Mod).
*/
-static tarval *computed_value_Proj_Mod(const ir_node *n)
+static ir_tarval *computed_value_Proj_Mod(const ir_node *n)
{
long proj_nr = get_Proj_proj(n);
/**
* Return the value of a Proj(Quot).
*/
-static tarval *computed_value_Proj_Quot(const ir_node *n)
+static ir_tarval *computed_value_Proj_Quot(const ir_node *n)
{
long proj_nr = get_Proj_proj(n);
/**
* Return the value of a Proj.
*/
-static tarval *computed_value_Proj(const ir_node *proj)
+static ir_tarval *computed_value_Proj(const ir_node *proj)
{
ir_node *n = get_Proj_pred(proj);
*
* @param n The node this should be evaluated
*/
-tarval *computed_value(const ir_node *n)
+ir_tarval *computed_value(const ir_node *n)
{
vrp_attr *vrp = vrp_get_info(n);
if (vrp && vrp->valid && tarval_cmp(vrp->bits_set, vrp->bits_not_set) == pn_Cmp_Eq) {
CASE(Borrow);
CASE(Minus);
CASE(Mul);
- CASE(Abs);
CASE(And);
CASE(Or);
CASE(Eor);
/* Jmp jumps into the block it is in -- deal self cycle. */
n = set_Block_dead(n);
DBG_OPT_DEAD_BLOCK(oldn, n);
- } else if (get_opt_control_flow_straightening()) {
+ } else {
n = predblock;
DBG_OPT_STG(oldn, n);
}
DBG_OPT_DEAD_BLOCK(oldn, n);
}
}
- } else if ((n_preds == 2) &&
- (get_opt_control_flow_weak_simplification())) {
+ } else if (n_preds == 2) {
/* Test whether Cond jumps twice to this block
* The more general case which more than 2 predecessors is handles
* in optimize_cf(), we handle only this special case for speed here.
ir_node *a = get_binop_left(n);
ir_node *b = get_binop_right(n);
- tarval *tv;
+ ir_tarval *tv;
ir_node *on;
/* After running compute_node there is only one constant predecessor.
{
ir_node *oldn = n;
- ir_node *a = get_binop_left(n);
- ir_node *b = get_binop_right(n);
- tarval *tb = value_of(b);
+ ir_node *a = get_binop_left(n);
+ ir_node *b = get_binop_right(n);
+ ir_tarval *tb = value_of(b);
if (tarval_is_null(tb)) {
n = a;
*/
static ir_node *equivalent_node_Sub(ir_node *n)
{
- ir_node *oldn = n;
- ir_node *b;
- ir_mode *mode = get_irn_mode(n);
- tarval *tb;
+ ir_node *oldn = n;
+ ir_node *b;
+ ir_mode *mode = get_irn_mode(n);
+ ir_tarval *tb;
/* for FP these optimizations are only allowed if fp_strict_algebraic is disabled */
if (mode_is_float(mode)) {
/* we can handle here only the n * n = n bit cases */
if (get_irn_mode(n) == get_irn_mode(a)) {
- ir_node *b = get_Mul_right(n);
- tarval *tv;
+ ir_node *b = get_Mul_right(n);
+ ir_tarval *tv;
/*
* Mul is commutative and has again an other neutral element.
{
ir_node *oldn = n;
- ir_node *a = get_Or_left(n);
- ir_node *b = get_Or_right(n);
- tarval *tv;
+ ir_node *a = get_Or_left(n);
+ ir_node *b = get_Or_right(n);
+ ir_tarval *tv;
if (a == b) {
n = a; /* Or has it's own neutral element */
{
ir_node *oldn = n;
- ir_node *a = get_And_left(n);
- ir_node *b = get_And_right(n);
- tarval *tv;
+ ir_node *a = get_And_left(n);
+ ir_node *b = get_And_right(n);
+ ir_tarval *tv;
if (a == b) {
n = a; /* And has it's own neutral element */
if (get_Conv_strict(n)) {
ir_node *p = a;
- /* neither Minus nor Abs nor Confirm change the precision,
+ /* neither Minus nor Confirm change the precision,
so we can "look-through" */
for (;;) {
if (is_Minus(p)) {
p = get_Minus_op(p);
- } else if (is_Abs(p)) {
- p = get_Abs_op(p);
} else if (is_Confirm(p)) {
p = get_Confirm_value(p);
} else {
}
if (is_Conv(p) && get_Conv_strict(p)) {
/* we known already, that a_mode == n_mode, and neither
- Abs nor Minus change the mode, so the second Conv
+ Minus change the mode, so the second Conv
can be kicked */
assert(get_irn_mode(p) == n_mode);
n = a;
return n;
} /* equivalent_node_Conv */
-/**
- * A Cast may be removed if the type of the previous node
- * is already the type of the Cast.
- */
-static ir_node *equivalent_node_Cast(ir_node *n)
-{
- ir_node *oldn = n;
- ir_node *pred = get_Cast_op(n);
-
- if (get_irn_type(pred) == get_Cast_type(n)) {
- n = pred;
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_CAST);
- }
- return n;
-} /* equivalent_node_Cast */
-
/**
* - fold Phi-nodes, iff they have only one predecessor except
* themselves.
ir_node *block;
ir_node *first_val = NULL; /* to shutup gcc */
- if (!get_opt_normalize()) return n;
+ if (!get_opt_optimize() &&
+ get_irg_phase_state(get_irn_irg(n)) != phase_building)
+ return n;
n_preds = get_Phi_n_preds(n);
}
}
- if (i >= n_preds) {
+ if (i >= n_preds && !is_Dummy(first_val)) {
/* Fold, if no multiple distinct non-self-referencing inputs */
n = first_val;
DBG_OPT_PHI(oldn, n);
*/
static ir_node *equivalent_node_Proj_Div(ir_node *proj)
{
- ir_node *oldn = proj;
- ir_node *div = get_Proj_pred(proj);
- ir_node *b = get_Div_right(div);
- tarval *tb = value_of(b);
+ ir_node *oldn = proj;
+ ir_node *div = get_Proj_pred(proj);
+ ir_node *b = get_Div_right(div);
+ ir_tarval *tb = value_of(b);
/* Div is not commutative. */
if (tarval_is_one(tb)) { /* div(x, 1) == x */
*/
static ir_node *equivalent_node_Proj_Quot(ir_node *proj)
{
- ir_node *oldn = proj;
- ir_node *quot = get_Proj_pred(proj);
- ir_node *b = get_Quot_right(quot);
- tarval *tb = value_of(b);
+ ir_node *oldn = proj;
+ ir_node *quot = get_Proj_pred(proj);
+ ir_node *b = get_Quot_right(quot);
+ ir_tarval *tb = value_of(b);
/* Div is not commutative. */
if (tarval_is_one(tb)) { /* Quot(x, 1) == x */
*/
static ir_node *equivalent_node_Proj_DivMod(ir_node *proj)
{
- ir_node *oldn = proj;
- ir_node *divmod = get_Proj_pred(proj);
- ir_node *b = get_DivMod_right(divmod);
- tarval *tb = value_of(b);
+ ir_node *oldn = proj;
+ ir_node *divmod = get_Proj_pred(proj);
+ ir_node *b = get_DivMod_right(divmod);
+ ir_tarval *tb = value_of(b);
/* Div is not commutative. */
if (tarval_is_one(tb)) { /* div(x, 1) == x */
ret_tuple = 1;
else if (is_Bound(pred)) {
/*
- * idx was Bounds checked in the same MacroBlock previously,
- * it is still valid if lower <= pred_lower && pred_upper <= upper.
+ * idx was Bounds checked previously, it is still valid if
+ * lower <= pred_lower && pred_upper <= upper.
*/
ir_node *lower = get_Bound_lower(bound);
ir_node *upper = get_Bound_upper(bound);
if (get_Bound_lower(pred) == lower &&
- get_Bound_upper(pred) == upper &&
- get_irn_MacroBlock(bound) == get_irn_MacroBlock(pred)) {
+ get_Bound_upper(pred) == upper) {
/*
* One could expect that we simply return the previous
* Bound here. However, this would be wrong, as we could
*/
static ir_node *equivalent_node_Mux(ir_node *n)
{
- ir_node *oldn = n, *sel = get_Mux_sel(n);
- ir_node *n_t, *n_f;
- tarval *ts = value_of(sel);
+ ir_node *oldn = n, *sel = get_Mux_sel(n);
+ ir_node *n_t, *n_f;
+ ir_tarval *ts = value_of(sel);
/* Mux(true, f, t) == t */
if (ts == tarval_b_true) {
pred = get_Confirm_value(n);
pnc = get_Confirm_cmp(n);
}
- if (get_opt_remove_confirm())
- return get_Confirm_value(n);
return n;
}
CASE(Or);
CASE(And);
CASE(Conv);
- CASE(Cast);
CASE(Phi);
CASE(Sync);
CASE_PROJ(Tuple);
return 1;
} /* is_const_Phi */
-typedef tarval *(*tarval_sub_type)(tarval *a, tarval *b, ir_mode *mode);
-typedef tarval *(*tarval_binop_type)(tarval *a, tarval *b);
+typedef ir_tarval *(*tarval_sub_type)(ir_tarval *a, ir_tarval *b, ir_mode *mode);
+typedef ir_tarval *(*tarval_binop_type)(ir_tarval *a, ir_tarval *b);
/**
* in reality eval_func should be tarval (*eval_func)() but incomplete
/**
* Wrapper for the tarval binop evaluation, tarval_sub has one more parameter.
*/
-static tarval *do_eval(eval_func eval, tarval *a, tarval *b, ir_mode *mode)
+static ir_tarval *do_eval(eval_func eval, ir_tarval *a, ir_tarval *b, ir_mode *mode)
{
if (eval == (eval_func) tarval_sub) {
tarval_sub_type func = (tarval_sub_type)eval;
*
* @return a new Phi node if the conversion was successful, NULL else
*/
-static ir_node *apply_binop_on_phi(ir_node *phi, tarval *other, eval_func eval, ir_mode *mode, int left)
+static ir_node *apply_binop_on_phi(ir_node *phi, ir_tarval *other, eval_func eval, ir_mode *mode, int left)
{
- tarval *tv;
- void **res;
- ir_node *pred;
- ir_graph *irg;
- int i, n = get_irn_arity(phi);
+ ir_tarval *tv;
+ void **res;
+ ir_node *pred;
+ ir_graph *irg;
+ int i, n = get_irn_arity(phi);
NEW_ARR_A(void *, res, n);
if (left) {
irg = get_irn_irg(phi);
for (i = 0; i < n; ++i) {
pred = get_irn_n(phi, i);
- res[i] = new_r_Const_type(irg, res[i], get_Const_type(pred));
+ res[i] = new_r_Const(irg, (ir_tarval*)res[i]);
}
return new_r_Phi(get_nodes_block(phi), n, (ir_node **)res, mode);
} /* apply_binop_on_phi */
*/
static ir_node *apply_binop_on_2_phis(ir_node *a, ir_node *b, eval_func eval, ir_mode *mode)
{
- tarval *tv_l, *tv_r, *tv;
+ ir_tarval *tv_l, *tv_r, *tv;
void **res;
ir_node *pred;
ir_graph *irg;
irg = get_irn_irg(a);
for (i = 0; i < n; ++i) {
pred = get_irn_n(a, i);
- res[i] = new_r_Const_type(irg, res[i], get_Const_type(pred));
+ res[i] = new_r_Const(irg, (ir_tarval*)res[i]);
}
return new_r_Phi(get_nodes_block(a), n, (ir_node **)res, mode);
} /* apply_binop_on_2_phis */
*
* @return a new Phi node if the conversion was successful, NULL else
*/
-static ir_node *apply_unop_on_phi(ir_node *phi, tarval *(*eval)(tarval *))
+static ir_node *apply_unop_on_phi(ir_node *phi, ir_tarval *(*eval)(ir_tarval *))
{
- tarval *tv;
+ ir_tarval *tv;
void **res;
ir_node *pred;
ir_mode *mode;
irg = get_irn_irg(phi);
for (i = 0; i < n; ++i) {
pred = get_irn_n(phi, i);
- res[i] = new_r_Const_type(irg, res[i], get_Const_type(pred));
+ res[i] = new_r_Const(irg, (ir_tarval*)res[i]);
}
return new_r_Phi(get_nodes_block(phi), n, (ir_node **)res, mode);
} /* apply_unop_on_phi */
*/
static ir_node *apply_conv_on_phi(ir_node *phi, ir_mode *mode)
{
- tarval *tv;
+ ir_tarval *tv;
void **res;
ir_node *pred;
ir_graph *irg;
irg = get_irn_irg(phi);
for (i = 0; i < n; ++i) {
pred = get_irn_n(phi, i);
- res[i] = new_r_Const_type(irg, res[i], get_Const_type(pred));
+ res[i] = new_r_Const(irg, (ir_tarval*)res[i]);
}
return new_r_Phi(get_nodes_block(phi), n, (ir_node **)res, mode);
} /* apply_conv_on_phi */
get_irn_dbg_info(n),
block,
a,
- new_Const_long(mode, 2),
+ new_r_Const_long(irg, mode, 2),
mode);
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ADD_A_A);
return n;
}
if (op == b) {
/* ~x + x = -1 */
- n = new_Const(get_mode_minus_one(mode));
+ n = new_r_Const(irg, get_mode_minus_one(mode));
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ADD_X_NOT_X);
return n;
}
if (op == a) {
/* x + ~x = -1 */
- n = new_Const(get_mode_minus_one(mode));
+ n = new_r_Const(irg, get_mode_minus_one(mode));
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ADD_X_NOT_X);
return n;
}
b_vrp = vrp_get_info(b);
if (a_vrp && b_vrp) {
- tarval *c = tarval_and(
- a_vrp->bits_not_set,
- b_vrp->bits_not_set
- );
+ ir_tarval *c = tarval_and(a_vrp->bits_not_set, b_vrp->bits_not_set);
if (tarval_is_null(c)) {
- dbg_info *dbgi = get_irn_dbg_info(n);
- return new_rd_Or(dbgi, get_nodes_block(n),
- a, b, mode);
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ return new_rd_Or(dbgi, get_nodes_block(n), a, b, mode);
}
}
return n;
*/
static ir_node *const_negate(ir_node *cnst)
{
- tarval *tv = tarval_neg(get_Const_tarval(cnst));
- dbg_info *dbgi = get_irn_dbg_info(cnst);
- ir_graph *irg = get_irn_irg(cnst);
+ ir_tarval *tv = tarval_neg(get_Const_tarval(cnst));
+ dbg_info *dbgi = get_irn_dbg_info(cnst);
+ ir_graph *irg = get_irn_irg(cnst);
if (tv == tarval_bad) return NULL;
return new_rd_Const(dbgi, irg, tv);
}
return n;
} else if (right == b) {
if (mode != get_irn_mode(left)) {
- /* This Sub is an effective Cast */
+ /* This Sub is an effective Cast */
left = new_r_Conv(get_nodes_block(n), left, mode);
}
n = left;
n = new_r_Minus(get_nodes_block(n), left, l_mode);
if (mode != l_mode) {
- /* This Sub is an effective Cast */
+ /* This Sub is an effective Cast */
n = new_r_Conv(get_nodes_block(n), n, mode);
}
DBG_OPT_ALGSIM1(oldn, a, b, n, FS_OPT_ADD_SUB);
ir_node *mb = get_Mul_right(a);
if (ma == b) {
- ir_node *blk = get_nodes_block(n);
+ ir_node *blk = get_nodes_block(n);
+ ir_graph *irg = get_irn_irg(n);
n = new_rd_Mul(
get_irn_dbg_info(n),
blk,
get_irn_dbg_info(n),
blk,
mb,
- new_Const(get_mode_one(mode)),
+ new_r_Const(irg, get_mode_one(mode)),
mode),
mode);
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_SUB_MUL_A_X_A);
return n;
} else if (mb == b) {
- ir_node *blk = get_nodes_block(n);
+ ir_node *blk = get_nodes_block(n);
+ ir_graph *irg = get_irn_irg(n);
n = new_rd_Mul(
get_irn_dbg_info(n),
blk,
get_irn_dbg_info(n),
blk,
ma,
- new_Const(get_mode_one(mode)),
+ new_r_Const(irg, get_mode_one(mode)),
mode),
mode);
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_SUB_MUL_A_X_A);
if (get_mode_arithmetic(mode) == irma_twos_complement) {
if (is_Const(a) && is_Not(b)) {
/* c - ~X = X + (c+1) */
- tarval *tv = get_Const_tarval(a);
+ ir_tarval *tv = get_Const_tarval(a);
tv = tarval_add(tv, get_mode_one(mode));
if (tv != tarval_bad) {
- ir_node *blk = get_nodes_block(n);
- ir_node *c = new_Const(tv);
+ ir_node *blk = get_nodes_block(n);
+ ir_graph *irg = get_irn_irg(n);
+ ir_node *c = new_r_Const(irg, tv);
n = new_rd_Add(get_irn_dbg_info(n), blk, get_Not_op(b), c, mode);
DBG_OPT_ALGSIM0(oldn, n, FS_OPT_SUB_C_NOT_X);
return n;
*/
static ir_node *transform_node_Mul2n(ir_node *n, ir_mode *mode)
{
- ir_node *oldn = n;
- ir_node *a = get_Mul_left(n);
- ir_node *b = get_Mul_right(n);
- tarval *ta = value_of(a);
- tarval *tb = value_of(b);
- ir_mode *smode = get_irn_mode(a);
+ ir_node *oldn = n;
+ ir_node *a = get_Mul_left(n);
+ ir_node *b = get_Mul_right(n);
+ ir_tarval *ta = value_of(a);
+ ir_tarval *tb = value_of(b);
+ ir_mode *smode = get_irn_mode(a);
if (ta == get_mode_one(smode)) {
/* (L)1 * (L)b = (L)b */
}
if (get_mode_arithmetic(mode) == irma_ieee754) {
if (is_Const(a)) {
- tarval *tv = get_Const_tarval(a);
+ ir_tarval *tv = get_Const_tarval(a);
if (tarval_ieee754_get_exponent(tv) == 1 && tarval_ieee754_zero_mantissa(tv)
&& !tarval_is_negative(tv)) {
/* 2.0 * b = b + b */
}
}
else if (is_Const(b)) {
- tarval *tv = get_Const_tarval(b);
+ ir_tarval *tv = get_Const_tarval(b);
if (tarval_ieee754_get_exponent(tv) == 1 && tarval_ieee754_zero_mantissa(tv)
&& !tarval_is_negative(tv)) {
/* a * 2.0 = a + a */
value = n;
if (a == b && value_not_zero(a, &dummy)) {
+ ir_graph *irg = get_irn_irg(n);
/* BEWARE: we can optimize a/a to 1 only if this cannot cause a exception */
- value = new_Const(get_mode_one(mode));
+ value = new_r_Const(irg, get_mode_one(mode));
DBG_OPT_CSTEVAL(n, value);
goto make_tuple;
} else {
if (mode_is_signed(mode) && is_Const(b)) {
- tarval *tv = get_Const_tarval(b);
+ ir_tarval *tv = get_Const_tarval(b);
if (tv == get_mode_minus_one(mode)) {
/* a / -1 */
if (value != n) {
ir_node *mem, *blk;
+ ir_graph *irg;
make_tuple:
/* Turn Div into a tuple (mem, jmp, bad, value) */
mem = get_Div_mem(n);
blk = get_nodes_block(n);
+ irg = get_irn_irg(blk);
/* skip a potential Pin */
mem = skip_Pin(mem);
turn_into_tuple(n, pn_Div_max);
set_Tuple_pred(n, pn_Div_M, mem);
set_Tuple_pred(n, pn_Div_X_regular, new_r_Jmp(blk));
- set_Tuple_pred(n, pn_Div_X_except, new_Bad());
+ set_Tuple_pred(n, pn_Div_X_except, get_irg_bad(irg));
set_Tuple_pred(n, pn_Div_res, value);
}
return n;
*/
static ir_node *transform_node_Mod(ir_node *n)
{
- ir_mode *mode = get_Mod_resmode(n);
- ir_node *a = get_Mod_left(n);
- ir_node *b = get_Mod_right(n);
- ir_node *value;
- tarval *tv;
+ ir_mode *mode = get_Mod_resmode(n);
+ ir_node *a = get_Mod_left(n);
+ ir_node *b = get_Mod_right(n);
+ ir_graph *irg;
+ ir_node *value;
+ ir_tarval *tv;
if (is_Const(b) && is_const_Phi(a)) {
/* check for Div(Phi, Const) */
value = n;
tv = value_of(n);
+ irg = get_irn_irg(n);
if (tv != tarval_bad) {
- value = new_Const(tv);
+ value = new_r_Const(irg, tv);
DBG_OPT_CSTEVAL(n, value);
goto make_tuple;
if (a == b && value_not_zero(a, &dummy)) {
/* BEWARE: we can optimize a%a to 0 only if this cannot cause a exception */
- value = new_Const(get_mode_null(mode));
+ value = new_r_Const(irg, get_mode_null(mode));
DBG_OPT_CSTEVAL(n, value);
goto make_tuple;
} else {
if (mode_is_signed(mode) && is_Const(b)) {
- tarval *tv = get_Const_tarval(b);
+ ir_tarval *tv = get_Const_tarval(b);
if (tv == get_mode_minus_one(mode)) {
/* a % -1 = 0 */
- value = new_Const(get_mode_null(mode));
+ value = new_r_Const(irg, get_mode_null(mode));
DBG_OPT_CSTEVAL(n, value);
goto make_tuple;
}
if (value != n) {
ir_node *mem, *blk;
+ ir_graph *irg;
make_tuple:
/* Turn Mod into a tuple (mem, jmp, bad, value) */
mem = get_Mod_mem(n);
blk = get_nodes_block(n);
+ irg = get_irn_irg(blk);
/* skip a potential Pin */
mem = skip_Pin(mem);
turn_into_tuple(n, pn_Mod_max);
set_Tuple_pred(n, pn_Mod_M, mem);
set_Tuple_pred(n, pn_Mod_X_regular, new_r_Jmp(blk));
- set_Tuple_pred(n, pn_Mod_X_except, new_Bad());
+ set_Tuple_pred(n, pn_Mod_X_except, get_irg_bad(irg));
set_Tuple_pred(n, pn_Mod_res, value);
}
return n;
ir_node *b = get_DivMod_right(n);
ir_mode *mode = get_DivMod_resmode(n);
ir_node *va, *vb;
- tarval *ta, *tb;
+ ir_graph *irg = get_irn_irg(n);
+ ir_tarval *ta, *tb;
int evaluated = 0;
if (is_Const(b) && is_const_Phi(a)) {
if (tb != tarval_bad) {
if (tb == get_mode_one(get_tarval_mode(tb))) {
va = a;
- vb = new_Const(get_mode_null(mode));
+ vb = new_r_Const(irg, get_mode_null(mode));
DBG_OPT_CSTEVAL(n, vb);
goto make_tuple;
} else if (ta != tarval_bad) {
- tarval *resa, *resb;
+ ir_tarval *resa, *resb;
resa = tarval_div(ta, tb);
if (resa == tarval_bad) return n; /* Causes exception!!! Model by replacing through
Jmp for X result!? */
resb = tarval_mod(ta, tb);
if (resb == tarval_bad) return n; /* Causes exception! */
- va = new_Const(resa);
- vb = new_Const(resb);
+ va = new_r_Const(irg, resa);
+ vb = new_r_Const(irg, resb);
DBG_OPT_CSTEVAL(n, va);
DBG_OPT_CSTEVAL(n, vb);
goto make_tuple;
} else if (mode_is_signed(mode) && tb == get_mode_minus_one(mode)) {
va = new_rd_Minus(get_irn_dbg_info(n), get_nodes_block(n), a, mode);
- vb = new_Const(get_mode_null(mode));
+ vb = new_r_Const(irg, get_mode_null(mode));
DBG_OPT_CSTEVAL(n, va);
DBG_OPT_CSTEVAL(n, vb);
goto make_tuple;
} else if (a == b) {
if (value_not_zero(a, &dummy)) {
/* a/a && a != 0 */
- va = new_Const(get_mode_one(mode));
- vb = new_Const(get_mode_null(mode));
+ va = new_r_Const(irg, get_mode_one(mode));
+ vb = new_r_Const(irg, get_mode_null(mode));
DBG_OPT_CSTEVAL(n, va);
DBG_OPT_CSTEVAL(n, vb);
goto make_tuple;
turn_into_tuple(n, pn_DivMod_max);
set_Tuple_pred(n, pn_DivMod_M, mem);
set_Tuple_pred(n, pn_DivMod_X_regular, new_r_Jmp(blk));
- set_Tuple_pred(n, pn_DivMod_X_except, new_Bad()); /* no exception */
+ set_Tuple_pred(n, pn_DivMod_X_except, get_irg_bad(irg)); /*no exception*/
set_Tuple_pred(n, pn_DivMod_res_div, va);
set_Tuple_pred(n, pn_DivMod_res_mod, vb);
}
ir_node *oldn = n;
if (get_mode_arithmetic(mode) == irma_ieee754) {
- ir_node *b = get_Quot_right(n);
- tarval *tv = value_of(b);
+ ir_node *b = get_Quot_right(n);
+ ir_tarval *tv = value_of(b);
if (tv != tarval_bad) {
int rem = tarval_fp_ops_enabled();
if (tv != tarval_bad &&
(tarval_ieee754_get_exact() || (get_irg_fp_model(get_irn_irg(n)) & fp_strict_algebraic) == 0)) {
ir_node *blk = get_nodes_block(n);
- ir_node *c = new_Const(tv);
+ ir_graph *irg = get_irn_irg(blk);
+ ir_node *c = new_r_Const(irg, tv);
ir_node *a = get_Quot_left(n);
ir_node *m = new_rd_Mul(get_irn_dbg_info(n), blk, a, c, mode);
ir_node *mem = get_Quot_mem(n);
turn_into_tuple(n, pn_Quot_max);
set_Tuple_pred(n, pn_Quot_M, mem);
set_Tuple_pred(n, pn_Quot_X_regular, new_r_Jmp(blk));
- set_Tuple_pred(n, pn_Quot_X_except, new_Bad());
+ set_Tuple_pred(n, pn_Quot_X_except, get_irg_bad(irg));
set_Tuple_pred(n, pn_Quot_res, m);
DBG_OPT_ALGSIM1(oldn, a, b, m, FS_OPT_FP_INV_MUL);
}
return n;
} /* transform_node_Quot */
-/**
- * Optimize Abs(x) into x if x is Confirmed >= 0
- * Optimize Abs(x) into -x if x is Confirmed <= 0
- * Optimize Abs(-x) int Abs(x)
- */
-static ir_node *transform_node_Abs(ir_node *n)
-{
- ir_node *c, *oldn = n;
- ir_node *a = get_Abs_op(n);
- ir_mode *mode;
-
- HANDLE_UNOP_PHI(tarval_abs, a, c);
-
- switch (classify_value_sign(a)) {
- case value_classified_negative:
- mode = get_irn_mode(n);
-
- /*
- * We can replace the Abs by -x here.
- * We even could add a new Confirm here
- * (if not twos complement)
- *
- * Note that -x would create a new node, so we could
- * not run it in the equivalent_node() context.
- */
- n = new_rd_Minus(get_irn_dbg_info(n), get_nodes_block(n), a, mode);
-
- DBG_OPT_CONFIRM(oldn, n);
- return n;
- case value_classified_positive:
- /* n is positive, Abs is not needed */
- n = a;
-
- DBG_OPT_CONFIRM(oldn, n);
- return n;
- default:
- break;
- }
- if (is_Minus(a)) {
- /* Abs(-x) = Abs(x) */
- mode = get_irn_mode(n);
- n = new_rd_Abs(get_irn_dbg_info(n), get_nodes_block(n), get_Minus_op(a), mode);
- DBG_OPT_ALGSIM0(oldn, n, FS_OPT_ABS_MINUS_X);
- return n;
- }
- return n;
-} /* transform_node_Abs */
-
/**
* Optimize -a CMP -b into b CMP a.
* This works only for for modes where unary Minus
static ir_node *transform_node_Cond(ir_node *n)
{
- ir_node *jmp;
- ir_node *a = get_Cond_selector(n);
- tarval *ta = value_of(a);
- ir_graph *irg = get_irn_irg(n);
+ ir_node *a = get_Cond_selector(n);
+ ir_tarval *ta = value_of(a);
+ ir_graph *irg = get_irn_irg(n);
+ ir_node *jmp;
/* we need block info which is not available in floating irgs */
if (get_irg_pinned(irg) == op_pin_state_floats)
jmp = new_r_Jmp(blk);
turn_into_tuple(n, pn_Cond_max);
if (ta == tarval_b_true) {
- set_Tuple_pred(n, pn_Cond_false, new_Bad());
+ set_Tuple_pred(n, pn_Cond_false, get_irg_bad(irg));
set_Tuple_pred(n, pn_Cond_true, jmp);
} else {
set_Tuple_pred(n, pn_Cond_false, jmp);
- set_Tuple_pred(n, pn_Cond_true, new_Bad());
+ set_Tuple_pred(n, pn_Cond_true, get_irg_bad(irg));
}
/* We might generate an endless loop, so keep it alive. */
add_End_keepalive(get_irg_end(irg), blk);
ir_node *pred_b = get_Proj_pred(b);
if (pred_a == pred_b) {
dbg_info *dbgi = get_irn_dbg_info(n);
- pn_Cmp pn_a = get_Proj_proj(a);
- pn_Cmp pn_b = get_Proj_proj(b);
+ pn_Cmp pn_a = get_Proj_pn_cmp(a);
+ pn_Cmp pn_b = get_Proj_pn_cmp(b);
/* yes, we can simply calculate with pncs */
pn_Cmp new_pnc = pn_a & pn_b;
ir_node *pred_b = get_Proj_pred(b);
if (pred_a == pred_b) {
dbg_info *dbgi = get_irn_dbg_info(n);
- pn_Cmp pn_a = get_Proj_proj(a);
- pn_Cmp pn_b = get_Proj_proj(b);
+ pn_Cmp pn_a = get_Proj_pn_cmp(a);
+ pn_Cmp pn_b = get_Proj_pn_cmp(b);
/* yes, we can simply calculate with pncs */
pn_Cmp new_pnc = pn_a ^ pn_b;
/* the following rules are only to twos-complement */
if (is_Not(a)) {
/* -(~x) = x + 1 */
- ir_node *op = get_Not_op(a);
- tarval *tv = get_mode_one(mode);
- ir_node *blk = get_nodes_block(n);
- ir_node *c = new_Const(tv);
+ ir_node *op = get_Not_op(a);
+ ir_tarval *tv = get_mode_one(mode);
+ ir_node *blk = get_nodes_block(n);
+ ir_graph *irg = get_irn_irg(blk);
+ ir_node *c = new_r_Const(irg, tv);
n = new_rd_Add(get_irn_dbg_info(n), blk, op, c, mode);
DBG_OPT_ALGSIM2(oldn, a, n, FS_OPT_MINUS_NOT);
return n;
ir_node *c = get_Shr_right(a);
if (is_Const(c)) {
- tarval *tv = get_Const_tarval(c);
+ ir_tarval *tv = get_Const_tarval(c);
if (tarval_is_long(tv) && get_tarval_long(tv) == (int) get_mode_size_bits(mode) - 1) {
/* -(a >>u (size-1)) = a >>s (size-1) */
ir_node *c = get_Shrs_right(a);
if (is_Const(c)) {
- tarval *tv = get_Const_tarval(c);
+ ir_tarval *tv = get_Const_tarval(c);
if (tarval_is_long(tv) && get_tarval_long(tv) == (int) get_mode_size_bits(mode) - 1) {
/* -(a >>s (size-1)) = a >>u (size-1) */
}
if (is_Mul(a)) { /* -(a * const) -> a * -const */
- ir_node *mul_l = get_Mul_left(a);
- ir_node *mul_r = get_Mul_right(a);
- tarval *tv = value_of(mul_r);
+ ir_node *mul_l = get_Mul_left(a);
+ ir_node *mul_r = get_Mul_right(a);
+ ir_tarval *tv = value_of(mul_r);
if (tv != tarval_bad) {
tv = tarval_neg(tv);
if (tv != tarval_bad) {
- ir_node *cnst = new_Const(tv);
+ ir_graph *irg = get_irn_irg(n);
+ ir_node *cnst = new_r_Const(irg, tv);
dbg_info *dbg = get_irn_dbg_info(a);
ir_node *block = get_nodes_block(a);
n = new_rd_Mul(dbg, block, mul_l, cnst, mode);
return n;
} /* transform_node_Minus */
-/**
- * Transform a Cast_type(Const) into a new Const_type
- */
-static ir_node *transform_node_Cast(ir_node *n)
-{
- ir_node *oldn = n;
- ir_node *pred = get_Cast_op(n);
- ir_type *tp = get_irn_type(n);
-
- if (is_Const(pred) && get_Const_type(pred) != tp) {
- ir_graph *irg = get_irn_irg(n);
- n = new_rd_Const_type(NULL, irg, get_Const_tarval(pred), tp);
- DBG_OPT_CSTEVAL(oldn, n);
- } else if (is_SymConst(pred) && get_SymConst_value_type(pred) != tp) {
- ir_graph *irg = get_irn_irg(n);
- n = new_rd_SymConst_type(NULL, irg, get_irn_mode(pred),
- get_SymConst_symbol(pred), get_SymConst_kind(pred), tp);
- DBG_OPT_CSTEVAL(oldn, n);
- }
-
- return n;
-} /* transform_node_Cast */
-
/**
* Transform a Proj(Load) with a non-null address.
*/
case pn_Div_X_regular:
return new_r_Jmp(get_nodes_block(div));
- case pn_Div_X_except:
+ case pn_Div_X_except: {
+ ir_graph *irg = get_irn_irg(proj);
/* we found an exception handler, remove it */
DBG_OPT_EXC_REM(proj);
- return new_Bad();
+ return get_irg_bad(irg);
+ }
case pn_Div_M: {
ir_graph *irg = get_irn_irg(proj);
case pn_Mod_X_regular:
return new_r_Jmp(get_irn_n(mod, -1));
- case pn_Mod_X_except:
+ case pn_Mod_X_except: {
+ ir_graph *irg = get_irn_irg(proj);
/* we found an exception handler, remove it */
DBG_OPT_EXC_REM(proj);
- return new_Bad();
+ return get_irg_bad(irg);
+ }
case pn_Mod_M: {
ir_graph *irg = get_irn_irg(proj);
case pn_Mod_res:
if (get_Mod_left(mod) == b) {
/* a % a = 0 if a != 0 */
- ir_mode *mode = get_irn_mode(proj);
- ir_node *res = new_Const(get_mode_null(mode));
+ ir_graph *irg = get_irn_irg(proj);
+ ir_mode *mode = get_irn_mode(proj);
+ ir_node *res = new_r_Const(irg, get_mode_null(mode));
DBG_OPT_CSTEVAL(mod, res);
return res;
case pn_DivMod_X_regular:
return new_r_Jmp(get_nodes_block(divmod));
- case pn_DivMod_X_except:
+ case pn_DivMod_X_except: {
/* we found an exception handler, remove it */
+ ir_graph *irg = get_irn_irg(proj);
DBG_OPT_EXC_REM(proj);
- return new_Bad();
+ return get_irg_bad(irg);
+ }
case pn_DivMod_M: {
ir_graph *irg = get_irn_irg(proj);
case pn_DivMod_res_mod:
if (get_DivMod_left(divmod) == b) {
/* a % a = 0 if a != 0 */
- ir_mode *mode = get_irn_mode(proj);
- ir_node *res = new_Const(get_mode_null(mode));
+ ir_graph *irg = get_irn_irg(proj);
+ ir_mode *mode = get_irn_mode(proj);
+ ir_node *res = new_r_Const(irg, get_mode_null(mode));
DBG_OPT_CSTEVAL(divmod, res);
return res;
ir_node *b = get_Cond_selector(n);
if (mode_is_int(get_irn_mode(b))) {
- tarval *tb = value_of(b);
+ ir_tarval *tb = value_of(b);
if (tb != tarval_bad) {
/* we have a constant switch */
vrp_attr *b_vrp = vrp_get_info(b);
if (num != get_Cond_default_proj(n) && b_vrp) {
/* Try handling with vrp data. We only remove dead parts. */
- tarval *tp = new_tarval_from_long(num, get_irn_mode(b));
+ ir_tarval *tp = new_tarval_from_long(num, get_irn_mode(b));
if (b_vrp->range_type == VRP_RANGE) {
pn_Cmp cmp_result = tarval_cmp(b_vrp->range_bottom, tp);
/**
* Create a 0 constant of given mode.
*/
-static ir_node *create_zero_const(ir_mode *mode)
+static ir_node *create_zero_const(ir_graph *irg, ir_mode *mode)
{
- tarval *tv = get_mode_null(mode);
- ir_node *cnst = new_Const(tv);
+ ir_tarval *tv = get_mode_null(mode);
+ ir_node *cnst = new_r_Const(irg, tv);
return cnst;
}
*/
static ir_node *transform_node_Proj_Cmp(ir_node *proj)
{
- ir_node *n = get_Proj_pred(proj);
- ir_node *left = get_Cmp_left(n);
- ir_node *right = get_Cmp_right(n);
- tarval *tv = NULL;
+ ir_node *n = get_Proj_pred(proj);
+ ir_node *left = get_Cmp_left(n);
+ ir_node *right = get_Cmp_right(n);
+ ir_tarval *tv = NULL;
int changed = 0;
ir_mode *mode = NULL;
long proj_nr = get_Proj_proj(proj);
/* we can evaluate some cases directly */
switch (proj_nr) {
- case pn_Cmp_False:
- return new_Const(get_tarval_b_false());
- case pn_Cmp_True:
- return new_Const(get_tarval_b_true());
+ case pn_Cmp_False: {
+ ir_graph *irg = get_irn_irg(proj);
+ return new_r_Const(irg, get_tarval_b_false());
+ }
+ case pn_Cmp_True: {
+ ir_graph *irg = get_irn_irg(proj);
+ return new_r_Const(irg, get_tarval_b_true());
+ }
case pn_Cmp_Leg:
- if (!mode_is_float(get_irn_mode(left)))
- return new_Const(get_tarval_b_true());
+ if (!mode_is_float(get_irn_mode(left))) {
+ ir_graph *irg = get_irn_irg(proj);
+ return new_r_Const(irg, get_tarval_b_true());
+ }
break;
default:
break;
lr = tmp;
}
if (ll == right) {
+ ir_graph *irg = get_irn_irg(n);
left = lr;
- right = create_zero_const(get_irn_mode(left));
+ right = create_zero_const(irg, get_irn_mode(left));
changed |= 1;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
}
rr = tmp;
}
if (rl == left) {
+ ir_graph *irg = get_irn_irg(n);
left = rr;
- right = create_zero_const(get_irn_mode(left));
+ right = create_zero_const(irg, get_irn_mode(left));
changed |= 1;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_OP_OP);
}
ir_node *llr = get_Shr_right(ll);
if (is_Const(llr)) {
dbg_info *dbg = get_irn_dbg_info(left);
+ ir_graph *irg = get_irn_irg(left);
- tarval *c1 = get_Const_tarval(llr);
- tarval *c2 = get_Const_tarval(lr);
- tarval *c3 = get_Const_tarval(right);
- tarval *mask = tarval_shl(c2, c1);
- tarval *value = tarval_shl(c3, c1);
+ ir_tarval *c1 = get_Const_tarval(llr);
+ ir_tarval *c2 = get_Const_tarval(lr);
+ ir_tarval *c3 = get_Const_tarval(right);
+ ir_tarval *mask = tarval_shl(c2, c1);
+ ir_tarval *value = tarval_shl(c3, c1);
- left = new_rd_And(dbg, block, get_Shr_left(ll), new_Const(mask), mode);
- right = new_Const(value);
+ left = new_rd_And(dbg, block, get_Shr_left(ll), new_r_Const(irg, mask), mode);
+ right = new_r_Const(irg, value);
changed |= 1;
}
}
/*
* UpConv(x) REL 0 ==> x REL 0
* Don't do this for float values as it's unclear whether it is a
- * win. (on the other side it makes detection/creation of fabs hard)
+ * win. (on the other side it makes detection/creation of fabs hard)
*/
if (get_mode_size_bits(mode) > get_mode_size_bits(op_mode) &&
((proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg) ||
/* a-c1 == c2 ==> a == c2+c1, a-c1 != c2 ==> a != c2+c1 */
if (is_Sub(left)) {
ir_node *c1 = get_Sub_right(left);
- tarval *tv2 = value_of(c1);
+ ir_tarval *tv2 = value_of(c1);
if (tv2 != tarval_bad) {
tv2 = tarval_add(tv, value_of(c1));
ir_node *a_l = get_Add_left(left);
ir_node *a_r = get_Add_right(left);
ir_node *a;
- tarval *tv2;
+ ir_tarval *tv2;
if (is_Const(a_l)) {
a = a_r;
}
/* -a == c ==> a == -c, -a != c ==> a != -c */
else if (is_Minus(left)) {
- tarval *tv2 = tarval_sub(get_mode_null(mode), tv, NULL);
+ ir_tarval *tv2 = tarval_sub(get_mode_null(mode), tv, NULL);
if (tv2 != tarval_bad) {
left = get_Minus_op(left);
}
}
} /* == or != */
- /* the following reassociations work only for <= */
- else if (proj_nr == pn_Cmp_Le || proj_nr == pn_Cmp_Lt) {
- if (tv != tarval_bad) {
- /* c >= 0 : Abs(a) <= c ==> (unsigned)(a + c) <= 2*c */
- if (is_Abs(left)) { // TODO something is missing here
- }
- }
- }
} /* mode_is_int */
if (proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg) {
* And(x, C1) == C2 ==> FALSE if C2 & C1 != C2
* And(x, C1) != C2 ==> TRUE if C2 & C1 != C2
*/
- tarval *mask = tarval_and(get_Const_tarval(c1), tv);
+ ir_tarval *mask = tarval_and(get_Const_tarval(c1), tv);
if (mask != tv) {
/* TODO: move to constant evaluation */
+ ir_graph *irg = get_irn_irg(n);
tv = proj_nr == pn_Cmp_Eq ? get_tarval_b_false() : get_tarval_b_true();
- c1 = new_Const(tv);
+ c1 = new_r_Const(irg, tv);
DBG_OPT_CSTEVAL(proj, c1);
return c1;
}
*/
if (! tarval_is_null(get_Const_tarval(c1))) {
/* TODO: move to constant evaluation */
+ ir_graph *irg = get_irn_irg(n);
tv = proj_nr == pn_Cmp_Eq ? get_tarval_b_false() : get_tarval_b_true();
- c1 = new_Const(tv);
+ c1 = new_r_Const(irg, tv);
DBG_OPT_CSTEVAL(proj, c1);
return c1;
}
*/
c1 = get_Shl_right(left);
if (is_Const(c1)) {
- tarval *tv1 = get_Const_tarval(c1);
- ir_mode *mode = get_irn_mode(left);
- tarval *minus1 = get_mode_all_one(mode);
- tarval *amask = tarval_shr(minus1, tv1);
- tarval *cmask = tarval_shl(minus1, tv1);
- ir_node *sl, *blk;
+ ir_graph *irg = get_irn_irg(c1);
+ ir_tarval *tv1 = get_Const_tarval(c1);
+ ir_mode *mode = get_irn_mode(left);
+ ir_tarval *minus1 = get_mode_all_one(mode);
+ ir_tarval *amask = tarval_shr(minus1, tv1);
+ ir_tarval *cmask = tarval_shl(minus1, tv1);
+ ir_node *sl, *blk;
if (tarval_and(tv, cmask) != tv) {
/* condition not met */
tv = proj_nr == pn_Cmp_Eq ? get_tarval_b_false() : get_tarval_b_true();
- c1 = new_Const(tv);
+ c1 = new_r_Const(irg, tv);
DBG_OPT_CSTEVAL(proj, c1);
return c1;
}
sl = get_Shl_left(left);
blk = get_nodes_block(n);
- left = new_rd_And(get_irn_dbg_info(left), blk, sl, new_Const(amask), mode);
+ left = new_rd_And(get_irn_dbg_info(left), blk, sl, new_r_Const(irg, amask), mode);
tv = tarval_shr(tv, tv1);
changed |= 2;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_SHF_TO_AND);
*/
c1 = get_Shr_right(left);
if (is_Const(c1)) {
- tarval *tv1 = get_Const_tarval(c1);
- ir_mode *mode = get_irn_mode(left);
- tarval *minus1 = get_mode_all_one(mode);
- tarval *amask = tarval_shl(minus1, tv1);
- tarval *cmask = tarval_shr(minus1, tv1);
- ir_node *sl, *blk;
+ ir_graph *irg = get_irn_irg(c1);
+ ir_tarval *tv1 = get_Const_tarval(c1);
+ ir_mode *mode = get_irn_mode(left);
+ ir_tarval *minus1 = get_mode_all_one(mode);
+ ir_tarval *amask = tarval_shl(minus1, tv1);
+ ir_tarval *cmask = tarval_shr(minus1, tv1);
+ ir_node *sl, *blk;
if (tarval_and(tv, cmask) != tv) {
/* condition not met */
tv = proj_nr == pn_Cmp_Eq ? get_tarval_b_false() : get_tarval_b_true();
- c1 = new_Const(tv);
+ c1 = new_r_Const(irg, tv);
DBG_OPT_CSTEVAL(proj, c1);
return c1;
}
sl = get_Shr_left(left);
blk = get_nodes_block(n);
- left = new_rd_And(get_irn_dbg_info(left), blk, sl, new_Const(amask), mode);
+ left = new_rd_And(get_irn_dbg_info(left), blk, sl, new_r_Const(irg, amask), mode);
tv = tarval_shl(tv, tv1);
changed |= 2;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_SHF_TO_AND);
*/
c1 = get_Shrs_right(left);
if (is_Const(c1)) {
- tarval *tv1 = get_Const_tarval(c1);
- ir_mode *mode = get_irn_mode(left);
- tarval *minus1 = get_mode_all_one(mode);
- tarval *amask = tarval_shl(minus1, tv1);
- tarval *cond = new_tarval_from_long(get_mode_size_bits(mode), get_tarval_mode(tv1));
+ ir_graph *irg = get_irn_irg(c1);
+ ir_tarval *tv1 = get_Const_tarval(c1);
+ ir_mode *mode = get_irn_mode(left);
+ ir_tarval *minus1 = get_mode_all_one(mode);
+ ir_tarval *amask = tarval_shl(minus1, tv1);
+ ir_tarval *cond = new_tarval_from_long(get_mode_size_bits(mode), get_tarval_mode(tv1));
ir_node *sl, *blk;
cond = tarval_sub(cond, tv1, NULL);
if (!tarval_is_all_one(cond) && !tarval_is_null(cond)) {
/* condition not met */
tv = proj_nr == pn_Cmp_Eq ? get_tarval_b_false() : get_tarval_b_true();
- c1 = new_Const(tv);
+ c1 = new_r_Const(irg, tv);
DBG_OPT_CSTEVAL(proj, c1);
return c1;
}
sl = get_Shrs_left(left);
blk = get_nodes_block(n);
- left = new_rd_And(get_irn_dbg_info(left), blk, sl, new_Const(amask), mode);
+ left = new_rd_And(get_irn_dbg_info(left), blk, sl, new_r_Const(irg, amask), mode);
tv = tarval_shl(tv, tv1);
changed |= 2;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_SHF_TO_AND);
} /* tarval != bad */
}
- if (changed & 2) /* need a new Const */
- right = new_Const(tv);
+ if (changed & 2) { /* need a new Const */
+ ir_graph *irg = get_irn_irg(n);
+ right = new_r_Const(irg, tv);
+ }
if ((proj_nr == pn_Cmp_Eq || proj_nr == pn_Cmp_Lg) && is_Const(right) && is_Const_null(right) && is_Proj(left)) {
ir_node *op = get_Proj_pred(left);
ir_node *c = get_binop_right(op);
if (is_Const(c)) {
- tarval *tv = get_Const_tarval(c);
+ ir_tarval *tv = get_Const_tarval(c);
if (tarval_is_single_bit(tv)) {
/* special case: (x % 2^n) CMP 0 ==> x & (2^n-1) CMP 0 */
ir_node *v = get_binop_left(op);
ir_node *blk = get_irn_n(op, -1);
+ ir_graph *irg = get_irn_irg(op);
ir_mode *mode = get_irn_mode(v);
tv = tarval_sub(tv, get_mode_one(mode), NULL);
- left = new_rd_And(get_irn_dbg_info(op), blk, v, new_Const(tv), mode);
+ left = new_rd_And(get_irn_dbg_info(op), blk, v, new_r_Const(irg, tv), mode);
changed |= 1;
DBG_OPT_ALGSIM0(n, n, FS_OPT_CMP_MOD_TO_AND);
}
ret_tuple = 1;
else if (is_Bound(pred)) {
/*
- * idx was Bounds checked in the same MacroBlock previously,
- * it is still valid if lower <= pred_lower && pred_upper <= upper.
+ * idx was Bounds checked previously, it is still valid if
+ * lower <= pred_lower && pred_upper <= upper.
*/
ir_node *lower = get_Bound_lower(bound);
ir_node *upper = get_Bound_upper(bound);
if (get_Bound_lower(pred) == lower &&
- get_Bound_upper(pred) == upper &&
- get_irn_MacroBlock(bound) == get_irn_MacroBlock(pred)) {
+ get_Bound_upper(pred) == upper) {
/*
* One could expect that we simply return the previous
* Bound here. However, this would be wrong, as we could
/* Beware of Phi0 */
if (n > 0) {
ir_node *pred = get_irn_n(phi, 0);
- ir_node *bound, *new_Phi, *block, **in;
+ ir_node *bound, *new_phi, *block, **in;
pn_Cmp pnc;
if (! is_Confirm(pred))
}
/* move the Confirm nodes "behind" the Phi */
block = get_irn_n(phi, -1);
- new_Phi = new_r_Phi(block, n, in, get_irn_mode(phi));
- return new_r_Confirm(block, new_Phi, bound, pnc);
+ new_phi = new_r_Phi(block, n, in, get_irn_mode(phi));
+ return new_r_Confirm(block, new_phi, bound, pnc);
}
}
return phi;
* AND c1 ===> OR if (c1 | c2) == 0x111..11
* OR
*/
-static ir_node *transform_node_Or_bf_store(ir_node *or)
+static ir_node *transform_node_Or_bf_store(ir_node *irn_or)
{
- ir_node *and, *c1;
+ ir_node *irn_and, *c1;
ir_node *or_l, *c2;
ir_node *and_l, *c3;
ir_node *value, *c4;
ir_node *new_and, *new_const, *block;
- ir_mode *mode = get_irn_mode(or);
+ ir_mode *mode = get_irn_mode(irn_or);
- tarval *tv1, *tv2, *tv3, *tv4, *tv;
+ ir_tarval *tv1, *tv2, *tv3, *tv4, *tv;
for (;;) {
- get_comm_Binop_Ops(or, &and, &c1);
- if (!is_Const(c1) || !is_And(and))
- return or;
+ ir_graph *irg;
+ get_comm_Binop_Ops(irn_or, &irn_and, &c1);
+ if (!is_Const(c1) || !is_And(irn_and))
+ return irn_or;
- get_comm_Binop_Ops(and, &or_l, &c2);
+ get_comm_Binop_Ops(irn_and, &or_l, &c2);
if (!is_Const(c2))
- return or;
+ return irn_or;
tv1 = get_Const_tarval(c1);
tv2 = get_Const_tarval(c2);
tv = tarval_or(tv1, tv2);
if (tarval_is_all_one(tv)) {
/* the AND does NOT clear a bit with isn't set by the OR */
- set_Or_left(or, or_l);
- set_Or_right(or, c1);
+ set_Or_left(irn_or, or_l);
+ set_Or_right(irn_or, c1);
/* check for more */
continue;
}
if (!is_Or(or_l))
- return or;
+ return irn_or;
get_comm_Binop_Ops(or_l, &and_l, &c3);
if (!is_Const(c3) || !is_And(and_l))
- return or;
+ return irn_or;
get_comm_Binop_Ops(and_l, &value, &c4);
if (!is_Const(c4))
- return or;
+ return irn_or;
/* ok, found the pattern, check for conditions */
- assert(mode == get_irn_mode(and));
+ assert(mode == get_irn_mode(irn_and));
assert(mode == get_irn_mode(or_l));
assert(mode == get_irn_mode(and_l));
tv = tarval_or(tv4, tv2);
if (!tarval_is_all_one(tv)) {
/* have at least one 0 at the same bit position */
- return or;
+ return irn_or;
}
if (tv3 != tarval_andnot(tv3, tv4)) {
/* bit in the or_mask is outside the and_mask */
- return or;
+ return irn_or;
}
if (tv1 != tarval_andnot(tv1, tv2)) {
/* bit in the or_mask is outside the and_mask */
- return or;
+ return irn_or;
}
/* ok, all conditions met */
- block = get_irn_n(or, -1);
+ block = get_irn_n(irn_or, -1);
+ irg = get_irn_irg(block);
- new_and = new_r_And(block, value, new_Const(tarval_and(tv4, tv2)), mode);
+ new_and = new_r_And(block, value, new_r_Const(irg, tarval_and(tv4, tv2)), mode);
- new_const = new_Const(tarval_or(tv3, tv1));
+ new_const = new_r_Const(irg, tarval_or(tv3, tv1));
- set_Or_left(or, new_and);
- set_Or_right(or, new_const);
+ set_Or_left(irn_or, new_and);
+ set_Or_right(irn_or, new_const);
/* check for more */
}
/**
* Optimize an Or(shl(x, c), shr(x, bits - c)) into a Rotl
*/
-static ir_node *transform_node_Or_Rotl(ir_node *or)
+static ir_node *transform_node_Or_Rotl(ir_node *irn_or)
{
- ir_mode *mode = get_irn_mode(or);
+ ir_mode *mode = get_irn_mode(irn_or);
ir_node *shl, *shr, *block;
- ir_node *irn, *x, *c1, *c2, *v, *sub, *n, *rotval;
- tarval *tv1, *tv2;
+ ir_node *irn, *x, *c1, *c2, *n;
+ ir_tarval *tv1, *tv2;
+
+ /* some backends can't handle rotl */
+ if (!be_get_backend_param()->support_rotl)
+ return irn_or;
if (! mode_is_int(mode))
- return or;
+ return irn_or;
- shl = get_binop_left(or);
- shr = get_binop_right(or);
+ shl = get_binop_left(irn_or);
+ shr = get_binop_right(irn_or);
if (is_Shr(shl)) {
if (!is_Shl(shr))
- return or;
+ return irn_or;
irn = shl;
shl = shr;
shr = irn;
} else if (!is_Shl(shl)) {
- return or;
+ return irn_or;
} else if (!is_Shr(shr)) {
- return or;
+ return irn_or;
}
x = get_Shl_left(shl);
if (x != get_Shr_left(shr))
- return or;
+ return irn_or;
c1 = get_Shl_right(shl);
c2 = get_Shr_right(shr);
if (is_Const(c1) && is_Const(c2)) {
tv1 = get_Const_tarval(c1);
if (! tarval_is_long(tv1))
- return or;
+ return irn_or;
tv2 = get_Const_tarval(c2);
if (! tarval_is_long(tv2))
- return or;
+ return irn_or;
if (get_tarval_long(tv1) + get_tarval_long(tv2)
!= (int) get_mode_size_bits(mode))
- return or;
-
- /* some backends can't handle rotl */
- if (!be_get_backend_param()->support_rotl)
- return or;
+ return irn_or;
/* yet, condition met */
- block = get_nodes_block(or);
+ block = get_nodes_block(irn_or);
n = new_r_Rotl(block, x, c1, mode);
- DBG_OPT_ALGSIM1(or, shl, shr, n, FS_OPT_OR_SHFT_TO_ROTL);
+ DBG_OPT_ALGSIM1(irn_or, shl, shr, n, FS_OPT_OR_SHFT_TO_ROTL);
return n;
}
- if (is_Sub(c1)) {
- v = c2;
- sub = c1;
- rotval = sub; /* a Rot right is not supported, so use a rot left */
- } else if (is_Sub(c2)) {
- v = c1;
- sub = c2;
- rotval = v;
- } else {
- return or;
+ /* Note: the obvious rot formulation (a << x) | (a >> (32-x)) gets
+ * transformed to (a << x) | (a >> -x) by transform_node_shift_modulo() */
+ if (!is_negated_value(c1, c2)) {
+ return irn_or;
}
- if (get_Sub_right(sub) != v)
- return or;
-
- c1 = get_Sub_left(sub);
- if (!is_Const(c1))
- return or;
-
- tv1 = get_Const_tarval(c1);
- if (! tarval_is_long(tv1))
- return or;
-
- if (get_tarval_long(tv1) != (int) get_mode_size_bits(mode))
- return or;
-
- /* some backends can't handle rotl */
- if (!be_get_backend_param()->support_rotl)
- return or;
-
/* yet, condition met */
- block = get_nodes_block(or);
-
- n = new_r_Rotl(block, x, rotval, mode);
-
- DBG_OPT_ALGSIM0(or, n, FS_OPT_OR_SHFT_TO_ROTL);
+ block = get_nodes_block(irn_or);
+ n = new_r_Rotl(block, x, c1, mode);
+ DBG_OPT_ALGSIM0(irn_or, n, FS_OPT_OR_SHFT_TO_ROTL);
return n;
} /* transform_node_Or_Rotl */
ir_node *pred_b = get_Proj_pred(b);
if (pred_a == pred_b) {
dbg_info *dbgi = get_irn_dbg_info(n);
- pn_Cmp pn_a = get_Proj_proj(a);
- pn_Cmp pn_b = get_Proj_proj(b);
+ pn_Cmp pn_a = get_Proj_pn_cmp(a);
+ pn_Cmp pn_b = get_Proj_pn_cmp(b);
/* yes, we can simply calculate with pncs */
pn_Cmp new_pnc = pn_a | pn_b;
{
ir_node *left, *right;
ir_mode *mode;
- tarval *tv1, *tv2, *res;
+ ir_tarval *tv1, *tv2, *res;
ir_node *in[2], *irn, *block;
+ ir_graph *irg;
left = get_binop_left(n);
res = tarval_add(tv1, tv2);
mode = get_irn_mode(n);
+ irg = get_irn_irg(n);
/* beware: a simple replacement works only, if res < modulo shift */
if (!is_Rotl(n)) {
int modulo_shf = get_mode_modulo_shift(mode);
if (modulo_shf > 0) {
- tarval *modulo = new_tarval_from_long(modulo_shf,
- get_tarval_mode(res));
+ ir_tarval *modulo = new_tarval_from_long(modulo_shf,
+ get_tarval_mode(res));
assert(modulo_shf >= (int) get_mode_size_bits(mode));
ir_node *block = get_nodes_block(n);
dbg_info *dbgi = get_irn_dbg_info(n);
ir_mode *smode = get_irn_mode(right);
- ir_node *cnst = new_Const_long(smode, get_mode_size_bits(mode) - 1);
+ ir_node *cnst = new_r_Const_long(irg, smode, get_mode_size_bits(mode) - 1);
return new_rd_Shrs(dbgi, block, get_binop_left(left), cnst, mode);
}
- return new_Const(get_mode_null(mode));
+ return new_r_Const(irg, get_mode_null(mode));
}
}
} else {
block = get_nodes_block(n);
in[0] = get_binop_left(left);
- in[1] = new_Const(res);
+ in[1] = new_r_Const(irg, res);
irn = new_ir_node(NULL, get_Block_irg(block), block, get_irn_op(n), mode, 2, in);
*/
static ir_node *transform_node_bitop_shift(ir_node *n)
{
- ir_node *left;
- ir_node *right = get_binop_right(n);
- ir_mode *mode = get_irn_mode(n);
- ir_node *bitop_left;
- ir_node *bitop_right;
- ir_op *op_left;
- ir_node *block;
- dbg_info *dbgi;
- ir_node *new_shift;
- ir_node *new_bitop;
- ir_node *new_const;
- tarval *tv1;
- tarval *tv2;
- tarval *tv_shift;
+ ir_node *left;
+ ir_node *right = get_binop_right(n);
+ ir_mode *mode = get_irn_mode(n);
+ ir_node *bitop_left;
+ ir_node *bitop_right;
+ ir_op *op_left;
+ ir_node *block;
+ dbg_info *dbgi;
+ ir_graph *irg;
+ ir_node *new_shift;
+ ir_node *new_bitop;
+ ir_node *new_const;
+ ir_tarval *tv1;
+ ir_tarval *tv2;
+ ir_tarval *tv_shift;
assert(is_Shrs(n) || is_Shr(n) || is_Shl(n) || is_Rotl(n));
}
assert(get_tarval_mode(tv_shift) == mode);
- new_const = new_Const(tv_shift);
+ irg = get_irn_irg(n);
+ new_const = new_r_Const(irg, tv_shift);
if (op_left == op_And) {
new_bitop = new_rd_And(dbgi, block, new_shift, new_const, mode);
*/
static ir_node *transform_node_shl_shr(ir_node *n)
{
- ir_node *left;
- ir_node *right = get_binop_right(n);
- ir_node *x;
- ir_node *block;
- ir_mode *mode;
- dbg_info *dbgi;
- ir_node *new_const;
- ir_node *new_shift;
- ir_node *new_and;
- tarval *tv_shl;
- tarval *tv_shr;
- tarval *tv_shift;
- tarval *tv_mask;
- pn_Cmp pnc;
- int need_shrs = 0;
+ ir_node *left;
+ ir_node *right = get_binop_right(n);
+ ir_node *x;
+ ir_node *block;
+ ir_mode *mode;
+ dbg_info *dbgi;
+ ir_node *new_const;
+ ir_node *new_shift;
+ ir_node *new_and;
+ ir_tarval *tv_shl;
+ ir_tarval *tv_shr;
+ ir_tarval *tv_shift;
+ ir_tarval *tv_mask;
+ ir_graph *irg;
+ pn_Cmp pnc;
+ int need_shrs = 0;
assert(is_Shl(n) || is_Shr(n) || is_Shrs(n));
assert(get_tarval_mode(tv_mask) == mode);
block = get_nodes_block(n);
+ irg = get_irn_irg(block);
dbgi = get_irn_dbg_info(n);
pnc = tarval_cmp(tv_shl, tv_shr);
if (pnc == pn_Cmp_Lt || pnc == pn_Cmp_Eq) {
tv_shift = tarval_sub(tv_shr, tv_shl, NULL);
- new_const = new_Const(tv_shift);
+ new_const = new_r_Const(irg, tv_shift);
if (need_shrs) {
new_shift = new_rd_Shrs(dbgi, block, x, new_const, mode);
} else {
} else {
assert(pnc == pn_Cmp_Gt);
tv_shift = tarval_sub(tv_shl, tv_shr, NULL);
- new_const = new_Const(tv_shift);
+ new_const = new_r_Const(irg, tv_shift);
new_shift = new_rd_Shl(dbgi, block, x, new_const, mode);
}
- new_const = new_Const(tv_mask);
+ new_const = new_r_Const(irg, tv_mask);
new_and = new_rd_And(dbgi, block, new_shift, new_const, mode);
return new_and;
}
+static ir_tarval *get_modulo_tv_value(ir_tarval *tv, int modulo_val)
+{
+ ir_mode *mode = get_tarval_mode(tv);
+ ir_tarval *modulo_tv = new_tarval_from_long(modulo_val, mode);
+ return tarval_mod(tv, modulo_tv);
+}
+
+typedef ir_node*(*new_shift_func)(dbg_info *dbgi, ir_node *block,
+ ir_node *left, ir_node *right, ir_mode *mode);
+
+/**
+ * Normalisation: if we have a shl/shr with modulo_shift behaviour
+ * then we can use that to minimize the value of Add(x, const) or
+ * Sub(Const, x). In particular this often avoids 1 instruction in some
+ * backends for the Shift(x, Sub(Const, y)) case because it can be replaced
+ * by Shift(x, Minus(y)) which doesnt't need an explicit Const constructed.
+ */
+static ir_node *transform_node_shift_modulo(ir_node *n,
+ new_shift_func new_shift)
+{
+ ir_mode *mode = get_irn_mode(n);
+ int modulo = get_mode_modulo_shift(mode);
+ ir_node *newop = NULL;
+ ir_mode *mode_right;
+ ir_node *block;
+ ir_node *right;
+ ir_graph *irg;
+
+ if (modulo == 0)
+ return n;
+ if (get_mode_arithmetic(mode) != irma_twos_complement)
+ return n;
+ if (!is_po2(modulo))
+ return n;
+
+ irg = get_irn_irg(n);
+ block = get_nodes_block(n);
+ right = get_binop_right(n);
+ mode_right = get_irn_mode(right);
+ if (is_Const(right)) {
+ ir_tarval *tv = get_Const_tarval(right);
+ ir_tarval *tv_mod = get_modulo_tv_value(tv, modulo);
+
+ if (tv_mod == tv)
+ return n;
+
+ newop = new_r_Const(irg, tv_mod);
+ } else if (is_Add(right)) {
+ ir_node *add_right = get_Add_right(right);
+ if (is_Const(add_right)) {
+ ir_tarval *tv = get_Const_tarval(add_right);
+ ir_tarval *tv_mod = get_modulo_tv_value(tv, modulo);
+ ir_node *newconst;
+ if (tv_mod == tv)
+ return n;
+
+ newconst = new_r_Const(irg, tv_mod);
+ newop = new_r_Add(block, get_Add_left(right), newconst,
+ mode_right);
+ }
+ } else if (is_Sub(right)) {
+ ir_node *sub_left = get_Sub_left(right);
+ if (is_Const(sub_left)) {
+ ir_tarval *tv = get_Const_tarval(sub_left);
+ ir_tarval *tv_mod = get_modulo_tv_value(tv, modulo);
+ ir_node *newconst;
+ if (tv_mod == tv)
+ return n;
+
+ newconst = new_r_Const(irg, tv_mod);
+ newop = new_r_Sub(block, newconst, get_Sub_right(right),
+ mode_right);
+ }
+ } else {
+ return n;
+ }
+
+ if (newop != NULL) {
+ dbg_info *dbgi = get_irn_dbg_info(n);
+ ir_node *left = get_binop_left(n);
+ return new_shift(dbgi, block, left, newop, mode);
+ }
+ return n;
+}
+
/**
* Transform a Shr.
*/
HANDLE_BINOP_PHI((eval_func) tarval_shr, left, right, c, mode);
n = transform_node_shift(n);
+ if (is_Shr(n))
+ n = transform_node_shift_modulo(n, new_rd_Shr);
if (is_Shr(n))
n = transform_node_shl_shr(n);
if (is_Shr(n))
HANDLE_BINOP_PHI((eval_func) tarval_shrs, a, b, c, mode);
n = transform_node_shift(n);
+ if (is_Shrs(n))
+ n = transform_node_shift_modulo(n, new_rd_Shrs);
if (is_Shrs(n))
n = transform_node_bitop_shift(n);
HANDLE_BINOP_PHI((eval_func) tarval_shl, a, b, c, mode);
n = transform_node_shift(n);
+ if (is_Shl(n))
+ n = transform_node_shift_modulo(n, new_rd_Shl);
if (is_Shl(n))
n = transform_node_shl_shr(n);
if (is_Shl(n))
}
/* first normalization step: try to move a constant to the false side,
- * 0 prefered on false side too */
+ * 0 preferred on false side too */
if (is_Proj(sel)) {
ir_node *cmp = get_Proj_pred(sel);
if (is_Cmp(cmp) && is_Const(t) &&
- (!is_Const(f) || (is_Const_null(t) && !is_Const_null(f)))) {
+ (!is_Const(f) || (is_Const_null(t) && !is_Const_null(f)))) {
+ pn_Cmp pnc = get_Proj_pn_cmp(sel);
ir_node *tmp = t;
t = f;
f = tmp;
/* Mux(x, a, b) => Mux(not(x), b, a) */
- pn_Cmp pnc = get_Proj_proj(sel);
sel = new_r_Proj(cmp, mode_b,
get_negated_pnc(pnc, get_irn_mode(get_Cmp_left(cmp))));
n = new_rd_Mux(get_irn_dbg_info(n), get_nodes_block(n), sel, f, t, mode);
ir_node *block = get_nodes_block(n);
if (is_Const(t)) {
- tarval *tv_t = get_Const_tarval(t);
+ ir_tarval *tv_t = get_Const_tarval(t);
if (tv_t == tarval_b_true) {
if (is_Const(f)) {
/* Muxb(sel, true, false) = sel */
}
}
} else if (is_Const(f)) {
- tarval *tv_f = get_Const_tarval(f);
+ ir_tarval *tv_f = get_Const_tarval(f);
if (tv_f == tarval_b_true) {
/* Muxb(sel, x, true) = Or(Not(sel), x) */
ir_node* not_sel = new_rd_Not(dbg, block, sel, mode_b);
/* more normalization: Mux(sel, 0, 1) is simply a conv from the mode_b
* value to integer. */
if (is_Const(t) && is_Const(f) && mode_is_int(mode)) {
- tarval *a = get_Const_tarval(t);
- tarval *b = get_Const_tarval(f);
+ ir_tarval *a = get_Const_tarval(t);
+ ir_tarval *b = get_Const_tarval(f);
if (tarval_is_one(a) && tarval_is_null(b)) {
ir_node *block = get_nodes_block(n);
/*
* Note: normalization puts the constant on the right side,
* so we check only one case.
- *
- * Note further that these optimization work even for floating point
- * with NaN's because -NaN == NaN.
- * However, if +0 and -0 is handled differently, we cannot use the Abs/-Abs
- * transformations.
*/
if (is_Cmp(cmp)) {
ir_node *cmp_r = get_Cmp_right(cmp);
ir_node *block = get_nodes_block(n);
ir_node *cmp_l = get_Cmp_left(cmp);
- if (!mode_honor_signed_zeros(mode) && is_negated_value(f, t)) {
- /* f = -t */
-
- /* NaN's work fine with abs, so it is ok to remove Uo */
- long pnc = pn & ~pn_Cmp_Uo;
-
- if ( (cmp_l == t && (pnc == pn_Cmp_Ge || pnc == pn_Cmp_Gt))
- || (cmp_l == f && (pnc == pn_Cmp_Le || pnc == pn_Cmp_Lt)))
- {
- /* Mux(a >/>= 0, a, -a) = Mux(a </<= 0, -a, a) ==> Abs(a) */
- n = new_rd_Abs(get_irn_dbg_info(n), block, cmp_l, mode);
- DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_ABS);
- return n;
- } else if ((cmp_l == t && (pnc == pn_Cmp_Le || pnc == pn_Cmp_Lt))
- || (cmp_l == f && (pnc == pn_Cmp_Ge || pnc == pn_Cmp_Gt)))
- {
- /* Mux(a </<= 0, a, -a) = Mux(a >/>= 0, -a, a) ==> -Abs(a) */
- n = new_rd_Abs(get_irn_dbg_info(n), block, cmp_l, mode);
- n = new_rd_Minus(get_irn_dbg_info(n), block, n, mode);
- DBG_OPT_ALGSIM1(oldn, cmp, sel, n, FS_OPT_MUX_TO_ABS);
- return n;
- }
- }
-
if (mode_is_int(mode)) {
/* integer only */
if ((pn == pn_Cmp_Lg || pn == pn_Cmp_Eq) && is_And(cmp_l)) {
CASE_PROJ_EX(Mod);
CASE_PROJ_EX(DivMod);
CASE(Quot);
- CASE(Abs);
CASE_PROJ_EX(Cmp);
CASE_PROJ_EX(Cond);
CASE(And);
CASE(Eor);
CASE(Not);
CASE(Minus);
- CASE(Cast);
CASE_PROJ(Load);
CASE_PROJ(Store);
CASE_PROJ(Bound);
/** Compares the attributes of two Const nodes. */
static int node_cmp_attr_Const(ir_node *a, ir_node *b)
{
- return (get_Const_tarval(a) != get_Const_tarval(b))
- || (get_Const_type(a) != get_Const_type(b));
-} /* node_cmp_attr_Const */
+ return get_Const_tarval(a) != get_Const_tarval(b);
+}
/** Compares the attributes of two Proj nodes. */
static int node_cmp_attr_Proj(ir_node *a, ir_node *b)
{
- return a->attr.proj != b->attr.proj;
+ return a->attr.proj.proj != b->attr.proj.proj;
} /* node_cmp_attr_Proj */
/** Compares the attributes of two Alloc nodes. */
const symconst_attr *pa = &a->attr.symc;
const symconst_attr *pb = &b->attr.symc;
return (pa->kind != pb->kind)
- || (pa->sym.type_p != pb->sym.type_p)
- || (pa->tp != pb->tp);
-} /* node_cmp_attr_SymConst */
+ || (pa->sym.type_p != pb->sym.type_p);
+}
/** Compares the attributes of two Call nodes. */
static int node_cmp_attr_Call(ir_node *a, ir_node *b)
if (irn_arity_a != get_irn_arity(b))
return 1;
+ /* blocks are never the same */
+ if (is_Block(a))
+ return 1;
+
if (get_irn_pinned(a) == op_pin_state_pinned) {
/* for pinned nodes, the block inputs must be equal */
if (get_irn_n(a, -1) != get_irn_n(b, -1))
return 1;
} else if (! get_opt_global_cse()) {
- /* for block-local CSE both nodes must be in the same MacroBlock */
- if (get_irn_MacroBlock(a) != get_irn_MacroBlock(b))
+ /* for block-local CSE both nodes must be in the same Block */
+ if (get_nodes_block(a) != get_nodes_block(b))
return 1;
}
}
} /* ir_normalize_node */
-/**
- * Update the nodes after a match in the value table. If both nodes have
- * the same MacroBlock but different Blocks, we must ensure that the node
- * with the dominating Block (the node that is near to the MacroBlock header
- * is stored in the table.
- * Because a MacroBlock has only one "non-exception" flow, we don't need
- * dominance info here: We known, that one block must dominate the other and
- * following the only block input will allow to find it.
- */
-static void update_known_irn(ir_node *known_irn, const ir_node *new_ir_node)
-{
- ir_node *known_blk, *new_block, *block, *mbh;
-
- if (get_opt_global_cse()) {
- /* Block inputs are meaning less */
- return;
- }
- known_blk = get_irn_n(known_irn, -1);
- new_block = get_irn_n(new_ir_node, -1);
- if (known_blk == new_block) {
- /* already in the same block */
- return;
- }
- /*
- * We expect the typical case when we built the graph. In that case, the
- * known_irn is already the upper one, so checking this should be faster.
- */
- block = new_block;
- mbh = get_Block_MacroBlock(new_block);
- for (;;) {
- if (block == known_blk) {
- /* ok, we have found it: known_block dominates new_block as expected */
- return;
- }
- if (block == mbh) {
- /*
- * We have reached the MacroBlock header NOT founding
- * the known_block. new_block must dominate known_block.
- * Update known_irn.
- */
- set_irn_n(known_irn, -1, new_block);
- return;
- }
- assert(get_Block_n_cfgpreds(block) == 1);
- block = get_Block_cfgpred_block(block, 0);
- }
-} /* update_value_table */
-
/*
* Return the canonical node computing the same value as n.
* Looks up the node in a hash table, enters it in the table
ir_normalize_node(n);
/* lookup or insert in hash table with given hash key. */
- nn = pset_insert(value_table, n, ir_node_hash(n));
+ nn = (ir_node*)pset_insert(value_table, n, ir_node_hash(n));
if (nn != n) {
- update_known_irn(nn, n);
-
/* n is reachable again */
edges_node_revival(nn, get_irn_irg(nn));
}
} /* identify_remember */
/**
- * During construction we set the op_pin_state_pinned flag in the graph right when the
- * optimization is performed. The flag turning on procedure global cse could
- * be changed between two allocations. This way we are safe.
+ * During construction we set the op_pin_state_pinned flag in the graph right
+ * when the optimization is performed. The flag turning on procedure global
+ * cse could be changed between two allocations. This way we are safe.
*
* @param n The node to lookup
*/
ir_node *old = n;
n = identify_remember(n);
- if (n != old && get_irn_MacroBlock(old) != get_irn_MacroBlock(n)) {
+ if (n != old && get_nodes_block(old) != get_nodes_block(n)) {
ir_graph *irg = get_irn_irg(n);
set_irg_pinned(irg, op_pin_state_floats);
}
ir_graph *rem = current_ir_graph;
current_ir_graph = irg;
- foreach_pset(irg->value_table, node) {
+ foreach_pset(irg->value_table, ir_node*, node) {
visit(node, env);
}
current_ir_graph = rem;
/* remove garbage blocks by looking at control flow that leaves the block
and replacing the control flow by Bad. */
if (get_irn_mode(node) == mode_X) {
- ir_node *block = get_nodes_block(skip_Proj(node));
+ ir_node *block = get_nodes_block(skip_Proj(node));
+ ir_graph *irg = get_irn_irg(block);
/* Don't optimize nodes in immature blocks. */
if (!get_Block_matured(block))
if (is_Block(block)) {
if (is_Block_dead(block)) {
/* control flow from dead block is dead */
- return new_Bad();
+ return get_irg_bad(irg);
}
for (i = get_irn_arity(block) - 1; i >= 0; --i) {
* but can be found by irg_walk()!
*/
set_Block_dead(block);
- return new_Bad();
+ return get_irg_bad(irg);
}
}
}
/* Blocks, Phis and Tuples may have dead inputs, e.g., if one of the
blocks predecessors is dead. */
- if (op != op_Block && op != op_Phi && op != op_Tuple) {
+ if (op != op_Block && op != op_Phi && op != op_Tuple && op != op_Anchor) {
+ ir_graph *irg = get_irn_irg(node);
irn_arity = get_irn_arity(node);
/*
*/
if (is_irn_pinned_in_irg(node) &&
is_Block_dead(get_nodes_block(skip_Proj(node))))
- return new_Bad();
+ return get_irg_bad(irg);
for (i = 0; i < irn_arity; i++) {
ir_node *pred = get_irn_n(node, i);
if (is_Bad(pred))
- return new_Bad();
+ return get_irg_bad(irg);
#if 0
/* Propagating Unknowns here seems to be a bad idea, because
sometimes we need a node as a input and did not want that
However, it might be useful to move this into a later phase
(if you think that optimizing such code is useful). */
if (is_Unknown(pred) && mode_is_data(get_irn_mode(node)))
- return new_Unknown(get_irn_mode(node));
+ return new_r_Unknown(irg, get_irn_mode(node));
#endif
}
}
for (i = 0; i < irn_arity; i++) {
if (!is_Bad(get_irn_n(node, i))) break;
}
- if (i == irn_arity) node = new_Bad();
+ if (i == irn_arity) node = get_irg_bad(irg);
}
#endif
return node;
*/
ir_node *optimize_node(ir_node *n)
{
- tarval *tv;
- ir_node *oldn = n;
- ir_graph *irg = get_irn_irg(n);
- ir_opcode iro = get_irn_opcode(n);
+ ir_node *oldn = n;
+ ir_graph *irg = get_irn_irg(n);
+ unsigned iro = get_irn_opcode(n);
+ ir_tarval *tv;
/* Always optimize Phi nodes: part of the construction. */
if ((!get_opt_optimize()) && (iro != iro_Phi)) return n;
if (get_opt_constant_folding()) {
/* neither constants nor Tuple values can be evaluated */
if (iro != iro_Const && (get_irn_mode(n) != mode_T)) {
- unsigned fp_model = get_irg_fp_model(irg);
- int old_fp_mode = tarval_fp_ops_enabled();
-
- tarval_enable_fp_ops(! (fp_model & fp_no_float_fold));
-
/* try to evaluate */
tv = computed_value(n);
if (tv != tarval_bad) {
ir_node *nw;
- ir_type *old_tp = get_irn_type(n);
- int i, arity = get_irn_arity(n);
- int node_size;
+ size_t node_size;
/*
- * Try to recover the type of the new expression.
- */
- for (i = 0; i < arity && !old_tp; ++i)
- old_tp = get_irn_type(get_irn_n(n, i));
-
- /*
- * we MUST copy the node here temporary, because it's still needed
- * for DBG_OPT_CSTEVAL
+ * we MUST copy the node here temporary, because it's still
+ * needed for DBG_OPT_CSTEVAL
*/
node_size = offsetof(ir_node, attr) + n->op->attr_size;
- oldn = alloca(node_size);
+ oldn = (ir_node*)alloca(node_size);
memcpy(oldn, n, node_size);
CLONE_ARR_A(ir_node *, oldn->in, n->in);
/* evaluation was successful -- replace the node. */
irg_kill_node(irg, n);
- nw = new_Const(tv);
+ nw = new_r_Const(irg, tv);
- if (old_tp && get_type_mode(old_tp) == get_tarval_mode(tv))
- set_Const_type(nw, old_tp);
DBG_OPT_CSTEVAL(oldn, nw);
- tarval_enable_fp_ops(old_fp_mode);
return nw;
}
- tarval_enable_fp_ops(old_fp_mode);
}
}
*/
ir_node *optimize_in_place_2(ir_node *n)
{
- tarval *tv;
- ir_node *oldn = n;
- ir_opcode iro = get_irn_opcode(n);
+ ir_tarval *tv;
+ ir_node *oldn = n;
+ unsigned iro = get_irn_opcode(n);
if (!get_opt_optimize() && !is_Phi(n)) return n;
+ if (iro == iro_Deleted)
+ return n;
+
/* constant expression evaluation / constant folding */
if (get_opt_constant_folding()) {
/* neither constants nor Tuple values can be evaluated */
if (iro != iro_Const && get_irn_mode(n) != mode_T) {
- ir_graph *irg = get_irn_irg(n);
- unsigned fp_model = get_irg_fp_model(irg);
- int old_fp_mode = tarval_fp_ops_enabled();
-
- tarval_enable_fp_ops((fp_model & fp_strict_algebraic) == 0);
/* try to evaluate */
tv = computed_value(n);
if (tv != tarval_bad) {
/* evaluation was successful -- replace the node. */
- ir_type *old_tp = get_irn_type(n);
- int i, arity = get_irn_arity(n);
-
- /*
- * Try to recover the type of the new expression.
- */
- for (i = 0; i < arity && !old_tp; ++i)
- old_tp = get_irn_type(get_irn_n(n, i));
-
- n = new_Const(tv);
+ ir_graph *irg = get_irn_irg(n);
- if (old_tp && get_type_mode(old_tp) == get_tarval_mode(tv))
- set_Const_type(n, old_tp);
+ n = new_r_Const(irg, tv);
DBG_OPT_CSTEVAL(oldn, n);
- tarval_enable_fp_ops(old_fp_mode);
return n;
}
- tarval_enable_fp_ops(old_fp_mode);
}
}
ops = firm_set_default_equivalent_node(code, ops);
ops = firm_set_default_transform_node(code, ops);
ops = firm_set_default_node_cmp_attr(code, ops);
- ops = firm_set_default_get_type(code, ops);
ops = firm_set_default_get_type_attr(code, ops);
ops = firm_set_default_get_entity_attr(code, ops);
projects / libfirm / blobdiff