Remove unused code, regroup similar function by category

1 files changed, 169 insertions, 398 deletions

diff --git a/miasm2/jitter/llvmconvert.py b/miasm2/jitter/llvmconvert.py
index 187562b8..415df0e5 100644
--- a/miasm2/jitter/llvmconvert.py
+++ b/miasm2/jitter/llvmconvert.py
@@ -267,12 +267,6 @@ class LLVMContext_JIT(LLVMContext):
 
         self.vmcpu = lookup_table
 
-    def set_IR_transformation(self, *args):
-        """Set a list of transformation to apply on expression before their
-        treatments.
-        args: function Expr(Expr)"""
-        self.IR_transformation_functions = args
-
     def memory_lookup(self, func, addr, size):
         """Perform a memory lookup at @addr of size @size (in bit)"""
         builder = func.builder
@@ -318,6 +312,7 @@ class LLVMContext_IRCompilation(LLVMContext):
                                       llvm_ir.PointerType(int_size))
         return builder.store(value, ptr_casted)
 
+
 class LLVMFunction():
     """Represent a LLVM function
 
@@ -362,15 +357,13 @@ class LLVMFunction():
         self.name = name
         self._llvm_mod = None
 
+    # Constructor utils
+
     def new_branch_name(self):
         "Return a new branch name"
         self.branch_counter += 1
         return str(self.branch_counter)
 
-    def viewCFG(self):
-        "Show the CFG of the current function"
-        self.fc.viewCFG()
-
     def append_basic_block(self, label, overwrite=True):
         """Add a new basic block to the current function.
         @label: str or asmlabel
@@ -385,6 +378,160 @@ class LLVMFunction():
 
         return bbl
 
+    def CreateEntryBlockAlloca(self, var_type, default_value=None):
+        """Create an alloca instruction at the beginning of the current fc
+        @default_value: if set, store the default_value just after the allocation
+        """
+        builder = self.builder
+        current_bbl = builder.basic_block
+        builder.position_at_start(self.entry_bbl)
+
+        ret = builder.alloca(var_type)
+        if default_value is not None:
+            builder.store(default_value, ret)
+        builder.position_at_end(current_bbl)
+        return ret
+
+    def get_ptr_by_expr(self, expr):
+        """"Return a pointer casted corresponding to ExprId expr. If it is not
+        already computed, compute it at the end of entry_bloc"""
+
+        name = expr.name
+
+        ptr_casted = self.local_vars_pointers.get(name, None)
+        if ptr_casted is not None:
+            # If the pointer has already been computed
+            return ptr_casted
+
+        # Get current objects
+        builder = self.builder
+        current_bbl = builder.basic_block
+
+        # Go at the right position
+        entry_bloc_bbl = self.entry_bbl
+        builder.position_at_end(entry_bloc_bbl)
+
+        # Compute the pointer address
+        offset = self.llvm_context.vmcpu[name]
+
+        # Pointer cast
+        ptr = builder.gep(self.local_vars["vmcpu"],
+                          [llvm_ir.Constant(LLVMType.IntType(),
+                                            offset)])
+        int_size = LLVMType.IntType(expr.size)
+        ptr_casted = builder.bitcast(ptr,
+                                     llvm_ir.PointerType(int_size))
+        # Store in cache
+        self.local_vars_pointers[name] = ptr_casted
+
+        # Reset builder
+        builder.position_at_end(current_bbl)
+
+        return ptr_casted
+
+    def update_cache(self, name, value):
+        "Add 'name' = 'value' to the cache iff main_stream = True"
+
+        if self.main_stream is True:
+            self.expr_cache[name] = value
+
+    def set_ret(self, var):
+        "Cast @var and return it at the end of current bbl"
+        if var.type.width < 64:
+            var_casted = self.builder.zext(var, LLVMType.IntType(64))
+        else:
+            var_casted = var
+        self.builder.ret(var_casted)
+
+    def canonize_label_name(self, label):
+        """Canonize @label names to a common form.
+        @label: str or asmlabel instance"""
+        if isinstance(label, str):
+            return label
+        elif isinstance(label, m2_asmbloc.asm_label):
+            return "label_%s" % label.name
+        elif m2_asmbloc.expr_is_label(label):
+            return "label_%s" % label.name.name
+        else:
+            raise ValueError("label must either be str or asmlabel")
+
+    def get_basic_bloc_by_label(self, label):
+        "Return the bbl corresponding to label, None otherwise"
+        return self.name2bbl.get(self.canonize_label_name(label), None)
+
+    def global_constant(self, name, value):
+        """
+        Inspired from numba/cgutils.py
+
+        Get or create a (LLVM module-)global constant with *name* or *value*.
+        """
+        module = self.mod
+        data = llvm_ir.GlobalVariable(self.mod, value.type, name=name)
+        data.global_constant = True
+        data.initializer = value
+        return data
+
+    def make_bytearray(self, buf):
+        """
+        Inspired from numba/cgutils.py
+
+        Make a byte array constant from *buf*.
+        """
+        b = bytearray(buf)
+        n = len(b)
+        return llvm_ir.Constant(llvm_ir.ArrayType(llvm_ir.IntType(8), n), b)
+
+    def printf(self, format, *args):
+        """
+        Inspired from numba/cgutils.py
+
+        Calls printf().
+        Argument `format` is expected to be a Python string.
+        Values to be printed are listed in `args`.
+
+        Note: There is no checking to ensure there is correct number of values
+        in `args` and there type matches the declaration in the format string.
+        """
+        assert isinstance(format, str)
+        mod = self.mod
+        # Make global constant for format string
+        cstring = llvm_ir.IntType(8).as_pointer()
+        fmt_bytes = self.make_bytearray((format + '\00').encode('ascii'))
+
+        base_name = "printf_format"
+        count = 0
+        while self.mod.get_global("%s_%d" % (base_name, count)):
+            count += 1
+        global_fmt = self.global_constant("%s_%d" % (base_name, count),
+                                          fmt_bytes)
+        fnty = llvm_ir.FunctionType(llvm_ir.IntType(32), [cstring],
+                                    var_arg=True)
+        # Insert printf()
+        fn = mod.get_global('printf')
+        if fn is None:
+            fn = llvm_ir.Function(mod, fnty, name="printf")
+        # Call
+        ptr_fmt = self.builder.bitcast(global_fmt, cstring)
+        return self.builder.call(fn, [ptr_fmt] + list(args))
+
+    # Effective constructors
+
+    def affect(self, src, dst):
+        "Affect from LLVM src to M2 dst"
+
+        # Destination
+        builder = self.builder
+
+        if isinstance(dst, m2_expr.ExprId):
+            ptr_casted = self.get_ptr_by_expr(dst)
+            builder.store(src, ptr_casted)
+
+        elif isinstance(dst, m2_expr.ExprMem):
+            addr = self.add_ir(dst.arg)
+            self.llvm_context.memory_write(self, addr, dst.size, src)
+        else:
+            raise Exception("UnknownAffectationType")
+
     def init_fc(self):
         "Init the function"
 
