about summary refs log tree commit diff stats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--example/disasm/callback.py4
-rw-r--r--example/disasm/file.py2
-rw-r--r--example/disasm/full.py6
-rw-r--r--example/disasm/function.py2
-rw-r--r--example/expression/access_c.py4
-rw-r--r--example/expression/asm_to_ir.py2
-rw-r--r--example/expression/graph_dataflow.py4
-rw-r--r--example/expression/solve_condition_stp.py8
-rw-r--r--example/ida/ctype_propagation.py10
-rw-r--r--example/ida/depgraph.py4
-rw-r--r--example/ida/graph_ir.py4
-rw-r--r--example/ida/symbol_exec.py4
-rw-r--r--example/jitter/unpack_upx.py2
-rw-r--r--example/symbol_exec/depgraph.py4
-rw-r--r--example/symbol_exec/single_instr.py4
-rw-r--r--miasm2/analysis/data_analysis.py2
-rw-r--r--miasm2/analysis/disasm_cb.py4
-rw-r--r--miasm2/analysis/dse.py4
-rw-r--r--miasm2/arch/mips32/ira.py4
-rw-r--r--miasm2/core/asmblock.py47
-rw-r--r--miasm2/ir/ir.py34
-rw-r--r--miasm2/ir/symbexec.py4
-rw-r--r--miasm2/jitter/jitcore.py4
-rwxr-xr-xtest/arch/x86/sem.py2
-rw-r--r--test/core/asmblock.py14
25 files changed, 112 insertions, 71 deletions
diff --git a/example/disasm/callback.py b/example/disasm/callback.py
index 06159138..5aae7f6f 100644
--- a/example/disasm/callback.py
+++ b/example/disasm/callback.py
@@ -46,7 +46,7 @@ bin_stream = bin_stream_str(shellcode)
 mdis = dis_x86_32(bin_stream)
 
 print "Without callback:\n"
-blocks = mdis.dis_multibloc(0)
+blocks = mdis.dis_multiblock(0)
 print "\n".join(str(block) for block in blocks)
 
 # Enable callback
@@ -59,7 +59,7 @@ mdis.job_done.clear()
 
 print "=" * 40
 print "With callback:\n"
-blocks_after = mdis.dis_multibloc(0)
+blocks_after = mdis.dis_multiblock(0)
 print "\n".join(str(block) for block in blocks_after)
 
 # Ensure the callback has been called
diff --git a/example/disasm/file.py b/example/disasm/file.py
index db5cd96b..88ba6162 100644
--- a/example/disasm/file.py
+++ b/example/disasm/file.py
@@ -13,6 +13,6 @@ cont = Container.from_stream(open(sys.argv[1]))
 mdis = dis_x86_32(cont.bin_stream)
 # Inform the engine to avoid disassembling null instructions
 mdis.dont_dis_nulstart_bloc = True
-blocks = mdis.dis_multibloc(addr)
+blocks = mdis.dis_multiblock(addr)
 
 open('graph.dot', 'w').write(blocks.dot())
diff --git a/example/disasm/full.py b/example/disasm/full.py
index dd0ac6cd..ad85f7dc 100644
--- a/example/disasm/full.py
+++ b/example/disasm/full.py
@@ -121,7 +121,7 @@ while not finish and todo:
         if ad in done:
             continue
         done.add(ad)
-        allblocks = mdis.dis_multibloc(ad)
+        allblocks = mdis.dis_multiblock(ad)
 
         log.info('func ok %.16x (%d)' % (ad, len(all_funcs)))
 
@@ -193,8 +193,8 @@ if args.gen_ir:
     for ad, all_block in all_funcs_blocks.items():
         log.info("generating IR... %x" % ad)
         for block in all_block:
-            ir_arch_a.add_bloc(block)
-            ir_arch.add_bloc(block)
+            ir_arch_a.add_block(block)
+            ir_arch.add_block(block)
 
     log.info("Print blocks (without analyse)")
     for label, block in ir_arch.blocks.iteritems():
