Rework linkage types in firm.

[libfirm] / ir / be / bearch.c

diff --git a/ir/be/bearch.c b/ir/be/bearch.c
index 3bb6a7b..83c0661 100644 (file)
--- a/ir/be/bearch.c
+++ b/ir/be/bearch.c
@@ -28,10 +28,11 @@
 #include <string.h>
 
 #include "bearch.h"
-#include "benode_t.h"
+#include "benode.h"
 #include "beinfo.h"
 #include "ircons_t.h"
 #include "irnode_t.h"
+#include "irop_t.h"
 
 #include "bitset.h"
 #include "pset.h"
@@ -65,42 +66,25 @@ static inline const arch_irn_ops_t *get_irn_ops(const ir_node *irn)
        ops    = get_irn_op(irn);
        be_ops = get_op_ops(ops)->be_ops;
 
-       assert(be_ops);
        return be_ops;
 }
 
 const arch_register_req_t *arch_get_register_req(const ir_node *irn, int pos)
 {
-       const arch_irn_ops_t *ops;
-
        if (is_Proj(irn)) {
                assert(pos == -1);
                pos = -1-get_Proj_proj(irn);
                irn = get_Proj_pred(irn);
        }
-       ops = get_irn_ops(irn);
+
        if (pos < 0) {
-               return ops->get_irn_reg_req_out(irn, -pos-1);
+               return arch_get_out_register_req(irn, -pos-1);
        } else {
+               const arch_irn_ops_t *ops = get_irn_ops_simple(irn);
                return ops->get_irn_reg_req_in(irn, pos);
        }
 }
 
-const arch_register_req_t *arch_get_register_req_out(const ir_node *irn)
-{
-       int                   pos = 0;
-       const arch_irn_ops_t *ops;
-
-       if (is_Proj(irn)) {
-               pos = get_Proj_proj(irn);
-               irn = get_Proj_pred(irn);
-       } else if (get_irn_mode(irn) == mode_T) {
-               return arch_no_register_req;
-       }
-       ops = get_irn_ops(irn);
-       return ops->get_irn_reg_req_out(irn, pos);
-}
-
 void arch_set_frame_offset(ir_node *irn, int offset)
 {
        const arch_irn_ops_t *ops = get_irn_ops(irn);
@@ -179,7 +163,8 @@ void arch_put_non_ignore_regs(const arch_register_class_t *cls, bitset_t *bs)
        }
 }
 
-int arch_reg_is_allocatable(const ir_node *irn, int pos, const arch_register_t *reg)
+int arch_reg_is_allocatable(const ir_node *irn, int pos,
+                            const arch_register_t *reg)
 {
        const arch_register_req_t *req = arch_get_register_req(irn, pos);
 
@@ -187,7 +172,8 @@ int arch_reg_is_allocatable(const ir_node *irn, int pos, const arch_register_t *
                return 0;
 
        if(arch_register_req_is(req, limited)) {
-               assert(arch_register_get_class(reg) == req->cls);
+               if (arch_register_get_class(reg) != req->cls)
+                       return 0;
                return rbitset_is_set(req->limited, arch_register_get_index(reg));
        }
 
@@ -277,23 +263,25 @@ void arch_irn_add_flags(ir_node *node, arch_irn_flags_t flags)
        info->flags |= flags;
 }
 
-extern char *arch_register_req_format(char *buf, size_t len,
-                                      const arch_register_req_t *req,
-                                      const ir_node *node)
+void arch_dump_register_req(FILE *F, const arch_register_req_t *req,
+                            const ir_node *node)
 {
-       char tmp[128];
-       snprintf(buf, len, "class: %s", req->cls->name);
+       if (req == NULL || req->type == arch_register_req_type_none) {
+               fprintf(F, "n/a");
+               return;
+       }
+
+       fprintf(F, "%s", req->cls->name);
 
        if(arch_register_req_is(req, limited)) {
                unsigned n_regs = req->cls->n_regs;
                unsigned i;
 
-               strncat(buf, " limited:", len);
+               fprintf(F, " limited to");
                for(i = 0; i < n_regs; ++i) {
                        if(rbitset_is_set(req->limited, i)) {
                                const arch_register_t *reg = &req->cls->regs[i];
-                               strncat(buf, " ", len);
-                               strncat(buf, reg->name, len);
+                               fprintf(F, " %s", reg->name);
                        }
                }
        }
@@ -302,11 +290,10 @@ extern char *arch_register_req_format(char *buf, size_t len,
                const unsigned other = req->other_same;
                int i;
 
-               ir_snprintf(tmp, sizeof(tmp), " same to:");
+               fprintf(F, " same as");
                for (i = 0; 1U << i <= other; ++i) {
                        if (other & (1U << i)) {
-                               ir_snprintf(tmp, sizeof(tmp), " %+F", get_irn_n(skip_Proj_const(node), i));
-                               strncat(buf, tmp, len);
+                               ir_fprintf(F, " %+F", get_irn_n(skip_Proj_const(node), i));
                        }
                }
        }
@@ -315,23 +302,64 @@ extern char *arch_register_req_format(char *buf, size_t len,
                const unsigned other = req->other_different;
                int i;
 
-               ir_snprintf(tmp, sizeof(tmp), " different from:");
+               fprintf(F, " different from");
                for (i = 0; 1U << i <= other; ++i) {
                        if (other & (1U << i)) {
-                               ir_snprintf(tmp, sizeof(tmp), " %+F", get_irn_n(skip_Proj_const(node), i));
-                               strncat(buf, tmp, len);
+                               ir_fprintf(F, " %+F", get_irn_n(skip_Proj_const(node), i));
                        }
                }
        }
 
        if (arch_register_req_is(req, ignore)) {
-               strncat(buf, " ignore", len);
+               fprintf(F, " ignore");
        }
        if (arch_register_req_is(req, produces_sp)) {
-               strncat(buf, " produces_sp", len);
+               fprintf(F, " produces_sp");
+       }
+}
+
+void arch_dump_reqs_and_registers(FILE *F, const ir_node *node)
+{
+       int              n_ins  = get_irn_arity(node);
+       int              n_outs = arch_irn_get_n_outs(node);
+       arch_irn_flags_t flags  = arch_irn_get_flags(node);
+       int              i;
+
+       for (i = 0; i < n_ins; ++i) {
+               const arch_register_req_t *req = arch_get_in_register_req(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_out_register_req(node, i);
+               fprintf(F, "outreq #%d = ", i);
+               arch_dump_register_req(F, req, node);
+               fputs("\n", F);
+       }
+       for (i = 0; i < n_outs; ++i) {
+               const arch_register_t     *reg = arch_irn_get_register(node, i);
+               const arch_register_req_t *req = arch_get_out_register_req(node, i);
+               if (req->cls == NULL)
+                       continue;
+               fprintf(F, "reg #%d = %s\n", i, reg != NULL ? reg->name : "n/a");
        }
 
-       return buf;
+       fprintf(F, "flags =");
+       if (flags == arch_irn_flags_none) {
+               fprintf(F, " none");
+       } else {
+               if (flags & arch_irn_flags_dont_spill) {
+                       fprintf(F, " unspillable");
+               }
+               if (flags & arch_irn_flags_rematerializable) {
+                       fprintf(F, " remat");
+               }
+               if (flags & arch_irn_flags_modify_flags) {
+                       fprintf(F, " modify_flags");
+               }
+       }
+       fprintf(F, " (%d)\n", flags);
 }
 
 static const arch_register_req_t no_requirement = {