@@ -414,7 +561,6 @@ class LLVMFunction():
         self.expr_cache = {}
         self.main_stream = True
         self.name2bbl = {}
-        self.offsets_jitted = set()
 
         # Function link
         self.fc = fc
@@ -425,72 +571,6 @@ class LLVMFunction():
         # Instruction builder
         self.builder = llvm_ir.IRBuilder(self.entry_bbl)
 
-    def CreateEntryBlockAlloca(self, var_type, default_value=None):
-        """Create an alloca instruction at the beginning of the current fc
-        @default_value: if set, store the default_value just after the allocation
-        """
-        builder = self.builder
-        current_bbl = builder.basic_block
-        builder.position_at_start(self.entry_bbl)
-
-        ret = builder.alloca(var_type)
-        if default_value is not None:
-            builder.store(default_value, ret)
-        builder.position_at_end(current_bbl)
-        return ret
-
-    def get_ptr_by_expr(self, expr):
-        """"Return a pointer casted corresponding to ExprId expr. If it is not
-        already computed, compute it at the end of entry_bloc"""
-
-        name = expr.name
-
-        try:
-            # If the pointer has already been computed
-            ptr_casted = self.local_vars_pointers[name]
-
-        except KeyError:
-            # Get current objects
-            builder = self.builder
-            current_bbl = builder.basic_block
-
-            # Go at the right position
-            entry_bloc_bbl = self.entry_bbl
-            builder.position_at_end(entry_bloc_bbl)
-
-            # Compute the pointer address
-            offset = self.llvm_context.vmcpu[name]
-
-            # Pointer cast
-            ptr = builder.gep(self.local_vars["vmcpu"],
-                              [llvm_ir.Constant(LLVMType.IntType(),
-                                                offset)])
-            int_size = LLVMType.IntType(expr.size)
-            ptr_casted = builder.bitcast(ptr,
-                                         llvm_ir.PointerType(int_size))
-            # Store in cache
-            self.local_vars_pointers[name] = ptr_casted
-
-            # Reset builder
-            builder.position_at_end(current_bbl)
-
-        return ptr_casted
-
-    def clear_cache(self, regs_updated):
-        "Remove from the cache values which depends on regs_updated"
-
-        regs_updated_set = set(regs_updated)
-
-        for expr in self.expr_cache.keys():
-            if expr.get_r(True).isdisjoint(regs_updated_set) is not True:
-                self.expr_cache.pop(expr)
-
-    def update_cache(self, name, value):
-        "Add 'name' = 'value' to the cache iff main_stream = True"
-
-        if self.main_stream is True:
-            self.expr_cache[name] = value
-
     def add_ir(self, expr):
         "Add a Miasm2 IR to the last bbl. Return the var created"
 
