Jitters: use loc_key instead of names or offset for basic block labeling

8 files changed, 27 insertions, 57 deletions

diff --git a/miasm2/arch/mips32/jit.py b/miasm2/arch/mips32/jit.py
index dad70de8..c637fb13 100644
--- a/miasm2/arch/mips32/jit.py
+++ b/miasm2/arch/mips32/jit.py
@@ -71,7 +71,7 @@ class mipsCGen(CGen):
 
         loc_key = self.get_block_post_label(block)
         offset = self.ir_arch.symbol_pool.loc_key_to_offset(loc_key)
-        out = (self.CODE_RETURN_NO_EXCEPTION % (self.loc_key_to_jitlabel(loc_key),
+        out = (self.CODE_RETURN_NO_EXCEPTION % (loc_key,
                                                 self.C_PC,
                                                 m2_expr.ExprId('branch_dst_irdst', 32),
                                                 m2_expr.ExprId('branch_dst_irdst', 32),
diff --git a/miasm2/ir/translators/C.py b/miasm2/ir/translators/C.py
index 2f354d47..b7821e85 100644
--- a/miasm2/ir/translators/C.py
+++ b/miasm2/ir/translators/C.py
@@ -56,10 +56,9 @@ class TranslatorC(Translator):
             return str(loc_key)
 
         offset = self.symbol_pool.loc_key_to_offset(loc_key)
-        name = self.symbol_pool.loc_key_to_name(loc_key)
-
         if offset is None:
-            return name
+            return str(loc_key)
+
         return "0x%x" % offset
 
     def from_ExprAff(self, expr):
diff --git a/miasm2/jitter/codegen.py b/miasm2/jitter/codegen.py
index 92af3259..c9e98d93 100644
--- a/miasm2/jitter/codegen.py
+++ b/miasm2/jitter/codegen.py
@@ -113,12 +113,6 @@ class CGen(object):
 
         self.C_PC = self.id_to_c(self.PC)
 
-    def loc_key_to_jitlabel(self, lbl):
-        """Convert LocKey to a jitter label name"""
-        offset = self.ir_arch.symbol_pool.loc_key_to_offset(lbl)
-        assert offset is not None
-        return "jitblock_%X" % offset
-
     def dst_to_c(self, src):
         """Translate Expr @src into C code"""
         if not isinstance(src, Expr):
@@ -241,7 +235,7 @@ class CGen(object):
 
         for dst, src in sorted(assignblk.iteritems()):
             src = src.replace_expr(prefetchers)
-            if dst is self.ir_arch.IRDst:
+            if dst == self.ir_arch.IRDst:
                 pass
             elif isinstance(dst, ExprId):
                 new_dst = self.add_local_var(dst_var, dst_index, dst)
@@ -263,7 +257,7 @@ class CGen(object):
                 raise ValueError("Unknown dst")
 
         for dst, new_dst in dst_var.iteritems():
-            if dst is self.ir_arch.IRDst:
+            if dst == self.ir_arch.IRDst:
                 continue
             c_updt.append('%s = %s;' % (self.id_to_c(dst), self.id_to_c(new_dst)))
             c_var.append("uint%d_t %s;" % (new_dst.size, new_dst))
@@ -376,15 +370,14 @@ class CGen(object):
         offset = self.ir_arch.symbol_pool.loc_key_to_offset(dst)
         if offset is None:
             # Generate goto for local labels
-            name = self.ir_arch.symbol_pool.loc_key_to_name(dst)
-            return ['goto %s;' % name]
+            return ['goto %s;' % dst]
         if (offset > attrib.instr.offset and
             offset in instr_offsets):
             # Only generate goto for next instructions.
             # (consecutive instructions)
             out += self.gen_post_code(attrib)
             out += self.gen_post_instr_checks(attrib)
-            out.append('goto %s;' % self.loc_key_to_jitlabel(dst))
+            out.append('goto %s;' % dst)
         else:
             out += self.gen_post_code(attrib)
             out.append('BlockDst->address = DST_value;')
@@ -537,8 +530,8 @@ class CGen(object):
         post_label = self.get_block_post_label(block)
         post_offset = self.ir_arch.symbol_pool.loc_key_to_offset(post_label)
         instr_offsets.append(post_offset)
-        lbl_start = self.ir_arch.symbol_pool.getby_offset_create(instr_offsets[0])
-        return (self.CODE_INIT % self.loc_key_to_jitlabel(lbl_start)).split("\n"), instr_offsets
+        lbl_start = block.loc_key
+        return (self.CODE_INIT % lbl_start).split("\n"), instr_offsets
 
     def gen_irblock(self, instr_attrib, attributes, instr_offsets, irblock):
         """
@@ -570,10 +563,10 @@ class CGen(object):
         Generate the C code for the final block instruction
         """
 
-        lbl = self.get_block_post_label(block)
-        offset = self.ir_arch.symbol_pool.loc_key_to_offset(lbl)
+        loc_key = self.get_block_post_label(block)
+        offset = self.ir_arch.symbol_pool.loc_key_to_offset(loc_key)
         dst = self.dst_to_c(offset)
-        code = self.CODE_RETURN_NO_EXCEPTION % (self.loc_key_to_jitlabel(lbl), self.C_PC, dst, dst)
+        code = self.CODE_RETURN_NO_EXCEPTION % (loc_key, self.C_PC, dst, dst)
         return code.split('\n')
 
     def gen_c(self, block, log_mn=False, log_regs=False):
@@ -592,15 +585,9 @@ class CGen(object):
             instr_attrib, irblocks_attributes = self.get_attributes(instr, irblocks, log_mn, log_regs)
             for index, irblock in enumerate(irblocks):
                 new_irblock = self.ir_arch.irbloc_fix_regs_for_mode(irblock, self.ir_arch.attrib)
-                label = new_irblock.loc_key
-                offset = self.ir_arch.symbol_pool.loc_key_to_offset(label)
-                if offset is None:
-                    name = self.ir_arch.symbol_pool.loc_key_to_name(label)
-                    out.append("%-40s // %.16X %s" %
-                               (str(name) + ":", instr.offset, instr))
-                else:
-                    out.append("%-40s // %.16X %s" %
-                               (self.loc_key_to_jitlabel(label) + ":", instr.offset, instr))
+                label = str(new_irblock.loc_key)
+                out.append("%-40s // %.16X %s" %
+                           (label + ":", instr.offset, instr))
                 if index == 0:
                     out += self.gen_pre_code(instr_attrib)
                 out += self.gen_irblock(instr_attrib, irblocks_attributes[index], instr_offsets, new_irblock)
diff --git a/miasm2/jitter/jitcore.py b/miasm2/jitter/jitcore.py
index 9d36bb97..495e8dd3 100644
--- a/miasm2/jitter/jitcore.py
+++ b/miasm2/jitter/jitcore.py
@@ -29,6 +29,9 @@ class JitCore(object):
 
     "JiT management. This is an abstract class"
 
+    # Jitted function's name
+    FUNCNAME = "block_entry"
+
     jitted_block_delete_cb = None
     jitted_block_max_size = 10000
 
diff --git a/miasm2/jitter/jitcore_cc_base.py b/miasm2/jitter/jitcore_cc_base.py
index f0a75cf4..e7c151ea 100644
--- a/miasm2/jitter/jitcore_cc_base.py
+++ b/miasm2/jitter/jitcore_cc_base.py
@@ -85,21 +85,12 @@ class JitCore_Cc_Base(JitCore):
         """
         self.codegen = codegen
 
-    def loc_key_to_filename(self, loc_key):
-        """
-        Generate function name from @loc_key
-        @loc_key: LocKey instance
-        """
-        return "block_%s" % self.codegen.loc_key_to_jitlabel(loc_key)
-
-    def gen_c_code(self, loc_key, block):
+    def gen_c_code(self, block):
         """
         Return the C code corresponding to the @irblocks
-        @loc_key: LocKey of the block to jit
         @irblocks: list of irblocks
         """
-        f_name = self.loc_key_to_filename(loc_key)
-        f_declaration = 'int %s(block_id * BlockDst, JitCpu* jitcpu)' % f_name
+        f_declaration = 'int %s(block_id * BlockDst, JitCpu* jitcpu)' % self.FUNCNAME
         out = self.codegen.gen_c(block, log_mn=self.log_mn, log_regs=self.log_regs)
         out = [f_declaration + '{'] + out + ['}\n']
         c_code = out
diff --git a/miasm2/jitter/jitcore_gcc.py b/miasm2/jitter/jitcore_gcc.py
index d9da3160..308998bc 100644
--- a/miasm2/jitter/jitcore_gcc.py
+++ b/miasm2/jitter/jitcore_gcc.py
@@ -25,9 +25,8 @@ class JitCore_Gcc(JitCore_Cc_Base):
         del self.states[offset]
 
     def load_code(self, label, fname_so):
-        f_name = self.loc_key_to_filename(label)
         lib = ctypes.cdll.LoadLibrary(fname_so)
-        func = getattr(lib, f_name)
+        func = getattr(lib, self.FUNCNAME)
         addr = ctypes.cast(func, ctypes.c_void_p).value
         offset = self.ir_arch.symbol_pool.loc_key_to_offset(label)
         self.loc_key_to_jit_block[offset] = addr
@@ -41,7 +40,7 @@ class JitCore_Gcc(JitCore_Cc_Base):
         fname_out = os.path.join(self.tempdir, "%s.so" % block_hash)
 
         if not os.access(fname_out, os.R_OK | os.X_OK):
-            func_code = self.gen_c_code(block.loc_key, block)
+            func_code = self.gen_c_code(block)
 
             # Create unique C file
             fdesc, fname_in = tempfile.mkstemp(suffix=".c")
diff --git a/miasm2/jitter/jitcore_llvm.py b/miasm2/jitter/jitcore_llvm.py
index 5152cf9e..9b0baae5 100644
--- a/miasm2/jitter/jitcore_llvm.py
+++ b/miasm2/jitter/jitcore_llvm.py
@@ -8,7 +8,6 @@ import Jitllvm
 
 
 class JitCore_LLVM(jitcore.JitCore):
-
     "JiT management, using LLVM as backend"
 
     # Architecture dependant libraries
@@ -84,7 +83,7 @@ class JitCore_LLVM(jitcore.JitCore):
 
         if not os.access(fname_out, os.R_OK):
             # Build a function in the context
-            func = LLVMFunction(self.context, block.loc_key)
+            func = LLVMFunction(self.context, self.FUNCNAME)
 
             # Set log level
             func.log_regs = self.log_regs
@@ -115,7 +114,7 @@ class JitCore_LLVM(jitcore.JitCore):
 
         else:
             # The cache file exists: function can be loaded from cache
-            ptr = self.context.get_ptr_from_cache(fname_out, block.loc_key)
+            ptr = self.context.get_ptr_from_cache(fname_out, self.FUNCNAME)
 
         # Store a pointer on the function jitted code
         loc_key = block.loc_key
diff --git a/miasm2/jitter/llvmconvert.py b/miasm2/jitter/llvmconvert.py
index 2045f083..16b08cf1 100644
--- a/miasm2/jitter/llvmconvert.py
+++ b/miasm2/jitter/llvmconvert.py
@@ -75,16 +75,10 @@ class LLVMContext():
         @label: str or asmlabel instance"""
         if isinstance(label, str):
             return label
-        if not isinstance(label, LocKey):
-            raise ValueError("label must either be str or LocKey")
-
-        offset = self.ir_arch.symbol_pool.loc_key_to_offset(label)
-
-        if offset is None:
-            name = self.ir_arch.symbol_pool.loc_key_to_name(label)
-            return "%s" % name
+        elif isinstance(label, LocKey):
+            return str(label)
         else:
-            return "label_off_%X" % offset
+            raise ValueError("label must either be str or LocKey")
 
     def optimise_level(self, level=2):
         """Set the optimisation level to @level from 0 to 2
@@ -341,7 +335,6 @@ class LLVMContext_JIT(LLVMContext):
     def get_ptr_from_cache(self, file_name, func_name):
         "Load @file_name and return a pointer on the jitter @func_name"
         # We use an empty module to avoid loosing time on function building
-        func_name = self.canonize_label_name(func_name)
         empty_module = llvm.parse_assembly("")
         empty_module.fname_out = file_name
 
@@ -398,7 +391,6 @@ class LLVMFunction():
     def __init__(self, llvm_context, name="fc", new_module=True):
         "Create a new function with name @name"
         self.llvm_context = llvm_context
-        name = self.llvm_context.canonize_label_name(name)
         if new_module:
             self.llvm_context.new_module()
         self.mod = self.llvm_context.get_module()