IRBlock take loc_db

21 files changed, 107 insertions, 97 deletions

diff --git a/example/ida/depgraph.py b/example/ida/depgraph.py
index d607fe96..65b57e89 100644
--- a/example/ida/depgraph.py
+++ b/example/ida/depgraph.py
@@ -254,7 +254,7 @@ def launch_depgraph():
                 dst, src = expr_simp(dst), expr_simp(src)
                 new_assignblk[dst] = src
             irs.append(AssignBlock(new_assignblk, instr=assignblk.instr))
-        ircfg.blocks[irb.loc_key] = IRBlock(irb.loc_key, irs)
+        ircfg.blocks[irb.loc_key] = IRBlock(irb.loc_db, irb.loc_key, irs)
 
     # Get dependency graphs
     dg = settings.depgraph
diff --git a/example/ida/graph_ir.py b/example/ida/graph_ir.py
index dee4e281..29f91efa 100644
--- a/example/ida/graph_ir.py
+++ b/example/ida/graph_ir.py
@@ -239,7 +239,7 @@ def build_graph(start_addr, type_graph, simplify=False, dontmodstack=True, loadi
                 for dst, src in viewitems(assignblk)
             }
             irs.append(AssignBlock(new_assignblk, instr=assignblk.instr))
-        ircfg.blocks[irb.loc_key] = IRBlock(irb.loc_key, irs)
+        ircfg.blocks[irb.loc_key] = IRBlock(irb.loc_db, irb.loc_key, irs)
 
     if verbose:
         out = ircfg.dot()
