about summary refs log tree commit diff stats
path: root/test/analysis
diff options
context:
space:
mode:
Diffstat (limited to 'test/analysis')
-rw-r--r--test/analysis/data_flow.py339
-rw-r--r--test/analysis/depgraph.py570
2 files changed, 553 insertions, 356 deletions
diff --git a/test/analysis/data_flow.py b/test/analysis/data_flow.py
index 8204d9ce..d0dbbd8d 100644
--- a/test/analysis/data_flow.py
+++ b/test/analysis/data_flow.py
@@ -77,108 +77,113 @@ class IRATest(ira):
     def get_out_regs(self, _):
         return set([self.ret_reg, self.sp])
 
+IRA = IRATest(loc_db)
+
 # graph 1 : Simple graph with dead and alive variables
 
-G1_IRA = IRATest(loc_db)
+G1_IRA = IRA.new_ircfg()
 
 G1_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)], [ExprAff(b, CST2)]])
 G1_IRB1 = gen_irblock(LBL1, [[ExprAff(a, b)]])
 G1_IRB2 = gen_irblock(LBL2, [[ExprAff(r, a)]])
 
-G1_IRA.blocks = {irb.loc_key : irb for irb in [G1_IRB0, G1_IRB1, G1_IRB2]}
+for irb in [G1_IRB0, G1_IRB1, G1_IRB2]:
+    G1_IRA.add_irblock(irb)
 
-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)
+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)
 
 # Expected output for graph 1
-G1_EXP_IRA = IRATest(loc_db)
+G1_EXP_IRA = IRA.new_ircfg()
 
 G1_EXP_IRB0 = gen_irblock(LBL0, [[], [ExprAff(b, CST2)]])
 G1_EXP_IRB1 = gen_irblock(LBL1, [[ExprAff(a, b)]])
 G1_EXP_IRB2 = gen_irblock(LBL2, [[ExprAff(r, a)]])
 
-G1_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G1_EXP_IRB0, G1_EXP_IRB1,
-                                                 G1_EXP_IRB2]}
+for irb in [G1_EXP_IRB0, G1_EXP_IRB1, G1_EXP_IRB2]:
+    G1_EXP_IRA.add_irblock(irb)
 
 # graph 2 : Natural loop with dead variable
 
-G2_IRA = IRATest(loc_db)
+G2_IRA = IRA.new_ircfg()
 
 G2_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)], [ExprAff(r, CST1)]])
 G2_IRB1 = gen_irblock(LBL1, [[ExprAff(a, a+CST1)]])
 G2_IRB2 = gen_irblock(LBL2, [[ExprAff(a, r)]])
 
-G2_IRA.blocks = {irb.loc_key : irb for irb in [G2_IRB0, G2_IRB1, G2_IRB2]}
+for irb in [G2_IRB0, G2_IRB1, G2_IRB2]:
+    G2_IRA.add_irblock(irb)
 
-G2_IRA.graph.add_uniq_edge(G2_IRB0.loc_key, G2_IRB1.loc_key)
-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)
+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)
 
 # Expected output for graph 2
-G2_EXP_IRA = IRATest(loc_db)
+G2_EXP_IRA = IRA.new_ircfg()
 
 G2_EXP_IRB0 = gen_irblock(LBL0, [[], [ExprAff(r, CST1)]])
 G2_EXP_IRB1 = gen_irblock(LBL1, [[]])
 G2_EXP_IRB2 = gen_irblock(LBL2, [[]])
 
-G2_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G2_EXP_IRB0, G2_EXP_IRB1,
-                                                 G2_EXP_IRB2]}
+for irb in [G2_EXP_IRB0, G2_EXP_IRB1, G2_EXP_IRB2]:
+    G2_EXP_IRA.add_irblock(irb)
 
 # graph 3 : Natural loop with alive variables
 
-G3_IRA = IRATest(loc_db)
+G3_IRA = IRA.new_ircfg()
 
 G3_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)]])
 G3_IRB1 = gen_irblock(LBL1, [[ExprAff(a, a+CST1)]])
 G3_IRB2 = gen_irblock(LBL2, [[ExprAff(r, a)]])
 
-G3_IRA.blocks = {irb.loc_key : irb for irb in [G3_IRB0, G3_IRB1, G3_IRB2]}
+for irb in [G3_IRB0, G3_IRB1, G3_IRB2]:
+    G3_IRA.add_irblock(irb)
 
-G3_IRA.graph.add_uniq_edge(G3_IRB0.loc_key, G3_IRB1.loc_key)
-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)
+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)
 
 # Expected output for graph 3
-G3_EXP_IRA = IRATest(loc_db)
+G3_EXP_IRA = IRA.new_ircfg()
 
 G3_EXP_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)]])
 G3_EXP_IRB1 = gen_irblock(LBL1, [[ExprAff(a, a+CST1)]])
 G3_EXP_IRB2 = gen_irblock(LBL2, [[ExprAff(r, a)]])
 
-G3_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G3_EXP_IRB0, G3_EXP_IRB1,
-                                                 G3_EXP_IRB2]}
+for irb in [G3_EXP_IRB0, G3_EXP_IRB1, G3_EXP_IRB2]:
+    G3_EXP_IRA.add_irblock(irb)
 
 # graph 4 : If/else with dead variables
 
-G4_IRA = IRATest(loc_db)
+G4_IRA = IRA.new_ircfg()
 
 G4_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)]])
 G4_IRB1 = gen_irblock(LBL1, [[ExprAff(a, a+CST1)]])
 G4_IRB2 = gen_irblock(LBL2, [[ExprAff(a, a+CST2)]])
 G4_IRB3 = gen_irblock(LBL3, [[ExprAff(a, CST3)], [ExprAff(r, a)]])
 
-G4_IRA.blocks = {irb.loc_key : irb for irb in [G4_IRB0, G4_IRB1, G4_IRB2,
-                                            G4_IRB3]}
+for irb in [G4_IRB0, G4_IRB1, G4_IRB2, G4_IRB3]:
+    G4_IRA.add_irblock(irb)
 
-G4_IRA.graph.add_uniq_edge(G4_IRB0.loc_key, G4_IRB1.loc_key)
-G4_IRA.graph.add_uniq_edge(G4_IRB0.loc_key, G4_IRB2.loc_key)
-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)
+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)
 
 # Expected output for graph 4
-G4_EXP_IRA = IRATest(loc_db)
+G4_EXP_IRA = IRA.new_ircfg()
 
 G4_EXP_IRB0 = gen_irblock(LBL0, [[]])
 G4_EXP_IRB1 = gen_irblock(LBL1, [[]])
 G4_EXP_IRB2 = gen_irblock(LBL2, [[]])
 G4_EXP_IRB3 = gen_irblock(LBL3, [[ExprAff(a, CST3)], [ExprAff(r, a)]])
 
-G4_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G4_EXP_IRB0, G4_EXP_IRB1,
-                                                 G4_EXP_IRB2, G4_EXP_IRB3]}
+for irb in [G4_EXP_IRB0, G4_EXP_IRB1, G4_EXP_IRB2, G4_EXP_IRB3]:
+    G4_EXP_IRA.add_irblock(irb)
 
 # graph 5 : Loop and If/else with dead variables
 
-G5_IRA = IRATest(loc_db)
+G5_IRA = IRA.new_ircfg()
 
 G5_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)]])
 G5_IRB1 = gen_irblock(LBL1, [[ExprAff(r, CST2)]])
@@ -187,19 +192,19 @@ G5_IRB3 = gen_irblock(LBL3, [[ExprAff(a, a+CST3)]])
 G5_IRB4 = gen_irblock(LBL4, [[ExprAff(a, a+CST1)]])
 G5_IRB5 = gen_irblock(LBL5, [[ExprAff(a, r)]])
 
-G5_IRA.blocks = {irb.loc_key : irb for irb in [G5_IRB0, G5_IRB1, G5_IRB2, G5_IRB3,
-                                            G5_IRB4, G5_IRB5]}
+for irb in [G5_IRB0, G5_IRB1, G5_IRB2, G5_IRB3, G5_IRB4, G5_IRB5]:
+    G5_IRA.add_irblock(irb)
 
-G5_IRA.graph.add_uniq_edge(G5_IRB0.loc_key, G5_IRB1.loc_key)
-G5_IRA.graph.add_uniq_edge(G5_IRB1.loc_key, G5_IRB2.loc_key)
-G5_IRA.graph.add_uniq_edge(G5_IRB1.loc_key, G5_IRB3.loc_key)
-G5_IRA.graph.add_uniq_edge(G5_IRB2.loc_key, G5_IRB4.loc_key)
-G5_IRA.graph.add_uniq_edge(G5_IRB3.loc_key, G5_IRB4.loc_key)
-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)
+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)
 
 # Expected output for graph 5
