diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl
index ca2d61716b6f8f33e01056c20f5b4da66abeecf2..c11294d2deccbda369d588904194662c5674647c 100755
Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ
diff --git a/src/bin/maple b/src/bin/maple
index ee03e846ee01f7b301bd6431480e2cbe00b3d1f5..fb67f14ffef69d2e3ee39ce90af13151d911247a 100755
Binary files a/src/bin/maple and b/src/bin/maple differ
diff --git a/src/maple_be/include/be/common_utils.h b/src/maple_be/include/be/common_utils.h
index b2f3583e753a1d04527f1e1b911eff61d8895d22..05c5db1897c356ecb8b68f9d0cc58b860fcce521 100644
--- a/src/maple_be/include/be/common_utils.h
+++ b/src/maple_be/include/be/common_utils.h
@@ -49,6 +49,7 @@ constexpr uint32 k14ByteSize = 14;
 constexpr uint32 k15ByteSize = 15;
 constexpr uint32 k16ByteSize = 16;
 
+constexpr uint32 k4BitShift = 2; /* 4 is 1 << 2; */
 constexpr uint32 k8BitShift = 3;  /* 8 is 1 << 3; */
 constexpr uint32 k16BitShift = 4; /* 16 is 1 << 4 */
 
diff --git a/src/maple_be/include/cg/aarch64/aarch64_cgfunc.h b/src/maple_be/include/cg/aarch64/aarch64_cgfunc.h
index 6cb19f0fd9102720080ea5ff72fbb8200990c187..94c0ad07693e1eda7b5f572c40338cacab8ed8a3 100644
--- a/src/maple_be/include/cg/aarch64/aarch64_cgfunc.h
+++ b/src/maple_be/include/cg/aarch64/aarch64_cgfunc.h
@@ -156,9 +156,9 @@ class AArch64CGFunc : public CGFunc {
   Operand *SelectMpy(BinaryNode &node, Operand &o0, Operand &o1) override;
   void SelectMpy(Operand &resOpnd, Operand &o0, Operand &o1, PrimType primType) override;
   /* method description contains method information which is metadata for reflection. */
-  MemOperand *AdjustMemOperandIfOffsetOutOfRange(MemOperand *memOpnd, regno_t regNO, uint8 isDest, Insn &insn,
-                                                 AArch64reg regNum, uint8 &isOutOfRange);
-  void SelectAddAfterInsn(Operand &resOpnd, Operand &o0, Operand &o1, PrimType primType, uint32 isDest, Insn &insn);
+  MemOperand *AdjustMemOperandIfOffsetOutOfRange(MemOperand *memOpnd, regno_t regNO, bool isDest, Insn &insn,
+                                                 AArch64reg regNum, bool &isOutOfRange);
+  void SelectAddAfterInsn(Operand &resOpnd, Operand &o0, Operand &o1, PrimType primType, bool isDest, Insn &insn);
   bool IsImmediateOffsetOutOfRange(AArch64MemOperand &memOpnd, uint32 bitLen);
   Operand *SelectRem(BinaryNode &node, Operand &opnd0, Operand &opnd1) override;
   void SelectDiv(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType) override;
@@ -422,7 +422,7 @@ class AArch64CGFunc : public CGFunc {
 
   bool CheckIfSplitOffsetWithAdd(const AArch64MemOperand &memOpnd, uint32 bitLen);
   AArch64MemOperand &SplitOffsetWithAddInstruction(const AArch64MemOperand &memOpnd, uint32 bitLen,
-                                                   AArch64reg baseRegNum = AArch64reg::kRinvalid, uint32 isDest = 0,
+                                                   AArch64reg baseRegNum = AArch64reg::kRinvalid, bool isDest = false,
                                                    Insn *insn = nullptr);
   AArch64MemOperand &CreateReplacementMemOperand(uint32 bitLen, RegOperand &baseReg, int32 offset);
 
diff --git a/src/maple_be/include/cg/aarch64/aarch64_color_ra.h b/src/maple_be/include/cg/aarch64/aarch64_color_ra.h
index 74203b1f297abe5ad411ebcaf1755238d1b164ee..c6e1df4869b9379f4d028cd100ee600c729367b1 100644
--- a/src/maple_be/include/cg/aarch64/aarch64_color_ra.h
+++ b/src/maple_be/include/cg/aarch64/aarch64_color_ra.h
@@ -1177,7 +1177,7 @@ class GraphColorRegAllocator : public AArch64RegAllocator {
   void LocalRaFinalAssignment(LocalRegAllocator &localRa, BBAssignInfo &bbInfo);
   void LocalRaDebug(BB &bb, LocalRegAllocator &localRa);
   void LocalRegisterAllocator(bool allocate);
-  MemOperand *GetSpillOrReuseMem(LiveRange &lr, uint32 regSize, uint8 &isOutOfRange, Insn &insn, bool isDef);
+  MemOperand *GetSpillOrReuseMem(LiveRange &lr, uint32 regSize, bool &isOutOfRange, Insn &insn, bool isDef);
   void SpillOperandForSpillPre(Insn &insn, const Operand &opnd, RegOperand &phyOpnd, uint32 spillIdx, bool needSpill);
   void SpillOperandForSpillPost(Insn &insn, const Operand &opnd, RegOperand &phyOpnd, uint32 spillIdx, bool needSpill);
   Insn *SpillOperand(Insn &insn, const Operand &opnd, bool isDef, RegOperand &phyOpnd);
@@ -1186,7 +1186,7 @@ class GraphColorRegAllocator : public AArch64RegAllocator {
   MemOperand *GetCommonReuseMem(const uint64 *conflict, const std::set<MemOperand*> &usedMemOpnd, uint32 size,
                                 RegType regType);
   MemOperand *GetReuseMem(uint32 vregNO, uint32 size, RegType regType);
-  MemOperand *GetSpillMem(uint32 vregNO, uint8 isDest, Insn &insn, AArch64reg regNO, uint8 &isOutOfRange);
+  MemOperand *GetSpillMem(uint32 vregNO, bool isDest, Insn &insn, AArch64reg regNO, bool &isOutOfRange);
   bool SetAvailableSpillReg(std::set<regno_t> &cannotUseReg, LiveRange &lr, uint64 &usedRegMask);
   void CollectCannotUseReg(std::set<regno_t> &cannotUseReg, LiveRange &lr, Insn &insn);
   regno_t PickRegForSpill(uint64 &usedRegMask, RegType regType, uint32 spillIdx, bool &needSpillLr);
diff --git a/src/maple_be/include/cg/cg_option.h b/src/maple_be/include/cg/cg_option.h
index 3e066d5bcfc0bc95e0c706bd4771dac4e3051511..750b303dc414bc6effb38b2c4762ae3021ae5adf 100644
--- a/src/maple_be/include/cg/cg_option.h
+++ b/src/maple_be/include/cg/cg_option.h
@@ -19,6 +19,7 @@
 #include "mempool_allocator.h"
 #include "mir_module.h"
 #include "types_def.h"
+#include "driver_option_common.h"
 
 namespace maplebe {
 using namespace maple;
@@ -28,7 +29,7 @@ struct Range {
   uint64 end;
 };
 
-class CGOptions {
+class CGOptions : public MapleDriverOptionBase {
  public:
   enum OptionEnum : uint64 {
     kUndefined = 0ULL,
@@ -108,8 +109,11 @@ class CGOptions {
   static const GenerateFlag kDefaultGflags = GenerateFlag(kGrootList | kPrimorList);
 
  public:
-  explicit CGOptions(MemPool &memPool) : optionAlloc(&memPool) {}
+  static CGOptions &GetInstance();
+  CGOptions();
   virtual ~CGOptions() = default;
+  bool SolveOptions(const std::vector<mapleOption::Option> &opts, bool isDebug);
+  void DecideMplcgRealLevel(const std::vector<mapleOption::Option> &inputOptions, bool isDebug);
 
   void DumpOptions();
   std::vector<std::string> &GetSequence() {
@@ -593,7 +597,6 @@ class CGOptions {
   }
 
  private:
-  MapleAllocator optionAlloc;
   std::vector<std::string> phaseSequence;
 
   bool insertCall = false;
diff --git a/src/maple_be/include/cg/cgfunc.h b/src/maple_be/include/cg/cgfunc.h
index 5ed67c860fda3885e14d18e27ad09dc45fd92757..b8586311f48ecb5b4c86f08f78b2ff0df6d85129 100644
--- a/src/maple_be/include/cg/cgfunc.h
+++ b/src/maple_be/include/cg/cgfunc.h
@@ -243,9 +243,7 @@ class CGFunc {
   virtual Operand *GetTrueOpnd() {
     return nullptr;
   }
-  virtual void ClearUnreachableGotInfos(BB &bb) {
-    return;
-  }
+  virtual void ClearUnreachableGotInfos(BB &bb) {};
   LabelIdx CreateLabel();
 
   virtual Operand &CreateFPImmZero(PrimType primType) = 0;
diff --git a/src/maple_be/include/cg/datainfo.h b/src/maple_be/include/cg/datainfo.h
index b8698e6c67420c8ab6a05a25e66512e67ecc5be8..5a0c8ea7cc62ef04e9af2ed5ccfc94d26c1ae490 100644
--- a/src/maple_be/include/cg/datainfo.h
+++ b/src/maple_be/include/cg/datainfo.h
@@ -141,10 +141,6 @@ class DataInfo {
     }
   }
 
-  int32 GetInfoIndex(const uint32 bitNO) const {
-    return bitNO / kWordSize;
-  }
-
   MapleSet<uint32> GetBitsOfInfo() {
     MapleSet<uint32> wordRes(allocator.Adapter());
     wordRes.clear();
diff --git a/src/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp b/src/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp
index d2b71d4aadeaeab70692265e613c6826523c82e2..660055c692597df9011ebb80624fdbac054d8e5d 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp
@@ -710,7 +710,7 @@ bool AArch64CGFunc::CheckIfSplitOffsetWithAdd(const AArch64MemOperand &memOpnd,
 }
 
 AArch64MemOperand &AArch64CGFunc::SplitOffsetWithAddInstruction(const AArch64MemOperand &memOpnd, uint32 bitLen,
-                                                                AArch64reg baseRegNum, uint32 isDest, Insn *insn) {
+                                                                AArch64reg baseRegNum, bool isDest, Insn *insn) {
   ASSERT((memOpnd.GetAddrMode() == AArch64MemOperand::kAddrModeBOi), "expect kAddrModeBOi memOpnd");
   ASSERT(memOpnd.IsIntactIndexed(), "expect intactIndexed memOpnd");
   AArch64OfstOperand *ofstOpnd = memOpnd.GetOffsetImmediate();
@@ -5525,7 +5525,7 @@ void AArch64CGFunc::AppendCall(const MIRSymbol &funcSymbol) {
 }
 
 void AArch64CGFunc::SelectAddAfterInsn(Operand &resOpnd, Operand &opnd0, Operand &opnd1, PrimType primType,
-                                       uint32 isDest, Insn &insn) {
+                                       bool isDest, Insn &insn) {
   uint32 dsize = GetPrimTypeBitSize(primType);
   bool is64Bits = (dsize == k64BitSize);
   ASSERT(opnd0.GetKind() == Operand::kOpdRegister, "Spill memory operand should based on register");
@@ -5579,7 +5579,7 @@ void AArch64CGFunc::SelectAddAfterInsn(Operand &resOpnd, Operand &opnd0, Operand
 }
 
 MemOperand *AArch64CGFunc::AdjustMemOperandIfOffsetOutOfRange(
-    MemOperand *memOpnd, regno_t vrNum, uint8 isDest, Insn &insn, AArch64reg regNum, uint8 &isOutOfRange) {
+    MemOperand *memOpnd, regno_t vrNum, bool isDest, Insn &insn, AArch64reg regNum, bool &isOutOfRange) {
   if (vrNum >= vRegTable.size()) {
     CHECK_FATAL(false, "index out of range in AArch64CGFunc::AdjustMemOperandIfOffsetOutOfRange");
   }
@@ -5587,12 +5587,12 @@ MemOperand *AArch64CGFunc::AdjustMemOperandIfOffsetOutOfRange(
   auto *a64MemOpnd = static_cast<AArch64MemOperand*>(memOpnd);
   if (IsImmediateOffsetOutOfRange(*a64MemOpnd, dataSize)) {
     if (CheckIfSplitOffsetWithAdd(*a64MemOpnd, dataSize)) {
-      isOutOfRange = 1;
+      isOutOfRange = true;
     }
     memOpnd =
         &SplitOffsetWithAddInstruction(*a64MemOpnd, dataSize, regNum, isDest, &insn);
   } else {
-    isOutOfRange = 0;
+    isOutOfRange = false;
   }
   return memOpnd;
 }
diff --git a/src/maple_be/src/cg/aarch64/aarch64_color_ra.cpp b/src/maple_be/src/cg/aarch64/aarch64_color_ra.cpp
index 2ec6c501f09aaa79489b0094f05844d2ba7b456f..dd641e8b88cb7d5f575d65ab767f46520c6b2aa2 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_color_ra.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_color_ra.cpp
@@ -2445,8 +2445,8 @@ MemOperand *GraphColorRegAllocator::GetReuseMem(uint32 vregNO, uint32 size, RegT
 #endif  /* CONSISTENT_MEMOPNDi */
 }
 
-MemOperand *GraphColorRegAllocator::GetSpillMem(uint32 vregNO, uint8 isDest, Insn &insn, AArch64reg regNO,
-                                                uint8 &isOutOfRange) {
+MemOperand *GraphColorRegAllocator::GetSpillMem(uint32 vregNO, bool isDest, Insn &insn, AArch64reg regNO,
+                                                bool &isOutOfRange) {
   auto *a64CGFunc = static_cast<AArch64CGFunc*>(cgFunc);
   MemOperand *memOpnd = a64CGFunc->GetOrCreatSpillMem(vregNO);
   return (a64CGFunc->AdjustMemOperandIfOffsetOutOfRange(memOpnd, vregNO, isDest, insn, regNO, isOutOfRange));
@@ -2525,7 +2525,7 @@ void GraphColorRegAllocator::SpillOperandForSpillPost(Insn &insn, const Operand
   }
 }
 
-MemOperand *GraphColorRegAllocator::GetSpillOrReuseMem(LiveRange &lr, uint32 regSize, uint8 &isOutOfRange, Insn &insn,
+MemOperand *GraphColorRegAllocator::GetSpillOrReuseMem(LiveRange &lr, uint32 regSize, bool &isOutOfRange, Insn &insn,
                                                        bool isDef) {
   (void)regSize;
   MemOperand *memOpnd = nullptr;
@@ -2577,7 +2577,7 @@ Insn *GraphColorRegAllocator::SpillOperand(Insn &insn, const Operand &opnd, bool
   }
 
   uint32 regSize = regOpnd.GetSize();
-  uint8 isOutOfRange = 0;
+  bool isOutOfRange = false;
   PrimType stype;
   RegType regType = regOpnd.GetRegisterType();
   if (regType == kRegTyInt) {
diff --git a/src/maple_be/src/cg/cg_option.cpp b/src/maple_be/src/cg/cg_option.cpp
index 821256198b93f90587dbf6a9b4ea0611c98d22de..099306f688aea895012c722be0a4bbcbbd1fd852 100644
--- a/src/maple_be/src/cg/cg_option.cpp
+++ b/src/maple_be/src/cg/cg_option.cpp
@@ -60,6 +60,792 @@ bool CGOptions::hotFix = false;
 bool CGOptions::genLongCalls = false;
 bool CGOptions::gcOnly = false;
 
+enum OptionIndex : uint64 {
+  kCGQuiet = kCommonOptionEnd + 1,
+  kPie,
+  kPic,
+  kVerbose,
+  kCGMapleLinker,
+  kCGHelp,
+  kCgen,
+  kCGNativeOpt,
+  kInsertCall,
+  kTrace,
+  kCGClassList,
+  kGenDef,
+  kGenGctib,
+  kCGBarrier,
+  kGenPrimorList,
+  kRaColor,
+  kConstFoldOpt,
+  kSuppressFinfo,
+  kEhList,
+  kObjMap,
+  kCGDumpcfg,
+  kCGDumpBefore,
+  kCGDumpAfter,
+  kCGTimePhases,
+  kCGDumpFunc,
+  kDebuggingInfo,
+  kStackGuard,
+  kDebugGenDwarf,
+  kDebugUseSrc,
+  kDebugUseMix,
+  kDebugAsmMix,
+  kProfilingInfo,
+  kProfileEnable,
+  kCGO0,
+  kCGO1,
+  kCGO2,
+  kProfileData,
+  kProepilogue,
+  kYieldPoing,
+  kLocalRc,
+  kCalleeCFI,
+  kCyclePatternList,
+  kDuplicateToDelPlt,
+  kInsertSoe,
+  kCheckArrayStore,
+  kPrintFunction,
+  kCGDumpPhases,
+  kCGSkipPhases,
+  kCGSkipFrom,
+  kCGSkipAfter,
+  kCGLazyBinding,
+  kCGHotFix,
+  kLongCalls,
+  kGcOnly,
+};
+
+const Descriptor kUsage[] = {
+  { kPie,
+    kEnable,
+    nullptr,
+    "pie",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --pie                       \tGenerate position-independent executable\n",
+    "mplcg",
+    {} },
+  { kPic,
+    kEnable,
+    nullptr,
+    "fpic",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --fpic                      \tGenerate position-independent shared library\n",
+    "mplcg",
+    {} },
+  { kVerbose,
+    kEnable,
+    nullptr,
+    "verbose-asm",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --verbose-asm               \tAdd comments to asm output\n",
+    "mplcg",
+    {} },
+  { kCGMapleLinker,
+    kEnable,
+    nullptr,
+    "maplelinker",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --maplelinker               \tGenerate the MapleLinker .s format\n",
+    "mplcg",
+    {} },
+      { kCGQuiet,
+    kEnable,
+    nullptr,
+    "quiet",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --quiet                     \tBe quiet (don't output debug messages)\n",
+    "mplcg",
+    {} },
+  { kCGHelp,
+    0,
+    "h-mplcg",
+    "help-mplcg",
+    kBuildTypeAll,
+    kArgCheckPolicyOptional,
+    "  -h-mplcg --help-mplcg       \tPrint usage and exit.Available command names:\n"
+    "                              \tmplcg\n",
+    "all",
+    {} },
+  { kCgen,
+    kEnable,
+    nullptr,
+    "cg",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --cg                        \tGenerate the output .s file\n",
+    "mplcg",
+    {} },
+  { kCGLazyBinding,
+    kEnable,
+    nullptr,
+    "lazy-binding",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --lazy-binding              \tBind class symbols lazily[default off]\n",
+    "mplcg",
+    {} },
+  { kCGHotFix,
+    kEnable,
+    nullptr,
+    "hot-fix",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --hot-fix                   \tOpen for App hot fix[default off]\n",
+    "mplcg",
+    {} },
+  { kCGNativeOpt,
+    kEnable,
+    nullptr,
+    "nativeopt",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --nativeopt                 \tEnable native opt\n",
+    "mplcg",
+    {} },
+  { kObjMap,
+    kEnable,
+    nullptr,
+    "objmap",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --objmap                    \tCreate object maps (GCTIBs) inside the main output (.s) file\n",
+    "mplcg",
+    {} },
+  { kYieldPoing,
+    kEnable,
+    nullptr,
+    "yieldpoint",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --yieldpoint                \tGenerate yieldpoints [default]\n",
+    "mplcg",
+    {} },
+  { kProepilogue,
+    kEnable,
+    nullptr,
+    "proepilogue",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --proepilogue               \tDo tail call optimization and eliminate unnecessary prologue and epilogue.\n",
+    "mplcg",
+    {} },
+  { kLocalRc,
+    kEnable,
+    nullptr,
+    "local-rc",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --local-rc                  \tHandle Local Stack RC [default]\n",
+    "mplcg",
+    {} },
+  { kInsertCall,
+    0,
+    nullptr,
+    "insert-call",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --insert-call=name          \tInsert a call to the named function\n",
+    "mplcg",
+    {} },
+  { kTrace,
+    0,
+    nullptr,
+    "add-debug-trace",
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  --add-debug-trace           \tInstrument the output .s file to print call traces at runtime\n",
+    "mplcg",
+    {} },
+  { kCGClassList,
+    0,
+    nullptr,
+    "class-list-file",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --class-list-file           \tSet the class list file for the following generation options,\n"
+    "                              \tif not given, generate for all visible classes\n"
+    "                              \t--class-list-file=class_list_file\n",
+    "mplcg",
+    {} },
+  { kGenDef,
+    kEnable,
+    nullptr,
+    "gen-c-macro-def",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --gen-c-macro-def           \tGenerate a .def file that contains extra type metadata, including the\n"
+    "                              \tclass instance sizes and field offsets (default)\n",
+    "mplcg",
+    {} },
+  { kGenGctib,
+    kEnable,
+    nullptr,
+    "gen-gctib-file",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --gen-gctib-file            \tGenerate a separate .s file for GCTIBs. Usually used together with\n"
+    "                              \t--no-objmap (not implemented yet)\n",
+    "mplcg",
+    {} },
+  { kStackGuard,
+    kEnable,
+    nullptr,
+    "stackguard",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  -stackguard                 \tadd stack guard\n",
+    "mplcg",
+    {} },
+  { kDebuggingInfo,
+    0,
+    "g",
+    nullptr,
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  -g                          \tGenerate debug information\n",
+    "mplcg",
+    {} },
+  { kDebugGenDwarf,
+    0,
+    nullptr,
+    "gdwarf",
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  --gdwarf                    \tGenerate dwarf infomation\n",
+    "mplcg",
+    {} },
+  { kDebugUseSrc,
+    0,
+    nullptr,
+    "gsrc",
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  --gsrc                      \tUse original source file instead of mpl file for debugging\n",
+    "mplcg",
+    {} },
+  { kDebugUseMix,
+    0,
+    nullptr,
+    "gmixedsrc",
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  --gmixedsrc                 \tUse both original source file and mpl file for debugging\n",
+    "mplcg",
+    {} },
+  { kDebugAsmMix,
+    0,
+    nullptr,
+    "gmixedasm",
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  --gmixedasm                 \tComment out both original source file and mpl file for debugging\n",
+    "mplcg",
+    {} },
+  { kRaColor,
+    0,
+    nullptr,
+    "with-ra-graph-color",
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  --with-ra-graph-color       \tDo coloring-based register allocation\n",
+    "mplcg",
+    {} },
+  { kConstFoldOpt,
+    0,
+    nullptr,
+    "const-fold",
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  --const-fold                \tEnable constant folding\n",
+    "mplcg",
+    {} },
+  { kEhList,
+    0,
+    nullptr,
+    "eh-exclusive-list",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --eh-exclusive-list         \tFor generating gold files in unit testing\n"
+    "                              \t--eh-exclusive-list=list_file\n",
+    "mplcg",
+    {} },
+  { kCGO0,
+    0,
+    nullptr,
+    "O0",
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  -O0                         \tNo optimization.\n",
+    "mplcg",
+    {} },
+  { kCGO1,
+    0,
+    nullptr,
+    "O1",
+    kBuildTypeAll,
+    kArgCheckPolicyOptional,
+    "  -O1                         \tDo some optimization.\n",
+    "mplcg",
+    {} },
+  { kCGO2,
+    0,
+    nullptr,
+    "O2",
+    kBuildTypeAll,
+    kArgCheckPolicyOptional,
+    "  -O2                          \tDo some optimization.\n",
+    "mplcg",
+    {} },
+  { kSuppressFinfo,
+    0,
+    nullptr,
+    "suppress-fileinfo",
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  --suppress-fileinfo         \tFor generating gold files in unit testing\n",
+    "mplcg",
+    {} },
+  { kCGDumpcfg,
+    0,
+    nullptr,
+    "dump-cfg",
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  --dump-cfg\n",
+    "mplcg",
+    {} },
+  { kCGDumpPhases,
+    0,
+    nullptr,
+    "dump-phases",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --dump-phases=PHASENAME,... \tEnable debug trace for specified phases in the comma separated list\n",
+    "mplcg",
+    {} },
+  { kCGSkipPhases,
+    0,
+    nullptr,
+    "skip-phases",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --skip-phases=PHASENAME,... \tSkip the phases specified in the comma separated list\n",
+    "mplcg",
+    {} },
+  { kCGSkipFrom,
+    0,
+    nullptr,
+    "skip-from",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --skip-from=PHASENAME       \tSkip the rest phases from PHASENAME(included)\n",
+    "mplcg",
+    {} },
+  { kCGSkipAfter,
+    0,
+    nullptr,
+    "skip-after",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --skip-after=PHASENAME      \tSkip the rest phases after PHASENAME(excluded)\n",
+    "mplcg",
+    {} },
+  { kCGDumpFunc,
+    0,
+    nullptr,
+    "dump-func",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --dump-func=FUNCNAME        \tDump/trace only for functions whose names contain FUNCNAME as substring\n"
+    "                              \t(can only specify once)\n",
+    "mplcg",
+    {} },
+  { kCGDumpBefore,
+    kEnable,
+    nullptr,
+    "dump-before",
+    kBuildTypeAll,
+    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",
+    "mplcg",
+    {} },
+  { kCGDumpAfter,
+    kEnable,
+    nullptr,
+    "dump-after",
+    kBuildTypeAll,
+    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",
+    "mplcg",
+    {} },
+  { kCGTimePhases,
+    kEnable,
+    nullptr,
+    "time-phases",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --time-phases               \tCollect compilation time stats for each phase\n"
+    "  --no-time-phases            \tDon't Collect compilation time stats for each phase\n",
+    "mplcg",
+    {} },
+  { kCGBarrier,
+    kEnable,
+    nullptr,
+    "use-barriers-for-volatile",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --use-barriers-for-volatile \tOptimize volatile load/str\n"
+    "  --no-use-barriers-for-volatile\n",
+    "mplcg",
+    {} },
+  { kCalleeCFI,
+    kEnable,
+    nullptr,
+    "callee-cfi",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --callee-cfi                \tcallee cfi message will be generated\n"
+    "  --no-callee-cfi             \tcallee cfi message will not be generated\n",
+    "mplcg",
+    {} },
+  { kPrintFunction,
+    kEnable,
+    nullptr,
+    "print-func",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --print-func\n"
+    "  --no-print-func\n",
+    "mplcg",
+    {} },
+  { kCyclePatternList,
+    0,
+    nullptr,
+    "cycle-pattern-list",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --cycle-pattern-list        \tFor generating cycle pattern meta\n"
+    "                              \t--cycle-pattern-list=list_file\n",
+    "mplcg",
+    {} },
+  { kDuplicateToDelPlt,
+    0,
+    nullptr,
+    "duplicate_asm_list",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --duplicate_asm_list        \tDuplicate asm functions to delete plt call\n"
+    "                              \t--duplicate_asm_list=list_file\n",
+    "mplcg",
+    {} },
+  { kInsertSoe,
+    0,
+    nullptr,
+    "soe-check",
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  --soe-check                 \tInsert a soe check instruction[default off]\n",
+    "mplcg",
+    {} },
+  { kCheckArrayStore,
+    kEnable,
+    nullptr,
+    "check-arraystore",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --check-arraystore          \tcheck arraystore exception[default off]\n",
+    "mplcg",
+    {} },
+  { kLongCalls,
+    kEnable,
+    nullptr,
+    "long-calls",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --long-calls                  \tgenerate long call\n",
+    "mplcg",
+    {} },
+  { kGcOnly,
+    kEnable,
+    nullptr,
+    "gconly",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --gconly                     \tEnable GCONLY, generate code without RC\n",
+    "mplcg",
+    {} },
+// End
+  { kUnknown,
+    0,
+    nullptr,
+    nullptr,
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    nullptr,
+    "mplcg",
+    {} }
+};
+
+CGOptions &CGOptions::GetInstance() {
+  static CGOptions instance;
+  return instance;
+}
+
+CGOptions::CGOptions() {
+  CreateUsages(kUsage);
+}
+
+void CGOptions::DecideMplcgRealLevel(const std::vector<mapleOption::Option> &inputOptions, bool isDebug) {
+  int realLevel = -1;
+  for (const mapleOption::Option &opt : inputOptions) {
+    switch (opt.Index()) {
+      case kCGO0:
+        realLevel = CGOptions::kLevel0;
+        break;
+      case kCGO1:
+        realLevel = CGOptions::kLevel1;
+        break;
+      case kCGO2:
+        realLevel = CGOptions::kLevel2;
+        break;
+      default:
+        break;
+    }
+  }
+  if (isDebug) {
+    LogInfo::MapleLogger() << "Real Mplcg level:" << std::to_string(realLevel) << "\n";
+  }
+  if (realLevel ==  CGOptions::kLevel0) {
+    EnableO0();
+  } else if (realLevel ==  CGOptions::kLevel1) {
+    EnableO1();
+  } else if (realLevel ==  CGOptions::kLevel2) {
+    EnableO2();
+  }
+}
+
+bool CGOptions::SolveOptions(const std::vector<Option> &opts, bool isDebug) {
+  DecideMplcgRealLevel(opts, isDebug);
+  for (const mapleOption::Option &opt : opts) {
+    if (isDebug) {
+      LogInfo::MapleLogger() << "mplcg options: "  << opt.Index() << " " << opt.OptionKey() << " " <<
+                                opt.Args() << '\n';
+    }
+    switch (opt.Index()) {
+      case kCGQuiet:
+        SetQuiet((opt.Type() == kEnable));
+        break;
+      case kPie:
+        (opt.Type() == kEnable) ? SetOption(CGOptions::kGenPie)
+                                : ClearOption(CGOptions::kGenPie);
+        break;
+      case kPic: {
+        if (opt.Type() == kEnable) {
+          EnablePIC();
+          SetOption(CGOptions::kGenPic);
+        } else {
+          DisablePIC();
+          ClearOption(CGOptions::kGenPic);
+        }
+        break;
+      }
+      case kVerbose:
+        (opt.Type() == kEnable) ? SetOption(CGOptions::kVerboseAsm)
+                                : ClearOption(CGOptions::kVerboseAsm);
+        break;
+      case kCGMapleLinker:
+        (opt.Type() == kEnable) ? EnableMapleLinker() : DisableMapleLinker();
+        break;
+      case kCGBarrier:
+        (opt.Type() == kEnable) ? EnableBarriersForVolatile() : DisableBarriersForVolatile();
+        break;
+      case kCGDumpBefore:
+        (opt.Type() == kEnable) ? EnableDumpBefore() : DisableDumpBefore();
+        break;
+      case kCGDumpAfter:
+        (opt.Type() == kEnable) ? EnableDumpAfter() : DisableDumpAfter();
+        break;
+      case kCGTimePhases:
+        (opt.Type() == kEnable) ? EnableTimePhases() : DisableTimePhases();
+        break;
+      case kCGDumpFunc:
+        SetDumpFunc(opt.Args());
+        break;
+      case kDuplicateToDelPlt:
+        SetDuplicateAsmFile(opt.Args());
+        break;
+      case kInsertCall:
+        SetInstrumentationFunction(opt.Args());
+        SetInsertCall(true);
+        break;
+      case kStackGuard:
+        SetOption(kUseStackGuard);
+        break;
+      case kDebuggingInfo:
+        SetOption(kDebugFriendly);
+        SetOption(kWithLoc);
+        ClearOption(kSuppressFileInfo);
+        break;
+      case kDebugGenDwarf:
+        SetOption(kDebugFriendly);
+        SetOption(kWithLoc);
+        SetOption(kWithDwarf);
+        SetParserOption(kWithDbgInfo);
+        ClearOption(kSuppressFileInfo);
+        EnableWithDwarf();
+        break;
+      case kDebugUseSrc:
+        SetOption(kDebugFriendly);
+        SetOption(kWithLoc);
+        SetOption(kWithSrc);
+        ClearOption(kWithMpl);
+        break;
+      case kDebugUseMix:
+        SetOption(kDebugFriendly);
+        SetOption(kWithLoc);
+        SetOption(kWithSrc);
+        SetOption(kWithMpl);
+        break;
+      case kDebugAsmMix:
+        SetOption(kDebugFriendly);
+        SetOption(kWithLoc);
+        SetOption(kWithSrc);
+        SetOption(kWithMpl);
+        SetOption(kWithAsm);
+        break;
+      case kProfilingInfo:
+        SetOption(kWithProfileCode);
+        SetParserOption(kWithProfileInfo);
+        break;
+      case kRaColor:
+        SetOption(kDoColorRegAlloc);
+        ClearOption(kDoLinearScanRegAlloc);
+        break;
+      case kPrintFunction:
+        (opt.Type() == kEnable) ? EnablePrintFunction() : DisablePrintFunction();
+        break;
+      case kTrace:
+        SetOption(kAddDebugTrace);
+        break;
+      case kProfileEnable:
+        SetOption(kAddFuncProfile);
+        break;
+      case kSuppressFinfo:
+        SetOption(kSuppressFileInfo);
+        break;
+      case kConstFoldOpt:
+        SetOption(kConstFold);
+        break;
+      case kCGDumpcfg:
+        SetOption(kDumpCFG);
+        break;
+      case kCGClassList:
+        SetClassListFile(opt.Args());
+        break;
+      case kGenDef:
+        SetOrClear(GetGenerateFlags(), CGOptions::kCMacroDef, opt.Type());
+        break;
+      case kGenGctib:
+        SetOrClear(GetGenerateFlags(), CGOptions::kGctib, opt.Type());
+        break;
+      case kGenPrimorList:
+        SetOrClear(GetGenerateFlags(), CGOptions::kPrimorList, opt.Type());
+        break;
+      case kYieldPoing:
+        SetOrClear(GetGenerateFlags(), CGOptions::kGenYieldPoint, opt.Type());
+        break;
+      case kLocalRc:
+        SetOrClear(GetGenerateFlags(), CGOptions::kGenLocalRc, opt.Type());
+        break;
+      case kEhList: {
+        const std::string &ehList = opt.Args();
+        SetEHExclusiveFile(ehList);
+        EnableExclusiveEH();
+        ParseExclusiveFunc(ehList);
+        break;
+      }
+      case kCyclePatternList: {
+        const std::string &patternList = opt.Args();
+        SetCyclePatternFile(patternList);
+        EnableEmitCyclePattern();
+        ParseCyclePattern(patternList);
+        break;
+      }
+      case kCgen: {
+        bool cgFlag = (opt.Type() == kEnable);
+        SetRunCGFlag(cgFlag);
+        cgFlag ? SetOption(CGOptions::kDoCg) : ClearOption(CGOptions::kDoCg);
+        break;
+      }
+      case kObjMap:
+        SetGenerateObjectMap(opt.Type() == kEnable);
+        break;
+      case kCGLazyBinding:
+        (opt.Type() == kEnable) ? EnableLazyBinding() : DisableLazyBinding();
+        break;
+      case kCGHotFix:
+        (opt.Type() == kEnable) ? EnableHotFix() : DisableHotFix();
+        break;
+      case kInsertSoe:
+        SetOption(CGOptions::kSoeCheckInsert);
+        break;
+      case kCheckArrayStore:
+        (opt.Type() == kEnable) ? EnableCheckArrayStore() : DisableCheckArrayStore();
+        break;
+      case kCGNativeOpt:
+        DisableNativeOpt();
+        break;
+      case kCalleeCFI:
+        (opt.Type() == kEnable) ? DisableNoCalleeCFI() : EnableNoCalleeCFI();
+        break;
+      case kProepilogue:
+        (opt.Type() == kEnable) ? SetOption(CGOptions::kProEpilogueOpt)
+                                : ClearOption(CGOptions::kProEpilogueOpt);
+        break;
+      case kCGO0:
+        // Already handled above in DecideMplcgRealLevel
+        break;
+      case kCGO1:
+        // Already handled above in DecideMplcgRealLevel
+        break;
+      case kCGO2:
+        // Already handled above in DecideMplcgRealLevel
+        break;
+      case kCGDumpPhases:
+        SplitPhases(opt.Args(), GetDumpPhases());
+        break;
+      case kCGSkipPhases:
+        SplitPhases(opt.Args(), GetSkipPhases());
+        break;
+      case kCGSkipFrom:
+        SetSkipFrom(opt.Args());
+        break;
+      case kCGSkipAfter:
+        SetSkipAfter(opt.Args());
+        break;
+      case kLongCalls:
+        (opt.Type() == kEnable) ? EnableLongCalls() : DisableLongCalls();
+        break;
+      case kGcOnly:
+        (opt.Type() == kEnable) ? EnableGCOnly() : DisableGCOnly();
+        break;
+      default:
+        WARN(kLncWarn, "input invalid key for mplcg " + opt.OptionKey());
+        break;
+    }
+  }
+  return true;
+}
+
 void CGOptions::ParseExclusiveFunc(const std::string &fileName) {
   std::ifstream file(fileName);
   if (!file.is_open()) {
diff --git a/src/maple_be/src/cg/cg_phasemanager.cpp b/src/maple_be/src/cg/cg_phasemanager.cpp
index eef20818199a2980c474b65afded042e86cbc0cb..7db673a17858c402112ed3bdade8db152580edd2 100644
--- a/src/maple_be/src/cg/cg_phasemanager.cpp
+++ b/src/maple_be/src/cg/cg_phasemanager.cpp
@@ -207,7 +207,7 @@ void CgFuncPhaseManager::Run(CGFunc &func) {
 }
 
 void CgFuncPhaseManager::ClearPhaseNameInfo() {
-  for (auto it = PhaseSequenceBegin(); it != PhaseSequenceEnd(); it++) {
+  for (auto it = PhaseSequenceBegin(); it != PhaseSequenceEnd(); ++it) {
     PhaseID id = GetPhaseId(it);
     FuncPhase *funcPhase = static_cast<FuncPhase*>(GetPhase(id));
     if (funcPhase == nullptr) {
diff --git a/src/maple_be/src/cg/cgfunc.cpp b/src/maple_be/src/cg/cgfunc.cpp
index 2eaa7ee5a2eafb179ef3c2e336bf8e90ad5e2fa7..96c42c019f0cf2bbe818172241164fb12113f3e7 100644
--- a/src/maple_be/src/cg/cgfunc.cpp
+++ b/src/maple_be/src/cg/cgfunc.cpp
@@ -316,7 +316,7 @@ Operand *HandleIntrinOp(const BaseNode &parent, BaseNode &expr, CGFunc &cgFunc)
 }
 
 using HandleExprFactory = FunctionFactory<Opcode, maplebe::Operand*, const BaseNode&, BaseNode&, CGFunc&>;
-bool InitHandleExprFactory() {
+void InitHandleExprFactory() {
   RegisterFactoryFunction<HandleExprFactory>(OP_dread, HandleDread);
   RegisterFactoryFunction<HandleExprFactory>(OP_regread, HandleRegread);
   RegisterFactoryFunction<HandleExprFactory>(OP_constval, HandleConstVal);
@@ -373,7 +373,6 @@ bool InitHandleExprFactory() {
   RegisterFactoryFunction<HandleExprFactory>(OP_gcmallocjarray, HandleJarrayMalloc);
   RegisterFactoryFunction<HandleExprFactory>(OP_gcpermallocjarray, HandleJarrayMalloc);
   RegisterFactoryFunction<HandleExprFactory>(OP_intrinsicop, HandleIntrinOp);
-  return true;
 }
 
 void HandleLabel(StmtNode &stmt, CGFunc &cgFunc) {
@@ -625,7 +624,7 @@ void HandleAssertNull(StmtNode &stmt, CGFunc &cgFunc) {
 }
 
 using HandleStmtFactory = FunctionFactory<Opcode, void, StmtNode&, CGFunc&>;
-bool InitHandleStmtFactory() {
+void InitHandleStmtFactory() {
   RegisterFactoryFunction<HandleStmtFactory>(OP_label, HandleLabel);
   RegisterFactoryFunction<HandleStmtFactory>(OP_goto, HandleGoto);
   RegisterFactoryFunction<HandleStmtFactory>(OP_brfalse, HandleCondbr);
@@ -649,7 +648,6 @@ bool InitHandleStmtFactory() {
   RegisterFactoryFunction<HandleStmtFactory>(OP_comment, HandleComment);
   RegisterFactoryFunction<HandleStmtFactory>(OP_catch, HandleCatchOp);
   RegisterFactoryFunction<HandleStmtFactory>(OP_assertnonnull, HandleAssertNull);
-  return true;
 }
 
 CGFunc::CGFunc(MIRModule &mod, CG &cg, MIRFunction &mirFunc, BECommon &beCommon, MemPool &memPool,
@@ -748,10 +746,8 @@ bool CGFunc::CheckSkipMembarOp(StmtNode &stmt) {
 }
 
 void CGFunc::GenerateInstruction() {
-  static auto exprHandlerLoader = InitHandleExprFactory();
-  (void)exprHandlerLoader;
-  static auto stmtHandlerLoader = InitHandleStmtFactory();
-  (void)stmtHandlerLoader;
+  InitHandleExprFactory();
+  InitHandleStmtFactory();
   StmtNode *secondStmt = HandleFirstStmt();
 
   /* First Pass: Creates the doubly-linked list of BBs (next,prev) */
diff --git a/src/maple_driver/BUILD.gn b/src/maple_driver/BUILD.gn
index ae3c82ea151192cacac0edf32bb4f008b17af372..f2f230e4d4458e2534b33437108ed7a8b4a2ebc1 100644
--- a/src/maple_driver/BUILD.gn
+++ b/src/maple_driver/BUILD.gn
@@ -55,12 +55,12 @@ executable("maple") {
     "src/mplcg_compiler.cpp",
   ]
 
-  cflags_cc += [ "-DOPTION_PARSER_EXTRAOPT" ]
 
   include_dirs = include_directories
 
   deps = [
-    ":liboption_parser_extra",
+    ":liboption_parser",
+    ":libdriver_option",
     "${MAPLEALL_ROOT}/huawei_secure_c:libHWSecureC",
     "${MAPLEALL_ROOT}/maple_be:libcg",
     "${MAPLEALL_ROOT}/maple_be:libmplad",
@@ -79,23 +79,16 @@ executable("maple") {
   ]
 }
 
-static_library("liboption_parser_extra") {
+static_library("libdriver_option") {
   sources = [
-    "src/option_parser.cpp",
-  ]
-
-  cflags_cc += [
-    "-DOPTION_PARSER_EXTRAOPT",
-    "-DOPTION_PARSER_DEBUG",
+    "src/driver_option_common.cpp",
   ]
 
   include_dirs = [
-    "${MAPLEALL_ROOT}/maple_util/include",
     "${MAPLEALL_ROOT}/maple_driver/include",
-    "${MAPLEALL_ROOT}/maple_ir/include",
-    "${MAPLEALL_ROOT}/mempool/include",
-    "${MAPLEALL_ROOT}/huawei_secure_c/include",
   ]
+
+  output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
 }
 
 static_library("liboption_parser") {
diff --git a/src/maple_driver/defs/default/O0_options_jbc2mpl.def b/src/maple_driver/defs/default/O0_options_jbc2mpl.def
index d6f2c48860d2e63cd5d4a862392b2544148fef34..4d82bd2e54cfc7894a41d3c87013c5904f03c759 100644
--- a/src/maple_driver/defs/default/O0_options_jbc2mpl.def
+++ b/src/maple_driver/defs/default/O0_options_jbc2mpl.def
@@ -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.
@@ -12,4 +12,4 @@
  * FIT FOR A PARTICULAR PURPOSE.
  * See the Mulan PSL v1 for more details.
  */
-// option name, option value, option connect sysmbol, can append?, append spilter.
+// option name, option value, append maple root path?
diff --git a/src/maple_driver/defs/default/O0_options_me.def b/src/maple_driver/defs/default/O0_options_me.def
index cd590df215e52881859dc6089afeded372e10875..ddb4ef6084bcae13795a469adaa0f751c1f6d481 100644
--- a/src/maple_driver/defs/default/O0_options_me.def
+++ b/src/maple_driver/defs/default/O0_options_me.def
@@ -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.
@@ -12,4 +12,5 @@
  * FIT FOR A PARTICULAR PURPOSE.
  * See the Mulan PSL v1 for more details.
  */
-{ "--quiet", "", "", false, "", false },
+// option name, option value, append maple root path?
+{ "--quiet", "", false },
diff --git a/src/maple_driver/defs/default/O0_options_mpl2mpl.def b/src/maple_driver/defs/default/O0_options_mpl2mpl.def
index f6c8080a0a5604fa5d52d155b7e25542450c322b..eb1519763202a1e71fd58920ccf08aa5eb7a56fa 100644
--- a/src/maple_driver/defs/default/O0_options_mpl2mpl.def
+++ b/src/maple_driver/defs/default/O0_options_mpl2mpl.def
@@ -12,8 +12,8 @@
  * FIT FOR A PARTICULAR PURPOSE.
  * See the Mulan PSL v1 for more details.
  */
-// option name, option value, option connect sysmbol, can append?, append spilter.
-{ "--quiet", "", "", false, "", false },
-{ "-regnativefunc", "", "", false, "", false },
-{ "--maplelinker", "", "", false, "", false },
-{ "--emitVtableImpl", "", "", false, "", false },
+// option name, option value, append maple root path?
+{ "--quiet", "", false },
+{ "-regnativefunc", "", false },
+{ "--maplelinker", "", false },
+{ "--emitVtableImpl", "", false },
diff --git a/src/maple_driver/defs/default/O0_options_mplcg.def b/src/maple_driver/defs/default/O0_options_mplcg.def
index 829a442d65f3fcf9e23075d3c2f81403d39d817c..b0ea5ddc290fbfe3328bbc32f5991ca8c14b7800 100644
--- a/src/maple_driver/defs/default/O0_options_mplcg.def
+++ b/src/maple_driver/defs/default/O0_options_mplcg.def
@@ -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.
@@ -12,9 +12,9 @@
  * FIT FOR A PARTICULAR PURPOSE.
  * See the Mulan PSL v1 for more details.
  */
-// option name, option value, option connect sysmbol, can append?, append spilter.
-{ "--quiet", "", "", false, "", false  },
-{ "--no-pie", "", "", false, "", false  },
-{ "--fpic", "", "", false, "", false  },
-{ "--verbose-asm", "", "", false, "", false  },
-{ "--maplelinker", "", "", false, "", false  },
+// option name, option value, append maple root path?
+{ "--quiet", "", false  },
+{ "--no-pie", "", false  },
+{ "--fpic", "", false  },
+{ "--verbose-asm", "", false  },
+{ "--maplelinker", "", false  },
diff --git a/src/maple_driver/defs/default/O2_options_me.def b/src/maple_driver/defs/default/O2_options_me.def
index 623af4569b8d286aec172d26e5a0c64554fb8d4f..a0c68d017aa9c2bdde554fccedd54f35c7058d0f 100644
--- a/src/maple_driver/defs/default/O2_options_me.def
+++ b/src/maple_driver/defs/default/O2_options_me.def
@@ -12,6 +12,6 @@
  * FIT FOR A PARTICULAR PURPOSE.
  * See the Mulan PSL v1 for more details.
  */
-// option name, option value, option connect sysmbol, can append?, append spilter.
-{ "-O2", "", "", false, "", false },
-{ "--quiet", "", "", false, "", false },
+// option name, option value, append maple root path?
+{ "-O2", "", false },
+{ "--quiet", "", false },
diff --git a/src/maple_driver/defs/default/O2_options_mpl2mpl.def b/src/maple_driver/defs/default/O2_options_mpl2mpl.def
index fa58e815c96ac9368f01146950b9189d289c77bb..524d60d00db5207510b667d958a2c24d48d48a63 100644
--- a/src/maple_driver/defs/default/O2_options_mpl2mpl.def
+++ b/src/maple_driver/defs/default/O2_options_mpl2mpl.def
@@ -12,9 +12,9 @@
  * FIT FOR A PARTICULAR PURPOSE.
  * See the Mulan PSL v1 for more details.
  */
-// option name, option value, option connect sysmbol, can append?, append spilter.
-{ "-O2", "", "", false, "", false },
-{ "--quiet", "", "", false, "", false },
-{ "--regnativefunc", "", "", false, "", false },
-{ "--no-nativeopt", "", "", false, "", false },
-{ "--emitVtableImpl", "", "", false, "", false },
+// option name, option value, append maple root path?
+{ "-O2", "", false },
+{ "--quiet", "", false },
+{ "--regnativefunc", "", false },
+{ "--no-nativeopt", "", false },
+{ "--emitVtableImpl", "", false },
diff --git a/src/maple_driver/defs/default/O2_options_mplcg.def b/src/maple_driver/defs/default/O2_options_mplcg.def
index 4f82acc0f99be8aa77d7f6a9b4d80a0b87a7f004..8e593d76d8bb8cba61620b3e0d0f2a508ebc404a 100644
--- a/src/maple_driver/defs/default/O2_options_mplcg.def
+++ b/src/maple_driver/defs/default/O2_options_mplcg.def
@@ -12,10 +12,10 @@
  * FIT FOR A PARTICULAR PURPOSE.
  * See the Mulan PSL v1 for more details.
  */
-// option name, option value, option connect sysmbol, can append?, append spilter.
-{ "-O2", "", "", false, "", false },
-{ "--quiet", "", "", false, "", false },
-{ "--no-pie", "", "", false, "", false },
-{ "--verbose-asm", "", "", false, "", false },
-{ "--fpic", "", "", false, "", false },
+// option name, option value, append maple root path?
+{ "-O2", "", false },
+{ "--quiet", "", false },
+{ "--no-pie", "", false },
+{ "--verbose-asm", "", false },
+{ "--fpic", "", false },
 
diff --git a/src/maple_driver/include/compiler.h b/src/maple_driver/include/compiler.h
index 2b82b75f2fcfeeb6604e8c19939750b5d2bfcc0b..23376d5009ae062d5400d5d04faf82b2fa753755 100644
--- a/src/maple_driver/include/compiler.h
+++ b/src/maple_driver/include/compiler.h
@@ -66,23 +66,13 @@ class Compiler {
     return DefaultOption();
   }
 
-  virtual std::string AppendSpecialOption(const MplOptions&, const std::string &optionStr) const {
-    return optionStr;
-  }
-
-  virtual std::string AppendOptimization(const MplOptions &options, const std::string &optionStr) const;
-
-  bool CanAppendOptimization() const;
-
  private:
   const std::string name;
   std::string MakeOption(const MplOptions &options) const;
   void AppendDefaultOptions(std::map<std::string, MplOption> &finalOptions,
                             const std::map<std::string, MplOption> &defaultOptions) const;
-  void AppendUserOptions(std::map<std::string, MplOption> &finalOptions,
-                         const std::vector<mapleOption::Option> &userOption) const;
-  void AppendOptions(std::map<std::string, MplOption> &finalOptions, const std::string &key, const std::string &value,
-                     const std::string &connectSymbol) const;
+  void AppendOptions(std::map<std::string, MplOption> &finalOptions, const std::string &key,
+                     const std::string &value) const;
   void AppendExtraOptions(std::map<std::string, MplOption> &finalOptions,
                           const std::map<std::string, std::vector<MplOption>> &extraOptions) const;
   std::map<std::string, MplOption> MakeDefaultOptions(const MplOptions &options) const;
@@ -117,12 +107,10 @@ class MapleCombCompiler : public Compiler {
 
  private:
   std::string realRunningExe;
-  void DecideMeRealLevel(MeOption &meOption, const std::vector<mapleOption::Option> &inputOptions);
-  void DecideMpl2MplRealLevel(Options &mpl2mplOption, const std::vector<mapleOption::Option> &inputOptions) const;
   std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions) const override;
   void GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector<std::string> &tempFiles) const override;
-  MeOption *MakeMeOptions(const MplOptions &options, MemPool &memPool);
-  Options *MakeMpl2MplOptions(const MplOptions &options, MemPool &memPool);
+  bool MakeMeOptions(const MplOptions &options);
+  bool MakeMpl2MplOptions(const MplOptions &options);
 };
 
 class MplcgCompiler : public Compiler {
@@ -135,10 +123,7 @@ class MplcgCompiler : public Compiler {
  private:
   std::string GetInputFileName(const MplOptions &options) const override;
   DefaultOption GetDefaultOptions(const MplOptions &options) const override;
-  maplebe::CGOptions *MakeCGOptions(const MplOptions &options, MemPool &memPool);
-  void DecideMplcgRealLevel(maplebe::CGOptions &cgOption,
-                            const std::vector<mapleOption::Option> &inputOptions,
-                            const MplOptions &options);
+  bool MakeCGOptions(const MplOptions &options);
   const std::string &GetBinName() const override;
 };
 }  // namespace maple
diff --git a/src/maple_driver/include/driver_option_common.h b/src/maple_driver/include/driver_option_common.h
new file mode 100644
index 0000000000000000000000000000000000000000..2185440c86ea0e420709aa3cc6ff20fd1e33a3be
--- /dev/null
+++ b/src/maple_driver/include/driver_option_common.h
@@ -0,0 +1,65 @@
+/*
+ * 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.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#ifndef DRIVER_OPTIONS_COMMON_H
+#define DRIVER_OPTIONS_COMMON_H
+#include "option_descriptor.h"
+
+namespace maple {
+enum DriverOptionIndex {
+  kUnknown,
+  kHelp,
+  kVersion,
+  kInFile,
+  kInMplt,
+  kOptimization0,
+  kOptimization2,
+  kMplcgOpt,
+  kMeOpt,
+  kMpl2MplOpt,
+  kSaveTemps,
+  kRun,
+  kOption,
+  kTimePhases,
+  kGenMeMpl,
+  kGenVtableImpl,
+  kAllDebug,
+  kCommonOptionEnd,
+};
+
+class MapleDriverOptionBase {
+ public:
+  void CreateUsages(const mapleOption::Descriptor usage[]) {
+    for (size_t i = 0; usage[i].help != nullptr; ++i) {
+      usageVec.push_back(usage[i]);
+    }
+  }
+  std::vector<mapleOption::Descriptor> &GetUsageVec() {
+    return usageVec;
+  }
+  MapleDriverOptionBase() = default;
+  ~MapleDriverOptionBase() = default;
+
+ private:
+  std::vector<mapleOption::Descriptor> usageVec;
+};
+
+class DriverOptionCommon : public MapleDriverOptionBase {
+ public:
+  static DriverOptionCommon &GetInstance();
+  DriverOptionCommon();
+  ~DriverOptionCommon() = default;
+};
+}  // namespace maple
+#endif //DRIVER_OPTIONS_COMMON_H
diff --git a/src/maple_driver/include/jbc2mpl_option.h b/src/maple_driver/include/jbc2mpl_option.h
new file mode 100644
index 0000000000000000000000000000000000000000..e09b4763494e9b2edfce56f425f7ddf96364ac3a
--- /dev/null
+++ b/src/maple_driver/include/jbc2mpl_option.h
@@ -0,0 +1,48 @@
+/*
+ * 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.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#ifndef MAPLE_JBC2MPL_OPTION_H
+#define MAPLE_JBC2MPL_OPTION_H
+#include "option_descriptor.h"
+
+namespace maple {
+using namespace mapleOption;
+
+enum JbcOptionIndex {
+  kUseStringFactory,
+  kOutMpl,
+};
+
+const Descriptor jbcUsage[] = {
+  { kUnknown, 0, "", "", kBuildTypeAll, kArgCheckPolicyUnknown,
+    "========================================\n"
+    " Usage: jbc2mpl [ options ]\n"
+    " options:\n",
+    "jbc2mpl",
+    {} },
+  { kUseStringFactory, 0, "", "use-string-factory", kBuildTypeAll, kArgCheckPolicyNone,
+    "  -use-string-factory    : Replace String.<init> by StringFactory call",
+    "jbc2mpl",
+    {} },
+  { kOutMpl, 0, "o", "out", kBuildTypeAll, kArgCheckPolicyRequired,
+    "  -o, -out output.mpl    : output mpl name",
+    "jbc2mpl",
+    {} },
+  { kUnknown, 0, nullptr, nullptr, kBuildTypeAll, kArgCheckPolicyNone,
+    nullptr,
+    "jbc2mpl",
+    {} }
+};
+} // namespace maple
+#endif //MAPLE_JBC2MPL_OPTION_H
diff --git a/src/maple_driver/include/mpl_options.h b/src/maple_driver/include/mpl_options.h
index 74458154cc4c9fde4a5d8b57e10a1a74f542949a..8f217efb958fd824072e3d223d804c5b0095ef10 100644
--- a/src/maple_driver/include/mpl_options.h
+++ b/src/maple_driver/include/mpl_options.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.
@@ -51,13 +51,9 @@ enum RunMode {
 
 class MplOption {
  public:
-  MplOption(const std::string &key, const std::string &value, const std::string &connectSymbol, bool isAppend,
-            const std::string &appendSplit, bool needRootPath = false)
+  MplOption(const std::string &key, const std::string &value, bool needRootPath = false)
       : key(key),
         value(value),
-        connectSymbol(connectSymbol),
-        isAppend(isAppend),
-        appendSplit(appendSplit),
         needRootPath(needRootPath) {
     CHECK_FATAL(!key.empty(), "MplOption got an empty key.");
   }
@@ -76,18 +72,6 @@ class MplOption {
     value = val;
   }
 
-  const std::string &GetconnectSymbol() const {
-    return connectSymbol;
-  }
-
-  bool GetIsAppend() const {
-    return isAppend;
-  }
-
-  const std::string &GetAppendSplit() const {
-    return appendSplit;
-  }
-
   bool GetNeedRootPath() const {
     return needRootPath;
   }
@@ -97,11 +81,6 @@ class MplOption {
   std::string key;
   // option value
   std::string value;
-  std::string connectSymbol;
-  // true --- append user option to default option with appendSplit.
-  // false --- override default option with user option.
-  bool isAppend;
-  std::string appendSplit;
   bool needRootPath;
 };
 
@@ -118,11 +97,6 @@ class MplOptions {
   ~MplOptions() = default;
 
   int Parse(int argc, char **argv);
-  std::string OptimizationLevelStr() const;
-
-  const std::map<std::string, std::vector<mapleOption::Option>> &GetOptions() const {
-    return options;
-  }
 
   const std::map<std::string, std::vector<mapleOption::Option>> &GetExeOptions() const {
     return exeOptions;
diff --git a/src/maple_driver/include/option_descriptor.h b/src/maple_driver/include/option_descriptor.h
new file mode 100644
index 0000000000000000000000000000000000000000..5e4162ee61e74d13c68f1321eb1cd7b0a229d801
--- /dev/null
+++ b/src/maple_driver/include/option_descriptor.h
@@ -0,0 +1,137 @@
+/*
+ * 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.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#ifndef MAPLE_OPTION_DESCRIPTOR_H
+#define MAPLE_OPTION_DESCRIPTOR_H
+#include <vector>
+#include <string>
+#include <algorithm>
+
+namespace mapleOption {
+enum BuildType {
+  kBuildTypeAll,
+  kBuildTypeDebug,
+  kBuildTypeRelease
+};
+
+enum ArgCheckPolicy {
+  kArgCheckPolicyUnknown,
+  kArgCheckPolicyNone,
+  kArgCheckPolicyOptional,
+  kArgCheckPolicyRequired,
+  kArgCheckPolicyNumeric,
+  kArgCheckPolicyBool
+};
+
+constexpr unsigned int kMaxExtraOptions = 10;
+
+struct Descriptor {
+  // Unique option index
+  const unsigned int index;
+
+  // Unique option type
+  const int type;
+
+  // Short form option key
+  const char * const shortOption;
+
+  // Long form option key
+  const char * const longOption;
+
+  // The option can be seen in which build type.
+  const BuildType enableBuildType;
+
+  // Should we have a parameter?
+  const ArgCheckPolicy checkPolicy;
+
+  // Help info
+  const char * const help;
+
+  const char * const exeName;
+
+  // option key mapping to target tool
+  const std::vector<std::string> extras;
+
+  bool IsEnabledForCurrentBuild() const {
+    switch (enableBuildType) {
+      case BuildType::kBuildTypeAll:
+        return true;
+      case BuildType::kBuildTypeDebug:
+        return true;
+      case BuildType::kBuildTypeRelease:
+        return false;
+      default:
+        // should never reach
+        return true;
+      }
+    }
+};
+
+class Option {
+ public:
+  Option(Descriptor desc, const std::string &optionKey, const std::string &args)
+      : descriptor(desc), optionKey(optionKey), args(args) {}
+
+  ~Option() = default;
+
+  unsigned int Index() const {
+    return descriptor.index;
+  }
+
+  unsigned int Type() const {
+    return descriptor.type;
+  }
+
+  const std::string &Args() const {
+    return args;
+  }
+
+  const std::string &OptionKey() const {
+    return optionKey;
+  }
+
+  bool HasExtra() const {
+    return (descriptor.extras.size() > 0);
+  }
+
+  std::vector<std::string> GetExtras() const {
+    auto ret = std::vector<std::string>();
+    unsigned int index = 0;
+    while (index < kMaxExtraOptions && index < descriptor.extras.size()) {
+      ret.push_back(descriptor.extras[index++]);
+    }
+    return ret;
+  }
+
+  bool FindExtra(const std::string &exeName) const {
+    auto item = std::find(descriptor.extras.begin(), descriptor.extras.end(), exeName);
+    if (item == descriptor.extras.end()) {
+      return false;
+    }
+    return true;
+  }
+
+ private:
+  Descriptor descriptor;
+  const std::string optionKey;
+  const std::string args;
+};
+
+enum EnabledIndex {
+  kDisable,
+  kEnable
+};
+}  // namespace mapleOption
+
+#endif //MAPLE_OPTION_DESCRIPTOR_H
diff --git a/src/maple_driver/include/option_parser.h b/src/maple_driver/include/option_parser.h
index 14461393ad63790e58cb8d8749e497365efa9ab3..4f707504ce854260ad1686fd4d0ba9088f4c1452 100644
--- a/src/maple_driver/include/option_parser.h
+++ b/src/maple_driver/include/option_parser.h
@@ -18,179 +18,23 @@
 #include <string>
 #include <vector>
 #include "error_code.h"
+#include "option_descriptor.h"
+#include "driver_option_common.h"
 
 namespace mapleOption {
-enum BuildType {
-  kBuildTypeAll,
-  kBuildTypeDebug,
-  kBuildTypeRelease
-};
-
-enum ArgCheckPolicy {
-  kArgCheckPolicyUnknown,
-  kArgCheckPolicyNone,
-  kArgCheckPolicyOptional,
-  kArgCheckPolicyRequired,
-  kArgCheckPolicyNumeric,
-  kArgCheckPolicyBool
-};
-
-struct ExtraOption {
-  // Tool bin name
-  const char * const exeName;
-
-  // Key mapping with -/-- if needed.
-  const char * const optionKey;
-
-  // Can override the connector defined in Descriptor.
-  const char * const connector;
-
-  // Can override the delimiter defined in Descriptor
-  const char * const delimiter;
-};
-
-constexpr unsigned int kMaxExtraOptions = 10;
-
-struct Descriptor {
-  // Unique option index
-  const unsigned int index;
-
-  // Unique option type
-  const int type;
-
-  // Short form option key
-  const char * const shortOption;
-
-  // Long form option key
-  const char * const longOption;
-
-#ifdef OPTION_PARSER_EXTRAOPT
-  // Connector followed after key when passing args to target tool.
-  const char * const connector;
-
-  // There's default args for the option.
-  // When user set it again, if true, append to the default args,
-  // else replace it.
-  const bool isCanAppend;
-
-  // Delimiter when append.
-  // if isCanAppend is false, it's meaningless.
-  const char * const delimiter;
-#endif
-
-  // The option can be seen in which build type.
-  const BuildType enableBuildType;
-
-  // Should we have a parameter?
-  const ArgCheckPolicy checkPolicy;
-
-  // Help info
-  const char * const help;
-
-#ifdef OPTION_PARSER_EXTRAOPT
-  const char * const exeName;
-
-  // option key mapping to target tool
-  const std::vector<ExtraOption> extras;
-#endif
-
-  bool IsEnabledForCurrentBuild() const {
-    switch (enableBuildType) {
-      case BuildType::kBuildTypeAll:
-        return true;
-      case BuildType::kBuildTypeDebug:
-        return true;
-      case BuildType::kBuildTypeRelease:
-        return false;
-      default:
-        // should never reach
-        return true;
-    }
-  }
-};
-
-class Option {
- public:
-  Option(Descriptor desc, const std::string &optionKey, const std::string &args)
-      : descriptor(desc), optionKey(optionKey), args(args) {}
-
-  ~Option() = default;
-
-  unsigned int Index() const {
-    return descriptor.index;
-  }
-
-  unsigned int Type() const {
-    return descriptor.type;
-  }
-
-  const std::string &Args() const {
-    return args;
-  }
-
-  const std::string &OptionKey() const {
-    return optionKey;
-  }
-
-#ifdef OPTION_PARSER_EXTRAOPT
-  std::string ConnectSymbol(const std::string &exeName) const {
-    auto extra = FindExtra(exeName);
-    if (extra != nullptr && extra->connector != nullptr) {
-      return extra->connector;
-    }
-    return descriptor.connector == nullptr ? "" : descriptor.connector;
-  }
-
-  std::string AppendSymbol(const std::string &exeName) const {
-    auto extra = FindExtra(exeName);
-    if (extra != nullptr && extra->delimiter != nullptr) {
-      return extra->delimiter;
-    }
-    return descriptor.delimiter == nullptr ? "" : descriptor.delimiter;
-  }
-
-  bool HasExtra() const {
-    return descriptor.extras[0].exeName != nullptr;
-  }
-
-  std::vector<ExtraOption> GetExtras() const {
-    auto ret = std::vector<ExtraOption>();
-    unsigned int index = 0;
-    while (index < kMaxExtraOptions && descriptor.extras[index].exeName != nullptr) {
-      ret.push_back(descriptor.extras[index++]);
-    }
-    return ret;
-  }
-
-  const ExtraOption *FindExtra(const std::string &exeName) const {
-    unsigned int index = 0;
-    while (index < kMaxExtraOptions && descriptor.extras[index].exeName != nullptr) {
-      if (exeName == descriptor.extras[index].exeName) {
-        return &descriptor.extras[index];
-      }
-      ++index;
-    }
-    return nullptr;
-  }
-
-#endif
-
- private:
-  Descriptor descriptor;
-  const std::string optionKey;
-  const std::string args;
-};
-
 class OptionParser {
  public:
-  explicit OptionParser(const Descriptor usage[]);
+  OptionParser() = default;
 
   ~OptionParser() = default;
 
-  maple::ErrorCode Parse(int argc, char **argv);
+  void RegisteUsages(maple::MapleDriverOptionBase &base);
+  void RegisteUsages(const Descriptor usage[]);
+
+  maple::ErrorCode Parse(int argc, char **argv, const std::string exeName = "all");
 
   maple::ErrorCode HandleInputArgs(const std::vector<std::string> &inputArgs, const std::string &exeName,
-                                   std::vector<mapleOption::Option> &inputOption);
+                                   std::vector<mapleOption::Option> &inputOption, bool isAllOption = false);
 
   const std::vector<Option> &GetOptions() const {
     return options;
@@ -204,19 +48,15 @@ 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
   bool SetOption(const std::string &key, const std::string &value, const std::string &exeName,
                  std::vector<mapleOption::Option> &exeOption);
-  void PrintUsage(const std::string &helpTyoe) const;
-#endif
+  void PrintUsage(const std::string &helpType) const;
 
  private:
   bool HandleKeyValue(const std::string &key, const std::string &value, bool isValueEmpty,
@@ -240,9 +80,11 @@ enum MatchedIndex {
   kMatchShortOpt,
   kMatchLongOpt
 };
-enum EnabledIndex {
-  kDisable,
-  kEnable
+enum Level {
+  kLevelZero = 0,
+  kLevelOne = 1,
+  kLevelTwo = 2,
+  kLevelThree = 3
 };
 }  // namespace mapleOption
 
diff --git a/src/maple_driver/src/compiler.cpp b/src/maple_driver/src/compiler.cpp
index 1d8b171fc07593f5cba2f27b0d0444599d174863..f7f6820bec7600cee3f39ee75cb920deaf62393f 100644
--- a/src/maple_driver/src/compiler.cpp
+++ b/src/maple_driver/src/compiler.cpp
@@ -62,14 +62,10 @@ std::string Compiler::MakeOption(const MplOptions &options) const {
   std::map<std::string, MplOption> finalOptions;
   std::map<std::string, MplOption> defaultOptions = MakeDefaultOptions(options);
   AppendDefaultOptions(finalOptions, defaultOptions);
-  auto userOption = options.GetOptions().find(GetBinName());
-  if (userOption != options.GetOptions().end()) {
-    AppendUserOptions(finalOptions, userOption->second);
-  }
   AppendExtraOptions(finalOptions, options.GetExtras());
   std::ostringstream strOption;
   for (const auto &finalOption : finalOptions) {
-    strOption << " " << finalOption.first << finalOption.second.GetconnectSymbol() << finalOption.second.GetValue();
+    strOption << " " << finalOption.first << " " << finalOption.second.GetValue();
     if (options.HasSetDebugFlag()) {
       LogInfo::MapleLogger() << Compiler::GetName() << " options: " << finalOption.first << " "
                              << finalOption.second.GetValue() << '\n';
@@ -89,17 +85,6 @@ void Compiler::AppendDefaultOptions(std::map<std::string, MplOption> &finalOptio
   }
 }
 
-void Compiler::AppendUserOptions(std::map<std::string, MplOption> &finalOptions,
-                                 const std::vector<Option> &userOptions) const {
-  const std::string &binName = GetBinName();
-  for (const auto &userOption : userOptions) {
-    auto extra = userOption.FindExtra(binName);
-    if (extra != nullptr) {
-      AppendOptions(finalOptions, extra->optionKey, userOption.Args(), userOption.ConnectSymbol(binName));
-    }
-  }
-}
-
 void Compiler::AppendExtraOptions(std::map<std::string, MplOption> &finalOptions,
                                   const std::map<std::string, std::vector<MplOption>> &extraOptions) const {
   const std::string &binName = GetBinName();
@@ -108,7 +93,7 @@ void Compiler::AppendExtraOptions(std::map<std::string, MplOption> &finalOptions
     return;
   }
   for (const auto &secondExtras : extras->second) {
-    AppendOptions(finalOptions, secondExtras.GetKey(), secondExtras.GetValue(), secondExtras.GetconnectSymbol());
+    AppendOptions(finalOptions, secondExtras.GetKey(), secondExtras.GetValue());
   }
 }
 
@@ -125,30 +110,13 @@ std::map<std::string, MplOption> Compiler::MakeDefaultOptions(const MplOptions &
 }
 
 void Compiler::AppendOptions(std::map<std::string, MplOption> &finalOptions, const std::string &key,
-                             const std::string &value, const std::string &connectSymbol) const {
+                             const std::string &value) const {
   auto finalOpt = finalOptions.find(key);
   if (finalOpt != finalOptions.end()) {
-    if (finalOpt->second.GetIsAppend()) {
-      std::string temp = finalOpt->second.GetValue() + finalOpt->second.GetAppendSplit() + value;
-      finalOpt->second.SetValue(temp);
-    } else {
-      finalOpt->second.SetValue(value);
-    }
+    finalOpt->second.SetValue(value);
   } else {
-    MplOption option(key, value, connectSymbol, false, "");
+    MplOption option(key, value);
     finalOptions.insert(make_pair(key, option));
   }
 }
-
-bool Compiler::CanAppendOptimization() const {
-  // there're some issues for passing -Ox to each component, let users determine self.
-  return false;
-}
-
-std::string Compiler::AppendOptimization(const MplOptions &options, const std::string &optionStr) const {
-  if (!CanAppendOptimization()) {
-    return optionStr;
-  }
-  return optionStr + " " + options.OptimizationLevelStr();
-}
 }  // namespace maple
diff --git a/src/maple_driver/src/driver_option_common.cpp b/src/maple_driver/src/driver_option_common.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..251b9cea2a58bb6592ba89c4312cec035deb5e59
--- /dev/null
+++ b/src/maple_driver/src/driver_option_common.cpp
@@ -0,0 +1,202 @@
+/*
+ * 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.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include "driver_option_common.h"
+
+namespace {
+using namespace maple;
+using namespace mapleOption;
+const mapleOption::Descriptor usages[] = {
+  // index, type , shortOption , longOption, connector, isCanAppend, delimiter, enableBuildType, checkPolicy, help,
+  // extra
+  { kUnknown,
+    0,
+    nullptr,
+    nullptr,
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "USAGE: maple [options]\n\n Options:",
+    "all",
+    {} },
+  { kHelp,
+    0,
+    "h",
+    "help",
+    kBuildTypeAll,
+    kArgCheckPolicyOptional,
+    "  -h --help [command]         \tPrint usage and exit.\n",
+    "all",
+    {} },
+  { kVersion,
+    0,
+    nullptr,
+    "version",
+    kBuildTypeAll,
+    kArgCheckPolicyOptional,
+    "  --version [command]         \tPrint version and exit.\n",
+    "all",
+    {} },
+  { kInFile,
+    0,
+    nullptr,
+    "infile",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --infile file1,file2,file3  \tInput files.\n",
+    "all",
+    {} },
+  { kInMplt,
+    0,
+    nullptr,
+    "mplt",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --mplt=file1,file2,file3    \tImport mplt files.\n",
+    "all",
+    { "jbc2mpl",
+    } },
+  { kOptimization0,
+    0,
+    "O0",
+    nullptr,
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  -O0                         \tNo optimization.\n",
+    "all",
+    {} },
+  { kOptimization2,
+    0,
+    "O2",
+    nullptr,
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  -O2                         \tDo more optimization. (Default)\n",
+    "all",
+    {} },
+  { kMeOpt,
+    0,
+    nullptr,
+    "me-opt",
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  --me-opt                    \tSet options for me\n",
+    "all",
+    {} },
+  { kMpl2MplOpt,
+    0,
+    nullptr,
+    "mpl2mpl-opt",
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  --mpl2mpl-opt               \tSet options for mpl2mpl\n",
+    "all",
+    {} },
+  { kSaveTemps,
+    0,
+    nullptr,
+    "save-temps",
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  --save-temps                \tDo not delete intermediate files.\n"
+    "                              \t--save-temps Save all intermediate files.\n"
+    "                              \t--save-temps=file1,file2,file3 Save the\n"
+    "                              \ttarget files.\n",
+    "all",
+    {} },
+  { kRun,
+    0,
+    nullptr,
+    "run",
+    kBuildTypeDebug,
+    kArgCheckPolicyRequired,
+    "  --run=cmd1:cmd2             \tThe name of executables that are going\n"
+    "                              \tto execute. IN SEQUENCE.\n"
+    "                              \tSeparated by \":\".Available exe names:\n"
+    "                              \tjbc2mpl, me, mpl2mpl, mplcg\n"
+    "                              \tInput file must match the tool can\n"
+    "                              \thandle\n",
+    "all",
+    {} },
+  { kOption,
+    0,
+    nullptr,
+    "option",
+    kBuildTypeDebug,
+    kArgCheckPolicyRequired,
+    "  --option=\"opt1:opt2\"      \tOptions for each executable,\n"
+    "                              \tseparated by \":\".\n"
+    "                              \tThe sequence must match the sequence in\n"
+    "                              \t--run.\n",
+    "all",
+    {} },
+  { kTimePhases,
+    0,
+    "time-phases",
+    nullptr,
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  -time-phases                \tTiming phases and print percentages\n",
+    "all",
+    {} },
+  { kGenMeMpl,
+    0,
+    nullptr,
+    "genmempl",
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  --genmempl                  \tGenerate me.mpl file\n",
+    "all",
+    {} },
+  { kGenVtableImpl,
+    0,
+    nullptr,
+    "genVtableImpl",
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  --genVtableImpl             \tGenerate VtableImpl.mpl file\n",
+    "all",
+    {} },
+  { kAllDebug,
+    0,
+    nullptr,
+    "debug",
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    "  --debug                     \tPrint debug info.\n",
+    "all",
+    {} },
+
+  { kUnknown,
+    0,
+    nullptr,
+    nullptr,
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    nullptr,
+    "all",
+    {} }
+};
+}  // namepsace
+
+namespace maple {
+using namespace mapleOption;
+DriverOptionCommon &DriverOptionCommon::GetInstance() {
+  static DriverOptionCommon instance;
+  return instance;
+}
+
+DriverOptionCommon::DriverOptionCommon() {
+  CreateUsages(usages);
+}
+}  // namespace maple
\ No newline at end of file
diff --git a/src/maple_driver/src/maple_comb_compiler.cpp b/src/maple_driver/src/maple_comb_compiler.cpp
index 1c8b72022e1146f0e926b1fef0d648607e63cd6b..a7fbeaf0f573b0c9dd5193b869dfd4146964319a 100644
--- a/src/maple_driver/src/maple_comb_compiler.cpp
+++ b/src/maple_driver/src/maple_comb_compiler.cpp
@@ -15,7 +15,6 @@
 #include <iterator>
 #include <algorithm>
 #include "compiler.h"
-#include "usages.h"
 #include "string_utils.h"
 #include "mpl_logging.h"
 #include "driver_runner.h"
@@ -97,383 +96,61 @@ void MapleCombCompiler::PrintCommand(const MplOptions &options) const {
                          << GetInputFileName(options) << options.GetPrintCommandStr() << '\n';
 }
 
-void MapleCombCompiler::DecideMeRealLevel(MeOption &meOption, const std::vector<mapleOption::Option> &inputOptions) {
-  for (const mapleOption::Option &opt : inputOptions) {
-    switch (opt.Index()) {
-      case kMeOptL1:
-        meOption.optLevel = MeOption::kLevelOne;
-        break;
-      case kMeOptL2:
-        meOption.optLevel = MeOption::kLevelTwo;
-        // Turn the followings ON only at O2
-        meOption.optDirectCall = true;
-        meOption.epreIncludeRef = true;
-        break;
-      default:
-        break;
-    }
-  }
-}
-
-MeOption *MapleCombCompiler::MakeMeOptions(const MplOptions &options, MemPool &optMp) {
-  MeOption *meOption = new MeOption(optMp);
+bool MapleCombCompiler::MakeMeOptions(const MplOptions &options) {
+  MeOption &meOption = MeOption::GetInstance();
   auto it = options.GetExeOptions().find(kBinNameMe);
   if (it == options.GetExeOptions().end()) {
     LogInfo::MapleLogger() << "no me input options\n";
-    return meOption;
+    return false;
   }
-  DecideMeRealLevel(*meOption, it->second);
-  if (options.HasSetDebugFlag()) {
-    LogInfo::MapleLogger() << "Real Me level:" << std::to_string(meOption->optLevel) << "\n";
+  bool result = meOption.SolveOptions(it->second, options.HasSetDebugFlag());
+  if (result == false) {
+    LogInfo::MapleLogger() << "Meet error mpl2mpl options\n";
+    return false;
   }
-  for (const mapleOption::Option &opt : it->second) {
-    if (options.HasSetDebugFlag()) {
-      LogInfo::MapleLogger() << "Me options: " << opt.Index() << " " << opt.OptionKey() << " " << opt.Args() << '\n';
-    }
-    switch (opt.Index()) {
-      case kMeSkipPhases:
-        meOption->SplitSkipPhases(opt.Args());
-        break;
-      case kMeOptL1:
-        // Already handled above in DecideMeRealLevel
-        break;
-      case kMeOptL2:
-        // Already handled above in DecideMeRealLevel
-        break;
-      case kMeRange:
-        meOption->useRange = true;
-        meOption->GetRange(opt.Args());
-        break;
-      case kMeDumpAfter:
-        meOption->dumpAfter = (opt.Type() == kEnable);
-        break;
-      case kMeDumpFunc:
-        meOption->dumpFunc = opt.Args();
-        break;
-      case kMeDumpPhases:
-        meOption->SplitPhases(opt.Args(), meOption->dumpPhases);
-        break;
-      case kMeQuiet:
-        meOption->quiet = (opt.Type() == kEnable);
-        break;
-      case kSetCalleeHasSideEffect:
-        meOption->setCalleeHasSideEffect = (opt.Type() == kEnable);
-        break;
-      case kNoSteensgaard:
-        meOption->noSteensgaard = (opt.Type() == kEnable);
-        break;
-      case kNoTBAA:
-        meOption->noTBAA = (opt.Type() == kEnable);
-        break;
-      case kAliasAnalysisLevel:
-        meOption->aliasAnalysisLevel = std::stoul(opt.Args(), nullptr);
-        if (meOption->aliasAnalysisLevel > MeOption::kLevelThree) {
-          meOption->aliasAnalysisLevel = MeOption::kLevelThree;
-        }
-        switch (meOption->aliasAnalysisLevel) {
-          case MeOption::kLevelThree:
-            meOption->setCalleeHasSideEffect = false;
-            meOption->noSteensgaard = false;
-            meOption->noTBAA = false;
-            break;
-          case MeOption::kLevelZero:
-            meOption->setCalleeHasSideEffect = true;
-            meOption->noSteensgaard = true;
-            meOption->noTBAA = true;
-            break;
-          case MeOption::kLevelOne:
-            meOption->setCalleeHasSideEffect = false;
-            meOption->noSteensgaard = false;
-            meOption->noTBAA = true;
-            break;
-          case MeOption::kLevelTwo:
-            meOption->setCalleeHasSideEffect = false;
-            meOption->noSteensgaard = true;
-            meOption->noTBAA = false;
-            break;
-          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 kRcLower:
-        meOption->rcLowering = (opt.Type() == kEnable);
-        break;
-      case kMeNoDot:
-        meOption->noDot = (opt.Type() == kEnable);
-        break;
-      case kStmtNum:
-        meOption->stmtNum = (opt.Type() == kEnable);
-        break;
-      case kEpreLimit:
-        meOption->epreLimit = std::stoul(opt.Args(), nullptr);
-        break;
-      case kEprepuLimit:
-        meOption->eprePULimit = std::stoul(opt.Args(), nullptr);
-        break;
-      case kStmtPrepuLimit:
-        meOption->stmtprePULimit = std::stoul(opt.Args(), nullptr);
-        break;
-      case kLpreLimit:
-        meOption->lpreLimit = std::stoul(opt.Args(), nullptr);
-        break;
-      case kLprepulLimit:
-        meOption->lprePULimit = std::stoul(opt.Args(), nullptr);
-        break;
-      case kPregreNameLimit:
-        meOption->pregRenameLimit = std::stoul(opt.Args(), nullptr);
-        break;
-      case kDelrcpuLimit:
-        meOption->delRcPULimit = std::stoul(opt.Args(), nullptr);
-        break;
-      case kEpreIncludeRef:
-        meOption->epreIncludeRef = (opt.Type() == kEnable);
-        break;
-      case kEpreLocalRefVar:
-        meOption->epreLocalRefVar = (opt.Type() == kEnable);
-        break;
-      case kEprelhSivar:
-        meOption->epreLHSIvar = (opt.Type() == kEnable);
-        break;
-      case kLessThrowAlias:
-        meOption->lessThrowAlias = (opt.Type() == kEnable);
-        break;
-      case kNodeLegateRc:
-        meOption->noDelegateRC = (opt.Type() == kEnable);
-        break;
-      case kNocondBasedRc:
-        meOption->noCondBasedRC = (opt.Type() == kEnable);
-        break;
-      case kNullcheckPre:
-        meOption->nullCheckPre = (opt.Type() == kEnable);
-        break;
-      case kClinitPre:
-        meOption->clinitPre = (opt.Type() == kEnable);
-        break;
-      case kDassignPre:
-        meOption->dassignPre = (opt.Type() == kEnable);
-        break;
-      case kAssign2finalPre:
-        meOption->assign2FinalPre = (opt.Type() == kEnable);
-        break;
-      case kRegReadAtReturn:
-        meOption->regreadAtReturn = (opt.Type() == kEnable);
-        break;
-      case kLpreSpeculate:
-        meOption->lpreSpeculate = (opt.Type() == kEnable);
-        break;
-      case kSpillatCatch:
-        meOption->spillAtCatch = (opt.Type() == kEnable);
-        break;
-      default:
-        WARN(kLncWarn, "input invalid key for me " + opt.OptionKey());
-        break;
-    }
-  }
-  return meOption;
+  return true;
 }
 
-void MapleCombCompiler::DecideMpl2MplRealLevel(Options &mpl2mplOption,
-                                               const std::vector<mapleOption::Option> &inputOptions) const {
-  for (const mapleOption::Option &opt : inputOptions) {
-    if (opt.Index() == kMpl2MplOptL2) {
-      mpl2mplOption.O2 = true;
-      mpl2mplOption.usePreg = true;
-      break;
-    }
-  }
-}
-
-Options *MapleCombCompiler::MakeMpl2MplOptions(const MplOptions &options, MemPool &optMp) {
-  auto *mpl2mplOption = new Options(optMp);
+bool MapleCombCompiler::MakeMpl2MplOptions(const MplOptions &options) {
+  auto &mpl2mplOption = Options::GetInstance();
   auto it = options.GetExeOptions().find(kBinNameMpl2mpl);
   if (it == options.GetExeOptions().end()) {
     LogInfo::MapleLogger() << "no mpl2mpl input options\n";
-    return mpl2mplOption;
+    return false;
   }
-  DecideMpl2MplRealLevel(*mpl2mplOption, it->second);
-  for (const mapleOption::Option &opt : it->second) {
-    if (options.HasSetDebugFlag()) {
-      LogInfo::MapleLogger() << "mpl2mpl options: " << opt.Index() << " " << opt.OptionKey() << " " << opt.Args()
-                             << '\n';
-    }
-    switch (opt.Index()) {
-      case kMpl2MplDumpBefore:
-        mpl2mplOption->dumpBefore = (opt.Type() == kEnable);
-        break;
-      case kMpl2MplDumpAfter:
-        mpl2mplOption->dumpAfter = (opt.Type() == kEnable);
-        break;
-      case kMpl2MplDumpFunc:
-        mpl2mplOption->dumpFunc = opt.Args();
-        break;
-      case kMpl2MplQuiet:
-        mpl2mplOption->quiet = (opt.Type() == kEnable);
-        break;
-      case kMpl2MplDumpPhase:
-        mpl2mplOption->dumpPhase = opt.Args();
-        break;
-      case kMpl2MplSkipPhase:
-        mpl2mplOption->skipPhase = opt.Args();
-        break;
-      case kMpl2MplSkipFrom:
-        mpl2mplOption->skipFrom = opt.Args();
-        break;
-      case kMpl2MplSkipAfter:
-        mpl2mplOption->skipAfter = opt.Args();
-        break;
-      case kRegNativeDynamicOnly:
-        mpl2mplOption->regNativeDynamicOnly = (opt.Type() == kEnable);
-        break;
-      case kRegNativeStaticBindingList:
-        mpl2mplOption->staticBindingList = opt.Args();
-        break;
-      case kMpl2MplStubJniFunc:
-        mpl2mplOption->regNativeFunc = (opt.Type() == kEnable);
-        break;
-      case kNativeWrapper:
-        mpl2mplOption->nativeWrapper = (opt.Type() == kEnable);
-        break;
-      case kInlineWithProfile:
-        mpl2mplOption->inlineWithProfile = (opt.Type() == kEnable);
-        break;
-      case kMpl2MplUseInline:
-        mpl2mplOption->useInline = (opt.Type() == kEnable);
-        break;
-      case kMpl2MplNoInlineFuncList:
-        mpl2mplOption->noInlineFuncList = opt.Args();
-        break;
-      case kMpl2MplUseCrossModuleInline:
-        mpl2mplOption->useCrossModuleInline = (opt.Type() == kEnable);
-        break;
-      case kInlineSmallFunctionThreshold:
-        if (opt.Args().empty()) {
-          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --inline-small-function-threshold\n";
-          exit(1);
-        } else {
-          mpl2mplOption->inlineSmallFunctionThreshold = std::stoul(opt.Args());
-        }
-        break;
-      case kInlineHotFunctionThreshold:
-        if (opt.Args().empty()) {
-          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --inline-hot-function-threshold\n";
-          exit(1);
-        } else {
-          mpl2mplOption->inlineHotFunctionThreshold = std::stoul(opt.Args());
-        }
-        break;
-      case kInlineModuleGrowth:
-        if (opt.Args().empty()) {
-          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --inline-module-growth\n";
-          exit(1);
-        } else {
-          mpl2mplOption->inlineModuleGrowth = std::stoul(opt.Args());
-        }
-        break;
-      case kInlineColdFunctionThreshold:
-        if (opt.Args().empty()) {
-          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --inline-cold-function-threshold\n";
-          exit(1);
-        } else {
-          mpl2mplOption->inlineColdFunctionThreshold = std::stoul(opt.Args());
-        }
-        break;
-      case kProfileHotCount:
-        if (opt.Args().empty()) {
-          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --profile-hot-count\n";
-          exit(1);
-        } else {
-          mpl2mplOption->profileHotCount = std::stoul(opt.Args());
-        }
-        break;
-      case kProfileColdCount:
-        if (opt.Args().empty()) {
-          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --profile-cold-count\n";
-          exit(1);
-        } else {
-          mpl2mplOption->profileColdCount = std::stoul(opt.Args());
-        }
-        break;
-      case kProfileHotRate:
-        if (opt.Args().empty()) {
-          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --profile-hot-rate\n";
-          exit(1);
-        } else {
-          mpl2mplOption->profileHotRate = std::stoul(opt.Args());
-        }
-        break;
-      case kProfileColdRate:
-        if (opt.Args().empty()) {
-          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --profile-cold-rate\n";
-          exit(1);
-        } else {
-          mpl2mplOption->profileColdRate = std::stoul(opt.Args());
-        }
-        break;
-      case kMpl2MplMapleLinker:
-        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 = (opt.Type() == kEnable);
-        break;
-      case kEmitVtableImpl:
-        mpl2mplOption->emitVtableImpl = (opt.Type() == kEnable);
-        break;
-#if MIR_JAVA
-      case kMpl2MplSkipVirtual:
-        mpl2mplOption->skipVirtualMethod = (opt.Type() == kEnable);
-        break;
-#endif
-      case kMpl2MplNativeOpt:
-        mpl2mplOption->nativeOpt = (opt.Type() == kEnable);
-        break;
-      case kMpl2MplOptL2:
-        // Already handled above in DecideMpl2MplRealLevel
-        break;
-      case kMpl2MplNoDot:
-        mpl2mplOption->noDot = (opt.Type() == kEnable);
-        break;
-      case kGenIRProfile:
-        mpl2mplOption->genIRProfile = (opt.Type() == kEnable);
-        break;
-      case kTestCase:
-        mpl2mplOption->testCase = (opt.Type() == kEnable);
-        break;
-      default:
-        WARN(kLncWarn, "input invalid key for mpl2mpl " + opt.OptionKey());
-        break;
-    }
+  bool result = mpl2mplOption.SolveOptions(it->second,
+                                           options.HasSetDebugFlag());
+  if (result == false) {
+    LogInfo::MapleLogger() << "Meet error mpl2mpl options\n";
+    return false;
   }
-  return mpl2mplOption;
+  return true;
 }
 
 ErrorCode MapleCombCompiler::Compile(const MplOptions &options, MIRModulePtr &theModule) {
   MemPool *optMp = memPoolCtrler.NewMemPool("maplecomb mempool");
   std::string fileName = GetInputFileName(options);
   theModule = new MIRModule(fileName);
-  std::unique_ptr<MeOption> meOptions;
-  std::unique_ptr<Options> mpl2mplOptions;
+  MeOption &meOptions = MeOption::GetInstance();
+  Options &mpl2mplOptions = Options::GetInstance();
   auto it = std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(), kBinNameMe);
   if (it != options.GetRunningExes().end()) {
-    meOptions.reset(MakeMeOptions(options, *optMp));
+    bool result = MakeMeOptions(options);
+    if (!result) {
+      return kErrorCompileFail;
+    }
   }
   auto iterMpl2Mpl = std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(), kBinNameMpl2mpl);
   if (iterMpl2Mpl != options.GetRunningExes().end()) {
-    mpl2mplOptions.reset(MakeMpl2MplOptions(options, *optMp));
+    bool result = MakeMpl2MplOptions(options);
+    if (!result) {
+      return kErrorCompileFail;
+    }
   }
 
   LogInfo::MapleLogger() << "Starting mpl2mpl&mplme\n";
   PrintCommand(options);
-  DriverRunner runner(theModule, options.GetRunningExes(), mpl2mplOptions.get(), fileName, meOptions.get(),
+  DriverRunner runner(theModule, options.GetRunningExes(), &mpl2mplOptions, fileName, &meOptions,
                       fileName, fileName, optMp,
                       options.HasSetTimePhases(), options.HasSetGenVtableImpl(), options.HasSetGenMeMpl());
   ErrorCode nErr = runner.Run();
diff --git a/src/maple_driver/src/mpl_options.cpp b/src/maple_driver/src/mpl_options.cpp
index 03e20f631c97ad26615a2a7f2081b36c67cc9937..3cf7c6a95a39c206b37edec1246e97195950a915 100644
--- a/src/maple_driver/src/mpl_options.cpp
+++ b/src/maple_driver/src/mpl_options.cpp
@@ -21,1752 +21,35 @@
 #include "mpl_logging.h"
 #include "option_parser.h"
 #include "string_utils.h"
-#include "usages.h"
 #include "version.h"
 #include "default_options.def"
-
-namespace {
-using namespace maple;
-const mapleOption::Descriptor usages[] = {
-  // index, type , shortOption , longOption, connector, isCanAppend, delimiter, enableBuildType, checkPolicy, help,
-  // extra
-  { kUnknown,
-    0,
-    nullptr,
-    nullptr,
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "USAGE: maple [options]\n\n Options:",
-    "all",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kHelp,
-    0,
-    "h",
-    "help",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyOptional,
-    "  -h --help [command]         \tPrint usage and exit.\n",
-    "all",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kVersion,
-    0,
-    nullptr,
-    "version",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyOptional,
-    "  --version [command]         \tPrint version and exit.\n",
-    "all",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kInFile,
-    0,
-    nullptr,
-    "infile",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --infile file1,file2,file3  \tInput files.\n",
-    "all",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kInMplt,
-    0,
-    nullptr,
-    "mplt",
-    "=",
-    true,
-    ",",
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --mplt=file1,file2,file3    \tImport mplt files.\n",
-    "all",
-    { { "jbc2mpl", "-mplt", " ", nullptr },
-      // End
-      { nullptr, nullptr, nullptr, nullptr } } },
-  { kOptimization0,
-    0,
-    "O0",
-    nullptr,
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  -O0                         \tNo optimization.\n",
-    "all",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kOptimization2,
-    0,
-    "O2",
-    nullptr,
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  -O2                         \tDo more optimization. (Default)\n",
-    "all",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMeOpt,
-    0,
-    nullptr,
-    "me-opt",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --me-opt                    \tSet options for me\n",
-    "all",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMpl2MplOpt,
-    0,
-    nullptr,
-    "mpl2mpl-opt",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --mpl2mpl-opt               \tSet options for mpl2mpl\n",
-    "all",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kSaveTemps,
-    0,
-    nullptr,
-    "save-temps",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --save-temps                \tDo not delete intermediate files.\n"
-    "                              \t--save-temps Save all intermediate files.\n"
-    "                              \t--save-temps=file1,file2,file3 Save the\n"
-    "                              \ttarget files.\n",
-    "all",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kRun,
-    0,
-    nullptr,
-    "run",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeDebug,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --run=cmd1:cmd2             \tThe name of executables that are going\n"
-    "                              \tto execute. IN SEQUENCE.\n"
-    "                              \tSeparated by \":\".Available exe names:\n"
-    "                              \tjbc2mpl, me, mpl2mpl, mplcg\n"
-    "                              \tInput file must match the tool can\n"
-    "                              \thandle\n",
-    "all",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kOption,
-    0,
-    nullptr,
-    "option",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeDebug,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --option=\"opt1:opt2\"      \tOptions for each executable,\n"
-    "                              \tseparated by \":\".\n"
-    "                              \tThe sequence must match the sequence in\n"
-    "                              \t--run.\n",
-    "all",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kTimePhases,
-    0,
-    "time-phases",
-    nullptr,
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  -time-phases                \tTiming phases and print percentages\n",
-    "all",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kGenMeMpl,
-    0,
-    nullptr,
-    "genmempl",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --genmempl                  \tGenerate me.mpl file\n",
-    "all",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kGenVtableImpl,
-    0,
-    nullptr,
-    "genVtableImpl",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --genVtableImpl             \tGenerate VtableImpl.mpl file\n",
-    "all",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kVerify,
-    0,
-    nullptr,
-    "verify",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --verify                    \tVerify mpl file\n",
-    "all",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kAllDebug,
-    0,
-    nullptr,
-    "debug",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --debug                     \tPrint debug info.\n",
-    "all",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  // jbc2mpl
-  { kUseStringFactory,
-    0,
-    nullptr,
-    "use-string-factory",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  -use-string-factory         \tReplace String.<init> by StringFactory call\n",
-    "jbc2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kJbc2mplOutMpl,
-    0,
-    "o",
-    "out",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeDebug,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  -o, -out=output.mpl         \toutput mpl name\n",
-    "jbc2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  // me
-  { kMeHelp,
-    0,
-    "h-me",
-    "help-me",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyOptional,
-    "  -h-me --help-me             \tPrint usage and exit.Available command names:\n"
-    "                              \tme\n",
-    "all",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMeOptL1,
-    0,
-    nullptr,
-    "O1",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyOptional,
-    "  -O1                         \tDo some optimization.\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMeOptL2,
-    0,
-    nullptr,
-    "O2",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyOptional,
-    "  -O2                         \tDo some optimization.\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMeRange,
-    0,
-    nullptr,
-    "range",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --range                     \tOptimize only functions in the range [NUM0, NUM1]\n"
-    "                              \t--range=NUM0,NUM1\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMeDumpPhases,
-    0,
-    nullptr,
-    "dump-phases",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --dump-phases               \tEnable debug trace for specified phases in the comma separated list\n"
-    "                              \t--dump-phases=PHASENAME,...\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMeSkipPhases,
-    0,
-    nullptr,
-    "skip-phases",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --skip-phases               \tSkip the phases specified in the comma separated list\n"
-    "                              \t--skip-phases=PHASENAME,...\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMeDumpFunc,
-    0,
-    nullptr,
-    "dump-func",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --dump-func                 \tDump/trace only for functions whose names contain FUNCNAME as substring\n"
-    "                              \t(can only specify once)\n"
-    "                              \t--dump-func=FUNCNAME\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMeQuiet,
-    kEnable,
-    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",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMeNoDot,
-    kEnable,
-    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",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kSetCalleeHasSideEffect,
-    kEnable,
-    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",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kNoSteensgaard,
-    kEnable,
-    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",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kNoTBAA,
-    kEnable,
-    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",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kAliasAnalysisLevel,
-    0,
-    nullptr,
-    "aliasAnalysisLevel",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --aliasAnalysisLevel        \tSet level of alias analysis. \n"
-    "                              \t0: most conservative;\n"
-    "                              \t1: Steensgaard-style alias analysis; 2: type-based alias analysis;\n"
-    "                              \t3: Steensgaard-style and type-based alias analysis\n"
-    "                              \t--aliasAnalysisLevel=NUM\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kStmtNum,
-    kEnable,
-    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",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kRcLower,
-    kEnable,
-    nullptr,
-    "rclower",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --rclower                   \tEnable rc lowering\n"
-    "  --no-rclower                \tDisable rc lowering\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMeDumpBefore,
-    kEnable,
-    nullptr,
-    "dump-before",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --dump-before               \tDo extra IR dump before the specified phase in me\n"
-    "  --no-dump-before            \tDon't extra IR dump before the specified phase in me\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMeDumpAfter,
-    kEnable,
-    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",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kEpreLimit,
-    0,
-    nullptr,
-    "eprelimit",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --eprelimit                 \tApply EPRE optimization only for the first NUM expressions\n"
-    "                              \t--eprelimit=NUM\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kEprepuLimit,
-    0,
-    nullptr,
-    "eprepulimit",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --eprepulimit               \tApply EPRE optimization only for the first NUM PUs\n"
-    "                              \t--eprepulimit=NUM\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kStmtPrepuLimit,
-    0,
-    nullptr,
-    "stmtprepulimit",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --stmtprepulimit            \tApply STMTPRE optimization only for the first NUM PUs\n"
-    "                              \t--stmtprepulimit=NUM\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kLpreLimit,
-    0,
-    nullptr,
-    "lprelimit",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --lprelimit                 \tApply LPRE optimization only for the first NUM variables\n"
-    "                              \t--lprelimit=NUM\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kLprepulLimit,
-    0,
-    nullptr,
-    "lprepulimit",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --lprepulimit               \tApply LPRE optimization only for the first NUM PUs\n"
-    "                              \t--lprepulimit=NUM\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kPregreNameLimit,
-    0,
-    nullptr,
-    "pregrenamelimit",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --pregrenamelimit           \tApply Preg Renaming optimization only up to NUM times\n"
-    "                              \t--pregrenamelimit=NUM\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kDelrcpuLimit,
-    0,
-    nullptr,
-    "delrcpulimit",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --delrcpulimit              \tApply DELEGATERC optimization only for the first NUM PUs\n"
-    "                              \t--delrcpulimit=NUM\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kEpreIncludeRef,
-    kEnable,
-    nullptr,
-    "epreincluderef",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --epreincluderef            \tInclude ref-type expressions when performing epre optimization\n"
-    "  --no-epreincluderef         \tDon't include ref-type expressions when performing epre optimization\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kEpreLocalRefVar,
-    kEnable,
-    nullptr,
-    "eprelocalrefvar",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --eprelocalrefvar           \tThe EPRE phase will create new localrefvars when appropriate\n"
-    "  --no-eprelocalrefvar        \tDisable the EPRE phase create new localrefvars when appropriate\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kEprelhSivar,
-    kEnable,
-    nullptr,
-    "eprelhsivar",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --eprelhsivar               \tThe EPRE phase will consider iassigns when optimizing ireads\n"
-    "  --no-eprelhsivar            \tDisable the EPRE phase consider iassigns when optimizing ireads\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kLessThrowAlias,
-    kEnable,
-    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",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kNodeLegateRc,
-    kEnable,
-    nullptr,
-    "nodelegaterc",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --nodelegateerc             \tDo not apply RC delegation to local object reference pointers\n"
-    "  --no-nodelegateerc          \tDisable nodelegateerc\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kNocondBasedRc,
-    kEnable,
-    nullptr,
-    "nocondbasedrc",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --nocondbasedrc             \tDo not apply condition-based RC optimization to\n"
-    "                              \tlocal object reference pointers\n"
-    "  --no-nocondbasedrc          \tDisable nocondbasedrc\n",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kRegReadAtReturn,
-    kEnable,
-    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",
-    "me",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  // mpl2mpl
-  { kMpl2MplHelp,
-    0,
-    "h-mpl2mpl",
-    "help-mpl2mpl",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyOptional,
-    "  -h-mpl2mpl --help-mpl2mpl   \tPrint usage and exit.Available command names:\n"
-    "                              \tmpl2mpl\n",
-    "all",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMpl2MplDumpPhase,
-    0,
-    nullptr,
-    "dump-phase",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --dump-phase                \tEnable debug trace for specified phase (can only specify once)\n"
-    "                              \t--dump-phase=PHASENAME\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMpl2MplSkipPhase,
-    0,
-    nullptr,
-    "skip-phase",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --skip-phase                \tSkip the phase when adding it to phase manager\n"
-    "                              \t--skip-phase=PHASENAME\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMpl2MplSkipFrom,
-    0,
-    nullptr,
-    "skip-from",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --skip-from                 \tSkip all remaining phases including PHASENAME\n"
-    "                              \t--skip-from=PHASENAME\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMpl2MplSkipAfter,
-    0,
-    nullptr,
-    "skip-after",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --skip-after                \tSkip all remaining phases after PHASENAME\n"
-    "                              \t--skip-after=PHASENAME\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMpl2MplDumpFunc,
-    0,
-    nullptr,
-    "dump-func",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --dump-func                 \tDump/trace only for functions whose names contain FUNCNAME as substring\n"
-    "                              \t(can only specify once)\n"
-    "                              \t--dump-func=FUNCNAME\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMpl2MplQuiet,
-    kEnable,
-    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",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMpl2MplMapleLinker,
-    kEnable,
-    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",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMpl2MplStubJniFunc,
-    kEnable,
-    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",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kInlineWithProfile,
-    kEnable,
-    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",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMpl2MplUseInline,
-    kEnable,
-    nullptr,
-    "inline",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --inline                    \tEnable function inlining\n"
-    "  --no-inline                 \tDisable function inlining\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMpl2MplNoInlineFuncList,
-    0,
-    nullptr,
-    "no-inlinefunclist",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --no-inlinefunclist=list    \tDo not inline function in this list\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMpl2MplUseCrossModuleInline,
-    kEnable,
-    nullptr,
-    "cross-module-inline",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --cross-module-inline       \tEnable cross-module inlining\n"
-    "  --no-cross-module-inline    \tDisable cross-module inlining\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kInlineSmallFunctionThreshold,
-    0,
-    nullptr,
-    "inline-small-function-threshold",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --inline-small-function-threshold=15            \tThreshold for inlining small function\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kInlineHotFunctionThreshold,
-    0,
-    nullptr,
-    "inline-hot-function-threshold",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --inline-hot-function-threshold=30              \tThreshold for inlining hot function\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kInlineModuleGrowth,
-    0,
-    nullptr,
-    "inline-module-growth",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --inline-module-growth=100000                   \tThreshold for maxmium code size growth rate (10%)\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kInlineColdFunctionThreshold,
-    0,
-    nullptr,
-    "inline-cold-function-threshold",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --inline-cold-function-threshold=3              \tThreshold for inlining hot function\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kProfileHotCount,
-    0,
-    nullptr,
-    "profile-hot-count",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --profile-hot-count=1000    \tA count is regarded as hot if it exceeds this number\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kProfileColdCount,
-    0,
-    nullptr,
-    "profile-cold-count",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --profile-cold-count=10     \tA count is regarded as cold if it is below this number\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kProfileHotRate,
-    0,
-    nullptr,
-    "profile-hot-rate",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --profile-hot-rate=500000   \tA count is regarded as hot if it is in the largest 50%\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kProfileColdRate,
-    0,
-    nullptr,
-    "profile-cold-rate",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --profile-cold-rate=900000  \tA count is regarded as cold if it is in the smallest 10%\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kNativeWrapper,
-    kEnable,
-    nullptr,
-    "nativewrapper",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --nativewrapper             \tGenerate native wrappers [default]\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kRegNativeDynamicOnly,
-    kEnable,
-    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",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kRegNativeStaticBindingList,
-    0,
-    nullptr,
-    "static-binding-list",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --static-bindig-list        \tOnly Generate static binding function in file configure list\n"
-    "                              \t--static-bindig-list=file\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMpl2MplDumpBefore,
-    kEnable,
-    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",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMpl2MplDumpAfter,
-    kEnable,
-    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",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMplnkDumpMuid,
-    kEnable,
-    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",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kEmitVtableImpl,
-    kEnable,
-    nullptr,
-    "emitVtableImpl",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --emitVtableImpl            \tgenerate VtableImpl file\n"
-    "  --no-emitVtableImpl         \tDon't generate VtableImpl file\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-#if MIR_JAVA
-  { kMpl2MplSkipVirtual,
-    kEnable,
-    nullptr,
-    "skipvirtual",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --skipvirtual\n"
-    "  --no-skipvirtual\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
+#include "driver_option_common.h"
+#ifndef EMUI_BUILD
+#include "jbc2mpl_option.h"
 #endif
-  { kMpl2MplNativeOpt,
-    kEnable,
-    nullptr,
-    "nativeopt",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --nativeopt                 \tEnable native opt\n"
-    "  --no-nativeopt              \tDisable native opt\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMpl2MplOptL2,
-    0,
-    nullptr,
-    "O2",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyOptional,
-    "  -O2                         \tDo some optimization.\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kMpl2MplNoDot,
-    kEnable,
-    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",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kGenIRProfile,
-    kEnable,
-    nullptr,
-    "ir-profile-gen",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --ir-profile-gen              \tGen IR level Profile\n"
-    "  --no-ir-profile-gen           \tDisable Gen IR level Profile\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kTestCase,
-    kEnable,
-    nullptr,
-    "testcase",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --testcase              \tTest Case\n"
-    "  --no-testcase           \tDisable Test Case\n",
-    "mpl2mpl",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  // mplcg
-  { kPie,
-    kEnable,
-    nullptr,
-    "pie",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --pie                       \tGenerate position-independent executable\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kPic,
-    kEnable,
-    nullptr,
-    "fpic",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --fpic                      \tGenerate position-independent shared library\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kVerbose,
-    kEnable,
-    nullptr,
-    "verbose-asm",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --verbose-asm               \tAdd comments to asm output\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGMapleLinker,
-    kEnable,
-    nullptr,
-    "maplelinker",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --maplelinker               \tGenerate the MapleLinker .s format\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGQuiet,
-    kEnable,
-    nullptr,
-    "quiet",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --quiet                     \tBe quiet (don't output debug messages)\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGHelp,
-    0,
-    "h-mplcg",
-    "help-mplcg",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyOptional,
-    "  -h-mplcg --help-mplcg       \tPrint usage and exit.Available command names:\n"
-    "                              \tmplcg\n",
-    "all",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCgen,
-    kEnable,
-    nullptr,
-    "cg",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --cg                        \tGenerate the output .s file\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGLazyBinding,
-    kEnable,
-    nullptr,
-    "lazy-binding",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --lazy-binding              \tBind class symbols lazily[default off]\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGHotFix,
-    kEnable,
-    nullptr,
-    "hot-fix",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --hot-fix                   \tOpen for App hot fix[default off]\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGNativeOpt,
-    kEnable,
-    nullptr,
-    "nativeopt",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --nativeopt                 \tEnable native opt\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kObjMap,
-    kEnable,
-    nullptr,
-    "objmap",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --objmap                    \tCreate object maps (GCTIBs) inside the main output (.s) file\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kYieldPoing,
-    kEnable,
-    nullptr,
-    "yieldpoint",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --yieldpoint                \tGenerate yieldpoints [default]\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kProepilogue,
-    kEnable,
-    nullptr,
-    "proepilogue",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --proepilogue               \tDo tail call optimization and eliminate unnecessary prologue and epilogue.\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kLocalRc,
-    kEnable,
-    nullptr,
-    "local-rc",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --local-rc                  \tHandle Local Stack RC [default]\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kInsertCall,
-    0,
-    nullptr,
-    "insert-call",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --insert-call=name          \tInsert a call to the named function\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kTrace,
-    0,
-    nullptr,
-    "add-debug-trace",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --add-debug-trace           \tInstrument the output .s file to print call traces at runtime\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGClassList,
-    0,
-    nullptr,
-    "class-list-file",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --class-list-file           \tSet the class list file for the following generation options,\n"
-    "                              \tif not given, generate for all visible classes\n"
-    "                              \t--class-list-file=class_list_file\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kGenDef,
-    kEnable,
-    nullptr,
-    "gen-c-macro-def",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --gen-c-macro-def           \tGenerate a .def file that contains extra type metadata, including the\n"
-    "                              \tclass instance sizes and field offsets (default)\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kGenGctib,
-    kEnable,
-    nullptr,
-    "gen-gctib-file",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --gen-gctib-file            \tGenerate a separate .s file for GCTIBs. Usually used together with\n"
-    "                              \t--no-objmap (not implemented yet)\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kStackGuard,
-    kEnable,
-    nullptr,
-    "stackguard",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  -stackguard                 \tadd stack guard\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kDebuggingInfo,
-    0,
-    "g",
-    nullptr,
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  -g                          \tGenerate debug information\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kDebugGenDwarf,
-    0,
-    nullptr,
-    "gdwarf",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --gdwarf                    \tGenerate dwarf infomation\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kDebugUseSrc,
-    0,
-    nullptr,
-    "gsrc",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --gsrc                      \tUse original source file instead of mpl file for debugging\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kDebugUseMix,
-    0,
-    nullptr,
-    "gmixedsrc",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --gmixedsrc                 \tUse both original source file and mpl file for debugging\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kDebugAsmMix,
-    0,
-    nullptr,
-    "gmixedasm",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --gmixedasm                 \tComment out both original source file and mpl file for debugging\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kRaColor,
-    0,
-    nullptr,
-    "with-ra-graph-color",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --with-ra-graph-color       \tDo coloring-based register allocation\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kConstFoldOpt,
-    0,
-    nullptr,
-    "const-fold",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --const-fold                \tEnable constant folding\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kEhList,
-    0,
-    nullptr,
-    "eh-exclusive-list",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --eh-exclusive-list         \tFor generating gold files in unit testing\n"
-    "                              \t--eh-exclusive-list=list_file\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGO0,
-    0,
-    nullptr,
-    "O0",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  -O0                         \tNo optimization.\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGO1,
-    0,
-    nullptr,
-    "O1",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyOptional,
-    "  -O1                         \tDo some optimization.\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGO2,
-    0,
-    nullptr,
-    "O2",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyOptional,
-    "  -O2                          \tDo some optimization.\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kSuppressFinfo,
-    0,
-    nullptr,
-    "suppress-fileinfo",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --suppress-fileinfo         \tFor generating gold files in unit testing\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGDumpcfg,
-    0,
-    nullptr,
-    "dump-cfg",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --dump-cfg\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGDumpPhases,
-    0,
-    nullptr,
-    "dump-phases",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --dump-phases=PHASENAME,... \tEnable debug trace for specified phases in the comma separated list\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGSkipPhases,
-    0,
-    nullptr,
-    "skip-phases",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --skip-phases=PHASENAME,... \tSkip the phases specified in the comma separated list\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGSkipFrom,
-    0,
-    nullptr,
-    "skip-from",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --skip-from=PHASENAME       \tSkip the rest phases from PHASENAME(included)\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGSkipAfter,
-    0,
-    nullptr,
-    "skip-after",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --skip-after=PHASENAME      \tSkip the rest phases after PHASENAME(excluded)\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGDumpFunc,
-    0,
-    nullptr,
-    "dump-func",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --dump-func=FUNCNAME        \tDump/trace only for functions whose names contain FUNCNAME as substring\n"
-    "                              \t(can only specify once)\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGDumpBefore,
-    kEnable,
-    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",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGDumpAfter,
-    kEnable,
-    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",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGTimePhases,
-    kEnable,
-    nullptr,
-    "time-phases",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --time-phases               \tCollect compilation time stats for each phase\n"
-    "  --no-time-phases            \tDon't Collect compilation time stats for each phase\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCGBarrier,
-    kEnable,
-    nullptr,
-    "use-barriers-for-volatile",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --use-barriers-for-volatile \tOptimize volatile load/str\n"
-    "  --no-use-barriers-for-volatile\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCalleeCFI,
-    kEnable,
-    nullptr,
-    "callee-cfi",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --callee-cfi                \tcallee cfi message will be generated\n"
-    "  --no-callee-cfi             \tcallee cfi message will not be generated\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kPrintFunction,
-    kEnable,
-    nullptr,
-    "print-func",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --print-func\n"
-    "  --no-print-func\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kProfileData,
-    0,
-    nullptr,
-    "profile_data",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --profile_data              \tuse profile info to sort funcbody and class static field\n"
-    "                              \t--profile_data=FUNCINFOFILE[:]CLASSINFOFILE\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCyclePatternList,
-    0,
-    nullptr,
-    "cycle-pattern-list",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --cycle-pattern-list        \tFor generating cycle pattern meta\n"
-    "                              \t--cycle-pattern-list=list_file\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kDuplicateToDelPlt,
-    0,
-    nullptr,
-    "duplicate_asm_list",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyRequired,
-    "  --duplicate_asm_list        \tDuplicate asm functions to delete plt call\n"
-    "                              \t--duplicate_asm_list=list_file\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kInsertSoe,
-    0,
-    nullptr,
-    "soe-check",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    "  --soe-check                 \tInsert a soe check instruction[default off]\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kCheckArrayStore,
-    kEnable,
-    nullptr,
-    "check-arraystore",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --check-arraystore          \tcheck arraystore exception[default off]\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kLongCalls,
-    kEnable,
-    nullptr,
-    "long-calls",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --long-calls                  \tgenerate long call\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-  { kGcOnly,
-    kEnable,
-    nullptr,
-    "gconly",
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --gconly                     \tEnable GCONLY, generate code without RC\n",
-    "mplcg",
-    { { nullptr, nullptr, nullptr, nullptr } } },
-// End
-
-  { kUnknown,
-    0,
-    nullptr,
-    nullptr,
-    nullptr,
-    false,
-    nullptr,
-    mapleOption::BuildType::kBuildTypeAll,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
-    nullptr,
-    "",
-    { { nullptr, nullptr, nullptr, nullptr } } }
-};
-} // namepsace
+#include "me_option.h"
+#include "option.h"
+#include "cg_option.h"
 
 namespace maple {
 using namespace mapleOption;
+using namespace maplebe;
 
 const std::string kMapleDriverVersion = "MapleDriver " + std::to_string(Version::kMajorMplVersion) + "." +
                                         std::to_string(Version::kMinorCompilerVersion) + " 20190929";
+
+const std::vector<std::string> kMapleCompilers = { "jbc2mpl",
+    "me", "mpl2mpl", "mplcg" };
+
 int MplOptions::Parse(int argc, char **argv) {
-  optionParser.reset(new OptionParser(usages));
+  optionParser.reset(new OptionParser());
+  optionParser->RegisteUsages(DriverOptionCommon::GetInstance());
+#ifndef EMUI_BUILD
+  optionParser->RegisteUsages(jbcUsage);
+#endif
+  optionParser->RegisteUsages(Options::GetInstance());
+  optionParser->RegisteUsages(MeOption::GetInstance());
+  optionParser->RegisteUsages(CGOptions::GetInstance());
   exeFolder = FileUtils::GetFileFolder(*argv);
   int ret = optionParser->Parse(argc, argv);
   if (ret != kErrorNoError) {
@@ -1816,6 +99,12 @@ ErrorCode MplOptions::HandleGeneralOptions() {
   for (auto opt : optionParser->GetOptions()) {
     switch (opt.Index()) {
       case kHelp: {
+        if (!opt.Args().empty()) {
+          if (std::find(kMapleCompilers.begin(), kMapleCompilers.end(), opt.Args()) != kMapleCompilers.end()) {
+            optionParser->PrintUsage(opt.Args());
+            return kErrorExitHelp;
+          }
+        }
         optionParser->PrintUsage("all");
         return kErrorExitHelp;
       }
@@ -1835,15 +124,6 @@ ErrorCode MplOptions::HandleGeneralOptions() {
           return ret;
         }
         break;
-      case kMeHelp:
-        optionParser->PrintUsage(kBinNameMe);
-        return kErrorExitHelp;
-      case kMpl2MplHelp:
-        optionParser->PrintUsage(kBinNameMpl2mpl);
-        return kErrorExitHelp;
-      case kCGHelp:
-        optionParser->PrintUsage(kBinNameMplcg);
-        return kErrorExitHelp;
       case kMplcgOpt:
         ret = UpdatePhaseOption(opt.Args(), kBinNameMplcg);
         if (ret != kErrorNoError) {
@@ -1862,10 +142,6 @@ ErrorCode MplOptions::HandleGeneralOptions() {
         genVtableImpl = true;
         printCommandStr += " --genVtableImpl";
         break;
-      case kVerify:
-        verify = true;
-        printCommandStr += " --verify";
-        break;
       case kSaveTemps:
         isSaveTmps = true;
         genMeMpl = true;
@@ -2018,15 +294,23 @@ ErrorCode MplOptions::AddOption(const mapleOption::Option &option) {
   if (!option.HasExtra()) {
     return kErrorNoError;
   }
-  for (const auto &extra : option.GetExtras()) {
-    auto iter = std::find(runningExes.begin(), runningExes.end(), extra.exeName);
+  for (const auto &exeName : option.GetExtras()) {
+    auto iter = std::find(runningExes.begin(), runningExes.end(), exeName);
     if (iter == runningExes.end()) {
       continue;
     }
-    // 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);
+    // For compilers, such as me, mpl2mpl
+    exeOptions[exeName].push_back(option);
+    // Fill extraOption
+    // For compiler bins called by system()
+    auto &extraOption = extras[exeName];
+    if (option.Args() != "") {
+      MplOption mplOption("-" + option.OptionKey(), option.Args());
+      extraOption.push_back(mplOption);
+    } else {
+      MplOption mplOption("-" + option.OptionKey(), "");
+      extraOption.push_back(mplOption);
+    }
   }
   return kErrorNoError;
 }
@@ -2061,20 +345,6 @@ bool MplOptions::Init(const std::string &inputFile) {
   return true;
 }
 
-std::string MplOptions::OptimizationLevelStr() const {
-  switch (optimizationLevel) {
-    case OptimizationLevel::kO0: {
-      return "-O0";
-    }
-    case OptimizationLevel::kO1: {
-      return "-O1";
-    }
-    case OptimizationLevel::kO2: {
-      return "-O2";
-    }
-  }
-}
-
 ErrorCode MplOptions::AppendDefaultCombOptions() {
   ErrorCode ret = kErrorNoError;
   if (optimizationLevel == kO0) {
@@ -2153,10 +423,10 @@ ErrorCode MplOptions::UpdatePhaseOption(const std::string &args, const std::stri
   auto &extraOption = extras[exeName];
   for (size_t i = 0; i < exeOption.size(); ++i) {
     if (exeOption[i].Args() != "") {
-      MplOption mplOption("-" + exeOption[i].OptionKey(), exeOption[i].Args(), "=", false, "");
+      MplOption mplOption("-" + exeOption[i].OptionKey(), exeOption[i].Args());
       extraOption.push_back(mplOption);
     } else {
-      MplOption mplOption("-" + exeOption[i].OptionKey(), "", " ", false, "");
+      MplOption mplOption("-" + exeOption[i].OptionKey(), "");
       extraOption.push_back(mplOption);
     }
   }
diff --git a/src/maple_driver/src/mplcg_compiler.cpp b/src/maple_driver/src/mplcg_compiler.cpp
index a5faf4a4c15fe34f6f19effd32fb621a1590ddab..449b1e06384c6e6243fc3bedd55e001ec698737d 100644
--- a/src/maple_driver/src/mplcg_compiler.cpp
+++ b/src/maple_driver/src/mplcg_compiler.cpp
@@ -16,7 +16,6 @@
 #include "compiler.h"
 #include "default_options.def"
 #include "mpl_logging.h"
-#include "usages.h"
 #include "driver_runner.h"
 
 namespace maple {
@@ -79,263 +78,29 @@ void MplcgCompiler::PrintCommand(const MplOptions &options) const {
                          << " --infile " << GetInputFileName(options) << '\n';
 }
 
-void MplcgCompiler::DecideMplcgRealLevel(CGOptions &cgOption,
-                                         const std::vector<mapleOption::Option> &inputOptions,
-                                         const MplOptions &options) {
-  int realLevel = -1;
-  for (const mapleOption::Option &opt : inputOptions) {
-    switch (opt.Index()) {
-      case kCGO0:
-        realLevel = CGOptions::kLevel0;
-        break;
-      case kCGO1:
-        realLevel = CGOptions::kLevel1;
-        break;
-      case kCGO2:
-        realLevel = CGOptions::kLevel2;
-        break;
-      default:
-        break;
-    }
-  }
-  if (options.HasSetDebugFlag()) {
-    LogInfo::MapleLogger() << "Real Mplcg level:" << std::to_string(realLevel) << "\n";
-  }
-  if (realLevel ==  CGOptions::kLevel0) {
-    cgOption.EnableO0();
-  } else if (realLevel ==  CGOptions::kLevel1) {
-    cgOption.EnableO1();
-  } else if (realLevel ==  CGOptions::kLevel2) {
-    cgOption.EnableO2();
-  }
-}
-
-CGOptions *MplcgCompiler::MakeCGOptions(const MplOptions &options, MemPool &optMp) {
-  auto *cgOption = new CGOptions(optMp);
-  cgOption->SetOption(CGOptions::kDefaultOptions);
-  cgOption->SetOption(CGOptions::kWithMpl);
-  cgOption->SetGenerateFlags(CGOptions::kDefaultGflags);
+bool MplcgCompiler::MakeCGOptions(const MplOptions &options) {
+  CGOptions &cgOption = CGOptions::GetInstance();
+  cgOption.SetOption(CGOptions::kDefaultOptions);
+  cgOption.SetOption(CGOptions::kWithMpl);
+  cgOption.SetGenerateFlags(CGOptions::kDefaultGflags);
   auto it = options.GetExeOptions().find(kBinNameMplcg);
   if (it == options.GetExeOptions().end()) {
     LogInfo::MapleLogger() << "no me input options\n";
-    return cgOption;
+    return false;
   }
-  DecideMplcgRealLevel(*cgOption, it->second, options);
-  for (const mapleOption::Option &opt : it->second) {
-    if (options.HasSetDebugFlag()) {
-      LogInfo::MapleLogger() << "mplcg options: " << opt.Index() << " " << opt.OptionKey() << " " << opt.Args()
-                             << '\n';
-    }
-    switch (opt.Index()) {
-      case kCGQuiet:
-        cgOption->SetQuiet((opt.Type() == kEnable));
-        break;
-      case kPie:
-        (opt.Type() == kEnable) ? cgOption->SetOption(CGOptions::kGenPie)
-                                : cgOption->ClearOption(CGOptions::kGenPie);
-        break;
-      case kPic: {
-        if (opt.Type() == kEnable) {
-          cgOption->EnablePIC();
-          cgOption->SetOption(CGOptions::kGenPic);
-        } else {
-          cgOption->DisablePIC();
-          cgOption->ClearOption(CGOptions::kGenPic);
-        }
-        break;
-      }
-      case kVerbose:
-        (opt.Type() == kEnable) ? cgOption->SetOption(CGOptions::kVerboseAsm)
-                                : cgOption->ClearOption(CGOptions::kVerboseAsm);
-        break;
-      case kCGMapleLinker:
-        (opt.Type() == kEnable) ? cgOption->EnableMapleLinker() : cgOption->DisableMapleLinker();
-        break;
-      case kCGBarrier:
-        (opt.Type() == kEnable) ? cgOption->EnableBarriersForVolatile() : cgOption->DisableBarriersForVolatile();
-        break;
-      case kCGDumpBefore:
-        (opt.Type() == kEnable) ? cgOption->EnableDumpBefore() : cgOption->DisableDumpBefore();
-        break;
-      case kCGDumpAfter:
-        (opt.Type() == kEnable) ? cgOption->EnableDumpAfter() : cgOption->DisableDumpAfter();
-        break;
-      case kCGTimePhases:
-        (opt.Type() == kEnable) ? cgOption->EnableTimePhases() : cgOption->DisableTimePhases();
-        break;
-      case kCGDumpFunc:
-        cgOption->SetDumpFunc(opt.Args());
-        break;
-      case kDuplicateToDelPlt:
-        cgOption->SetDuplicateAsmFile(opt.Args());
-        break;
-      case kInsertCall:
-        cgOption->SetInstrumentationFunction(opt.Args());
-        cgOption->SetInsertCall(true);
-        break;
-      case kStackGuard:
-        cgOption->SetOption(cgOption->kUseStackGuard);
-        break;
-      case kDebuggingInfo:
-        cgOption->SetOption(cgOption->kDebugFriendly);
-        cgOption->SetOption(cgOption->kWithLoc);
-        cgOption->ClearOption(cgOption->kSuppressFileInfo);
-        break;
-      case kDebugGenDwarf:
-        cgOption->SetOption(cgOption->kDebugFriendly);
-        cgOption->SetOption(cgOption->kWithLoc);
-        cgOption->SetOption(cgOption->kWithDwarf);
-        cgOption->SetParserOption(kWithDbgInfo);
-        cgOption->ClearOption(cgOption->kSuppressFileInfo);
-        cgOption->EnableWithDwarf();
-        break;
-      case kDebugUseSrc:
-        cgOption->SetOption(cgOption->kDebugFriendly);
-        cgOption->SetOption(cgOption->kWithLoc);
-        cgOption->SetOption(cgOption->kWithSrc);
-        cgOption->ClearOption(cgOption->kWithMpl);
-        break;
-      case kDebugUseMix:
-        cgOption->SetOption(cgOption->kDebugFriendly);
-        cgOption->SetOption(cgOption->kWithLoc);
-        cgOption->SetOption(cgOption->kWithSrc);
-        cgOption->SetOption(cgOption->kWithMpl);
-        break;
-      case kDebugAsmMix:
-        cgOption->SetOption(cgOption->kDebugFriendly);
-        cgOption->SetOption(cgOption->kWithLoc);
-        cgOption->SetOption(cgOption->kWithSrc);
-        cgOption->SetOption(cgOption->kWithMpl);
-        cgOption->SetOption(cgOption->kWithAsm);
-        break;
-      case kProfilingInfo:
-        cgOption->SetOption(cgOption->kWithProfileCode);
-        cgOption->SetParserOption(kWithProfileInfo);
-        break;
-      case kRaColor:
-        cgOption->SetOption(cgOption->kDoColorRegAlloc);
-        cgOption->ClearOption(cgOption->kDoLinearScanRegAlloc);
-        break;
-      case kPrintFunction:
-        (opt.Type() == kEnable) ? cgOption->EnablePrintFunction() : cgOption->DisablePrintFunction();
-        break;
-      case kTrace:
-        cgOption->SetOption(cgOption->kAddDebugTrace);
-        break;
-      case kProfileEnable:
-        cgOption->SetOption(cgOption->kAddFuncProfile);
-        break;
-      case kSuppressFinfo:
-        cgOption->SetOption(cgOption->kSuppressFileInfo);
-        break;
-      case kConstFoldOpt:
-        cgOption->SetOption(cgOption->kConstFold);
-        break;
-      case kCGDumpcfg:
-        cgOption->SetOption(cgOption->kDumpCFG);
-        break;
-      case kCGClassList:
-        cgOption->SetClassListFile(opt.Args());
-        break;
-      case kGenDef:
-        cgOption->SetOrClear(cgOption->GetGenerateFlags(), CGOptions::kCMacroDef, opt.Type());
-        break;
-      case kGenGctib:
-        cgOption->SetOrClear(cgOption->GetGenerateFlags(), CGOptions::kGctib, opt.Type());
-        break;
-      case kGenPrimorList:
-        cgOption->SetOrClear(cgOption->GetGenerateFlags(), CGOptions::kPrimorList, opt.Type());
-        break;
-      case kYieldPoing:
-        cgOption->SetOrClear(cgOption->GetGenerateFlags(), CGOptions::kGenYieldPoint, opt.Type());
-        break;
-      case kLocalRc:
-        cgOption->SetOrClear(cgOption->GetGenerateFlags(), CGOptions::kGenLocalRc, opt.Type());
-        break;
-      case kEhList: {
-        const std::string &ehList = opt.Args();
-        cgOption->SetEHExclusiveFile(ehList);
-        cgOption->EnableExclusiveEH();
-        cgOption->ParseExclusiveFunc(ehList);
-        break;
-      }
-      case kCyclePatternList: {
-        const std::string &patternList = opt.Args();
-        cgOption->SetCyclePatternFile(patternList);
-        cgOption->EnableEmitCyclePattern();
-        cgOption->ParseCyclePattern(patternList);
-        break;
-      }
-      case kCgen: {
-        bool cgFlag = (opt.Type() == kEnable);
-        cgOption->SetRunCGFlag(cgFlag);
-        cgFlag ? cgOption->SetOption(CGOptions::kDoCg) : cgOption->ClearOption(CGOptions::kDoCg);
-        break;
-      }
-      case kObjMap:
-        cgOption->SetGenerateObjectMap(opt.Type() == kEnable);
-        break;
-      case kCGLazyBinding:
-        (opt.Type() == kEnable) ? cgOption->EnableLazyBinding() : cgOption->DisableLazyBinding();
-        break;
-      case kCGHotFix:
-        (opt.Type() == kEnable) ? cgOption->EnableHotFix() : cgOption->DisableHotFix();
-        break;
-      case kInsertSoe:
-        cgOption->SetOption(CGOptions::kSoeCheckInsert);
-        break;
-      case kCheckArrayStore:
-        (opt.Type() == kEnable) ? cgOption->EnableCheckArrayStore() : cgOption->DisableCheckArrayStore();
-        break;
-      case kCGNativeOpt:
-        cgOption->DisableNativeOpt();
-        break;
-      case kCalleeCFI:
-        (opt.Type() == kEnable) ? cgOption->DisableNoCalleeCFI() : cgOption->EnableNoCalleeCFI();
-        break;
-      case kProepilogue:
-        (opt.Type() == kEnable) ? cgOption->SetOption(CGOptions::kProEpilogueOpt)
-                                : cgOption->ClearOption(CGOptions::kProEpilogueOpt);
-        break;
-      case kCGO0:
-        // Already handled above in DecideMplcgRealLevel
-        break;
-      case kCGO1:
-        // Already handled above in DecideMplcgRealLevel
-        break;
-      case kCGO2:
-        // Already handled above in DecideMplcgRealLevel
-        break;
-      case kCGDumpPhases:
-        cgOption->SplitPhases(opt.Args(), cgOption->GetDumpPhases());
-        break;
-      case kCGSkipPhases:
-        cgOption->SplitPhases(opt.Args(), cgOption->GetSkipPhases());
-        break;
-      case kCGSkipFrom:
-        cgOption->SetSkipFrom(opt.Args());
-        break;
-      case kCGSkipAfter:
-        cgOption->SetSkipAfter(opt.Args());
-        break;
-      case kLongCalls:
-        (opt.Type() == kEnable) ? cgOption->EnableLongCalls() : cgOption->DisableLongCalls();
-        break;
-      case kGcOnly:
-        (opt.Type() == kEnable) ? cgOption->EnableGCOnly() : cgOption->DisableGCOnly();
-        break;
-      default:
-        WARN(kLncWarn, "input invalid key for mplcg " + opt.OptionKey());
-        break;
-    }
+  bool result = cgOption.SolveOptions(it->second, options.HasSetDebugFlag());
+  if (result == false) {
+    LogInfo::MapleLogger() << "Meet error mplcg options\n";
+    return false;
   }
-  return cgOption;
+  return true;
 }
 
 ErrorCode MplcgCompiler::Compile(const MplOptions &options, MIRModulePtr &theModule) {
   MemPool *optMp = memPoolCtrler.NewMemPool("maplecg mempool");
-  std::unique_ptr<CGOptions> cgOption(MakeCGOptions(options, *optMp));
-  if (cgOption == nullptr) {
+  CGOptions &cgOption = CGOptions::GetInstance();
+  bool result = MakeCGOptions(options);
+  if (!result) {
     return kErrorCompileFail;
   }
   std::string fileName = GetInputFileName(options);
@@ -349,9 +114,9 @@ ErrorCode MplcgCompiler::Compile(const MplOptions &options, MIRModulePtr &theMod
         std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(),
                   kBinNameMe) != options.GetRunningExes().end());
     theParser.reset(new MIRParser(*theModule));
-    parsed = theParser->ParseMIR(0, cgOption->GetParserOption());
+    parsed = theParser->ParseMIR(0, cgOption.GetParserOption());
     if (parsed) {
-      if (!cgOption->IsQuiet() && theParser->GetWarning().size()) {
+      if (!cgOption.IsQuiet() && theParser->GetWarning().size()) {
         theParser->EmitWarning(fileName);
       }
     } else {
@@ -366,7 +131,7 @@ ErrorCode MplcgCompiler::Compile(const MplOptions &options, MIRModulePtr &theMod
   LogInfo::MapleLogger() << "Starting mplcg\n";
   DriverRunner runner(theModule, options.GetRunningExes(), fileName, optMp, options.HasSetTimePhases());
   PrintCommand(options);
-  runner.SetCGInfo(cgOption.get(), fileName);
+  runner.SetCGInfo(&cgOption, fileName);
   runner.ProcessCGPhase(output, baseName);
 
   memPoolCtrler.DeleteMemPool(optMp);
diff --git a/src/maple_driver/src/option_parser.cpp b/src/maple_driver/src/option_parser.cpp
index 351f428b3e233b4aeebf99f6d6280ce41658f911..2cbe76e5850ccf109ad78e1ff77149afdaa4d39d 100644
--- a/src/maple_driver/src/option_parser.cpp
+++ b/src/maple_driver/src/option_parser.cpp
@@ -17,46 +17,23 @@
 #include <iostream>
 #include <cstring>
 #include "mpl_logging.h"
+#include "driver_option_common.h"
 
 using namespace maple;
 using namespace mapleOption;
 
-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) {
+  while (index < kMaxExtraOptions && index < usage.extras.size()) {
     Descriptor tempUsage = { usage.index,
                              usage.type,
                              usage.shortOption,
                              usage.longOption,
-                             nullptr,
-                             false,
-                             nullptr,
                              usage.enableBuildType,
                              usage.checkPolicy,
                              usage.help,
-                             usage.extras[index].exeName,
-                             { { nullptr, nullptr, nullptr, nullptr } } };
+                             usage.extras[index].c_str(),
+                             {} };
     if (usage.shortOption != nullptr) {
       InsertOption(std::string(usage.shortOption), tempUsage);
     }
@@ -67,7 +44,6 @@ void OptionParser::InsertExtraUsage(const Descriptor &usage) {
     index++;
   }
 }
-#endif
 
 void OptionParser::CreateNoOption(const Descriptor &usage) {
   std::string longOpt = "";
@@ -87,29 +63,58 @@ void OptionParser::CreateNoOption(const Descriptor &usage) {
                            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
-  };
+                           usage.extras };
   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::RegisteUsages(MapleDriverOptionBase &base) {
+  for (auto &usage : base.GetUsageVec()) {
+    if (usage.help == nullptr) {
+      continue;
+    }
+    rawUsages.push_back(usage);
+    if (usage.shortOption != nullptr) {
+      InsertOption(std::string(usage.shortOption), usage);
+    }
+    if (usage.longOption != nullptr) {
+      InsertOption(std::string(usage.longOption), usage);
+    }
+    // Insert usage for extra options
+    InsertExtraUsage(usage);
+    // Add --no-opt for boolean option
+    if (usage.checkPolicy == kArgCheckPolicyBool) {
+      CreateNoOption(usage);
+    }
+  }
+}
+
+void OptionParser::RegisteUsages(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]);
+    }
+    // Insert usage for extra options
+    InsertExtraUsage(usage[i]);
+    // Add --no-opt for boolean option
+    if (usage[i].checkPolicy == kArgCheckPolicyBool) {
+      CreateNoOption(usage[i]);
+    }
+  }
 }
 
 void OptionParser::PrintUsage() const {
@@ -120,7 +125,6 @@ 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) {
@@ -128,17 +132,11 @@ void OptionParser::PrintUsage(const std::string &helpType) const {
     }
   }
 }
-#endif
 
-#ifdef OPTION_PARSER_EXTRAOPT
+
 bool OptionParser::HandleKeyValue(const std::string &key, const std::string &value, bool isValueEmpty,
                                   std::vector<mapleOption::Option> &inputOption, const std::string &exeName,
                                   bool isAllOption) {
-#else
-bool OptionParser::HandleKeyValue(const std::string &key, const std::string &value, bool isValueEmpty,
-                                  std::vector<mapleOption::Option> &inputOption, const std::string&,
-                                  bool isAllOption) {
-#endif
   if (key.empty()) {
     if (!isAllOption) {
       LogInfo::MapleLogger(kLlErr) << "Cannot recognize " << value << '\n';
@@ -149,12 +147,10 @@ bool OptionParser::HandleKeyValue(const std::string &key, const std::string &val
   }
   size_t count = usages.count(key);
   auto item = usages.find(key);
-#ifdef OPTION_PARSER_EXTRAOPT
   while (count > 0 && item->second.exeName != exeName) {
     ++item;
     --count;
   }
-#endif
   if (count == 0) {
     LogInfo::MapleLogger(kLlErr) << ("Unknown Option: " + key) << '\n';
     return false;
@@ -192,7 +188,6 @@ bool OptionParser::HandleKeyValue(const std::string &key, const std::string &val
   return true;
 }
 
-#ifdef OPTION_PARSER_EXTRAOPT
 bool OptionParser::SetOption(const std::string &rawKey, const std::string &value, const std::string &exeName,
                              std::vector<mapleOption::Option> &exeOption) {
   constexpr char kOptionMark = '-';
@@ -235,7 +230,6 @@ bool OptionParser::SetOption(const std::string &rawKey, const std::string &value
   exeOption.push_back(Option(item->second, key, value));
   return true;
 }
-#endif
 
 bool OptionParser::CheckOpt(const std::string option, std::string &lastKey,
                             bool &isLastMatch, std::vector<mapleOption::Option> &inputOption,
@@ -266,7 +260,7 @@ bool OptionParser::CheckOpt(const std::string option, std::string &lastKey,
 }
 
 ErrorCode OptionParser::HandleInputArgs(const std::vector<std::string> &inputArgs, const std::string &exeName,
-                                        std::vector<mapleOption::Option> &inputOption) {
+                                        std::vector<mapleOption::Option> &inputOption, bool isAllOption) {
   bool isLastMatchOpt = false;
   std::string lastKey = "";
   bool ret = true;
@@ -289,7 +283,6 @@ ErrorCode OptionParser::HandleInputArgs(const std::vector<std::string> &inputArg
       isMatchLongOpt = true;
     }
     std::string arg = inputArgs[i].substr(index);
-    bool isAllOption = (exeName == "all") ? true : false;
     bool isOptMatched = isMatchLongOpt || isMatchShortOpt;
     if (!isLastMatchOpt && isOptMatched) {
       ret = CheckOpt(arg, lastKey, isLastMatchOpt, inputOption, exeName);
@@ -313,17 +306,13 @@ ErrorCode OptionParser::HandleInputArgs(const std::vector<std::string> &inputArg
   return kErrorNoError;
 }
 
-ErrorCode OptionParser::Parse(int argc, char **argv) {
+ErrorCode OptionParser::Parse(int argc, char **argv, const std::string exeName) {
   if (argc > 0) {
     --argc;
     ++argv;  // skip program name argv[0] if present
   }
   if (argc == 0 || *argv == nullptr) {
-#ifdef OPTION_PARSER_EXTRAOPT
-    PrintUsage("all");
-#else
-    PrintUsage();
-#endif
+    PrintUsage(exeName);
     LogInfo::MapleLogger(kLlErr) << "No input files!" << '\n';
     return kErrorInitFail;
   }
@@ -334,6 +323,6 @@ ErrorCode OptionParser::Parse(int argc, char **argv) {
     ++argv;
     --argc;
   }
-  ErrorCode ret = HandleInputArgs(inputArgs, "all", options);
+  ErrorCode ret = HandleInputArgs(inputArgs, exeName, options, true);
   return ret;
 }
diff --git a/src/maple_ipa/BUILD.gn b/src/maple_ipa/BUILD.gn
index 2211cce5297de518bd80904fcb0122992d01fe1d..db21556e27af47d2b92c4109cc124fb24fce2107 100644
--- a/src/maple_ipa/BUILD.gn
+++ b/src/maple_ipa/BUILD.gn
@@ -20,6 +20,7 @@ include_directories = [
   "${MAPLEALL_ROOT}/maple_ipa/include",
   "${MAPLEALL_ROOT}/mpl2mpl/include",
   "${MAPLEALL_ROOT}/maple_phase/include",
+  "${MAPLEALL_ROOT}/maple_driver/include",
   "${MAPLEALL_ROOT}/huawei_secure_c/include",
 ]
 
diff --git a/src/maple_ir/BUILD.gn b/src/maple_ir/BUILD.gn
index f03abd6d5d6c1a9f5bf20f0af332cd4505d9e2ee..c4c1e52bb4cb0c37835dc5cb9cb9bc8f7956c878 100644
--- a/src/maple_ir/BUILD.gn
+++ b/src/maple_ir/BUILD.gn
@@ -61,6 +61,7 @@ static_library("libmplir") {
   libs += [ "${OPENSOURCE_DEPS}/libmplutil.a" ]
   deps = [
     "${MAPLEALL_ROOT}/maple_driver:liboption_parser",
+    "${MAPLEALL_ROOT}/maple_driver:libdriver_option",
   ]
 }
 
diff --git a/src/maple_ir/include/option.h b/src/maple_ir/include/option.h
index dfc843657780e55672f09ae2478cc993bf656f51..ae6383c92ae85a3935ab5d58e528136fdb6d7da2 100644
--- a/src/maple_ir/include/option.h
+++ b/src/maple_ir/include/option.h
@@ -20,13 +20,20 @@
 #include "mempool_allocator.h"
 #include "parser_opt.h"
 #include "types_def.h"
+#include "driver_option_common.h"
+#include "option_descriptor.h"
 
 namespace maple {
-class Options {
+class Options : public MapleDriverOptionBase {
  public:
-  explicit Options(MemPool &memPool) : optionAlloc(&memPool) {}
+  static Options &GetInstance();
+
+  Options();
 
   bool ParseOptions(int argc, char **argv, std::string &fileName) const;
+
+  bool SolveOptions(const std::vector<mapleOption::Option> &opts,
+                    bool isDebug) const;
   ~Options() = default;
 
   void DumpOptions() const;
@@ -93,7 +100,7 @@ class Options {
   static bool testCase;
   static bool checkArrayStore;
  private:
-  MapleAllocator optionAlloc;
+  void DecideMpl2MplRealLevel(const std::vector<mapleOption::Option> &inputOptions) const;
   std::vector<std::string> phaseSeq;
 };
 }  // namespace maple
diff --git a/src/maple_ir/src/option.cpp b/src/maple_ir/src/option.cpp
index bf80e8d756441c5dd662732b2970ee9d9b5bc278..4d3714e2c371523b891adeb4ee5e1265b1d2cbe6 100644
--- a/src/maple_ir/src/option.cpp
+++ b/src/maple_ir/src/option.cpp
@@ -66,22 +66,28 @@ std::string Options::proFileFuncData = "";
 std::string Options::proFileClassData = "";
 bool Options::checkArrayStore = false;
 enum OptionIndex {
-  kUnknown,
-  kHelp,
-  kDumpPhase,
-  kSkipPhase,
-  kSkipFrom,
-  kSkipAfter,
-  kDumpFunc,
-  kQuiet,
-  kStubJniFunc,
+  kMpl2MplHelp = kCommonOptionEnd + 1,
+  kMpl2MplDumpPhase,
+  kMpl2MplSkipPhase,
+  kMpl2MplSkipFrom,
+  kMpl2MplSkipAfter,
+  kMpl2MplDumpFunc,
+  kMpl2MplQuiet,
+  kMpl2MplStubJniFunc,
+  kMpl2MplSkipVirtual,
+  kRegNativeDynamicOnly,
+  kRegNativeStaticBindingList,
+  kNativeWrapper,
+  kMpl2MplDumpBefore,
+  kMpl2MplDumpAfter,
+  kMpl2MplMapleLinker,
+  kMplnkDumpMuid,
+  kEmitVtableImpl,
   kInlineWithProfile,
   kInlineWithoutProfile,
-  kUseInline,
-  kNoInline,
-  kNoInlineFuncList,
-  kUseCrossModuleInline,
-  kNoCrossModuleInline,
+  kMpl2MplUseInline,
+  kMpl2MplNoInlineFuncList,
+  kMpl2MplUseCrossModuleInline,
   kInlineSmallFunctionThreshold,
   kInlineHotFunctionThreshold,
   kInlineModuleGrowth,
@@ -90,229 +96,581 @@ enum OptionIndex {
   kProfileColdCount,
   kProfileHotRate,
   kProfileColdRate,
-  kRegNativeDynamicOnly,
-  kRegNativeStaticBindingList,
-  kNativeWrapper,
-  kDumpBefore,
-  kDumpAfter,
-  kSkipVirtual,
-  kMapleLinker,
-  kMplnkDumpMuid,
-  kEmitVtableImpl,
-  kCheckArrayStore,
+  kMpl2MplNativeOpt,
+  kMpl2MplOptL0,
+  kMpl2MplOptL2,
+  kMpl2MplNoDot,
+  kGenIRProfile,
+  kTestCase,
 };
 
 const Descriptor kUsage[] = {
-  { kUnknown, 0, "", "", kBuildTypeAll, kArgCheckPolicyUnknown,
-    "USAGE:  mplxxx [options] *.mpl\n\n"
-    "OPTIONS:" },
-  { kHelp, 0, "h", "help", kBuildTypeAll, kArgCheckPolicyNone,
-    "  -h, --help                        Print usage and exit" },
-  { kDumpPhase, 0, "", "dump-phase", kBuildTypeAll, kArgCheckPolicyRequired,
-    "  --dump-phase=PHASENAME            Enable debug trace for specified phase (can only specify once)" },
-  { kSkipPhase, 0, "", "skip-phase", kBuildTypeAll, kArgCheckPolicyRequired,
-    "  --skip-phase=PHASENAME            Skip the phase when adding it to phase manager" },
-  { kSkipFrom, 0, "", "skip-from", kBuildTypeAll, kArgCheckPolicyRequired,
-    "  --skip-from=PHASENAME             Skip all remaining phases including PHASENAME" },
-  { kSkipAfter, 0, "", "skip-after", kBuildTypeAll, kArgCheckPolicyRequired,
-    "  --skip-after=PHASENAME            Skip all remaining phases after PHASENAME" },
-  { kDumpFunc, 0, "", "dump-func", kBuildTypeAll, kArgCheckPolicyRequired,
-    "  --dump-func=FUNCNAME              Dump/trace only for functions whose names contain FUNCNAME as substring\n"
-    "                                    (can only specify once)" },
-  { kQuiet, 0, "", "quiet", kBuildTypeAll, kArgCheckPolicyNone,
-    "  --quiet                           Disable brief trace messages with phase/function names" },
-  { kStubJniFunc, 0, "", "regnativefunc", kBuildTypeAll, kArgCheckPolicyNone,
-    "  --regnativefunc                   Generate native stub function to support JNI registration and calling" },
-  { kInlineWithProfile, 0, "", "inline-with-profile", kBuildTypeAll, kArgCheckPolicyNone,
-    "  --inline-with-profile             Enable profile-based inlining" },
-  { kInlineWithoutProfile, 0, "", "inline-without-profile", kBuildTypeAll, kArgCheckPolicyNone,
-    "  --inline-without-profile          Disable profile-based inlining" },
-  { kUseInline, 0, "", "inline", kBuildTypeAll, kArgCheckPolicyNone,
-    "  --inline                          Enable function inlining" },
-  { kNoInline, 0, "", "no-inline", kBuildTypeAll, kArgCheckPolicyNone,
-    "  --no-inline                       Disable function inlining" },
-  { kNoInlineFuncList, 0, "", "no-inlinefunclist", kBuildTypeAll, kArgCheckPolicyRequired,
-    "  --no-inlinefunclist=list          Do not inline function in this list" },
-  { kUseCrossModuleInline, 0, "", "cross-module-inline", kBuildTypeAll, kArgCheckPolicyNone,
-    "  --cross-module-inline             Enable cross-module inlining" },
-  { kNoCrossModuleInline, 0, "", "no-cross-module-inline", kBuildTypeAll, kArgCheckPolicyNone,
-    "  --no-cross-module-inline          Disable cross-module inlining" },
-  { kInlineSmallFunctionThreshold, 0, "", "inline-small-function-threshold", kBuildTypeAll, kArgCheckPolicyRequired,
-    "  --inline-small-function-threshold=15        Threshold for inlining small function" },
-  { kInlineHotFunctionThreshold, 0, "", "inline-hot-function-threshold", kBuildTypeAll, kArgCheckPolicyRequired,
-    "  --inline-hot-function-threshold=30          Threshold for inlining hot function" },
-  { kInlineModuleGrowth, 0, "", "inline-module-growth", kBuildTypeAll, kArgCheckPolicyRequired,
-    "  --inline-module-growth=100000               Threshold for maxmium code size growth rate. (10%)" },
-  { kInlineColdFunctionThreshold, 0, "", "inline-cold-function-threshold", kBuildTypeAll, kArgCheckPolicyRequired,
-    "  --inline-cold-function-threshold=3          Threshold for inlining cold function" },
-  { kProfileHotCount, 0, "", "profile-hot-count", kBuildTypeAll, kArgCheckPolicyRequired,
-    "  --profile-hot-count=1000          A count is regarded as hot if it exceeds this number" },
-  { kProfileColdCount, 0, "", "profile-cold-count", kBuildTypeAll, kArgCheckPolicyRequired,
-    "  --profile-cold-count=10           A count is regarded as cold if it is below this number" },
-  { kProfileHotRate, 0, "", "profile-hot-rate", kBuildTypeAll, kArgCheckPolicyRequired,
-    "  --profile-hot-rate=500000         A count is regarded as hot if it is in the largest 50%" },
-  { kProfileColdRate, 0, "", "profile-cold-rate", kBuildTypeAll, kArgCheckPolicyRequired,
-    "  --profile-cold-rate=900000        A count is regarded as cold if it is in the smallest 10%" },
-  { kNativeWrapper, 1, "", "nativewrapper", kBuildTypeAll, kArgCheckPolicyNone,
-    "  --nativewrapper                   Generate native wrappers [default]" },
-  { kNativeWrapper, 0, "", "no-nativewrapper", kBuildTypeAll, kArgCheckPolicyNone,
-    "  --no-nativewrapper                Do not generate native wrappers" },
-  { kRegNativeDynamicOnly, 0, "", "regnative-dynamic-only", kBuildTypeAll, kArgCheckPolicyNone,
-    "  --regnative-dynamic-only          Only Generate dynamic register code, Report Fatal Msg if no implemented" },
-  { kRegNativeStaticBindingList, 0, "", "static-binding-list", kBuildTypeAll, kArgCheckPolicyRequired,
-    "  --static-bindig-list=file         Only Generate static binding function in file configure list" },
-  { kDumpBefore, 0, "", "dump-before", kBuildTypeAll, kArgCheckPolicyNone,
-    "  --dump-before                     Do extra IR dump before the specified phase" },
-  { kDumpAfter, 0, "", "dump-after", kBuildTypeAll, kArgCheckPolicyNone,
-    "  --dump-after                      Do extra IR dump after the specified phase" },
-  { kMapleLinker, 0, "", "maplelinker", kBuildTypeAll, kArgCheckPolicyNone,
-    "  --maplelinker                     Generate MUID symbol tables and references" },
-  { kMplnkDumpMuid, 0, "", "dump-muid", kBuildTypeAll, kArgCheckPolicyNone,
-    "  --dump-muid                       Dump MUID def information into a .muid file" },
-  { kEmitVtableImpl, 0, "", "emitVtableImpl", kBuildTypeAll, kArgCheckPolicyNone,
-    "  --emitVtableImpl                  Generate VtableImpl file" },
+  { kMpl2MplHelp,
+    0,
+    "h-mpl2mpl",
+    "help-mpl2mpl",
+    kBuildTypeAll,
+    kArgCheckPolicyOptional,
+    "  -h-mpl2mpl --help-mpl2mpl   \tPrint usage and exit.Available command names:\n"
+    "                              \tmpl2mpl\n",
+    "mpl2mpl",
+    {} },
+  { kMpl2MplDumpPhase,
+    0,
+    nullptr,
+    "dump-phase",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --dump-phase                \tEnable debug trace for specified phase (can only specify once)\n"
+    "                              \t--dump-phase=PHASENAME\n",
+    "mpl2mpl",
+    {} },
+  { kMpl2MplSkipPhase,
+    0,
+    nullptr,
+    "skip-phase",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --skip-phase                \tSkip the phase when adding it to phase manager\n"
+    "                              \t--skip-phase=PHASENAME\n",
+    "mpl2mpl",
+    {} },
+  { kMpl2MplSkipFrom,
+    0,
+    nullptr,
+    "skip-from",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --skip-from                 \tSkip all remaining phases including PHASENAME\n"
+    "                              \t--skip-from=PHASENAME\n",
+    "mpl2mpl",
+    {} },
+  { kMpl2MplSkipAfter,
+    0,
+    nullptr,
+    "skip-after",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --skip-after                \tSkip all remaining phases after PHASENAME\n"
+    "                              \t--skip-after=PHASENAME\n",
+    "mpl2mpl",
+    {} },
+  { kMpl2MplDumpFunc,
+    0,
+    nullptr,
+    "dump-func",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --dump-func                 \tDump/trace only for functions whose names contain FUNCNAME as substring\n"
+    "                              \t(can only specify once)\n"
+    "                              \t--dump-func=FUNCNAME\n",
+    "mpl2mpl",
+    {} },
+  { kMpl2MplQuiet,
+    kEnable,
+    nullptr,
+    "quiet",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --quiet                     \tDisable brief trace messages with phase/function names\n"
+    "  --no-quiet                  \tEnable brief trace messages with phase/function names\n",
+    "mpl2mpl",
+    {} },
+  { kMpl2MplMapleLinker,
+    kEnable,
+    nullptr,
+    "maplelinker",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --maplelinker               \tGenerate MUID symbol tables and references\n"
+    "  --no-maplelinker            \tDon't Generate MUID symbol tables and references\n",
+    "mpl2mpl",
+    {} },
+  { kMpl2MplStubJniFunc,
+    kEnable,
+    nullptr,
+    "regnativefunc",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --regnativefunc             \tGenerate native stub function to support JNI registration and calling\n"
+    "  --no-regnativefunc          \tDisable regnativefunc\n",
+    "mpl2mpl",
+    {} },
+  { kInlineWithProfile,
+    kEnable,
+    nullptr,
+    "inline-with-profile",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --inline-with-profile       \tEnable profile-based inlining\n"
+    "  --no-inline-with-profile    \tDisable profile-based inlining\n",
+    "mpl2mpl",
+    {} },
+  { kMpl2MplUseInline,
+    kEnable,
+    nullptr,
+    "inline",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --inline                    \tEnable function inlining\n"
+    "  --no-inline                 \tDisable function inlining\n",
+    "mpl2mpl",
+    {} },
+  { kMpl2MplNoInlineFuncList,
+    0,
+    nullptr,
+    "no-inlinefunclist",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --no-inlinefunclist=list    \tDo not inline function in this list\n",
+    "mpl2mpl",
+    {} },
+  { kMpl2MplUseCrossModuleInline,
+    kEnable,
+    nullptr,
+    "cross-module-inline",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --cross-module-inline       \tEnable cross-module inlining\n"
+    "  --no-cross-module-inline    \tDisable cross-module inlining\n",
+    "mpl2mpl",
+    {} },
+  { kInlineSmallFunctionThreshold,
+    0,
+    nullptr,
+    "inline-small-function-threshold",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --inline-small-function-threshold=15            \tThreshold for inlining small function\n",
+    "mpl2mpl",
+    {} },
+  { kInlineHotFunctionThreshold,
+    0,
+    nullptr,
+    "inline-hot-function-threshold",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --inline-hot-function-threshold=30              \tThreshold for inlining hot function\n",
+    "mpl2mpl",
+    {} },
+  { kInlineModuleGrowth,
+    0,
+    nullptr,
+    "inline-module-growth",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --inline-module-growth=100000                   \tThreshold for maxmium code size growth rate (10%)\n",
+    "mpl2mpl",
+    {} },
+  { kInlineColdFunctionThreshold,
+    0,
+    nullptr,
+    "inline-cold-function-threshold",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --inline-cold-function-threshold=3              \tThreshold for inlining hot function\n",
+    "mpl2mpl",
+    {} },
+  { kProfileHotCount,
+    0,
+    nullptr,
+    "profile-hot-count",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --profile-hot-count=1000    \tA count is regarded as hot if it exceeds this number\n",
+    "mpl2mpl",
+    {} },
+  { kProfileColdCount,
+    0,
+    nullptr,
+    "profile-cold-count",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --profile-cold-count=10     \tA count is regarded as cold if it is below this number\n",
+    "mpl2mpl",
+    {} },
+  { kProfileHotRate,
+    0,
+    nullptr,
+    "profile-hot-rate",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --profile-hot-rate=500000   \tA count is regarded as hot if it is in the largest 50%\n",
+    "mpl2mpl",
+    {} },
+  { kProfileColdRate,
+    0,
+    nullptr,
+    "profile-cold-rate",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --profile-cold-rate=900000  \tA count is regarded as cold if it is in the smallest 10%\n",
+    "mpl2mpl",
+    {} },
+  { kNativeWrapper,
+    kEnable,
+    nullptr,
+    "nativewrapper",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --nativewrapper             \tGenerate native wrappers [default]\n",
+    "mpl2mpl",
+    {} },
+  { kRegNativeDynamicOnly,
+    kEnable,
+    nullptr,
+    "regnative-dynamic-only",
+    kBuildTypeAll,
+    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",
+    {} },
+  { kRegNativeStaticBindingList,
+    0,
+    nullptr,
+    "static-binding-list",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --static-bindig-list        \tOnly Generate static binding function in file configure list\n"
+    "                              \t--static-bindig-list=file\n",
+    "mpl2mpl",
+    {} },
+  { kMpl2MplDumpBefore,
+    kEnable,
+    nullptr,
+    "dump-before",
+    kBuildTypeAll,
+    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",
+    {} },
+  { kMpl2MplDumpAfter,
+    kEnable,
+    nullptr,
+    "dump-after",
+    kBuildTypeAll,
+    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",
+    {} },
+  { kMplnkDumpMuid,
+    kEnable,
+    nullptr,
+    "dump-muid",
+    kBuildTypeAll,
+    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",
+    {} },
+  { kEmitVtableImpl,
+    kEnable,
+    nullptr,
+    "emitVtableImpl",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --emitVtableImpl            \tgenerate VtableImpl file\n"
+    "  --no-emitVtableImpl         \tDon't generate VtableImpl file\n",
+    "mpl2mpl",
+    {} },
 #if MIR_JAVA
-  { kSkipVirtual, 0, "", "skipvirtual", kBuildTypeAll, kArgCheckPolicyNone, "  --skipvirtual" },
+  { kMpl2MplSkipVirtual,
+    kEnable,
+    nullptr,
+    "skipvirtual",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --skipvirtual\n"
+    "  --no-skipvirtual\n",
+    "mpl2mpl",
+    {} },
 #endif
-  { kCheckArrayStore, 0, "", "check-array-store", kBuildTypeAll, kArgCheckPolicyNone,
-    "  --check-array-store               Check array store[default off]" },
-  { 0, 0, nullptr, nullptr, kBuildTypeAll, kArgCheckPolicyNone, nullptr }
+  { kMpl2MplNativeOpt,
+    kEnable,
+    nullptr,
+    "nativeopt",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --nativeopt                 \tEnable native opt\n"
+    "  --no-nativeopt              \tDisable native opt\n",
+    "mpl2mpl",
+    {} },
+  { kMpl2MplOptL0,
+    0,
+    nullptr,
+    "O0",
+    kBuildTypeAll,
+    kArgCheckPolicyOptional,
+    "  -O0                         \tDo some optimization.\n",
+    "mpl2mpl",
+    {} },
+  { kMpl2MplOptL2,
+    0,
+    nullptr,
+    "O2",
+    kBuildTypeAll,
+    kArgCheckPolicyOptional,
+    "  -O2                         \tDo some optimization.\n",
+    "mpl2mpl",
+    {} },
+  { kMpl2MplNoDot,
+    kEnable,
+    nullptr,
+    "nodot",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --nodot                     \tDisable dot file generation from cfg\n"
+    "  --no-nodot                  \tEnable dot file generation from cfg\n",
+    "mpl2mpl",
+    {} },
+  { kGenIRProfile,
+    kEnable,
+    nullptr,
+    "ir-profile-gen",
+    mapleOption::BuildType::kBuildTypeAll,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    "  --ir-profile-gen              \tGen IR level Profile\n"
+    "  --no-ir-profile-gen           \tDisable Gen IR level Profile\n",
+    "mpl2mpl",
+    {} },
+  { kTestCase,
+    kEnable,
+    nullptr,
+    "testcase",
+    mapleOption::BuildType::kBuildTypeAll,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
+    "  --testcase              \tTest Case\n"
+    "  --no-testcase           \tDisable Test Case\n",
+    "mpl2mpl",
+    {} },
+  { kUnknown,
+    0,
+    nullptr,
+    nullptr,
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    nullptr,
+    "mpl2mpl",
+    {} }
 };
 
-bool Options::ParseOptions(int argc, char **argv, std::string &fileName) const {
-  bool result = true;
-  OptionParser optionParser(kUsage);
-  int ret = optionParser.Parse(argc, argv);
-  CHECK_FATAL(ret == kErrorNoError, "option parser error");
-  for (auto opt : optionParser.GetOptions()) {
+Options &Options::GetInstance() {
+  static Options instance;
+  return instance;
+}
+
+Options::Options() {
+  CreateUsages(kUsage);
+}
+
+void Options::DecideMpl2MplRealLevel(const std::vector<mapleOption::Option> &inputOptions) const {
+  int realLevel = -1;
+  for (const mapleOption::Option &opt : inputOptions) {
     switch (opt.Index()) {
-      case kHelp: {
-        if (opt.Args().empty()) {
-          optionParser.PrintUsage();
-          result = false;
-        }
+      case kMpl2MplOptL0:
+        realLevel = kLevelZero;
         break;
-      }
-      case kDumpBefore:
-        Options::dumpBefore = true;
+      case kMpl2MplOptL2:
+        realLevel = kLevelTwo;
         break;
-      case kDumpAfter:
-        Options::dumpAfter = true;
+      default:
         break;
-      case kDumpFunc:
-        Options::dumpFunc = opt.Args();
+    }
+  }
+  if (realLevel == kLevelTwo) {
+    O2 = true;
+    usePreg = true;
+  }
+}
+
+bool Options::SolveOptions(const std::vector<Option> &opts,
+                           bool isDebug) const {
+  DecideMpl2MplRealLevel(opts);
+  bool result = true;
+  for (const mapleOption::Option &opt : opts) {
+    if (isDebug) {
+      LogInfo::MapleLogger() << "mpl2mpl options: " << opt.Index() << " " << opt.OptionKey() << " " <<
+                                opt.Args() << '\n';
+    }
+    switch (opt.Index()) {
+      case kMpl2MplDumpBefore:
+        dumpBefore = (opt.Type() == kEnable);
         break;
-      case kDumpPhase:
-        Options::dumpPhase = opt.Args();
+      case kMpl2MplDumpAfter:
+        dumpAfter = (opt.Type() == kEnable);
         break;
-      case kSkipPhase:
-        Options::skipPhase = opt.Args();
+      case kMpl2MplDumpFunc:
+        dumpFunc = opt.Args();
         break;
-      case kSkipFrom:
-        Options::skipFrom = opt.Args();
+      case kMpl2MplQuiet:
+        quiet = (opt.Type() == kEnable);
         break;
-      case kSkipAfter:
-        Options::skipAfter = opt.Args();
+      case kMpl2MplDumpPhase:
+        dumpPhase = opt.Args();
         break;
-      case kQuiet:
-        Options::quiet = true;
+      case kMpl2MplSkipPhase:
+        skipPhase = opt.Args();
         break;
-      case kRegNativeDynamicOnly:
-        Options::regNativeDynamicOnly = true;
+      case kMpl2MplSkipFrom:
+        skipFrom = opt.Args();
         break;
-      case kRegNativeStaticBindingList:
-        Options::staticBindingList = opt.Args();
+      case kMpl2MplSkipAfter:
+        skipAfter = opt.Args();
         break;
-      case kStubJniFunc:
-        Options::regNativeFunc = true;
+      case kRegNativeDynamicOnly:
+        regNativeDynamicOnly = (opt.Type() == kEnable);
         break;
-      case kInlineWithProfile:
-        Options::inlineWithProfile = true;
+      case kRegNativeStaticBindingList:
+        staticBindingList = opt.Args();
         break;
-      case kInlineWithoutProfile:
-        Options::inlineWithProfile = false;
+      case kMpl2MplStubJniFunc:
+        regNativeFunc = (opt.Type() == kEnable);
         break;
-      case kUseInline:
-        Options::useInline = true;
+      case kNativeWrapper:
+        nativeWrapper = (opt.Type() == kEnable);
         break;
-      case kNoInline:
-        Options::useInline = false;
+      case kInlineWithProfile:
+        inlineWithProfile = (opt.Type() == kEnable);
         break;
-      case kNoInlineFuncList:
-        Options::noInlineFuncList = opt.Args();
+      case kMpl2MplUseInline:
+        useInline = (opt.Type() == kEnable);
         break;
-      case kUseCrossModuleInline:
-        Options::useCrossModuleInline = true;
+      case kMpl2MplNoInlineFuncList:
+        noInlineFuncList = opt.Args();
         break;
-      case kNoCrossModuleInline:
-        Options::useCrossModuleInline = false;
+      case kMpl2MplUseCrossModuleInline:
+        useCrossModuleInline = (opt.Type() == kEnable);
         break;
       case kInlineSmallFunctionThreshold:
-        Options::inlineSmallFunctionThreshold = std::stoul(opt.Args());
+        if (opt.Args().empty()) {
+          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --inline-small-function-threshold\n";
+          result = false;
+        } else {
+          inlineSmallFunctionThreshold = std::stoul(opt.Args());
+        }
         break;
       case kInlineHotFunctionThreshold:
-        Options::inlineHotFunctionThreshold = std::stoul(opt.Args());
+        if (opt.Args().empty()) {
+          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --inline-hot-function-threshold\n";
+          result = false;
+        } else {
+          inlineHotFunctionThreshold = std::stoul(opt.Args());
+        }
         break;
       case kInlineModuleGrowth:
-        Options::inlineModuleGrowth = std::stoul(opt.Args());
+        if (opt.Args().empty()) {
+          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --inline-module-growth\n";
+          result = false;
+        } else {
+          inlineModuleGrowth = std::stoul(opt.Args());
+        }
         break;
       case kInlineColdFunctionThreshold:
-        Options::inlineColdFunctionThreshold = std::stoul(opt.Args());
+        if (opt.Args().empty()) {
+          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --inline-cold-function-threshold\n";
+          result = false;
+        } else {
+          inlineColdFunctionThreshold = std::stoul(opt.Args());
+        }
         break;
       case kProfileHotCount:
-        Options::profileHotCount = std::stoul(opt.Args());
-        Options::profileHotCountSeted = true;
+        if (opt.Args().empty()) {
+          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --profile-hot-count\n";
+          result = false;
+        } else {
+          profileHotCount = std::stoul(opt.Args());
+        }
         break;
       case kProfileColdCount:
-        Options::profileColdCount = std::stoul(opt.Args());
-        Options::profileColdCountSeted = true;
+        if (opt.Args().empty()) {
+          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --profile-cold-count\n";
+          result = false;
+        } else {
+          profileColdCount = std::stoul(opt.Args());
+        }
         break;
       case kProfileHotRate:
-        Options::profileHotRate = std::stoul(opt.Args());
+        if (opt.Args().empty()) {
+          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --profile-hot-rate\n";
+          result = false;
+        } else {
+          profileHotRate = std::stoul(opt.Args());
+        }
         break;
       case kProfileColdRate:
-        Options::profileColdRate = std::stoul(opt.Args());
-        break;
-      case kNativeWrapper:
-        Options::nativeWrapper = opt.Type();
+        if (opt.Args().empty()) {
+          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --profile-cold-rate\n";
+          result = false;
+        } else {
+          profileColdRate = std::stoul(opt.Args());
+        }
         break;
-      case kMapleLinker:
-        Options::mapleLinker = true;
-        Options::dumpMuidFile = false;
+      case kMpl2MplMapleLinker:
+        mapleLinker = (opt.Type() == kEnable);
+        dumpMuidFile = (opt.Type() == kEnable);
+        if (isDebug) {
+          LogInfo::MapleLogger() << "--sub options: dumpMuidFile " << dumpMuidFile << '\n';
+        }
         break;
       case kMplnkDumpMuid:
-        Options::dumpMuidFile = true;
+        dumpMuidFile = (opt.Type() == kEnable);
         break;
       case kEmitVtableImpl:
-        Options::emitVtableImpl = true;
+        emitVtableImpl = (opt.Type() == kEnable);
         break;
 #if MIR_JAVA
-      case kSkipVirtual:
-        Options::skipVirtualMethod = true;
+      case kMpl2MplSkipVirtual:
+        skipVirtualMethod = (opt.Type() == kEnable);
         break;
 #endif
-      case kCheckArrayStore:
-        Options::checkArrayStore = true;
+      case kMpl2MplNativeOpt:
+        nativeOpt = (opt.Type() == kEnable);
+        break;
+      case kMpl2MplOptL2:
+        // Already handled above in DecideMpl2MplRealLevel
+        break;
+      case kMpl2MplNoDot:
+        noDot = (opt.Type() == kEnable);
+        break;
+      case kGenIRProfile:
+        genIRProfile = (opt.Type() == kEnable);
+        break;
+      case kTestCase:
+        testCase = (opt.Type() == kEnable);
         break;
       default:
-        result = false;
-        ASSERT(false, "unhandled case in Options");
+        WARN(kLncWarn, "input invalid key for mpl2mpl " + opt.OptionKey());
+        break;
     }
   }
+  return result;
+}
 
-  if (result) {
-    if (optionParser.GetNonOptionsCount() != 1) {
-      LogInfo::MapleLogger(kLlErr) << "expecting one .mpl file as last argument, found: ";
-      for (const auto &optionArg : optionParser.GetNonOptions()) {
-        LogInfo::MapleLogger(kLlErr) << optionArg << " ";
-      }
-      LogInfo::MapleLogger(kLlErr) << "\n";
-      result = false;
+bool Options::ParseOptions(int argc, char **argv, std::string &fileName) const {
+  OptionParser optionParser;
+  optionParser.RegisteUsages(DriverOptionCommon::GetInstance());
+  optionParser.RegisteUsages(Options::GetInstance());
+  int ret = optionParser.Parse(argc, argv, "mpl2mpl");
+  CHECK_FATAL(ret == kErrorNoError, "option parser error");
+  bool result = SolveOptions(optionParser.GetOptions(),
+                             false);
+  if (!result) {
+    return result;
+  }
+  if (optionParser.GetNonOptionsCount() != 1) {
+    LogInfo::MapleLogger(kLlErr) << "expecting one .mpl file as last argument, found: ";
+    for (const auto &optionArg : optionParser.GetNonOptions()) {
+      LogInfo::MapleLogger(kLlErr) << optionArg << " ";
     }
+    LogInfo::MapleLogger(kLlErr) << "\n";
+    result = false;
+  }
 
-    if (result) {
-      fileName = optionParser.GetNonOptions().front();
-    }
+  if (result) {
+    fileName = optionParser.GetNonOptions().front();
   }
   return result;
 }
diff --git a/src/maple_me/include/me_option.h b/src/maple_me/include/me_option.h
index 5cf5ce3b099efc1e4e32b5d0f3138a167b2dbc88..79399efd38bb20ef63a7bce72aaafb4d6fa15d88 100644
--- a/src/maple_me/include/me_option.h
+++ b/src/maple_me/include/me_option.h
@@ -19,28 +19,27 @@
 #include "mempool.h"
 #include "mempool_allocator.h"
 #include "types_def.h"
+#include "driver_option_common.h"
+#include "option_parser.h"
 
 namespace maple {
-class MeOption {
+class MeOption : public MapleDriverOptionBase {
  public:
-  enum Level {
-    kLevelZero = 0,
-    kLevelOne = 1,
-    kLevelTwo = 2,
-    kLevelThree = 3
-  };
+  static MeOption &GetInstance();
 
-  explicit MeOption(MemPool &memPool) : optionAlloc(&memPool) {}
+  MeOption();
 
   ~MeOption() = default;
 
+  bool SolveOptions(const std::vector<mapleOption::Option> &opts, bool isDebug);
+
   void ParseOptions(int argc, char **argv, std::string &fileName);
 
   void SplitPhases(const std::string &str, std::unordered_set<std::string> &set) const;
   void SplitSkipPhases(const std::string &str) {
     SplitPhases(str, skipPhases);
   }
-  void GetRange(const std::string &str) const;
+  bool GetRange(const std::string &str) const;
 
   const std::unordered_set<std::string> &GetSkipPhases() const {
     return skipPhases;
@@ -95,8 +94,8 @@ class MeOption {
   static bool spillAtCatch;
   static bool optDirectCall;
  private:
+  void DecideMeRealLevel(const std::vector<mapleOption::Option> &inputOptions) const;
   std::unordered_set<std::string> skipPhases;
-  MapleAllocator optionAlloc;
 };
 
 #ifndef DEBUGFUNC
diff --git a/src/maple_me/src/me_function.cpp b/src/maple_me/src/me_function.cpp
index 0b2b904e4dfd634f9f16a023081235c7f62ef49e..3dfc0166c86af704bf17efdae9feb820d35a8259 100644
--- a/src/maple_me/src/me_function.cpp
+++ b/src/maple_me/src/me_function.cpp
@@ -410,7 +410,7 @@ void MeFunction::Prepare(unsigned long rangeNum) {
   RemoveEhEdgesInSyncRegion();
   theCFG = memPool->New<MeCFG>(*this);
   theCFG->BuildMirCFG();
-  if (MeOption::optLevel > MeOption::kLevelZero) {
+  if (MeOption::optLevel > mapleOption::kLevelZero) {
     theCFG->FixMirCFG();
   }
   theCFG->VerifyLabels();
diff --git a/src/maple_me/src/me_option.cpp b/src/maple_me/src/me_option.cpp
index fe82545779fc7d3b1e120fad733a9e244ee024be..05043621a14f870e078f68441f89f4dea4873a27 100644
--- a/src/maple_me/src/me_option.cpp
+++ b/src/maple_me/src/me_option.cpp
@@ -66,6 +66,569 @@ bool MeOption::optDirectCall = false;
 bool MeOption::propAtPhi = true;
 bool MeOption::dseKeepRef = false;
 
+enum OptionIndex {
+  kMeHelp = kCommonOptionEnd + 1,
+  kMeDumpPhases,
+  kMeSkipPhases,
+  kMeDumpFunc,
+  kMeQuiet,
+  kMeNoDot,
+  kMeSkipFrom,
+  kMeSkipAfter,
+  kSetCalleeHasSideEffect,
+  kNoSteensgaard,
+  kNoTBAA,
+  kAliasAnalysisLevel,
+  kStmtNum,
+  kRcLower,
+  kNoRcLower,
+  kMeDumpBefore,
+  kMeDumpAfter,
+  kMeOptL1,
+  kMeOptL2,
+  kMeRange,
+  kEpreLimit,
+  kEprepuLimit,
+  kStmtPrepuLimit,
+  kLpreLimit,
+  kLprepulLimit,
+  kPregreNameLimit,
+  kDelrcpuLimit,
+  kEpreIncludeRef,
+  kNoEpreIncludeRef,
+  kEpreLocalRefVar,
+  kNoEpreLocalRefVar,
+  kEprelhSivar,
+  kLessThrowAlias,
+  kNodeLegateRc,
+  kNocondBasedRc,
+  kNullcheckPre,
+  kClinitPre,
+  kDassignPre,
+  kAssign2finalPre,
+  kRegReadAtReturn,
+  kLpreSpeculate,
+  kNoLpreSpeculate,
+  kSpillatCatch,
+};
+
+const Descriptor kUsage[] = {
+  { kMeHelp,
+    0,
+    "h-me",
+    "help-me",
+    kBuildTypeAll,
+    kArgCheckPolicyOptional,
+    "  -h-me --help-me             \tPrint usage and exit.Available command names:\n"
+    "                              \tme\n",
+    "me",
+    {} },
+  { kMeOptL1,
+    0,
+    nullptr,
+    "O1",
+    kBuildTypeAll,
+    kArgCheckPolicyOptional,
+    "  -O1                         \tDo some optimization.\n",
+    "me",
+    {} },
+  { kMeOptL2,
+    0,
+    nullptr,
+    "O2",
+    kBuildTypeAll,
+    kArgCheckPolicyOptional,
+    "  -O2                         \tDo some optimization.\n",
+    "me",
+    {} },
+  { kMeRange,
+    0,
+    nullptr,
+    "range",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --range                     \tOptimize only functions in the range [NUM0, NUM1]\n"
+    "                              \t--range=NUM0,NUM1\n",
+    "me",
+    {} },
+  { kMeDumpPhases,
+    0,
+    nullptr,
+    "dump-phases",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --dump-phases               \tEnable debug trace for specified phases in the comma separated list\n"
+    "                              \t--dump-phases=PHASENAME,...\n",
+    "me",
+    {} },
+  { kMeSkipPhases,
+    0,
+    nullptr,
+    "skip-phases",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --skip-phases               \tSkip the phases specified in the comma separated list\n"
+    "                              \t--skip-phases=PHASENAME,...\n",
+    "me",
+    {} },
+  { kMeDumpFunc,
+    0,
+    nullptr,
+    "dump-func",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --dump-func                 \tDump/trace only for functions whose names contain FUNCNAME as substring\n"
+    "                              \t(can only specify once)\n"
+    "                              \t--dump-func=FUNCNAME\n",
+    "me",
+    {} },
+  { kMeQuiet,
+    kEnable,
+    nullptr,
+    "quiet",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --quiet                     \tDisable brief trace messages with phase/function names\n"
+    "  --no-quiet                  \tEnable brief trace messages with phase/function names\n",
+    "me",
+    {} },
+  { kMeNoDot,
+    kEnable,
+    nullptr,
+    "nodot",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --nodot                     \tDisable dot file generation from cfg\n"
+    "  --no-nodot                  \tEnable dot file generation from cfg\n",
+    "me",
+    {} },
+  { kSetCalleeHasSideEffect,
+    kEnable,
+    nullptr,
+    "setCalleeHasSideEffect",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --setCalleeHasSideEffect    \tSet all the callees have side effect\n"
+    "  --no-setCalleeHasSideEffect \tNot set all the callees have side effect\n",
+    "me",
+    {} },
+  { kNoSteensgaard,
+    kEnable,
+    nullptr,
+    "noSteensgaard",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --noSteensgaard             \tDisable Steensgaard-style alias analysis\n"
+    "  --no-noSteensgaard          \tEnable Steensgaard-style alias analysis\n",
+    "me",
+    {} },
+  { kNoTBAA,
+    kEnable,
+    nullptr,
+    "noTBAA",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --noTBAA                    \tDisable type-based alias analysis\n"
+    "  --no-noTBAA                 \tEnable type-based alias analysis\n",
+    "me",
+    {} },
+  { kAliasAnalysisLevel,
+    0,
+    nullptr,
+    "aliasAnalysisLevel",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --aliasAnalysisLevel        \tSet level of alias analysis. \n"
+    "                              \t0: most conservative;\n"
+    "                              \t1: Steensgaard-style alias analysis; 2: type-based alias analysis;\n"
+    "                              \t3: Steensgaard-style and type-based alias analysis\n"
+    "                              \t--aliasAnalysisLevel=NUM\n",
+    "me",
+    {} },
+  { kStmtNum,
+    kEnable,
+    nullptr,
+    "stmtnum",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --stmtnum                   \tPrint MeStmt index number in IR dump\n"
+    "  --no-stmtnum                \tDon't print MeStmt index number in IR dump\n",
+    "me",
+    {} },
+  { kRcLower,
+    kEnable,
+    nullptr,
+    "rclower",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --rclower                   \tEnable rc lowering\n"
+    "  --no-rclower                \tDisable rc lowering\n",
+    "me",
+    {} },
+  { kMeDumpBefore,
+    kEnable,
+    nullptr,
+    "dump-before",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --dump-before               \tDo extra IR dump before the specified phase in me\n"
+    "  --no-dump-before            \tDon't extra IR dump before the specified phase in me\n",
+    "me",
+    {} },
+  { kMeDumpAfter,
+    kEnable,
+    nullptr,
+    "dump-after",
+    kBuildTypeAll,
+    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",
+    {} },
+  { kEpreLimit,
+    0,
+    nullptr,
+    "eprelimit",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --eprelimit                 \tApply EPRE optimization only for the first NUM expressions\n"
+    "                              \t--eprelimit=NUM\n",
+    "me",
+    {} },
+  { kEprepuLimit,
+    0,
+    nullptr,
+    "eprepulimit",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --eprepulimit               \tApply EPRE optimization only for the first NUM PUs\n"
+    "                              \t--eprepulimit=NUM\n",
+    "me",
+    {} },
+  { kStmtPrepuLimit,
+    0,
+    nullptr,
+    "stmtprepulimit",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --stmtprepulimit            \tApply STMTPRE optimization only for the first NUM PUs\n"
+    "                              \t--stmtprepulimit=NUM\n",
+    "me",
+    {} },
+  { kLpreLimit,
+    0,
+    nullptr,
+    "lprelimit",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --lprelimit                 \tApply LPRE optimization only for the first NUM variables\n"
+    "                              \t--lprelimit=NUM\n",
+    "me",
+    {} },
+  { kLprepulLimit,
+    0,
+    nullptr,
+    "lprepulimit",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --lprepulimit               \tApply LPRE optimization only for the first NUM PUs\n"
+    "                              \t--lprepulimit=NUM\n",
+    "me",
+    {} },
+  { kPregreNameLimit,
+    0,
+    nullptr,
+    "pregrenamelimit",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --pregrenamelimit           \tApply Preg Renaming optimization only up to NUM times\n"
+    "                              \t--pregrenamelimit=NUM\n",
+    "me",
+    {} },
+  { kDelrcpuLimit,
+    0,
+    nullptr,
+    "delrcpulimit",
+    kBuildTypeAll,
+    kArgCheckPolicyRequired,
+    "  --delrcpulimit              \tApply DELEGATERC optimization only for the first NUM PUs\n"
+    "                              \t--delrcpulimit=NUM\n",
+    "me",
+    {} },
+  { kEpreIncludeRef,
+    kEnable,
+    nullptr,
+    "epreincluderef",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --epreincluderef            \tInclude ref-type expressions when performing epre optimization\n"
+    "  --no-epreincluderef         \tDon't include ref-type expressions when performing epre optimization\n",
+    "me",
+    {} },
+  { kEpreLocalRefVar,
+    kEnable,
+    nullptr,
+    "eprelocalrefvar",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --eprelocalrefvar           \tThe EPRE phase will create new localrefvars when appropriate\n"
+    "  --no-eprelocalrefvar        \tDisable the EPRE phase create new localrefvars when appropriate\n",
+    "me",
+    {} },
+  { kEprelhSivar,
+    kEnable,
+    nullptr,
+    "eprelhsivar",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --eprelhsivar               \tThe EPRE phase will consider iassigns when optimizing ireads\n"
+    "  --no-eprelhsivar            \tDisable the EPRE phase consider iassigns when optimizing ireads\n",
+    "me",
+    {} },
+  { kLessThrowAlias,
+    kEnable,
+    nullptr,
+    "lessthrowalias",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --lessthrowalias            \tHandle aliases at java throw statements more accurately\n"
+    "  --no-lessthrowalias         \tDisable lessthrowalias\n",
+    "me",
+    {} },
+  { kNodeLegateRc,
+    kEnable,
+    nullptr,
+    "nodelegaterc",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --nodelegateerc             \tDo not apply RC delegation to local object reference pointers\n"
+    "  --no-nodelegateerc          \tDisable nodelegateerc\n",
+    "me",
+    {} },
+  { kNocondBasedRc,
+    kEnable,
+    nullptr,
+    "nocondbasedrc",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --nocondbasedrc             \tDo not apply condition-based RC optimization to\n"
+    "                              \tlocal object reference pointers\n"
+    "  --no-nocondbasedrc          \tDisable nocondbasedrc\n",
+    "me",
+    {} },
+  { kRegReadAtReturn,
+    kEnable,
+    nullptr,
+    "regreadatreturn",
+    kBuildTypeAll,
+    kArgCheckPolicyBool,
+    "  --regreadatreturn           \tAllow register promotion to promote the operand of return statements\n"
+    "  --no-regreadatreturn        \tDisable regreadatreturn\n",
+    "me",
+    {} },
+  { kUnknown,
+    0,
+    nullptr,
+    nullptr,
+    kBuildTypeAll,
+    kArgCheckPolicyNone,
+    nullptr,
+    "me",
+    {} }
+};
+
+void MeOption::DecideMeRealLevel(const std::vector<mapleOption::Option> &inputOptions) const {
+  int realLevel = -1;
+  for (const mapleOption::Option &opt : inputOptions) {
+    switch (opt.Index()) {
+      case kMeOptL1:
+        realLevel = kLevelOne;
+        break;
+      case kMeOptL2:
+        realLevel = kLevelTwo;
+        break;
+      default:
+        break;
+    }
+  }
+  if (realLevel == kLevelOne) {
+    optLevel = kLevelOne;
+  } else if (realLevel == kLevelTwo) {
+    optLevel = kLevelTwo;
+    // Turn the followings ON only at O2
+    optDirectCall = true;
+    epreIncludeRef = true;
+  }
+}
+
+bool MeOption::SolveOptions(const std::vector<mapleOption::Option> &opts, bool isDebug) {
+  DecideMeRealLevel(opts);
+  if (isDebug) {
+    LogInfo::MapleLogger() << "Real Me level:" << std::to_string(optLevel) << "\n";
+  }
+  bool result = true;
+  for (const mapleOption::Option &opt : opts) {
+    if (isDebug) {
+      LogInfo::MapleLogger() << "Me options: " << opt.Index() << " " << opt.OptionKey() << " " << opt.Args() << '\n';
+    }
+    switch (opt.Index()) {
+      case kMeSkipPhases:
+        SplitSkipPhases(opt.Args());
+        break;
+      case kMeOptL1:
+        // Already handled above in DecideMeRealLevel
+        break;
+      case kMeOptL2:
+        // Already handled above in DecideMeRealLevel
+        break;
+      case kMeRange:
+        useRange = true;
+        result = GetRange(opt.Args());
+        break;
+      case kMeDumpAfter:
+        dumpAfter = (opt.Type() == kEnable);
+        break;
+      case kMeDumpFunc:
+        dumpFunc = opt.Args();
+        break;
+      case kMeDumpPhases:
+        SplitPhases(opt.Args(), dumpPhases);
+        break;
+      case kMeQuiet:
+        quiet = (opt.Type() == kEnable);
+        break;
+      case kSetCalleeHasSideEffect:
+        setCalleeHasSideEffect = (opt.Type() == kEnable);
+        break;
+      case kNoSteensgaard:
+        noSteensgaard = (opt.Type() == kEnable);
+        break;
+      case kNoTBAA:
+        noTBAA = (opt.Type() == kEnable);
+        break;
+      case kAliasAnalysisLevel:
+        aliasAnalysisLevel = std::stoul(opt.Args(), nullptr);
+        if (aliasAnalysisLevel > kLevelThree) {
+          aliasAnalysisLevel = kLevelThree;
+        }
+        switch (aliasAnalysisLevel) {
+          case kLevelThree:
+            setCalleeHasSideEffect = false;
+            noSteensgaard = false;
+            noTBAA = false;
+            break;
+          case kLevelZero:
+            setCalleeHasSideEffect = true;
+            noSteensgaard = true;
+            noTBAA = true;
+            break;
+          case kLevelOne:
+            setCalleeHasSideEffect = false;
+            noSteensgaard = false;
+            noTBAA = true;
+            break;
+          case kLevelTwo:
+            setCalleeHasSideEffect = false;
+            noSteensgaard = true;
+            noTBAA = false;
+            break;
+          default:
+            break;
+        }
+        if (isDebug) {
+          LogInfo::MapleLogger() << "--sub options: setCalleeHasSideEffect "
+                                 << setCalleeHasSideEffect << '\n';
+          LogInfo::MapleLogger() << "--sub options: noSteensgaard " << noSteensgaard << '\n';
+          LogInfo::MapleLogger() << "--sub options: noTBAA " << noTBAA << '\n';
+        }
+        break;
+      case kRcLower:
+        rcLowering = (opt.Type() == kEnable);
+        break;
+      case kMeNoDot:
+        noDot = (opt.Type() == kEnable);
+        break;
+      case kStmtNum:
+        stmtNum = (opt.Type() == kEnable);
+        break;
+      case kEpreLimit:
+        epreLimit = std::stoul(opt.Args(), nullptr);
+        break;
+      case kEprepuLimit:
+        eprePULimit = std::stoul(opt.Args(), nullptr);
+        break;
+      case kStmtPrepuLimit:
+        stmtprePULimit = std::stoul(opt.Args(), nullptr);
+        break;
+      case kLpreLimit:
+        lpreLimit = std::stoul(opt.Args(), nullptr);
+        break;
+      case kLprepulLimit:
+        lprePULimit = std::stoul(opt.Args(), nullptr);
+        break;
+      case kPregreNameLimit:
+        pregRenameLimit = std::stoul(opt.Args(), nullptr);
+        break;
+      case kDelrcpuLimit:
+        delRcPULimit = std::stoul(opt.Args(), nullptr);
+        break;
+      case kEpreIncludeRef:
+        epreIncludeRef = (opt.Type() == kEnable);
+        break;
+      case kEpreLocalRefVar:
+        epreLocalRefVar = (opt.Type() == kEnable);
+        break;
+      case kEprelhSivar:
+        epreLHSIvar = (opt.Type() == kEnable);
+        break;
+      case kLessThrowAlias:
+        lessThrowAlias = (opt.Type() == kEnable);
+        break;
+      case kNodeLegateRc:
+        noDelegateRC = (opt.Type() == kEnable);
+        break;
+      case kNocondBasedRc:
+        noCondBasedRC = (opt.Type() == kEnable);
+        break;
+      case kNullcheckPre:
+        nullCheckPre = (opt.Type() == kEnable);
+        break;
+      case kClinitPre:
+        clinitPre = (opt.Type() == kEnable);
+        break;
+      case kDassignPre:
+        dassignPre = (opt.Type() == kEnable);
+        break;
+      case kAssign2finalPre:
+        assign2FinalPre = (opt.Type() == kEnable);
+        break;
+      case kRegReadAtReturn:
+        regreadAtReturn = (opt.Type() == kEnable);
+        break;
+      case kLpreSpeculate:
+        lpreSpeculate = (opt.Type() == kEnable);
+        break;
+      case kSpillatCatch:
+        spillAtCatch = (opt.Type() == kEnable);
+        break;
+      default:
+        WARN(kLncWarn, "input invalid key for me " + opt.OptionKey());
+        break;
+    }
+  }
+  return result;
+}
+
+MeOption &MeOption::GetInstance() {
+  static MeOption instance;
+  return instance;
+}
+
+MeOption::MeOption() {
+  CreateUsages(kUsage);
+}
+
+
 void MeOption::SplitPhases(const std::string &str, std::unordered_set<std::string> &set) const {
   std::string s{ str };
 
@@ -76,7 +639,7 @@ void MeOption::SplitPhases(const std::string &str, std::unordered_set<std::strin
   StringUtils::Split(s, set, ',');
 }
 
-void MeOption::GetRange(const std::string &str) const {
+bool MeOption::GetRange(const std::string &str) const {
   std::string s{ str };
   size_t comma = s.find_first_of(",", 0);
   if (comma != std::string::npos) {
@@ -85,8 +648,9 @@ void MeOption::GetRange(const std::string &str) const {
   }
   if (range[0] > range[1]) {
     LogInfo::MapleLogger(kLlErr) << "invalid values for --range=" << range[0] << "," << range[1] << '\n';
-    ASSERT(false, "GetRange exit");
+    return false;
   }
+  return true;
 }
 
 bool MeOption::DumpPhase(const std::string &phase) {
diff --git a/src/mplfe/BUILD.gn b/src/mplfe/BUILD.gn
index 30e61b18e10f5dad09af1fc5abe8fffa4a05fd3f..895da36d0c3187b91725d2b2ba2851290fb24c8f 100644
--- a/src/mplfe/BUILD.gn
+++ b/src/mplfe/BUILD.gn
@@ -89,6 +89,7 @@ executable("mplfe") {
     "${MAPLEALL_ROOT}/huawei_secure_c:libHWSecureC",
     "${MAPLEALL_ROOT}/maple_ir:libmplir",
     "${MAPLEALL_ROOT}/mpl2mpl:libmpl2mpl",
+    "${MAPLEALL_ROOT}/maple_driver:libdriver_option",
   ]
   libs = [
     "${OPENSOURCE_DEPS}/libmempool.a",
diff --git a/src/mplfe/common/include/mplfe_options.h b/src/mplfe/common/include/mplfe_options.h
index b74e873935e2f448e802b091d780cba21654a37a..320c5dd27454be3b3d7e34cef34fa2584e0702b1 100644
--- a/src/mplfe/common/include/mplfe_options.h
+++ b/src/mplfe/common/include/mplfe_options.h
@@ -20,15 +20,17 @@
 #include "parser_opt.h"
 #include "option_parser.h"
 #include "types_def.h"
+#include "driver_option_common.h"
 
 namespace maple {
-class MPLFEOptions {
+class MPLFEOptions : public maple::MapleDriverOptionBase {
  public:
   static MPLFEOptions &GetInstance() {
     return options;
   }
   void Init();
   static bool InitFactory();
+  bool SolveOptions(const std::vector<mapleOption::Option> &opts, bool isDebug);
   bool SolveArgs(int argc, char **argv);
   void DumpUsage() const;
   void DumpVersion() const;
diff --git a/src/mplfe/common/src/mplfe_options.cpp b/src/mplfe/common/src/mplfe_options.cpp
index f2a33962fa60d55d3593ca14cc1f6a22e0b11a9a..7506781e66534a4fff65cffbc91b9b1637ffb6df 100644
--- a/src/mplfe/common/src/mplfe_options.cpp
+++ b/src/mplfe/common/src/mplfe_options.cpp
@@ -22,10 +22,10 @@
 #include "fe_file_type.h"
 
 namespace maple {
+using namespace mapleOption;
+
 enum OptionIndex : uint32 {
-  kUnknown,
-  kHelp,
-  kVersion,
+  kMplfeHelp = kCommonOptionEnd + 1,
   // input control options
   kInClass,
   kInJar,
@@ -62,129 +62,131 @@ const mapleOption::Descriptor kUsage[] = {
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
     "========================================\n"
     " Usage: mplfe [ options ] input1 input2 input3\n"
-    " options:" },
-  { static_cast<uint32>(kHelp), 0, "h", "help",
+    " options:", "mplfe", {} },
+  { static_cast<uint32>(kMplfeHelp), 0, "h", "help",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  -h, --help             : print usage and exit" },
+    "  -h, --help             : print usage and exit", "mplfe", {} },
   { static_cast<uint32>(kVersion), 0, "v", "version",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  -v, --version          : print version and exit" },
+    "  -v, --version          : print version and exit", "mplfe", {} },
 
   // input control options
   { static_cast<uint32>(kUnknown), 0, "", "",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
-    "========== Input Control Options ==========" },
+    "========== Input Control Options ==========", "mplfe", {} },
   { static_cast<uint32>(kInClass), 0, "", "in-class",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
     "  --in-class file1.jar,file2.jar\n"
-    "                         : input class files" },
+    "                         : input class files", "mplfe", {} },
   { static_cast<uint32>(kInJar), 0, "", "in-jar",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
     "  --in-jar file1.jar,file2.jar\n"
-    "                         : input jar files" },
+    "                         : input jar files", "mplfe", {} },
 
   // output control options
   { static_cast<uint32>(kUnknown), 0, "", "",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
-    "========== Output Control Options ==========" },
+    "========== Output Control Options ==========", "mplfe", {} },
   { static_cast<uint32>(kOutputPath), 0, "p", "output",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
-    "  -p, --output            : output path" },
+    "  -p, --output            : output path", "mplfe", {} },
   { static_cast<uint32>(kOutputName), 0, "o", "output-name",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
-    "  -o, --output-name       : output name" },
+    "  -o, --output-name       : output name", "mplfe", {} },
   { static_cast<uint32>(kGenMpltOnly), 0, "t", "",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  -t                     : generate mplt only" },
+    "  -t                     : generate mplt only", "mplfe", {} },
   { static_cast<uint32>(kGenAsciiMplt), 0, "", "asciimplt",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  --asciimplt            : generate mplt in ascii format" },
+    "  --asciimplt            : generate mplt in ascii format", "mplfe", {} },
   { static_cast<uint32>(kDumpInstComment), 0, "", "dump-inst-comment",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  --dump-inst-comment    : dump instruction comment" },
+    "  --dump-inst-comment    : dump instruction comment", "mplfe", {} },
 
   // debug info control options
   { static_cast<uint32>(kUnknown), 0, "", "",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
-    "========== Debug Info Control Options ==========" },
+    "========== Debug Info Control Options ==========", "mplfe", {} },
   { static_cast<uint32>(kDumpLevel), 0, "d", "dump-level",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNumeric,
     "  -d, --dump-level xx    : debug info dump level\n"
     "                             [0] disable\n"
     "                             [1] dump simple info\n"
     "                             [2] dump detail info\n"
-    "                             [3] dump debug info" },
+    "                             [3] dump debug info", "mplfe", {} },
   { static_cast<uint32>(kDumpTime), 0, "", "dump-time",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  --dump-time            : dump time" },
+    "  --dump-time            : dump time", "mplfe", {} },
   { static_cast<uint32>(kDumpPhaseTime), 0, "", "dump-phase-time",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  --dump-phase-time      : dump total phase time" },
+    "  --dump-phase-time      : dump total phase time", "mplfe", {} },
   { static_cast<uint32>(kDumpPhaseTimeDetail), 0, "", "dump-phase-time-detail",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
     "  --dump-phase-time-detail"
-    "                         : dump phase time for each method" },
+    "                         : dump phase time for each method", "mplfe", {} },
   // java bytecode compile options
   { static_cast<uint32>(kUnknown), 0, "", "",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
-    "========== Java Bytecode Compile Options ==========" },
+    "========== Java Bytecode Compile Options ==========", "mplfe", {} },
   { static_cast<uint32>(kJavaStaticFieldName), 0, "", "java-staticfield-name",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
     "  --java-staticfield-name\n"
     "                         : java static field name mode\n"
     "                             [notype]  all static fields have no types in names\n"
     "                             [alltype] all static fields have types in names\n"
-    "                             [smart]   only static fields in field-proguard class have types in names\n" },
+    "                             [smart]   only static fields in field-proguard class have types in names\n",
+    "mplfe", {} },
   { static_cast<uint32>(kJBCInfoUsePathName), 0, "", "jbc-info-use-pathname",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
     "  --jbc-info-use-pathname\n"
-    "                         : use JBC pathname in file info" },
+    "                         : use JBC pathname in file info", "mplfe", {} },
   { static_cast<uint32>(kDumpJBCStmt), 0, "", "dump-jbc-stmt",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  --dump-jbc-stmt        : dump JBC Stmt" },
+    "  --dump-jbc-stmt        : dump JBC Stmt", "mplfe", {} },
   { static_cast<uint32>(kDumpJBCBB), 0, "", "dump-jbc-bb",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  --dump-jbc-bb          : dump JBC BB" },
+    "  --dump-jbc-bb          : dump JBC BB", "mplfe", {} },
   { static_cast<uint32>(kDumpJBCAll), 0, "", "dump-jbc-all",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  --dump-jbc-all         : dump all JBC function" },
+    "  --dump-jbc-all         : dump all JBC function", "mplfe", {} },
   { static_cast<uint32>(kDumpJBCErrorOnly), 0, "", "dump-jbc-error-only",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
     "  --dump-jbc-error-only\n"
-    "                         : dump JBC functions with errors" },
+    "                         : dump JBC functions with errors", "mplfe", {} },
   { static_cast<uint32>(kDumpJBCFuncName), 0, "", "dump-jbc-funcname",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
     "  --dump-jbc-funcname=name1,name2,...\n"
     "                         : dump JBC functions with specified names\n"
-    "                         : name format: ClassName;|MethodName|Signature" },
+    "                         : name format: ClassName;|MethodName|Signature", "mplfe", {} },
   // general stmt/bb/cfg debug options
   { static_cast<uint32>(kDumpGenCFGGraph), 0, "", "dump-general-cfg-graph",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
     "  --dump-general-cfg-graph=graph.dot\n"
-    "                         : dump General CFG into graphviz dot file" },
+    "                         : dump General CFG into graphviz dot file", "mplfe", {} },
   { static_cast<uint32>(kEmitJBCLocalVarInfo), 0, "", "emit-jbc-localvar-info",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
     "  --emit-jbc-localvar-info\n"
-    "                         : emit jbc's LocalVar Info in mpl using comments" },
+    "                         : emit jbc's LocalVar Info in mpl using comments", "mplfe", {} },
   // multi-thread control
   { static_cast<uint32>(kUnknown), 0, "", "",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
-    "========== Multi-Thread Control Options ==========" },
+    "========== Multi-Thread Control Options ==========", "mplfe", {} },
   { static_cast<uint32>(kNThreads), 0, "", "np",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
-    "  --np num               : number of threads" },
+    "  --np num               : number of threads", "mplfe", {} },
   { static_cast<uint32>(kDumpThreadTime), 0, "", "dump-thread-time",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  --dump-thread-time     : dump thread time in mpl schedular" },
+    "  --dump-thread-time     : dump thread time in mpl schedular", "mplfe", {} },
   { static_cast<uint32>(kReleaseAfterEmit), 0, "", "release-after-emit",
     mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  --release-after-emit   : release temp memory after emit" },
-  { 0, 0, 0, 0, mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone, 0 }
+    "  --release-after-emit   : release temp memory after emit", "mplfe", {} },
+  { 0, 0, nullptr, nullptr, mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone, nullptr, "mplfe", {} }
 };
 
 MPLFEOptions MPLFEOptions::options;
 
 MPLFEOptions::MPLFEOptions() {
+  CreateUsages(kUsage);
   Init();
 }
 
@@ -195,7 +197,7 @@ void MPLFEOptions::Init() {
 }
 
 bool MPLFEOptions::InitFactory() {
-  RegisterFactoryFunction<OptionProcessFactory>(static_cast<uint32>(kHelp),
+  RegisterFactoryFunction<OptionProcessFactory>(static_cast<uint32>(kMplfeHelp),
                                                 &MPLFEOptions::ProcessHelp);
   RegisterFactoryFunction<OptionProcessFactory>(static_cast<uint32>(kVersion),
                                                 &MPLFEOptions::ProcessVersion);
@@ -258,25 +260,41 @@ bool MPLFEOptions::InitFactory() {
   return true;
 }
 
+bool MPLFEOptions::SolveOptions(const std::vector<mapleOption::Option> &opts, bool isDebug) {
+  for (const mapleOption::Option &opt : opts) {
+    if (isDebug) {
+      LogInfo::MapleLogger() << "mplfe options: " << opt.Index() << " " << opt.OptionKey() << " " <<
+                                opt.Args() << '\n';
+    }
+    auto func = CreateProductFunction<OptionProcessFactory>(opt.Index());
+    if (func != nullptr) {
+      if (!func(this, opt)) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
 bool MPLFEOptions::SolveArgs(int argc, char **argv) {
-  mapleOption::OptionParser optionParser(kUsage);
+  OptionParser optionParser;
+  optionParser.RegisteUsages(DriverOptionCommon::GetInstance());
+  optionParser.RegisteUsages(MPLFEOptions::GetInstance());
   if (argc == 1) {
     DumpUsage();
     return false;
   }
-  ErrorCode ret = optionParser.Parse(argc, argv);
+  ErrorCode ret = optionParser.Parse(argc, argv, "mplfe");
   if (ret != ErrorCode::kErrorNoError) {
     DumpUsage();
     return false;
   }
-  for (const mapleOption::Option &opt : optionParser.GetOptions()) {
-    auto func = CreateProductFunction<OptionProcessFactory>(opt.Index());
-    if (func != nullptr) {
-      if (!func(this, opt)) {
-        return false;
-      }
-    }
+
+  bool result = SolveOptions(optionParser.GetOptions(), false);
+  if (!result) {
+    return result;
   }
+
   if (optionParser.GetNonOptionsCount() >= 1) {
     const std::vector<std::string> &inputs = optionParser.GetNonOptions();
     ProcessInputFiles(inputs);