sparc: split Mulh node into SMulh and UMulh

[libfirm] / ir / be / belower.c

diff --git a/ir/be/belower.c b/ir/be/belower.c
index e320bae..e564ce4 100644 (file)
--- a/ir/be/belower.c
+++ b/ir/be/belower.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -52,7 +52,7 @@ DEBUG_ONLY(static firm_dbg_module_t *dbg;)
 DEBUG_ONLY(static firm_dbg_module_t *dbg_constr;)
 DEBUG_ONLY(static firm_dbg_module_t *dbg_permmove;)
 
-/** Associates an ir_node with it's copy and CopyKeep. */
+/** Associates an ir_node with its copy and CopyKeep. */
 typedef struct {
        ir_nodeset_t copies; /**< all non-spillable copies of this irn */
        const arch_register_class_t *cls;
@@ -455,7 +455,7 @@ static void lower_perm_node(ir_node *irn, lower_env_t *env)
                                        DB((dbg, LEVEL_1, "%+F creating copy node (%+F, %s) -> (%+F, %s)\n",
                                                                irn, arg1, cycle.elems[i]->name, res2, cycle.elems[i + 1]->name));
 
-                                       cpyxchg = be_new_Copy(reg_class, block, arg1);
+                                       cpyxchg = be_new_Copy(block, arg1);
                                        arch_set_irn_register(cpyxchg, cycle.elems[i + 1]);
 
                                        /* exchange copy node and proj */
@@ -516,7 +516,7 @@ static void gen_assure_different_pattern(ir_node *irn, ir_node *other_different,
 
        op_set = &env->op_set;
        block  = get_nodes_block(irn);
-       cls    = arch_get_irn_reg_class_out(other_different);
+       cls    = arch_get_irn_reg_class(other_different);
 
        /* Make a not spillable copy of the different node   */
        /* this is needed because the different irn could be */
@@ -526,8 +526,8 @@ static void gen_assure_different_pattern(ir_node *irn, ir_node *other_different,
        /* check if already exists such a copy in the schedule immediately before */
        cpy = find_copy(skip_Proj(irn), other_different);
        if (! cpy) {
-               cpy = be_new_Copy(cls, block, other_different);
-               arch_irn_set_flags(cpy, arch_irn_flags_dont_spill);
+               cpy = be_new_Copy(block, other_different);
+               arch_set_irn_flags(cpy, arch_irn_flags_dont_spill);
                DB((dbg_constr, LEVEL_1, "created non-spillable %+F for value %+F\n", cpy, other_different));
        } else {
                DB((dbg_constr, LEVEL_1, "using already existing %+F for value %+F\n", cpy, other_different));
@@ -536,7 +536,7 @@ static void gen_assure_different_pattern(ir_node *irn, ir_node *other_different,
        /* Add the Keep resp. CopyKeep and reroute the users */
        /* of the other_different irn in case of CopyKeep.   */
        if (has_irn_users(other_different)) {
-               keep = be_new_CopyKeep_single(cls, block, cpy, irn, get_irn_mode(other_different));
+               keep = be_new_CopyKeep_single(block, cpy, irn);
                be_node_set_reg_class_in(keep, 1, cls);
        } else {
                ir_node *in[2];
@@ -554,7 +554,7 @@ static void gen_assure_different_pattern(ir_node *irn, ir_node *other_different,
                sched_add_before(skip_Proj(irn), cpy);
        sched_add_after(skip_Proj(irn), keep);
 
-       /* insert the other different and it's copies into the map */
+       /* insert the other different and its copies into the map */
        entry = (op_copy_assoc_t*)ir_nodemap_get(op_set, other_different);
        if (! entry) {
                entry      = OALLOC(&env->obst, op_copy_assoc_t);
@@ -582,7 +582,7 @@ static void gen_assure_different_pattern(ir_node *irn, ir_node *other_different,
  */
 static void assure_different_constraints(ir_node *irn, ir_node *skipped_irn, constraint_env_t *env)
 {
-       const arch_register_req_t *req = arch_get_register_req_out(irn);
+       const arch_register_req_t *req = arch_get_irn_register_req(irn);
 
        if (arch_register_req_is(req, must_be_different)) {
                const unsigned other = req->other_different;
@@ -733,10 +733,10 @@ static void melt_copykeeps(constraint_env_t *cenv)
                                }
 
 #ifdef KEEP_ALIVE_COPYKEEP_HACK
-                               new_ck = be_new_CopyKeep(entry->cls, get_nodes_block(ref), be_get_CopyKeep_op(ref), n_melt, new_ck_in, mode_ANY);
+                               new_ck = be_new_CopyKeep(get_nodes_block(ref), be_get_CopyKeep_op(ref), n_melt, new_ck_in);
                                keep_alive(new_ck);
 #else
-                               new_ck = be_new_CopyKeep(entry->cls, get_nodes_block(ref), be_get_CopyKeep_op(ref), n_melt, new_ck_in, get_irn_mode(ref));
+                               new_ck = be_new_CopyKeep(get_nodes_block(ref), be_get_CopyKeep_op(ref), n_melt, new_ck_in);
 #endif /* KEEP_ALIVE_COPYKEEP_HACK */
 
                                /* set register class for all kept inputs */
@@ -786,7 +786,7 @@ void assure_constraints(ir_graph *irg)
        /* for all */
        foreach_ir_nodemap(&cenv.op_set, map_entry, map_iter) {
                op_copy_assoc_t          *entry = (op_copy_assoc_t*)map_entry.data;
-               int                       n     = ir_nodeset_size(&entry->copies);
+               size_t                    n     = ir_nodeset_size(&entry->copies);
                ir_node                 **nodes = ALLOCAN(ir_node*, n);
                ir_node                  *cp;
                ir_nodeset_iterator_t     iter;
@@ -804,7 +804,7 @@ void assure_constraints(ir_graph *irg)
 
                DB((dbg_constr, LEVEL_1, "\n"));
 
-               /* introduce the copies for the operand and it's copies */
+               /* introduce the copies for the operand and its copies */
                be_ssa_construction_init(&senv, irg);
                be_ssa_construction_add_copy(&senv, map_entry.node);
                be_ssa_construction_add_copies(&senv, nodes, n);
@@ -867,7 +867,7 @@ static int push_through_perm(ir_node *perm)
        /* get some Proj and find out the register class of that Proj. */
        const ir_edge_t             *edge     = get_irn_out_edge_first_kind(perm, EDGE_KIND_NORMAL);
        ir_node                     *one_proj = get_edge_src_irn(edge);
-       const arch_register_class_t *cls      = arch_get_irn_reg_class_out(one_proj);
+       const arch_register_class_t *cls      = arch_get_irn_reg_class(one_proj);
        assert(is_Proj(one_proj));
 
        DB((dbg_permmove, LEVEL_1, "perm move %+F irg %+F\n", perm, irg));
@@ -900,7 +900,7 @@ found_front:
        while (!sched_is_begin(node)) {
                const arch_register_req_t *req;
                int                        input = -1;
-               ir_node                   *proj;
+               ir_node                   *proj  = NULL;
 
                /* search if node is a INPUT of Perm */
                foreach_out_edge(perm, edge) {
@@ -920,7 +920,7 @@ found_front:
                        break;
                if (arch_irn_is(node, modify_flags))
                        break;
-               req = arch_get_register_req_out(node);
+               req = arch_get_irn_register_req(node);
                if (req->type != arch_register_req_type_normal)
                        break;
                for (i = get_irn_arity(node) - 1; i >= 0; --i) {