symbol_pool -> loc_db

1 files changed, 26 insertions, 21 deletions

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)