expose some critical bearch functions for inlining

[libfirm] / ir / be / benode.c

diff --git a/ir/be/benode.c b/ir/be/benode.c
index 2612496..b4a2197 100644 (file)
--- a/ir/be/benode.c
+++ b/ir/be/benode.c
@@ -30,6 +30,7 @@
 
 #include <stdlib.h>
 
+#include "beirg.h"
 #include "obst.h"
 #include "set.h"
 #include "pmap.h"
@@ -241,10 +242,10 @@ static void init_node_attr(ir_node *node, int n_inputs, int n_outputs)
        }
 }
 
-static void add_register_req_in(ir_node *node)
+static void add_register_req_in(ir_node *node, const arch_register_req_t *req)
 {
        backend_info_t *info = be_get_info(node);
-       ARR_APP1(const arch_register_req_t*, info->in_reqs, arch_no_register_req);
+       ARR_APP1(const arch_register_req_t*, info->in_reqs, req);
 }
 
 ir_node *be_new_Spill(const arch_register_class_t *cls,
@@ -443,11 +444,6 @@ ir_node *be_get_Copy_op(const ir_node *cpy)
        return get_irn_n(cpy, n_be_Copy_op);
 }
 
-void be_set_Copy_op(ir_node *cpy, ir_node *op)
-{
-       set_irn_n(cpy, n_be_Copy_op, op);
-}
-
 ir_node *be_new_Keep(ir_node *block, int n, ir_node *in[])
 {
        int i;
@@ -461,8 +457,11 @@ ir_node *be_new_Keep(ir_node *block, int n, ir_node *in[])
        attr->exc.pin_state = op_pin_state_pinned;
 
        for (i = 0; i < n; ++i) {
-               add_irn_n(res, in[i]);
-               add_register_req_in(res);
+               ir_node *pred = in[i];
+               add_irn_n(res, pred);
+               const arch_register_req_t *req = arch_get_irn_register_req(pred);
+               req = req->cls != NULL ? req->cls->class_req : arch_no_register_req;
+               add_register_req_in(res, req);
        }
        keep_alive(res);
 
@@ -471,12 +470,9 @@ ir_node *be_new_Keep(ir_node *block, int n, ir_node *in[])
 
 void be_Keep_add_node(ir_node *keep, const arch_register_class_t *cls, ir_node *node)
 {
-       int n;
-
        assert(be_is_Keep(keep));
-       n = add_irn_n(keep, node);
-       add_register_req_in(keep);
-       be_node_set_reg_class_in(keep, n, cls);
+       add_irn_n(keep, node);
+       add_register_req_in(keep, cls->class_req);
 }
 
 ir_node *be_new_Call(dbg_info *dbg, ir_graph *irg, ir_node *bl, ir_node *mem,
@@ -730,6 +726,12 @@ ir_node *be_new_CopyKeep(ir_node *bl, ir_node *src, int n, ir_node *in_keep[])
        attr->exc.pin_state = op_pin_state_floats;
        be_node_set_reg_class_in(irn, 0, cls);
        be_node_set_reg_class_out(irn, 0, cls);
+       for (int i = 0; i < n; ++i) {
+               ir_node *pred = in_keep[i];
+               const arch_register_req_t *req = arch_get_irn_register_req(pred);
+               req = req->cls != NULL ? req->cls->class_req : arch_no_register_req;
+               be_set_constr_in(irn, i+1, req);
+       }
 
        return irn;
 }
@@ -829,11 +831,11 @@ const arch_register_req_t *be_create_reg_req(struct obstack *obst,
                const arch_register_t *reg, arch_register_req_type_t additional_types)
 {
        arch_register_req_t         *req = OALLOC(obst, arch_register_req_t);
-       const arch_register_class_t *cls = arch_register_get_class(reg);
+       const arch_register_class_t *cls = reg->reg_class;
        unsigned                    *limited_bitset;
 
        limited_bitset = rbitset_obstack_alloc(obst, arch_register_class_n_regs(cls));
-       rbitset_set(limited_bitset, arch_register_get_index(reg));
+       rbitset_set(limited_bitset, reg->index);
 
        req->type    = arch_register_req_type_limited | additional_types;
        req->cls     = cls;
@@ -968,7 +970,6 @@ static const arch_irn_ops_t be_node_irn_ops = {
        be_node_get_frame_entity,
        be_node_set_frame_offset,
        be_node_get_sp_bias,
-       NULL,    /* get_inverse             */
        NULL,    /* get_op_estimated_cost   */
        NULL,    /* possible_memory_operand */
        NULL,    /* perform_memory_operand  */
@@ -986,7 +987,7 @@ static int get_start_reg_index(ir_graph *irg, const arch_register_t *reg)
                        = arch_get_irn_register_req_out(start, i);
                if (! (out_req->type & arch_register_req_type_limited))
                        continue;
-               if (out_req->cls != arch_register_get_class(reg))
+               if (out_req->cls != reg->reg_class)
                        continue;
                if (!rbitset_is_set(out_req->limited, reg->index))
                        continue;
@@ -999,7 +1000,7 @@ ir_node *be_get_initial_reg_value(ir_graph *irg, const arch_register_t *reg)
 {
        int      i     = get_start_reg_index(irg, reg);
        ir_node *start = get_irg_start(irg);
-       ir_mode *mode  = arch_register_class_mode(arch_register_get_class(reg));
+       ir_mode *mode  = arch_register_class_mode(reg->reg_class);
 
        foreach_out_edge(start, edge) {
                ir_node *proj = get_edge_src_irn(edge);
@@ -1021,7 +1022,7 @@ int be_find_return_reg_input(ir_node *ret, const arch_register_t *reg)
                const arch_register_req_t *req = arch_get_irn_register_req_in(ret, i);
                if (! (req->type & arch_register_req_type_limited))
                        continue;
-               if (req->cls != arch_register_get_class(reg))
+               if (req->cls != reg->reg_class)
                        continue;
                if (!rbitset_is_set(req->limited, reg->index))
                        continue;
@@ -1054,7 +1055,6 @@ static const arch_irn_ops_t dummy_be_irn_ops = {
        dummy_get_frame_entity,
        dummy_set_frame_offset,
        dummy_get_sp_bias,
-       NULL,      /* get_inverse           */
        NULL,      /* get_op_estimated_cost */
        NULL,      /* possible_memory_operand */
        NULL,      /* perform_memory_operand */
@@ -1129,7 +1129,6 @@ static const arch_irn_ops_t phi_irn_ops = {
        dummy_get_frame_entity,
        dummy_set_frame_offset,
        dummy_get_sp_bias,
-       NULL,    /* get_inverse             */
        NULL,    /* get_op_estimated_cost   */
        NULL,    /* possible_memory_operand */
        NULL,    /* perform_memory_operand  */