diff --git a/gen_input/templates/llvm/CORENAME.cpp.gtl b/gen_input/templates/llvm/CORENAME.cpp.gtl
index 447c720..07601c1 100644
--- a/gen_input/templates/llvm/CORENAME.cpp.gtl
+++ b/gen_input/templates/llvm/CORENAME.cpp.gtl
@@ -170,13 +170,13 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ ${instr.length/8};
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         <%instr.behavior.eachLine{%>${it}
         <%}%>
+        this->gen_sync(POST_SYNC, ${idx});
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, ${idx});
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -185,6 +185,15 @@ private:
      * end opcode definitions
      ****************************************************************************/
     std::tuple<continuation_e, BasicBlock *> illegal_instruction(virt_addr_t &pc, code_word_t instr, BasicBlock *bb) {
+        if(this->disass_enabled){
+            auto mnemonic = std::string("illegal_instruction");
+            std::vector<Value*> args {
+                this->core_ptr,
+                this->gen_const(64, pc.val),
+                this->builder.CreateGlobalStringPtr(mnemonic),
+            };
+            this->builder.CreateCall(this->mod->getFunction("print_disass"), args);
+        }
 		this->gen_sync(iss::PRE_SYNC, instr_descr.size());
         this->builder.CreateStore(this->builder.CreateLoad(this->get_typeptr(traits::NEXT_PC), get_reg_ptr(traits::NEXT_PC), true),
                                    get_reg_ptr(traits::PC), true);
@@ -193,6 +202,7 @@ private:
                                      this->gen_const(64U, 1)),
             get_reg_ptr(traits::ICOUNT), true);
         pc = pc + ((instr & 3) == 3 ? 4 : 2);
+        this->set_tval(instr);
         this->gen_raise_trap(0, 2);     // illegal instruction trap
 		this->gen_sync(iss::POST_SYNC, instr_descr.size());
         this->gen_instr_epilogue(this->leave_blk);
@@ -341,7 +351,6 @@ inline void vm_impl<ARCH>::set_tval(Value* new_tval) {
 template <typename ARCH> 
 void vm_impl<ARCH>::gen_trap_behavior(BasicBlock *trap_blk) {
     this->builder.SetInsertPoint(trap_blk);
-    this->gen_sync(POST_SYNC, -1); //TODO get right InstrId
     auto *trap_state_val = this->builder.CreateLoad(this->get_typeptr(traits::TRAP_STATE), get_reg_ptr(traits::TRAP_STATE), true);
     this->builder.CreateStore(this->gen_const(32U, std::numeric_limits<uint32_t>::max()),
                               get_reg_ptr(traits::LAST_BRANCH), false);
diff --git a/src/vm/llvm/vm_tgc5c.cpp b/src/vm/llvm/vm_tgc5c.cpp
index 9ab029c..4313a53 100644
--- a/src/vm/llvm/vm_tgc5c.cpp
+++ b/src/vm/llvm/vm_tgc5c.cpp
@@ -351,7 +351,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -367,8 +367,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 0);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 0);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -395,7 +395,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -411,8 +411,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 1);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 1);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -439,7 +439,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -464,8 +464,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 2);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 2);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -493,7 +493,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -540,8 +540,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 3);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 3);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -569,7 +569,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -600,8 +600,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 4);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 4);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -629,7 +629,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -660,8 +660,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 5);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 5);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -689,7 +689,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -724,8 +724,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 6);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 6);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -753,7 +753,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -788,8 +788,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 7);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 7);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -817,7 +817,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -848,8 +848,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 8);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 8);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -877,7 +877,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -908,8 +908,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 9);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 9);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -937,7 +937,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -964,8 +964,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 10);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 10);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -993,7 +993,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1020,8 +1020,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 11);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 11);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1049,7 +1049,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1076,8 +1076,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 12);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 12);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1105,7 +1105,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1130,8 +1130,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 13);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 13);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1159,7 +1159,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1184,8 +1184,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 14);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 14);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1213,7 +1213,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1235,8 +1235,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 15);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 15);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1264,7 +1264,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1286,8 +1286,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 16);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 16);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1315,7 +1315,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1337,8 +1337,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 17);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 17);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1366,7 +1366,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1387,8 +1387,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 18);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 18);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1416,7 +1416,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1439,8 +1439,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 19);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 19);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1468,7 +1468,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1490,8 +1490,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 20);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 20);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1519,7 +1519,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1538,8 +1538,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 21);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 21);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1567,7 +1567,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1586,8 +1586,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 22);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 22);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1615,7 +1615,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1634,8 +1634,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 23);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 23);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1663,7 +1663,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1682,8 +1682,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 24);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 24);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1711,7 +1711,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1730,8 +1730,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 25);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 25);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1759,7 +1759,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -1780,8 +1780,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 26);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 26);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1809,7 +1809,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -1830,8 +1830,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 27);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 27);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1859,7 +1859,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -1880,8 +1880,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 28);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 28);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1909,7 +1909,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -1931,8 +1931,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 29);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 29);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -1960,7 +1960,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -1984,8 +1984,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 30);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 30);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2013,7 +2013,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2035,8 +2035,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 31);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 31);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2064,7 +2064,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2083,8 +2083,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 32);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 32);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2112,7 +2112,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2134,8 +2134,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 33);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 33);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2163,7 +2163,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2188,8 +2188,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 34);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 34);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2217,7 +2217,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2236,8 +2236,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 35);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 35);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2265,7 +2265,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2284,8 +2284,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 36);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 36);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2315,7 +2315,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_write_mem(traits::FENCE,
@@ -2324,8 +2324,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 37);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 37);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2342,15 +2342,15 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_raise_trap(0, 11);
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(TRAP,nullptr);
         