diff --git a/example/disasm/function.py b/example/disasm/function.py
index 1fe1754f..89f65abb 100644
--- a/example/disasm/function.py
+++ b/example/disasm/function.py
@@ -8,7 +8,7 @@ from miasm2.arch.x86.disasm import dis_x86_32
 # RET
 shellcode = '\xb8\xef\xbe7\x13\xb9\x04\x00\x00\x00\xc1\xc0\x08\xe2\xfb\xc3'
 mdis = dis_x86_32(shellcode)
-blocks = mdis.dis_multibloc(0)
+blocks = mdis.dis_multiblock(0)
 
 for block in blocks:
     print block
diff --git a/example/expression/access_c.py b/example/expression/access_c.py
index 9ba33822..7255e23a 100644
--- a/example/expression/access_c.py
+++ b/example/expression/access_c.py
@@ -157,12 +157,12 @@ dis_engine, ira = machine.dis_engine, machine.ira
 
 mdis = dis_engine(cont.bin_stream, symbol_pool=cont.symbol_pool)
 addr_head = 0
-blocks = mdis.dis_multibloc(addr_head)
+blocks = mdis.dis_multiblock(addr_head)
 lbl_head = mdis.symbol_pool.getby_offset(addr_head)
 
 ir_arch_a = ira(mdis.symbol_pool)
 for block in blocks:
-    ir_arch_a.add_bloc(block)
+    ir_arch_a.add_block(block)
 
 open('graph_irflow.dot', 'w').write(ir_arch_a.graph.dot())
 
diff --git a/example/expression/asm_to_ir.py b/example/expression/asm_to_ir.py
index 058910e3..786b860e 100644
--- a/example/expression/asm_to_ir.py
+++ b/example/expression/asm_to_ir.py
@@ -38,7 +38,7 @@ ir_arch = ir_a_x86_32(symbol_pool)
 for block in blocks:
     print 'add block'
     print block
-    ir_arch.add_bloc(block)
+    ir_arch.add_block(block)
 
 # Display IR
 for lbl, irblock in ir_arch.blocks.items():
diff --git a/example/expression/graph_dataflow.py b/example/expression/graph_dataflow.py
index 8fe39777..120cd73a 100644
--- a/example/expression/graph_dataflow.py
+++ b/example/expression/graph_dataflow.py
@@ -151,7 +151,7 @@ ad = int(args.addr, 16)
 print 'disasm...'
 mdis = dis_x86_32(data)
 mdis.follow_call = True
-ab = mdis.dis_multibloc(ad)
+ab = mdis.dis_multiblock(ad)
 print 'ok'
 
 
@@ -161,7 +161,7 @@ ir_arch = ir_a_x86_32(mdis.symbol_pool)
 blocks = ab
 for block in blocks:
     print block
-    ir_arch.add_bloc(block)
+    ir_arch.add_block(block)
 for irblock in ir_arch.blocks.values():
     print irblock
     if irblock.label.offset != 0:
diff --git a/example/expression/solve_condition_stp.py b/example/expression/solve_condition_stp.py
index 27b0512f..c9d4c7af 100644
--- a/example/expression/solve_condition_stp.py
+++ b/example/expression/solve_condition_stp.py
@@ -37,9 +37,9 @@ def get_block(ir_arch, mdis, ad):
         l = mdis.symbol_pool.getby_offset_create(ad)
     if not l in ir_arch.blocks:
         ad = l.offset
-        b = mdis.dis_bloc(ad)
-        ir_arch.add_bloc(b)
-    b = ir_arch.get_bloc(l)
+        b = mdis.dis_block(ad)
+        ir_arch.add_block(b)
+    b = ir_arch.get_block(l)
     if b is None:
         raise LookupError('no block found at that address: %s' % l)
     return b
@@ -168,7 +168,7 @@ if __name__ == '__main__':
     # add fake address and len to parsed instructions
     for i, line in enumerate(b.lines):
         line.offset, line.l = i, 1
-    ir_arch.add_bloc(b)
+    ir_arch.add_block(b)
     irb = get_block(ir_arch, mdis, 0)
     sb.emulbloc(irb)
     sb.dump_mem()
diff --git a/example/ida/ctype_propagation.py b/example/ida/ctype_propagation.py
index f4fdc3b5..a48179e9 100644
--- a/example/ida/ctype_propagation.py
+++ b/example/ida/ctype_propagation.py
@@ -60,9 +60,9 @@ def get_block(ir_arch, mdis, addr):
     mdis.job_done.clear()
     lbl = ir_arch.get_label(addr)
     if not lbl in ir_arch.blocks:
-        block = mdis.dis_bloc(lbl.offset)
-        ir_arch.add_bloc(block)
-    irblock = ir_arch.get_bloc(lbl)
+        block = mdis.dis_block(lbl.offset)
+        ir_arch.add_block(block)
+    irblock = ir_arch.get_block(lbl)
     if irblock is None:
         raise LookupError('No block found at that address: %s' % lbl)
     return irblock
@@ -165,10 +165,10 @@ def analyse_function():
     # Get the current function
     func = ida_funcs.get_func(idc.ScreenEA())
     addr = func.startEA
-    blocks = mdis.dis_multibloc(addr)
+    blocks = mdis.dis_multiblock(addr)
     # Generate IR
     for block in blocks:
-        ir_arch.add_bloc(block)
+        ir_arch.add_block(block)
 
     # Get settings
     settings = TypePropagationForm(ir_arch)
diff --git a/example/ida/depgraph.py b/example/ida/depgraph.py
index 12d01af9..915f14bc 100644
--- a/example/ida/depgraph.py
+++ b/example/ida/depgraph.py
@@ -214,11 +214,11 @@ def launch_depgraph():
     # Get the current function
     addr = idc.ScreenEA()
     func = ida_funcs.get_func(addr)
-    blocks = mdis.dis_multibloc(func.startEA)
+    blocks = mdis.dis_multiblock(func.startEA)
 
     # Generate IR
     for block in blocks:
-        ir_arch.add_bloc(block)
+        ir_arch.add_block(block)
 
     # Get settings
     settings = depGraphSettingsForm(ir_arch)
diff --git a/example/ida/graph_ir.py b/example/ida/graph_ir.py
index 8c7e80f5..9a65617b 100644
--- a/example/ida/graph_ir.py
+++ b/example/ida/graph_ir.py
@@ -138,7 +138,7 @@ def build_graph(verbose=False, simplify=False):
     if verbose:
         print hex(addr)
 
-    blocks = mdis.dis_multibloc(addr)
+    blocks = mdis.dis_multiblock(addr)
 
     if verbose:
         print "generating graph"
@@ -150,7 +150,7 @@ def build_graph(verbose=False, simplify=False):
         if verbose:
             print 'ADD'
             print block
-        ir_arch.add_bloc(block)
+        ir_arch.add_block(block)
 
     if verbose:
         print "IR ok... %x" % addr
diff --git a/example/ida/symbol_exec.py b/example/ida/symbol_exec.py
index 7599dde7..3d4a64fa 100644
--- a/example/ida/symbol_exec.py
+++ b/example/ida/symbol_exec.py
@@ -87,10 +87,10 @@ def symbolic_exec():
     start, end = idc.SelStart(), idc.SelEnd()
 
     mdis.dont_dis = [end]
-    blocks = mdis.dis_multibloc(start)
+    blocks = mdis.dis_multiblock(start)
     ira = machine.ira()
     for block in blocks:
-        ira.add_bloc(block)
+        ira.add_block(block)
 
     print "Run symbolic execution..."
     sb = SymbolicExecutionEngine(ira, machine.mn.regs.regs_init)
diff --git a/example/jitter/unpack_upx.py b/example/jitter/unpack_upx.py
index 8160e51b..f9b0aed1 100644
--- a/example/jitter/unpack_upx.py
+++ b/example/jitter/unpack_upx.py
@@ -53,7 +53,7 @@ if options.verbose is True:
 # Ensure there is one and only one leave (for OEP discovering)
 mdis = sb.machine.dis_engine(sb.jitter.bs)
 mdis.dont_dis_nulstart_bloc = True
-ab = mdis.dis_multibloc(sb.entry_point)
+ab = mdis.dis_multiblock(sb.entry_point)
 
 leaves = list(ab.get_bad_blocks_predecessors())
 assert(len(leaves) == 1)
diff --git a/example/symbol_exec/depgraph.py b/example/symbol_exec/depgraph.py
index 56ca3f82..4d518cb3 100644
--- a/example/symbol_exec/depgraph.py
+++ b/example/symbol_exec/depgraph.py
@@ -59,11 +59,11 @@ if args.rename_args:
             init_ctx[e_mem] = ExprId("arg%d" % i)
 
 # Disassemble the targeted function
-blocks = mdis.dis_multibloc(int(args.func_addr, 0))
+blocks = mdis.dis_multiblock(int(args.func_addr, 0))
 
 # Generate IR
 for block in blocks:
-    ir_arch.add_bloc(block)
+    ir_arch.add_block(block)
 
 # Get the instance
 dg = DependencyGraph(ir_arch, implicit=args.implicit,
diff --git a/example/symbol_exec/single_instr.py b/example/symbol_exec/single_instr.py
index c31de738..263c0252 100644
--- a/example/symbol_exec/single_instr.py
+++ b/example/symbol_exec/single_instr.py
@@ -14,11 +14,11 @@ asm = machine.mn.asm(line)[0]
 # Get back block
 bin_stream = bin_stream_str(asm)
 mdis = machine.dis_engine(bin_stream)
-asm_block = mdis.dis_bloc(START_ADDR)
+asm_block = mdis.dis_block(START_ADDR)
 
 # Translate ASM -> IR
 ira = machine.ira(mdis.symbol_pool)
-ira.add_bloc(asm_block)
+ira.add_block(asm_block)
 
 # Instanciate a Symbolic Execution engine with default value for registers
 ## EAX = EAX_init, ...
diff --git a/miasm2/analysis/data_analysis.py b/miasm2/analysis/data_analysis.py
index c745b6c7..b3e15ca6 100644
--- a/miasm2/analysis/data_analysis.py
+++ b/miasm2/analysis/data_analysis.py
@@ -221,7 +221,7 @@ class symb_exec_func:
         variables = dict(state.symbols.items())
 
         # get bloc dead, and remove from state
-        b = self.ir_arch.get_bloc(ad)
+        b = self.ir_arch.get_block(ad)
         if b is None:
             raise ValueError("unknown bloc! %s" % ad)
         """
diff --git a/miasm2/analysis/disasm_cb.py b/miasm2/analysis/disasm_cb.py
index f6385c9c..9a75603f 100644
--- a/miasm2/analysis/disasm_cb.py
+++ b/miasm2/analysis/disasm_cb.py
@@ -29,7 +29,7 @@ def arm_guess_subcall(
     ir_arch = ira(sp)
     print '###'
     print cur_bloc
-    ir_arch.add_bloc(cur_bloc)
+    ir_arch.add_block(cur_bloc)
 
     ir_blocks = ir_arch.blocks.values()
     # flow_graph = DiGraph()
@@ -76,7 +76,7 @@ def arm_guess_jump_table(
 
     sp = AsmSymbolPool()
     ir_arch = ira(sp)
-    ir_arch.add_bloc(cur_bloc)
+    ir_arch.add_block(cur_bloc)
 
     ir_blocks = ir_arch.blocks.values()
     for irblock in ir_blocks:
diff --git a/miasm2/analysis/dse.py b/miasm2/analysis/dse.py
index 56ed3292..329323e2 100644
--- a/miasm2/analysis/dse.py
+++ b/miasm2/analysis/dse.py
@@ -301,8 +301,8 @@ class DSEEngine(object):
             self.ir_arch.blocks.clear()# = {}
 
             ## Update current state
-            asm_block = self.mdis.dis_bloc(cur_addr)
-            self.ir_arch.add_bloc(asm_block)
+            asm_block = self.mdis.dis_block(cur_addr)
+            self.ir_arch.add_block(asm_block)
             self.addr_to_cacheblocks[cur_addr] = dict(self.ir_arch.blocks)
 
         # Emulate the current instruction
diff --git a/miasm2/arch/mips32/ira.py b/miasm2/arch/mips32/ira.py
index e342a6fd..f1e21a41 100644
--- a/miasm2/arch/mips32/ira.py
+++ b/miasm2/arch/mips32/ira.py
@@ -15,8 +15,8 @@ class ir_a_mips32l(ir_mips32l, ira):
         # Avoid adding side effects, already done in post_add_bloc
         return False
 
-    def post_add_bloc(self, block, ir_blocks):
-        IntermediateRepresentation.post_add_bloc(self, block, ir_blocks)
+    def post_add_block(self, block, ir_blocks):
+        IntermediateRepresentation.post_add_block(self, block, ir_blocks)
         new_irblocks = []
         for irb in ir_blocks:
             pc_val = None
diff --git a/miasm2/core/asmblock.py b/miasm2/core/asmblock.py
index 965b22c4..6cbe37a4 100644
--- a/miasm2/core/asmblock.py
+++ b/miasm2/core/asmblock.py
@@ -1386,7 +1386,7 @@ class disasmEngine(object):
         # Override options if needed
         self.__dict__.update(kwargs)
 
-    def _dis_bloc(self, offset):
+    def _dis_block(self, offset):
         """Disassemble the block at offset @offset
         Return the created AsmBlock and future offsets to disassemble
         """
@@ -1519,44 +1519,61 @@ class disasmEngine(object):
                                    symbol_pool=self.symbol_pool)
         return cur_block, offsets_to_dis
 
-    def dis_bloc(self, offset):
+    def dis_block(self, offset):
         """Disassemble the block at offset @offset and return the created
         AsmBlock
         @offset: targeted offset to disassemble
         """
-        current_block, _ = self._dis_bloc(offset)
+        current_block, _ = self._dis_block(offset)
         return current_block
 
-    def dis_multibloc(self, offset, blocs=None):
+    def dis_bloc(self, offset):
+        """
+        DEPRECATED function
+        Use dis_block instead of dis_bloc
+        """
+        warnings.warn('DEPRECATION WARNING: use "dis_block" instead of "dis_bloc"')
+        return self.dis_block(offset)
+
+    def dis_multiblock(self, offset, blocks=None):
         """Disassemble every block reachable from @offset regarding
         specific disasmEngine conditions
         Return an AsmCFG instance containing disassembled blocks
         @offset: starting offset
-        @blocs: (optional) AsmCFG instance of already disassembled blocks to
+        @blocks: (optional) AsmCFG instance of already disassembled blocks to
                 merge with
         """
         log_asmblock.info("dis bloc all")
-        if blocs is None:
-            blocs = AsmCFG()
+        if blocks is None:
+            blocks = AsmCFG()
         todo = [offset]
 
         bloc_cpt = 0
         while len(todo):
             bloc_cpt += 1
             if self.blocs_wd is not None and bloc_cpt > self.blocs_wd:
-                log_asmblock.debug("blocs watchdog reached at %X", int(offset))
+                log_asmblock.debug("blocks watchdog reached at %X", int(offset))
                 break
 
             target_offset = int(todo.pop(0))
             if (target_offset is None or
                     target_offset in self.job_done):
                 continue
-            cur_block, nexts = self._dis_bloc(target_offset)
+            cur_block, nexts = self._dis_block(target_offset)
             todo += nexts
-            blocs.add_node(cur_block)
+            blocks.add_node(cur_block)
+
+        blocks.apply_splitting(self.symbol_pool,
+                               dis_block_callback=self.dis_bloc_callback,
+                               mn=self.arch, attrib=self.attrib,
+                               pool_bin=self.bin_stream)
+        return blocks
+
+    def dis_multibloc(self, offset, blocs=None):
+        """
+        DEPRECATED function
+        Use dis_multiblock instead of dis_multibloc
+        """
+        warnings.warn('DEPRECATION WARNING: use "dis_multiblock" instead of "dis_multibloc"')
+        return self.dis_multiblock(offset, blocs)
 
-        blocs.apply_splitting(self.symbol_pool,
-                              dis_block_callback=self.dis_bloc_callback,
-                              mn=self.arch, attrib=self.attrib,
-                              pool_bin=self.bin_stream)
-        return blocs
diff --git a/miasm2/ir/ir.py b/miasm2/ir/ir.py
index 7c39cf04..603d3fd0 100644
--- a/miasm2/ir/ir.py
+++ b/miasm2/ir/ir.py
@@ -477,17 +477,25 @@ class IntermediateRepresentation(object):
             addr = self.symbol_pool.getby_name_create(addr.name)
         return addr
 
-    def get_bloc(self, addr):
+    def get_block(self, addr):
         """Returns the irbloc associated to an ExprId/ExprInt/label/int
         @addr: an ExprId/ExprInt/label/int"""
 
         label = self.get_label(addr)
         return self.blocks.get(label, None)
 
+    def get_bloc(self, addr):
+        """
+        DEPRECATED function
+        Use get_block instead of get_block
+        """
+        warnings.warn('DEPRECATION WARNING: use "get_block" instead of "get_bloc"')
+        return self.get_block(addr)
+
     def add_instr(self, line, addr=0, gen_pc_updt=False):
         block = AsmBlock(self.gen_label())
         block.lines = [line]
-        self.add_bloc(block, gen_pc_updt)
+        self.add_block(block, gen_pc_updt)
 
     def getby_offset(self, offset):
         out = set()
@@ -552,7 +560,7 @@ class IntermediateRepresentation(object):
             return True
         return False
 
-    def add_bloc(self, block, gen_pc_updt=False):
+    def add_block(self, block, gen_pc_updt=False):
         """
         Add a native block to the current IR
         @block: native assembly block
@@ -574,11 +582,19 @@ class IntermediateRepresentation(object):
         if label is not None:
             ir_blocks_all.append(IRBlock(label, assignments))
 
-        new_ir_blocks_all = self.post_add_bloc(block, ir_blocks_all)
+        new_ir_blocks_all = self.post_add_block(block, ir_blocks_all)
         for irblock in new_ir_blocks_all:
             self.blocks[irblock.label] = irblock
         return new_ir_blocks_all
 
+    def add_bloc(self, block, gen_pc_updt=False):
+        """
+        DEPRECATED function
+        Use add_block instead of add_block
+        """
+        warnings.warn('DEPRECATION WARNING: use "add_block" instead of "add_bloc"')
+        return self.add_block(block, gen_pc_updt)
+
     def expr_fix_regs_for_mode(self, expr, *args, **kwargs):
         return expr
 
@@ -610,7 +626,7 @@ class IntermediateRepresentation(object):
             assignblk = AssignBlock({self.IRDst: dst}, irblock.irs[-1].instr)
             ir_blocks[index] = IRBlock(irblock.label, list(irblock.irs) + [assignblk])
 
-    def post_add_bloc(self, block, ir_blocks):
+    def post_add_block(self, block, ir_blocks):
         self.set_empty_dst_to_next(block, ir_blocks)
 
         new_irblocks = []
@@ -622,6 +638,14 @@ class IntermediateRepresentation(object):
         self._graph = None
         return new_irblocks
 
+    def post_add_bloc(self, block, ir_blocks):
+        """
+        DEPRECATED function
+        Use post_add_block instead of post_add_bloc
+        """
+        warnings.warn('DEPRECATION WARNING: use "post_add_block" instead of "post_add_bloc"')
+        return self.post_add_block(block, ir_blocks)
+
     def get_instr_label(self, instr):
         """Returns the label associated to an instruction
         @instr: current instruction"""
diff --git a/miasm2/ir/symbexec.py b/miasm2/ir/symbexec.py
index e98744c0..6d6ba630 100644
--- a/miasm2/ir/symbexec.py
+++ b/miasm2/ir/symbexec.py
@@ -530,7 +530,7 @@ class SymbolicExecutionEngine(object):
         return self.emul_ir_block(addr, step)
 
     def emul_ir_block(self, addr, step=False):
-        irblock = self.ir_arch.get_bloc(addr)
+        irblock = self.ir_arch.get_block(addr)
         if irblock is not None:
             addr = self.emulbloc(irblock, step=step)
         return addr
@@ -541,7 +541,7 @@ class SymbolicExecutionEngine(object):
 
     def emul_ir_blocks(self, addr, lbl_stop=None, step=False):
         while True:
-            irblock = self.ir_arch.get_bloc(addr)
+            irblock = self.ir_arch.get_block(addr)
             if irblock is None:
                 break
             if irblock.label == lbl_stop:
diff --git a/miasm2/jitter/jitcore.py b/miasm2/jitter/jitcore.py
index 0ccbfcd7..6c4d197e 100644
--- a/miasm2/jitter/jitcore.py
+++ b/miasm2/jitter/jitcore.py
@@ -122,7 +122,7 @@ class JitCore(object):
         @block: asm_bloc to add
         """
 
-        irblocks = self.ir_arch.add_bloc(block, gen_pc_updt = True)
+        irblocks = self.ir_arch.add_block(block, gen_pc_updt = True)
         block.blocks = irblocks
         self.jitirblocs(block.label, irblocks)
 
@@ -143,7 +143,7 @@ class JitCore(object):
 
         # Disassemble it
         try:
-            cur_block = self.mdis.dis_bloc(addr)
+            cur_block = self.mdis.dis_block(addr)
         except IOError:
             # vm_exception_flag is set
             label = self.ir_arch.symbol_pool.getby_offset_create(addr)
diff --git a/test/arch/x86/sem.py b/test/arch/x86/sem.py
index 7b6a20b7..c08cf3f6 100755
--- a/test/arch/x86/sem.py
+++ b/test/arch/x86/sem.py
@@ -50,7 +50,7 @@ def compute_txt(ir, mode, txt, inputstate={}, debug=False):
     patches = asmblock.asm_resolve_final(mn, blocks, symbol_pool)
     interm = ir(symbol_pool)
     for bbl in blocks:
-        interm.add_bloc(bbl)
+        interm.add_block(bbl)
     return symb_exec(interm, inputstate, debug)
 
 op_add = lambda a, b: a+b
diff --git a/test/core/asmblock.py b/test/core/asmblock.py
index d12cd510..c3b220df 100644
--- a/test/core/asmblock.py
+++ b/test/core/asmblock.py
@@ -15,17 +15,17 @@ cont = Container.from_string(data)
 # Test Disasm engine
 mdis = dis_x86_32(cont.bin_stream)
 ## Disassembly of one block
-first_block = mdis.dis_bloc(0)
+first_block = mdis.dis_block(0)
 assert len(first_block.lines) == 5
 print first_block
 
 ## Disassembly of several block, with cache
-blocks = mdis.dis_multibloc(0)
+blocks = mdis.dis_multiblock(0)
 assert len(blocks) == 0
 
 ## Test cache
 mdis.job_done.clear()
-blocks = mdis.dis_multibloc(0)
+blocks = mdis.dis_multiblock(0)
 assert len(blocks) == 17
 ## Equality between assembly lines is not yet implemented
 assert len(blocks.heads()) == 1
@@ -202,11 +202,11 @@ data2 = "31c0eb0c31c9750c31d2eb0c31ffebf831dbebf031edebfc31f6ebf031e4c3".decode(
 cont2 = Container.from_string(data2)
 mdis = dis_x86_32(cont2.bin_stream)
 ## Elements to merge
-blocks = mdis.dis_multibloc(0)
+blocks = mdis.dis_multiblock(0)
 ## Block alone
-blocks.add_node(mdis.dis_bloc(0x1c))
+blocks.add_node(mdis.dis_block(0x1c))
 ## Bad block
-blocks.add_node(mdis.dis_bloc(len(data2)))
+blocks.add_node(mdis.dis_block(len(data2)))
 ## Dump the graph before merging
 open("graph3.dot", "w").write(blocks.dot())
 ## Apply merging
@@ -285,7 +285,7 @@ assert blocks.edges2constraint[(tob, newb)] == AsmConstraint.c_to
 data = "74097405b8020000007405b803000000b804000000c3".decode('hex')
 cont = Container.from_string(data)
 mdis = dis_x86_32(cont.bin_stream)
-blocks = mdis.dis_multibloc(0)
+blocks = mdis.dis_multiblock(0)
 ## Check resulting disasm
 assert len(blocks.nodes()) == 6
 blocks.sanity_check()