Rename ira => LifterModelCall

9 files changed, 184 insertions, 184 deletions

diff --git a/test/analysis/data_flow.py b/test/analysis/data_flow.py
index 840bf9ce..6a3c2ce7 100644
--- a/test/analysis/data_flow.py
+++ b/test/analysis/data_flow.py
@@ -6,7 +6,7 @@ from future.utils import viewitems
 from miasm.expression.expression import ExprId, ExprInt, ExprAssign, ExprMem
 from miasm.core.locationdb import LocationDB
 from miasm.analysis.data_flow import DeadRemoval, ReachingDefinitions, DiGraphDefUse
-from miasm.ir.analysis import ira
+from miasm.ir.analysis import LifterModelCall
 from miasm.ir.ir import IRBlock, AssignBlock
 
 loc_db = LocationDB()
@@ -68,99 +68,99 @@ class Arch(object):
     def getsp(self, _):
         return sp
 
-class IRATest(ira):
+class LifterTest(LifterModelCall):
 
-    """Fake IRA class for tests"""
+    """Fake Lifter class for tests"""
 
     def __init__(self, loc_db):
         arch = Arch()
-        super(IRATest, self).__init__(arch, 32, loc_db)
+        super(LifterTest, self).__init__(arch, 32, loc_db)
         self.IRDst = IRDst
         self.ret_reg = r
 
     def get_out_regs(self, _):
         return set([self.ret_reg, self.sp])
 
-IRA = IRATest(loc_db)
-deadrm = DeadRemoval(IRA)
+Lifter = LifterTest(loc_db)
+deadrm = DeadRemoval(Lifter)
 
 # graph 1 : Simple graph with dead and alive variables
 
-G1_IRA = IRA.new_ircfg()
+G1_cfg = Lifter.new_ircfg()
 
 G1_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, CST1)], [ExprAssign(b, CST2)]])
 G1_IRB1 = gen_irblock(LBL1, [[ExprAssign(a, b)]])
 G1_IRB2 = gen_irblock(LBL2, [[ExprAssign(r, a)]])
 
 for irb in [G1_IRB0, G1_IRB1, G1_IRB2]:
-    G1_IRA.add_irblock(irb)
+    G1_cfg.add_irblock(irb)
 
-G1_IRA.add_uniq_edge(G1_IRB0.loc_key, G1_IRB1.loc_key)
-G1_IRA.add_uniq_edge(G1_IRB1.loc_key, G1_IRB2.loc_key)
+G1_cfg.add_uniq_edge(G1_IRB0.loc_key, G1_IRB1.loc_key)
+G1_cfg.add_uniq_edge(G1_IRB1.loc_key, G1_IRB2.loc_key)
 
 # Expected output for graph 1
-G1_EXP_IRA = IRA.new_ircfg()
+G1_EXP_cfg = Lifter.new_ircfg()
 
 G1_EXP_IRB0 = gen_irblock(LBL0, [[], [ExprAssign(b, CST2)]])
 G1_EXP_IRB1 = gen_irblock(LBL1, [[ExprAssign(a, b)]])
 G1_EXP_IRB2 = gen_irblock(LBL2, [[ExprAssign(r, a)]])
 
 for irb in [G1_EXP_IRB0, G1_EXP_IRB1, G1_EXP_IRB2]:
-    G1_EXP_IRA.add_irblock(irb)
+    G1_EXP_cfg.add_irblock(irb)
 
 # graph 2 : Natural loop with dead variable
 
-G2_IRA = IRA.new_ircfg()
+G2_cfg = Lifter.new_ircfg()
 
 G2_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, CST1)], [ExprAssign(r, CST1)]])
 G2_IRB1 = gen_irblock(LBL1, [[ExprAssign(a, a+CST1)]])
 G2_IRB2 = gen_irblock(LBL2, [[ExprAssign(a, r)]])
 
 for irb in [G2_IRB0, G2_IRB1, G2_IRB2]:
-    G2_IRA.add_irblock(irb)
+    G2_cfg.add_irblock(irb)
 
-G2_IRA.add_uniq_edge(G2_IRB0.loc_key, G2_IRB1.loc_key)
-G2_IRA.add_uniq_edge(G2_IRB1.loc_key, G2_IRB2.loc_key)
-G2_IRA.add_uniq_edge(G2_IRB1.loc_key, G2_IRB1.loc_key)
+G2_cfg.add_uniq_edge(G2_IRB0.loc_key, G2_IRB1.loc_key)
+G2_cfg.add_uniq_edge(G2_IRB1.loc_key, G2_IRB2.loc_key)
+G2_cfg.add_uniq_edge(G2_IRB1.loc_key, G2_IRB1.loc_key)
 
 # Expected output for graph 2
-G2_EXP_IRA = IRA.new_ircfg()
+G2_EXP_cfg = Lifter.new_ircfg()
 
 G2_EXP_IRB0 = gen_irblock(LBL0, [[], [ExprAssign(r, CST1)]])
 G2_EXP_IRB1 = gen_irblock(LBL1, [[]])
 G2_EXP_IRB2 = gen_irblock(LBL2, [[]])
 
 for irb in [G2_EXP_IRB0, G2_EXP_IRB1, G2_EXP_IRB2]:
-    G2_EXP_IRA.add_irblock(irb)
+    G2_EXP_cfg.add_irblock(irb)
 
 # graph 3 : Natural loop with alive variables
 
-G3_IRA = IRA.new_ircfg()
+G3_cfg = Lifter.new_ircfg()
 
 G3_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, CST1)]])
 G3_IRB1 = gen_irblock(LBL1, [[ExprAssign(a, a+CST1)]])
 G3_IRB2 = gen_irblock(LBL2, [[ExprAssign(r, a)]])
 
 for irb in [G3_IRB0, G3_IRB1, G3_IRB2]:
-    G3_IRA.add_irblock(irb)
+    G3_cfg.add_irblock(irb)
 
-G3_IRA.add_uniq_edge(G3_IRB0.loc_key, G3_IRB1.loc_key)
-G3_IRA.add_uniq_edge(G3_IRB1.loc_key, G3_IRB2.loc_key)
-G3_IRA.add_uniq_edge(G3_IRB1.loc_key, G3_IRB1.loc_key)
+G3_cfg.add_uniq_edge(G3_IRB0.loc_key, G3_IRB1.loc_key)
+G3_cfg.add_uniq_edge(G3_IRB1.loc_key, G3_IRB2.loc_key)
+G3_cfg.add_uniq_edge(G3_IRB1.loc_key, G3_IRB1.loc_key)
 
 # Expected output for graph 3
