diff --git a/Makefile b/Makefile
index 33900be7692a2e3a368a74ee08aeeb36a78e7b03..3887020450dd087c3f7e03c30c22e4f2f0896d1a 100644
--- a/Makefile
+++ b/Makefile
@@ -38,7 +38,7 @@ GN_OPTIONS := \
   OPS_ANDROID=$(OPS_ANDROID)
 
 .PHONY: default
-default: install
+default: install mplfe
 
 .PHONY: maplegen
 maplegen:
diff --git a/src/mapleall/maple_be/src/be/lower.cpp b/src/mapleall/maple_be/src/be/lower.cpp
index 087b3d9fee55e52f2586deff49fb62f013a99cba..5d366e6f32ba850da7ba39d171efca312cc29fc4 100644
--- a/src/mapleall/maple_be/src/be/lower.cpp
+++ b/src/mapleall/maple_be/src/be/lower.cpp
@@ -101,6 +101,7 @@ void CGLowerer::RegisterExternalLibraryFunctions() {
 
     MIRFunction *func = mirModule.GetMIRBuilder()->GetOrCreateFunction(extFnDescrs[i].name,
                                                                        TyIdx(extFnDescrs[i].retType));
+    func->AllocSymTab();
     MIRSymbol *funcSym = func->GetFuncSymbol();
     funcSym->SetStorageClass(kScExtern);
     /* return type */
@@ -1156,6 +1157,7 @@ StmtNode *CGLowerer::LowerCall(CallNode &callNode, StmtNode *&nextStmt, BlockNod
 
     if (needCheckStore) {
       MIRFunction *fn = mirModule.GetMIRBuilder()->GetOrCreateFunction("MCC_Reflect_Check_Arraystore", TyIdx(PTY_void));
+      fn->AllocSymTab();
       MapleVector<BaseNode*> args(mirModule.GetMIRBuilder()->GetCurrentFuncCodeMpAllocator()->Adapter());
       args.emplace_back(callNode.Opnd(0));
       args.emplace_back(callNode.Opnd(kNodeThirdOpnd));
@@ -1417,6 +1419,7 @@ std::unordered_map<std::string, size_t> CGLowerer::arrayClassCacheIndex;
 MIRFunction *CGLowerer::RegisterFunctionVoidStarToVoid(BuiltinFunctionID id, const std::string &name,
                                                        const std::string &paramName) {
   MIRFunction *func = mirBuilder->GetOrCreateFunction(name, GlobalTables::GetTypeTable().GetVoid()->GetTypeIndex());
+  func->AllocSymTab();
   MIRSymbol *funcSym = func->GetFuncSymbol();
   funcSym->SetStorageClass(kScExtern);
   MIRType *argTy = GlobalTables::GetTypeTable().GetPtr();
@@ -1456,6 +1459,7 @@ void CGLowerer::RegisterBuiltIns() {
 
     MIRFunction *func = mirBuilder->GetOrCreateFunction(cgBuiltins[i].second,
                                                         GlobalTables::GetTypeTable().GetVoid()->GetTypeIndex());
+    func->AllocSymTab();
     MIRSymbol *funcSym = func->GetFuncSymbol();
     funcSym->SetStorageClass(kScExtern);
     /* return type */
@@ -1613,6 +1617,7 @@ void CGLowerer::ProcessArrayExpr(BaseNode &expr, BlockNode &blkNode) {
                                                    arrayNode.GetNopndAt(1), lenRegreadNode);
     CondGotoNode *brFalseNode = mirBuilder->CreateStmtCondGoto(cond, OP_brfalse, labIdx);
     MIRFunction *fn = mirBuilder->GetOrCreateFunction("MCC_Array_Boundary_Check", TyIdx(PTY_void));
+    fn->AllocSymTab();
     MapleVector<BaseNode*> args(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
     args.emplace_back(arrayNode.GetNopndAt(0));
     args.emplace_back(arrayNode.GetNopndAt(1));
@@ -1809,7 +1814,6 @@ StmtNode *CGLowerer::LowerIntrinsicopDassign(const DassignNode &dsNode,
   st->SetStorageClass(kScText);
   st->SetSKind(kStFunc);
   MIRFunction *fn = mirModule.GetMemPool()->New<MIRFunction>(&mirModule, st->GetStIdx());
-  fn->Init();
   MapleVector<BaseNode*> &nOpnds = intrinNode.GetNopnd();
   st->SetFunction(fn);
   std::vector<TyIdx> fnTyVec;
@@ -1864,7 +1868,6 @@ BaseNode *CGLowerer::LowerJavascriptIntrinsicop(IntrinsicopNode &intrinNode, con
   st->SetStorageClass(kScText);
   st->SetSKind(kStFunc);
   MIRFunction *fn = mirModule.GetMemPool()->New<MIRFunction>(&mirModule, st->GetStIdx());
-  fn->Init();
   MapleVector<BaseNode*> &nOpnds = intrinNode.GetNopnd();
   st->SetFunction(fn);
   std::vector<TyIdx> fnTyVec;
@@ -2049,6 +2052,7 @@ BaseNode *CGLowerer::LowerIntrinJavaArrayLength(const BaseNode &parent, Intrinsi
     MIRFunction *newFunc =
         mirBuilder->GetOrCreateFunction("MCC_ThrowNullArrayNullPointerException",
                                         GlobalTables::GetTypeTable().GetVoid()->GetTypeIndex());
+    newFunc->AllocSymTab();
     MapleVector<BaseNode*> args(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
     StmtNode *call = mirBuilder->CreateStmtCallAssigned(newFunc->GetPuidx(), args, nullptr, OP_callassigned);
 
@@ -2405,7 +2409,9 @@ StmtNode *CGLowerer::LowerIntrinsicRCCall(IntrinsiccallNode &intrincall) {
   /* convert intrinsic call into function call. */
   if (intrinFuncIDs.find(intrinDesc) == intrinFuncIDs.end()) {
     /* add funcid into map */
-    intrinFuncIDs[intrinDesc] = mirBuilder->GetOrCreateFunction(intrinDesc->name, TyIdx(PTY_void))->GetPuidx();
+    MIRFunction *fn = mirBuilder->GetOrCreateFunction(intrinDesc->name, TyIdx(PTY_void));
+    fn->AllocSymTab();
+    intrinFuncIDs[intrinDesc] = fn->GetPuidx();
   }
   CallNode *callStmt = mirModule.CurFuncCodeMemPool()->New<CallNode>(mirModule, OP_call);
   callStmt->SetPUIdx(intrinFuncIDs.at(intrinDesc));
@@ -2431,6 +2437,7 @@ void CGLowerer::LowerArrayStore(IntrinsiccallNode &intrincall, BlockNode &newBlk
 
   if (needCheckStore) {
     MIRFunction *fn = mirBuilder->GetOrCreateFunction("MCC_Reflect_Check_Arraystore", TyIdx(PTY_void));
+    fn->AllocSymTab();
     MapleVector<BaseNode*> args(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
     args.emplace_back(intrincall.Opnd(0));
     args.emplace_back(intrincall.Opnd(kNodeThirdOpnd));
@@ -2512,6 +2519,7 @@ StmtNode *CGLowerer::LowerIntrinsiccall(IntrinsiccallNode &intrincall, BlockNode
   st->SetStorageClass(kScText);
   st->SetSKind(kStFunc);
   MIRFunction *fn = mirBuilder->GetOrCreateFunction(intrinDesc->name, TyIdx(0));
+  fn->AllocSymTab();
   st->SetFunction(fn);
   return LowerDefaultIntrinsicCall(intrincall, *st, *fn);
 }
@@ -2583,6 +2591,7 @@ PUIdx CGLowerer::GetBuiltinToUse(BuiltinFunctionID id) const {
 void CGLowerer::LowerGCMalloc(const BaseNode &node, const GCMallocNode &gcmalloc, BlockNode &blkNode, bool perm) {
   MIRFunction *func = mirBuilder->GetOrCreateFunction((perm ? "MCC_NewPermanentObject" : "MCC_NewObj_fixed_class"),
                                                       (TyIdx)(LOWERED_PTR_TYPE));
+  func->AllocSymTab();
   /* Get the classinfo */
   MIRStructType *classType = static_cast<MIRStructType*>(
       GlobalTables::GetTypeTable().GetTypeFromTyIdx(gcmalloc.GetTyIdx()));
@@ -2599,6 +2608,7 @@ void CGLowerer::LowerGCMalloc(const BaseNode &node, const GCMallocNode &gcmalloc
   if (classSym->GetAttr(ATTR_abstract) || classSym->GetAttr(ATTR_interface)) {
     MIRFunction *funcSecond = mirBuilder->GetOrCreateFunction("MCC_Reflect_ThrowInstantiationError",
                                                              (TyIdx)(LOWERED_PTR_TYPE));
+    funcSecond->AllocSymTab();
     BaseNode *arg = mirBuilder->CreateExprAddrof(0, *classSym);
     if (node.GetOpCode() == OP_dassign) {
       auto &dsNode = static_cast<const DassignNode&>(node);
@@ -2715,6 +2725,7 @@ void CGLowerer::LowerJarrayMalloc(const StmtNode &stmt, const JarrayMallocNode &
     args.emplace_back(mirBuilder->CreateIntConst(0, PTY_u32));
   }
   MIRFunction *func = mirBuilder->GetOrCreateFunction(funcName, (TyIdx)(LOWERED_PTR_TYPE));
+  func->AllocSymTab();
   CallNode *callAssign = nullptr;
   if (stmt.GetOpCode() == OP_dassign) {
     auto &dsNode = static_cast<const DassignNode&>(stmt);
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp
index 481a2521f747275450d49b81e0dca34d5f84cfc3..b96235654827d0cffd1c0a6366b936ebf13971f4 100644
--- a/src/mapleall/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp
@@ -3572,7 +3572,7 @@ void AArch64CGFunc::SelectRangeGoto(RangeGotoNode &rangeGotoNode, Operand &srcOp
   for (const auto &itPair : switchTable) {
     LabelIdx labelIdx = itPair.second;
     GetCurBB()->PushBackRangeGotoLabel(labelIdx);
-    MIRConst *mirConst = memPool->New<MIRLblConst>(labelIdx, *etype);
+    MIRConst *mirConst = memPool->New<MIRLblConst>(labelIdx, GetFunction().GetPuidx(), *etype);
     arrayConst->PushBack(mirConst);
   }
 
diff --git a/src/mapleall/maple_ipa/src/clone.cpp b/src/mapleall/maple_ipa/src/clone.cpp
index 6144cef0c408a262f3f8c3c7dff64ffb46169871..39c8e111b79575581b29375fdc6d11fc037f1a7b 100644
--- a/src/mapleall/maple_ipa/src/clone.cpp
+++ b/src/mapleall/maple_ipa/src/clone.cpp
@@ -127,10 +127,6 @@ MIRFunction *Clone::CloneFunction(MIRFunction &originalFunction, const std::stri
     CloneLabels(*newFunc, originalFunction);
     mirBuilder.SetCurrentFunction(*originalCurrFunction);
   }
-  // clone pregIndex
-  if (newFunc->GetPregTab() != nullptr && originalFunction.GetPregTab() != nullptr) {
-    newFunc->GetPregTab()->SetIndex(originalFunction.GetPregTab()->GetIndex());
-  }
   return newFunc;
 }
 
diff --git a/src/mapleall/maple_ir/include/bin_mpl_export.h b/src/mapleall/maple_ir/include/bin_mpl_export.h
index 62891cd4fc89fcb2893e305ae53ce28f5bb1648e..db49e74ed01f4cdcf3f9b05b516852fcbda86c0e 100644
--- a/src/mapleall/maple_ir/include/bin_mpl_export.h
+++ b/src/mapleall/maple_ir/include/bin_mpl_export.h
@@ -65,7 +65,32 @@ enum : uint8 {
   kBinEaCgRefNode = 39,
   kBinEaCgObjNode = 40,
   kBinEaCgStart = 41,
-  kBinEaStart = 42
+  kBinEaStart = 42,
+  kBinNodeBlock = 43,
+  kBinOpStatement = 44,
+  kBinOpExpression = 45,
+  kBinReturnvals = 46,
+  kBinTypeTabStart = 47,
+  kBinSymStart = 48,
+  kBinSymTabStart = 49,
+  kBinFuncIdInfoStart = 50,
+  kBinFormalStart = 51,
+  kBinPreg = 52,
+  kBinPregStart = 53,
+  kBinLabelStart = 54,
+  kBinTypenameStart = 55,
+  kBinHeaderStart = 56,
+  kBinAliasMapStart = 57,
+  kBinKindTypeViaTypename = 58,
+  kBinKindSymViaSymname = 59,
+  kBinKindFuncViaSymname = 60,
+  kBinFunctionBodyStart = 61,
+  kBinFormalWordsTypeTagged = 62,
+  kBinFormalWordsRefCounted = 63,
+  kBinLocalWordsTypeTagged = 64,
+  kBinLocalWordsRefCounter = 65,
+  kBinKindConstAddrofLabel = 66,
+  kBinKindConstAddrofLocal = 67,
 };
 
 // this value is used to check wether a file is a binary mplt file
diff --git a/src/mapleall/maple_ir/include/intrinsic_c.def b/src/mapleall/maple_ir/include/intrinsic_c.def
new file mode 100644
index 0000000000000000000000000000000000000000..b91bf236f91a62326ea9e0db0d0f63ce3a6de9bb
--- /dev/null
+++ b/src/mapleall/maple_ir/include/intrinsic_c.def
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+// DEF_MIR_INTRINSIC(STR, NAME, INTRN_CLASS, RETURN_TYPE, ARG0, ARG1, ARG2, ARG3, ARG4, ARG5)
+
+DEF_MIR_INTRINSIC(C_strcmp,\
+                  "strcmp", INTRNNOSIDEEFFECT | INTRNISPURE, kArgTyI32, kArgTyPtr, kArgTyPtr)
+DEF_MIR_INTRINSIC(C_strncmp,\
+                  "strncmp", INTRNNOSIDEEFFECT | INTRNISPURE, kArgTyI32, kArgTyPtr, kArgTyPtr, kArgTyU32)
+DEF_MIR_INTRINSIC(C_strcpy,\
+                  "strcpy", 0, kArgTyVoid, kArgTyPtr, kArgTyPtr)
+DEF_MIR_INTRINSIC(C_strncpy,\
+                  "strncpy", 0, kArgTyVoid, kArgTyPtr, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C_strlen,\
+                  "strlen", INTRNNOSIDEEFFECT | INTRNISPURE, kArgTyU64, kArgTyPtr)
+DEF_MIR_INTRINSIC(C_memcmp,\
+                  "memcmp", INTRNNOSIDEEFFECT | INTRNISPURE, kArgTyI32, kArgTyPtr, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C_memcpy,\
+                  "memcpy", 0, kArgTyVoid, kArgTyPtr, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C_memmove,\
+                  "memmove", 0, kArgTyVoid, kArgTyPtr, kArgTyPtr, kArgTyU64)
+DEF_MIR_INTRINSIC(C_memset,\
+                  "memset", 0, kArgTyVoid, kArgTyPtr, kArgTyI32, kArgTyU64)
+DEF_MIR_INTRINSIC(C_acosf,\
+                  "acosf", INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_asinf,\
+                  "asinf", INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_atanf,\
+                  "atanf", INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_cosf,\
+                  "cosf", INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_coshf,\
+                  "coshf", INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_expf,\
+                  "expf", INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_logf,\
+                  "logf", INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_log10f,\
+                  "log10f", INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_sinf,\
+                  "sinf", INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_sinhf,\
+                  "sinhf", INTRNISPURE, kArgTyF32, kArgTyF32)
+DEF_MIR_INTRINSIC(C_acos,\
+                  "acos", INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_asin,\
+                  "asin", INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_atan,\
+                  "atan", INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_cos,\
+                  "cos", INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_cosh,\
+                  "cosh", INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_exp,\
+                  "exp", INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_log,\
+                  "log", INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_log10,\
+                  "log10", INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_sin,\
+                  "sin", INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_sinh,\
+                  "sinh", INTRNISPURE, kArgTyF64, kArgTyF64)
+DEF_MIR_INTRINSIC(C_ffs,\
+                  "ffs", INTRNISPURE, kArgTyI32, kArgTyI32)
+DEF_MIR_INTRINSIC(C_va_start,\
+                  "sinh"/*dummy*/, INTRNISPURE, kArgTyVoid, kArgTyPtr, kArgTyI32)
+DEF_MIR_INTRINSIC(C_constant_p,\
+                  "sinh"/*dummy*/, 0, kArgTyI32, kArgTyDynany)
+DEF_MIR_INTRINSIC(C_clz32,\
+                  "sinh"/*dummy*/, INTRNISPURE, kArgTyI32, kArgTyU32)
+DEF_MIR_INTRINSIC(C_clz64,\
+                  "sinh"/*dummy*/, INTRNISPURE, kArgTyI32, kArgTyU64)
+DEF_MIR_INTRINSIC(C_ctz32,\
+                  "sinh"/*dummy*/, INTRNISPURE, kArgTyI32, kArgTyU32)
+DEF_MIR_INTRINSIC(C_ctz64,\
+                  "sinh"/*dummy*/, INTRNISPURE, kArgTyI32, kArgTyU64)
diff --git a/src/mapleall/maple_ir/include/intrinsic_js.def b/src/mapleall/maple_ir/include/intrinsic_js.def
new file mode 100644
index 0000000000000000000000000000000000000000..83bfaf1200c0bf3050e419e426282fb569f46aa7
--- /dev/null
+++ b/src/mapleall/maple_ir/include/intrinsic_js.def
@@ -0,0 +1,119 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+// DEF_MIR_INTRINSIC(STR, NAME, INTRN_CLASS, RETURN_TYPE, ARG0, ARG1, ARG2, ARG3, ARG4, ARG5)
+DEF_MIR_INTRINSIC(JS_INIT_CONTEXT,\
+                  "__js_init_context", INTRNISJS, kArgTyVoid, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_REQUIRE,\
+                  "__js_require", INTRNISJS | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_GET_BIOBJECT,\
+                  "__jsobj_get_or_create_builtin", INTRNISJS | INTRNISPURE, kArgTySimpleobj, kArgTyU32, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_GET_BISTRING,\
+                  "__jsstr_get_builtin", INTRNISJS | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTySimplestr, kArgTyU32, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_THIS,\
+                  "__jsop_this", INTRNISJS | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_ADD,\
+                  "__jsop_add", INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_CONCAT,\
+                  "__jsstr_concat_2", INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTySimplestr, kArgTySimplestr, kArgTySimplestr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_STRICTEQ,\
+                  "__jsop_stricteq", INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU1, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSSTR_STRICTEQ,\
+                  "__jsstr_equal", INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU1, kArgTySimplestr, kArgTySimplestr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_STRICTNE,\
+                  "__jsop_strictne", INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU1, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSSTR_STRICTNE,\
+                  "__jsstr_ne", INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU1, kArgTySimplestr, kArgTySimplestr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_INSTANCEOF,\
+                  "__jsop_instanceof", INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU1, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_IN,\
+                  "__jsop_in", INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU1, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_OR,\
+                  "__jsop_or", INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI32, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_AND,\
+                  "__jsop_and", INTRNISJS | INTRNISJSBINARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI32, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_TYPEOF,\
+                  "__jsop_typeof", INTRNISJS | INTRNISJSUNARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_NEW,\
+                  "__js_new", INTRNISJS | INTRNNOSIDEEFFECT, kArgTyPtr, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_STRING,\
+                  "__js_ToString", INTRNISJS | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTySimplestr, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSSTR_LENGTH,\
+                  "__jsstr_get_length", INTRNISJS | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU32, kArgTySimplestr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_BOOLEAN,\
+                  "__js_ToBoolean", INTRNISJS | INTRNISJSUNARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyU1, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_NUMBER,\
+                  "__js_ToNumber", INTRNISJS | INTRNISJSUNARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI32, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_INT32,\
+                  "__js_ToInt32", INTRNISJS | INTRNISJSUNARY | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyI32, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_PRINT,\
+                  "__jsop_print", INTRNISJS | INTRNISPURE | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_ERROR,\
+                  "__js_error", INTRNISJS | INTRNISPURE | INTRNNOSIDEEFFECT | INTRNNEVERRETURN, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_EVAL,\
+                  "__js_eval", kIntrnUndef, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_ICALL,\
+                  "__js_icall", INTRNISJS | INTRNRETURNSTRUCT, kArgTyDynany, kArgTyA32, kArgTyU32, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_CALL,
+                  "__jsop_call", INTRNISJS, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyPtr, kArgTyU32, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_CCALL,\
+                  "__jsop_ccall", INTRNISJS, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyPtr, kArgTyU32, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_NEW,
+                  "__jsop_new", INTRNISJS | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyPtr, kArgTyU32, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_SETTIMEOUT,
+                  "__js_setTimeout", INTRNISJS | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTyI32, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_SETCYCLEHEADER,\
+                  "__js_setCycleHeader", INTRNISJS, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_NEW_OBJECT_0,\
+                  "__js_new_obj_obj_0", INTRNISJS | INTRNNOSIDEEFFECT, kArgTySimpleobj, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_NEW_OBJECT_1,\
+                  "__js_new_obj_obj_1", INTRNISJS | INTRNNOSIDEEFFECT, kArgTySimpleobj, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_SETPROP,\
+                  "__jsop_setprop", INTRNISJS, kArgTyVoid, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_GETPROP,\
+                  "__jsop_getprop", INTRNISJS | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_DELPROP,\
+                  "__jsop_delprop", INTRNISJS, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_SETPROP_BY_NAME,\
+                  "__jsop_setprop_by_name", INTRNISJS, kArgTyVoid, kArgTyDynany, kArgTySimplestr, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_GETPROP_BY_NAME,\
+                  "__jsop_getprop_by_name", INTRNISJS | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTySimplestr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_SETPROP_BY_INDEX,\
+                  "__jsop_setprop_by_index", INTRNISJS, kArgTyVoid, kArgTyDynany, kArgTyU32, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_GETPROP_BY_INDEX,\
+                  "__jsop_getprop_by_index", INTRNISJS | INTRNLOADMEM | INTRNNOSIDEEFFECT, kArgTyDynany, kArgTyDynany, kArgTyU32, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_INITPROP_BY_NAME,\
+                  "__jsop_initprop", INTRNISJS, kArgTyVoid, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_INITPROP_GETTER,\
+                  "__jsop_initprop_getter", INTRNISJS, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_INITPROP_SETTER,\
+                  "__jsop_initprop_setter", INTRNISJS, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_NEW_FUNCTION,\
+                  "__js_new_function", INTRNISJS, kArgTyDynany, kArgTyPtr, kArgTyPtr, kArgTyU32, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_NEW_ARR_ELEMS,\
+                  "__js_new_arr_elems", INTRNISJS | INTRNNOSIDEEFFECT, kArgTySimpleobj, kArgTyPtr, kArgTyU32, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_NEW_ARR_LENGTH,\
+                  "__js_new_arr_length", INTRNISJS | INTRNNOSIDEEFFECT, kArgTySimpleobj, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_LENGTH,\
+                  "__jsop_length", INTRNISJS | INTRNLOADMEM | INTRNNOSIDEEFFECT | INTRNISPURE, kArgTyI32, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_NEW_ITERATOR,\
+                  "__jsop_valueto_iterator", INTRNISJS, kArgTyPtr, kArgTyDynany, kArgTyU32, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_NEXT_ITERATOR,\
+                  "__jsop_iterator_next", INTRNISJS, kArgTyDynany, kArgTyPtr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_MORE_ITERATOR,\
+                  "__jsop_more_iterator", INTRNISJS, kArgTyU32, kArgTyPtr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_ADDSYSEVENTLISTENER,\
+                  "__js_add_sysevent_listener", INTRNISJS, kArgTyU32, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+
diff --git a/src/mapleall/maple_ir/include/intrinsic_js_eng.def b/src/mapleall/maple_ir/include/intrinsic_js_eng.def
new file mode 100644
index 0000000000000000000000000000000000000000..5af255782944ce97d2492eb926769f16d84b90e3
--- /dev/null
+++ b/src/mapleall/maple_ir/include/intrinsic_js_eng.def
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+// DEF_MIR_INTRINSIC(STR, NAME, INTRN_CLASS, RETURN_TYPE, ARG0, ARG1, ARG2, ARG3, ARG4, ARG5)
+DEF_MIR_INTRINSIC(JS_GET_ARGUMENTOBJECT,\
+                  "__jsobj_get_or_create_argument", INTRNISJS | INTRNISPURE, kArgTySimpleobj, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_GET_ERROR_OBJECT,\
+                  "__jsobj_get_or_create_error", INTRNISJS | INTRNISPURE, kArgTySimpleobj, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_GET_EVALERROR_OBJECT,\
+                  "__jsobj_get_or_create_evalError", INTRNISJS | INTRNISPURE, kArgTySimpleobj, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_GET_RANGEERROR_OBJECT,\
+                  "__jsobj_get_or_create_rangeError", INTRNISJS | INTRNISPURE, kArgTySimpleobj, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_GET_REFERENCEERROR_OBJECT,\
+                  "__jsobj_get_or_create_referenceError", INTRNISJS | INTRNISPURE, kArgTySimpleobj, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_GET_SYNTAXERROR_OBJECT,\
+                  "__jsobj_get_or_create_syntaxError", INTRNISJS | INTRNISPURE, kArgTySimpleobj, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_GET_TYPEERROR_OBJECT,\
+                  "__jsobj_get_or_create_typeError", INTRNISJS | INTRNISPURE, kArgTySimpleobj, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JS_GET_URIERROR_OBJECT,\
+                  "__jsobj_get_or_create_uriError", INTRNISJS | INTRNISPURE, kArgTySimpleobj, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JSOP_ASSERTVALUE,
+                  "__jsop_assert_value", INTRNISJS, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
diff --git a/src/mapleall/maple_ir/include/intrinsics.def b/src/mapleall/maple_ir/include/intrinsics.def
index 582088976215554df32eed7798a0a344a1b427ec..fca1fae5c76a4e5a079b6aeeaaa641e7ab9c6c60 100644
--- a/src/mapleall/maple_ir/include/intrinsics.def
+++ b/src/mapleall/maple_ir/include/intrinsics.def
@@ -134,5 +134,8 @@ DEF_MIR_INTRINSIC(MCCSaveProf,\
 
 #include "intrinsic_java.def"
 #include "simplifyintrinsics.def"
+#include "intrinsic_c.def"
+#include "intrinsic_js.def"
+#include "intrinsic_js_eng.def"
 DEF_MIR_INTRINSIC(LAST,\
                   nullptr, kIntrnUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
diff --git a/src/mapleall/maple_ir/include/mir_const.h b/src/mapleall/maple_ir/include/mir_const.h
index 7583aeafd9b6e295665037822f63a3effb464ec8..29ff8b35db0ecbe744bf027e8ba139a17de607a3 100644
--- a/src/mapleall/maple_ir/include/mir_const.h
+++ b/src/mapleall/maple_ir/include/mir_const.h
@@ -44,7 +44,7 @@ class MIRConst {
 
   virtual ~MIRConst() = default;
 
-  virtual void Dump() const;
+  virtual void Dump(const MIRSymbolTable *localsymtab = nullptr) const;
 
   uint32 GetFieldId() const {
     return fieldID;
@@ -116,10 +116,13 @@ class MIRIntConst : public MIRConst {
 
   int64 GetValueUnderType() const;
 
-  void Dump() const override;
+  void Dump(const MIRSymbolTable *localsymtab = nullptr) const override;
   bool IsZero() const override {
     return value == 0 && IsPrimitiveInteger(GetType().GetPrimType());
   }
+  bool IsGeZero() {
+    return value >= 0 && IsPrimitiveInteger(GetType().GetPrimType());
+  }
 
   bool IsOne() const override {
     return value == 1 && IsPrimitiveInteger(GetType().GetPrimType());
@@ -163,7 +166,9 @@ class MIRIntConst : public MIRConst {
 
 class MIRAddrofConst : public MIRConst {
  public:
-  MIRAddrofConst(StIdx sy, FieldID fi, MIRType &ty) : MIRConst(ty, kConstAddrof), stIdx(sy), fldID(fi) {}
+  MIRAddrofConst(StIdx sy, FieldID fi, MIRType &ty, uint32 fieldID = 0) : MIRConst(ty, kConstAddrof), stIdx(sy), fldID(fi), offset(0) {}
+
+  MIRAddrofConst(StIdx sy, FieldID fi, MIRType &ty, int32 ofst, uint32 fieldID = 0) : MIRConst(ty, kConstAddrof, fieldID), stIdx(sy), fldID(fi), offset(ofst) {}
 
   ~MIRAddrofConst() = default;
 
@@ -175,7 +180,11 @@ class MIRAddrofConst : public MIRConst {
     return fldID;
   }
 
-  void Dump() const override;
+  int32 GetOffset() const {
+    return offset;
+  }
+
+  void Dump(const MIRSymbolTable *localsymtab = nullptr) const override;
 
   bool operator==(const MIRConst &rhs) const override;
 
@@ -186,6 +195,7 @@ class MIRAddrofConst : public MIRConst {
  private:
   StIdx stIdx;
   FieldID fldID;
+  int32 offset;
 };
 
 class MIRAddroffuncConst : public MIRConst {
@@ -199,7 +209,7 @@ class MIRAddroffuncConst : public MIRConst {
     return puIdx;
   }
 
-  void Dump() const override;
+  void Dump(const MIRSymbolTable *localsymtab = nullptr) const override;
 
   bool operator==(const MIRConst &rhs) const override;
 
@@ -213,10 +223,12 @@ class MIRAddroffuncConst : public MIRConst {
 
 class MIRLblConst : public MIRConst {
  public:
-  MIRLblConst(LabelIdx val, MIRType &type) : MIRConst(type, kConstLblConst), value(val) {}
+  MIRLblConst(LabelIdx val, PUIdx pidx, MIRType &type, uint32 fieldID = 0) : MIRConst(type, kConstLblConst, fieldID), value(val), puIdx(pidx) {}
 
   ~MIRLblConst() = default;
 
+  void Dump(const MIRSymbolTable *localsymtab = nullptr) const override;
+
   bool operator==(const MIRConst &rhs) const override;
 
   MIRLblConst *Clone(MemPool &memPool) const override {
@@ -227,19 +239,24 @@ class MIRLblConst : public MIRConst {
     return value;
   }
 
+  PUIdx GetPUIdx() const {
+    return puIdx;
+  }
+
  private:
   LabelIdx value;
+  PUIdx puIdx;
 };
 
 class MIRStrConst : public MIRConst {
  public:
   MIRStrConst(UStrIdx val, MIRType &type, uint32 fieldID = 0) : MIRConst(type, kConstStrConst, fieldID), value(val) {}
 
-  MIRStrConst(const std::string &str, MIRType &type);
+  MIRStrConst(const std::string &str, MIRType &type, uint32 fieldID = 0);
 
   ~MIRStrConst() = default;
 
-  void Dump() const override;
+  void Dump(const MIRSymbolTable *localsymtab = nullptr) const override;
   bool operator==(const MIRConst &rhs) const override;
 
   MIRStrConst *Clone(MemPool &memPool) const override {
@@ -261,9 +278,9 @@ class MIRStrConst : public MIRConst {
 
 class MIRStr16Const : public MIRConst {
  public:
-  MIRStr16Const(U16StrIdx val, MIRType &type) : MIRConst(type, kConstStr16Const), value(val) {}
+  MIRStr16Const(U16StrIdx val, MIRType &type, uint32 fieldID = 0) : MIRConst(type, kConstStr16Const, fieldID), value(val) {}
 
-  MIRStr16Const(const std::u16string &str, MIRType &type);
+  MIRStr16Const(const std::u16string &str, MIRType &type, uint32 fieldID = 0);
 
   ~MIRStr16Const() = default;
 
@@ -271,7 +288,7 @@ class MIRStr16Const : public MIRConst {
     return kPrimType;
   }
 
-  void Dump() const override;
+  void Dump(const MIRSymbolTable *localsymtab = nullptr) const override;
   bool operator==(const MIRConst &rhs) const override;
 
   MIRStr16Const *Clone(MemPool &memPool) const override {
@@ -290,7 +307,7 @@ class MIRStr16Const : public MIRConst {
 class MIRFloatConst : public MIRConst {
  public:
   using value_type = float;
-  MIRFloatConst(float val, MIRType &type) : MIRConst(type, kConstFloatConst) {
+  MIRFloatConst(float val, MIRType &type, uint32 fieldID = 0) : MIRConst(type, kConstFloatConst, fieldID) {
     value.floatValue = val;
   }
 
@@ -316,11 +333,19 @@ class MIRFloatConst : public MIRConst {
     return GetFloatValue();
   }
 
-  void Dump() const override;
+  void Dump(const MIRSymbolTable *localsymtab = nullptr) const override;
   bool IsZero() const override {
     return fabs(value.floatValue) <= 1e-6;
   }
 
+  bool IsGeZero() {
+    return value.floatValue >= 0;
+  }
+
+  bool IsNeg() {
+    return ((value.intValue & 0x80000000) == 0x80000000);
+  }
+
   bool IsOne() const override {
     return fabs(value.floatValue - 1) <= 1e-6;
   };
@@ -348,7 +373,7 @@ class MIRFloatConst : public MIRConst {
 class MIRDoubleConst : public MIRConst {
  public:
   using value_type = double;
-  MIRDoubleConst(double val, MIRType &type) : MIRConst(type, kConstDoubleConst) {
+  MIRDoubleConst(double val, MIRType &type, uint32 fieldID = 0) : MIRConst(type, kConstDoubleConst, fieldID) {
     value.dValue = val;
   }
 
@@ -376,11 +401,19 @@ class MIRDoubleConst : public MIRConst {
     return kPrimType;
   }
 
-  void Dump() const override;
+  void Dump(const MIRSymbolTable *localsymtab = nullptr) const override;
   bool IsZero() const override {
     return fabs(value.dValue) <= 1e-15;
   }
 
+  bool IsGeZero() {
+    return value.dValue >= 0;
+  }
+
+  bool IsNeg() {
+    return ((value.intValue & 0x8000000000000000LL) == 0x8000000000000000LL);
+  }
+
   bool IsOne() const override {
     return fabs(value.dValue - 1) <= 1e-15;
   };
@@ -407,7 +440,7 @@ class MIRDoubleConst : public MIRConst {
 
 class MIRFloat128Const : public MIRConst {
  public:
-  MIRFloat128Const(const uint64 &val, MIRType &type) : MIRConst(type, kConstFloat128Const) {
+  MIRFloat128Const(const uint64 &val, MIRType &type, uint32 fieldID = 0) : MIRConst(type, kConstFloat128Const, fieldID) {
     value = &val;
   }
 
@@ -441,7 +474,7 @@ class MIRFloat128Const : public MIRConst {
     return res;
   }
 
-  void Dump() const override;
+  void Dump(const MIRSymbolTable *localsymtab = nullptr) const override;
 
  private:
   static const PrimType kPrimType = PTY_f128;
@@ -451,8 +484,8 @@ class MIRFloat128Const : public MIRConst {
 
 class MIRAggConst : public MIRConst {
  public:
-  MIRAggConst(MIRModule &mod, MIRType &type)
-      : MIRConst(type, kConstAggConst), constVec(mod.GetMPAllocator().Adapter()) {}
+  MIRAggConst(MIRModule &mod, MIRType &type, uint32 fieldID = 0)
+      : MIRConst(type, kConstAggConst, fieldID), constVec(mod.GetMPAllocator().Adapter()) {}
 
   ~MIRAggConst() = default;
 
@@ -489,7 +522,7 @@ class MIRAggConst : public MIRConst {
     constVec.push_back(elem);
   }
 
-  void Dump() const override;
+  void Dump(const MIRSymbolTable *localsymtab = nullptr) const override;
   bool operator==(const MIRConst &rhs) const override;
 
   MIRAggConst *Clone(MemPool &memPool) const override {
@@ -503,8 +536,8 @@ class MIRAggConst : public MIRConst {
 // the const has one or more symbols
 class MIRStConst : public MIRConst {
  public:
-  MIRStConst(MIRModule &mod, MIRType &type)
-      : MIRConst(type, kConstStConst), stVec(mod.GetMPAllocator().Adapter()),
+  MIRStConst(MIRModule &mod, MIRType &type, uint32 fieldID = 0)
+      : MIRConst(type, kConstStConst, fieldID), stVec(mod.GetMPAllocator().Adapter()),
         stOffsetVec(mod.GetMPAllocator().Adapter()) {}
 
   const MapleVector<MIRSymbol*> &GetStVec() const {
diff --git a/src/mapleall/maple_ir/include/mir_function.h b/src/mapleall/maple_ir/include/mir_function.h
index de7b374b96f6b4826d5736e719904051416e9b2a..21cd2509a8d4b2c0dc376a010970e21db247f15a 100644
--- a/src/mapleall/maple_ir/include/mir_function.h
+++ b/src/mapleall/maple_ir/include/mir_function.h
@@ -44,6 +44,19 @@ enum FuncAttrProp : uint32_t {
   kDefEffect = 0x80
 };
 
+// describe a formal definition in a function declaration
+class FormalDef {
+ public:
+  GStrIdx formalStrIdx = GStrIdx(0);    // used when processing the prototype
+  MIRSymbol *formalSym = nullptr;       // used in the function definition
+  TyIdx formalTyIdx = TyIdx();
+  TypeAttrs formalAttrs = TypeAttrs();  // the formal's type attributes
+
+  FormalDef() {};
+  FormalDef(MIRSymbol *s, TyIdx tidx, TypeAttrs at) : formalSym(s), formalTyIdx(tidx), formalAttrs(at) {}
+  FormalDef(GStrIdx sidx, MIRSymbol *s, TyIdx tidx, TypeAttrs at) : formalStrIdx(sidx), formalSym(s), formalTyIdx(tidx), formalAttrs(at) {}
+};
+
 class MeFunction;  // circular dependency exists, no other choice
 class EAConnectionGraph;  // circular dependency exists, no other choice
 class MIRFunction {
@@ -54,8 +67,6 @@ class MIRFunction {
 
   ~MIRFunction() = default;
 
-  void Init();
-
   void Dump(bool withoutBody = false);
   void DumpUpFormal(int32 indent) const;
   void DumpFrame(int32 indent) const;
@@ -139,6 +150,11 @@ class MIRFunction {
     classTyIdx.reset(idx);
   }
 
+  void AddArgument(MIRSymbol *st) {
+    FormalDef formalDef(st, st->GetTyIdx(), st->GetAttrs());
+    formalDefVec.push_back(formalDef);
+  }
+
   size_t GetParamSize() const {
     CHECK_FATAL(funcType != nullptr, "funcType is nullptr");
     return funcType->GetParamTypeList().size();
@@ -158,8 +174,8 @@ class MIRFunction {
   MIRType *GetNthParamType(size_t i);
 
   const TypeAttrs &GetNthParamAttr(size_t i) const {
-    ASSERT(i < formals.size(), "array index out of range");
-    return formals[i]->GetAttrs();
+    ASSERT(i < formalDefVec.size(), "array index out of range");
+    return formalDefVec[i].formalAttrs;
   }
 
   void UpdateFuncTypeAndFormals(const std::vector<MIRSymbol*> &symbols, bool clearOldArgs = false);
@@ -351,9 +367,9 @@ class MIRFunction {
   bool IsClinit() const;
   uint32 GetInfo(GStrIdx strIdx) const;
   uint32 GetInfo(const std::string &str) const;
-  bool IsAFormal(const MIRSymbol *symbol) const {
-    for (const MIRSymbol *fSymbol : formals) {
-      if (symbol == fSymbol) {
+  bool IsAFormal(const MIRSymbol *st) const {
+    for (MapleVector<FormalDef>::const_iterator it = formalDefVec.begin(); it != formalDefVec.end(); it++) {
+      if (st == it->formalSym) {
         return true;
       }
     }
@@ -361,8 +377,8 @@ class MIRFunction {
   }
 
   uint32 GetFormalIndex(const MIRSymbol *symbol) const {
-    for (size_t i = 0; i < formals.size(); ++i)
-      if (formals[i] == symbol) {
+    for (size_t i = 0; i < formalDefVec.size(); ++i)
+      if (formalDefVec[i].formalSym == symbol) {
         return i;
       }
     return 0xffffffff;
@@ -473,10 +489,7 @@ class MIRFunction {
       labelTab = module->GetMemPool()->New<MIRLabelTable>(module->GetMPAllocator());
     }
   }
-  MIRPregTable *GetPregTab() {
-    return pregTab;
-  }
-  const MIRPregTable *GetPregTab() const {
+  MIRPregTable *GetPregTab() const {
     return pregTab;
   }
   void SetPregTab(MIRPregTable *tab) {
@@ -505,10 +518,10 @@ class MIRFunction {
   }
 
   SrcPosition &GetSrcPosition() {
-    return srcPosition;
+    return GetFuncSymbol()->GetSrcPosition();
   }
-  void SetSrcPosition(const SrcPosition &position) {
-    srcPosition = position;
+  void SetSrcPosition(SrcPosition &position) {
+    GetFuncSymbol()->SetSrcPosition(position);
   }
 
   const FuncAttrs &GetFuncAttrs() const {
@@ -689,32 +702,24 @@ class MIRFunction {
     eacg = eacgVal;
   }
 
-  void SetFormals(const MapleVector<MIRSymbol*> &currFormals) {
-    formals = currFormals;
-  }
-  MIRSymbol *GetFormal(size_t i) {
-    return const_cast<MIRSymbol*>(const_cast<const MIRFunction*>(this)->GetFormal(i));
+  void SetFormalDefVec(const MapleVector<FormalDef> &currFormals) {
+    formalDefVec = currFormals;
   }
-  const MIRSymbol *GetFormal(size_t i) const {
-    ASSERT(i < formals.size(), "array index out of range");
-    return formals[i];
+  MapleVector<FormalDef> &GetFormalDefVec() {
+    return formalDefVec;
   }
-  void SetFormal(size_t index, MIRSymbol *value) {
-    ASSERT(index < formals.size(), "array index out of range");
-    formals[index] = value;
+  MIRSymbol *GetFormal(size_t i) {
+    return formalDefVec[i].formalSym;
   }
   size_t GetFormalCount() const {
-    return formals.size();
-  }
-  void AddFormal(MIRSymbol *formal) {
-    formals.push_back(formal);
+    return formalDefVec.size();
   }
   void ClearFormals() {
-    formals.clear();
+    formalDefVec.clear();
   }
 
   void ClearArguments() {
-    formals.clear();
+    formalDefVec.clear();
     funcType->GetParamTypeList().clear();
     funcType->GetParamAttrsList().clear();
   }
@@ -836,7 +841,7 @@ class MIRFunction {
   TyIdx inferredReturnTyIdx{0};     // the actual return type of of this function (may be a
                                     // subclass of the above). 0 means can not be inferred.
   TyIdx classTyIdx{0};              // class/interface type this function belongs to
-  MapleVector<MIRSymbol*> formals{module->GetMPAllocator().Adapter()};  // formal parameter symbols of this function
+  MapleVector<FormalDef> formalDefVec{module->GetMPAllocator().Adapter()};  // the formals in func definition
   MapleSet<MIRSymbol*> retRefSym{module->GetMPAllocator().Adapter()};
 
   MapleVector<GenericDeclare*> genericDeclare{module->GetMPAllocator().Adapter()};
@@ -852,7 +857,6 @@ class MIRFunction {
   MapleAllocator codeMemPoolAllocator{nullptr};
   uint32 callTimes = 0;
   BlockNode *body = nullptr;
-  SrcPosition srcPosition{};
   FuncAttrs funcAttrs{};
   uint32 flag = 0;
   uint16 hashCode = 0;   // for methodmetadata order
diff --git a/src/mapleall/maple_ir/include/mir_nodes.h b/src/mapleall/maple_ir/include/mir_nodes.h
index b6bfa3f479e40466c7672f28d1f021cfede974e9..cba529ad39813693dd7f390688ec3fd2f37c8bbc 100644
--- a/src/mapleall/maple_ir/include/mir_nodes.h
+++ b/src/mapleall/maple_ir/include/mir_nodes.h
@@ -23,8 +23,8 @@
 #include "mir_module.h"
 #include "mir_const.h"
 #include "maple_string.h"
+#include "src_position.h"
 #include "ptr_list_ref.h"
-#include "global_tables.h"
 
 namespace maple {
 extern MIRModule *theMIRModule;
@@ -529,6 +529,18 @@ class IreadFPoffNode : public BaseNode {
   int32 offset = 0;
 };
 
+class IreadPCoffNode : public IreadFPoffNode {
+  public:
+
+  IreadPCoffNode(Opcode o, PrimType typ, uint8 numopns) {
+    op = o;
+    ptyp = typ;
+    numOpnds = numopns;
+  }
+};
+
+typedef IreadPCoffNode AddroffPCNode;
+
 class BinaryOpnds {
  public:
   virtual ~BinaryOpnds() = default;
@@ -1311,85 +1323,10 @@ class AddroflabelNode : public BaseNode {
   }
 
  private:
-  uint32 offset = 0;
-};
-
-// to store source position information
-class SrcPosition {
- public:
-  SrcPosition() {
-    u.word0 = 0;
-  }
-
-  virtual ~SrcPosition() = default;
-
-  uint32 RawData() const {
-    return u.word0;
-  }
-
-  uint32 FileNum() const {
-    return u.fileColumn.fileNum;
-  }
-
-  uint32 Column() const {
-    return u.fileColumn.column;
-  }
-
-  uint32 LineNum() const {
-    return lineNum;
-  }
-
-  uint32 MplLineNum() const {
-    return mplLineNum;
-  }
-
-  void SetFileNum(uint16 n) {
-    u.fileColumn.fileNum = n;
-  }
-
-  void SetColumn(uint16 n) {
-    u.fileColumn.column = n;
-  }
-
-  void SetLineNum(uint32 n) {
-    lineNum = n;
-  }
-
-  void SetRawData(uint32 n) {
-    u.word0 = n;
-  }
-
-  void SetMplLineNum(uint32 n) {
-    mplLineNum = n;
-  }
-
-  void CondSetLineNum(uint32 n) {
-    lineNum = lineNum ? lineNum : n;
-  }
-
-  void CondSetFileNum(uint16 n) {
-    uint16 i = u.fileColumn.fileNum;
-    u.fileColumn.fileNum = i ? i : n;
-  }
-
- private:
-  union {
-    struct {
-      uint16 fileNum;
-      uint16 column : 12;
-      uint16 stmtBegin : 1;
-      uint16 bbBegin : 1;
-      uint16 unused : 2;
-    } fileColumn;
-
-    uint32 word0;
-  } u;
-
-  uint32 lineNum = 0;     // line number of original src file, like foo.java
-  uint32 mplLineNum = 0;  // line number of mpl file
+  LabelIdx offset = 0;
 };
 
-// for cleanuptry, catch, finally, retsub, endtry, membaracquire, membarrelease,
+// for cleanuptry, jscatch, finally, retsub, endtry, membaracquire, membarrelease,
 // membarstoreload, membarstorestore
 class StmtNode : public BaseNode, public PtrListNodeBase<StmtNode> {
  public:
@@ -1584,7 +1521,7 @@ class GotoNode : public StmtNode {
   uint32 offset = 0;
 };
 
-// try
+// jstry
 class JsTryNode : public StmtNode {
  public:
   JsTryNode() : StmtNode(OP_jstry) {}
@@ -1623,7 +1560,7 @@ class JsTryNode : public StmtNode {
   uint16 finallyOffset = 0;
 };
 
-// try
+// try, cpptry
 class TryNode : public StmtNode {
  public:
   explicit TryNode(MapleAllocator &allocator) : StmtNode(OP_try), offsets(allocator.Adapter()) {}
@@ -1748,6 +1685,32 @@ class CatchNode : public StmtNode {
   MapleVector<TyIdx> exceptionTyIdxVec;
 };
 
+// cppcatch
+class CppCatchNode : public StmtNode {
+ public:
+  explicit CppCatchNode(TyIdx idx) : StmtNode(OP_cppcatch), exceptionTyIdx(idx) {}
+  explicit CppCatchNode() : CppCatchNode(TyIdx(0)) {}
+
+  CppCatchNode(CppCatchNode &node) = delete;
+  CppCatchNode &operator=(const CppCatchNode &node) = delete;
+  ~CppCatchNode() = default;
+
+  void Dump(int32 indent) const override;
+
+  CppCatchNode *CloneTree(MapleAllocator &allocator) const override {
+    CppCatchNode *node = allocator.GetMemPool()->New<CppCatchNode>();
+    node->SetStmtID(stmtIDNext++);
+    node->exceptionTyIdx = exceptionTyIdx;
+    return node;
+  }
+
+  CppCatchNode *CloneTree(MIRModule *mod) const {
+    return CppCatchNode::CloneTree(*mod->CurFuncCodeMemPoolAllocator());
+  }
+ public:
+  TyIdx exceptionTyIdx;
+};
+
 using CasePair = std::pair<int32, LabelIdx>;
 using CaseVector = MapleVector<CasePair>;
 class SwitchNode : public StmtNode {
@@ -1908,7 +1871,7 @@ class MultiwayNode : public StmtNode {
   MCaseVector multiWayTable;
 };
 
-// eval, throw, free, decref, incref, decrefreset, assertnonnull
+// eval, throw, free, decref, incref, decrefreset, assertnonnull, igoto
 class UnaryStmtNode : public StmtNode {
  public:
   explicit UnaryStmtNode(Opcode o) : StmtNode(o, 1) {}
@@ -2649,6 +2612,8 @@ class IassignFPoffNode : public UnaryStmtNode {
   int32 offset = 0;
 };
 
+typedef IassignFPoffNode IassignPCoffNode;
+
 // used by return, syncenter, syncexit
 class NaryStmtNode : public StmtNode, public NaryOpnds {
  public:
@@ -2717,21 +2682,13 @@ class NaryStmtNode : public StmtNode, public NaryOpnds {
   }
 };
 
-class ReturnValuePart {
- public:
-  explicit ReturnValuePart(MapleAllocator &allocator) : returnValues(allocator.Adapter()) {}
-
-  virtual ~ReturnValuePart() = default;
-
- private:
-  CallReturnVector returnValues;
-};
-
 // used by call, virtualcall, virtualicall, superclasscall, interfacecall,
 // interfaceicall, customcall
+// polymorphiccall
 // callassigned, virtualcallassigned, virtualicallassigned,
 // superclasscallassigned, interfacecallassigned, interfaceicallassigned,
 // customcallassigned
+// polymorphiccallassigned
 class CallNode : public NaryStmtNode {
  public:
   CallNode(MapleAllocator &allocator, Opcode o) : NaryStmtNode(allocator, o), returnValues(allocator.Adapter()) {}
@@ -3011,8 +2968,7 @@ class IntrinsiccallNode : public NaryStmtNode {
 };
 
 // used by callinstant, virtualcallinstant, superclasscallinstant and
-// interfacecallinstant
-// for callinstantassigned, virtualcallinstantassigned,
+// interfacecallinstant, callinstantassigned, virtualcallinstantassigned,
 // superclasscallinstantassigned and interfacecallinstantassigned
 class CallinstantNode : public CallNode {
  public:
diff --git a/src/mapleall/maple_ir/include/mir_parser.h b/src/mapleall/maple_ir/include/mir_parser.h
index 97ba01cc44bb01242bec9fa05f9ef0d68f7e0533..b244a02c9bccf4694777d3f55868535f9c9c2012 100644
--- a/src/mapleall/maple_ir/include/mir_parser.h
+++ b/src/mapleall/maple_ir/include/mir_parser.h
@@ -25,6 +25,8 @@ using BaseNodePtr = BaseNode*;
 using StmtNodePtr = StmtNode*;
 using BlockNodePtr = BlockNode*;
 
+class FormalDef;
+
 class MIRParser {
  public:
   explicit MIRParser(MIRModule &md)
@@ -34,15 +36,13 @@ class MIRParser {
 
   ~MIRParser() = default;
 
-  MIRPreg *CreateMirPreg(uint32 pregNo) const;
-  PregIdx LookupOrCreatePregIdx(uint32 pregNo, bool isref, MIRFunction &curfunc);
-  void ResetMaxPregNo(MIRFunction&);
   MIRFunction *CreateDummyFunction();
   void ResetCurrentFunction() {
     mod.SetCurFunction(dummyFunction);
   }
 
-  bool ParseLoc(StmtNodePtr &stmt);
+  bool ParseLoc();
+  bool ParseLocStmt(StmtNodePtr &stmt);
   bool ParseAlias(StmtNodePtr &stmt);
   uint8 *ParseWordsInfo(uint32 size);
   bool ParseSwitchCase(int32&, LabelIdx&);
@@ -88,13 +88,13 @@ class MIRParser {
   bool ParseStatement(StmtNodePtr &stmt);
   bool ParseSpecialReg(PregIdx &pregIdx);
   bool ParsePseudoReg(PrimType pty, PregIdx &pregIdx);
-  bool ParseRefPseudoReg(PregIdx&);
   bool ParseStmtBlock(BlockNodePtr &blk);
   bool ParsePrototype(MIRFunction &fn, MIRSymbol &funcSt, TyIdx &funcTyIdx);
   bool ParseFunction(uint32 fileIdx = 0);
   bool ParseStorageClass(MIRSymbol &st) const;
   bool ParseDeclareVar(MIRSymbol&);
   bool ParseDeclareReg(MIRSymbol&, MIRFunction&);
+  bool ParseDeclareFormal(FormalDef *);
   bool ParsePrototypeRemaining(MIRFunction&, std::vector<TyIdx> &, std::vector<TypeAttrs>&, bool&);
 
   // Stmt Parser
@@ -260,7 +260,7 @@ class MIRParser {
   bool ParseStmtBlockForFuncInfo();
 
   // common func
-  void SetSrcPos(StmtNodePtr stmt, uint32 mplNum);
+  void SetSrcPos(SrcPosition &srcPosition, uint32 mplNum);
 
   // func for ParseExpr
   Opcode paramOpForStmt = OP_undef;
@@ -279,7 +279,6 @@ class MIRParser {
   uint32 lastLineNum = 0;                    // to remember second number after LOC
   uint32 firstLineNum = 0;                   // to track function starting line
   std::map<TyIdx, TyIdx> typeDefIdxMap;      // map previous declared tyIdx
-  uint32 maxPregNo = 0;                      // max pregNo seen so far in current function
   bool firstImport = true;                   // Mark the first imported mplt file
   bool paramParseLocalType = false;          // param for ParseTypedef
   uint32 paramFileIdx = 0;                   // param for ParseMIR()
diff --git a/src/mapleall/maple_ir/include/mir_preg.h b/src/mapleall/maple_ir/include/mir_preg.h
index cf8530386b9366b81ea939ebf1712e79f947701f..cd8e7cc4eaab62ff3a1b22a295343be79cd18804 100644
--- a/src/mapleall/maple_ir/include/mir_preg.h
+++ b/src/mapleall/maple_ir/include/mir_preg.h
@@ -21,6 +21,8 @@
 #endif  // MIR_FEATURE_FULL
 
 namespace maple {
+extern void PrintIndentation(int32 );
+
 // these special registers are encoded by negating the enumeration
 enum SpecialReg : signed int {
   kSregSp = 1,
@@ -29,14 +31,17 @@ enum SpecialReg : signed int {
   kSregThrownval = 4,
   kSregMethodhdl = 5,
   kSregRetval0 = 6,
-  kSregLast = 7,
+  kSregRetval1 = 7,
+  kSregLast = 8,
 };
 #if MIR_FEATURE_FULL
 class MIRPreg {
  public:
-  explicit MIRPreg(uint32 n = 0) : MIRPreg(n, nullptr) {}
+  explicit MIRPreg(uint32 n = 0) : MIRPreg(n, kPtyInvalid, nullptr) {}
+
+  MIRPreg(uint32 n, PrimType ptyp) : primType(ptyp), pregNo(n) {}
 
-  MIRPreg(uint32 n, MIRType *mType) : pregNo(n), mirType(mType) {}
+  MIRPreg(uint32 n, PrimType ptyp, MIRType *mType) : primType(ptyp), pregNo(n), mirType(mType) {}
 
   ~MIRPreg() = default;
   void SetNeedRC(bool needRC = true) {
@@ -48,11 +53,7 @@ class MIRPreg {
   }
 
   bool IsRef() const {
-    return isRef;
-  }
-
-  void SetIsRef(bool isRef) {
-    this->isRef = isRef;
+    return mirType != nullptr && primType == PTY_ref;
   }
 
   PrimType GetPrimType() const {
@@ -81,7 +82,6 @@ class MIRPreg {
 
  private:
   PrimType primType = kPtyInvalid;
-  bool isRef = false;
   bool needRC = false;
   int32 pregNo;  // the number in maple IR after the %
   MIRType *mirType;
@@ -89,11 +89,9 @@ class MIRPreg {
 
 class MIRPregTable {
  public:
-  static constexpr uint32 kMaxUserPregIndex = 10000;
   MIRPregTable(MIRModule *mod, MapleAllocator *allocator)
       : pregNoToPregIdxMap(allocator->Adapter()),
         pregTable(allocator->Adapter()),
-        module(mod),
         mAllocator(allocator) {
     pregTable.push_back(nullptr);
     specPregTable[0].SetPregNo(0);
@@ -103,6 +101,7 @@ class MIRPregTable {
     specPregTable[kSregThrownval].SetPregNo(-kSregThrownval);
     specPregTable[kSregMethodhdl].SetPregNo(-kSregMethodhdl);
     specPregTable[kSregRetval0].SetPregNo(-kSregRetval0);
+    specPregTable[kSregRetval1].SetPregNo(-kSregRetval1);
     for (uint32 i = 0; i < kSregLast; ++i) {
       specPregTable[i].SetPrimType(PTY_unknown);
     }
@@ -110,44 +109,26 @@ class MIRPregTable {
 
   ~MIRPregTable();
 
-  PregIdx CreatePreg(PrimType primType) {
-    uint32 index = pregIndex++;
-    MIRPreg *preg = mAllocator->GetMemPool()->New<MIRPreg>(index);
-    preg->SetPrimType(primType);
-    PregIdx idx = static_cast<PregIdx>(pregTable.size());
-    ASSERT(idx < USHRT_MAX, "will has problem if over 16 bits");
-    pregTable.push_back(preg);
-    pregNoToPregIdxMap[index] = idx;
-    pregTable[idx]->SetMIRType(GlobalTables::GetTypeTable().GetPrimType(primType));
-    return idx;
+  PregIdx CreatePreg(PrimType primType, MIRType *mtype = nullptr) {
+    ASSERT(!mtype || mtype->GetPrimType() == PTY_ref || mtype->GetPrimType() == PTY_ptr, "ref or ptr type");
+    uint32 index = ++maxPregNo;
+    MIRPreg *preg = mAllocator->GetMemPool()->New<MIRPreg>(index, primType, mtype);
+    return AddPreg(preg);
   }
 
-  PregIdx CreateRefPreg(MIRType &mirType) {
-    ASSERT(mirType.GetPrimType() == PTY_ref, "only ref type needed");
-    PregIdx idx = CreatePreg(mirType.GetPrimType());
-    pregTable[idx]->SetMIRType(&mirType);
-    return idx;
-  }
-
-  PregIdx CreateRefPreg(MIRPreg &mirPreg) {
-    uint32 index = pregIndex++;
-    MIRPreg *preg = mAllocator->GetMemPool()->New<MIRPreg>(index, mirPreg.GetMIRType());
-    preg->SetPrimType(mirPreg.GetPrimType());
-    preg->SetMIRType(mirPreg.GetMIRType());
-    preg->SetNeedRC(mirPreg.NeedRC());
-    PregIdx idx = static_cast<PregIdx>(pregTable.size());
-    ASSERT(idx < USHRT_MAX, "will has problem if over 16 bits");
-    pregTable.push_back(preg);
-    pregNoToPregIdxMap[index] = idx;
+  PregIdx ClonePreg(MIRPreg *rfpreg) {
+    PregIdx idx = CreatePreg(rfpreg->GetPrimType(), rfpreg->GetMIRType());
+    MIRPreg *preg = pregTable[idx];
+    preg->SetNeedRC(rfpreg->NeedRC());
     return idx;
   }
 
-  MIRPreg *PregFromPregIdx(PregIdx pregIdx) {
-    return const_cast<MIRPreg*>(const_cast<const MIRPregTable*>(this)->PregFromPregIdx(pregIdx));
-  }
-  const MIRPreg *PregFromPregIdx(PregIdx pregIdx) const {
-    // pregIdx < 0 denotes special register
-    return (pregIdx < 0) ? &specPregTable[-pregIdx] : pregTable.at(pregIdx);
+  MIRPreg *PregFromPregIdx(PregIdx pregidx) {
+    if (pregidx < 0) {  // special register
+      return &specPregTable[-pregidx];
+    } else {
+      return pregTable.at(pregidx);
+    }
   }
 
   PregIdx GetPregIdxFromPregno(uint32 pregNo) {
@@ -155,17 +136,46 @@ class MIRPregTable {
     return (it == pregNoToPregIdxMap.end()) ? PregIdx(0) : it->second;
   }
 
-  void DumpRef(int32);
+  void DumpPregsWithTypes(int32 indent) {
+    MapleVector<MIRPreg *> &pregtable = pregTable;
+    for (uint32 i = 1; i < pregtable.size(); i++) {
+      MIRPreg *mirpreg = pregtable[i];
+      if (mirpreg->GetMIRType() == nullptr) {
+        continue;
+      }
+      PrintIndentation(indent);
+      LogInfo::MapleLogger() << "reg ";
+      LogInfo::MapleLogger() << "%" << mirpreg->GetPregNo();
+      LogInfo::MapleLogger() << " ";
+      mirpreg->GetMIRType()->Dump(0);
+      LogInfo::MapleLogger() << " " << (mirpreg->NeedRC() ? 1 : 0);
+      LogInfo::MapleLogger() << "\n";
+    }
+  }
+
   size_t Size() const {
     return pregTable.size();
   }
 
-  void AddPreg(MIRPreg *preg) {
+  PregIdx AddPreg(MIRPreg *preg) {
     CHECK_FATAL(preg != nullptr, "invalid nullptr in AddPreg");
     PregIdx idx = static_cast<PregIdx>(pregTable.size());
     pregTable.push_back(preg);
     ASSERT(pregNoToPregIdxMap.find(preg->GetPregNo()) == pregNoToPregIdxMap.end(), "The same pregno is already taken");
     pregNoToPregIdxMap[preg->GetPregNo()] = idx;
+    return idx;
+  }
+
+  PregIdx EnterPregNo(uint32 pregNo, PrimType ptyp, MIRType *ty = nullptr) {
+    PregIdx idx = GetPregIdxFromPregno(pregNo);
+    if (idx == 0) {
+      if (pregNo > maxPregNo) {
+        maxPregNo = pregNo;
+      }
+      MIRPreg *preg = mAllocator->GetMemPool()->New<MIRPreg>(pregNo, ptyp, ty);
+      return AddPreg(preg);
+    }
+    return idx;
   }
 
   MapleVector<MIRPreg*> &GetPregTable() {
@@ -185,20 +195,19 @@ class MIRPregTable {
     pregNoToPregIdxMap[key] = value;
   }
 
-  uint32 GetIndex() const {
-    return pregIndex;
+  uint32 GetMaxPregNo() const {
+    return maxPregNo;
   }
 
-  void SetIndex(uint32 index) {
-    pregIndex = index;
+  void SetMaxPregNo(uint32 index) {
+    maxPregNo = index;
   }
 
  private:
-  uint32 pregIndex = kMaxUserPregIndex;          // user(maple_ir)'s preg must less than this value
+  uint32 maxPregNo = 0;  //  the max pregNo that has been allocated
   MapleMap<uint32, PregIdx> pregNoToPregIdxMap;  // for quick lookup based on pregno
   MapleVector<MIRPreg*> pregTable;
   MIRPreg specPregTable[kSregLast];  // for the MIRPreg nodes corresponding to special registers
-  MIRModule *module;
   MapleAllocator *mAllocator;
 };
 
diff --git a/src/mapleall/maple_ir/include/mir_symbol.h b/src/mapleall/maple_ir/include/mir_symbol.h
index 4efba6752c51f8fafafc9c8335544f9e59b0130c..a43666031dc335f4605598796ca6b6a3f381d175 100644
--- a/src/mapleall/maple_ir/include/mir_symbol.h
+++ b/src/mapleall/maple_ir/include/mir_symbol.h
@@ -17,7 +17,7 @@
 #include <sstream>
 #include "mir_const.h"
 #include "mir_preg.h"
-#include "global_tables.h"
+#include "src_position.h"
 
 constexpr int kScopeLocal = 2;   // the default scope level for function variables
 constexpr int kScopeGlobal = 1;  // the scope level for global variables
@@ -46,6 +46,7 @@ enum MIRStorageClass : uint8 {
   kScTypeInfo,      // used for eh type st
   kScTypeInfoName,  // used for eh type st name
   kScTypeCxxAbi,    // used for eh inherited from c++ __cxxabiv1
+  kScEHRegionSupp,  // used for tables that control C++ exception handling
   kScUnused
 };
 
@@ -125,6 +126,14 @@ class MIRSymbol {
     return isTmpUnused;
   }
 
+  void SetAppearsInCode(bool appears) {
+    appearsInCode = appears;
+  }
+
+  bool GetAppearsInCode() const {
+    return appearsInCode;
+  }
+
   void SetTyIdx(TyIdx tyIdx) {
     this->tyIdx = tyIdx;
   }
@@ -298,6 +307,14 @@ class MIRSymbol {
     this->value = value;
   }
 
+  SrcPosition &GetSrcPosition() {
+    return srcPosition;
+  }
+
+  void SetSrcPosition(SrcPosition &position) {
+    srcPosition = position;
+  }
+
   MIRPreg *GetPreg() {
     ASSERT(IsPreg(), "must be Preg");
     return value.preg;
@@ -417,13 +434,17 @@ class MIRSymbol {
   bool isImported = false;
   bool isImportedDecl = false;
   bool isTmpUnused = false;  // when parse the mplt_inline file, mark all the new symbol as tmpunused
+  bool appearsInCode = false;  // only used for kStFunc
   StIdx stIdx { 0, 0 };
   TypeAttrs typeAttrs;
   GStrIdx nameStrIdx{ 0 };
   SymbolType value = { nullptr };
+  SrcPosition srcPosition;      // where the symbol is defined
   static GStrIdx reflectClassNameIdx;
   static GStrIdx reflectMethodNameIdx;
   static GStrIdx reflectFieldNameIdx;
+ public:
+  static uint32 lastPrintedLineNum;     // used during printing ascii output
 };
 
 class MIRSymbolTable {
@@ -510,7 +531,8 @@ class MIRLabelTable {
   explicit MIRLabelTable(MapleAllocator &allocator)
       : mAllocator(allocator),
         strIdxToLabIdxMap(std::less<GStrIdx>(), mAllocator.Adapter()),
-        labelTable(mAllocator.Adapter()) {
+        labelTable(mAllocator.Adapter()),
+        addrTakenLabels(mAllocator.Adapter()) {
     labelTable.push_back(GStrIdx(kDummyLabel));  // push dummy label index 0
   }
 
@@ -580,6 +602,7 @@ class MIRLabelTable {
   MapleAllocator mAllocator;
   MapleMap<GStrIdx, LabelIdx> strIdxToLabIdxMap;
   MapleVector<GStrIdx> labelTable;  // map label idx to label name
+  MapleUnorderedSet<LabelIdx> addrTakenLabels; // those appeared in addroflabel or MIRLblConst
 };
 }  // namespace maple
 #endif  // MAPLE_IR_INCLUDE_MIR_SYMBOL_H
diff --git a/src/mapleall/maple_ir/include/mir_type.h b/src/mapleall/maple_ir/include/mir_type.h
index 53c324fc74e76a71ec7ca03ec366a6ec7c34b2f4..dad4cf9fcd1fac296d23989f8c51ccbf5722078b 100755
--- a/src/mapleall/maple_ir/include/mir_type.h
+++ b/src/mapleall/maple_ir/include/mir_type.h
@@ -19,12 +19,14 @@
 #include "prim_types.h"
 #include "mir_pragma.h"
 #include "mpl_logging.h"
-#include "safe_cast.h"
 #if MIR_FEATURE_FULL
 #include "mempool.h"
 #include "mempool_allocator.h"
 #endif  // MIR_FEATURE_FULL
 
+#define POINTER_SIZE 8
+#define POINTER_P2SIZE 3
+
 namespace maple {
 constexpr int kTypeHashLength = 12289;  // hash length for mirtype, ref: planetmath.org/goodhashtableprimes
 
@@ -40,8 +42,10 @@ const std::string kJstrTypeName = "constStr";
 extern bool VerifyPrimType(PrimType primType1, PrimType primType2);       // verify if primType1 and primType2 match
 extern uint32 GetPrimTypeSize(PrimType primType);                         // answer in bytes; 0 if unknown
 extern uint32 GetPrimTypeP2Size(PrimType primType);                       // answer in bytes in power-of-two.
+extern const PrimType GetSignedPrimType(PrimType pty);                    // return signed version
 extern const char *GetPrimTypeName(PrimType primType);
 extern const char *GetPrimTypeJavaName(PrimType primType);
+
 inline uint32 GetPrimTypeBitSize(PrimType primType) {
   // 1 byte = 8 bits = 2^3 bits
   return GetPrimTypeSize(primType) << 3;
@@ -659,6 +663,7 @@ class MIRArrayType : public MIRType {
       CHECK_FATAL(i < kMaxArrayDim, "array index out of range");
       hIdx += (sizeArray[i] << i);
     }
+    hIdx += (typeAttrs.GetAttrFlag() << 3) + typeAttrs.GetAlignValue();
     return hIdx % kTypeHashLength;
   }
 
@@ -668,6 +673,7 @@ class MIRArrayType : public MIRType {
   TyIdx eTyIdx{ 0 };
   uint16 dim = 0;
   std::array<uint32, kMaxArrayDim> sizeArray{ {0} };
+  TypeAttrs typeAttrs;
 };
 
 // flexible array type, must be last field of a top-level struct
@@ -1074,6 +1080,7 @@ class MIRStructType : public MIRType {
   // Weak indicates the actual definition is in another module.
   bool isImported = false;
   bool isUsed = false;
+  bool isCPlusPlus = false;        // empty struct in C++ has size 1 byte
   mutable bool hasVolatileField = false;     // for caching computed value
   mutable bool hasVolatileFieldSet = false;  // if true, just read hasVolatileField;
                                              // otherwise compute to initialize hasVolatileField
diff --git a/src/mapleall/maple_ir/include/opcodes.def b/src/mapleall/maple_ir/include/opcodes.def
index 5ea724410ec552993dd8e0a068516fd0f30364e4..9ae6410bbd7fdb77255c9629ea987230649444b1 100644
--- a/src/mapleall/maple_ir/include/opcodes.def
+++ b/src/mapleall/maple_ir/include/opcodes.def
@@ -93,10 +93,13 @@
   // exception handling
   OPCODE(jstry, JsTryNode, OPCODEISSTMT, 8)
   OPCODE(try, TryNode, (OPCODEISSTMT | OPCODENOTMMPL), 8)
+  OPCODE(cpptry, TryNode, (OPCODEISSTMT | OPCODENOTMMPL), 8)
 
   OPCODE(throw, UnaryStmtNode, (OPCODEISSTMT | OPCODEHASSSAUSE), 0)
-  OPCODE(jscatch, BaseNode, OPCODEISSTMT, 4)
+
+  OPCODE(jscatch, StmtNode, OPCODEISSTMT, 4)
   OPCODE(catch, CatchNode, OPCODEISSTMT, 8)
+  OPCODE(cppcatch, CppCatchNode, OPCODEISSTMT, 8)
 
   OPCODE(finally, StmtNode, OPCODEISSTMT, 6)
   OPCODE(cleanuptry, StmtNode, OPCODEISSTMT, 6)
@@ -147,8 +150,10 @@
   OPCODE(malloc, UnaryNode, OPCODENOTPURE, 0)
   OPCODE(gcmalloc, GCMallocNode, OPCODENOTPURE, 8)
   OPCODE(gcpermalloc, GCMallocNode, OPCODENOTPURE, 8)
+  OPCODE(stackmalloc, GCMallocNode, OPCODENOTPURE, 8)
   OPCODE(gcmallocjarray, JarrayMallocNode, OPCODENOTPURE, 12)
   OPCODE(gcpermallocjarray, JarrayMallocNode, OPCODENOTPURE, 12)
+  OPCODE(stackmallocjarray, JarrayMallocNode, OPCODENOTPURE, 12)
   OPCODE(resolveinterfacefunc, ResolveFuncNode, 0, 8)
   OPCODE(resolvevirtualfunc, ResolveFuncNode, 0, 8)
   // binary expression opcodes
@@ -187,3 +192,11 @@
   // Other expression opcodes
   OPCODE(extractbits, ExtractbitsNode, 0, 8)
   OPCODE(depositbits, DepositbitsNode, 0, 8)
+  // storage access
+  OPCODE(iassignpcoff, IassignPCoffNode, OPCODEISSTMT, 0)
+  OPCODE(ireadpcoff, IreadPCoffNode, 0, 0)
+  // barrier
+  OPCODE(checkpoint, StmtNode, OPCODEISSTMT, 0)
+  // leaf node
+  OPCODE(addroffpc, AddroffPCNode, 0, 0)
+  OPCODE(igoto, UnaryStmtNode, OPCODEISSTMT, 0)
diff --git a/src/mapleall/maple_ir/include/src_position.h b/src/mapleall/maple_ir/include/src_position.h
new file mode 100644
index 0000000000000000000000000000000000000000..2573182aefd9c4e8bff23bf48d10b50a33a4a75e
--- /dev/null
+++ b/src/mapleall/maple_ir/include/src_position.h
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) [2020] Huawei Technologies Co., Ltd. All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan Permissive Software License v2.
+ * You can use this software according to the terms and conditions of the MulanPSL - 2.0.
+ * You may obtain a copy of MulanPSL - 2.0 at:
+ *
+ *   https://opensource.org/licenses/MulanPSL-2.0
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the MulanPSL - 2.0 for more details.
+ */
+
+#ifndef MAPLE_IR_INCLUDE_SRC_POSITION_H
+#define MAPLE_IR_INCLUDE_SRC_POSITION_H
+
+namespace maple {
+
+// to store source position information
+class SrcPosition {
+ private:
+  union {
+    struct {
+      uint16 fileNum;
+      uint16 column : 12;
+      uint16 stmtBegin : 1;
+      uint16 bbBegin : 1;
+      uint16 unused : 2;
+    } fileColumn;
+    uint32 word0;
+  } u;
+  uint32 lineNum;     // line number of original src file, like foo.java
+  uint32 mplLineNum;  // line number of mpl file
+ public:
+  SrcPosition() : lineNum(0), mplLineNum(0) {
+    u.word0 = 0;
+  }
+
+  virtual ~SrcPosition() = default;
+
+  uint32 RawData() const {
+    return u.word0;
+  }
+
+  uint32 FileNum() const {
+    return u.fileColumn.fileNum;
+  }
+
+  uint32 Column() const {
+    return u.fileColumn.column;
+  }
+
+  uint32 LineNum() const {
+    return lineNum;
+  }
+
+  uint32 MplLineNum() const {
+    return mplLineNum;
+  }
+
+  void SetFileNum(int n) {
+    u.fileColumn.fileNum = n;
+  }
+
+  void SetColumn(int n) {
+    u.fileColumn.column = n;
+  }
+
+  void SetLineNum(int n) {
+    lineNum = n;
+  }
+
+  void SetRawData(uint32 n) {
+    u.word0 = n;
+  }
+
+  void SetMplLineNum(int n) {
+    mplLineNum = n;
+  }
+
+  void CondSetLineNum(int n) {
+    lineNum = lineNum ? lineNum : n;
+  }
+
+  void CondSetFileNum(int n) {
+    uint32 i = u.fileColumn.fileNum;
+    u.fileColumn.fileNum = i ? i : n;
+  }
+};
+}  // namespace maple
+#endif  // MAPLE_IR_INCLUDE_SRC_POSITION_H
+
diff --git a/src/mapleall/maple_ir/src/bin_mpl_import.cpp b/src/mapleall/maple_ir/src/bin_mpl_import.cpp
index 37a6c0fa544f88d16ea55bfd6bd176d704c1f811..0b554d3c16fa024e76c141f4e5f612e0f7d4988f 100755
--- a/src/mapleall/maple_ir/src/bin_mpl_import.cpp
+++ b/src/mapleall/maple_ir/src/bin_mpl_import.cpp
@@ -303,7 +303,6 @@ void BinaryMplImport::ImportMethodPair(MethodPair &memPool) {
     methodSymbols.push_back(funcSt);
 
     fn = mod.GetMemPool()->New<MIRFunction>(&mod, funcSt->GetStIdx());
-    fn->Init();
     fn->SetPuidx(GlobalTables::GetFunctionTable().GetFuncTable().size());
     GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn);
     funcSt->SetFunction(fn);
diff --git a/src/mapleall/maple_ir/src/mir_builder.cpp b/src/mapleall/maple_ir/src/mir_builder.cpp
index f2dfedf6e2f0ee16c6ab2f43b1376408dbfcda65..c2be5689e54960100c69232081f3f15b9b01b961 100644
--- a/src/mapleall/maple_ir/src/mir_builder.cpp
+++ b/src/mapleall/maple_ir/src/mir_builder.cpp
@@ -226,10 +226,9 @@ MIRFunction *MIRBuilder::GetOrCreateFunction(const std::string &str, TyIdx retTy
     strIdx = GetOrCreateStringIndex(str);
     funcSt = CreateSymbol(TyIdx(0), strIdx, kStFunc, kScText, nullptr, kScopeGlobal);
   }
-  auto *fn = mirModule->GetMemPool()->New<MIRFunction>(mirModule, funcSt->GetStIdx());
-  fn->Init();
+  MIRFunction *fn = mirModule->GetMemPool()->New<MIRFunction>(mirModule, funcSt->GetStIdx());
   fn->SetPuidx(GlobalTables::GetFunctionTable().GetFuncTable().size());
-  auto *funcType = mirModule->GetMemPool()->New<MIRFuncType>(mirModule->GetMPAllocator());
+  MIRFuncType *funcType = mirModule->GetMemPool()->New<MIRFuncType>(mirModule->GetMPAllocator());
   fn->SetMIRFuncType(funcType);
   fn->SetReturnTyIdx(retTyIdx);
   GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn);
@@ -264,22 +263,19 @@ MIRFunction *MIRBuilder::CreateFunction(const std::string &name, const MIRType &
   funcSymbol->SetStorageClass(kScText);
   funcSymbol->SetSKind(kStFunc);
   auto *fn = mirModule->GetMemPool()->New<MIRFunction>(mirModule, funcSymbol->GetStIdx());
-  fn->Init();
   fn->SetPuidx(GlobalTables::GetFunctionTable().GetFuncTable().size());
   GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn);
   std::vector<TyIdx> funcVecType;
   std::vector<TypeAttrs> funcVecAttrs;
   for (size_t i = 0; i < arguments.size(); ++i) {
-    MIRSymbol *argSymbol = fn->GetSymTab()->CreateSymbol(kScopeLocal);
-    argSymbol->SetNameStrIdx(GetOrCreateStringIndex(arguments[i].first));
     MIRType *ty = arguments[i].second;
-    argSymbol->SetTyIdx(ty->GetTypeIndex());
-    argSymbol->SetStorageClass(kScFormal);
-    argSymbol->SetSKind(kStVar);
-    (void)fn->GetSymTab()->AddToStringSymbolMap(*argSymbol);
-    fn->AddFormal(argSymbol);
+    FormalDef formalDef(GetOrCreateStringIndex(arguments[i].first.c_str()), nullptr, ty->GetTypeIndex(), TypeAttrs());
+    fn->GetFormalDefVec().push_back(formalDef);
     funcVecType.push_back(ty->GetTypeIndex());
     funcVecAttrs.push_back(TypeAttrs());
+    if (fn->GetSymTab() != nullptr && formalDef.formalSym != nullptr) {
+      (void)fn->GetSymTab()->AddToStringSymbolMap(*formalDef.formalSym);
+    }
   }
   funcSymbol->SetTyIdx(GlobalTables::GetTypeTable().GetOrCreateFunctionType(
       *mirModule, returnType.GetTypeIndex(), funcVecType, funcVecAttrs, isVarg)->GetTypeIndex());
@@ -294,7 +290,6 @@ MIRFunction *MIRBuilder::CreateFunction(const std::string &name, const MIRType &
 
 MIRFunction *MIRBuilder::CreateFunction(StIdx stIdx, bool addToTable) const {
   auto *fn = mirModule->GetMemPool()->New<MIRFunction>(mirModule, stIdx);
-  fn->Init();
   fn->SetPuidx(GlobalTables::GetFunctionTable().GetFuncTable().size());
   if (addToTable) {
     GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn);
diff --git a/src/mapleall/maple_ir/src/mir_const.cpp b/src/mapleall/maple_ir/src/mir_const.cpp
index 2cf7693ad5c012448598b5ef715fc0500e0de771..f9ebe058635bedd12b789f7b40a10612e9942009 100644
--- a/src/mapleall/maple_ir/src/mir_const.cpp
+++ b/src/mapleall/maple_ir/src/mir_const.cpp
@@ -21,14 +21,14 @@
 #if MIR_FEATURE_FULL
 
 namespace maple {
-void MIRConst::Dump() const {
+void MIRConst::Dump(const MIRSymbolTable *localsymtab) const {
   if (fieldID) {
     LogInfo::MapleLogger() << fieldID << "= ";
   }
 }
 
-void MIRIntConst::Dump() const {
-  MIRConst::Dump();
+void MIRIntConst::Dump(const MIRSymbolTable *localsymtab) const {
+  MIRConst::Dump(localsymtab);
   constexpr int64 valThreshold = 1024;
   if (value <= valThreshold) {
     LogInfo::MapleLogger() << value;
@@ -87,15 +87,20 @@ int64 MIRIntConst::GetValueUnderType() const {
   return static_cast<int64>((unsignedVal << shiftBitNum) >> shiftBitNum);
 }
 
-void MIRAddrofConst::Dump() const {
-  MIRConst::Dump();
+void MIRAddrofConst::Dump(const MIRSymbolTable *localsymtab) const {
+  MIRConst::Dump(localsymtab);
   LogInfo::MapleLogger() << "addrof " << GetPrimTypeName(PTY_ptr);
-  ASSERT(stIdx.IsGlobal(), "MIRAddrofConst can only point to a global symbol");
-  MIRSymbol *sym = GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx());
-  LogInfo::MapleLogger() << " $" << sym->GetName();
+  const MIRSymbol *sym = stIdx.IsGlobal() ? GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx())
+                        : localsymtab->GetSymbolFromStIdx(stIdx.Idx());
+  ASSERT(stIdx.IsGlobal() || sym->GetStorageClass() == kScPstatic || sym->GetStorageClass() == kScFstatic,
+              "MIRAddrofConst can only point to a global symbol");
+  LogInfo::MapleLogger() << (stIdx.IsGlobal() ? " $" : " %") << sym->GetName();
   if (fldID > 0) {
     LogInfo::MapleLogger() << " " << fldID;
   }
+  if (offset != 0) {
+    LogInfo::MapleLogger() << " (" << offset << ")";
+  }
 }
 
 bool MIRAddrofConst::operator==(const MIRConst &rhs) const {
@@ -112,8 +117,8 @@ bool MIRAddrofConst::operator==(const MIRConst &rhs) const {
   return (stIdx == rhsA.stIdx) && (fldID == rhsA.fldID);
 }
 
-void MIRAddroffuncConst::Dump() const {
-  MIRConst::Dump();
+void MIRAddroffuncConst::Dump(const MIRSymbolTable *localsymtab) const {
+  MIRConst::Dump(localsymtab);
   LogInfo::MapleLogger() << "addroffunc " << GetPrimTypeName(PTY_ptr);
   MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
   LogInfo::MapleLogger() << " &" << GlobalTables::GetGsymTable().GetSymbolFromStidx(func->GetStIdx().Idx())->GetName();
@@ -130,6 +135,13 @@ bool MIRAddroffuncConst::operator==(const MIRConst &rhs) const {
   return (&GetType() == &rhs.GetType()) && (puIdx == rhsAf.puIdx);
 }
 
+void MIRLblConst::Dump(const MIRSymbolTable *localsymtab) const {
+  MIRConst::Dump(localsymtab);
+  LogInfo::MapleLogger() << "addroflabel " << GetPrimTypeName(PTY_ptr);
+  MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+  LogInfo::MapleLogger() << " @" << func->GetLabelName(value);
+}
+
 bool MIRLblConst::operator==(const MIRConst &rhs) const {
   if (&rhs == this) {
     return true;
@@ -208,19 +220,19 @@ bool MIRAggConst::operator==(const MIRConst &rhs) const {
   return true;
 }
 
-void MIRFloatConst::Dump() const {
-  MIRConst::Dump();
+void MIRFloatConst::Dump(const MIRSymbolTable *localsymtab) const {
+  MIRConst::Dump(localsymtab);
   LogInfo::MapleLogger() << std::setprecision(std::numeric_limits<float>::max_digits10) << value.floatValue << "f";
 }
 
-void MIRDoubleConst::Dump() const {
-  MIRConst::Dump();
+void MIRDoubleConst::Dump(const MIRSymbolTable *localsymtab) const {
+  MIRConst::Dump(localsymtab);
   LogInfo::MapleLogger() << std::setprecision(std::numeric_limits<double>::max_digits10) << value.dValue;
 }
 
-void MIRFloat128Const::Dump() const {
+void MIRFloat128Const::Dump(const MIRSymbolTable *localsymtab) const {
   constexpr int fieldWidth = 16;
-  MIRConst::Dump();
+  MIRConst::Dump(localsymtab);
   std::ios::fmtflags f(LogInfo::MapleLogger().flags());
   LogInfo::MapleLogger().setf(std::ios::uppercase);
   LogInfo::MapleLogger() << "0xL" << std::hex << std::setfill('0') << std::setw(fieldWidth) << value[0]
@@ -228,12 +240,12 @@ void MIRFloat128Const::Dump() const {
   LogInfo::MapleLogger().flags(f);
 }
 
-void MIRAggConst::Dump() const {
-  MIRConst::Dump();
+void MIRAggConst::Dump(const MIRSymbolTable *localsymtab) const {
+  MIRConst::Dump(localsymtab);
   LogInfo::MapleLogger() << "[";
   size_t size = constVec.size();
   for (size_t i = 0; i < size; ++i) {
-    constVec[i]->Dump();
+    constVec[i]->Dump(localsymtab);
     if (i != size - 1) {
       LogInfo::MapleLogger() << ", ";
     }
@@ -241,11 +253,11 @@ void MIRAggConst::Dump() const {
   LogInfo::MapleLogger() << "]";
 }
 
-MIRStrConst::MIRStrConst(const std::string &str, MIRType &type)
-    : MIRConst(type, kConstStrConst), value(GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(str)) {}
+MIRStrConst::MIRStrConst(const std::string &str, MIRType &type, uint32 fieldID)
+    : MIRConst(type, kConstStrConst, fieldID), value(GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(str)) {}
 
-void MIRStrConst::Dump() const {
-  MIRConst::Dump();
+void MIRStrConst::Dump(const MIRSymbolTable *localsymtab) const {
+  MIRConst::Dump(localsymtab);
   LogInfo::MapleLogger() << "conststr " << GetPrimTypeName(GetType().GetPrimType());
   const std::string &dumpStr = GlobalTables::GetUStrTable().GetStringFromStrIdx(value);
   PrintString(dumpStr);
@@ -262,11 +274,11 @@ bool MIRStrConst::operator==(const MIRConst &rhs) const {
   return (&rhs.GetType() == &GetType()) && (value == rhsCs.value);
 }
 
-MIRStr16Const::MIRStr16Const(const std::u16string &str, MIRType &type)
-    : MIRConst(type, kConstStr16Const), value(GlobalTables::GetU16StrTable().GetOrCreateStrIdxFromName(str)) {}
+MIRStr16Const::MIRStr16Const(const std::u16string &str, MIRType &type, uint32 fieldID)
+    : MIRConst(type, kConstStr16Const, fieldID), value(GlobalTables::GetU16StrTable().GetOrCreateStrIdxFromName(str)) {}
 
-void MIRStr16Const::Dump() const {
-  MIRConst::Dump();
+void MIRStr16Const::Dump(const MIRSymbolTable *localsymtab) const {
+  MIRConst::Dump(localsymtab);
   LogInfo::MapleLogger() << "conststr16 " << GetPrimTypeName(GetType().GetPrimType());
   std::u16string str16 = GlobalTables::GetU16StrTable().GetStringFromStrIdx(value);
   // UTF-16 string are dumped as UTF-8 string in mpl to keep the printable chars in ascii form
diff --git a/src/mapleall/maple_ir/src/mir_function.cpp b/src/mapleall/maple_ir/src/mir_function.cpp
index 76bb6cbaaa60c0f01cd267ca56c3146abdb1cd4d..56bbeb1f02db6b34ec1b37ec4e4cc5adbe2aaaba 100644
--- a/src/mapleall/maple_ir/src/mir_function.cpp
+++ b/src/mapleall/maple_ir/src/mir_function.cpp
@@ -34,13 +34,6 @@ enum FuncProp : uint32_t {
 }  // namespace
 
 namespace maple {
-void MIRFunction::Init() {
-  symTab = module->GetMemPool()->New<MIRSymbolTable>(module->GetMPAllocator());
-  if (!module->IsWithMe()) {
-    pregTab = module->GetMemPool()->New<MIRPregTable>(module, &module->GetMPAllocator());
-  }
-  return;
-}
 
 const MIRSymbol *MIRFunction::GetFuncSymbol() const {
   return GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolTableIdx.Idx());
@@ -97,12 +90,13 @@ MIRType *MIRFunction::GetNthParamType(size_t i) {
 MIRFuncType *MIRFunction::ReconstructFormals(const std::vector<MIRSymbol*> &symbols, bool clearOldArgs) {
   auto *newFuncType = static_cast<MIRFuncType*>(funcType->CopyMIRTypeNode());
   if (clearOldArgs) {
-    formals.clear();
+    formalDefVec.clear();
     newFuncType->GetParamTypeList().clear();
     newFuncType->GetParamAttrsList().clear();
   }
   for (auto *symbol : symbols) {
-    formals.push_back(symbol);
+    FormalDef formalDef(symbol->GetNameStrIdx(), symbol, symbol->GetTyIdx(), symbol->GetAttrs());
+    formalDefVec.push_back(formalDef);
     newFuncType->GetParamTypeList().push_back(symbol->GetTyIdx());
     newFuncType->GetParamAttrsList().push_back(symbol->GetAttrs());
   }
@@ -229,28 +223,33 @@ void MIRFunction::DumpFlavorLoweredThanMmpl() const {
   LogInfo::MapleLogger() << " (";
 
   // Dump arguments
-  size_t argSize = GetParamSize();
-  for (size_t i = 0; i < argSize; ++i) {
-    const MIRSymbol *symbol = formals[i];
-    if (symbol != nullptr) {
+  bool hasPrintedFormal = false;
+  for (uint32 i = 0; i < formalDefVec.size(); i++) {
+    MIRSymbol *symbol = formalDefVec[i].formalSym;
+    if (symbol == nullptr && (formalDefVec[i].formalStrIdx.GetIdx() == 0 ||
+                              GlobalTables::GetStrTable().GetStringFromStrIdx(formalDefVec[i].formalStrIdx).empty())) {
+      break;
+    }
+    hasPrintedFormal = true;
+    if (symbol == nullptr) {
+      LogInfo::MapleLogger() << "var %" << GlobalTables::GetStrTable().GetStringFromStrIdx(formalDefVec[i].formalStrIdx) << " ";
+    } else {
       if (symbol->GetSKind() != kStPreg) {
         LogInfo::MapleLogger() << "var %" << symbol->GetName() << " ";
       } else {
         LogInfo::MapleLogger() << "reg %" << symbol->GetPreg()->GetPregNo() << " ";
       }
     }
-    constexpr int kIndent = 2;
-    const MIRType *type = GetNthParamType(i);
-    type->Dump(kIndent);
-    if (symbol->GetAttr(ATTR_localrefvar)) {
-      LogInfo::MapleLogger() << " localrefvar";
-    }
-    if (i != (argSize - 1)) {
+    MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(formalDefVec[i].formalTyIdx);
+    ty->Dump(2);
+    TypeAttrs tA = formalDefVec[i].formalAttrs;
+    tA.DumpAttributes();
+    if (i != (formalDefVec.size() - 1)) {
       LogInfo::MapleLogger() << ", ";
     }
   }
   if (IsVarargs()) {
-    if (argSize == 0) {
+    if (!hasPrintedFormal) {
       LogInfo::MapleLogger() << "...";
     } else {
       LogInfo::MapleLogger() << ", ...";
@@ -266,7 +265,7 @@ void MIRFunction::Dump(bool withoutBody) {
   // class and interface decls.  these has nothing in formals
   // they do have paramtypelist_. this can not skip ones without args
   // but for them at least the func decls are valid
-  if (GetParamSize() != formals.size() || GetAttr(FUNCATTR_optimized)) {
+  if (GetParamSize() != formalDefVec.size() || GetAttr(FUNCATTR_optimized)) {
     return;
   }
 
@@ -276,6 +275,12 @@ void MIRFunction::Dump(bool withoutBody) {
 
   MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolTableIdx.Idx());
   ASSERT(symbol != nullptr, "symbol MIRSymbol is null");
+  if (!withoutBody) {
+    if (symbol->GetSrcPosition().FileNum() != 0 && symbol->GetSrcPosition().LineNum() != 0 && symbol->GetSrcPosition().LineNum() != MIRSymbol::lastPrintedLineNum) {
+      LogInfo::MapleLogger() << "LOC " << symbol->GetSrcPosition().FileNum() << " " << symbol->GetSrcPosition().LineNum() << std::endl;
+      MIRSymbol::lastPrintedLineNum = symbol->GetSrcPosition().LineNum();
+    }
+  }
   LogInfo::MapleLogger() << "func " << "&" << symbol->GetName();
   theMIRModule = module;
   funcAttrs.DumpAttributes();
@@ -504,7 +509,7 @@ const MIRType *MIRFunction::GetNodeType(const BaseNode &node) const {
   }
   if (node.GetOpCode() == OP_regread) {
     const auto &nodeReg = static_cast<const RegreadNode&>(node);
-    const MIRPreg *pReg = GetPregTab()->PregFromPregIdx(nodeReg.GetRegIdx());
+    MIRPreg *pReg = GetPregTab()->PregFromPregIdx(nodeReg.GetRegIdx());
     if (pReg->GetPrimType() == PTY_ref) {
       return pReg->GetMIRType();
     }
@@ -524,11 +529,46 @@ void MIRFunction::NewBody() {
   MIRPregTable *oldPregTable = GetPregTab();
   MIRTypeNameTable *oldTypeNameTable = typeNameTab;
   MIRLabelTable *oldLabelTable = GetLabelTab();
+
   symTab = module->GetMemPool()->New<MIRSymbolTable>(module->GetMPAllocator());
   pregTab = module->GetMemPool()->New<MIRPregTable>(module, &module->GetMPAllocator());
   typeNameTab = module->GetMemPool()->New<MIRTypeNameTable>(module->GetMPAllocator());
   labelTab = module->GetMemPool()->New<MIRLabelTable>(module->GetMPAllocator());
-  if (oldSymTable != nullptr) {
+
+  if (oldSymTable == nullptr) {
+    // formals not yet entered into symTab; enter them now
+    for (size_t i = 0; i < formalDefVec.size(); i++) {
+      FormalDef &formalDef = formalDefVec[i];
+      formalDef.formalSym = symTab->CreateSymbol(kScopeLocal);
+      formalDef.formalSym->SetStorageClass(kScFormal);
+      formalDef.formalSym->SetNameStrIdx(formalDef.formalStrIdx);
+      formalDef.formalSym->SetTyIdx(formalDef.formalTyIdx);
+      formalDef.formalSym->SetAttrs(formalDef.formalAttrs);
+      const std::string formalName = GlobalTables::GetStrTable().GetStringFromStrIdx(formalDef.formalStrIdx);
+      if (!isdigit(formalName.front())) {
+        formalDef.formalSym->SetSKind(kStVar);
+        symTab->AddToStringSymbolMap(*formalDef.formalSym);
+      } else {
+        formalDef.formalSym->SetSKind(kStPreg);
+        uint32 thepregno = std::stoi(formalName);
+        MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(formalDef.formalTyIdx);
+        PrimType pType = mirType->GetPrimType();
+        // if mirType info is not needed, set mirType to nullptr
+        if (mirType->GetPrimType() != PTY_ref && mirType->GetPrimType() != PTY_ptr) {
+          mirType = nullptr;
+        } else if (mirType->GetPrimType() == PTY_ptr) {
+          MIRType *pointedType = static_cast<MIRPtrType *>(mirType)->GetPointedType();
+          if (pointedType == nullptr || pointedType->GetKind() != kTypeFunction) {
+            mirType = nullptr;
+          }
+        }
+        PregIdx pregIdx = pregTab->EnterPregNo(thepregno, pType, mirType);
+        MIRPreg *preg = pregTab->PregFromPregIdx(pregIdx);
+        formalDef.formalSym->SetPreg(preg);
+      }
+    }
+  }
+  else {
     for (size_t i = 1; i < oldSymTable->GetSymbolTableSize(); ++i) {
       (void)GetSymTab()->AddStOutside(oldSymTable->GetSymbolFromStIdx(i));
     }
diff --git a/src/mapleall/maple_ir/src/mir_nodes.cpp b/src/mapleall/maple_ir/src/mir_nodes.cpp
index 73940a9030b2b4733ba96b9b741fc0f736e569ea..d2848be75bc6c2dae425495cdc78675c13867ecd 100644
--- a/src/mapleall/maple_ir/src/mir_nodes.cpp
+++ b/src/mapleall/maple_ir/src/mir_nodes.cpp
@@ -242,6 +242,17 @@ void CatchNode::Dump() const {
   this->BaseNode::Dump();
 }
 
+void CppCatchNode::Dump( int32 indent) const {
+  PrintIndentation(indent);
+  LogInfo::MapleLogger() << kOpcodeInfo.GetName(op);
+  if (exceptionTyIdx.GetIdx() != 0) {
+    LogInfo::MapleLogger() << " { ";
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(exceptionTyIdx)->Dump(indent + 1);
+    LogInfo::MapleLogger() << " }";
+  }
+  LogInfo::MapleLogger() << std::endl;
+}
+
 void UnaryNode::DumpOpnd(const MIRModule&, int indent) const {
   LogInfo::MapleLogger() << " (";
   uOpnd->Dump(indent);
@@ -1113,12 +1124,8 @@ void BlockNode::Dump(int32 indent, const MIRSymbolTable *theSymTab, MIRPregTable
         }
       }
       // print the locally declared variables
-      if (theSymTab != nullptr) {
-        theSymTab->Dump(true, indent + 1);
-      }
-      if (thePregTab != nullptr) {
-        thePregTab->DumpRef(indent + 1);
-      }
+      theSymTab->Dump(true, indent + 1);
+      thePregTab->DumpPregsWithTypes(indent + 1);
     }
     LogInfo::MapleLogger() << '\n';
     if (theMIRModule->CurFunction()->NeedEmitAliasInfo()) {
diff --git a/src/mapleall/maple_ir/src/mir_parser.cpp b/src/mapleall/maple_ir/src/mir_parser.cpp
index 7705e77ba3cac6a162f8e57312639b069cdc9937..7020a0f15e44769e3870544eeabc27d56495be56 100644
--- a/src/mapleall/maple_ir/src/mir_parser.cpp
+++ b/src/mapleall/maple_ir/src/mir_parser.cpp
@@ -98,12 +98,6 @@ bool MIRParser::ParseStmtRegassign(StmtNodePtr &stmt) {
         Error("inconsistent preg primitive dynamic type at ");
         return false;
       }
-    } else if (preg->GetPrimType() != expr->GetPrimType()) {
-      if (!IsRefOrPtrAssign(preg->GetPrimType(), expr->GetPrimType()) &&
-          !IsNoCvtNeeded(preg->GetPrimType(), expr->GetPrimType())) {
-        Error("inconsistent preg primitive type or need a cvt ");
-        return false;
-      }
     }
   }
   stmt = regAssign;
@@ -200,7 +194,9 @@ bool MIRParser::ParseStmtDoloop(StmtNodePtr &stmt) {
   stmt = doLoopNode;
   lexer.NextToken();
   if (lexer.GetTokenKind() == TK_preg) {
-    PregIdx pregIdx = LookupOrCreatePregIdx(static_cast<uint32>(lexer.GetTheIntVal()), false, *mod.CurFunction());
+    uint32 pregNo = static_cast<uint32>(lexer.GetTheIntVal());
+    MIRFunction *curfunc = mod.CurFunction();
+    PregIdx pregIdx = curfunc->GetPregTab()->EnterPregNo(pregNo, kPtyInvalid);
     doLoopNode->SetIsPreg(true);
     doLoopNode->SetDoVarStFullIdx(pregIdx);
     // let other appearances handle the preg primitive type
@@ -696,7 +692,6 @@ PUIdx MIRParser::EnterUndeclaredFunction(bool isMcount) {
   funcSt->SetStorageClass(kScText);
   funcSt->SetSKind(kStFunc);
   auto *fn = mod.GetMemPool()->New<MIRFunction>(&mod, funcSt->GetStIdx());
-  fn->Init();
   fn->SetPuidx(GlobalTables::GetFunctionTable().GetFuncTable().size());
   GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn);
   funcSt->SetFunction(fn);
@@ -1342,7 +1337,7 @@ bool MIRParser::ParseNaryStmtSyncExit(StmtNodePtr &stmt) {
   return ParseNaryStmt(stmt, OP_syncexit);
 }
 
-bool MIRParser::ParseLoc(StmtNodePtr&) {
+bool MIRParser::ParseLoc() {
   if (lexer.NextToken() != TK_intconst) {
     Error("expect intconst in LOC but get ");
     return false;
@@ -1360,6 +1355,10 @@ bool MIRParser::ParseLoc(StmtNodePtr&) {
   return true;
 }
 
+bool MIRParser::ParseLocStmt(StmtNodePtr&) {
+  return ParseLoc();
+}
+
 bool MIRParser::ParseStatement(StmtNodePtr &stmt) {
   paramTokenKindForStmt = lexer.GetTokenKind();
   uint32 mplNum = lexer.GetLineNum();
@@ -1412,7 +1411,7 @@ bool MIRParser::ParseStmtBlock(BlockNodePtr &blk) {
         return false;
       }
       if (stmt != nullptr) {  // stmt is nullptr if it is a LOC
-        SetSrcPos(stmt, mplNum);
+        SetSrcPos(stmt->GetSrcPos(), mplNum);
         blk->AddStatement(stmt);
       }
     } else {
@@ -1445,7 +1444,7 @@ void MIRParser::ParseStmtBlockForSeenComment(BlockNodePtr blk, uint32 mplNum) {
     for (size_t i = 0; i < lexer.seenComments.size(); ++i) {
       auto *cmnt = mod.CurFuncCodeMemPool()->New<CommentNode>(mod);
       cmnt->SetComment(lexer.seenComments[i]);
-      SetSrcPos(cmnt, mplNum);
+      SetSrcPos(cmnt->GetSrcPos(), mplNum);
       blk->AddStatement(cmnt);
     }
     lexer.seenComments.clear();
@@ -1457,6 +1456,7 @@ bool MIRParser::ParseStmtBlockForVar(TokenKind stmtTK) {
   MIRSymbol *st = fn->GetSymTab()->CreateSymbol(kScopeLocal);
   st->SetStorageClass(kScAuto);
   st->SetSKind(kStVar);
+  SetSrcPos(st->GetSrcPosition(), lexer.GetLineNum());
   if (stmtTK == TK_tempvar) {
     st->SetIsTmp(true);
   }
@@ -1485,7 +1485,7 @@ bool MIRParser::ParseStmtBlockForReg() {
     return false;
   }
   PregIdx pregIdx;
-  if (!ParseRefPseudoReg(pregIdx)) {
+  if (!ParsePseudoReg(PTY_ref, pregIdx)) {
     return false;
   }
   MIRPreg *preg = mod.CurFunction()->GetPregTab()->PregFromPregIdx(pregIdx);
@@ -1783,6 +1783,7 @@ bool MIRParser::ParseDeclaredFunc(PUIdx &puidx) {
   }
   MIRFunction *func = st->GetFunction();
   puidx = func->GetPuidx();
+  st->SetAppearsInCode(true);
   return true;
 }
 
@@ -1842,22 +1843,15 @@ bool MIRParser::ParseExprRegread(BaseNodePtr &expr) {
   expr->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(tyidx));
   if (lexer.GetTokenKind() == TK_specialreg) {
     PregIdx tempPregIdx = regRead->GetRegIdx();
-    bool isSuccess = ParseSpecialReg(tempPregIdx);
+    bool isSuccess =  ParseSpecialReg(tempPregIdx);
     regRead->SetRegIdx(tempPregIdx);
     return isSuccess;
   }
   if (lexer.GetTokenKind() == TK_preg) {
-    if (expr->GetPrimType() == PTY_ptr || expr->GetPrimType() == PTY_ref) {
-      PregIdx tempPregIdx = regRead->GetRegIdx();
-      bool isSuccess = ParseRefPseudoReg(tempPregIdx);
-      regRead->SetRegIdx(tempPregIdx);
-      return isSuccess;
-    } else {
-      PregIdx tempPregIdx = regRead->GetRegIdx();
-      bool isSuccess = ParsePseudoReg(expr->GetPrimType(), tempPregIdx);
-      regRead->SetRegIdx(tempPregIdx);
-      return isSuccess;
-    }
+    PregIdx tempPregIdx = regRead->GetRegIdx();
+    bool isSuccess = ParsePseudoReg(regRead->GetPrimType(), tempPregIdx);
+    regRead->SetRegIdx(tempPregIdx);
+    return isSuccess;
   }
   Error("expect special or pseudo register but get ");
   return false;
@@ -2841,7 +2835,7 @@ std::map<TokenKind, MIRParser::FuncPtrParseStmt> MIRParser::InitFuncPtrMapForPar
   funcPtrMap[TK_assertge] = &MIRParser::ParseBinaryStmtAssertGE;
   funcPtrMap[TK_assertlt] = &MIRParser::ParseBinaryStmtAssertLT;
   funcPtrMap[TK_label] = &MIRParser::ParseStmtLabel;
-  funcPtrMap[TK_LOC] = &MIRParser::ParseLoc;
+  funcPtrMap[TK_LOC] = &MIRParser::ParseLocStmt;
   funcPtrMap[TK_ALIAS] = &MIRParser::ParseAlias;
   return funcPtrMap;
 }
@@ -2865,9 +2859,9 @@ std::map<TokenKind, MIRParser::FuncPtrParseStmtBlock> MIRParser::InitFuncPtrMapF
   return funcPtrMap;
 }
 
-void MIRParser::SetSrcPos(StmtNodePtr stmt, uint32 mplNum) {
-  stmt->GetSrcPos().SetFileNum(lastFileNum);
-  stmt->GetSrcPos().SetLineNum(lastLineNum);
-  stmt->GetSrcPos().SetMplLineNum(mplNum);
+void MIRParser::SetSrcPos(SrcPosition &srcPosition, uint32 mplNum) {
+  srcPosition.SetFileNum(lastFileNum);
+  srcPosition.SetLineNum(lastLineNum);
+  srcPosition.SetMplLineNum(mplNum);
 }
 }  // namespace maple
diff --git a/src/mapleall/maple_ir/src/mir_symbol.cpp b/src/mapleall/maple_ir/src/mir_symbol.cpp
index 39f10ef219473e0f78fd39db995e009c270bec93..402cf03384c44d63e3301faf5f78d09df1af490c 100644
--- a/src/mapleall/maple_ir/src/mir_symbol.cpp
+++ b/src/mapleall/maple_ir/src/mir_symbol.cpp
@@ -27,6 +27,8 @@
 namespace maple {
 using namespace namemangler;
 
+uint32 MIRSymbol::lastPrintedLineNum = 0;
+
 bool MIRSymbol::IsTypeVolatile(int fieldID) const {
   const MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(GetTyIdx());
   return ty->IsVolatile(fieldID);
@@ -291,11 +293,20 @@ bool MIRSymbol::IgnoreRC() const {
 }
 
 void MIRSymbol::Dump(bool isLocal, int32 indent, bool suppressInit) const {
+  if (sKind == kStVar || sKind == kStFunc) {
+    if (srcPosition.FileNum() != 0 && srcPosition.LineNum() != 0 && srcPosition.LineNum() != lastPrintedLineNum) {
+      LogInfo::MapleLogger() << "LOC " << srcPosition.FileNum() << " " << srcPosition.LineNum() << std::endl;
+      lastPrintedLineNum = srcPosition.LineNum();
+    }
+  }
   // exclude unused symbols, formal symbols and extern functions
   if (GetStorageClass() == kScUnused || GetStorageClass() == kScFormal ||
       (GetStorageClass() == kScExtern && sKind == kStFunc)) {
     return;
   }
+  if (GetIsImported() && !GetAppearsInCode()) {
+    return;
+  }
   if (GetTyIdx() >= GlobalTables::GetTypeTable().GetTypeTable().size()) {
     FATAL(kLncFatal, "valid maple_ir with illegal type");
   }
@@ -389,24 +400,4 @@ bool MIRLabelTable::AddToStringLabelMap(LabelIdx labelIdx) {
   strIdxToLabIdxMap[strIdx] = labelIdx;
   return true;
 }
-
-void MIRPregTable::DumpRef(int32 indent) {
-  MapleVector<MIRPreg*> &pRegTable = pregTable;
-  for (size_t i = 1; i < pRegTable.size(); ++i) {
-    MIRPreg *mirPReg = pRegTable[i];
-    if (mirPReg->GetPrimType() != PTY_ref) {
-      continue;
-    }
-    if (mirPReg->GetMIRType() == nullptr) {
-      continue;
-    }
-    PrintIndentation(indent);
-    LogInfo::MapleLogger() << "reg ";
-    LogInfo::MapleLogger() << "%" << mirPReg->GetPregNo();
-    LogInfo::MapleLogger() << " ";
-    mirPReg->GetMIRType()->Dump(0);
-    LogInfo::MapleLogger() << " " << (mirPReg->NeedRC() ? 1 : 0);
-    LogInfo::MapleLogger() << "\n";
-  }
-}
 }  // namespace maple
diff --git a/src/mapleall/maple_ir/src/mir_type.cpp b/src/mapleall/maple_ir/src/mir_type.cpp
index 648bdeb9e62d8b2233aef5e224ba8c06b1ff250d..cd56335d589a3ca81c668a98083300ecd331ac48 100755
--- a/src/mapleall/maple_ir/src/mir_type.cpp
+++ b/src/mapleall/maple_ir/src/mir_type.cpp
@@ -229,6 +229,26 @@ uint32 GetPrimTypeP2Size(PrimType primType) {
   }
 }
 
+// return the signed version that has the same size
+const PrimType GetSignedPrimType(PrimType pty) {
+  switch (pty) {
+    case PTY_ptr:
+    case PTY_ref:
+    case PTY_a64:
+    case PTY_u64:
+      return PTY_i64;
+    case PTY_u8:
+      return PTY_i8;
+    case PTY_u16:
+      return PTY_i16;
+    case PTY_a32:
+    case PTY_u32:
+      return PTY_i32;
+    default: ;
+  }
+  return pty;
+}
+
 const char *GetPrimTypeName(PrimType primType) {
 #define LOAD_ALGO_PRIMARY_TYPE
   switch (primType) {
diff --git a/src/mapleall/maple_ir/src/parser.cpp b/src/mapleall/maple_ir/src/parser.cpp
index d335ec417075a0b297686e1b6621166b80271772..332ae41f6ee8f34d464e8b63b4d5d80a4903aacf 100755
--- a/src/mapleall/maple_ir/src/parser.cpp
+++ b/src/mapleall/maple_ir/src/parser.cpp
@@ -86,43 +86,6 @@ MIRFunction *MIRParser::CreateDummyFunction() {
   return func;
 }
 
-void MIRParser::ResetMaxPregNo(MIRFunction &func) {
-  for (uint32 i = 0; i < func.GetFormalCount(); ++i) {
-    MIRSymbol *formalSt = func.GetFormal(i);
-    if (formalSt->IsPreg()) {
-      // no special register appears in the formals
-      uint32 pRegNO = static_cast<uint32>(formalSt->GetPreg()->GetPregNo());
-      if (pRegNO > maxPregNo) {
-        maxPregNo = pRegNO;
-      }
-    }
-  }
-}
-
-MIRPreg *MIRParser::CreateMirPreg(uint32 pregNo) const {
-  return mod.GetMemPool()->New<MIRPreg>(pregNo);
-}
-
-PregIdx MIRParser::LookupOrCreatePregIdx(uint32 pregNo, bool isRef, MIRFunction &func) {
-  MIRPregTable *pRegTab = func.GetPregTab();
-  PregIdx idx = pRegTab->GetPregIdxFromPregno(pregNo);
-  if (idx == 0) {
-    if (pregNo > maxPregNo) {
-      maxPregNo = pregNo;
-    }
-    MIRPreg *preg = CreateMirPreg(pregNo);
-    if (isRef) {
-      preg->SetPrimType(PTY_ref);
-    }
-    size_t pregIndex = pRegTab->GetPregTable().size();
-    CHECK_FATAL(pregIndex <= INT_MAX, "pregIndex out of range");
-    idx = static_cast<PregIdx>(pregIndex);
-    pRegTab->GetPregTable().push_back(preg);
-    pRegTab->SetPregNoToPregIdxMapItem(pregNo, idx);
-  }
-  return idx;
-}
-
 bool MIRParser::IsDelimitationTK(TokenKind tk) const {
   switch (tk) {
     case TK_rparen:
@@ -250,41 +213,24 @@ bool MIRParser::ParseSpecialReg(PregIdx &pRegIdx) {
   return false;
 }
 
-bool MIRParser::ParseRefPseudoReg(PregIdx &pRegIdx) {
-  uint32 pRegNO = static_cast<uint32>(lexer.GetTheIntVal());
-  ASSERT(pRegNO <= 0xffff, "preg number must be 16 bits");
-  pRegIdx = LookupOrCreatePregIdx(pRegNO, true, *mod.CurFunction());
-  lexer.NextToken();
-  return true;
-}
-
 bool MIRParser::ParsePseudoReg(PrimType primType, PregIdx &pRegIdx) {
-  MIRFunction *func = mod.CurFunction();
-  ASSERT(func != nullptr, "func nullptr check");
-  pRegIdx = LookupOrCreatePregIdx(static_cast<uint32>(lexer.GetTheIntVal()), false, *func);
-  MIRPreg *preg = func->GetPregTab()->PregFromPregIdx(pRegIdx);
-
-  if (primType == kPtyInvalid || preg->GetPrimType() == primType) {
-    lexer.NextToken();
-    return true;
-  }
-
-  // check type consistenency for the preg
-  if (preg->GetPrimType() == kPtyInvalid) {
-    preg->SetPrimType(primType);
-    lexer.NextToken();
-    return true;
-  }
-
-  if ((primType == PTY_ref || primType == PTY_ptr) &&
-      (preg->GetPrimType() == PTY_ref || preg->GetPrimType() == PTY_ptr)) {
-    // PTY_ref and PTY_ptr are compatible with each other
-    lexer.NextToken();
-    return true;
+  uint32 pregNo = static_cast<uint32>(lexer.GetTheIntVal());
+  ASSERT(pregNo <= 0xffff, "preg number must be 16 bits");
+  MIRFunction *curfunc = mod.CurFunction();
+  pRegIdx = curfunc->GetPregTab()->EnterPregNo(pregNo, primType);
+  MIRPreg *preg = curfunc->GetPregTab()->PregFromPregIdx(pRegIdx);
+  if (primType != kPtyInvalid) {
+    if (preg->GetPrimType() != primType) {
+      if ((primType == PTY_ref || primType == PTY_ptr) && (preg->GetPrimType() == PTY_ref || preg->GetPrimType() == PTY_ptr))
+        ;  // PTY_ref and PTY_ptr are compatible with each other
+      else {
+        Error("inconsistent preg primitive type at ");
+        return false;
+      }
+    }
   }
-
-  Error("inconsistent preg primitive type at ");
-  return false;
+  lexer.NextToken();
+  return true;
 }
 
 bool MIRParser::CheckPrimAndDerivedType(TokenKind tokenKind, TyIdx &tyIdx) {
@@ -752,8 +698,9 @@ bool MIRParser::ParseFields(MIRStructType &type) {
     maple::MIRBuilder mirBuilder(&mod);
     MIRSymbol *funcSymbol = mirBuilder.CreateSymbol(TyIdx(0), strIdx, kStFunc, kScText, nullptr, kScopeGlobal);
     ASSERT(funcSymbol != nullptr, "Failed to create MIRSymbol");
-    auto *fn = mod.GetMemPool()->New<MIRFunction>(&mod, funcSymbol->GetStIdx());
-    fn->Init();
+    SetSrcPos(funcSymbol->GetSrcPosition(), lexer.GetLineNum());
+
+    MIRFunction *fn = mod.GetMemPool()->New<MIRFunction>(&mod, funcSymbol->GetStIdx());
     fn->SetPuidx(GlobalTables::GetFunctionTable().GetFuncTable().size());
     GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn);
     funcSymbol->SetFunction(fn);
@@ -772,10 +719,16 @@ bool MIRParser::ParseFields(MIRStructType &type) {
       return false;
     }
     // tyIdx does not work. Calling EqualTo does not work either.
-    auto *funcType = static_cast<MIRFuncType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcTyIdx));
+    MIRFuncType *funcType = static_cast<MIRFuncType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcTyIdx));
     fn->SetMIRFuncType(funcType);
     fn->SetReturnStruct(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetRetTyIdx()));
     funcSymbol->SetTyIdx(funcTyIdx);
+
+    for (size_t i = 0; i < funcType->GetParamTypeList().size(); i++) {
+      FormalDef formalDef(nullptr, funcType->GetParamTypeList()[i], funcType->GetParamAttrsList()[i]);
+      fn->GetFormalDefVec().push_back(formalDef);
+    }
+
     MethodPair p = MethodPair(funcSymbol->GetStIdx(), TyidxFuncAttrPair(funcTyIdx, FuncAttrs(tA)));
     type.GetMethods().push_back(p);
     tk = lexer.GetTokenKind();
@@ -1655,10 +1608,9 @@ bool MIRParser::ParseDeclareReg(MIRSymbol &symbol, MIRFunction &func) {
   }
   symbol.SetTyIdx(tyIdx);
   MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
-  PregIdx pRegIdx = LookupOrCreatePregIdx(thePRegNO, mirType->GetPrimType() == PTY_ref, func);
+  PregIdx pRegIdx = func.GetPregTab()->EnterPregNo(thePRegNO, mirType->GetPrimType(), mirType);
   MIRPregTable *pRegTab = func.GetPregTab();
   MIRPreg *preg = pRegTab->PregFromPregIdx(pRegIdx);
-  preg->SetIsRef(mirType->GetPrimType() == PTY_ref);
   preg->SetPrimType(mirType->GetPrimType());
   symbol.SetPreg(preg);
   if (!ParseVarTypeAttrs(symbol)) {
@@ -1762,6 +1714,41 @@ bool MIRParser::ParseDeclareVar(MIRSymbol &symbol) {
   return true;
 }
 
+bool MIRParser::ParseDeclareFormal(FormalDef *formalDef) {
+  TokenKind tk = lexer.GetTokenKind();
+  if (tk != TK_var && tk != TK_reg) {
+    return false;
+  }
+  TokenKind nameTk = lexer.NextToken();
+  if (tk == TK_var) {
+    if (nameTk != TK_lname) {
+      Error("expect local name but get ");
+      return false;
+    }
+    formalDef->formalStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+  } else {  // tk == TK_reg
+    if (nameTk != TK_preg) {
+      Error("expect preg but get ");
+      return false;
+    }
+    formalDef->formalStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(std::to_string(lexer.GetTheIntVal()));
+  }
+  tk = lexer.NextToken();
+  if (!ParseType(formalDef->formalTyIdx)) {
+    Error("ParseDeclareFormal failed when parsing the type");
+    return false;
+  }
+  if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(formalDef->formalTyIdx)->GetKind() == kTypeByName) {
+    Error("type in var declaration cannot be forward-referenced at ");
+    return false;
+  }
+  if (!ParseTypeAttrs(formalDef->formalAttrs)) {
+    Error("ParseDeclareFormal failed when parsing type attributes");
+    return false;
+  }
+  return true;
+}
+
 bool MIRParser::ParsePrototype(MIRFunction &func, MIRSymbol &funcSymbol, TyIdx &funcTyIdx) {
   if (lexer.GetTokenKind() == TK_lbrace) {
     if (mod.GetFlavor() < kMmpl) {
@@ -1771,8 +1758,8 @@ bool MIRParser::ParsePrototype(MIRFunction &func, MIRSymbol &funcSymbol, TyIdx &
     // mmpl flavor has no prototype declaration, return normally
     return true;
   }
-  std::vector<TyIdx> vecType;       // for storing the parameter types
-  std::vector<TypeAttrs> vecAttrs;  // for storing the parameter type attributes
+  std::vector<TyIdx> vecTy;    // for storing the parameter types
+  std::vector<TypeAttrs> vecAt;  // for storing the parameter type attributes
   // this part for parsing the argument list and return type
   if (lexer.GetTokenKind() != TK_lparen) {
     Error("expect ( for func but get ");
@@ -1781,7 +1768,8 @@ bool MIRParser::ParsePrototype(MIRFunction &func, MIRSymbol &funcSymbol, TyIdx &
   // parse parameters
   bool varArgs = false;
   TokenKind pmTk = lexer.NextToken();
-  if (pmTk != TK_rparen) {
+
+  while (pmTk != TK_rparen) {
     if (pmTk == TK_dotdotdot) {
       varArgs = true;
       func.SetVarArgs();
@@ -1790,39 +1778,27 @@ bool MIRParser::ParsePrototype(MIRFunction &func, MIRSymbol &funcSymbol, TyIdx &
         Error("expect ) after ... but get");
         return false;
       }
+      break;
     } else {
-      MIRSymbol *symbol = func.GetSymTab()->CreateSymbol(kScopeLocal);
-      ASSERT(symbol != nullptr, "Failed to create MIRSymbol");
-      symbol->SetStorageClass(kScFormal);
-      TokenKind symbolTK = lexer.GetTokenKind();
-      if (symbolTK == TK_reg) {
-        symbol->SetSKind(kStPreg);
-        if (!ParseDeclareReg(*symbol, func)) {
-          Error("ParseFunction expect preg for parameter");
-          return false;
-        }
-        func.AddFormal(symbol);
-        vecType.push_back(symbol->GetTyIdx());
-        vecAttrs.push_back(symbol->GetAttrs());
-        if (!ParsePrototypeRemaining(func, vecType, vecAttrs, varArgs)) {
-          return false;
-        }
-      } else {
-        symbol->SetSKind(kStVar);
-        if (!ParseDeclareVar(*symbol)) {
-          Error("ParseFunction expect scalar value");
-          return false;
-        }
-        (void)func.GetSymTab()->AddToStringSymbolMap(*symbol);
-        func.AddFormal(symbol);
-        vecType.push_back(symbol->GetTyIdx());
-        vecAttrs.push_back(symbol->GetAttrs());
-        if (!ParsePrototypeRemaining(func, vecType, vecAttrs, varArgs)) {
+      FormalDef formalDef;
+      if (!ParseDeclareFormal(&formalDef)) {
+        Error("ParsePrototype expects formal parameter declaration");
+        return false;
+      }
+      func.GetFormalDefVec().push_back(formalDef);
+      vecTy.push_back(formalDef.formalTyIdx);
+      vecAt.push_back(formalDef.formalAttrs);
+      pmTk = lexer.GetTokenKind();
+      if (pmTk == TK_coma) {
+        pmTk = lexer.NextToken();
+        if (pmTk == TK_rparen) {
+          Error("\',\' cannot be followed by");
           return false;
         }
       }
     }
   }
+
   // parse return type
   lexer.NextToken();
   TyIdx tyIdx(0);
@@ -1831,8 +1807,7 @@ bool MIRParser::ParsePrototype(MIRFunction &func, MIRSymbol &funcSymbol, TyIdx &
   }
   MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
   func.SetReturnStruct(*retType);
-  MIRType *funcType =
-      GlobalTables::GetTypeTable().GetOrCreateFunctionType(mod, tyIdx, vecType, vecAttrs, varArgs, false);
+  MIRType *funcType = GlobalTables::GetTypeTable().GetOrCreateFunctionType(mod, tyIdx, vecTy, vecAt, varArgs, false);
   funcTyIdx = funcType->GetTypeIndex();
   funcSymbol.SetTyIdx(funcTyIdx);
   func.SetMIRFuncType(static_cast<MIRFuncType*>(funcType));
@@ -1875,9 +1850,9 @@ bool MIRParser::ParseFunction(uint32 fileIdx) {
       // is indeed another definition, we will throw error.
       MIRSymbol *tmpSymbol = mod.GetMemPool()->New<MIRSymbol>();
       tmpSymbol->SetStorageClass(kScText);
+      tmpSymbol->SetAppearsInCode(true);
       tmpSymbol->SetSKind(kStFunc);
       MIRFunction *tmpFunc = mod.GetMemPool()->New<MIRFunction>(&mod, tmpSymbol->GetStIdx());
-      tmpFunc->Init();
       tmpSymbol->SetFunction(tmpFunc);
       TyIdx tmpTyIdx;
       if (!ParsePrototype(*tmpFunc, *tmpSymbol, tmpTyIdx)) {
@@ -1892,7 +1867,7 @@ bool MIRParser::ParseFunction(uint32 fileIdx) {
     // Skip attribute checking
     func = funcSymbol->GetFunction();
     func->ClearFormals();
-    func->Init();
+
     // update with current attr
     if (funcAttrs.GetAttrFlag()) {
       if (func->IsIpaSeen()) {
@@ -1924,8 +1899,9 @@ bool MIRParser::ParseFunction(uint32 fileIdx) {
   } else {
     maple::MIRBuilder mirBuilder(&mod);
     funcSymbol = mirBuilder.CreateSymbol(TyIdx(0), strIdx, kStFunc, kScText, nullptr, kScopeGlobal);
+    SetSrcPos(funcSymbol->GetSrcPosition(), lexer.GetLineNum());
+
     func = mod.GetMemPool()->New<MIRFunction>(&mod, funcSymbol->GetStIdx());
-    func->Init();
     func->SetPuidx(GlobalTables::GetFunctionTable().GetFuncTable().size());
     GlobalTables::GetFunctionTable().GetFuncTable().push_back(func);
     funcSymbol->SetFunction(func);
@@ -1933,17 +1909,19 @@ bool MIRParser::ParseFunction(uint32 fileIdx) {
   }
   func->SetFileIndex(fileIdx);
   curFunc = func;
+
   if (mod.IsJavaModule()) {
     func->SetBaseClassFuncNames(funcSymbol->GetNameStrIdx());
   }
+
   TyIdx funcTyidx;
   if (!ParsePrototype(*func, *funcSymbol, funcTyidx)) {
     return false;
   }
+
   if (lexer.GetTokenKind() == TK_lbrace) {  // #2 parse Function body
+    funcSymbol->SetAppearsInCode(true);
     definedLabels.clear();
-    maxPregNo = 0;
-    ResetMaxPregNo(*func);  // reset the maxPregNo due to the change of parameters
     mod.SetCurFunction(func);
     mod.AddFunction(func);
     // set maple line number for function
@@ -1960,7 +1938,7 @@ bool MIRParser::ParseFunction(uint32 fileIdx) {
       return false;
     }
     func->SetBody(block);
-    mod.CurFunction()->GetPregTab()->SetIndex(maxPregNo + 1);
+
     // set source file number for function
     func->GetSrcPosition().SetLineNum(firstLineNum);
     func->GetSrcPosition().SetFileNum(lastFileNum);
@@ -2360,6 +2338,7 @@ std::map<TokenKind, MIRParser::FuncPtrParseMIRForElem> MIRParser::InitFuncPtrMap
   funcPtrMap[TK_srcfileinfo] = &MIRParser::ParseMIRForSrcFileInfo;
   funcPtrMap[TK_import] = &MIRParser::ParseMIRForImport;
   funcPtrMap[TK_importpath] = &MIRParser::ParseMIRForImportPath;
+  funcPtrMap[TK_LOC] = &MIRParser::ParseLoc;
   return funcPtrMap;
 }
 
@@ -2407,6 +2386,7 @@ bool MIRParser::ParseMIRForVar() {
     newst->SetAttrs(st.GetAttrs());
     newst->SetNameStrIdx(st.GetNameStrIdx());
     newst->SetValue(st.GetValue());
+    SetSrcPos(newst->GetSrcPosition(), lexer.GetLineNum());
   }
   return true;
 }
@@ -2824,7 +2804,7 @@ bool MIRParser::ParsePrototypeRemaining(MIRFunction &func, std::vector<TyIdx> &v
       }
       (void)func.GetSymTab()->AddToStringSymbolMap(*symbol);
     }
-    func.AddFormal(symbol);
+    func.AddArgument(symbol);
     vecTyIdx.push_back(symbol->GetTyIdx());
     vecAttrs.push_back(symbol->GetAttrs());
     pmTk = lexer.GetTokenKind();
diff --git a/src/mapleall/maple_me/src/irmap.cpp b/src/mapleall/maple_me/src/irmap.cpp
index ba30ea3258c194d5d1cd614fc9c30eddef441f0e..eb49b4ce8882d5a7cc0e42efc5455a002500e730 100755
--- a/src/mapleall/maple_me/src/irmap.cpp
+++ b/src/mapleall/maple_me/src/irmap.cpp
@@ -200,7 +200,7 @@ RegMeExpr *IRMap::CreateRefRegMeExpr(const MIRSymbol &mirSt) {
   MIRType *stType = mirSt.GetType();
   PrimType pType = stType->GetPrimType();
   ASSERT(pType == PTY_ref, "only PTY_ref needed");
-  PregIdx regIdx = mirFunc->GetPregTab()->CreateRefPreg(*stType);
+  PregIdx regIdx = mirFunc->GetPregTab()->CreatePreg(PTY_ref, stType);
   ASSERT(regIdx <= 0xffff, "register oversized");
   MIRPreg *preg = mirFunc->GetPregTab()->PregFromPregIdx(regIdx);
   if (!mirSt.IgnoreRC()) {
@@ -226,7 +226,7 @@ RegMeExpr *IRMap::CreateRegMeExpr(PrimType pType) {
 
 RegMeExpr *IRMap::CreateRegRefMeExpr(MIRType &mirType) {
   MIRFunction *mirFunc = mirModule.CurFunction();
-  PregIdx regIdx = mirFunc->GetPregTab()->CreateRefPreg(mirType);
+  PregIdx regIdx = mirFunc->GetPregTab()->CreatePreg(PTY_ref, &mirType);
   ASSERT(regIdx <= 0xffff, "register oversized");
   OriginalSt *ost = ssaTab.GetOriginalStTable().CreatePregOriginalSt(regIdx, mirFunc->GetPuidx());
   auto *regReadExpr = NewInPool<RegMeExpr>(exprID++, regIdx, mirFunc->GetPuidx(), ost->GetIndex(), 0);
diff --git a/src/mapleall/maple_me/src/me_rename2preg.cpp b/src/mapleall/maple_me/src/me_rename2preg.cpp
index 38f4badaa629ae722c2b4e9f2063685b7e730d75..d43b2bd04b4d7ea1f7faa03fe1c73f700067cce2 100755
--- a/src/mapleall/maple_me/src/me_rename2preg.cpp
+++ b/src/mapleall/maple_me/src/me_rename2preg.cpp
@@ -154,16 +154,16 @@ class FormalRenaming final {
         MIRType &irTy = utils::ToRef(irFunc.GetNthParamType(i));
         MIRPregTable &irPregTbl = utils::ToRef(irFunc.GetPregTab());
         PregIdx16 regIdx = (irTy.GetPrimType() == PTY_ref) ?
-            static_cast<PregIdx16>(irPregTbl.CreateRefPreg(irTy)) :
+            static_cast<PregIdx16>(irPregTbl.CreatePreg(PTY_ref, &irTy)) :
             static_cast<PregIdx16>(irPregTbl.CreatePreg(irTy.GetPrimType()));
-        irFunc.SetFormal(i, irBuilder.CreatePregFormalSymbol(irTy.GetTypeIndex(), regIdx, irFunc));
+        irFunc.GetFormalDefVec()[i].formalSym = irBuilder.CreatePregFormalSymbol(irTy.GetTypeIndex(), regIdx, irFunc);
       } else {
         RegMeExpr *regExpr = renamedReg[i];
         if (regExpr != nullptr) {
           PregIdx16 regIdx = regExpr->GetRegIdx();
           MIRSymbol &irSym = utils::ToRef(irFunc.GetFormal(i));
           MIRSymbol *newIrSym = irBuilder.CreatePregFormalSymbol(irSym.GetTyIdx(), regIdx, irFunc);
-          irFunc.SetFormal(i, newIrSym);
+          irFunc.GetFormalDefVec()[i].formalSym = newIrSym;
         }
       }
     }
diff --git a/src/mapleall/maple_me/src/me_ssa_lpre.cpp b/src/mapleall/maple_me/src/me_ssa_lpre.cpp
index 9603331e0660bf08a8d50b856474361dc25e9f4c..f244bbcd270a389eb6449a881e66bdc186e9361e 100755
--- a/src/mapleall/maple_me/src/me_ssa_lpre.cpp
+++ b/src/mapleall/maple_me/src/me_ssa_lpre.cpp
@@ -40,8 +40,8 @@ void MeSSALPre::GenerateSaveRealOcc(MeRealOcc &realOcc) {
                                                                                 *func->GetMirFunc());
     size_t i = 0;
     for (; i < func->GetMirFunc()->GetFormalCount(); ++i) {
-      if (func->GetMirFunc()->GetFormal(i) == oldFormalSt) {
-        func->GetMirFunc()->SetFormal(i, newFormalSt);
+      if (func->GetMirFunc()->GetFormalDefVec()[i].formalSym == oldFormalSt) {
+        func->GetMirFunc()->GetFormalDefVec()[i].formalSym = newFormalSt;
         break;
       }
     }
diff --git a/src/mapleall/maple_me/src/preg_renamer.cpp b/src/mapleall/maple_me/src/preg_renamer.cpp
index fd0c2b701cbc1c1c9b1306f922a673e786dbd6bb..fade98bc021400aed07a1d6d892478d8a15ad301 100755
--- a/src/mapleall/maple_me/src/preg_renamer.cpp
+++ b/src/mapleall/maple_me/src/preg_renamer.cpp
@@ -98,7 +98,7 @@ void PregRenamer::RunSelf() const {
       continue;
     }
     newPregIdx = (regMeExpr->GetPrimType() == PTY_ref) ?
-                 pregTab->CreateRefPreg(*pregTab->PregFromPregIdx(regMeExpr->GetRegIdx())->GetMIRType()) :
+                 pregTab->CreatePreg(PTY_ref, pregTab->PregFromPregIdx(regMeExpr->GetRegIdx())->GetMIRType()) :
                  pregTab->CreatePreg(regMeExpr->GetPrimType());
     ++renameCount;
     if (enabledDebug) {
diff --git a/src/mplfe/common/src/fe_function.cpp b/src/mplfe/common/src/fe_function.cpp
index d2f61c91728ca80da9cf76068632dbe8dda4bf5a..c41806a09620e56c029f19947cb72be1f0b44ede 100644
--- a/src/mplfe/common/src/fe_function.cpp
+++ b/src/mplfe/common/src/fe_function.cpp
@@ -432,7 +432,7 @@ bool FEFunction::UpdateFormal(const std::string &phaseName) {
       sym = argVar->GenerateMIRSymbol(FEManager::GetMIRBuilder());
     }
     sym->SetStorageClass(kScFormal);
-    mirFunction.AddFormal(sym);
+    mirFunction.AddArgument(sym);
     idx++;
   }
   return phaseResult.Finish();
diff --git a/src/mplfe/common/src/fe_type_manager.cpp b/src/mplfe/common/src/fe_type_manager.cpp
index 681c42512fd41003e2301dfc3257ba3e6fb96003..2955e96d018b8ccc3baf234c9a958b5a1c28a138 100644
--- a/src/mplfe/common/src/fe_type_manager.cpp
+++ b/src/mplfe/common/src/fe_type_manager.cpp
@@ -383,7 +383,6 @@ MIRFunction *FETypeManager::CreateFunction(const GStrIdx &nameIdx, const TyIdx &
   MemPool *mpModule = module.GetMemPool();
   ASSERT(mpModule, "mem pool is nullptr");
   mirFunc = mpModule->New<MIRFunction>(&module, funcSymbol->GetStIdx());
-  mirFunc->Init();
   size_t idx = GlobalTables::GetFunctionTable().GetFuncTable().size();
   CHECK_FATAL(idx < UINT32_MAX, "PUIdx is out of range");
   mirFunc->SetPuidx(static_cast<uint32>(idx));
@@ -584,4 +583,4 @@ MIRFunction *FETypeManager::GetMCCFunction(const GStrIdx &funcNameIdx) const {
     return it->second;
   }
 }
-}  // namespace maple
\ No newline at end of file
+}  // namespace maple