diff --git a/src/BUILD.gn b/src/BUILD.gn
index d3151eceb1b1fdc8f3c9dbb1bbb94c4e81bd7b3c..c2406b6ae40c166d8b0ab9de67160593e3c0da34 100644
--- a/src/BUILD.gn
+++ b/src/BUILD.gn
@@ -6,12 +6,8 @@ config("mapleallcompilecfg") {
   ]
 
   if (GN_BUILD_TYPE == "DEBUG") {
-    cflags_c += [
-      "-DDEBUG",
-    ]
-    cflags_cc += [
-      "-DDEBUG",
-    ]
+    cflags_c += [ "-DDEBUG" ]
+    cflags_cc += [ "-DDEBUG" ]
   }
 
   if (HOST_ARCH == 64) {
diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl
index a37f7269b4fa9d9a5e6ed47458b08456d3be3dd5..17dc2c32c6d4d65483c9d09f5de5231a67de1e21 100755
Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ
diff --git a/src/bin/maple b/src/bin/maple
index ca7759adca8fa036566c5f6814098959c016e248..a93ce9804a9290c9a5eafef1f5ae8660bb5ca8b8 100755
Binary files a/src/bin/maple and b/src/bin/maple differ
diff --git a/src/bin/mplcg b/src/bin/mplcg
index 74860e0b7cc4c0af80e6aca6fc5dd41746d5f6fd..d82b7ed62a8d37899a5b5d00f9921b1f7d75ee3a 100755
Binary files a/src/bin/mplcg and b/src/bin/mplcg differ
diff --git a/src/deplibs/libmplutil.a b/src/deplibs/libmplutil.a
index 29f99e06dfe6faaf4fe06be748d87fc64ed32c99..1295f6e06da54aece2c4a83a0ee32569dfa11f17 100644
Binary files a/src/deplibs/libmplutil.a and b/src/deplibs/libmplutil.a differ
diff --git a/src/maple_driver/include/compiler.h b/src/maple_driver/include/compiler.h
index 2881f4f9a882ad4fea4ef642b82e3180860337a7..e2cefeafe3c2a4042db181f630c041ac43df81eb 100644
--- a/src/maple_driver/include/compiler.h
+++ b/src/maple_driver/include/compiler.h
@@ -130,14 +130,11 @@ class MplcgCompiler : public Compiler {
   explicit MplcgCompiler(const std::string &name) : Compiler(name) {}
 
   ~MplcgCompiler() = default;
-
-
  private:
   std::string GetInputFileName(const MplOptions &options) const override;
   DefaultOption GetDefaultOptions(const MplOptions &options) const override;
   std::string GetBinName() const override;
   std::vector<std::string> GetBinNames() const override;
 };
-
 }  // namespace maple
 #endif  // MAPLE_DRIVER_INCLUDE_COMPILER_H
diff --git a/src/maple_driver/include/driver_runner.h b/src/maple_driver/include/driver_runner.h
index 7ca19e26c7dee24ed02e31c29432cbc865d0484c..e48f9c4edf540b866f4f70f2fd098523d492f609 100644
--- a/src/maple_driver/include/driver_runner.h
+++ b/src/maple_driver/include/driver_runner.h
@@ -20,10 +20,7 @@
 #include "me_option.h"
 #include "interleaved_manager.h"
 #include "error_code.h"
