simply use long long

[libfirm] / ir / be / arm / arm_emitter.c

diff --git a/ir/be/arm/arm_emitter.c b/ir/be/arm/arm_emitter.c
index dc7e632..7d1c215 100644 (file)
--- a/ir/be/arm/arm_emitter.c
+++ b/ir/be/arm/arm_emitter.c
@@ -42,11 +42,11 @@
 #include "raw_bitset.h"
 #include "dbginfo.h"
 
-#include "../besched.h"
-#include "../beblocksched.h"
-#include "../beirg.h"
-#include "../begnuas.h"
-#include "../be_dbgout.h"
+#include "besched.h"
+#include "beblocksched.h"
+#include "beirg.h"
+#include "begnuas.h"
+#include "be_dbgout.h"
 
 #include "arm_emitter.h"
 #include "arm_optimize.h"
@@ -56,7 +56,7 @@
 #include "arm_map_regs.h"
 #include "gen_arm_regalloc_if.h"
 
-#include "../benode.h"
+#include "benode.h"
 
 #define SNPRINTF_BUF_LEN 128
 
@@ -65,75 +65,6 @@ DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
 static set       *sym_or_tv;
 static arm_isa_t *isa;
 
-/**
- * Returns the register at in position pos.
- */
-static const arch_register_t *get_in_reg(const ir_node *irn, int pos)
-{
-       ir_node                *op;
-       const arch_register_t  *reg = NULL;
-
-       assert(get_irn_arity(irn) > pos && "Invalid IN position");
-
-       /* The out register of the operator at position pos is the
-          in register we need. */
-       op = get_irn_n(irn, pos);
-
-       reg = arch_get_irn_register(op);
-
-       assert(reg && "no in register found");
-
-       /* in case of a joker register: just return a valid register */
-       if (reg->type & arch_register_type_joker) {
-               const arch_register_req_t *req = arch_get_register_req(irn, pos);
-
-               if (arch_register_req_is(req, limited)) {
-                       /* in case of limited requirements: get the first allowed register */
-                       unsigned idx = rbitset_next(req->limited, 0, 1);
-                       reg = arch_register_for_index(req->cls, idx);
-               } else {
-                       /* otherwise get first register in class */
-                       reg = arch_register_for_index(req->cls, 0);
-               }
-       }
-       return reg;
-}
-
-
-/**
- * Returns the register at out position pos.
- */
-static const arch_register_t *get_out_reg(const ir_node *node, int pos)
-{
-    ir_node                *proj;
-    const arch_register_t  *reg = NULL;
-
-    /* 1st case: irn is not of mode_T, so it has only                 */
-    /*           one OUT register -> good                             */
-    /* 2nd case: irn is of mode_T -> collect all Projs and ask the    */
-    /*           Proj with the corresponding projnum for the register */
-
-    if (get_irn_mode(node) != mode_T) {
-        reg = arch_get_irn_register(node);
-    } else if (is_arm_irn(node)) {
-        reg = arch_irn_get_register(node, pos);
-    } else {
-        const ir_edge_t *edge;
-
-        foreach_out_edge(node, edge) {
-            proj = get_edge_src_irn(edge);
-            assert(is_Proj(proj) && "non-Proj from mode_T node");
-            if (get_Proj_proj(proj) == pos) {
-                reg = arch_get_irn_register(proj);
-                break;
-            }
-        }
-    }
-
-    assert(reg && "no out register found");
-    return reg;
-}
-
 static void arm_emit_register(const arch_register_t *reg)
 {
        be_emit_string(arch_register_get_name(reg));
@@ -141,13 +72,13 @@ static void arm_emit_register(const arch_register_t *reg)
 
 void arm_emit_source_register(const ir_node *node, int pos)
 {
-       const arch_register_t *reg = get_in_reg(node, pos);
+       const arch_register_t *reg = arch_get_irn_register_in(node, pos);
        arm_emit_register(reg);
 }
 
 void arm_emit_dest_register(const ir_node *node, int pos)
 {
-       const arch_register_t *reg = get_out_reg(node, pos);
+       const arch_register_t *reg = arch_get_irn_register_out(node, pos);
        arm_emit_register(reg);
 }
 
@@ -510,16 +441,16 @@ static void emit_arm_CopyB(const ir_node *irn)
        const arm_CopyB_attr_t *attr = get_arm_CopyB_attr_const(irn);
        unsigned size = attr->size;
 
-       const char *tgt = arch_register_get_name(get_in_reg(irn, 0));
-       const char *src = arch_register_get_name(get_in_reg(irn, 1));
+       const char *tgt = arch_register_get_name(arch_get_irn_register_in(irn, 0));
+       const char *src = arch_register_get_name(arch_get_irn_register_in(irn, 1));
        const char *t0, *t1, *t2, *t3;
 
        const arch_register_t *tmpregs[4];
 
        /* collect the temporary registers and sort them, we need ascending order */
-       tmpregs[0] = get_in_reg(irn, 2);
-       tmpregs[1] = get_in_reg(irn, 3);
-       tmpregs[2] = get_in_reg(irn, 4);
+       tmpregs[0] = arch_get_irn_register_in(irn, 2);
+       tmpregs[1] = arch_get_irn_register_in(irn, 3);
+       tmpregs[2] = arch_get_irn_register_in(irn, 4);
        tmpregs[3] = &arm_registers[REG_R12];
 
        /* Note: R12 is always the last register because the RA did not assign higher ones */
@@ -751,7 +682,7 @@ static void emit_be_Copy(const ir_node *irn)
 {
        ir_mode *mode = get_irn_mode(irn);
 
-       if (get_in_reg(irn, 0) == get_out_reg(irn, 0)) {
+       if (arch_get_irn_register_in(irn, 0) == arch_get_irn_register_out(irn, 0)) {
                /* omitted Copy */
                return;
        }