*/
#ifdef HAVE_CONFIG_H
-# include <config.h>
+# include "config.h"
#endif
# include "irnode_t.h"
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)
{
{
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 *dbg = 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);
+ 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_Add(dbg, current_ir_graph, block, irn, get_Sub_left(n), get_irn_mode(n));
+ irn = new_rd_Add(dbg, current_ir_graph, block, left, irn, get_irn_mode(n));
- printf("Applied: %s - %s => (-%s) + %s\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)) );
-
+ get_irn_opname(get_Sub_left(n)), get_irn_opname(c) );
+*/
exchange(n, irn);
return 1;
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;
+ */
+ /*
+ * 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);
+ 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)
{
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));
-
+*/
exchange(n, irn);
return 1;
walker_t *wenv = env;
int res;
+ stat_reassociate(1);
+
/* reassociation must run until fixpoint */
do {
ir_op *op = get_irn_op(n);
}
}
} while (res == 1);
+
+ stat_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);
+ INIT(And);
+ INIT(Or);
+ INIT(Eor);
#undef CASE
}
projects / libfirm / blobdiff