diff --git a/Readme.md b/Readme.md
index f8b08f09d68d310776cae873cce2a734c21b5dda..8f5c955775e599a7bef067b1e7500d477b82b048 100644
--- a/Readme.md
+++ b/Readme.md
@@ -1,98 +1,112 @@
-# OpenArkCompiler
-
-## 概述
------------------
-> 面向多设备、支持多语言的统一编程平台。
-
-OpenArkCompiler是来自华为方舟编译器的开源项目。
-
-### OpenArkCompiler 四个技术特点 ###
-
-能够将不同语言代码编译成一套可执行文件，在运行环境中高效执行：
-- 支持多语言联合优化、消除跨语言调用开销；
-- 更轻量的语言运行时；
-- 软硬协同充分发挥硬件能效；
-- 支持多样化的终端设备平台
-
-## 开源计划
-**编译器框架代码开源**
-- 时间：2019年8月 
-- 开源范围：编译器IR+中端语言实现
-- 开放能力：
-   - 框架开源供参考学习，了解方舟编译器架构及框架代码
-   - 开发者可构建出完整编译器工具链，支持Java Sample程序编译（非应用）
-
-**后续开源范围**
-陆续开源编译器前端、后端、编译优化；完整支持Java程序编译、JavaScript语言应用的编译等。
-
-**计划持续更新...**
-
-## 相关文档
-
-- 架构设计原理
-   - [MAPLE IR Design](doc/en/MapleIRDesign.md)
-   - [RC API](doc/cn/RC_API.md)
-   - [Naive RC操作插入原理](doc/cn/Naive_RC_Insertion_Description.md)
-   - [虚函数表和接口函数表设计介绍](doc/cn/Vtable_Itable_Description.md)
-   - [Phase设计介绍](doc/cn/Compiler_Phase_Description.md)
-
-- [环境配置](doc/cn/Development_Preparation.md)
-
-- [开发者指南](doc/cn/Developer_Guide.md)
-
-- [编程规范](doc/cn/Programming_Specifications.md)
-
-
-
-## 许可证
-- [LICENSE](license/LICENSE)
-
-
-
-## Overview
------------------
-> Unified programming platform supporting multiple devices and languages
-
-OpenArkCompiler is Huawei's open source project.
-
-### Four Technical Features of OpenArkCompiler ###
-
-Compiles code of different languages into a set of executable files and efficiently executes the files in the running environment.
-- Supports joint optimization of multiple languages and eliminates cross-language calling overhead.
-- Achieves lightweight language runtime.
-- Collaborates hardware and software to maximize hardware energy efficiency.
-- Supports diversified terminal platforms.
-
-## Open Source Plan
-**Open source compiler framework code**
-- Time: August, 2019 
-- Scope: Compiler IR and middle-end language implementation
-- Benefits:
-   - Provides an open source framework for understanding the architecture and framework code of OpenArkCompiler.
-   - Allows developers to build a complete compiler toolchain that supports the compilation of Java samples (non-application).
-
-**Subsequent open source scope**
-Open the front end, back end, and compilation optimization of compilers. Support the full compilation of Java programs and JavaScript applications.
-
-**Updating...**
-
-## Related Documents
-
-- Architecture Design Principles
-   - [MAPLE IR Design](doc/en/MapleIRDesign.md)
-   - [RC API](doc/en/RC_API.md)
-   - [Naive RC Insertion Principle](doc/en/Naive_RC_Insertion_Description.md)
-   - [Virtual Table and Interface Table Design](doc/en/Vtable_Itable_Description.md)
-   - [Phase Design](doc/en/Compiler_Phase_Description.md)
-
-
-- [Environment Configuration](doc/en/Development_Preparation.md)
-
-- [Developer Guide](doc/en/Developer_Guide.md)
-
-- [Programming Specifications](doc/en/Programming_Specifications.md)
-
-
-
-## License
-- [LICENSE](license/LICENSE)
\ No newline at end of file
+# OpenArkCompiler
+
+## 概述
+-----------------
+> 面向多设备、支持多语言的统一编程平台。
+
+OpenArkCompiler是来自华为方舟编译器的开源项目。
+
+### OpenArkCompiler 四个技术特点 ###
+
+能够将不同语言代码编译成一套可执行文件，在运行环境中高效执行：
+- 支持多语言联合优化、消除跨语言调用开销；
+- 更轻量的语言运行时；
+- 软硬协同充分发挥硬件能效；
+- 支持多样化的终端设备平台
+
+## 开源计划
+**编译器框架代码开源**
+- 时间：2019年8月
+- 开源范围：编译器IR+中端语言实现
+- 开放能力：
+   - 框架开源供参考学习，了解方舟编译器架构及框架代码
+   - 开发者可构建出完整编译器工具链，支持Java Sample程序编译（非应用）
+
+**后续开源范围**
+陆续开源编译器前端、后端、编译优化；完整支持Java程序编译、JavaScript语言应用的编译等。
+
+|开源范围          |2020年3月       |2020年5月             |
+| ------------ | -------------------|--------------------- |
+|编译器前端    |jbc前端基础框架     |前端全量开源          |
+|编译器中端    |独立优化Phase每周持续开源                  ||
+|编译器后端    |后端开源(O0) (aarch64)|独立优化按周开源(O2) (aarch64)|
+|测试框架      |测试框架+基础用例开源| |
+
+**计划持续更新...**
+
+## 相关文档
+
+- 架构设计原理
+   - [MAPLE IR Design](doc/en/MapleIRDesign.md)
+   - [RC API](doc/cn/RC_API.md)
+   - [Naive RC操作插入原理](doc/cn/Naive_RC_Insertion_Description.md)
+   - [虚函数表和接口函数表设计介绍](doc/cn/Vtable_Itable_Description.md)
+   - [Phase设计介绍](doc/cn/Compiler_Phase_Description.md)
+
+- [环境配置](doc/cn/Development_Preparation.md)
+
+- [开发者指南](doc/cn/Developer_Guide.md)
+
+- [编程规范](doc/cn/Programming_Specifications.md)
+
+
+
+## 许可证
+- [LICENSE](license/LICENSE)
+
+
+
+## Overview
+-----------------
+> Unified programming platform supporting multiple devices and languages
+
+OpenArkCompiler is Huawei's open source project.
+
+### Four Technical Features of OpenArkCompiler ###
+
+Compiles code of different languages into a set of executable files and efficiently executes the files in the running environment.
+- Supports joint optimization of multiple languages and eliminates cross-language calling overhead.
+- Achieves lightweight language runtime.
+- Collaborates hardware and software to maximize hardware energy efficiency.
+- Supports diversified terminal platforms.
+
+## Open Source Plan
+**Open source compiler framework code**
+- Time: August, 2019
+- Scope: Compiler IR and middle-end language implementation
+- Benefits:
+   - Provides an open source framework for understanding the architecture and framework code of OpenArkCompiler.
+   - Allows developers to build a complete compiler toolchain that supports the compilation of Java samples (non-application).
+
+**Subsequent open source scope**
+Open the front end, back end, and compilation optimization of compilers. Support the full compilation of Java programs and JavaScript applications.
+
+|Open Source Scope|March 2020 |May 2020 |
+| ------------ | -------------------|--------------------- |
+|Front end| Jbc front-end basic framework | Front-end full open source |
+|Middle end |Weekly open source optimization phase |       |
+|Back end |Backend open source (O0) (aarch64)|Weekly open source optimization (O2) (aarch64)|
+|Test framework|Test framework and basic Cases|     |
+
+**Updating...**
+
+## Related Documents
+
+- Architecture Design Principles
+   - [MAPLE IR Design](doc/en/MapleIRDesign.md)
+   - [RC API](doc/en/RC_API.md)
+   - [Naive RC Insertion Principle](doc/en/Naive_RC_Insertion_Description.md)
+   - [Virtual Table and Interface Table Design](doc/en/Vtable_Itable_Description.md)
+   - [Phase Design](doc/en/Compiler_Phase_Description.md)
+
+
+- [Environment Configuration](doc/en/Development_Preparation.md)
+
+- [Developer Guide](doc/en/Developer_Guide.md)
+
+- [Programming Specifications](doc/en/Programming_Specifications.md)
+
+
+
+## License
+- [LICENSE](license/LICENSE)
diff --git a/build/config/BUILDCONFIG.gn b/build/config/BUILDCONFIG.gn
index c36b0f3b9430e167055d9f124cb74ef9f56777e7..072250868a59e6935c52e23c37cb46512d5bfc3e 100644
--- a/build/config/BUILDCONFIG.gn
+++ b/build/config/BUILDCONFIG.gn
@@ -44,18 +44,29 @@ GN_RANLIB_CROSS_COMPILER = "/usr/bin/aarch64-linux-gnu-ranlib"
 
 # C/CXX Build flags
 cflags = []
+cflags_cc = []
+cflags_c = []
 if (GN_BUILD_TYPE == "RELEASE") {
-  cflags_cc = [ "-O3" ]
-  cflags_c = [ "-O3" ]
+  cflags_cc += [ "-O2" ]
+  cflags_c += [ "-O2" ]
 } else if (GN_BUILD_TYPE == "DEBUG") {
-  cflags_cc = [
+  cflags_cc += [
     "-O0",
     "-g3",
   ]
-  cflags_c = [
+  cflags_c += [
     "-O0",
     "-g3",
   ]
+} else {
+  cflags_cc += [
+    "-O2",
+    "-g",
+  ]
+  cflags_c += [
+    "-O2",
+    "-g",
+  ]
 }
 
 cflags_c += [
diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl
index 17dc2c32c6d4d65483c9d09f5de5231a67de1e21..cda7ba6d4877991ece9166593edc8e5aaeafbf5e 100755
Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ
diff --git a/src/bin/maple b/src/bin/maple
index a93ce9804a9290c9a5eafef1f5ae8660bb5ca8b8..7c64c05eacea21dce23efacac0cfb0482a9afc63 100755
Binary files a/src/bin/maple and b/src/bin/maple differ
diff --git a/src/deplibs/libmplphase.a b/src/deplibs/libmplphase.a
index 5548da460e160e785e02080520b02449cedaad31..3948955a14d609c1ab3234140e4df415018f77e1 100644
Binary files a/src/deplibs/libmplphase.a and b/src/deplibs/libmplphase.a differ
diff --git a/src/deplibs/libmplutil.a b/src/deplibs/libmplutil.a
index 1295f6e06da54aece2c4a83a0ee32569dfa11f17..87ca3e6fbb4f3f331ebc32da081cc729dccca0f4 100644
Binary files a/src/deplibs/libmplutil.a and b/src/deplibs/libmplutil.a differ
diff --git a/src/maple_driver/include/option_parser.h b/src/maple_driver/include/option_parser.h
index 3ef522dee9453213fb72f254e69be9ae3b9b3f6a..f228412da855bbb834ab01fe295a6a52b567ccfe 100644
--- a/src/maple_driver/include/option_parser.h
+++ b/src/maple_driver/include/option_parser.h
@@ -31,8 +31,7 @@ enum ArgCheckPolicy {
   kArgCheckPolicyNone,
   kArgCheckPolicyOptional,
   kArgCheckPolicyRequired,
-  kArgCheckPolicyNumeric,
-  kArgCheckPolicyBool
+  kArgCheckPolicyNumeric
 };
 
 struct ExtraOption {
@@ -91,7 +90,7 @@ struct Descriptor {
   const char * const exeName;
 
   // option key mapping to target tool
-  const std::vector<ExtraOption> extras;
+  const ExtraOption extras[kMaxExtraOptions];
 #endif
 
   bool IsEnabledForCurrentBuild() const {
@@ -204,12 +203,6 @@ class OptionParser {
     return nonOptionsArgs.size();
   }
 
-#ifdef OPTION_PARSER_EXTRAOPT
-  void InsertExtraUsage(const Descriptor &usage);
-#endif
-
-  void CreateNoOption(const Descriptor &usage);
-
   void PrintUsage() const;
 
 #ifdef OPTION_PARSER_EXTRAOPT
@@ -230,15 +223,11 @@ class OptionParser {
     }
   }
   bool CheckSpecialOption(const std::string &option, std::string &key, std::string &value);
-  std::vector<Descriptor> rawUsages;
+  const Descriptor *rawUsages;
   std::multimap<std::string, Descriptor> usages;
   std::vector<Option> options;
   std::vector<std::string> nonOptionsArgs;
 };
-enum EnabledIndex {
-  kDisable,
-  kEnable
-};
 }  // namespace mapleOption
 
 #endif  // MAPLE_UTIL_INCLUDE_OPTION_PARSER_H
diff --git a/src/maple_driver/include/safe_exe.h b/src/maple_driver/include/safe_exe.h
index 626782ebf06ebcbd61477ffadd57376349782ade..0f0532e2139240bcbe0e33c228d8466abdb1e3ab 100644
--- a/src/maple_driver/include/safe_exe.h
+++ b/src/maple_driver/include/safe_exe.h
@@ -44,7 +44,7 @@ class SafeExe {
     // argv[0] is program name
     // copy args
     for (size_t j = 0; j < vectorArgs.size(); ++j) {
-      int strLength = vectorArgs[j].size();
+      size_t strLength = vectorArgs[j].size();
       argv[j] = new char[strLength + 1];
       strncpy_s(argv[j], strLength + 1, vectorArgs[j].c_str(), strLength);
       argv[j][strLength] = '\0';
diff --git a/src/maple_driver/include/usages.h b/src/maple_driver/include/usages.h
index 4292712b072ec17d2aa2e9ab5d777130064d0732..2f2dbccfd794cfaac4cd68dc963c9f80c6b33acb 100644
--- a/src/maple_driver/include/usages.h
+++ b/src/maple_driver/include/usages.h
@@ -74,8 +74,10 @@ enum OptionIndex : uint64 {
   kInlineWithProfile,
   kInlineWithoutProfile,
   kMpl2MplUseInline,
+  kMpl2MplNoInline,
   kMpl2MplNoInlineFuncList,
   kMpl2MplUseCrossModuleInline,
+  kMpl2MplNoCrossModuleInline,
   kInlineSmallFunctionThreshold,
   kInlineHotFunctionThreshold,
   kInlineModuleGrowth,
diff --git a/src/maple_driver/src/compiler_factory.cpp b/src/maple_driver/src/compiler_factory.cpp
index 42d4eb81266aa026b669f30e0d0bb65be04e969c..ed011cff0dc884eb3b5bb3d98679914289859ba6 100644
--- a/src/maple_driver/src/compiler_factory.cpp
+++ b/src/maple_driver/src/compiler_factory.cpp
@@ -84,6 +84,10 @@ ErrorCode CompilerFactory::DeleteTmpFiles(const MplOptions &mplOptions, const st
 
 ErrorCode CompilerFactory::Compile(const MplOptions &mplOptions) {
   std::vector<Compiler*> compilers;
+  if (compilerSelector == nullptr) {
+    LogInfo::MapleLogger() << "Failed! Compiler is null." << "\n";
+    return kErrorCompileFail;
+  }
   ErrorCode ret = compilerSelector->Select(supportedCompilers, mplOptions, compilers);
   if (ret != kErrorNoError) {
     return ret;
diff --git a/src/maple_driver/src/maple_comb_compiler.cpp b/src/maple_driver/src/maple_comb_compiler.cpp
index 30f2d85d117d35f06864526a13dcb96d35cf426a..4814de4aa4922f72e67ad220cb0b4672043b0ec0 100644
--- a/src/maple_driver/src/maple_comb_compiler.cpp
+++ b/src/maple_driver/src/maple_comb_compiler.cpp
@@ -24,8 +24,10 @@ namespace maple {
 using namespace mapleOption;
 
 std::string MapleCombCompiler::GetInputFileName(const MplOptions &options) const {
-  if (options.GetRunningExes()[0] == kBinNameMe || options.GetRunningExes()[0] == kBinNameMpl2mpl) {
-    return options.GetInputFiles();
+  if (!options.GetRunningExes().empty()) {
+    if (options.GetRunningExes()[0] == kBinNameMe || options.GetRunningExes()[0] == kBinNameMpl2mpl) {
+      return options.GetInputFiles();
+    }
   }
   if (options.GetInputFileType() == InputFileType::kVtableImplMpl) {
     return options.GetOutputFolder() + options.GetOutputName() + ".VtableImpl.mpl";
@@ -94,7 +96,7 @@ MeOption *MapleCombCompiler::MakeMeOptions(const MplOptions &options, MemPool &o
         meOption->GetRange(opt.Args());
         break;
       case kMeDumpAfter:
-        meOption->dumpAfter = (opt.Type() == kEnable);
+        meOption->dumpAfter = true;
         break;
       case kMeDumpFunc:
         meOption->dumpFunc = opt.Args();
@@ -103,16 +105,16 @@ MeOption *MapleCombCompiler::MakeMeOptions(const MplOptions &options, MemPool &o
         meOption->SplitPhases(opt.Args(), meOption->dumpPhases);
         break;
       case kMeQuiet:
-        meOption->quiet = (opt.Type() == kEnable);
+        meOption->quiet = true;
         break;
       case kSetCalleeHasSideEffect:
-        meOption->setCalleeHasSideEffect = (opt.Type() == kEnable);
+        meOption->setCalleeHasSideEffect = true;
         break;
       case kNoSteensgaard:
-        meOption->noSteensgaard = (opt.Type() == kEnable);
+        meOption->noSteensgaard = true;
         break;
       case kNoTBAA:
-        meOption->noTBAA = (opt.Type() == kEnable);
+        meOption->noTBAA = true;
         break;
       case kAliasAnalysisLevel:
         meOption->aliasAnalysisLevel = std::stoul(opt.Args(), nullptr);
@@ -143,24 +145,18 @@ MeOption *MapleCombCompiler::MakeMeOptions(const MplOptions &options, MemPool &o
           default:
             break;
         }
-        if (options.HasSetDebugFlag()) {
-          LogInfo::MapleLogger() << "--sub options: setCalleeHasSideEffect "
-                                 << meOption->setCalleeHasSideEffect << '\n';
-          LogInfo::MapleLogger() << "--sub options: noSteensgaard " << meOption->noSteensgaard << '\n';
-          LogInfo::MapleLogger() << "--sub options: noTBAA " << meOption->noTBAA << '\n';
-        }
         break;
       case kMeNoDot:
-        meOption->noDot = (opt.Type() == kEnable);
+        meOption->noDot = true;
         break;
       case kStmtNum:
-        meOption->stmtNum = (opt.Type() == kEnable);
+        meOption->stmtNum = true;
         break;
       case kLessThrowAlias:
-        meOption->lessThrowAlias = (opt.Type() == kEnable);
+        meOption->lessThrowAlias = true;
         break;
       case kRegReadAtReturn:
-        meOption->regreadAtReturn = (opt.Type() == kEnable);
+        meOption->regreadAtReturn = true;
         break;
       default:
         WARN(kLncWarn, "input invalid key for me " + opt.OptionKey());
@@ -185,16 +181,16 @@ Options *MapleCombCompiler::MakeMpl2MplOptions(const MplOptions &options, MemPoo
     }
     switch (opt.Index()) {
       case kMpl2MplDumpBefore:
-        mpl2mplOption->dumpBefore = (opt.Type() == kEnable);
+        mpl2mplOption->dumpBefore = true;
         break;
       case kMpl2MplDumpAfter:
-        mpl2mplOption->dumpAfter = (opt.Type() == kEnable);
+        mpl2mplOption->dumpAfter = true;
         break;
       case kMpl2MplDumpFunc:
         mpl2mplOption->dumpFunc = opt.Args();
         break;
       case kMpl2MplQuiet:
-        mpl2mplOption->quiet = (opt.Type() == kEnable);
+        mpl2mplOption->quiet = true;
         break;
       case kMpl2MplDumpPhase:
         mpl2mplOption->dumpPhase = opt.Args();
@@ -209,28 +205,37 @@ Options *MapleCombCompiler::MakeMpl2MplOptions(const MplOptions &options, MemPoo
         mpl2mplOption->skipAfter = opt.Args();
         break;
       case kRegNativeDynamicOnly:
-        mpl2mplOption->regNativeDynamicOnly = (opt.Type() == kEnable);
+        mpl2mplOption->regNativeDynamicOnly = true;
         break;
       case kRegNativeStaticBindingList:
         mpl2mplOption->staticBindingList = opt.Args();
         break;
       case kMpl2MplStubJniFunc:
-        mpl2mplOption->regNativeFunc = (opt.Type() == kEnable);
+        mpl2mplOption->regNativeFunc = true;
         break;
       case kNativeWrapper:
-        mpl2mplOption->nativeWrapper = (opt.Type() == kEnable);
+        mpl2mplOption->nativeWrapper = opt.Type() > 0;
         break;
       case kInlineWithProfile:
-        mpl2mplOption->inlineWithProfile = (opt.Type() == kEnable);
+        mpl2mplOption->inlineWithProfile = true;
+        break;
+      case kInlineWithoutProfile:
+        mpl2mplOption->inlineWithProfile = false;
         break;
       case kMpl2MplUseInline:
-        mpl2mplOption->useInline = (opt.Type() == kEnable);
+        mpl2mplOption->useInline = true;
+        break;
+      case kMpl2MplNoInline:
+        mpl2mplOption->useInline = false;
         break;
       case kMpl2MplNoInlineFuncList:
         mpl2mplOption->noInlineFuncList = opt.Args();
         break;
       case kMpl2MplUseCrossModuleInline:
-        mpl2mplOption->useCrossModuleInline = (opt.Type() == kEnable);
+        mpl2mplOption->useCrossModuleInline = true;
+        break;
+      case kMpl2MplNoCrossModuleInline:
+        mpl2mplOption->useCrossModuleInline = false;
         break;
       case kInlineSmallFunctionThreshold:
         if (opt.Args().empty()) {
@@ -297,21 +302,18 @@ Options *MapleCombCompiler::MakeMpl2MplOptions(const MplOptions &options, MemPoo
         }
         break;
       case kMpl2MplMapleLinker:
-        mpl2mplOption->mapleLinker = (opt.Type() == kEnable);
-        mpl2mplOption->dumpMuidFile = (opt.Type() == kEnable);
-        if (options.HasSetDebugFlag()) {
-          LogInfo::MapleLogger() << "--sub options: dumpMuidFile " << mpl2mplOption->dumpMuidFile << '\n';
-        }
+        mpl2mplOption->mapleLinker = true;
+        mpl2mplOption->dumpMuidFile = true;
         break;
       case kMplnkDumpMuid:
-        mpl2mplOption->dumpMuidFile = (opt.Type() == kEnable);
+        mpl2mplOption->dumpMuidFile = true;
         break;
       case kEmitVtableImpl:
-        mpl2mplOption->emitVtableImpl = (opt.Type() == kEnable);
+        mpl2mplOption->emitVtableImpl = true;
         break;
 #if MIR_JAVA
       case kMpl2MplSkipVirtual:
-        mpl2mplOption->skipVirtualMethod = (opt.Type() == kEnable);
+        mpl2mplOption->skipVirtualMethod = true;
         break;
 #endif
       default:
diff --git a/src/maple_driver/src/mpl_options.cpp b/src/maple_driver/src/mpl_options.cpp
index 7d677cb3ded152fd11a350a9bb2d02412fc97b15..d00d5959f09b9cdcdb845378a7c6790ab17cb8e4 100644
--- a/src/maple_driver/src/mpl_options.cpp
+++ b/src/maple_driver/src/mpl_options.cpp
@@ -328,68 +328,63 @@ const mapleOption::Descriptor USAGES[] = {
     "me",
     { { nullptr } } },
   { kMeQuiet,
-    kEnable,
+    0,
     nullptr,
     "quiet",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --quiet                     \tDisable brief trace messages with phase/function names\n"
-    "  --no-quiet                  \tEnable brief trace messages with phase/function names\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --quiet                     \tDisable brief trace messages with phase/function names\n",
     "me",
     { { nullptr } } },
   { kMeNoDot,
-    kEnable,
+    0,
     nullptr,
     "nodot",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --nodot                     \tDisable dot file generation from cfg\n"
-    "  --no-nodot                  \tEnable dot file generation from cfg\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --nodot                     \tDisable dot file generation from cfg\n",
     "me",
     { { nullptr } } },
   { kSetCalleeHasSideEffect,
-    kEnable,
+    0,
     nullptr,
     "setCalleeHasSideEffect",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --setCalleeHasSideEffect    \tSet all the callees have side effect\n"
-    "  --no-setCalleeHasSideEffect \tNot set all the callees have side effect\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --setCalleeHasSideEffect    \tSet all the callees have side effect\n",
     "me",
     { { nullptr } } },
   { kNoSteensgaard,
-    kEnable,
+    0,
     nullptr,
     "noSteensgaard",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --noSteensgaard             \tDisable Steensgaard-style alias analysis\n"
-    "  --no-noSteensgaard          \tEnable Steensgaard-style alias analysis\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --noSteensgaard             \tDisable Steensgaard-style alias analysis\n",
     "me",
     { { nullptr } } },
   { kNoTBAA,
-    kEnable,
+    0,
     nullptr,
     "noTBAA",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --noTBAA                    \tDisable type-based alias analysis\n"
-    "  --no-noTBAA                 \tEnable type-based alias analysis\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --noTBAA                    \tDisable type-based alias analysis\n",
     "me",
     { { nullptr } } },
   { kAliasAnalysisLevel,
@@ -409,55 +404,51 @@ const mapleOption::Descriptor USAGES[] = {
     "me",
     { { nullptr } } },
   { kStmtNum,
-    kEnable,
+    0,
     nullptr,
     "stmtnum",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --stmtnum                   \tPrint MeStmt index number in IR dump\n"
-    "  --no-stmtnum                \tDon't print MeStmt index number in IR dump\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --stmtnum                   \tPrint MeStmt index number in IR dump\n",
     "me",
     { { nullptr } } },
   { kMeDumpAfter,
-    kEnable,
+    0,
     nullptr,
     "dump-after",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --dump-after                \tDo extra IR dump after the specified phase in me\n"
-    "  --no-dump-after             \tDo not extra IR dump after the specified phase in me\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --dump-after                \tDo extra IR dump after the specified phase in me\n",
     "me",
     { { nullptr } } },
   { kLessThrowAlias,
-    kEnable,
+    0,
     nullptr,
     "lessthrowalias",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --lessthrowalias            \tHandle aliases at java throw statements more accurately\n"
-    "  --no-lessthrowalias         \tDisable lessthrowalias\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --lessthrowalias            \tHandle aliases at java throw statements more accurately\n",
     "me",
     { { nullptr } } },
   { kRegReadAtReturn,
-    kEnable,
+    0,
     nullptr,
     "regreadatreturn",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --regreadatreturn           \tAllow register promotion to promote the operand of return statements\n"
-    "  --no-regreadatreturn        \tDisable regreadatreturn\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --regreadatreturn           \tAllow register promotion to promote the operand of return statements\n",
     "me",
     { { nullptr } } },
   // mpl2mpl
@@ -541,67 +532,86 @@ const mapleOption::Descriptor USAGES[] = {
     "mpl2mpl",
     { { nullptr } } },
   { kMpl2MplQuiet,
-    kEnable,
+    0,
     nullptr,
     "quiet",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --quiet                     \tDisable brief trace messages with phase/function names\n"
-    "  --no-quiet                  \tEnable brief trace messages with phase/function names\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --quiet                     \tDisable brief trace messages with phase/function names\n",
     "mpl2mpl",
     { { nullptr } } },
   { kMpl2MplMapleLinker,
-    kEnable,
+    0,
     nullptr,
     "maplelinker",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --maplelinker               \tGenerate MUID symbol tables and references\n"
-    "  --no-maplelinker            \tDon't Generate MUID symbol tables and references\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --maplelinker               \tGenerate MUID symbol tables and references\n",
     "mpl2mpl",
     { { nullptr } } },
   { kMpl2MplStubJniFunc,
-    kEnable,
+    0,
     nullptr,
     "regnativefunc",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --regnativefunc             \tGenerate native stub function to support JNI registration and calling\n"
-    "  --no-regnativefunc          \tDisable regnativefunc\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --regnativefunc             \tGenerate native stub function to support JNI registration and calling\n",
     "mpl2mpl",
     { { nullptr } } },
   { kInlineWithProfile,
-    kEnable,
+    0,
     nullptr,
     "inline-with-profile",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --inline-with-profile       \tEnable profile-based inlining\n"
-    "  --no-inline-with-profile    \tDisable profile-based inlining\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --inline-with-profile       \tEnable profile-based inlining\n",
+    "mpl2mpl",
+    { { nullptr } } },
+  { kInlineWithoutProfile,
+    0,
+    nullptr,
+    "inline-without-profile",
+    nullptr,
+    false,
+    nullptr,
+    mapleOption::BuildType::kBuildTypeAll,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --inline-without-profile    \tDisable profile-based inlining\n",
     "mpl2mpl",
     { { nullptr } } },
   { kMpl2MplUseInline,
-    kEnable,
+    0,
     nullptr,
     "inline",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --inline                    \tEnable function inlining\n"
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --inline                    \tEnable function inlining\n",
+    "mpl2mpl",
+    { { nullptr } } },
+  { kMpl2MplNoInline,
+    0,
+    nullptr,
+    "no-inline",
+    nullptr,
+    false,
+    nullptr,
+    mapleOption::BuildType::kBuildTypeAll,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
     "  --no-inline                 \tDisable function inlining\n",
     "mpl2mpl",
     { { nullptr } } },
@@ -618,15 +628,26 @@ const mapleOption::Descriptor USAGES[] = {
     "mpl2mpl",
     { { nullptr } } },
   { kMpl2MplUseCrossModuleInline,
-    kEnable,
+    0,
     nullptr,
     "cross-module-inline",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --cross-module-inline       \tEnable cross-module inlining\n"
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --cross-module-inline       \tEnable cross-module inlining\n",
+    "mpl2mpl",
+    { { nullptr } } },
+  { kMpl2MplNoCrossModuleInline,
+    0,
+    nullptr,
+    "no-cross-module-inline",
+    nullptr,
+    false,
+    nullptr,
+    mapleOption::BuildType::kBuildTypeAll,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
     "  --no-cross-module-inline    \tDisable cross-module inlining\n",
     "mpl2mpl",
     { { nullptr } } },
@@ -734,21 +755,32 @@ const mapleOption::Descriptor USAGES[] = {
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
     "  --nativewrapper             \tGenerate native wrappers [default]\n",
     "mpl2mpl",
     { { nullptr } } },
+  { kNativeWrapper,
+    kDisable,
+    nullptr,
+    "no-nativewrapper",
+    nullptr,
+    false,
+    nullptr,
+    mapleOption::BuildType::kBuildTypeAll,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --no-nativewrapper\n",
+    "mpl2mpl",
+    { { nullptr } } },
   { kRegNativeDynamicOnly,
-    kEnable,
+    0,
     nullptr,
     "regnative-dynamic-only",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --regnative-dynamic-only    \tOnly Generate dynamic register code, Report Fatal Msg if no implemented\n"
-    "  --no-regnative-dynamic-only \tDisable regnative-dynamic-only\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --regnative-dynamic-only    \tOnly Generate dynamic register code, Report Fatal Msg if no implemented\n",
     "mpl2mpl",
     { { nullptr } } },
   { kRegNativeStaticBindingList,
@@ -765,69 +797,64 @@ const mapleOption::Descriptor USAGES[] = {
     "mpl2mpl",
     { { nullptr } } },
   { kMpl2MplDumpBefore,
-    kEnable,
+    0,
     nullptr,
     "dump-before",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --dump-before               \tDo extra IR dump before the specified phase\n"
-    "  --no-dump-before            \tDon't extra IR dump before the specified phase\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --dump-before               \tDo extra IR dump before the specified phase\n",
     "mpl2mpl",
     { { nullptr } } },
   { kMpl2MplDumpAfter,
-    kEnable,
+    0,
     nullptr,
     "dump-after",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --dump-after                \tDo extra IR dump after the specified phase\n"
-    "  --no-dump-after             \tDon't extra IR dump after the specified phase\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --dump-after                \tDo extra IR dump after the specified phase\n",
     "mpl2mpl",
     { { nullptr } } },
   { kMplnkDumpMuid,
-    kEnable,
+    0,
     nullptr,
     "dump-muid",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --dump-muid                 \tDump MUID def information into a .muid file\n"
-    "  --no-dump-muid              \tDon't dump MUID def information into a .muid file\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --dump-muid                 \tDump MUID def information into a .muid file\n",
     "mpl2mpl",
     { { nullptr } } },
   { kEmitVtableImpl,
-    kEnable,
+    0,
     nullptr,
     "emitVtableImpl",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --emitVtableImpl            \tgenerate VtableImpl file\n"
-    "  --no-emitVtableImpl         \tDon't generate VtableImpl file\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --emitVtableImpl            \tgenerate VtableImpl file\n",
     "mpl2mpl",
     { { nullptr } } },
 #if MIR_JAVA
   { kMpl2MplSkipVirtual,
-    kEnable,
+    0,
     nullptr,
     "skipvirtual",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --skipvirtual\n"
-    "  --no-skipvirtual\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --skipvirtual\n",
     "mpl2mpl",
     { { nullptr } } },
 #endif
@@ -840,10 +867,22 @@ const mapleOption::Descriptor USAGES[] = {
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    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,
@@ -852,10 +891,22 @@ const mapleOption::Descriptor USAGES[] = {
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    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,
@@ -864,10 +915,22 @@ const mapleOption::Descriptor USAGES[] = {
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    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,
@@ -876,7 +939,7 @@ const mapleOption::Descriptor USAGES[] = {
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
     "  --maplelinker               \tGenerate the MapleLinker .s format\n",
     "mplcg",
     { { nullptr } } },
@@ -888,10 +951,23 @@ const mapleOption::Descriptor USAGES[] = {
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    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 } } },
+
   { kDuplicateToDelPlt,
     0,
     nullptr,
@@ -1166,7 +1242,11 @@ ErrorCode MplOptions::AddOption(const mapleOption::Option &option) {
     // For outside compilers, such as jbc2mpl
     options[extra.exeName].push_back(option);
     // For internel compilers, such as me, mpl2mpl
-    exeOptions[extra.exeName].push_back(option);
+    auto &exeOption = exeOptions[extra.exeName];
+    bool ret = optionParser->SetOption(option.OptionKey(), option.Args(), extra.exeName, exeOption);
+    if (!ret) {
+      return kErrorInvalidParameter;
+    }
   }
   return kErrorNoError;
 }
diff --git a/src/maple_driver/src/mplcg_compiler.cpp b/src/maple_driver/src/mplcg_compiler.cpp
index f5fc2f53cbc77db824ef73dba1c5f044f35beaf1..497a34eacb18f4d26384fa4639dfc66c11e99994 100644
--- a/src/maple_driver/src/mplcg_compiler.cpp
+++ b/src/maple_driver/src/mplcg_compiler.cpp
@@ -41,8 +41,10 @@ std::vector<std::string> MplcgCompiler::GetBinNames() const {
 }
 
 std::string MplcgCompiler::GetInputFileName(const MplOptions &options) const {
-  if (options.GetRunningExes()[0] == kBinNameMplcg) {
-    return options.GetInputFiles();
+  if (!options.GetRunningExes().empty()) {
+    if (options.GetRunningExes()[0] == kBinNameMplcg) {
+      return options.GetInputFiles();
+    }
   }
   auto idx = options.GetOutputName().find(".VtableImpl");
   std::string outputName = options.GetOutputName();
diff --git a/src/maple_driver/src/option_parser.cpp b/src/maple_driver/src/option_parser.cpp
index cfc5d5bddf24318386f192fd4cd336445d0e1460..b639a8f6a72b4d1d57cb40ec7092cb7debb33333 100644
--- a/src/maple_driver/src/option_parser.cpp
+++ b/src/maple_driver/src/option_parser.cpp
@@ -21,100 +21,20 @@
 using namespace maple;
 using namespace mapleOption;
 
-OptionParser::OptionParser(const Descriptor usage[]) {
+OptionParser::OptionParser(const Descriptor usage[]) : rawUsages(usage) {
   for (size_t i = 0; usage[i].help != nullptr; ++i) {
-    rawUsages.push_back(usage[i]);
     if (usage[i].shortOption != nullptr) {
       InsertOption(std::string(usage[i].shortOption), usage[i]);
     }
     if (usage[i].longOption != nullptr) {
       InsertOption(std::string(usage[i].longOption), usage[i]);
     }
-#ifdef OPTION_PARSER_EXTRAOPT
-    // Insert usage for extra options
-    InsertExtraUsage(usage[i]);
-#endif
-    // Add --no-opt for boolean option
-    if (usage[i].checkPolicy == kArgCheckPolicyBool) {
-      CreateNoOption(usage[i]);
-    }
-  }
-}
-
-#ifdef OPTION_PARSER_EXTRAOPT
-void OptionParser::InsertExtraUsage(const Descriptor &usage) {
-  unsigned int index = 0;
-  while (index < kMaxExtraOptions && usage.extras[index].exeName != nullptr) {
-    Descriptor tempUsage = { usage.index,
-                             usage.type,
-                             usage.shortOption,
-                             usage.longOption,
-                             nullptr,
-                             false,
-                             nullptr,
-                             usage.enableBuildType,
-                             usage.checkPolicy,
-                             usage.help,
-                             usage.extras[index].exeName,
-                             { { nullptr } } };
-    if (usage.shortOption != nullptr) {
-      InsertOption(std::string(usage.shortOption), tempUsage);
-    }
-    if (usage.longOption != nullptr) {
-      InsertOption(std::string(usage.longOption), tempUsage);
-    }
-    rawUsages.push_back(tempUsage);
-    index++;
-  }
-}
-#endif
-
-void OptionParser::CreateNoOption(const Descriptor &usage) {
-  std::string longOpt = "";
-  std::string shortOpt = "";
-  std::string newHelpInfo = "";
-  if (usage.shortOption != nullptr) {
-    std::ostringstream optionString;
-    optionString << "no-" << usage.shortOption; // Generate short option: no-opt
-    shortOpt = optionString.str();
-  }
-  if (usage.longOption != nullptr) {
-    std::ostringstream optionString;
-    optionString << "no-" << usage.longOption; // Generate long option: no-opt
-    longOpt = optionString.str();
   }
-  Descriptor tempUsage = { usage.index,
-                           kDisable, // Change to disable
-                           (usage.shortOption != nullptr) ? shortOpt.c_str() : nullptr,
-                           (usage.longOption != nullptr) ? longOpt.c_str() : nullptr,
-#ifdef OPTION_PARSER_EXTRAOPT
-                           nullptr,
-                           false,
-                           nullptr,
-#endif
-                           usage.enableBuildType,
-                           usage.checkPolicy,
-                           usage.help,
-#ifdef OPTION_PARSER_EXTRAOPT
-                           usage.exeName,
-                           usage.extras
-#endif
-  };
-  if (usage.shortOption != nullptr) {
-    InsertOption(shortOpt, tempUsage);
-  }
-  if (usage.longOption != nullptr) {
-    InsertOption(longOpt, tempUsage);
-  }
-#ifdef OPTION_PARSER_EXTRAOPT
-  // Insert usage for extra options
-  InsertExtraUsage(tempUsage);
-#endif
 }
 
 void OptionParser::PrintUsage() const {
-  for (size_t i = 0; i < rawUsages.size(); ++i) {
-    if (rawUsages[i].help != nullptr && rawUsages[i].IsEnabledForCurrentBuild()) {
+  for (size_t i = 0; rawUsages[i].help != nullptr; ++i) {
+    if (rawUsages[i].IsEnabledForCurrentBuild()) {
       LogInfo::MapleLogger() << rawUsages[i].help << '\n';
     }
   }
@@ -122,8 +42,8 @@ void OptionParser::PrintUsage() const {
 
 #ifdef OPTION_PARSER_EXTRAOPT
 void OptionParser::PrintUsage(const std::string &helpType) const {
-  for (size_t i = 0; i < rawUsages.size(); ++i) {
-    if (rawUsages[i].help != nullptr && rawUsages[i].IsEnabledForCurrentBuild() && rawUsages[i].exeName == helpType) {
+  for (size_t i = 0; rawUsages[i].help != nullptr; ++i) {
+    if (rawUsages[i].IsEnabledForCurrentBuild() && rawUsages[i].exeName == helpType) {
       LogInfo::MapleLogger() << rawUsages[i].help << '\n';
     }
   }
diff --git a/src/maple_ipa/include/interleaved_manager.h b/src/maple_ipa/include/interleaved_manager.h
index 9357539da3db25b34ed94671a9244837b5d90f6b..3e477f55462e7a696c164c0a4abc8265243c0b1d 100644
--- a/src/maple_ipa/include/interleaved_manager.h
+++ b/src/maple_ipa/include/interleaved_manager.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ * Copyright (c) [2019-2020] 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.
@@ -46,20 +46,13 @@ class InterleavedManager {
     return &allocator;
   }
 
-  MemPool *GetMempool() {
+  MemPool *GetMemPool() {
     return allocator.GetMemPool();
   }
 
   void AddPhases(const std::vector<std::string> &phases, bool isModulePhase, bool timePhases = false,
                  bool genMpl = false);
-  void AddIPAPhases(std::vector<std::string> &phases, bool timePhases = false, bool genMpl = false);
   void Run();
-  void IPARun(MeFuncPhaseManager&);
-
-  const PhaseManager *AccessPhaseManager(size_t i) const {
-    return phaseManagers.at(i);
-  }
-
   const PhaseManager *GetSupportPhaseManager(const std::string &phase);
 
  private:
diff --git a/src/maple_ipa/include/module_phase.h b/src/maple_ipa/include/module_phase.h
index a1d8cbe8736dc667a75d87e06ecf378e4a73f601..c80949ea61001f3573ea1db9328d7425df6efa4e 100644
--- a/src/maple_ipa/include/module_phase.h
+++ b/src/maple_ipa/include/module_phase.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ * Copyright (c) [2019-2020] 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.
@@ -36,7 +36,7 @@ class ModulePhase : public Phase {
 
   virtual ~ModulePhase() = default;
 
-  virtual AnalysisResult *Run(MIRModule *module, ModuleResultMgr*) = 0;
+  virtual AnalysisResult *Run(MIRModule *module, ModuleResultMgr *mrm) = 0;
 
   ModulePhaseID GetPhaseID() const {
     return phaseID;
diff --git a/src/maple_ipa/include/module_phase_manager.h b/src/maple_ipa/include/module_phase_manager.h
index 69091a28b2d6036f40b43591c54f67d9c75f20a4..6d67477e066306656abb209455710f8431b85416 100644
--- a/src/maple_ipa/include/module_phase_manager.h
+++ b/src/maple_ipa/include/module_phase_manager.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ * Copyright (c) [2019-2020] 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.
@@ -30,11 +30,10 @@ class ModulePhaseManager : public PhaseManager {
 
   ~ModulePhaseManager() = default;
 
-  // register all module phases defined in module_phases.def
+  // Register all module phases defined in module_phases.def
   void RegisterModulePhases();
   // Add module phases which are going to be run
   void AddModulePhases(const std::vector<std::string> &phases);
-  void RunModulePhases() const;
   ModuleResultMgr *GetModResultMgr() override {
     return arModuleMgr;
   }
diff --git a/src/maple_ipa/src/interleaved_manager.cpp b/src/maple_ipa/src/interleaved_manager.cpp
index 997d380680ce87277e1d138b1798d2f48a7f575f..e41d87f5ba9720e52c1fd52a0e9ddd5f18815455 100644
--- a/src/maple_ipa/src/interleaved_manager.cpp
+++ b/src/maple_ipa/src/interleaved_manager.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ * Copyright (c) [2019-2020] 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.
@@ -16,7 +16,6 @@
 #include <string>
 #include <vector>
 #include <iomanip>
-
 #include "module_phase.h"
 #include "mir_function.h"
 #include "me_option.h"
@@ -24,7 +23,6 @@
 #include "phase_manager.h"
 
 namespace maple {
-
 void InterleavedManager::AddPhases(const std::vector<std::string> &phases, bool isModulePhase, bool timePhases,
                                    bool genMpl) {
   ModuleResultMgr *mrm = nullptr;
@@ -35,7 +33,7 @@ void InterleavedManager::AddPhases(const std::vector<std::string> &phases, bool
   }
 
   if (isModulePhase) {
-    auto *mpm = GetMempool()->New<ModulePhaseManager>(GetMempool(), mirModule, mrm);
+    auto *mpm = GetMemPool()->New<ModulePhaseManager>(GetMemPool(), mirModule, mrm);
     mpm->RegisterModulePhases();
     mpm->AddModulePhases(phases);
     if (timePhases) {
@@ -43,7 +41,7 @@ void InterleavedManager::AddPhases(const std::vector<std::string> &phases, bool
     }
     phaseManagers.push_back(mpm);
   } else {  // MeFuncPhase
-    auto *fpm = GetMempool()->New<MeFuncPhaseManager>(GetMempool(), mirModule, mrm);
+    auto *fpm = GetMemPool()->New<MeFuncPhaseManager>(GetMemPool(), mirModule, mrm);
     fpm->RegisterFuncPhases();
     if (genMpl) {
       fpm->SetGenMeMpl(true);
@@ -128,13 +126,13 @@ void InterleavedManager::DumpTimers() {
 void InterleavedManager::InitSupportPhaseManagers() {
   ASSERT(supportPhaseManagers.empty(), "Phase managers already initialized");
 
-  auto *mpm = GetMempool()->New<ModulePhaseManager>(GetMempool(), mirModule, nullptr);
+  auto *mpm = GetMemPool()->New<ModulePhaseManager>(GetMemPool(), mirModule, nullptr);
   mpm->RegisterModulePhases();
   supportPhaseManagers.push_back(mpm);
 
   ModuleResultMgr *mrm = mpm->GetModResultMgr();
 
-  auto *fpm = GetMempool()->New<MeFuncPhaseManager>(GetMempool(), mirModule, mrm);
+  auto *fpm = GetMemPool()->New<MeFuncPhaseManager>(GetMemPool(), mirModule, mrm);
   fpm->RegisterFuncPhases();
   supportPhaseManagers.push_back(fpm);
 }
diff --git a/src/maple_ipa/src/module_phase_manager.cpp b/src/maple_ipa/src/module_phase_manager.cpp
index d0d2d3388323a906945f68125833acc492f295d9..22f4985aafdd8cb558b42ed0ccd7572852d8a4b2 100644
--- a/src/maple_ipa/src/module_phase_manager.cpp
+++ b/src/maple_ipa/src/module_phase_manager.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ * Copyright (c) [2019-2020] 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.
@@ -16,6 +16,8 @@
 #include "class_hierarchy.h"
 #include "class_init.h"
 #include "option.h"
+#include "bin_mpl_export.h"
+#include "mpl_timer.h"
 #if MIR_JAVA
 #include "native_stub_func.h"
 #include "vtable_analysis.h"
@@ -26,32 +28,29 @@
 #include "native_stub_func.h"
 #include "muid_replacement.h"
 #include "gen_check_cast.h"
-#endif
-#include "bin_mpl_export.h"
-#include "mpl_timer.h"
+#endif  // ~MIR_JAVA
 
 namespace {
 constexpr char kDotStr[] = ".";
 constexpr char kDotMplStr[] = ".mpl";
-} // namespace
+}
 
 namespace maple {
-// Manage the phases of middle and implement some maplecomb-options such as
-// skipAfter, skipFrom, quiet.
 void ModulePhaseManager::RegisterModulePhases() {
 #define MODAPHASE(id, modphase)                                                    \
   do {                                                                             \
     MemPool *memPool = GetMemPool();                                               \
     ModulePhase *phase = new (memPool->Malloc(sizeof(modphase(id)))) modphase(id); \
-    CHECK_FATAL(phase != nullptr, "null ptr check ");                              \
+    CHECK_NULL_FATAL(phase);                                                       \
     RegisterPhase(id, *phase);                                                     \
     arModuleMgr->AddAnalysisPhase(id, phase);                                      \
   } while (0);
-#define MODTPHASE(id, modphase)                                                    \
+
+#define MODTPHASE(id, modPhase)                                                    \
   do {                                                                             \
     MemPool *memPool = GetMemPool();                                               \
-    ModulePhase *phase = new (memPool->Malloc(sizeof(modphase(id)))) modphase(id); \
-    CHECK_FATAL(phase != nullptr, "null ptr check ");                              \
+    ModulePhase *phase = new (memPool->Malloc(sizeof(modPhase(id)))) modPhase(id); \
+    CHECK_NULL_FATAL(phase);                                                       \
     RegisterPhase(id, *phase);                                                     \
   } while (0);
 #include "module_phases.def"
@@ -65,8 +64,6 @@ void ModulePhaseManager::AddModulePhases(const std::vector<std::string> &phases)
   }
 }
 
-void ModulePhaseManager::RunModulePhases() const {}
-
 void ModulePhaseManager::Run() {
   int phaseIndex = 0;
   for (auto it = PhaseSequenceBegin(); it != PhaseSequenceEnd(); ++it, ++phaseIndex) {
@@ -96,7 +93,6 @@ void ModulePhaseManager::Run() {
 }
 
 void ModulePhaseManager::Emit(const std::string &passName) {
-  // Form output file name.
   std::string outFileName;
   std::string moduleFileName = mirModule.GetFileName();
   std::string::size_type lastDot = moduleFileName.find_last_of(kDotStr);
@@ -105,8 +101,7 @@ void ModulePhaseManager::Emit(const std::string &passName) {
   } else {
     outFileName = moduleFileName.substr(0, lastDot) + kDotStr;
   }
-  outFileName = outFileName.append(passName);
-  outFileName = outFileName.append(kDotMplStr);
+  outFileName = outFileName.append(passName).append(kDotMplStr);
   mirModule.DumpToFile(outFileName);
 }
 }  // namespace maple
diff --git a/src/maple_ir/include/mir_module.h b/src/maple_ir/include/mir_module.h
index 236c4dd41e45208a105aa570bf274f0557aaa93d..6df3fd9891c19c2213f0057e64ec254b7f233529 100644
--- a/src/maple_ir/include/mir_module.h
+++ b/src/maple_ir/include/mir_module.h
@@ -277,6 +277,9 @@ class MIRModule {
   void SetPuIdxFieldSet(PUIdx puIdx, MapleSet<FieldID> *fieldIDSet) {
     puIdxFieldInitializedMap[puIdx] = fieldIDSet;
   }
+  auto &GetRealCaller() {
+    return realCaller;
+  }
 
   MapleSet<FieldID> *GetPUIdxFieldInitializedMapItem(PUIdx key) {
     return puIdxFieldInitializedMap[key];
@@ -519,6 +522,7 @@ class MIRModule {
   // if puIdx appears in the map, and the value of first corresponding MapleSet is 0, the puIdx appears in this module
   // and writes to all field id otherwise, it writes the field ids in MapleSet
   MapleMap<PUIdx, MapleSet<FieldID>*> puIdxFieldInitializedMap;
+  std::map<std::pair<GStrIdx, GStrIdx>, GStrIdx> realCaller;
 };
 #endif  // MIR_FEATURE_FULL
 }  // namespace maple
diff --git a/src/maple_ir/include/opcodes.def b/src/maple_ir/include/opcodes.def
index fc2df36c3850f55a38e48ee2f3984d6baa3781be..5ea724410ec552993dd8e0a068516fd0f30364e4 100644
--- a/src/maple_ir/include/opcodes.def
+++ b/src/maple_ir/include/opcodes.def
@@ -15,7 +15,7 @@
 // Stmt & Notmmpl
   // storage access opcodes
   OPCODE(dassign, DassignNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEHASSSADEF), 8)
-  OPCODE(paiassign, PaiassignNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEHASSSADEF), 8)
+  OPCODE(piassign, PiassignNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEHASSSADEF), 8)
   OPCODE(maydassign, DassignNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEHASSSADEF), 8)
   OPCODE(iassign, IassignNode, (OPCODEISSTMT | OPCODENOTMMPL | OPCODEHASSSADEF), 12)
   // hierarchical control flow opcodes
diff --git a/src/maple_ir/include/option.h b/src/maple_ir/include/option.h
index bbb1daf689e4a6ceb983bcbf4f7a4a619eea4f00..b7ff05e34b0a129280fc9f739db1f9b524ab6f72 100644
--- a/src/maple_ir/include/option.h
+++ b/src/maple_ir/include/option.h
@@ -22,16 +22,8 @@
 #include "types_def.h"
 
 namespace maple {
-constexpr uint32 kNoDecouple = 0;
-constexpr uint32 kConservativeDecouple = 1;
-constexpr uint32 kRadicalDecouple = 2;
 class Options {
  public:
-  enum Level {
-    kMpl2MplLevelZero = 0,
-    kMpl2MplLevelOne = 1,
-    kMpl2MplLevelTwo = 2
-  };
   explicit Options(MemPool &memPool) : optionAlloc(&memPool) {}
 
   bool ParseOptions(int argc, char **argv, std::string &fileName) const;
@@ -46,6 +38,17 @@ class Options {
     return phaseSeq.empty() ? "noopt" : phaseSeq[phaseSeq.size() - 1];
   }
 
+  enum Level {
+    kMpl2MplLevelZero = 0,
+    kMpl2MplLevelOne = 1,
+    kMpl2MplLevelTwo = 2
+  };
+  enum DecoupleLevel {
+    kNoDecouple = 0,
+    kConservativeDecouple = 1,
+    kAggressiveDecouple = 2,
+    kDecoupleAndLazy = 3
+  };
   static bool dumpBefore;
   static bool dumpAfter;
   static std::string dumpPhase;
diff --git a/src/maple_ir/src/mir_builder.cpp b/src/maple_ir/src/mir_builder.cpp
index 8836e3e1f7ed66ac83e84d26cfee4f7db65e7c49..99ec983fec8068fd2901b59f9f29ab413ab2ed72 100644
--- a/src/maple_ir/src/mir_builder.cpp
+++ b/src/maple_ir/src/mir_builder.cpp
@@ -924,7 +924,6 @@ SwitchNode *MIRBuilder::CreateStmtSwitch(BaseNode *opnd, LabelIdx defaultLabel,
   auto *switchNode = GetCurrentFuncCodeMp()->New<SwitchNode>(*GetCurrentFuncCodeMpAllocator(),
                                                              defaultLabel, opnd);
   switchNode->SetSwitchTable(switchTable);
-  switchNode->SetNumOpnds(switchTable.size());
   return switchNode;
 }
 
diff --git a/src/maple_me/include/bb.h b/src/maple_me/include/bb.h
index 7322457f57c014f09014cda4ecc41cc7ab813e74..0c1e4f58f43e95aed785d98abc8f9325172c9313 100644
--- a/src/maple_me/include/bb.h
+++ b/src/maple_me/include/bb.h
@@ -25,7 +25,7 @@ namespace maple {
 class MeStmt;  // circular dependency exists, no other choice
 class MeVarPhiNode;  // circular dependency exists, no other choice
 class MeRegPhiNode;  // circular dependency exists, no other choice
-class PaiassignMeStmt;  // circular dependency exists, no other choice
+class PiassignMeStmt;  // circular dependency exists, no other choice
 class IRMap;  // circular dependency exists, no other choice
 enum BBKind {
   kBBUnknown,  // uninitialized
@@ -68,7 +68,7 @@ class BB {
         phiList(versAlloc->Adapter()),
         meVarPhiList(alloc->Adapter()),
         meRegPhiList(alloc->Adapter()),
-        meVarPaiList(alloc->Adapter()) {
+        meVarPiList(alloc->Adapter()) {
     pred.pop_back();
     pred.pop_back();
     succ.pop_back();
@@ -82,7 +82,7 @@ class BB {
         phiList(versAlloc->Adapter()),
         meVarPhiList(alloc->Adapter()),
         meRegPhiList(alloc->Adapter()),
-        meVarPaiList(alloc->Adapter()),
+        meVarPiList(alloc->Adapter()),
         stmtNodeList(firstStmt, lastStmt) {
     pred.pop_back();
     pred.pop_back();
@@ -218,16 +218,16 @@ class BB {
     RemoveBBFromSucc(succBB);
   }
 
-  void InsertPai(BB &bb, PaiassignMeStmt &s) {
-    if (meVarPaiList.find(&bb) == meVarPaiList.end()) {
-      std::vector<PaiassignMeStmt*> tmp;
-      meVarPaiList[&bb] = tmp;
+  void InsertPi(BB &bb, PiassignMeStmt &s) {
+    if (meVarPiList.find(&bb) == meVarPiList.end()) {
+      std::vector<PiassignMeStmt*> tmp;
+      meVarPiList[&bb] = tmp;
     }
-    meVarPaiList[&bb].push_back(&s);
+    meVarPiList[&bb].push_back(&s);
   }
 
-  MapleMap<BB*, std::vector<PaiassignMeStmt*>> &GetPaiList() {
-    return meVarPaiList;
+  MapleMap<BB*, std::vector<PiassignMeStmt*>> &GetPiList() {
+    return meVarPiList;
   }
 
   bool IsMeStmtEmpty() const {
@@ -248,7 +248,7 @@ class BB {
   void ReplaceMeStmt(MeStmt *stmt, MeStmt *newStmt);
   void DumpMeVarPhiList(IRMap *irMap);
   void DumpMeRegPhiList(IRMap *irMap);
-  void DumpMeVarPaiList(IRMap *irMap);
+  void DumpMeVarPiList(IRMap *irMap);
   StmtNodes &GetStmtNodes() {
     return stmtNodeList;
   }
@@ -374,7 +374,7 @@ class BB {
   MapleMap<const OriginalSt*, PhiNode> phiList;
   MapleMap<OStIdx, MeVarPhiNode*> meVarPhiList;
   MapleMap<OStIdx, MeRegPhiNode*> meRegPhiList;
-  MapleMap<BB*, std::vector<PaiassignMeStmt*>> meVarPaiList;
+  MapleMap<BB*, std::vector<PiassignMeStmt*>> meVarPiList;
   uint32 frequency = 0;
   BBKind kind = kBBUnknown;
   uint32 attributes = 0;
diff --git a/src/maple_me/include/me_ir.h b/src/maple_me/include/me_ir.h
index b6e1d7836eea54e622f5a923d44383e47a409c27..f621aca165e9ffc82c39dbea944c39f4a567502f 100644
--- a/src/maple_me/include/me_ir.h
+++ b/src/maple_me/include/me_ir.h
@@ -399,12 +399,12 @@ class MeVarPhiNode {
     lhs = value;
   }
 
-  void SetPaiAdded() {
-    isPaiAdded = true;
+  void SetPiAdded() {
+    isPiAdded = true;
   }
 
-  bool IsPaiAdded() const {
-    return isPaiAdded;
+  bool IsPiAdded() const {
+    return isPiAdded;
   }
 
  private:
@@ -412,7 +412,7 @@ class MeVarPhiNode {
   MapleVector<VarMeExpr*> opnds;
   bool isLive = true;
   BB *defBB = nullptr;  // the bb that defines this phi
-  bool isPaiAdded = false;
+  bool isPiAdded = false;
 };
 
 class RegMeExpr : public MeExpr {
@@ -1445,11 +1445,11 @@ class MustDefMeNode {
   bool isLive = true;
 };
 
-class PaiassignMeStmt : public MeStmt {
+class PiassignMeStmt : public MeStmt {
  public:
-  explicit PaiassignMeStmt(MapleAllocator *alloc)
-      : MeStmt(OP_paiassign) {}
-  ~PaiassignMeStmt() = default;
+  explicit PiassignMeStmt(MapleAllocator *alloc)
+      : MeStmt(OP_piassign) {}
+  ~PiassignMeStmt() = default;
 
   void SetLHS(VarMeExpr &l) {
     lhs = &l;
diff --git a/src/maple_me/include/me_safe_cast_traits.def b/src/maple_me/include/me_safe_cast_traits.def
index 38df0045ff9368b660ef142b2f33dc3aa119701f..b39d0efdaaed53815f121e8ee45ca68fb849bdbf 100644
--- a/src/maple_me/include/me_safe_cast_traits.def
+++ b/src/maple_me/include/me_safe_cast_traits.def
@@ -34,7 +34,7 @@ REGISTER_SAFE_CAST(NaryMeExpr, from.GetMeOp() == kMeOpNary);
 
 #ifdef LOAD_SAFE_CAST_FOR_ME_STMT
 #undef LOAD_SAFE_CAST_FOR_ME_STMT
-REGISTER_SAFE_CAST(PaiassignMeStmt, from.GetOp() == OP_paiassign);
+REGISTER_SAFE_CAST(PiassignMeStmt, from.GetOp() == OP_piassign);
 REGISTER_SAFE_CAST(DassignMeStmt, from.GetOp() == OP_dassign);
 REGISTER_SAFE_CAST(RegassignMeStmt, from.GetOp() == OP_regassign);
 REGISTER_SAFE_CAST(MaydassignMeStmt, from.GetOp() == OP_maydassign);
diff --git a/src/maple_me/src/bb.cpp b/src/maple_me/src/bb.cpp
index fa63e983f4d13d0b378394c9bc41b4787376f0b9..ad5d167308051881c017862229421583b447ccd6 100644
--- a/src/maple_me/src/bb.cpp
+++ b/src/maple_me/src/bb.cpp
@@ -343,19 +343,19 @@ void BB::DumpMeBB(IRMap &irMap) {
   }
 }
 
-void BB::DumpMeVarPaiList(IRMap *irMap) {
-  if (meVarPaiList.empty()) {
+void BB::DumpMeVarPiList(IRMap *irMap) {
+  if (meVarPiList.empty()) {
     return;
   }
-  std::cout << "<<<<<<<<<<<<<<  PAI Node Start >>>>>>>>>>>>>>>>>>\n";
-  for (const auto &pair : meVarPaiList) {
+  std::cout << "<<<<<<<<<<<<<<  PI Node Start >>>>>>>>>>>>>>>>>>\n";
+  for (const auto &pair : meVarPiList) {
     BB *bb = pair.first;
     std::cout << "Frome BB : " << bb->GetBBId() << '\n';
     for (const auto *stmt : pair.second) {
       stmt->Dump(irMap);
     }
   }
-  std::cout << "<<<<<<<<<<<<<<  PAI Node End >>>>>>>>>>>>>>>>>>>>\n";
+  std::cout << "<<<<<<<<<<<<<<  PI Node End >>>>>>>>>>>>>>>>>>>>\n";
 }
 
 void BB::DumpMeVarPhiList(IRMap *irMap) {
diff --git a/src/maple_me/src/irmap_emit.cpp b/src/maple_me/src/irmap_emit.cpp
index 1fc0e91ebe92ec844ab63f58e68911c7ca73166a..cfbf0a6353a98f6ddf08e1199ecbeda83ba0a94c 100644
--- a/src/maple_me/src/irmap_emit.cpp
+++ b/src/maple_me/src/irmap_emit.cpp
@@ -174,8 +174,8 @@ BaseNode &OpMeExpr::EmitExpr(SSATab &ssaTab) {
     case OP_select: {
       auto *ternaryNode = ssaTab.GetModule().CurFunction()->GetCodeMempool()->New<TernaryNode>(
           Opcode(GetOp()), PrimType(GetPrimType()));
-      constexpr size_t kOpndNumOfTernary = 3;
-      for (size_t i = 0; i < kOpndNumOfTernary; ++i) {
+      const size_t opndNumOfTernary = 3;
+      for (size_t i = 0; i < opndNumOfTernary; ++i) {
         ternaryNode->SetOpnd(&opnds[i]->EmitExpr(ssaTab), i);
       }
       return *ternaryNode;
@@ -253,6 +253,7 @@ BaseNode &NaryMeExpr::EmitExpr(SSATab &ssaTab) {
 }
 
 BaseNode &IvarMeExpr::EmitExpr(SSATab &ssaTab) {
+  CHECK_NULL_FATAL(base);
   auto *ireadNode =
       ssaTab.GetModule().CurFunction()->GetCodeMempool()->New<IreadNode>(OP_iread, PrimType(GetPrimType()));
   ireadNode->SetOpnd(&base->EmitExpr(ssaTab));
@@ -284,6 +285,8 @@ StmtNode &DassignMeStmt::EmitStmt(SSATab &ssaTab) {
 }
 
 StmtNode &RegassignMeStmt::EmitStmt(SSATab &ssaTab) {
+  CHECK_NULL_FATAL(lhs);
+  CHECK_NULL_FATAL(rhs);
   RegassignNode *regassignStmt = ssaTab.GetModule().GetMIRBuilder()->CreateStmtRegassign(
       lhs->GetPrimType(), lhs->GetRegIdx(), &rhs->EmitExpr(ssaTab));
   regassignStmt->SetSrcPos(GetSrcPosition());
@@ -291,6 +294,7 @@ StmtNode &RegassignMeStmt::EmitStmt(SSATab &ssaTab) {
 }
 
 StmtNode &MaydassignMeStmt::EmitStmt(SSATab &ssaTab) {
+  CHECK_NULL_FATAL(rhs);
   auto *dassignStmt = ssaTab.GetModule().CurFunction()->GetCodeMempool()->New<DassignNode>();
   MIRSymbol *symbol = mayDSSym->GetMIRSymbol();
   if (symbol->IsLocal()) {
@@ -319,6 +323,8 @@ void MeStmt::EmitCallReturnVector(SSATab &ssaTab, CallReturnVector &nRets) {
 }
 
 StmtNode &IassignMeStmt::EmitStmt(SSATab &ssaTab) {
+  CHECK_NULL_FATAL(lhsVar);
+  CHECK_NULL_FATAL(rhs);
   auto *iassignNode = ssaTab.GetModule().CurFunction()->GetCodeMempool()->New<IassignNode>();
   iassignNode->SetTyIdx(tyIdx);
   iassignNode->SetFieldID(lhsVar->GetFieldID());
@@ -470,6 +476,7 @@ StmtNode &NaryMeStmt::EmitStmt(SSATab &ssaTab) {
 
 StmtNode &UnaryMeStmt::EmitStmt(SSATab &ssaTab) {
   auto *unaryStmt = ssaTab.GetModule().CurFunction()->GetCodeMempool()->New<UnaryStmtNode>(Opcode(GetOp()));
+  CHECK_NULL_FATAL(opnd);
   unaryStmt->SetOpnd(&opnd->EmitExpr(ssaTab), 0);
   unaryStmt->SetSrcPos(GetSrcPosition());
   return *unaryStmt;
@@ -534,6 +541,7 @@ StmtNode &CommentMeStmt::EmitStmt(SSATab &ssaTab) {
 
 StmtNode &ThrowMeStmt::EmitStmt(SSATab &ssaTab) {
   auto *unaryStmt = ssaTab.GetModule().CurFunction()->GetCodeMempool()->New<UnaryStmtNode>(OP_throw);
+  CHECK_NULL_FATAL(opnd);
   unaryStmt->SetOpnd(&opnd->EmitExpr(ssaTab), 0);
   unaryStmt->SetSrcPos(GetSrcPosition());
   return *unaryStmt;
diff --git a/src/maple_me/src/me_ir.cpp b/src/maple_me/src/me_ir.cpp
index 09249bc315e63a3132ec98214f51ad513fe85530..74e30a0db204f5f695bf5d06fc59911397bfb833 100644
--- a/src/maple_me/src/me_ir.cpp
+++ b/src/maple_me/src/me_ir.cpp
@@ -692,8 +692,8 @@ MeExpr *AddroffuncMeExpr::GetIdenticalExpr(MeExpr &expr) const {
 }
 
 void MeVarPhiNode::Dump(IRMap *irMap) const {
-  if (isPaiAdded) {
-    LogInfo::MapleLogger() << "PAI_ADD VAR:";
+  if (isPiAdded) {
+    LogInfo::MapleLogger() << "PI_ADD VAR:";
   }
   LogInfo::MapleLogger() << "VAR:";
   irMap->GetSSATab().GetOriginalStFromID(lhs->GetOStIdx())->Dump();
@@ -981,8 +981,8 @@ MeStmt *MeStmt::GetNextMeStmt() const {
   return nextMeStmt;
 }
 
-void PaiassignMeStmt::Dump(IRMap *irMap) const {
-  LogInfo::MapleLogger() << "||MEIR PAI|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << " ";
+void PiassignMeStmt::Dump(IRMap *irMap) const {
+  LogInfo::MapleLogger() << "||MEIR PI|| " << kOpcodeInfo.GetTableItemAt(GetOp()).name << " ";
   lhs->Dump(irMap);
   LogInfo::MapleLogger() << '\n';
   PrintIndentation(kDefaultPrintIndentNum);
diff --git a/src/maple_me/src/me_irmap.cpp b/src/maple_me/src/me_irmap.cpp
index 34a828527c635e59efc7a175499e9fafe95465e7..836bb75e1b4a2f5f65210509775b609c17f007c8 100644
--- a/src/maple_me/src/me_irmap.cpp
+++ b/src/maple_me/src/me_irmap.cpp
@@ -39,7 +39,7 @@ void MeIRMap::Dump() {
     auto *bb = *bIt;
     bb->DumpHeader(&GetMIRModule());
     LogInfo::MapleLogger() << "frequency : " << bb->GetFrequency() << "\n";
-    bb->DumpMeVarPaiList(this);
+    bb->DumpMeVarPiList(this);
     bb->DumpMeVarPhiList(this);
     bb->DumpMeRegPhiList(this);
     int i = 0;
@@ -47,7 +47,7 @@ void MeIRMap::Dump() {
       if (GetDumpStmtNum()) {
         LogInfo::MapleLogger() << "(" << i++ << ") ";
       }
-      if (meStmt.GetOp() != OP_paiassign) {
+      if (meStmt.GetOp() != OP_piassign) {
         meStmt.EmitStmt(GetSSATab()).Dump(GetMIRModule(), 0);
       }
       meStmt.Dump(this);
diff --git a/src/maple_phase/include/phase_impl.h b/src/maple_phase/include/phase_impl.h
index e4beacecd0cd2e596ede15494c6c0c0901f35afa..2454e8227266e824f3a550d695b5a7b244caedba 100644
--- a/src/maple_phase/include/phase_impl.h
+++ b/src/maple_phase/include/phase_impl.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ * Copyright (c) [2019-2020] 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.
@@ -17,6 +17,7 @@
 #include "class_hierarchy.h"
 #include "mir_builder.h"
 #include "mpl_scheduler.h"
+#include "utils.h"
 
 namespace maple {
 class FuncOptimizeImpl : public MplTaskParam {
@@ -68,7 +69,7 @@ class FuncOptimizeIterator {
 
 #define OPT_TEMPLATE(OPT_NAME)                                                                 \
   auto *kh = static_cast<KlassHierarchy*>(mrm->GetAnalysisResult(MoPhase_CHA, mod));           \
-  ASSERT(kh, "null ptr check");                                                                \
+  ASSERT_NOT_NULL(kh);                                                                         \
   FuncOptimizeIterator opt(PhaseName(), new OPT_NAME(mod, kh, TRACE_PHASE));                   \
   opt.Run();
 }  // namespace maple
diff --git a/src/maple_util/include/literal_str_name.h b/src/maple_util/include/literal_str_name.h
index 4f6a68dcd435d9527a2b41331d1f76512006c508..623a5e6f45d1d153cb959b972916eb37c4c183b2 100644
--- a/src/maple_util/include/literal_str_name.h
+++ b/src/maple_util/include/literal_str_name.h
@@ -41,7 +41,7 @@ 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) {
+  static uint32_t CalculateHash(const char16_t *data, uint32_t len, bool dataIsCompress) {
     uint32_t hash = 0;
     if (dataIsCompress) {
       const char *dataStart = reinterpret_cast<const char*>(data);
diff --git a/src/maple_util/include/mpl_logging.h b/src/maple_util/include/mpl_logging.h
index 441c452b84c247f32261305079f515c59f30bc51..25519e41c00fc7baca4108a58d5a767d941c0ba0 100644
--- a/src/maple_util/include/mpl_logging.h
+++ b/src/maple_util/include/mpl_logging.h
@@ -234,7 +234,7 @@ class LogInfo {
 #define CHECK_FATAL(cond, fmt, ...)                                                 \
   do {                                                                              \
     if (!(cond)) {                                                                  \
-      logInfo.EmitErrorMessage(#cond, __FILE__, __LINE__, fmt "\n", ##__VA_ARGS__); \
+      maple::logInfo.EmitErrorMessage(#cond, __FILE__, __LINE__, fmt "\n", ##__VA_ARGS__); \
       if (DEBUG_TEST) {                                                             \
         abort();                                                                    \
       } else {                                                                         \
@@ -249,7 +249,7 @@ class LogInfo {
 #define ASSERT(cond, fmt, ...)                                                      \
   do {                                                                              \
     if (!(cond)) {                                                                  \
-      logInfo.EmitErrorMessage(#cond, __FILE__, __LINE__, fmt "\n", ##__VA_ARGS__); \
+      maple::logInfo.EmitErrorMessage(#cond, __FILE__, __LINE__, fmt "\n", ##__VA_ARGS__); \
       abort();                                                                      \
     }                                                                               \
   } while (0)
diff --git a/src/maple_util/include/name_mangler.h b/src/maple_util/include/name_mangler.h
index 9f13e4ac9178a63e3f372f23d896f0b2868ec628..041ed35999d00d7f8f5d5e1a9fbdbc01c9cad73f 100644
--- a/src/maple_util/include/name_mangler.h
+++ b/src/maple_util/include/name_mangler.h
@@ -120,6 +120,8 @@ static constexpr const char kBssSectionStr[] = "__bss_section";
 static constexpr const char kLinkerHashSoStr[] = "__linkerHashSo";
 
 static constexpr const char kStaticFieldNamePrefixStr[] = "__static_field_name";
+static constexpr const char kMplSuffix[] = ".mpl";
+static constexpr const char kClinvocation[] = ".clinvocation";
 static constexpr const char kPackageNameSplitterStr[] = "_2F";
 static constexpr const char kFileNameSplitterStr[] = "$$";
 static constexpr const char kNameSplitterStr[] = "_7C";  // 7C is the ascii code for |
@@ -127,6 +129,7 @@ static constexpr const char kRigthBracketStr[] = "_29";  // 29 is the ascii code
 static constexpr const char kClassNameSplitterStr[] = "_3B_7C";
 static constexpr const char kJavaLangClassStr[] = "Ljava_2Flang_2FClass_3B";
 static constexpr const char kJavaLangObjectStr[] = "Ljava_2Flang_2FObject_3B";
+static constexpr const char kJavaLangClassloader[] = "Ljava_2Flang_2FClassLoader_3B";
 static constexpr const char kJavaLangObjectStrJVersion[] = "Ljava/lang/Object;";
 static constexpr const char kJavaLangStringStr[] = "Ljava_2Flang_2FString_3B";
 static constexpr const char kJavaLangExceptionStr[] = "Ljava_2Flang_2FException_3B";
@@ -149,6 +152,7 @@ static constexpr const char kBindingProtectedRegionStr[] = "__BindingProtectRegi
 
 static constexpr const char kClassNamePrefixStr[] = "L";
 static constexpr const char kClassMethodSplitterStr[] = "_3B";
+static constexpr const char kFuncGetCurrentCl[] = "MCC_GetCurrentClassLoader";
 // Serve as a global flag to indicate whether frequent strings have been compressed
 extern bool doCompression;
 
diff --git a/src/mpl2mpl/src/reflection_analysis.cpp b/src/mpl2mpl/src/reflection_analysis.cpp
index 77d16c775f5bf6724f8eff4f98cfd313f0f40b53..ac2e9480903be1366c287e14846a4fdd04bb1919 100644
--- a/src/mpl2mpl/src/reflection_analysis.cpp
+++ b/src/mpl2mpl/src/reflection_analysis.cpp
@@ -495,13 +495,6 @@ void ReflectionAnalysis::GenAllFieldHash(std::vector<std::pair<FieldPair, uint16
     uint16 h = field.second;
     hashVector.push_back(h);
   }
-  for (auto &field : fieldV) {
-    uint16 h = field.second;
-    int c = std::count(hashVector.begin(), hashVector.end(), h);
-    if (c > 1) {
-      field.second = kHashConflictFlag;  // Conflict flag.
-    }
-  }
 }
 
 uint16 GetFieldHash(const std::vector<std::pair<FieldPair, uint16>> &fieldV, const FieldPair &fieldSources) {