+        this->gen_sync(POST_SYNC, 38);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 38);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2367,15 +2367,15 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_raise_trap(0, 3);
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(TRAP,nullptr);
         
+        this->gen_sync(POST_SYNC, 39);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 39);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2392,15 +2392,15 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_leave_trap(3);
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(TRAP,nullptr);
         
+        this->gen_sync(POST_SYNC, 40);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 40);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2417,15 +2417,15 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_wait(1);
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 41);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 41);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2453,7 +2453,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -2478,8 +2478,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 42);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 42);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2507,7 +2507,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -2533,8 +2533,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 43);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 43);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2562,7 +2562,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -2588,8 +2588,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 44);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 44);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2617,7 +2617,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -2637,8 +2637,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 45);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 45);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2666,7 +2666,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -2691,8 +2691,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 46);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 46);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2720,7 +2720,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -2745,8 +2745,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 47);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 47);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2774,7 +2774,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_write_mem(traits::FENCE,
@@ -2783,8 +2783,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(FLUSH,nullptr);
         
+        this->gen_sync(POST_SYNC, 48);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 48);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2812,7 +2812,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2836,8 +2836,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 49);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 49);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2865,7 +2865,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2892,8 +2892,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 50);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 50);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2921,7 +2921,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -2947,8 +2947,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 51);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 51);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -2976,7 +2976,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -3001,8 +3001,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 52);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 52);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3030,7 +3030,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -3099,8 +3099,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 53);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 53);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3128,7 +3128,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -3168,8 +3168,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 54);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 54);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3197,7 +3197,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -3270,8 +3270,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 55);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 55);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3299,7 +3299,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 4;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rs1>=static_cast<uint32_t>(traits::RFS)||rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -3339,8 +3339,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 56);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 56);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3367,7 +3367,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(imm) {
@@ -3386,8 +3386,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 57);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 57);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3415,7 +3415,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         auto offs =this->gen_ext(
@@ -3434,8 +3434,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 58);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 58);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3463,7 +3463,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         auto offs =this->gen_ext(
@@ -3480,8 +3480,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 59);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 59);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3508,7 +3508,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -3529,8 +3529,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 60);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 60);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3548,14 +3548,14 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 61);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 61);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3581,7 +3581,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -3593,8 +3593,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 62);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 62);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3621,7 +3621,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -3637,8 +3637,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 63);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 63);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3665,7 +3665,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(imm==0||rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -3679,8 +3679,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 64);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 64);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3706,7 +3706,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(nzimm) {
@@ -3725,8 +3725,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 65);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 65);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3744,15 +3744,15 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 66);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 66);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3779,7 +3779,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -3791,8 +3791,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 67);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 67);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3819,7 +3819,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(shamt){ this->builder.CreateStore(
@@ -3849,8 +3849,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 68);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 68);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3877,7 +3877,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -3891,8 +3891,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 69);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 69);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3919,7 +3919,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -3933,8 +3933,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 70);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 70);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -3961,7 +3961,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -3973,8 +3973,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 71);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 71);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4001,7 +4001,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -4013,8 +4013,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 72);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 72);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4041,7 +4041,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->builder.CreateStore(
@@ -4053,8 +4053,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 73);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 73);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4080,7 +4080,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         auto PC_val_v = (uint32_t)(PC+(int16_t)sext<12>(imm));
@@ -4089,8 +4089,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 74);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 74);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4117,7 +4117,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
@@ -4137,8 +4137,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 75);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 75);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4165,7 +4165,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         auto bb_merge = BasicBlock::Create(this->mod->getContext(), "bb_merge", this->func, this->leave_blk);
@@ -4185,8 +4185,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 76);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 76);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4213,7 +4213,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -4232,8 +4232,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 77);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 77);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4260,7 +4260,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)||rd==0) {
@@ -4284,8 +4284,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 78);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 78);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4312,7 +4312,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -4328,8 +4328,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 79);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 79);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4355,7 +4355,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs1&&rs1<static_cast<uint32_t>(traits::RFS)){ auto addr_mask =(uint32_t)- 2;
@@ -4372,8 +4372,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 80);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 80);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4390,15 +4390,15 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_raise_trap(0, 2);
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 81);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 81);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4425,7 +4425,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rd>=static_cast<uint32_t>(traits::RFS)) {
@@ -4446,8 +4446,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 82);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 82);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4473,7 +4473,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs1>=static_cast<uint32_t>(traits::RFS)) {
@@ -4495,8 +4495,8 @@ private:
         bb = this->leave_blk;
         auto returnValue = std::make_tuple(BRANCH,nullptr);
         
+        this->gen_sync(POST_SYNC, 83);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 83);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4513,15 +4513,15 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_raise_trap(0, 3);
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 84);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 84);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4548,7 +4548,7 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         if(rs2>=static_cast<uint32_t>(traits::RFS)) {
@@ -4570,8 +4570,8 @@ private:
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 85);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 85);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4588,15 +4588,15 @@ private:
         auto cur_pc_val = this->gen_const(32,pc.val);
         pc=pc+ 2;
         this->gen_set_pc(pc, traits::NEXT_PC);
