*/
#ifdef HAVE_CONFIG_H
-# include <config.h>
+# include "config.h"
#endif
# include "irnode_t.h"
# include "irflag_t.h"
# include "irgwalk.h"
# include "reassoc_t.h"
-# include "firmstat.h"
+# include "irhooks.h"
+# include "debug.h"
+
+static firm_dbg_module_t *dbg;
typedef struct _walker_t {
int changes; /* set, if a reassociation take place */
typedef enum {
NO_CONSTANT = 0, /**< node is not constant */
- REAL_CONSTANT = 1, /**< node is a constnt that is suitable for constant folding */
- CONST_EXPR = 4 /**< node is not constnt expression in the current context,
+ REAL_CONSTANT = 1, /**< node is a Const that is suitable for constant folding */
+ CONST_EXPR = 4 /**< node is a constant expression in the current context,
use 4 here to simplify implementation of get_comm_Binop_ops() */
} const_class_t;
/**
- * returns wheater a node is constant, ie is a constant or
+ * returns whether a node is constant, ie is a constant or
* is loop invariant
*/
static const_class_t get_const_class(ir_node *n)
* returns the operands of a commutative bin-op, if one operand is
* a constant in the current context, it is returned as the second one.
*
- * Beware: Real constrants must be returned with higher priority than
- * constnt expression, because they might be folded.
+ * Beware: Real constants must be returned with higher priority than
+ * constant expression, because they might be folded.
*/
static void get_comm_Binop_ops(ir_node *binop, ir_node **a, ir_node **c)
{
/**
* reassociate a Sub: x - c = (-c) + x
*/
-static int reassoc_Sub(ir_node *n)
+static int reassoc_Sub(ir_node **in)
{
+ ir_node *n = *in;
ir_node *right = get_Sub_right(n);
+ /* FIXME: Do not apply this rule for unsigned Sub's because our code
+ * generation is currently buggy :-)
+ */
+ if (! mode_is_signed(get_irn_mode(n)))
+ return 0;
+
/* handles rule R6:
* convert x - c => (-c) + x
*
* for non-real constants yet.
* */
if (get_const_class(right) == REAL_CONSTANT) {
- ir_node *block = get_nodes_block(right);
- ir_mode *mode = get_irn_mode(right);
- dbg_info *dbg = get_irn_dbg_info(right);
+ ir_node *left = get_Sub_left(n);
+ ir_node *block = get_nodes_block(n);
+ ir_mode *mode = get_irn_mode(n);
+ dbg_info *dbi = get_irn_dbg_info(n);
ir_node *irn, *c;
+ switch (get_const_class(left)) {
+ case REAL_CONSTANT:
+ irn = optimize_in_place(n);
+ if (irn != n) {
+ exchange(n, irn);
+ *in = irn;
+ return 1;
+ }
+ return 0;
+ case NO_CONSTANT:
+ break;
+ default:
+ /* already constant, nothing to do */
+ return 0;
+ }
+
c = new_r_Const(current_ir_graph, block, mode, get_mode_null(mode));
- irn = new_rd_Sub(dbg, current_ir_graph, block, c, right, mode);
+ irn = new_rd_Sub(dbi, current_ir_graph, block, c, right, mode);
- irn = new_rd_Add(dbg, current_ir_graph, block, irn, get_Sub_left(n), get_irn_mode(n));
+ irn = new_rd_Add(dbi, current_ir_graph, block, left, irn, get_irn_mode(n));
- printf("Applied: %s - %s => (-%s) + %s\n",
- get_irn_opname(get_Sub_left(n)), get_irn_opname(c),
- get_irn_opname(c), get_irn_opname(get_Sub_left(n)) );
+ DBG((dbg, LEVEL_5, "Applied: %n - %n => %n + (-%n)\n",
+ get_Sub_left(n), c, get_Sub_left(n), c));
exchange(n, irn);
+ *in = irn;
return 1;
}
* all two operands are are constant expressions and the third is a
* constant, so avoid this situation.
*/
-static int reassoc_commutative(ir_node *n)
+static int reassoc_commutative(ir_node **node)
{
+ ir_node *n = *node;
ir_op *op = get_irn_op(n);
ir_node *block = get_nodes_block(n);
ir_node *t1, *c1;
get_comm_Binop_ops(t1, &t2, &c2);
+ /* do not optimize Bad nodes, will fail later */
+ if (is_Bad(t2))
+ return 0;
+
c_c1 = get_const_class(c1);
c_c2 = get_const_class(c2);
c_t2 = get_const_class(t2);
/* all three are constant and either all are constant expressions or two of them are:
* then, applying this rule would lead into a cycle
*
- * Note that if t2 is a onstant so is c2, so we save one test.
+ * Note that if t2 is a constant so is c2, so we save one test.
*/
return 0;
}
* convert c1 .OP. (c2 .OP. x) => (c1 .OP. c2) .OP. x
*/
ir_node *irn, *in[2];
- ir_mode *mode;
+ ir_mode *mode, *mode_c1 = get_irn_mode(c1), *mode_c2 = get_irn_mode(c2);
+
+ /* It might happen, that c1 and c2 have different modes, for instance Is and Iu.
+ * Handle this here.
+ */
+ if (mode_c1 != mode_c2) {
+ if (mode_is_int(mode_c1) && mode_is_int(mode_c2)) {
+ /* get the bigger one */
+ if (get_mode_size_bits(mode_c1) > get_mode_size_bits(mode_c2))
+ c2 = new_r_Conv(current_ir_graph, block, c2, mode_c1);
+ else if (get_mode_size_bits(mode_c1) < get_mode_size_bits(mode_c2))
+ c1 = new_r_Conv(current_ir_graph, block, c1, mode_c2);
+ else {
+ /* Try to cast the real const */
+ if (c_c1 == REAL_CONSTANT)
+ c1 = new_r_Conv(current_ir_graph, block, c1, mode_c2);
+ else
+ c2 = new_r_Conv(current_ir_graph, block, c2, mode_c1);
+ }
+ }
+ }
in[0] = c1;
in[1] = c2;
mode = get_mode_from_ops(in[0], in[1]);
irn = optimize_node(new_ir_node(NULL, current_ir_graph, block, op, mode, 2, in));
- printf("Applied: %s .%s. (%s .%s. %s) => (%s .%s. %s) .%s. %s\n",
- get_irn_opname(c1), get_irn_opname(n), get_irn_opname(c2), get_irn_opname(n), get_irn_opname(t2),
- get_irn_opname(c1), get_irn_opname(n), get_irn_opname(c2), get_irn_opname(n), get_irn_opname(t2));
-
- exchange(n, irn);
-
- return 1;
+ DBG((dbg, LEVEL_5, "Applied: %n .%s. (%n .%s. %n) => (%n .%s. %n) .%s. %n\n",
+ c1, get_irn_opname(n), c2, get_irn_opname(n),
+ t2, c1, get_irn_opname(n), c2, get_irn_opname(n), t2));
+ /*
+ * in some rare cases it can really happen that we get the same node back.
+ * This might be happen in dead loops, were the Phi nodes are already gone away.
+ * So check this.
+ */
+ if (n != irn) {
+ exchange(n, irn);
+ *node = irn;
+ return 1;
+ }
}
}
return 0;
}
#define reassoc_Add reassoc_commutative
+#define reassoc_And reassoc_commutative
+#define reassoc_Or reassoc_commutative
+#define reassoc_Eor reassoc_commutative
/**
- * reassociate using distibutive law for Mul and Add/Sub
+ * reassociate using distributive law for Mul and Add/Sub
*/
-static int reassoc_Mul(ir_node *n)
+static int reassoc_Mul(ir_node **node)
{
+ ir_node *n = *node;
ir_node *add_sub, *c;
ir_op *op;
- if (reassoc_commutative(n))
+ if (reassoc_commutative(&n))
return 1;
get_comm_Binop_ops(n, &add_sub, &c);
mode = get_mode_from_ops(in[0], in[1]);
irn = optimize_node(new_ir_node(NULL, current_ir_graph, block, op, mode, 2, in));
- printf("Applied: (%s .%s. %s) %s %s => (%s %s %s) .%s. (%s %s %s)\n",
- get_irn_opname(t1), get_op_name(op), get_irn_opname(t2), get_irn_opname(n), get_irn_opname(c),
- get_irn_opname(t1), get_irn_opname(n), get_irn_opname(c),
- get_op_name(op),
- get_irn_opname(t2), get_irn_opname(n), get_irn_opname(c));
-
+ DBG((dbg, LEVEL_5, "Applied: (%n .%s. %n) %n %n => (%n %n %n) .%s. (%n %n %n)\n",
+ t1, get_op_name(op), t2, n, c, t1, n, c, get_op_name(op), t2, n, c));
exchange(n, irn);
+ *node = irn;
return 1;
}
walker_t *wenv = env;
int res;
+ hook_reassociate(1);
+
/* reassociation must run until fixpoint */
do {
ir_op *op = get_irn_op(n);
/* reassociation works only for integer or reference modes */
if (op->reassociate && (mode_is_int(mode) || mode_is_reference(mode))) {
- res = op->reassociate(n);
- if (res) {
- wenv->changes = 1;
+ res = op->reassociate(&n);
- /* we need a skip here, or we will see an Id in the next iteration */
- n = skip_Id(n);
- }
+ wenv->changes |= res;
}
} while (res == 1);
+
+ hook_reassociate(0);
}
/*
}
}
-/* initialise the reassociation by adding operations to some opcodes */
+/* initialize the reassociation by adding operations to some opcodes */
void firm_init_reassociation(void)
{
#define INIT(a) op_##a->reassociate = reassoc_##a;
INIT(Mul);
INIT(Add);
INIT(Sub);
-#undef CASE
+ INIT(And);
+ INIT(Or);
+ INIT(Eor);
+#undef INIT
+
+ dbg = firm_dbg_register("firm.opt.reassoc");
}
projects / libfirm / blobdiff