-G3_EXP_IRA = IRA.new_ircfg()
+G3_EXP_cfg = Lifter.new_ircfg()
 
 G3_EXP_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, CST1)]])
 G3_EXP_IRB1 = gen_irblock(LBL1, [[ExprAssign(a, a+CST1)]])
 G3_EXP_IRB2 = gen_irblock(LBL2, [[ExprAssign(r, a)]])
 
 for irb in [G3_EXP_IRB0, G3_EXP_IRB1, G3_EXP_IRB2]:
-    G3_EXP_IRA.add_irblock(irb)
+    G3_EXP_cfg.add_irblock(irb)
 
 # graph 4 : If/else with dead variables
 
-G4_IRA = IRA.new_ircfg()
+G4_cfg = Lifter.new_ircfg()
 
 G4_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, CST1)]])
 G4_IRB1 = gen_irblock(LBL1, [[ExprAssign(a, a+CST1)]])
@@ -168,15 +168,15 @@ G4_IRB2 = gen_irblock(LBL2, [[ExprAssign(a, a+CST2)]])
 G4_IRB3 = gen_irblock(LBL3, [[ExprAssign(a, CST3)], [ExprAssign(r, a)]])
 
 for irb in [G4_IRB0, G4_IRB1, G4_IRB2, G4_IRB3]:
-    G4_IRA.add_irblock(irb)
+    G4_cfg.add_irblock(irb)
 
-G4_IRA.add_uniq_edge(G4_IRB0.loc_key, G4_IRB1.loc_key)
-G4_IRA.add_uniq_edge(G4_IRB0.loc_key, G4_IRB2.loc_key)
-G4_IRA.add_uniq_edge(G4_IRB1.loc_key, G4_IRB3.loc_key)
-G4_IRA.add_uniq_edge(G4_IRB2.loc_key, G4_IRB3.loc_key)
+G4_cfg.add_uniq_edge(G4_IRB0.loc_key, G4_IRB1.loc_key)
+G4_cfg.add_uniq_edge(G4_IRB0.loc_key, G4_IRB2.loc_key)
+G4_cfg.add_uniq_edge(G4_IRB1.loc_key, G4_IRB3.loc_key)
+G4_cfg.add_uniq_edge(G4_IRB2.loc_key, G4_IRB3.loc_key)
 
 # Expected output for graph 4
-G4_EXP_IRA = IRA.new_ircfg()
+G4_EXP_cfg = Lifter.new_ircfg()
 
 G4_EXP_IRB0 = gen_irblock(LBL0, [[]])
 G4_EXP_IRB1 = gen_irblock(LBL1, [[]])
@@ -184,11 +184,11 @@ G4_EXP_IRB2 = gen_irblock(LBL2, [[]])
 G4_EXP_IRB3 = gen_irblock(LBL3, [[ExprAssign(a, CST3)], [ExprAssign(r, a)]])
 
 for irb in [G4_EXP_IRB0, G4_EXP_IRB1, G4_EXP_IRB2, G4_EXP_IRB3]:
-    G4_EXP_IRA.add_irblock(irb)
+    G4_EXP_cfg.add_irblock(irb)
 
 # graph 5 : Loop and If/else with dead variables
 
-G5_IRA = IRA.new_ircfg()
+G5_cfg = Lifter.new_ircfg()
 
 G5_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, CST1)]])
 G5_IRB1 = gen_irblock(LBL1, [[ExprAssign(r, CST2)]])
@@ -198,18 +198,18 @@ G5_IRB4 = gen_irblock(LBL4, [[ExprAssign(a, a+CST1)]])
 G5_IRB5 = gen_irblock(LBL5, [[ExprAssign(a, r)]])
 
 for irb in [G5_IRB0, G5_IRB1, G5_IRB2, G5_IRB3, G5_IRB4, G5_IRB5]:
-    G5_IRA.add_irblock(irb)
+    G5_cfg.add_irblock(irb)
 
-G5_IRA.add_uniq_edge(G5_IRB0.loc_key, G5_IRB1.loc_key)
-G5_IRA.add_uniq_edge(G5_IRB1.loc_key, G5_IRB2.loc_key)
-G5_IRA.add_uniq_edge(G5_IRB1.loc_key, G5_IRB3.loc_key)
-G5_IRA.add_uniq_edge(G5_IRB2.loc_key, G5_IRB4.loc_key)
-G5_IRA.add_uniq_edge(G5_IRB3.loc_key, G5_IRB4.loc_key)
-G5_IRA.add_uniq_edge(G5_IRB4.loc_key, G5_IRB5.loc_key)
-G5_IRA.add_uniq_edge(G5_IRB4.loc_key, G5_IRB1.loc_key)
+G5_cfg.add_uniq_edge(G5_IRB0.loc_key, G5_IRB1.loc_key)
+G5_cfg.add_uniq_edge(G5_IRB1.loc_key, G5_IRB2.loc_key)
+G5_cfg.add_uniq_edge(G5_IRB1.loc_key, G5_IRB3.loc_key)
+G5_cfg.add_uniq_edge(G5_IRB2.loc_key, G5_IRB4.loc_key)
+G5_cfg.add_uniq_edge(G5_IRB3.loc_key, G5_IRB4.loc_key)
+G5_cfg.add_uniq_edge(G5_IRB4.loc_key, G5_IRB5.loc_key)
+G5_cfg.add_uniq_edge(G5_IRB4.loc_key, G5_IRB1.loc_key)
 
 # Expected output for graph 5
-G5_EXP_IRA = IRA.new_ircfg()
+G5_EXP_cfg = Lifter.new_ircfg()
 
 G5_EXP_IRB0 = gen_irblock(LBL0, [[]])
 G5_EXP_IRB1 = gen_irblock(LBL1, [[ExprAssign(r, CST2)]])
@@ -220,12 +220,12 @@ G5_EXP_IRB5 = gen_irblock(LBL5, [[]])
 
 for irb in [G5_EXP_IRB0, G5_EXP_IRB1, G5_EXP_IRB2,
             G5_EXP_IRB3, G5_EXP_IRB4, G5_EXP_IRB5]:
-    G5_EXP_IRA.add_irblock(irb)
+    G5_EXP_cfg.add_irblock(irb)
 
 # graph 6 : Natural loop with dead variables symmetric assignment
 # (a = b <-> b = a )
 
-G6_IRA = IRA.new_ircfg()
+G6_cfg = Lifter.new_ircfg()
 
 G6_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, CST1)]])
 G6_IRB1 = gen_irblock(LBL1, [[ExprAssign(b, a)]])