@@ -286,7 +286,7 @@ def build_graph(start_addr, type_graph, simplify=False, dontmodstack=True, loadi
         assignblks = list(irblock)
         new_assiblk = AssignBlock(regs, assignblks[-1].instr)
         assignblks.append(new_assiblk)
-        new_irblock = IRBlock(irblock.loc_key, assignblks)
+        new_irblock = IRBlock(irblock.loc_db, irblock.loc_key, assignblks)
         ircfg.blocks[loc] = new_irblock
 
 
diff --git a/miasm/analysis/cst_propag.py b/miasm/analysis/cst_propag.py
index 4b040763..ba9b3aee 100644
--- a/miasm/analysis/cst_propag.py
+++ b/miasm/analysis/cst_propag.py
@@ -113,7 +113,7 @@ class SymbExecStateFix(SymbolicExecutionEngine):
 
             self.eval_updt_assignblk(assignblk)
             assignblks.append(AssignBlock(new_assignblk, assignblk.instr))
-        self.ircfg.blocks[irb.loc_key] = IRBlock(irb.loc_key, assignblks)
+        self.ircfg.blocks[irb.loc_key] = IRBlock(irb.loc_db, irb.loc_key, assignblks)
 
 
 def compute_cst_propagation_states(ir_arch, ircfg, init_addr, init_infos):
diff --git a/miasm/analysis/data_flow.py b/miasm/analysis/data_flow.py
index 7340c023..49384a8b 100644
--- a/miasm/analysis/data_flow.py
+++ b/miasm/analysis/data_flow.py
@@ -387,7 +387,7 @@ class DeadRemoval(object):
                         del new_assignblk[lval]
                         modified = True
                 irs.append(AssignBlock(new_assignblk, assignblk.instr))
-            ircfg.blocks[block.loc_key] = IRBlock(block.loc_key, irs)
+            ircfg.blocks[block.loc_key] = IRBlock(block.loc_db, block.loc_key, irs)
         return modified
 
     def __call__(self, ircfg):
@@ -438,7 +438,7 @@ def _do_merge_blocks(ircfg, loc_key, son_loc_key):
             assignblks.append(AssignBlock(affs, assignblk.instr))
 
     assignblks += ircfg.blocks[son_loc_key].assignblks
-    new_block = IRBlock(loc_key, assignblks)
+    new_block = IRBlock(ircfg.loc_db, loc_key, assignblks)
 
     ircfg.discard_edge(loc_key, son_loc_key)
 
@@ -564,7 +564,7 @@ def _remove_to_parent(ircfg, loc_key, son_loc_key):
     ircfg.del_edge(loc_key, son_loc_key)
 
     old_irblock = ircfg.blocks[son_loc_key]
-    new_irblock = IRBlock(loc_key, old_irblock.assignblks)
+    new_irblock = IRBlock(ircfg.loc_db, loc_key, old_irblock.assignblks)
 
     ircfg.blocks[son_loc_key] = new_irblock
 
@@ -657,7 +657,7 @@ def remove_empty_assignblks(ircfg):
             else:
                 block_modified = True
         if block_modified:
-            new_irblock = IRBlock(loc_key, irs)
+            new_irblock = IRBlock(ircfg.loc_db, loc_key, irs)
             ircfg.blocks[loc_key] = new_irblock
             modified = True
     return modified
@@ -909,7 +909,7 @@ def replace_stack_vars(ir_arch_a, ircfg):
 
             out = AssignBlock(out, assignblk.instr)
             assignblks.append(out)
-        new_block = IRBlock(block.loc_key, assignblks)
+        new_block = IRBlock(block.loc_db, block.loc_key, assignblks)
         ircfg.blocks[block.loc_key] = new_block
     return modified
 
@@ -987,7 +987,7 @@ def load_from_int(ir_arch, bs, is_addr_ro_variable):
                 out[dst] = src_new
             out = AssignBlock(out, assignblk.instr)
             assignblks.append(out)
-        block = IRBlock(block.loc_key, assignblks)
+        block = IRBlock(block.loc_db, block.loc_key, assignblks)
         ir_arch.blocks[block.loc_key] = block
     return modified
 
@@ -1233,7 +1233,7 @@ def discard_phi_sources(ircfg, deleted_vars):
         assignblk.update(todo)
         assignblk = AssignBlock(assignblk, assignblks[0].instr)
         assignblks[0] = assignblk
-        new_irblock = IRBlock(block.loc_key, assignblks)
+        new_irblock = IRBlock(block.loc_db, block.loc_key, assignblks)
         ircfg.blocks[block.loc_key] = new_irblock
     return True
 
@@ -1312,7 +1312,7 @@ def update_phi_with_deleted_edges(ircfg, edges_to_del):
                 out[dst] = ExprOp('Phi', *to_keep)
         assignblk = AssignBlock(out, assignblks[0].instr)
         assignblks[0] = assignblk
-        new_irblock = IRBlock(loc_dst, assignblks)
+        new_irblock = IRBlock(block.loc_db, loc_dst, assignblks)
         blocks[block.loc_key] = new_irblock
 
     for loc_key, block in viewitems(blocks):
@@ -1490,7 +1490,7 @@ class DelDummyPhi(object):
                 assignblks = list(block)
                 assignblks[0] = AssignBlock(fixed_phis, assignblk.instr)
                 assignblks[1:1] = [AssignBlock({dst: true_value}, assignblk.instr)]
-                new_irblock = IRBlock(block.loc_key, assignblks)
+                new_irblock = IRBlock(block.loc_db, block.loc_key, assignblks)
                 ssa.graph.blocks[block.loc_key] = new_irblock
 
         return modified
@@ -2152,7 +2152,7 @@ class PropagateExpressions(object):
             if new_assignblk != assignblock:
                 modified = True
 
-        new_irblock = IRBlock(irblock.loc_key, new_assignblocks)
+        new_irblock = IRBlock(irblock.loc_db, irblock.loc_key, new_assignblocks)
 
         return new_irblock, modified
 
diff --git a/miasm/analysis/depgraph.py b/miasm/analysis/depgraph.py
index 0b370f61..ae853756 100644
--- a/miasm/analysis/depgraph.py
+++ b/miasm/analysis/depgraph.py
@@ -280,7 +280,7 @@ class DependencyResult(DependencyState):
                     assignmnts[element] = irb[line_nb][element]
             assignblks.append(AssignBlock(assignmnts))
 
-        return IRBlock(irb.loc_key, assignblks)
+        return IRBlock(irb.loc_db, irb.loc_key, assignblks)
 
     def emul(self, ir_arch, ctx=None, step=False):
         """Symbolic execution of relevant nodes according to the history
@@ -311,7 +311,7 @@ class DependencyResult(DependencyState):
         loc_db = ir_arch.loc_db
         temp_loc = loc_db.get_or_create_name_location("Temp")
         symb_exec = SymbolicExecutionEngine(ir_arch, ctx_init)
-        symb_exec.eval_updt_irblock(IRBlock(temp_loc, assignblks), step=step)
+        symb_exec.eval_updt_irblock(IRBlock(loc_db, temp_loc, assignblks), step=step)
 
         # Return only inputs values (others could be wrongs)
         return {element: symb_exec.symbols[element]
diff --git a/miasm/analysis/outofssa.py b/miasm/analysis/outofssa.py
index c52b3250..2f2b185c 100644
--- a/miasm/analysis/outofssa.py
+++ b/miasm/analysis/outofssa.py
@@ -73,7 +73,7 @@ class UnSSADiGraph(object):
 
             assignblks = list(irblock)
             assignblks[0] = AssignBlock(parallel_copies, irblock[0].instr)
-            new_irblock = IRBlock(irblock.loc_key, assignblks)
+            new_irblock = IRBlock(irblock.loc_db, irblock.loc_key, assignblks)
             ircfg.blocks[irblock.loc_key] = new_irblock
 
             # Insert new_var = src in each Phi's parent, at the end of the block
@@ -88,7 +88,7 @@ class UnSSADiGraph(object):
                 parent = ircfg.blocks[parent]
                 assignblks = list(parent)
                 assignblks.append(AssignBlock(parallel_copies, parent[-1].instr))
-                new_irblock = IRBlock(parent.loc_key, assignblks)
+                new_irblock = IRBlock(parent.loc_db, parent.loc_key, assignblks)
                 ircfg.blocks[parent.loc_key] = new_irblock
 
     def create_copy_var(self, var):
@@ -397,7 +397,7 @@ class UnSSADiGraph(object):
                     continue
                 out[dst] = src
             assignblks[0] = AssignBlock(out, assignblks[0].instr)
-            self.ssa.graph.blocks[irblock.loc_key] = IRBlock(irblock.loc_key, assignblks)
+            self.ssa.graph.blocks[irblock.loc_key] = IRBlock(irblock.loc_db, irblock.loc_key, assignblks)
 
     def remove_assign_eq(self):
         """
@@ -412,4 +412,4 @@ class UnSSADiGraph(object):
                         continue
                     out[dst] = src
                 assignblks[i] = AssignBlock(out, assignblk.instr)
-            self.ssa.graph.blocks[irblock.loc_key] = IRBlock(irblock.loc_key, assignblks)
+            self.ssa.graph.blocks[irblock.loc_key] = IRBlock(irblock.loc_db, irblock.loc_key, assignblks)
diff --git a/miasm/analysis/ssa.py b/miasm/analysis/ssa.py
index 7f0b0f13..b9af1033 100644
--- a/miasm/analysis/ssa.py
+++ b/miasm/analysis/ssa.py
@@ -28,7 +28,7 @@ def sanitize_graph_head(ircfg, head):
         lambda expr:expr.replace_expr(replaced_expr)
     )
     # Duplicate head block
-    ircfg.add_irblock(IRBlock(sub_head, list(ircfg.blocks[head])))
+    ircfg.add_irblock(IRBlock(ircfg.loc_db, sub_head, list(ircfg.blocks[head])))
 
     # Remove original head block
     ircfg.del_node(head)
@@ -38,7 +38,7 @@ def sanitize_graph_head(ircfg, head):
 
     # Create new head, jumping to sub_head
     assignblk = AssignBlock({ircfg.IRDst:ExprLoc(sub_head, ircfg.IRDst.size)})
-    new_irblock = IRBlock(head, [assignblk])
+    new_irblock = IRBlock(ircfg.loc_db, head, [assignblk])
     ircfg.add_irblock(new_irblock)
 
 
@@ -246,7 +246,7 @@ class SSA(object):
                 instructions.append(next(ssa_iter))
             # replace instructions of assignblock in IRBlock
             new_irs.append(AssignBlock(instructions, assignblk.instr))