-G5_EXP_IRA = IRATest(loc_db)
+G5_EXP_IRA = IRA.new_ircfg()
 
 G5_EXP_IRB0 = gen_irblock(LBL0, [[]])
 G5_EXP_IRB1 = gen_irblock(LBL1, [[ExprAff(r, CST2)]])
@@ -208,72 +213,72 @@ G5_EXP_IRB3 = gen_irblock(LBL3, [[]])
 G5_EXP_IRB4 = gen_irblock(LBL4, [[]])
 G5_EXP_IRB5 = gen_irblock(LBL5, [[]])
 
-G5_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G5_EXP_IRB0, G5_EXP_IRB1,
-                                                 G5_EXP_IRB2, G5_EXP_IRB3,
-                                                 G5_EXP_IRB4, G5_EXP_IRB5]}
+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)
 
 # graph 6 : Natural loop with dead variables symetric affectation
 # (a = b <-> b = a )
 
-G6_IRA = IRATest(loc_db)
+G6_IRA = IRA.new_ircfg()
 
 G6_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)]])
 G6_IRB1 = gen_irblock(LBL1, [[ExprAff(b, a)]])
 G6_IRB2 = gen_irblock(LBL2, [[ExprAff(a, b)]])
 G6_IRB3 = gen_irblock(LBL3, [[ExprAff(r, CST2)]])
 
-G6_IRA.blocks = {irb.loc_key : irb for irb in [G6_IRB0, G6_IRB1, G6_IRB2,
-                                            G6_IRB3]}
+for irb in [G6_IRB0, G6_IRB1, G6_IRB2, G6_IRB3]:
+    G6_IRA.add_irblock(irb)
 
-G6_IRA.graph.add_uniq_edge(G6_IRB0.loc_key, G6_IRB1.loc_key)
-G6_IRA.graph.add_uniq_edge(G6_IRB1.loc_key, G6_IRB2.loc_key)
-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)
+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)
 
 # Expected output for graph 6
-G6_EXP_IRA = IRATest(loc_db)
+G6_EXP_IRA = IRA.new_ircfg()
 
 G6_EXP_IRB0 = gen_irblock(LBL0, [[]])
 G6_EXP_IRB1 = gen_irblock(LBL1, [[]])
 G6_EXP_IRB2 = gen_irblock(LBL2, [[]])
 G6_EXP_IRB3 = gen_irblock(LBL3, [[ExprAff(r, CST2)]])
 
-G6_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G6_EXP_IRB0, G6_EXP_IRB1,
-                                                 G6_EXP_IRB2, G6_EXP_IRB3]}
+for irb in [G6_EXP_IRB0, G6_EXP_IRB1, G6_EXP_IRB2, G6_EXP_IRB3]:
+    G6_EXP_IRA.add_irblock(irb)
 
 # graph 7 : Double entry loop with dead variables
 
-G7_IRA = IRATest(loc_db)
+G7_IRA = IRA.new_ircfg()
 
 G7_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)], [ExprAff(r, CST1)]])
 G7_IRB1 = gen_irblock(LBL1, [[ExprAff(a, a+CST1)]])
 G7_IRB2 = gen_irblock(LBL2, [[ExprAff(a, a+CST2)]])
 G7_IRB3 = gen_irblock(LBL3, [[ExprAff(a, r)]])
 
-G7_IRA.blocks = {irb.loc_key : irb for irb in [G7_IRB0, G7_IRB1, G7_IRB2,
-                                            G7_IRB3]}
+for irb in [G7_IRB0, G7_IRB1, G7_IRB2, G7_IRB3]:
+    G7_IRA.add_irblock(irb)
 
-G7_IRA.graph.add_uniq_edge(G7_IRB0.loc_key, G7_IRB1.loc_key)
-G7_IRA.graph.add_uniq_edge(G7_IRB1.loc_key, G7_IRB2.loc_key)
-G7_IRA.graph.add_uniq_edge(G7_IRB2.loc_key, G7_IRB1.loc_key)
-G7_IRA.graph.add_uniq_edge(G7_IRB2.loc_key, G7_IRB3.loc_key)
-G7_IRA.graph.add_uniq_edge(G7_IRB0.loc_key, G7_IRB2.loc_key)
+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)
 
 
 # Expected output for graph 7
-G7_EXP_IRA = IRATest(loc_db)
+G7_EXP_IRA = IRA.new_ircfg()
 
 G7_EXP_IRB0 = gen_irblock(LBL0, [[], [ExprAff(r, CST1)]])
 G7_EXP_IRB1 = gen_irblock(LBL1, [[]])
 G7_EXP_IRB2 = gen_irblock(LBL2, [[]])
 G7_EXP_IRB3 = gen_irblock(LBL3, [[]])
 
-G7_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G7_EXP_IRB0, G7_EXP_IRB1,
-                                                 G7_EXP_IRB2, G7_EXP_IRB3]}
+for irb in [G7_EXP_IRB0, G7_EXP_IRB1, G7_EXP_IRB2, G7_EXP_IRB3]:
+    G7_EXP_IRA.add_irblock(irb)
 
 # graph 8 : Nested loops with dead variables
 
-G8_IRA = IRATest(loc_db)
+G8_IRA = IRA.new_ircfg()
 
 G8_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)], [ExprAff(b, CST1)]])
 G8_IRB1 = gen_irblock(LBL1, [[ExprAff(a, a+CST1)]])
@@ -281,31 +286,31 @@ G8_IRB2 = gen_irblock(LBL2, [[ExprAff(b, b+CST2)]])
 G8_IRB3 = gen_irblock(LBL3, [[ExprAff(a, b)]])
 
 
-G8_IRA.blocks = {irb.loc_key : irb for irb in [G8_IRB0, G8_IRB1, G8_IRB2,
-                                            G8_IRB3]}
+for irb in [G8_IRB0, G8_IRB1, G8_IRB2, G8_IRB3]:
+    G8_IRA.add_irblock(irb)
 
-G8_IRA.graph.add_uniq_edge(G8_IRB0.loc_key, G8_IRB1.loc_key)
-G8_IRA.graph.add_uniq_edge(G8_IRB1.loc_key, G8_IRB2.loc_key)
-G8_IRA.graph.add_uniq_edge(G8_IRB2.loc_key, G8_IRB1.loc_key)
-G8_IRA.graph.add_uniq_edge(G8_IRB2.loc_key, G8_IRB3.loc_key)
-G8_IRA.graph.add_uniq_edge(G8_IRB3.loc_key, G8_IRB2.loc_key)
+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)
 
 
 # Expected output for graph 8
 
-G8_EXP_IRA = IRATest(loc_db)
+G8_EXP_IRA = IRA.new_ircfg()
 
 G8_EXP_IRB0 = gen_irblock(LBL0, [[], []])
 G8_EXP_IRB1 = gen_irblock(LBL1, [[]])
 G8_EXP_IRB2 = gen_irblock(LBL2, [[]])
 G8_EXP_IRB3 = gen_irblock(LBL3, [[]])
 
-G8_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G8_EXP_IRB0, G8_EXP_IRB1,
-                                                 G8_EXP_IRB2, G8_EXP_IRB3]}
+for irb in [G8_EXP_IRB0, G8_EXP_IRB1, G8_EXP_IRB2, G8_EXP_IRB3]:
+    G8_EXP_IRA.add_irblock(irb)
 
 # graph 9 : Miultiple-exits loops with dead variables
 
-G9_IRA = IRATest(loc_db)
+G9_IRA = IRA.new_ircfg()
 
 G9_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)], [ExprAff(b, CST1)]])
 G9_IRB1 = gen_irblock(LBL1, [[ExprAff(a, a+CST1)], [ExprAff(b, b+CST1)]])
@@ -313,22 +318,22 @@ G9_IRB2 = gen_irblock(LBL2, [[ExprAff(a, a+CST2)], [ExprAff(b, b+CST2)]])
 G9_IRB3 = gen_irblock(LBL3, [[ExprAff(a, b)]])
 G9_IRB4 = gen_irblock(LBL4, [[ExprAff(r, a)], [ExprAff(r, b)]])
 
-G9_IRA.blocks = {irb.loc_key : irb for irb in [G9_IRB0, G9_IRB1, G9_IRB2,
-                                            G9_IRB3, G9_IRB4]}
+for irb in [G9_IRB0, G9_IRB1, G9_IRB2, G9_IRB3, G9_IRB4]:
+    G9_IRA.add_irblock(irb)
 
