heur4: Avoid unnecessary bitset operations when the node is not limited.

[libfirm] / ir / be / bearch.c

diff --git a/ir/be/bearch.c b/ir/be/bearch.c
index 3172eff..d21611d 100644 (file)
--- a/ir/be/bearch.c
+++ b/ir/be/bearch.c
@@ -21,7 +21,6 @@
  * @file
  * @brief       Processor architecture specification.
  * @author      Sebastian Hack
- * @version     $Id$
  */
 #include "config.h"
 
@@ -56,9 +55,10 @@ static reg_out_info_t dummy_info = {
 };
 
 /* Initialize the architecture environment struct. */
-arch_env_t *arch_env_init(const arch_isa_if_t *isa_if, FILE *file_handle, be_main_env_t *main_env)
+arch_env_t *arch_env_begin_codegeneration(const arch_isa_if_t *isa_if,
+                                          be_main_env_t *main_env)
 {
-       arch_env_t *arch_env = isa_if->init(file_handle);
+       arch_env_t *arch_env = isa_if->begin_codegeneration(main_env);
        arch_env->main_env   = main_env;
        return arch_env;
 }
@@ -70,16 +70,13 @@ arch_env_t *arch_env_init(const arch_isa_if_t *isa_if, FILE *file_handle, be_mai
  */
 static const arch_irn_ops_t *get_irn_ops(const ir_node *irn)
 {
-       const ir_op          *ops;
-       const arch_irn_ops_t *be_ops;
-
        if (is_Proj(irn)) {
                irn = get_Proj_pred(irn);
                assert(!is_Proj(irn));
        }
 
-       ops    = get_irn_op(irn);
-       be_ops = get_op_ops(ops)->be_ops;
+       ir_op                *ops    = get_irn_op(irn);
+       const arch_irn_ops_t *be_ops = get_op_ops(ops)->be_ops;
 
        return be_ops;
 }
@@ -167,11 +164,11 @@ static reg_out_info_t *get_out_info(const ir_node *node)
        return &info->out_infos[pos];
 }
 
-static reg_out_info_t *get_out_info_n(const ir_node *node, int pos)
+static reg_out_info_t *get_out_info_n(const ir_node *node, unsigned pos)
 {
        const backend_info_t *info = be_get_info(node);
        assert(!is_Proj(node));
-       assert(pos >= 0 && pos < (int)ARR_LEN(info->out_infos));
+       assert(pos < (unsigned)ARR_LEN(info->out_infos));
        return &info->out_infos[pos];
 }
 
@@ -182,7 +179,8 @@ const arch_register_t *arch_get_irn_register(const ir_node *node)
        return out->reg;
 }
 
-const arch_register_t *arch_get_irn_register_out(const ir_node *node, int pos)
+const arch_register_t *arch_get_irn_register_out(const ir_node *node,
+                                                 unsigned pos)
 {
        const reg_out_info_t *out = get_out_info_n(node, pos);
        return out->reg;
@@ -194,7 +192,7 @@ const arch_register_t *arch_get_irn_register_in(const ir_node *node, int pos)
        return arch_get_irn_register(op);
 }
 
-void arch_set_irn_register_out(ir_node *node, int pos,
+void arch_set_irn_register_out(ir_node *node, unsigned pos,
                                const arch_register_t *reg)
 {
        reg_out_info_t *out = get_out_info_n(node, pos);
@@ -213,12 +211,6 @@ const arch_register_req_t *arch_get_irn_register_req(const ir_node *node)
        return out->req;
 }
 
-arch_irn_class_t arch_irn_classify(const ir_node *node)
-{
-       const arch_irn_ops_t *ops = get_irn_ops(node);
-       return ops->classify(node);
-}
-
 arch_irn_flags_t arch_get_irn_flags(const ir_node *node)
 {
        backend_info_t *info;
@@ -257,11 +249,11 @@ bool arch_reg_is_allocatable(const arch_register_req_t *req,
        if (req->type == arch_register_req_type_none)
                return false;
        if (req->type & arch_register_req_type_limited) {
-               if (arch_register_get_class(reg) != req->cls)
+               if (reg->reg_class != req->cls)
                        return false;
-               return rbitset_is_set(req->limited, arch_register_get_index(reg));
+               return rbitset_is_set(req->limited, reg->index);
        }
-       return req->cls == arch_register_get_class(reg);
+       return req->cls == reg->reg_class;
 }
 
 void arch_dump_register_req(FILE *F, const arch_register_req_t *req,
@@ -327,32 +319,30 @@ void arch_dump_register_req(FILE *F, const arch_register_req_t *req,
 
 void arch_dump_reqs_and_registers(FILE *F, const ir_node *node)
 {
-       int              n_ins  = get_irn_arity(node);
-       int              n_outs = arch_get_irn_n_outs(node);
-       arch_irn_flags_t flags  = arch_get_irn_flags(node);
-       int              i;
-
-       for (i = 0; i < n_ins; ++i) {
+       int n_ins  = get_irn_arity(node);
+       for (int i = 0; i < n_ins; ++i) {
                const arch_register_req_t *req = arch_get_irn_register_req_in(node, i);
                fprintf(F, "inreq #%d = ", i);
                arch_dump_register_req(F, req, node);
                fputs("\n", F);
        }
-       for (i = 0; i < n_outs; ++i) {
-               const arch_register_req_t *req = arch_get_irn_register_req_out(node, i);
-               fprintf(F, "outreq #%d = ", i);
+       unsigned n_outs = arch_get_irn_n_outs(node);
+       for (unsigned o = 0; o < n_outs; ++o) {
+               const arch_register_req_t *req = arch_get_irn_register_req_out(node, o);
+               fprintf(F, "outreq #%u = ", o);
                arch_dump_register_req(F, req, node);
                fputs("\n", F);
        }
-       for (i = 0; i < n_outs; ++i) {
-               const arch_register_t     *reg = arch_get_irn_register_out(node, i);
-               const arch_register_req_t *req = arch_get_irn_register_req_out(node, i);
+       for (unsigned o = 0; o < n_outs; ++o) {
+               const arch_register_t     *reg = arch_get_irn_register_out(node, o);
+               const arch_register_req_t *req = arch_get_irn_register_req_out(node, o);
                if (req->cls == NULL)
                        continue;
-               fprintf(F, "reg #%d = %s\n", i, reg != NULL ? reg->name : "n/a");
+               fprintf(F, "reg #%u = %s\n", o, reg != NULL ? reg->name : "n/a");
        }
 
        fprintf(F, "flags =");
+       arch_irn_flags_t flags = arch_get_irn_flags(node);
        if (flags == arch_irn_flags_none) {
                fprintf(F, " none");
        } else {
@@ -372,5 +362,5 @@ void arch_dump_reqs_and_registers(FILE *F, const ir_node *node)
                        fprintf(F, " not_scheduled");
                }
        }
-       fprintf(F, " (%d)\n", (int)flags);
+       fprintf(F, " (0x%x)\n", (unsigned)flags);
 }