@@ -233,15 +233,15 @@ G6_IRB2 = gen_irblock(LBL2, [[ExprAssign(a, b)]])
 G6_IRB3 = gen_irblock(LBL3, [[ExprAssign(r, CST2)]])
 
 for irb in [G6_IRB0, G6_IRB1, G6_IRB2, G6_IRB3]:
-    G6_IRA.add_irblock(irb)
+    G6_cfg.add_irblock(irb)
 
-G6_IRA.add_uniq_edge(G6_IRB0.loc_key, G6_IRB1.loc_key)
-G6_IRA.add_uniq_edge(G6_IRB1.loc_key, G6_IRB2.loc_key)
-G6_IRA.add_uniq_edge(G6_IRB2.loc_key, G6_IRB1.loc_key)
-G6_IRA.add_uniq_edge(G6_IRB2.loc_key, G6_IRB3.loc_key)
+G6_cfg.add_uniq_edge(G6_IRB0.loc_key, G6_IRB1.loc_key)
+G6_cfg.add_uniq_edge(G6_IRB1.loc_key, G6_IRB2.loc_key)
+G6_cfg.add_uniq_edge(G6_IRB2.loc_key, G6_IRB1.loc_key)
+G6_cfg.add_uniq_edge(G6_IRB2.loc_key, G6_IRB3.loc_key)
 
 # Expected output for graph 6
-G6_EXP_IRA = IRA.new_ircfg()
+G6_EXP_cfg = Lifter.new_ircfg()
 
 G6_EXP_IRB0 = gen_irblock(LBL0, [[]])
 G6_EXP_IRB1 = gen_irblock(LBL1, [[]])
@@ -249,11 +249,11 @@ G6_EXP_IRB2 = gen_irblock(LBL2, [[]])
 G6_EXP_IRB3 = gen_irblock(LBL3, [[ExprAssign(r, CST2)]])
 
 for irb in [G6_EXP_IRB0, G6_EXP_IRB1, G6_EXP_IRB2, G6_EXP_IRB3]:
-    G6_EXP_IRA.add_irblock(irb)
+    G6_EXP_cfg.add_irblock(irb)
 
 # graph 7 : Double entry loop with dead variables
 
-G7_IRA = IRA.new_ircfg()
+G7_cfg = Lifter.new_ircfg()
 
 G7_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, CST1)], [ExprAssign(r, CST1)]])
 G7_IRB1 = gen_irblock(LBL1, [[ExprAssign(a, a+CST1)]])
@@ -261,17 +261,17 @@ G7_IRB2 = gen_irblock(LBL2, [[ExprAssign(a, a+CST2)]])
 G7_IRB3 = gen_irblock(LBL3, [[ExprAssign(a, r)]])
 
 for irb in [G7_IRB0, G7_IRB1, G7_IRB2, G7_IRB3]:
-    G7_IRA.add_irblock(irb)
+    G7_cfg.add_irblock(irb)
 
-G7_IRA.add_uniq_edge(G7_IRB0.loc_key, G7_IRB1.loc_key)
-G7_IRA.add_uniq_edge(G7_IRB1.loc_key, G7_IRB2.loc_key)
-G7_IRA.add_uniq_edge(G7_IRB2.loc_key, G7_IRB1.loc_key)
-G7_IRA.add_uniq_edge(G7_IRB2.loc_key, G7_IRB3.loc_key)
-G7_IRA.add_uniq_edge(G7_IRB0.loc_key, G7_IRB2.loc_key)
+G7_cfg.add_uniq_edge(G7_IRB0.loc_key, G7_IRB1.loc_key)
+G7_cfg.add_uniq_edge(G7_IRB1.loc_key, G7_IRB2.loc_key)
+G7_cfg.add_uniq_edge(G7_IRB2.loc_key, G7_IRB1.loc_key)
+G7_cfg.add_uniq_edge(G7_IRB2.loc_key, G7_IRB3.loc_key)
+G7_cfg.add_uniq_edge(G7_IRB0.loc_key, G7_IRB2.loc_key)
 
 
 # Expected output for graph 7
-G7_EXP_IRA = IRA.new_ircfg()
+G7_EXP_cfg = Lifter.new_ircfg()
 
 G7_EXP_IRB0 = gen_irblock(LBL0, [[], [ExprAssign(r, CST1)]])
 G7_EXP_IRB1 = gen_irblock(LBL1, [[]])
@@ -279,11 +279,11 @@ G7_EXP_IRB2 = gen_irblock(LBL2, [[]])
 G7_EXP_IRB3 = gen_irblock(LBL3, [[]])
 
 for irb in [G7_EXP_IRB0, G7_EXP_IRB1, G7_EXP_IRB2, G7_EXP_IRB3]:
-    G7_EXP_IRA.add_irblock(irb)
+    G7_EXP_cfg.add_irblock(irb)
 
 # graph 8 : Nested loops with dead variables
 
-G8_IRA = IRA.new_ircfg()
+G8_cfg = Lifter.new_ircfg()
 
 G8_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, CST1)], [ExprAssign(b, CST1)]])
 G8_IRB1 = gen_irblock(LBL1, [[ExprAssign(a, a+CST1)]])
@@ -292,18 +292,18 @@ G8_IRB3 = gen_irblock(LBL3, [[ExprAssign(a, b)]])
 
 
 for irb in [G8_IRB0, G8_IRB1, G8_IRB2, G8_IRB3]:
-    G8_IRA.add_irblock(irb)
+    G8_cfg.add_irblock(irb)
 
-G8_IRA.add_uniq_edge(G8_IRB0.loc_key, G8_IRB1.loc_key)
-G8_IRA.add_uniq_edge(G8_IRB1.loc_key, G8_IRB2.loc_key)
-G8_IRA.add_uniq_edge(G8_IRB2.loc_key, G8_IRB1.loc_key)
-G8_IRA.add_uniq_edge(G8_IRB2.loc_key, G8_IRB3.loc_key)
-G8_IRA.add_uniq_edge(G8_IRB3.loc_key, G8_IRB2.loc_key)
+G8_cfg.add_uniq_edge(G8_IRB0.loc_key, G8_IRB1.loc_key)
+G8_cfg.add_uniq_edge(G8_IRB1.loc_key, G8_IRB2.loc_key)
+G8_cfg.add_uniq_edge(G8_IRB2.loc_key, G8_IRB1.loc_key)
+G8_cfg.add_uniq_edge(G8_IRB2.loc_key, G8_IRB3.loc_key)
+G8_cfg.add_uniq_edge(G8_IRB3.loc_key, G8_IRB2.loc_key)
 
 
 # Expected output for graph 8
 