-G9_IRA.graph.add_uniq_edge(G9_IRB0.loc_key, G9_IRB4.loc_key)
-G9_IRA.graph.add_uniq_edge(G9_IRB0.loc_key, G9_IRB1.loc_key)
-G9_IRA.graph.add_uniq_edge(G9_IRB1.loc_key, G9_IRB0.loc_key)
-G9_IRA.graph.add_uniq_edge(G9_IRB1.loc_key, G9_IRB4.loc_key)
-G9_IRA.graph.add_uniq_edge(G9_IRB1.loc_key, G9_IRB2.loc_key)
-G9_IRA.graph.add_uniq_edge(G9_IRB2.loc_key, G9_IRB0.loc_key)
-G9_IRA.graph.add_uniq_edge(G9_IRB2.loc_key, G9_IRB3.loc_key)
-G9_IRA.graph.add_uniq_edge(G9_IRB3.loc_key, G9_IRB4.loc_key)
+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)
 
 
 # Expected output for graph 9
 
-G9_EXP_IRA = IRATest(loc_db)
+G9_EXP_IRA = IRA.new_ircfg()
 
 G9_EXP_IRB0 = gen_irblock(LBL0, [[], [ExprAff(b, CST1)]])
 G9_EXP_IRB1 = gen_irblock(LBL1, [[], [ExprAff(b, b+CST1)]])
@@ -336,42 +341,42 @@ G9_EXP_IRB2 = gen_irblock(LBL2, [[], [ExprAff(b, b+CST2)]])
 G9_EXP_IRB3 = gen_irblock(LBL3, [[]])
 G9_EXP_IRB4 = gen_irblock(LBL4, [[], [ExprAff(r, b)]])
 
-G9_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G9_EXP_IRB0, G9_EXP_IRB1,
-                                                 G9_EXP_IRB2, G9_EXP_IRB3,
-                                                 G9_EXP_IRB4]}
+for irb in [G9_EXP_IRB0, G9_EXP_IRB1, G9_EXP_IRB2, G9_EXP_IRB3, G9_EXP_IRB4]:
+    G9_EXP_IRA.add_irblock(irb)
 
 # graph 10 : Natural loop with alive variables symetric affectation
 # (a = b <-> b = a )
 
-G10_IRA = IRATest(loc_db)
+G10_IRA = IRA.new_ircfg()
 
 G10_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)]])
 G10_IRB1 = gen_irblock(LBL1, [[ExprAff(b, a)]])
 G10_IRB2 = gen_irblock(LBL2, [[ExprAff(a, b)]])
 G10_IRB3 = gen_irblock(LBL3, [[ExprAff(r, CST1)]])
 
-G10_IRA.blocks = {irb.loc_key : irb for irb in [G10_IRB0, G10_IRB1,
-                                             G10_IRB2, G10_IRB3]}
+for irb in [G10_IRB0, G10_IRB1, G10_IRB2, G10_IRB3]:
+    G10_IRA.add_irblock(irb)
+
 
-G10_IRA.graph.add_uniq_edge(G10_IRB0.loc_key, G10_IRB1.loc_key)
-G10_IRA.graph.add_uniq_edge(G10_IRB1.loc_key, G10_IRB2.loc_key)
-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)
+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)
 
 # Expected output for graph 10
-G10_EXP_IRA = IRATest(loc_db)
+G10_EXP_IRA = IRA.new_ircfg()
 
 G10_EXP_IRB0 = gen_irblock(LBL0, [[]])
 G10_EXP_IRB1 = gen_irblock(LBL1, [[]])
 G10_EXP_IRB2 = gen_irblock(LBL2, [[]])
 G10_EXP_IRB3 = gen_irblock(LBL3, [[ExprAff(r, CST1)]])
 
-G10_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G10_EXP_IRB0, G10_EXP_IRB1,
-                                                  G10_EXP_IRB2, G10_EXP_IRB3]}
+for irb in [G10_EXP_IRB0, G10_EXP_IRB1, G10_EXP_IRB2, G10_EXP_IRB3]:
+    G10_EXP_IRA.add_irblock(irb)
 
 # graph 11 : If/Else conditions with alive variables
 
-G11_IRA = IRATest(loc_db)
+G11_IRA = IRA.new_ircfg()
 
 G11_IRB0 = gen_irblock(LBL0, [[ExprAff(a, b)]])
 G11_IRB1 = gen_irblock(LBL1, [[ExprAff(b, a)]])
@@ -380,17 +385,18 @@ G11_IRB3 = gen_irblock(LBL3, [[ExprAff(a, a+CST1)]])
 G11_IRB4 = gen_irblock(LBL4, [[ExprAff(b, b+CST1)]])
 
 
-G11_IRA.blocks = {irb.loc_key : irb for irb in [G11_IRB0, G11_IRB1, G11_IRB2]}
+for irb in [G11_IRB0, G11_IRB1, G11_IRB2]:
+    G11_IRA.add_irblock(irb)
 
-G11_IRA.graph.add_uniq_edge(G11_IRB0.loc_key, G11_IRB1.loc_key)
-#G11_IRA.graph.add_uniq_edge(G11_IRB3.loc_key, G11_IRB1.loc_key)
-G11_IRA.graph.add_uniq_edge(G11_IRB1.loc_key, G11_IRB0.loc_key)
-#G11_IRA.graph.add_uniq_edge(G11_IRB4.loc_key, G11_IRB0.loc_key)
-G11_IRA.graph.add_uniq_edge(G11_IRB1.loc_key, G11_IRB2.loc_key)
+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)
 
 
 # Expected output for graph 11
-G11_EXP_IRA = IRATest(loc_db)
+G11_EXP_IRA = IRA.new_ircfg()
 
 G11_EXP_IRB0 = gen_irblock(LBL0, [[ExprAff(a, b)]])
 G11_EXP_IRB1 = gen_irblock(LBL1, [[ExprAff(b, a)]])
@@ -398,13 +404,14 @@ G11_EXP_IRB2 = gen_irblock(LBL2, [[ExprAff(r, a)]])
 #G11_EXP_IRB3 = gen_irblock(LBL3, [[ExprAff(a, a+CST1)]])
 #G11_EXP_IRB4 = gen_irblock(LBL4, [[ExprAff(b, b+CST1)]])
 
-G11_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G11_EXP_IRB0, G11_EXP_IRB1,
-                                                  G11_EXP_IRB2]}
+for irb in [G11_EXP_IRB0, G11_EXP_IRB1,
+            G11_EXP_IRB2]:
+    G11_EXP_IRA.add_irblock(irb)
 
 # graph 12 : Graph with multiple out points and useless definitions
 # of return register
 
-G12_IRA = IRATest(loc_db)
+G12_IRA = IRA.new_ircfg()
 
 G12_IRB0 = gen_irblock(LBL0, [[ExprAff(r, CST1)], [ExprAff(a, CST2)]])
 G12_IRB1 = gen_irblock(LBL1, [[ExprAff(r, CST2)]])
@@ -413,17 +420,17 @@ G12_IRB3 = gen_irblock(LBL3, [[ExprAff(r, CST3)]])
 G12_IRB4 = gen_irblock(LBL4, [[ExprAff(r, CST2)]])
 G12_IRB5 = gen_irblock(LBL5, [[ExprAff(r, b)]])
 
-G12_IRA.blocks = {irb.loc_key : irb for irb in [G12_IRB0, G12_IRB1, G12_IRB2,
-                                             G12_IRB3, G12_IRB4, G12_IRB5]}
+for irb in [G12_IRB0, G12_IRB1, G12_IRB2, G12_IRB3, G12_IRB4, G12_IRB5]:
+    G12_IRA.add_irblock(irb)
 
-G12_IRA.graph.add_uniq_edge(G12_IRB0.loc_key, G12_IRB1.loc_key)
-G12_IRA.graph.add_uniq_edge(G12_IRB0.loc_key, G12_IRB2.loc_key)
-G12_IRA.graph.add_uniq_edge(G12_IRB2.loc_key, G12_IRB3.loc_key)
-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)
+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)
 
 # Expected output for graph 12
-G12_EXP_IRA = IRATest(loc_db)
+G12_EXP_IRA = IRA.new_ircfg()
 
 G12_EXP_IRB0 = gen_irblock(LBL0, [[], []])
 G12_EXP_IRB1 = gen_irblock(LBL1, [[ExprAff(r, CST2)]])
@@ -433,13 +440,14 @@ G12_EXP_IRB4 = gen_irblock(LBL4, [[]])
 G12_EXP_IRB5 = gen_irblock(LBL5, [[ExprAff(r, b)]])
 
 
-G12_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G12_EXP_IRB0, G12_EXP_IRB1,
-                                                  G12_EXP_IRB2, G12_EXP_IRB3,
-                                                  G12_EXP_IRB4, G12_EXP_IRB5]}
+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)
 
 # graph 13 : Graph where a leaf has lost its son
 
-G13_IRA = IRATest(loc_db)
+G13_IRA = IRA.new_ircfg()
 
 G13_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)], [ExprAff(b, CST2)]])
 G13_IRB1 = gen_irblock(LBL1, [[ExprAff(r, b)]])