-        return IRBlock(irblock.loc_key, new_irs)
+        return IRBlock(irblock.loc_db, irblock.loc_key, new_irs)
 
     def _rename_expressions(self, loc_key):
         """
@@ -614,10 +614,10 @@ class SSADiGraph(SSA):
                 out = dict(assignblks[0])
                 out.update(dict(assignblk))
                 assignblks[0] = AssignBlock(out, assignblk.instr)
-                new_irblock = IRBlock(loc_key, assignblks)
+                new_irblock = IRBlock(self.ircfg.loc_db, loc_key, assignblks)
             else:
                 # insert at the beginning
-                new_irblock = IRBlock(loc_key, [assignblk] + list(irblock.assignblks))
+                new_irblock = IRBlock(self.ircfg.loc_db, loc_key, [assignblk] + list(irblock.assignblks))
             self.ircfg.blocks[loc_key] = new_irblock
 
     def _fix_no_def_var(self, head):
@@ -646,7 +646,7 @@ class SSADiGraph(SSA):
             irblock = self.ircfg.blocks[head]
             assignblks = list(irblock)
             assignblks[0:0] = [AssignBlock(newname_to_var, assignblks[0].instr)]
-            self.ircfg.blocks[head] = IRBlock(head, assignblks)
+            self.ircfg.blocks[head] = IRBlock(self.ircfg.loc_db, head, assignblks)
 
         # Updt structure
         for loc_key in self._phinodes:
diff --git a/miasm/arch/aarch64/sem.py b/miasm/arch/aarch64/sem.py
index 915cd02e..e77df911 100644
--- a/miasm/arch/aarch64/sem.py
+++ b/miasm/arch/aarch64/sem.py
@@ -2065,13 +2065,13 @@ def casp(ir, instr, arg1, arg2, arg3):
     e_store = []
     e_store.append(ExprAssign(data, new_value))
     e_store.append(ExprAssign(ir.IRDst, loc_do))
-    blk_store = IRBlock(loc_store.loc_key, [AssignBlock(e_store, instr)])
+    blk_store = IRBlock(ir.loc_db, loc_store.loc_key, [AssignBlock(e_store, instr)])
 
     e_do = []
     e_do.append(ExprAssign(regs[index1], data[:data.size // 2]))
     e_do.append(ExprAssign(regs[index1 + 1], data[data.size // 2:]))
     e_do.append(ExprAssign(ir.IRDst, loc_next))
-    blk_do = IRBlock(loc_do.loc_key, [AssignBlock(e_do, instr)])
+    blk_do = IRBlock(ir.loc_db, loc_do.loc_key, [AssignBlock(e_do, instr)])
 
     return e, [blk_store, blk_do]
 
@@ -2274,7 +2274,7 @@ class ir_aarch64l(IntermediateRepresentation):
                 src = self.expr_fix_regs_for_mode(src)
                 new_assignblk[dst] = src
             irs.append(AssignBlock(new_assignblk, assignblk.instr))
-        return IRBlock(irblock.loc_key, irs)
+        return IRBlock(self.loc_db, irblock.loc_key, irs)
 
     def mod_pc(self, instr, instr_ir, extra_ir):
         "Replace PC by the instruction's offset"
@@ -2307,7 +2307,7 @@ class ir_aarch64l(IntermediateRepresentation):
                     if dst not in regs_to_fix
                 }
                 irs.append(AssignBlock(new_dsts, assignblk.instr))
-            new_irblocks.append(IRBlock(irblock.loc_key, irs))
+            new_irblocks.append(IRBlock(self.loc_db, irblock.loc_key, irs))
 
         return instr_ir, new_irblocks
 
diff --git a/miasm/arch/arm/sem.py b/miasm/arch/arm/sem.py
index 027c3a6a..1884abe8 100644
--- a/miasm/arch/arm/sem.py
+++ b/miasm/arch/arm/sem.py
@@ -804,7 +804,7 @@ def sdiv(ir, instr, a, b, c=None):
     do_except = []
     do_except.append(ExprAssign(exception_flags, ExprInt(EXCEPT_DIV_BY_ZERO, exception_flags.size)))
     do_except.append(ExprAssign(ir.IRDst, loc_next))
-    blk_except = IRBlock(loc_except.loc_key, [AssignBlock(do_except, instr)])
+    blk_except = IRBlock(ir.loc_db, loc_except.loc_key, [AssignBlock(do_except, instr)])
 
 
 
@@ -816,7 +816,7 @@ def sdiv(ir, instr, a, b, c=None):
         do_div.append(ExprAssign(ir.IRDst, r))
 
     do_div.append(ExprAssign(ir.IRDst, loc_next))
-    blk_div = IRBlock(loc_div.loc_key, [AssignBlock(do_div, instr)])
+    blk_div = IRBlock(ir.loc_db, loc_div.loc_key, [AssignBlock(do_div, instr)])
 
     return e, [blk_div, blk_except]
 
@@ -837,7 +837,7 @@ def udiv(ir, instr, a, b, c=None):
     do_except = []
     do_except.append(ExprAssign(exception_flags, ExprInt(EXCEPT_DIV_BY_ZERO, exception_flags.size)))
     do_except.append(ExprAssign(ir.IRDst, loc_next))
-    blk_except = IRBlock(loc_except.loc_key, [AssignBlock(do_except, instr)])
+    blk_except = IRBlock(ir.loc_db, loc_except.loc_key, [AssignBlock(do_except, instr)])
 
 
     r = ExprOp("udiv", b, c)
@@ -848,7 +848,7 @@ def udiv(ir, instr, a, b, c=None):
         do_div.append(ExprAssign(ir.IRDst, r))
 
     do_div.append(ExprAssign(ir.IRDst, loc_next))
-    blk_div = IRBlock(loc_div.loc_key, [AssignBlock(do_div, instr)])
+    blk_div = IRBlock(ir.loc_db, loc_div.loc_key, [AssignBlock(do_div, instr)])
 
     return e, [blk_div, blk_except]
 
@@ -1723,7 +1723,7 @@ def add_condition_expr(ir, instr, cond, instr_ir, extra_ir):
             break
     if not has_irdst:
         instr_ir.append(ExprAssign(ir.IRDst, loc_next_expr))
-    e_do = IRBlock(loc_do, [AssignBlock(instr_ir, instr)])
+    e_do = IRBlock(ir.loc_db, loc_do, [AssignBlock(instr_ir, instr)])
     e = [ExprAssign(ir.IRDst, dst_cond)]
     return e, [e_do] + extra_ir
 
@@ -2004,7 +2004,7 @@ class ir_arml(IntermediateRepresentation):
         dst = ExprAssign(self.IRDst, ExprLoc(loc_next, 32))
         dst_blk = AssignBlock([dst], instr)
         assignments.append(dst_blk)
-        irblock = IRBlock(loc, assignments)
+        irblock = IRBlock(self.loc_db, loc, assignments)
         ir_blocks_all.append([irblock])
 
         loc = loc_next
@@ -2025,7 +2025,7 @@ class ir_arml(IntermediateRepresentation):
             dst = ExprAssign(self.IRDst, ExprCond(local_cond, ExprLoc(loc_do, 32), ExprLoc(loc_next, 32)))
             dst_blk = AssignBlock([dst], instr)
             assignments.append(dst_blk)
-            irblock = IRBlock(loc, assignments)
+            irblock = IRBlock(self.loc_db, loc, assignments)
 
             irblocks.append(irblock)
 
@@ -2070,7 +2070,7 @@ class ir_arml(IntermediateRepresentation):
                             assignment.instr
                         )
                         out.append(assignment)
-                    new_irblock = IRBlock(irblock.loc_key, out)
+                    new_irblock = IRBlock(self.loc_db, irblock.loc_key, out)
                     new_irblocks.append(new_irblock)
                 it_instr_irblocks = new_irblocks
 
@@ -2078,7 +2078,7 @@ class ir_arml(IntermediateRepresentation):
             dst = ExprAssign(self.IRDst, ExprLoc(loc_next, 32))
             dst_blk = AssignBlock([dst], instr)
             assignments.append(dst_blk)
-            irblock = IRBlock(loc, assignments)
+            irblock = IRBlock(self.loc_db, loc, assignments)
             irblocks.append(irblock)
             loc = loc_next
             assignments = []
@@ -2116,11 +2116,11 @@ class ir_arml(IntermediateRepresentation):
                 ir_blocks_all, gen_pc_updt
             )
             if split:
-                ir_blocks_all.append(IRBlock(label, assignments))
+                ir_blocks_all.append(IRBlock(self.loc_db, label, assignments))
                 label = None
                 assignments = []
         if label is not None:
-            ir_blocks_all.append(IRBlock(label, assignments))
+            ir_blocks_all.append(IRBlock(self.loc_db, label, assignments))
 
         new_ir_blocks_all = self.post_add_asmblock_to_ircfg(block, ircfg, ir_blocks_all)
         for irblock in new_ir_blocks_all:
diff --git a/miasm/arch/mips32/ira.py b/miasm/arch/mips32/ira.py
index 04a51c6c..e7b5d7f2 100644
--- a/miasm/arch/mips32/ira.py
+++ b/miasm/arch/mips32/ira.py
@@ -67,11 +67,11 @@ class ir_a_mips32l(ir_mips32l, ira):
                 ir_blocks_all, gen_pc_updt
             )
             if split:
-                ir_blocks_all.append(IRBlock(loc_key, assignments))
+                ir_blocks_all.append(IRBlock(self.loc_db, loc_key, assignments))
                 loc_key = None
                 assignments = []
         if loc_key is not None:
-            ir_blocks_all.append(IRBlock(loc_key, assignments))
+            ir_blocks_all.append(IRBlock(self.loc_db, loc_key, assignments))
 
         new_ir_blocks_all = self.post_add_asmblock_to_ircfg(block, ircfg, ir_blocks_all)
         for irblock in new_ir_blocks_all:
diff --git a/miasm/arch/mips32/jit.py b/miasm/arch/mips32/jit.py
index 1c2c182e..d8bd8c66 100644
--- a/miasm/arch/mips32/jit.py
+++ b/miasm/arch/mips32/jit.py
@@ -61,7 +61,7 @@ class mipsCGen(CGen):
                     dst_loc_key = self.ir_arch.get_next_instr(assignblock.instr)
                     assignments[self.ir_arch.IRDst] = m2_expr.ExprLoc(dst_loc_key, 32)
                     irs.append(AssignBlock(assignments, assignblock.instr))
-                irblocks[blk_idx] = IRBlock(irblock.loc_key, irs)
+                irblocks[blk_idx] = IRBlock(irblock.loc_db, irblock.loc_key, irs)
 
         return irblocks_list
 
diff --git a/miasm/arch/mips32/sem.py b/miasm/arch/mips32/sem.py
index 23684a8d..b4252486 100644
--- a/miasm/arch/mips32/sem.py
+++ b/miasm/arch/mips32/sem.py
@@ -538,7 +538,7 @@ def teq(ir, instr, arg1, arg2):
     do_except.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt(
         EXCEPT_DIV_BY_ZERO, exception_flags.size)))
     do_except.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr))
-    blk_except = IRBlock(loc_except, [AssignBlock(do_except, instr)])
+    blk_except = IRBlock(ir.loc_db, loc_except, [AssignBlock(do_except, instr)])
 
     cond = arg1 - arg2
 
@@ -560,7 +560,7 @@ def tne(ir, instr, arg1, arg2):
     do_except.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt(
         EXCEPT_DIV_BY_ZERO, exception_flags.size)))
     do_except.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr))
-    blk_except = IRBlock(loc_except, [AssignBlock(do_except, instr)])
+    blk_except = IRBlock(ir.loc_db, loc_except, [AssignBlock(do_except, instr)])
 
     cond = arg1 ^ arg2
 
diff --git a/miasm/arch/ppc/sem.py b/miasm/arch/ppc/sem.py
index 7ca7e3e1..26b3d84b 100644
--- a/miasm/arch/ppc/sem.py
+++ b/miasm/arch/ppc/sem.py
@@ -675,8 +675,8 @@ def mn_do_store(ir, instr, arg1, arg2, arg3=None):
         ret.append(ExprAssign(ir.IRDst, loc_next))
         dont = flags + [ ExprAssign(CR0_EQ, ExprInt(0,1)),
                          ExprAssign(ir.IRDst, loc_next) ]
-        additional_ir = [ IRBlock(loc_do.loc_key, [ AssignBlock(ret) ]),
-                          IRBlock(loc_dont.loc_key, [ AssignBlock(dont) ]) ]
+        additional_ir = [ IRBlock(ir.loc_db, loc_do.loc_key, [ AssignBlock(ret) ]),
+                          IRBlock(ir.loc_db, loc_dont.loc_key, [ AssignBlock(dont) ]) ]
         ret = [ ExprAssign(reserve, ExprInt(0, 1)),
                 ExprAssign(ir.IRDst, ExprCond(reserve, loc_do, loc_dont)) ]
 
diff --git a/miasm/arch/x86/sem.py b/miasm/arch/x86/sem.py
index cf58079c..723272d5 100644
--- a/miasm/arch/x86/sem.py
+++ b/miasm/arch/x86/sem.py
@@ -386,7 +386,7 @@ def gen_fcmov(ir, instr, cond, arg1, arg2, mov_if):
     e_do, extra_irs = [m2_expr.ExprAssign(arg1, arg2)], []
     e_do.append(m2_expr.ExprAssign(ir.IRDst, loc_skip_expr))
     e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(cond, dstA, dstB)))
-    return e, [IRBlock(loc_do, [AssignBlock(e_do, instr)])]
+    return e, [IRBlock(ir.loc_db, loc_do, [AssignBlock(e_do, instr)])]
 
 
 def gen_cmov(ir, instr, cond, dst, src, mov_if):
@@ -408,7 +408,7 @@ def gen_cmov(ir, instr, cond, dst, src, mov_if):
     e_do.append(m2_expr.ExprAssign(ir.IRDst, loc_skip_expr))
     e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(cond, dstA, dstB)))
     e += set_float_cs_eip(instr)
-    return e, [IRBlock(loc_do, [AssignBlock(e_do, instr)])]
+    return e, [IRBlock(ir.loc_db, loc_do, [AssignBlock(e_do, instr)])]
 
 
 def mov(_, instr, dst, src):
@@ -655,7 +655,7 @@ def _rotate_tpl(ir, instr, dst, src, op, left=False):
     e_do.append(m2_expr.ExprAssign(ir.IRDst, loc_skip_expr))
     e.append(m2_expr.ExprAssign(
         ir.IRDst, m2_expr.ExprCond(shifter, loc_do_expr, loc_skip_expr)))
-    return (e, [IRBlock(loc_do, [AssignBlock(e_do, instr)])])
+    return (e, [IRBlock(ir.loc_db, loc_do, [AssignBlock(e_do, instr)])])
 
 
 def l_rol(ir, instr, dst, src):
@@ -703,7 +703,7 @@ def rotate_with_carry_tpl(ir, instr, op, dst, src):
     e_do.append(m2_expr.ExprAssign(ir.IRDst, loc_skip_expr))
     e.append(m2_expr.ExprAssign(
         ir.IRDst, m2_expr.ExprCond(shifter, loc_do_expr, loc_skip_expr)))
-    return (e, [IRBlock(loc_do, [AssignBlock(e_do, instr)])])
+    return (e, [IRBlock(ir.loc_db, loc_do, [AssignBlock(e_do, instr)])])
 
 def rcl(ir, instr, dst, src):
     return rotate_with_carry_tpl(ir, instr, '<<<', dst, src)
@@ -789,7 +789,7 @@ def _shift_tpl(op, ir, instr, a, b, c=None, op_inv=None, left=False,
     e_do.append(m2_expr.ExprAssign(ir.IRDst, loc_skip_expr))
     e.append(m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(shifter, loc_do_expr,
                                                         loc_skip_expr)))
-    return e, [IRBlock(loc_do, [AssignBlock(e_do, instr)])]
+    return e, [IRBlock(ir.loc_db, loc_do, [AssignBlock(e_do, instr)])]
 
 
 def sar(ir, instr, dst, src):
@@ -1206,13 +1206,13 @@ def cmps(ir, instr, size):
     e0.append(m2_expr.ExprAssign(src1, src1 + offset))
     e0.append(m2_expr.ExprAssign(src2, src2 + offset))
     e0.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr))
-    e0 = IRBlock(loc_df_0, [AssignBlock(e0, instr)])
+    e0 = IRBlock(ir.loc_db, loc_df_0, [AssignBlock(e0, instr)])
 
     e1 = []
     e1.append(m2_expr.ExprAssign(src1, src1 - offset))
     e1.append(m2_expr.ExprAssign(src2, src2 - offset))
     e1.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr))
-    e1 = IRBlock(loc_df_1, [AssignBlock(e1, instr)])
+    e1 = IRBlock(ir.loc_db, loc_df_1, [AssignBlock(e1, instr)])
 
     e.append(m2_expr.ExprAssign(ir.IRDst,
                              m2_expr.ExprCond(df, loc_df_1_expr, loc_df_0_expr)))
@@ -1243,12 +1243,12 @@ def scas(ir, instr, size):
     e0.append(m2_expr.ExprAssign(src, src + offset))
 
     e0.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr))
-    e0 = IRBlock(loc_df_0, [AssignBlock(e0, instr)])
+    e0 = IRBlock(ir.loc_db, loc_df_0, [AssignBlock(e0, instr)])
 
     e1 = []
     e1.append(m2_expr.ExprAssign(src, src - offset))
     e1.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr))
-    e1 = IRBlock(loc_df_1, [AssignBlock(e1, instr)])
+    e1 = IRBlock(ir.loc_db, loc_df_1, [AssignBlock(e1, instr)])
 
     e.append(m2_expr.ExprAssign(ir.IRDst,
                              m2_expr.ExprCond(df, loc_df_1_expr, loc_df_0_expr)))
@@ -1733,13 +1733,13 @@ def div(ir, instr, src1):
     do_div = []
     do_div += e
     do_div.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr))
-    blk_div = IRBlock(loc_div, [AssignBlock(do_div, instr)])
+    blk_div = IRBlock(ir.loc_db, loc_div, [AssignBlock(do_div, instr)])
 
     do_except = []
     do_except.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt(
         EXCEPT_DIV_BY_ZERO, exception_flags.size)))
     do_except.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr))
-    blk_except = IRBlock(loc_except, [AssignBlock(do_except, instr)])
+    blk_except = IRBlock(ir.loc_db, loc_except, [AssignBlock(do_except, instr)])
 
     e = []
     e.append(m2_expr.ExprAssign(ir.IRDst,
@@ -1780,13 +1780,13 @@ def idiv(ir, instr, src1):
     do_div = []
     do_div += e
     do_div.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr))
-    blk_div = IRBlock(loc_div, [AssignBlock(do_div, instr)])
+    blk_div = IRBlock(ir.loc_db, loc_div, [AssignBlock(do_div, instr)])
 
     do_except = []
     do_except.append(m2_expr.ExprAssign(exception_flags, m2_expr.ExprInt(
         EXCEPT_DIV_BY_ZERO, exception_flags.size)))
     do_except.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr))
-    blk_except = IRBlock(loc_except, [AssignBlock(do_except, instr)])
+    blk_except = IRBlock(ir.loc_db, loc_except, [AssignBlock(do_except, instr)])
 
     e = []
     e.append(m2_expr.ExprAssign(ir.IRDst,
@@ -1952,12 +1952,12 @@ def stos(ir, instr, size):
     e0 = []
     e0.append(m2_expr.ExprAssign(addr_o, addr_p))
     e0.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr))
-    e0 = IRBlock(loc_df_0, [AssignBlock(e0, instr)])
+    e0 = IRBlock(ir.loc_db, loc_df_0, [AssignBlock(e0, instr)])
 
     e1 = []
     e1.append(m2_expr.ExprAssign(addr_o, addr_m))
     e1.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr))
-    e1 = IRBlock(loc_df_1, [AssignBlock(e1, instr)])
+    e1 = IRBlock(ir.loc_db, loc_df_1, [AssignBlock(e1, instr)])
 
     e = []
     e.append(m2_expr.ExprAssign(ir.ExprMem(addr, size), b))
@@ -1988,12 +1988,12 @@ def lods(ir, instr, size):
     e0 = []
     e0.append(m2_expr.ExprAssign(addr_o, addr_p))
     e0.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr))
-    e0 = IRBlock(loc_df_0, [AssignBlock(e0, instr)])
+    e0 = IRBlock(ir.loc_db, loc_df_0, [AssignBlock(e0, instr)])
 
     e1 = []
     e1.append(m2_expr.ExprAssign(addr_o, addr_m))
     e1.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr))
-    e1 = IRBlock(loc_df_1, [AssignBlock(e1, instr)])
+    e1 = IRBlock(ir.loc_db, loc_df_1, [AssignBlock(e1, instr)])
 
     e = []
     if instr.mode == 64 and b.size == 32:
@@ -2035,13 +2035,13 @@ def movs(ir, instr, size):
     e0.append(m2_expr.ExprAssign(src, src + offset))
     e0.append(m2_expr.ExprAssign(dst, dst + offset))
     e0.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr))
-    e0 = IRBlock(loc_df_0, [AssignBlock(e0, instr)])
+    e0 = IRBlock(ir.loc_db, loc_df_0, [AssignBlock(e0, instr)])
 
     e1 = []
     e1.append(m2_expr.ExprAssign(src, src - offset))
     e1.append(m2_expr.ExprAssign(dst, dst - offset))
     e1.append(m2_expr.ExprAssign(ir.IRDst, loc_next_expr))
-    e1 = IRBlock(loc_df_1, [AssignBlock(e1, instr)])
+    e1 = IRBlock(ir.loc_db, loc_df_1, [AssignBlock(e1, instr)])
 
     e.append(m2_expr.ExprAssign(ir.IRDst,
                              m2_expr.ExprCond(df, loc_df_1_expr, loc_df_0_expr)))
@@ -2198,31 +2198,31 @@ def fxam(ir, instr):
     base += set_float_cs_eip(instr)
 
     out = [
-        IRBlock(locs["Zero"][0], [AssignBlock({
+        IRBlock(ir.loc_db, locs["Zero"][0], [AssignBlock({
             float_c0: m2_expr.ExprInt(0, float_c0.size),
             float_c2: m2_expr.ExprInt(0, float_c2.size),
             float_c3: m2_expr.ExprInt(1, float_c3.size),
             ir.IRDst: loc_next_expr,
         }, instr)]),
-        IRBlock(locs["Denormal"][0], [AssignBlock({
+        IRBlock(ir.loc_db, locs["Denormal"][0], [AssignBlock({
             float_c0: m2_expr.ExprInt(0, float_c0.size),
             float_c2: m2_expr.ExprInt(1, float_c2.size),
             float_c3: m2_expr.ExprInt(1, float_c3.size),
             ir.IRDst: loc_next_expr,
         }, instr)]),
-        IRBlock(locs["NaN"][0], [AssignBlock({
+        IRBlock(ir.loc_db, locs["NaN"][0], [AssignBlock({
             float_c0: m2_expr.ExprInt(1, float_c0.size),
             float_c2: m2_expr.ExprInt(0, float_c2.size),
             float_c3: m2_expr.ExprInt(0, float_c3.size),
             ir.IRDst: loc_next_expr,
         }, instr)]),
-        IRBlock(locs["Infinity"][0], [AssignBlock({
+        IRBlock(ir.loc_db, locs["Infinity"][0], [AssignBlock({
             float_c0: m2_expr.ExprInt(1, float_c0.size),
             float_c2: m2_expr.ExprInt(1, float_c2.size),
             float_c3: m2_expr.ExprInt(0, float_c3.size),
             ir.IRDst: loc_next_expr,
         }, instr)]),
-        IRBlock(locs["Normal"][0], [AssignBlock({
+        IRBlock(ir.loc_db, locs["Normal"][0], [AssignBlock({
             float_c0: m2_expr.ExprInt(0, float_c0.size),
             float_c2: m2_expr.ExprInt(1, float_c2.size),
             float_c3: m2_expr.ExprInt(0, float_c3.size),
@@ -3255,8 +3255,8 @@ def bsr_bsf(ir, instr, dst, src, op_func):
     e_src_not_null.append(m2_expr.ExprAssign(dst, op_func(src)))
     e_src_not_null.append(aff_dst)
 
-    return e, [IRBlock(loc_src_null, [AssignBlock(e_src_null, instr)]),
-               IRBlock(loc_src_not_null, [AssignBlock(e_src_not_null, instr)])]
+    return e, [IRBlock(ir.loc_db, loc_src_null, [AssignBlock(e_src_null, instr)]),
+               IRBlock(ir.loc_db, loc_src_not_null, [AssignBlock(e_src_not_null, instr)])]
 
 
 def bsf(ir, instr, dst, src):
@@ -4963,7 +4963,7 @@ def maskmovq(ir, instr, src, mask):
                                 m2_expr.ExprCond(bit,
                                                  write_label,
                                                  next_check_label))
-        blks.append(IRBlock(cur_label.loc_key, [AssignBlock([check], instr)]))
+        blks.append(IRBlock(ir.loc_db, cur_label.loc_key, [AssignBlock([check], instr)]))
 
     # Build write blocks
     dst_addr = mRDI[instr.mode]
@@ -4976,7 +4976,7 @@ def maskmovq(ir, instr, src, mask):
         write_mem = m2_expr.ExprAssign(m2_expr.ExprMem(write_addr, 8),
                                     src[start: start + 8])
         jump = m2_expr.ExprAssign(ir.IRDst, next_check_label)
-        blks.append(IRBlock(cur_label.loc_key, [AssignBlock([write_mem, jump], instr)]))
+        blks.append(IRBlock(ir.loc_db, cur_label.loc_key, [AssignBlock([write_mem, jump], instr)]))
 
     # If mask is null, bypass all
     e = [m2_expr.ExprAssign(ir.IRDst, m2_expr.ExprCond(mask,
@@ -5837,10 +5837,10 @@ class ir_x86_16(IntermediateRepresentation):
         cond_bloc.append(m2_expr.ExprAssign(self.IRDst, m2_expr.ExprCond(c_cond,
                                                                       loc_skip_expr,
                                                                       loc_do_expr)))
-        cond_bloc = IRBlock(loc_end, [AssignBlock(cond_bloc, instr)])
+        cond_bloc = IRBlock(self.loc_db, loc_end, [AssignBlock(cond_bloc, instr)])
         e_do = instr_ir
 
-        c = IRBlock(loc_do, [AssignBlock(e_do, instr)])
+        c = IRBlock(self.loc_db, loc_do, [AssignBlock(e_do, instr)])
         e_n = [m2_expr.ExprAssign(self.IRDst, m2_expr.ExprCond(c_reg, loc_do_expr,
                                                             loc_skip_expr))]
         return e_n, [cond_bloc, c] + new_extra_ir
@@ -5871,7 +5871,7 @@ class ir_x86_16(IntermediateRepresentation):
                 src = self.expr_fix_regs_for_mode(src, mode)
                 new_assignblk[dst] = src
             irs.append(AssignBlock(new_assignblk, assignblk.instr))
-        return IRBlock(irblock.loc_key, irs)
+        return IRBlock(self.loc_db, irblock.loc_key, irs)
 
 
 class ir_x86_32(ir_x86_16):
diff --git a/miasm/core/sembuilder.py b/miasm/core/sembuilder.py
index efd80ce4..653ac46b 100644
--- a/miasm/core/sembuilder.py
+++ b/miasm/core/sembuilder.py
@@ -242,6 +242,9 @@ class SemBuilder(object):
                 IRDst = ast.Attribute(value=ast.Name(id='ir',
                                                      ctx=ast.Load()),
                                       attr='IRDst', ctx=ast.Load())
+                loc_db = ast.Attribute(value=ast.Name(id='ir',
+                                                     ctx=ast.Load()),
+                                      attr='loc_db', ctx=ast.Load())
                 blocks[-1][-1].append(ast.Call(func=ast.Name(id='ExprAssign',
                                                              ctx=ast.Load()),
                                                args=[IRDst, dst],
@@ -288,8 +291,11 @@ class SemBuilder(object):
 
                     sub_blocks[-1] = ast.Call(func=ast.Name(id='IRBlock',
                                                             ctx=ast.Load()),
-                                              args=[loc_if_name,
-                                                    assignblks],
+                                              args=[
+                                                  loc_db,
+                                                  loc_if_name,
+                                                  assignblks
+                                              ],
                                               keywords=[],
                                               starargs=None,
                                               kwargs=None)
diff --git a/miasm/ir/ir.py b/miasm/ir/ir.py
index 1da907ef..00c73d09 100644
--- a/miasm/ir/ir.py
+++ b/miasm/ir/ir.py
@@ -316,9 +316,9 @@ class IRBlock(object):
     Stand for an intermediate representation  basic block.
     """
 