-G8_EXP_IRA = IRA.new_ircfg()
+G8_EXP_cfg = Lifter.new_ircfg()
 
 G8_EXP_IRB0 = gen_irblock(LBL0, [[], []])
 G8_EXP_IRB1 = gen_irblock(LBL1, [[]])
@@ -311,11 +311,11 @@ G8_EXP_IRB2 = gen_irblock(LBL2, [[]])
 G8_EXP_IRB3 = gen_irblock(LBL3, [[]])
 
 for irb in [G8_EXP_IRB0, G8_EXP_IRB1, G8_EXP_IRB2, G8_EXP_IRB3]:
-    G8_EXP_IRA.add_irblock(irb)
+    G8_EXP_cfg.add_irblock(irb)
 
 # graph 9 : Miultiple-exits loops with dead variables
 
-G9_IRA = IRA.new_ircfg()
+G9_cfg = Lifter.new_ircfg()
 
 G9_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, CST1)], [ExprAssign(b, CST1)]])
 G9_IRB1 = gen_irblock(LBL1, [[ExprAssign(a, a+CST1)], [ExprAssign(b, b+CST1)]])
@@ -324,21 +324,21 @@ G9_IRB3 = gen_irblock(LBL3, [[ExprAssign(a, b)]])
 G9_IRB4 = gen_irblock(LBL4, [[ExprAssign(r, a)], [ExprAssign(r, b)]])
 
 for irb in [G9_IRB0, G9_IRB1, G9_IRB2, G9_IRB3, G9_IRB4]:
-    G9_IRA.add_irblock(irb)
+    G9_cfg.add_irblock(irb)
 
-G9_IRA.add_uniq_edge(G9_IRB0.loc_key, G9_IRB4.loc_key)
-G9_IRA.add_uniq_edge(G9_IRB0.loc_key, G9_IRB1.loc_key)
-G9_IRA.add_uniq_edge(G9_IRB1.loc_key, G9_IRB0.loc_key)
-G9_IRA.add_uniq_edge(G9_IRB1.loc_key, G9_IRB4.loc_key)
-G9_IRA.add_uniq_edge(G9_IRB1.loc_key, G9_IRB2.loc_key)
-G9_IRA.add_uniq_edge(G9_IRB2.loc_key, G9_IRB0.loc_key)
-G9_IRA.add_uniq_edge(G9_IRB2.loc_key, G9_IRB3.loc_key)
-G9_IRA.add_uniq_edge(G9_IRB3.loc_key, G9_IRB4.loc_key)
+G9_cfg.add_uniq_edge(G9_IRB0.loc_key, G9_IRB4.loc_key)
+G9_cfg.add_uniq_edge(G9_IRB0.loc_key, G9_IRB1.loc_key)
+G9_cfg.add_uniq_edge(G9_IRB1.loc_key, G9_IRB0.loc_key)
+G9_cfg.add_uniq_edge(G9_IRB1.loc_key, G9_IRB4.loc_key)
+G9_cfg.add_uniq_edge(G9_IRB1.loc_key, G9_IRB2.loc_key)
+G9_cfg.add_uniq_edge(G9_IRB2.loc_key, G9_IRB0.loc_key)
+G9_cfg.add_uniq_edge(G9_IRB2.loc_key, G9_IRB3.loc_key)
+G9_cfg.add_uniq_edge(G9_IRB3.loc_key, G9_IRB4.loc_key)
 
 
 # Expected output for graph 9
 
-G9_EXP_IRA = IRA.new_ircfg()
+G9_EXP_cfg = Lifter.new_ircfg()
 
 G9_EXP_IRB0 = gen_irblock(LBL0, [[], [ExprAssign(b, CST1)]])
 G9_EXP_IRB1 = gen_irblock(LBL1, [[], [ExprAssign(b, b+CST1)]])
@@ -347,12 +347,12 @@ G9_EXP_IRB3 = gen_irblock(LBL3, [[]])
 G9_EXP_IRB4 = gen_irblock(LBL4, [[], [ExprAssign(r, b)]])
 
 for irb in [G9_EXP_IRB0, G9_EXP_IRB1, G9_EXP_IRB2, G9_EXP_IRB3, G9_EXP_IRB4]:
-    G9_EXP_IRA.add_irblock(irb)
+    G9_EXP_cfg.add_irblock(irb)
 
 # graph 10 : Natural loop with alive variables symmetric assignment
 # (a = b <-> b = a )
 
-G10_IRA = IRA.new_ircfg()
+G10_cfg = Lifter.new_ircfg()
 
 G10_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, CST1)]])
 G10_IRB1 = gen_irblock(LBL1, [[ExprAssign(b, a)]])
@@ -360,16 +360,16 @@ G10_IRB2 = gen_irblock(LBL2, [[ExprAssign(a, b)]])
 G10_IRB3 = gen_irblock(LBL3, [[ExprAssign(r, CST1)]])
 
 for irb in [G10_IRB0, G10_IRB1, G10_IRB2, G10_IRB3]:
-    G10_IRA.add_irblock(irb)
+    G10_cfg.add_irblock(irb)
 
 
-G10_IRA.add_uniq_edge(G10_IRB0.loc_key, G10_IRB1.loc_key)
-G10_IRA.add_uniq_edge(G10_IRB1.loc_key, G10_IRB2.loc_key)
-G10_IRA.add_uniq_edge(G10_IRB2.loc_key, G10_IRB1.loc_key)
-G10_IRA.add_uniq_edge(G10_IRB2.loc_key, G10_IRB3.loc_key)
+G10_cfg.add_uniq_edge(G10_IRB0.loc_key, G10_IRB1.loc_key)
+G10_cfg.add_uniq_edge(G10_IRB1.loc_key, G10_IRB2.loc_key)
+G10_cfg.add_uniq_edge(G10_IRB2.loc_key, G10_IRB1.loc_key)
+G10_cfg.add_uniq_edge(G10_IRB2.loc_key, G10_IRB3.loc_key)
 
 # Expected output for graph 10
-G10_EXP_IRA = IRA.new_ircfg()
+G10_EXP_cfg = Lifter.new_ircfg()
 
 G10_EXP_IRB0 = gen_irblock(LBL0, [[]])
 G10_EXP_IRB1 = gen_irblock(LBL1, [[]])