@@ -448,16 +456,16 @@ G13_IRB2 = gen_irblock(LBL2, [[ExprAff(d, CST2)], [ExprAff(a, b+CST1),
 G13_IRB3 = gen_irblock(LBL3, [[]]) # lost son
 G13_IRB4 = gen_irblock(LBL4, [[ExprAff(b, CST2)]])
 
-G13_IRA.blocks = {irb.loc_key : irb for irb in [G13_IRB0, G13_IRB1, G13_IRB2,
-                                             G13_IRB4]}
+for irb in [G13_IRB0, G13_IRB1, G13_IRB2, G13_IRB4]:
+    G13_IRA.add_irblock(irb)
 
-G13_IRA.graph.add_uniq_edge(G13_IRB0.loc_key, G13_IRB1.loc_key)
-G13_IRA.graph.add_uniq_edge(G13_IRB0.loc_key, G13_IRB4.loc_key)
-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)
+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)
 
 # Expected output for graph 13
-G13_EXP_IRA = IRATest(loc_db)
+G13_EXP_IRA = IRA.new_ircfg()
 
 G13_EXP_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)], [ExprAff(b, CST2)]])
 G13_EXP_IRB1 = gen_irblock(LBL1, [[ExprAff(r, b)]])
@@ -466,58 +474,62 @@ G13_EXP_IRB2 = gen_irblock(LBL2, [[ExprAff(d, CST2)], [ExprAff(a, b+CST1),
 G13_EXP_IRB3 = gen_irblock(LBL3, [[]])
 G13_EXP_IRB4 = gen_irblock(LBL4, [[ExprAff(b, CST2)]])
 
-G13_EXP_IRA.blocks = {irb.loc_key: irb for irb in [G13_EXP_IRB0, G13_EXP_IRB1,
-                                                 G13_EXP_IRB2, G13_EXP_IRB4]}
+for irb in [G13_EXP_IRB0, G13_EXP_IRB1, G13_EXP_IRB2, G13_EXP_IRB4]:
+    G13_EXP_IRA.add_irblock(irb)
 
 #G13_EXP_IRA = G13_IRA
 
 # graph 14 : Graph where variable assigned multiple times in a block but still
 # useful in the end
 
-G14_IRA = IRATest(loc_db)
+G14_IRA = IRA.new_ircfg()
 
 G14_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)], [ExprAff(c, a)],
                               [ExprAff(a, CST2)]])
 G14_IRB1 = gen_irblock(LBL1, [[ExprAff(r, a+c)]])
 
-G14_IRA.blocks = {irb.loc_key : irb for irb in [G14_IRB0, G14_IRB1]}
+for irb in [G14_IRB0, G14_IRB1]:
+    G14_IRA.add_irblock(irb)
 
-G14_IRA.graph.add_uniq_edge(G14_IRB0.loc_key, G14_IRB1.loc_key)
+G14_IRA.add_uniq_edge(G14_IRB0.loc_key, G14_IRB1.loc_key)
 
 # Expected output for graph 1
-G14_EXP_IRA = IRATest(loc_db)
+G14_EXP_IRA = IRA.new_ircfg()
 
 G14_EXP_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1)], [ExprAff(c, a)],
                                   [ExprAff(a, CST2)]])
 G14_EXP_IRB1 = gen_irblock(LBL1, [[ExprAff(r, a+c)]])
 
-G14_EXP_IRA.blocks = {irb.loc_key: irb for irb in [G14_EXP_IRB0, G14_EXP_IRB1]}
+for irb in [G14_EXP_IRB0, G14_EXP_IRB1]:
+    G14_EXP_IRA.add_irblock(irb)
 
 # graph 15 : Graph where variable assigned multiple and read at the same time,
 # but useless
 
-G15_IRA = IRATest(loc_db)
+G15_IRA = IRA.new_ircfg()
 
 G15_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST2)], [ExprAff(a, CST1),
                                                    ExprAff(b, a+CST2),
                                                    ExprAff(c, CST1)]])
 G15_IRB1 = gen_irblock(LBL1, [[ExprAff(r, a)]])
 
-G15_IRA.blocks = {irb.loc_key : irb for irb in [G15_IRB0, G15_IRB1]}
+for irb in [G15_IRB0, G15_IRB1]:
+    G15_IRA.add_irblock(irb)
 
-G15_IRA.graph.add_uniq_edge(G15_IRB0.loc_key, G15_IRB1.loc_key)
+G15_IRA.add_uniq_edge(G15_IRB0.loc_key, G15_IRB1.loc_key)
 
 # Expected output for graph 1
-G15_EXP_IRA = IRATest(loc_db)
+G15_EXP_IRA = IRA.new_ircfg()
 
 G15_EXP_IRB0 = gen_irblock(LBL0, [[], [ExprAff(a, CST1)]])
 G15_EXP_IRB1 = gen_irblock(LBL1, [[ExprAff(r, a)]])
 
-G15_EXP_IRA.blocks = {irb.loc_key: irb for irb in [G15_EXP_IRB0, G15_EXP_IRB1]}
+for irb in [G15_EXP_IRB0, G15_EXP_IRB1]:
+    G15_EXP_IRA.add_irblock(irb)
 
 # graph 16 : Graph where variable assigned multiple times in the same bloc
 
