Added support for out edges.

[libfirm] / ir / opt / reassoc.c

diff --git a/ir/opt/reassoc.c b/ir/opt/reassoc.c
index e3ee256..20af0e9 100644 (file)
--- a/ir/opt/reassoc.c
+++ b/ir/opt/reassoc.c
@@ -10,7 +10,7 @@
  */
 
 #ifdef HAVE_CONFIG_H
-# include <config.h>
+# include "config.h"
 #endif
 
 # include "irnode_t.h"
@@ -24,7 +24,7 @@
 # include "irflag_t.h"
 # include "irgwalk.h"
 # include "reassoc_t.h"
-# include "firmstat.h"
+# include "irhooks.h"
 
 typedef struct _walker_t {
   int changes;          /* set, if a reassociation take place */
@@ -32,13 +32,13 @@ typedef struct _walker_t {
 
 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)
@@ -57,8 +57,8 @@ 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)
 {
@@ -196,7 +196,7 @@ static int reassoc_commutative(ir_node *n)
       /* 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;
     }
@@ -258,9 +258,12 @@ static int reassoc_commutative(ir_node *n)
 }
 
 #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)
 {
@@ -310,6 +313,8 @@ static void do_reassociation(ir_node *n, void *env)
   walker_t *wenv = env;
   int res;
 
+  hook_reassociate(1);
+
   /* reassociation must run until fixpoint */
   do {
     ir_op   *op    = get_irn_op(n);
@@ -328,6 +333,8 @@ static void do_reassociation(ir_node *n, void *env)
       }
     }
   } while (res == 1);
+
+  hook_reassociate(0);
 }
 
 /*
@@ -357,12 +364,15 @@ void optimize_reassociation(ir_graph *irg)
   }
 }
 
-/* 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
 }