@@ -377,11 +377,11 @@ G10_EXP_IRB2 = gen_irblock(LBL2, [[]])
 G10_EXP_IRB3 = gen_irblock(LBL3, [[ExprAssign(r, CST1)]])
 
 for irb in [G10_EXP_IRB0, G10_EXP_IRB1, G10_EXP_IRB2, G10_EXP_IRB3]:
-    G10_EXP_IRA.add_irblock(irb)
+    G10_EXP_cfg.add_irblock(irb)
 
 # graph 11 : If/Else conditions with alive variables
 
-G11_IRA = IRA.new_ircfg()
+G11_cfg = Lifter.new_ircfg()
 
 G11_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, b)]])
 G11_IRB1 = gen_irblock(LBL1, [[ExprAssign(b, a)]])
@@ -391,17 +391,17 @@ G11_IRB4 = gen_irblock(LBL4, [[ExprAssign(b, b+CST1)]])
 
 
 for irb in [G11_IRB0, G11_IRB1, G11_IRB2]:
-    G11_IRA.add_irblock(irb)
+    G11_cfg.add_irblock(irb)
 
-G11_IRA.add_uniq_edge(G11_IRB0.loc_key, G11_IRB1.loc_key)
-#G11_IRA.add_uniq_edge(G11_IRB3.loc_key, G11_IRB1.loc_key)
-G11_IRA.add_uniq_edge(G11_IRB1.loc_key, G11_IRB0.loc_key)
-#G11_IRA.add_uniq_edge(G11_IRB4.loc_key, G11_IRB0.loc_key)
-G11_IRA.add_uniq_edge(G11_IRB1.loc_key, G11_IRB2.loc_key)
+G11_cfg.add_uniq_edge(G11_IRB0.loc_key, G11_IRB1.loc_key)
+#G11_cfg.add_uniq_edge(G11_IRB3.loc_key, G11_IRB1.loc_key)
+G11_cfg.add_uniq_edge(G11_IRB1.loc_key, G11_IRB0.loc_key)
+#G11_cfg.add_uniq_edge(G11_IRB4.loc_key, G11_IRB0.loc_key)
+G11_cfg.add_uniq_edge(G11_IRB1.loc_key, G11_IRB2.loc_key)
 
 
 # Expected output for graph 11
-G11_EXP_IRA = IRA.new_ircfg()
+G11_EXP_cfg = Lifter.new_ircfg()
 
 G11_EXP_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, b)]])
 G11_EXP_IRB1 = gen_irblock(LBL1, [[ExprAssign(b, a)]])
@@ -411,12 +411,12 @@ G11_EXP_IRB2 = gen_irblock(LBL2, [[ExprAssign(r, a)]])
 
 for irb in [G11_EXP_IRB0, G11_EXP_IRB1,
             G11_EXP_IRB2]:
-    G11_EXP_IRA.add_irblock(irb)
+    G11_EXP_cfg.add_irblock(irb)
 
 # graph 12 : Graph with multiple out points and useless definitions
 # of return register
 
-G12_IRA = IRA.new_ircfg()
+G12_cfg = Lifter.new_ircfg()
 
 G12_IRB0 = gen_irblock(LBL0, [[ExprAssign(r, CST1)], [ExprAssign(a, CST2)]])
 G12_IRB1 = gen_irblock(LBL1, [[ExprAssign(r, CST2)]])
@@ -426,16 +426,16 @@ G12_IRB4 = gen_irblock(LBL4, [[ExprAssign(r, CST2)]])
 G12_IRB5 = gen_irblock(LBL5, [[ExprAssign(r, b)]])
 
 for irb in [G12_IRB0, G12_IRB1, G12_IRB2, G12_IRB3, G12_IRB4, G12_IRB5]:
-    G12_IRA.add_irblock(irb)
+    G12_cfg.add_irblock(irb)
 
-G12_IRA.add_uniq_edge(G12_IRB0.loc_key, G12_IRB1.loc_key)
-G12_IRA.add_uniq_edge(G12_IRB0.loc_key, G12_IRB2.loc_key)
-G12_IRA.add_uniq_edge(G12_IRB2.loc_key, G12_IRB3.loc_key)
-G12_IRA.add_uniq_edge(G12_IRB2.loc_key, G12_IRB4.loc_key)
-G12_IRA.add_uniq_edge(G12_IRB4.loc_key, G12_IRB5.loc_key)
+G12_cfg.add_uniq_edge(G12_IRB0.loc_key, G12_IRB1.loc_key)
+G12_cfg.add_uniq_edge(G12_IRB0.loc_key, G12_IRB2.loc_key)
+G12_cfg.add_uniq_edge(G12_IRB2.loc_key, G12_IRB3.loc_key)
+G12_cfg.add_uniq_edge(G12_IRB2.loc_key, G12_IRB4.loc_key)
+G12_cfg.add_uniq_edge(G12_IRB4.loc_key, G12_IRB5.loc_key)
 
 # Expected output for graph 12
-G12_EXP_IRA = IRA.new_ircfg()
+G12_EXP_cfg = Lifter.new_ircfg()
 
 G12_EXP_IRB0 = gen_irblock(LBL0, [[], []])
 G12_EXP_IRB1 = gen_irblock(LBL1, [[ExprAssign(r, CST2)]])
@@ -448,11 +448,11 @@ G12_EXP_IRB5 = gen_irblock(LBL5, [[ExprAssign(r, b)]])
 for irb in [G12_EXP_IRB0, G12_EXP_IRB1,
             G12_EXP_IRB2, G12_EXP_IRB3,
             G12_EXP_IRB4, G12_EXP_IRB5]:
-    G12_EXP_IRA.add_irblock(irb)
+    G12_EXP_cfg.add_irblock(irb)
 
 # graph 13 : Graph where a leaf has lost its son
 
-G13_IRA = IRA.new_ircfg()
+G13_cfg = Lifter.new_ircfg()
 
 G13_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, CST1)], [ExprAssign(b, CST2)]])
 G13_IRB1 = gen_irblock(LBL1, [[ExprAssign(r, b)]])
@@ -462,15 +462,15 @@ G13_IRB3 = gen_irblock(LBL3, [[]]) # lost son
 G13_IRB4 = gen_irblock(LBL4, [[ExprAssign(b, CST2)]])
 
 for irb in [G13_IRB0, G13_IRB1, G13_IRB2, G13_IRB4]:
-    G13_IRA.add_irblock(irb)
+    G13_cfg.add_irblock(irb)
 