-G16_IRA = IRATest(loc_db)
+G16_IRA = IRA.new_ircfg()
 
 G16_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1), ExprAff(b, CST2),
                                ExprAff(c, CST3)], [ExprAff(a, c+CST1),
@@ -525,25 +537,28 @@ G16_IRB0 = gen_irblock(LBL0, [[ExprAff(a, CST1), ExprAff(b, CST2),
 G16_IRB1 = gen_irblock(LBL1, [[ExprAff(r, a+b)], [ExprAff(r, c+r)]])
 G16_IRB2 = gen_irblock(LBL2, [[]])
 
-G16_IRA.blocks = {irb.loc_key : irb for irb in [G16_IRB0, G16_IRB1]}
+for irb in [G16_IRB0, G16_IRB1]:
+    G16_IRA.add_irblock(irb)
 
-G16_IRA.graph.add_uniq_edge(G16_IRB0.loc_key, G16_IRB1.loc_key)
-G16_IRA.graph.add_uniq_edge(G16_IRB1.loc_key, G16_IRB2.loc_key)
+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_IRA.blocks = {irb.loc_key : irb for irb in [G16_IRB0, G16_IRB1]}
+for irb in [G16_IRB0, G16_IRB1]:
+    G16_IRA.add_irblock(irb)
 
 # Expected output for graph 1
-G16_EXP_IRA = IRATest(loc_db)
+G16_EXP_IRA = IRA.new_ircfg()
 
 G16_EXP_IRB0 = gen_irblock(LBL0, [[ExprAff(c, CST3)], [ExprAff(a, c + CST1),
                                                        ExprAff(b, c + CST2)]])
 G16_EXP_IRB1 = gen_irblock(LBL1, [[ExprAff(r, a+b)], [ExprAff(r, c+r)]])
 
-G16_EXP_IRA.blocks = {irb.loc_key: irb for irb in [G16_EXP_IRB0, G16_EXP_IRB1]}
+for irb in [G16_EXP_IRB0, G16_EXP_IRB1]:
+    G16_EXP_IRA.add_irblock(irb)
 
 # graph 17 : parallel ir
 
-G17_IRA = IRATest(loc_db)
+G17_IRA = IRA.new_ircfg()
 
 G17_IRB0 = gen_irblock(LBL0, [[ExprAff(a, a*b),
                                ExprAff(b, c),
@@ -599,12 +614,13 @@ G17_IRB0 = gen_irblock(LBL0, [[ExprAff(a, a*b),
 
                          ])
 
-G17_IRA.blocks = {irb.loc_key : irb for irb in [G17_IRB0]}
+for irb in [G17_IRB0]:
+    G17_IRA.add_irblock(irb)
 
-G17_IRA.graph.add_node(G17_IRB0.loc_key)
+#G17_IRA.graph.add_node(G17_IRB0.loc_key)
 
 # Expected output for graph 17
-G17_EXP_IRA = IRATest(loc_db)
+G17_EXP_IRA = IRA.new_ircfg()
 
 G17_EXP_IRB0 = gen_irblock(LBL0, [[],
 
@@ -641,7 +657,8 @@ G17_EXP_IRB0 = gen_irblock(LBL0, [[],
                                   # Trick because a+b+c != ((a+b)+c)
                                  ])
 
-G17_EXP_IRA.blocks = {irb.loc_key : irb for irb in [G17_EXP_IRB0]}
+for irb in [G17_EXP_IRB0]:
+    G17_EXP_IRA.add_irblock(irb)
 
 # Begining  of tests
 
@@ -669,16 +686,16 @@ for test_nb, test in enumerate([(G1_IRA, G1_EXP_IRA),
     print "[+] Test", test_nb+1
 
     # Print initial graph, for debug
-    open("graph_%02d.dot" % (test_nb+1), "w").write(g_ira.graph.dot())
+    open("graph_%02d.dot" % (test_nb+1), "w").write(g_ira.dot())
 
     reaching_defs = ReachingDefinitions(g_ira)
     defuse = DiGraphDefUse(reaching_defs, deref_mem=True)
 
     # # Simplify graph
-    dead_simp(g_ira)
+    dead_simp(IRA, g_ira)
 
     # # Print simplified graph, for debug
-    open("simp_graph_%02d.dot" % (test_nb+1), "w").write(g_ira.graph.dot())
+    open("simp_graph_%02d.dot" % (test_nb+1), "w").write(g_ira.dot())
 
     # Same number of blocks
     assert len(g_ira.blocks) == len(g_exp_ira.blocks)
diff --git a/test/analysis/depgraph.py b/test/analysis/depgraph.py
index f0772cca..2ba5f044 100644
--- a/test/analysis/depgraph.py
+++ b/test/analysis/depgraph.py
@@ -24,6 +24,7 @@ B = ExprId("b", 32)
 C = ExprId("c", 32)
 D = ExprId("d", 32)
 R = ExprId("r", 32)
+COND = ExprId("cond", 32)
 
 A_INIT = ExprId("a_init", 32)
 B_INIT = ExprId("b_init", 32)
@@ -93,13 +94,84 @@ class IRATest(ira):
     def __init__(self, loc_db=None):
         arch = Arch()
         super(IRATest, self).__init__(arch, 32, loc_db)
-        self.IRDst = PC
+        self.IRDst = ExprId("IRDst", 32)
         self.ret_reg = R
 
     def get_out_regs(self, _):
         return set([self.ret_reg, self.sp])
 
 
+def bloc2graph(irgraph, label=False, lines=True):
+    """Render dot graph of @blocks"""
+
+    escape_chars = re.compile('[' + re.escape('{}') + ']')
+    label_attr = 'colspan="2" align="center" bgcolor="grey"'
+    edge_attr = 'label = "%s" color="%s" style="bold"'
+    td_attr = 'align="left"'
+    block_attr = 'shape="Mrecord" fontname="Courier New"'
+
+    out = ["digraph asm_graph {"]
+    fix_chars = lambda x: '\\' + x.group()
+
+    # Generate basic blocks
+    out_blocks = []
+    for label in irgraph.nodes():
+        assert isinstance(label, LocKey)
+        label_names = irgraph.loc_db.get_location_names(label)
+        label_name = list(label_names)[0]
+
+        if hasattr(irgraph, 'blocks'):
+            irblock = irgraph.blocks[label]
+        else:
+            irblock = None
+        if isinstance(label, LocKey):
+            out_block = '%s [\n' % label_name
+        else:
+            out_block = '%s [\n' % label
+        out_block += "%s " % block_attr
+        out_block += 'label =<<table border="0" cellborder="0" cellpadding="3">'
+
+        block_label = '<tr><td %s>%s</td></tr>' % (
+            label_attr, label_name)
+        block_html_lines = []
+        if lines and irblock is not None:
+            for assignblk in irblock:
+                for dst, src in assignblk.iteritems():
+                    if False:
+                        out_render = "%.8X</td><td %s> " % (0, td_attr)
+                    else:
+                        out_render = ""
+                    out_render += escape_chars.sub(fix_chars, "%s = %s" % (dst, src))
+                    block_html_lines.append(out_render)
+                block_html_lines.append(" ")
+            block_html_lines.pop()
+        block_html_lines = ('<tr><td %s>' % td_attr +
+                            ('</td></tr><tr><td %s>' % td_attr).join(block_html_lines) +
+                            '</td></tr>')
+        out_block += "%s " % block_label
+        out_block += block_html_lines + "</table>> ];"
+        out_blocks.append(out_block)
+
+    out += out_blocks
+    # Generate links
+    for src, dst in irgraph.edges():
+        assert isinstance(src, LocKey)
+        src_names = irgraph.loc_db.get_location_names(src)
+        assert isinstance(dst, LocKey)
+        dst_names = irgraph.loc_db.get_location_names(dst)
+
+        src_name = list(src_names)[0]
+        dst_name = list(dst_names)[0]
+
+        edge_color = "black"
+        out.append('%s -> %s' % (src_name,
+                                 dst_name) +
+                   '[' + edge_attr % ("", edge_color) + '];')
+
+    out.append("}")
+    return '\n'.join(out)
+
+
 def dg2graph(graph, label=False, lines=True):
     """Render dot graph of @blocks"""
 
@@ -157,287 +229,393 @@ DNC2 = DependencyNode(LBL1, C, 0)
 DNB3 = DependencyNode(LBL1, B, 1)
 DNC3 = DependencyNode(LBL1, C, 0)
 
+IRA = IRATest(loc_db)
+IRDst = IRA.IRDst
+END = ExprId("END", IRDst.size)
 # graph 1
 
-G1_IRA = IRATest(loc_db)
+G1_IRA = IRA.new_ircfg()
 
-G1_IRB0 = gen_irblock(LBL0, [[ExprAff(C, CST1)]])
-G1_IRB1 = gen_irblock(LBL1, [[ExprAff(B, C)]])
-G1_IRB2 = gen_irblock(LBL2, [[ExprAff(A, B)]])
+G1_IRB0 = gen_irblock(LBL0, [[ExprAff(C, CST1), ExprAff(IRDst, ExprLoc(LBL1, 32))]])
+G1_IRB1 = gen_irblock(LBL1, [[ExprAff(B, C), ExprAff(IRDst, ExprLoc(LBL2, 32))]])
+G1_IRB2 = gen_irblock(LBL2, [[ExprAff(A, B), ExprAff(IRDst, END)]])
 
-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)
-
-G1_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G1_IRB0, G1_IRB1, G1_IRB2]])
+for irb in [G1_IRB0, G1_IRB1, G1_IRB2]:
+    G1_IRA.add_irblock(irb)
 
 # graph 2
 
-G2_IRA = IRATest(loc_db)
-
-G2_IRB0 = gen_irblock(LBL0, [[ExprAff(C, CST1)]])
-G2_IRB1 = gen_irblock(LBL1, [[ExprAff(B, CST2)]])
-G2_IRB2 = gen_irblock(LBL2, [[ExprAff(A, B + C)]])
+G2_IRA = IRA.new_ircfg()
 
-G2_IRA.graph.add_uniq_edge(G2_IRB0.loc_key, G2_IRB1.loc_key)
-G2_IRA.graph.add_uniq_edge(G2_IRB1.loc_key, G2_IRB2.loc_key)
+G2_IRB0 = gen_irblock(LBL0, [[ExprAff(C, CST1), ExprAff(IRDst, ExprLoc(LBL1, 32))]])
+G2_IRB1 = gen_irblock(LBL1, [[ExprAff(B, CST2), ExprAff(IRDst, ExprLoc(LBL2, 32))]])
+G2_IRB2 = gen_irblock(LBL2, [[ExprAff(A, B + C), ExprAff(IRDst, END)]])
 
-G2_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G2_IRB0, G2_IRB1, G2_IRB2]])
+for irb in [G2_IRB0, G2_IRB1, G2_IRB2]:
+    G2_IRA.add_irblock(irb)
 
 
 # graph 3
 
-G3_IRA = IRATest(loc_db)
-
-G3_IRB0 = gen_irblock(LBL0, [[ExprAff(C, CST1)]])
-G3_IRB1 = gen_irblock(LBL1, [[ExprAff(B, CST2)]])
-G3_IRB2 = gen_irblock(LBL2, [[ExprAff(B, CST3)]])
-G3_IRB3 = gen_irblock(LBL3, [[ExprAff(A, B + C)]])
-
-G3_IRA.graph.add_uniq_edge(G3_IRB0.loc_key, G3_IRB1.loc_key)
-G3_IRA.graph.add_uniq_edge(G3_IRB0.loc_key, G3_IRB2.loc_key)
-G3_IRA.graph.add_uniq_edge(G3_IRB1.loc_key, G3_IRB3.loc_key)
-G3_IRA.graph.add_uniq_edge(G3_IRB2.loc_key, G3_IRB3.loc_key)
-
-G3_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G3_IRB0, G3_IRB1,
-                                                   G3_IRB2, G3_IRB3]])
+G3_IRA = IRA.new_ircfg()
+
+G3_IRB0 = gen_irblock(
+    LBL0,
+    [
+        [ExprAff(C, CST1), ExprAff(
+            IRDst, ExprCond(
+                COND,
+                ExprLoc(LBL1, 32),
+                ExprLoc(LBL2, 32)
+            )
+        )
+        ]
+    ]
+)
+
+G3_IRB1 = gen_irblock(LBL1, [[ExprAff(B, CST2), ExprAff(IRDst, ExprLoc(LBL3, 32))]])
+G3_IRB2 = gen_irblock(LBL2, [[ExprAff(B, CST3), ExprAff(IRDst, ExprLoc(LBL3, 32))]])
+G3_IRB3 = gen_irblock(LBL3, [[ExprAff(A, B + C), ExprAff(IRDst, END)]])
+
+for irb in [G3_IRB0, G3_IRB1, G3_IRB2, G3_IRB3]:
+    G3_IRA.add_irblock(irb)
 
 # graph 4
 
-G4_IRA = IRATest(loc_db)
-
-G4_IRB0 = gen_irblock(LBL0, [[ExprAff(C, CST1)]])
-G4_IRB1 = gen_irblock(LBL1, [[ExprAff(C, C + CST2)],
-                             [ExprAff(G4_IRA.IRDst,
-                                      ExprCond(C, ExprLoc(LBL2, 32),
-                                               ExprLoc(LBL1, 32)))]])
+G4_IRA = IRA.new_ircfg()
 
-G4_IRB2 = gen_irblock(LBL2, [[ExprAff(A, B)]])
+G4_IRB0 = gen_irblock(LBL0, [[ExprAff(C, CST1), ExprAff(IRDst, ExprLoc(LBL1, 32))]])
+G4_IRB1 = gen_irblock(
+    LBL1,
+    [
+        [ExprAff(C, C + CST2)],
+        [ExprAff(IRDst,
+                 ExprCond(
+                     C,
+                     ExprLoc(LBL2, 32),
+                     ExprLoc(LBL1, 32))
+        )
+        ]]
+)
 
-G4_IRA.graph.add_uniq_edge(G4_IRB0.loc_key, G4_IRB1.loc_key)
-G4_IRA.graph.add_uniq_edge(G4_IRB1.loc_key, G4_IRB2.loc_key)
-G4_IRA.graph.add_uniq_edge(G4_IRB1.loc_key, G4_IRB1.loc_key)
+G4_IRB2 = gen_irblock(LBL2, [[ExprAff(A, B), ExprAff(IRDst, END)]])
 
-G4_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G4_IRB0, G4_IRB1, G4_IRB2]])
+for irb in [G4_IRB0, G4_IRB1, G4_IRB2]:
+    G4_IRA.add_irblock(irb)
 
 
 # graph 5
 