-    __slots__ = ["_loc_key", "_assignblks", "_dst", "_dst_linenb"]
+    __slots__ = ["_loc_db", "_loc_key", "_assignblks", "_dst", "_dst_linenb"]
 
-    def __init__(self, loc_key, assignblks):
+    def __init__(self, loc_db, loc_key, assignblks):
         """
         @loc_key: LocKey of the IR basic block
         @assignblks: list of AssignBlock
@@ -326,6 +326,7 @@ class IRBlock(object):
 
         assert isinstance(loc_key, m2_expr.LocKey)
         self._loc_key = loc_key
+        self._loc_db = loc_db
         for assignblk in assignblks:
             assert isinstance(assignblk, AssignBlock)
         self._assignblks = tuple(assignblks)
@@ -337,6 +338,8 @@ class IRBlock(object):
             return False
         if self.loc_key != other.loc_key:
             return False
+        if self.loc_db != other.loc_db:
+            return False
         if len(self.assignblks) != len(other.assignblks):
             return False
         for assignblk1, assignblk2 in zip(self.assignblks, other.assignblks):
@@ -352,6 +355,7 @@ class IRBlock(object):
         return self.loc_key
 
     loc_key = property(lambda self:self._loc_key)
+    loc_db = property(lambda self:self._loc_db)
     label = property(get_label)
 
     @property
@@ -413,7 +417,7 @@ class IRBlock(object):
                 else:
                     new_assignblk[dst] = src
             irs.append(AssignBlock(new_assignblk, assignblk.instr))
-        return IRBlock(self.loc_key, irs)
+        return IRBlock(self.loc_db, self.loc_key, irs)
 
     @property
     def dst_linenb(self):
@@ -451,7 +455,7 @@ class IRBlock(object):
             for dst, src in viewitems(assignblk):
                 new_assignblk[mod_dst(dst)] = mod_src(src)
             assignblks.append(AssignBlock(new_assignblk, assignblk.instr))
-        return IRBlock(self.loc_key, assignblks)
+        return IRBlock(self.loc_db, self.loc_key, assignblks)
 
     def to_string(self, loc_db=None):
         out = []
@@ -482,7 +486,7 @@ class IRBlock(object):
             if assignblk != new_assignblk:
                 modified = True
             assignblks.append(new_assignblk)
-        return modified, IRBlock(self.loc_key, assignblks)
+        return modified, IRBlock(self.loc_db, self.loc_key, assignblks)
 
 
 class irbloc(IRBlock):
@@ -656,7 +660,7 @@ class IRCFG(DiGraph):
                 if assignblk != new_assignblk:
                     modified = True
                 assignblks.append(new_assignblk)
-            self.blocks[loc_key] = IRBlock(loc_key, assignblks)
+            self.blocks[loc_key] = IRBlock(self.loc_db, loc_key, assignblks)
         return modified
 
     def _extract_dst(self, todo, done):
@@ -757,7 +761,7 @@ class IntermediateRepresentation(object):
             irs = []
             for assignblk in irb:
                 irs.append(AssignBlock(assignblk, instr))
-            extra_irblocks[index] = IRBlock(irb.loc_key, irs)
+            extra_irblocks[index] = IRBlock(self.loc_db, irb.loc_key, irs)
         assignblk = AssignBlock(ir_bloc_cur, instr)
         return assignblk, extra_irblocks
 
@@ -827,11 +831,11 @@ class IntermediateRepresentation(object):
                 ir_blocks_all, gen_pc_updt
             )
             if split:
-                ir_blocks_all.append(IRBlock(loc_key, assignments))
+                ir_blocks_all.append(IRBlock(self.loc_db, loc_key, assignments))
                 loc_key = None
                 assignments = []
         if loc_key is not None:
-            ir_blocks_all.append(IRBlock(loc_key, assignments))
+            ir_blocks_all.append(IRBlock(self.loc_db, loc_key, assignments))
 
         new_ir_blocks_all = self.post_add_asmblock_to_ircfg(block, ircfg, ir_blocks_all)
         for irblock in new_ir_blocks_all:
@@ -915,7 +919,7 @@ class IntermediateRepresentation(object):
             else:
                 instr = None
             assignblk = AssignBlock({self.IRDst: dst}, instr)
-            ir_blocks[index] = IRBlock(irblock.loc_key, list(irblock.assignblks) + [assignblk])
+            ir_blocks[index] = IRBlock(self.loc_db, irblock.loc_key, list(irblock.assignblks) + [assignblk])
 
     def post_add_asmblock_to_ircfg(self, block, ircfg, ir_blocks):
         self.set_empty_dst_to_next(block, ir_blocks)
diff --git a/miasm/jitter/codegen.py b/miasm/jitter/codegen.py
index 0b5b7961..d05865f2 100644
--- a/miasm/jitter/codegen.py
+++ b/miasm/jitter/codegen.py
@@ -156,7 +156,7 @@ class CGen(object):
             dst = ExprLoc(loc_key, self.ir_arch.IRDst.size)
             new_assignblk[self.ir_arch.IRDst] = dst
         irs = [AssignBlock(new_assignblk, instr)]
-        return IRBlock(self.ir_arch.get_loc_key_for_instr(instr), irs)
+        return IRBlock(self.ir_arch.loc_db, self.ir_arch.get_loc_key_for_instr(instr), irs)
 
     def block2assignblks(self, block):
         """