@@ -752,47 +832,7 @@ class LLVMFunction():
 
         raise Exception("UnkownExpression", expr.__class__.__name__)
 
-    def set_ret(self, var):
-        "Cast @var and return it at the end of current bbl"
-        if var.type.width < 64:
-            var_casted = self.builder.zext(var, LLVMType.IntType(64))
-        else:
-            var_casted = var
-        self.builder.ret(var_casted)
-
-    def from_expr(self, expr):
-        "Build the function from an expression"
-
-        # Build function signature
-        args = expr.get_r(True)
-        for a in args:
-            if not isinstance(a, m2_expr.ExprMem):
-                self.my_args.append((a, LLVMType.IntType(a.size), a.name))
-
-        self.ret_type = LLVMType.IntType(expr.size)
-
-        # Initialise the function
-        self.init_fc()
-
-        ret = self.add_ir(expr)
-
-        self.set_ret(ret)
-
-    def affect(self, src, dst):
-        "Affect from LLVM src to M2 dst"
-
-        # Destination
-        builder = self.builder
-
-        if isinstance(dst, m2_expr.ExprId):
-            ptr_casted = self.get_ptr_by_expr(dst)
-            builder.store(src, ptr_casted)
-
-        elif isinstance(dst, m2_expr.ExprMem):
-            addr = self.add_ir(dst.arg)
-            self.llvm_context.memory_write(self, addr, dst.size, src)
-        else:
-            raise Exception("UnknownAffectationType")
+    # JiT specifics
 
     def check_memory_exception(self, offset, restricted_exception=False):
         """Add a check for memory errors.
@@ -892,240 +932,6 @@ class LLVMFunction():
         # Reactivate object caching
         self.main_stream = current_main_stream
 
-    def add_bloc(self, bloc, lines):
-        "Add a bloc of instruction in the current function"
-
-        for assignblk, line in zip(bloc, lines):
-            new_reg = {}
-
-            # Check general errors only at the beggining of instruction
-            if line.offset not in self.offsets_jitted:
-                self.offsets_jitted.add(line.offset)
-                self.check_error(line)
-
-                # Log mn and registers if options is set
-                self.log_instruction(assignblk, line)
-
-
-            # Pass on empty instruction
-            if not assignblk:
-                continue
-
-            for dst, src in assignblk.iteritems():
-                # Apply preinit transformation
-                for func in self.llvm_context.IR_transformation_functions:
-                    dst = func(dst)
-                    src = func(src)
-
-                # Treat current expression
-                if isinstance(dst, m2_expr.ExprId):
-                    new_reg[dst] = self.add_ir(src)
-                else:
-                    assert isinstance(dst, m2_expr.ExprMem)
-                    # Source
-                    src = self.add_ir(src)
-                    self.affect(src, dst)
-
-            # Check for errors (without updating PC)
-            self.check_error(line, except_do_not_update_pc=True)
-
-            # new -> normal
-            for dst, src in new_reg.iteritems():
-                self.affect(src, dst)
-
-            # Clear cache
-            self.clear_cache(new_reg)
-            self.main_stream = True
-
-    def from_bloc(self, bloc, final_expr):
-        """Build the function from a bloc, with the dst equation.
-        Prototype : f(i8* jitcpu, i8* vmcpu, i8* vmmngr)"""
-
-        # Build function signature
-        self.my_args.append((m2_expr.ExprId("jitcpu"),
-                             llvm_ir.PointerType(LLVMType.IntType(8)),
-                             "jitcpu"))
-        self.my_args.append((m2_expr.ExprId("vmcpu"),
-                             llvm_ir.PointerType(LLVMType.IntType(8)),
-                             "vmcpu"))
-        self.my_args.append((m2_expr.ExprId("vmmngr"),
-                             llvm_ir.PointerType(LLVMType.IntType(8)),
-                             "vmmngr"))
-        self.ret_type = LLVMType.IntType(final_expr.size)
-
-        # Initialise the function
-        self.init_fc()
-
-        # Add content
-        self.add_bloc(bloc, [])
-
-        # Finalise the function
-        self.set_ret(self.add_ir(final_expr))
-
-        raise NotImplementedError("Not tested")
-
-    def canonize_label_name(self, label):
-        """Canonize @label names to a common form.
-        @label: str or asmlabel instance"""
-        if isinstance(label, str):
-            return label
-        elif isinstance(label, m2_asmbloc.asm_label):
-            return "label_%s" % label.name
-        elif m2_asmbloc.expr_is_label(label):
-            return "label_%s" % label.name.name
-        else:
-            raise ValueError("label must either be str or asmlabel")
-
-    def get_basic_bloc_by_label(self, label):
-        "Return the bbl corresponding to label, None otherwise"
-        return self.name2bbl.get(self.canonize_label_name(label), None)
-
-    def gen_ret_or_branch(self, dest):
-        """Manage the dest ExprId. If label, branch on it if it is known.
-        Otherwise, return the ExprId or the offset value"""
-
-        builder = self.builder
-
-        if isinstance(dest, m2_expr.ExprId):
-            dest_name = dest.name
-        elif isinstance(dest, m2_expr.ExprSlice) and \
-                isinstance(dest.arg, m2_expr.ExprId):
-            # Manage ExprId mask case
-            dest_name = dest.arg.name
-        else:
-            raise ValueError()
-
-        if not isinstance(dest_name, str):
-            label = dest_name
-            target_bbl = self.get_basic_bloc_by_label(label)
-            if target_bbl is None:
-                self.set_ret(self.add_ir(dest))
-            else:
-                builder.branch(target_bbl)
-        else:
-            self.set_ret(self.add_ir(dest))
-
-    def add_irbloc(self, irbloc):
-        "Add the content of irbloc at the corresponding labeled block"
-        builder = self.builder
-
-        bloc = irbloc.irs
-        dest = irbloc.dst
-        label = irbloc.label
-        lines = irbloc.lines
-
-        # Get labeled basic bloc
-        label_block = self.get_basic_bloc_by_label(label)
-        builder.position_at_end(label_block)
-
-        # Erase cache
-        self.expr_cache = {}
-
-        # Add the content of the bloc with corresponding lines
-        self.add_bloc(bloc, lines)
-
-        # Erase cache
-        self.expr_cache = {}
-
-        # Manage ret
-        for func in self.llvm_context.IR_transformation_functions:
-            dest = func(dest)
-
-        if isinstance(dest, m2_expr.ExprCond):
-            # Compute cond
-            cond = self.add_ir(dest.cond)
-            zero_casted = llvm_ir.Constant(LLVMType.IntType(dest.cond.size),
-                                           0)
-            condition_bool = builder.icmp_unsigned("!=", cond,
-                                                   zero_casted)
-
-            # Create bbls
-            branch_id = self.new_branch_name()
-            then_block = self.append_basic_block('then%s' % branch_id)
-            else_block = self.append_basic_block('else%s' % branch_id)
-
-            builder.cbranch(condition_bool, then_block, else_block)
-
-            # Then Bloc
-            builder.position_at_end(then_block)
-            self.gen_ret_or_branch(dest.src1)
-
-            # Else Bloc
-            builder.position_at_end(else_block)
-            self.gen_ret_or_branch(dest.src2)
-
-        elif isinstance(dest, m2_expr.ExprId):
-            self.gen_ret_or_branch(dest)
-
-        elif isinstance(dest, m2_expr.ExprSlice):
-            self.gen_ret_or_branch(dest)
-
-        elif isinstance(dest, m2_expr.ExprMem):
-            self.set_ret(self.add_ir(self.ir_arch.IRDst))
-
-        else:
-            raise Exception("Bloc dst has to be an ExprId or an ExprCond")
-
-    def canonize_instr_bbl(self, instr):
-        if isinstance(instr, (int, long)):
-            return "instr_%s" % hex(instr)
-        return "instr_%s" % hex(instr.offset)
-
-    def global_constant(self, name, value):
-        """
-        Inspired from numba/cgutils.py
-
-        Get or create a (LLVM module-)global constant with *name* or *value*.
-        """
-        module = self.mod
-        data = llvm_ir.GlobalVariable(self.mod, value.type, name=name)
-        data.global_constant = True
-        data.initializer = value
-        return data
-
-    def make_bytearray(self, buf):
-        """
-        Inspired from numba/cgutils.py
-
-        Make a byte array constant from *buf*.
-        """
-        b = bytearray(buf)
-        n = len(b)
-        return llvm_ir.Constant(llvm_ir.ArrayType(llvm_ir.IntType(8), n), b)
-
-    def printf(self, format, *args):
-        """
-        Inspired from numba/cgutils.py
-
-        Calls printf().
-        Argument `format` is expected to be a Python string.
-        Values to be printed are listed in `args`.
-
-        Note: There is no checking to ensure there is correct number of values
-        in `args` and there type matches the declaration in the format string.
-        """
-        assert isinstance(format, str)
-        mod = self.mod
-        # Make global constant for format string
-        cstring = llvm_ir.IntType(8).as_pointer()
-        fmt_bytes = self.make_bytearray((format + '\00').encode('ascii'))
-
-        base_name = "printf_format"
-        count = 0
-        while self.mod.get_global("%s_%d" % (base_name, count)):
-            count += 1
-        global_fmt = self.global_constant("%s_%d" % (base_name, count),
-                                          fmt_bytes)
-        fnty = llvm_ir.FunctionType(llvm_ir.IntType(32), [cstring],
-                                    var_arg=True)
-        # Insert printf()
-        fn = mod.get_global('printf')
-        if fn is None:
-            fn = llvm_ir.Function(mod, fnty, name="printf")
-        # Call
-        ptr_fmt = self.builder.bitcast(global_fmt, cstring)
-        return self.builder.call(fn, [ptr_fmt] + list(args))
-
     def gen_pre_code(self, attributes):
         if attributes.log_mn:
             self.printf("%.8X %s\n" % (attributes.instr.offset,
@@ -1446,49 +1252,23 @@ class LLVMFunction():
         first_label_bbl = self.get_basic_bloc_by_label(asmblock.label)
         builder.branch(first_label_bbl)
 
-    def from_blocs(self, blocs):
-        """Build the function from a list of bloc (irbloc instances).
-        Prototype : f(i8* jitcpu, i8* vmcpu, i8* vmmngr)"""
 
-        # Build function signature
-        self.my_args.append((m2_expr.ExprId("jitcpu"),
-                             llvm_ir.PointerType(LLVMType.IntType(8)),
-                             "jitcpu"))
-        self.my_args.append((m2_expr.ExprId("vmcpu"),
-                             llvm_ir.PointerType(LLVMType.IntType(8)),
-                             "vmcpu"))
-        self.my_args.append((m2_expr.ExprId("vmmngr"),
-                             llvm_ir.PointerType(LLVMType.IntType(8)),
-                             "vmmngr"))
-        ret_size = 64
-
-        self.ret_type = LLVMType.IntType(ret_size)
-
-        # Initialise the function
-        self.init_fc()
-
-        # Create basic blocks (for label branchs)
-        entry_bbl, builder = self.entry_bbl, self.builder
-
-        for irbloc in blocs:
-            name = self.canonize_label_name(irbloc.label)
-            self.append_basic_block(name)
-
-        # Add content
-        builder.position_at_end(entry_bbl)
-
-        for irbloc in blocs:
-            self.add_irbloc(irbloc)
-
-        # Branch entry_bbl on first label
-        builder.position_at_end(entry_bbl)
-        first_label_bbl = self.get_basic_bloc_by_label(blocs[0].label)
-        builder.branch(first_label_bbl)
+    # LLVMFunction manipulation
 
     def __str__(self):
         "Print the llvm IR corresponding to the current module"
         return str(self.mod)
 
+    def dot(self):
+        "Return the CFG of the current function"
+        return llvm.get_function_cfg(self.fc)
+
+    def as_llvm_mod(self):
+        """Return a ModuleRef standing for the current function"""
+        if self._llvm_mod is None:
+            self._llvm_mod = llvm.parse_assembly(str(self.mod))
+        return self._llvm_mod
+
     def verify(self):
         "Verify the module syntax"
         return self.as_llvm_mod().verify()
@@ -1515,12 +1295,6 @@ class LLVMFunction():
 
         return ret.as_int()
 
-    def as_llvm_mod(self):
-        """Return a ModuleRef standing for the current function"""
-        if self._llvm_mod is None:
-            self._llvm_mod = llvm.parse_assembly(str(self.mod))
-        return self._llvm_mod
-
     def get_function_pointer(self):
         "Return a pointer on the Jitted function"
         engine = self.llvm_context.get_execengine()
@@ -1530,6 +1304,3 @@ class LLVMFunction():
         engine.finalize_object()
 
         return engine.get_function_address(self.fc.name)
-
-# TODO:
-# - Add more expressions