-G5_IRA = IRATest(loc_db)
-
-G5_IRB0 = gen_irblock(LBL0, [[ExprAff(B, CST1)]])
-G5_IRB1 = gen_irblock(LBL1, [[ExprAff(B, B + CST2)],
-                             [ExprAff(G5_IRA.IRDst,
-                                      ExprCond(B, ExprLoc(LBL2, 32),
-                                               ExprLoc(LBL1, 32)))]])
-
-G5_IRB2 = gen_irblock(LBL2, [[ExprAff(A, B)]])
-
-G5_IRA.graph.add_uniq_edge(G5_IRB0.loc_key, G5_IRB1.loc_key)
-G5_IRA.graph.add_uniq_edge(G5_IRB1.loc_key, G5_IRB2.loc_key)
-G5_IRA.graph.add_uniq_edge(G5_IRB1.loc_key, G5_IRB1.loc_key)
-
-G5_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G5_IRB0, G5_IRB1, G5_IRB2]])
+G5_IRA = IRA.new_ircfg()
+
+G5_IRB0 = gen_irblock(LBL0, [[ExprAff(B, CST1), ExprAff(IRDst, ExprLoc(LBL1, 32))]])
+G5_IRB1 = gen_irblock(
+    LBL1,
+    [
+        [ExprAff(B, B + CST2)],
+        [ExprAff(
+            IRDst,
+            ExprCond(
+                B,
+                ExprLoc(LBL2, 32),
+                ExprLoc(LBL1, 32)
+            )
+        )
+        ]
+    ]
+)
+
+G5_IRB2 = gen_irblock(LBL2, [[ExprAff(A, B), ExprAff(IRDst, END)]])
+
+for irb in [G5_IRB0, G5_IRB1, G5_IRB2]:
+    G5_IRA.add_irblock(irb)
 
 # graph 6
 
-G6_IRA = IRATest(loc_db)
+G6_IRA = IRA.new_ircfg()
 
-G6_IRB0 = gen_irblock(LBL0, [[ExprAff(B, CST1)]])
-G6_IRB1 = gen_irblock(LBL1, [[ExprAff(A, B)]])
+G6_IRB0 = gen_irblock(LBL0, [[ExprAff(B, CST1), ExprAff(IRDst, ExprLoc(LBL1, 32))]])
+G6_IRB1 = gen_irblock(LBL1, [[ExprAff(A, B), ExprAff(IRDst, ExprLoc(LBL1, 32))]])
 
-G6_IRA.graph.add_uniq_edge(G6_IRB0.loc_key, G6_IRB1.loc_key)
-G6_IRA.graph.add_uniq_edge(G6_IRB1.loc_key, G6_IRB1.loc_key)
-
-G6_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G6_IRB0, G6_IRB1]])
+for irb in [G6_IRB0, G6_IRB1]:
+    G6_IRA.add_irblock(irb)
 
 # graph 7
 
-G7_IRA = IRATest(loc_db)
-
-G7_IRB0 = gen_irblock(LBL0, [[ExprAff(C, CST1)]])
-G7_IRB1 = gen_irblock(LBL1, [[ExprAff(B, C)], [ExprAff(A, B)]])
-G7_IRB2 = gen_irblock(LBL2, [[ExprAff(D, A)]])
-
-G7_IRA.graph.add_uniq_edge(G7_IRB0.loc_key, G7_IRB1.loc_key)
-G7_IRA.graph.add_uniq_edge(G7_IRB1.loc_key, G7_IRB1.loc_key)
-G7_IRA.graph.add_uniq_edge(G7_IRB1.loc_key, G7_IRB2.loc_key)
-
-G7_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G7_IRB0, G7_IRB1, G7_IRB2]])
+G7_IRA = IRA.new_ircfg()
+
+G7_IRB0 = gen_irblock(LBL0, [[ExprAff(C, CST1), ExprAff(IRDst, ExprLoc(LBL1, 32))]])
+G7_IRB1 = gen_irblock(
+    LBL1,
+    [
+        [ExprAff(B, C)],
+        [ExprAff(A, B)],
+        [ExprAff(
+            IRDst,
+            ExprCond(
+                COND,
+                ExprLoc(LBL1, 32),
+                ExprLoc(LBL2, 32)
+            )
+        )
+        ]
+    ]
+)
+
+G7_IRB2 = gen_irblock(LBL2, [[ExprAff(D, A), ExprAff(IRDst, END)]])
+
+for irb in [G7_IRB0, G7_IRB1, G7_IRB2]:
+    G7_IRA.add_irblock(irb)
 
 # graph 8
 
-G8_IRA = IRATest(loc_db)
-
-G8_IRB0 = gen_irblock(LBL0, [[ExprAff(C, CST1)]])
-G8_IRB1 = gen_irblock(LBL1, [[ExprAff(B, C)], [ExprAff(C, D)]])
-G8_IRB2 = gen_irblock(LBL2, [[ExprAff(A, B)]])
-
-G8_IRA.graph.add_uniq_edge(G8_IRB0.loc_key, G8_IRB1.loc_key)
-G8_IRA.graph.add_uniq_edge(G8_IRB1.loc_key, G8_IRB1.loc_key)
-G8_IRA.graph.add_uniq_edge(G8_IRB1.loc_key, G8_IRB2.loc_key)
-
-G8_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G8_IRB0, G8_IRB1, G8_IRB2]])
+G8_IRA = IRA.new_ircfg()
+
+G8_IRB0 = gen_irblock(LBL0, [[ExprAff(C, CST1), ExprAff(IRDst, ExprLoc(LBL1, 32))]])
+G8_IRB1 = gen_irblock(
+    LBL1,
+    [
+        [ExprAff(B, C)],
+        [ExprAff(C, D),
+         ExprAff(
+             IRDst,
+             ExprCond(
+                 COND,
+                 ExprLoc(LBL1, 32),
+                 ExprLoc(LBL2, 32)
+             )
+         )
+        ]
+    ]
+)
+G8_IRB2 = gen_irblock(LBL2, [[ExprAff(A, B), ExprAff(IRDst, END)]])
+
+for irb in [G8_IRB0, G8_IRB1, G8_IRB2]:
+    G8_IRA.add_irblock(irb)
 
 # graph 9 is graph 8
 
 # graph 10
 
