besched: Add and use sched_replace().

[libfirm] / ir / be / beinsn.c

diff --git a/ir/be/beinsn.c b/ir/be/beinsn.c
index 9afe833..bbe72e9 100644 (file)
--- a/ir/be/beinsn.c
+++ b/ir/be/beinsn.c
@@ -35,80 +35,52 @@
 #include "beabi.h"
 #include "raw_bitset.h"
 
-be_insn_t *be_scan_insn(be_chordal_env_t const *const env, ir_node *const irn)
+be_insn_t *be_scan_insn(be_chordal_env_t *const env, ir_node *const irn)
 {
-       struct obstack *obst = env->obst;
+       struct obstack *const obst = &env->obst;
        be_operand_t o;
-       int i, n;
 
        be_insn_t *insn = OALLOCZ(obst, be_insn_t);
 
        bool has_constraints = false;
 
+       const arch_register_class_t *cls = env->cls;
        insn->irn = irn;
-       if (get_irn_mode(irn) == mode_T) {
-               ir_node *p;
-
-               /* This instruction might create more than one def. These are handled
-                  by Proj's, find them. */
-               foreach_out_edge(irn, edge) {
-                       p = get_edge_src_irn(edge);
-
-                       /* did not work if the result is a ProjT. This should NOT happen
-                          in the backend, but check it for now. */
-                       assert(get_irn_mode(p) != mode_T);
-
-                       if (arch_irn_consider_in_reg_alloc(env->cls, p)) {
-                               /* found a def: create a new operand */
-                               o.req             = arch_get_irn_register_req(p);
-                               o.carrier         = p;
-                               o.partner         = NULL;
-                               obstack_grow(obst, &o, sizeof(o));
-                               insn->n_ops++;
-                               has_constraints |= arch_register_req_is(o.req, limited) | (o.req->width > 1);
-                       }
+       be_foreach_definition(irn, cls, p, req,
+               /* found a def: create a new operand */
+               if (arch_register_req_is(req, limited)) {
+                       o.regs          = req->limited;
+                       has_constraints = true;
+               } else {
+                       o.regs           = env->allocatable_regs->data;
+                       has_constraints |= req->width > 1;
                }
-       } else if (arch_irn_consider_in_reg_alloc(env->cls, irn)) {
-               /* only one def, create one operand */
-               o.req     = arch_get_irn_register_req(irn);
-               o.carrier = irn;
+               o.carrier = p;
                o.partner = NULL;
                obstack_grow(obst, &o, sizeof(o));
                insn->n_ops++;
-               has_constraints |= arch_register_req_is(o.req, limited) | (o.req->width > 1);
-       }
+       );
 
        insn->use_start = insn->n_ops;
 
        /* now collect the uses for this node */
-       for (i = 0, n = get_irn_arity(irn); i < n; ++i) {
-               ir_node *op = get_irn_n(irn, i);
-
-               if (arch_irn_consider_in_reg_alloc(env->cls, op)) {
-                       /* found a register use, create an operand */
-                       o.req     = arch_get_irn_register_req_in(irn, i);
-                       o.carrier = op;
-                       o.partner = NULL;
-                       obstack_grow(obst, &o, sizeof(o));
-                       insn->n_ops++;
-                       has_constraints |= arch_register_req_is(o.req, limited);
+       be_foreach_use(irn, cls, in_req, op, op_req,
+               /* found a register use, create an operand */
+               if (arch_register_req_is(in_req, limited)) {
+                       o.regs          = in_req->limited;
+                       has_constraints = true;
+               } else {
+                       o.regs = env->allocatable_regs->data;
                }
-       }
+               o.carrier = op;
+               o.partner = NULL;
+               obstack_grow(obst, &o, sizeof(o));
+               insn->n_ops++;
+       );
 
        if (!has_constraints)
                return NULL;
 
        insn->ops = (be_operand_t*)obstack_finish(obst);
-
-       /* Compute the admissible registers bitsets. */
-       for (i = 0; i < insn->n_ops; ++i) {
-               be_operand_t              *const op  = &insn->ops[i];
-               arch_register_req_t const *const req = op->req;
-               assert(req->cls == env->cls);
-
-               op->regs = arch_register_req_is(req, limited) ?
-                       req->limited : env->allocatable_regs->data;
-       }
-
        return insn;
 }