- add pass for combo()

[libfirm] / ir / opt / combo.c

diff --git a/ir/opt/combo.c b/ir/opt/combo.c
index af5bc66..081eee9 100644 (file)
--- a/ir/opt/combo.c
+++ b/ir/opt/combo.c
@@ -72,6 +72,7 @@
 #include "irgraph_t.h"
 #include "irnode_t.h"
 #include "iropt_t.h"
+#include "irpass_t.h"
 #include "irgwalk.h"
 #include "irop.h"
 #include "irouts.h"
@@ -288,7 +289,7 @@ static void check_opcode(const partition_t *Z) {
                                key.u.intVal = get_Conv_strict(irn);
                                break;
                        case iro_Div:
-                               key.u.intVal = is_Div_remainderless(irn);
+                               key.u.intVal = get_Div_no_remainder(irn);
                                break;
                        case iro_Block:
                                key.u.block = irn;
@@ -319,7 +320,7 @@ static void check_opcode(const partition_t *Z) {
                                assert(key.u.intVal == get_Conv_strict(irn));
                                break;
                        case iro_Div:
-                               assert(key.u.intVal == is_Div_remainderless(irn));
+                               assert(key.u.intVal == get_Div_no_remainder(irn));
                                break;
                        case iro_Block:
                                assert(key.u.block == irn);
@@ -352,6 +353,8 @@ static void check_all_partitions(environment_t *env) {
                        assert(leader != node && leader->part == node->part);
                }
        }
+#else
+       (void) env;
 #endif
 }
 
@@ -359,13 +362,19 @@ static void check_all_partitions(environment_t *env) {
  * Check list.
  */
 static void do_check_list(const node_t *list, int ofs, const partition_t *Z) {
-       const node_t *e;
 
+#ifndef NDEBUG
+       const node_t *e;
 #define NEXT(e)  *((const node_t **)((char *)(e) + (ofs)))
        for (e = list; e != NULL; e = NEXT(e)) {
                assert(e->part == Z);
        }
 #undef NEXT
+#else
+       (void) list;
+       (void) ofs;
+       (void) Z;
+#endif
 }  /* ido_check_list */
 
 /**
@@ -1673,7 +1682,7 @@ static void *lambda_opcode(const node_t *node, environment_t *env) {
                key.u.intVal = get_Conv_strict(irn);
                break;
        case iro_Div:
-               key.u.intVal = is_Div_remainderless(irn);
+               key.u.intVal = get_Div_no_remainder(irn);
                break;
        case iro_Block:
                /*
@@ -1914,7 +1923,7 @@ static void compute_Block(node_t *node) {
        int     i;
        ir_node *block = node->node;
 
-       if (block == get_irg_start_block(current_ir_graph) || has_Block_label(block)) {
+       if (block == get_irg_start_block(current_ir_graph) || has_Block_entity(block)) {
                /* start block and labelled blocks are always reachable */
                node->type.tv = tarval_reachable;
                return;
@@ -1956,7 +1965,7 @@ static void compute_Unknown(node_t *node) {
         * It would be safe to compute Top IF it can be assured, that only Cmp
         * nodes are inputs to Conds. We check that first.
         * This is the way Frontends typically build Firm, but some optimizations
-        * (cond_eval for instance) might replace them by Phib's...
+        * (jump threading for instance) might replace them by Phib's...
         */
        node->type.tv = tarval_UNKNOWN;
 }  /* compute_Unknown */
@@ -2954,7 +2963,7 @@ static int only_one_reachable_proj(ir_node *n) {
  * @param block  the destination block
  */
 static int can_exchange(ir_node *pred, ir_node *block) {
-       if (is_Start(pred) || has_Block_label(block))
+       if (is_Start(pred) || has_Block_entity(block))
                return 0;
        else if (is_Jmp(pred))
                return 1;
@@ -3140,7 +3149,7 @@ static void exchange_leader(ir_node *irn, ir_node *leader) {
                ir_node  *block = get_nodes_block(leader);
                dbg_info *dbg   = get_irn_dbg_info(irn);
 
-               leader = new_rd_Conv(dbg, current_ir_graph, block, leader, mode);
+               leader = new_rd_Conv(dbg, block, leader, mode);
        }
        exchange(irn, leader);
 }  /* exchange_leader */
@@ -3263,7 +3272,7 @@ static void apply_result(ir_node *irn, void *ctx) {
 
                                if (is_Cond(cond)) {
                                        if (only_one_reachable_proj(cond)) {
-                                               ir_node *jmp = new_r_Jmp(current_ir_graph, block->node);
+                                               ir_node *jmp = new_r_Jmp(block->node);
                                                set_irn_node(jmp, node);
                                                node->node = jmp;
                                                DB((dbg, LEVEL_1, "%+F is replaced by %+F\n", irn, jmp));
@@ -3305,7 +3314,7 @@ static void apply_result(ir_node *irn, void *ctx) {
                        } else if (is_entity(node->type.sym.entity_p)) {
                                if (! is_SymConst(irn)) {
                                        /* can be replaced by a SymConst */
-                                       ir_node *symc = new_r_SymConst(current_ir_graph, block->node, get_irn_mode(irn), node->type.sym, symconst_addr_ent);
+                                       ir_node *symc = new_r_SymConst(current_ir_graph, get_irn_mode(irn), node->type.sym, symconst_addr_ent);
                                        set_irn_node(symc, node);
                                        node->node = symc;
 
@@ -3559,3 +3568,29 @@ void combo(ir_graph *irg) {
        set_value_of_func(NULL);
        current_ir_graph = rem;
 }  /* combo */
+
+/**
+ * Wrapper for running combo() as an ir_graph pass.
+ */
+static int pass_wrapper(ir_graph *irg, void *context) {
+       (void)context;
+       combo(irg);
+       /* combo is a fix-point iteration */
+       return 0;
+}  /* pass_wrapper */
+
+/* Creates an ir_graph pass for combo. */
+ir_graph_pass_t *combo_pass(const char *name, int verify, int dump) {
+       struct ir_graph_pass_t *pass = XMALLOCZ(ir_graph_pass_t);
+
+       pass->kind       = k_ir_prog_pass;
+       pass->run_on_irg = pass_wrapper;
+       pass->context    = pass;
+       pass->name       = name ? name : "combo";
+       pass->verify     = verify != 0;
+       pass->dump       = dump != 0;
+
+       INIT_LIST_HEAD(&pass->list);
+
+       return pass;
+}  /* combo_pass */