bearch: Use arch_register_req_is(req, ignore) instead of arch_irn_is_ignore(...)...
[libfirm] / ir / be / becopyopt.c
index da381e6..873d58c 100644 (file)
@@ -39,7 +39,7 @@
 #include "irgwalk.h"
 #include "irloop_t.h"
 #include "irnode.h"
-#include "irprintf_t.h"
+#include "irprintf.h"
 #include "irprog.h"
 #include "irtools.h"
 #include "pmap.h"
@@ -241,16 +241,14 @@ void free_copy_opt(copy_opt_t *co)
  */
 static int co_is_optimizable_root(ir_node *irn)
 {
-       const arch_register_req_t *req;
-
-       if (arch_irn_is_ignore(irn))
+       arch_register_req_t const *const req = arch_get_irn_register_req(irn);
+       if (arch_register_req_is(req, ignore))
                return 0;
 
        if (is_Reg_Phi(irn) || is_Perm_Proj(irn))
                return 1;
 
-       req = arch_get_irn_register_req(irn);
-       if (is_2addr_code(req))
+       if (arch_register_req_is(req, should_be_same))
                return 1;
 
        return 0;
@@ -488,47 +486,45 @@ static void co_collect_units(ir_node *irn, void *env)
                unit->nodes[0] = irn;
                unit->nodes[1] = get_Perm_src(irn);
                unit->costs[1] = co->get_costs(irn, -1);
-       } else {
+       } else if (arch_register_req_is(req, should_be_same)) {
                /* Src == Tgt of a 2-addr-code instruction */
-               if (is_2addr_code(req)) {
-                       const unsigned other = req->other_same;
-                       int            count = 0;
-                       int            i;
+               const unsigned other = req->other_same;
+               int            count = 0;
+               int            i;
+
+               for (i = 0; (1U << i) <= other; ++i) {
+                       if (other & (1U << i)) {
+                               ir_node *o  = get_irn_n(skip_Proj(irn), i);
+                               if (arch_irn_is_ignore(o))
+                                       continue;
+                               if (nodes_interfere(co->cenv, irn, o))
+                                       continue;
+                               ++count;
+                       }
+               }
 
-                       for (i = 0; (1U << i) <= other; ++i) {
+               if (count != 0) {
+                       int k = 0;
+                       ++count;
+                       unit->nodes = XMALLOCN(ir_node*, count);
+                       unit->costs = XMALLOCN(int,      count);
+                       unit->node_count = count;
+                       unit->nodes[k++] = irn;
+
+                       for (i = 0; 1U << i <= other; ++i) {
                                if (other & (1U << i)) {
                                        ir_node *o  = get_irn_n(skip_Proj(irn), i);
-                                       if (arch_irn_is_ignore(o))
-                                               continue;
-                                       if (nodes_interfere(co->cenv, irn, o))
-                                               continue;
-                                       ++count;
-                               }
-                       }
-
-                       if (count != 0) {
-                               int k = 0;
-                               ++count;
-                               unit->nodes = XMALLOCN(ir_node*, count);
-                               unit->costs = XMALLOCN(int,      count);
-                               unit->node_count = count;
-                               unit->nodes[k++] = irn;
-
-                               for (i = 0; 1U << i <= other; ++i) {
-                                       if (other & (1U << i)) {
-                                               ir_node *o  = get_irn_n(skip_Proj(irn), i);
-                                               if (!arch_irn_is_ignore(o) &&
-                                                               !nodes_interfere(co->cenv, irn, o)) {
-                                                       unit->nodes[k] = o;
-                                                       unit->costs[k] = co->get_costs(irn, -1);
-                                                       ++k;
-                                               }
+                                       if (!arch_irn_is_ignore(o) &&
+                                                       !nodes_interfere(co->cenv, irn, o)) {
+                                               unit->nodes[k] = o;
+                                               unit->costs[k] = co->get_costs(irn, -1);
+                                               ++k;
                                        }
                                }
                        }
-               } else {
-                       assert(0 && "This is not an optimizable node!");
                }
+       } else {
+               assert(0 && "This is not an optimizable node!");
        }
 
        /* Insert the new unit at a position according to its costs */
@@ -819,7 +815,7 @@ static void build_graph_walker(ir_node *irn, void *env)
        if (get_irn_mode(irn) == mode_T)
                return;
        req = arch_get_irn_register_req(irn);
-       if (req->cls != co->cls || arch_irn_is_ignore(irn))
+       if (req->cls != co->cls || arch_register_req_is(req, ignore))
                return;
 
        if (is_Reg_Phi(irn)) { /* Phis */
@@ -830,17 +826,15 @@ static void build_graph_walker(ir_node *irn, void *env)
        } else if (is_Perm_Proj(irn)) { /* Perms */
                ir_node *arg = get_Perm_src(irn);
                add_edges(co, irn, arg, co->get_costs(irn, -1));
-       } else { /* 2-address code */
-               if (is_2addr_code(req)) {
-                       const unsigned other = req->other_same;
-                       int i;
+       } else if (arch_register_req_is(req, should_be_same)) {
+               const unsigned other = req->other_same;
+               int i;
 
-                       for (i = 0; 1U << i <= other; ++i) {
-                               if (other & (1U << i)) {
-                                       ir_node *other = get_irn_n(skip_Proj(irn), i);
-                                       if (!arch_irn_is_ignore(other))
-                                               add_edges(co, irn, other, co->get_costs(irn, -1));
-                               }
+               for (i = 0; 1U << i <= other; ++i) {
+                       if (other & (1U << i)) {
+                               ir_node *other = get_irn_n(skip_Proj(irn), i);
+                               if (!arch_irn_is_ignore(other))
+                                       add_edges(co, irn, other, co->get_costs(irn, -1));
                        }
                }
        }
@@ -944,35 +938,36 @@ static void co_dump_appel_graph(const copy_opt_t *co, FILE *f)
        fprintf(f, "%d %d\n", n, n_regs);
 
        be_ifg_foreach_node(ifg, &it, irn) {
-               if (!arch_irn_is_ignore(irn)) {
-                       int idx                        = node_map[get_irn_idx(irn)];
-                       affinity_node_t           *a   = get_affinity_info(co, irn);
-                       const arch_register_req_t *req = arch_get_irn_register_req(irn);
-                       ir_node                   *adj;
-
-                       if (arch_register_req_is(req, limited)) {
-                               for (i = 0; i < co->cls->n_regs; ++i) {
-                                       if (!rbitset_is_set(req->limited, i) && color_map[i] >= 0)
-                                               fprintf(f, "%d %d -1\n", color_map[i], idx);
-                               }
+               arch_register_req_t const *const req = arch_get_irn_register_req(irn);
+               if (arch_register_req_is(req, ignore))
+                       continue;
+
+               int              idx = node_map[get_irn_idx(irn)];
+               affinity_node_t *a   = get_affinity_info(co, irn);
+               ir_node         *adj;
+
+               if (arch_register_req_is(req, limited)) {
+                       for (i = 0; i < co->cls->n_regs; ++i) {
+                               if (!rbitset_is_set(req->limited, i) && color_map[i] >= 0)
+                                       fprintf(f, "%d %d -1\n", color_map[i], idx);
                        }
+               }
 
-                       be_ifg_foreach_neighbour(ifg, &nit, irn, adj) {
-                               if (!arch_irn_is_ignore(adj) &&
-                                               !co_dump_appel_disjoint_constraints(co, irn, adj)) {
-                                       int adj_idx = node_map[get_irn_idx(adj)];
-                                       if (idx < adj_idx)
-                                               fprintf(f, "%d %d -1\n", idx, adj_idx);
-                               }
+               be_ifg_foreach_neighbour(ifg, &nit, irn, adj) {
+                       if (!arch_irn_is_ignore(adj) &&
+                                       !co_dump_appel_disjoint_constraints(co, irn, adj)) {
+                               int adj_idx = node_map[get_irn_idx(adj)];
+                               if (idx < adj_idx)
+                                       fprintf(f, "%d %d -1\n", idx, adj_idx);
                        }
+               }
 
-                       if (a) {
-                               co_gs_foreach_neighb(a, n) {
-                                       if (!arch_irn_is_ignore(n->irn)) {
-                                               int n_idx = node_map[get_irn_idx(n->irn)];
-                                               if (idx < n_idx)
-                                                       fprintf(f, "%d %d %d\n", idx, n_idx, (int) n->costs);
-                                       }
+               if (a) {
+                       co_gs_foreach_neighb(a, n) {
+                               if (!arch_irn_is_ignore(n->irn)) {
+                                       int n_idx = node_map[get_irn_idx(n->irn)];
+                                       if (idx < n_idx)
+                                               fprintf(f, "%d %d %d\n", idx, n_idx, (int) n->costs);
                                }
                        }
                }