-
-
 namespace maple {
-
 extern const std::string mpl2Mpl;
 extern const std::string mplME;
 
@@ -32,7 +29,7 @@ class DriverRunner final {
   DriverRunner(MIRModule *theModule, const std::vector<std::string> &exeNames, Options *mpl2mplOptions,
                std::string mpl2mplInput, MeOption *meOptions, const std::string &meInput, std::string actualInput,
                MemPool *optMp, bool timePhases = false,
-               bool genMeMpl = false)
+               bool genVtableImpl = false, bool genMeMpl = false)
       : theModule(theModule),
         exeNames(exeNames),
         mpl2mplOptions(mpl2mplOptions),
@@ -42,17 +39,17 @@ class DriverRunner final {
         actualInput(actualInput),
         optMp(optMp),
         timePhases(timePhases),
+        genVtableImpl(genVtableImpl),
         genMeMpl(genMeMpl) {}
 
   DriverRunner(MIRModule *theModule, const std::vector<std::string> &exeNames, std::string actualInput, MemPool *optMp,
                bool timePhases = false, bool genVtableImpl = false, bool genMeMpl = false)
-      : DriverRunner(theModule, exeNames, nullptr, "", nullptr, "", actualInput, optMp, timePhases, genMeMpl) {}
+      : DriverRunner(theModule, exeNames, nullptr, "", nullptr, "", actualInput, optMp, timePhases, genVtableImpl,
+                     genMeMpl) {}
 
   ~DriverRunner() = default;
 
   ErrorCode Run();
-
-
  private:
   static bool FuncOrderLessThan(const MIRFunction *left, const MIRFunction *right);
 
@@ -64,8 +61,6 @@ class DriverRunner final {
                  const PhaseManager &phaseManager) const;
   void AddPhase(std::vector<std::string> &phases, const std::string phase, const PhaseManager &phaseManager) const;
   void ProcessMpl2mplAndMePhases(const std::string &outputFile, const std::string &vtableImplFile) const;
-
-
   MIRModule *theModule;
   std::vector<std::string> exeNames;
   Options *mpl2mplOptions = nullptr;
@@ -75,6 +70,7 @@ class DriverRunner final {
   std::string actualInput;
   MemPool *optMp;
   bool timePhases = false;
+  bool genVtableImpl = false;
   bool genMeMpl = false;
   std::string printOutExe;
 };
diff --git a/src/maple_driver/include/option_parser.h b/src/maple_driver/include/option_parser.h
index f228412da855bbb834ab01fe295a6a52b567ccfe..3ef522dee9453213fb72f254e69be9ae3b9b3f6a 100644
--- a/src/maple_driver/include/option_parser.h
+++ b/src/maple_driver/include/option_parser.h
@@ -31,7 +31,8 @@ enum ArgCheckPolicy {
   kArgCheckPolicyNone,
   kArgCheckPolicyOptional,
   kArgCheckPolicyRequired,
-  kArgCheckPolicyNumeric
+  kArgCheckPolicyNumeric,
+  kArgCheckPolicyBool
 };
 
 struct ExtraOption {
@@ -90,7 +91,7 @@ struct Descriptor {
   const char * const exeName;
 
   // option key mapping to target tool
-  const ExtraOption extras[kMaxExtraOptions];
+  const std::vector<ExtraOption> extras;
 #endif
 
   bool IsEnabledForCurrentBuild() const {
@@ -203,6 +204,12 @@ 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
@@ -223,11 +230,15 @@ class OptionParser {
     }
   }
   bool CheckSpecialOption(const std::string &option, std::string &key, std::string &value);
-  const Descriptor *rawUsages;
+  std::vector<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/usages.h b/src/maple_driver/include/usages.h
index cbc774fd57d377a6035e64799ce0b7ad591e195e..4292712b072ec17d2aa2e9ab5d777130064d0732 100644
--- a/src/maple_driver/include/usages.h
+++ b/src/maple_driver/include/usages.h
@@ -74,10 +74,8 @@ enum OptionIndex : uint64 {
   kInlineWithProfile,
   kInlineWithoutProfile,
   kMpl2MplUseInline,
-  kMpl2MplNoInline,
   kMpl2MplNoInlineFuncList,
   kMpl2MplUseCrossModuleInline,
-  kMpl2MplNoCrossModuleInline,
   kInlineSmallFunctionThreshold,
   kInlineHotFunctionThreshold,
   kInlineModuleGrowth,
@@ -92,6 +90,8 @@ enum OptionIndex : uint64 {
   kPic,
   kVerbose,
   kCGMapleLinker,
+  kDuplicateToDelPlt,
+// ----------mplcg end-----------
 };
 
 enum EnabledIndex {
diff --git a/src/maple_driver/src/driver_runner.cpp b/src/maple_driver/src/driver_runner.cpp
index 67886338eb0fd823f4fe3a554517a9d31d3d9920..4fe26232cef31ab21ebea03f311e83925a28f83a 100644
--- a/src/maple_driver/src/driver_runner.cpp
+++ b/src/maple_driver/src/driver_runner.cpp
@@ -20,6 +20,7 @@
 #include "mir_function.h"
 #include "mir_parser.h"
 
+
 #define JAVALANG (theModule->IsJavaModule())
 
 #define CHECK_MODULE(errorCode...)                                              \
@@ -51,7 +52,6 @@
   }
 
 namespace maple {
-
 const std::string mpl2Mpl = "mpl2mpl";
 const std::string mplME = "me";
 
@@ -142,7 +142,12 @@ void DriverRunner::ProcessMpl2mplAndMePhases(const std::string &outputFile, cons
     InitPhases(mgr, phases);
     mgr.Run();
 
-    theModule->Emit(vtableImplFile);
+    // emit after module phase
+    if (printOutExe == mpl2Mpl || printOutExe == mplME) {
+      theModule->Emit(outputFile);
+    } else if (genVtableImpl || Options::emitVtableImpl) {
+      theModule->Emit(vtableImplFile);
+    }
 
     timer.Stop();
     LogInfo::MapleLogger() << "Mpl2mpl&mplme consumed " << timer.Elapsed() << "s" << '\n';
diff --git a/src/maple_driver/src/maple_comb_compiler.cpp b/src/maple_driver/src/maple_comb_compiler.cpp
index 6621692a0a88d4af950ac0c3750d7f6e9dc3b8f0..30f2d85d117d35f06864526a13dcb96d35cf426a 100644
--- a/src/maple_driver/src/maple_comb_compiler.cpp
+++ b/src/maple_driver/src/maple_comb_compiler.cpp
@@ -94,7 +94,7 @@ MeOption *MapleCombCompiler::MakeMeOptions(const MplOptions &options, MemPool &o
         meOption->GetRange(opt.Args());
         break;
       case kMeDumpAfter:
-        meOption->dumpAfter = true;
+        meOption->dumpAfter = (opt.Type() == kEnable);
         break;
       case kMeDumpFunc:
         meOption->dumpFunc = opt.Args();
@@ -103,16 +103,16 @@ MeOption *MapleCombCompiler::MakeMeOptions(const MplOptions &options, MemPool &o
         meOption->SplitPhases(opt.Args(), meOption->dumpPhases);
         break;
       case kMeQuiet:
-        meOption->quiet = true;
+        meOption->quiet = (opt.Type() == kEnable);
         break;
       case kSetCalleeHasSideEffect:
-        meOption->setCalleeHasSideEffect = true;
+        meOption->setCalleeHasSideEffect = (opt.Type() == kEnable);
         break;
       case kNoSteensgaard:
-        meOption->noSteensgaard = true;
+        meOption->noSteensgaard = (opt.Type() == kEnable);
         break;
       case kNoTBAA:
-        meOption->noTBAA = true;
+        meOption->noTBAA = (opt.Type() == kEnable);
         break;
       case kAliasAnalysisLevel:
         meOption->aliasAnalysisLevel = std::stoul(opt.Args(), nullptr);
@@ -143,18 +143,24 @@ 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 = true;
+        meOption->noDot = (opt.Type() == kEnable);
         break;
       case kStmtNum:
-        meOption->stmtNum = true;
+        meOption->stmtNum = (opt.Type() == kEnable);
         break;
       case kLessThrowAlias:
-        meOption->lessThrowAlias = true;
+        meOption->lessThrowAlias = (opt.Type() == kEnable);
         break;
       case kRegReadAtReturn:
-        meOption->regreadAtReturn = true;
+        meOption->regreadAtReturn = (opt.Type() == kEnable);
         break;
       default:
         WARN(kLncWarn, "input invalid key for me " + opt.OptionKey());
@@ -179,16 +185,16 @@ Options *MapleCombCompiler::MakeMpl2MplOptions(const MplOptions &options, MemPoo
     }
     switch (opt.Index()) {
       case kMpl2MplDumpBefore:
-        mpl2mplOption->dumpBefore = true;
+        mpl2mplOption->dumpBefore = (opt.Type() == kEnable);
         break;
       case kMpl2MplDumpAfter:
-        mpl2mplOption->dumpAfter = true;
+        mpl2mplOption->dumpAfter = (opt.Type() == kEnable);
         break;
       case kMpl2MplDumpFunc:
         mpl2mplOption->dumpFunc = opt.Args();
         break;
       case kMpl2MplQuiet:
-        mpl2mplOption->quiet = true;
+        mpl2mplOption->quiet = (opt.Type() == kEnable);
         break;
       case kMpl2MplDumpPhase:
         mpl2mplOption->dumpPhase = opt.Args();
@@ -203,37 +209,28 @@ Options *MapleCombCompiler::MakeMpl2MplOptions(const MplOptions &options, MemPoo
         mpl2mplOption->skipAfter = opt.Args();
         break;
       case kRegNativeDynamicOnly:
-        mpl2mplOption->regNativeDynamicOnly = true;
+        mpl2mplOption->regNativeDynamicOnly = (opt.Type() == kEnable);
         break;
       case kRegNativeStaticBindingList:
         mpl2mplOption->staticBindingList = opt.Args();
         break;
       case kMpl2MplStubJniFunc:
-        mpl2mplOption->regNativeFunc = true;
+        mpl2mplOption->regNativeFunc = (opt.Type() == kEnable);
         break;
       case kNativeWrapper:
-        mpl2mplOption->nativeWrapper = opt.Type() > 0;
+        mpl2mplOption->nativeWrapper = (opt.Type() == kEnable);
         break;
       case kInlineWithProfile:
-        mpl2mplOption->inlineWithProfile = true;
-        break;
-      case kInlineWithoutProfile:
-        mpl2mplOption->inlineWithProfile = false;
+        mpl2mplOption->inlineWithProfile = (opt.Type() == kEnable);
         break;
       case kMpl2MplUseInline:
-        mpl2mplOption->useInline = true;
-        break;
-      case kMpl2MplNoInline:
-        mpl2mplOption->useInline = false;
+        mpl2mplOption->useInline = (opt.Type() == kEnable);
         break;
       case kMpl2MplNoInlineFuncList:
         mpl2mplOption->noInlineFuncList = opt.Args();
         break;
       case kMpl2MplUseCrossModuleInline:
-        mpl2mplOption->useCrossModuleInline = true;
-        break;
-      case kMpl2MplNoCrossModuleInline:
-        mpl2mplOption->useCrossModuleInline = false;
+        mpl2mplOption->useCrossModuleInline = (opt.Type() == kEnable);
         break;
       case kInlineSmallFunctionThreshold:
         if (opt.Args().empty()) {
@@ -300,18 +297,21 @@ Options *MapleCombCompiler::MakeMpl2MplOptions(const MplOptions &options, MemPoo
         }
         break;
       case kMpl2MplMapleLinker:
-        mpl2mplOption->mapleLinker = true;
-        mpl2mplOption->dumpMuidFile = true;
+        mpl2mplOption->mapleLinker = (opt.Type() == kEnable);
+        mpl2mplOption->dumpMuidFile = (opt.Type() == kEnable);
+        if (options.HasSetDebugFlag()) {
+          LogInfo::MapleLogger() << "--sub options: dumpMuidFile " << mpl2mplOption->dumpMuidFile << '\n';
+        }
         break;
       case kMplnkDumpMuid:
-        mpl2mplOption->dumpMuidFile = true;
+        mpl2mplOption->dumpMuidFile = (opt.Type() == kEnable);
         break;
       case kEmitVtableImpl:
-        mpl2mplOption->emitVtableImpl = true;
+        mpl2mplOption->emitVtableImpl = (opt.Type() == kEnable);
         break;
 #if MIR_JAVA
       case kMpl2MplSkipVirtual:
-        mpl2mplOption->skipVirtualMethod = true;
+        mpl2mplOption->skipVirtualMethod = (opt.Type() == kEnable);
         break;
 #endif
       default:
@@ -341,7 +341,7 @@ ErrorCode MapleCombCompiler::Compile(const MplOptions &options, MIRModulePtr &th
   PrintCommand(options);
   DriverRunner runner(theModule, options.GetRunningExes(), mpl2mplOptions.get(), fileName, meOptions.get(),
                       fileName, fileName, optMp,
-                      options.HasSetTimePhases(), options.HasSetGenMeMpl());
+                      options.HasSetTimePhases(), options.HasSetGenVtableImpl(), options.HasSetGenMeMpl());
   ErrorCode nErr = runner.Run();
 
   memPoolCtrler.DeleteMemPool(optMp);
diff --git a/src/maple_driver/src/mpl_options.cpp b/src/maple_driver/src/mpl_options.cpp
index 51fa14563b8ac4ef96f2334a3fb3436162596844..7d677cb3ded152fd11a350a9bb2d02412fc97b15 100644
--- a/src/maple_driver/src/mpl_options.cpp
+++ b/src/maple_driver/src/mpl_options.cpp
@@ -328,63 +328,68 @@ const mapleOption::Descriptor USAGES[] = {
     "me",
     { { nullptr } } },
   { kMeQuiet,
-    0,
+    kEnable,
     nullptr,
     "quiet",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --quiet                     \tDisable brief trace messages with phase/function names\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    "  --quiet                     \tDisable brief trace messages with phase/function names\n"
+    "  --no-quiet                  \tEnable brief trace messages with phase/function names\n",
     "me",
     { { nullptr } } },
   { kMeNoDot,
-    0,
+    kEnable,
     nullptr,
     "nodot",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --nodot                     \tDisable dot file generation from cfg\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    "  --nodot                     \tDisable dot file generation from cfg\n"
+    "  --no-nodot                  \tEnable dot file generation from cfg\n",
     "me",
     { { nullptr } } },
   { kSetCalleeHasSideEffect,
-    0,
+    kEnable,
     nullptr,
     "setCalleeHasSideEffect",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --setCalleeHasSideEffect    \tSet all the callees have side effect\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    "  --setCalleeHasSideEffect    \tSet all the callees have side effect\n"
+    "  --no-setCalleeHasSideEffect \tNot set all the callees have side effect\n",
     "me",
     { { nullptr } } },
   { kNoSteensgaard,
-    0,
+    kEnable,
     nullptr,
     "noSteensgaard",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --noSteensgaard             \tDisable Steensgaard-style alias analysis\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    "  --noSteensgaard             \tDisable Steensgaard-style alias analysis\n"
+    "  --no-noSteensgaard          \tEnable Steensgaard-style alias analysis\n",
     "me",
     { { nullptr } } },
   { kNoTBAA,
-    0,
+    kEnable,
     nullptr,
     "noTBAA",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --noTBAA                    \tDisable type-based alias analysis\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    "  --noTBAA                    \tDisable type-based alias analysis\n"
+    "  --no-noTBAA                 \tEnable type-based alias analysis\n",
     "me",
     { { nullptr } } },
   { kAliasAnalysisLevel,
@@ -404,51 +409,55 @@ const mapleOption::Descriptor USAGES[] = {
     "me",
     { { nullptr } } },
   { kStmtNum,
-    0,
+    kEnable,
     nullptr,
     "stmtnum",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --stmtnum                   \tPrint MeStmt index number in IR dump\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    "  --stmtnum                   \tPrint MeStmt index number in IR dump\n"
+    "  --no-stmtnum                \tDon't print MeStmt index number in IR dump\n",
     "me",
     { { nullptr } } },
   { kMeDumpAfter,
-    0,
+    kEnable,
     nullptr,
     "dump-after",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --dump-after                \tDo extra IR dump after the specified phase in me\n",
+    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",
     "me",
     { { nullptr } } },
   { kLessThrowAlias,
-    0,
+    kEnable,
     nullptr,
     "lessthrowalias",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --lessthrowalias            \tHandle aliases at java throw statements more accurately\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    "  --lessthrowalias            \tHandle aliases at java throw statements more accurately\n"
+    "  --no-lessthrowalias         \tDisable lessthrowalias\n",
     "me",
     { { nullptr } } },
   { kRegReadAtReturn,
-    0,
+    kEnable,
     nullptr,
     "regreadatreturn",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --regreadatreturn           \tAllow register promotion to promote the operand of return statements\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    "  --regreadatreturn           \tAllow register promotion to promote the operand of return statements\n"
+    "  --no-regreadatreturn        \tDisable regreadatreturn\n",
     "me",
     { { nullptr } } },
   // mpl2mpl
@@ -532,86 +541,67 @@ const mapleOption::Descriptor USAGES[] = {
     "mpl2mpl",
     { { nullptr } } },
   { kMpl2MplQuiet,
-    0,
+    kEnable,
     nullptr,
     "quiet",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --quiet                     \tDisable brief trace messages with phase/function names\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    "  --quiet                     \tDisable brief trace messages with phase/function names\n"
+    "  --no-quiet                  \tEnable brief trace messages with phase/function names\n",
     "mpl2mpl",
     { { nullptr } } },
   { kMpl2MplMapleLinker,
-    0,
+    kEnable,
     nullptr,
     "maplelinker",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --maplelinker               \tGenerate MUID symbol tables and references\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    "  --maplelinker               \tGenerate MUID symbol tables and references\n"
+    "  --no-maplelinker            \tDon't Generate MUID symbol tables and references\n",
     "mpl2mpl",
     { { nullptr } } },
   { kMpl2MplStubJniFunc,
-    0,
+    kEnable,
     nullptr,
     "regnativefunc",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --regnativefunc             \tGenerate native stub function to support JNI registration and calling\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    "  --regnativefunc             \tGenerate native stub function to support JNI registration and calling\n"
+    "  --no-regnativefunc          \tDisable regnativefunc\n",
     "mpl2mpl",
     { { nullptr } } },
   { kInlineWithProfile,
-    0,
+    kEnable,
     nullptr,
     "inline-with-profile",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    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",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    "  --inline-with-profile       \tEnable profile-based inlining\n"
+    "  --no-inline-with-profile    \tDisable profile-based inlining\n",
     "mpl2mpl",
     { { nullptr } } },
   { kMpl2MplUseInline,
-    0,
+    kEnable,
     nullptr,
     "inline",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --inline                    \tEnable function inlining\n",
-    "mpl2mpl",
-    { { nullptr } } },
-  { kMpl2MplNoInline,
-    0,
-    nullptr,
-    "no-inline",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    "  --inline                    \tEnable function inlining\n"
     "  --no-inline                 \tDisable function inlining\n",
     "mpl2mpl",
     { { nullptr } } },
@@ -628,26 +618,15 @@ const mapleOption::Descriptor USAGES[] = {
     "mpl2mpl",
     { { nullptr } } },
   { kMpl2MplUseCrossModuleInline,
-    0,
+    kEnable,
     nullptr,
     "cross-module-inline",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    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,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    "  --cross-module-inline       \tEnable cross-module inlining\n"
     "  --no-cross-module-inline    \tDisable cross-module inlining\n",
     "mpl2mpl",
     { { nullptr } } },
@@ -755,32 +734,21 @@ const mapleOption::Descriptor USAGES[] = {
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
     "  --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,
-    0,
+    kEnable,
     nullptr,
     "regnative-dynamic-only",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --regnative-dynamic-only    \tOnly Generate dynamic register code, Report Fatal Msg if no implemented\n",
+    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",
     "mpl2mpl",
     { { nullptr } } },
   { kRegNativeStaticBindingList,
@@ -797,64 +765,69 @@ const mapleOption::Descriptor USAGES[] = {
     "mpl2mpl",
     { { nullptr } } },
   { kMpl2MplDumpBefore,
-    0,
+    kEnable,
     nullptr,
     "dump-before",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --dump-before               \tDo extra IR dump before the specified phase\n",
+    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",
     "mpl2mpl",
     { { nullptr } } },
   { kMpl2MplDumpAfter,
-    0,
+    kEnable,
     nullptr,
     "dump-after",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --dump-after                \tDo extra IR dump after the specified phase\n",
+    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",
     "mpl2mpl",
     { { nullptr } } },
   { kMplnkDumpMuid,
-    0,
+    kEnable,
     nullptr,
     "dump-muid",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --dump-muid                 \tDump MUID def information into a .muid file\n",
+    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",
     "mpl2mpl",
     { { nullptr } } },
   { kEmitVtableImpl,
-    0,
+    kEnable,
     nullptr,
     "emitVtableImpl",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --emitVtableImpl            \tgenerate VtableImpl file\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    "  --emitVtableImpl            \tgenerate VtableImpl file\n"
+    "  --no-emitVtableImpl         \tDon't generate VtableImpl file\n",
     "mpl2mpl",
     { { nullptr } } },
 #if MIR_JAVA
   { kMpl2MplSkipVirtual,
-    0,
+    kEnable,
     nullptr,
     "skipvirtual",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --skipvirtual\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    "  --skipvirtual\n"
+    "  --no-skipvirtual\n",
     "mpl2mpl",
     { { nullptr } } },
 #endif
@@ -867,22 +840,10 @@ const mapleOption::Descriptor USAGES[] = {
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
     "  --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,
@@ -891,22 +852,10 @@ const mapleOption::Descriptor USAGES[] = {
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
     "  --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,
@@ -915,22 +864,10 @@ const mapleOption::Descriptor USAGES[] = {
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
     "  --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,
@@ -939,7 +876,7 @@ const mapleOption::Descriptor USAGES[] = {
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
     "  --maplelinker               \tGenerate the MapleLinker .s format\n",
     "mplcg",
     { { nullptr } } },
@@ -951,20 +888,21 @@ const mapleOption::Descriptor USAGES[] = {
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
     "  --quiet                     \tBe quiet (don't output debug messages)\n",
     "mplcg",
     { { nullptr } } },
-  { kCGQuiet,
-    kDisable,
+  { kDuplicateToDelPlt,
+    0,
     nullptr,
-    "no-quiet",
+    "duplicate_asm_list",
     nullptr,
     false,
     nullptr,
     mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --no-quiet\n",
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
+    "  --duplicate_asm_list        \tDuplicate asm functions to delete plt call\n"
+    "                              \t--duplicate_asm_list=list_file\n",
     "mplcg",
     { { nullptr } } },
 
@@ -1228,11 +1166,7 @@ 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
-    auto &exeOption = exeOptions[extra.exeName];
-    bool ret = optionParser->SetOption(option.OptionKey(), option.Args(), extra.exeName, exeOption);
-    if (!ret) {
-      return kErrorInvalidParameter;
-    }
+    exeOptions[extra.exeName].push_back(option);
   }
   return kErrorNoError;
 }
diff --git a/src/maple_driver/src/mplcg_compiler.cpp b/src/maple_driver/src/mplcg_compiler.cpp
index 35e3cab38b042a846a7bf60000bde66fe0e09869..f5fc2f53cbc77db824ef73dba1c5f044f35beaf1 100644
--- a/src/maple_driver/src/mplcg_compiler.cpp
+++ b/src/maple_driver/src/mplcg_compiler.cpp
@@ -15,8 +15,12 @@
 #include <cstdlib>
 #include "compiler.h"
 #include "default_options.def"
+#include "mpl_logging.h"
+#include "usages.h"
+#include "driver_runner.h"
 
 namespace maple {
+using namespace mapleOption;
 
 DefaultOption MplcgCompiler::GetDefaultOptions(const MplOptions &options) const {
   DefaultOption defaultOptions = { nullptr, 0 };
@@ -47,5 +51,4 @@ std::string MplcgCompiler::GetInputFileName(const MplOptions &options) const {
   }
   return options.GetOutputFolder() + outputName + ".VtableImpl.mpl";
 }
-
 }  // namespace maple
diff --git a/src/maple_driver/src/option_parser.cpp b/src/maple_driver/src/option_parser.cpp
index b639a8f6a72b4d1d57cb40ec7092cb7debb33333..cfc5d5bddf24318386f192fd4cd336445d0e1460 100644
--- a/src/maple_driver/src/option_parser.cpp
+++ b/src/maple_driver/src/option_parser.cpp
@@ -21,20 +21,100 @@
 using namespace maple;
 using namespace mapleOption;
 
-OptionParser::OptionParser(const Descriptor usage[]) : rawUsages(usage) {
+OptionParser::OptionParser(const Descriptor 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; rawUsages[i].help != nullptr; ++i) {
-    if (rawUsages[i].IsEnabledForCurrentBuild()) {
+  for (size_t i = 0; i < rawUsages.size(); ++i) {
+    if (rawUsages[i].help != nullptr && rawUsages[i].IsEnabledForCurrentBuild()) {
       LogInfo::MapleLogger() << rawUsages[i].help << '\n';
     }
   }
@@ -42,8 +122,8 @@ void OptionParser::PrintUsage() const {
 
 #ifdef OPTION_PARSER_EXTRAOPT
 void OptionParser::PrintUsage(const std::string &helpType) const {
-  for (size_t i = 0; rawUsages[i].help != nullptr; ++i) {
-    if (rawUsages[i].IsEnabledForCurrentBuild() && rawUsages[i].exeName == helpType) {
+  for (size_t i = 0; i < rawUsages.size(); ++i) {
+    if (rawUsages[i].help != nullptr && rawUsages[i].IsEnabledForCurrentBuild() && rawUsages[i].exeName == helpType) {
       LogInfo::MapleLogger() << rawUsages[i].help << '\n';
     }
   }
diff --git a/src/maple_ir/include/intrinsic_java.def b/src/maple_ir/include/intrinsic_java.def
index c0379f58c3369fa821188ff09fceab73ef7139c9..717c6ea664013853d2dc313422ff72084410f040 100644
--- a/src/maple_ir/include/intrinsic_java.def
+++ b/src/maple_ir/include/intrinsic_java.def
@@ -35,3 +35,5 @@ DEF_MIR_INTRINSIC(JAVA_POLYMORPHIC_CALL,\
                   "__java_polymorphic_call", INTRNISJAVA, kArgTyDynany, kArgTyDynany, kArgTyDynany, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
 DEF_MIR_INTRINSIC(JAVA_THROW_ARITHMETIC,\
                   "MCC_ThrowArithmeticException", INTRNISJAVA | INTRNNEVERRETURN, kArgTyVoid, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
+DEF_MIR_INTRINSIC(JAVA_GET_CLASS,\
+                 "MCC_GetClass", INTRNISJAVA | INTRNNOSIDEEFFECT, kArgTyPtr, kArgTyPtr, kArgTyPtr, kArgTyUndef, kArgTyUndef, kArgTyUndef, kArgTyUndef)
\ No newline at end of file
diff --git a/src/maple_util/include/file_layout.h b/src/maple_util/include/file_layout.h
index 95f3fdc2f5187aee8709db3c9815eaaf931d30df..dea8fb88cf631bc8620069b4f4a50ce8a84c982f 100644
--- a/src/maple_util/include/file_layout.h
+++ b/src/maple_util/include/file_layout.h
@@ -32,6 +32,5 @@ enum LayoutType : uint8_t {
 // this used for c string layout
 static uint8_t kCStringShift = 1;
 std::string GetLayoutTypeString(uint32_t type);
-
 } // namespace maple
 #endif
diff --git a/src/mpl2mpl/include/class_hierarchy.h b/src/mpl2mpl/include/class_hierarchy.h
index 1338cc7ef7d6cc23fc4853ac4c0f9c31cfbf68d7..f69effbb4f504cf4bf64a4dd0209d81a88e8e04b 100644
--- a/src/mpl2mpl/include/class_hierarchy.h
+++ b/src/mpl2mpl/include/class_hierarchy.h
@@ -35,6 +35,7 @@ constexpr uint32 kClassIscoldclass = 0x0800;
 constexpr uint32 kClassNeedDecouple = 0x1000;
 constexpr uint32 kClassLazyBindingClass = 0x2000;
 constexpr uint32 kClassLazyBoundClass = 0x4000; // Only used in runtime, occupancy.
+constexpr uint32 kClassRuntimeVerify = 0x8000; // True if need verifier in runtime (error or deferred check).
 constexpr char kJavaLangNoMethodStr[] = "Ljava_2Flang_2FNoSuchMethodException_3B";
 constexpr uint32 kClassReference = (kClassSoftreference | kClassWeakreference | kClassCleaner |
                                     kClassFinalizereference | kClassPhantomreference);