-G10_IRA = IRATest(loc_db)
-
-G10_IRB1 = gen_irblock(LBL1, [[ExprAff(B, B + CST2)]])
-G10_IRB2 = gen_irblock(LBL2, [[ExprAff(A, B)]])
-
-G10_IRA.graph.add_uniq_edge(G10_IRB1.loc_key, G10_IRB2.loc_key)
-G10_IRA.graph.add_uniq_edge(G10_IRB1.loc_key, G10_IRB1.loc_key)
-
-G10_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G10_IRB1, G10_IRB2]])
+G10_IRA = IRA.new_ircfg()
+
+G10_IRB1 = gen_irblock(
+    LBL1,
+    [
+        [ExprAff(B, B + CST2),
+         ExprAff(
+             IRDst,
+             ExprCond(
+                 COND,
+                 ExprLoc(LBL1, 32),
+                 ExprLoc(LBL2, 32)
+             )
+         )
+        ]
+    ]
+)
+
+G10_IRB2 = gen_irblock(LBL2, [[ExprAff(A, B), ExprAff(IRDst, END)]])
+
+for irb in [G10_IRB1, G10_IRB2]:
+    G10_IRA.add_irblock(irb)
 
 # graph 11
 
-G11_IRA = IRATest(loc_db)
-
-G11_IRB0 = gen_irblock(LBL0, [[ExprAff(A, CST1),
-                               ExprAff(B, CST2)]])
-G11_IRB1 = gen_irblock(LBL1, [[ExprAff(A, B),
-                               ExprAff(B, A)]])
-G11_IRB2 = gen_irblock(LBL2, [[ExprAff(A, A - B)]])
-
-G11_IRA.graph.add_uniq_edge(G11_IRB0.loc_key, G11_IRB1.loc_key)
-G11_IRA.graph.add_uniq_edge(G11_IRB1.loc_key, G11_IRB2.loc_key)
-
-G11_IRA.blocks = dict([(irb.loc_key, irb)
-                       for irb in [G11_IRB0, G11_IRB1, G11_IRB2]])
+G11_IRA = IRA.new_ircfg()
+
+G11_IRB0 = gen_irblock(
+    LBL0,
+    [
+        [ExprAff(A, CST1),
+         ExprAff(B, CST2),
+         ExprAff(IRDst, ExprLoc(LBL1, 32))
+        ]
+    ]
+)
+
+G11_IRB1 = gen_irblock(
+    LBL1,
+    [
+        [ExprAff(A, B),
+         ExprAff(B, A),
+         ExprAff(IRDst, ExprLoc(LBL2, 32))
+        ]
+    ]
+)
+
+G11_IRB2 = gen_irblock(LBL2, [[ExprAff(A, A - B), ExprAff(IRDst, END)]])
+
+for irb in [G11_IRB0, G11_IRB1, G11_IRB2]:
+    G11_IRA.add_irblock(irb)
 
 # graph 12
 
-G12_IRA = IRATest(loc_db)
+G12_IRA = IRA.new_ircfg()
 
-G12_IRB0 = gen_irblock(LBL0, [[ExprAff(B, CST1)]])
-G12_IRB1 = gen_irblock(LBL1, [[ExprAff(A, B)], [ExprAff(B, B + CST2)]])
-G12_IRB2 = gen_irblock(LBL2, [[ExprAff(B, A)]])
+G12_IRB0 = gen_irblock(LBL0, [[ExprAff(B, CST1), ExprAff(IRDst, ExprLoc(LBL1, 32))]])
+G12_IRB1 = gen_irblock(
+    LBL1,
+    [
+        [ExprAff(A, B)],
+        [ExprAff(B, B + CST2),
+         ExprAff(
+             IRDst,
+             ExprCond(
+                 COND,
+                 ExprLoc(LBL1, 32),
+                 ExprLoc(LBL2, 32)
+             )
+         )
+        ]
+    ]
+)
 
-G12_IRA.graph.add_uniq_edge(G12_IRB0.loc_key, G12_IRB1.loc_key)
-G12_IRA.graph.add_uniq_edge(G12_IRB1.loc_key, G12_IRB2.loc_key)
-G12_IRA.graph.add_uniq_edge(G12_IRB1.loc_key, G12_IRB1.loc_key)
+G12_IRB2 = gen_irblock(LBL2, [[ExprAff(B, A), ExprAff(IRDst, END)]])
 
-G12_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G12_IRB0, G12_IRB1,
-                                                    G12_IRB2]])
+for irb in [G12_IRB0, G12_IRB1, G12_IRB2]:
+    G12_IRA.add_irblock(irb)
 
 
 # graph 13
 
-G13_IRA = IRATest(loc_db)
+G13_IRA = IRA.new_ircfg()
 
 G13_IRB0 = gen_irblock(LBL0, [[ExprAff(A, CST1)],
                               #[ExprAff(B, A)],
-                              [ExprAff(G13_IRA.IRDst,
+                              [ExprAff(IRDst,
                                        ExprLoc(LBL1, 32))]])
 G13_IRB1 = gen_irblock(LBL1, [[ExprAff(C, A)],
                               #[ExprAff(A, A + CST1)],
-                              [ExprAff(G13_IRA.IRDst,
-                                       ExprCond(R, ExprLoc(LBL2, 32),
-                                                ExprLoc(LBL1, 32)))]])
+                              [ExprAff(IRDst,
+                                       ExprCond(
+                                           R,
+                                           ExprLoc(LBL2, 32),
+                                           ExprLoc(LBL3, 32)
+                                       )
+                              )]])
 
 G13_IRB2 = gen_irblock(LBL2, [[ExprAff(B, A + CST3)], [ExprAff(A, B + CST3)],
-                              [ExprAff(G13_IRA.IRDst,
+                              [ExprAff(IRDst,
                                        ExprLoc(LBL1, 32))]])
 
-G13_IRB3 = gen_irblock(LBL3, [[ExprAff(R, C)]])
-
-G13_IRA.graph.add_uniq_edge(G13_IRB0.loc_key, G13_IRB1.loc_key)
-G13_IRA.graph.add_uniq_edge(G13_IRB1.loc_key, G13_IRB2.loc_key)
-G13_IRA.graph.add_uniq_edge(G13_IRB2.loc_key, G13_IRB1.loc_key)
-G13_IRA.graph.add_uniq_edge(G13_IRB1.loc_key, G13_IRB3.loc_key)
+G13_IRB3 = gen_irblock(LBL3, [[ExprAff(R, C), ExprAff(IRDst, END)]])
 
-G13_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G13_IRB0, G13_IRB1,
-                                                    G13_IRB2, G13_IRB3]])
+for irb in [G13_IRB0, G13_IRB1, G13_IRB2, G13_IRB3]:
+    G13_IRA.add_irblock(irb)
 
 # graph 14
 
-G14_IRA = IRATest(loc_db)
+G14_IRA = IRA.new_ircfg()
 
 G14_IRB0 = gen_irblock(LBL0, [[ExprAff(A, CST1)],
-                              [ExprAff(G14_IRA.IRDst,
+                              [ExprAff(IRDst,
                                        ExprLoc(LBL1, 32))]
                              ])
 G14_IRB1 = gen_irblock(LBL1, [[ExprAff(B, A)],
-                              [ExprAff(G14_IRA.IRDst,
-                                       ExprCond(C, ExprLoc(LBL2, 32),
-                                                ExprLoc(LBL3, 32)))]
+                              [ExprAff(IRDst,
+                                       ExprCond(
+                                           C,
+                                           ExprLoc(LBL2, 32),
+                                           ExprLoc(LBL3, 32)
+                                       )
+                              )
+                              ]
                              ])
 
 G14_IRB2 = gen_irblock(LBL2, [[ExprAff(D, A)],
                               [ExprAff(A, D + CST1)],
-                              [ExprAff(G14_IRA.IRDst,
+                              [ExprAff(IRDst,
                                        ExprLoc(LBL1, 32))]
                              ])
 
-G14_IRB3 = gen_irblock(LBL3, [[ExprAff(R, D + B)]])
+G14_IRB3 = gen_irblock(LBL3, [[ExprAff(R, D + B), ExprAff(IRDst, END)]])
 
-G14_IRA.graph.add_uniq_edge(G14_IRB0.loc_key, G14_IRB1.loc_key)
-G14_IRA.graph.add_uniq_edge(G14_IRB1.loc_key, G14_IRB2.loc_key)
-G14_IRA.graph.add_uniq_edge(G14_IRB2.loc_key, G14_IRB1.loc_key)
-G14_IRA.graph.add_uniq_edge(G14_IRB1.loc_key, G14_IRB3.loc_key)
-
-G14_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G14_IRB0, G14_IRB1,
-                                                    G14_IRB2, G14_IRB3]])
+for irb in [G14_IRB0, G14_IRB1, G14_IRB2, G14_IRB3]:
+    G14_IRA.add_irblock(irb)
 
 # graph 16
 
-G15_IRA = IRATest(loc_db)
+G15_IRA = IRA.new_ircfg()
 
-G15_IRB0 = gen_irblock(LBL0, [[ExprAff(A, CST1)]])
+G15_IRB0 = gen_irblock(LBL0, [[ExprAff(A, CST1), ExprAff(IRDst, ExprLoc(LBL1, 32))]])
 G15_IRB1 = gen_irblock(LBL1, [[ExprAff(D, A + B)],
                               [ExprAff(C, D)],
-                              [ExprAff(B, C)]])
-G15_IRB2 = gen_irblock(LBL2, [[ExprAff(R, B)]])
-
-G15_IRA.graph.add_uniq_edge(G15_IRB0.loc_key, G15_IRB1.loc_key)
-G15_IRA.graph.add_uniq_edge(G15_IRB1.loc_key, G15_IRB2.loc_key)
-G15_IRA.graph.add_uniq_edge(G15_IRB1.loc_key, G15_IRB1.loc_key)
-
-G15_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G15_IRB0, G15_IRB1,
-                                                    G15_IRB2]])
+                              [ExprAff(B, C),
+                               ExprAff(IRDst,
+                                       ExprCond(
+                                           C,
+                                           ExprLoc(LBL1, 32),
+                                           ExprLoc(LBL2, 32)
+                                       )
+                               )]])
+G15_IRB2 = gen_irblock(LBL2, [[ExprAff(R, B), ExprAff(IRDst, END)]])
+
+for irb in [G15_IRB0, G15_IRB1, G15_IRB2]:
+    G15_IRA.add_irblock(irb)
 
 # graph 16
 
