diff --git a/doc/Programming_Specifications.md b/doc/Programming_Specifications.md
index b6b00fb859b0f85870839416f11aa1128989b660..4d598b81fd231888956ec55d5625f9dd83163b54 100644
--- a/doc/Programming_Specifications.md
+++ b/doc/Programming_Specifications.md
@@ -557,7 +557,7 @@ default:                // Bad: default 未缩进
 // 假设下面第一行已经不满足行宽要求
 ```cpp
 if (currentValue > threshold &&  
-  someConditionsion) {
+    someConditionsion) {
   DoSomething();
   ...
 }
@@ -1069,7 +1069,7 @@ FIXME 注释一般用来描述已知缺陷
 头文件应当职责单一。头文件过于复杂，依赖过于复杂还是导致编译时间过长的主要原因。
 
 ### <a name="a5-1-1"></a>建议5.1.1 每一个.cpp文件应有一个对应的.h文件，用于声明需要对外公开的类与接口
-通常情况下，每个.cpp文件都有一个相应的.h，用于放置对外提供的函数声明、宏定义、类型定义等。
+通常情况下，每个.cpp文件都有一个相应的.h，用于放置对外提供的函数声明、宏定义、类型定义等。另外，可根据实际情况添加对应的.inline.h文件优化代码。
 如果一个.cpp文件不需要对外公布任何接口，则其就不应当存在。
 例外：__程序的入口（如main函数所在的文件），单元测试代码，动态库代码。__
 
@@ -1575,7 +1575,7 @@ int main(void) {
 说明：如果用户不定义，编译器默认会生成拷贝构造函数和拷贝赋值操作符， 移动构造和移动赋值操作符（移动语义的函数C++11以后才有）。
 如果我们不要使用拷贝构造函数，或者赋值操作符，请明确拒绝：
 
-1. 将拷贝构造函数或者赋值操作符设置为private，并且不实现：
+1.将拷贝构造函数或者赋值操作符设置为private，并且不实现：
 
 ```cpp
 class Foo {
@@ -1584,12 +1584,20 @@ class Foo {
   Foo& operator=(const Foo&);
 };
 ```
-2. 使用C++11提供的delete, 请参见后面现代C++的相关章节。
-3. 静态方法类，禁用构造函数，防止创建实例
+2.使用C++11提供的delete:
 
 ```cpp
-class Helper
-{
+// 同时禁止, 使用C++11的delete
+class Foo {
+ public:
+  Foo(Foo&&) = delete;
+  Foo& operator=(Foo&&) = delete;
+};
+```
+3.静态方法类，禁用构造函数，防止创建实例
+
+```cpp
+class Helper {
  public:
   static bool DoSomething();
 
@@ -1597,25 +1605,26 @@ class Helper
   Helper();
 };
 ```
-4. 单例类，禁用构造函数，拷贝构造函数，防止创建实例
+4.单例类，禁用构造函数，拷贝构造函数，防止创建实例
 
 ```cpp
 class Foo {
  private:
-  static Foo *instance_;
+  static Foo *instance;
   Foo() {}
   Foo(const Foo &a);
   Foo& operator=(const Foo &a);
  public:
-  static Foo &instance() {
-    if (!instance_)
-      instance_ = new Foo();
-    return *instance_;
+  static Foo &Instance() {
+    if (!instance) {
+      instance = new Foo();
+    }
+    return *instance;
   }
 };
 ```
 
-5. 析构函数通过裸指针释放资源的，禁用拷贝构造、拷贝赋值，防止重复释放
+5.析构函数通过裸指针释放资源的，禁用拷贝构造、拷贝赋值，防止重复释放
 
 ```cpp
 class Foo {
@@ -1633,8 +1642,7 @@ class Foo {
   }
 };
 
-
-Foo* Foo::instance_ = nullptr;
+Foo* Foo::instance = nullptr;
 ```
 
 ### <a name="r7-1-4"></a>规则7.1.4 拷贝构造和拷贝赋值操作符应该是成对出现或者禁止
diff --git a/src/BUILD.gn b/src/BUILD.gn
index 6d5231e842923c4347a6dd93e94316c529a39e16..cab2a1b79d3541c98bbae37bddacb7b414c6771f 100644
--- a/src/BUILD.gn
+++ b/src/BUILD.gn
@@ -32,5 +32,6 @@ config("mapleallcompilecfg") {
 group("mapleall") {
   deps = [
     "${MAPLEALL_ROOT}/maple_driver:maple",
+    "${MAPLEALL_ROOT}/maple_ir:irbuild",
   ]
 }
diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl
index c6fb0c159eec2691f5650a38165543d16c12961b..51eaf158335be60db30f8dc54f1d816e7073d01a 100755
Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ
diff --git a/src/bin/maple b/src/bin/maple
index 24f6c41ff53f701a150e89423934db0a43c849e5..3c894dc2065639965f7246dbd6880f6dba0d8731 100755
Binary files a/src/bin/maple and b/src/bin/maple differ
diff --git a/src/bin/mplcg b/src/bin/mplcg
index eadd67e6a2b0907a52d0c5a0ed77cc7e80bb3311..152930e4d0a333c61f7b0185f16d2f5ae9a5058b 100755
Binary files a/src/bin/mplcg and b/src/bin/mplcg differ
diff --git a/src/deplibs/libmaple_driverutil.a b/src/deplibs/libmaple_driverutil.a
index 8d75632400f7345efa44a50cab20629a04fbf0a8..2b49fd1e96ee2b8bbbf3732a55788b347c86d190 100644
Binary files a/src/deplibs/libmaple_driverutil.a and b/src/deplibs/libmaple_driverutil.a differ
diff --git a/src/deplibs/libmplutil.a b/src/deplibs/libmplutil.a
index 1870e9609bf3cc5dd868278603caa5bba58c4ad8..8ac35620d909d91934585a1ad68f288e133a356f 100644
Binary files a/src/deplibs/libmplutil.a and b/src/deplibs/libmplutil.a differ
diff --git a/src/maple_driver/include/usages.h b/src/maple_driver/include/usages.h
index de543715afb988833810fedb06a5d71e22a6e686..f466bdc3694e21433fe71d51cb1f48b10f78f275 100644
--- a/src/maple_driver/include/usages.h
+++ b/src/maple_driver/include/usages.h
@@ -27,6 +27,9 @@ enum OptionIndex {
   kRun,
   kOption,
   kAllDebug,
+  // ----------jbc2mpl begin-------
+  kUseStringFactory,
+  kJbc2mplOutMpl,
   //-------- comb begin-------- --
   kCombTimePhases,
   kGenMeMpl,
@@ -66,6 +69,12 @@ enum OptionIndex {
   kMpl2MplMapleLinker,
   kMplnkDumpMuid,
   kEmitVtableImpl,
+  //----------mplcg begin---------
+  kCGQuiet,
+  kPie,
+  kPic,
+  kVerbose,
+  kCGMapleLinker,
 };
 
 enum EnabledIndex { kDisable, kEnable };
@@ -242,6 +251,31 @@ const static mapleOption::Descriptor USAGES[] = {
     "  --debug                     \tPrint debug info.\n",
     "all",
     { { nullptr } } },
+  // jbc2mpl
+  { kUseStringFactory,
+    0,
+    nullptr,
+    "use-string-factory",
+    nullptr,
+    false,
+    nullptr,
+    mapleOption::BuildType::kBuildTypeAll,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  -use-string-factory         \tReplace String.<init> by StringFactory call\n",
+    "jbc2mpl",
+    { { nullptr } } },
+  { kJbc2mplOutMpl,
+    0,
+    "o",
+    "out",
+    nullptr,
+    false,
+    nullptr,
+    mapleOption::BuildType::kBuildTypeDebug,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
+    "  -o, -out=output.mpl         \toutput mpl name\n",
+    "jbc2mpl",
+    { { nullptr } } },
   // me
   { kMeHelp,
     0,
@@ -672,6 +706,115 @@ const static mapleOption::Descriptor USAGES[] = {
     "mpl2mpl",
     { { nullptr } } },
 #endif
+  // mplcg
+  { kPie,
+    kEnable,
+    nullptr,
+    "pie",
+    nullptr,
+    false,
+    nullptr,
+    mapleOption::BuildType::kBuildTypeAll,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --pie                       \tGenerate position-independent executable\n",
+    "mplcg",
+    { { nullptr } } },
+  { kPie,
+    kDisable,
+    nullptr,
+    "no-pie",
+    nullptr,
+    false,
+    nullptr,
+    mapleOption::BuildType::kBuildTypeAll,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --no-pie\n",
+    "mplcg",
+    { { nullptr } } },
+  { kPic,
+    kEnable,
+    nullptr,
+    "fpic",
+    nullptr,
+    false,
+    nullptr,
+    mapleOption::BuildType::kBuildTypeAll,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --fpic                      \tGenerate position-independent shared library\n",
+    "mplcg",
+    { { nullptr } } },
+  { kPic,
+    kDisable,
+    nullptr,
+    "no-fpic",
+    nullptr,
+    false,
+    nullptr,
+    mapleOption::BuildType::kBuildTypeAll,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --no-fpic\n",
+    "mplcg",
+    { { nullptr } } },
+  { kVerbose,
+    kEnable,
+    nullptr,
+    "verbose-asm",
+    nullptr,
+    false,
+    nullptr,
+    mapleOption::BuildType::kBuildTypeAll,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --verbose-asm               \tAdd comments to asm output\n",
+    "mplcg",
+    { { nullptr } } },
+  { kVerbose,
+    kDisable,
+    nullptr,
+    "no-verbose-asm",
+    nullptr,
+    false,
+    nullptr,
+    mapleOption::BuildType::kBuildTypeAll,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --no-verbose-asm\n",
+    "mplcg",
+    { { nullptr } } },
+  { kCGMapleLinker,
+    kEnable,
+    nullptr,
+    "maplelinker",
+    nullptr,
+    false,
+    nullptr,
+    mapleOption::BuildType::kBuildTypeAll,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --maplelinker               \tGenerate the MapleLinker .s format\n",
+    "mplcg",
+    { { nullptr } } },
+  { kCGQuiet,
+    kEnable,
+    nullptr,
+    "quiet",
+    nullptr,
+    false,
+    nullptr,
+    mapleOption::BuildType::kBuildTypeAll,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --quiet                     \tBe quiet (don't output debug messages)\n",
+    "mplcg",
+    { { nullptr } } },
+  { kCGQuiet,
+    kDisable,
+    nullptr,
+    "no-quiet",
+    nullptr,
+    false,
+    nullptr,
+    mapleOption::BuildType::kBuildTypeAll,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --no-quiet\n",
+    "mplcg",
+    { { nullptr } } },
   // End
 
   { kUnknown,
diff --git a/src/maple_driver/src/maple_comb_compiler.cpp b/src/maple_driver/src/maple_comb_compiler.cpp
index 0373f6b819b795865e6a75e224eac641dbe66a04..8578aa3340038e6c83f04e1040a86fd1abe286fa 100644
--- a/src/maple_driver/src/maple_comb_compiler.cpp
+++ b/src/maple_driver/src/maple_comb_compiler.cpp
@@ -59,11 +59,11 @@ void MapleCombCompiler::PrintCommand(const MplOptions &options) const {
     } else {
       runStr += "mpl2mpl";
     }
-  }
-  auto inputMpl2mplOptions = options.exeOptions.find(kBinNameMpl2mpl);
-  for (auto &opt : inputMpl2mplOptions->second) {
-    connectSym = opt.Args() != "" ? "=" : "";
-    optionStr += " --" + opt.OptionKey() + connectSym + opt.Args();
+    auto inputMpl2mplOptions = options.exeOptions.find(kBinNameMpl2mpl);
+    for (auto &opt : inputMpl2mplOptions->second) {
+      connectSym = opt.Args() != "" ? "=" : "";
+      optionStr += " --" + opt.OptionKey() + connectSym + opt.Args();
+    }
   }
   optionStr += "\"";
   LogInfo::MapleLogger() << "Starting:" << options.exeFolder << "maple " << runStr << " " << optionStr << " "
diff --git a/src/maple_driver/src/mpl_options.cpp b/src/maple_driver/src/mpl_options.cpp
index 869d50e89fe4e8c5276df600fe548ed168298989..8b770293f3bb2656f4cec9189fa41ad91b3e717a 100644
--- a/src/maple_driver/src/mpl_options.cpp
+++ b/src/maple_driver/src/mpl_options.cpp
@@ -39,6 +39,7 @@ int MplOptions::Parse(int argc, char **argv) {
   if (ret != ErrorCode::kErrorNoError) {
     return ErrorCode::kErrorInvalidParameter;
   }
+  auto options = optionParser->GetOptions();
   // We should recognize O0, O2 and run options firstly to decide the real options
   for (auto opt : optionParser->GetOptions()) {
     switch (opt.Index()) {
@@ -264,43 +265,29 @@ ErrorCode MplOptions::UpdateExtraOptionOpt(const std::string &args) {
   }
   auto settingExe = runningExes.begin();
   for (const auto &tempIt : temp) {
-    bool ret = true;
+    ErrorCode ret = ErrorCode::kErrorNoError;
 
     std::vector<std::string> tmpArgs;
     // Split options with ' '
     StringUtils::Split(tempIt, tmpArgs, ' ');
     auto &exeOption = exeOptions[*settingExe];
+    ret = optionParser->HandleInputArgs(tmpArgs, *settingExe, exeOption);
+    if (ret != ErrorCode::kErrorNoError) {
+      return ret;
+    }
+    // Fill extraOption
     // For compiler bins called by system()
     auto &extraOption = extras[*settingExe];
-    for (const auto &argsIt : tmpArgs) {
+    for (int i = 0; i < exeOption.size(); i++) {
       MplOption mplOption;
-      // If "=" is not in the string, indicates that it is an option without value
-      if (argsIt.find("=") == std::string::npos) {
-        if (!argsIt.empty()) {
-          // Set key only
-          mplOption.init(argsIt, "", " ", false, "");
-          ret &= optionParser->SetOption(argsIt, "", *settingExe, exeOption);
-        } else {
-          continue;
-        }
+      if (exeOption[i].Args() != "") {
+        mplOption.init("-" + exeOption[i].OptionKey(), exeOption[i].Args(), "=", false, "");
       } else {
-        // If "=" is in the string, indicates that it is an option with value
-        std::vector<std::string> arg;
-        StringUtils::Split(argsIt, arg, '=');
-        if (arg.size() > 1) {
-          // Set key and value
-          mplOption.init(arg.at(0), arg.at(1), "=", false, "");
-          ret &= optionParser->SetOption(arg.at(0), arg.at(1), *settingExe, exeOption);
-        } else {
-          WARN(kLncWarn, "warning no args after \'=\' for " + arg.at(0));
-          continue;
-        }
+        mplOption.init("-" + exeOption[i].OptionKey(), "", " ", false, "");
       }
       extraOption.push_back(mplOption);
     }
-    if (!ret) {
-      return ErrorCode::kErrorInvalidParameter;
-    }
+
     settingExe++;
   }
   return ErrorCode::kErrorNoError;
diff --git a/src/maple_ir/BUILD.gn b/src/maple_ir/BUILD.gn
index 7566b5664f389acd53b301269b0496adb26f5ef6..0d5fa07eb62f6ee8ae1c0403c77a65038d3553d8 100644
--- a/src/maple_ir/BUILD.gn
+++ b/src/maple_ir/BUILD.gn
@@ -31,6 +31,8 @@ src_libmplir = [
   "src/bin_mpl_export.cpp",
 ]
 
+src_irbuild = [ "src/driver.cpp" ]
+
 configs = [ "${MAPLEALL_ROOT}:mapleallcompilecfg" ]
 
 cflags_cc += [ "-DSTORE_BACK_VTABLE_REF_AFTER_LOAD=1" ]
@@ -42,3 +44,19 @@ static_library("libmplir") {
   libs = []
   libs += [ "${OPENSOURCE_DEPS}/libmplutil.a" ]
 }
+
+executable("irbuild") {
+  sources = src_irbuild
+  include_dirs = include_directories
+  deps = [
+    ":libmplir",
+    "${MAPLEALL_ROOT}/huawei_secure_c:libHWSecureC",
+    "${MAPLEALL_ROOT}/mpl2mpl:libmpl2mpl",
+  ]
+  libs = []
+  libs += [
+    "${OPENSOURCE_DEPS}/libmplphase.a",
+    "${OPENSOURCE_DEPS}/libmempool.a",
+    "${OPENSOURCE_DEPS}/libmaple_driverutil.a",
+  ]
+}
diff --git a/src/maple_ir/include/intrinsics.def b/src/maple_ir/include/intrinsics.def
index 6b4c23eb736a58dbab9e8a3c115960a43e22090b..c8fe2c60fdc5d5ae711a641377db1b057473ba85 100644
--- a/src/maple_ir/include/intrinsics.def
+++ b/src/maple_ir/include/intrinsics.def
@@ -25,6 +25,8 @@ DEF_MIR_INTRINSIC(MPL_GET_VTAB_FUNC,\
                   "MCC_getFuncPtrFromVtab", kIntrnUndef, kArgTyA64, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
 DEF_MIR_INTRINSIC(MPL_READ_OVTABLE_ENTRY,\
                   "__mpl_const_offset", INTRNISPURE, kArgTyA32, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(MPL_READ_OVTABLE_ENTRY_LAZY,\
+                  "__mpl_const_offset_lazy", INTRNNOSIDEEFFECT, kArgTyA32, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
 DEF_MIR_INTRINSIC(MPL_READ_OVTABLE_ENTRY_VTAB_LAZY,\
                   "__mpl_const_offset_vtab_lazy", INTRNISPURE, kArgTyA32, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
 DEF_MIR_INTRINSIC(MPL_READ_OVTABLE_ENTRY_FIELD_LAZY,\
diff --git a/src/maple_ir/include/mir_builder.h b/src/maple_ir/include/mir_builder.h
index 88c994ffcc38b78f6deab2901f16d2df5bf4a967..001da552876368554420bd650bb26bc0aac0e03e 100644
--- a/src/maple_ir/include/mir_builder.h
+++ b/src/maple_ir/include/mir_builder.h
@@ -291,6 +291,10 @@ class MIRBuilder {
  private:
   MIRSymbol *GetOrCreateDecl(const std::string &str, const MIRType *type, MIRFunction *func, bool isLocal,
                              bool &created);
+  bool IsValidCallReturn(const MIRSymbol &ret) const {
+    return ret.GetStorageClass() == kScAuto || ret.GetStorageClass() == kScFormal ||
+           ret.GetStorageClass() == kScExtern || ret.GetStorageClass() == kScGlobal;
+  }
 };
 
 }  // namespace maple
diff --git a/src/maple_ir/include/mir_nodes.h b/src/maple_ir/include/mir_nodes.h
index 274475b71aa41e7dca8852555ccf17b5b35b1ea2..370391ef25623818419f95c37c40b8c62236c35e 100644
--- a/src/maple_ir/include/mir_nodes.h
+++ b/src/maple_ir/include/mir_nodes.h
@@ -274,6 +274,9 @@ class RetypeNode : public TypeCvtNode {
 
   explicit RetypeNode(PrimType typ) : TypeCvtNode(OP_retype, typ), tyIdx(0) {}
 
+  RetypeNode(PrimType typ, PrimType fromtyp, TyIdx idx, BaseNode *expr)
+      : TypeCvtNode(OP_retype, typ, fromtyp, expr), tyIdx(idx) {}
+
   ~RetypeNode() = default;
   void Dump(const MIRModule *mod, int32 indent) const;
 
@@ -380,6 +383,8 @@ class JarrayMallocNode : public UnaryNode {
 
   JarrayMallocNode(Opcode o, PrimType typ, TyIdx typeIdx) : UnaryNode(o, typ), tyIdx(typeIdx) {}
 
+  JarrayMallocNode(Opcode o, PrimType typ, TyIdx typeIdx, BaseNode *opnd) : UnaryNode(o, typ, opnd), tyIdx(typeIdx) {}
+
   ~JarrayMallocNode() = default;
 
   void Dump(const MIRModule *mod, int32 indent) const;
@@ -463,6 +468,8 @@ class IreadoffNode : public UnaryNode {
 
   IreadoffNode(PrimType ptyp, int32 ofst) : UnaryNode(OP_ireadoff, ptyp), offset(ofst) {}
 
+  IreadoffNode(PrimType ptyp, BaseNode *opnd, int32 ofst) : UnaryNode(OP_ireadoff, ptyp, opnd), offset(ofst) {}
+
   ~IreadoffNode() = default;
 
   void Dump(const MIRModule *mod, int32 indent) const;
@@ -882,7 +889,7 @@ class NaryNode : public BaseNode, public NaryOpnds {
 class IntrinsicopNode : public NaryNode {
  public:
   explicit IntrinsicopNode(MapleAllocator *allocator, Opcode o, TyIdx typeIdx = TyIdx())
-      : NaryNode(allocator, 0), intrinsic(INTRN_UNDEFINED), tyIdx(typeIdx) {}
+      : NaryNode(allocator, o), intrinsic(INTRN_UNDEFINED), tyIdx(typeIdx) {}
 
   explicit IntrinsicopNode(const MIRModule *mod, Opcode o, TyIdx typeIdx = TyIdx())
       : IntrinsicopNode(mod->CurFuncCodeMemPoolAllocator(), o, typeIdx) {}
@@ -1185,6 +1192,8 @@ class AddrofNode : public BaseNode {
  public:
   explicit AddrofNode(Opcode o) : BaseNode(o), stIdx(), fieldID(0) {}
 
+  AddrofNode(Opcode o, PrimType typ) : AddrofNode(o, typ, StIdx(), 0) {}
+
   AddrofNode(Opcode o, PrimType typ, StIdx sIdx, FieldID fid) : BaseNode(o, typ, 0), stIdx(sIdx), fieldID(fid) {}
 
   ~AddrofNode() = default;
@@ -1232,6 +1241,10 @@ class RegreadNode : public BaseNode {
 
   RegreadNode(PregIdx pIdx) : BaseNode(OP_regread), regIdx(pIdx) {}
 
+  RegreadNode(PrimType primType, PregIdx pIdx) : RegreadNode(pIdx) {
+    ptyp = primType;
+  }
+
   ~RegreadNode() = default;
 
   virtual void Dump(const MIRModule *mod, int32 indent) const;
@@ -1454,7 +1467,10 @@ class StmtNode : public BaseNode, public PtrListNodeBase<StmtNode> {
 
 class IassignNode : public StmtNode {
  public:
-  IassignNode() : StmtNode(OP_iassign), tyIdx(0), fieldID(0), addrExpr(nullptr), rhs(nullptr) {
+  IassignNode() : IassignNode(TyIdx(0), 0, nullptr, nullptr) {}
+
+  IassignNode(TyIdx tyIdx, FieldID fieldID, BaseNode *addrOpnd, BaseNode *rhsOpnd)
+      : StmtNode(OP_iassign), tyIdx(tyIdx), fieldID(fieldID), addrExpr(addrOpnd), rhs(rhsOpnd) {
     SetNumOpnds(2);
   }
 
@@ -1607,6 +1623,8 @@ class TryNode : public StmtNode {
  public:
   explicit TryNode(MapleAllocator *allocator) : StmtNode(OP_try), offsets(allocator->Adapter()) {}
 
+  TryNode(MapleAllocator *allocator, const MapleVector<LabelIdx> &offsets) : StmtNode(OP_try), offsets(offsets) {}
+
   explicit TryNode(const MIRModule *mod) : TryNode(mod->CurFuncCodeMemPoolAllocator()) {}
 
   TryNode(TryNode &node) = delete;
@@ -1642,6 +1660,19 @@ class TryNode : public StmtNode {
     return offsets.size();
   }
 
+  MapleVector<LabelIdx>::iterator GetOffsetsBegin() {
+    return offsets.begin();
+  }
+
+  MapleVector<LabelIdx>::iterator GetOffsetsEnd() {
+    return offsets.end();
+  }
+
+  void OffsetsInsert(MapleVector<LabelIdx>::iterator a, MapleVector<LabelIdx>::iterator b,
+                     MapleVector<LabelIdx>::iterator c) {
+    offsets.insert(a, b, c);
+  }
+
   TryNode *CloneTree(MapleAllocator *allocator) const {
     TryNode *nd = allocator->GetMemPool()->New<TryNode>(allocator);
     nd->SetStmtID(stmtIDNext++);
@@ -1660,6 +1691,9 @@ class CatchNode : public StmtNode {
  public:
   explicit CatchNode(MapleAllocator *allocator) : StmtNode(OP_catch), exceptionTyIdxVec(allocator->Adapter()) {}
 
+  CatchNode(MapleAllocator *allocator, const MapleVector<TyIdx> &tyIdxVec)
+      : StmtNode(OP_catch), exceptionTyIdxVec(tyIdxVec) {}
+
   explicit CatchNode(const MIRModule *mod) : CatchNode(mod->CurFuncCodeMemPoolAllocator()) {}
 
   CatchNode(CatchNode &node) = delete;
@@ -1718,8 +1752,10 @@ class SwitchNode : public StmtNode {
 
   explicit SwitchNode(const MIRModule *mod) : SwitchNode(mod->CurFuncCodeMemPoolAllocator()) {}
 
-  SwitchNode(MapleAllocator *allocator, LabelIdx label)
-      : StmtNode(OP_switch, 1), switchOpnd(nullptr), defaultLabel(label), switchTable(allocator->Adapter()) {}
+  SwitchNode(MapleAllocator *allocator, LabelIdx label) : SwitchNode(allocator, label, nullptr) {}
+
+  SwitchNode(MapleAllocator *allocator, LabelIdx label, BaseNode *opnd)
+      : StmtNode(OP_switch, 1), switchOpnd(opnd), defaultLabel(label), switchTable(allocator->Adapter()) {}
 
   SwitchNode(const MIRModule *mod, LabelIdx label) : SwitchNode(mod->CurFuncCodeMemPoolAllocator(), label) {}
 
@@ -1929,6 +1965,8 @@ class DassignNode : public UnaryStmtNode {
   DassignNode(PrimType typ, BaseNode *opnd, StIdx idx, FieldID fieldID)
       : UnaryStmtNode(OP_dassign, typ, opnd), stIdx(idx), fieldID(fieldID) {}
 
+  DassignNode(BaseNode *opnd, StIdx idx, FieldID fieldID) : DassignNode(kPtyInvalid, opnd, idx, fieldID) {}
+
   ~DassignNode() = default;
 
   void Dump(const MIRModule *mod, int32 indent) const;
@@ -1990,6 +2028,9 @@ class RegassignNode : public UnaryStmtNode {
 
   explicit RegassignNode(const RegassignNode &node) : UnaryStmtNode(node), regIdx(node.regIdx) {}
 
+  RegassignNode(PrimType primType, PregIdx idx, BaseNode *opnd)
+      : UnaryStmtNode(OP_regassign, primType, opnd), regIdx(idx) {}
+
   ~RegassignNode() = default;
 
   void Dump(const MIRModule *mod, int32 indent) const;
@@ -2029,7 +2070,9 @@ class RegassignNode : public UnaryStmtNode {
 // brtrue and brfalse
 class CondGotoNode : public UnaryStmtNode {
  public:
-  explicit CondGotoNode(Opcode o) : UnaryStmtNode(o), offset(0) {
+  explicit CondGotoNode(Opcode o) : CondGotoNode(o, 0, nullptr) {}
+
+  CondGotoNode(Opcode o, uint32 offset, BaseNode *opnd) : UnaryStmtNode(o, kPtyInvalid, opnd), offset(offset) {
     SetNumOpnds(1);
   }
 
@@ -2311,14 +2354,16 @@ class WhileStmtNode : public UnaryStmtNode {
 
 class DoloopNode : public StmtNode {
  public:
-  DoloopNode()
+  DoloopNode() : DoloopNode(StIdx(), false, nullptr, nullptr, nullptr, nullptr) {}
+
+  DoloopNode(StIdx doVarStIdx, bool isPReg, BaseNode *startExp, BaseNode *contExp, BaseNode *incrExp, BlockNode *doBody)
       : StmtNode(OP_doloop, 4),
-        doVarStIdx(),
-        isPreg(false),
-        startExpr(nullptr),
-        condExpr(nullptr),
-        incrExpr(nullptr),
-        doBody(nullptr) {}
+        doVarStIdx(doVarStIdx),
+        isPreg(isPReg),
+        startExpr(startExp),
+        condExpr(contExp),
+        incrExpr(incrExp),
+        doBody(doBody) {}
 
   ~DoloopNode() = default;
 
@@ -2527,6 +2572,12 @@ class IassignoffNode : public BinaryStmtNode {
 
   explicit IassignoffNode(int32 ofst) : BinaryStmtNode(OP_iassignoff), offset(ofst) {}
 
+  IassignoffNode(PrimType primType, int32 offset, BaseNode *addrOpnd, BaseNode *srcOpnd) : IassignoffNode(offset) {
+    SetPrimType(primType);
+    SetBOpnd(addrOpnd, 0);
+    SetBOpnd(srcOpnd, 1);
+  }
+
   ~IassignoffNode() = default;
 
   void Dump(const MIRModule *mod, int32 indent) const;
@@ -2547,6 +2598,11 @@ class IassignFPoffNode : public UnaryStmtNode {
 
   explicit IassignFPoffNode(int32 ofst) : UnaryStmtNode(OP_iassignfpoff), offset(ofst) {}
 
+  IassignFPoffNode(PrimType primType, int32 offset, BaseNode *src) : IassignFPoffNode(offset) {
+    SetPrimType(primType);
+    SetOpnd(src);
+  }
+
   ~IassignFPoffNode() = default;
 
   void Dump(const MIRModule *mod, int32 indent) const;
@@ -2613,6 +2669,18 @@ class NaryStmtNode : public StmtNode, public NaryOpnds {
     ASSERT(numopnds == GetNopndSize(), "NaryStmtNode has wrong numopnds field");
     return GetNopndSize();
   }
+
+  void SetOpnds(const MapleVector<BaseNode*> &arguments) {
+    SetNOpnd(arguments);
+    SetNumOpnds(arguments.size());
+  }
+
+  void PushOpnd(BaseNode *node) {
+    if (node != nullptr) {
+      GetNopnd().push_back(node);
+    }
+    SetNumOpnds(GetNopndSize());
+  }
 };
 
 class ReturnValuePart {
@@ -2635,6 +2703,8 @@ class CallNode : public NaryStmtNode {
   CallNode(MapleAllocator *allocator, Opcode o)
       : NaryStmtNode(allocator, o), puIdx(0), tyIdx(0), returnValues(allocator->Adapter()) {}
 
+  CallNode(MapleAllocator *allocator, Opcode o, PUIdx idx) : CallNode(allocator, o, idx, TyIdx()) {}
+
   CallNode(MapleAllocator *allocator, Opcode o, PUIdx idx, TyIdx tdx)
       : NaryStmtNode(allocator, o), puIdx(idx), tyIdx(tdx), returnValues(allocator->Adapter()) {}
 
diff --git a/src/maple_ir/include/mir_symbol.h b/src/maple_ir/include/mir_symbol.h
index 928db876c11ce5c4ee0e07379482feb887ce8158..c8cd04df6ba7a8868f10f4807e880da9410ce561 100644
--- a/src/maple_ir/include/mir_symbol.h
+++ b/src/maple_ir/include/mir_symbol.h
@@ -533,6 +533,14 @@ class MIRLabelTable {
     labelTable[idx] = strIdx;
   }
 
+  MapleVector<GStrIdx> GetLabelTable() {
+    return labelTable;
+  }
+
+  MapleMap<GStrIdx, LabelIdx> &GetStrIdxToLabelIdxMap() {
+    return strIdxToLabIdxMap;
+  }
+
  private:
   static constexpr uint32 kDummyLabel = 0;
   MapleAllocator *mAllocator;
diff --git a/src/maple_ir/src/driver.cpp b/src/maple_ir/src/driver.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c4c23b62b2daa7eee1c25742d879898b4c5a3aa9
--- /dev/null
+++ b/src/maple_ir/src/driver.cpp
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * 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 Mulan PSL v1 for more details.
+ */
+#include <cstdlib>
+#include <iostream>
+#include <fstream>
+#include "mir_parser.h"
+#include "bin_mplt.h"
+#include "opcode_info.h"
+#include "mir_function.h"
+#include "mir_type.h"
+
+using namespace maple;
+#if MIR_FEATURE_FULL
+void ConstantFoldModule(maple::MIRModule *module) {
+  MapleVector<maple::MIRFunction*> &funcList = module->GetFunctionList();
+  for (auto it = funcList.begin(); it != funcList.end(); it++) {
+    maple::MIRFunction *curfun = *it;
+    module->SetCurFunction(curfun);
+  }
+}
+
+int main(int argc, char **argv) {
+  if (argc < 2) {
+    MIR_PRINTF(
+        "usage: ./irbuild [i|e] <any number of mpl files>\n\n"
+        "The optional 'i' flag will convert the binary mplt input file to ascii\n\n"
+        "The optional 'e' flag will convert the textual mplt input file to binary\n");
+    exit(1);
+  }
+  char flag = '\0';
+  maple::int32 i = 1;
+  if (argv[1][0] == 'i' && argv[1][1] == '\0') {
+    flag = 'i';
+    i = 2;
+  } else if (argv[1][0] == 'e' && argv[1][1] == '\0') {
+    flag = 'e';
+    i = 2;
+  }
+  while (i < argc) {
+    maple::MIRModule module{ argv[i] };
+    if (flag == '\0') {
+      maple::MIRParser theparser(module);
+      if (theparser.ParseMIR()) {
+        ConstantFoldModule(&module);
+        module.OutputAsciiMpl(".irb");
+      } else {
+        theparser.EmitError(module.GetFileName().c_str());
+        return 1;
+      }
+    } else if (flag == 'e') {
+      maple::MIRParser theparser(module);
+      if (theparser.ParseMIR()) {
+        ConstantFoldModule(&module);
+        BinaryMplt binmplt(module);
+        std::string modid = module.GetFileName();
+        binmplt.Export("bin." + modid);
+      } else {
+        theparser.EmitError(module.GetFileName().c_str());
+        return 1;
+      }
+    } else if (flag == 'i') {
+      module.SetFlavor(kFeProduced);
+      module.SetSrcLang(kSrcLangJava);
+      BinaryMplImport binmplt(module);
+      binmplt.SetImported(false);
+      std::string modid = module.GetFileName();
+      binmplt.Import(modid, true);
+      module.OutputAsciiMpl(".irb");
+    }
+    i++;
+  }
+  return 0;
+}
+
+/* hello.mpl
+   flavor 1
+   srclang 3
+
+   type $person <struct {@age i64,
+                      @data <* f32>}>
+   var $BOB i32 = 8
+ */
+#else
+#warning "this module is compiled without MIR_FEATURE_FULL=1 defined"
+#endif  // MIR_FEATURE_FULL
diff --git a/src/maple_ir/src/mir_builder.cpp b/src/maple_ir/src/mir_builder.cpp
index d14f26e32f37e7dd5e15ed23b75614235544a775..f73b0360cf8202e4626c7280845788e097372ce5 100644
--- a/src/maple_ir/src/mir_builder.cpp
+++ b/src/maple_ir/src/mir_builder.cpp
@@ -20,10 +20,9 @@ namespace maple {
 // This is for compiler-generated metadata 1-level struct
 void MIRBuilder::AddIntFieldConst(const MIRStructType *sType, MIRAggConst *newConst, uint32 fieldID, int64 constValue) {
   if (sType != nullptr && newConst != nullptr) {
-    MIRConst *fieldConst = mirModule->GetMemPool()->New<MIRIntConst>(constValue, sType->GetElemType(fieldID - 1));
-    MapleVector<MIRConst*> &constVec = newConst->GetConstVec();
-    fieldConst->SetFieldID(fieldID);
-    constVec.push_back(fieldConst);
+    MIRConst *fieldConst = mirModule->GetMemPool()->New<MIRIntConst>(constValue,
+                                                                     sType->GetElemType(fieldID - 1), fieldID);
+    newConst->GetConstVec().push_back(fieldConst);
   }
 }
 
@@ -34,9 +33,8 @@ void MIRBuilder::AddAddrofFieldConst(const MIRStructType *structType, MIRAggCons
     AddrofNode *fieldExpr = CreateExprAddrof(0, fieldSymbol, mirModule->GetMemPool());
     MIRConst *fieldConst = mirModule->GetMemPool()->New<MIRAddrofConst>(fieldExpr->GetStIdx(), fieldExpr->GetFieldID(),
                                                                         structType->GetElemType(fieldID - 1));
-    MapleVector<MIRConst*> &constVec = newConst->GetConstVec();
     fieldConst->SetFieldID(fieldID);
-    constVec.push_back(fieldConst);
+    newConst->GetConstVec().push_back(fieldConst);
   }
 }
 
@@ -47,16 +45,14 @@ void MIRBuilder::AddAddroffuncFieldConst(const MIRStructType *structType, MIRAgg
     MIRConst *fieldConst = nullptr;
     MIRFunction *vMethod = funcSymbol->GetFunction();
     if (vMethod->IsAbstract()) {
-      fieldConst = mirModule->GetMemPool()->New<MIRIntConst>(0, structType->GetElemType(fieldID - 1));
+      fieldConst = mirModule->GetMemPool()->New<MIRIntConst>(0, structType->GetElemType(fieldID - 1), fieldID);
     } else {
       AddroffuncNode *addrofFuncExpr =
           CreateExprAddroffunc(funcSymbol->GetFunction()->GetPuidx(), mirModule->GetMemPool());
       fieldConst = mirModule->GetMemPool()->New<MIRAddroffuncConst>(addrofFuncExpr->GetPUIdx(),
-                                                                    structType->GetElemType(fieldID - 1));
+                                                                    structType->GetElemType(fieldID - 1), fieldID);
     }
-    fieldConst->SetFieldID(fieldID);
-    MapleVector<MIRConst*> &constVec = newConst->GetConstVec();
-    constVec.push_back(fieldConst);
+    newConst->GetConstVec().push_back(fieldConst);
   }
 }
 
@@ -454,94 +450,72 @@ MIRSymbol *MIRBuilder::GetOrCreateGlobalDecl(const std::string &str, const MIRTy
 }
 
 ConstvalNode *MIRBuilder::CreateIntConst(int64 val, PrimType pty) {
-  ConstvalNode *constvalNode = GetCurrentFuncCodeMp()->New<ConstvalNode>();
   MIRFunction *currentFunctionInner = GetCurrentFunction();
   ASSERT(currentFunctionInner != nullptr, "null ptr check");
-  MIRIntConst *intConst =
+  MIRIntConst *mirConst =
       currentFunctionInner->GetDataMemPool()->New<MIRIntConst>(val, GlobalTables::GetTypeTable().GetPrimType(pty));
-  constvalNode->SetPrimType(pty);
-  constvalNode->SetConstVal(intConst);
-  return constvalNode;
+  return GetCurrentFuncCodeMp()->New<ConstvalNode>(pty, mirConst);
 }
 
 ConstvalNode *MIRBuilder::CreateFloatConst(float val) {
-  ConstvalNode *constvalNode = GetCurrentFuncCodeMp()->New<ConstvalNode>();
   MIRFunction *currentFunctionInner = GetCurrentFunction();
   ASSERT(currentFunctionInner != nullptr, "null ptr check");
-  MIRFloatConst *floatConst = currentFunctionInner->GetDataMemPool()->New<MIRFloatConst>(
+  MIRFloatConst *mirConst = currentFunctionInner->GetDataMemPool()->New<MIRFloatConst>(
       val, GlobalTables::GetTypeTable().GetPrimType(PTY_f32));
-  constvalNode->SetPrimType(PTY_f32);
-  constvalNode->SetConstVal(floatConst);
-  return constvalNode;
+  return GetCurrentFuncCodeMp()->New<ConstvalNode>(PTY_f32, mirConst);
 }
 
 ConstvalNode *MIRBuilder::CreateDoubleConst(double val) {
-  ConstvalNode *constvalNode = GetCurrentFuncCodeMp()->New<ConstvalNode>();
   MIRFunction *currentFunctionInner = GetCurrentFunction();
   ASSERT(currentFunctionInner != nullptr, "null ptr check");
-  MIRDoubleConst *dblConst = currentFunctionInner->GetDataMemPool()->New<MIRDoubleConst>(
+  MIRDoubleConst *mirConst = currentFunctionInner->GetDataMemPool()->New<MIRDoubleConst>(
       val, GlobalTables::GetTypeTable().GetPrimType(PTY_f64));
-  constvalNode->SetPrimType(PTY_f64);
-  constvalNode->SetConstVal(dblConst);
-  return constvalNode;
+  return GetCurrentFuncCodeMp()->New<ConstvalNode>(PTY_f64, mirConst);
 }
 
 ConstvalNode *MIRBuilder::CreateFloat128Const(const uint64 *val) {
-  ConstvalNode *constvalNode = GetCurrentFuncCodeMp()->New<ConstvalNode>();
   MIRFunction *currentFunctionInner = GetCurrentFunction();
   ASSERT(currentFunctionInner != nullptr, "null ptr check");
-  MIRFloat128Const *f128Const = currentFunctionInner->GetDataMemPool()->New<MIRFloat128Const>(
+  MIRFloat128Const *mirConst = currentFunctionInner->GetDataMemPool()->New<MIRFloat128Const>(
       val, GlobalTables::GetTypeTable().GetPrimType(PTY_f128));
-  constvalNode->SetPrimType(PTY_f128);
-  constvalNode->SetConstVal(f128Const);
-  return constvalNode;
+  return GetCurrentFuncCodeMp()->New<ConstvalNode>(PTY_f128, mirConst);
 }
 
 ConstvalNode *MIRBuilder::GetConstInt(MemPool *memPool, int i) {
-  ConstvalNode *constvalNode = memPool->New<ConstvalNode>();
-  MIRIntConst *intConst = memPool->New<MIRIntConst>(i, GlobalTables::GetTypeTable().GetInt64());
-  constvalNode->SetPrimType(PTY_i32);
-  constvalNode->SetConstVal(intConst);
-  return constvalNode;
+  MIRIntConst *mirConst = memPool->New<MIRIntConst>(i, GlobalTables::GetTypeTable().GetInt64());
+  return memPool->New<ConstvalNode>(PTY_i32, mirConst);
 }
 
 ConstvalNode *MIRBuilder::CreateAddrofConst(BaseNode *e) {
-  ConstvalNode *constvalNode = GetCurrentFuncCodeMp()->New<ConstvalNode>();
   ASSERT(e->GetOpCode() == OP_addrof, "illegal op for addrof const");
-  AddrofNode *aNode = static_cast<AddrofNode*>(e);
-  // determine the type of 'e' and create a pointer type, accordingly
   MIRFunction *currentFunctionInner = GetCurrentFunction();
   ASSERT(currentFunctionInner != nullptr, "null ptr check");
-  MIRSymbol *var = currentFunctionInner->GetLocalOrGlobalSymbol(static_cast<AddrofNode*>(e)->GetStIdx());
+
+  // determine the type of 'e' and create a pointer type, accordingly
+  AddrofNode *aNode = static_cast<AddrofNode*>(e);
+  MIRSymbol *var = currentFunctionInner->GetLocalOrGlobalSymbol(aNode->GetStIdx());
   TyIdx ptyIdx = var->GetTyIdx();
   MIRPtrType ptrType(ptyIdx);
   ptyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType);
   MIRType *exprty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptyIdx);
-  MIRAddrofConst *addr = mirModule->GetMemPool()->New<MIRAddrofConst>(aNode->GetStIdx(), aNode->GetFieldID(), exprty);
-  constvalNode->SetPrimType(PTY_ptr);
-  constvalNode->SetConstVal(addr);
-  return constvalNode;
+  MIRAddrofConst *temp = mirModule->GetMemPool()->New<MIRAddrofConst>(aNode->GetStIdx(), aNode->GetFieldID(), exprty);
+  return GetCurrentFuncCodeMp()->New<ConstvalNode>(PTY_ptr, temp);
 }
 
 ConstvalNode *MIRBuilder::CreateAddroffuncConst(const BaseNode *e) {
-  ConstvalNode *constvalNode = GetCurrentFuncCodeMp()->New<ConstvalNode>();
   ASSERT(e->GetOpCode() == OP_addroffunc, "illegal op for addroffunc const");
-  MIRFunction *f =
-      GlobalTables::GetFunctionTable().GetFunctionFromPuidx(static_cast<const AddroffuncNode*>(e)->GetPUIdx());
-  MIRSymbol *fname = f->GetFuncSymbol();
-  TyIdx ptyIdx = fname->GetTyIdx();
+
+  const AddroffuncNode *aNode = static_cast<const AddroffuncNode*>(e);
+  MIRFunction *f = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(aNode->GetPUIdx());
+  TyIdx ptyIdx = f->GetFuncSymbol()->GetTyIdx();
   MIRPtrType ptrType(ptyIdx);
   ptyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType);
   MIRType *exprty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptyIdx);
-  MIRAddroffuncConst *fadr =
-      mirModule->GetMemPool()->New<MIRAddroffuncConst>(static_cast<const AddroffuncNode*>(e)->GetPUIdx(), exprty);
-  constvalNode->SetPrimType(PTY_ptr);
-  constvalNode->SetConstVal(fadr);
-  return constvalNode;
+  MIRAddroffuncConst *mirConst = mirModule->GetMemPool()->New<MIRAddroffuncConst>(aNode->GetPUIdx(), exprty);
+  return GetCurrentFuncCodeMp()->New<ConstvalNode>(PTY_ptr, mirConst);
 }
 
 ConstvalNode *MIRBuilder::CreateStrConst(const BaseNode *e) {
-  ConstvalNode *constvalNode = GetCurrentFuncCodeMp()->New<ConstvalNode>();
   ASSERT(e->GetOpCode() == OP_conststr, "illegal op for conststr const");
   UStrIdx strIdx = static_cast<const ConststrNode*>(e)->GetStrIdx();
   CHECK_FATAL(PTY_u8 < GlobalTables::GetTypeTable().GetTypeTable().size(),
@@ -550,14 +524,11 @@ ConstvalNode *MIRBuilder::CreateStrConst(const BaseNode *e) {
   MIRPtrType ptrType(ptyidx);
   ptyidx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType);
   MIRType *exprType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptyidx);
-  MIRStrConst *cStr = mirModule->GetMemPool()->New<MIRStrConst>(strIdx, exprType);
-  constvalNode->SetPrimType(PTY_ptr);
-  constvalNode->SetConstVal(cStr);
-  return constvalNode;
+  MIRStrConst *mirConst = mirModule->GetMemPool()->New<MIRStrConst>(strIdx, exprType);
+  return GetCurrentFuncCodeMp()->New<ConstvalNode>(PTY_ptr, mirConst);
 }
 
 ConstvalNode *MIRBuilder::CreateStr16Const(const BaseNode *e) {
-  ConstvalNode *constvalNode = GetCurrentFuncCodeMp()->New<ConstvalNode>();
   ASSERT(e->GetOpCode() == OP_conststr16, "illegal op for conststr16 const");
   U16StrIdx strIdx = static_cast<const Conststr16Node*>(e)->GetStrIdx();
   CHECK_FATAL(PTY_u16 < GlobalTables::GetTypeTable().GetTypeTable().size(),
@@ -566,10 +537,8 @@ ConstvalNode *MIRBuilder::CreateStr16Const(const BaseNode *e) {
   MIRPtrType ptrType(ptyIdx);
   ptyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType);
   MIRType *exprty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptyIdx);
-  MIRStr16Const *cstr = mirModule->GetMemPool()->New<MIRStr16Const>(strIdx, exprty);
-  constvalNode->SetPrimType(PTY_ptr);
-  constvalNode->SetConstVal(cstr);
-  return constvalNode;
+  MIRStr16Const *mirConst = mirModule->GetMemPool()->New<MIRStr16Const>(strIdx, exprty);
+  return GetCurrentFuncCodeMp()->New<ConstvalNode>(PTY_ptr, mirConst);
 }
 
 MIRSymbol *MIRBuilder::GetSymbolFromEnclosingScope(StIdx stIdx) {
@@ -589,8 +558,7 @@ MIRSymbol *MIRBuilder::GetSymbolFromEnclosingScope(StIdx stIdx) {
 
 MIRSymbol *MIRBuilder::GetSymbol(TyIdx tyIdx, const std::string &name, MIRSymKind mClass, MIRStorageClass sClass,
                                  MIRFunction *func, uint8 scpID, bool sameType = false) {
-  GStrIdx strIdx = GetOrCreateStringIndex(name);
-  return GetSymbol(tyIdx, strIdx, mClass, sClass, func, scpID, sameType);
+  return GetSymbol(tyIdx, GetOrCreateStringIndex(name), mClass, sClass, func, scpID, sameType);
 }
 
 // when sametype is true, it means match everything the of the symbol
@@ -622,8 +590,7 @@ MIRSymbol *MIRBuilder::GetSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind mClass,
 MIRSymbol *MIRBuilder::GetOrCreateSymbol(TyIdx tyIdx, const std::string &name, MIRSymKind mClass,
                                          MIRStorageClass sClass, MIRFunction *func, uint8 scpID,
                                          bool sametype = false) {
-  GStrIdx stridx = GetOrCreateStringIndex(name);
-  return GetOrCreateSymbol(tyIdx, stridx, mClass, sClass, func, scpID, sametype);
+  return GetOrCreateSymbol(tyIdx, GetOrCreateStringIndex(name), mClass, sClass, func, scpID, sametype);
 }
 
 MIRSymbol *MIRBuilder::GetOrCreateSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind mClass, MIRStorageClass sClass,
@@ -637,8 +604,7 @@ MIRSymbol *MIRBuilder::GetOrCreateSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind
 // when func is null, create global symbol, otherwise create local symbol
 MIRSymbol *MIRBuilder::CreateSymbol(TyIdx tyIdx, const std::string &name, MIRSymKind mClass, MIRStorageClass sClass,
                                     MIRFunction *func, uint8 scpID) {
-  GStrIdx stridx = GetOrCreateStringIndex(name);
-  return CreateSymbol(tyIdx, stridx, mClass, sClass, func, scpID);
+  return CreateSymbol(tyIdx, GetOrCreateStringIndex(name), mClass, sClass, func, scpID);
 }
 
 // when func is null, create global symbol, otherwise create local symbol
@@ -730,57 +696,33 @@ MIRFunction *MIRBuilder::CreateFunction(const StIdx stIdx, bool addToTable) {
 }
 
 SizeoftypeNode *MIRBuilder::CreateExprSizeoftype(const MIRType *type) {
-  SizeoftypeNode *sizeOfTypeNode = GetCurrentFuncCodeMp()->New<SizeoftypeNode>();
-  sizeOfTypeNode->SetPrimType(PTY_u32);
-  sizeOfTypeNode->SetTyIdx(type->GetTypeIndex());
-  return sizeOfTypeNode;
+  return GetCurrentFuncCodeMp()->New<SizeoftypeNode>(PTY_u32, type->GetTypeIndex());
 }
 
 FieldsDistNode *MIRBuilder::CreateExprFieldsDist(const MIRType *type, FieldID field1, FieldID field2) {
-  FieldsDistNode *node = GetCurrentFuncCodeMp()->New<FieldsDistNode>();
-  node->SetPrimType(PTY_i32);
-  node->SetTyIdx(type->GetTypeIndex());
-  node->SetFiledID1(field1);
-  node->SetFiledID2(field2);
-  return node;
+  return GetCurrentFuncCodeMp()->New<FieldsDistNode>(PTY_i32, type->GetTypeIndex(), field1, field2);
 }
 
 AddrofNode *MIRBuilder::CreateExprAddrof(FieldID fieldID, const MIRSymbol *symbol, MemPool *memPool) {
-  if (memPool == nullptr) {
-    memPool = GetCurrentFuncCodeMp();
-  }
-  AddrofNode *addrofNode = memPool->New<AddrofNode>(OP_addrof);
-  addrofNode->SetPrimType(PTY_ptr);
-  addrofNode->SetStIdx(symbol->GetStIdx());
-  addrofNode->SetFieldID(fieldID);
-  return addrofNode;
+  return CreateExprAddrof(fieldID, symbol->GetStIdx(), memPool);
 }
 
 AddrofNode *MIRBuilder::CreateExprAddrof(FieldID fieldID, StIdx symbolStIdx, MemPool *memPool) {
   if (memPool == nullptr) {
     memPool = GetCurrentFuncCodeMp();
   }
-  AddrofNode *addrofNode = memPool->New<AddrofNode>(OP_addrof);
-  addrofNode->SetPrimType(PTY_ptr);
-  addrofNode->SetStIdx(symbolStIdx);
-  addrofNode->SetFieldID(fieldID);
-  return addrofNode;
+  return memPool->New<AddrofNode>(OP_addrof, PTY_ptr, symbolStIdx, fieldID);
 }
 
 AddroffuncNode *MIRBuilder::CreateExprAddroffunc(PUIdx puIdx, MemPool *memPool) {
   if (memPool == nullptr) {
     memPool = GetCurrentFuncCodeMp();
   }
-  AddroffuncNode *addrofFunc = memPool->New<AddroffuncNode>();
-  addrofFunc->SetPrimType(PTY_ptr);
-  addrofFunc->SetPUIdx(puIdx);
-  return addrofFunc;
+  return memPool->New<AddroffuncNode>(PTY_ptr, puIdx);
 }
 
 AddrofNode *MIRBuilder::CreateExprDread(const MIRType *type, FieldID fieldID, const MIRSymbol *symbol) {
-  AddrofNode *drn = GetCurrentFuncCodeMp()->New<AddrofNode>(OP_dread);
-  drn->SetStIdx(symbol->GetStIdx());
-  drn->SetFieldID(fieldID);
+  AddrofNode *drn = GetCurrentFuncCodeMp()->New<AddrofNode>(OP_dread, kPtyInvalid, symbol->GetStIdx(), fieldID);
   CHECK(type->GetTypeIndex().GetIdx() < GlobalTables::GetTypeTable().GetTypeTable().size(),
         "index out of range in MIRBuilder::CreateExprDread");
   drn->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(type->GetTypeIndex()));
@@ -788,10 +730,7 @@ AddrofNode *MIRBuilder::CreateExprDread(const MIRType *type, FieldID fieldID, co
 }
 
 RegreadNode *MIRBuilder::CreateExprRegread(PrimType pty, PregIdx regIdx) {
-  RegreadNode *regRead = GetCurrentFuncCodeMp()->New<RegreadNode>();
-  regRead->SetPrimType(pty);
-  regRead->SetRegIdx(regIdx);
-  return regRead;
+  return GetCurrentFuncCodeMp()->New<RegreadNode>(pty, regIdx);
 }
 
 AddrofNode *MIRBuilder::CreateExprDread(MIRType *type, MIRSymbol *symbol) {
@@ -811,42 +750,28 @@ AddrofNode *MIRBuilder::CreateExprDread(MIRSymbol *symbol) {
 }
 
 AddrofNode *MIRBuilder::CreateExprDread(PregIdx pregID, PrimType pty) {
-  AddrofNode *dread = GetCurrentFuncCodeMp()->New<AddrofNode>(OP_dread);
-  dread->SetPrimType(pty);
+  AddrofNode *dread = GetCurrentFuncCodeMp()->New<AddrofNode>(OP_dread, pty);
   dread->GetStIdx().SetFullIdx(pregID);
   return dread;
 }
 
 IreadNode *MIRBuilder::CreateExprIread(const MIRType *returnType, const MIRType *ptrType, FieldID fieldID,
                                        BaseNode *addr) {
-  IreadNode *irn = GetCurrentFuncCodeMp()->New<IreadNode>(OP_iread);
-  TyIdx ptrTypeIdx = ptrType->GetTypeIndex();
   TyIdx returnTypeIdx = returnType->GetTypeIndex();
   ASSERT(returnTypeIdx.GetIdx() < GlobalTables::GetTypeTable().GetTypeTable().size(),
-        "index out of range in MIRBuilder::CreateExprIread");
-  irn->SetPrimType(GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(returnTypeIdx));
-  irn->SetTyIdx(ptrTypeIdx);
-
+         "index out of range in MIRBuilder::CreateExprIread");
   ASSERT(fieldID != 0 || ptrType->GetPrimType() != PTY_agg,
          "Error: Fieldid should not be 0 when trying to iread a field from type ");
-  irn->SetFieldID(fieldID);
-  irn->SetOpnd(addr);
-  return irn;
+  PrimType type = GlobalTables::GetTypeTable().GetPrimTypeFromTyIdx(returnTypeIdx);
+  return GetCurrentFuncCodeMp()->New<IreadNode>(OP_iread, type, ptrType->GetTypeIndex(), fieldID, addr);
 }
 
 IreadoffNode *MIRBuilder::CreateExprIreadoff(PrimType pty, int32 offset, BaseNode *opnd0) {
-  IreadoffNode *ireadOff = GetCurrentFuncCodeMp()->New<IreadoffNode>();
-  ireadOff->SetPrimType(pty);
-  ireadOff->SetOffset(offset);
-  ireadOff->SetOpnd(opnd0);
-  return ireadOff;
+  return GetCurrentFuncCodeMp()->New<IreadoffNode>(pty, opnd0, offset);
 }
 
 IreadFPoffNode *MIRBuilder::CreateExprIreadFPoff(PrimType pty, int32 offset) {
-  IreadFPoffNode *ireadOff = GetCurrentFuncCodeMp()->New<IreadFPoffNode>();
-  ireadOff->SetPrimType(pty);
-  ireadOff->SetOffset(offset);
-  return ireadOff;
+  return GetCurrentFuncCodeMp()->New<IreadFPoffNode>(pty, offset);
 }
 
 IaddrofNode *MIRBuilder::CreateExprIaddrof(const MIRType *returnType, const MIRType *ptrType, FieldID fieldID,
@@ -857,98 +782,55 @@ IaddrofNode *MIRBuilder::CreateExprIaddrof(const MIRType *returnType, const MIRT
 }
 
 IaddrofNode *MIRBuilder::CreateExprIaddrof(PrimType returnTypePty, TyIdx ptrTypeIdx, FieldID fieldID, BaseNode *addr) {
-  IaddrofNode *iaddrofNode = GetCurrentFuncCodeMp()->New<IreadNode>(OP_iaddrof);
-  iaddrofNode->SetPrimType(returnTypePty);
-  iaddrofNode->SetTyIdx(ptrTypeIdx);
-  iaddrofNode->SetFieldID(fieldID);
-  iaddrofNode->SetOpnd(addr);
-  return iaddrofNode;
+  return GetCurrentFuncCodeMp()->New<IreadNode>(OP_iaddrof, returnTypePty, ptrTypeIdx, fieldID, addr);
 }
 
 UnaryNode *MIRBuilder::CreateExprUnary(Opcode opcode, const MIRType *type, BaseNode *opnd) {
-  UnaryNode *un = GetCurrentFuncCodeMp()->New<UnaryNode>(opcode);
-  un->SetPrimType(type->GetPrimType());
-  un->SetOpnd(opnd);
-  return un;
+  return GetCurrentFuncCodeMp()->New<UnaryNode>(opcode, type->GetPrimType(), opnd);
 }
 
 GCMallocNode *MIRBuilder::CreateExprGCMalloc(Opcode opcode, const MIRType *ptype, const MIRType *type) {
-  GCMallocNode *un = GetCurrentFuncCodeMp()->New<GCMallocNode>(opcode);
-  un->SetPrimType(ptype->GetPrimType());
-  un->SetTyIdx(type->GetTypeIndex());
-  return un;
+  return GetCurrentFuncCodeMp()->New<GCMallocNode>(opcode, ptype->GetPrimType(), type->GetTypeIndex());
 }
 
 JarrayMallocNode *MIRBuilder::CreateExprJarrayMalloc(Opcode opcode, const MIRType *ptype, const MIRType *type,
                                                      BaseNode *opnd) {
-  JarrayMallocNode *un = GetCurrentFuncCodeMp()->New<JarrayMallocNode>(opcode);
-  un->SetPrimType(ptype->GetPrimType());
-  un->SetTyIdx(type->GetTypeIndex());
-  un->SetOpnd(opnd);
-  return un;
+  return GetCurrentFuncCodeMp()->New<JarrayMallocNode>(opcode, ptype->GetPrimType(), type->GetTypeIndex(), opnd);
 }
 
 TypeCvtNode *MIRBuilder::CreateExprTypeCvt(Opcode o, const MIRType *type, const MIRType *fromType, BaseNode *opnd) {
-  TypeCvtNode *un = GetCurrentFuncCodeMp()->New<TypeCvtNode>(o);
-  un->SetPrimType(type->GetPrimType());
-  un->SetFromType(fromType->GetPrimType());
-  un->SetOpnd(static_cast<BaseNode*>(opnd));
-  return un;
+  return GetCurrentFuncCodeMp()->New<TypeCvtNode>(o, type->GetPrimType(), fromType->GetPrimType(), opnd);
 }
 
 ExtractbitsNode *MIRBuilder::CreateExprExtractbits(Opcode o, const MIRType *type, uint32 bOffset, uint32 bsize,
                                                    BaseNode *opnd) {
-  ExtractbitsNode *ext = GetCurrentFuncCodeMp()->New<ExtractbitsNode>(o);
-  ext->SetPrimType(type->GetPrimType());
-  ext->SetBitsOffset(bOffset);
-  ext->SetBitsSize(bsize);
-  ext->SetOpnd(static_cast<BaseNode*>(opnd));
-  return ext;
+  return GetCurrentFuncCodeMp()->New<ExtractbitsNode>(o, type->GetPrimType(), bOffset, bsize, opnd);
 }
 
 RetypeNode *MIRBuilder::CreateExprRetype(const MIRType *type, const MIRType *fromType, BaseNode *opnd) {
-  RetypeNode *un = GetCurrentFuncCodeMp()->New<RetypeNode>();
-  un->SetPrimType(type->GetPrimType());
-  un->SetFromType(fromType->GetPrimType());
-  un->SetTyIdx(type->GetTypeIndex());
-  un->SetOpnd(static_cast<BaseNode*>(opnd));
-  return un;
+  return GetCurrentFuncCodeMp()->New<RetypeNode>(type->GetPrimType(), fromType->GetPrimType(),
+                                                 type->GetTypeIndex(), opnd);
 }
 
 BinaryNode *MIRBuilder::CreateExprBinary(Opcode opcode, const MIRType *type, BaseNode *opnd0, BaseNode *opnd1) {
-  BinaryNode *bn = GetCurrentFuncCodeMp()->New<BinaryNode>(opcode);
-  bn->SetPrimType(type->GetPrimType());
-  bn->SetBOpnd(opnd0, 0);
-  bn->SetBOpnd(opnd1, 1);
-  return bn;
+  return GetCurrentFuncCodeMp()->New<BinaryNode>(opcode, type->GetPrimType(), opnd0, opnd1);
 }
 
 TernaryNode *MIRBuilder::CreateExprTernary(Opcode opcode, const MIRType *type, BaseNode *opnd0, BaseNode *opnd1,
                                            BaseNode *opnd2) {
-  TernaryNode *tn = GetCurrentFuncCodeMp()->New<TernaryNode>(opcode);
-  tn->SetPrimType(type->GetPrimType());
-  tn->SetOpnd(opnd0, 0);
-  tn->SetOpnd(opnd1, 1);
-  tn->SetOpnd(opnd2, 2);
-  return tn;
+  return GetCurrentFuncCodeMp()->New<TernaryNode>(opcode, type->GetPrimType(), opnd0, opnd1, opnd2);
 }
 
 CompareNode *MIRBuilder::CreateExprCompare(Opcode opcode, const MIRType *type, const MIRType *opndType, BaseNode *opnd0,
                                            BaseNode *opnd1) {
-  CompareNode *bn = GetCurrentFuncCodeMp()->New<CompareNode>(opcode);
-  bn->SetPrimType(type->GetPrimType());
-  bn->SetOpndType(opndType->GetPrimType());
-  bn->SetBOpnd(opnd0, 0);
-  bn->SetBOpnd(opnd1, 1);
-  return bn;
+  return GetCurrentFuncCodeMp()->New<CompareNode>(opcode, type->GetPrimType(), opndType->GetPrimType(), opnd0, opnd1);
 }
 
 ArrayNode *MIRBuilder::CreateExprArray(const MIRType *arrayType) {
-  ArrayNode *arrayNode = GetCurrentFuncCodeMp()->New<ArrayNode>(GetCurrentFuncCodeMpAllocator());
   MIRType *addrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(arrayType);
   ASSERT(addrType != nullptr, "addrType is null");
-  arrayNode->SetPrimType(addrType->GetPrimType());
-  arrayNode->SetTyIdx(addrType->GetTypeIndex());
+  ArrayNode *arrayNode = GetCurrentFuncCodeMp()->New<ArrayNode>(GetCurrentFuncCodeMpAllocator(),
+                                                                addrType->GetPrimType(), addrType->GetTypeIndex());
   arrayNode->SetNumOpnds(0);
   return arrayNode;
 }
@@ -961,8 +843,7 @@ ArrayNode *MIRBuilder::CreateExprArray(const MIRType *arrayType, BaseNode *op) {
 }
 
 ArrayNode *MIRBuilder::CreateExprArray(const MIRType *arrayType, BaseNode *op1, BaseNode *op2) {
-  ArrayNode *arrayNode = CreateExprArray(arrayType);
-  arrayNode->GetNopnd().push_back(op1);
+  ArrayNode *arrayNode = CreateExprArray(arrayType, op1);
   arrayNode->GetNopnd().push_back(op2);
   arrayNode->SetNumOpnds(2);
   return arrayNode;
@@ -982,58 +863,31 @@ IntrinsicopNode *MIRBuilder::CreateExprIntrinsicop(MIRIntrinsicID idx, Opcode op
 }
 
 DassignNode *MIRBuilder::CreateStmtDassign(const MIRSymbol *symbol, FieldID fieldID, BaseNode *src) {
-  DassignNode *stmt = GetCurrentFuncCodeMp()->New<DassignNode>();
-  stmt->SetStIdx(symbol->GetStIdx());
-  stmt->SetFieldID(fieldID);
-  stmt->SetRHS(src);
-  return stmt;
+  return GetCurrentFuncCodeMp()->New<DassignNode>(src, symbol->GetStIdx(), fieldID);
 }
 
 RegassignNode *MIRBuilder::CreateStmtRegassign(PrimType pty, PregIdx regIdx, BaseNode *src) {
-  RegassignNode *stmt = GetCurrentFuncCodeMp()->New<RegassignNode>();
-  stmt->SetPrimType(pty);
-  stmt->SetRegIdx(regIdx);
-  stmt->SetOpnd(src);
-  return stmt;
+  return GetCurrentFuncCodeMp()->New<RegassignNode>(pty, regIdx, src);
 }
 
 DassignNode *MIRBuilder::CreateStmtDassign(StIdx sIdx, FieldID fieldID, BaseNode *src) {
-  DassignNode *stmt = GetCurrentFuncCodeMp()->New<DassignNode>();
-  stmt->SetStIdx(sIdx);
-  stmt->SetFieldID(fieldID);
-  stmt->SetRHS(src);
-  return stmt;
+  return GetCurrentFuncCodeMp()->New<DassignNode>(src, sIdx, fieldID);
 }
 
 IassignNode *MIRBuilder::CreateStmtIassign(const MIRType *type, FieldID fieldID, BaseNode *addr, BaseNode *src) {
-  IassignNode *stmt = GetCurrentFuncCodeMp()->New<IassignNode>();
-  stmt->SetTyIdx(type->GetTypeIndex());
-  stmt->SetFieldID(fieldID);
-  stmt->SetOpnd(addr, 0);
-  stmt->SetRHS(src);
-  return stmt;
+  return GetCurrentFuncCodeMp()->New<IassignNode>(type->GetTypeIndex(), fieldID, addr, src);
 }
 
 IassignoffNode *MIRBuilder::CreateStmtIassignoff(PrimType pty, int32 offset, BaseNode *addr, BaseNode *src) {
-  IassignoffNode *stmt = GetCurrentFuncCodeMp()->New<IassignoffNode>();
-  stmt->SetPrimType(pty);
-  stmt->offset = offset;
-  stmt->SetBOpnd(addr, 0);
-  stmt->SetBOpnd(src, 1);
-  return stmt;
+  return GetCurrentFuncCodeMp()->New<IassignoffNode>(pty, offset, addr, src);
 }
 
 IassignFPoffNode *MIRBuilder::CreateStmtIassignFPoff(PrimType pty, int32 offset, BaseNode *src) {
-  IassignFPoffNode *stmt = GetCurrentFuncCodeMp()->New<IassignFPoffNode>();
-  stmt->SetPrimType(pty);
-  stmt->SetOffset(offset);
-  stmt->SetOpnd(src);
-  return stmt;
+  return GetCurrentFuncCodeMp()->New<IassignFPoffNode>(pty, offset, src);
 }
 
 CallNode *MIRBuilder::CreateStmtCall(PUIdx puIdx, const MapleVector<BaseNode*> &args, Opcode opCode) {
-  CallNode *stmt = GetCurrentFuncCodeMp()->New<CallNode>(GetCurrentFuncCodeMpAllocator(), opCode);
-  stmt->SetPUIdx(puIdx);
+  CallNode *stmt = GetCurrentFuncCodeMp()->New<CallNode>(GetCurrentFuncCodeMpAllocator(), opCode, puIdx, TyIdx());
   stmt->SetNOpnd(args);
   stmt->SetNumOpnds(args.size());
   return stmt;
@@ -1050,38 +904,32 @@ CallNode *MIRBuilder::CreateStmtCall(const std::string &callee, const MapleVecto
 
 IcallNode *MIRBuilder::CreateStmtIcall(const MapleVector<BaseNode*> &args) {
   IcallNode *stmt = GetCurrentFuncCodeMp()->New<IcallNode>(GetCurrentFuncCodeMpAllocator(), OP_icall);
-  stmt->SetNOpnd(args);
-  stmt->SetNumOpnds(args.size());
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->SetOpnds(args);
   return stmt;
 }
 
 IntrinsiccallNode *MIRBuilder::CreateStmtIntrinsicCall(MIRIntrinsicID idx, const MapleVector<BaseNode*> &arguments,
                                                        TyIdx tyIdx) {
   IntrinsiccallNode *stmt = GetCurrentFuncCodeMp()->New<IntrinsiccallNode>(
-      GetCurrentFuncCodeMpAllocator(), tyIdx == 0 ? OP_intrinsiccall : OP_intrinsiccallwithtype);
-  stmt->SetIntrinsic(idx);
+      GetCurrentFuncCodeMpAllocator(), tyIdx == 0 ? OP_intrinsiccall : OP_intrinsiccallwithtype, idx);
   stmt->SetTyIdx(tyIdx);
-  stmt->SetNOpnd(arguments);
-  stmt->SetNumOpnds(arguments.size());
+  stmt->SetOpnds(arguments);
   return stmt;
 }
 
 IntrinsiccallNode *MIRBuilder::CreateStmtXintrinsicCall(MIRIntrinsicID idx, const MapleVector<BaseNode*> &arguments) {
   IntrinsiccallNode *stmt =
-      GetCurrentFuncCodeMp()->New<IntrinsiccallNode>(GetCurrentFuncCodeMpAllocator(), OP_xintrinsiccall);
-  stmt->SetIntrinsic(idx);
-  stmt->SetNOpnd(arguments);
-  stmt->SetNumOpnds(arguments.size());
+      GetCurrentFuncCodeMp()->New<IntrinsiccallNode>(GetCurrentFuncCodeMpAllocator(), OP_xintrinsiccall, idx);
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->SetOpnds(arguments);
   return stmt;
 }
 
 CallNode *MIRBuilder::CreateStmtCallAssigned(PUIdx puIdx, const MIRSymbol *ret, Opcode op) {
-  CallNode *stmt = GetCurrentFuncCodeMp()->New<CallNode>(GetCurrentFuncCodeMpAllocator(), op);
-  stmt->SetPUIdx(puIdx);
+  CallNode *stmt = GetCurrentFuncCodeMp()->New<CallNode>(GetCurrentFuncCodeMpAllocator(), op, puIdx);
   if (ret) {
-    ASSERT((ret->GetStorageClass() == kScAuto || ret->GetStorageClass() == kScFormal ||
-            ret->GetStorageClass() == kScExtern || ret->GetStorageClass() == kScGlobal),
-           "Not Expected ret");
+    ASSERT(IsValidCallReturn(*ret), "Not Excepted ret");
     stmt->GetReturnVec().push_back(CallReturnPair(ret->GetStIdx(), RegFieldPair(0, 0)));
   }
   return stmt;
@@ -1089,23 +937,18 @@ CallNode *MIRBuilder::CreateStmtCallAssigned(PUIdx puIdx, const MIRSymbol *ret,
 
 CallNode *MIRBuilder::CreateStmtCallAssigned(PUIdx puIdx, const MapleVector<BaseNode*> &args, const MIRSymbol *ret,
                                              Opcode opcode, TyIdx tyIdx) {
-  CallNode *stmt = GetCurrentFuncCodeMp()->New<CallNode>(GetCurrentFuncCodeMpAllocator(), opcode);
-  stmt->SetPUIdx(puIdx);
-  stmt->SetTyIdx(tyIdx);
-  stmt->SetNOpnd(args);
-  stmt->SetNumOpnds(args.size());
+  CallNode *stmt = GetCurrentFuncCodeMp()->New<CallNode>(GetCurrentFuncCodeMpAllocator(), opcode, puIdx, tyIdx);
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->SetOpnds(args);
   if (ret != nullptr) {
-    ASSERT((ret->GetStorageClass() == kScAuto || ret->GetStorageClass() == kScFormal ||
-            ret->GetStorageClass() == kScExtern || ret->GetStorageClass() == kScGlobal),
-           "Not Expected ret");
+    ASSERT(IsValidCallReturn(*ret), "Not Excepted ret");
     stmt->GetReturnVec().push_back(CallReturnPair(ret->GetStIdx(), RegFieldPair(0, 0)));
   }
   return stmt;
 }
 
 CallNode *MIRBuilder::CreateStmtCallRegassigned(PUIdx puIdx, PregIdx pRegIdxt, Opcode opcode, BaseNode *arg) {
-  CallNode *stmt = GetCurrentFuncCodeMp()->New<CallNode>(GetCurrentFuncCodeMpAllocator(), opcode);
-  stmt->SetPUIdx(puIdx);
+  CallNode *stmt = GetCurrentFuncCodeMp()->New<CallNode>(GetCurrentFuncCodeMpAllocator(), opcode, puIdx);
   stmt->GetNopnd().push_back(arg);
   stmt->SetNumOpnds(stmt->GetNopndSize());
   if (pRegIdxt > 0) {
@@ -1116,10 +959,9 @@ CallNode *MIRBuilder::CreateStmtCallRegassigned(PUIdx puIdx, PregIdx pRegIdxt, O
 
 CallNode *MIRBuilder::CreateStmtCallRegassigned(PUIdx puIdx, const MapleVector<BaseNode*> &args, PregIdx pRegIdxt,
                                                 Opcode opcode) {
-  CallNode *stmt = GetCurrentFuncCodeMp()->New<CallNode>(GetCurrentFuncCodeMpAllocator(), opcode);
-  stmt->SetPUIdx(puIdx);
-  stmt->SetNOpnd(args);
-  stmt->SetNumOpnds(args.size());
+  CallNode *stmt = GetCurrentFuncCodeMp()->New<CallNode>(GetCurrentFuncCodeMpAllocator(), opcode, puIdx);
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->SetOpnds(args);
   if (pRegIdxt > 0) {
     stmt->GetReturnVec().push_back(CallReturnPair(StIdx(), RegFieldPair(0, pRegIdxt)));
   }
@@ -1129,10 +971,9 @@ CallNode *MIRBuilder::CreateStmtCallRegassigned(PUIdx puIdx, const MapleVector<B
 IntrinsiccallNode *MIRBuilder::CreateStmtIntrinsicCallAssigned(MIRIntrinsicID idx, const MapleVector<BaseNode*> &args,
                                                                PregIdx retPregIdx) {
   IntrinsiccallNode *stmt =
-      GetCurrentFuncCodeMp()->New<IntrinsiccallNode>(GetCurrentFuncCodeMpAllocator(), OP_intrinsiccallassigned);
-  stmt->SetIntrinsic(idx);
-  stmt->SetNOpnd(args);
-  stmt->SetNumOpnds(args.size());
+      GetCurrentFuncCodeMp()->New<IntrinsiccallNode>(GetCurrentFuncCodeMpAllocator(), OP_intrinsiccallassigned, idx);
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->SetOpnds(args);
   if (retPregIdx > 0) {
     stmt->GetReturnVec().push_back(CallReturnPair(StIdx(), RegFieldPair(0, retPregIdx)));
   }
@@ -1142,16 +983,12 @@ IntrinsiccallNode *MIRBuilder::CreateStmtIntrinsicCallAssigned(MIRIntrinsicID id
 IntrinsiccallNode *MIRBuilder::CreateStmtIntrinsicCallAssigned(MIRIntrinsicID idx, const MapleVector<BaseNode*> &args,
                                                                const MIRSymbol *ret, TyIdx tyIdx) {
   IntrinsiccallNode *stmt = GetCurrentFuncCodeMp()->New<IntrinsiccallNode>(
-      GetCurrentFuncCodeMpAllocator(), tyIdx == 0 ? OP_intrinsiccallassigned : OP_intrinsiccallwithtypeassigned);
-  stmt->SetIntrinsic(idx);
+      GetCurrentFuncCodeMpAllocator(), tyIdx == 0 ? OP_intrinsiccallassigned : OP_intrinsiccallwithtypeassigned, idx);
   stmt->SetTyIdx(tyIdx);
-  stmt->SetNOpnd(args);
-  stmt->SetNumOpnds(args.size());
+  stmt->SetOpnds(args);
   CallReturnVector nrets(GetCurrentFuncCodeMpAllocator()->Adapter());
   if (ret != nullptr) {
-    ASSERT((ret->GetStorageClass() == kScAuto || ret->GetStorageClass() == kScFormal ||
-            ret->GetStorageClass() == kScExtern || ret->GetStorageClass() == kScGlobal),
-           "Not Excepted ret");
+    ASSERT(IsValidCallReturn(*ret), "Not Excepted ret");
     nrets.push_back(CallReturnPair(ret->GetStIdx(), RegFieldPair(0, 0)));
   }
   stmt->SetReturnVec(nrets);
@@ -1161,15 +998,12 @@ IntrinsiccallNode *MIRBuilder::CreateStmtIntrinsicCallAssigned(MIRIntrinsicID id
 IntrinsiccallNode *MIRBuilder::CreateStmtXintrinsicCallAssigned(MIRIntrinsicID idx, const MapleVector<BaseNode*> &args,
                                                                 const MIRSymbol *ret) {
   IntrinsiccallNode *stmt =
-      GetCurrentFuncCodeMp()->New<IntrinsiccallNode>(GetCurrentFuncCodeMpAllocator(), OP_xintrinsiccallassigned);
-  stmt->SetIntrinsic(idx);
-  stmt->SetNOpnd(args);
-  stmt->SetNumOpnds(args.size());
+      GetCurrentFuncCodeMp()->New<IntrinsiccallNode>(GetCurrentFuncCodeMpAllocator(), OP_xintrinsiccallassigned, idx);
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->SetOpnds(args);
   CallReturnVector nrets(GetCurrentFuncCodeMpAllocator()->Adapter());
   if (ret != nullptr) {
-    ASSERT((ret->GetStorageClass() == kScAuto || ret->GetStorageClass() == kScFormal ||
-            ret->GetStorageClass() == kScExtern || ret->GetStorageClass() == kScGlobal),
-           "Not Excepted ret");
+    ASSERT(IsValidCallReturn(*ret), "Not Excepted ret");
     nrets.push_back(CallReturnPair(ret->GetStIdx(), RegFieldPair(0, 0)));
   }
   stmt->SetReturnVec(nrets);
@@ -1178,33 +1012,27 @@ IntrinsiccallNode *MIRBuilder::CreateStmtXintrinsicCallAssigned(MIRIntrinsicID i
 
 NaryStmtNode *MIRBuilder::CreateStmtReturn(BaseNode *rVal) {
   NaryStmtNode *stmt = GetCurrentFuncCodeMp()->New<NaryStmtNode>(GetCurrentFuncCodeMpAllocator(), OP_return);
-  if (rVal) {
-    stmt->GetNopnd().push_back(rVal);
-  }
-  stmt->SetNumOpnds(stmt->GetNopndSize());
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->PushOpnd(rVal);
   return stmt;
 }
 
 NaryStmtNode *MIRBuilder::CreateStmtNary(Opcode op, const MapleVector<BaseNode*> &rVals) {
   NaryStmtNode *stmt = GetCurrentFuncCodeMp()->New<NaryStmtNode>(GetCurrentFuncCodeMpAllocator(), op);
-  stmt->SetNOpnd(rVals);
-  stmt->SetNumOpnds(stmt->GetNopndSize());
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->SetOpnds(rVals);
   return stmt;
 }
 
 NaryStmtNode *MIRBuilder::CreateStmtNary(Opcode op, BaseNode *rVal) {
   NaryStmtNode *stmt = GetCurrentFuncCodeMp()->New<NaryStmtNode>(GetCurrentFuncCodeMpAllocator(), op);
-  if (rVal) {
-    stmt->GetNopnd().push_back(rVal);
-  }
-  stmt->SetNumOpnds(stmt->GetNopndSize());
+  ASSERT(stmt != nullptr, "stmt is null");
+  stmt->PushOpnd(rVal);
   return stmt;
 }
 
 UnaryStmtNode *MIRBuilder::CreateStmtUnary(Opcode op, BaseNode *rVal) {
-  UnaryStmtNode *stmt = GetCurrentFuncCodeMp()->New<UnaryStmtNode>(op);
-  stmt->SetOpnd(rVal);
-  return stmt;
+  return GetCurrentFuncCodeMp()->New<UnaryStmtNode>(op, kPtyInvalid, rVal);
 }
 
 UnaryStmtNode *MIRBuilder::CreateStmtThrow(BaseNode *rVal) {
@@ -1232,49 +1060,31 @@ IfStmtNode *MIRBuilder::CreateStmtIfThenElse(BaseNode *cond) {
 
 DoloopNode *MIRBuilder::CreateStmtDoloop(StIdx doVarStIdx, bool isPReg, BaseNode *startExp, BaseNode *contExp,
                                          BaseNode *incrExp) {
-  DoloopNode *doLoopNode = GetCurrentFuncCodeMp()->New<DoloopNode>();
-  doLoopNode->SetDoVarStIdx(doVarStIdx);
-  doLoopNode->SetIsPreg(isPReg);
-  doLoopNode->SetStartExpr(startExp);
-  doLoopNode->SetContExpr(contExp);
-  doLoopNode->SetIncrExpr(incrExp);
-  doLoopNode->SetDoBody(GetCurrentFuncCodeMp()->New<BlockNode>());
-  doLoopNode->SetNumOpnds(4);
-  return doLoopNode;
+  return GetCurrentFuncCodeMp()->New<DoloopNode>(doVarStIdx, isPReg, startExp, contExp, incrExp,
+                                                 GetCurrentFuncCodeMp()->New<BlockNode>());
 }
 
 SwitchNode *MIRBuilder::CreateStmtSwitch(BaseNode *opnd, LabelIdx defaultLabel, const CaseVector &switchTable) {
-  SwitchNode *switchNode = GetCurrentFuncCodeMp()->New<SwitchNode>(GetCurrentFuncCodeMpAllocator());
-  switchNode->SetSwitchOpnd(opnd);
-  switchNode->SetDefaultLabel(defaultLabel);
+  SwitchNode *switchNode = GetCurrentFuncCodeMp()->New<SwitchNode>(GetCurrentFuncCodeMpAllocator(), defaultLabel, opnd);
   switchNode->SetSwitchTable(switchTable);
   switchNode->SetNumOpnds(switchTable.size());
   return switchNode;
 }
 
 GotoNode *MIRBuilder::CreateStmtGoto(Opcode o, LabelIdx labIdx) {
-  GotoNode *gotoNode = GetCurrentFuncCodeMp()->New<GotoNode>(o);
-  gotoNode->SetOffset(labIdx);
-  return gotoNode;
+  return GetCurrentFuncCodeMp()->New<GotoNode>(o, labIdx);
 }
 
 JsTryNode *MIRBuilder::CreateStmtJsTry(Opcode o, LabelIdx cLabIdx, LabelIdx fLabIdx) {
-  JsTryNode *tryNode = GetCurrentFuncCodeMp()->New<JsTryNode>();
-  tryNode->SetCatchOffset(static_cast<uint16>(cLabIdx));
-  tryNode->SetFinallyOffset(static_cast<uint16>(fLabIdx));
-  return tryNode;
+  return GetCurrentFuncCodeMp()->New<JsTryNode>(static_cast<uint16>(cLabIdx), static_cast<uint16>(fLabIdx));
 }
 
 TryNode *MIRBuilder::CreateStmtTry(const MapleVector<LabelIdx> &cLabIdxs) {
-  TryNode *tryNode = GetCurrentFuncCodeMp()->New<TryNode>(GetCurrentFuncCodeMpAllocator());
-  tryNode->SetOffsets(cLabIdxs);
-  return tryNode;
+  return GetCurrentFuncCodeMp()->New<TryNode>(GetCurrentFuncCodeMpAllocator(), cLabIdxs);
 }
 
 CatchNode *MIRBuilder::CreateStmtCatch(const MapleVector<TyIdx> &tyIdxVec) {
-  CatchNode *catchNode = GetCurrentFuncCodeMp()->New<CatchNode>(GetCurrentFuncCodeMpAllocator());
-  catchNode->SetExceptionTyIdxVec(tyIdxVec);
-  return catchNode;
+  return GetCurrentFuncCodeMp()->New<CatchNode>(GetCurrentFuncCodeMpAllocator(), tyIdxVec);
 }
 
 LabelIdx MIRBuilder::GetOrCreateMIRLabel(const std::string &name) {
@@ -1297,14 +1107,11 @@ LabelIdx MIRBuilder::CreateLabIdx(MIRFunction *mirFunc) {
 }
 
 LabelNode *MIRBuilder::CreateStmtLabel(LabelIdx labIdx) {
-  LabelNode *label = GetCurrentFuncCodeMp()->New<LabelNode>();
-  label->SetLabelIdx(labIdx);
-  return label;
+  return GetCurrentFuncCodeMp()->New<LabelNode>(labIdx);
 }
 
 StmtNode *MIRBuilder::CreateStmtComment(const std::string &cmnt) {
-  CommentNode *cmntNode = GetCurrentFuncCodeMp()->New<CommentNode>(GetCurrentFuncCodeMpAllocator(), cmnt);
-  return cmntNode;
+  return GetCurrentFuncCodeMp()->New<CommentNode>(GetCurrentFuncCodeMpAllocator(), cmnt);
 }
 
 void MIRBuilder::AddStmtInCurrentFunctionBody(StmtNode *stmt) {
@@ -1315,25 +1122,15 @@ void MIRBuilder::AddStmtInCurrentFunctionBody(StmtNode *stmt) {
 }
 
 AddrofNode *MIRBuilder::CreateAddrof(const MIRSymbol *st, PrimType pty) {
-  AddrofNode *addrofNode = GetCurrentFuncCodeMp()->New<AddrofNode>(OP_addrof);
-  addrofNode->SetPrimType(pty);
-  addrofNode->SetStIdx(st->GetStIdx());
-  return addrofNode;
+  return GetCurrentFuncCodeMp()->New<AddrofNode>(OP_addrof, pty, st->GetStIdx(), 0);
 }
 
 AddrofNode *MIRBuilder::CreateDread(const MIRSymbol *st, PrimType pty) {
-  AddrofNode *dread = GetCurrentFuncCodeMp()->New<AddrofNode>(OP_dread);
-  dread->SetPrimType(pty);
-  dread->SetStIdx(st->GetStIdx());
-  dread->SetFieldID(0);
-  return dread;
+  return GetCurrentFuncCodeMp()->New<AddrofNode>(OP_dread, pty, st->GetStIdx(), 0);
 }
 
 CondGotoNode *MIRBuilder::CreateStmtCondGoto(BaseNode *cond, Opcode op, LabelIdx labIdx) {
-  CondGotoNode *condGoto = GetCurrentFuncCodeMp()->New<CondGotoNode>(op == OP_brtrue ? OP_brtrue : OP_brfalse);
-  condGoto->SetOffset(labIdx);
-  condGoto->SetOpnd(cond);
-  return condGoto;
+  return GetCurrentFuncCodeMp()->New<CondGotoNode>(op == OP_brtrue ? OP_brtrue : OP_brfalse, labIdx, cond);
 }
 
 MemPool *MIRBuilder::GetCurrentFuncCodeMp() {
diff --git a/src/maple_ir/src/mir_parser.cpp b/src/maple_ir/src/mir_parser.cpp
index 6cde961a2044df033273eee5a036d59c8832e290..4b6ebc9095a5338da8dfc90a55f0a16e5289f6dc 100644
--- a/src/maple_ir/src/mir_parser.cpp
+++ b/src/maple_ir/src/mir_parser.cpp
@@ -2625,6 +2625,7 @@ bool MIRParser::ParseConstAddrLeafExpr(MIRConstPtr &cexpr, MIRType *type) {
     MIRFunction *currfn = static_cast<MIRFunction*>(mod.CurFunction());
     MIRSymbol *var = currfn->GetLocalOrGlobalSymbol(anode->GetStIdx());
     var->SetNeedForwDecl();
+    mod.SetSomeSymbolNeedForDecl(true);
     TyIdx ptyidx = var->GetTyIdx();
     MIRPtrType ptrtype(ptyidx, (mod.IsJavaModule() ? PTY_ref : PTY_ptr));
     ptyidx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrtype);
diff --git a/src/maple_me/include/bb.h b/src/maple_me/include/bb.h
index 2d1964cc3ae79d5c9e5c45955990b561f445c806..cadf730d4fe77f07d96332467ef822e743094320 100644
--- a/src/maple_me/include/bb.h
+++ b/src/maple_me/include/bb.h
@@ -211,6 +211,14 @@ class BB {
     stmtNodeList.update_back(stmt);
   }
 
+  StmtNode *GetFirst() {
+    return &stmtNodeList.front();
+  }
+
+  StmtNode *GetLast() {
+    return &stmtNodeList.back();
+  }
+
   void SetFirstMe(MeStmt *stmt);
   void SetLastMe(MeStmt *stmt);
   bool IsInList(MapleVector<BB*> &) const;
diff --git a/src/maple_me/include/me_function.h b/src/maple_me/include/me_function.h
index 2b65cf9a0b58ae38974c9d0ab459b03b63ae7625..6237137f7710f3067775a893a68e0afb697c0bcd 100644
--- a/src/maple_me/include/me_function.h
+++ b/src/maple_me/include/me_function.h
@@ -316,7 +316,7 @@ class MeFunction : public FuncEmit {
   void CreateBBLabel(BB *bb);
   /* clone stmtnodes from orig to newbb */
   void CloneBasicBlock(BB *newbb, BB *orig);
-  BB *SplitBB(BB *bb, StmtNode *splitPoint);
+  BB *SplitBB(BB *bb, StmtNode *splitPoint, BB *newBB = nullptr);
   const bool HasException() const {
     return hasEH;
   }
@@ -418,6 +418,10 @@ class MeFunction : public FuncEmit {
     nextBBId = currNextBBId;
   }
 
+  uint32 &GetNextBBId() {
+    return nextBBId;
+  }
+
   uint32 GetRegNum() const {
     return regNum;
   }
diff --git a/src/maple_me/include/me_ir.h b/src/maple_me/include/me_ir.h
index a608208ea1f60b0f54d74af18fddf9362673e8ce..d253296a04f5b0cca6c43e73be5346a93c00989f 100644
--- a/src/maple_me/include/me_ir.h
+++ b/src/maple_me/include/me_ir.h
@@ -187,13 +187,14 @@ class IassignMeStmt;  // forward decl
 class VarMeExpr : public MeExpr {
  public:
  public:
-  VarMeExpr(int32 exprid, OStIdx oidx, size_t vidx)
+  VarMeExpr(MapleAllocator *alloc, int32 exprid, OStIdx oidx, size_t vidx)
       : MeExpr(exprid, kMeOpVar),
         def{ .defStmt = nullptr },
         ostIdx(oidx),
         vstIdx(vidx),
         fieldID(0),
         inferredTyIdx(0),
+        inferredTypeCandidates(alloc->Adapter()),
         defBy(kDefByNo),
         maybeNull(true) {
   }
@@ -253,6 +254,10 @@ class VarMeExpr : public MeExpr {
     inferredTyIdx = inferredTyIdxVal;
   }
 
+  MapleVector<TyIdx> &GetInferredTypeCandidates() {
+    return inferredTypeCandidates;
+  }
+
   MeDefBy GetDefBy() const {
     return defBy;
   }
@@ -313,6 +318,7 @@ class VarMeExpr : public MeExpr {
   size_t vstIdx;  // the index in MEOptimizer's VersionStTable, 0 if not in VersionStTable
   FieldID fieldID;
   TyIdx inferredTyIdx; /* Non zero if it has a known type (allocation type is seen). */
+  MapleVector<TyIdx> inferredTypeCandidates;
   MeDefBy defBy;
   bool maybeNull;  // false if definitely not null
 };
@@ -821,7 +827,7 @@ class OpMeExpr : public MeExpr {
     bitsOffset = bitsOffSetVal;
   }
 
-  uint8 GetBitsSize() {
+  uint8 GetBitsSize() const {
     return bitsSize;
   }
 
@@ -1458,6 +1464,14 @@ class DassignMeStmt : public MeStmt {
     return needDecref;
   }
 
+  void SetNeedDecref(bool isNeedDecref) {
+    needDecref = isNeedDecref;
+  }
+
+  void SetNeedIncref(bool isNeedIncref) {
+    needIncref = isNeedIncref;
+  }
+
   void EnableNeedDecref() {
     needDecref = true;
   }
diff --git a/src/maple_me/src/irmap.cpp b/src/maple_me/src/irmap.cpp
index a11d181031d689c5ae6b35df049bd3b5bd91ec5b..a8d3597aaf9ae3121e0d8549c343f7d079d5b9f7 100644
--- a/src/maple_me/src/irmap.cpp
+++ b/src/maple_me/src/irmap.cpp
@@ -78,7 +78,7 @@ void IRMap::BuildPhiMeNode(BB *bb) {
 }
 
 VarMeExpr *IRMap::CreateVarMeExprVersion(const VarMeExpr *origExpr) {
-  VarMeExpr *varmeexpr = New<VarMeExpr>(exprID++, origExpr->GetOStIdx(), verst2MeExprTable.size());
+  VarMeExpr *varmeexpr = New<VarMeExpr>(&irMapAlloc, exprID++, origExpr->GetOStIdx(), verst2MeExprTable.size());
   verst2MeExprTable.push_back(varmeexpr);
   varmeexpr->InitBase(origExpr->GetOp(), origExpr->GetPrimType(), origExpr->GetNumOpnds());
   varmeexpr->SetFieldID(origExpr->GetFieldID());
@@ -111,7 +111,7 @@ VarMeExpr *IRMap::CreateNewGlobalTmp(GStrIdx strIdx, PrimType ptyp) {
       mirModule->GetMIRBuilder()->CreateSymbol((TyIdx)ptyp, strIdx, kStVar, kScGlobal, nullptr, kScopeGlobal);
   st->SetIsTmp(true);
   OriginalSt *oSt = ssaTab->CreateSymbolOriginalSt(st, 0, 0);
-  VarMeExpr *varx = New<VarMeExpr>(exprID++, oSt->GetIndex(), oSt->GetZeroVersionIndex());
+  VarMeExpr *varx = New<VarMeExpr>(&irMapAlloc, exprID++, oSt->GetIndex(), oSt->GetZeroVersionIndex());
   varx->InitBase(OP_dread, ptyp, 0);
   return varx;
 }
@@ -124,7 +124,7 @@ VarMeExpr *IRMap::CreateNewLocalRefVarTmp(GStrIdx strIdx, TyIdx tIdx) {
   oSt->SetZeroVersionIndex(verst2MeExprTable.size());
   verst2MeExprTable.push_back(nullptr);
   oSt->GetVersionsIndex().push_back(oSt->GetZeroVersionIndex());
-  VarMeExpr *newlocalrefvar = New<VarMeExpr>(exprID++, oSt->GetIndex(), verst2MeExprTable.size());
+  VarMeExpr *newlocalrefvar = New<VarMeExpr>(&irMapAlloc, exprID++, oSt->GetIndex(), verst2MeExprTable.size());
   verst2MeExprTable.push_back(newlocalrefvar);
   newlocalrefvar->InitBase(OP_dread, PTY_ref, 0);
   return newlocalrefvar;
@@ -236,7 +236,7 @@ VarMeExpr *IRMap::GetOrCreateVarFromVerSt(const VersionSt *verSt) {
   }
   OriginalSt *oSt = verSt->GetOrigSt();
   ASSERT(oSt->IsSymbolOst(), "GetOrCreateVarFromVerSt: wrong ost_type");
-  VarMeExpr *varx = New<VarMeExpr>(exprID++, oSt->GetIndex(), vindex);
+  VarMeExpr *varx = New<VarMeExpr>(&irMapAlloc, exprID++, oSt->GetIndex(), vindex);
   ASSERT(!GlobalTables::GetTypeTable().GetTypeTable().empty(), "container check");
   varx->InitBase(OP_dread, GlobalTables::GetTypeTable().GetTypeFromTyIdx(oSt->GetTyIdx())->GetPrimType(), 0);
   varx->SetFieldID(oSt->GetFieldID());
@@ -252,7 +252,7 @@ VarMeExpr *IRMap::GetOrCreateZeroVersionVarMeExpr(OriginalSt *oSt) {
     verst2MeExprTable.push_back(nullptr);
   }
   if (verst2MeExprTable[oSt->GetZeroVersionIndex()] == nullptr) {
-    VarMeExpr *varmeexpr = New<VarMeExpr>(exprID++, oSt->GetIndex(), oSt->GetZeroVersionIndex());
+    VarMeExpr *varmeexpr = New<VarMeExpr>(&irMapAlloc, exprID++, oSt->GetIndex(), oSt->GetZeroVersionIndex());
     varmeexpr->SetFieldID(oSt->GetFieldID());
     varmeexpr->SetOp(OP_dread);
     ASSERT(!GlobalTables::GetTypeTable().GetTypeTable().empty(), "container check");
diff --git a/src/maple_me/src/me_function.cpp b/src/maple_me/src/me_function.cpp
index 70b15af2a8fdee8e4b2529d5d939151af3be7786..601f04e1aef4d5062d2d6a91af768e156dd2c62c 100644
--- a/src/maple_me/src/me_function.cpp
+++ b/src/maple_me/src/me_function.cpp
@@ -499,8 +499,10 @@ void MeFunction::CloneBasicBlock(BB *newBB, BB *orig) {
 }
 
 /* Split BB at split_point */
-BB *MeFunction::SplitBB(BB *bb, StmtNode *splitPoint) {
-  BB *newBB = memPool->New<BB>(&alloc, &versAlloc, BBId(nextBBId++));
+BB *MeFunction::SplitBB(BB *bb, StmtNode *splitPoint, BB *newBB) {
+  if (newBB == nullptr){
+    newBB = memPool->New<BB>(&alloc, &versAlloc, BBId(nextBBId++));
+  }
   StmtNode *newBBStart = splitPoint->GetNext();
   // Fix Stmt in BB.
   if (newBBStart != nullptr) {
diff --git a/src/maple_me/src/me_ir.cpp b/src/maple_me/src/me_ir.cpp
index 7a2299ddedcb3ac91243b4dc23751a57895eca9b..5598336cec26c0b5a8cf970186dc8d92c39d871c 100644
--- a/src/maple_me/src/me_ir.cpp
+++ b/src/maple_me/src/me_ir.cpp
@@ -41,14 +41,16 @@ bool MeExpr::IsTheSameWorkcand(MeExpr *meexpr) const {
     // exclude cvt for different return type
     return false;
   }
-  if (op == OP_resolveinterfacefunc || op == OP_resolvevirtualfunc)
+  if (op == OP_sext &&
+      static_cast<const OpMeExpr*>(this)->GetBitsSize() != static_cast<OpMeExpr*>(meexpr)->GetBitsSize()) {
+    return false;
+  }
+  if (op == OP_resolveinterfacefunc || op == OP_resolvevirtualfunc) {
     if (static_cast<const OpMeExpr*>(this)->GetFieldID() != static_cast<OpMeExpr*>(meexpr)->GetFieldID()) {
       return false;
     }
-  if (IsUseSameSymbol(meexpr)) {
-    return true;
   }
-  return false;
+  return IsUseSameSymbol(meexpr);
 }
 
 void MeExpr::UpdateDepth() {
diff --git a/src/maple_me/src/me_rc_lowering.cpp b/src/maple_me/src/me_rc_lowering.cpp
index 330f11ac05f9ca4b3206d6e92a44f726e037d20c..ac9573d9bd6b2636fb303f162d55b2378149a5ba 100644
--- a/src/maple_me/src/me_rc_lowering.cpp
+++ b/src/maple_me/src/me_rc_lowering.cpp
@@ -761,7 +761,8 @@ VarMeExpr *RCLowering::CreateNewTmpVarMeExpr(bool isLocalrefvar) {
     ost->GetVersionsIndex().push_back(ost->GetZeroVersionIndex());
   }
   irMap->SetExprID(irMap->GetExprID() + 1);
-  VarMeExpr *varMeExpr = irMap->New<VarMeExpr>(irMap->GetExprID(), ost->GetIndex(), irMap->GetVerst2MeExprTableSize());
+  VarMeExpr *varMeExpr = irMap->New<VarMeExpr>(&irMap->GetIRMapAlloc(), irMap->GetExprID(), ost->GetIndex(),
+                                               irMap->GetVerst2MeExprTableSize());
   varMeExpr->InitBase(OP_dread, PTY_ptr, 0);
   varMeExpr->SetFieldID(0);
   irMap->PushBackVerst2MeExprTable(varMeExpr);
diff --git a/src/maple_me/src/me_ssa_update.cpp b/src/maple_me/src/me_ssa_update.cpp
index a03eec677ea42f8bda1bc6a83e554c554047b421..3c1d46c74741201788fcf3f66c55a3e5d7c0e7a4 100644
--- a/src/maple_me/src/me_ssa_update.cpp
+++ b/src/maple_me/src/me_ssa_update.cpp
@@ -76,7 +76,8 @@ void SSAUpdate::RenamePhi(BB *bb) {
       if (phi->GetLHS() == nullptr) {
         // create a new VarMeExpr defined by this phi
         irMap->SetExprID(irMap->GetExprID() + 1);
-        VarMeExpr *newvar = irMap->New<VarMeExpr>(irMap->GetExprID(), it2->first, irMap->GetVerst2MeExprTableSize());
+        VarMeExpr *newvar = irMap->New<VarMeExpr>(&irMap->GetIRMapAlloc(), irMap->GetExprID(), it2->first,
+                                                  irMap->GetVerst2MeExprTableSize());
         newvar->InitBase(OP_dread, PTY_ref, 0);
         newvar->SetFieldID(0);
         irMap->PushBackVerst2MeExprTable(newvar);
diff --git a/src/maple_util/include/literal_str_name.h b/src/maple_util/include/literal_str_name.h
index ae1d6fe3ae053a517c6a5df16e138b06fd8d4ba8..4f6a68dcd435d9527a2b41331d1f76512006c508 100644
--- a/src/maple_util/include/literal_str_name.h
+++ b/src/maple_util/include/literal_str_name.h
@@ -41,9 +41,8 @@ union DigestHash {
 class LiteralStrName {
  public:
   static int32_t CalculateHashSwapByte(const char16_t *data, uint32_t len);
-
   static int32_t CalculateHash(const char16_t *data, uint32_t len, bool dataIsCompress) {
-    int hash = 0;
+    uint32_t hash = 0;
     if (dataIsCompress) {
       const char *dataStart = reinterpret_cast<const char*>(data);
       const char *end = dataStart + len;
diff --git a/src/maple_util/include/muid.h b/src/maple_util/include/muid.h
index 341fa076ae89a95325c3498b533ce8840e9a29b8..bafa0e16d6e9a52185fd5b2a290cd0040ea8abfa 100644
--- a/src/maple_util/include/muid.h
+++ b/src/maple_util/include/muid.h
@@ -30,6 +30,10 @@ constexpr unsigned int kSystemNamespace = 0xc0;
 constexpr unsigned int kApkNamespace = 0x80;
 constexpr unsigned int kBitMask = 0x3f;
 
+// For Lazy decoupling load
+const uint32_t kMplLazyLoadMagicNumber = 0x1a2;              // For trigger SIGSEGV
+const uint64_t kMplLazyLoadSentryNumber = 0x1a27b10d10810ade;
+
 #ifdef USE_64BIT_MUID
 #undef MUID_LENGTH
 #define MUID_LENGTH 8
diff --git a/src/maple_util/include/option_parser.h b/src/maple_util/include/option_parser.h
index 2ce4b32e102da90c90485c92fc009978bd71c32c..b26d3c311f79610fb5a463786da121b22c617d5a 100644
--- a/src/maple_util/include/option_parser.h
+++ b/src/maple_util/include/option_parser.h
@@ -217,6 +217,9 @@ class OptionParser {
 
   const maple::ErrorCode Parse(int argc, char **argv);
 
+  const maple::ErrorCode HandleInputArgs(const std::vector<std::string> &inputArgs, const std::string &exeName,
+                                         std::vector<mapleOption::Option> &inputOption);
+
   const std::vector<Option> &GetOptions() const {
     return options;
   }
@@ -245,9 +248,13 @@ class OptionParser {
 
   const ArgStatus CheckArg(Option &option) const;
 
-  const bool HandleKeyValue(const std::string &key, const std::string &value, bool isValueEmpty);
-  const bool CheckOpt(const std::string option, std::string &lastKey, bool &isLastMatch);
+  const bool HandleKeyValue(const std::string &key, const std::string &value, bool isValueEmpty,
+                            std::vector<mapleOption::Option> &inputOption,  const std::string &exeName);
+  const bool CheckOpt(const std::string option, std::string &lastKey, bool &isLastMatch,
+                      std::vector<mapleOption::Option> &inputOption, const std::string &exeName);
   void InsertOption(const char *opt, Descriptor usage);
+
+  const bool CheckSpecialOption(const std::string &option, std::string &key, std::string &value);
 };
 
 }  // namespace mapleOption
diff --git a/src/mpl2mpl/include/gen_check_cast.h b/src/mpl2mpl/include/gen_check_cast.h
index 3a84298c177968b59d754d0829af9ef2ad246892..088a182e9a1e305ff617eb170da0e728766c0267 100644
--- a/src/mpl2mpl/include/gen_check_cast.h
+++ b/src/mpl2mpl/include/gen_check_cast.h
@@ -47,8 +47,6 @@ class CheckCastGenerator : public FuncOptimizeImpl {
   void GenCheckCast(BaseNode *stmt);
   BaseNode *GetObjectShadow(BaseNode *opnd);
   MIRSymbol *GetOrCreateClassInfoSymbol(const std::string &className);
-  bool FindUseExpr(BaseNode *node, StIdx idx);
-  bool FindUse(StIdx idx);
 };
 
 class DoCheckCastGeneration : public ModulePhase {
diff --git a/src/mpl2mpl/include/vtable_impl.h b/src/mpl2mpl/include/vtable_impl.h
index c5f0180155c87b771e7283709b30d6f269d2abc7..e96e6c2c2de8843c34f02db0925f98c0f243a3d3 100644
--- a/src/mpl2mpl/include/vtable_impl.h
+++ b/src/mpl2mpl/include/vtable_impl.h
@@ -19,7 +19,7 @@
 
 namespace maple {
 static constexpr int kNumOfMCCParas = 5;
-enum CallKind { kVirtual = 1, kNoVirtual = 2};
+enum CallKind { kStaticCall = 0, kVirtualCall = 1, kSuperCall = 2};
 
 #ifdef USE_32BIT_REF
 static constexpr char kInterfaceMethod[] = "MCC_getFuncPtrFromItab";
diff --git a/src/mpl2mpl/src/gen_check_cast.cpp b/src/mpl2mpl/src/gen_check_cast.cpp
index 289deef29ed951ad5f0b81dcd4124751c1028eef..f58f91570384219643d21d94662bb59e8716c9a0 100644
--- a/src/mpl2mpl/src/gen_check_cast.cpp
+++ b/src/mpl2mpl/src/gen_check_cast.cpp
@@ -282,114 +282,6 @@ BaseNode *CheckCastGenerator::GetObjectShadow(BaseNode *opnd) {
 }
 
 
-bool CheckCastGenerator::FindUseExpr(BaseNode *baseNode, StIdx idx) {
-  switch (baseNode->GetOpCode()) {
-    case OP_dread:
-    case OP_addrof: {
-      AddrofNode *node = static_cast<AddrofNode*>(baseNode);
-      if (node->GetStIdx() == idx) {
-        return true;
-      }
-      break;
-    }
-    case OP_cvt:
-    case OP_ceil:
-    case OP_floor:
-    case OP_round:
-    case OP_trunc:
-    case OP_abs:
-    case OP_bnot:
-    case OP_lnot:
-    case OP_sqrt:
-    case OP_neg:
-    case OP_iread:
-    case OP_zext:
-    case OP_sext: {
-      UnaryNode *node = static_cast<UnaryNode*>(baseNode);
-      if (FindUseExpr(node->Opnd(), idx)) {
-        return true;
-      }
-      break;
-    }
-    case OP_add:
-    case OP_sub:
-    case OP_mul:
-    case OP_div:
-    case OP_rem:
-    case OP_ashr:
-    case OP_lshr:
-    case OP_shl:
-    case OP_max:
-    case OP_min:
-    case OP_band:
-    case OP_bior:
-    case OP_bxor:
-    case OP_eq:
-    case OP_ge:
-    case OP_gt:
-    case OP_le:
-    case OP_lt:
-    case OP_ne:
-    case OP_cmp:
-    case OP_cmpl:
-    case OP_cmpg:
-    case OP_land:
-    case OP_lior:
-    case OP_cand:
-    case OP_cior:
-    case OP_resolveinterfacefunc: {
-      BinaryNode *node = static_cast<BinaryNode*>(baseNode);
-      if (FindUseExpr(node->GetBOpnd(0), idx) || FindUseExpr(node->GetBOpnd(1), idx)) {
-        return true;
-      }
-      break;
-    }
-    case OP_array:
-    case OP_intrinsicop:
-    case OP_intrinsiccall:
-    case OP_intrinsicopwithtype: {
-      NaryNode *node = static_cast<NaryNode*>(baseNode);
-      for (size_t i = 0; i < node->NumOpnds(); i++) {
-        if (FindUseExpr(node->GetNopndAt(i), idx)) {
-          return true;
-        }
-      }
-      break;
-    }
-    case OP_block:
-    case OP_regread:
-    case OP_constval:
-    case OP_conststr:
-    case OP_conststr16:
-    case OP_gcmalloc:
-    case OP_gcpermalloc:
-    case OP_gcmallocjarray:
-    case OP_gcpermallocjarray: {
-      return false;
-    }
-    default: {
-      CHECK_FATAL(false, "can't reach here!");
-    }
-  }
-  return false;
-}
-
-bool CheckCastGenerator::FindUse(StIdx idx) {
-  StmtNode *stmt = currFunc->GetBody()->GetFirst();
-  StmtNode *next = nullptr;
-  while (stmt != nullptr) {
-    next = stmt->GetNext();
-    for (size_t i = 0; i < stmt->GetNumOpnds(); i++) {
-      if (FindUseExpr(stmt->Opnd(i), idx)) {
-        return true;
-      }
-    }
-    stmt = next;
-  }
-  return false;
-}
-
-
 void CheckCastGenerator::ProcessFunc(MIRFunction *func) {
   if (func->IsEmpty()) {
     return;
diff --git a/src/mpl2mpl/src/muid_replacement.cpp b/src/mpl2mpl/src/muid_replacement.cpp
index 536c8a215637f848a140f30fdce2f4dcadd1a77a..29686fffaab1d7be8e7d7346d2b9d5bec15be52a 100644
--- a/src/mpl2mpl/src/muid_replacement.cpp
+++ b/src/mpl2mpl/src/muid_replacement.cpp
@@ -1070,6 +1070,7 @@ void MUIDReplacement::ProcessFunc(MIRFunction *func) {
   }
 }
 
+// Create GC Root
 void MUIDReplacement::GenericGlobalRootList() {
   MIRType *voidType = GlobalTables::GetTypeTable().GetVoidPtr();
   MIRArrayType *arrayType = GlobalTables::GetTypeTable().GetOrCreateArrayType(voidType, 0);
diff --git a/src/mpl2mpl/src/reflection_analysis.cpp b/src/mpl2mpl/src/reflection_analysis.cpp
index 586180d4ce058d3d3aaf753456188334b97b741f..64a50a95f04b0cbc9d0b30cd974f137caf32d686 100644
--- a/src/mpl2mpl/src/reflection_analysis.cpp
+++ b/src/mpl2mpl/src/reflection_analysis.cpp
@@ -44,53 +44,9 @@ std::string ReflectionAnalysis::strTabStartHot = std::string(1, '\0');
 std::string ReflectionAnalysis::strTabBothHot = std::string(1, '\0');
 std::string ReflectionAnalysis::strTabRunHot = std::string(1, '\0');
 bool ReflectionAnalysis::strTabInited = false;
-uint8 *DeflateBuffer(const uint8 *rawBuffer, uint32 rawBufferSize, uint32 *deflateSize) {
-  z_stream stream;
-  stream.zalloc = Z_NULL;
-  stream.zfree = Z_NULL;
-  stream.opaque = Z_NULL;
-  int ret = deflateInit(&stream, Z_BEST_COMPRESSION);
-  if (ret != Z_OK) {
-    return nullptr;
-  }
-  uint32 deflateMaxSize = deflateBound(&stream, rawBufferSize);
-  CHECK_FATAL(deflateMaxSize > 0, "Buffer size checkout");
-  uint8 *deflateBuffer = nullptr;
-  deflateBuffer = new uint8[deflateMaxSize];
-  stream.avail_in = rawBufferSize;
-  stream.next_in = const_cast<uint8*>(rawBuffer);
-  stream.avail_out = deflateMaxSize;
-  stream.next_out = &deflateBuffer[0];
-  ret = deflate(&stream, Z_FINISH);
-  if (ret == Z_STREAM_ERROR) {
-    delete[] deflateBuffer;
-    deflateBuffer = nullptr;
-    return nullptr;
-  }
-  *deflateSize = deflateMaxSize - stream.avail_out;
-  deflateEnd(&stream);
-  return deflateBuffer;
-}
 
 int ReflectionAnalysis::GetDeflateStringIdx(const std::string &subStr) {
-  uint32 deflateSize = 0;
-  uint32 signatureIdx;
-  char *deflateBuffer =
-      reinterpret_cast<char*>(DeflateBuffer((const uint8*)(subStr.c_str()), subStr.size(), &deflateSize));
-  // The flag length at least 6 byte, so we do not compress if compress gain less than 6 byte.
-  if (subStr.size() < deflateSize + 6) {
-    signatureIdx = FindOrInsertReflectString("0!" + subStr);
-  } else {
-    CHECK_FATAL(deflateBuffer != nullptr, "deflateBuffer check");
-    std::string deflateString(deflateBuffer, deflateBuffer + deflateSize);
-    signatureIdx = FindOrInsertReflectString(std::to_string(deflateSize) + "!" + std::to_string(subStr.size()) + "!" +
-                                             deflateString);
-  }
-  if (deflateBuffer != nullptr) {
-    delete[] deflateBuffer;
-    deflateBuffer = nullptr;
-  }
-  return signatureIdx;
+  return FindOrInsertReflectString("0!" + subStr);
 }
 
 static uint32 FirstFindOrInsertRepeatString(const std::string &str, bool isHot, uint8 hotType) {
@@ -809,6 +765,10 @@ static void ConvertFieldName(std::string &fieldname, bool staticfield) {
     CHECK_FATAL(pos1 != fieldname.npos, "fieldname not found");
     int fieldLength = strlen(kClassNameSplitterStr);
     fieldname = fieldname.substr(pos1 + fieldLength);
+    size_t pos2 = fieldname.find(kNameSplitterStr);
+    if (pos2 != fieldname.npos) {
+      fieldname = fieldname.substr(0, pos2);
+    }
   }
   fieldname = NameMangler::DecodeName(fieldname);
 }