-        this->set_tval(PC);
+        this->set_tval(instr);
 
         /*generate behavior*/
         this->gen_raise_trap(0, static_cast<int32_t>(traits::RV_CAUSE_ILLEGAL_INSTRUCTION));
         bb = BasicBlock::Create(this->mod->getContext(), "entry", this->func, this->leave_blk);
         auto returnValue = std::make_tuple(CONT,bb);
         
+        this->gen_sync(POST_SYNC, 86);
         this->gen_instr_epilogue(bb);
-    	this->gen_sync(POST_SYNC, 86);
         this->builder.CreateBr(bb);
     	return returnValue;        
     }
@@ -4604,7 +4604,16 @@ private:
     /****************************************************************************
      * end opcode definitions
      ****************************************************************************/
-    std::tuple<continuation_e, BasicBlock *> illegal_intruction(virt_addr_t &pc, code_word_t instr, BasicBlock *bb) {
+    std::tuple<continuation_e, BasicBlock *> illegal_instruction(virt_addr_t &pc, code_word_t instr, BasicBlock *bb) {
+        if(this->disass_enabled){
+            auto mnemonic = std::string("illegal_instruction");
+            std::vector<Value*> args {
+                this->core_ptr,
+                this->gen_const(64, pc.val),
+                this->builder.CreateGlobalStringPtr(mnemonic),
+            };
+            this->builder.CreateCall(this->mod->getFunction("print_disass"), args);
+        }
 		this->gen_sync(iss::PRE_SYNC, instr_descr.size());
         this->builder.CreateStore(this->builder.CreateLoad(this->get_typeptr(traits::NEXT_PC), get_reg_ptr(traits::NEXT_PC), true),
                                    get_reg_ptr(traits::PC), true);
@@ -4613,6 +4622,7 @@ private:
                                      this->gen_const(64U, 1)),
             get_reg_ptr(traits::ICOUNT), true);
         pc = pc + ((instr & 3) == 3 ? 4 : 2);
+        this->set_tval(instr);
         this->gen_raise_trap(0, 2);     // illegal instruction trap
 		this->gen_sync(iss::POST_SYNC, instr_descr.size());
         this->gen_instr_epilogue(this->leave_blk);
@@ -4716,7 +4726,7 @@ vm_impl<ARCH>::gen_single_inst_behavior(virt_addr_t &pc, unsigned int &inst_cnt,
     ++inst_cnt;
     auto f = decode_instr(root, instr);
     if (f == nullptr) {
-        f = &this_class::illegal_intruction;
+        f = &this_class::illegal_instruction;
     }
     return (this->*f)(pc, instr, this_block);
 }
@@ -4757,11 +4767,10 @@ inline void vm_impl<ARCH>::set_tval(uint64_t tval) {
 template <typename ARCH>
 inline void vm_impl<ARCH>::set_tval(Value* new_tval) {
     this->builder.CreateStore(this->gen_ext(new_tval, 64, false), this->tval);
-}   
+}
 template <typename ARCH> 
 void vm_impl<ARCH>::gen_trap_behavior(BasicBlock *trap_blk) {
     this->builder.SetInsertPoint(trap_blk);
-    this->gen_sync(POST_SYNC, -1); //TODO get right InstrId
     auto *trap_state_val = this->builder.CreateLoad(this->get_typeptr(traits::TRAP_STATE), get_reg_ptr(traits::TRAP_STATE), true);
     this->builder.CreateStore(this->gen_const(32U, std::numeric_limits<uint32_t>::max()),
                               get_reg_ptr(traits::LAST_BRANCH), false);