-G16_IRA = IRATest(loc_db)
-
-G16_IRB0 = gen_irblock(LBL0, [[ExprAff(A, CST1)]])
-G16_IRB1 = gen_irblock(LBL1, [[ExprAff(R, D)]])
-G16_IRB2 = gen_irblock(LBL2, [[ExprAff(D, A)]])
-G16_IRB3 = gen_irblock(LBL3, [[ExprAff(R, D)]])
-G16_IRB4 = gen_irblock(LBL4, [[ExprAff(R, A)]])
-G16_IRB5 = gen_irblock(LBL5, [[ExprAff(R, A)]])
-
-G16_IRA.graph.add_uniq_edge(G16_IRB0.loc_key, G16_IRB1.loc_key)
-G16_IRA.graph.add_uniq_edge(G16_IRB1.loc_key, G16_IRB2.loc_key)
-G16_IRA.graph.add_uniq_edge(G16_IRB2.loc_key, G16_IRB1.loc_key)
-G16_IRA.graph.add_uniq_edge(G16_IRB1.loc_key, G16_IRB3.loc_key)
-G16_IRA.graph.add_uniq_edge(G16_IRB3.loc_key, G16_IRB1.loc_key)
-G16_IRA.graph.add_uniq_edge(G16_IRB1.loc_key, G16_IRB4.loc_key)
-G16_IRA.graph.add_uniq_edge(G16_IRB4.loc_key, G16_IRB1.loc_key)
-G16_IRA.graph.add_uniq_edge(G16_IRB1.loc_key, G16_IRB5.loc_key)
-
-G16_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G16_IRB0, G16_IRB1,
-                                                    G16_IRB2, G16_IRB3,
-                                                    G16_IRB4, G16_IRB5]])
+G16_IRA = IRA.new_ircfg()
+
+G16_IRB0 = gen_irblock(
+    LBL0, [
+        [ExprAff(A, CST1), ExprAff(IRDst, ExprLoc(LBL1, 32))]
+    ]
+)
+
+G16_IRB1 = gen_irblock(
+    LBL1,
+    [
+        [ExprAff(R, D),
+         ExprAff(
+             IRDst,
+             ExprCond(
+                 C,
+                 ExprCond(
+                     C,
+                     ExprCond(
+                         C,
+                         ExprLoc(LBL2, 32),
+                         ExprLoc(LBL3, 32)
+                     ),
+                     ExprLoc(LBL4, 32)
+                 ),
+                 ExprLoc(LBL5, 32)
+             )
+         )
+        ]
+    ]
+)
+
+
+
+G16_IRB2 = gen_irblock(LBL2, [[ExprAff(D, A), ExprAff(IRDst, ExprLoc(LBL1, 32))]])
+G16_IRB3 = gen_irblock(LBL3, [[ExprAff(R, D), ExprAff(IRDst, ExprLoc(LBL1, 32))]])
+G16_IRB4 = gen_irblock(LBL4, [[ExprAff(R, A), ExprAff(IRDst, ExprLoc(LBL1, 32))]])
+G16_IRB5 = gen_irblock(LBL5, [[ExprAff(R, A), ExprAff(IRDst, ExprLoc(LBL1, 32))]])
+
+for irb in [G16_IRB0, G16_IRB1, G16_IRB2, G16_IRB3, G16_IRB4, G16_IRB5]:
+    G16_IRA.add_irblock(irb)
 
 # graph 17
 
-G17_IRA = IRATest(loc_db)
+G17_IRA = IRA.new_ircfg()
 
 G17_IRB0 = gen_irblock(LBL0, [[ExprAff(A, CST1),
-                               ExprAff(D, CST2)]])
+                               ExprAff(D, CST2),
+                               ExprAff(IRDst, ExprLoc(LBL1, 32))]])
 G17_IRB1 = gen_irblock(LBL1, [[ExprAff(A, D),
-                               ExprAff(B, D)]])
-G17_IRB2 = gen_irblock(LBL2, [[ExprAff(A, A - B)]])
+                               ExprAff(B, D),
+                               ExprAff(IRDst, ExprLoc(LBL2, 32))]])
+G17_IRB2 = gen_irblock(LBL2, [[ExprAff(A, A - B),
+                               ExprAff(IRDst, END)]])
 
-G17_IRA.graph.add_uniq_edge(G17_IRB0.loc_key, G17_IRB1.loc_key)
-G17_IRA.graph.add_uniq_edge(G17_IRB1.loc_key, G17_IRB2.loc_key)
+G17_IRA.add_uniq_edge(G17_IRB0.loc_key, G17_IRB1.loc_key)
+G17_IRA.add_uniq_edge(G17_IRB1.loc_key, G17_IRB2.loc_key)
 
-G17_IRA.blocks = dict([(irb.loc_key, irb) for irb in [G17_IRB0, G17_IRB1,
-                                                    G17_IRB2]])
+for irb in [G17_IRB0, G17_IRB1, G17_IRB2]:
+    G17_IRA.add_irblock(irb)
 
 # Test graph 1
 G1_TEST1_DN1 = DependencyNode(
@@ -950,20 +1128,23 @@ for test_nb, test in enumerate([(G1_IRA, G1_INPUT),
 
     # Extract test elements
     print "[+] Test", test_nb + 1
-    g_ira, (depnodes, heads) = test
+    ircfg, (depnodes, heads) = test
 
-    open("graph_%02d.dot" % (test_nb + 1), "w").write(g_ira.graph.dot())
+    open("graph_%02d.dot" % (test_nb + 1), "w").write(ircfg.dot())
+    open("graph_%02d.dot" % (test_nb + 1), "w").write(bloc2graph(ircfg))
 
     # Different options
     suffix_key_list = ["", "_nosimp", "_nomem", "_nocall",
                        "_implicit"]
     # Test classes
-    for g_ind, g_dep in enumerate([DependencyGraph(g_ira),
-                                   DependencyGraph(g_ira, apply_simp=False),
-                                   DependencyGraph(g_ira, follow_mem=False),
-                                   DependencyGraph(g_ira, follow_mem=False,
-                                                   follow_call=False),
-                                   # DependencyGraph(g_ira, implicit=True),
+    for g_ind, g_dep in enumerate([DependencyGraph(ircfg),
+                                   DependencyGraph(ircfg, apply_simp=False),
+                                   DependencyGraph(ircfg, follow_mem=False),
+                                   DependencyGraph(
+                                       ircfg, follow_mem=False,
+                                       follow_call=False
+                                   ),
+                                   # DependencyGraph(ircfg, implicit=True),
                                    ]):
         # if g_ind == 4:
         # TODO: Implicit specifications
@@ -991,7 +1172,6 @@ for test_nb, test in enumerate([(G1_IRA, G1_INPUT),
         flat_depnodes = get_flat_init_depnodes(depnodes)
         if not match_results(all_results, test_results[test_nb], flat_depnodes):
             FAILED.add(test_nb)
-            # fds
         continue
 
 if FAILED: