diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl
index ed11e3a0b6ea16dcd537ab18b3256e8ef71fdda8..ec83475285712225594e5719e35631a7044ca711 100755
Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ
diff --git a/src/bin/maple b/src/bin/maple
index 1d4d000c451ea1ec64a0fcea30710c3c6046e86e..579c530236d0bdf8e7c01fb6eac16857a933dd44 100755
Binary files a/src/bin/maple and b/src/bin/maple differ
diff --git a/src/maple_driver/include/option_parser.h b/src/maple_driver/include/option_parser.h
index 03dece32e57e03317a018073140b6d8bd08e9f5f..14461393ad63790e58cb8d8749e497365efa9ab3 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,7 +230,7 @@ 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;
@@ -233,6 +240,10 @@ enum MatchedIndex {
   kMatchShortOpt,
   kMatchLongOpt
 };
+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 85da21f5f7b2467be4ecaf87a8a5f40ee39448a3..6a948fdce9db7ff158ebbb33fa8aa1c1ff3fa3d0 100644
--- a/src/maple_driver/include/usages.h
+++ b/src/maple_driver/include/usages.h
@@ -73,10 +73,8 @@ enum OptionIndex : uint64 {
   kInlineWithProfile,
   kInlineWithoutProfile,
   kMpl2MplUseInline,
-  kMpl2MplNoInline,
   kMpl2MplNoInlineFuncList,
   kMpl2MplUseCrossModuleInline,
-  kMpl2MplNoCrossModuleInline,
   kInlineSmallFunctionThreshold,
   kInlineHotFunctionThreshold,
   kInlineModuleGrowth,
diff --git a/src/maple_driver/src/maple_comb_compiler.cpp b/src/maple_driver/src/maple_comb_compiler.cpp
index 04ceb8c8d153e84b4b54b17aa0db8248297e4d36..b407f79283abce45edb106cd58af4e5ccb2fa742 100644
--- a/src/maple_driver/src/maple_comb_compiler.cpp
+++ b/src/maple_driver/src/maple_comb_compiler.cpp
@@ -96,7 +96,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();
@@ -105,16 +105,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);
@@ -145,18 +145,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());
@@ -181,16 +187,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();
@@ -205,37 +211,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()) {
@@ -302,18 +299,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:
diff --git a/src/maple_driver/src/mpl_options.cpp b/src/maple_driver/src/mpl_options.cpp
index c9f3e9434c8b2cf4437ae475c9a5977b909448ae..37cea78321fe6b0c78027e6d9abf75e000cd95e2 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,23 +888,10 @@ 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,
-    nullptr,
-    "no-quiet",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --no-quiet\n",
-    "mplcg",
-    { { nullptr } } },
-
   { kDuplicateToDelPlt,
     0,
     nullptr,
@@ -1242,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/option_parser.cpp b/src/maple_driver/src/option_parser.cpp
index 735ca4de2117746dea08d60c5a9980e2e7854076..a9135de5d0d29878b7c763ec25950c0d3925cee7 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_me/include/irmap.h b/src/maple_me/include/irmap.h
index c47e3a95042b79fcc0aec1efe25f5c7933b10a27..15e6ee8ddcb9c095665a985d856e458044a4d7a9 100644
--- a/src/maple_me/include/irmap.h
+++ b/src/maple_me/include/irmap.h
@@ -55,7 +55,12 @@ class IRMap : public AnalysisResult {
   RegMeExpr *CreateRegRefMeExpr(MeExpr&);
   RegMeExpr *CreateRegRefMeExpr(MIRType&);
   VarMeExpr *CreateVarMeExprVersion(const VarMeExpr&);
+  MeExpr *CreateAddrofMeExpr(OStIdx ostIdx);
   MeExpr *CreateAddrofMeExpr(MeExpr&);
+  MeExpr *CreateAddroffuncMeExpr(PUIdx);
+  MeExpr *CreateAddrofMeExprFromSymbol(MIRSymbol& sym, PUIdx  puIdx);
+  MeExpr *CreateIaddrofMeExpr(MeExpr &expr, TyIdx tyIdx, MeExpr &base);
+  MeExpr *CreateIvarMeExpr(MeExpr &expr, TyIdx tyIdx, MeExpr &base);
   RegMeExpr *CreateRegMeExpr(PrimType);
   RegMeExpr *CreateRegMeExprVersion(const OriginalSt&);
   RegMeExpr *CreateRegMeExprVersion(const RegMeExpr&);
@@ -200,7 +205,6 @@ class IRMap : public AnalysisResult {
   MeExpr *BuildLHSReg(const VersionSt &vst, RegassignMeStmt &defMeStmt, const RegassignNode &regassign);
   RegMeExpr *CreateRefRegMeExpr(const MIRSymbol&);
   MeExpr *CreateMeExprCompare(Opcode, PrimType, PrimType, MeExpr&, MeExpr&);
-  MeExpr *CreateAddrofMeExprFromNewSymbol(MIRSymbol&, PUIdx);
   VarMeExpr *GetOrCreateVarFromVerSt(const VersionSt &vst);
   RegMeExpr *GetOrCreateRegFromVerSt(const VersionSt &vst);
   void BuildChiList(MeStmt&, MapleMap<OStIdx, MayDefNode>&, MapleMap<OStIdx, ChiMeNode*>&);
diff --git a/src/maple_me/src/irmap.cpp b/src/maple_me/src/irmap.cpp
index fae2c756f1eab03bdedf6f7560ad5d20fa87778a..210103dbfd632c136eaa50c20697bf98dd11d55a 100644
--- a/src/maple_me/src/irmap.cpp
+++ b/src/maple_me/src/irmap.cpp
@@ -85,13 +85,18 @@ VarMeExpr *IRMap::CreateVarMeExprVersion(const VarMeExpr &origExpr) {
   return varMeExpr;
 }
 
+MeExpr *IRMap::CreateAddrofMeExpr(OStIdx ostIdx) {
+  AddrofMeExpr addrofMeExpr(-1, ostIdx);
+  addrofMeExpr.SetOp(OP_addrof);
+  addrofMeExpr.SetPtyp(PTY_ptr);
+  addrofMeExpr.SetNumOpnds(0);
+  return HashMeExpr(addrofMeExpr);
+}
+
 MeExpr *IRMap::CreateAddrofMeExpr(MeExpr &expr) {
   if (expr.GetMeOp() == kMeOpVar) {
     auto &varMeExpr = static_cast<VarMeExpr&>(expr);
-    AddrofMeExpr addrOfMe(kInvalidExprID, varMeExpr.GetOStIdx());
-    addrOfMe.SetOp(OP_addrof);
-    addrOfMe.SetPtyp(PTY_ptr);
-    return HashMeExpr(addrOfMe);
+    return CreateAddrofMeExpr(varMeExpr.GetOStIdx());
   } else {
     ASSERT(expr.GetMeOp() == kMeOpIvar, "expecting IVarMeExpr");
     auto &ivarExpr = static_cast<IvarMeExpr&>(expr);
@@ -106,8 +111,42 @@ MeExpr *IRMap::CreateAddrofMeExpr(MeExpr &expr) {
   }
 }
 
-VarMeExpr *IRMap::CreateNewVarMeExpr(OStIdx oStIdx, PrimType pType, FieldID fieldID) {
-  VarMeExpr *varMeExpr = meBuilder.BuildVarMeExpr(exprID++, oStIdx, vst2MeExprTable.size(), pType, fieldID);
+MeExpr *IRMap::CreateAddroffuncMeExpr(PUIdx puIdx) {
+  AddroffuncMeExpr addroffuncMeExpr(-1, puIdx);
+  addroffuncMeExpr.SetOp(OP_addroffunc);
+  addroffuncMeExpr.SetPtyp(PTY_ptr);
+  addroffuncMeExpr.SetNumOpnds(0);
+  return HashMeExpr(addroffuncMeExpr);
+}
+
+MeExpr *IRMap::CreateIaddrofMeExpr(MeExpr &expr, TyIdx tyIdx, MeExpr &base) {
+  ASSERT(expr.GetMeOp() == kMeOpIvar, "expecting IVarMeExpr");
+  auto &ivarExpr = static_cast<IvarMeExpr&>(expr);
+  OpMeExpr opMeExpr(kInvalidExprID);
+  opMeExpr.SetFieldID(ivarExpr.GetFieldID());
+  opMeExpr.SetTyIdx(tyIdx);
+  opMeExpr.SetOpnd(0, &base);
+  opMeExpr.SetOp(OP_iaddrof);
+  opMeExpr.SetPtyp(PTY_ptr);
+  opMeExpr.SetNumOpnds(1);
+  return HashMeExpr(opMeExpr);
+}
+
+MeExpr *IRMap::CreateIvarMeExpr(MeExpr &expr, TyIdx tyIdx, MeExpr &base) {
+  ASSERT(expr.GetMeOp() == kMeOpVar, "expecting IVarMeExpr");
+  auto &varMeExpr = static_cast<VarMeExpr&>(expr);
+  IvarMeExpr ivarMeExpr(-1);
+  ivarMeExpr.SetFieldID(varMeExpr.GetFieldID());
+  ivarMeExpr.SetTyIdx(tyIdx);
+  ivarMeExpr.SetBase(&base);
+  ivarMeExpr.InitBase(varMeExpr.GetOp(), varMeExpr.GetPrimType(), 1);
+  ivarMeExpr.SetOp(OP_iread);
+  ivarMeExpr.SetMuVal(&varMeExpr);
+  return HashMeExpr(ivarMeExpr);
+}
+
+VarMeExpr *IRMap::CreateNewVarMeExpr(OStIdx ostIdx, PrimType pType, FieldID fieldID) {
+  VarMeExpr *varMeExpr = meBuilder.BuildVarMeExpr(exprID++, ostIdx, vst2MeExprTable.size(), pType, fieldID);
   PushBackVerst2MeExprTable(varMeExpr);
   return varMeExpr;
 }
@@ -876,8 +915,8 @@ IntrinsiccallMeStmt *IRMap::CreateIntrinsicCallAssignedMeStmt(MIRIntrinsicID idx
   return meStmt;
 }
 
-MeExpr *IRMap::CreateAddrofMeExprFromNewSymbol(MIRSymbol &st, PUIdx puIdx) {
-  OriginalSt *baseOst = ssaTab.CreateSymbolOriginalSt(st, puIdx, 0);
+MeExpr *IRMap::CreateAddrofMeExprFromSymbol(MIRSymbol &st, PUIdx puIdx) {
+  OriginalSt *baseOst = ssaTab.FindOrCreateSymbolOriginalSt(st, puIdx, 0);
   AddrofMeExpr addrOfMe(kInvalidExprID, baseOst->GetIndex());
   addrOfMe.SetOp(OP_addrof);
   addrOfMe.SetPtyp(PTY_ptr);