-G13_IRA.add_uniq_edge(G13_IRB0.loc_key, G13_IRB1.loc_key)
-G13_IRA.add_uniq_edge(G13_IRB0.loc_key, G13_IRB4.loc_key)
-G13_IRA.add_uniq_edge(G13_IRB2.loc_key, G13_IRB3.loc_key)
-G13_IRA.add_uniq_edge(G13_IRB4.loc_key, G13_IRB2.loc_key)
+G13_cfg.add_uniq_edge(G13_IRB0.loc_key, G13_IRB1.loc_key)
+G13_cfg.add_uniq_edge(G13_IRB0.loc_key, G13_IRB4.loc_key)
+G13_cfg.add_uniq_edge(G13_IRB2.loc_key, G13_IRB3.loc_key)
+G13_cfg.add_uniq_edge(G13_IRB4.loc_key, G13_IRB2.loc_key)
 
 # Expected output for graph 13
-G13_EXP_IRA = IRA.new_ircfg()
+G13_EXP_cfg = Lifter.new_ircfg()
 
 G13_EXP_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, CST1)], [ExprAssign(b, CST2)]])
 G13_EXP_IRB1 = gen_irblock(LBL1, [[ExprAssign(r, b)]])
@@ -480,38 +480,38 @@ G13_EXP_IRB3 = gen_irblock(LBL3, [[]])
 G13_EXP_IRB4 = gen_irblock(LBL4, [[ExprAssign(b, CST2)]])
 
 for irb in [G13_EXP_IRB0, G13_EXP_IRB1, G13_EXP_IRB2, G13_EXP_IRB4]:
-    G13_EXP_IRA.add_irblock(irb)
+    G13_EXP_cfg.add_irblock(irb)
 
-#G13_EXP_IRA = G13_IRA
+#G13_EXP_cfg = G13_cfg
 
 # graph 14 : Graph where variable assigned multiple times in a block but still
 # useful in the end
 
-G14_IRA = IRA.new_ircfg()
+G14_cfg = Lifter.new_ircfg()
 
 G14_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, CST1)], [ExprAssign(c, a)],
                               [ExprAssign(a, CST2)]])
 G14_IRB1 = gen_irblock(LBL1, [[ExprAssign(r, a+c)]])
 
 for irb in [G14_IRB0, G14_IRB1]:
-    G14_IRA.add_irblock(irb)
+    G14_cfg.add_irblock(irb)
 
-G14_IRA.add_uniq_edge(G14_IRB0.loc_key, G14_IRB1.loc_key)
+G14_cfg.add_uniq_edge(G14_IRB0.loc_key, G14_IRB1.loc_key)
 
 # Expected output for graph 1
-G14_EXP_IRA = IRA.new_ircfg()
+G14_EXP_cfg = Lifter.new_ircfg()
 
 G14_EXP_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, CST1)], [ExprAssign(c, a)],
                                   [ExprAssign(a, CST2)]])
 G14_EXP_IRB1 = gen_irblock(LBL1, [[ExprAssign(r, a+c)]])
 
 for irb in [G14_EXP_IRB0, G14_EXP_IRB1]:
-    G14_EXP_IRA.add_irblock(irb)
+    G14_EXP_cfg.add_irblock(irb)
 
 # graph 15 : Graph where variable assigned multiple and read at the same time,
 # but useless
 
-G15_IRA = IRA.new_ircfg()
+G15_cfg = Lifter.new_ircfg()
 
 G15_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, CST2)], [ExprAssign(a, CST1),
                                                    ExprAssign(b, a+CST2),
@@ -519,22 +519,22 @@ G15_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, CST2)], [ExprAssign(a, CST1),
 G15_IRB1 = gen_irblock(LBL1, [[ExprAssign(r, a)]])
 
 for irb in [G15_IRB0, G15_IRB1]:
-    G15_IRA.add_irblock(irb)
+    G15_cfg.add_irblock(irb)
 
-G15_IRA.add_uniq_edge(G15_IRB0.loc_key, G15_IRB1.loc_key)
+G15_cfg.add_uniq_edge(G15_IRB0.loc_key, G15_IRB1.loc_key)
 
 # Expected output for graph 1
-G15_EXP_IRA = IRA.new_ircfg()
+G15_EXP_cfg = Lifter.new_ircfg()
 
 G15_EXP_IRB0 = gen_irblock(LBL0, [[], [ExprAssign(a, CST1)]])
 G15_EXP_IRB1 = gen_irblock(LBL1, [[ExprAssign(r, a)]])
 
 for irb in [G15_EXP_IRB0, G15_EXP_IRB1]:
-    G15_EXP_IRA.add_irblock(irb)
+    G15_EXP_cfg.add_irblock(irb)
 
 # graph 16 : Graph where variable assigned multiple times in the same block
 
-G16_IRA = IRA.new_ircfg()
+G16_cfg = Lifter.new_ircfg()
 
 G16_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, CST1), ExprAssign(b, CST2),
                                ExprAssign(c, CST3)], [ExprAssign(a, c+CST1),
@@ -543,27 +543,27 @@ G16_IRB1 = gen_irblock(LBL1, [[ExprAssign(r, a+b)], [ExprAssign(r, c+r)]])
 G16_IRB2 = gen_irblock(LBL2, [[]])
 
 for irb in [G16_IRB0, G16_IRB1]:
-    G16_IRA.add_irblock(irb)
+    G16_cfg.add_irblock(irb)
 
-G16_IRA.add_uniq_edge(G16_IRB0.loc_key, G16_IRB1.loc_key)
-G16_IRA.add_uniq_edge(G16_IRB1.loc_key, G16_IRB2.loc_key)
+G16_cfg.add_uniq_edge(G16_IRB0.loc_key, G16_IRB1.loc_key)
+G16_cfg.add_uniq_edge(G16_IRB1.loc_key, G16_IRB2.loc_key)
 
 for irb in [G16_IRB0, G16_IRB1]:
-    G16_IRA.add_irblock(irb)
+    G16_cfg.add_irblock(irb)
 
 # Expected output for graph 1
-G16_EXP_IRA = IRA.new_ircfg()
+G16_EXP_cfg = Lifter.new_ircfg()
 
 G16_EXP_IRB0 = gen_irblock(LBL0, [[ExprAssign(c, CST3)], [ExprAssign(a, c + CST1),
                                                        ExprAssign(b, c + CST2)]])
 G16_EXP_IRB1 = gen_irblock(LBL1, [[ExprAssign(r, a+b)], [ExprAssign(r, c+r)]])
 
 for irb in [G16_EXP_IRB0, G16_EXP_IRB1]:
-    G16_EXP_IRA.add_irblock(irb)
+    G16_EXP_cfg.add_irblock(irb)
 
 # graph 17 : parallel ir
 
-G17_IRA = IRA.new_ircfg()
+G17_cfg = Lifter.new_ircfg()
 
 G17_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, a*b),
                                ExprAssign(b, c),
