diff options
| author | Ajax <commial@gmail.com> | 2018-07-02 17:31:59 +0200 |
|---|---|---|
| committer | Ajax <commial@gmail.com> | 2018-07-03 14:28:18 +0200 |
| commit | 68fac2e86cc61eba9adfe520fa0e04a7e8943450 (patch) | |
| tree | 2be74a21b54a3111f3c18746badfb0cf1ed41149 | |
| parent | 6ef8dbb2223d0847e3822b545b249511e96a1f9b (diff) | |
| download | miasm-68fac2e86cc61eba9adfe520fa0e04a7e8943450.tar.gz miasm-68fac2e86cc61eba9adfe520fa0e04a7e8943450.zip | |
symbol_pool -> loc_db
86 files changed, 720 insertions, 706 deletions
diff --git a/example/asm/shellcode.py b/example/asm/shellcode.py index 0ee32146..331e4d69 100755 --- a/example/asm/shellcode.py +++ b/example/asm/shellcode.py @@ -8,6 +8,7 @@ from elfesteem.strpatchwork import StrPatchwork from miasm2.core import parse_asm, asmblock from miasm2.analysis.machine import Machine from miasm2.core.interval import interval +from miasm2.core.locationdb import LocationDB parser = ArgumentParser("Multi-arch (32 bits) assembler") parser.add_argument('architecture', help="architecture: " + @@ -65,15 +66,15 @@ with open(args.source) as fstream: source = fstream.read() -symbol_pool = asmblock.AsmSymbolPool() +loc_db = LocationDB() -asmcfg, symbol_pool = parse_asm.parse_txt(machine.mn, attrib, source, symbol_pool) +asmcfg, loc_db = parse_asm.parse_txt(machine.mn, attrib, source, loc_db) # Fix shellcode addrs -symbol_pool.set_offset(symbol_pool.getby_name("main"), addr_main) +loc_db.set_offset(loc_db.getby_name("main"), addr_main) if args.PE: - symbol_pool.set_offset(symbol_pool.getby_name_create("MessageBoxA"), + loc_db.set_offset(loc_db.getby_name_create("MessageBoxA"), pe.DirImport.get_funcvirt('USER32.dll', 'MessageBoxA')) # Print and graph firsts blocks before patching it @@ -84,14 +85,14 @@ open("graph.dot", "w").write(asmcfg.dot()) # Apply patches patches = asmblock.asm_resolve_final(machine.mn, asmcfg, - symbol_pool, + loc_db, dst_interval) if args.encrypt: # Encrypt code - loc_start = symbol_pool.getby_name_create(args.encrypt[0]) - loc_stop = symbol_pool.getby_name_create(args.encrypt[1]) - ad_start = symbol_pool.loc_key_to_offset(loc_start) - ad_stop = symbol_pool.loc_key_to_offset(loc_stop) + loc_start = loc_db.getby_name_create(args.encrypt[0]) + loc_stop = loc_db.getby_name_create(args.encrypt[1]) + ad_start = loc_db.loc_key_to_offset(loc_start) + ad_stop = loc_db.loc_key_to_offset(loc_stop) new_patches = dict(patches) for ad, val in patches.items(): diff --git a/example/asm/simple.py b/example/asm/simple.py index 09df8d94..068d3627 100644 --- a/example/asm/simple.py +++ b/example/asm/simple.py @@ -6,7 +6,7 @@ from miasm2.core import parse_asm, asmblock # Assemble code -asmcfg, symbol_pool = parse_asm.parse_txt(mn_x86, 32, ''' +asmcfg, loc_db = parse_asm.parse_txt(mn_x86, 32, ''' main: MOV EAX, 1 MOV EBX, 2 @@ -22,10 +22,10 @@ loop: ''') # Set 'main' loc_key's offset -symbol_pool.set_offset(symbol_pool.getby_name("main"), 0x0) +loc_db.set_offset(loc_db.getby_name("main"), 0x0) # Spread information and resolve instructions offset -patches = asmblock.asm_resolve_final(mn_x86, asmcfg, symbol_pool) +patches = asmblock.asm_resolve_final(mn_x86, asmcfg, loc_db) # Show resolved asmcfg for block in asmcfg.blocks: diff --git a/example/disasm/callback.py b/example/disasm/callback.py index a00cf5e5..85090070 100644 --- a/example/disasm/callback.py +++ b/example/disasm/callback.py @@ -3,7 +3,7 @@ from miasm2.core.asmblock import AsmConstraint from miasm2.arch.x86.disasm import dis_x86_32, cb_x86_funcs -def cb_x86_callpop(cur_bloc, symbol_pool, *args, **kwargs): +def cb_x86_callpop(cur_bloc, loc_db, *args, **kwargs): """ 1000: call 1005 1005: pop @@ -27,7 +27,7 @@ def cb_x86_callpop(cur_bloc, symbol_pool, *args, **kwargs): return loc_key = dst.loc_key - offset = symbol_pool.loc_key_to_offset(loc_key) + offset = loc_db.loc_key_to_offset(loc_key) ## The destination must be the next instruction if offset != last_instr.offset + last_instr.l: return diff --git a/example/disasm/full.py b/example/disasm/full.py index b0c34bff..1e5d2334 100644 --- a/example/disasm/full.py +++ b/example/disasm/full.py @@ -85,7 +85,7 @@ mn, dis_engine = machine.mn, machine.dis_engine ira, ir = machine.ira, machine.ir log.info('ok') -mdis = dis_engine(bs, symbol_pool=cont.symbol_pool) +mdis = dis_engine(bs, loc_db=cont.loc_db) # configure disasm engine mdis.dontdis_retcall = args.dontdis_retcall mdis.blocs_wd = args.blockwatchdog @@ -99,8 +99,8 @@ for addr in args.address: addrs.append(int(addr, 0)) except ValueError: # Second chance, try with symbol - loc_key = mdis.symbol_pool.getby_name(addr) - offset = mdis.symbol_pool.loc_key_to_offset(loc_key) + loc_key = mdis.loc_db.getby_name(addr) + offset = mdis.loc_db.loc_key_to_offset(loc_key) addrs.append(offset) if len(addrs) == 0 and default_addr is not None: @@ -140,10 +140,10 @@ while not finish and todo: instr = block.get_subcall_instr() if not instr: continue - for dest in instr.getdstflow(mdis.symbol_pool): + for dest in instr.getdstflow(mdis.loc_db): if not dest.is_loc(): continue - offset = mdis.symbol_pool.loc_key_to_offset(dest.loc_key) + offset = mdis.loc_db.loc_key_to_offset(dest.loc_key) todo.append((mdis, instr, offset)) if args.funcswatchdog is not None and args.funcswatchdog <= 0: @@ -158,7 +158,7 @@ while not finish and todo: # Generate dotty graph -all_asmcfg = AsmCFG(mdis.symbol_pool) +all_asmcfg = AsmCFG(mdis.loc_db) for blocks in all_funcs_blocks.values(): all_asmcfg += blocks @@ -189,8 +189,8 @@ log.info('total lines %s' % total_l) if args.gen_ir: log.info("generating IR and IR analysis") - ir_arch = ir(mdis.symbol_pool) - ir_arch_a = ira(mdis.symbol_pool) + ir_arch = ir(mdis.loc_db) + ir_arch_a = ira(mdis.loc_db) ir_arch.blocks = {} ir_arch_a.blocks = {} for ad, asmcfg in all_funcs_blocks.items(): diff --git a/example/disasm/single_instr.py b/example/disasm/single_instr.py index 59b81de7..d17e303f 100644 --- a/example/disasm/single_instr.py +++ b/example/disasm/single_instr.py @@ -1,9 +1,9 @@ from miasm2.arch.x86.arch import mn_x86 from miasm2.arch.x86.regs import EDX -from miasm2.core.asmblock import AsmSymbolPool +from miasm2.core.locationdb import LocationDB -symbol_pool = AsmSymbolPool() -l = mn_x86.fromstring('MOV EAX, EBX', symbol_pool, 32) +loc_db = LocationDB() +l = mn_x86.fromstring('MOV EAX, EBX', loc_db, 32) print "instruction:", l print "arg:", l.args[0] x = mn_x86.asm(l) diff --git a/example/expression/access_c.py b/example/expression/access_c.py index 8856f6f8..9b92d201 100644 --- a/example/expression/access_c.py +++ b/example/expression/access_c.py @@ -141,12 +141,12 @@ cont = Container.fallback_container(data, None, addr=0) machine = Machine("x86_64") dis_engine, ira = machine.dis_engine, machine.ira -mdis = dis_engine(cont.bin_stream, symbol_pool=cont.symbol_pool) +mdis = dis_engine(cont.bin_stream, loc_db=cont.loc_db) addr_head = 0 asmcfg = mdis.dis_multiblock(addr_head) -lbl_head = mdis.symbol_pool.getby_offset(addr_head) +lbl_head = mdis.loc_db.getby_offset(addr_head) -ir_arch_a = ira(mdis.symbol_pool) +ir_arch_a = ira(mdis.loc_db) for block in asmcfg.blocks: ir_arch_a.add_block(block) diff --git a/example/expression/asm_to_ir.py b/example/expression/asm_to_ir.py index 36965bfa..421d0884 100644 --- a/example/expression/asm_to_ir.py +++ b/example/expression/asm_to_ir.py @@ -8,7 +8,7 @@ from miasm2.arch.x86.ira import ir_a_x86_32 from miasm2.analysis.data_flow import dead_simp # First, asm code -asmcfg, symbol_pool = parse_asm.parse_txt(mn_x86, 32, ''' +asmcfg, loc_db = parse_asm.parse_txt(mn_x86, 32, ''' main: MOV EAX, 1 MOV EBX, 2 @@ -24,17 +24,17 @@ loop: ''') -symbol_pool.set_offset(symbol_pool.getby_name("main"), 0x0) +loc_db.set_offset(loc_db.getby_name("main"), 0x0) for block in asmcfg.blocks: print block print "symbols:" -print symbol_pool -patches = asmblock.asm_resolve_final(mn_x86, asmcfg, symbol_pool) +print loc_db +patches = asmblock.asm_resolve_final(mn_x86, asmcfg, loc_db) # Translate to IR -ir_arch = ir_a_x86_32(symbol_pool) +ir_arch = ir_a_x86_32(loc_db) for block in asmcfg.blocks: print 'add block' print block diff --git a/example/expression/constant_propagation.py b/example/expression/constant_propagation.py index 3a81d909..b39bcafd 100644 --- a/example/expression/constant_propagation.py +++ b/example/expression/constant_propagation.py @@ -28,7 +28,7 @@ machine = Machine("x86_32") cont = Container.from_stream(open(args.filename)) ira, dis_engine = machine.ira, machine.dis_engine mdis = dis_engine(cont.bin_stream) -ir_arch = ira(mdis.symbol_pool) +ir_arch = ira(mdis.loc_db) addr = int(args.address, 0) diff --git a/example/expression/get_read_write.py b/example/expression/get_read_write.py index 9e3b5caf..1bacb251 100644 --- a/example/expression/get_read_write.py +++ b/example/expression/get_read_write.py @@ -1,9 +1,9 @@ from miasm2.arch.x86.arch import mn_x86 from miasm2.expression.expression import get_rw from miasm2.arch.x86.ira import ir_a_x86_32 -from miasm2.core.asmblock import AsmSymbolPool +from miasm2.core.locationdb import LocationDB -symbol_pool = AsmSymbolPool() +loc_db = LocationDB() print """ @@ -14,7 +14,7 @@ Get read/written registers for a given instruction arch = mn_x86 ir_arch = ir_a_x86_32() -l = arch.fromstring('LODSB', symbol_pool, 32) +l = arch.fromstring('LODSB', loc_db, 32) l.offset, l.l = 0, 15 ir_arch.add_instr(l) diff --git a/example/expression/graph_dataflow.py b/example/expression/graph_dataflow.py index 9b45a52d..d0d5564a 100644 --- a/example/expression/graph_dataflow.py +++ b/example/expression/graph_dataflow.py @@ -97,7 +97,7 @@ def gen_block_data_flow_graph(ir_arch, ad, block_flow_cb): irblock_0 = None for irblock in ir_arch.blocks.values(): loc_key = irblock.loc_key - offset = ir_arch.symbol_pool.loc_key_to_offset(loc_key) + offset = ir_arch.loc_db.loc_key_to_offset(loc_key) if offset == ad: irblock_0 = irblock break @@ -139,7 +139,7 @@ print 'ok' print 'generating dataflow graph for:' -ir_arch = ir_a_x86_32(mdis.symbol_pool) +ir_arch = ir_a_x86_32(mdis.loc_db) for block in asmcfg.blocks: print block diff --git a/example/expression/solve_condition_stp.py b/example/expression/solve_condition_stp.py index 42e6670c..b941f092 100644 --- a/example/expression/solve_condition_stp.py +++ b/example/expression/solve_condition_stp.py @@ -88,23 +88,23 @@ if __name__ == '__main__': symbols_init = dict(machine.mn.regs.regs_init) - ir_arch = machine.ir(mdis.symbol_pool) + ir_arch = machine.ir(mdis.loc_db) symbexec = SymbolicExecutionEngine(ir_arch, symbols_init) - asmcfg, symbol_pool = parse_asm.parse_txt(machine.mn, 32, ''' + asmcfg, loc_db = parse_asm.parse_txt(machine.mn, 32, ''' init: PUSH argv PUSH argc PUSH ret_addr ''', - symbol_pool=mdis.symbol_pool) + loc_db=mdis.loc_db) - argc_lbl = symbol_pool.getby_name('argc') - argv_lbl = symbol_pool.getby_name('argv') - ret_addr_lbl = symbol_pool.getby_name('ret_addr') - init_lbl = symbol_pool.getby_name('init') + argc_lbl = loc_db.getby_name('argc') + argv_lbl = loc_db.getby_name('argv') + ret_addr_lbl = loc_db.getby_name('ret_addr') + init_lbl = loc_db.getby_name('init') argc = ExprLoc(argc_lbl, 32) argv = ExprLoc(argv_lbl, 32) diff --git a/example/ida/ctype_propagation.py b/example/ida/ctype_propagation.py index db324833..9a81baef 100644 --- a/example/ida/ctype_propagation.py +++ b/example/ida/ctype_propagation.py @@ -266,7 +266,7 @@ def analyse_function(): iraCallStackFixer = get_ira_call_fixer(ira) - ir_arch = iraCallStackFixer(mdis.symbol_pool) + ir_arch = iraCallStackFixer(mdis.loc_db) asmcfg = mdis.dis_multiblock(addr) # Generate IR @@ -304,8 +304,8 @@ def analyse_function(): infos_types[expr] = set([objc]) # Add fake head - lbl_real_start = ir_arch.symbol_pool.getby_offset(addr) - lbl_head = ir_arch.symbol_pool.getby_name_create("start") + lbl_real_start = ir_arch.loc_db.getby_offset(addr) + lbl_head = ir_arch.loc_db.getby_name_create("start") first_block = asmcfg.label2block(lbl_real_start) diff --git a/example/ida/depgraph.py b/example/ida/depgraph.py index 4320be8d..8e635203 100644 --- a/example/ida/depgraph.py +++ b/example/ida/depgraph.py @@ -28,7 +28,7 @@ class depGraphSettingsForm(ida_kernwin.Form): self.address = idc.ScreenEA() cur_block = None for block in ira.getby_offset(self.address): - offset = self.ira.symbol_pool.loc_key_to_offset(block.loc_key) + offset = self.ira.loc_db.loc_key_to_offset(block.loc_key) if offset is not None: # Only one block non-generated assert cur_block is None @@ -208,13 +208,13 @@ def launch_depgraph(): bs = bin_stream_ida() mdis = dis_engine(bs, dont_dis_nulstart_bloc=True) - ir_arch = ira(mdis.symbol_pool) + ir_arch = ira(mdis.loc_db) # Populate symbols with ida names for ad, name in idautils.Names(): if name is None: continue - mdis.symbol_pool.add_location(name, ad) + mdis.loc_db.add_location(name, ad) asmcfg = mdis.dis_multiblock(func.startEA) @@ -230,7 +230,7 @@ def launch_depgraph(): # Simplify affectations for irb in ir_arch.blocks.values(): irs = [] - offset = ir_arch.symbol_pool.loc_key_to_offset(irb.loc_key) + offset = ir_arch.loc_db.loc_key_to_offset(irb.loc_key) fix_stack = offset is not None and settings.unalias_stack for assignblk in irb: if fix_stack: @@ -251,7 +251,7 @@ def launch_depgraph(): # Get dependency graphs dg = settings.depgraph graphs = dg.get(loc_key, elements, line_nb, - set([ir_arch.symbol_pool.getby_offset(func.startEA)])) + set([ir_arch.loc_db.getby_offset(func.startEA)])) # Display the result comments = {} diff --git a/example/ida/graph_ir.py b/example/ida/graph_ir.py index dd842281..955dee62 100644 --- a/example/ida/graph_ir.py +++ b/example/ida/graph_ir.py @@ -36,12 +36,12 @@ def label_str(self): def color_irblock(irblock, ir_arch): out = [] - lbl = idaapi.COLSTR(ir_arch.symbol_pool.str_loc_key(irblock.loc_key), idaapi.SCOLOR_INSN) + lbl = idaapi.COLSTR(ir_arch.loc_db.str_loc_key(irblock.loc_key), idaapi.SCOLOR_INSN) out.append(lbl) for assignblk in irblock: for dst, src in sorted(assignblk.iteritems()): - dst_f = expr2colorstr(dst, symbol_pool=ir_arch.symbol_pool) - src_f = expr2colorstr(src, symbol_pool=ir_arch.symbol_pool) + dst_f = expr2colorstr(dst, loc_db=ir_arch.loc_db) + src_f = expr2colorstr(src, loc_db=ir_arch.loc_db) line = idaapi.COLSTR("%s = %s" % (dst_f, src_f), idaapi.SCOLOR_INSN) out.append(' %s' % line) out.append("") @@ -112,17 +112,17 @@ def build_graph(verbose=False, simplify=False): bs = bin_stream_ida() mdis = dis_engine(bs) - ir_arch = ira(mdis.symbol_pool) + ir_arch = ira(mdis.loc_db) # populate symbols with ida names for addr, name in idautils.Names(): if name is None: continue - if (mdis.symbol_pool.getby_offset(addr) or - mdis.symbol_pool.getby_name(name)): + if (mdis.loc_db.getby_offset(addr) or + mdis.loc_db.getby_name(name)): # Symbol alias continue - mdis.symbol_pool.add_location(name, addr) + mdis.loc_db.add_location(name, addr) if verbose: print "start disasm" diff --git a/example/ida/symbol_exec.py b/example/ida/symbol_exec.py index 0d8c63c2..43100943 100644 --- a/example/ida/symbol_exec.py +++ b/example/ida/symbol_exec.py @@ -37,11 +37,11 @@ class symbolicexec_t(idaapi.simplecustviewer_t): self.AddLine("%s = %s" % ( expr2colorstr( key, - symbol_pool=self.symbol_pool + loc_db=self.loc_db ), expr2colorstr( value, - symbol_pool=self.symbol_pool + loc_db=self.loc_db ) )) @@ -69,12 +69,12 @@ class symbolicexec_t(idaapi.simplecustviewer_t): form.Compile() form.Execute() - def Create(self, equations, machine, symbol_pool, *args, **kwargs): + def Create(self, equations, machine, loc_db, *args, **kwargs): if not super(symbolicexec_t, self).Create(*args, **kwargs): return False self.machine = machine - self.symbol_pool = symbol_pool + self.loc_db = loc_db self.line2eq = sorted(equations.items(), key=operator.itemgetter(0)) self.lines_expanded = set() @@ -141,7 +141,7 @@ def symbolic_exec(): mdis.dont_dis = [end] asmcfg = mdis.dis_multiblock(start) - ira = machine.ira(symbol_pool=mdis.symbol_pool) + ira = machine.ira(loc_db=mdis.loc_db) for block in asmcfg.blocks: ira.add_block(block) @@ -155,7 +155,7 @@ def symbolic_exec(): view = symbolicexec_t() all_views.append(view) - if not view.Create(modified, machine, mdis.symbol_pool, + if not view.Create(modified, machine, mdis.loc_db, "Symbolic Execution - 0x%x to 0x%x" % (start, idc.prev_head(end))): return diff --git a/example/ida/utils.py b/example/ida/utils.py index 5620a881..254617ba 100644 --- a/example/ida/utils.py +++ b/example/ida/utils.py @@ -79,9 +79,9 @@ class TranslatorIDA(Translator): # Implemented language __LANG__ = "ida_w_color" - def __init__(self, symbol_pool=None, **kwargs): + def __init__(self, loc_db=None, **kwargs): super(TranslatorIDA, self).__init__(**kwargs) - self.symbol_pool = symbol_pool + self.loc_db = loc_db def str_protected_child(self, child, parent): return ("(%s)" % ( @@ -97,8 +97,8 @@ class TranslatorIDA(Translator): return out def from_ExprLoc(self, expr): - if self.symbol_pool is not None: - out = self.symbol_pool.str_loc_key(expr.loc_key) + if self.loc_db is not None: + out = self.loc_db.str_loc_key(expr.loc_key) else: out = str(expr) out = idaapi.COLSTR(out, idaapi.SCOLOR_REG) @@ -150,13 +150,13 @@ class TranslatorIDA(Translator): -def expr2colorstr(expr, symbol_pool): +def expr2colorstr(expr, loc_db): """Colorize an Expr instance for IDA @expr: Expr instance to colorize - @symbol_pool: AsmSymbolPool instance + @loc_db: LocationDB instance """ - translator = TranslatorIDA(symbol_pool=symbol_pool) + translator = TranslatorIDA(loc_db=loc_db) return translator.from_expr(expr) diff --git a/example/jitter/sandbox_call.py b/example/jitter/sandbox_call.py index 7a9fd946..5fc50a9c 100644 --- a/example/jitter/sandbox_call.py +++ b/example/jitter/sandbox_call.py @@ -15,8 +15,8 @@ sb = Sandbox_Linux_arml(options.filename, options, globals()) with open(options.filename, "rb") as fdesc: cont = Container.from_stream(fdesc) - loc_key = cont.symbol_pool.getby_name("md5_starts") - addr_to_call = cont.symbol_pool.loc_key_to_offset(loc_key) + loc_key = cont.loc_db.getby_name("md5_starts") + addr_to_call = cont.loc_db.loc_key_to_offset(loc_key) # Calling md5_starts(malloc(0x64)) addr = linobjs.heap.alloc(sb.jitter, 0x64) diff --git a/example/jitter/unpack_upx.py b/example/jitter/unpack_upx.py index cd0818ec..6b7b4f50 100644 --- a/example/jitter/unpack_upx.py +++ b/example/jitter/unpack_upx.py @@ -60,7 +60,7 @@ assert(len(leaves) == 1) l = leaves.pop() logging.info(l) -end_offset = mdis.symbol_pool.loc_key_to_offset(l) +end_offset = mdis.loc_db.loc_key_to_offset(l) logging.info('final offset') logging.info(hex(end_offset)) diff --git a/example/symbol_exec/depgraph.py b/example/symbol_exec/depgraph.py index 621e8fca..88540a83 100644 --- a/example/symbol_exec/depgraph.py +++ b/example/symbol_exec/depgraph.py @@ -47,7 +47,7 @@ for element in args.element: raise ValueError("Unknown element '%s'" % element) mdis = machine.dis_engine(cont.bin_stream, dont_dis_nulstart_bloc=True) -ir_arch = machine.ira(mdis.symbol_pool) +ir_arch = machine.ira(mdis.loc_db) # Common argument forms init_ctx = {} diff --git a/example/symbol_exec/single_instr.py b/example/symbol_exec/single_instr.py index 22a48fc6..fd454212 100644 --- a/example/symbol_exec/single_instr.py +++ b/example/symbol_exec/single_instr.py @@ -2,27 +2,25 @@ from miasm2.core.bin_stream import bin_stream_str from miasm2.ir.symbexec import SymbolicExecutionEngine from miasm2.analysis.machine import Machine -from miasm2.core.asmblock import AsmSymbolPool +from miasm2.core.locationdb import LocationDB START_ADDR = 0 machine = Machine("x86_32") - -symbol_pool = AsmSymbolPool() - +loc_db = LocationDB() # Assemble and disassemble a MOV ## Ensure that attributes 'offset' and 'l' are set -line = machine.mn.fromstring("MOV EAX, EBX", symbol_pool, 32) +line = machine.mn.fromstring("MOV EAX, EBX", loc_db, 32) asm = machine.mn.asm(line)[0] # Get back block bin_stream = bin_stream_str(asm) -mdis = machine.dis_engine(bin_stream, symbol_pool=symbol_pool) +mdis = machine.dis_engine(bin_stream, loc_db=loc_db) mdis.lines_wd = 1 asm_block = mdis.dis_block(START_ADDR) # Translate ASM -> IR -ira = machine.ira(mdis.symbol_pool) +ira = machine.ira(mdis.loc_db) ira.add_block(asm_block) # Instanciate a Symbolic Execution engine with default value for registers diff --git a/miasm2/analysis/binary.py b/miasm2/analysis/binary.py index 5d9374da..ae3b964e 100644 --- a/miasm2/analysis/binary.py +++ b/miasm2/analysis/binary.py @@ -1,8 +1,9 @@ import logging +import warnings from miasm2.core.bin_stream import bin_stream_str, bin_stream_elf, bin_stream_pe from miasm2.jitter.csts import PAGE_READ -from miasm2.core.asmblock import AsmSymbolPool +from miasm2.core.locationdb import LocationDB log = logging.getLogger("binary") @@ -94,7 +95,7 @@ class Container(object): self._bin_stream = None self._entry_point = None self._arch = None - self._symbol_pool = AsmSymbolPool() + self._loc_db = LocationDB() # Launch parsing self.parse(*args, **kwargs) @@ -120,10 +121,15 @@ class Container(object): return self._arch @property - def symbol_pool(self): - "AsmSymbolPool instance preloaded with container symbols (if any)" - return self._symbol_pool + def loc_db(self): + "LocationDB instance preloaded with container symbols (if any)" + return self._loc_db + @property + def symbol_pool(self): + "[DEPRECATED API]" + warnings.warn("Deprecated API: use 'loc_db'") + return self.loc_db ## Format dependent classes class ContainerPE(Container): @@ -205,13 +211,13 @@ class ContainerELF(Container): if not name: continue try: - self._symbol_pool.add_location(name, offset) + self._loc_db.add_location(name, offset) except ValueError: # Two symbols points on the same offset log.warning("Same offset (%s) for %s and %s", (hex(offset), name, - self._symbol_pool.getby_offset(offset))) + self._loc_db.getby_offset(offset))) continue diff --git a/miasm2/analysis/depgraph.py b/miasm2/analysis/depgraph.py index 0f4d168d..6532a3ef 100644 --- a/miasm2/analysis/depgraph.py +++ b/miasm2/analysis/depgraph.py @@ -2,7 +2,7 @@ from miasm2.expression.expression import ExprInt, ExprLoc, ExprAff from miasm2.core.graph import DiGraph -from miasm2.core.asmblock import AsmSymbolPool +from miasm2.core.locationdb import LocationDB from miasm2.expression.simplifications import expr_simp from miasm2.ir.symbexec import SymbolicExecutionEngine from miasm2.ir.ir import IRBlock, AssignBlock @@ -297,8 +297,8 @@ class DependencyResult(DependencyState): line_nb).assignblks # Eval the block - symbol_pool = AsmSymbolPool() - temp_loc = symbol_pool.getby_name_create("Temp") + loc_db = LocationDB() + temp_loc = loc_db.getby_name_create("Temp") symb_exec = SymbolicExecutionEngine(self._ira, ctx_init) symb_exec.eval_updt_irblock(IRBlock(temp_loc, assignblks), step=step) @@ -322,10 +322,10 @@ class DependencyResultImplicit(DependencyResult): generated loc_keys """ out = [] - expected = self._ira.symbol_pool.canonize_to_exprloc(expected) + expected = self._ira.loc_db.canonize_to_exprloc(expected) expected_is_loc_key = expected.is_loc() for consval in possible_values(expr): - value = self._ira.symbol_pool.canonize_to_exprloc(consval.value) + value = self._ira.loc_db.canonize_to_exprloc(consval.value) if expected_is_loc_key and value != expected: continue if not expected_is_loc_key and value.is_loc_key(): diff --git a/miasm2/analysis/disasm_cb.py b/miasm2/analysis/disasm_cb.py index 0dc482ac..54832104 100644 --- a/miasm2/analysis/disasm_cb.py +++ b/miasm2/analysis/disasm_cb.py @@ -2,8 +2,8 @@ from miasm2.expression.expression import ExprInt, ExprId, ExprMem, match_expr from miasm2.expression.simplifications import expr_simp -from miasm2.core.asmblock \ - import AsmSymbolPool, AsmConstraintNext, AsmConstraintTo +from miasm2.core.asmblock import AsmConstraintNext, AsmConstraintTo +from miasm2.core.locationdb import LocationDB from miasm2.core.utils import upck32 @@ -21,10 +21,10 @@ def get_ira(mnemo, attrib): def arm_guess_subcall( - mnemo, attrib, pool_bin, cur_bloc, offsets_to_dis, symbol_pool): + mnemo, attrib, pool_bin, cur_bloc, offsets_to_dis, loc_db): ira = get_ira(mnemo, attrib) - sp = AsmSymbolPool() + sp = LocationDB() ir_arch = ira(sp) print '###' print cur_bloc @@ -49,7 +49,7 @@ def arm_guess_subcall( l = cur_bloc.lines[-1] if lr_val.arg != l.offset + l.l: continue - l = symbol_pool.getby_offset_create(int(lr_val)) + l = loc_db.getby_offset_create(int(lr_val)) c = AsmConstraintNext(l) to_add.add(c) @@ -60,13 +60,13 @@ def arm_guess_subcall( def arm_guess_jump_table( - mnemo, attrib, pool_bin, cur_bloc, offsets_to_dis, symbol_pool): + mnemo, attrib, pool_bin, cur_bloc, offsets_to_dis, loc_db): ira = get_ira(mnemo, attrib) jra = ExprId('jra') jrb = ExprId('jrb') - sp = AsmSymbolPool() + sp = LocationDB() ir_arch = ira(sp) ir_arch.add_block(cur_bloc) @@ -111,7 +111,7 @@ def arm_guess_jump_table( for ad in addrs: offsets_to_dis.add(ad) - l = symbol_pool.getby_offset_create(ad) + l = loc_db.getby_offset_create(ad) c = AsmConstraintTo(l) cur_bloc.addto(c) @@ -119,6 +119,6 @@ guess_funcs = [] def guess_multi_cb( - mnemo, attrib, pool_bin, cur_bloc, offsets_to_dis, symbol_pool): + mnemo, attrib, pool_bin, cur_bloc, offsets_to_dis, loc_db): for f in guess_funcs: - f(mnemo, attrib, pool_bin, cur_bloc, offsets_to_dis, symbol_pool) + f(mnemo, attrib, pool_bin, cur_bloc, offsets_to_dis, loc_db) diff --git a/miasm2/analysis/dse.py b/miasm2/analysis/dse.py index 1fd177bb..e2758d6c 100644 --- a/miasm2/analysis/dse.py +++ b/miasm2/analysis/dse.py @@ -159,14 +159,14 @@ class DSEEngine(object): self.symb_concrete = None # Concrete SymbExec for path desambiguisation self.mdis = None # DisasmEngine - self.symbol_pool = self.ir_arch.symbol_pool + self.loc_db = self.ir_arch.loc_db def prepare(self): """Prepare the environment for attachment with a jitter""" # Disassembler self.mdis = self.machine.dis_engine(bin_stream_vm(self.jitter.vm), lines_wd=1, - symbol_pool=self.symbol_pool) + loc_db=self.loc_db) # Symbexec engine ## Prepare symbexec engines @@ -297,7 +297,7 @@ class DSEEngine(object): # Call callbacks associated to the current address cur_addr = self.jitter.pc if isinstance(cur_addr, LocKey): - lbl = self.ir_arch.symbol_pool.loc_key_to_label(cur_addr) + lbl = self.ir_arch.loc_db.loc_key_to_label(cur_addr) cur_addr = lbl.offset if cur_addr in self.handler: @@ -348,7 +348,7 @@ class DSEEngine(object): self.symb.run_block_at(cur_addr) if not (isinstance(next_addr_concrete, ExprLoc) and - self.ir_arch.symbol_pool.loc_key_to_offset( + self.ir_arch.loc_db.loc_key_to_offset( next_addr_concrete.loc_key ) is None): # Not a lbl_gen, exit @@ -604,17 +604,17 @@ class DSEPathConstraint(DSEEngine): self.cur_solver.add(self.z3_trans.from_expr(cons)) def handle(self, cur_addr): - cur_addr = self.ir_arch.symbol_pool.canonize_to_exprloc(cur_addr) + cur_addr = self.ir_arch.loc_db.canonize_to_exprloc(cur_addr) symb_pc = self.eval_expr(self.ir_arch.IRDst) possibilities = possible_values(symb_pc) cur_path_constraint = set() # path_constraint for the concrete path if len(possibilities) == 1: dst = next(iter(possibilities)).value - dst = self.ir_arch.symbol_pool.canonize_to_exprloc(dst) + dst = self.ir_arch.loc_db.canonize_to_exprloc(dst) assert dst == cur_addr else: for possibility in possibilities: - target_addr = self.ir_arch.symbol_pool.canonize_to_exprloc( + target_addr = self.ir_arch.loc_db.canonize_to_exprloc( possibility.value ) path_constraint = set() # Set of ExprAff for the possible path diff --git a/miasm2/arch/aarch64/arch.py b/miasm2/arch/aarch64/arch.py index a57e585f..79b76743 100644 --- a/miasm2/arch/aarch64/arch.py +++ b/miasm2/arch/aarch64/arch.py @@ -263,7 +263,7 @@ conds_inv_expr, _, conds_inv_info = gen_regs(CONDS_INV, {}) class aarch64_arg(m_arg): - def asm_ast_to_expr(self, value, symbol_pool, size_hint=None, fixed_size=None): + def asm_ast_to_expr(self, value, loc_db, size_hint=None, fixed_size=None): if size_hint is None: size_hint = 64 if fixed_size is None: @@ -276,25 +276,25 @@ class aarch64_arg(m_arg): if isinstance(value.name, ExprId): fixed_size.add(value.name.size) return value.name - loc_key = symbol_pool.getby_name_create(value.name) + loc_key = loc_db.getby_name_create(value.name) return ExprLoc(loc_key, size_hint) if isinstance(value, AstInt): assert size_hint is not None return ExprInt(value.value, size_hint) if isinstance(value, AstOp): if value.op == "segm": - segm = self.asm_ast_to_expr(value.args[0], symbol_pool) - ptr = self.asm_ast_to_expr(value.args[1], symbol_pool, None, fixed_size) + segm = self.asm_ast_to_expr(value.args[0], loc_db) + ptr = self.asm_ast_to_expr(value.args[1], loc_db, None, fixed_size) return ExprOp('segm', segm, ptr) - args = [self.asm_ast_to_expr(arg, symbol_pool, None, fixed_size) for arg in value.args] + args = [self.asm_ast_to_expr(arg, loc_db, None, fixed_size) for arg in value.args] if len(fixed_size) == 0: # No fixed size pass elif len(fixed_size) == 1: # One fixed size, regen all size = list(fixed_size)[0] - args = [self.asm_ast_to_expr(arg, symbol_pool, size, fixed_size) for arg in value.args] + args = [self.asm_ast_to_expr(arg, loc_db, size, fixed_size) for arg in value.args] else: raise ValueError("Size conflict") @@ -310,13 +310,13 @@ class instruction_aarch64(instruction): super(instruction_aarch64, self).__init__(*args, **kargs) @staticmethod - def arg2str(expr, index=None, symbol_pool=None): + def arg2str(expr, index=None, loc_db=None): wb = False if expr.is_id() or expr.is_int(): return str(expr) elif expr.is_loc(): - if symbol_pool is not None: - return symbol_pool.str_loc_key(expr.loc_key) + if loc_db is not None: + return loc_db.str_loc_key(expr.loc_key) else: return str(expr) elif isinstance(expr, m2_expr.ExprOp) and expr.op in shift_expr: @@ -368,13 +368,13 @@ class instruction_aarch64(instruction): else: return 0 - def dstflow2label(self, symbol_pool): + def dstflow2label(self, loc_db): index = self.mnemo_flow_to_dst_index(self.name) expr = self.args[index] if not expr.is_int(): return addr = expr.arg + self.offset - loc_key = symbol_pool.getby_offset_create(addr) + loc_key = loc_db.getby_offset_create(addr) self.args[index] = m2_expr.ExprLoc(loc_key, expr.size) def breakflow(self): @@ -383,14 +383,14 @@ class instruction_aarch64(instruction): def is_subcall(self): return self.name in ["BLR", "BL"] - def getdstflow(self, symbol_pool): + def getdstflow(self, loc_db): index = self.mnemo_flow_to_dst_index(self.name) return [self.args[index]] def splitflow(self): return self.name in BRCOND + ["BLR", "BL"] - def get_symbol_size(self, symbol, symbol_pool): + def get_symbol_size(self, symbol, loc_db): return 64 def fixDstOffset(self): @@ -502,7 +502,7 @@ class mn_aarch64(cls_mn): else: raise NotImplementedError('bad attrib') - def get_symbol_size(self, symbol, symbol_pool, mode): + def get_symbol_size(self, symbol, loc_db, mode): return 32 def reset_class(self): @@ -800,8 +800,8 @@ def set_imm_to_size(size, expr): class aarch64_imm_sf(imm_noarg): parser = base_expr - def fromstring(self, text, symbol_pool, parser_result=None): - start, stop = super(aarch64_imm_sf, self).fromstring(text, symbol_pool, parser_result) + def fromstring(self, text, loc_db, parser_result=None): + start, stop = super(aarch64_imm_sf, self).fromstring(text, loc_db, parser_result) if start is None: return start, stop size = self.parent.args[0].expr.size diff --git a/miasm2/arch/aarch64/ira.py b/miasm2/arch/aarch64/ira.py index 5a89e910..a895b549 100644 --- a/miasm2/arch/aarch64/ira.py +++ b/miasm2/arch/aarch64/ira.py @@ -6,22 +6,22 @@ from miasm2.arch.aarch64.sem import ir_aarch64l, ir_aarch64b class ir_a_aarch64l_base(ir_aarch64l, ira): - def __init__(self, symbol_pool=None): - ir_aarch64l.__init__(self, symbol_pool) + def __init__(self, loc_db=None): + ir_aarch64l.__init__(self, loc_db) self.ret_reg = self.arch.regs.X0 class ir_a_aarch64b_base(ir_aarch64b, ira): - def __init__(self, symbol_pool=None): - ir_aarch64b.__init__(self, symbol_pool) + def __init__(self, loc_db=None): + ir_aarch64b.__init__(self, loc_db) self.ret_reg = self.arch.regs.X0 class ir_a_aarch64l(ir_a_aarch64l_base): - def __init__(self, symbol_pool=None): - ir_a_aarch64l_base.__init__(self, symbol_pool) + def __init__(self, loc_db=None): + ir_a_aarch64l_base.__init__(self, loc_db) self.ret_reg = self.arch.regs.X0 def get_out_regs(self, _): @@ -45,6 +45,6 @@ class ir_a_aarch64l(ir_a_aarch64l_base): class ir_a_aarch64b(ir_a_aarch64b_base, ir_a_aarch64l): - def __init__(self, symbol_pool=None): - ir_a_aarch64b_base.__init__(self, symbol_pool) + def __init__(self, loc_db=None): + ir_a_aarch64b_base.__init__(self, loc_db) self.ret_reg = self.arch.regs.X0 diff --git a/miasm2/arch/aarch64/jit.py b/miasm2/arch/aarch64/jit.py index b557a179..91c32c68 100644 --- a/miasm2/arch/aarch64/jit.py +++ b/miasm2/arch/aarch64/jit.py @@ -1,7 +1,7 @@ import logging from miasm2.jitter.jitload import Jitter, named_arguments -from miasm2.core import asmblock +from miasm2.core.locationdb import LocationDB from miasm2.core.utils import pck64, upck64 from miasm2.arch.aarch64.sem import ir_aarch64b, ir_aarch64l @@ -15,8 +15,7 @@ class jitter_aarch64l(Jitter): max_reg_arg = 8 def __init__(self, *args, **kwargs): - sp = asmblock.AsmSymbolPool() - Jitter.__init__(self, ir_aarch64l(sp), *args, **kwargs) + Jitter.__init__(self, ir_aarch64l(LocationDB()), *args, **kwargs) self.vm.set_little_endian() def push_uint64_t(self, value): @@ -76,6 +75,5 @@ class jitter_aarch64l(Jitter): class jitter_aarch64b(jitter_aarch64l): def __init__(self, *args, **kwargs): - sp = asmblock.AsmSymbolPool() - Jitter.__init__(self, ir_aarch64b(sp), *args, **kwargs) + Jitter.__init__(self, ir_aarch64b(LocationDB()), *args, **kwargs) self.vm.set_big_endian() diff --git a/miasm2/arch/aarch64/sem.py b/miasm2/arch/aarch64/sem.py index c232e8dc..a17c0f14 100644 --- a/miasm2/arch/aarch64/sem.py +++ b/miasm2/arch/aarch64/sem.py @@ -861,8 +861,8 @@ class aarch64info: class ir_aarch64l(IntermediateRepresentation): - def __init__(self, symbol_pool=None): - IntermediateRepresentation.__init__(self, mn_aarch64, "l", symbol_pool) + def __init__(self, loc_db=None): + IntermediateRepresentation.__init__(self, mn_aarch64, "l", loc_db) self.pc = PC self.sp = SP self.IRDst = m2_expr.ExprId('IRDst', 64) @@ -945,8 +945,8 @@ class ir_aarch64l(IntermediateRepresentation): class ir_aarch64b(ir_aarch64l): - def __init__(self, symbol_pool=None): - IntermediateRepresentation.__init__(self, mn_aarch64, "b", symbol_pool) + def __init__(self, loc_db=None): + IntermediateRepresentation.__init__(self, mn_aarch64, "b", loc_db) self.pc = PC self.sp = SP self.IRDst = m2_expr.ExprId('IRDst', 64) diff --git a/miasm2/arch/arm/arch.py b/miasm2/arch/arm/arch.py index 624642cf..498de94c 100644 --- a/miasm2/arch/arm/arch.py +++ b/miasm2/arch/arm/arch.py @@ -343,13 +343,13 @@ class instruction_arm(instruction): super(instruction_arm, self).__init__(*args, **kargs) @staticmethod - def arg2str(expr, index=None, symbol_pool=None): + def arg2str(expr, index=None, loc_db=None): wb = False if expr.is_id() or expr.is_int(): return str(expr) elif expr.is_loc(): - if symbol_pool is not None: - return symbol_pool.str_loc_key(expr.loc_key) + if loc_db is not None: + return loc_db.str_loc_key(expr.loc_key) else: return str(expr) if isinstance(expr, ExprOp) and expr.op in expr2shift_dct: @@ -422,7 +422,7 @@ class instruction_arm(instruction): def dstflow(self): return self.name in conditional_branch + unconditional_branch - def dstflow2label(self, symbol_pool): + def dstflow2label(self, loc_db): expr = self.args[0] if not isinstance(expr, ExprInt): return @@ -430,7 +430,7 @@ class instruction_arm(instruction): addr = expr.arg + self.offset else: addr = expr.arg + self.offset - loc_key = symbol_pool.getby_offset_create(addr) + loc_key = loc_db.getby_offset_create(addr) self.args[0] = ExprLoc(loc_key, expr.size) def breakflow(self): @@ -447,7 +447,7 @@ class instruction_arm(instruction): return True return self.additional_info.lnk - def getdstflow(self, symbol_pool): + def getdstflow(self, loc_db): return [self.args[0]] def splitflow(self): @@ -459,7 +459,7 @@ class instruction_arm(instruction): return False return self.breakflow() and self.additional_info.cond != 14 - def get_symbol_size(self, symbol, symbol_pool): + def get_symbol_size(self, symbol, loc_db): return 32 def fixDstOffset(self): @@ -494,7 +494,7 @@ class instruction_armt(instruction_arm): return True return self.name in conditional_branch + unconditional_branch - def dstflow2label(self, symbol_pool): + def dstflow2label(self, loc_db): if self.name in ["CBZ", "CBNZ"]: expr = self.args[1] else: @@ -512,7 +512,7 @@ class instruction_armt(instruction_arm): else: addr = expr.arg + self.offset - loc_key = symbol_pool.getby_offset_create(addr) + loc_key = loc_db.getby_offset_create(addr) dst = ExprLoc(loc_key, expr.size) if self.name in ["CBZ", "CBNZ"]: @@ -529,7 +529,7 @@ class instruction_armt(instruction_arm): return True return False - def getdstflow(self, symbol_pool): + def getdstflow(self, loc_db): if self.name in ['CBZ', 'CBNZ']: return [self.args[1]] return [self.args[0]] @@ -662,7 +662,7 @@ class mn_arm(cls_mn): raise NotImplementedError('bad attrib') - def get_symbol_size(self, symbol, symbol_pool, mode): + def get_symbol_size(self, symbol, loc_db, mode): return 32 @@ -769,28 +769,28 @@ class mn_armt(cls_mn): args = [a.expr for a in self.args] return args - def get_symbol_size(self, symbol, symbol_pool, mode): + def get_symbol_size(self, symbol, loc_db, mode): return 32 class arm_arg(m_arg): - def asm_ast_to_expr(self, arg, symbol_pool): + def asm_ast_to_expr(self, arg, loc_db): if isinstance(arg, AstId): if isinstance(arg.name, ExprId): return arg.name if arg.name in gpregs.str: return None - loc_key = symbol_pool.getby_name_create(arg.name) + loc_key = loc_db.getby_name_create(arg.name) return ExprLoc(loc_key, 32) if isinstance(arg, AstOp): - args = [self.asm_ast_to_expr(tmp, symbol_pool) for tmp in arg.args] + args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args] if None in args: return None return ExprOp(arg.op, *args) if isinstance(arg, AstInt): return ExprInt(arg.value, 32) if isinstance(arg, AstMem): - ptr = self.asm_ast_to_expr(arg.ptr, symbol_pool) + ptr = self.asm_ast_to_expr(arg.ptr, loc_db) if ptr is None: return None return ExprMem(ptr, arg.size) @@ -2809,8 +2809,8 @@ class armt_aif(reg_noarg, arm_arg): return ret return self.value != 0 - def fromstring(self, text, symbol_pool, parser_result=None): - start, stop = super(armt_aif, self).fromstring(text, symbol_pool, parser_result) + def fromstring(self, text, loc_db, parser_result=None): + start, stop = super(armt_aif, self).fromstring(text, loc_db, parser_result) if self.expr.name == "X": return None, None return start, stop diff --git a/miasm2/arch/arm/disasm.py b/miasm2/arch/arm/disasm.py index 8997fa2b..41034211 100644 --- a/miasm2/arch/arm/disasm.py +++ b/miasm2/arch/arm/disasm.py @@ -2,7 +2,7 @@ from miasm2.core.asmblock import AsmConstraint, disasmEngine from miasm2.arch.arm.arch import mn_arm, mn_armt -def cb_arm_fix_call(mn, cur_bloc, symbol_pool, offsets_to_dis, *args, **kwargs): +def cb_arm_fix_call(mn, cur_bloc, loc_db, offsets_to_dis, *args, **kwargs): """ for arm: MOV LR, PC @@ -24,7 +24,7 @@ def cb_arm_fix_call(mn, cur_bloc, symbol_pool, offsets_to_dis, *args, **kwargs): return if not l2.args[1] in values: return - loc_key_cst = symbol_pool.getby_offset_create(l1.offset + 4) + loc_key_cst = loc_db.getby_offset_create(l1.offset + 4) cur_bloc.add_cst(loc_key_cst, AsmConstraint.c_next) offsets_to_dis.add(l1.offset + 4) diff --git a/miasm2/arch/arm/ira.py b/miasm2/arch/arm/ira.py index cfcb294c..0c84c919 100644 --- a/miasm2/arch/arm/ira.py +++ b/miasm2/arch/arm/ira.py @@ -5,20 +5,20 @@ from miasm2.arch.arm.sem import ir_arml, ir_armtl, ir_armb, ir_armtb class ir_a_arml_base(ir_arml, ira): - def __init__(self, symbol_pool=None): - ir_arml.__init__(self, symbol_pool) + def __init__(self, loc_db=None): + ir_arml.__init__(self, loc_db) self.ret_reg = self.arch.regs.R0 class ir_a_armb_base(ir_armb, ira): - def __init__(self, symbol_pool=None): - ir_armb.__init__(self, symbol_pool) + def __init__(self, loc_db=None): + ir_armb.__init__(self, loc_db) self.ret_reg = self.arch.regs.R0 class ir_a_arml(ir_a_arml_base): - def __init__(self, symbol_pool=None): - ir_a_arml_base.__init__(self, symbol_pool) + def __init__(self, loc_db=None): + ir_a_arml_base.__init__(self, loc_db) self.ret_reg = self.arch.regs.R0 def get_out_regs(self, _): @@ -41,17 +41,17 @@ class ir_a_arml(ir_a_arml_base): class ir_a_armb(ir_a_armb_base, ir_a_arml): - def __init__(self, symbol_pool=None): - ir_a_armb_base.__init__(self, symbol_pool) + def __init__(self, loc_db=None): + ir_a_armb_base.__init__(self, loc_db) self.ret_reg = self.arch.regs.R0 class ir_a_armtl(ir_armtl, ir_a_arml): - def __init__(self, symbol_pool=None): - ir_armtl.__init__(self, symbol_pool) + def __init__(self, loc_db=None): + ir_armtl.__init__(self, loc_db) self.ret_reg = self.arch.regs.R0 class ir_a_armtb(ir_a_armtl, ir_armtb, ir_a_armb): - def __init__(self, symbol_pool=None): - ir_armtb.__init__(self, symbol_pool) + def __init__(self, loc_db=None): + ir_armtb.__init__(self, loc_db) self.ret_reg = self.arch.regs.R0 diff --git a/miasm2/arch/arm/jit.py b/miasm2/arch/arm/jit.py index ef2e14ae..10a7c644 100644 --- a/miasm2/arch/arm/jit.py +++ b/miasm2/arch/arm/jit.py @@ -1,7 +1,7 @@ import logging from miasm2.jitter.jitload import Jitter, named_arguments -from miasm2.core import asmblock +from miasm2.core.locationdb import LocationDB from miasm2.core.utils import pck32, upck32 from miasm2.arch.arm.sem import ir_armb, ir_arml, ir_armtl, ir_armtb, cond_dct_inv, tab_cond from miasm2.jitter.codegen import CGen @@ -55,7 +55,7 @@ class jitter_arml(Jitter): C_Gen = arm_CGen def __init__(self, *args, **kwargs): - sp = asmblock.AsmSymbolPool() + sp = LocationDB() Jitter.__init__(self, ir_arml(sp), *args, **kwargs) self.vm.set_little_endian() @@ -115,7 +115,7 @@ class jitter_armb(jitter_arml): C_Gen = arm_CGen def __init__(self, *args, **kwargs): - sp = asmblock.AsmSymbolPool() + sp = LocationDB() Jitter.__init__(self, ir_armb(sp), *args, **kwargs) self.vm.set_big_endian() @@ -124,6 +124,6 @@ class jitter_armtl(jitter_arml): C_Gen = arm_CGen def __init__(self, *args, **kwargs): - sp = asmblock.AsmSymbolPool() + sp = LocationDB() Jitter.__init__(self, ir_armtl(sp), *args, **kwargs) self.vm.set_little_endian() diff --git a/miasm2/arch/arm/sem.py b/miasm2/arch/arm/sem.py index ccd56e8f..6e311f8e 100644 --- a/miasm2/arch/arm/sem.py +++ b/miasm2/arch/arm/sem.py @@ -441,8 +441,8 @@ def sdiv(ir, instr, a, b, c=None): if c is None: b, c = a, b - loc_div = ExprLoc(ir.symbol_pool.gen_loc_key(), ir.IRDst.size) - loc_except = ExprId(ir.symbol_pool.gen_loc_key(), ir.IRDst.size) + loc_div = ExprLoc(ir.loc_db.gen_loc_key(), ir.IRDst.size) + loc_except = ExprId(ir.loc_db.gen_loc_key(), ir.IRDst.size) loc_next = ExprLoc(ir.get_next_loc_key(instr), ir.IRDst.size) e.append(ExprAff(ir.IRDst, ExprCond(c, loc_div, loc_except))) @@ -474,8 +474,8 @@ def udiv(ir, instr, a, b, c=None): - loc_div = ExprLoc(ir.symbol_pool.gen_loc_key(), ir.IRDst.size) - loc_except = ExprLoc(ir.symbol_pool.gen_loc_key(), ir.IRDst.size) + loc_div = ExprLoc(ir.loc_db.gen_loc_key(), ir.IRDst.size) + loc_except = ExprLoc(ir.loc_db.gen_loc_key(), ir.IRDst.size) loc_next = ExprLoc(ir.get_next_loc_key(instr), ir.IRDst.size) e.append(ExprAff(ir.IRDst, ExprCond(c, loc_div, loc_except))) @@ -1266,7 +1266,7 @@ def add_condition_expr(ir, instr, cond, instr_ir, extra_ir): loc_next = ir.get_next_loc_key(instr) loc_next_expr = ExprLoc(loc_next, 32) - loc_do = ir.symbol_pool.gen_loc_key() + loc_do = ir.loc_db.gen_loc_key() loc_do_expr = ExprLoc(loc_do, 32) dst_cond = ExprCond(cond, loc_do_expr, loc_next_expr) @@ -1474,8 +1474,8 @@ class arminfo: class ir_arml(IntermediateRepresentation): - def __init__(self, symbol_pool=None): - IntermediateRepresentation.__init__(self, mn_arm, "l", symbol_pool) + def __init__(self, loc_db=None): + IntermediateRepresentation.__init__(self, mn_arm, "l", loc_db) self.pc = PC self.sp = SP self.IRDst = ExprId('IRDst', 32) @@ -1556,7 +1556,7 @@ class ir_arml(IntermediateRepresentation): instr = block.lines[index] # Add conditionnal jump to current irblock - loc_do = self.symbol_pool.gen_loc_key() + loc_do = self.loc_db.gen_loc_key() loc_next = self.get_next_loc_key(instr) if hint: @@ -1630,8 +1630,8 @@ class ir_arml(IntermediateRepresentation): class ir_armb(ir_arml): - def __init__(self, symbol_pool=None): - IntermediateRepresentation.__init__(self, mn_arm, "b", symbol_pool) + def __init__(self, loc_db=None): + IntermediateRepresentation.__init__(self, mn_arm, "b", loc_db) self.pc = PC self.sp = SP self.IRDst = ExprId('IRDst', 32) @@ -1639,8 +1639,8 @@ class ir_armb(ir_arml): class ir_armtl(ir_arml): - def __init__(self, symbol_pool=None): - IntermediateRepresentation.__init__(self, mn_armt, "l", symbol_pool) + def __init__(self, loc_db=None): + IntermediateRepresentation.__init__(self, mn_armt, "l", loc_db) self.pc = PC self.sp = SP self.IRDst = ExprId('IRDst', 32) @@ -1665,8 +1665,8 @@ class ir_armtl(ir_arml): class ir_armtb(ir_armtl): - def __init__(self, symbol_pool=None): - IntermediateRepresentation.__init__(self, mn_armt, "b", symbol_pool) + def __init__(self, loc_db=None): + IntermediateRepresentation.__init__(self, mn_armt, "b", loc_db) self.pc = PC self.sp = SP self.IRDst = ExprId('IRDst', 32) diff --git a/miasm2/arch/mips32/arch.py b/miasm2/arch/mips32/arch.py index 1502cde4..a47c606b 100644 --- a/miasm2/arch/mips32/arch.py +++ b/miasm2/arch/mips32/arch.py @@ -60,12 +60,12 @@ class instruction_mips32(cpu.instruction): @staticmethod - def arg2str(expr, index=None, symbol_pool=None): + def arg2str(expr, index=None, loc_db=None): if expr.is_id() or expr.is_int(): return str(expr) elif expr.is_loc(): - if symbol_pool is not None: - return symbol_pool.str_loc_key(expr.loc_key) + if loc_db is not None: + return loc_db.str_loc_key(expr.loc_key) else: return str(expr) assert(isinstance(expr, ExprMem)) @@ -93,11 +93,11 @@ class instruction_mips32(cpu.instruction): raise NotImplementedError("TODO %s"%self) return i - def dstflow2label(self, symbol_pool): + def dstflow2label(self, loc_db): if self.name in ["J", 'JAL']: expr = self.args[0].arg addr = (self.offset & (0xFFFFFFFF ^ ((1<< 28)-1))) + expr - loc_key = symbol_pool.getby_offset_create(addr) + loc_key = loc_db.getby_offset_create(addr) self.args[0] = ExprLoc(loc_key, expr.size) return @@ -107,7 +107,7 @@ class instruction_mips32(cpu.instruction): if not isinstance(expr, ExprInt): return addr = expr.arg + self.offset - loc_key = symbol_pool.getby_offset_create(addr) + loc_key = loc_db.getby_offset_create(addr) self.args[ndx] = ExprLoc(loc_key, expr.size) def breakflow(self): @@ -122,7 +122,7 @@ class instruction_mips32(cpu.instruction): return True return False - def getdstflow(self, symbol_pool): + def getdstflow(self, loc_db): if self.name in br_0: return [self.args[0]] elif self.name in br_1: @@ -147,7 +147,7 @@ class instruction_mips32(cpu.instruction): return True return False - def get_symbol_size(self, symbol, symbol_pool): + def get_symbol_size(self, symbol, loc_db): return 32 def fixDstOffset(self): @@ -259,23 +259,23 @@ def mips32op(name, fields, args=None, alias=False): #type(name, (mn_mips32b,), dct) class mips32_arg(cpu.m_arg): - def asm_ast_to_expr(self, arg, symbol_pool): + def asm_ast_to_expr(self, arg, loc_db): if isinstance(arg, AstId): if isinstance(arg.name, ExprId): return arg.name if arg.name in gpregs.str: return None - loc_key = symbol_pool.getby_name_create(arg.name) + loc_key = loc_db.getby_name_create(arg.name) return ExprLoc(loc_key, 32) if isinstance(arg, AstOp): - args = [self.asm_ast_to_expr(tmp, symbol_pool) for tmp in arg.args] + args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args] if None in args: return None return ExprOp(arg.op, *args) if isinstance(arg, AstInt): return ExprInt(arg.value, 32) if isinstance(arg, AstMem): - ptr = self.asm_ast_to_expr(arg.ptr, symbol_pool) + ptr = self.asm_ast_to_expr(arg.ptr, loc_db) if ptr is None: return None return ExprMem(ptr, arg.size) diff --git a/miasm2/arch/mips32/ira.py b/miasm2/arch/mips32/ira.py index b6d92ee0..791e67bf 100644 --- a/miasm2/arch/mips32/ira.py +++ b/miasm2/arch/mips32/ira.py @@ -6,8 +6,8 @@ from miasm2.ir.analysis import ira from miasm2.arch.mips32.sem import ir_mips32l, ir_mips32b class ir_a_mips32l(ir_mips32l, ira): - def __init__(self, symbol_pool=None): - ir_mips32l.__init__(self, symbol_pool) + def __init__(self, loc_db=None): + ir_mips32l.__init__(self, loc_db) self.ret_reg = self.arch.regs.V0 def pre_add_instr(self, block, instr, assignments, ir_blocks_all, gen_pc_updt): @@ -28,7 +28,7 @@ class ir_a_mips32l(ir_mips32l, ira): new_irblocks.append(irb) continue if lr_val.is_loc(): - offset = self.symbol_pool.loc_key_to_offset(lr_val.loc_key) + offset = self.loc_db.loc_key_to_offset(lr_val.loc_key) if offset is not None: lr_val = ExprInt(offset, 32) if not lr_val.is_int(): @@ -70,6 +70,6 @@ class ir_a_mips32l(ir_mips32l, ira): class ir_a_mips32b(ir_mips32b, ir_a_mips32l): - def __init__(self, symbol_pool=None): - ir_mips32b.__init__(self, symbol_pool) + def __init__(self, loc_db=None): + ir_mips32b.__init__(self, loc_db) self.ret_reg = self.arch.regs.V0 diff --git a/miasm2/arch/mips32/jit.py b/miasm2/arch/mips32/jit.py index c637fb13..0c4eb85b 100644 --- a/miasm2/arch/mips32/jit.py +++ b/miasm2/arch/mips32/jit.py @@ -1,7 +1,7 @@ import logging from miasm2.jitter.jitload import Jitter, named_arguments -from miasm2.core import asmblock +from miasm2.core.locationdb import LocationDB from miasm2.core.utils import pck32, upck32 from miasm2.arch.mips32.sem import ir_mips32l, ir_mips32b from miasm2.jitter.codegen import CGen @@ -70,7 +70,7 @@ class mipsCGen(CGen): """ loc_key = self.get_block_post_label(block) - offset = self.ir_arch.symbol_pool.loc_key_to_offset(loc_key) + offset = self.ir_arch.loc_db.loc_key_to_offset(loc_key) out = (self.CODE_RETURN_NO_EXCEPTION % (loc_key, self.C_PC, m2_expr.ExprId('branch_dst_irdst', 32), @@ -85,7 +85,7 @@ class jitter_mips32l(Jitter): C_Gen = mipsCGen def __init__(self, *args, **kwargs): - sp = asmblock.AsmSymbolPool() + sp = LocationDB() Jitter.__init__(self, ir_mips32l(sp), *args, **kwargs) self.vm.set_little_endian() @@ -145,6 +145,6 @@ class jitter_mips32l(Jitter): class jitter_mips32b(jitter_mips32l): def __init__(self, *args, **kwargs): - sp = asmblock.AsmSymbolPool() + sp = LocationDB() Jitter.__init__(self, ir_mips32b(sp), *args, **kwargs) self.vm.set_big_endian() diff --git a/miasm2/arch/mips32/sem.py b/miasm2/arch/mips32/sem.py index fd4fa655..df13cd2c 100644 --- a/miasm2/arch/mips32/sem.py +++ b/miasm2/arch/mips32/sem.py @@ -469,8 +469,8 @@ def get_mnemo_expr(ir, instr, *args): class ir_mips32l(IntermediateRepresentation): - def __init__(self, symbol_pool=None): - IntermediateRepresentation.__init__(self, mn_mips32, 'l', symbol_pool) + def __init__(self, loc_db=None): + IntermediateRepresentation.__init__(self, mn_mips32, 'l', loc_db) self.pc = mn_mips32.getpc() self.sp = mn_mips32.getsp() self.IRDst = m2_expr.ExprId('IRDst', 32) @@ -490,14 +490,14 @@ class ir_mips32l(IntermediateRepresentation): return instr_ir, new_extra_ir def get_next_instr(self, instr): - return self.symbol_pool.getby_offset_create(instr.offset + 4) + return self.loc_db.getby_offset_create(instr.offset + 4) def get_next_break_loc_key(self, instr): - return self.symbol_pool.getby_offset_create(instr.offset + 8) + return self.loc_db.getby_offset_create(instr.offset + 8) class ir_mips32b(ir_mips32l): - def __init__(self, symbol_pool=None): - IntermediateRepresentation.__init__(self, mn_mips32, 'b', symbol_pool) + def __init__(self, loc_db=None): + IntermediateRepresentation.__init__(self, mn_mips32, 'b', loc_db) self.pc = mn_mips32.getpc() self.sp = mn_mips32.getsp() self.IRDst = m2_expr.ExprId('IRDst', 32) diff --git a/miasm2/arch/msp430/arch.py b/miasm2/arch/msp430/arch.py index 1842f577..7c739561 100644 --- a/miasm2/arch/msp430/arch.py +++ b/miasm2/arch/msp430/arch.py @@ -59,7 +59,7 @@ sreg_p = (deref_pinc | deref_nooff | deref_off | base_expr).setParseAction(cb_ex class msp430_arg(m_arg): - def asm_ast_to_expr(self, value, symbol_pool): + def asm_ast_to_expr(self, value, loc_db): if isinstance(value, AstId): name = value.name if isinstance(name, Expr): @@ -69,17 +69,17 @@ class msp430_arg(m_arg): index = gpregs.str.index(name) reg = gpregs.expr[index] return reg - loc_key = symbol_pool.getby_name_create(value.name) + loc_key = loc_db.getby_name_create(value.name) return ExprLoc(loc_key, 16) if isinstance(value, AstOp): - args = [self.asm_ast_to_expr(tmp, symbol_pool) for tmp in value.args] + args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in value.args] if None in args: return None return ExprOp(value.op, *args) if isinstance(value, AstInt): return ExprInt(value.value, 16) if isinstance(value, AstMem): - ptr = self.asm_ast_to_expr(value.ptr, symbol_pool) + ptr = self.asm_ast_to_expr(value.ptr, loc_db) if ptr is None: return None return ExprMem(ptr, value.size) @@ -102,14 +102,14 @@ class instruction_msp430(instruction): return self.name in ['call'] @staticmethod - def arg2str(expr, index=None, symbol_pool=None): + def arg2str(expr, index=None, loc_db=None): if isinstance(expr, ExprId): o = str(expr) elif isinstance(expr, ExprInt): o = str(expr) elif expr.is_loc(): - if symbol_pool is not None: - return symbol_pool.str_loc_key(expr.loc_key) + if loc_db is not None: + return loc_db.str_loc_key(expr.loc_key) else: return str(expr) elif isinstance(expr, ExprOp) and expr.op == "autoinc": @@ -129,7 +129,7 @@ class instruction_msp430(instruction): return o - def dstflow2label(self, symbol_pool): + def dstflow2label(self, loc_db): expr = self.args[0] if not isinstance(expr, ExprInt): return @@ -138,7 +138,7 @@ class instruction_msp430(instruction): else: addr = expr.arg + int(self.offset) - loc_key = symbol_pool.getby_offset_create(addr) + loc_key = loc_db.getby_offset_create(addr) self.args[0] = ExprLoc(loc_key, expr.size) def breakflow(self): @@ -165,10 +165,10 @@ class instruction_msp430(instruction): def is_subcall(self): return self.name in ['call'] - def getdstflow(self, symbol_pool): + def getdstflow(self, loc_db): return [self.args[0]] - def get_symbol_size(self, symbol, symbol_pool): + def get_symbol_size(self, symbol, loc_db): return 16 def fixDstOffset(self): @@ -289,7 +289,7 @@ class mn_msp430(cls_mn): def reset_class(self): super(mn_msp430, self).reset_class() - def getnextflow(self, symbol_pool): + def getnextflow(self, loc_db): raise NotImplementedError('not fully functional') diff --git a/miasm2/arch/msp430/ira.py b/miasm2/arch/msp430/ira.py index 0f88facc..2a850d82 100644 --- a/miasm2/arch/msp430/ira.py +++ b/miasm2/arch/msp430/ira.py @@ -6,15 +6,15 @@ from miasm2.arch.msp430.sem import ir_msp430 class ir_a_msp430_base(ir_msp430, ira): - def __init__(self, symbol_pool=None): - ir_msp430.__init__(self, symbol_pool) + def __init__(self, loc_db=None): + ir_msp430.__init__(self, loc_db) self.ret_reg = self.arch.regs.R15 class ir_a_msp430(ir_a_msp430_base): - def __init__(self, symbol_pool=None): - ir_a_msp430_base.__init__(self, symbol_pool) + def __init__(self, loc_db=None): + ir_a_msp430_base.__init__(self, loc_db) def get_out_regs(self, _): return set([self.ret_reg, self.sp]) diff --git a/miasm2/arch/msp430/jit.py b/miasm2/arch/msp430/jit.py index dcd7e91a..9fbbc639 100644 --- a/miasm2/arch/msp430/jit.py +++ b/miasm2/arch/msp430/jit.py @@ -1,5 +1,5 @@ from miasm2.jitter.jitload import Jitter -from miasm2.core import asmblock +from miasm2.core.locationdb import LocationDB from miasm2.core.utils import pck16, upck16 from miasm2.arch.msp430.sem import ir_msp430 @@ -14,7 +14,7 @@ log.setLevel(logging.CRITICAL) class jitter_msp430(Jitter): def __init__(self, *args, **kwargs): - sp = asmblock.AsmSymbolPool() + sp = LocationDB() Jitter.__init__(self, ir_msp430(sp), *args, **kwargs) self.vm.set_little_endian() diff --git a/miasm2/arch/msp430/sem.py b/miasm2/arch/msp430/sem.py index a3521fb5..191abe75 100644 --- a/miasm2/arch/msp430/sem.py +++ b/miasm2/arch/msp430/sem.py @@ -423,8 +423,8 @@ def ComposeExprAff(dst, src): class ir_msp430(IntermediateRepresentation): - def __init__(self, symbol_pool=None): - IntermediateRepresentation.__init__(self, mn_msp430, None, symbol_pool) + def __init__(self, loc_db=None): + IntermediateRepresentation.__init__(self, mn_msp430, None, loc_db) self.pc = PC self.sp = SP self.IRDst = ExprId('IRDst', 16) diff --git a/miasm2/arch/ppc/arch.py b/miasm2/arch/ppc/arch.py index 5336ea21..94b2b903 100644 --- a/miasm2/arch/ppc/arch.py +++ b/miasm2/arch/ppc/arch.py @@ -34,23 +34,23 @@ deref = deref_reg | deref_reg_disp class ppc_arg(m_arg): - def asm_ast_to_expr(self, arg, symbol_pool): + def asm_ast_to_expr(self, arg, loc_db): if isinstance(arg, AstId): if isinstance(arg.name, ExprId): return arg.name if arg.name in gpregs.str: return None - loc_key = symbol_pool.getby_name_create(arg.name) + loc_key = loc_db.getby_name_create(arg.name) return ExprLoc(loc_key, 32) if isinstance(arg, AstOp): - args = [self.asm_ast_to_expr(tmp, symbol_pool) for tmp in arg.args] + args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args] if None in args: return None return ExprOp(arg.op, *args) if isinstance(arg, AstInt): return ExprInt(arg.value, 32) if isinstance(arg, AstMem): - ptr = self.asm_ast_to_expr(arg.ptr, symbol_pool) + ptr = self.asm_ast_to_expr(arg.ptr, loc_db) if ptr is None: return None return ExprMem(ptr, arg.size) @@ -73,7 +73,7 @@ class instruction_ppc(instruction): super(instruction_ppc, self).__init__(*args, **kargs) @staticmethod - def arg2str(e, pos = None, symbol_pool=None): + def arg2str(e, pos = None, loc_db=None): if isinstance(e, ExprId) or isinstance(e, ExprInt): return str(e) elif isinstance(e, ExprMem): @@ -109,7 +109,7 @@ class instruction_ppc(instruction): name[-3:] != 'CTR' and name[-4:] != 'CTRL') - def dstflow2label(self, symbol_pool): + def dstflow2label(self, loc_db): name = self.name if name[-1] == '+' or name[-1] == '-': name = name[:-1] @@ -131,7 +131,7 @@ class instruction_ppc(instruction): ad = e.arg + self.offset else: ad = e.arg - loc_key = symbol_pool.getby_offset_create(ad) + loc_key = loc_db.getby_offset_create(ad) s = ExprLoc(loc_key, e.size) self.args[address_index] = s @@ -144,7 +144,7 @@ class instruction_ppc(instruction): name = name[0:-1] return name[0] == 'B' and (name[-1] == 'L' or name[-2:-1] == 'LA') - def getdstflow(self, symbol_pool): + def getdstflow(self, loc_db): if 'LR' in self.name: return [ LR ] elif 'CTR' in self.name: @@ -163,7 +163,7 @@ class instruction_ppc(instruction): ret = ret or self.is_subcall() return ret - def get_symbol_size(self, symbol, symbol_pool): + def get_symbol_size(self, symbol, loc_db): return 32 def fixDstOffset(self): @@ -279,7 +279,7 @@ class mn_ppc(cls_mn): else: raise NotImplementedError("bad attrib") - def get_symbol_size(self, symbol, symbol_pool, mode): + def get_symbol_size(self, symbol, loc_db, mode): return 32 diff --git a/miasm2/arch/ppc/jit.py b/miasm2/arch/ppc/jit.py index e79faabd..14c203a9 100644 --- a/miasm2/arch/ppc/jit.py +++ b/miasm2/arch/ppc/jit.py @@ -1,5 +1,5 @@ from miasm2.jitter.jitload import Jitter, named_arguments -from miasm2.core import asmblock +from miasm2.core.locationdb import LocationDB from miasm2.arch.ppc.sem import ir_ppc32b import struct @@ -15,7 +15,7 @@ class jitter_ppc32b(Jitter): max_reg_arg = 8 def __init__(self, *args, **kwargs): - super(jitter_ppc32b, self).__init__(ir_ppc32b(asmblock.AsmSymbolPool()), + super(jitter_ppc32b, self).__init__(ir_ppc32b(LocationDB()), *args, **kwargs) self.vm.set_big_endian() diff --git a/miasm2/arch/ppc/sem.py b/miasm2/arch/ppc/sem.py index 8ddb43ef..77e4973a 100644 --- a/miasm2/arch/ppc/sem.py +++ b/miasm2/arch/ppc/sem.py @@ -606,8 +606,8 @@ def mn_do_store(ir, instr, arg1, arg2, arg3=None): ret.append(ExprAff(arg2, address)) if is_stwcx: - loc_do = ExprLoc(ir.symbol_pool.gen_loc_key(), ir.IRDst.size) - loc_dont = ExprLoc(ir.symbol_pool.gen_loc_key(), ir.IRDst.size) + loc_do = ExprLoc(ir.loc_db.gen_loc_key(), ir.IRDst.size) + loc_dont = ExprLoc(ir.loc_db.gen_loc_key(), ir.IRDst.size) loc_next = ExprLoc(ir.get_next_loc_key(instr), ir.IRDst.size) flags = [ ExprAff(CR0_LT, ExprInt(0,1)), ExprAff(CR0_GT, ExprInt(0,1)), @@ -842,8 +842,8 @@ sem_dir = { class ir_ppc32b(IntermediateRepresentation): - def __init__(self, symbol_pool=None): - super(ir_ppc32b, self).__init__(mn_ppc, 'b', symbol_pool) + def __init__(self, loc_db=None): + super(ir_ppc32b, self).__init__(mn_ppc, 'b', loc_db) self.pc = mn_ppc.getpc() self.sp = mn_ppc.getsp() self.IRDst = expr.ExprId('IRDst', 32) @@ -916,9 +916,9 @@ class ir_ppc32b(IntermediateRepresentation): return instr_ir, extra_ir def get_next_instr(self, instr): - l = self.symbol_pool.getby_offset_create(instr.offset + 4) + l = self.loc_db.getby_offset_create(instr.offset + 4) return l def get_next_break_loc_key(self, instr): - l = self.symbol_pool.getby_offset_create(instr.offset + 4) + l = self.loc_db.getby_offset_create(instr.offset + 4) return l diff --git a/miasm2/arch/sh4/arch.py b/miasm2/arch/sh4/arch.py index 477edeaf..46e316f8 100644 --- a/miasm2/arch/sh4/arch.py +++ b/miasm2/arch/sh4/arch.py @@ -96,23 +96,23 @@ dgbr_reg = (DEREF + LPARENT + reg_info_gbr.parser + COMMA + gpregs.parser + RPAR class sh4_arg(m_arg): - def asm_ast_to_expr(self, arg, symbol_pool): + def asm_ast_to_expr(self, arg, loc_db): if isinstance(arg, AstId): if isinstance(arg.name, ExprId): return arg.name if arg.name in gpregs.str: return None - loc_key = symbol_pool.getby_name_create(arg.name) + loc_key = loc_db.getby_name_create(arg.name) return ExprLoc(loc_key, 32) if isinstance(arg, AstOp): - args = [self.asm_ast_to_expr(tmp, symbol_pool) for tmp in arg.args] + args = [self.asm_ast_to_expr(tmp, loc_db) for tmp in arg.args] if None in args: return None return ExprOp(arg.op, *args) if isinstance(arg, AstInt): return ExprInt(arg.value, 32) if isinstance(arg, AstMem): - ptr = self.asm_ast_to_expr(arg.ptr, symbol_pool) + ptr = self.asm_ast_to_expr(arg.ptr, loc_db) if ptr is None: return None return ExprMem(ptr, arg.size) @@ -165,8 +165,8 @@ class sh4_freg(sh4_reg): class sh4_dgpreg(sh4_arg): parser = dgpregs_base - def fromstring(self, text, symbol_pool, parser_result=None): - start, stop = super(sh4_dgpreg, self).fromstring(text, symbol_pool, parser_result) + def fromstring(self, text, loc_db, parser_result=None): + start, stop = super(sh4_dgpreg, self).fromstring(text, loc_db, parser_result) if start is None or self.expr == [None]: return start, stop self.expr = ExprMem(self.expr.arg, self.sz) @@ -191,8 +191,8 @@ class sh4_dgpreg(sh4_arg): class sh4_dgpregpinc(sh4_arg): parser = dgpregs_p - def fromstring(self, text, symbol_pool, parser_result=None): - start, stop = super(sh4_dgpregpinc, self).fromstring(text, symbol_pool, parser_result) + def fromstring(self, text, loc_db, parser_result=None): + start, stop = super(sh4_dgpregpinc, self).fromstring(text, loc_db, parser_result) if self.expr == [None]: return None, None if not isinstance(self.expr.arg, ExprOp): @@ -406,12 +406,12 @@ class instruction_sh4(instruction): return self.name.startswith('J') @staticmethod - def arg2str(expr, index=None, symbol_pool=None): + def arg2str(expr, index=None, loc_db=None): if isinstance(expr, ExprId) or isinstance(expr, ExprInt): return str(expr) elif expr.is_loc(): - if symbol_pool is not None: - return symbol_pool.str_loc_key(expr.loc_key) + if loc_db is not None: + return loc_db.str_loc_key(expr.loc_key) else: return str(expr) assert(isinstance(expr, ExprMem)) @@ -435,7 +435,7 @@ class instruction_sh4(instruction): """ - def dstflow2label(self, symbol_pool): + def dstflow2label(self, loc_db): e = self.args[0] if not isinstance(e, ExprInt): return @@ -443,7 +443,7 @@ class instruction_sh4(instruction): ad = e.arg+8+self.offset else: ad = e.arg+8+self.offset - l = symbol_pool.getby_offset_create(ad) + l = loc_db.getby_offset_create(ad) s = ExprId(l, e.size) self.args[0] = s """ @@ -456,13 +456,13 @@ class instruction_sh4(instruction): def is_subcall(self): return self.name == 'JSR' - def getdstflow(self, symbol_pool): + def getdstflow(self, loc_db): return [self.args[0]] def splitflow(self): return self.name == 'JSR' - def get_symbol_size(self, symbol, symbol_pool): + def get_symbol_size(self, symbol, loc_db): return 32 def fixDstOffset(self): @@ -823,10 +823,10 @@ addop("bf", [bs('10001011'), s08imm]) return True def dstflow(self): return True - def dstflow2label(self, symbol_pool): + def dstflow2label(self, loc_db): e = self.args[0].expr ad = e.arg*2+4+self.offset - l = symbol_pool.getby_offset_create(ad) + l = loc_db.getby_offset_create(ad) s = ExprId(l, e.size) self.args[0].expr = s """ @@ -846,10 +846,10 @@ addop("bra", [bs('1010'), s12imm]) return True def dstflow(self): return True - def dstflow2label(self, symbol_pool): + def dstflow2label(self, loc_db): e = self.args[0].expr ad = e.arg*2+4+self.offset - l = symbol_pool.getby_offset_create(ad) + l = loc_db.getby_offset_create(ad) s = ExprId(l, e.size) self.args[0].expr = s """ diff --git a/miasm2/arch/x86/arch.py b/miasm2/arch/x86/arch.py index 2be64c0e..3a537c01 100644 --- a/miasm2/arch/x86/arch.py +++ b/miasm2/arch/x86/arch.py @@ -254,7 +254,7 @@ cl_or_imm |= base_expr class x86_arg(m_arg): - def asm_ast_to_expr(self, value, symbol_pool, size_hint=None, fixed_size=None): + def asm_ast_to_expr(self, value, loc_db, size_hint=None, fixed_size=None): if size_hint is None: size_hint = self.parent.v_opmode() if fixed_size is None: @@ -272,22 +272,22 @@ class x86_arg(m_arg): if value.name in ["FAR"]: return None - loc_key = symbol_pool.getby_name_create(value.name) + loc_key = loc_db.getby_name_create(value.name) return ExprLoc(loc_key, size_hint) if isinstance(value, AstOp): # First pass to retreive fixed_size if value.op == "segm": - segm = self.asm_ast_to_expr(value.args[0], symbol_pool) - ptr = self.asm_ast_to_expr(value.args[1], symbol_pool, None, fixed_size) + segm = self.asm_ast_to_expr(value.args[0], loc_db) + ptr = self.asm_ast_to_expr(value.args[1], loc_db, None, fixed_size) return ExprOp('segm', segm, ptr) - args = [self.asm_ast_to_expr(arg, symbol_pool, None, fixed_size) for arg in value.args] + args = [self.asm_ast_to_expr(arg, loc_db, None, fixed_size) for arg in value.args] if len(fixed_size) == 0: # No fixed size pass elif len(fixed_size) == 1: # One fixed size, regen all size = list(fixed_size)[0] - args = [self.asm_ast_to_expr(arg, symbol_pool, size, fixed_size) for arg in value.args] + args = [self.asm_ast_to_expr(arg, loc_db, size, fixed_size) for arg in value.args] else: raise ValueError("Size conflict") if None in args: @@ -299,7 +299,7 @@ class x86_arg(m_arg): return ExprInt(value.value, size_hint) if isinstance(value, AstMem): fixed_size.add(value.size) - ptr = self.asm_ast_to_expr(value.ptr, symbol_pool, None, set()) + ptr = self.asm_ast_to_expr(value.ptr, loc_db, None, set()) if ptr is None: return None return ExprMem(ptr, value.size) @@ -469,14 +469,14 @@ class instruction_x86(instruction): return True return self.name in ['CALL'] - def dstflow2label(self, symbol_pool): + def dstflow2label(self, loc_db): if self.additional_info.g1.value & 6 and self.name in repeat_mn: return expr = self.args[0] if not expr.is_int(): return addr = expr.arg + int(self.offset) - loc_key = symbol_pool.getby_offset_create(addr) + loc_key = loc_db.getby_offset_create(addr) self.args[0] = ExprLoc(loc_key, expr.size) def breakflow(self): @@ -511,14 +511,14 @@ class instruction_x86(instruction): def is_subcall(self): return self.name in ['CALL'] - def getdstflow(self, symbol_pool): + def getdstflow(self, loc_db): if self.additional_info.g1.value & 6 and self.name in repeat_mn: addr = int(self.offset) - loc_key = symbol_pool.getby_offset_create(addr) + loc_key = loc_db.getby_offset_create(addr) return [ExprLoc(loc_key, self.v_opmode())] return [self.args[0]] - def get_symbol_size(self, symbol, symbol_pool): + def get_symbol_size(self, symbol, loc_db): return self.mode def fixDstOffset(self): @@ -559,12 +559,12 @@ class instruction_x86(instruction): return args @staticmethod - def arg2str(expr, index=None, symbol_pool=None): + def arg2str(expr, index=None, loc_db=None): if expr.is_id() or expr.is_int(): o = str(expr) elif expr.is_loc(): - if symbol_pool is not None: - o = symbol_pool.str_loc_key(expr.loc_key) + if loc_db is not None: + o = loc_db.str_loc_key(expr.loc_key) else: o = str(expr) elif ((isinstance(expr, ExprOp) and expr.op == 'far' and @@ -668,7 +668,7 @@ class mn_x86(cls_mn): return [(subcls, name, bases, dct, fields)] @classmethod - def fromstring(cls, text, symbol_pool, mode): + def fromstring(cls, text, loc_db, mode): pref = 0 prefix, new_s = get_prefix(text) if prefix == "LOCK": @@ -680,7 +680,7 @@ class mn_x86(cls_mn): elif prefix == "REPE": pref |= 4 text = new_s - c = super(mn_x86, cls).fromstring(text, symbol_pool, mode) + c = super(mn_x86, cls).fromstring(text, loc_db, mode) c.additional_info.g1.value = pref return c @@ -877,7 +877,7 @@ class mn_x86(cls_mn): return None return prefix + v - def getnextflow(self, symbol_pool): + def getnextflow(self, loc_db): raise NotImplementedError('not fully functional') def ir_pre_instruction(self): @@ -1920,8 +1920,8 @@ def modrm2expr(modrm, parent, w8, sx=0, xmm=0, mm=0, bnd=0): class x86_rm_arg(x86_arg): parser = rmarg - def fromstring(self, text, symbol_pool, parser_result=None): - start, stop = super(x86_rm_arg, self).fromstring(text, symbol_pool, parser_result) + def fromstring(self, text, loc_db, parser_result=None): + start, stop = super(x86_rm_arg, self).fromstring(text, loc_db, parser_result) p = self.parent if start is None: return None, None @@ -2056,9 +2056,9 @@ class x86_rm_arg(x86_arg): yield x class x86_rm_mem(x86_rm_arg): - def fromstring(self, text, symbol_pool, parser_result=None): + def fromstring(self, text, loc_db, parser_result=None): self.expr = None - start, stop = super(x86_rm_mem, self).fromstring(text, symbol_pool, parser_result) + start, stop = super(x86_rm_mem, self).fromstring(text, loc_db, parser_result) if not isinstance(self.expr, ExprMem): return None, None return start, stop @@ -2066,9 +2066,9 @@ class x86_rm_mem(x86_rm_arg): class x86_rm_mem_far(x86_rm_arg): parser = mem_far - def fromstring(self, text, symbol_pool, parser_result=None): + def fromstring(self, text, loc_db, parser_result=None): self.expr = None - start, stop = super(x86_rm_mem_far, self).fromstring(text, symbol_pool, parser_result) + start, stop = super(x86_rm_mem_far, self).fromstring(text, loc_db, parser_result) if not isinstance(self.expr, ExprMem): return None, None self.expr = ExprOp('far', self.expr) @@ -2438,7 +2438,7 @@ class x86_rm_reg_noarg(object): parser = gpreg - def fromstring(self, text, symbol_pool, parser_result=None): + def fromstring(self, text, loc_db, parser_result=None): if not hasattr(self.parent, 'sx') and hasattr(self.parent, "w8"): self.parent.w8.value = 1 if parser_result: @@ -2455,7 +2455,7 @@ class x86_rm_reg_noarg(object): result, start, stop = self.parser.scanString(text).next() except StopIteration: return None, None - expr = self.asm_ast_to_expr(result[0], symbol_pool) + expr = self.asm_ast_to_expr(result[0], loc_db) if expr is None: return None, None @@ -2742,7 +2742,7 @@ class bs_cond_imm(bs_cond_scale, x86_arg): parser = base_expr max_size = 32 - def fromstring(self, text, symbol_pool, parser_result=None): + def fromstring(self, text, loc_db, parser_result=None): if parser_result: expr, start, stop = parser_result[self.parser] else: @@ -2869,7 +2869,7 @@ class bs_cond_imm64(bs_cond_imm): class bs_rel_off(bs_cond_imm): parser = base_expr - def fromstring(self, text, symbol_pool, parser_result=None): + def fromstring(self, text, loc_db, parser_result=None): if parser_result: expr, start, stop = parser_result[self.parser] else: @@ -3011,7 +3011,7 @@ class bs_moff(bsi): class bs_movoff(x86_arg): parser = deref_mem - def fromstring(self, text, symbol_pool, parser_result=None): + def fromstring(self, text, loc_db, parser_result=None): if parser_result: e, start, stop = parser_result[self.parser] if e is None: @@ -3078,7 +3078,7 @@ class bs_movoff(x86_arg): class bs_msegoff(x86_arg): parser = deref_ptr - def fromstring(self, text, symbol_pool, parser_result=None): + def fromstring(self, text, loc_db, parser_result=None): if parser_result: e, start, stop = parser_result[self.parser] if e is None: diff --git a/miasm2/arch/x86/ira.py b/miasm2/arch/x86/ira.py index d0bebfb6..be10213e 100644 --- a/miasm2/arch/x86/ira.py +++ b/miasm2/arch/x86/ira.py @@ -8,8 +8,8 @@ from miasm2.arch.x86.sem import ir_x86_16, ir_x86_32, ir_x86_64 class ir_a_x86_16(ir_x86_16, ira): - def __init__(self, symbol_pool=None): - ir_x86_16.__init__(self, symbol_pool) + def __init__(self, loc_db=None): + ir_x86_16.__init__(self, loc_db) self.ret_reg = self.arch.regs.AX def get_out_regs(self, _): @@ -17,8 +17,8 @@ class ir_a_x86_16(ir_x86_16, ira): class ir_a_x86_32(ir_x86_32, ir_a_x86_16): - def __init__(self, symbol_pool=None): - ir_x86_32.__init__(self, symbol_pool) + def __init__(self, loc_db=None): + ir_x86_32.__init__(self, loc_db) self.ret_reg = self.arch.regs.EAX def sizeof_char(self): @@ -39,8 +39,8 @@ class ir_a_x86_32(ir_x86_32, ir_a_x86_16): class ir_a_x86_64(ir_x86_64, ir_a_x86_16): - def __init__(self, symbol_pool=None): - ir_x86_64.__init__(self, symbol_pool) + def __init__(self, loc_db=None): + ir_x86_64.__init__(self, loc_db) self.ret_reg = self.arch.regs.RAX def call_effects(self, ad, instr): diff --git a/miasm2/arch/x86/jit.py b/miasm2/arch/x86/jit.py index 5485ed85..bf74051d 100644 --- a/miasm2/arch/x86/jit.py +++ b/miasm2/arch/x86/jit.py @@ -1,10 +1,10 @@ import logging from miasm2.jitter.jitload import Jitter, named_arguments -from miasm2.core import asmblock from miasm2.core.utils import pck16, pck32, pck64, upck16, upck32, upck64 from miasm2.arch.x86.sem import ir_x86_16, ir_x86_32, ir_x86_64 from miasm2.jitter.codegen import CGen +from miasm2.core.locationdb import LocationDB from miasm2.ir.translators.C import TranslatorC log = logging.getLogger('jit_x86') @@ -18,7 +18,7 @@ class x86_32_CGen(CGen): def __init__(self, ir_arch): self.ir_arch = ir_arch self.PC = self.ir_arch.arch.regs.RIP - self.translator = TranslatorC(self.ir_arch.symbol_pool) + self.translator = TranslatorC(self.ir_arch.loc_db) self.init_arch_C() def gen_post_code(self, attrib): @@ -39,7 +39,7 @@ class jitter_x86_16(Jitter): C_Gen = x86_32_CGen def __init__(self, *args, **kwargs): - sp = asmblock.AsmSymbolPool() + sp = LocationDB() Jitter.__init__(self, ir_x86_16(sp), *args, **kwargs) self.vm.set_little_endian() self.ir_arch.do_stk_segm = False @@ -71,7 +71,7 @@ class jitter_x86_32(Jitter): C_Gen = x86_32_CGen def __init__(self, *args, **kwargs): - sp = asmblock.AsmSymbolPool() + sp = LocationDB() Jitter.__init__(self, ir_x86_32(sp), *args, **kwargs) self.vm.set_little_endian() self.ir_arch.do_stk_segm = False @@ -187,7 +187,7 @@ class jitter_x86_64(Jitter): args_regs_stdcall = ['RCX', 'RDX', 'R8', 'R9'] def __init__(self, *args, **kwargs): - sp = asmblock.AsmSymbolPool() + sp = LocationDB() Jitter.__init__(self, ir_x86_64(sp), *args, **kwargs) self.vm.set_little_endian() self.ir_arch.do_stk_segm = False diff --git a/miasm2/arch/x86/sem.py b/miasm2/arch/x86/sem.py index 5989a0b4..f3ca3a62 100644 --- a/miasm2/arch/x86/sem.py +++ b/miasm2/arch/x86/sem.py @@ -5066,8 +5066,8 @@ mnemo_func = {'mov': mov, class ir_x86_16(IntermediateRepresentation): - def __init__(self, symbol_pool=None): - IntermediateRepresentation.__init__(self, mn_x86, 16, symbol_pool) + def __init__(self, loc_db=None): + IntermediateRepresentation.__init__(self, mn_x86, 16, loc_db) self.do_stk_segm = False self.do_ds_segm = False self.do_str_segm = False @@ -5214,8 +5214,8 @@ class ir_x86_16(IntermediateRepresentation): class ir_x86_32(ir_x86_16): - def __init__(self, symbol_pool=None): - IntermediateRepresentation.__init__(self, mn_x86, 32, symbol_pool) + def __init__(self, loc_db=None): + IntermediateRepresentation.__init__(self, mn_x86, 32, loc_db) self.do_stk_segm = False self.do_ds_segm = False self.do_str_segm = False @@ -5228,8 +5228,8 @@ class ir_x86_32(ir_x86_16): class ir_x86_64(ir_x86_16): - def __init__(self, symbol_pool=None): - IntermediateRepresentation.__init__(self, mn_x86, 64, symbol_pool) + def __init__(self, loc_db=None): + IntermediateRepresentation.__init__(self, mn_x86, 64, loc_db) self.do_stk_segm = False self.do_ds_segm = False self.do_str_segm = False diff --git a/miasm2/core/asmblock.py b/miasm2/core/asmblock.py index 2829737e..1aa057bd 100644 --- a/miasm2/core/asmblock.py +++ b/miasm2/core/asmblock.py @@ -36,7 +36,7 @@ class AsmRaw(object): def __str__(self): return repr(self.raw) - def to_string(self, symbol_pool): + def to_string(self, loc_db): return str(self) @@ -68,13 +68,13 @@ class AsmConstraint(object): label = property(get_label, set_label) - def to_string(self, symbol_pool=None): - if symbol_pool is None: + def to_string(self, loc_db=None): + if loc_db is None: return "%s:%s" % (self.c_t, self.loc_key) else: return "%s:%s" % ( self.c_t, - symbol_pool.str_loc_key(self.loc_key) + loc_db.str_loc_key(self.loc_key) ) def __str__(self): @@ -137,22 +137,22 @@ class AsmBlock(object): label = property(get_label) - def to_string(self, symbol_pool=None): + def to_string(self, loc_db=None): out = [] - if symbol_pool is None: + if loc_db is None: out.append(str(self.loc_key)) else: - out.append(symbol_pool.str_loc_key(self.loc_key)) + out.append(loc_db.str_loc_key(self.loc_key)) for instr in self.lines: - out.append(instr.to_string(symbol_pool)) + out.append(instr.to_string(loc_db)) if self.bto: lbls = ["->"] for dst in self.bto: if dst is None: lbls.append("Unknown? ") else: - lbls.append(dst.to_string(symbol_pool) + " ") + lbls.append(dst.to_string(loc_db) + " ") lbls = '\t'.join(lbls) out.append(lbls) return '\n'.join(out) @@ -167,12 +167,12 @@ class AsmBlock(object): assert isinstance(self.bto, set) self.bto.add(c) - def split(self, symbol_pool, offset): - loc_key = symbol_pool.getby_offset_create(offset) + def split(self, loc_db, offset): + loc_key = loc_db.getby_offset_create(offset) log_asmblock.debug('split at %x', offset) i = -1 offsets = [x.offset for x in self.lines] - offset = symbol_pool.loc_key_to_offset(loc_key) + offset = loc_db.loc_key_to_offset(loc_key) if offset not in offsets: log_asmblock.warning( 'cannot split bloc at %X ' % offset + @@ -376,7 +376,7 @@ class AsmCFG(DiGraph): AsmCFGPending = namedtuple("AsmCFGPending", ["waiter", "constraint"]) - def __init__(self, symbol_pool=None, *args, **kwargs): + def __init__(self, loc_db=None, *args, **kwargs): super(AsmCFG, self).__init__(*args, **kwargs) # Edges -> constraint self.edges2constraint = {} @@ -384,13 +384,13 @@ class AsmCFG(DiGraph): self._pendings = {} # Loc_Key2block built on the fly self._loc_key_to_block = {} - # symbol_pool - self.symbol_pool = symbol_pool + # loc_db + self.loc_db = loc_db def copy(self): """Copy the current graph instance""" - graph = self.__class__(self.symbol_pool) + graph = self.__class__(self.loc_db) return graph + self @@ -537,10 +537,10 @@ class AsmCFG(DiGraph): def node2lines(self, node): - if self.symbol_pool is None: + if self.loc_db is None: loc_key_name = str(node) else: - loc_key_name = self.symbol_pool.str_loc_key(node) + loc_key_name = self.loc_db.str_loc_key(node) yield self.DotCellDescription(text=loc_key_name, attr={'align': 'center', 'colspan': 2, @@ -561,9 +561,9 @@ class AsmCFG(DiGraph): if self._dot_offset: yield [self.DotCellDescription(text="%.8X" % line.offset, attr={}), - self.DotCellDescription(text=line.to_string(self.symbol_pool), attr={})] + self.DotCellDescription(text=line.to_string(self.loc_db), attr={})] else: - yield self.DotCellDescription(text=line.to_string(self.symbol_pool), attr={}) + yield self.DotCellDescription(text=line.to_string(self.loc_db), attr={}) def node_attr(self, node): block = self._loc_key_to_block.get(node, None) @@ -762,13 +762,13 @@ class AsmCFG(DiGraph): block.max_size = size log_asmblock.info("size: %d max: %d", block.size, block.max_size) - def apply_splitting(self, symbol_pool, dis_block_callback=None, **kwargs): + def apply_splitting(self, loc_db, dis_block_callback=None, **kwargs): """Consider @self' bto destinations and split block in @self if one of these destinations jumps in the middle of this block. In order to work, they must be only one block in @self per loc_key in - @symbol_pool (which is true if @self come from the same disasmEngine). + @loc_db (which is true if @self come from the same disasmEngine). - @symbol_pool: AsmSymbolPool instance associated with @self'loc_keys + @loc_db: LocationDB instance associated with @self'loc_keys @dis_block_callback: (optional) if set, this callback will be called on new block destinations @kwargs: (optional) named arguments to pass to dis_block_callback @@ -777,7 +777,7 @@ class AsmCFG(DiGraph): # offset block_dst = [] for loc_key in self.pendings: - offset = symbol_pool.loc_key_to_offset(loc_key) + offset = loc_db.loc_key_to_offset(loc_key) if offset is not None: block_dst.append(offset) @@ -793,8 +793,9 @@ class AsmCFG(DiGraph): if not (off > range_start and off < range_stop): continue - # `cur_block` must be splitted at offset `off` - new_b = cur_block.split(symbol_pool, off) + # `cur_block` must be splitted at offset `off`from miasm2.core.locationdb import LocationDB + + new_b = cur_block.split(loc_db, off) log_asmblock.debug("Split block %x", off) if new_b is None: log_asmblock.error("Cannot split %x!!", off) @@ -811,12 +812,12 @@ class AsmCFG(DiGraph): # The new block destinations may need to be disassembled if dis_block_callback: offsets_to_dis = set( - self.symbol_pool.loc_key_to_offset(constraint.loc_key) + self.loc_db.loc_key_to_offset(constraint.loc_key) for constraint in new_b.bto ) dis_block_callback(cur_bloc=new_b, offsets_to_dis=offsets_to_dis, - symbol_pool=symbol_pool, **kwargs) + loc_db=loc_db, **kwargs) # Update structure rebuild_needed = True @@ -929,16 +930,16 @@ def fix_expr_val(expr, symbols): return result -def fix_loc_offset(symbol_pool, loc_key, offset, modified): +def fix_loc_offset(loc_db, loc_key, offset, modified): """ Fix the @loc_key offset to @offset. If the @offset has changed, add @loc_key to @modified - @symbol_pool: current symbol_pool + @loc_db: current loc_db """ - loc_offset = symbol_pool.loc_key_to_offset(loc_key) + loc_offset = loc_db.loc_key_to_offset(loc_key) if loc_offset == offset: return - symbol_pool.set_offset(loc_key, offset) + loc_db.set_offset(loc_key, offset) modified.add(loc_key) @@ -946,8 +947,8 @@ class BlockChain(object): """Manage blocks linked with an asm_constraint_next""" - def __init__(self, symbol_pool, blocks): - self.symbol_pool = symbol_pool + def __init__(self, loc_db, blocks): + self.loc_db = loc_db self.blocks = blocks self.place() @@ -960,7 +961,7 @@ class BlockChain(object): self.pinned_block_idx = None for i, block in enumerate(self.blocks): loc_key = block.loc_key - if self.symbol_pool.loc_key_to_offset(loc_key) is not None: + if self.loc_db.loc_key_to_offset(loc_key) is not None: if self.pinned_block_idx is not None: raise ValueError("Multiples pinned block detected") self.pinned_block_idx = i @@ -979,7 +980,7 @@ class BlockChain(object): return loc = self.blocks[self.pinned_block_idx].loc_key - offset_base = self.symbol_pool.loc_key_to_offset(loc) + offset_base = self.loc_db.loc_key_to_offset(loc) assert(offset_base % self.blocks[self.pinned_block_idx].alignment == 0) self.offset_min = offset_base @@ -1008,25 +1009,25 @@ class BlockChain(object): # Propagate offset to blocks before pinned block pinned_block = self.blocks[self.pinned_block_idx] - offset = self.symbol_pool.loc_key_to_offset(pinned_block.loc_key) + offset = self.loc_db.loc_key_to_offset(pinned_block.loc_key) if offset % pinned_block.alignment != 0: raise RuntimeError('Bad alignment') for block in self.blocks[:self.pinned_block_idx - 1:-1]: new_offset = offset - block.size new_offset = new_offset - new_offset % pinned_block.alignment - fix_loc_offset(self.symbol_pool, + fix_loc_offset(self.loc_db, block.loc_key, new_offset, modified_loc_keys) # Propagate offset to blocks after pinned block - offset = self.symbol_pool.loc_key_to_offset(pinned_block.loc_key) + pinned_block.size + offset = self.loc_db.loc_key_to_offset(pinned_block.loc_key) + pinned_block.size last_block = pinned_block for block in self.blocks[self.pinned_block_idx + 1:]: offset += (- offset) % last_block.alignment - fix_loc_offset(self.symbol_pool, + fix_loc_offset(self.loc_db, block.loc_key, offset, modified_loc_keys) @@ -1039,8 +1040,8 @@ class BlockChainWedge(object): """Stand for wedges between blocks""" - def __init__(self, symbol_pool, offset, size): - self.symbol_pool = symbol_pool + def __init__(self, loc_db, offset, size): + self.loc_db = loc_db self.offset = offset self.max_size = size self.offset_min = offset @@ -1049,12 +1050,12 @@ class BlockChainWedge(object): def merge(self, chain): """Best effort merge two block chains Return the list of resulting blockchains""" - self.symbol_pool.set_offset(chain.blocks[0].loc_key, self.offset_max) + self.loc_db.set_offset(chain.blocks[0].loc_key, self.offset_max) chain.place() return [self, chain] -def group_constrained_blocks(symbol_pool, asmcfg): +def group_constrained_blocks(loc_db, asmcfg): """ Return the BlockChains list built from grouped blocks in asmcfg linked by asm_constraint_next @@ -1093,7 +1094,7 @@ def group_constrained_blocks(symbol_pool, asmcfg): out_block_chains = [] for loc_key in known_block_chains: - chain = BlockChain(symbol_pool, known_block_chains[loc_key]) + chain = BlockChain(loc_db, known_block_chains[loc_key]) out_block_chains.append(chain) return out_block_chains @@ -1113,7 +1114,7 @@ def get_blockchains_address_interval(blockChains, dst_interval): return allocated_interval -def resolve_symbol(blockChains, symbol_pool, dst_interval=None): +def resolve_symbol(blockChains, loc_db, dst_interval=None): """Place @blockChains in the @dst_interval""" log_asmblock.info('resolve_symbol') @@ -1131,7 +1132,7 @@ def resolve_symbol(blockChains, symbol_pool, dst_interval=None): # Add wedge in forbidden intervals for start, stop in forbidden_interval.intervals: wedge = BlockChainWedge( - symbol_pool, offset=start, size=stop + 1 - start) + loc_db, offset=start, size=stop + 1 - start) pinned_chains.append(wedge) # Try to place bigger blockChains first @@ -1174,8 +1175,8 @@ def get_block_loc_keys(block): return symbols -def assemble_block(mnemo, block, symbol_pool, conservative=False): - """Assemble a @block using @symbol_pool +def assemble_block(mnemo, block, loc_db, conservative=False): + """Assemble a @block using @loc_db @conservative: (optional) use original bytes when possible """ offset_i = 0 @@ -1186,7 +1187,7 @@ def assemble_block(mnemo, block, symbol_pool, conservative=False): # Fix special AsmRaw data = "" for expr in instr.raw: - expr_int = fix_expr_val(expr, symbol_pool) + expr_int = fix_expr_val(expr, loc_db) data += pck[expr_int.size](expr_int.arg) instr.data = data @@ -1196,16 +1197,16 @@ def assemble_block(mnemo, block, symbol_pool, conservative=False): # Assemble an instruction saved_args = list(instr.args) - instr.offset = symbol_pool.loc_key_to_offset(block.loc_key) + offset_i + instr.offset = loc_db.loc_key_to_offset(block.loc_key) + offset_i # Replace instruction's arguments by resolved ones - instr.args = instr.resolve_args_with_symbols(symbol_pool) + instr.args = instr.resolve_args_with_symbols(loc_db) if instr.dstflow(): instr.fixDstOffset() old_l = instr.l - cached_candidate, _ = conservative_asm(mnemo, instr, symbol_pool, + cached_candidate, _ = conservative_asm(mnemo, instr, loc_db, conservative) # Restore original arguments @@ -1219,8 +1220,8 @@ def assemble_block(mnemo, block, symbol_pool, conservative=False): offset_i += instr.l -def asmblock_final(mnemo, asmcfg, blockChains, symbol_pool, conservative=False): - """Resolve and assemble @blockChains using @symbol_pool until fixed point is +def asmblock_final(mnemo, asmcfg, blockChains, loc_db, conservative=False): + """Resolve and assemble @blockChains using @loc_db until fixed point is reached""" log_asmblock.debug("asmbloc_final") @@ -1267,36 +1268,36 @@ def asmblock_final(mnemo, asmcfg, blockChains, symbol_pool, conservative=False): while blocks_to_rework: block = blocks_to_rework.pop() - assemble_block(mnemo, block, symbol_pool, conservative) + assemble_block(mnemo, block, loc_db, conservative) -def asmbloc_final(mnemo, blocks, blockChains, symbol_pool, conservative=False): - """Resolve and assemble @blockChains using @symbol_pool until fixed point is +def asmbloc_final(mnemo, blocks, blockChains, loc_db, conservative=False): + """Resolve and assemble @blockChains using @loc_db until fixed point is reached""" warnings.warn('DEPRECATION WARNING: use "asmblock_final" instead of "asmbloc_final"') - asmblock_final(mnemo, blocks, blockChains, symbol_pool, conservative) + asmblock_final(mnemo, blocks, blockChains, loc_db, conservative) -def asm_resolve_final(mnemo, asmcfg, symbol_pool, dst_interval=None): - """Resolve and assemble @asmcfg using @symbol_pool into interval +def asm_resolve_final(mnemo, asmcfg, loc_db, dst_interval=None): + """Resolve and assemble @asmcfg using @loc_db into interval @dst_interval""" asmcfg.sanity_check() asmcfg.guess_blocks_size(mnemo) - blockChains = group_constrained_blocks(symbol_pool, asmcfg) + blockChains = group_constrained_blocks(loc_db, asmcfg) resolved_blockChains = resolve_symbol( blockChains, - symbol_pool, + loc_db, dst_interval ) - asmblock_final(mnemo, asmcfg, resolved_blockChains, symbol_pool) + asmblock_final(mnemo, asmcfg, resolved_blockChains, loc_db) patches = {} output_interval = interval() for block in asmcfg.blocks: - offset = symbol_pool.loc_key_to_offset(block.loc_key) + offset = loc_db.loc_key_to_offset(block.loc_key) for instr in block.lines: if not instr.data: # Empty line @@ -1335,7 +1336,7 @@ class disasmEngine(object): - blocs_wd: maximum number of distinct disassembled block + callback(arch, attrib, pool_bin, cur_bloc, offsets_to_dis, - symbol_pool) + loc_db) - dis_block_callback: callback after each new disassembled block """ @@ -1349,7 +1350,7 @@ class disasmEngine(object): self.arch = arch self.attrib = attrib self.bin_stream = bin_stream - self.symbol_pool = AsmSymbolPool() + self.loc_db = LocationDB() # Setup options self.dont_dis = [] @@ -1381,6 +1382,10 @@ class disasmEngine(object): warnings.warn("""DEPRECATION WARNING: "dis_bloc_callback" use dis_block_callback.""") self.dis_block_callback = function + @property + def symbol_pool(self): + warnings.warn("""DEPRECATION WARNING: use 'loc_db'""") + return self.loc_db # Deprecated job_done = property(get_job_done, set_job_done) @@ -1399,7 +1404,7 @@ class disasmEngine(object): delayslot_count = self.arch.delayslot offsets_to_dis = set() add_next_offset = False - loc_key = self.symbol_pool.getby_offset_create(offset) + loc_key = self.loc_db.getby_offset_create(offset) cur_block = AsmBlock(loc_key) log_asmblock.debug("dis at %X", int(offset)) while not in_delayslot or delayslot_count > 0: @@ -1414,12 +1419,12 @@ class disasmEngine(object): else: # Block is not empty, stop the desassembly pass and add a # constraint to the next block - loc_key_cst = self.symbol_pool.getby_offset_create(offset) + loc_key_cst = self.loc_db.getby_offset_create(offset) cur_block.add_cst(loc_key_cst, AsmConstraint.c_next) break if lines_cpt > 0 and offset in self.split_dis: - loc_key_cst = self.symbol_pool.getby_offset_create(offset) + loc_key_cst = self.loc_db.getby_offset_create(offset) cur_block.add_cst(loc_key_cst, AsmConstraint.c_next) offsets_to_dis.add(offset) break @@ -1430,7 +1435,7 @@ class disasmEngine(object): break if offset in job_done: - loc_key_cst = self.symbol_pool.getby_offset_create(offset) + loc_key_cst = self.loc_db.getby_offset_create(offset) cur_block.add_cst(loc_key_cst, AsmConstraint.c_next) break @@ -1457,7 +1462,7 @@ class disasmEngine(object): else: # Block is not empty, stop the desassembly pass and add a # constraint to the next block - loc_key_cst = self.symbol_pool.getby_offset_create(off_i) + loc_key_cst = self.loc_db.getby_offset_create(off_i) cur_block.add_cst(loc_key_cst, AsmConstraint.c_next) break @@ -1470,7 +1475,7 @@ class disasmEngine(object): else: # Block is not empty, stop the desassembly pass and add a # constraint to the next block - loc_key_cst = self.symbol_pool.getby_offset_create(off_i) + loc_key_cst = self.loc_db.getby_offset_create(off_i) cur_block.add_cst(loc_key_cst, AsmConstraint.c_next) break @@ -1493,14 +1498,14 @@ class disasmEngine(object): if instr.splitflow() and not (instr.is_subcall() and self.dontdis_retcall): add_next_offset = True if instr.dstflow(): - instr.dstflow2label(self.symbol_pool) - destinations = instr.getdstflow(self.symbol_pool) + instr.dstflow2label(self.loc_db) + destinations = instr.getdstflow(self.loc_db) known_dsts = [] for dst in destinations: if not dst.is_loc(): continue loc_key = dst.loc_key - loc_key_offset = self.symbol_pool.loc_key_to_offset(loc_key) + loc_key_offset = self.loc_db.loc_key_to_offset(loc_key) known_dsts.append(loc_key) if loc_key_offset in self.dont_dis_retcall_funcs: add_next_offset = False @@ -1512,11 +1517,11 @@ class disasmEngine(object): delayslot_count = instr.delayslot for c in cur_block.bto: - loc_key_offset = self.symbol_pool.loc_key_to_offset(c.loc_key) + loc_key_offset = self.loc_db.loc_key_to_offset(c.loc_key) offsets_to_dis.add(loc_key_offset) if add_next_offset: - loc_key_cst = self.symbol_pool.getby_offset_create(offset) + loc_key_cst = self.loc_db.getby_offset_create(offset) cur_block.add_cst(loc_key_cst, AsmConstraint.c_next) offsets_to_dis.add(offset) @@ -1527,7 +1532,9 @@ class disasmEngine(object): self.dis_block_callback(mn=self.arch, attrib=self.attrib, pool_bin=self.bin_stream, cur_bloc=cur_block, offsets_to_dis=offsets_to_dis, - symbol_pool=self.symbol_pool) + loc_db=self.loc_db, + # Deprecated API + symbol_pool=self.loc_db) return cur_block, offsets_to_dis def dis_block(self, offset): @@ -1557,7 +1564,7 @@ class disasmEngine(object): log_asmblock.info("dis bloc all") job_done = set() if blocks is None: - blocks = AsmCFG(self.symbol_pool) + blocks = AsmCFG(self.loc_db) todo = [offset] bloc_cpt = 0 @@ -1575,7 +1582,7 @@ class disasmEngine(object): todo += nexts blocks.add_block(cur_block) - blocks.apply_splitting(self.symbol_pool, + blocks.apply_splitting(self.loc_db, dis_block_callback=self.dis_block_callback, mn=self.arch, attrib=self.attrib, pool_bin=self.bin_stream) diff --git a/miasm2/core/cpu.py b/miasm2/core/cpu.py index 80f81aff..3b36c8d4 100644 --- a/miasm2/core/cpu.py +++ b/miasm2/core/cpu.py @@ -671,7 +671,7 @@ class bs_swapargs(bs_divert): class m_arg(object): - def fromstring(self, text, symbol_pool, parser_result=None): + def fromstring(self, text, loc_db, parser_result=None): if parser_result: e, start, stop = parser_result[self.parser] self.expr = e @@ -681,11 +681,11 @@ class m_arg(object): except StopIteration: return None, None arg = v[0] - expr = self.asm_ast_to_expr(arg, symbol_pool) + expr = self.asm_ast_to_expr(arg, loc_db) self.expr = expr return start, stop - def asm_ast_to_expr(self, arg, symbol_pool): + def asm_ast_to_expr(self, arg, loc_db): raise NotImplementedError("Virtual") @@ -708,7 +708,7 @@ class reg_noarg(object): reg_info = None parser = None - def fromstring(self, text, symbol_pool, parser_result=None): + def fromstring(self, text, loc_db, parser_result=None): if parser_result: e, start, stop = parser_result[self.parser] self.expr = e @@ -718,7 +718,7 @@ class reg_noarg(object): except StopIteration: return None, None arg = v[0] - expr = self.parses_to_expr(arg, symbol_pool) + expr = self.parses_to_expr(arg, loc_db) self.expr = expr return start, stop @@ -995,13 +995,13 @@ class instruction(object): def __str__(self): return self.to_string() - def to_string(self, symbol_pool=None): + def to_string(self, loc_db=None): o = "%-10s " % self.name args = [] for i, arg in enumerate(self.args): if not isinstance(arg, m2_expr.Expr): raise ValueError('zarb arg type') - x = self.arg2str(arg, i, symbol_pool) + x = self.arg2str(arg, i, loc_db) args.append(x) o += self.gen_args(args) return o @@ -1280,7 +1280,7 @@ class cls_mn(object): return out[0] @classmethod - def fromstring(cls, text, symbol_pool, mode = None): + def fromstring(cls, text, loc_db, mode = None): global total_scans name = re.search('(\S+)', text).groups() if not name: @@ -1320,11 +1320,11 @@ class cls_mn(object): if start != 0: v, start, stop = [None], None, None if v != [None]: - v = f.asm_ast_to_expr(v[0], symbol_pool) + v = f.asm_ast_to_expr(v[0], loc_db) if v is None: v, start, stop = [None], None, None parsers[(i, start_i)][p] = v, start, stop - start, stop = f.fromstring(args_str, symbol_pool, parsers[(i, start_i)]) + start, stop = f.fromstring(args_str, loc_db, parsers[(i, start_i)]) if start != 0: log.debug("cannot fromstring %r", args_str) cannot_parse = True @@ -1529,12 +1529,12 @@ class cls_mn(object): def parse_prefix(self, v): return 0 - def set_dst_symbol(self, symbol_pool): - dst = self.getdstflow(symbol_pool) + def set_dst_symbol(self, loc_db): + dst = self.getdstflow(loc_db) args = [] for d in dst: if isinstance(d, m2_expr.ExprInt): - l = symbol_pool.getby_offset_create(int(d)) + l = loc_db.getby_offset_create(int(d)) a = m2_expr.ExprId(l.name, d.size) else: @@ -1542,7 +1542,7 @@ class cls_mn(object): args.append(a) self.args_symb = args - def getdstflow(self, symbol_pool): + def getdstflow(self, loc_db): return [self.args[0].expr] @@ -1563,7 +1563,7 @@ class imm_noarg(object): return None return v - def fromstring(self, text, symbol_pool, parser_result=None): + def fromstring(self, text, loc_db, parser_result=None): if parser_result: e, start, stop = parser_result[self.parser] else: diff --git a/miasm2/core/parse_asm.py b/miasm2/core/parse_asm.py index 3b97cbb6..e40351cd 100644 --- a/miasm2/core/parse_asm.py +++ b/miasm2/core/parse_asm.py @@ -60,16 +60,16 @@ class DirectiveDontSplit(Directive): pass -def guess_next_new_label(symbol_pool): +def guess_next_new_label(loc_db): """Generate a new label - @symbol_pool: the AsmSymbolPool instance""" + @loc_db: the LocationDB instance""" i = 0 gen_name = "loc_%.8X" while True: name = gen_name % i - label = symbol_pool.getby_name(name) + label = loc_db.getby_name(name) if label is None: - return symbol_pool.add_location(name) + return loc_db.add_location(name) i += 1 @@ -77,30 +77,30 @@ STATE_NO_BLOC = 0 STATE_IN_BLOC = 1 -def asm_ast_to_expr_with_size(arg, symbol_pool, size): +def asm_ast_to_expr_with_size(arg, loc_db, size): if isinstance(arg, AstId): return ExprId(arg.name, size) if isinstance(arg, AstOp): - args = [asm_ast_to_expr_with_size(tmp, symbol_pool, size) for tmp in arg.args] + args = [asm_ast_to_expr_with_size(tmp, loc_db, size) for tmp in arg.args] return ExprOp(arg.op, *args) if isinstance(arg, AstInt): return ExprInt(arg.value, size) return None -def parse_txt(mnemo, attrib, txt, symbol_pool=None): - """Parse an assembly listing. Returns a couple (asmcfg, symbol_pool), where - asmcfg is an AsmCfg instance and symbol_pool the associated AsmSymbolPool +def parse_txt(mnemo, attrib, txt, loc_db=None): + """Parse an assembly listing. Returns a couple (asmcfg, loc_db), where + asmcfg is an AsmCfg instance and loc_db the associated LocationDB @mnemo: architecture used @attrib: architecture attribute @txt: assembly listing - @symbol_pool: (optional) the AsmSymbolPool instance used to handle labels + @loc_db: (optional) the LocationDB instance used to handle labels of the listing """ - if symbol_pool is None: - symbol_pool = asmblock.AsmSymbolPool() + if loc_db is None: + loc_db = asmblock.LocationDB() C_NEXT = asmblock.AsmConstraint.c_next C_TO = asmblock.AsmConstraint.c_to @@ -121,7 +121,7 @@ def parse_txt(mnemo, attrib, txt, symbol_pool=None): match_re = LABEL_RE.match(line) if match_re: label_name = match_re.group(1) - label = symbol_pool.getby_name_create(label_name) + label = loc_db.getby_name_create(label_name) lines.append(label) continue # directive @@ -158,7 +158,7 @@ def parse_txt(mnemo, attrib, txt, symbol_pool=None): for element in data_raw: element = element.strip() element_parsed = base_expr.parseString(element)[0] - element_expr = asm_ast_to_expr_with_size(element_parsed, symbol_pool, size) + element_expr = asm_ast_to_expr_with_size(element_parsed, loc_db, size) expr_list.append(element_expr) raw_data = asmblock.AsmRaw(expr_list) @@ -190,7 +190,7 @@ def parse_txt(mnemo, attrib, txt, symbol_pool=None): match_re = LABEL_RE.match(line) if match_re: label_name = match_re.group(1) - label = symbol_pool.getby_name_create(label_name) + label = loc_db.getby_name_create(label_name) lines.append(label) continue @@ -198,10 +198,10 @@ def parse_txt(mnemo, attrib, txt, symbol_pool=None): if ';' in line: line = line[:line.find(';')] line = line.strip(' ').strip('\t') - instr = mnemo.fromstring(line, symbol_pool, attrib) + instr = mnemo.fromstring(line, loc_db, attrib) if instr.dstflow(): - instr.dstflow2label(symbol_pool) + instr.dstflow2label(loc_db) lines.append(instr) asmblock.log_asmblock.info("___pre asm oki___") @@ -210,7 +210,7 @@ def parse_txt(mnemo, attrib, txt, symbol_pool=None): cur_block = None state = STATE_NO_BLOC i = 0 - asmcfg = asmblock.AsmCFG(symbol_pool) + asmcfg = asmblock.AsmCFG(loc_db) block_to_nlink = None delayslot = 0 while i < len(lines): @@ -232,7 +232,7 @@ def parse_txt(mnemo, attrib, txt, symbol_pool=None): elif not isinstance(line, LocKey): # First line must be a label. If it's not the case, generate # it. - loc = guess_next_new_label(symbol_pool) + loc = guess_next_new_label(loc_db) cur_block = asmblock.AsmBlock(loc, alignment=mnemo.alignment) else: cur_block = asmblock.AsmBlock(line, alignment=mnemo.alignment) @@ -281,7 +281,7 @@ def parse_txt(mnemo, attrib, txt, symbol_pool=None): if delayslot: raise RuntimeError("Cannot have breakflow in delayslot") if line.dstflow(): - for dst in line.getdstflow(symbol_pool): + for dst in line.getdstflow(loc_db): if not isinstance(dst, ExprId): continue if dst in mnemo.regs.all_regs_ids: @@ -302,4 +302,4 @@ def parse_txt(mnemo, attrib, txt, symbol_pool=None): # Log block asmblock.log_asmblock.info(block) - return asmcfg, symbol_pool + return asmcfg, loc_db diff --git a/miasm2/core/sembuilder.py b/miasm2/core/sembuilder.py index 530685db..a6ec40f0 100644 --- a/miasm2/core/sembuilder.py +++ b/miasm2/core/sembuilder.py @@ -146,12 +146,12 @@ class SemBuilder(object): loc_end_expr = "loc_end_expr = ExprLoc(loc_end, ir.IRDst.size)" out = ast.parse(loc_end).body out += ast.parse(loc_end_expr).body - loc_if = "loc_if = ir.symbol_pool.gen_loc_key()" + loc_if = "loc_if = ir.loc_db.gen_loc_key()" loc_if_expr = "loc_if_expr = ExprLoc(loc_if, ir.IRDst.size)" out += ast.parse(loc_if).body out += ast.parse(loc_if_expr).body if loc_else: - loc_else = "loc_else = ir.symbol_pool.gen_loc_key()" + loc_else = "loc_else = ir.loc_db.gen_loc_key()" loc_else_expr = "loc_else_expr = ExprLoc(loc_else, ir.IRDst.size)" out += ast.parse(loc_else).body out += ast.parse(loc_else_expr).body diff --git a/miasm2/ir/ir.py b/miasm2/ir/ir.py index 6084e67d..234be181 100644 --- a/miasm2/ir/ir.py +++ b/miasm2/ir/ir.py @@ -23,8 +23,8 @@ from itertools import chain import miasm2.expression.expression as m2_expr from miasm2.expression.expression_helper import get_missing_interval -from miasm2.core.asmblock import AsmSymbolPool, AsmBlock, \ - AsmConstraint, AsmBlockBad +from miasm2.core.asmblock import AsmBlock, AsmConstraint, AsmBlockBad +from miasm2.core.locationdb import LocationDB from miasm2.core.graph import DiGraph class AssignBlock(object): @@ -402,28 +402,28 @@ class DiGraphIR(DiGraph): """DiGraph for IR instances""" - def __init__(self, blocks, symbol_pool=None, *args, **kwargs): + def __init__(self, blocks, loc_db=None, *args, **kwargs): """Instanciate a DiGraphIR @blocks: IR blocks """ - self.symbol_pool = symbol_pool + self.loc_db = loc_db self._blocks = blocks super(DiGraphIR, self).__init__(*args, **kwargs) def _expr_loc_to_symb(self, expr): if not expr.is_loc(): return expr - if self.symbol_pool is None: + if self.loc_db is None: name = str(expr) else: - name = self.symbol_pool.loc_key_to_name(expr.loc_key) + name = self.loc_db.loc_key_to_name(expr.loc_key) return m2_expr.ExprId(name, expr.size) def node2lines(self, node): - if self.symbol_pool is None: + if self.loc_db is None: node_name = str(node) else: - node_name = self.symbol_pool.loc_key_to_name(node) + node_name = self.loc_db.loc_key_to_name(node) yield self.DotCellDescription( text="%s" % node_name, attr={ @@ -481,10 +481,10 @@ class IntermediateRepresentation(object): Allow native assembly to intermediate representation traduction """ - def __init__(self, arch, attrib, symbol_pool=None): - if symbol_pool is None: - symbol_pool = AsmSymbolPool() - self.symbol_pool = symbol_pool + def __init__(self, arch, attrib, loc_db=None): + if loc_db is None: + loc_db = LocationDB() + self.loc_db = loc_db self.blocks = {} self.pc = arch.getpc(attrib) self.sp = arch.getsp(attrib) @@ -498,6 +498,11 @@ class IntermediateRepresentation(object): warnings.warn('DEPRECATION WARNING: use ".blocks" instead of ".blocs"') return self.blocks + @property + def symbol_pool(self): + warnings.warn('DEPRECATION WARNING: use ".loc_db" instead of ".symbol_pool"') + return self.loc_db + def get_ir(self, instr): raise NotImplementedError("Abstract Method") @@ -525,7 +530,7 @@ class IntermediateRepresentation(object): except (ValueError, TypeError): return None - return self.symbol_pool.getby_offset_create(addr) + return self.loc_db.getby_offset_create(addr) def get_block(self, addr): """Returns the irbloc associated to an ExprId/ExprInt/loc_key/int @@ -546,7 +551,7 @@ class IntermediateRepresentation(object): def add_instr(self, line, loc_key=None, gen_pc_updt=False): if loc_key is None: - loc_key = self.symbol_pool.gen_loc_key() + loc_key = self.loc_db.gen_loc_key() block = AsmBlock(loc_key) block.lines = [line] self.add_block(block, gen_pc_updt) @@ -682,9 +687,9 @@ class IntermediateRepresentation(object): if block.lines: line = block.lines[-1] if line.offset is not None: - loc_key = self.symbol_pool.getby_offset_create(line.offset + line.l) + loc_key = self.loc_db.getby_offset_create(line.offset + line.l) if loc_key is None: - loc_key = self.symbol_pool.gen_loc_key() + loc_key = self.loc_db.gen_loc_key() block.add_cst(loc_key, AsmConstraint.c_next) else: loc_key = next_loc_key @@ -719,18 +724,18 @@ class IntermediateRepresentation(object): def get_loc_key_for_instr(self, instr): """Returns the loc_key associated to an instruction @instr: current instruction""" - return self.symbol_pool.getby_offset_create(instr.offset) + return self.loc_db.getby_offset_create(instr.offset) def gen_loc_key_and_expr(self, size): """ Return a loc_key and it's corresponding ExprLoc @size: size of expression """ - loc_key = self.symbol_pool.gen_loc_key() + loc_key = self.loc_db.gen_loc_key() return loc_key, m2_expr.ExprLoc(loc_key, size) def get_next_loc_key(self, instr): - loc_key = self.symbol_pool.getby_offset_create(instr.offset + instr.l) + loc_key = self.loc_db.getby_offset_create(instr.offset + instr.l) return loc_key def simplify(self, simplifier): @@ -814,13 +819,13 @@ class IntermediateRepresentation(object): """ Gen irbloc digraph """ - self._graph = DiGraphIR(self.blocks, self.symbol_pool) + self._graph = DiGraphIR(self.blocks, self.loc_db) for lbl, block in self.blocks.iteritems(): assert isinstance(lbl, m2_expr.LocKey) self._graph.add_node(lbl) for dst in self.dst_trackback(block): if dst.is_int(): - dst_lbl = self.symbol_pool.getby_offset_create(int(dst)) + dst_lbl = self.loc_db.getby_offset_create(int(dst)) dst = m2_expr.ExprLoc(dst_lbl.loc_key, self.pc.size) if dst.is_loc(): self._graph.add_edge(lbl, dst.loc_key) diff --git a/miasm2/ir/symbexec.py b/miasm2/ir/symbexec.py index c75bd9e8..09113311 100644 --- a/miasm2/ir/symbexec.py +++ b/miasm2/ir/symbexec.py @@ -19,7 +19,7 @@ def get_block(ir_arch, mdis, addr): """Get IRBlock at address @addr""" lbl = ir_arch.get_loc_key(addr) if not lbl in ir_arch.blocks: - offset = mdis.symbol_pool.loc_key_to_offset(lbl) + offset = mdis.loc_db.loc_key_to_offset(lbl) block = mdis.dis_block(offset) ir_arch.add_block(block) irblock = ir_arch.get_block(lbl) @@ -892,7 +892,7 @@ class SymbolicExecutionEngine(object): def eval_exprloc(self, expr, **kwargs): """[DEV]: Evaluate an ExprLoc using the current state""" - offset = self.ir_arch.symbol_pool.loc_key_to_offset(expr.loc_key) + offset = self.ir_arch.loc_db.loc_key_to_offset(expr.loc_key) if offset is not None: ret = ExprInt(offset, expr.size) else: diff --git a/miasm2/ir/symbexec_top.py b/miasm2/ir/symbexec_top.py index 64d428b4..e0976c9b 100644 --- a/miasm2/ir/symbexec_top.py +++ b/miasm2/ir/symbexec_top.py @@ -128,7 +128,7 @@ class SymbExecTopNoMem(SymbolicExecutionEngine): return ret def eval_exprloc(self, expr, **kwargs): - offset = self.ir_arch.symbol_pool.loc_key_to_offset(expr.loc_key) + offset = self.ir_arch.loc_db.loc_key_to_offset(expr.loc_key) if offset is not None: ret = ExprInt(offset, expr.size) else: diff --git a/miasm2/ir/translators/C.py b/miasm2/ir/translators/C.py index b7821e85..28222803 100644 --- a/miasm2/ir/translators/C.py +++ b/miasm2/ir/translators/C.py @@ -18,13 +18,13 @@ class TranslatorC(Translator): '>>>': 'rot_right', } - def __init__(self, symbol_pool=None, **kwargs): + def __init__(self, loc_db=None, **kwargs): """Instance a C translator - @symbol_pool: AsmSymbolPool instance + @loc_db: LocationDB instance """ super(TranslatorC, self).__init__(**kwargs) # symbol pool - self.symbol_pool = symbol_pool + self.loc_db = loc_db def _size2mask(self, size): """Return a C string corresponding to the size2mask operation, with support for @@ -52,10 +52,10 @@ class TranslatorC(Translator): def from_ExprLoc(self, expr): loc_key = expr.loc_key - if self.symbol_pool is None: + if self.loc_db is None: return str(loc_key) - offset = self.symbol_pool.loc_key_to_offset(loc_key) + offset = self.loc_db.loc_key_to_offset(loc_key) if offset is None: return str(loc_key) diff --git a/miasm2/ir/translators/smt2.py b/miasm2/ir/translators/smt2.py index f5d633e0..f5e69163 100644 --- a/miasm2/ir/translators/smt2.py +++ b/miasm2/ir/translators/smt2.py @@ -119,7 +119,7 @@ class TranslatorSMT2(Translator): # Implemented language __LANG__ = "smt2" - def __init__(self, endianness="<", symbol_pool=None, **kwargs): + def __init__(self, endianness="<", loc_db=None, **kwargs): """Instance a SMT2 translator @endianness: (optional) memory endianness """ @@ -129,7 +129,7 @@ class TranslatorSMT2(Translator): # map of translated bit vectors self._bitvectors = dict() # symbol pool - self.symbol_pool = symbol_pool + self.loc_db = loc_db def from_ExprInt(self, expr): return bit_vec_val(expr.arg.arg, expr.size) @@ -141,13 +141,13 @@ class TranslatorSMT2(Translator): def from_ExprLoc(self, expr): loc_key = expr.loc_key - if self.symbol_pool is None: + if self.loc_db is None: if str(loc_key) not in self._bitvectors: self._bitvectors[str(loc_key)] = expr.size return str(loc_key) - offset = self.symbol_pool.loc_key_to_offset(loc_key) - name = self.symbol_pool.loc_key_to_name(loc_key) + offset = self.loc_db.loc_key_to_offset(loc_key) + name = self.loc_db.loc_key_to_name(loc_key) if offset is None: return bit_vec_val(str(offset), expr.size) diff --git a/miasm2/ir/translators/z3_ir.py b/miasm2/ir/translators/z3_ir.py index d01b73fa..bfb29d06 100644 --- a/miasm2/ir/translators/z3_ir.py +++ b/miasm2/ir/translators/z3_ir.py @@ -115,7 +115,7 @@ class TranslatorZ3(Translator): # Operations translation trivial_ops = ["+", "-", "/", "%", "&", "^", "|", "*", "<<"] - def __init__(self, endianness="<", symbol_pool=None, **kwargs): + def __init__(self, endianness="<", loc_db=None, **kwargs): """Instance a Z3 translator @endianness: (optional) memory endianness """ @@ -125,8 +125,7 @@ class TranslatorZ3(Translator): super(TranslatorZ3, self).__init__(**kwargs) self._mem = Z3Mem(endianness) - # symbol pool - self.symbol_pool = symbol_pool + self.loc_db = loc_db def from_ExprInt(self, expr): return z3.BitVecVal(expr.arg.arg, expr.size) @@ -135,12 +134,12 @@ class TranslatorZ3(Translator): return z3.BitVec(str(expr), expr.size) def from_ExprLoc(self, expr): - if self.symbol_pool is None: - # No symbol_pool, fallback to default name + if self.loc_db is None: + # No loc_db, fallback to default name return z3.BitVec(str(expr), expr.size) loc_key = expr.loc_key - offset = self.symbol_pool.loc_key_to_offset(loc_key) - name = self.symbol_pool.loc_key_to_name(loc_key) + offset = self.loc_db.loc_key_to_offset(loc_key) + name = self.loc_db.loc_key_to_name(loc_key) if offset is not None: return z3.BitVecVal(offset, expr.size) if name is not None: diff --git a/miasm2/jitter/codegen.py b/miasm2/jitter/codegen.py index c9e98d93..cf8f1711 100644 --- a/miasm2/jitter/codegen.py +++ b/miasm2/jitter/codegen.py @@ -9,7 +9,7 @@ from miasm2.ir.ir import IRBlock, AssignBlock from miasm2.ir.translators.C import TranslatorC from miasm2.core.asmblock import AsmBlockBad -TRANSLATOR_NO_SYMBOL = TranslatorC(symbol_pool=None) +TRANSLATOR_NO_SYMBOL = TranslatorC(loc_db=None) SIZE_TO_MASK = {size: TRANSLATOR_NO_SYMBOL.from_expr(ExprInt(0, size).mask) for size in (1, 2, 3, 7, 8, 16, 32, 64, 128)} @@ -102,7 +102,7 @@ class CGen(object): def __init__(self, ir_arch): self.ir_arch = ir_arch self.PC = self.ir_arch.pc - self.translator = TranslatorC(self.ir_arch.symbol_pool) + self.translator = TranslatorC(self.ir_arch.loc_db) self.init_arch_C() def init_arch_C(self): @@ -143,7 +143,7 @@ class CGen(object): new_assignblk = dict(assignblk) if self.ir_arch.IRDst not in assignblk: offset = instr.offset + instr.l - loc_key = self.ir_arch.symbol_pool.getby_offset_create(offset) + loc_key = self.ir_arch.loc_db.getby_offset_create(offset) dst = ExprLoc(loc_key, self.ir_arch.IRDst.size) new_assignblk[self.ir_arch.IRDst] = dst irs = [AssignBlock(new_assignblk, instr)] @@ -290,12 +290,12 @@ class CGen(object): "((%s)?(%s):(%s))" % (cond, src1b, src2b)) if isinstance(expr, ExprInt): offset = int(expr) - loc_key = self.ir_arch.symbol_pool.getby_offset_create(offset) + loc_key = self.ir_arch.loc_db.getby_offset_create(offset) self.add_label_index(dst2index, loc_key) return ("%s" % dst2index[loc_key], hex(offset)) if expr.is_loc(): loc_key = expr.loc_key - offset = self.ir_arch.symbol_pool.loc_key_to_offset(expr.loc_key) + offset = self.ir_arch.loc_db.loc_key_to_offset(expr.loc_key) if offset is not None: self.add_label_index(dst2index, loc_key) return ("%s" % dst2index[loc_key], hex(offset)) @@ -339,7 +339,7 @@ class CGen(object): out.append( 'printf("%.8X %s\\n");' % ( instr_attrib.instr.offset, - instr_attrib.instr.to_string(self.ir_arch.symbol_pool) + instr_attrib.instr.to_string(self.ir_arch.loc_db) ) ) return out @@ -367,7 +367,7 @@ class CGen(object): return out assert isinstance(dst, LocKey) - offset = self.ir_arch.symbol_pool.loc_key_to_offset(dst) + offset = self.ir_arch.loc_db.loc_key_to_offset(dst) if offset is None: # Generate goto for local labels return ['goto %s;' % dst] @@ -518,7 +518,7 @@ class CGen(object): last_instr = block.lines[-1] offset = last_instr.offset + last_instr.l - return self.ir_arch.symbol_pool.getby_offset_create(offset) + return self.ir_arch.loc_db.getby_offset_create(offset) def gen_init(self, block): """ @@ -528,7 +528,7 @@ class CGen(object): instr_offsets = [line.offset for line in block.lines] post_label = self.get_block_post_label(block) - post_offset = self.ir_arch.symbol_pool.loc_key_to_offset(post_label) + post_offset = self.ir_arch.loc_db.loc_key_to_offset(post_label) instr_offsets.append(post_offset) lbl_start = block.loc_key return (self.CODE_INIT % lbl_start).split("\n"), instr_offsets @@ -564,7 +564,7 @@ class CGen(object): """ loc_key = self.get_block_post_label(block) - offset = self.ir_arch.symbol_pool.loc_key_to_offset(loc_key) + offset = self.ir_arch.loc_db.loc_key_to_offset(loc_key) dst = self.dst_to_c(offset) code = self.CODE_RETURN_NO_EXCEPTION % (loc_key, self.C_PC, dst, dst) return code.split('\n') diff --git a/miasm2/jitter/jitcore.py b/miasm2/jitter/jitcore.py index b636782d..8084fe56 100644 --- a/miasm2/jitter/jitcore.py +++ b/miasm2/jitter/jitcore.py @@ -63,7 +63,7 @@ class JitCore(object): self.mdis = disasmEngine( ir_arch.arch, ir_arch.attrib, bin_stream, lines_wd=self.options["jit_maxline"], - symbol_pool=ir_arch.symbol_pool, + loc_db=ir_arch.loc_db, follow_call=False, dontdis_retcall=False, split_dis=self.split_dis, @@ -101,7 +101,7 @@ class JitCore(object): cur_block.ad_max = cur_block.lines[-1].offset + cur_block.lines[-1].l else: # 1 byte block for unknown mnemonic - offset = ir_arch.symbol_pool.loc_key_to_offset(cur_block.loc_key) + offset = ir_arch.loc_db.loc_key_to_offset(cur_block.loc_key) cur_block.ad_min = offset cur_block.ad_max = offset+1 @@ -138,7 +138,7 @@ class JitCore(object): # Get the block if isinstance(addr, LocKey): - addr = self.ir_arch.symbol_pool.loc_key_to_offset(addr) + addr = self.ir_arch.loc_db.loc_key_to_offset(addr) if addr is None: raise RuntimeError("Unknown offset for LocKey") @@ -151,7 +151,7 @@ class JitCore(object): return cur_block # Logging if self.log_newbloc: - print cur_block.to_string(self.mdis.symbol_pool) + print cur_block.to_string(self.mdis.loc_db) # Update label -> block self.loc_key_to_block[cur_block.loc_key] = cur_block @@ -253,13 +253,13 @@ class JitCore(object): try: for irblock in block.blocks: # Remove offset -> jitted block link - offset = self.ir_arch.symbol_pool.loc_key_to_offset(irblock.loc_key) + offset = self.ir_arch.loc_db.loc_key_to_offset(irblock.loc_key) if offset in self.offset_to_jitted_func: del(self.offset_to_jitted_func[offset]) except AttributeError: # The block has never been translated in IR - offset = self.ir_arch.symbol_pool.loc_key_to_offset(block.loc_key) + offset = self.ir_arch.loc_db.loc_key_to_offset(block.loc_key) if offset in self.offset_to_jitted_func: del(self.offset_to_jitted_func[offset]) @@ -293,7 +293,7 @@ class JitCore(object): @block: asmblock """ block_raw = "".join(line.b for line in block.lines) - offset = self.ir_arch.symbol_pool.loc_key_to_offset(block.loc_key) + offset = self.ir_arch.loc_db.loc_key_to_offset(block.loc_key) block_hash = md5("%X_%s_%s_%s_%s" % (offset, self.arch_name, self.log_mn, diff --git a/miasm2/jitter/jitcore_gcc.py b/miasm2/jitter/jitcore_gcc.py index cd92bab1..c7ffdd01 100644 --- a/miasm2/jitter/jitcore_gcc.py +++ b/miasm2/jitter/jitcore_gcc.py @@ -28,7 +28,7 @@ class JitCore_Gcc(JitCore_Cc_Base): lib = ctypes.cdll.LoadLibrary(fname_so) 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) + offset = self.ir_arch.loc_db.loc_key_to_offset(label) self.offset_to_jitted_func[offset] = addr self.states[offset] = lib diff --git a/miasm2/jitter/jitcore_llvm.py b/miasm2/jitter/jitcore_llvm.py index bc921569..397c73f9 100644 --- a/miasm2/jitter/jitcore_llvm.py +++ b/miasm2/jitter/jitcore_llvm.py @@ -118,5 +118,5 @@ class JitCore_LLVM(jitcore.JitCore): # Store a pointer on the function jitted code loc_key = block.loc_key - offset = self.ir_arch.symbol_pool.loc_key_to_offset(loc_key) + offset = self.ir_arch.loc_db.loc_key_to_offset(loc_key) self.offset_to_jitted_func[offset] = ptr diff --git a/miasm2/jitter/jitcore_python.py b/miasm2/jitter/jitcore_python.py index 45b418b5..5ca07c38 100644 --- a/miasm2/jitter/jitcore_python.py +++ b/miasm2/jitter/jitcore_python.py @@ -127,7 +127,7 @@ class JitCore_Python(jitcore.JitCore): raise NotImplementedError("Type not handled: %s" % ad) # Associate myfunc with current loc_key - offset = self.ir_arch.symbol_pool.loc_key_to_offset(loc_key) + offset = self.ir_arch.loc_db.loc_key_to_offset(loc_key) assert offset is not None self.offset_to_jitted_func[offset] = myfunc diff --git a/miasm2/jitter/llvmconvert.py b/miasm2/jitter/llvmconvert.py index 16b08cf1..09aafa71 100644 --- a/miasm2/jitter/llvmconvert.py +++ b/miasm2/jitter/llvmconvert.py @@ -625,7 +625,7 @@ class LLVMFunction(): return ret if expr.is_loc(): - offset = self.llvm_context.ir_arch.symbol_pool.loc_key_to_offset(expr.loc_key) + offset = self.llvm_context.ir_arch.loc_db.loc_key_to_offset(expr.loc_key) ret = llvm_ir.Constant(LLVMType.IntType(expr.size), offset) self.update_cache(expr, ret) return ret @@ -1099,13 +1099,13 @@ class LLVMFunction(): self.main_stream = False if isinstance(dst, ExprInt): - loc_key = self.llvm_context.ir_arch.symbol_pool.getby_offset_create(int(dst)) + loc_key = self.llvm_context.ir_arch.loc_db.getby_offset_create(int(dst)) dst = ExprLoc(loc_key, dst.size) if isinstance(dst, ExprLoc): loc_key = dst.loc_key bbl = self.get_basic_block_by_loc_key(loc_key) - offset = self.llvm_context.ir_arch.symbol_pool.loc_key_to_offset(loc_key) + offset = self.llvm_context.ir_arch.loc_db.loc_key_to_offset(loc_key) if bbl is not None: # "local" jump, inside this function if offset is None: @@ -1234,7 +1234,7 @@ class LLVMFunction(): ExprId("status", 32)) self.affect(t_size(m2_csts.EXCEPT_UNK_MNEMO), m2_exception_flag) - offset = self.llvm_context.ir_arch.symbol_pool.loc_key_to_offset(asmblock.loc_key) + offset = self.llvm_context.ir_arch.loc_db.loc_key_to_offset(asmblock.loc_key) self.set_ret(LLVMType.IntType(64)(offset)) def gen_finalize(self, asmblock, codegen): @@ -1280,7 +1280,7 @@ class LLVMFunction(): # Else Block builder.position_at_end(else_block) PC = self.llvm_context.PC - next_label_offset = self.llvm_context.ir_arch.symbol_pool.loc_key_to_offset(next_label) + next_label_offset = self.llvm_context.ir_arch.loc_db.loc_key_to_offset(next_label) to_ret = LLVMType.IntType(PC.size)(next_label_offset) self.affect(to_ret, PC) self.set_ret(to_ret) @@ -1317,7 +1317,7 @@ class LLVMFunction(): # Create basic blocks (for label branchs) entry_bbl, builder = self.entry_bbl, self.builder for instr in asmblock.lines: - lbl = self.llvm_context.ir_arch.symbol_pool.getby_offset_create(instr.offset) + lbl = self.llvm_context.ir_arch.loc_db.getby_offset_create(instr.offset) self.append_basic_block(lbl) # TODO: merge duplicate code with CGen @@ -1333,7 +1333,7 @@ class LLVMFunction(): default_value=eltype(0)) self.local_vars_pointers[element.name] = ptr loc_key = codegen.get_block_post_label(asmblock) - offset = self.llvm_context.ir_arch.symbol_pool.loc_key_to_offset(loc_key) + offset = self.llvm_context.ir_arch.loc_db.loc_key_to_offset(loc_key) instr_offsets.append(offset) self.append_basic_block(loc_key) diff --git a/test/analysis/data_flow.py b/test/analysis/data_flow.py index d5b197d2..8204d9ce 100644 --- a/test/analysis/data_flow.py +++ b/test/analysis/data_flow.py @@ -1,11 +1,11 @@ """ Test cases for dead code elimination""" from miasm2.expression.expression import ExprId, ExprInt, ExprAff, ExprMem -from miasm2.core.asmblock import AsmSymbolPool +from miasm2.core.locationdb import LocationDB from miasm2.analysis.data_flow import * from miasm2.ir.analysis import ira from miasm2.ir.ir import IRBlock, AssignBlock -symbol_pool = AsmSymbolPool() +loc_db = LocationDB() a = ExprId("a", 32) b = ExprId("b", 32) @@ -26,13 +26,13 @@ CST1 = ExprInt(0x11, 32) CST2 = ExprInt(0x12, 32) CST3 = ExprInt(0x13, 32) -LBL0 = symbol_pool.add_location("lbl0", 0) -LBL1 = symbol_pool.add_location("lbl1", 1) -LBL2 = symbol_pool.add_location("lbl2", 2) -LBL3 = symbol_pool.add_location("lbl3", 3) -LBL4 = symbol_pool.add_location("lbl4", 4) -LBL5 = symbol_pool.add_location("lbl5", 5) -LBL6 = symbol_pool.add_location("lbl6", 6) +LBL0 = loc_db.add_location("lbl0", 0) +LBL1 = loc_db.add_location("lbl1", 1) +LBL2 = loc_db.add_location("lbl2", 2) +LBL3 = loc_db.add_location("lbl3", 3) +LBL4 = loc_db.add_location("lbl4", 4) +LBL5 = loc_db.add_location("lbl5", 5) +LBL6 = loc_db.add_location("lbl6", 6) IRDst = ExprId('IRDst', 32) dummy = ExprId('dummy', 32) @@ -68,9 +68,9 @@ class IRATest(ira): """Fake IRA class for tests""" - def __init__(self, symbol_pool=None): + def __init__(self, loc_db=None): arch = Arch() - super(IRATest, self).__init__(arch, 32, symbol_pool) + super(IRATest, self).__init__(arch, 32, loc_db) self.IRDst = IRDst self.ret_reg = r @@ -79,7 +79,7 @@ class IRATest(ira): # graph 1 : Simple graph with dead and alive variables -G1_IRA = IRATest(symbol_pool) +G1_IRA = IRATest(loc_db) G1_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)], [ExprAff(b, CST2)]]) G1_IRB1 = gen_irblock(LBL1, [[ExprAff(a, b)]]) @@ -91,7 +91,7 @@ G1_IRA.graph.add_uniq_edge(G1_IRB0.loc_key, G1_IRB1.loc_key) G1_IRA.graph.add_uniq_edge(G1_IRB1.loc_key, G1_IRB2.loc_key) # Expected output for graph 1 -G1_EXP_IRA = IRATest(symbol_pool) +G1_EXP_IRA = IRATest(loc_db) G1_EXP_IRB0 = gen_irblock(LBL0, [[], [ExprAff(b, CST2)]]) G1_EXP_IRB1 = gen_irblock(LBL1, [[ExprAff(a, b)]]) @@ -102,7 +102,7 @@ G1_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G1_EXP_IRB0, G1_EXP_IRB1, # graph 2 : Natural loop with dead variable -G2_IRA = IRATest(symbol_pool) +G2_IRA = IRATest(loc_db) G2_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)], [ExprAff(r, CST1)]]) G2_IRB1 = gen_irblock(LBL1, [[ExprAff(a, a+CST1)]]) @@ -115,7 +115,7 @@ G2_IRA.graph.add_uniq_edge(G2_IRB1.loc_key, G2_IRB2.loc_key) G2_IRA.graph.add_uniq_edge(G2_IRB1.loc_key, G2_IRB1.loc_key) # Expected output for graph 2 -G2_EXP_IRA = IRATest(symbol_pool) +G2_EXP_IRA = IRATest(loc_db) G2_EXP_IRB0 = gen_irblock(LBL0, [[], [ExprAff(r, CST1)]]) G2_EXP_IRB1 = gen_irblock(LBL1, [[]]) @@ -126,7 +126,7 @@ G2_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G2_EXP_IRB0, G2_EXP_IRB1, # graph 3 : Natural loop with alive variables -G3_IRA = IRATest(symbol_pool) +G3_IRA = IRATest(loc_db) G3_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)]]) G3_IRB1 = gen_irblock(LBL1, [[ExprAff(a, a+CST1)]]) @@ -139,7 +139,7 @@ G3_IRA.graph.add_uniq_edge(G3_IRB1.loc_key, G3_IRB2.loc_key) G3_IRA.graph.add_uniq_edge(G3_IRB1.loc_key, G3_IRB1.loc_key) # Expected output for graph 3 -G3_EXP_IRA = IRATest(symbol_pool) +G3_EXP_IRA = IRATest(loc_db) G3_EXP_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)]]) G3_EXP_IRB1 = gen_irblock(LBL1, [[ExprAff(a, a+CST1)]]) @@ -150,7 +150,7 @@ G3_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G3_EXP_IRB0, G3_EXP_IRB1, # graph 4 : If/else with dead variables -G4_IRA = IRATest(symbol_pool) +G4_IRA = IRATest(loc_db) G4_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)]]) G4_IRB1 = gen_irblock(LBL1, [[ExprAff(a, a+CST1)]]) @@ -166,7 +166,7 @@ G4_IRA.graph.add_uniq_edge(G4_IRB1.loc_key, G4_IRB3.loc_key) G4_IRA.graph.add_uniq_edge(G4_IRB2.loc_key, G4_IRB3.loc_key) # Expected output for graph 4 -G4_EXP_IRA = IRATest(symbol_pool) +G4_EXP_IRA = IRATest(loc_db) G4_EXP_IRB0 = gen_irblock(LBL0, [[]]) G4_EXP_IRB1 = gen_irblock(LBL1, [[]]) @@ -178,7 +178,7 @@ G4_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G4_EXP_IRB0, G4_EXP_IRB1, # graph 5 : Loop and If/else with dead variables -G5_IRA = IRATest(symbol_pool) +G5_IRA = IRATest(loc_db) G5_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)]]) G5_IRB1 = gen_irblock(LBL1, [[ExprAff(r, CST2)]]) @@ -199,7 +199,7 @@ G5_IRA.graph.add_uniq_edge(G5_IRB4.loc_key, G5_IRB5.loc_key) G5_IRA.graph.add_uniq_edge(G5_IRB4.loc_key, G5_IRB1.loc_key) # Expected output for graph 5 -G5_EXP_IRA = IRATest(symbol_pool) +G5_EXP_IRA = IRATest(loc_db) G5_EXP_IRB0 = gen_irblock(LBL0, [[]]) G5_EXP_IRB1 = gen_irblock(LBL1, [[ExprAff(r, CST2)]]) @@ -215,7 +215,7 @@ G5_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G5_EXP_IRB0, G5_EXP_IRB1, # graph 6 : Natural loop with dead variables symetric affectation # (a = b <-> b = a ) -G6_IRA = IRATest(symbol_pool) +G6_IRA = IRATest(loc_db) G6_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)]]) G6_IRB1 = gen_irblock(LBL1, [[ExprAff(b, a)]]) @@ -231,7 +231,7 @@ G6_IRA.graph.add_uniq_edge(G6_IRB2.loc_key, G6_IRB1.loc_key) G6_IRA.graph.add_uniq_edge(G6_IRB2.loc_key, G6_IRB3.loc_key) # Expected output for graph 6 -G6_EXP_IRA = IRATest(symbol_pool) +G6_EXP_IRA = IRATest(loc_db) G6_EXP_IRB0 = gen_irblock(LBL0, [[]]) G6_EXP_IRB1 = gen_irblock(LBL1, [[]]) @@ -243,7 +243,7 @@ G6_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G6_EXP_IRB0, G6_EXP_IRB1, # graph 7 : Double entry loop with dead variables -G7_IRA = IRATest(symbol_pool) +G7_IRA = IRATest(loc_db) G7_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)], [ExprAff(r, CST1)]]) G7_IRB1 = gen_irblock(LBL1, [[ExprAff(a, a+CST1)]]) @@ -261,7 +261,7 @@ G7_IRA.graph.add_uniq_edge(G7_IRB0.loc_key, G7_IRB2.loc_key) # Expected output for graph 7 -G7_EXP_IRA = IRATest(symbol_pool) +G7_EXP_IRA = IRATest(loc_db) G7_EXP_IRB0 = gen_irblock(LBL0, [[], [ExprAff(r, CST1)]]) G7_EXP_IRB1 = gen_irblock(LBL1, [[]]) @@ -273,7 +273,7 @@ G7_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G7_EXP_IRB0, G7_EXP_IRB1, # graph 8 : Nested loops with dead variables -G8_IRA = IRATest(symbol_pool) +G8_IRA = IRATest(loc_db) G8_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)], [ExprAff(b, CST1)]]) G8_IRB1 = gen_irblock(LBL1, [[ExprAff(a, a+CST1)]]) @@ -293,7 +293,7 @@ G8_IRA.graph.add_uniq_edge(G8_IRB3.loc_key, G8_IRB2.loc_key) # Expected output for graph 8 -G8_EXP_IRA = IRATest(symbol_pool) +G8_EXP_IRA = IRATest(loc_db) G8_EXP_IRB0 = gen_irblock(LBL0, [[], []]) G8_EXP_IRB1 = gen_irblock(LBL1, [[]]) @@ -305,7 +305,7 @@ G8_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G8_EXP_IRB0, G8_EXP_IRB1, # graph 9 : Miultiple-exits loops with dead variables -G9_IRA = IRATest(symbol_pool) +G9_IRA = IRATest(loc_db) G9_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)], [ExprAff(b, CST1)]]) G9_IRB1 = gen_irblock(LBL1, [[ExprAff(a, a+CST1)], [ExprAff(b, b+CST1)]]) @@ -328,7 +328,7 @@ G9_IRA.graph.add_uniq_edge(G9_IRB3.loc_key, G9_IRB4.loc_key) # Expected output for graph 9 -G9_EXP_IRA = IRATest(symbol_pool) +G9_EXP_IRA = IRATest(loc_db) G9_EXP_IRB0 = gen_irblock(LBL0, [[], [ExprAff(b, CST1)]]) G9_EXP_IRB1 = gen_irblock(LBL1, [[], [ExprAff(b, b+CST1)]]) @@ -343,7 +343,7 @@ G9_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G9_EXP_IRB0, G9_EXP_IRB1, # graph 10 : Natural loop with alive variables symetric affectation # (a = b <-> b = a ) -G10_IRA = IRATest(symbol_pool) +G10_IRA = IRATest(loc_db) G10_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)]]) G10_IRB1 = gen_irblock(LBL1, [[ExprAff(b, a)]]) @@ -359,7 +359,7 @@ G10_IRA.graph.add_uniq_edge(G10_IRB2.loc_key, G10_IRB1.loc_key) G10_IRA.graph.add_uniq_edge(G10_IRB2.loc_key, G10_IRB3.loc_key) # Expected output for graph 10 -G10_EXP_IRA = IRATest(symbol_pool) +G10_EXP_IRA = IRATest(loc_db) G10_EXP_IRB0 = gen_irblock(LBL0, [[]]) G10_EXP_IRB1 = gen_irblock(LBL1, [[]]) @@ -371,7 +371,7 @@ G10_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G10_EXP_IRB0, G10_EXP_IRB1, # graph 11 : If/Else conditions with alive variables -G11_IRA = IRATest(symbol_pool) +G11_IRA = IRATest(loc_db) G11_IRB0 = gen_irblock(LBL0, [[ExprAff(a, b)]]) G11_IRB1 = gen_irblock(LBL1, [[ExprAff(b, a)]]) @@ -390,7 +390,7 @@ G11_IRA.graph.add_uniq_edge(G11_IRB1.loc_key, G11_IRB2.loc_key) # Expected output for graph 11 -G11_EXP_IRA = IRATest(symbol_pool) +G11_EXP_IRA = IRATest(loc_db) G11_EXP_IRB0 = gen_irblock(LBL0, [[ExprAff(a, b)]]) G11_EXP_IRB1 = gen_irblock(LBL1, [[ExprAff(b, a)]]) @@ -404,7 +404,7 @@ G11_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G11_EXP_IRB0, G11_EXP_IRB1, # graph 12 : Graph with multiple out points and useless definitions # of return register -G12_IRA = IRATest(symbol_pool) +G12_IRA = IRATest(loc_db) G12_IRB0 = gen_irblock(LBL0, [[ExprAff(r, CST1)], [ExprAff(a, CST2)]]) G12_IRB1 = gen_irblock(LBL1, [[ExprAff(r, CST2)]]) @@ -423,7 +423,7 @@ G12_IRA.graph.add_uniq_edge(G12_IRB2.loc_key, G12_IRB4.loc_key) G12_IRA.graph.add_uniq_edge(G12_IRB4.loc_key, G12_IRB5.loc_key) # Expected output for graph 12 -G12_EXP_IRA = IRATest(symbol_pool) +G12_EXP_IRA = IRATest(loc_db) G12_EXP_IRB0 = gen_irblock(LBL0, [[], []]) G12_EXP_IRB1 = gen_irblock(LBL1, [[ExprAff(r, CST2)]]) @@ -439,7 +439,7 @@ G12_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G12_EXP_IRB0, G12_EXP_IRB1, # graph 13 : Graph where a leaf has lost its son -G13_IRA = IRATest(symbol_pool) +G13_IRA = IRATest(loc_db) G13_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)], [ExprAff(b, CST2)]]) G13_IRB1 = gen_irblock(LBL1, [[ExprAff(r, b)]]) @@ -457,7 +457,7 @@ G13_IRA.graph.add_uniq_edge(G13_IRB2.loc_key, G13_IRB3.loc_key) G13_IRA.graph.add_uniq_edge(G13_IRB4.loc_key, G13_IRB2.loc_key) # Expected output for graph 13 -G13_EXP_IRA = IRATest(symbol_pool) +G13_EXP_IRA = IRATest(loc_db) G13_EXP_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)], [ExprAff(b, CST2)]]) G13_EXP_IRB1 = gen_irblock(LBL1, [[ExprAff(r, b)]]) @@ -474,7 +474,7 @@ G13_EXP_IRA.blocks = {irb.loc_key: irb for irb in [G13_EXP_IRB0, G13_EXP_IRB1, # graph 14 : Graph where variable assigned multiple times in a block but still # useful in the end -G14_IRA = IRATest(symbol_pool) +G14_IRA = IRATest(loc_db) G14_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)], [ExprAff(c, a)], [ExprAff(a, CST2)]]) @@ -485,7 +485,7 @@ G14_IRA.blocks = {irb.loc_key : irb for irb in [G14_IRB0, G14_IRB1]} G14_IRA.graph.add_uniq_edge(G14_IRB0.loc_key, G14_IRB1.loc_key) # Expected output for graph 1 -G14_EXP_IRA = IRATest(symbol_pool) +G14_EXP_IRA = IRATest(loc_db) G14_EXP_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)], [ExprAff(c, a)], [ExprAff(a, CST2)]]) @@ -496,7 +496,7 @@ G14_EXP_IRA.blocks = {irb.loc_key: irb for irb in [G14_EXP_IRB0, G14_EXP_IRB1]} # graph 15 : Graph where variable assigned multiple and read at the same time, # but useless -G15_IRA = IRATest(symbol_pool) +G15_IRA = IRATest(loc_db) G15_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST2)], [ExprAff(a, CST1), ExprAff(b, a+CST2), @@ -508,7 +508,7 @@ G15_IRA.blocks = {irb.loc_key : irb for irb in [G15_IRB0, G15_IRB1]} G15_IRA.graph.add_uniq_edge(G15_IRB0.loc_key, G15_IRB1.loc_key) # Expected output for graph 1 -G15_EXP_IRA = IRATest(symbol_pool) +G15_EXP_IRA = IRATest(loc_db) G15_EXP_IRB0 = gen_irblock(LBL0, [[], [ExprAff(a, CST1)]]) G15_EXP_IRB1 = gen_irblock(LBL1, [[ExprAff(r, a)]]) @@ -517,7 +517,7 @@ G15_EXP_IRA.blocks = {irb.loc_key: irb for irb in [G15_EXP_IRB0, G15_EXP_IRB1]} # graph 16 : Graph where variable assigned multiple times in the same bloc -G16_IRA = IRATest(symbol_pool) +G16_IRA = IRATest(loc_db) G16_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1), ExprAff(b, CST2), ExprAff(c, CST3)], [ExprAff(a, c+CST1), @@ -533,7 +533,7 @@ G16_IRA.graph.add_uniq_edge(G16_IRB1.loc_key, G16_IRB2.loc_key) G16_IRA.blocks = {irb.loc_key : irb for irb in [G16_IRB0, G16_IRB1]} # Expected output for graph 1 -G16_EXP_IRA = IRATest(symbol_pool) +G16_EXP_IRA = IRATest(loc_db) G16_EXP_IRB0 = gen_irblock(LBL0, [[ExprAff(c, CST3)], [ExprAff(a, c + CST1), ExprAff(b, c + CST2)]]) @@ -543,7 +543,7 @@ G16_EXP_IRA.blocks = {irb.loc_key: irb for irb in [G16_EXP_IRB0, G16_EXP_IRB1]} # graph 17 : parallel ir -G17_IRA = IRATest(symbol_pool) +G17_IRA = IRATest(loc_db) G17_IRB0 = gen_irblock(LBL0, [[ExprAff(a, a*b), ExprAff(b, c), @@ -604,7 +604,7 @@ G17_IRA.blocks = {irb.loc_key : irb for irb in [G17_IRB0]} G17_IRA.graph.add_node(G17_IRB0.loc_key) # Expected output for graph 17 -G17_EXP_IRA = IRATest(symbol_pool) +G17_EXP_IRA = IRATest(loc_db) G17_EXP_IRB0 = gen_irblock(LBL0, [[], diff --git a/test/analysis/depgraph.py b/test/analysis/depgraph.py index 86857182..a7d3a148 100644 --- a/test/analysis/depgraph.py +++ b/test/analysis/depgraph.py @@ -1,7 +1,7 @@ """Regression test module for DependencyGraph""" from miasm2.expression.expression import ExprId, ExprInt, ExprAff, ExprCond, \ ExprLoc, LocKey -from miasm2.core.asmblock import AsmSymbolPool +from miasm2.core.locationdb import LocationDB from miasm2.ir.analysis import ira from miasm2.ir.ir import IRBlock, AssignBlock from miasm2.core.graph import DiGraph @@ -10,7 +10,7 @@ from itertools import count from pdb import pm import re -symbol_pool = AsmSymbolPool() +loc_db = LocationDB() EMULATION = True try: @@ -44,13 +44,13 @@ CST33 = ExprInt(0x33, 32) CST35 = ExprInt(0x35, 32) CST37 = ExprInt(0x37, 32) -LBL0 = symbol_pool.add_location("lbl0", 0) -LBL1 = symbol_pool.add_location("lbl1", 1) -LBL2 = symbol_pool.add_location("lbl2", 2) -LBL3 = symbol_pool.add_location("lbl3", 3) -LBL4 = symbol_pool.add_location("lbl4", 4) -LBL5 = symbol_pool.add_location("lbl5", 5) -LBL6 = symbol_pool.add_location("lbl6", 6) +LBL0 = loc_db.add_location("lbl0", 0) +LBL1 = loc_db.add_location("lbl1", 1) +LBL2 = loc_db.add_location("lbl2", 2) +LBL3 = loc_db.add_location("lbl3", 3) +LBL4 = loc_db.add_location("lbl4", 4) +LBL5 = loc_db.add_location("lbl5", 5) +LBL6 = loc_db.add_location("lbl6", 6) def gen_irblock(label, exprs_list): """ Returns an IRBlock. @@ -90,9 +90,9 @@ class IRATest(ira): """Fake IRA class for tests""" - def __init__(self, symbol_pool=None): + def __init__(self, loc_db=None): arch = Arch() - super(IRATest, self).__init__(arch, 32, symbol_pool) + super(IRATest, self).__init__(arch, 32, loc_db) self.IRDst = PC self.ret_reg = R @@ -116,7 +116,7 @@ def bloc2graph(irgraph, label=False, lines=True): out_blocks = [] for label in irgraph.graph.nodes(): if isinstance(label, LocKey): - label_name = irgraph.symbol_pool.loc_key_to_name(label) + label_name = irgraph.loc_db.loc_key_to_name(label) else: label_name = str(label) @@ -156,11 +156,11 @@ def bloc2graph(irgraph, label=False, lines=True): # Generate links for src, dst in irgraph.graph.edges(): if isinstance(src, LocKey): - src_name = irgraph.symbol_pool.loc_key_to_name(src) + src_name = irgraph.loc_db.loc_key_to_name(src) else: src_name = str(src) if isinstance(dst, LocKey): - dst_name = irgraph.symbol_pool.loc_key_to_name(dst) + dst_name = irgraph.loc_db.loc_key_to_name(dst) else: dst_name = str(dst) @@ -189,7 +189,7 @@ def dg2graph(graph, label=False, lines=True): out_blocks = [] for node in graph.nodes(): if isinstance(node, DependencyNode): - name = symbol_pool.loc_key_to_name(node.loc_key) + name = loc_db.loc_key_to_name(node.loc_key) node_name = "%s %s %s" % (name, node.element, node.line_nb) @@ -232,7 +232,7 @@ DNC3 = DependencyNode(LBL1, C, 0) # graph 1 -G1_IRA = IRATest(symbol_pool) +G1_IRA = IRATest(loc_db) G1_IRB0 = gen_irblock(LBL0, [[ExprAff(C, CST1)]]) G1_IRB1 = gen_irblock(LBL1, [[ExprAff(B, C)]]) @@ -245,7 +245,7 @@ G1_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G1_IRB0, G1_IRB1, G1_IRB2]] # graph 2 -G2_IRA = IRATest(symbol_pool) +G2_IRA = IRATest(loc_db) G2_IRB0 = gen_irblock(LBL0, [[ExprAff(C, CST1)]]) G2_IRB1 = gen_irblock(LBL1, [[ExprAff(B, CST2)]]) @@ -259,7 +259,7 @@ G2_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G2_IRB0, G2_IRB1, G2_IRB2]] # graph 3 -G3_IRA = IRATest(symbol_pool) +G3_IRA = IRATest(loc_db) G3_IRB0 = gen_irblock(LBL0, [[ExprAff(C, CST1)]]) G3_IRB1 = gen_irblock(LBL1, [[ExprAff(B, CST2)]]) @@ -276,7 +276,7 @@ G3_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G3_IRB0, G3_IRB1, # graph 4 -G4_IRA = IRATest(symbol_pool) +G4_IRA = IRATest(loc_db) G4_IRB0 = gen_irblock(LBL0, [[ExprAff(C, CST1)]]) G4_IRB1 = gen_irblock(LBL1, [[ExprAff(C, C + CST2)], @@ -295,7 +295,7 @@ G4_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G4_IRB0, G4_IRB1, G4_IRB2]] # graph 5 -G5_IRA = IRATest(symbol_pool) +G5_IRA = IRATest(loc_db) G5_IRB0 = gen_irblock(LBL0, [[ExprAff(B, CST1)]]) G5_IRB1 = gen_irblock(LBL1, [[ExprAff(B, B + CST2)], @@ -313,7 +313,7 @@ G5_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G5_IRB0, G5_IRB1, G5_IRB2]] # graph 6 -G6_IRA = IRATest(symbol_pool) +G6_IRA = IRATest(loc_db) G6_IRB0 = gen_irblock(LBL0, [[ExprAff(B, CST1)]]) G6_IRB1 = gen_irblock(LBL1, [[ExprAff(A, B)]]) @@ -325,7 +325,7 @@ G6_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G6_IRB0, G6_IRB1]]) # graph 7 -G7_IRA = IRATest(symbol_pool) +G7_IRA = IRATest(loc_db) G7_IRB0 = gen_irblock(LBL0, [[ExprAff(C, CST1)]]) G7_IRB1 = gen_irblock(LBL1, [[ExprAff(B, C)], [ExprAff(A, B)]]) @@ -339,7 +339,7 @@ G7_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G7_IRB0, G7_IRB1, G7_IRB2]] # graph 8 -G8_IRA = IRATest(symbol_pool) +G8_IRA = IRATest(loc_db) G8_IRB0 = gen_irblock(LBL0, [[ExprAff(C, CST1)]]) G8_IRB1 = gen_irblock(LBL1, [[ExprAff(B, C)], [ExprAff(C, D)]]) @@ -355,7 +355,7 @@ G8_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G8_IRB0, G8_IRB1, G8_IRB2]] # graph 10 -G10_IRA = IRATest(symbol_pool) +G10_IRA = IRATest(loc_db) G10_IRB1 = gen_irblock(LBL1, [[ExprAff(B, B + CST2)]]) G10_IRB2 = gen_irblock(LBL2, [[ExprAff(A, B)]]) @@ -367,7 +367,7 @@ G10_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G10_IRB1, G10_IRB2]]) # graph 11 -G11_IRA = IRATest(symbol_pool) +G11_IRA = IRATest(loc_db) G11_IRB0 = gen_irblock(LBL0, [[ExprAff(A, CST1), ExprAff(B, CST2)]]) @@ -383,7 +383,7 @@ G11_IRA.blocks = dict([(irb.loc_key, irb) # graph 12 -G12_IRA = IRATest(symbol_pool) +G12_IRA = IRATest(loc_db) G12_IRB0 = gen_irblock(LBL0, [[ExprAff(B, CST1)]]) G12_IRB1 = gen_irblock(LBL1, [[ExprAff(A, B)], [ExprAff(B, B + CST2)]]) @@ -399,7 +399,7 @@ G12_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G12_IRB0, G12_IRB1, # graph 13 -G13_IRA = IRATest(symbol_pool) +G13_IRA = IRATest(loc_db) G13_IRB0 = gen_irblock(LBL0, [[ExprAff(A, CST1)], #[ExprAff(B, A)], @@ -427,7 +427,7 @@ G13_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G13_IRB0, G13_IRB1, # graph 14 -G14_IRA = IRATest(symbol_pool) +G14_IRA = IRATest(loc_db) G14_IRB0 = gen_irblock(LBL0, [[ExprAff(A, CST1)], [ExprAff(G14_IRA.IRDst, @@ -457,7 +457,7 @@ G14_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G14_IRB0, G14_IRB1, # graph 16 -G15_IRA = IRATest(symbol_pool) +G15_IRA = IRATest(loc_db) G15_IRB0 = gen_irblock(LBL0, [[ExprAff(A, CST1)]]) G15_IRB1 = gen_irblock(LBL1, [[ExprAff(D, A + B)], @@ -474,7 +474,7 @@ G15_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G15_IRB0, G15_IRB1, # graph 16 -G16_IRA = IRATest(symbol_pool) +G16_IRA = IRATest(loc_db) G16_IRB0 = gen_irblock(LBL0, [[ExprAff(A, CST1)]]) G16_IRB1 = gen_irblock(LBL1, [[ExprAff(R, D)]]) @@ -498,7 +498,7 @@ G16_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G16_IRB0, G16_IRB1, # graph 17 -G17_IRA = IRATest(symbol_pool) +G17_IRA = IRATest(loc_db) G17_IRB0 = gen_irblock(LBL0, [[ExprAff(A, CST1), ExprAff(D, CST2)]]) @@ -642,7 +642,7 @@ def flatNode(node): element = int(node.element.arg) else: RuntimeError("Unsupported type '%s'" % type(enode.element)) - name = symbol_pool.loc_key_to_name(node.loc_key) + name = loc_db.loc_key_to_name(node.loc_key) return (name, element, node.line_nb) @@ -741,7 +741,7 @@ def match_results(resultsA, resultsB, nodes): def get_flat_init_depnodes(depnodes): out = [] for node in depnodes: - name = symbol_pool.loc_key_to_name(node.loc_key) + name = loc_db.loc_key_to_name(node.loc_key) out.append((name, node.element.name, node.line_nb, diff --git a/test/analysis/dse.py b/test/analysis/dse.py index 4367f6f7..56de4d4e 100644 --- a/test/analysis/dse.py +++ b/test/analysis/dse.py @@ -69,17 +69,17 @@ class DSETest(object): def asm(self): mn_x86 = self.machine.mn - blocks, symbol_pool = parse_asm.parse_txt( + blocks, loc_db = parse_asm.parse_txt( mn_x86, self.arch_attrib, self.TXT, - symbol_pool=self.myjit.ir_arch.symbol_pool + loc_db=self.myjit.ir_arch.loc_db ) # fix shellcode addr - symbol_pool.set_offset(symbol_pool.getby_name("main"), 0x0) + loc_db.set_offset(loc_db.getby_name("main"), 0x0) output = StrPatchwork() - patches = asm_resolve_final(mn_x86, blocks, symbol_pool) + patches = asm_resolve_final(mn_x86, blocks, loc_db) for offset, raw in patches.items(): output[offset] = raw diff --git a/test/arch/aarch64/arch.py b/test/arch/aarch64/arch.py index a6aa7ba5..cba175e6 100644 --- a/test/arch/aarch64/arch.py +++ b/test/arch/aarch64/arch.py @@ -2,9 +2,9 @@ import sys import time from pdb import pm from miasm2.arch.aarch64.arch import * -from miasm2.core.asmblock import AsmSymbolPool +from miasm2.core.locationdb import LocationDB -symbol_pool = AsmSymbolPool() +loc_db = LocationDB() reg_tests_aarch64 = [ ("XXXXXXXX MOV W1, WZR", @@ -1814,7 +1814,7 @@ for s, l in reg_tests_aarch64[:]: print s print mn assert(str(mn) == s) - l = mn_aarch64.fromstring(s, symbol_pool, 'l') + l = mn_aarch64.fromstring(s, loc_db, 'l') assert(str(l) == s) a = mn_aarch64.asm(l) print [x for x in a] diff --git a/test/arch/aarch64/unit/asm_test.py b/test/arch/aarch64/unit/asm_test.py index 437a8056..d3221ec0 100644 --- a/test/arch/aarch64/unit/asm_test.py +++ b/test/arch/aarch64/unit/asm_test.py @@ -22,12 +22,12 @@ class Asm_Test(object): self.check() def asm(self): - blocks, symbol_pool = parse_asm.parse_txt(mn_aarch64, 'l', self.TXT, - symbol_pool = self.myjit.ir_arch.symbol_pool) + blocks, loc_db = parse_asm.parse_txt(mn_aarch64, 'l', self.TXT, + loc_db = self.myjit.ir_arch.loc_db) # fix shellcode addr - symbol_pool.set_offset(symbol_pool.getby_name("main"), 0x0) + loc_db.set_offset(loc_db.getby_name("main"), 0x0) s = StrPatchwork() - patches = asmblock.asm_resolve_final(mn_aarch64, blocks, symbol_pool) + patches = asmblock.asm_resolve_final(mn_aarch64, blocks, loc_db) for offset, raw in patches.items(): s[offset] = raw diff --git a/test/arch/arm/arch.py b/test/arch/arm/arch.py index f69bb104..3550a816 100644 --- a/test/arch/arm/arch.py +++ b/test/arch/arm/arch.py @@ -1,10 +1,10 @@ import time from miasm2.arch.arm.arch import * -from miasm2.core.asmblock import AsmSymbolPool +from miasm2.core.locationdb import LocationDB from pdb import pm -symbol_pool = AsmSymbolPool() +loc_db = LocationDB() def h2i(s): return s.replace(' ', '').decode('hex') @@ -233,7 +233,7 @@ for s, l in reg_tests_arm: print s print mn assert(str(mn) == s) - l = mn_arm.fromstring(s, symbol_pool, 'l') + l = mn_arm.fromstring(s, loc_db, 'l') assert(str(l) == s) a = mn_arm.asm(l) print [x for x in a] @@ -681,7 +681,7 @@ for s, l in reg_tests_armt: print s print mn assert(str(mn) == s) - l = mn_armt.fromstring(s, symbol_pool, 'l') + l = mn_armt.fromstring(s, loc_db, 'l') assert(str(l) == s) print 'Asm..', l a = mn_armt.asm(l) diff --git a/test/arch/arm/sem.py b/test/arch/arm/sem.py index 05d26f5c..252e5954 100755 --- a/test/arch/arm/sem.py +++ b/test/arch/arm/sem.py @@ -9,13 +9,13 @@ from miasm2.arch.arm.arch import mn_arm as mn from miasm2.arch.arm.sem import ir_arml as ir_arch from miasm2.arch.arm.regs import * from miasm2.expression.expression import * -from miasm2.core.asmblock import AsmSymbolPool +from miasm2.core.locationdb import LocationDB from pdb import pm logging.getLogger('cpuhelper').setLevel(logging.ERROR) EXCLUDE_REGS = set([ir_arch().IRDst]) -symbol_pool = AsmSymbolPool() +loc_db = LocationDB() def M(addr): return ExprMem(ExprInt(addr, 16), 16) @@ -26,7 +26,7 @@ def compute(asm, inputstate={}, debug=False): sympool.update({k: ExprInt(v, k.size) for k, v in inputstate.iteritems()}) interm = ir_arch() symexec = SymbolicExecutionEngine(interm, sympool) - instr = mn.fromstring(asm, symbol_pool, "l") + instr = mn.fromstring(asm, loc_db, "l") code = mn.asm(instr)[0] instr = mn.dis(code, "l") instr.offset = inputstate.get(PC, 0) diff --git a/test/arch/mips32/arch.py b/test/arch/mips32/arch.py index 6fc36d13..1cbb554d 100644 --- a/test/arch/mips32/arch.py +++ b/test/arch/mips32/arch.py @@ -1,10 +1,10 @@ import time from pdb import pm -from miasm2.core.asmblock import AsmSymbolPool +from miasm2.core.locationdb import LocationDB from miasm2.arch.mips32.arch import * -symbol_pool = AsmSymbolPool() +loc_db = LocationDB() reg_tests_mips32 = [ ("004496D8 ADDU GP, GP, T9", @@ -228,7 +228,7 @@ for s, l in reg_tests_mips32: print s print mn assert(str(mn) == s) - l = mn_mips32.fromstring(s, symbol_pool, 'b') + l = mn_mips32.fromstring(s, loc_db, 'b') assert(str(l) == s) a = mn_mips32.asm(l, 'b') print [x for x in a] diff --git a/test/arch/mips32/unit/asm_test.py b/test/arch/mips32/unit/asm_test.py index a2203783..be26bf49 100644 --- a/test/arch/mips32/unit/asm_test.py +++ b/test/arch/mips32/unit/asm_test.py @@ -24,12 +24,12 @@ class Asm_Test(object): self.check() def asm(self): - blocks, symbol_pool = parse_asm.parse_txt(mn_mips32, 'l', self.TXT, - symbol_pool=self.myjit.ir_arch.symbol_pool) + blocks, loc_db = parse_asm.parse_txt(mn_mips32, 'l', self.TXT, + loc_db=self.myjit.ir_arch.loc_db) # fix shellcode addr - symbol_pool.set_offset(symbol_pool.getby_name("main"), 0x0) + loc_db.set_offset(loc_db.getby_name("main"), 0x0) s = StrPatchwork() - patches = asmblock.asm_resolve_final(mn_mips32, blocks, symbol_pool) + patches = asmblock.asm_resolve_final(mn_mips32, blocks, loc_db) for offset, raw in patches.items(): s[offset] = raw diff --git a/test/arch/msp430/arch.py b/test/arch/msp430/arch.py index 08e5bdae..91de95b3 100644 --- a/test/arch/msp430/arch.py +++ b/test/arch/msp430/arch.py @@ -1,9 +1,9 @@ import time from pdb import pm from miasm2.arch.msp430.arch import * -from miasm2.core.asmblock import AsmSymbolPool +from miasm2.core.locationdb import LocationDB -symbol_pool = AsmSymbolPool() +loc_db = LocationDB() def h2i(s): return s.replace(' ', '').decode('hex') @@ -95,7 +95,7 @@ for s, l in reg_tests_msp: print s print mn assert(str(mn) == s) - l = mn_msp430.fromstring(s, symbol_pool, None) + l = mn_msp430.fromstring(s, loc_db, None) assert(str(l) == s) a = mn_msp430.asm(l) print [x for x in a] diff --git a/test/arch/sh4/arch.py b/test/arch/sh4/arch.py index 9162fdbc..f744b215 100644 --- a/test/arch/sh4/arch.py +++ b/test/arch/sh4/arch.py @@ -2,9 +2,9 @@ import time from pdb import pm from sys import stderr from miasm2.arch.sh4.arch import * -from miasm2.core.asmblock import AsmSymbolPool +from miasm2.core.locationdb import LocationDB -symbol_pool = AsmSymbolPool() +loc_db = LocationDB() def h2i(s): return s.replace(' ', '').decode('hex') @@ -398,7 +398,7 @@ for s, l in reg_tests_sh4: print s print mn assert(str(mn) == s) - l = mn_sh4.fromstring(s, symbol_pool, None) + l = mn_sh4.fromstring(s, loc_db, None) assert(str(l) == s) a = mn_sh4.asm(l) print [x for x in a] diff --git a/test/arch/x86/arch.py b/test/arch/x86/arch.py index 1865ceba..43e973e1 100644 --- a/test/arch/x86/arch.py +++ b/test/arch/x86/arch.py @@ -5,9 +5,9 @@ from miasm2.arch.x86.arch import mn_x86, deref_mem_ad, \ base_expr, rmarg, print_size from miasm2.arch.x86.sem import ir_x86_16, ir_x86_32, ir_x86_64 from miasm2.core.bin_stream import bin_stream_str -from miasm2.core.asmblock import AsmSymbolPool +from miasm2.core.locationdb import LocationDB -symbol_pool = AsmSymbolPool() +loc_db = LocationDB() mylabel16 = m2_expr.ExprId('mylabel16', 16) mylabel32 = m2_expr.ExprId('mylabel32', 32) @@ -3063,7 +3063,7 @@ for mode, s, l, in reg_tests: print mn assert(str(mn).strip() == s) print 'fromstring', repr(s) - l = mn_x86.fromstring(s, symbol_pool, mode) + l = mn_x86.fromstring(s, loc_db, mode) print 'str args', [(str(x), x.size) for x in l.args] assert(str(l).strip(' ') == s) a = mn_x86.asm(l) diff --git a/test/arch/x86/sem.py b/test/arch/x86/sem.py index baa05341..23b22245 100755 --- a/test/arch/x86/sem.py +++ b/test/arch/x86/sem.py @@ -14,13 +14,13 @@ from miasm2.arch.x86.regs import * from miasm2.expression.expression import * from miasm2.expression.simplifications import expr_simp from miasm2.core import parse_asm, asmblock -from miasm2.core.asmblock import AsmSymbolPool +from miasm2.core.locationdb import LocationDB logging.getLogger('cpuhelper').setLevel(logging.ERROR) EXCLUDE_REGS = set([ir_32().IRDst, ir_64().IRDst]) -symbol_pool = AsmSymbolPool() +loc_db = LocationDB() m32 = 32 m64 = 64 @@ -38,7 +38,7 @@ def symb_exec(lbl, interm, inputstate, debug): if k not in EXCLUDE_REGS and regs_init.get(k, None) != v} def compute(ir, mode, asm, inputstate={}, debug=False): - instr = mn.fromstring(asm, symbol_pool, mode) + instr = mn.fromstring(asm, loc_db, mode) code = mn.asm(instr)[0] instr = mn.dis(code, mode) instr.offset = inputstate.get(EIP, 0) @@ -48,11 +48,11 @@ def compute(ir, mode, asm, inputstate={}, debug=False): def compute_txt(ir, mode, txt, inputstate={}, debug=False): - asmcfg, symbol_pool = parse_asm.parse_txt(mn, mode, txt) - symbol_pool.set_offset(symbol_pool.getby_name("main"), 0x0) - patches = asmblock.asm_resolve_final(mn, asmcfg, symbol_pool) - interm = ir(symbol_pool) - lbl = symbol_pool.getby_name("main") + asmcfg, loc_db = parse_asm.parse_txt(mn, mode, txt) + loc_db.set_offset(loc_db.getby_name("main"), 0x0) + patches = asmblock.asm_resolve_final(mn, asmcfg, loc_db) + interm = ir(loc_db) + lbl = loc_db.getby_name("main") for bbl in asmcfg.blocks: interm.add_block(bbl) return symb_exec(lbl, interm, inputstate, debug) diff --git a/test/arch/x86/unit/asm_test.py b/test/arch/x86/unit/asm_test.py index 4b802606..e626768d 100644 --- a/test/arch/x86/unit/asm_test.py +++ b/test/arch/x86/unit/asm_test.py @@ -40,12 +40,12 @@ class Asm_Test(object): assert(self.myjit.pc == self.ret_addr) def asm(self): - blocks, symbol_pool = parse_asm.parse_txt(mn_x86, self.arch_attrib, self.TXT, - symbol_pool = self.myjit.ir_arch.symbol_pool) + blocks, loc_db = parse_asm.parse_txt(mn_x86, self.arch_attrib, self.TXT, + loc_db = self.myjit.ir_arch.loc_db) # fix shellcode addr - symbol_pool.set_offset(symbol_pool.getby_name("main"), 0x0) + loc_db.set_offset(loc_db.getby_name("main"), 0x0) s = StrPatchwork() - patches = asmblock.asm_resolve_final(mn_x86, blocks, symbol_pool) + patches = asmblock.asm_resolve_final(mn_x86, blocks, loc_db) for offset, raw in patches.items(): s[offset] = raw diff --git a/test/arch/x86/unit/mn_cdq.py b/test/arch/x86/unit/mn_cdq.py index 15b73913..947b40bb 100644 --- a/test/arch/x86/unit/mn_cdq.py +++ b/test/arch/x86/unit/mn_cdq.py @@ -10,7 +10,7 @@ class Test_CBW_16(Asm_Test_16): MYSTRING = "test CBW 16" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.myjit.cpu.EAX = 0x87654321 @@ -31,7 +31,7 @@ class Test_CBW_16_signed(Asm_Test_16): MYSTRING = "test CBW 16 signed" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.myjit.cpu.EAX = 0x87654381 @@ -52,7 +52,7 @@ class Test_CBW_32(Asm_Test_32): MYSTRING = "test CBW 32" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.myjit.cpu.EAX = 0x87654321 @@ -73,7 +73,7 @@ class Test_CBW_32_signed(Asm_Test_32): MYSTRING = "test CBW 32 signed" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.myjit.cpu.EAX = 0x87654381 @@ -94,7 +94,7 @@ class Test_CDQ_32(Asm_Test_32): MYSTRING = "test cdq 32" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.myjit.cpu.EAX = 0x77654321 @@ -115,7 +115,7 @@ class Test_CDQ_32_signed(Asm_Test_32): MYSTRING = "test cdq 32 signed" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.myjit.cpu.EAX = 0x87654321 @@ -136,7 +136,7 @@ class Test_CDQ_64(Asm_Test_64): MYSTRING = "test cdq 64" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.myjit.cpu.RAX = 0x1234567877654321 @@ -157,7 +157,7 @@ class Test_CDQ_64_signed(Asm_Test_64): MYSTRING = "test cdq 64 signed" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.myjit.cpu.RAX = 0x1234567887654321 @@ -178,7 +178,7 @@ class Test_CDQE_64(Asm_Test_64): MYSTRING = "test cdq 64" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.myjit.cpu.RAX = 0x1234567877654321 @@ -199,7 +199,7 @@ class Test_CDQE_64_signed(Asm_Test_64): MYSTRING = "test cdq 64 signed" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.myjit.cpu.RAX = 0x1234567887654321 @@ -220,7 +220,7 @@ class Test_CWD_32(Asm_Test_32): MYSTRING = "test cdq 32" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.myjit.cpu.EAX = 0x87654321 @@ -241,7 +241,7 @@ class Test_CWD_32_signed(Asm_Test_32): MYSTRING = "test cdq 32" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.myjit.cpu.EAX = 0x87658321 @@ -262,7 +262,7 @@ class Test_CWD_32(Asm_Test_32): MYSTRING = "test cdq 32" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.myjit.cpu.EAX = 0x87654321 @@ -283,7 +283,7 @@ class Test_CWDE_32(Asm_Test_32): MYSTRING = "test cwde 32" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.myjit.cpu.EAX = 0x87654321 @@ -304,7 +304,7 @@ class Test_CWDE_32_signed(Asm_Test_32): MYSTRING = "test cwde 32 signed" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.myjit.cpu.RAX = 0x87658321 @@ -325,7 +325,7 @@ class Test_CWDE_64(Asm_Test_64): MYSTRING = "test cwde 64" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.myjit.cpu.RAX = 0x1234567887654321 @@ -346,7 +346,7 @@ class Test_CWDE_64_signed(Asm_Test_64): MYSTRING = "test cwde 64 signed" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.myjit.cpu.RAX = 0x1234567887658321 @@ -367,7 +367,7 @@ class Test_CQO_64(Asm_Test_64): MYSTRING = "test cwde 64" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.myjit.cpu.RAX = 0x1234567887654321 @@ -388,7 +388,7 @@ class Test_CQO_64_signed(Asm_Test_64): MYSTRING = "test cwde 64 signed" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.myjit.cpu.RAX = 0x8234567887658321 diff --git a/test/arch/x86/unit/mn_pushpop.py b/test/arch/x86/unit/mn_pushpop.py index bed70ea3..6e9005ca 100755 --- a/test/arch/x86/unit/mn_pushpop.py +++ b/test/arch/x86/unit/mn_pushpop.py @@ -21,7 +21,7 @@ class Test_PUSHAD_32(Asm_Test_32): MYSTRING = "test pushad 32" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): init_regs(self) @@ -48,7 +48,7 @@ class Test_PUSHA_32(Asm_Test_32): MYSTRING = "test pusha 32" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): init_regs(self) @@ -75,7 +75,7 @@ class Test_PUSHA_16(Asm_Test_16): MYSTRING = "test pusha 16" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): init_regs(self) @@ -102,7 +102,7 @@ class Test_PUSHAD_16(Asm_Test_16): MYSTRING = "test pushad 16" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): init_regs(self) @@ -129,7 +129,7 @@ class Test_PUSH_mode32_32(Asm_Test_32): MYSTRING = "test push mode32 32" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): init_regs(self) @@ -152,7 +152,7 @@ class Test_PUSH_mode32_16(Asm_Test_32): MYSTRING = "test push mode32 16" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): init_regs(self) @@ -175,7 +175,7 @@ class Test_PUSH_mode16_16(Asm_Test_16): MYSTRING = "test push mode16 16" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): init_regs(self) @@ -198,7 +198,7 @@ class Test_PUSH_mode16_32(Asm_Test_16): MYSTRING = "test push mode16 32" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): init_regs(self) @@ -221,7 +221,7 @@ class Test_POP_mode32_32(Asm_Test_32): MYSTRING = "test pop mode32 32" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.value = 0x11223344 @@ -243,7 +243,7 @@ class Test_POP_mode32_16(Asm_Test_32): MYSTRING = "test pop mode32 16" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.value = 0x1122 @@ -265,7 +265,7 @@ class Test_POP_mode16_16(Asm_Test_16): MYSTRING = "test pop mode16 16" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.value = 0x1122 @@ -287,7 +287,7 @@ class Test_POP_mode16_32(Asm_Test_16): MYSTRING = "test pop mode16 32" def prepare(self): - self.myjit.ir_arch.symbol_pool.add_location("lbl_ret", self.ret_addr) + self.myjit.ir_arch.loc_db.add_location("lbl_ret", self.ret_addr) def test_init(self): self.value = 0x11223344 diff --git a/test/arch/x86/unit/mn_strings.py b/test/arch/x86/unit/mn_strings.py index 44da0a70..a6facd08 100755 --- a/test/arch/x86/unit/mn_strings.py +++ b/test/arch/x86/unit/mn_strings.py @@ -21,8 +21,8 @@ class Test_SCAS(Asm_Test_32): def check(self): assert(self.myjit.cpu.ECX == len(self.MYSTRING)) - mystr = self.myjit.ir_arch.symbol_pool.getby_name('mystr') - assert(self.myjit.cpu.EDI == self.myjit.ir_arch.symbol_pool.loc_key_to_offset(mystr) + len(self.MYSTRING)+1) + mystr = self.myjit.ir_arch.loc_db.getby_name('mystr') + assert(self.myjit.cpu.EDI == self.myjit.ir_arch.loc_db.loc_key_to_offset(mystr) + len(self.MYSTRING)+1) class Test_MOVS(Asm_Test_32): @@ -43,10 +43,10 @@ class Test_MOVS(Asm_Test_32): def check(self): assert(self.myjit.cpu.ECX == 0) - buffer = self.myjit.ir_arch.symbol_pool.getby_name('buffer') - assert(self.myjit.cpu.EDI == self.myjit.ir_arch.symbol_pool.loc_key_to_offset(buffer) + len(self.MYSTRING)) - mystr = self.myjit.ir_arch.symbol_pool.getby_name('mystr') - assert(self.myjit.cpu.ESI == self.myjit.ir_arch.symbol_pool.loc_key_to_offset(mystr) + len(self.MYSTRING)) + buffer = self.myjit.ir_arch.loc_db.getby_name('buffer') + assert(self.myjit.cpu.EDI == self.myjit.ir_arch.loc_db.loc_key_to_offset(buffer) + len(self.MYSTRING)) + mystr = self.myjit.ir_arch.loc_db.getby_name('mystr') + assert(self.myjit.cpu.ESI == self.myjit.ir_arch.loc_db.loc_key_to_offset(mystr) + len(self.MYSTRING)) if __name__ == "__main__": diff --git a/test/core/asmblock.py b/test/core/asmblock.py index 0e965bfd..465697f4 100644 --- a/test/core/asmblock.py +++ b/test/core/asmblock.py @@ -105,7 +105,7 @@ open("graph2.dot", "w").write(asmcfg.dot()) # Test helper methods ## loc_key_to_block should always be updated assert asmcfg.loc_key_to_block(first_block.loc_key) == first_block -testlabel = mdis.symbol_pool.getby_name_create("testlabel") +testlabel = mdis.loc_db.getby_name_create("testlabel") my_block = AsmBlock(testlabel) asmcfg.add_block(my_block) assert len(asmcfg) == 3 @@ -116,7 +116,7 @@ assert asmcfg.loc_key_to_block(my_block.loc_key) == my_block assert len(list(asmcfg.get_bad_blocks())) == 0 assert len(list(asmcfg.get_bad_blocks_predecessors())) == 0 ### Add a bad block, not linked -testlabel_bad = mdis.symbol_pool.getby_name_create("testlabel_bad") +testlabel_bad = mdis.loc_db.getby_name_create("testlabel_bad") my_bad_block = AsmBlockBad(testlabel_bad) asmcfg.add_block(my_bad_block) assert list(asmcfg.get_bad_blocks()) == [my_bad_block] @@ -135,7 +135,7 @@ assert len(list(asmcfg.get_bad_blocks_predecessors(strict=True))) == 0 ## Sanity check asmcfg.sanity_check() ### Next on itself -testlabel_nextitself = mdis.symbol_pool.getby_name_create("testlabel_nextitself") +testlabel_nextitself = mdis.loc_db.getby_name_create("testlabel_nextitself") my_block_ni = AsmBlock(testlabel_nextitself) my_block_ni.bto.add(AsmConstraintNext(my_block_ni.loc_key)) asmcfg.add_block(my_block_ni) @@ -149,11 +149,11 @@ assert error_raised asmcfg.del_block(my_block_ni) asmcfg.sanity_check() ### Multiple next on the same node -testlabel_target = mdis.symbol_pool.getby_name_create("testlabel_target") +testlabel_target = mdis.loc_db.getby_name_create("testlabel_target") my_block_target = AsmBlock(testlabel_target) asmcfg.add_block(my_block_target) -testlabel_src1 = mdis.symbol_pool.getby_name_create("testlabel_src1") -testlabel_src2 = mdis.symbol_pool.getby_name_create("testlabel_src2") +testlabel_src1 = mdis.loc_db.getby_name_create("testlabel_src1") +testlabel_src2 = mdis.loc_db.getby_name_create("testlabel_src2") my_block_src1 = AsmBlock(testlabel_src1) my_block_src2 = AsmBlock(testlabel_src2) my_block_src1.bto.add(AsmConstraintNext(my_block_target.loc_key)) @@ -184,8 +184,8 @@ assert asmcfg.loc_key_to_block(my_block_src1.loc_key).max_size == 0 ## Check pendings ### Create a pending element -testlabel_pend_src = mdis.symbol_pool.getby_name_create("testlabel_pend_src") -testlabel_pend_dst = mdis.symbol_pool.getby_name_create("testlabel_pend_dst") +testlabel_pend_src = mdis.loc_db.getby_name_create("testlabel_pend_src") +testlabel_pend_dst = mdis.loc_db.getby_name_create("testlabel_pend_dst") my_block_src = AsmBlock(testlabel_pend_src) my_block_dst = AsmBlock(testlabel_pend_dst) my_block_src.bto.add(AsmConstraintTo(my_block_dst.loc_key)) @@ -268,16 +268,16 @@ assert asmcfg.successors(tob.loc_key) == [tob.loc_key] # Check split_block ## Without condition for a split, no change asmcfg_bef = asmcfg.copy() -asmcfg.apply_splitting(mdis.symbol_pool) +asmcfg.apply_splitting(mdis.loc_db) assert asmcfg_bef == asmcfg open("graph5.dot", "w").write(asmcfg.dot()) ## Create conditions for a block split -inside_firstbbl = mdis.symbol_pool.getby_offset(4) +inside_firstbbl = mdis.loc_db.getby_offset(4) tob.bto.add(AsmConstraintTo(inside_firstbbl)) asmcfg.rebuild_edges() assert len(asmcfg.pendings) == 1 assert inside_firstbbl in asmcfg.pendings -asmcfg.apply_splitting(mdis.symbol_pool) +asmcfg.apply_splitting(mdis.loc_db) ## Check result assert len(asmcfg) == 6 assert len(asmcfg.pendings) == 0 @@ -322,10 +322,10 @@ solutions = list(matcher.match(asmcfg)) assert len(solutions) == 1 solution = solutions.pop() for jbbl, label in solution.iteritems(): - offset = mdis.symbol_pool.loc_key_to_offset(label) + offset = mdis.loc_db.loc_key_to_offset(label) assert offset == int(jbbl._name, 16) -loc_key_dum = mdis.symbol_pool.getby_name_create("dummy_loc") +loc_key_dum = mdis.loc_db.getby_name_create("dummy_loc") asmcfg.add_node(loc_key_dum) error_raised = False try: diff --git a/test/core/parse_asm.py b/test/core/parse_asm.py index fab3a815..e8d5adc5 100755 --- a/test/core/parse_asm.py +++ b/test/core/parse_asm.py @@ -64,15 +64,15 @@ class TestParseAsm(unittest.TestCase): .string "toto" ''' - asmcfg, symbol_pool = parse_txt(mn_x86, 32, ASM0) + asmcfg, loc_db = parse_txt(mn_x86, 32, ASM0) patches = asm_resolve_final(mn_x86, asmcfg, - symbol_pool) + loc_db) lbls = [] for i in xrange(6): - lbls.append(symbol_pool.getby_name('lbl%d' % i)) + lbls.append(loc_db.getby_name('lbl%d' % i)) # align test - offset = symbol_pool.loc_key_to_offset(lbls[5]) + offset = loc_db.loc_key_to_offset(lbls[5]) assert(offset % 0x10 == 0) lbl2block = {} for block in asmcfg.blocks: @@ -95,10 +95,10 @@ class TestParseAsm(unittest.TestCase): RET ''' - asmcfg, symbol_pool = parse_txt(mn_x86, 32, ASM0) + asmcfg, loc_db = parse_txt(mn_x86, 32, ASM0) lbls = [] for i in xrange(2): - lbls.append(symbol_pool.getby_name('lbl%d' % i)) + lbls.append(loc_db.getby_name('lbl%d' % i)) lbl2block = {} for block in asmcfg.blocks: lbl2block[block.loc_key] = block diff --git a/test/core/sembuilder.py b/test/core/sembuilder.py index 53aa199d..f7a96b89 100644 --- a/test/core/sembuilder.py +++ b/test/core/sembuilder.py @@ -2,15 +2,15 @@ import inspect from pdb import pm from miasm2.core.sembuilder import SemBuilder -from miasm2.core.asmblock import AsmSymbolPool +from miasm2.core.locationdb import LocationDB import miasm2.expression.expression as m2_expr # Test classes class IR(object): - def __init__(self, symbol_pool): - self.symbol_pool = symbol_pool + def __init__(self, loc_db): + self.loc_db = loc_db IRDst = m2_expr.ExprId("IRDst", 32) @@ -45,8 +45,8 @@ def test(Arg1, Arg2, Arg3): a = m2_expr.ExprId('A', 32) b = m2_expr.ExprId('B', 32) c = m2_expr.ExprId('C', 32) -symbol_pool = AsmSymbolPool() -ir = IR(symbol_pool) +loc_db = LocationDB() +ir = IR(loc_db) instr = Instr() res = test(ir, instr, a, b, c) diff --git a/test/ir/translators/z3_ir.py b/test/ir/translators/z3_ir.py index 29b3c39d..4806ad96 100644 --- a/test/ir/translators/z3_ir.py +++ b/test/ir/translators/z3_ir.py @@ -1,14 +1,14 @@ import z3 -from miasm2.core.asmblock import AsmSymbolPool +from miasm2.core.locationdb import LocationDB from miasm2.expression.expression import * from miasm2.ir.translators.z3_ir import Z3Mem, TranslatorZ3 # Some examples of use/unit tests. -symbol_pool = AsmSymbolPool() -translator1 = TranslatorZ3(endianness="<", symbol_pool=symbol_pool) -translator2 = TranslatorZ3(endianness=">", symbol_pool=symbol_pool) +loc_db = LocationDB() +translator1 = TranslatorZ3(endianness="<", loc_db=loc_db) +translator2 = TranslatorZ3(endianness=">", loc_db=loc_db) def equiv(z3_expr1, z3_expr2): @@ -143,14 +143,14 @@ for miasm_int, res in [(five, -5), (four, -4)]: assert equiv(ez3, z3_e6) # -------------------------------------------------------------------------- -label_histoire = symbol_pool.add_location("label_histoire", 0xdeadbeef) +label_histoire = loc_db.add_location("label_histoire", 0xdeadbeef) e7 = ExprLoc(label_histoire, 32) ez3 = translator1.from_expr(e7) z3_e7 = z3.BitVecVal(0xdeadbeef, 32) assert equiv(ez3, z3_e7) # Should just not throw anything to pass -lbl_e8 = symbol_pool.add_location("label_jambe") +lbl_e8 = loc_db.add_location("label_jambe") e8 = ExprLoc(lbl_e8, 32) ez3 = translator1.from_expr(e8) |