diff --git a/test/analysis/data_flow.py b/test/analysis/data_flow.py
index 98efecbe..47d521bc 100644
--- a/test/analysis/data_flow.py
+++ b/test/analysis/data_flow.py
@@ -51,7 +51,7 @@ def gen_irblock(label, exprs_list):
             irs.append(AssignBlock(exprs))
 
     irs.append(AssignBlock({IRDst:dummy}))
-    irbl = IRBlock(label, irs)
+    irbl = IRBlock(loc_db, label, irs)
     return irbl
 
 
diff --git a/test/analysis/depgraph.py b/test/analysis/depgraph.py
index eb6507dc..a458e533 100644
--- a/test/analysis/depgraph.py
+++ b/test/analysis/depgraph.py
@@ -68,7 +68,7 @@ def gen_irblock(label, exprs_list):
         else:
             irs.append(AssignBlock(exprs))
 
-    irbl = IRBlock(label, irs)
+    irbl = IRBlock(loc_db, label, irs)
     return irbl
 
 
diff --git a/test/analysis/unssa.py b/test/analysis/unssa.py
index 2bfe9254..5844bfb4 100644
--- a/test/analysis/unssa.py
+++ b/test/analysis/unssa.py
@@ -56,7 +56,7 @@ def gen_irblock(label, exprs_list):
         else:
             irs.append(AssignBlock(exprs))
 
-    irbl = IRBlock(label, irs)
+    irbl = IRBlock(loc_db, label, irs)
     return irbl
 
 
@@ -587,7 +587,7 @@ def add_out_reg_end(ir_arch_a, ircfg_a):
         assignblks = list(irblock)
         new_assiblk = AssignBlock(regs, assignblks[-1].instr)
         assignblks.append(new_assiblk)
-        new_irblock = IRBlock(irblock.loc_key, assignblks)
+        new_irblock = IRBlock(loc_db, irblock.loc_key, assignblks)
         ircfg_a.blocks[loc] = new_irblock
 
 
diff --git a/test/ir/reduce_graph.py b/test/ir/reduce_graph.py
index 8835b4aa..73af4860 100644
--- a/test/ir/reduce_graph.py
+++ b/test/ir/reduce_graph.py
@@ -95,7 +95,7 @@ def gen_irblock(label, exprs_list):
         else:
             irs.append(AssignBlock(exprs))
 
-    irbl = IRBlock(label, irs)
+    irbl = IRBlock(loc_db, label, irs)
     return irbl