@@ -620,12 +620,12 @@ G17_IRB0 = gen_irblock(LBL0, [[ExprAssign(a, a*b),
                          ])
 
 for irb in [G17_IRB0]:
-    G17_IRA.add_irblock(irb)
+    G17_cfg.add_irblock(irb)
 
-#G17_IRA.graph.add_node(G17_IRB0.loc_key)
+#G17_cfg.graph.add_node(G17_IRB0.loc_key)
 
 # Expected output for graph 17
-G17_EXP_IRA = IRA.new_ircfg()
+G17_EXP_cfg = Lifter.new_ircfg()
 
 G17_EXP_IRB0 = gen_irblock(LBL0, [[],
 
@@ -663,48 +663,48 @@ G17_EXP_IRB0 = gen_irblock(LBL0, [[],
                                  ])
 
 for irb in [G17_EXP_IRB0]:
-    G17_EXP_IRA.add_irblock(irb)
+    G17_EXP_cfg.add_irblock(irb)
 
 # Beginning  of tests
 
-for test_nb, test in enumerate([(G1_IRA, G1_EXP_IRA),
-                                (G2_IRA, G2_EXP_IRA),
-                                (G3_IRA, G3_EXP_IRA),
-                                (G4_IRA, G4_EXP_IRA),
-                                (G5_IRA, G5_EXP_IRA),
-                                (G6_IRA, G6_EXP_IRA),
-                                (G7_IRA, G7_EXP_IRA),
-                                (G8_IRA, G8_EXP_IRA),
-                                (G9_IRA, G9_EXP_IRA),
-                                (G10_IRA, G10_EXP_IRA),
-                                (G11_IRA, G11_EXP_IRA),
-                                (G12_IRA, G12_EXP_IRA),
-                                (G13_IRA, G13_EXP_IRA),
-                                (G14_IRA, G14_EXP_IRA),
-                                (G15_IRA, G15_EXP_IRA),
-                                (G16_IRA, G16_EXP_IRA),
-                                (G17_IRA, G17_EXP_IRA)
+for test_nb, test in enumerate([(G1_cfg, G1_EXP_cfg),
+                                (G2_cfg, G2_EXP_cfg),
+                                (G3_cfg, G3_EXP_cfg),
+                                (G4_cfg, G4_EXP_cfg),
+                                (G5_cfg, G5_EXP_cfg),
+                                (G6_cfg, G6_EXP_cfg),
+                                (G7_cfg, G7_EXP_cfg),
+                                (G8_cfg, G8_EXP_cfg),
+                                (G9_cfg, G9_EXP_cfg),
+                                (G10_cfg, G10_EXP_cfg),
+                                (G11_cfg, G11_EXP_cfg),
+                                (G12_cfg, G12_EXP_cfg),
+                                (G13_cfg, G13_EXP_cfg),
+                                (G14_cfg, G14_EXP_cfg),
+                                (G15_cfg, G15_EXP_cfg),
+                                (G16_cfg, G16_EXP_cfg),
+                                (G17_cfg, G17_EXP_cfg)
 ]):
     # Extract test elements
-    g_ira, g_exp_ira = test
+    g_ircfg, g_exp_ircfg = test
 
     print("[+] Test", test_nb+1)
 
     # Print initial graph, for debug
-    open("graph_%02d.dot" % (test_nb+1), "w").write(g_ira.dot())
+    open("graph_%02d.dot" % (test_nb+1), "w").write(g_ircfg.dot())
 
-    reaching_defs = ReachingDefinitions(g_ira)
+    reaching_defs = ReachingDefinitions(g_ircfg)
     defuse = DiGraphDefUse(reaching_defs, deref_mem=True)
 
     # # Simplify graph
-    deadrm(g_ira)
+    deadrm(g_ircfg)
 
     # # Print simplified graph, for debug
-    open("simp_graph_%02d.dot" % (test_nb+1), "w").write(g_ira.dot())
+    open("simp_graph_%02d.dot" % (test_nb+1), "w").write(g_ircfg.dot())
 
     # Same number of blocks
-    assert len(g_ira.blocks) == len(g_exp_ira.blocks)
+    assert len(g_ircfg.blocks) == len(g_exp_ircfg.blocks)
     # Check that each expr in the blocks are the same
-    for lbl, irb in viewitems(g_ira.blocks):
-        exp_irb = g_exp_ira.blocks[lbl]
+    for lbl, irb in viewitems(g_ircfg.blocks):
+        exp_irb = g_exp_ircfg.blocks[lbl]
         assert exp_irb.assignblks == irb.assignblks
diff --git a/test/analysis/depgraph.py b/test/analysis/depgraph.py
index 49a395a1..f0b67737 100644
--- a/test/analysis/depgraph.py
+++ b/test/analysis/depgraph.py
@@ -6,7 +6,7 @@ from future.utils import viewitems
 from miasm.expression.expression import ExprId, ExprInt, ExprAssign, \
     ExprCond, ExprLoc, LocKey
 from miasm.core.locationdb import LocationDB
-from miasm.ir.analysis import ira
+from miasm.ir.analysis import LifterModelCall
 from miasm.ir.ir import IRBlock, AssignBlock
 from miasm.core.graph import DiGraph
 from miasm.analysis.depgraph import DependencyNode, DependencyGraph
@@ -91,7 +91,7 @@ class Arch(object):
         return SP
 
 
-class IRATest(ira):
+class IRATest(LifterModelCall):
 
     """Fake IRA class for tests"""
 
diff --git a/test/analysis/dse.py b/test/analysis/dse.py
index 570860e4..7a2843e0 100644
--- a/test/analysis/dse.py
+++ b/test/analysis/dse.py
@@ -90,7 +90,7 @@ class DSETest(object):
         self.assembly = bytes(output)
 
     def check(self):
-        regs = self.dse.ir_arch.arch.regs
+        regs = self.dse.lifter.arch.regs
         value = self.dse.eval_expr(regs.EDX)
         # The expected value should contains '<<', showing it has been in the
         # corresponding generated label
@@ -116,8 +116,8 @@ class DSEAttachInBreakpoint(DSETest):
     def __init__(self, *args, **kwargs):
         super(DSEAttachInBreakpoint, self).__init__(*args, **kwargs)
         self._dse = None
-        ircls = self.machine.ir
-        self._regs = ircls(self.loc_db).arch.regs
+        lifter_cls = self.machine.lifter
+        self._regs = lifter_cls(self.loc_db).arch.regs
         self._testid = ExprId("TEST", self._regs.EBX.size)
 
     def bp_attach(self, jitter):
diff --git a/test/analysis/unssa.py b/test/analysis/unssa.py
index 5844bfb4..bc7db487 100644
--- a/test/analysis/unssa.py
+++ b/test/analysis/unssa.py
@@ -5,7 +5,7 @@ from miasm.expression.expression import ExprId, ExprInt, ExprAssign, ExprMem, \
     ExprCond, ExprLoc
 from miasm.core.locationdb import LocationDB
 from miasm.analysis.simplifier import IRCFGSimplifierSSA
-from miasm.ir.analysis import ira
+from miasm.ir.analysis import LifterModelCall
 from miasm.ir.ir import IRCFG, IRBlock, AssignBlock
 
 loc_db = LocationDB()
@@ -73,7 +73,7 @@ class Arch(object):
     def getsp(self, _):
         return sp
 
-class IRATest(ira):
+class IRATest(LifterModelCall):
 
     """Fake IRA class for tests"""
 
@@ -601,8 +601,8 @@ class CustomIRCFGSimplifierSSA(IRCFGSimplifierSSA):
         """
         regs = set(
             [
-                self.ir_arch.pc,
-                self.ir_arch.IRDst,
+                self.lifter.pc,
+                self.lifter.IRDst,
             ]
         )
         return regs
diff --git a/test/arch/mep/ir/test_ir.py b/test/arch/mep/ir/test_ir.py
index 97a3ec1e..c811988b 100644
--- a/test/arch/mep/ir/test_ir.py
+++ b/test/arch/mep/ir/test_ir.py
@@ -6,7 +6,7 @@ from __future__ import print_function
 from miasm.core.utils import decode_hex
 from miasm.arch.mep.arch import mn_mep
 from miasm.arch.mep.regs import regs_init
-from miasm.arch.mep.ira import ir_mepb, ir_a_mepb
+from miasm.arch.mep.lifter_model_call import ir_mepb, ir_a_mepb
 from miasm.expression.expression import ExprId, ExprInt, ExprMem
 from miasm.ir.symbexec import SymbolicExecutionEngine
 from miasm.core.locationdb import LocationDB
diff --git a/test/arch/mep/ir/ut_helpers_ir.py b/test/arch/mep/ir/ut_helpers_ir.py
index c5bf36b9..ddbfdffb 100644
--- a/test/arch/mep/ir/ut_helpers_ir.py
+++ b/test/arch/mep/ir/ut_helpers_ir.py
@@ -11,7 +11,7 @@ from miasm.ir.symbexec import SymbolicExecutionEngine
 from miasm.core.locationdb import LocationDB
 from miasm.core.utils import Disasm_Exception
 from miasm.ir.ir import AssignBlock
-from miasm.arch.mep.ira import ir_a_mepb
+from miasm.arch.mep.lifter_model_call import ir_a_mepb
 from miasm.expression.expression import ExprId, ExprInt, ExprOp, ExprMem, \
     ExprAssign, ExprLoc
 
diff --git a/test/ir/reduce_graph.py b/test/ir/reduce_graph.py
index 4aa2d5ef..5142cf5a 100644
--- a/test/ir/reduce_graph.py
+++ b/test/ir/reduce_graph.py
@@ -9,7 +9,7 @@ from miasm.expression.expression import ExprId, ExprInt, ExprAssign, ExprCond, \
     ExprLoc, LocKey
 
 from miasm.core.locationdb import LocationDB
-from miasm.ir.analysis import ira
+from miasm.ir.analysis import LifterModelCall
 from miasm.ir.ir import IRBlock, AssignBlock, IRCFG
 from miasm.analysis.data_flow import merge_blocks
 
@@ -70,7 +70,7 @@ class Arch(object):
         return SP
 
 
-class IRATest(ira):
+class IRATest(LifterModelCall):
 
     """Fake IRA class for tests"""
 
diff --git a/test/ir/symbexec.py b/test/ir/symbexec.py
index d627f4b9..5b4d19b2 100755
--- a/test/ir/symbexec.py
+++ b/test/ir/symbexec.py
@@ -20,8 +20,8 @@ class TestSymbExec(unittest.TestCase):
 
 
         loc_db = LocationDB()
-        ira = ir_x86_32(loc_db)
-        ircfg = ira.new_ircfg()
+        lifter_model_call = ir_x86_32(loc_db)
+        ircfg = lifter_model_call.new_ircfg()
 
         id_x = ExprId('x', 32)
         id_a = ExprId('a', 32)
@@ -36,7 +36,7 @@ class TestSymbExec(unittest.TestCase):
                     return id_x
                 return super(CustomSymbExec, self).mem_read(expr)
 
-        sb = CustomSymbExec(ira,
+        sb = CustomSymbExec(lifter_model_call,
                             {
                                 ExprMem(ExprInt(0x4, 32), 8): ExprInt(0x44, 8),
                                 ExprMem(ExprInt(0x5, 32), 8): ExprInt(0x33, 8),
@@ -229,7 +229,7 @@ class TestSymbExec(unittest.TestCase):
         assert found
 
 
-        sb_empty = SymbolicExecutionEngine(ira)
+        sb_empty = SymbolicExecutionEngine(lifter_model_call)
         sb_empty.dump()
 
 
diff --git a/test/test_all.py b/test/test_all.py
index c2391572..a8e55b2f 100755
--- a/test/test_all.py
+++ b/test/test_all.py
@@ -602,8 +602,8 @@ for script, prods, depends in [
         ], ["bin_cfg.dot"], [test_x86_32_dis]),
         (["dis_binary_ir.py", Example.get_sample("test_x86_32_dis.bin"),
         ], ["bin_ir_cfg.dot"], [test_x86_32_dis]),
-        (["dis_binary_ira.py", Example.get_sample("test_x86_32_dis.bin"),
-        ], ["bin_ira_cfg.dot"], [test_x86_32_dis]),
+        (["dis_binary_lifter_model_call.py", Example.get_sample("test_x86_32_dis.bin"),
+        ], ["bin_lifter_model_call_cfg.dot"], [test_x86_32_dis]),
         (["full.py", Example.get_sample("box_upx.exe")],
          ["graph_execflow.dot", "lines.dot"], []),
 ]: