diff --git a/BUILD.gn b/BUILD.gn
index 40e691379fdb548eb9a6292775b15262bfa1c51d..03ee5f1e1029561697cb91a6470d5db6bbd4baa8 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -41,7 +41,8 @@ group("ast2mpl") {
 
 group("mapleallUT") {
   deps = [
-    "${MAPLEALL_ROOT}/test:mapleallUT",
+    "${MAPLEALL_ROOT}/test:UTDriver",
+    "${MAPLEALL_ROOT}/test:UTCL",
   ]
 }
 
diff --git a/src/hir2mpl/BUILD.gn b/src/hir2mpl/BUILD.gn
index 80b4e5e920ecc003426b7bf3ef3ded50aad58a32..eac5c38b06dde4a350c5b76d8c080d5ddc696aa6 100644
--- a/src/hir2mpl/BUILD.gn
+++ b/src/hir2mpl/BUILD.gn
@@ -97,6 +97,7 @@ static_library("lib_hir2mpl_common") {
     "${HIR2MPL_ROOT}/common/src/hir2mpl_compiler_component.cpp",
     "${HIR2MPL_ROOT}/common/src/hir2mpl_env.cpp",
     "${HIR2MPL_ROOT}/common/src/hir2mpl_options.cpp",
+    "${HIR2MPL_ROOT}/common/src/hir2mpl_option.cpp",
     "${HIR2MPL_ROOT}/common/src/simple_xml.cpp",
     "${HIR2MPL_ROOT}/common/src/simple_zip.cpp",
     "${HIR2MPL_ROOT}/common/src/generic_attrs.cpp",
diff --git a/src/hir2mpl/common/include/hir2mpl_option.h b/src/hir2mpl/common/include/hir2mpl_option.h
new file mode 100644
index 0000000000000000000000000000000000000000..d92e11e9393fae910fe1a2395ec726aca00062d1
--- /dev/null
+++ b/src/hir2mpl/common/include/hir2mpl_option.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * 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 v2 for more details.
+ */
+
+#ifndef HIR2MPL_COMMON_INCLUDE_HIR2MPL_OPTIONS_H
+#define HIR2MPL_COMMON_INCLUDE_HIR2MPL_OPTIONS_H
+
+#include "driver_options.h"
+
+#include <stdint.h>
+#include <string>
+
+namespace opts::hir2mpl {
+extern cl::Option<bool> help;
+extern cl::Option<bool> version;
+extern cl::Option<std::string> mpltSys;
+extern cl::Option<std::string> mpltApk;
+extern cl::Option<std::string> mplt;
+extern cl::Option<std::string> inClass;
+extern cl::Option<std::string> inJar;
+extern cl::Option<std::string> inDex;
+ extern cl::Option<std::string> inAst;
+extern cl::Option<std::string> inMast;
+extern cl::Option<std::string> output;
+extern cl::Option<std::string> outputName;
+extern cl::Option<bool> mpltOnly;
+extern cl::Option<bool> asciimplt;
+extern cl::Option<bool> dumpInstComment;
+extern cl::Option<bool> noMplFile;
+extern cl::Option<uint32_t> dumpLevel;
+extern cl::Option<bool> dumpTime;
+extern cl::Option<bool> dumpComment;
+extern cl::Option<bool> dumpLOC;
+extern cl::Option<bool> dumpPhaseTime;
+extern cl::Option<bool> dumpPhaseTimeDetail;
+extern cl::Option<bool> rc;
+extern cl::Option<bool> nobarrier;
+extern cl::Option<bool> usesignedchar;
+extern cl::Option<bool> be;
+extern cl::Option<bool> o2;
+extern cl::Option<bool> simplifyShortCircuit;
+extern cl::Option<bool> enableVariableArray;
+extern cl::Option<uint32_t> funcInliceSize;
+extern cl::Option<uint32_t> np;
+extern cl::Option<bool> dumpThreadTime;
+extern cl::Option<std::string> xbootclasspath;
+extern cl::Option<std::string> classloadercontext;
+extern cl::Option<std::string> dep;
+extern cl::Option<std::string> depsamename;
+extern cl::Option<bool> npeCheckDynamic;
+extern cl::Option<bool> boundaryCheckDynamic;
+extern cl::Option<bool> safeRegion;
+extern cl::Option<bool> dumpFEIRBB;
+extern cl::Option<std::string> dumpFEIRCFGGraph;
+extern cl::Option<bool> wpaa;
+extern cl::Option<bool> debug;
+
+}
+
+#endif /* HIR2MPL_COMMON_INCLUDE_HIR2MPL_OPTIONS_H */
diff --git a/src/hir2mpl/common/include/hir2mpl_options.h b/src/hir2mpl/common/include/hir2mpl_options.h
index bbfe437c9b53e1181ae15cd33d5c5dc33a2c5e48..e561fce1ae967a9ea3dc15cc41758fa131aca695 100644
--- a/src/hir2mpl/common/include/hir2mpl_options.h
+++ b/src/hir2mpl/common/include/hir2mpl_options.h
@@ -18,12 +18,12 @@
 #include <list>
 #include "factory.h"
 #include "parser_opt.h"
-#include "option_parser.h"
+#include "mpl_options.h"
 #include "types_def.h"
-#include "driver_option_common.h"
+#include "hir2mpl_option.h"
 
 namespace maple {
-class HIR2MPLOptions : public maple::MapleDriverOptionBase {
+class HIR2MPLOptions {
  public:
   static inline HIR2MPLOptions &GetInstance() {
     static HIR2MPLOptions options;
@@ -31,7 +31,7 @@ class HIR2MPLOptions : public maple::MapleDriverOptionBase {
   }
   void Init();
   static bool InitFactory();
-  bool SolveOptions(const std::deque<mapleOption::Option> &opts, bool isDebug);
+  bool SolveOptions(bool isDebug);
   bool SolveArgs(int argc, char **argv);
   void DumpUsage() const;
   void DumpVersion() const;
@@ -43,86 +43,86 @@ class HIR2MPLOptions : public maple::MapleDriverOptionBase {
   void ProcessInputFiles(const std::vector<std::string> &inputs);
 
  private:
-  using OptionProcessFactory = FunctionFactory<uint32, bool, HIR2MPLOptions*, const mapleOption::Option&>;
+  template <typename T>
+  using OptionProcessFactory = FunctionFactory<cl::OptionInterface *, bool, HIR2MPLOptions*, const T &>;
+  using OptionFactory = OptionProcessFactory<cl::OptionInterface>;
 
   HIR2MPLOptions();
   ~HIR2MPLOptions() = default;
 
   // option process
-  bool ProcessHelp(const mapleOption::Option &opt);
-  bool ProcessVersion(const mapleOption::Option &opt);
+  bool ProcessHelp(const cl::OptionInterface &opt);
+  bool ProcessVersion(const cl::OptionInterface &opt);
 
   // input control options
-  bool ProcessInClass(const mapleOption::Option &opt);
-  bool ProcessInJar(const mapleOption::Option &opt);
-  bool ProcessInDex(const mapleOption::Option &opt);
-  bool ProcessInAST(const mapleOption::Option &opt);
-  bool ProcessInMAST(const mapleOption::Option &opt);
-  bool ProcessInputMplt(const mapleOption::Option &opt);
-  bool ProcessInputMpltFromSys(const mapleOption::Option &opt);
-  bool ProcessInputMpltFromApk(const mapleOption::Option &opt);
-
-  // output control options
-  bool ProcessOutputPath(const mapleOption::Option &opt);
-  bool ProcessOutputName(const mapleOption::Option &opt);
-  bool ProcessGenMpltOnly(const mapleOption::Option &opt);
-  bool ProcessGenAsciiMplt(const mapleOption::Option &opt);
-  bool ProcessDumpInstComment(const mapleOption::Option &opt);
-  bool ProcessNoMplFile(const mapleOption::Option &opt);
-
-  // debug info control options
-  bool ProcessDumpLevel(const mapleOption::Option &opt);
-  bool ProcessDumpTime(const mapleOption::Option &opt);
-  bool ProcessDumpComment(const mapleOption::Option &opt);
-  bool ProcessDumpLOC(const mapleOption::Option &opt);
-  bool ProcessDumpPhaseTime(const mapleOption::Option &opt);
-  bool ProcessDumpPhaseTimeDetail(const mapleOption::Option &opt);
+  bool ProcessInClass(const cl::OptionInterface &mpltSys);
+  bool ProcessInJar(const cl::OptionInterface &mpltApk);
+  bool ProcessInDex(const cl::OptionInterface &inDex);
+  bool ProcessInAST(const cl::OptionInterface &inAst);
+  bool ProcessInMAST(const cl::OptionInterface &inMast);
+  bool ProcessInputMplt(const cl::OptionInterface &mplt);
+  bool ProcessInputMpltFromSys(const cl::OptionInterface &mpltSys);
+  bool ProcessInputMpltFromApk(const cl::OptionInterface &mpltApk);
+
+  // // output control options
+  bool ProcessOutputPath(const cl::OptionInterface &output);
+  bool ProcessOutputName(const cl::OptionInterface &outputName);
+  bool ProcessGenMpltOnly(const cl::OptionInterface &opt);
+  bool ProcessGenAsciiMplt(const cl::OptionInterface &opt);
+  bool ProcessDumpInstComment(const cl::OptionInterface &opt);
+  bool ProcessNoMplFile(const cl::OptionInterface &opt);
+
+  // // debug info control options
+  bool ProcessDumpLevel(const cl::OptionInterface &outputName);
+  bool ProcessDumpTime(const cl::OptionInterface &opt);
+  bool ProcessDumpComment(const cl::OptionInterface &opt);
+  bool ProcessDumpLOC(const cl::OptionInterface &opt);
+  bool ProcessDumpPhaseTime(const cl::OptionInterface &opt);
+  bool ProcessDumpPhaseTimeDetail(const cl::OptionInterface &opt);
 
   // java compiler options
-  bool ProcessModeForJavaStaticFieldName(const mapleOption::Option &opt);
-  bool ProcessJBCInfoUsePathName(const mapleOption::Option &opt);
-  bool ProcessDumpJBCStmt(const mapleOption::Option &opt);
-  bool ProcessDumpJBCAll(const mapleOption::Option &opt);
-  bool ProcessDumpJBCErrorOnly(const mapleOption::Option &opt);
-  bool ProcessDumpJBCFuncName(const mapleOption::Option &opt);
-  bool ProcessEmitJBCLocalVarInfo(const mapleOption::Option &opt);
+  bool ProcessModeForJavaStaticFieldName(const cl::OptionInterface &opt);
+  bool ProcessJBCInfoUsePathName(const cl::OptionInterface &opt);
+  bool ProcessDumpJBCStmt(const cl::OptionInterface &opt);
+  bool ProcessDumpJBCAll(const cl::OptionInterface &opt);
+  bool ProcessDumpJBCErrorOnly(const cl::OptionInterface &opt);
+  bool ProcessDumpJBCFuncName(const cl::OptionInterface &opt);
+  bool ProcessEmitJBCLocalVarInfo(const cl::OptionInterface &opt);
 
   // bc compiler options
-  bool ProcessRC(const mapleOption::Option &opt);
-  bool ProcessNoBarrier(const mapleOption::Option &opt);
-  bool ProcessO2(const mapleOption::Option &opt);
-  bool ProcessSimplifyShortCircuit(const mapleOption::Option &opt);
-  bool ProcessEnableVariableArray(const mapleOption::Option &opt);
-  bool ProcessFuncInlineSize(const mapleOption::Option &opt);
-  bool ProcessWPAA(const mapleOption::Option &opt);
+  bool ProcessRC(const cl::OptionInterface &opt);
+  bool ProcessNoBarrier(const cl::OptionInterface &opt);
+  bool ProcessO2(const cl::OptionInterface &opt);
+  bool ProcessSimplifyShortCircuit(const cl::OptionInterface &opt);
+  bool ProcessEnableVariableArray(const cl::OptionInterface &opt);
+  bool ProcessFuncInlineSize(const cl::OptionInterface &funcInliceSize);
+  bool ProcessWPAA(const cl::OptionInterface &opt);
 
   // ast compiler options
-  bool ProcessUseSignedChar(const mapleOption::Option &opt);
-  bool ProcessBigEndian(const mapleOption::Option &opt);
+  bool ProcessUseSignedChar(const cl::OptionInterface &opt);
+  bool ProcessBigEndian(const cl::OptionInterface &opt);
 
   // general stmt/bb/cfg options
-  bool ProcessDumpFEIRBB(const mapleOption::Option &opt);
-  bool ProcessDumpFEIRCFGGraph(const mapleOption::Option &opt);
+  bool ProcessDumpFEIRBB(const cl::OptionInterface &opt);
+  bool ProcessDumpFEIRCFGGraph(const cl::OptionInterface &opt);
 
-  // multi-thread control options
-  bool ProcessNThreads(const mapleOption::Option &opt);
-  bool ProcessDumpThreadTime(const mapleOption::Option &opt);
-  bool ProcessReleaseAfterEmit(const mapleOption::Option &opt);
+  // // multi-thread control options
+  bool ProcessNThreads(const cl::OptionInterface &numThreads);
+  bool ProcessDumpThreadTime(const cl::OptionInterface &opt);
 
   // On Demand Type Creation
-  bool ProcessXbootclasspath(const mapleOption::Option &opt);
-  bool ProcessClassLoaderContext(const mapleOption::Option &opt);
-  bool ProcessCompilefile(const mapleOption::Option &opt);
-  bool ProcessCollectDepTypes(const mapleOption::Option &opt);
-  bool ProcessDepSameNamePolicy(const mapleOption::Option &opt);
+  bool ProcessXbootclasspath(const cl::OptionInterface &xbootclasspath);
+  bool ProcessClassLoaderContext(const cl::OptionInterface &classloadercontext);
+  bool ProcessCollectDepTypes(const cl::OptionInterface &dep);
+  bool ProcessDepSameNamePolicy(const cl::OptionInterface &depsamename);
 
   // EnhanceC
-  bool ProcessNpeCheckDynamic(const mapleOption::Option &opt);
-  bool ProcessBoundaryCheckDynamic(const mapleOption::Option &opt);
-  bool ProcessSafeRegion(const mapleOption::Option &opt);
+  bool ProcessNpeCheckDynamic(const cl::OptionInterface &opt);
+  bool ProcessBoundaryCheckDynamic(const cl::OptionInterface &opt);
+  bool ProcessSafeRegion(const cl::OptionInterface &opt);
 
   // symbol resolve
-  bool ProcessAOT(const mapleOption::Option &opt);
+  bool ProcessAOT(const cl::OptionInterface &opt);
 };  // class HIR2MPLOptions
 }  // namespace maple
 #endif  // HIR2MPL_INCLUDE_COMMON_HIR2MPL_OPTIONS_H
diff --git a/src/hir2mpl/common/src/hir2mpl_option.cpp b/src/hir2mpl/common/src/hir2mpl_option.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2a0b082edba44a8d8843979f60b30d7dc0655039
--- /dev/null
+++ b/src/hir2mpl/common/src/hir2mpl_option.cpp
@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * 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 v2 for more details.
+ */
+
+#include "driver_options.h"
+
+#include <stdint.h>
+#include <string>
+
+namespace opts::hir2mpl {
+
+cl::Option<bool> help({"--help", "-h"},
+                      "  -h, -help              : print usage and exit",
+                      {hir2mplCategory});
+
+cl::Option<bool> version({"--version", "-v"},
+                         "  -v, -version           : print version and exit",
+                         {hir2mplCategory});
+
+cl::Option<std::string> mpltSys({"--mplt-sys", "-mplt-sys"},
+                                "  -mplt-sys sys1.mplt,sys2.mplt\n"
+                                "                         : input sys mplt files",
+                                {hir2mplCategory});
+
+cl::Option<std::string> mpltApk({"--mplt-apk", "-mplt-apk"},
+                                "  -mplt-apk apk1.mplt,apk2.mplt\n"
+                                "                         : input apk mplt files",
+                                {hir2mplCategory});
+
+cl::Option<std::string> mplt({"--mplt", "-mplt"},
+                             "  -mplt lib1.mplt,lib2.mplt\n"
+                             "                         : input mplt files",
+                             {hir2mplCategory});
+
+cl::Option<std::string> inClass({"--in-class", "-in-class"},
+                                "  -in-class file1.jar,file2.jar\n"
+                                "                         : input class files",
+                                {hir2mplCategory});
+
+cl::Option<std::string> inJar({"--in-jar", "-in-jar"},
+                              "  -in-jar file1.jar,file2.jar\n"
+                              "                         : input jar files",
+                              {hir2mplCategory});
+
+cl::Option<std::string> inDex({"--in-dex", "-in-dex"},
+                              "  -in-dex file1.dex,file2.dex\n"
+                              "                         : input dex files",
+                              {hir2mplCategory});
+
+cl::Option<std::string> inAst({"--in-ast", "-in-ast"},
+                              "  -in-ast file1.ast,file2.ast\n"
+                              "                         : input ast files",
+                              {hir2mplCategory});
+
+cl::Option<std::string> inMast({"--in-mast", "-in-mast"},
+                               "  -in-mast file1.mast,file2.mast\n"
+                               "                         : input mast files",
+                               {hir2mplCategory});
+
+cl::Option<std::string> output({"--output", "-p"},
+                               "  -p, -output            : output path",
+                               {hir2mplCategory});
+
+cl::Option<std::string> outputName({"--output-name", "-o"},
+                                   "  -o, -output-name       : output name",
+                                   {hir2mplCategory});
+
+cl::Option<bool> mpltOnly({"--t", "-t"},
+                          "  -t                     : generate mplt only",
+                          {hir2mplCategory});
+
+cl::Option<bool> asciimplt({"--asciimplt", "-asciimplt"},
+                           "  -asciimplt             : generate mplt in ascii format",
+                           {hir2mplCategory});
+
+cl::Option<bool> dumpInstComment({"--dump-inst-comment", "-dump-inst-comment"},
+                                 "  -dump-inst-comment     : dump instruction comment",
+                                 {hir2mplCategory});
+
+cl::Option<bool> noMplFile({"--no-mpl-file", "-no-mpl-file"},
+                           "  -no-mpl-file           : disable dump mpl file",
+                           {hir2mplCategory});
+
+cl::Option<uint32_t> dumpLevel({"--dump-level", "-d"},
+                               "  -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",
+                               {hir2mplCategory});
+
+cl::Option<bool> dumpTime({"--dump-time", "-dump-time"},
+                          "  -dump-time             : dump time",
+                          {hir2mplCategory});
+
+cl::Option<bool> dumpComment({"--dump-comment", "-dump-comment"},
+                             "  -dump-comment          : gen comment stmt",
+                             {hir2mplCategory});
+
+cl::Option<bool> dumpLOC({"--dump-LOC", "-dump-LOC"},
+                         "  -dump-LOC              : gen LOC",
+                         {hir2mplCategory});
+
+cl::Option<bool> dumpPhaseTime({"--dump-phase-time", "-dump-phase-time"},
+                               "  -dump-phase-time       : dump total phase time",
+                               {hir2mplCategory});
+
+cl::Option<bool> dumpPhaseTimeDetail({"-dump-phase-time-detail", "--dump-phase-time-detail"},
+                                     "  -dump-phase-time-detail\n"      \
+                                     "                         : dump phase time for each method",
+                                     {hir2mplCategory});
+
+cl::Option<bool> rc({"-rc", "--rc"},
+                    "  -rc                    : enable rc",
+                    {hir2mplCategory});
+
+cl::Option<bool> nobarrier({"-nobarrier", "--nobarrier"},
+                           "  -nobarrier             : no barrier",
+                           {hir2mplCategory});
+
+cl::Option<bool> usesignedchar({"-usesignedchar", "--usesignedchar"},
+                               "  -usesignedchar         : use signed char",
+                               {hir2mplCategory});
+
+cl::Option<bool> be({"-be", "--be"},
+                    "  -be                    : enable big endian",
+                    {hir2mplCategory});
+
+cl::Option<bool> o2({"-O2", "--O2"},
+                    "  -O2                    : enable hir2mpl O2 optimize",
+                    {hir2mplCategory});
+
+cl::Option<bool> simplifyShortCircuit({"-simplify-short-circuit", "--simplify-short-circuit"},
+                                      "  -simplify-short-circuit\n"     \
+                                      "                         : enable simplify short circuit",
+                                      {hir2mplCategory});
+
+cl::Option<bool> enableVariableArray({"-enable-variable-array", "--enable-variable-array"},
+                                     "  -enable-variable-array\n" \
+                                     "                         : enable variable array",
+                                     {hir2mplCategory});
+
+cl::Option<uint32_t> funcInliceSize({"-func-inline-size", "--func-inline-size"},
+                                    "  -func-inline-size      : set func inline size",
+                                    {hir2mplCategory});
+
+cl::Option<uint32_t> np({"-np", "--np"},
+                        "  -np num                : number of threads",
+                        {hir2mplCategory});
+
+cl::Option<bool> dumpThreadTime({"-dump-thread-time", "--dump-thread-time"},
+                                "  -dump-thread-time      : dump thread time in mpl schedular",
+                                {hir2mplCategory});
+
+cl::Option<std::string> xbootclasspath({"-Xbootclasspath", "--Xbootclasspath"},
+                                       "  -Xbootclasspath=bootclasspath\n" \
+                                       "                         : boot class path list",
+                                       {hir2mplCategory});
+
+cl::Option<std::string> classloadercontext({"-classloadercontext", "--classloadercontext"},
+                                           "  -classloadercontext=pcl\n" \
+                                           "                         : class loader context \n" \
+                                           "                         : path class loader",
+                                           {hir2mplCategory});
+
+cl::Option<std::string> dep({"-dep", "--dep"},
+                            "  -dep=all or func\n"                      \
+                            "                         : [all]  collect all dependent types\n" \
+                            "                         : [func] collect dependent types in function",
+                            {hir2mplCategory});
+
+cl::Option<std::string> depsamename({"-depsamename", "--depsamename"},
+                                    "  -DepSameNamePolicy=sys or src\n" \
+                                    "                         : [sys] load type from sys when on-demand load same name type\n" \
+                                    "                         : [src] load type from src when on-demand load same name type",
+                                    {hir2mplCategory});
+
+cl::Option<bool> npeCheckDynamic({"-npe-check-dynamic", "--npe-check-dynamic"},
+                                 "  -npe-check-dynamic     : Nonnull pointr dynamic checking",
+                                 {hir2mplCategory});
+
+cl::Option<bool> boundaryCheckDynamic({"-boundary-check-dynamic", "--boundary-check-dynamic"},
+                                      "  -boundary-check-dynamic\n"     \
+                                      "                         : Boundary dynamic checking",
+                                      {hir2mplCategory});
+
+cl::Option<bool> safeRegion({"-safe-region", "--safe-region"},
+                            "  -boundary-check-dynamic\n"               \
+                            "  -safe-region           : Enable safe region",
+                            {hir2mplCategory});
+
+cl::Option<bool> dumpFEIRBB({"-dump-bb", "--dump-bb"},
+                            "  -dump-bb               : dump basic blocks info",
+                            {hir2mplCategory});
+
+cl::Option<std::string> dumpFEIRCFGGraph({"-dump-cfg", "--dump-cfg"},
+                                         "  -dump-cfg funcname1,funcname2\n" \
+                                         "                         : dump cfg graph to dot file",
+                                         {hir2mplCategory});
+
+cl::Option<bool> wpaa({"-wpaa", "--wpaa"},
+                      "  -dump-cfg funcname1,funcname2\n"               \
+                      "  -wpaa                  : enable whole program ailas analysis",
+                      {hir2mplCategory});
+
+cl::Option<bool> debug({"-debug", "--debug"},
+                      "  -debug                 : dump enabled options",
+                      {hir2mplCategory});
+
+}
diff --git a/src/hir2mpl/common/src/hir2mpl_options.cpp b/src/hir2mpl/common/src/hir2mpl_options.cpp
index aae8a15cdba3a181c97f36f10d696cf852f92e9d..8d14c9c34a3e5e910d1913c8f9db8914888a2000 100644
--- a/src/hir2mpl/common/src/hir2mpl_options.cpp
+++ b/src/hir2mpl/common/src/hir2mpl_options.cpp
@@ -12,284 +12,29 @@
  * FIT FOR A PARTICULAR PURPOSE.
  * See the Mulan PSL v2 for more details.
  */
+#include "driver_options.h"
+#include "file_utils.h"
+#include "hir2mpl_option.h"
 #include "hir2mpl_options.h"
-#include <iostream>
-#include <sstream>
 #include "fe_options.h"
 #include "fe_macros.h"
-#include "option_parser.h"
+#include "mpl_options.h"
 #include "parser_opt.h"
 #include "fe_file_type.h"
+#include "types_def.h"
 #include "version.h"
 
+#include <cstdint>
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include <unordered_set>
+
 namespace maple {
 using namespace mapleOption;
 
-enum OptionIndex : uint32 {
-  kHir2mplHelp = kCommonOptionEnd + 1,
-  // input control options
-  kMpltSys,
-  kMpltApk,
-  kInClass,
-  kInJar,
-  kInDex,
-  kInAST,
-  kInMAST,
-  // output control options
-  kOutputPath,
-  kOutputName,
-  kGenMpltOnly,
-  kGenAsciiMplt,
-  kDumpInstComment,
-  kNoMplFile,
-  // debug info control options
-  kDumpLevel,
-  kDumpTime,
-  kDumpComment,
-  kDumpLOC,
-  kDumpPhaseTime,
-  kDumpPhaseTimeDetail,
-  // bc bytecode compile options
-  kRC,
-  kNoBarrier,
-  // java bytecode compile options
-  kJavaStaticFieldName,
-  kJBCInfoUsePathName,
-  kDumpJBCStmt,
-  kDumpJBCAll,
-  kDumpJBCErrorOnly,
-  kDumpJBCFuncName,
-  kEmitJBCLocalVarInfo,
-  // ast compiler options
-  kUseSignedChar,
-  kFEBigEndian,
-  // general stmt/bb/cfg debug options
-  kDumpFEIRBB,
-  kDumpFEIRCFGGraph,
-  // multi-thread control options
-  kNThreads,
-  kDumpThreadTime,
-  // type-infer
-  kTypeInfer,
-  // On Demand Type Creation
-  kXBootClassPath,
-  kClassLoaderContext,
-  kInputFile,
-  kCollectDepTypes,
-  kDepSameNamePolicy,
-  // EnhanceC
-  kNpeCheckDynamic,
-  kBoundaryCheckDynamic,
-  kSafeRegion,
-  kO2,
-  kSimplifyShortCircuit,
-  kEnableVariableArray,
-  kFuncInlineSize,
-  kWPAA,
-};
-
-const Descriptor kUsage[] = {
-  { kUnknown, 0, "", "",
-    kBuildTypeAll, kArgCheckPolicyUnknown,
-    "\n====== Usage: hir2mpl [options] input1 input2 input3 ======\n"
-    " options:", "hir2mpl", {} },
-  { kHir2mplHelp, 0, "h", "help",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -h, -help              : print usage and exit", "hir2mpl", {} },
-  { kVersion, 0, "v", "version",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -v, -version           : print version and exit", "hir2mpl", {} },
-
-  // input control options
-  { kUnknown, 0, "", "",
-    kBuildTypeAll, kArgCheckPolicyUnknown,
-    "\n====== Input Control Options ======", "hir2mpl", {} },
-  { kMpltSys, 0, "", "mplt-sys",
-    kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -mplt-sys sys1.mplt,sys2.mplt\n"
-    "                         : input sys mplt files", "hir2mpl", {} },
-  { kMpltApk, 0, "", "mplt-apk",
-    kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -mplt-apk apk1.mplt,apk2.mplt\n"
-    "                         : input apk mplt files", "hir2mpl", {} },
-  { kInMplt, 0, "", "mplt",
-    kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -mplt lib1.mplt,lib2.mplt\n"
-    "                         : input mplt files", "hir2mpl", {} },
-  { kInClass, 0, "", "in-class",
-    kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -in-class file1.jar,file2.jar\n"
-    "                         : input class files", "hir2mpl", {} },
-  { kInJar, 0, "", "in-jar",
-    kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -in-jar file1.jar,file2.jar\n"
-    "                         : input jar files", "hir2mpl", {} },
-  { kInDex, 0, "", "in-dex",
-    kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -in-dex file1.dex,file2.dex\n"
-    "                         : input dex files", "hir2mpl", {} },
-  { kInAST, 0, "", "in-ast",
-    kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -in-ast file1.ast,file2.ast\n"
-    "                         : input ast files", "hir2mpl", {} },
-  { kInMAST, 0, "", "in-mast",
-    kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -in-mast file1.mast,file2.mast\n"
-    "                         : input mast files", "hir2mpl", {} },
-
-  // output control options
-  { kUnknown, 0, "", "",
-    kBuildTypeAll, kArgCheckPolicyUnknown,
-    "\n====== Output Control Options ======", "hir2mpl", {} },
-  { kOutputPath, 0, "p", "output",
-    kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -p, -output            : output path", "hir2mpl", {} },
-  { kOutputName, 0, "o", "output-name",
-    kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -o, -output-name       : output name", "hir2mpl", {} },
-  { kGenMpltOnly, 0, "t", "",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -t                     : generate mplt only", "hir2mpl", {} },
-  { kGenAsciiMplt, 0, "", "asciimplt",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -asciimplt             : generate mplt in ascii format", "hir2mpl", {} },
-  { kDumpInstComment, 0, "", "dump-inst-comment",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -dump-inst-comment     : dump instruction comment", "hir2mpl", {} },
-  { kNoMplFile, 0, "", "no-mpl-file",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -no-mpl-file           : disable dump mpl file", "hir2mpl", {} },
-
-  // debug info control options
-  { kUnknown, 0, "", "",
-    kBuildTypeAll, kArgCheckPolicyUnknown,
-    "\n====== Debug Info Control Options ======", "hir2mpl", {} },
-  { kDumpLevel, 0, "d", "dump-level",
-    kBuildTypeAll, 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", "hir2mpl", {} },
-  { kDumpTime, 0, "", "dump-time",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -dump-time             : dump time", "hir2mpl", {} },
-  { kDumpComment, 0, "", "dump-comment",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -dump-comment          : gen comment stmt", "hir2mpl", {} },
-  { kDumpLOC, 0, "", "dump-LOC",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -dump-LOC              : gen LOC", "hir2mpl", {} },
-  { kDumpPhaseTime, 0, "", "dump-phase-time",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -dump-phase-time       : dump total phase time", "hir2mpl", {} },
-  { kDumpPhaseTimeDetail, 0, "", "dump-phase-time-detail",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -dump-phase-time-detail\n" \
-    "                         : dump phase time for each method", "hir2mpl", {} },
-  { kDumpFEIRBB, 0, "", "dump-bb",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -dump-bb               : dump basic blocks info", "hir2mpl", {} },
-  { kDumpFEIRCFGGraph, 0, "", "dump-cfg",
-    kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -dump-cfg funcname1,funcname2\n"\
-    "                         : dump cfg graph to dot file", "hir2mpl", {} },
-
-  // bc bytecode compile options
-  { kUnknown, 0, "", "",
-    kBuildTypeAll, kArgCheckPolicyUnknown,
-    "\n====== BC Bytecode Compile Options ======", "hir2mpl", {} },
-  { kRC, 0, "", "rc",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -rc                    : enable rc", "hir2mpl", {} },
-  { kNoBarrier, 0, "", "nobarrier",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -nobarrier             : no barrier", "hir2mpl", {} },
-
-  // ast compiler options
-  { kUnknown, 0, "", "",
-    kBuildTypeAll, kArgCheckPolicyUnknown,
-    "\n====== ast Compile Options ======", "hir2mpl", {} },
-  { kUseSignedChar, 0, "", "usesignedchar",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -usesignedchar         : use signed char", "hir2mpl", {} },
-  { kFEBigEndian, 0, "", "be",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -be                    : enable big endian", "hir2mpl", {} },
-      { kO2, 0, "O2", "",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -O2                    : enable hir2mpl O2 optimize", "hir2mpl", {} },
-  { kSimplifyShortCircuit, 0, "", "simplify-short-circuit",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -simplify-short-circuit\n" \
-    "                         : enable simplify short circuit", "hir2mpl", {} },
-  { kEnableVariableArray, 0, "", "enable-variable-array",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -enable-variable-array\n" \
-    "                         : enable variable array", "hir2mpl", {} },
-  { kFuncInlineSize, 0, "", "func-inline-size",
-    kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -func-inline-size      : set func inline size", "hir2mpl", {} },
-  { kWPAA, 0, "", "wpaa",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -wpaa                  : enable whole program ailas analysis", "hir2mpl", {} },
-
-  // multi-thread control
-  { kUnknown, 0, "", "",
-    kBuildTypeAll, kArgCheckPolicyUnknown,
-    "\n====== Multi-Thread Control Options ======", "hir2mpl", {} },
-  { kNThreads, 0, "", "np",
-    kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -np num                : number of threads", "hir2mpl", {} },
-  { kDumpThreadTime, 0, "", "dump-thread-time",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -dump-thread-time      : dump thread time in mpl schedular", "hir2mpl", {} },
-
-  // On Demand Type Creation
-  { kUnknown, 0, "", "",
-    kBuildTypeAll, kArgCheckPolicyUnknown,
-    "\n====== On Demand Type Creation ======", "hir2mpl", {} },
-  { kXBootClassPath, 0, "", "Xbootclasspath",
-    kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -Xbootclasspath=bootclasspath\n"\
-    "                         : boot class path list", "hir2mpl", {} },
-  { kClassLoaderContext, 0, "", "classloadercontext",
-    kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -classloadercontext=pcl\n"\
-    "                         : class loader context \n"\
-    "                         : path class loader", "hir2mpl", {} },
-  { kCollectDepTypes, 0, "", "dep",
-    kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -dep=all or func\n"\
-    "                         : [all]  collect all dependent types\n"\
-    "                         : [func] collect dependent types in function", "hir2mpl", {} },
-  { kDepSameNamePolicy, 0, "", "depsamename",
-    kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -DepSameNamePolicy=sys or src\n"\
-    "                         : [sys] load type from sys when on-demand load same name type\n"\
-    "                         : [src] load type from src when on-demand load same name type", "hir2mpl", {} },
-
-  // security check
-  { kUnknown, 0, "", "",
-    kBuildTypeAll, kArgCheckPolicyUnknown,
-    "\n====== Security Check ======", "hir2mpl", {} },
-  { kNpeCheckDynamic, 0, "", "npe-check-dynamic",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -npe-check-dynamic     : Nonnull pointr dynamic checking", "hir2mpl", {} },
-  { kBoundaryCheckDynamic, 0, "", "boundary-check-dynamic",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -boundary-check-dynamic\n" \
-    "                         : Boundary dynamic checking", "hir2mpl", {} },
-  { kSafeRegion, 0, "", "safe-region",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "  -safe-region           : Enable safe region", "hir2mpl", {} },
-  { kUnknown, 0, "", "",
-    kBuildTypeAll, kArgCheckPolicyNone,
-    "\n", "hir2mpl", {} }
-};
-
 HIR2MPLOptions::HIR2MPLOptions() {
-  CreateUsages(kUsage);
   Init();
 }
 
@@ -300,315 +45,318 @@ void HIR2MPLOptions::Init() {
 }
 
 bool HIR2MPLOptions::InitFactory() {
-  RegisterFactoryFunction<OptionProcessFactory>(kHir2mplHelp,
-                                                &HIR2MPLOptions::ProcessHelp);
-  RegisterFactoryFunction<OptionProcessFactory>(kVersion,
-                                                &HIR2MPLOptions::ProcessVersion);
+
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::help,
+                                         &HIR2MPLOptions::ProcessHelp);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::version,
+                                         &HIR2MPLOptions::ProcessVersion);
 
   // input control options
-  RegisterFactoryFunction<OptionProcessFactory>(kMpltSys,
-                                                &HIR2MPLOptions::ProcessInputMpltFromSys);
-  RegisterFactoryFunction<OptionProcessFactory>(kMpltApk,
-                                                &HIR2MPLOptions::ProcessInputMpltFromApk);
-  RegisterFactoryFunction<OptionProcessFactory>(kInMplt,
-                                                &HIR2MPLOptions::ProcessInputMplt);
-  RegisterFactoryFunction<OptionProcessFactory>(kInClass,
-                                                &HIR2MPLOptions::ProcessInClass);
-  RegisterFactoryFunction<OptionProcessFactory>(kInJar,
-                                                &HIR2MPLOptions::ProcessInJar);
-  RegisterFactoryFunction<OptionProcessFactory>(kInDex,
-                                                &HIR2MPLOptions::ProcessInDex);
-  RegisterFactoryFunction<OptionProcessFactory>(kInAST,
-                                                &HIR2MPLOptions::ProcessInAST);
-  RegisterFactoryFunction<OptionProcessFactory>(kInMAST,
-                                                &HIR2MPLOptions::ProcessInMAST);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::mpltSys,
+                                         &HIR2MPLOptions::ProcessInputMpltFromSys);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::mpltApk,
+                                         &HIR2MPLOptions::ProcessInputMpltFromApk);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::mplt,
+                                         &HIR2MPLOptions::ProcessInputMplt);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::inClass,
+                                         &HIR2MPLOptions::ProcessInClass);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::inJar,
+                                         &HIR2MPLOptions::ProcessInJar);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::inDex,
+                                         &HIR2MPLOptions::ProcessInDex);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::inAst,
+                                         &HIR2MPLOptions::ProcessInAST);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::inMast,
+                                         &HIR2MPLOptions::ProcessInMAST);
 
   // output control options
-  RegisterFactoryFunction<OptionProcessFactory>(kOutputPath,
-                                                &HIR2MPLOptions::ProcessOutputPath);
-  RegisterFactoryFunction<OptionProcessFactory>(kOutputName,
-                                                &HIR2MPLOptions::ProcessOutputName);
-  RegisterFactoryFunction<OptionProcessFactory>(kGenMpltOnly,
-                                                &HIR2MPLOptions::ProcessGenMpltOnly);
-  RegisterFactoryFunction<OptionProcessFactory>(kGenAsciiMplt,
-                                                &HIR2MPLOptions::ProcessGenAsciiMplt);
-  RegisterFactoryFunction<OptionProcessFactory>(kDumpInstComment,
-                                                &HIR2MPLOptions::ProcessDumpInstComment);
-  RegisterFactoryFunction<OptionProcessFactory>(kNoMplFile,
-                                                &HIR2MPLOptions::ProcessNoMplFile);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::output,
+                                         &HIR2MPLOptions::ProcessOutputPath);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::outputName,
+                                         &HIR2MPLOptions::ProcessOutputName);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::mpltOnly,
+                                         &HIR2MPLOptions::ProcessGenMpltOnly);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::asciimplt,
+                                         &HIR2MPLOptions::ProcessGenAsciiMplt);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpInstComment,
+                                         &HIR2MPLOptions::ProcessDumpInstComment);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::noMplFile,
+                                         &HIR2MPLOptions::ProcessNoMplFile);
 
   // debug info control options
-  RegisterFactoryFunction<OptionProcessFactory>(kDumpLevel,
-                                                &HIR2MPLOptions::ProcessDumpLevel);
-  RegisterFactoryFunction<OptionProcessFactory>(kDumpTime,
-                                                &HIR2MPLOptions::ProcessDumpTime);
-  RegisterFactoryFunction<OptionProcessFactory>(kDumpComment,
-                                                &HIR2MPLOptions::ProcessDumpComment);
-  RegisterFactoryFunction<OptionProcessFactory>(kDumpLOC,
-                                                &HIR2MPLOptions::ProcessDumpLOC);
-  RegisterFactoryFunction<OptionProcessFactory>(kDumpPhaseTime,
-                                                &HIR2MPLOptions::ProcessDumpPhaseTime);
-  RegisterFactoryFunction<OptionProcessFactory>(kDumpPhaseTimeDetail,
-                                                &HIR2MPLOptions::ProcessDumpPhaseTimeDetail);
-
-  // java bytecode compile options
-  RegisterFactoryFunction<OptionProcessFactory>(kJavaStaticFieldName,
-                                                &HIR2MPLOptions::ProcessModeForJavaStaticFieldName);
-  RegisterFactoryFunction<OptionProcessFactory>(kJBCInfoUsePathName,
-                                                &HIR2MPLOptions::ProcessJBCInfoUsePathName);
-  RegisterFactoryFunction<OptionProcessFactory>(kDumpJBCStmt,
-                                                &HIR2MPLOptions::ProcessDumpJBCStmt);
-  RegisterFactoryFunction<OptionProcessFactory>(kDumpJBCErrorOnly,
-                                                &HIR2MPLOptions::ProcessDumpJBCErrorOnly);
-  RegisterFactoryFunction<OptionProcessFactory>(kDumpJBCFuncName,
-                                                &HIR2MPLOptions::ProcessDumpJBCFuncName);
-  RegisterFactoryFunction<OptionProcessFactory>(kEmitJBCLocalVarInfo,
-                                                &HIR2MPLOptions::ProcessEmitJBCLocalVarInfo);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpLevel,
+                                         &HIR2MPLOptions::ProcessDumpLevel);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpTime,
+                                         &HIR2MPLOptions::ProcessDumpTime);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpComment,
+                                         &HIR2MPLOptions::ProcessDumpComment);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpLOC,
+                                         &HIR2MPLOptions::ProcessDumpLOC);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpPhaseTime,
+                                         &HIR2MPLOptions::ProcessDumpPhaseTime);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpPhaseTimeDetail,
+                                         &HIR2MPLOptions::ProcessDumpPhaseTimeDetail);
 
   // general stmt/bb/cfg debug options
-  RegisterFactoryFunction<OptionProcessFactory>(kDumpFEIRBB,
-                                                &HIR2MPLOptions::ProcessDumpFEIRBB);
-  RegisterFactoryFunction<OptionProcessFactory>(kDumpFEIRCFGGraph,
-                                                &HIR2MPLOptions::ProcessDumpFEIRCFGGraph);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpFEIRBB,
+                                         &HIR2MPLOptions::ProcessDumpFEIRBB);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpFEIRCFGGraph,
+                                         &HIR2MPLOptions::ProcessDumpFEIRCFGGraph);
 
   // multi-thread control options
-  RegisterFactoryFunction<OptionProcessFactory>(kNThreads,
-                                                &HIR2MPLOptions::ProcessNThreads);
-  RegisterFactoryFunction<OptionProcessFactory>(kDumpThreadTime,
-                                                &HIR2MPLOptions::ProcessDumpThreadTime);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::np,
+                                         &HIR2MPLOptions::ProcessNThreads);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dumpThreadTime,
+                                         &HIR2MPLOptions::ProcessDumpThreadTime);
 
-  RegisterFactoryFunction<OptionProcessFactory>(kRC,
-                                                &HIR2MPLOptions::ProcessRC);
-  RegisterFactoryFunction<OptionProcessFactory>(kNoBarrier,
-                                                &HIR2MPLOptions::ProcessNoBarrier);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::rc,
+                                         &HIR2MPLOptions::ProcessRC);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::nobarrier,
+                                         &HIR2MPLOptions::ProcessNoBarrier);
 
   // ast compiler options
-  RegisterFactoryFunction<OptionProcessFactory>(kUseSignedChar,
-                                                &HIR2MPLOptions::ProcessUseSignedChar);
-  RegisterFactoryFunction<OptionProcessFactory>(kFEBigEndian,
-                                                &HIR2MPLOptions::ProcessBigEndian);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::usesignedchar,
+                                         &HIR2MPLOptions::ProcessUseSignedChar);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::be,
+                                         &HIR2MPLOptions::ProcessBigEndian);
   // On Demand Type Creation
-  RegisterFactoryFunction<OptionProcessFactory>(kXBootClassPath,
-                                                &HIR2MPLOptions::ProcessXbootclasspath);
-  RegisterFactoryFunction<OptionProcessFactory>(kClassLoaderContext,
-                                                &HIR2MPLOptions::ProcessClassLoaderContext);
-  RegisterFactoryFunction<OptionProcessFactory>(kInputFile,
-                                                &HIR2MPLOptions::ProcessCompilefile);
-  RegisterFactoryFunction<OptionProcessFactory>(kCollectDepTypes,
-                                                &HIR2MPLOptions::ProcessCollectDepTypes);
-  RegisterFactoryFunction<OptionProcessFactory>(kDepSameNamePolicy,
-                                                &HIR2MPLOptions::ProcessDepSameNamePolicy);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::xbootclasspath,
+                                         &HIR2MPLOptions::ProcessXbootclasspath);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::classloadercontext,
+                                         &HIR2MPLOptions::ProcessClassLoaderContext);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::dep,
+                                         &HIR2MPLOptions::ProcessCollectDepTypes);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::depsamename,
+                                         &HIR2MPLOptions::ProcessDepSameNamePolicy);
   // EnhanceC
-  RegisterFactoryFunction<OptionProcessFactory>(kNpeCheckDynamic,
-                                                &HIR2MPLOptions::ProcessNpeCheckDynamic);
-  RegisterFactoryFunction<OptionProcessFactory>(kBoundaryCheckDynamic,
-                                                &HIR2MPLOptions::ProcessBoundaryCheckDynamic);
-  RegisterFactoryFunction<OptionProcessFactory>(kSafeRegion,
-                                                &HIR2MPLOptions::ProcessSafeRegion);
-
-  RegisterFactoryFunction<OptionProcessFactory>(kO2,
-                                                &HIR2MPLOptions::ProcessO2);
-  RegisterFactoryFunction<OptionProcessFactory>(kSimplifyShortCircuit,
-                                                &HIR2MPLOptions::ProcessSimplifyShortCircuit);
-  RegisterFactoryFunction<OptionProcessFactory>(kEnableVariableArray,
-                                                &HIR2MPLOptions::ProcessEnableVariableArray);
-  RegisterFactoryFunction<OptionProcessFactory>(kFuncInlineSize,
-                                                &HIR2MPLOptions::ProcessFuncInlineSize);
-  RegisterFactoryFunction<OptionProcessFactory>(kWPAA,
-                                                &HIR2MPLOptions::ProcessWPAA);
-  return true;
-}
-
-bool HIR2MPLOptions::SolveOptions(const std::deque<Option> &opts, bool isDebug) {
-  for (const Option &opt : opts) {
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::npeCheckDynamic,
+                                         &HIR2MPLOptions::ProcessNpeCheckDynamic);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::boundaryCheckDynamic,
+                                         &HIR2MPLOptions::ProcessBoundaryCheckDynamic);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::safeRegion,
+                                         &HIR2MPLOptions::ProcessSafeRegion);
+
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::o2,
+                                         &HIR2MPLOptions::ProcessO2);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::simplifyShortCircuit,
+                                         &HIR2MPLOptions::ProcessSimplifyShortCircuit);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::enableVariableArray,
+                                         &HIR2MPLOptions::ProcessEnableVariableArray);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::funcInliceSize,
+                                         &HIR2MPLOptions::ProcessFuncInlineSize);
+  RegisterFactoryFunction<OptionFactory>(&opts::hir2mpl::wpaa,
+                                         &HIR2MPLOptions::ProcessWPAA);
+
+  return true;
+}
+
+bool HIR2MPLOptions::SolveOptions(bool isDebug) {
+
+  for (const auto &opt : hir2mplCategory.GetEnabledOptions()) {
+    std::string printOpt;
     if (isDebug) {
-      LogInfo::MapleLogger() << "hir2mpl options: " << opt.Index() << " " << opt.OptionKey() << " " <<
-                                opt.Args() << '\n';
+      for (const auto &val : opt->GetRawValues()) {
+        printOpt += opt->GetName() + " " + val + " ";
+      }
+      LogInfo::MapleLogger() << "hir2mpl options: " << printOpt << '\n';
     }
-    auto func = CreateProductFunction<OptionProcessFactory>(opt.Index());
+
+    auto func = CreateProductFunction<OptionFactory>(opt);
     if (func != nullptr) {
-      if (!func(this, opt)) {
+      if (!func(this, *opt)) {
         return false;
       }
     }
   }
+
   return true;
 }
 
 bool HIR2MPLOptions::SolveArgs(int argc, char **argv) {
-  OptionParser optionParser;
-  optionParser.RegisteUsages(DriverOptionCommon::GetInstance());
-  optionParser.RegisteUsages(HIR2MPLOptions::GetInstance());
-  if (argc == 1) {
-    DumpUsage();
-    return false;
-  }
-  ErrorCode ret = optionParser.Parse(argc, argv, "hir2mpl");
-  if (ret != ErrorCode::kErrorNoError) {
-    DumpUsage();
-    return false;
-  }
-
-  bool result = SolveOptions(optionParser.GetOptions(), false);
+  cl::CommandLine::GetCommandLine().Parse(argc, (char **)argv, hir2mplCategory);
+  bool result = SolveOptions(opts::hir2mpl::debug);
   if (!result) {
     return result;
   }
 
-  if (optionParser.GetNonOptionsCount() >= 1) {
-    const std::vector<std::string> &inputs = optionParser.GetNonOptions();
+  std::vector<std::string> inputs;
+  for (auto &arg : cl::CommandLine::GetCommandLine().badCLArgs) {
+    if (FileUtils::IsFileExists(arg.first)) {
+      inputs.push_back(arg.first);
+    } else {
+      ERR(kLncErr, "Unknown Option: %s\n", arg.first.c_str());
+      DumpUsage();
+      return result;
+    }
+  }
+
+  if (inputs.size() >= 1) {
     ProcessInputFiles(inputs);
+    return true;
+  } else {
+    ERR(kLncErr, "Input File is not specified\n");
+    DumpUsage();
+    return false;
   }
-  return true;
 }
 
 void HIR2MPLOptions::DumpUsage() const {
-  for (unsigned int i = 0; kUsage[i].help != ""; i++) {
-    std::cout << kUsage[i].help << std::endl;
-  }
+  std::cout << "\n====== Usage: hir2mpl [options] input1 input2 input3 ======\n";
+  cl::CommandLine::GetCommandLine().HelpPrinter(hir2mplCategory);
 }
 
 void HIR2MPLOptions::DumpVersion() const {
   std::cout << "Maple FE Version : " << Version::GetVersionStr() << std::endl;
 }
 
-bool HIR2MPLOptions::ProcessHelp(const Option &opt) {
+bool HIR2MPLOptions::ProcessHelp(const cl::OptionInterface &) {
   DumpUsage();
   return false;
 }
 
-bool HIR2MPLOptions::ProcessVersion(const Option &opt) {
+bool HIR2MPLOptions::ProcessVersion(const cl::OptionInterface &) {
   DumpVersion();
   return false;
 }
 
-bool HIR2MPLOptions::ProcessInClass(const Option &opt) {
-  std::list<std::string> listFiles = SplitByComma(opt.Args());
+bool HIR2MPLOptions::ProcessInClass(const cl::OptionInterface &inClass) {
+  std::string arg = inClass.GetCommonValue();
+  std::list<std::string> listFiles = SplitByComma(arg);
   for (const std::string &fileName : listFiles) {
     FEOptions::GetInstance().AddInputClassFile(fileName);
   }
   return true;
 }
 
-bool HIR2MPLOptions::ProcessInJar(const Option &opt) {
-  std::list<std::string> listFiles = SplitByComma(opt.Args());
+bool HIR2MPLOptions::ProcessInJar(const cl::OptionInterface &inJar) {
+  std::string arg = inJar.GetCommonValue();
+  std::list<std::string> listFiles = SplitByComma(arg);
   for (const std::string &fileName : listFiles) {
     FEOptions::GetInstance().AddInputJarFile(fileName);
   }
   return true;
 }
 
-bool HIR2MPLOptions::ProcessInDex(const Option &opt) {
-  std::list<std::string> listFiles = SplitByComma(opt.Args());
+bool HIR2MPLOptions::ProcessInDex(const cl::OptionInterface &inDex) {
+  std::string arg = inDex.GetCommonValue();
+  std::list<std::string> listFiles = SplitByComma(arg);
   for (const std::string &fileName : listFiles) {
     FEOptions::GetInstance().AddInputDexFile(fileName);
   }
   return true;
 }
 
-bool HIR2MPLOptions::ProcessInAST(const Option &opt) {
-  std::list<std::string> listFiles = SplitByComma(opt.Args());
+bool HIR2MPLOptions::ProcessInAST(const cl::OptionInterface &inAst) {
+  std::string arg = inAst.GetCommonValue();
+  std::list<std::string> listFiles = SplitByComma(arg);
   for (const std::string &fileName : listFiles) {
     FEOptions::GetInstance().AddInputASTFile(fileName);
   }
   return true;
 }
 
-bool HIR2MPLOptions::ProcessInMAST(const Option &opt) {
-  std::list<std::string> listFiles = SplitByComma(opt.Args());
+bool HIR2MPLOptions::ProcessInMAST(const cl::OptionInterface &inMast) {
+  std::string arg = inMast.GetCommonValue();
+  std::list<std::string> listFiles = SplitByComma(arg);
   for (const std::string &fileName : listFiles) {
     FEOptions::GetInstance().AddInputMASTFile(fileName);
   }
   return true;
 }
 
-bool HIR2MPLOptions::ProcessInputMplt(const Option &opt) {
-  std::list<std::string> listFiles = SplitByComma(opt.Args());
+bool HIR2MPLOptions::ProcessInputMplt(const cl::OptionInterface &mplt) {
+  std::string arg = mplt.GetCommonValue();
+  std::list<std::string> listFiles = SplitByComma(arg);
   for (const std::string &fileName : listFiles) {
     FEOptions::GetInstance().AddInputMpltFile(fileName);
   }
   return true;
 }
 
-bool HIR2MPLOptions::ProcessInputMpltFromSys(const Option &opt) {
-  std::list<std::string> listFiles = SplitByComma(opt.Args());
+bool HIR2MPLOptions::ProcessInputMpltFromSys(const cl::OptionInterface &mpltSys) {
+  std::string arg = mpltSys.GetCommonValue();
+  std::list<std::string> listFiles = SplitByComma(arg);
   for (const std::string &fileName : listFiles) {
     FEOptions::GetInstance().AddInputMpltFileFromSys(fileName);
   }
   return true;
 }
 
-bool HIR2MPLOptions::ProcessInputMpltFromApk(const Option &opt) {
-  std::list<std::string> listFiles = SplitByComma(opt.Args());
+bool HIR2MPLOptions::ProcessInputMpltFromApk(const cl::OptionInterface &mpltApk) {
+  std::string arg = mpltApk.GetCommonValue();;
+  std::list<std::string> listFiles = SplitByComma(arg);
   for (const std::string &fileName : listFiles) {
     FEOptions::GetInstance().AddInputMpltFileFromApk(fileName);
   }
   return true;
 }
 
-bool HIR2MPLOptions::ProcessOutputPath(const Option &opt) {
-  FEOptions::GetInstance().SetOutputPath(opt.Args());
+bool HIR2MPLOptions::ProcessOutputPath(const cl::OptionInterface &output) {
+  std::string arg = output.GetCommonValue();
+  FEOptions::GetInstance().SetOutputPath(arg);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessOutputName(const Option &opt) {
-  FEOptions::GetInstance().SetOutputName(opt.Args());
+bool HIR2MPLOptions::ProcessOutputName(const cl::OptionInterface &outputName) {
+  std::string arg = outputName.GetCommonValue();
+  FEOptions::GetInstance().SetOutputName(arg);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessGenMpltOnly(const Option &opt) {
+bool HIR2MPLOptions::ProcessGenMpltOnly(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetIsGenMpltOnly(true);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessGenAsciiMplt(const Option &opt) {
+bool HIR2MPLOptions::ProcessGenAsciiMplt(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetIsGenAsciiMplt(true);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessDumpInstComment(const Option &opt) {
+bool HIR2MPLOptions::ProcessDumpInstComment(const cl::OptionInterface &) {
   FEOptions::GetInstance().EnableDumpInstComment();
   return true;
 }
 
-bool HIR2MPLOptions::ProcessNoMplFile(const Option &opt) {
-  (void)opt;
+bool HIR2MPLOptions::ProcessNoMplFile(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetNoMplFile();
   return true;
 }
 
-bool HIR2MPLOptions::ProcessDumpLevel(const Option &opt) {
-  FEOptions::GetInstance().SetDumpLevel(std::stoi(opt.Args()));
+bool HIR2MPLOptions::ProcessDumpLevel(const cl::OptionInterface &outputName) {
+  uint32_t arg = outputName.GetCommonValue();
+  FEOptions::GetInstance().SetDumpLevel(arg);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessDumpTime(const Option &opt) {
+bool HIR2MPLOptions::ProcessDumpTime(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetIsDumpTime(true);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessDumpComment(const Option &opt) {
+bool HIR2MPLOptions::ProcessDumpComment(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetIsDumpComment(true);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessDumpLOC(const Option &opt) {
+bool HIR2MPLOptions::ProcessDumpLOC(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetIsDumpLOC(true);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessDumpPhaseTime(const Option &opt) {
+bool HIR2MPLOptions::ProcessDumpPhaseTime(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetIsDumpPhaseTime(true);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessDumpPhaseTimeDetail(const Option &opt) {
+bool HIR2MPLOptions::ProcessDumpPhaseTimeDetail(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetIsDumpPhaseTimeDetail(true);
   return true;
 }
 
 // java compiler options
-bool HIR2MPLOptions::ProcessModeForJavaStaticFieldName(const Option &opt) {
-  std::string arg = opt.Args();
+bool HIR2MPLOptions::ProcessModeForJavaStaticFieldName(const cl::OptionInterface &opt) {
+  const std::string &arg = opt.GetCommonValue();
   if (arg.compare("notype") == 0) {
     FEOptions::GetInstance().SetModeJavaStaticFieldName(FEOptions::ModeJavaStaticFieldName::kNoType);
   } else if (arg.compare("alltype") == 0) {
@@ -622,28 +370,28 @@ bool HIR2MPLOptions::ProcessModeForJavaStaticFieldName(const Option &opt) {
   return true;
 }
 
-bool HIR2MPLOptions::ProcessJBCInfoUsePathName(const Option &opt) {
+bool HIR2MPLOptions::ProcessJBCInfoUsePathName(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetIsJBCInfoUsePathName(true);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessDumpJBCStmt(const Option &opt) {
+bool HIR2MPLOptions::ProcessDumpJBCStmt(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetIsDumpJBCStmt(true);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessDumpJBCAll(const Option &opt) {
+bool HIR2MPLOptions::ProcessDumpJBCAll(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetIsDumpJBCAll(true);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessDumpJBCErrorOnly(const Option &opt) {
+bool HIR2MPLOptions::ProcessDumpJBCErrorOnly(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetIsDumpJBCErrorOnly(true);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessDumpJBCFuncName(const Option &opt) {
-  std::string arg = opt.Args();
+bool HIR2MPLOptions::ProcessDumpJBCFuncName(const cl::OptionInterface &opt) {
+  std::string arg = opt.GetCommonValue();
   while (!arg.empty()) {
     size_t pos = arg.find(",");
     if (pos != std::string::npos) {
@@ -657,41 +405,42 @@ bool HIR2MPLOptions::ProcessDumpJBCFuncName(const Option &opt) {
   return true;
 }
 
-bool HIR2MPLOptions::ProcessEmitJBCLocalVarInfo(const Option &opt) {
+bool HIR2MPLOptions::ProcessEmitJBCLocalVarInfo(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetIsEmitJBCLocalVarInfo(true);
   return true;
 }
 
 // bc compiler options
-bool HIR2MPLOptions::ProcessRC(const Option &opt) {
+bool HIR2MPLOptions::ProcessRC(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetRC(true);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessNoBarrier(const Option &opt) {
+bool HIR2MPLOptions::ProcessNoBarrier(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetNoBarrier(true);
   return true;
 }
 
 // ast compiler options
-bool HIR2MPLOptions::ProcessUseSignedChar(const Option &opt) {
+bool HIR2MPLOptions::ProcessUseSignedChar(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetUseSignedChar(true);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessBigEndian(const Option &opt) {
+bool HIR2MPLOptions::ProcessBigEndian(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetBigEndian(true);
   return true;
 }
 
 // general stmt/bb/cfg debug options
-bool HIR2MPLOptions::ProcessDumpFEIRBB(const Option &opt) {
+bool HIR2MPLOptions::ProcessDumpFEIRBB(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetIsDumpFEIRBB(true);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessDumpFEIRCFGGraph(const Option &opt) {
-  std::list<std::string> funcNameList = SplitByComma(opt.Args());
+bool HIR2MPLOptions::ProcessDumpFEIRCFGGraph(const cl::OptionInterface &opt) {
+  std::string arg = opt.GetCommonValue();
+  std::list<std::string> funcNameList = SplitByComma(arg);
   for (const std::string &funcName : funcNameList) {
     FEOptions::GetInstance().AddFuncNameForDumpCFGGraph(funcName);
   }
@@ -699,16 +448,13 @@ bool HIR2MPLOptions::ProcessDumpFEIRCFGGraph(const Option &opt) {
 }
 
 // multi-thread control options
-bool HIR2MPLOptions::ProcessNThreads(const Option &opt) {
-  std::string arg = opt.Args();
-  int np = std::stoi(arg);
-  if (np > 0) {
-    FEOptions::GetInstance().SetNThreads(static_cast<uint32>(np));
-  }
+bool HIR2MPLOptions::ProcessNThreads(const cl::OptionInterface &numThreads) {
+  uint32_t num = numThreads.GetCommonValue();
+  FEOptions::GetInstance().SetNThreads(num);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessDumpThreadTime(const Option &opt) {
+bool HIR2MPLOptions::ProcessDumpThreadTime(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetDumpThreadTime(true);
   return true;
 }
@@ -746,26 +492,22 @@ void HIR2MPLOptions::ProcessInputFiles(const std::vector<std::string> &inputs) {
 }
 
 // Xbootclasspath
-bool HIR2MPLOptions::ProcessXbootclasspath(const Option &opt) {
-  FEOptions::GetInstance().SetXBootClassPath(opt.Args());
+bool HIR2MPLOptions::ProcessXbootclasspath(const cl::OptionInterface &xbootclasspath) {
+  std::string arg = xbootclasspath.GetCommonValue();
+  FEOptions::GetInstance().SetXBootClassPath(arg);
   return true;
 }
 
 // PCL
-bool HIR2MPLOptions::ProcessClassLoaderContext(const Option &opt) {
-  FEOptions::GetInstance().SetClassLoaderContext(opt.Args());
-  return true;
-}
-
-// CompileFile
-bool HIR2MPLOptions::ProcessCompilefile(const Option &opt) {
-  FEOptions::GetInstance().SetCompileFileName(opt.Args());
+bool HIR2MPLOptions::ProcessClassLoaderContext(const cl::OptionInterface &classloadercontext) {
+  std::string arg = classloadercontext.GetCommonValue();
+  FEOptions::GetInstance().SetClassLoaderContext(arg);
   return true;
 }
 
 // Dep
-bool HIR2MPLOptions::ProcessCollectDepTypes(const Option &opt) {
-  std::string arg = opt.Args();
+bool HIR2MPLOptions::ProcessCollectDepTypes(const cl::OptionInterface &dep) {
+  const std::string arg = dep.GetCommonValue();
   if (arg.compare("all") == 0) {
     FEOptions::GetInstance().SetModeCollectDepTypes(FEOptions::ModeCollectDepTypes::kAll);
   } else if (arg.compare("func") == 0) {
@@ -778,8 +520,8 @@ bool HIR2MPLOptions::ProcessCollectDepTypes(const Option &opt) {
 }
 
 // SameNamePolicy
-bool HIR2MPLOptions::ProcessDepSameNamePolicy(const Option &opt) {
-  std::string arg = opt.Args();
+bool HIR2MPLOptions::ProcessDepSameNamePolicy(const cl::OptionInterface &depsamename) {
+  const std::string arg = depsamename.GetCommonValue();
   if (arg.compare("sys") == 0) {
     FEOptions::GetInstance().SetModeDepSameNamePolicy(FEOptions::ModeDepSameNamePolicy::kSys);
   } else if (arg.compare("src") == 0) {
@@ -792,17 +534,17 @@ bool HIR2MPLOptions::ProcessDepSameNamePolicy(const Option &opt) {
 }
 
 // EnhanceC
-bool HIR2MPLOptions::ProcessNpeCheckDynamic(const mapleOption::Option &opt) {
+bool HIR2MPLOptions::ProcessNpeCheckDynamic(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetNpeCheckDynamic(true);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessBoundaryCheckDynamic(const mapleOption::Option &opt) {
+bool HIR2MPLOptions::ProcessBoundaryCheckDynamic(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetBoundaryCheckDynamic(true);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessSafeRegion(const mapleOption::Option &opt) {
+bool HIR2MPLOptions::ProcessSafeRegion(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetSafeRegion(true);
   // boundary and npe checking options will be opened, if safe region option is opened
   FEOptions::GetInstance().SetNpeCheckDynamic(true);
@@ -810,38 +552,35 @@ bool HIR2MPLOptions::ProcessSafeRegion(const mapleOption::Option &opt) {
   return true;
 }
 
-bool HIR2MPLOptions::ProcessO2(const mapleOption::Option &opt) {
-  FEOptions::GetInstance().SetO2(true);
+bool HIR2MPLOptions::ProcessO2(const cl::OptionInterface &) {
+  /* Enable when O2 for hir2mpl will be fixed: FEOptions::GetInstance().SetO2(true); */
   return true;
 }
 
-bool HIR2MPLOptions::ProcessSimplifyShortCircuit(const mapleOption::Option &opt) {
+bool HIR2MPLOptions::ProcessSimplifyShortCircuit(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetSimplifyShortCircuit(true);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessEnableVariableArray(const mapleOption::Option &opt) {
+bool HIR2MPLOptions::ProcessEnableVariableArray(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetEnableVariableArray(true);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessFuncInlineSize(const mapleOption::Option &opt) {
-  std::string arg = opt.Args();
-  int size = std::stoi(arg);
-  if (size > 0) {
-    FEOptions::GetInstance().SetFuncInlineSize(static_cast<uint32>(size));
-  }
+bool HIR2MPLOptions::ProcessFuncInlineSize(const cl::OptionInterface &funcInliceSize) {
+  uint32_t size = funcInliceSize.GetCommonValue();
+  FEOptions::GetInstance().SetFuncInlineSize(size);
   return true;
 }
 
-bool HIR2MPLOptions::ProcessWPAA(const mapleOption::Option &opt) {
+bool HIR2MPLOptions::ProcessWPAA(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetWPAA(true);
   FEOptions::GetInstance().SetFuncInlineSize(UINT32_MAX);
   return true;
 }
 
 // AOT
-bool HIR2MPLOptions::ProcessAOT(const Option &opt) {
+bool HIR2MPLOptions::ProcessAOT(const cl::OptionInterface &) {
   FEOptions::GetInstance().SetIsAOT(true);
   return true;
 }
diff --git a/src/hir2mpl/test/common/hir2mpl_ut_options.cpp b/src/hir2mpl/test/common/hir2mpl_ut_options.cpp
index d4e1df5b18e021c095a1cfc0e49298653dd755b7..4fbda43b5d1420e907b94d8f87b761c090e9adc5 100644
--- a/src/hir2mpl/test/common/hir2mpl_ut_options.cpp
+++ b/src/hir2mpl/test/common/hir2mpl_ut_options.cpp
@@ -12,60 +12,56 @@
  * FIT FOR A PARTICULAR PURPOSE.
  * See the Mulan PSL v2 for more details.
  */
+#include "cl_option.h"
 #include "hir2mpl_ut_options.h"
 #include <iostream>
 #include "mpl_logging.h"
-#include "option_parser.h"
+#include "mpl_options.h"
 #include "parser_opt.h"
 
 namespace maple {
 using namespace mapleOption;
 
-enum OptionIndex {
-  kHir2mplUTHelp = kCommonOptionEnd + 1,   // -h
-  kGenBase64,                            // -genBase64
-  kInClass,                              // -in-class
-  kInJar,                                // -in-jar
-  kMplt,                                 // -mplt
-};
-
-const Descriptor kUsage[] = {
-  { kUnknown, 0, "", "", kBuildTypeAll, kArgCheckPolicyUnknown,
-    "========================================\n"
-    " Run gtest: hir2mplUT\n"
-    " Run gtest: hir2mplUT test [ options for gtest ]\n"
-    " Run ext mode: hir2mplUT ext [ options ]\n"
-    "========= options for ext mode =========" },
-  { kHelp, 0, "h", "help", kBuildTypeAll, kArgCheckPolicyNone,
-    "  -h, --help                : print usage and exit", "hir2mplUT", {} },
-  { kGenBase64, 0, "", "gen-base64", kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -gen-base64 file.xx       : generate base64 string for file.xx", "hir2mplUT", {} },
-  { kInClass, 0, "", "in-class", kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -in-class file1.class,file2.class\n"
-    "                            : input class files", "hir2mplUT", {} },
-  { kInJar, 0, "", "in-jar", kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -in-jar file1.jar,file2.jar\n"
-    "                            : input jar files", "hir2mplUT", {} },
-  { kMplt, 0, "", "mplt", kBuildTypeAll, kArgCheckPolicyRequired,
-    "  -mplt lib1.mplt,lib2.mplt\n"
-    "                            : input mplt files", "hir2mplUT", {} },
-  { kUnknown, 0, "", "", kBuildTypeAll, kArgCheckPolicyNone, "", "hir2mplUT", {} }
-};
+namespace opts::hir2mplut {
+
+static cl::OptionCategory hir2mplUTCategory;
+
+cl::Option<bool> help({"--help", "-h"},
+                      "  -h, -help              : print usage and exit",
+                      {hir2mplUTCategory});
+cl::Option<std::string> genBase64({"--gen-base64", "-gen-base64"},
+                                  "  -gen-base64 file.xx       : generate base64 string for file.xx",
+                                  {hir2mplUTCategory});
+cl::Option<std::string> mplt({"--mplt", "-mplt"},
+                             "  -mplt lib1.mplt,lib2.mplt\n"
+                             "                         : input mplt files",
+                             {hir2mplUTCategory});
+
+cl::Option<std::string> inClass({"--in-class", "-in-class"},
+                                "  -in-class file1.jar,file2.jar\n"
+                                "                         : input class files",
+                                {hir2mplUTCategory});
+
+cl::Option<std::string> inJar({"--in-jar", "-in-jar"},
+                              "  -in-jar file1.jar,file2.jar\n"
+                              "                         : input jar files",
+                              {hir2mplUTCategory});
+}
 
 HIR2MPLUTOptions::HIR2MPLUTOptions()
     : runAll(false),
       runAllWithCore(false),
       genBase64(false),
       base64SrcFileName(""),
-      coreMpltName("") {
-        CreateUsages(kUsage);
-      }
+      coreMpltName("") {}
 
 void HIR2MPLUTOptions::DumpUsage() const {
-  for (unsigned int i = 0; !kUsage[i].help.empty(); i++) {
-    std::cout << kUsage[i].help << std::endl;
-  }
-  exit(1);
+  std::cout << "========================================\n"
+            << " Run gtest: hir2mplUT\n"
+            << " Run gtest: hir2mplUT test [ options for gtest ]\n"
+            << " Run ext mode: hir2mplUT ext [ options ]\n"
+            << "========= options for ext mode =========\n";
+  cl::CommandLine::GetCommandLine().HelpPrinter(opts::hir2mplut::hir2mplUTCategory);
 }
 
 bool HIR2MPLUTOptions::SolveArgs(int argc, char **argv) {
@@ -88,40 +84,31 @@ bool HIR2MPLUTOptions::SolveArgs(int argc, char **argv) {
     return false;
   }
   runAll = false;
-  OptionParser optionParser;
-  optionParser.RegisteUsages(DriverOptionCommon::GetInstance());
-  optionParser.RegisteUsages(HIR2MPLUTOptions::GetInstance());
 
-  ErrorCode ret = optionParser.Parse(argc, argv, "hir2mplUT");
-  if (ret != ErrorCode::kErrorNoError) {
+  cl::CommandLine::GetCommandLine().Parse(argc, (char **)argv,
+                                          opts::hir2mplut::hir2mplUTCategory);
+
+  if (opts::hir2mplut::help) {
     DumpUsage();
     return false;
   }
 
-  for (auto opt : optionParser.GetOptions()) {
-    switch (opt.Index()) {
-      case kHir2mplUTHelp:
-        DumpUsage();
-        return false;
-      case kGenBase64:
-        base64SrcFileName = opt.Args();
-        genBase64 = true;
-        break;
-      case kInClass:
-        Split(opt.Args(), ',', std::back_inserter(classFileList));
-        break;
-      case kInJar:
-        Split(opt.Args(), ',', std::back_inserter(jarFileList));
-        break;
-      case kMplt:
-        Split(opt.Args(), ',', std::back_inserter(mpltFileList));
-        break;
-      default:
-        FATAL(kLncFatal, "Unsupport option %s", opt.OptionKey().c_str());
-        DumpUsage();
-        return false;
-    }
+  if (opts::hir2mplut::genBase64.IsEnabledByUser()) {
+    base64SrcFileName = opts::hir2mplut::genBase64;
   }
+
+  if (opts::hir2mplut::inClass.IsEnabledByUser()) {
+    Split(opts::hir2mplut::inClass, ',', std::back_inserter(classFileList));
+  }
+
+  if (opts::hir2mplut::inJar.IsEnabledByUser()) {
+    Split(opts::hir2mplut::inJar, ',', std::back_inserter(jarFileList));
+  }
+
+  if (opts::hir2mplut::mplt.IsEnabledByUser()) {
+    Split(opts::hir2mplut::mplt, ',', std::back_inserter(mpltFileList));
+  }
+
   return true;
 }
 
@@ -134,4 +121,4 @@ void HIR2MPLUTOptions::Split(const std::string &s, char delim, Out result) {
     *(result++) = item;
   }
 }
-}  // namespace maple
\ No newline at end of file
+}  // namespace maple
diff --git a/src/hir2mpl/test/common/hir2mpl_ut_options.h b/src/hir2mpl/test/common/hir2mpl_ut_options.h
index ebce2bf7016ac41d5e93ed9e108622555cd1df86..58ff2b6bdb5df5825d704b54474a364381c45c2f 100644
--- a/src/hir2mpl/test/common/hir2mpl_ut_options.h
+++ b/src/hir2mpl/test/common/hir2mpl_ut_options.h
@@ -16,10 +16,9 @@
 #define HIR2MPL_INCLUDE_HIR2MPL_UT_OPTIONS_H
 #include <string>
 #include <list>
-#include "driver_option_common.h"
 
 namespace maple {
-class HIR2MPLUTOptions : public maple::MapleDriverOptionBase {
+class HIR2MPLUTOptions {
  public:
   HIR2MPLUTOptions();
   ~HIR2MPLUTOptions() = default;
@@ -77,4 +76,4 @@ class HIR2MPLUTOptions : public maple::MapleDriverOptionBase {
 };
 }  // namespace maple
 
-#endif  // HIR2MPL_INCLUDE_HIR2MPL_UT_OPTIONS_H
\ No newline at end of file
+#endif  // HIR2MPL_INCLUDE_HIR2MPL_UT_OPTIONS_H
diff --git a/src/mapleall/maple_be/BUILD.gn b/src/mapleall/maple_be/BUILD.gn
index 484c399a42edd87c753788f53425750c89609c34..d7f76c67b649f55dc8f0d52951abee9d6d7fca6b 100644
--- a/src/mapleall/maple_be/BUILD.gn
+++ b/src/mapleall/maple_be/BUILD.gn
@@ -207,6 +207,7 @@ src_libcg = [
   "src/cg/cgfunc.cpp",
   "src/cg/cg_cfg.cpp",
   "src/cg/cg_option.cpp",
+  "src/cg/cg_options.cpp",
   "src/cg/dbg.cpp",
   "src/cg/optimize_common.cpp",
   "src/cg/eh_func.cpp",
diff --git a/src/mapleall/maple_be/include/cg/cg_option.h b/src/mapleall/maple_be/include/cg/cg_option.h
index 604ac147fa303ac0574f44a4669c4bc2432f3bde..21cf36b57fc810797a3a6d3bcd0898ea5098a1fe 100644
--- a/src/mapleall/maple_be/include/cg/cg_option.h
+++ b/src/mapleall/maple_be/include/cg/cg_option.h
@@ -20,7 +20,6 @@
 #include "mempool_allocator.h"
 #include "mir_module.h"
 #include "types_def.h"
-#include "driver_option_common.h"
 
 namespace maplebe {
 using namespace maple;
@@ -30,7 +29,7 @@ struct Range {
   uint64 end;
 };
 
-class CGOptions : public MapleDriverOptionBase {
+class CGOptions {
  public:
   enum OptionEnum : uint64 {
     kUndefined = 0ULL,
@@ -126,10 +125,8 @@ class CGOptions : public MapleDriverOptionBase {
 
  public:
   static CGOptions &GetInstance();
-  CGOptions();
   virtual ~CGOptions() = default;
-  bool SolveOptions(const std::deque<mapleOption::Option> &opts, bool isDebug);
-  void DecideMplcgRealLevel(const std::deque<mapleOption::Option> &inputOptions, bool isDebug);
+  bool SolveOptions(bool isDebug);
 
   void DumpOptions();
   std::vector<std::string> &GetSequence() {
diff --git a/src/mapleall/maple_be/include/cg/cg_options.h b/src/mapleall/maple_be/include/cg/cg_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..cc9e0b1b5c8150c17b2f47834a04b457b3190864
--- /dev/null
+++ b/src/mapleall/maple_be/include/cg/cg_options.h
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * 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 v2 for more details.
+ */
+
+#ifndef MAPLE_BE_INCLUDE_CG_OPTION_H
+#define MAPLE_BE_INCLUDE_CG_OPTION_H
+
+#include "cl_option.h"
+#include "cl_parser.h"
+
+#include <bits/stdint-uintn.h>
+#include <stdint.h>
+#include <string>
+
+namespace opts::cg {
+
+extern cl::Option<bool> pie;
+extern cl::Option<bool> fpic;
+extern cl::Option<bool> verboseAsm;
+extern cl::Option<bool> verboseCg;
+extern cl::Option<bool> maplelinker;
+extern cl::Option<bool> quiet;
+extern cl::Option<bool> cg;
+extern cl::Option<bool> replaceAsm;
+extern cl::Option<bool> generalRegOnly;
+extern cl::Option<bool> lazyBinding;
+extern cl::Option<bool> hotFix;
+extern cl::Option<bool> ebo;
+extern cl::Option<bool> cfgo;
+extern cl::Option<bool> ico;
+extern cl::Option<bool> storeloadopt;
+extern cl::Option<bool> globalopt;
+extern cl::Option<bool> prelsra;
+extern cl::Option<bool> lsraLvarspill;
+extern cl::Option<bool> lsraOptcallee;
+extern cl::Option<bool> calleeregsPlacement;
+extern cl::Option<bool> ssapreSave;
+extern cl::Option<bool> ssupreRestore;
+extern cl::Option<bool> prepeep;
+extern cl::Option<bool> peep;
+extern cl::Option<bool> preschedule;
+extern cl::Option<bool> schedule;
+extern cl::Option<bool> retMerge;
+extern cl::Option<bool> vregRename;
+extern cl::Option<bool> fullcolor;
+extern cl::Option<bool> writefieldopt;
+extern cl::Option<bool> dumpOlog;
+extern cl::Option<bool> nativeopt;
+extern cl::Option<bool> objmap;
+extern cl::Option<bool> yieldpoint;
+extern cl::Option<bool> proepilogue;
+extern cl::Option<bool> localRc;
+extern cl::Option<std::string> insertCall;
+extern cl::Option<bool> addDebugTrace;
+extern cl::Option<bool> addFuncProfile;
+extern cl::Option<std::string> classListFile;
+extern cl::Option<bool> genCMacroDef;
+extern cl::Option<bool> genGctibFile;
+extern cl::Option<bool> stackguard;
+extern cl::Option<bool> debug;
+extern cl::Option<bool> gdwarf;
+extern cl::Option<bool> gsrc;
+extern cl::Option<bool> gmixedsrc;
+extern cl::Option<bool> gmixedasm;
+extern cl::Option<bool> profile;
+extern cl::Option<bool> withRaLinearScan;
+extern cl::Option<bool> withRaGraphColor;
+extern cl::Option<bool> patchLongBranch;
+extern cl::Option<bool> constFold;
+extern cl::Option<std::string> ehExclusiveList;
+extern cl::Option<bool> o0;
+extern cl::Option<bool> o1;
+extern cl::Option<bool> o2;
+extern cl::Option<bool> os;
+extern cl::Option<uint64_t> lsraBb;
+extern cl::Option<uint64_t> lsraInsn;
+extern cl::Option<uint64_t> lsraOverlap;
+extern cl::Option<uint8_t> remat;
+extern cl::Option<bool> suppressFileinfo;
+extern cl::Option<bool> dumpCfg;
+extern cl::Option<std::string> target;
+extern cl::Option<std::string> dumpPhases;
+extern cl::Option<std::string> skipPhases;
+extern cl::Option<std::string> skipFrom;
+extern cl::Option<std::string> skipAfter;
+extern cl::Option<std::string> dumpFunc;
+extern cl::Option<bool> timePhases;
+extern cl::Option<bool> useBarriersForVolatile;
+extern cl::Option<std::string> range;
+extern cl::Option<uint8_t> fastAlloc;
+extern cl::Option<std::string> spillRange;
+extern cl::Option<bool> dupBb;
+extern cl::Option<bool> calleeCfi;
+extern cl::Option<bool> printFunc;
+extern cl::Option<std::string> cyclePatternList;
+extern cl::Option<std::string> duplicateAsmList;
+extern cl::Option<std::string> duplicateAsmList2;
+extern cl::Option<std::string> blockMarker;
+extern cl::Option<bool> soeCheck;
+extern cl::Option<bool> checkArraystore;
+extern cl::Option<bool> debugSchedule;
+extern cl::Option<bool> bruteforceSchedule;
+extern cl::Option<bool> simulateSchedule;
+extern cl::Option<bool> crossLoc;
+extern cl::Option<std::string> floatAbi;
+extern cl::Option<std::string> filetype;
+extern cl::Option<bool> longCalls;
+extern cl::Option<bool> functionSections;
+extern cl::Option<bool> omitFramePointer;
+extern cl::Option<bool> fastMath;
+extern cl::Option<bool> tailcall;
+extern cl::Option<bool> alignAnalysis;
+extern cl::Option<bool> cgSsa;
+extern cl::Option<bool> common;
+extern cl::Option<bool> arm64Ilp32;
+extern cl::Option<bool> condbrAlign;
+extern cl::Option<uint32_t> alignMinBbSize;
+extern cl::Option<uint32_t> alignMaxBbSize;
+extern cl::Option<uint32_t> loopAlignPow;
+extern cl::Option<uint32_t> jumpAlignPow;
+extern cl::Option<uint32_t> funcAlignPow;
+
+}
+
+#endif /* MAPLE_BE_INCLUDE_CG_OPTION_H */
diff --git a/src/mapleall/maple_be/src/cg/cg_option.cpp b/src/mapleall/maple_be/src/cg/cg_option.cpp
index 26490e26b7cc83b94d722556989b82800a6361fe..61638d20b11087d3fd9fc841a680a75d0c2d2590 100644
--- a/src/mapleall/maple_be/src/cg/cg_option.cpp
+++ b/src/mapleall/maple_be/src/cg/cg_option.cpp
@@ -13,13 +13,16 @@
  * See the Mulan PSL v2 for more details.
  */
 #include "cg_option.h"
+#include "cg_options.h"
+#include "driver_options.h"
+#include <cstdint>
 #include <fstream>
 #include <string>
 #include <unordered_map>
 #include "mpl_logging.h"
 #include "parser_opt.h"
 #include "mir_parser.h"
-#include "option_parser.h"
+#include "mpl_options.h"
 #include "string_utils.h"
 
 namespace maplebe {
@@ -121,1577 +124,475 @@ bool CGOptions::cgBigEndian = false;
 bool CGOptions::arm64ilp32 = false;
 bool CGOptions::noCommon = false;
 
-enum OptionIndex : uint64 {
-  kCGQuiet = kCommonOptionEnd + 1,
-  kTargetMachine,
-  kPie,
-  kPic,
-  kCGVerbose,
-  kCGVerboseCG,
-  kCGMapleLinker,
-  kCgen,
-  kEbo,
-  kCfgo,
-  kIco,
-  kSlo,
-  kGo,
-  kPreLSRAOpt,
-  kLocalrefSpill,
-  kOptCallee,
-  kPrepeep,
-  kPeep,
-  kPreSchedule,
-  kSchedule,
-  kRetMerge,
-  kVregRename,
-  kMultiPassRA,
-  kWriteRefFieldOpt,
-  kDumpOlog,
-  kCGNativeOpt,
-  kInsertCall,
-  kTrace,
-  kCGClassList,
-  kGenDef,
-  kGenGctib,
-  kCGBarrier,
-  kGenPrimorList,
-  kRaLinear,
-  kRaColor,
-  kPatchBranch,
-  kConstFoldOpt,
-  kSuppressFinfo,
-  kEhList,
-  kObjMap,
-  kCGDumpcfg,
-  kCGTimePhases,
-  kCGDumpFunc,
-  kDebuggingInfo,
-  kStackGuard,
-  kDebugGenDwarf,
-  kDebugUseSrc,
-  kDebugUseMix,
-  kDebugAsmMix,
-  kProfilingInfo,
-  kProfileEnable,
-  kLSRABB,
-  kLSRAInsn,
-  kLSRAOverlap,
-  kRaRemat,
-  kCGO0,
-  kCGO1,
-  kCGO2,
-  kCGOs,  // optimize for size
-  kProepilogue,
-  kYieldPoing,
-  kLocalRc,
-  kCGRange,
-  kFastAlloc,
-  kSpillRange,
-  kDuplicateBB,
-  kCalleeCFI,
-  kCyclePatternList,
-  kDuplicateToDelPlt,
-  kDuplicateToDelPlt2,
-  kReplaceAsm,
-  kUseGeneralRegOnly,
-  kEmitBlockMarker,
-  kInsertSoe,
-  kCheckArrayStore,
-  kPrintFunction,
-  kCGDumpPhases,
-  kCGSkipPhases,
-  kCGSkipFrom,
-  kCGSkipAfter,
-  kCGLazyBinding,
-  kCGHotFix,
-  kDebugSched,
-  kBruteForceSched,
-  kSimulateSched,
-  kCrossLoc,
-  kABIType,
-  kEmitFileType,
-  kLongCalls,
-  kFunctionSections,
-  kOmitFramePointer,
-  kFastMath,
-  kTailCall,
-  kAlignAnalysis,
-  kCondBrAlign,
-  kRegSaves,
-  kSsaPreSave,
-  kSsuPreRestore,
-  kArm64ilp32,
-  kCGSSA,
-  kCommon,
-  kAlignMinBBSize,
-  kAlignMaxBBSize,
-  kLoopAlignPow,
-  kJumpAlignPow,
-  kFuncAlignPow,
-};
-
-const Descriptor kUsage[] = {
-  { kPie,
-    kEnable,
-    "",
-    "pie",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --pie                       \tGenerate position-independent executable\n"
-    "  --no-pie\n",
-    "mplcg",
-    {"driver"} },
-  { kPic,
-    kEnable,
-    "",
-    "fpic",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --fpic                      \tGenerate position-independent shared library\n"
-    "  --no-fpic\n",
-    "mplcg",
-    {"driver"} },
-  { kCGVerbose,
-    kEnable,
-    "",
-    "verbose-asm",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --verbose-asm               \tAdd comments to asm output\n"
-    "  --no-verbose-asm\n",
-    "mplcg",
-    {} },
-  { kCGVerboseCG,
-    kEnable,
-    "",
-    "verbose-cg",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --verbose-cg               \tAdd comments to cg output\n"
-    "  --no-verbose-cg\n",
-    "mplcg",
-    {} },
-  { kCGMapleLinker,
-    kEnable,
-    "",
-    "maplelinker",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --maplelinker               \tGenerate the MapleLinker .s format\n"
-    "  --no-maplelinker\n",
-    "mplcg",
-    {} },
-  { kCGQuiet,
-    kEnable,
-    "",
-    "quiet",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --quiet                     \tBe quiet (don't output debug messages)\n"
-    "  --no-quiet\n",
-    "mplcg",
-    {} },
-  { kCgen,
-    kEnable,
-    "",
-    "cg",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --cg                        \tGenerate the output .s file\n"
-    "  --no-cg\n",
-    "mplcg",
-    {} },
-  { kReplaceAsm,
-    kEnable,
-    "",
-    "replaceasm",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --replaceasm                \tReplace the the assembly code\n"
-    "  --no-replaceasm\n",
-    "mplcg",
-    {} },
-  { kUseGeneralRegOnly,
-    kEnable,
-    "",
-    "general-reg-only",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    " --general-reg-only           \tdisable floating-point or Advanced SIMD registers\n"
-    " --no-general-reg-only\n",
-    "mplcg",
-    {} },
-  { kCGLazyBinding,
-    kEnable,
-    "",
-    "lazy-binding",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --lazy-binding              \tBind class symbols lazily[default off]\n",
-    "mplcg",
-    {} },
-  { kCGHotFix,
-    kEnable,
-    "",
-    "hot-fix",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --hot-fix                   \tOpen for App hot fix[default off]\n"
-    "  --no-hot-fix\n",
-    "mplcg",
-    {} },
-  { kEbo,
-    kEnable,
-    "",
-    "ebo",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --ebo                       \tPerform Extend block optimization\n"
-    "  --no-ebo\n",
-    "mplcg",
-    {} },
-  { kCfgo,
-    kEnable,
-    "",
-    "cfgo",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --cfgo                      \tPerform control flow optimization\n"
-    "  --no-cfgo\n",
-    "mplcg",
-    {} },
-  { kIco,
-    kEnable,
-    "",
-    "ico",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --ico                       \tPerform if-conversion optimization\n"
-    "  --no-ico\n",
-    "mplcg",
-    {} },
-  { kSlo,
-    kEnable,
-    "",
-    "storeloadopt",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --storeloadopt              \tPerform global store-load optimization\n"
-    "  --no-storeloadopt\n",
-    "mplcg",
-    {} },
-  { kGo,
-    kEnable,
-    "",
-    "globalopt",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --globalopt                 \tPerform global optimization\n"
-    "  --no-globalopt\n",
-    "mplcg",
-    {} },
-  { kPreLSRAOpt,
-    kEnable,
-    "",
-    "prelsra",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --prelsra                   \tPerform live interval simplification in LSRA\n"
-    "  --no-prelsra\n",
-    "mplcg",
-    {} },
-  { kLocalrefSpill,
-    kEnable,
-    "",
-    "lsra-lvarspill",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --lsra-lvarspill            \tPerform LSRA spill using local ref var stack locations\n"
-    "  --no-lsra-lvarspill\n",
-    "mplcg",
-    {} },
-  { kOptCallee,
-    kEnable,
-    "",
-    "lsra-optcallee",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --lsra-optcallee            \tSpill callee if only one def to use\n"
-    "  --no-lsra-optcallee\n",
-    "mplcg",
-    {} },
-  { kRegSaves,
-    kEnable,
-    "",
-    "calleeregs-placement",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --calleeregs-placement      \tOptimize placement of callee-save registers\n"
-    "  --no-calleeregs-placement\n",
-    "mplcg",
-    {} },
-  { kSsaPreSave,
-    kEnable,
-    "",
-    "ssapre-save",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --ssapre-save                \tUse ssapre algorithm to save callee-save registers\n"
-    "  --no-ssapre-save\n",
-    "mplcg",
-    {} },
-  { kSsuPreRestore,
-    kEnable,
-    "",
-    "ssupre-restore",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --ssupre-restore             \tUse ssupre algorithm to restore callee-save registers\n"
-    "  --no-ssupre-restore\n",
-    "mplcg",
-    {} },
-  { kPrepeep,
-    kEnable,
-    "",
-    "prepeep",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --prepeep                   \tPerform peephole optimization before RA\n"
-    "  --no-prepeep\n",
-    "mplcg",
-    {} },
-  { kPeep,
-    kEnable,
-    "",
-    "peep",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --peep                      \tPerform peephole optimization after RA\n"
-    "  --no-peep\n",
-    "mplcg",
-    {} },
-  { kPreSchedule,
-    kEnable,
-    "",
-    "preschedule",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --preschedule               \tPerform prescheduling\n"
-    "  --no-preschedule\n",
-    "mplcg",
-    {} },
-  { kSchedule,
-    kEnable,
-    "",
-    "schedule",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --schedule                  \tPerform scheduling\n"
-    "  --no-schedule\n",
-    "mplcg",
-    {} },
-  { kRetMerge,
-    kEnable,
-    "",
-    "ret-merge",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --ret-merge                 \tMerge return bb into a single destination\n"
-    "  --no-ret-merge              \tallows for multiple return bb\n",
-    "mplcg",
-    {} },
-  { kVregRename,
-    kEnable,
-    "",
-    "vreg-rename",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --vreg-rename                  \tPerform rename of long live range around loops in coloring RA\n"
-    "  --no-vreg-rename\n",
-    "mplcg",
-    {} },
-  { kMultiPassRA,
-    kEnable,
-    "",
-    "fullcolor",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --fullcolor                  \tPerform multi-pass coloring RA\n"
-    "  --no-fullcolor\n",
-    "mplcg",
-    {} },
-  { kWriteRefFieldOpt,
-    kEnable,
-    "",
-    "writefieldopt",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --writefieldopt                  \tPerform WriteRefFieldOpt\n"
-    "  --no-writefieldopt\n",
-    "mplcg",
-    {} },
-  { kDumpOlog,
-    kEnable,
-    "",
-    "dump-olog",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --dump-olog                 \tDump CFGO and ICO debug information\n"
-    "  --no-dump-olog\n",
-    "mplcg",
-    {} },
-  { kCGNativeOpt,
-    kEnable,
-    "",
-    "nativeopt",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --nativeopt                 \tEnable native opt\n"
-    "  --no-nativeopt\n",
-    "mplcg",
-    {} },
-  { kObjMap,
-    kEnable,
-    "",
-    "objmap",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --objmap                    \tCreate object maps (GCTIBs) inside the main output (.s) file\n"
-    "  --no-objmap\n",
-    "mplcg",
-    {} },
-  { kYieldPoing,
-    kEnable,
-    "",
-    "yieldpoint",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --yieldpoint                \tGenerate yieldpoints [default]\n"
-    "  --no-yieldpoint\n",
-    "mplcg",
-    {} },
-  { kProepilogue,
-    kEnable,
-    "",
-    "proepilogue",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --proepilogue               \tDo tail call optimization and eliminate unnecessary prologue and epilogue.\n"
-    "  --no-proepilogue\n",
-    "mplcg",
-    {} },
-  { kLocalRc,
-    kEnable,
-    "",
-    "local-rc",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --local-rc                  \tHandle Local Stack RC [default]\n"
-    "  --no-local-rc\n",
-    "mplcg",
-    {} },
-  { kInsertCall,
-    0,
-    "",
-    "insert-call",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --insert-call=name          \tInsert a call to the named function\n",
-    "mplcg",
-    {} },
-  { kTrace,
-    0,
-    "",
-    "add-debug-trace",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --add-debug-trace           \tInstrument the output .s file to print call traces at runtime\n",
-    "mplcg",
-    {} },
-  { kProfileEnable,
-    0,
-    "",
-    "add-func-profile",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNone,
-    "  --add-func-profile          \tInstrument the output .s file to record func at runtime\n",
-    "mplcg",
-    {} },
-  { kCGClassList,
-    0,
-    "",
-    "class-list-file",
-    kBuildTypeExperimental,
-    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,
-    "",
-    "gen-c-macro-def",
-    kBuildTypeProduct,
-    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"
-    "  --no-gen-c-macro-def\n",
-    "mplcg",
-    {} },
-  { kGenGctib,
-    kEnable,
-    "",
-    "gen-gctib-file",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --gen-gctib-file            \tGenerate a separate .s file for GCTIBs. Usually used together with\n"
-    "                              \t--no-objmap (not implemented yet)\n"
-    "  --no-gen-gctib-file\n",
-    "mplcg",
-    {} },
-  { kStackGuard,
-    kEnable,
-    "",
-    "stackguard",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  -stackguard                 \tadd stack guard\n"
-    "  -no-stackguard\n",
-    "mplcg",
-    {} },
-  { kDebuggingInfo,
-    0,
-    "g",
-    "",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNone,
-    "  -g                          \tGenerate debug information\n",
-    "mplcg",
-    {} },
-  { kDebugGenDwarf,
-    0,
-    "",
-    "gdwarf",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --gdwarf                    \tGenerate dwarf infomation\n",
-    "mplcg",
-    {} },
-  { kDebugUseSrc,
-    0,
-    "",
-    "gsrc",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --gsrc                      \tUse original source file instead of mpl file for debugging\n",
-    "mplcg",
-    {} },
-  { kDebugUseMix,
-    0,
-    "",
-    "gmixedsrc",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --gmixedsrc                 \tUse both original source file and mpl file for debugging\n",
-    "mplcg",
-    {} },
-  { kDebugAsmMix,
-    0,
-    "",
-    "gmixedasm",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNone,
-    "  --gmixedasm                 \tComment out both original source file and mpl file for debugging\n",
-    "mplcg",
-    {} },
-  { kProfilingInfo,
-    0,
-    "p",
-    "",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNone,
-    "  -p                          \tGenerate profiling infomation\n",
-    "mplcg",
-    {} },
-  { kRaLinear,
-    0,
-    "",
-    "with-ra-linear-scan",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNone,
-    "  --with-ra-linear-scan       \tDo linear-scan register allocation\n",
-    "mplcg",
-    {} },
-  { kRaColor,
-    0,
-    "",
-    "with-ra-graph-color",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNone,
-    "  --with-ra-graph-color       \tDo coloring-based register allocation\n",
-    "mplcg",
-    {} },
-  { kPatchBranch,
-    0,
-    "",
-    "patch-long-branch",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNone,
-    "  --patch-long-branch         \tEnable patching long distance branch with jumping pad\n",
-    "mplcg",
-    {} },
-  { kConstFoldOpt,
-    kEnable,
-    "",
-    "const-fold",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --const-fold                \tEnable constant folding\n"
-    "  --no-const-fold\n",
-    "mplcg",
-    {} },
-  { kEhList,
-    0,
-    "",
-    "eh-exclusive-list",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --eh-exclusive-list         \tFor generating gold files in unit testing\n"
-    "                              \t--eh-exclusive-list=list_file\n",
-    "mplcg",
-    {} },
-  { kCGO0,
-    0,
-    "O0",
-    "",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNone,
-    "  -O0                         \tNo optimization.\n",
-    "mplcg",
-    {} },
-  { kCGO1,
-    0,
-    "O1",
-    "",
-    kBuildTypeExperimental,
-    kArgCheckPolicyOptional,
-    "  -O1                         \tDo some optimization.\n",
-    "mplcg",
-    {} },
-  { kCGO2,
-    0,
-    "O2",
-    "",
-    kBuildTypeProduct,
-    kArgCheckPolicyOptional,
-    "  -O2                          \tDo some optimization.\n",
-    "mplcg",
-    {} },
-  { kCGOs,
-      0,
-      "Os",
-      "",
-      kBuildTypeProduct,
-      kArgCheckPolicyOptional,
-      "  -Os                          \tOptimize for size, based on O2.\n",
-      "mplcg",
-      {} },
-  { kLSRABB,
-    0,
-    "",
-    "lsra-bb",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --lsra-bb=NUM               \tSwitch to spill mode if number of bb in function exceeds NUM\n",
-    "mplcg",
-    {} },
-  { kLSRAInsn,
-    0,
-    "",
-    "lsra-insn",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --lsra-insn=NUM             \tSwitch to spill mode if number of instructons in function exceeds NUM\n",
-    "mplcg",
-    {} },
-  { kLSRAOverlap,
-    0,
-    "",
-    "lsra-overlap",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --lsra-overlap=NUM          \toverlap NUM to decide pre spill in lsra\n",
-    "mplcg",
-    {} },
-  { kRaRemat,
-    0,
-    "",
-    "remat",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --remat                     \tEnable rematerialization during register allocation\n"
-    "                              \t     0: no rematerialization (default)\n"
-    "                              \t  >= 1: rematerialize constants\n"
-    "                              \t  >= 2: rematerialize addresses\n"
-    "                              \t  >= 3: rematerialize local dreads\n"
-    "                              \t  >= 4: rematerialize global dreads\n",
-    "mplcg",
-    {} },
-  { kSuppressFinfo,
-    0,
-    "",
-    "suppress-fileinfo",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNone,
-    "  --suppress-fileinfo         \tFor generating gold files in unit testing\n",
-    "mplcg",
-    {} },
-  { kCGDumpcfg,
-    0,
-    "",
-    "dump-cfg",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNone,
-    "  --dump-cfg\n",
-    "mplcg",
-    {} },
-  { kTargetMachine,
-    0,
-    "",
-    "target",
-    kBuildTypeProduct,
-    kArgCheckPolicyOptional,
-    "  --target=TARGETMACHINE \t generate code for TARGETMACHINE\n",
-    "mplcg",
-    {} },
-  { kCGDumpPhases,
-    0,
-    "",
-    "dump-phases",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --dump-phases=PHASENAME,... \tEnable debug trace for specified phases in the comma separated list\n",
-    "mplcg",
-    {} },
-  { kCGSkipPhases,
-    0,
-    "",
-    "skip-phases",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --skip-phases=PHASENAME,... \tSkip the phases specified in the comma separated list\n",
-    "mplcg",
-    {} },
-  { kCGSkipFrom,
-    0,
-    "",
-    "skip-from",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --skip-from=PHASENAME       \tSkip the rest phases from PHASENAME(included)\n",
-    "mplcg",
-    {} },
-  { kCGSkipAfter,
-    0,
-    "",
-    "skip-after",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --skip-after=PHASENAME      \tSkip the rest phases after PHASENAME(excluded)\n",
-    "mplcg",
-    {} },
-  { kCGDumpFunc,
-    0,
-    "",
-    "dump-func",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --dump-func=FUNCNAME        \tDump/trace only for functions whose names contain FUNCNAME as substring\n"
-    "                              \t(can only specify once)\n",
-    "mplcg",
-    {} },
-  { kCGTimePhases,
-    kEnable,
-    "",
-    "time-phases",
-    kBuildTypeExperimental,
-    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,
-    "",
-    "use-barriers-for-volatile",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --use-barriers-for-volatile \tOptimize volatile load/str\n"
-    "  --no-use-barriers-for-volatile\n",
-    "mplcg",
-    {} },
-  { kCGRange,
-    0,
-    "",
-    "range",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --range=NUM0,NUM1           \tOptimize only functions in the range [NUM0, NUM1]\n",
-    "mplcg",
-    {} },
-  { kFastAlloc,
-    0,
-    "",
-    "fast-alloc",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --fast-alloc=[0/1]          \tO2 RA fast mode, set to 1 to spill all registers\n",
-    "mplcg",
-    {} },
-  { kSpillRange,
-    0,
-    "",
-    "spill_range",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --spill_range=NUM0,NUM1     \tO2 RA spill registers in the range [NUM0, NUM1]\n",
-    "mplcg",
-    {} },
-  { kDuplicateBB,
-    kEnable,
-    "",
-    "dup-bb",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --dup-bb                 \tAllow cfg optimizer to duplicate bb\n"
-    "  --no-dup-bb              \tDon't allow cfg optimizer to duplicate bb\n",
-    "mplcg",
-    {} },
-  { kCalleeCFI,
-    kEnable,
-    "",
-    "callee-cfi",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --callee-cfi                \tcallee cfi message will be generated\n"
-    "  --no-callee-cfi             \tcallee cfi message will not be generated\n",
-    "mplcg",
-    {} },
-  { kPrintFunction,
-    kEnable,
-    "",
-    "print-func",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --print-func\n"
-    "  --no-print-func\n",
-    "mplcg",
-    {} },
-  { kCyclePatternList,
-    0,
-    "",
-    "cycle-pattern-list",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --cycle-pattern-list        \tFor generating cycle pattern meta\n"
-    "                              \t--cycle-pattern-list=list_file\n",
-    "mplcg",
-    {} },
-  { kDuplicateToDelPlt,
-    0,
-    "",
-    "duplicate_asm_list",
-    kBuildTypeProduct,
-    kArgCheckPolicyRequired,
-    "  --duplicate_asm_list        \tDuplicate asm functions to delete plt call\n"
-    "                              \t--duplicate_asm_list=list_file\n",
-    "mplcg",
-    {} },
-  { kDuplicateToDelPlt2,
-    0,
-    "",
-    "duplicate_asm_list2",
-    kBuildTypeProduct,
-    kArgCheckPolicyRequired,
-    "  --duplicate_asm_list2       \tDuplicate more asm functions to delete plt call\n"
-    "                              \t--duplicate_asm_list2=list_file\n",
-    "mplcg",
-    {} },
-  { kEmitBlockMarker,
-    0,
-    "",
-    "block-marker",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --block-marker              \tEmit block marker symbols in emitted assembly files\n",
-    "mplcg",
-    {} },
-  { kInsertSoe,
-    0,
-    "",
-    "soe-check",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNone,
-    "  --soe-check                 \tInsert a soe check instruction[default off]\n",
-    "mplcg",
-    {} },
-  { kCheckArrayStore,
-    kEnable,
-    "",
-    "check-arraystore",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --check-arraystore          \tcheck arraystore exception[default off]\n"
-    "  --no-check-arraystore\n",
-    "mplcg",
-    {} },
-  { kDebugSched,
-    kEnable,
-    "",
-    "debug-schedule",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --debug-schedule            \tdump scheduling information\n"
-    "  --no-debug-schedule\n",
-    "mplcg",
-    {} },
-  { kBruteForceSched,
-    kEnable,
-    "",
-    "bruteforce-schedule",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --bruteforce-schedule       \tdo brute force schedule\n"
-    "  --no-bruteforce-schedule\n",
-    "mplcg",
-    {} },
-  { kSimulateSched,
-    kEnable,
-    "",
-    "simulate-schedule",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --simulate-schedule         \tdo simulate schedule\n"
-    "  --no-simulate-schedule\n",
-    "mplcg",
-    {} },
-  { kCrossLoc,
-    kEnable,
-    "",
-    "cross-loc",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --cross-loc                 \tcross loc insn schedule\n"
-    "  --no-cross-loc\n",
-    "mplcg",
-    {} },
-  { kABIType,
-    0,
-    "",
-    "float-abi",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --float-abi=name            \tPrint the abi type.\n"
-    "                              \tname=hard: abi-hard (Default)\n"
-    "                              \tname=soft: abi-soft\n"
-    "                              \tname=softfp: abi-softfp\n",
-    "mplcg",
-    {} },
-  { kEmitFileType,
-    0,
-    "",
-    "filetype",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --filetype=name             \tChoose a file type.\n"
-    "                              \tname=asm: Emit an assembly file (Default)\n"
-    "                              \tname=obj: Emit an object file\n"
-    "                              \tname=null: not support yet\n",
-    "mplcg",
-    {} },
-  { kLongCalls,
-    kEnable,
-    "",
-    "long-calls",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --long-calls                \tgenerate long call\n"
-    "  --no-long-calls\n",
-    "mplcg",
-    {} },
-  { kFunctionSections,
-    kEnable,
-    "",
-    "function-sections",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    " --function-sections           \t \n"
-    "  --no-function-sections\n",
-    "mplcg",
-    {} },
-  { kOmitFramePointer,
-    kEnable,
-    "",
-    "omit-frame-pointer",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    " --omit-frame-pointer          \t do not use frame pointer \n"
-    " --no-omit-frame-pointer\n",
-    "mplcg",
-    {"driver"} },
-  { kFastMath,
-    kEnable,
-    "",
-    "fast-math",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --fast-math                  \tPerform fast math\n"
-    "  --no-fast-math\n",
-    "mplcg",
-    {} },
-  { kTailCall,
-    kEnable,
-    "",
-    "tailcall",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --tailcall                   \tDo tail call optimization\n"
-    "  --no-tailcall\n",
-    "mplcg",
-    {} },
-  { kAlignAnalysis,
-    kEnable,
-    "",
-    "align-analysis",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --align-analysis                 \tPerform alignanalysis\n"
-    "  --no-align-analysis\n",
-    "mplcg",
-    {} },
-  { kCondBrAlign,
-    kEnable,
-    "",
-    "condbr-align",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --condbr-align                   \tPerform condbr align\n"
-    "  --no-condbr-align\n",
-    "mplcg",
-    {} },
-  { kCGSSA,
-    kEnable,
-    "",
-    "cg-ssa",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --cg-ssa                     \tPerform cg ssa\n"
-    "  --no-cg-ssa\n",
-    "mplcg",
-    {} },
-  { kArm64ilp32, /* change to Target */
-    kEnable,
-    "ilp32",
-    "arm64-ilp32",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    " --arm64-ilp32                 \tarm64 with a 32-bit ABI instead of a 64bit ABI\n"
-    " --no-arm64-ilp32\n",
-    "mplcg",
-    {} },
-  { kCommon,
-    kEnable,
-    "",
-    "common",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    " --common           \t \n"
-    " --no-common\n",
-    "mplcg",
-    {} },
-  { kAlignMinBBSize,
-    0,
-    "",
-    "align-min-bb-size",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    " --align-min-bb-size=NUM           \tO2 Minimum bb size for alignment   unit:byte\n",
-    "mplcg",
-    {} },
-  { kAlignMaxBBSize,
-    0,
-    "",
-    "align-max-bb-size",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    " --align-max-bb-size=NUM           \tO2 Maximum bb size for alignment   unit:byte\n",
-    "mplcg",
-    {} },
-  { kLoopAlignPow,
-    0,
-    "",
-    "loop-align-pow",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    " --loop-align-pow=NUM           \tO2 loop bb align pow (NUM == 0, no loop-align)\n",
-    "mplcg",
-    {} },
-  { kJumpAlignPow,
-    0,
-    "",
-    "jump-align-pow",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    " --jump-align-pow=NUM           \tO2 jump bb align pow (NUM == 0, no jump-align)\n",
-    "mplcg",
-    {} },
-  { kFuncAlignPow,
-    0,
-    "",
-    "func-align-pow",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    " --func-align-pow=NUM           \tO2 func bb align pow (NUM == 0, no func-align)\n",
-    "mplcg",
-    {} },
-
-// End
-  { kUnknown,
-    0,
-    "",
-    "",
-    kBuildTypeAll,
-    kArgCheckPolicyNone,
-    "",
-    "mplcg",
-    {} }
-};
-
 CGOptions &CGOptions::GetInstance() {
   static CGOptions instance;
   return instance;
 }
 
-CGOptions::CGOptions() {
-  CreateUsages(kUsage);
-}
-
-void CGOptions::DecideMplcgRealLevel(const std::deque<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;
-      case kCGOs:
-        optForSize = true;
-        realLevel = CGOptions::kLevel2;
-        break;
-      default:
-        break;
+bool CGOptions::SolveOptions(bool isDebug) {
+  for (const auto &opt : cgCategory.GetEnabledOptions()) {
+    std::string printOpt;
+    if (isDebug) {
+      for (const auto &val : opt->GetRawValues()) {
+        printOpt += opt->GetName() + " " + val + " ";
+      }
+      LogInfo::MapleLogger() << "cg options: " << printOpt << '\n';
     }
   }
-  if (isDebug) {
-    LogInfo::MapleLogger() << "Real Mplcg level:" << std::to_string(realLevel) << "\n";
-  }
-  if (realLevel ==  CGOptions::kLevel0) {
+
+  if (opts::cg::o0) {
     EnableO0();
-  } else if (realLevel ==  CGOptions::kLevel1) {
+  }
+
+  if (opts::cg::o1) {
     EnableO1();
-  } else if (realLevel ==  CGOptions::kLevel2) {
-    EnableO2();
   }
-}
 
-bool CGOptions::SolveOptions(const std::deque<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';
+  if (opts::cg::o2 || opts::cg::os) {
+    if (opts::cg::os) {
+      optForSize = true;
     }
-    switch (opt.Index()) {
-      case kCGQuiet:
-        SetQuiet((opt.Type() == kEnable));
-        break;
-      case kVerbose:
-        SetQuiet((opt.Type() == kEnable) ? false : true);
-        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 kCGVerbose:
-        (opt.Type() == kEnable) ? SetOption(CGOptions::kVerboseAsm)
-                                : ClearOption(CGOptions::kVerboseAsm);
-        break;
-      case kCGVerboseCG:
-        (opt.Type() == kEnable) ? SetOption(CGOptions::kVerboseCG)
-                                : ClearOption(CGOptions::kVerboseCG);
-        break;
-      case kCGMapleLinker:
-        (opt.Type() == kEnable) ? EnableMapleLinker() : DisableMapleLinker();
-        break;
-      case kFastAlloc:
-        EnableFastAlloc();
-        SetFastAllocMode(std::stoul(opt.Args(), nullptr));
-        break;
-      case kCGBarrier:
-        (opt.Type() == kEnable) ? EnableBarriersForVolatile() : DisableBarriersForVolatile();
-        break;
-      case kSpillRange:
-        SetRange(opt.Args(), "--pill-range", GetSpillRanges());
-        break;
-      case kCGRange:
-        SetRange(opt.Args(), "--range", GetRange());
-        break;
-      case kCGTimePhases:
-        (opt.Type() == kEnable) ? EnableTimePhases() : DisableTimePhases();
-        break;
-      case kCGDumpFunc:
-        SetDumpFunc(opt.Args());
-        break;
-      case kDuplicateToDelPlt:
-        SetDuplicateAsmFile(opt.Args());
-        break;
-      case kDuplicateToDelPlt2:
-        SetFastFuncsAsmFile(opt.Args());
-        break;
-      case kInsertCall:
-        SetOption(kGenInsertCall);
-        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);
-        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 kRaLinear:
-        SetOption(kDoLinearScanRegAlloc);
-        ClearOption(kDoColorRegAlloc);
-        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 kPatchBranch:
-        SetOption(kPatchLongBranch);
-        break;
-      case kConstFoldOpt:
-        (opt.Type() == kEnable) ? SetOption(kConstFold) : ClearOption(kConstFold);
-        break;
-      case kCGDumpcfg:
-        SetOption(kDumpCFG);
-        break;
-      case kCGClassList:
-        SetClassListFile(opt.Args());
-        break;
-      case kGenDef:
-        SetOrClear(GetGenerateFlags(), CGOptions::kCMacroDef, static_cast<bool>(opt.Type()));
-        break;
-      case kGenGctib:
-        SetOrClear(GetGenerateFlags(), CGOptions::kGctib, static_cast<bool>(opt.Type()));
-        break;
-      case kGenPrimorList:
-        SetOrClear(GetGenerateFlags(), CGOptions::kPrimorList, static_cast<bool>(opt.Type()));
-        break;
-      case kYieldPoing:
-        SetOrClear(GetGenerateFlags(), CGOptions::kGenYieldPoint, static_cast<bool>(opt.Type()));
-        break;
-      case kLocalRc:
-        SetOrClear(GetGenerateFlags(), CGOptions::kGenLocalRc, static_cast<bool>(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 kReplaceAsm:
-        (opt.Type() == kEnable) ? EnableReplaceASM() : DisableReplaceASM();
-        break;
-      case kUseGeneralRegOnly:
-        (opt.Type() == kEnable) ? EnableGeneralRegOnly() : DisableGeneralRegOnly();
-        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 kEbo:
-        (opt.Type() == kEnable) ? EnableEBO() : DisableEBO();
-        break;
-
-      case kCfgo:
-        (opt.Type() == kEnable) ? EnableCFGO() : DisableCFGO();
-        break;
-      case kIco:
-        (opt.Type() == kEnable) ? EnableICO() : DisableICO();
-        break;
-      case kSlo:
-        (opt.Type() == kEnable) ? EnableStoreLoadOpt() : DisableStoreLoadOpt();
-        break;
-      case kGo:
-        (opt.Type() == kEnable) ? EnableGlobalOpt() : DisableGlobalOpt();
-        break;
-      case kPreLSRAOpt:
-        (opt.Type() == kEnable) ? EnablePreLSRAOpt() : DisablePreLSRAOpt();
-        break;
-      case kLocalrefSpill:
-        (opt.Type() == kEnable) ? EnableLocalRefSpill() : DisableLocalRefSpill();
-        break;
-      case kOptCallee:
-        (opt.Type() == kEnable) ? EnableCalleeToSpill() : DisableCalleeToSpill();
-        break;
-      case kPrepeep:
-        (opt.Type() == kEnable) ? EnablePrePeephole() : DisablePrePeephole();
-        break;
-      case kPeep:
-        (opt.Type() == kEnable) ? EnablePeephole() : DisablePeephole();
-        break;
-      case kRetMerge:
-        (opt.Type() == kEnable) ? EnableRetMerge() : DisableRetMerge();
-        break;
-      case kPreSchedule:
-        (opt.Type() == kEnable) ? EnablePreSchedule() : DisablePreSchedule();
-        break;
-      case kSchedule:
-        (opt.Type() == kEnable) ? EnableSchedule() : DisableSchedule();
-        break;
-      case kVregRename:
-        (opt.Type() == kEnable) ? EnableVregRename() : DisableVregRename();
-        break;
-      case kMultiPassRA:
-        (opt.Type() == kEnable) ? EnableMultiPassColorRA() : DisableMultiPassColorRA();
-        break;
-      case kWriteRefFieldOpt:
-        (opt.Type() == kEnable) ? EnableWriteRefFieldOpt() : DisableWriteRefFieldOpt();
-        break;
-      case kDumpOlog:
-        (opt.Type() == kEnable) ? EnableDumpOptimizeCommonLog() : DisableDumpOptimizeCommonLog();
-        break;
-      case kCGNativeOpt:
-        DisableNativeOpt();
-        break;
-      case kDuplicateBB:
-        (opt.Type() == kEnable) ? DisableNoDupBB() : EnableNoDupBB();
-        break;
-      case kCalleeCFI:
-        (opt.Type() == kEnable) ? DisableNoCalleeCFI() : EnableNoCalleeCFI();
-        break;
-      case kProepilogue:
-        (opt.Type() == kEnable) ? SetOption(CGOptions::kProEpilogueOpt)
-                                : ClearOption(CGOptions::kProEpilogueOpt);
-        break;
-      case kTailCall:
-        (opt.Type() == kEnable) ? SetOption(CGOptions::kTailCallOpt)
-                                : ClearOption(CGOptions::kTailCallOpt);
-        break;
-      case kRegSaves:
-        (opt.Type() == kEnable) ? EnableRegSavesOpt() : DisableRegSavesOpt();
-        break;
-      case kSsaPreSave:
-        (opt.Type() == kEnable) ? EnableSsaPreSave() : DisableSsaPreSave();
-        break;
-      case kSsuPreRestore:
-        (opt.Type() == kEnable) ? EnableSsuPreRestore() : DisableSsuPreRestore();
-        break;
-      case kLSRABB:
-        SetLSRABBOptSize(std::stoul(opt.Args(), nullptr));
-        break;
-      case kLSRAInsn:
-        SetLSRAInsnOptSize(std::stoul(opt.Args(), nullptr));
-        break;
-      case kLSRAOverlap:
-        SetOverlapNum(std::stoul(opt.Args(), nullptr));
-        break;
-      case kRaRemat:
-        SetRematLevel(std::stoul(opt.Args(), nullptr));
-        break;
-      case kCGO0:
-        // Already handled above in DecideMplcgRealLevel
-        break;
-      case kCGO1:
-        // Already handled above in DecideMplcgRealLevel
-        break;
-      case kCGO2:
-      case kCGOs:
-        // Already handled above in DecideMplcgRealLevel
-        break;
-      case kCGDumpPhases:
-        SplitPhases(opt.Args(), GetDumpPhases());
-        break;
-      case kTargetMachine:
-        SetTargetMachine(opt.Args());
-        break;
-      case kCGSkipPhases:
-        SplitPhases(opt.Args(), GetSkipPhases());
-        break;
-      case kCGSkipFrom:
-        SetSkipFrom(opt.Args());
-        break;
-      case kCGSkipAfter:
-        SetSkipAfter(opt.Args());
-        break;
-      case kDebugSched:
-        (opt.Type() == kEnable) ? EnableDebugSched() : DisableDebugSched();
-        break;
-      case kBruteForceSched:
-        (opt.Type() == kEnable) ? EnableDruteForceSched() : DisableDruteForceSched();
-        break;
-      case kSimulateSched:
-        (opt.Type() == kEnable) ? EnableSimulateSched() : DisableSimulateSched();
-        break;
-      case kProfilePath:
-        SetProfileData(opt.Args());
-        break;
-      case kABIType:
-        SetABIType(opt.Args());
-        break;
-      case kEmitFileType:
-        SetEmitFileType(opt.Args());
-        break;
-      case kLongCalls:
-        (opt.Type() == kEnable) ? EnableLongCalls() : DisableLongCalls();
-        break;
-      case kFunctionSections:
-        (opt.Type() == kEnable) ? EnableFunctionSections() : DisableFunctionSections();
-        break;
-      case kOmitFramePointer:
-        (opt.Type() == kEnable) ?  DisableFramePointer() : EnableFramePointer();
-        break;
-      case kGCOnly:
-        (opt.Type() == kEnable) ? EnableGCOnly() : DisableGCOnly();
-        break;
-      case kFastMath:
-        (opt.Type() == kEnable) ? EnableFastMath() : DisableFastMath();
-        break;
-      case kAlignAnalysis:
-        (opt.Type() == kEnable) ? EnableAlignAnalysis() : DisableAlignAnalysis();
-        break;
-      case kCondBrAlign:
-        (opt.Type() == kEnable) ? EnableCondBrAlign() : DisableCondBrAlign();
-        break;
-      case kBigEndian:
-        (opt.Type() == kEnable) ? EnableBigEndianInCG() : DisableBigEndianInCG();
-        break;
-      case kArm64ilp32:
-        (opt.Type() == kEnable) ? EnableArm64ilp32() : DisableArm64ilp32();
-        break;
-      case kCGSSA:
-        (opt.Type() == kEnable) ? EnableCGSSA() : DisableCGSSA();
-        break;
-      case kCommon:
-        (opt.Type() == kEnable) ? EnableCommon() : DisableCommon();
-        break;
-      case kAlignMinBBSize:
-        SetAlignMinBBSize(std::stoul(opt.Args(), nullptr));
-        break;
-      case kAlignMaxBBSize:
-        SetAlignMaxBBSize(std::stoul(opt.Args(), nullptr));
-        break;
-      case kLoopAlignPow:
-        SetLoopAlignPow(std::stoul(opt.Args(), nullptr));
-        break;
-      case kJumpAlignPow:
-        SetJumpAlignPow(std::stoul(opt.Args(), nullptr));
-        break;
-      case kFuncAlignPow:
-        SetFuncAlignPow(std::stoul(opt.Args(), nullptr));
-        break;
-      default:
-        WARN(kLncWarn, "input invalid key for mplcg " + opt.OptionKey());
-        break;
+    EnableO2();
+  }
+
+  if (opts::cg::quiet) {
+    SetQuiet(true);
+  }
+
+  if (opts::verbose) {
+    SetQuiet(false);
+  }
+
+  if (opts::cg::pie.IsEnabledByUser()) {
+    opts::cg::pie ? SetOption(CGOptions::kGenPie) : ClearOption(CGOptions::kGenPie);
+  }
+
+  if (opts::cg::fpic.IsEnabledByUser()) {
+    if (opts::cg::fpic) {
+      EnablePIC();
+      SetOption(CGOptions::kGenPic);
+    } else {
+      DisablePIC();
+      ClearOption(CGOptions::kGenPic);
     }
   }
+
+  if (opts::cg::verboseAsm.IsEnabledByUser()) {
+    opts::cg::verboseAsm ? SetOption(CGOptions::kVerboseAsm) : ClearOption(CGOptions::kVerboseAsm);
+  }
+
+  if (opts::cg::verboseCg.IsEnabledByUser()) {
+    opts::cg::verboseCg ? SetOption(CGOptions::kVerboseCG) : ClearOption(CGOptions::kVerboseCG);
+  }
+
+  if (opts::cg::maplelinker.IsEnabledByUser()) {
+    opts::cg::maplelinker ? EnableMapleLinker() : DisableMapleLinker();
+  }
+
+  if (opts::cg::fastAlloc.IsEnabledByUser()) {
+    EnableFastAlloc();
+    SetFastAllocMode(opts::cg::fastAlloc);
+  }
+
+  if (opts::cg::useBarriersForVolatile.IsEnabledByUser()) {
+    opts::cg::useBarriersForVolatile ? EnableBarriersForVolatile() : DisableBarriersForVolatile();
+  }
+
+  if (opts::cg::spillRange.IsEnabledByUser()) {
+    SetRange(opts::cg::spillRange, "--pill-range", GetSpillRanges());
+  }
+
+  if (opts::cg::range.IsEnabledByUser()) {
+    SetRange(opts::cg::range, "--range", GetRange());
+  }
+
+  if (opts::cg::timePhases.IsEnabledByUser()) {
+    opts::cg::timePhases ? EnableTimePhases() : DisableTimePhases();
+  }
+
+  if (opts::cg::dumpFunc.IsEnabledByUser()) {
+    SetDumpFunc(opts::cg::dumpFunc);
+  }
+
+  if (opts::cg::duplicateAsmList.IsEnabledByUser()) {
+    SetDuplicateAsmFile(opts::cg::duplicateAsmList);
+  }
+
+  if (opts::cg::duplicateAsmList2.IsEnabledByUser()) {
+    SetFastFuncsAsmFile(opts::cg::duplicateAsmList2);
+  }
+
+  if (opts::cg::insertCall.IsEnabledByUser()) {
+    SetOption(kGenInsertCall);
+    SetInstrumentationFunction(opts::cg::insertCall);
+    SetInsertCall(true);
+  }
+
+  if (opts::cg::stackguard.IsEnabledByUser()) {
+    SetOption(kUseStackGuard);
+  }
+
+  if (opts::cg::debug.IsEnabledByUser()) {
+    SetOption(kDebugFriendly);
+    SetOption(kWithLoc);
+    ClearOption(kSuppressFileInfo);
+  }
+
+  if (opts::cg::gdwarf.IsEnabledByUser()) {
+    SetOption(kDebugFriendly);
+    SetOption(kWithLoc);
+    SetOption(kWithDwarf);
+    SetParserOption(kWithDbgInfo);
+    ClearOption(kSuppressFileInfo);
+  }
+
+  if (opts::cg::gsrc.IsEnabledByUser()) {
+    SetOption(kDebugFriendly);
+    SetOption(kWithLoc);
+    SetOption(kWithSrc);
+    ClearOption(kWithMpl);
+  }
+
+  if (opts::cg::gmixedsrc.IsEnabledByUser()) {
+    SetOption(kDebugFriendly);
+    SetOption(kWithLoc);
+    SetOption(kWithSrc);
+    SetOption(kWithMpl);
+  }
+
+  if (opts::cg::gmixedasm.IsEnabledByUser()) {
+    SetOption(kDebugFriendly);
+    SetOption(kWithLoc);
+    SetOption(kWithSrc);
+    SetOption(kWithMpl);
+    SetOption(kWithAsm);
+  }
+
+  if (opts::cg::profile.IsEnabledByUser()) {
+    SetOption(kWithProfileCode);
+    SetParserOption(kWithProfileInfo);
+  }
+
+  if (opts::cg::withRaLinearScan) {
+    SetOption(kDoLinearScanRegAlloc);
+    ClearOption(kDoColorRegAlloc);
+  }
+
+  if (opts::cg::withRaGraphColor) {
+    SetOption(kDoColorRegAlloc);
+    ClearOption(kDoLinearScanRegAlloc);
+  }
+
+  if (opts::cg::addDebugTrace) {
+    SetOption(kAddDebugTrace);
+  }
+
+  if (opts::cg::addFuncProfile) {
+    SetOption(kAddFuncProfile);
+  }
+
+  if (opts::cg::suppressFileinfo) {
+    SetOption(kSuppressFileInfo);
+  }
+
+  if (opts::cg::patchLongBranch) {
+    SetOption(kPatchLongBranch);
+  }
+
+  if (opts::cg::constFold.IsEnabledByUser()) {
+    opts::cg::constFold ? SetOption(kConstFold) : ClearOption(kConstFold);
+  }
+
+  if (opts::cg::dumpCfg) {
+    SetOption(kDumpCFG);
+  }
+
+  if (opts::cg::classListFile.IsEnabledByUser()) {
+    SetClassListFile(opts::cg::classListFile);
+  }
+
+  if (opts::cg::genCMacroDef.IsEnabledByUser()) {
+    SetOrClear(GetGenerateFlags(), CGOptions::kCMacroDef, opts::cg::genCMacroDef);
+  }
+
+  if (opts::cg::genGctibFile.IsEnabledByUser()) {
+    SetOrClear(GetGenerateFlags(), CGOptions::kGctib, opts::cg::genGctibFile);
+  }
+
+  if (opts::cg::yieldpoint.IsEnabledByUser()) {
+    SetOrClear(GetGenerateFlags(), CGOptions::kGenYieldPoint, opts::cg::yieldpoint);
+  }
+
+  if (opts::cg::localRc.IsEnabledByUser()) {
+    SetOrClear(GetGenerateFlags(), CGOptions::kGenLocalRc, opts::cg::localRc);
+  }
+
+  if (opts::cg::ehExclusiveList.IsEnabledByUser()) {
+    SetEHExclusiveFile(opts::cg::ehExclusiveList);
+    EnableExclusiveEH();
+    ParseExclusiveFunc(opts::cg::ehExclusiveList);
+  }
+
+  if (opts::cg::cg.IsEnabledByUser()) {
+    SetRunCGFlag(opts::cg::cg);
+    opts::cg::cg ? SetOption(CGOptions::kDoCg) : ClearOption(CGOptions::kDoCg);
+  }
+
+  if (opts::cg::objmap.IsEnabledByUser()) {
+    SetGenerateObjectMap(opts::cg::objmap);
+  }
+
+  if (opts::cg::replaceAsm.IsEnabledByUser()) {
+    opts::cg::replaceAsm ? EnableReplaceASM() : DisableReplaceASM();
+  }
+
+  if (opts::cg::generalRegOnly.IsEnabledByUser()) {
+    opts::cg::generalRegOnly ? EnableGeneralRegOnly() : DisableGeneralRegOnly();
+  }
+
+  if (opts::cg::lazyBinding.IsEnabledByUser()) {
+    opts::cg::lazyBinding ? EnableLazyBinding() : DisableLazyBinding();
+  }
+
+  if (opts::cg::hotFix.IsEnabledByUser()) {
+    opts::cg::hotFix ? EnableHotFix() : DisableHotFix();
+  }
+
+  if (opts::cg::soeCheck) {
+    SetOption(CGOptions::kSoeCheckInsert);
+  }
+
+  if (opts::cg::checkArraystore.IsEnabledByUser()) {
+    opts::cg::checkArraystore ? EnableCheckArrayStore() : DisableCheckArrayStore();
+  }
+
+  if (opts::cg::ebo.IsEnabledByUser()) {
+    opts::cg::ebo ? EnableEBO() : DisableEBO();
+  }
+
+  if (opts::cg::cfgo.IsEnabledByUser()) {
+    opts::cg::cfgo ? EnableCFGO() : DisableCFGO();
+  }
+
+  if (opts::cg::ico.IsEnabledByUser()) {
+    opts::cg::ico ? EnableICO() : DisableICO();
+  }
+
+  if (opts::cg::storeloadopt.IsEnabledByUser()) {
+    opts::cg::storeloadopt ? EnableStoreLoadOpt() : DisableStoreLoadOpt();
+  }
+
+  if (opts::cg::globalopt.IsEnabledByUser()) {
+    opts::cg::globalopt ? EnableGlobalOpt() : DisableGlobalOpt();
+  }
+
+  if (opts::cg::prelsra.IsEnabledByUser()) {
+    opts::cg::prelsra ? EnablePreLSRAOpt() : DisablePreLSRAOpt();
+  }
+
+  if (opts::cg::lsraLvarspill.IsEnabledByUser()) {
+    opts::cg::lsraLvarspill ? EnableLocalRefSpill() : DisableLocalRefSpill();
+  }
+
+  if (opts::cg::lsraOptcallee.IsEnabledByUser()) {
+    opts::cg::lsraOptcallee ? EnableCalleeToSpill() : DisableCalleeToSpill();
+  }
+
+  if (opts::cg::prepeep.IsEnabledByUser()) {
+    opts::cg::prepeep ? EnablePrePeephole() : DisablePrePeephole();
+  }
+
+  if (opts::cg::peep.IsEnabledByUser()) {
+    opts::cg::peep ? EnablePeephole() : DisablePeephole();
+  }
+
+  if (opts::cg::retMerge.IsEnabledByUser()) {
+    opts::cg::retMerge ? EnableRetMerge() : DisableRetMerge();
+  }
+
+  if (opts::cg::preschedule.IsEnabledByUser()) {
+    opts::cg::preschedule ? EnablePreSchedule() : DisablePreSchedule();
+  }
+
+  if (opts::cg::schedule.IsEnabledByUser()) {
+    opts::cg::schedule ? EnableSchedule() : DisableSchedule();
+  }
+
+  if (opts::cg::vregRename.IsEnabledByUser()) {
+    opts::cg::vregRename ? EnableVregRename() : DisableVregRename();
+  }
+
+  if (opts::cg::fullcolor.IsEnabledByUser()) {
+    opts::cg::fullcolor ? EnableMultiPassColorRA() : DisableMultiPassColorRA();
+  }
+
+  if (opts::cg::writefieldopt.IsEnabledByUser()) {
+    opts::cg::writefieldopt ? EnableWriteRefFieldOpt() : DisableWriteRefFieldOpt();
+  }
+
+  if (opts::cg::dumpOlog.IsEnabledByUser()) {
+    opts::cg::dumpOlog ? EnableDumpOptimizeCommonLog() : DisableDumpOptimizeCommonLog();
+  }
+
+  if (opts::cg::nativeopt) {
+    // FIXME: Looks strage: should be checked by author of the code
+    DisableNativeOpt();
+  }
+
+  if (opts::cg::dupBb.IsEnabledByUser()) {
+    opts::cg::dupBb ? DisableNoDupBB() : EnableNoDupBB();
+  }
+
+  if (opts::cg::calleeCfi.IsEnabledByUser()) {
+    opts::cg::calleeCfi ? DisableNoCalleeCFI() : EnableNoCalleeCFI();
+  }
+
+  if (opts::cg::proepilogue.IsEnabledByUser()) {
+    opts::cg::proepilogue ? SetOption(CGOptions::kProEpilogueOpt)
+                          : ClearOption(CGOptions::kProEpilogueOpt);
+  }
+
+  if (opts::cg::tailcall.IsEnabledByUser()) {
+    opts::cg::tailcall ? SetOption(CGOptions::kTailCallOpt)
+                       : ClearOption(CGOptions::kTailCallOpt);
+  }
+
+  if (opts::cg::calleeregsPlacement.IsEnabledByUser()) {
+    opts::cg::calleeregsPlacement ? EnableRegSavesOpt() : DisableRegSavesOpt();
+  }
+
+  if (opts::cg::ssapreSave.IsEnabledByUser()) {
+    opts::cg::ssapreSave ? EnableSsaPreSave() : DisableSsaPreSave();
+  }
+
+  if (opts::cg::ssupreRestore.IsEnabledByUser()) {
+    opts::cg::ssupreRestore ? EnableSsuPreRestore() : DisableSsuPreRestore();
+  }
+
+  if (opts::cg::lsraBb.IsEnabledByUser()) {
+    SetLSRABBOptSize(opts::cg::lsraBb);
+  }
+
+  if (opts::cg::lsraInsn.IsEnabledByUser()) {
+    SetLSRAInsnOptSize(opts::cg::lsraInsn);
+  }
+
+  if (opts::cg::lsraOverlap.IsEnabledByUser()) {
+    SetOverlapNum(opts::cg::lsraOverlap);
+  }
+
+  if (opts::cg::remat.IsEnabledByUser()) {
+    SetRematLevel(opts::cg::remat);
+  }
+
+  if (opts::cg::dumpPhases.IsEnabledByUser()) {
+    SplitPhases(opts::cg::dumpPhases, GetDumpPhases());
+  }
+
+  if (opts::cg::target.IsEnabledByUser()) {
+    SetTargetMachine(opts::cg::target);
+  }
+
+  if (opts::cg::skipPhases.IsEnabledByUser()) {
+    SplitPhases(opts::cg::skipPhases, GetSkipPhases());
+  }
+
+  if (opts::cg::skipFrom.IsEnabledByUser()) {
+    SetSkipFrom(opts::cg::skipFrom);
+  }
+
+  if (opts::cg::skipAfter.IsEnabledByUser()) {
+    SetSkipAfter(opts::cg::skipAfter);
+  }
+
+  if (opts::cg::debugSchedule.IsEnabledByUser()) {
+    opts::cg::debugSchedule ? EnableDebugSched() : DisableDebugSched();
+  }
+
+  if (opts::cg::bruteforceSchedule.IsEnabledByUser()) {
+    opts::cg::bruteforceSchedule ? EnableDruteForceSched() : DisableDruteForceSched();
+  }
+
+  if (opts::cg::simulateSchedule.IsEnabledByUser()) {
+    opts::cg::simulateSchedule ? EnableSimulateSched() : DisableSimulateSched();
+  }
+
+  if (opts::profile.IsEnabledByUser()) {
+    SetProfileData(opts::profile);
+  }
+
+  if (opts::cg::floatAbi.IsEnabledByUser()) {
+    SetABIType(opts::cg::floatAbi);
+  }
+
+  if (opts::cg::filetype.IsEnabledByUser()) {
+    SetEmitFileType(opts::cg::filetype);
+  }
+
+  if (opts::cg::longCalls.IsEnabledByUser()) {
+    opts::cg::longCalls ? EnableLongCalls() : DisableLongCalls();
+  }
+
+  if (opts::cg::functionSections.IsEnabledByUser()) {
+    opts::cg::functionSections ? EnableFunctionSections() : DisableFunctionSections();
+  }
+
+  if (opts::cg::omitFramePointer.IsEnabledByUser()) {
+    opts::cg::omitFramePointer ? DisableFramePointer() : EnableFramePointer();
+  }
+
+  if (opts::gconly.IsEnabledByUser()) {
+    opts::gconly ? EnableGCOnly() : DisableGCOnly();
+  }
+
+  if (opts::cg::fastMath.IsEnabledByUser()) {
+    opts::cg::fastMath ? EnableFastMath() : DisableFastMath();
+  }
+
+  if (opts::cg::alignAnalysis.IsEnabledByUser()) {
+    opts::cg::alignAnalysis ? EnableAlignAnalysis() : DisableAlignAnalysis();
+  }
+
+  if (opts::cg::condbrAlign.IsEnabledByUser()) {
+    opts::cg::condbrAlign ? EnableCondBrAlign() : DisableCondBrAlign();
+  }
+
+  if (opts::bigendian.IsEnabledByUser()) {
+    opts::bigendian ? EnableBigEndianInCG() : DisableBigEndianInCG();
+  }
+
+  if (opts::cg::arm64Ilp32.IsEnabledByUser()) {
+    opts::cg::arm64Ilp32 ? EnableArm64ilp32() : DisableArm64ilp32();
+  }
+
+  if (opts::cg::cgSsa.IsEnabledByUser()) {
+    opts::cg::cgSsa ? EnableCGSSA() : DisableCGSSA();
+  }
+
+  if (opts::cg::common.IsEnabledByUser()) {
+    opts::cg::common ? EnableCommon() : DisableCommon();
+  }
+
+  if (opts::cg::alignMinBbSize.IsEnabledByUser()) {
+    SetAlignMinBBSize(opts::cg::alignMinBbSize);
+  }
+
+  if (opts::cg::alignMaxBbSize.IsEnabledByUser()) {
+    SetAlignMaxBBSize(opts::cg::alignMaxBbSize);
+  }
+
+  if (opts::cg::loopAlignPow.IsEnabledByUser()) {
+    SetLoopAlignPow(opts::cg::loopAlignPow);
+  }
+
+  if (opts::cg::jumpAlignPow.IsEnabledByUser()) {
+    SetJumpAlignPow(opts::cg::jumpAlignPow);
+  }
+
+  if (opts::cg::funcAlignPow.IsEnabledByUser()) {
+    SetFuncAlignPow(opts::cg::funcAlignPow);
+  }
+
   /* override some options when loc, dwarf is generated */
   if (WithLoc()) {
     DisableSchedule();
@@ -1707,6 +608,7 @@ bool CGOptions::SolveOptions(const std::deque<Option> &opts, bool isDebug) {
     SetOption(kWithLoc);
     ClearOption(kSuppressFileInfo);
   }
+
   return true;
 }
 
diff --git a/src/mapleall/maple_be/src/cg/cg_options.cpp b/src/mapleall/maple_be/src/cg/cg_options.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..77eaabcd0ea84f672771d0a5779a0a99ccea061a
--- /dev/null
+++ b/src/mapleall/maple_be/src/cg/cg_options.cpp
@@ -0,0 +1,584 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * 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 v2 for more details.
+ */
+
+#include "driver_options.h"
+
+#include <bits/stdint-uintn.h>
+#include <stdint.h>
+#include <string>
+
+namespace opts::cg {
+
+cl::Option<bool> pie({"--pie"},
+                     "  --pie                       \tGenerate position-independent executable\n"
+                     "  --no-pie\n",
+                     {cgCategory},
+                     cl::DisableWith("--no-pie"));
+
+cl::Option<bool> fpic({"--fpic"},
+                      "  --fpic                      \tGenerate position-independent shared library\n"
+                      "  --no-fpic\n",
+                      {cgCategory},
+                      cl::DisableWith("--no-fpic"));
+
+cl::Option<bool> verboseAsm({"--verbose-asm"},
+                            "  --verbose-asm               \tAdd comments to asm output\n"
+                            "  --no-verbose-asm\n",
+                            {cgCategory},
+                            cl::DisableWith("--no-verbose-asm"));
+
+cl::Option<bool> verboseCg({"--verbose-cg"},
+                           "  --verbose-cg               \tAdd comments to cg output\n"
+                           "  --no-verbose-cg\n",
+                           {cgCategory},
+                           cl::DisableWith("--no-verbose-cg"));
+
+cl::Option<bool> maplelinker({"--maplelinker"},
+                             "  --maplelinker               \tGenerate the MapleLinker .s format\n"
+                             "  --no-maplelinker\n",
+                             {cgCategory},
+                             cl::DisableWith("--no-maplelinker"));
+
+cl::Option<bool> quiet({"--quiet"},
+                       "  --quiet                     \tBe quiet (don't output debug messages)\n"
+                       "  --no-quiet\n",
+                       {cgCategory},
+                       cl::DisableWith("--no-quiet"));
+
+cl::Option<bool> cg({"--cg"},
+                    "  --cg                        \tGenerate the output .s file\n"
+                    "  --no-cg\n",
+                    {cgCategory},
+                    cl::DisableWith("--no-cg"));
+
+cl::Option<bool> replaceAsm({"--replaceasm"},
+                            "  --replaceasm                \tReplace the the assembly code\n"
+                            "  --no-replaceasm\n",
+                            {cgCategory},
+                            cl::DisableWith("--no-replaceasm"));
+
+cl::Option<bool> generalRegOnly({"--general-reg-only"},
+                                " --general-reg-only           \tdisable floating-point or Advanced SIMD registers\n"
+                                " --no-general-reg-only\n",
+                                {cgCategory},
+                                cl::DisableWith("--no-general-reg-only"));
+
+cl::Option<bool> lazyBinding({"--lazy-binding"},
+                              "  --lazy-binding              \tBind class symbols lazily[default off]\n",
+                             {cgCategory},
+                              cl::DisableWith("--no-lazy-binding"));
+
+cl::Option<bool> hotFix({"--hot-fix"},
+                        "  --hot-fix                   \tOpen for App hot fix[default off]\n"
+                        "  --no-hot-fix\n",
+                        {cgCategory},
+                        cl::DisableWith("--no-hot-fix"));
+
+cl::Option<bool> ebo({"--ebo"},
+                     "  --ebo                       \tPerform Extend block optimization\n"
+                     "  --no-ebo\n",
+                     {cgCategory},
+                     cl::DisableWith("--no-ebo"));
+
+cl::Option<bool> cfgo({"--cfgo"},
+                      "  --cfgo                      \tPerform control flow optimization\n"
+                      "  --no-cfgo\n",
+                      {cgCategory},
+                      cl::DisableWith("--no-cfgo"));
+
+cl::Option<bool> ico({"--ico"},
+                     "  --ico                       \tPerform if-conversion optimization\n"
+                     "  --no-ico\n",
+                     {cgCategory},
+                     cl::DisableWith("--no-ico"));
+
+cl::Option<bool> storeloadopt({"--storeloadopt"},
+                              "  --storeloadopt              \tPerform global store-load optimization\n"
+                              "  --no-storeloadopt\n",
+                              {cgCategory},
+                              cl::DisableWith("--no-storeloadopt"));
+
+cl::Option<bool> globalopt({"--globalopt"},
+                           "  --globalopt                 \tPerform global optimization\n"
+                           "  --no-globalopt\n",
+                           {cgCategory},
+                           cl::DisableWith("--no-globalopt"));
+
+cl::Option<bool> prelsra({"--prelsra"},
+                         "  --prelsra                   \tPerform live interval simplification in LSRA\n"
+                         "  --no-prelsra\n",
+                         {cgCategory},
+                         cl::DisableWith("--no-prelsra"));
+
+cl::Option<bool> lsraLvarspill({"--lsra-lvarspill"},
+                                "  --lsra-lvarspill            \tPerform LSRA spill using local ref var stack locations\n"
+                                "  --no-lsra-lvarspill\n",
+                               {cgCategory},
+                                cl::DisableWith("--no-lsra-lvarspill"));
+
+cl::Option<bool> lsraOptcallee({"--lsra-optcallee"},
+                               "  --lsra-optcallee            \tSpill callee if only one def to use\n"
+                               "  --no-lsra-optcallee\n",
+                               {cgCategory},
+                               cl::DisableWith("--no-lsra-optcallee"));
+
+cl::Option<bool> calleeregsPlacement({"--calleeregs-placement"},
+                                     "  --calleeregs-placement      \tOptimize placement of callee-save registers\n"
+                                     "  --no-calleeregs-placement\n",
+                                     {cgCategory},
+                                     cl::DisableWith("--no-calleeregs-placement"));
+
+cl::Option<bool> ssapreSave({"--ssapre-save"},
+                            "  --ssapre-save                \tUse ssapre algorithm to save callee-save registers\n"
+                            "  --no-ssapre-save\n",
+                            {cgCategory},
+                            cl::DisableWith("--no-ssapre-save"));
+
+cl::Option<bool> ssupreRestore({"--ssupre-restore"},
+                                "  --ssupre-restore             \tUse ssupre algorithm to restore callee-save registers\n"
+                                "  --no-ssupre-restore\n",
+                               {cgCategory},
+                                cl::DisableWith("--no-ssupre-restore"));
+
+cl::Option<bool> prepeep({"--prepeep"},
+                         "  --prepeep                   \tPerform peephole optimization before RA\n"
+                         "  --no-prepeep\n",
+                         {cgCategory},
+                         cl::DisableWith("--no-prepeep"));
+
+cl::Option<bool> peep({"--peep"},
+                      "  --peep                      \tPerform peephole optimization after RA\n"
+                      "  --no-peep\n",
+                      {cgCategory},
+                      cl::DisableWith("--no-peep"));
+
+cl::Option<bool> preschedule({"--preschedule"},
+                             "  --preschedule               \tPerform prescheduling\n"
+                             "  --no-preschedule\n",
+                             {cgCategory},
+                             cl::DisableWith("--no-preschedule"));
+
+cl::Option<bool> schedule({"--schedule"},
+                          "  --schedule                  \tPerform scheduling\n"
+                          "  --no-schedule\n",
+                          {cgCategory},
+                          cl::DisableWith("--no-schedule"));
+
+cl::Option<bool> retMerge({"--ret-merge"},
+                           "  --ret-merge                 \tMerge return bb into a single destination\n"
+                           "  --no-ret-merge              \tallows for multiple return bb\n",
+                          {cgCategory},
+                           cl::DisableWith("--no-ret-merge"));
+
+cl::Option<bool> vregRename({"--vreg-rename"},
+                             "  --vreg-rename                  \tPerform rename of long live range around loops in coloring RA\n"
+                             "  --no-vreg-rename\n",
+                            {cgCategory},
+                             cl::DisableWith("--no-vreg-rename"));
+
+cl::Option<bool> fullcolor({"--fullcolor"},
+                           "  --fullcolor                  \tPerform multi-pass coloring RA\n"
+                           "  --no-fullcolor\n",
+                           {cgCategory},
+                           cl::DisableWith("--no-fullcolor"));
+
+cl::Option<bool> writefieldopt({"--writefieldopt"},
+                               "  --writefieldopt                  \tPerform WriteRefFieldOpt\n"
+                               "  --no-writefieldopt\n",
+                               {cgCategory},
+                               cl::DisableWith("--no-writefieldopt"));
+
+cl::Option<bool> dumpOlog({"--dump-olog"},
+                          "  --dump-olog                 \tDump CFGO and ICO debug information\n"
+                          "  --no-dump-olog\n",
+                          {cgCategory},
+                          cl::DisableWith("--no-dump-olog"));
+
+cl::Option<bool> nativeopt({"--nativeopt"},
+                           "  --nativeopt                 \tEnable native opt\n"
+                           "  --no-nativeopt\n",
+                           {cgCategory},
+                           cl::DisableWith("--no-nativeopt"));
+
+cl::Option<bool> objmap({"--objmap"},
+                        "  --objmap                    \tCreate object maps (GCTIBs) inside the main output (.s) file\n"
+                        "  --no-objmap\n",
+                        {cgCategory},
+                        cl::DisableWith("--no-objmap"));
+
+cl::Option<bool> yieldpoint({"--yieldpoint"},
+                            "  --yieldpoint                \tGenerate yieldpoints [default]\n"
+                            "  --no-yieldpoint\n",
+                            {cgCategory},
+                            cl::DisableWith("--no-yieldpoint"));
+
+cl::Option<bool> proepilogue({"--proepilogue"},
+                             "  --proepilogue               \tDo tail call optimization and eliminate unnecessary prologue and epilogue.\n"
+                             "  --no-proepilogue\n",
+                             {cgCategory},
+                             cl::DisableWith("--no-proepilogue"));
+
+cl::Option<bool> localRc({"--local-rc"},
+                         "  --local-rc                  \tHandle Local Stack RC [default]\n"
+                         "  --no-local-rc\n",
+                         {cgCategory},
+                         cl::DisableWith("--no-local-rc"));
+
+cl::Option<std::string> insertCall({"--insert-call"},
+                                   "  --insert-call=name          \tInsert a call to the named function\n",
+                                   {cgCategory});
+
+cl::Option<bool> addDebugTrace({"--add-debug-trace"},
+                               "  --add-debug-trace           \tInstrument the output .s file to print call traces at runtime\n",
+                               {cgCategory});
+
+cl::Option<bool> addFuncProfile({"--add-func-profile"},
+                                "  --add-func-profile          \tInstrument the output .s file to record func at runtime\n",
+                                {cgCategory});
+
+cl::Option<std::string> classListFile({"--class-list-file"},
+                                      "  --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",
+                                      {cgCategory});
+
+cl::Option<bool> genCMacroDef({"--gen-c-macro-def"},
+                              "  --gen-c-macro-def           \tGenerate a .def file that contains extra type metadata, including the\n"
+                              "                              \tclass instance sizes and field offsets (default)\n"
+                              "  --no-gen-c-macro-def\n",
+                              {cgCategory},
+                              cl::DisableWith("--no-gen-c-macro-def"));
+
+cl::Option<bool> genGctibFile({"--gen-gctib-file"},
+                              "  --gen-gctib-file            \tGenerate a separate .s file for GCTIBs. Usually used together with\n"
+                              "                              \t--no-objmap (not implemented yet)\n"
+                              "  --no-gen-gctib-file\n",
+                              {cgCategory},
+                              cl::DisableWith("--no-gen-gctib-file"));
+
+cl::Option<bool> stackguard({"--stackguard"},
+                            "  --stackguard                 \tadd stack guard\n"
+                            "  --no-stackguard\n",
+                            {cgCategory},
+                            cl::DisableWith("--no-stackguard"));
+
+cl::Option<bool> debug({"-g", "--g"},
+                       "  -g                          \tGenerate debug information\n",
+                       {cgCategory});
+
+cl::Option<bool> gdwarf({"--gdwarf"},
+                        "  --gdwarf                    \tGenerate dwarf infomation\n",
+                        {cgCategory});
+
+cl::Option<bool> gsrc({"--gsrc"},
+                      "  --gsrc                      \tUse original source file instead of mpl file for debugging\n",
+                      {cgCategory});
+
+cl::Option<bool> gmixedsrc({"--gmixedsrc"},
+                           "  --gmixedsrc                 \tUse both original source file and mpl file for debugging\n",
+                           {cgCategory});
+
+cl::Option<bool> gmixedasm({"--gmixedasm"},
+                           "  --gmixedasm                 \tComment out both original source file and mpl file for debugging\n",
+                           {cgCategory});
+
+cl::Option<bool> profile({"--p", "-p"},
+                         "  -p                          \tGenerate profiling infomation\n",
+                         {cgCategory});
+
+cl::Option<bool> withRaLinearScan({"--with-ra-linear-scan"},
+                                  "  --with-ra-linear-scan       \tDo linear-scan register allocation\n",
+                                  {cgCategory});
+
+cl::Option<bool> withRaGraphColor({"--with-ra-graph-color"},
+                                  "  --with-ra-graph-color       \tDo coloring-based register allocation\n",
+                                  {cgCategory});
+
+cl::Option<bool> patchLongBranch({"--patch-long-branch"},
+                                 "  --patch-long-branch         \tEnable patching long distance branch with jumping pad\n",
+                                 {cgCategory});
+
+cl::Option<bool> constFold({"--const-fold"},
+                           "  --const-fold                \tEnable constant folding\n"
+                           "  --no-const-fold\n",
+                           {cgCategory},
+                           cl::DisableWith("--no-const-fold"));
+
+cl::Option<std::string> ehExclusiveList({"--eh-exclusive-list"},
+                                          "  --eh-exclusive-list         \tFor generating gold files in unit testing\n"
+                                          "                              \t--eh-exclusive-list=list_file\n",
+                                        {cgCategory});
+
+cl::Option<bool> o0({"-O0", "--O0"},
+                    "  -O0                         \tNo optimization.\n",
+                    {cgCategory});
+
+cl::Option<bool> o1({"-O1", "--O1"},
+                    "  -O1                         \tDo some optimization.\n",
+                    {cgCategory});
+
+cl::Option<bool> o2({"-O2", "--O2"},
+                    "  -O2                          \tDo some optimization.\n",
+                    {cgCategory});
+
+cl::Option<bool> os({"-Os", "--Os"},
+                    "  -Os                          \tOptimize for size, based on O2.\n",
+                    {cgCategory});
+
+cl::Option<uint64_t> lsraBb({"--lsra-bb"},
+                            "  --lsra-bb=NUM               \tSwitch to spill mode if number of bb in function exceeds NUM\n",
+                            {cgCategory});
+
+cl::Option<uint64_t> lsraInsn({"--lsra-insn"},
+                              "  --lsra-insn=NUM             \tSwitch to spill mode if number of instructons in function exceeds NUM\n",
+                              {cgCategory});
+
+cl::Option<uint64_t> lsraOverlap({"--lsra-overlap"},
+                                 "  --lsra-overlap=NUM          \toverlap NUM to decide pre spill in lsra\n",
+                                 {cgCategory});
+
+cl::Option<uint8_t> remat({"--remat"},
+                          "  --remat                     \tEnable rematerialization during register allocation\n"
+                          "                              \t     0: no rematerialization (default)\n"
+                          "                              \t  >= 1: rematerialize constants\n"
+                          "                              \t  >= 2: rematerialize addresses\n"
+                          "                              \t  >= 3: rematerialize local dreads\n"
+                          "                              \t  >= 4: rematerialize global dreads\n",
+                          {cgCategory});
+
+cl::Option<bool> suppressFileinfo({"--suppress-fileinfo"},
+                                  "  --suppress-fileinfo         \tFor generating gold files in unit testing\n",
+                                  {cgCategory});
+
+cl::Option<bool> dumpCfg({"--dump-cfg"},
+                         "  --dump-cfg\n",
+                         {cgCategory});
+
+cl::Option<std::string> target({"--target"},
+                               "  --target=TARGETMACHINE \t generate code for TARGETMACHINE\n",
+                               {cgCategory},
+                               cl::optionalValue);
+
+cl::Option<std::string> dumpPhases({"--dump-phases"},
+                                   "  --dump-phases=PHASENAME,... \tEnable debug trace for specified phases in the comma separated list\n",
+                                   {cgCategory});
+
+cl::Option<std::string> skipPhases({"--skip-phases"},
+                                   "  --skip-phases=PHASENAME,... \tSkip the phases specified in the comma separated list\n",
+                                   {cgCategory});
+
+cl::Option<std::string> skipFrom({"--skip-from"},
+                                 "  --skip-from=PHASENAME       \tSkip the rest phases from PHASENAME(included)\n",
+                                 {cgCategory});
+
+cl::Option<std::string> skipAfter({"--skip-after"},
+                                  "  --skip-after=PHASENAME      \tSkip the rest phases after PHASENAME(excluded)\n",
+                                  {cgCategory});
+
+cl::Option<std::string> dumpFunc({"--dump-func"},
+                                 "  --dump-func=FUNCNAME        \tDump/trace only for functions whose names contain FUNCNAME as substring\n"
+                                 "                              \t(can only specify once)\n",
+                                 {cgCategory});
+
+cl::Option<bool> timePhases({"--time-phases"},
+                            "  --time-phases               \tCollect compilation time stats for each phase\n"
+                            "  --no-time-phases            \tDon't Collect compilation time stats for each phase\n",
+                            {cgCategory},
+                            cl::DisableWith("--no-time-phases"));
+
+cl::Option<bool> useBarriersForVolatile({"--use-barriers-for-volatile"},
+                                        "  --use-barriers-for-volatile \tOptimize volatile load/str\n"
+                                        "  --no-use-barriers-for-volatile\n",
+                                        {cgCategory},
+                                        cl::DisableWith("--no-use-barriers-for-volatile"));
+
+cl::Option<std::string> range({"--range"},
+                              "  --range=NUM0,NUM1           \tOptimize only functions in the range [NUM0, NUM1]\n",
+                              {cgCategory});
+
+cl::Option<uint8_t> fastAlloc({"--fast-alloc"},
+                              "  --fast-alloc=[0/1]          \tO2 RA fast mode, set to 1 to spill all registers\n",
+                              {cgCategory});
+
+cl::Option<std::string> spillRange({"--spill_range"},
+                                   "  --spill_range=NUM0,NUM1     \tO2 RA spill registers in the range [NUM0, NUM1]\n",
+                                   {cgCategory});
+
+cl::Option<bool> dupBb({"--dup-bb"},
+                       "  --dup-bb                 \tAllow cfg optimizer to duplicate bb\n"
+                       "  --no-dup-bb              \tDon't allow cfg optimizer to duplicate bb\n",
+                       {cgCategory},
+                       cl::DisableWith("--no-dup-bb"));
+
+cl::Option<bool> calleeCfi({"--callee-cfi"},
+                           "  --callee-cfi                \tcallee cfi message will be generated\n"
+                           "  --no-callee-cfi             \tcallee cfi message will not be generated\n",
+                           {cgCategory},
+                           cl::DisableWith("--no-callee-cfi"));
+
+cl::Option<bool> printFunc({"--print-func"},
+                            "  --print-func\n"
+                            "  --no-print-func\n",
+                           {cgCategory},
+                            cl::DisableWith("--no-print-func"));
+
+cl::Option<std::string> cyclePatternList({"--cycle-pattern-list"},
+                                         "  --cycle-pattern-list        \tFor generating cycle pattern meta\n"
+                                         "                              \t--cycle-pattern-list=list_file\n",
+                                         {cgCategory});
+
+cl::Option<std::string> duplicateAsmList({"--duplicate_asm_list"},
+                                         "  --duplicate_asm_list        \tDuplicate asm functions to delete plt call\n"
+                                         "                              \t--duplicate_asm_list=list_file\n",
+                                         {cgCategory});
+
+cl::Option<std::string> duplicateAsmList2({"--duplicate_asm_list2"},
+                                          "  --duplicate_asm_list2       \tDuplicate more asm functions to delete plt call\n"
+                                          "                              \t--duplicate_asm_list2=list_file\n",
+                                          {cgCategory});
+
+cl::Option<std::string> blockMarker({"--block-marker"},
+                                    "  --block-marker              \tEmit block marker symbols in emitted assembly files\n",
+                                    {cgCategory});
+
+cl::Option<bool> soeCheck({"--soe-check"},
+                          "  --soe-check                 \tInsert a soe check instruction[default off]\n",
+                          {cgCategory});
+
+cl::Option<bool> checkArraystore({"--check-arraystore"},
+                                 "  --check-arraystore          \tcheck arraystore exception[default off]\n"
+                                 "  --no-check-arraystore\n",
+                                 {cgCategory},
+                                 cl::DisableWith("--no-check-arraystore"));
+
+cl::Option<bool> debugSchedule({"--debug-schedule"},
+                               "  --debug-schedule            \tdump scheduling information\n"
+                               "  --no-debug-schedule\n",
+                               {cgCategory},
+                               cl::DisableWith("--no-debug-schedule"));
+
+cl::Option<bool> bruteforceSchedule({"--bruteforce-schedule"},
+                                    "  --bruteforce-schedule       \tdo brute force schedule\n"
+                                    "  --no-bruteforce-schedule\n",
+                                    {cgCategory},
+                                    cl::DisableWith("--no-bruteforce-schedule"));
+
+cl::Option<bool> simulateSchedule({"--simulate-schedule"},
+                                  "  --simulate-schedule         \tdo simulate schedule\n"
+                                  "  --no-simulate-schedule\n",
+                                  {cgCategory},
+                                  cl::DisableWith("--no-simulate-schedule"));
+
+cl::Option<bool> crossLoc({"--cross-loc"},
+                          "  --cross-loc                 \tcross loc insn schedule\n"
+                          "  --no-cross-loc\n",
+                          {cgCategory},
+                          cl::DisableWith("--no-cross-loc"));
+
+cl::Option<std::string> floatAbi({"--float-abi"},
+                                 "  --float-abi=name            \tPrint the abi type.\n"
+                                 "                              \tname=hard: abi-hard (Default)\n"
+                                 "                              \tname=soft: abi-soft\n"
+                                 "                              \tname=softfp: abi-softfp\n",
+                                 {cgCategory});
+
+cl::Option<std::string> filetype({"--filetype"},
+                                 "  --filetype=name             \tChoose a file type.\n"
+                                 "                              \tname=asm: Emit an assembly file (Default)\n"
+                                 "                              \tname=obj: Emit an object file\n"
+                                 "                              \tname=null: not support yet\n",
+                                 {cgCategory});
+
+cl::Option<bool> longCalls({"--long-calls"},
+                           "  --long-calls                \tgenerate long call\n"
+                           "  --no-long-calls\n",
+                           {cgCategory},
+                           cl::DisableWith("--no-long-calls"));
+
+cl::Option<bool> functionSections({"--function-sections"},
+                                  " --function-sections           \t \n"
+                                  "  --no-function-sections\n",
+                                  {cgCategory},
+                                  cl::DisableWith("--no-function-sections"));
+
+cl::Option<bool> omitFramePointer({"--omit-frame-pointer"},
+                                  " --omit-frame-pointer          \t do not use frame pointer \n"
+                                  " --no-omit-frame-pointer\n",
+                                  {cgCategory},
+                                  cl::DisableWith("--no-omit-frame-pointer"));
+
+cl::Option<bool> fastMath({"--fast-math"},
+                          "  --fast-math                  \tPerform fast math\n"
+                          "  --no-fast-math\n",
+                          {cgCategory},
+                          cl::DisableWith("--no-fast-math"));
+
+cl::Option<bool> tailcall({"--tailcall"},
+                          "  --tailcall                   \tDo tail call optimization\n"
+                          "  --no-tailcall\n",
+                          {cgCategory},
+                          cl::DisableWith("--no-tailcall"));
+
+cl::Option<bool> alignAnalysis({"--align-analysis"},
+                               "  --align-analysis                 \tPerform alignanalysis\n"
+                               "  --no-align-analysis\n",
+                               {cgCategory},
+                               cl::DisableWith("--no-align-analysis"));
+
+cl::Option<bool> cgSsa({"--cg-ssa"},
+                       "  --cg-ssa                     \tPerform cg ssa\n"
+                       "  --no-cg-ssa\n",
+                       {cgCategory},
+                       cl::DisableWith("--no-cg-ssa"));
+
+cl::Option<bool> common({"--common"},
+                        " --common           \t \n"
+                        " --no-common\n",
+                       {cgCategory},
+                       cl::DisableWith("--no-common"));
+
+cl::Option<bool> arm64Ilp32({"--arm64-ilp32"},
+                            " --arm64-ilp32                 \tarm64 with a 32-bit ABI instead of a 64bit ABI\n"
+                            " --no-arm64-ilp32\n",
+                            {cgCategory},
+                            cl::DisableWith("--no-arm64-ilp32"));
+
+cl::Option<bool> condbrAlign({"--condbr-align"},
+                             "  --condbr-align                   \tPerform condbr align\n"
+                             "  --no-condbr-align\n",
+                             {cgCategory},
+                             cl::DisableWith("--no-condbr-align"));
+
+cl::Option<uint32_t> alignMinBbSize({"--align-min-bb-size"},
+                                    " --align-min-bb-size=NUM           \tO2 Minimum bb size for alignment   unit:byte\n",
+                                    {cgCategory});
+
+cl::Option<uint32_t> alignMaxBbSize({"--align-max-bb-size"},
+                                    " --align-max-bb-size=NUM           \tO2 Maximum bb size for alignment   unit:byte\n",
+                                    {cgCategory});
+
+cl::Option<uint32_t> loopAlignPow({"--loop-align-pow"},
+                                  " --loop-align-pow=NUM           \tO2 loop bb align pow (NUM == 0, no loop-align)\n",
+                                  {cgCategory});
+
+cl::Option<uint32_t> jumpAlignPow({"--jump-align-pow"},
+                                  " --jump-align-pow=NUM           \tO2 jump bb align pow (NUM == 0, no jump-align)\n",
+                                  {cgCategory});
+
+cl::Option<uint32_t> funcAlignPow({"--func-align-pow"},
+                                  " --func-align-pow=NUM           \tO2 func bb align pow (NUM == 0, no func-align)\n",
+                                  {cgCategory});
+
+}
diff --git a/src/mapleall/maple_driver/BUILD.gn b/src/mapleall/maple_driver/BUILD.gn
index 4cdb42df47e3ff02adeec7c32e56da89dc23ca8e..e48f0cec34522307b551e3c8bc933651db727bc0 100644
--- a/src/mapleall/maple_driver/BUILD.gn
+++ b/src/mapleall/maple_driver/BUILD.gn
@@ -39,31 +39,13 @@ include_directories = [
 ]
 
 executable("maple") {
-  sources = [
-    "src/as_compiler.cpp",
-    "src/compiler.cpp",
-    "src/compiler_factory.cpp",
-    "src/compiler_selector.cpp",
-    "src/dex2mpl_compiler.cpp",
-    "src/driver_runner.cpp",
-    "src/file_utils.cpp",
-    "src/ipa_compiler.cpp",
-    "src/jbc2mpl_compiler.cpp",
-    "src/cpp2mpl_compiler.cpp",
-    "src/clang_compiler.cpp",
-    "src/ld_compiler.cpp",
-    "src/maple.cpp",
-    "src/maple_comb_compiler_wrapper.cpp",
-    "src/maple_comb_compiler.cpp",
-    "src/mpl_options.cpp",
-    "src/mplcg_compiler.cpp",
-  ]
+  sources = [ "src/maple.cpp" ]
 
   include_dirs = include_directories
 
   deps = [
+    ":libdriver",
     ":libdriver_option",
-    ":liboption_parser",
     "${MAPLEALL_ROOT}/maple_be:libcg",
     "${MAPLEALL_ROOT}/maple_be:libmplad",
     "${MAPLEALL_ROOT}/maple_be:libmplbe",
@@ -74,29 +56,44 @@ executable("maple") {
     "${MAPLEALL_ROOT}/maple_phase:libmplphase",
     "${MAPLEALL_ROOT}/maple_phase:libmplphase",
     "${MAPLEALL_ROOT}/maple_util:libmplutil",
+    "${MAPLEALL_ROOT}/maple_util:libcommandline",
     "${MAPLEALL_ROOT}/mempool:libmempool",
     "${MAPLEALL_ROOT}/mpl2mpl:libmpl2mpl",
     "${THIRD_PARTY_ROOT}/bounds_checking_function:libHWSecureC",
   ]
 }
 
-static_library("libdriver_option") {
-  sources = [ "src/driver_option_common.cpp" ]
+static_library("libdriver") {
+  sources = [
+    "src/as_compiler.cpp",
+    "src/compiler.cpp",
+    "src/compiler_factory.cpp",
+    "src/compiler_selector.cpp",
+    "src/dex2mpl_compiler.cpp",
+    "src/driver_runner.cpp",
+    "src/ipa_compiler.cpp",
+    "src/jbc2mpl_compiler.cpp",
+    "src/cpp2mpl_compiler.cpp",
+    "src/clang_compiler.cpp",
+    "src/ld_compiler.cpp",
+    "src/maple_driver.cpp",
+    "src/maple_comb_compiler_wrapper.cpp",
+    "src/maple_comb_compiler.cpp",
+    "src/mplcg_compiler.cpp",
+    "src/jbc2mpl_options.cpp",
+  ]
 
-  include_dirs = [ "${MAPLEALL_ROOT}/maple_driver/include" ]
+  include_dirs = include_directories
 
   output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
 }
 
-static_library("liboption_parser") {
-  sources = ["src/option_parser.cpp"]
+static_library("libdriver_option") {
+  sources = [ "src/driver_options.cpp" ]
 
-  include_dirs = [
-    "${MAPLEALL_ROOT}/maple_util/include",
-    "${MAPLEALL_ROOT}/maple_driver/include",
-    "${MAPLEALL_ROOT}/maple_ir/include",
-    "${MAPLEALL_ROOT}/mempool/include",
-    "${THIRD_PARTY_ROOT}/bounds_checking_function/include",
-  ] output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
-}
+  include_dirs = [ "${MAPLEALL_ROOT}/maple_driver/include",
+                   "${MAPLEALL_ROOT}/maple_util/include"
+                 ]
 
+  output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
+}
diff --git a/src/mapleall/maple_driver/include/as_option.h b/src/mapleall/maple_driver/include/as_option.h
deleted file mode 100644
index 8e55d7c5670ded43df722a4c297de7c3f46a3881..0000000000000000000000000000000000000000
--- a/src/mapleall/maple_driver/include/as_option.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
- *
- * OpenArkCompiler is licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *
- *     http://license.coscl.org.cn/MulanPSL2
- *
- * 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 v2 for more details.
- */
-#ifndef MAPLE_AS_OPTION_H
-#define MAPLE_AS_OPTION_H
-#include "option_descriptor.h"
-
-namespace maple {
-enum AsOptionIndex {
-  kAsHelp,
-};
-
-const mapleOption::Descriptor asUsage[] = {
-  { kUnknown, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
-    "========================================\n"
-    " Usage: as [ options ]\n"
-    " options:\n",
-    "as",
-    {} },
-
-  { kAsHelp, 0, "h", "help", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-    "   -h, --help          : print usage and exit.\n",
-    "as",
-    {} },
-
-  { kUnknown, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "",
-    "as",
-    {} }
-};
-} // namespace maple
-#endif // MAPLE_AS_OPTION_H
diff --git a/src/mapleall/maple_driver/include/compiler.h b/src/mapleall/maple_driver/include/compiler.h
index 0284f635590892580757e567b42ad6cc6abe52da..28ceda66c69863495493d50c314a2394b224f830 100644
--- a/src/mapleall/maple_driver/include/compiler.h
+++ b/src/mapleall/maple_driver/include/compiler.h
@@ -15,6 +15,7 @@
 #ifndef MAPLE_DRIVER_INCLUDE_COMPILER_H
 #define MAPLE_DRIVER_INCLUDE_COMPILER_H
 #include <map>
+#include <string>
 #include <unordered_set>
 #include "error_code.h"
 #include "mpl_options.h"
@@ -28,31 +29,9 @@
 #ifdef INTERGRATE_DRIVER
 #include "dex2mpl_options.h"
 #endif
+#include "maple_driver.h"
 
 namespace maple {
-const std::string kBinNameNone = "";
-const std::string kBinNameJbc2mpl = "jbc2mpl";
-const std::string kBinNameCpp2mpl = "hir2mpl";
-const std::string kBinNameClang = "clang";
-const std::string kBinNameDex2mpl = "dex2mpl";
-const std::string kBinNameMplipa = "mplipa";
-const std::string kBinNameMe = "me";
-const std::string kBinNameMpl2mpl = "mpl2mpl";
-const std::string kBinNameMplcg = "mplcg";
-const std::string kBinNameMapleComb = "maplecomb";
-const std::string kBinNameMapleCombWrp = "maplecombwrp";
-const std::string kMachine = "aarch64-";
-const std::string kVendor = "unknown-";
-const std::string kOperatingSystem = "linux-gnu-";
-const std::string kLdFlag = "ld";
-const std::string kGccFlag = "gcc";
-const std::string kGppFlag = "g++";
-const std::string kAsFlag = "as";
-const std::string kInputPhase = "input";
-const std::string kBinNameLd = kMachine + kOperatingSystem + kLdFlag;
-const std::string kBinNameAs = kMachine + kOperatingSystem + kAsFlag;
-const std::string kBinNameGcc = kMachine + kOperatingSystem + kGccFlag;
-const std::string kBinNameGpp = kMachine + kOperatingSystem + kGppFlag;
 
 class Compiler {
  public:
@@ -60,20 +39,20 @@ class Compiler {
 
   virtual ~Compiler() = default;
 
-  virtual ErrorCode Compile(MplOptions &options, const Action &action,
+  virtual ErrorCode Compile(const Action &action,
                             std::unique_ptr<MIRModule> &theModule);
 
-  virtual void GetTmpFilesToDelete(const MplOptions&, const Action&,
+  virtual void GetTmpFilesToDelete(const Action&,
                                    std::vector<std::string>&) const {}
 
-  virtual std::unordered_set<std::string> GetFinalOutputs(const MplOptions&, const Action&) const {
+  virtual std::unordered_set<std::string> GetFinalOutputs(const Action&) const {
     return std::unordered_set<std::string>();
   }
 
-  virtual void PrintCommand(const MplOptions&, const Action&) const {}
+  virtual void PrintCommand(const Action&) const {}
 
  protected:
-  virtual std::string GetBinPath(const MplOptions &mplOptions) const;
+  virtual std::string GetBinPath() const;
   virtual const std::string &GetBinName() const {
     return kBinNameNone;
   }
@@ -85,30 +64,32 @@ class Compiler {
     return GetBinName();
   }
 
-  virtual std::string GetInputFileName(const MplOptions&, const Action &action) const {
+  virtual std::string GetInputFileName(const Action &action) const {
     return action.GetInputFile();
   }
 
-  virtual DefaultOption GetDefaultOptions(const MplOptions&, const Action&) const {
+  virtual DefaultOption GetDefaultOptions(const Action&) const {
     return DefaultOption();
   }
 
+  virtual void AppendOutputOption(std::vector<MplOption> &, const std::string &) const {
+    return;
+  }
+
  private:
   const std::string name;
-  std::vector<MplOption> MakeOption(const MplOptions &options,
-                                    const Action &action) const;
+  std::vector<MplOption> MakeOption(const Action &action) const;
   void AppendDefaultOptions(std::vector<MplOption> &finalOptions,
                             const std::vector<MplOption> &defaultOptions,
                             bool isDebug) const;
   void AppendExtraOptions(std::vector<MplOption> &finalOptions,
-                          const MplOptions &options, bool isDebug) const;
+                          bool isDebug, const Action &action) const;
   void AppendInputsAsOptions(std::vector<MplOption> &finalOptions,
-                             const MplOptions &mplOptions, const Action &action) const;
+                             const Action &action) const;
   void ReplaceOrInsertOption(std::vector<MplOption> &finalOptions,
                              const std::string &key, const std::string &value) const;
-  std::vector<MplOption> MakeDefaultOptions(const MplOptions &options,
-                                            const Action &action) const;
-  int Exe(const MplOptions &mplOptions, const std::vector<MplOption> &options) const;
+  std::vector<MplOption> MakeDefaultOptions(const Action &action) const;
+  int Exe(const std::vector<MplOption> &options) const;
   const std::string &GetName() const {
     return name;
   }
@@ -122,11 +103,10 @@ class Jbc2MplCompiler : public Compiler {
 
  private:
   const std::string &GetBinName() const override;
-  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
-  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+  DefaultOption GetDefaultOptions(const Action &action) const override;
+  void GetTmpFilesToDelete(const Action &action,
                            std::vector<std::string> &tempFiles) const override;
-  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
-                                                  const Action &action) const override;
+  std::unordered_set<std::string> GetFinalOutputs(const Action &action) const override;
 };
 
 class ClangCompiler : public Compiler {
@@ -137,12 +117,12 @@ class ClangCompiler : public Compiler {
 
  private:
   const std::string &GetBinName() const override;
-  std::string GetBinPath(const MplOptions &options) const override;
-  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
-  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+  std::string GetBinPath() const override;
+  DefaultOption GetDefaultOptions(const Action &action) const override;
+  void GetTmpFilesToDelete(const Action &action,
                            std::vector<std::string> &tempFiles) const override;
-  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
-                                                  const Action &action) const override ;
+  std::unordered_set<std::string> GetFinalOutputs(const Action &action) const override;
+  void AppendOutputOption(std::vector<MplOption> &finalOptions, const std::string &name) const override;
 };
 
 class Cpp2MplCompiler : public Compiler {
@@ -152,14 +132,14 @@ class Cpp2MplCompiler : public Compiler {
   ~Cpp2MplCompiler() = default;
 
  private:
-  std::string GetBinPath(const MplOptions &options) const override;
+  std::string GetBinPath() const override;
   const std::string &GetBinName() const override;
-  std::string GetInputFileName(const MplOptions &options, const Action &action) const override;
-  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
-  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+  std::string GetInputFileName(const Action &action) const override;
+  DefaultOption GetDefaultOptions(const Action &action) const override;
+  void GetTmpFilesToDelete(const Action &action,
                            std::vector<std::string> &tempFiles) const override;
-  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
-                                                  const Action &action) const override;
+  std::unordered_set<std::string> GetFinalOutputs(const Action &action) const override;
+  void AppendOutputOption(std::vector<MplOption> &finalOptions, const std::string &name) const override;
 };
 
 class Dex2MplCompiler : public Compiler {
@@ -167,24 +147,14 @@ class Dex2MplCompiler : public Compiler {
   explicit Dex2MplCompiler(const std::string &name) : Compiler(name) {}
 
   ~Dex2MplCompiler() = default;
-#ifdef INTERGRATE_DRIVER
-  ErrorCode Compile(MplOptions &options, const Action &action,
-                    std::unique_ptr<MIRModule> &theModule) override;
-#endif
-
-  void PrintCommand(const MplOptions &options, const Action &action) const override;
+  void PrintCommand(const Action &action) const override;
 
  private:
   const std::string &GetBinName() const override;
-  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
-  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+  DefaultOption GetDefaultOptions(const Action &action) const override;
+  void GetTmpFilesToDelete(const Action &action,
                            std::vector<std::string> &tempFiles) const override;
-  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
-                                                  const Action &action) const override;
-#ifdef INTERGRATE_DRIVER
-  void PostDex2Mpl(std::unique_ptr<MIRModule> &theModule) const;
-  bool MakeDex2mplOptions(const MplOptions &options);
-#endif
+  std::unordered_set<std::string> GetFinalOutputs(const Action &action) const override;
 };
 
 class IpaCompiler : public Compiler {
@@ -195,8 +165,8 @@ class IpaCompiler : public Compiler {
 
  private:
   const std::string &GetBinName() const override;
-  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
-  std::string GetInputFileName(const MplOptions &options, const Action &action) const override;
+  DefaultOption GetDefaultOptions(const Action &action) const override;
+  std::string GetInputFileName(const Action &action) const override;
 };
 
 class MapleCombCompiler : public Compiler {
@@ -205,19 +175,19 @@ class MapleCombCompiler : public Compiler {
 
   ~MapleCombCompiler() = default;
 
-  ErrorCode Compile(MplOptions &options, const Action &action,
+  ErrorCode Compile(const Action &action,
                     std::unique_ptr<MIRModule> &theModule) override;
-  void PrintCommand(const MplOptions &options, const Action &action) const override;
-  std::string GetInputFileName(const MplOptions &options, const Action &action) const override;
+  void PrintCommand(const Action &action) const override;
+  std::string GetInputFileName(const Action &action) const override;
 
  private:
-  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
-                                                  const Action &action) const override;
-  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+  std::unordered_set<std::string> GetFinalOutputs(const Action &action) const override;
+  void GetTmpFilesToDelete(const Action &action,
                            std::vector<std::string> &tempFiles) const override;
-  ErrorCode MakeMeOptions(const MplOptions &options, DriverRunner &runner);
-  ErrorCode MakeMpl2MplOptions(const MplOptions &options, DriverRunner &runner);
-  std::string DecideOutExe(const MplOptions &options);
+  const std::string &DecideOutExe() const;
+  ErrorCode AppendCombOptions(MIRSrcLang srcLang);
+  ErrorCode MakeMeOptions(DriverRunner &runner);
+  ErrorCode MakeMpl2MplOptions(DriverRunner &runner);
 };
 
 class MplcgCompiler : public Compiler {
@@ -225,15 +195,15 @@ class MplcgCompiler : public Compiler {
   explicit MplcgCompiler(const std::string &name) : Compiler(name) {}
 
   ~MplcgCompiler() = default;
-  ErrorCode Compile(MplOptions &options, const Action &action,
+  ErrorCode Compile(const Action &action,
                     std::unique_ptr<MIRModule> &theModule) override;
-  void PrintMplcgCommand(const MplOptions &options, const Action &action, const MIRModule &md) const;
-  void SetOutputFileName(const MplOptions &options, const Action &action, const MIRModule &md);
-  std::string GetInputFile(const MplOptions &options, const Action &action, const MIRModule *md) const;
+  void PrintMplcgCommand(const Action &action, const MIRModule &md) const;
+  void SetOutputFileName(const Action &action, const MIRModule &md);
+  std::string GetInputFile(const Action &action, const MIRModule *md) const;
  private:
-  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
-  ErrorCode GetMplcgOptions(MplOptions &options, const Action &action, const MIRModule *theModule);
-  ErrorCode MakeCGOptions(const MplOptions &options);
+  ErrorCode GetMplcgOptions(const Action &action, const MIRModule *theModule);
+  ErrorCode AppendMplcgOptions(MIRSrcLang srcLang);
+  ErrorCode MakeCGOptions();
   const std::string &GetBinName() const override;
   std::string baseName;
   std::string outputFile;
@@ -244,16 +214,15 @@ class MapleCombCompilerWrp : public Compiler {
   explicit MapleCombCompilerWrp(const std::string &name) : Compiler(name) {}
   ~MapleCombCompilerWrp() = default;
 
-  std::string GetInputFileName(const MplOptions &options, const Action &action) const override;
+  std::string GetInputFileName(const Action &action) const override;
 
  private:
-  std::string GetBinPath(const MplOptions &options) const override;
+  std::string GetBinPath() const override;
   const std::string &GetBinName() const override;
-  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
-  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+  DefaultOption GetDefaultOptions(const Action &action) const override;
+  void GetTmpFilesToDelete(const Action &action,
                            std::vector<std::string> &tempFiles) const override;
-  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
-                                                  const Action &action) const override;
+  std::unordered_set<std::string> GetFinalOutputs(const Action &action) const override;
 };
 
 // Build .s to .o
@@ -264,15 +233,15 @@ class AsCompiler : public Compiler {
   ~AsCompiler() = default;
 
  private:
-  std::string GetBinPath(const MplOptions &options) const override;
+  std::string GetBinPath() const override;
   const std::string &GetBinName() const override;
   const std::string &GetTool() const override;
-  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
-  std::string GetInputFileName(const MplOptions &options, const Action &action) const override;
-  void GetTmpFilesToDelete(const MplOptions &mplOptions, const Action &action,
+  DefaultOption GetDefaultOptions(const Action &action) const override;
+  std::string GetInputFileName(const Action &action) const override;
+  void GetTmpFilesToDelete(const Action &action,
                            std::vector<std::string> &tempFiles) const override;
-  std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions,
-                                                  const Action &action) const override;
+  std::unordered_set<std::string> GetFinalOutputs(const Action &action) const override;
+  void AppendOutputOption(std::vector<MplOption> &finalOptions, const std::string &name) const override;
 };
 
 // Build .o to .so
@@ -283,11 +252,12 @@ class LdCompiler : public Compiler {
   ~LdCompiler() = default;
 
  private:
-  std::string GetBinPath(const MplOptions &options) const override;
+  std::string GetBinPath() const override;
   const std::string &GetBinName() const override;
   const std::string &GetTool() const override;
-  DefaultOption GetDefaultOptions(const MplOptions &options, const Action &action) const override;
-  std::string GetInputFileName(const MplOptions &options, const Action &action) const override;
+  DefaultOption GetDefaultOptions(const Action &action) const override;
+  std::string GetInputFileName(const Action &action) const override;
+  void AppendOutputOption(std::vector<MplOption> &finalOptions, const std::string &name) const override;
 };
 }  // namespace maple
 #endif  // MAPLE_DRIVER_INCLUDE_COMPILER_H
diff --git a/src/mapleall/maple_driver/include/compiler_factory.h b/src/mapleall/maple_driver/include/compiler_factory.h
index 1b5118ff5d94164fede2fe4c98a248923824f84c..85eb4c80b5645269650ddf13a0915ec4b82187e9 100644
--- a/src/mapleall/maple_driver/include/compiler_factory.h
+++ b/src/mapleall/maple_driver/include/compiler_factory.h
@@ -30,14 +30,17 @@ class CompilerFactory {
   CompilerFactory &operator=(const CompilerFactory&) = delete;
   CompilerFactory &operator=(CompilerFactory&&) = delete;
   ~CompilerFactory();
-  ErrorCode Compile(MplOptions &mplOptions);
+
+  ErrorCode Compile(const MplDriver::RootActionsType &rootActions);
+  ErrorCode DeleteTmpFiles(const std::vector<std::string> &tempFiles,
+                           const std::vector<std::string> &saveFiles,
+                           const std::vector<std::string> &inputFiles,
+                           const MplDriver::RootActionsType &actions) const;
 
  private:
   bool compileFinished = false;
   CompilerFactory();
   void Insert(const std::string &name, Compiler *value);
-  ErrorCode DeleteTmpFiles(const MplOptions &mplOptions,
-                           const std::vector<std::string> &tempFiles) const;
   SupportedCompilers supportedCompilers;
   CompilerSelector *compilerSelector;
   std::unique_ptr<MIRModule> theModule;
diff --git a/src/mapleall/maple_driver/include/compiler_selector.h b/src/mapleall/maple_driver/include/compiler_selector.h
index fa599313f35fc09af4bdea8a563493e47d72e7d5..d35348dd795ba924b3f81a026cc0fe421035ae0c 100644
--- a/src/mapleall/maple_driver/include/compiler_selector.h
+++ b/src/mapleall/maple_driver/include/compiler_selector.h
@@ -27,7 +27,7 @@ class CompilerSelector {
 
   virtual ~CompilerSelector() = default;
 
-  virtual ErrorCode Select(const SupportedCompilers&, const MplOptions&,
+  virtual ErrorCode Select(const SupportedCompilers&, const MplDriver::RootActionsType&,
                            std::vector<Action*>&) const {
     return kErrorToolNotFound;
   }
@@ -39,14 +39,12 @@ class CompilerSelectorImpl : public CompilerSelector {
 
   ~CompilerSelectorImpl() = default;
 
-  ErrorCode Select(const SupportedCompilers &supportedCompilers, const MplOptions &mplOptions,
+  ErrorCode Select(const SupportedCompilers &supportedCompilers, const MplDriver::RootActionsType&,
                    std::vector<Action*> &selectedActions) const override;
 
  private:
   Compiler *FindCompiler(const SupportedCompilers &compilers, const std::string &name) const;
-  ErrorCode InsertCompilerIfNeeded(std::vector<Compiler*> &selected, const SupportedCompilers &compilers,
-                                   const std::string &name) const;
-  ErrorCode Select(const SupportedCompilers &supportedCompilers, const MplOptions &mplOptions,
+  ErrorCode Select(const SupportedCompilers &supportedCompilers,
                    Action &action, std::vector<Action*> &selectedActions) const;
 };
 }  // namespace maple
diff --git a/src/mapleall/maple_driver/include/cpp2mpl_option.h b/src/mapleall/maple_driver/include/cpp2mpl_option.h
deleted file mode 100644
index b87a990444ce1b758cedaa416cf5b82f2cad1db5..0000000000000000000000000000000000000000
--- a/src/mapleall/maple_driver/include/cpp2mpl_option.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
- *
- * OpenArkCompiler is licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *
- *     http://license.coscl.org.cn/MulanPSL2
- *
- * 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 v2 for more details.
- */
-#ifndef MAPLE_CPP2MPL_OPTION_H
-#define MAPLE_CPP2MPL_OPTION_H
-#include "option_descriptor.h"
-
-namespace maple {
-enum CppOptionIndex {
-  kInAst,
-  kCpp2mplHelp,
-};
-
-const mapleOption::Descriptor cppUsage[] = {
-  { kUnknown, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
-    "========================================\n"
-    " Usage: hir2mpl [ options ]\n"
-    " options:\n",
-    "hir2mpl",
-    {} },
-
-  { kInAst, 0, "", "inast", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
-    "  -inast file1.ast,file2.ast\n"
-    "                         : input ast files",
-    "c2mpl",
-    {} },
-
-  { kCpp2mplHelp, 0, "h", "help", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-    "   -h, --help          : print usage and exit.\n",
-    "hir2mpl",
-    {} },
-
-  { kUnknown, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "",
-    "hir2mpl",
-    {} }
-};
-} // namespace maple
-
-#endif //MAPLE_CPP2MPL_OPTION_H
-
diff --git a/src/mapleall/maple_driver/include/driver_option_common.h b/src/mapleall/maple_driver/include/driver_option_common.h
deleted file mode 100644
index 6be56ed9613024c6433896ad0891896597cd8136..0000000000000000000000000000000000000000
--- a/src/mapleall/maple_driver/include/driver_option_common.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
- * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
- *
- * OpenArkCompiler is licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *
- *     http://license.coscl.org.cn/MulanPSL2
- *
- * 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 v2 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,
-  kOptimization1,
-  kOptimization2,
-  kOptimizationS,  // optimize for size
-  kWithIpa,
-  kGenObj,
-  kJbc2mplOpt,
-  kCpp2mplOpt,
-  kAsOpt,
-  kLdOpt,
-  kDex2mplOpt,
-  kMplipaOpt,
-  kVerify,
-  // Common options for each compiler
-  kDecoupleStatic,
-  // DAI2.0
-  kDecoupleInit,
-  kProfilePath,
-  kProfileGen,
-  kProfileUse,
-  kGCOnly,
-  kBigEndian,
-  kMplcgOpt,
-  kMeOpt,
-  kMpl2MplOpt,
-  kSaveTemps,
-  kRun,
-  kOption,
-  kTimePhases,
-  kGenMeMpl,
-  kGenMapleBC,
-  kGenLMBC,
-  kGenVtableImpl,
-  kVerbose,
-  kAllDebug,
-  kWithDwarf,
-  kHelpLevel,
-  kPartO2,
-  kNpeNoCheck,
-  kNpeStaticCheck,
-  kNpeDynamicCheck,
-  kNpeDynamicCheckSilent,
-  kNpeDynamicCheckAll,
-  kBoundaryNoCheck,
-  kBoundaryStaticCheck,
-  kBoundaryDynamicCheck,
-  kBoundaryDynamicCheckSilent,
-  kSafeRegionOption,
-  kMaplePrintPhases,
-  kMaplePhaseOnly,
-  kLdStatic,
-  kLdLib,
-  kLdLibPath,
-  kClangMacro,
-  kClangUMacro,
-  kClangInclude,
-  kClangISystem,
-  kMapleOut,
-  kCommonOptionEnd,
-};
-
-class MapleDriverOptionBase {
- public:
-  void CreateUsages(const mapleOption::Descriptor usage[]) {
-    for (size_t i = 0; usage[i].help != ""; ++i) {
-      usageVec.push_back(usage[i]);
-    }
-  }
-  const std::vector<mapleOption::Descriptor> &GetUsageVec() const {
-    return usageVec;
-  }
-  MapleDriverOptionBase() = default;
-  ~MapleDriverOptionBase() = default;
-
- private:
-  std::vector<mapleOption::Descriptor> usageVec;
-};
-
-class DriverOptionCommon : public MapleDriverOptionBase {
- public:
-  ~DriverOptionCommon() = default;
-  static DriverOptionCommon &GetInstance();
-
- private:
-  DriverOptionCommon();
-};
-}  // namespace maple
-#endif // DRIVER_OPTIONS_COMMON_H
diff --git a/src/mapleall/maple_driver/include/driver_options.h b/src/mapleall/maple_driver/include/driver_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..3ea9f488ef5d478213364ff057bd5138fa6465d0
--- /dev/null
+++ b/src/mapleall/maple_driver/include/driver_options.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * 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 v2 for more details.
+ */
+
+#ifndef MAPLE_DRIVER_INCLUDE_DRIVER_OPTIONS_H
+#define MAPLE_DRIVER_INCLUDE_DRIVER_OPTIONS_H
+
+#include "cl_option.h"
+#include "cl_parser.h"
+
+#include <string>
+
+static cl::OptionCategory &driverCategory = cl::CommandLine::GetCommandLine().defaultCategory;
+
+static cl::OptionCategory &clangCategory = cl::CommandLine::GetCommandLine().clangCategory;
+static cl::OptionCategory &hir2mplCategory = cl::CommandLine::GetCommandLine().hir2mplCategory;
+static cl::OptionCategory &mpl2mplCategory = cl::CommandLine::GetCommandLine().mpl2mplCategory;
+static cl::OptionCategory &meCategory = cl::CommandLine::GetCommandLine().meCategory;
+static cl::OptionCategory &cgCategory = cl::CommandLine::GetCommandLine().cgCategory;
+static cl::OptionCategory &asCategory = cl::CommandLine::GetCommandLine().asCategory;
+static cl::OptionCategory &ldCategory = cl::CommandLine::GetCommandLine().ldCategory;
+
+static cl::OptionCategory &dex2mplCategory = cl::CommandLine::GetCommandLine().dex2mplCategory;
+static cl::OptionCategory &jbc2mplCategory = cl::CommandLine::GetCommandLine().jbc2mplCategory;
+static cl::OptionCategory &ipaCategory = cl::CommandLine::GetCommandLine().ipaCategory;
+
+namespace opts {
+
+/* ##################### BOOL Options ############################################################### */
+
+extern cl::Option<bool> version;
+extern cl::Option<bool> o0;
+extern cl::Option<bool> o1;
+extern cl::Option<bool> o2;
+extern cl::Option<bool> os;
+extern cl::Option<bool> verify;
+extern cl::Option<bool> decoupleStatic;
+extern cl::Option<bool> bigendian;
+extern cl::Option<bool> gconly;
+extern cl::Option<bool> timePhase;
+extern cl::Option<bool> genMeMpl;
+extern cl::Option<bool> compileWOLink;
+extern cl::Option<bool> genVtable;
+extern cl::Option<bool> verbose;
+extern cl::Option<bool> debug;
+extern cl::Option<bool> withDwarf;
+extern cl::Option<bool> npeNoCheck;
+extern cl::Option<bool> npeStaticCheck;
+extern cl::Option<bool> npeDynamicCheck;
+extern cl::Option<bool> npeDynamicCheckSilent;
+extern cl::Option<bool> npeDynamicCheckAll;
+extern cl::Option<bool> boundaryNoCheck;
+extern cl::Option<bool> boundaryStaticCheck;
+extern cl::Option<bool> boundaryDynamicCheck;
+extern cl::Option<bool> boundaryDynamicCheckSilent;
+extern cl::Option<bool> safeRegionOption;
+extern cl::Option<bool> printDriverPhases;
+extern cl::Option<bool> ldStatic;
+extern cl::Option<bool> maplePhase;
+extern cl::Option<bool> genMapleBC;
+extern cl::Option<bool> genLMBC;
+extern cl::Option<bool> profileGen;
+extern cl::Option<bool> profileUse;
+
+/* ##################### STRING Options ############################################################### */
+
+extern cl::Option<std::string> help;
+extern cl::Option<std::string> infile;
+extern cl::Option<std::string> mplt;
+extern cl::Option<std::string> partO2;
+extern cl::List<std::string> jbc2mplOpt;
+extern cl::List<std::string> hir2mplOpt;
+extern cl::List<std::string> clangOpt;
+extern cl::List<std::string> asOpt;
+extern cl::List<std::string> ldOpt;
+extern cl::List<std::string> dex2mplOpt;
+extern cl::List<std::string> mplipaOpt;
+extern cl::List<std::string> mplcgOpt;
+extern cl::List<std::string> meOpt;
+extern cl::List<std::string> mpl2mplOpt;
+extern cl::Option<std::string> profile;
+extern cl::Option<std::string> run;
+extern cl::Option<std::string> optionOpt;
+extern cl::List<std::string> ldLib;
+extern cl::List<std::string> ldLibPath;
+extern cl::List<std::string> enableMacro;
+extern cl::List<std::string> disableMacro;
+extern cl::List<std::string> includeDir;
+extern cl::List<std::string> includeSystem;
+extern cl::Option<std::string> output;
+extern cl::Option<std::string> saveTempOpt;
+
+/* ##################### DIGITAL Options ############################################################### */
+
+extern cl::Option<uint32_t> helpLevel;
+
+/* #################################################################################################### */
+
+} /* opts */
+
+#endif /* MAPLE_DRIVER_INCLUDE_DRIVER_OPTIONS_H */
diff --git a/src/mapleall/maple_driver/include/driver_runner.h b/src/mapleall/maple_driver/include/driver_runner.h
index ca245d1e22dce392bed0e75f0e33950dc1d7900d..5412891765eedf50f9bed7f079803c31f886a02b 100644
--- a/src/mapleall/maple_driver/include/driver_runner.h
+++ b/src/mapleall/maple_driver/include/driver_runner.h
@@ -15,16 +15,19 @@
 #ifndef MAPLE_DRIVER_INCLUDE_DRIVER_RUNNER_H
 #define MAPLE_DRIVER_INCLUDE_DRIVER_RUNNER_H
 
-#include <vector>
-#include <string>
-#include <cstdlib>
-#include "me_option.h"
-#include "module_phase_manager.h"
-#include "error_code.h"
 #include "cg.h"
 #include "cg_option.h"
 #include "cg_phasemanager.h"
+#include "error_code.h"
+#include "maple_driver.h"
 #include "maple_phase_manager.h"
+#include "me_option.h"
+#include "module_phase_manager.h"
+
+#include <vector>
+#include <string>
+#include <cstdlib>
+
 namespace maple {
 using namespace maplebe;
 
diff --git a/src/mapleall/maple_driver/include/jbc2mpl_option.h b/src/mapleall/maple_driver/include/jbc2mpl_option.h
index 48bc3b5f0b0bbfa9eaa78e89750bf0958d7b77bd..cdd2d6b47f6d5f4132f36d5df4f6f3ee58483644 100644
--- a/src/mapleall/maple_driver/include/jbc2mpl_option.h
+++ b/src/mapleall/maple_driver/include/jbc2mpl_option.h
@@ -14,161 +14,38 @@
  */
 #ifndef MAPLE_JBC2MPL_OPTION_H
 #define MAPLE_JBC2MPL_OPTION_H
-#include "option_descriptor.h"
 
-namespace maple {
-enum JbcOptionIndex {
-  kUseStringFactory,
-  kOutMpl,
-  kInClass,
-  kInJar,
-  kInApkMplt,
-  kOutClassXML,
-  kOutPath,
-  // profiling
-  kProfileLiteral,
-  // options
-  kGenMplt,
-  kGenAsciiMplt,
-  kTypeSameName,
-  kEnableTypeInfer,
-  kDumpLevel,
-  kDumpTime,
-  kDumpPolymorphic,
-  kDebugJBCFuncName,
-  kDebugDumpJBCFuncCFG,
-  kDebugDumpJBCFuncLocalVar,
-  kDebugDumpFEFuncStmt,
-  kDebugDumpFEFuncCFG,
-  kDebugDumpFEFuncDataFlow,
-};
+#include "cl_option.h"
+
+#include <cstdint>
+#include <stdint.h>
+#include <string>
+
+namespace opts::jbc2mpl {
+
+extern cl::Option<bool> useStringFactory;
+extern cl::Option<std::string> out;
+extern cl::Option<std::string> inclass;
+extern cl::Option<std::string> injar;
+extern cl::Option<std::string> mplt;
+extern cl::Option<std::string> apkmplt;
+extern cl::Option<std::string> outClassXML;
+extern cl::Option<std::string> outPath;
+extern cl::Option<bool> mpltOnly;
+extern cl::Option<bool> asciimplt;
+extern cl::Option<std::string> litprofile;
+extern cl::Option<std::string> sameName;
+extern cl::Option<bool> enableTypeinfer;
+extern cl::Option<uint32_t> dumpLevel;
+extern cl::Option<bool> dumpTime;
+extern cl::Option<bool> dumpPolymorphic;
+extern cl::Option<std::string> debugJbcfuncname;
+extern cl::Option<bool> debugDumpJbcfuncCfg;
+extern cl::Option<std::string> debugDumpJbcfuncLocalvar;
+extern cl::Option<bool> debugDumpDefuncStmt;
+extern cl::Option<bool> debugDumpFefuncCfg;
+extern cl::Option<bool> debugDumpDefuncDataflow;
+
+} /* namespace opts::jbc2mpl */
 
-const mapleOption::Descriptor jbcUsage[] = {
-  { kUnknown, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
-    "========================================\n"
-    " Usage: jbc2mpl [ options ]\n"
-    " options:\n",
-    "jbc2mpl",
-    {} },
-  { kUseStringFactory, 0, "", "use-string-factory", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  -use-string-factory    : Replace String.<init> by StringFactory call",
-    "jbc2mpl",
-    {} },
-  { kOutMpl, 0, "o", "out", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
-    "  -o, -out output.mpl    : output mpl name",
-    "jbc2mpl",
-    {} },
-  { kInClass, 0, "", "inclass", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
-    "  -inclass file1.class,file2.class\n"
-    "                         : input class files",
-    "jbc2mpl",
-    {} },
-  { kInJar, 0, "", "injar", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
-    "  -injar file1.jar,file2.jar\n"
-    "                         : input jar files",
-    "jbc2mpl",
-    {} },
-  { kInMplt, 0, "", "mplt", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
-    "  -mplt file1.mplt,file2.mplt\n"
-    "                         : import mplt files",
-    "jbc2mpl",
-    {} },
-  { kInApkMplt, 0, "", "apkmplt", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
-    "  -apkmplt file1.mplt,file2.mplt\n"
-    "                         : import apk mplt files",
-    "jbc2mpl",
-    {} },
-  { kOutClassXML, 0, "", "out-classXML", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
-    "  -out-classXML classes.xml\n"
-    "                         : output class in XML",
-    "jbc2mpl",
-    {} },
-  { kOutPath, 0, "", "output", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
-    "  -output path           : output path",
-    "jbc2mpl",
-    {} },
-  { kGenMplt, 0, "t", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  -t                     : Generate mplt only",
-    "jbc2mpl",
-    {} },
-  { kGenAsciiMplt, 0, "", "asciimplt", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  -asciimplt             : Generate ascii mplt",
-    "jbc2mpl",
-    {} },
-  { kUnknown, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
-    "========== Profiling ==========",
-    "jbc2mpl",
-    {} },
-  { kProfileLiteral, 0, "", "litprofile", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
-    "  -litprofile=litprofilefile\n"
-    "                         : optimize based on literal profiling data",
-    "jbc2mpl",
-    {} },
-  { kTypeSameName, 0, "", "same-name", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
-    "  -same-name=strategy\n"
-    "                         : strategy when type with the same name\n"
-    "                         : strategy list\n"
-    "                         :   ERROR:    print error and stop compiling (default)\n"
-    "                         :   USELIB:   use first imported by sequence apkmplt-mplt-class/jar\n"
-    "                         :   USEINPUT: use definition in class/jar",
-    "jbc2mpl",
-    {} },
-  { kEnableTypeInfer, 0, "", "enable-typeinfer", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  -enable-typeinfer      : enable type infer operation",
-    "jbc2mpl",
-    {} },
-  { kUnknown, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
-    "========== Debugging ==========",
-    "jbc2mpl",
-    {} },
-  { kDumpLevel, 0, "", "dump-level", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
-    "  -dump-level            : dump level",
-    "jbc2mpl",
-    {} },
-  { kDumpTime, 0, "", "dump-time", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  -dump-time             : dump time",
-    "jbc2mpl",
-    {} },
-  { kDumpPolymorphic, 0, "", "dump-polymorphic", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  -dump-polymorphic      : dump polymorphic methods",
-    "jbc2mpl",
-    {} },
-  { kDebugJBCFuncName, 0, "", "debug-jbcfuncname", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyRequired,
-    "  -debug-jbcfuncname=funcName\n"
-    "                         : debug jbc func name",
-    "jbc2mpl",
-    {} },
-  { kDebugDumpJBCFuncCFG, 0, "", "debug-dump-jbcfunc-cfg", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  -debug-dump-jbcfunc-cfg\n"
-    "                         : debug dump jbc func cfg",
-    "jbc2mpl",
-    {} },
-  { kDebugDumpJBCFuncLocalVar, 0, "", "debug-dump-jbcfunc-localvar",
-    mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  -debug-dump-jbcfunc-localvar\n"
-    "                         : debug dump jbc func local variable info",
-    "jbc2mpl",
-    {} },
-  { kDebugDumpFEFuncStmt, 0, "", "debug-dump-fefunc-stmt", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  -debug-dump-fefunc-stmt\n"
-    "                         : debug dump fe func stmt",
-    "jbc2mpl",
-    {} },
-  { kDebugDumpFEFuncCFG, 0, "", "debug-dump-fefunc-cfg", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  -debug-dump-fefunc-cfg\n"
-    "                         : debug dump fe func cfg",
-    "jbc2mpl",
-    {} },
-  { kDebugDumpFEFuncDataFlow, 0, "", "debug-dump-fefunc-dataflow",
-    mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "  -debug-dump-fefunc-dataflow\n"
-    "                         : debug dump fe func dataflow",
-    "jbc2mpl",
-    {} },
-  { kUnknown, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "",
-    "jbc2mpl",
-    {} }
-};
-} // namespace maple
 #endif // MAPLE_JBC2MPL_OPTION_H
diff --git a/src/mapleall/maple_driver/include/ld_option.h b/src/mapleall/maple_driver/include/ld_option.h
deleted file mode 100644
index 5a8002f5b7646f5ab900e6030fa269290609353b..0000000000000000000000000000000000000000
--- a/src/mapleall/maple_driver/include/ld_option.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
- *
- * OpenArkCompiler is licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *
- *     http://license.coscl.org.cn/MulanPSL2
- *
- * 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 v2 for more details.
- */
-#ifndef MAPLE_LD_OPTION_H
-#define MAPLE_LD_OPTION_H
-#include "option_descriptor.h"
-
-namespace maple {
-enum LdOptionIndex {
-  kLdHelp,
-  kStaticLinking,
-};
-
-const mapleOption::Descriptor ldUsage[] = {
-  { kUnknown, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
-    "========================================\n"
-    " Usage: as [ options ]\n"
-    " options:\n",
-    "ld",
-    {} },
-
-  { kLdHelp, 0, "h", "help", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-    "   -h, --help          : print usage and exit.\n",
-    "ld",
-    {} },
-
-  { kStaticLinking, 0, "static", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "   -static              : equal to -static option of gcc\n",
-    "ld",
-    {} },
-
-  { kUnknown, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-    "",
-    "ld",
-    {} }
-};
-} // namespace maple
-
-#endif //MAPLE_CPP2MPL_OPTION_H
diff --git a/src/mapleall/maple_driver/include/maple_dex2mpl_option.h b/src/mapleall/maple_driver/include/maple_dex2mpl_option.h
deleted file mode 100644
index 620edd8e727bf11388330b405f663a9cd2d172ee..0000000000000000000000000000000000000000
--- a/src/mapleall/maple_driver/include/maple_dex2mpl_option.h
+++ /dev/null
@@ -1,502 +0,0 @@
-/*
- * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
- *
- * OpenArkCompiler is licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *
- *     http://license.coscl.org.cn/MulanPSL2
- *
- * 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 v2 for more details.
- */
-#ifndef MAPLE_DEX2MPL_OPTION_H
-#define MAPLE_DEX2MPL_OPTION_H
-#include "driver_option_common.h"
-
-namespace maple {
-enum Dex2mplOptionIndex {
-  kDex2mplHelp = kCommonOptionEnd + 1,
-  kOutput,
-  kApkmplt,
-  kDex2MplClass,
-  kDex2MplClasslist,
-  kFunc,
-  kFunlist,
-  kDex2MplInlineFunclist,
-  kExtraFields,
-  kEmitCxxHeader,
-  kLitatter,
-  kLitProfile,
-  kSkipFieldlist,
-  kLib,
-  kExcludeClasslist,
-  kIncludeClasslist,
-  // OPTION
-  kSkipInvokeCustom,
-  kBinarymplt,
-  kUnicode,
-  kDex2MplOption,
-  kMinupdate,
-  kSkipCodeAnal,
-  kMultiso,
-  kMultisoMergeMpl,
-  // OPTION (EMIT)
-  kEmitClosure,
-  kEmitTrace,
-  kEmitMoredexinfo,
-  kEmitClinit,
-  kEmitClassDumper,
-  // OPTION (NATIVE)
-  kNonativeMethodDef,
-  kNativeSetret,
-  kNativeSetweak,
-  // OPTION (GEN)
-  kGenClassDefonly,
-  kGenrtInterfaceCall,
-  kGenJavaFuncMap,
-  kGendeDaultFunch,
-  kGendeDaultFuncc,
-  // OPTION (STATIC)
-  kGetStaticFields,
-  kStaticFieldMap,
-  kCollectClinit,
-  kZeroCostClinit,
-  // OPTION (CONTROL)
-  kNoptrRef,
-  kNocomment,
-  kNoGcmalloc,
-  kKeepDexname,
-  kAddBarrier,
-  kInsertLiteral,
-  KAllHotLiteral,
-  kFuncClosure,
-  kExtraObjfields,
-  kContainerPragma,
-  kCvtName,
-  kFastDataFlow,
-  kDataFlowAlgorithm,
-  kRefineCatch,
-  kUseFullJavaFileName,
-  // OPTION (OTHER)
-  kBeta,
-  kMaxID,
-  kMinID,
-  kDisableStrFac,
-  // OPITIMIZATION
-  kOptCheckCastoff,
-  kOptEmitStmt,
-  kOptStatistic,
-  kOptSwitchDisable,
-  // CHECKTOOL
-  kChecktool,
-  kCheckInvoke,
-  kInvokeChecklist,
-  kCheckIncomplete,
-  kIncompleteWhiteList,
-  kIncompleteWhiteListAuto,
-  kIncompleteDetail,
-  kCheckStaticString,
-  kAddInterpreterInfo,
-
-  // APK_OPTION
-  kBlacklistInvoke,
-  kGenstringFieldValue,
-  kRcFieldattrWhiteList,
-  kDexCatch,
-  kAntiProguardFieldName,
-  kDex2mplDecouple,
-  kDex2mplAntiProguardAuto,
-  // DAI 2.0
-  kDex2mplDeferredVisit,
-  kDeferredVisitWhiteList,
-  kDeferredVisitStatic,
-  kDeferredVisitCount,
-  // opcode statistics
-  kStatOpStatic,
-  // MULTITHREAD
-  kPidnum,
-  // DEBUG
-  kDebugDumpOption,
-  kDebugLevel,
-  kDexVersion,
-  kDumpIncomplete,
-  kDumpDataflow,
-  kDumpClassdepOnly,
-  kDex2mplDumpCFG,
-  // Hidden API
-  kHiddenApi,
-  kHiddenApiBlackList,
-  kHiddenApiGreyList,
-  kHiddenApiDex,
-  kHelpEnd,
-};
-
-const mapleOption::Descriptor dex2mplUsage[] = {
-    { kUnknown, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
-      "=============================================\n"
-      " usage: dex2mpl foo.dex [ options ]\n"
-      " options:\n", "dex2mpl", {} },
-    // kHelp
-    // kHelp, kVersion,
-    { kDex2mplHelp, 0, "h", "help", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -h, --help          : print usage and exit.\n", "dex2mpl", {} },
-    { kVersion, 0, "v", "version", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -v, --version       : print version and exit.\n", "dex2mpl", {} },
-    // VALUE
-    // OUTPUT, MPLT, APKMPLT, CLASS, CLASSLIST, FUNC, FUNCLIST, INLINEFUNCLIST,
-    // EXTRAFIELDS, EMITCXXHEADER, LITATTR, LITPROFILE, SKIPFIELDLIST, LIB,
-    // EXCLUDE_CLASSLIST,
-    { kSkipInvokeCustom, 0, "skipcustom", "skipinvokecustom",
-      mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -skipcustom, --skipinvokecustom\n"
-      "                       : skip compile invoke-custom instruction.\n", "dex2mpl", {} },
-    { kOutput, 0, "", "output", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyRequired,
-      "   -output=/directoy/  : emit mpl and mplt to destination directoy\n"
-      "                       : directoy must be exist.", "dex2mpl", {} },
-    { kApkmplt, 0, "", "apkmplt", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyRequired,
-      "   -apkmplt=file1.mplt,file2.mplt\n"
-      "                       : import apk mplt files ", "dex2mpl", {} },
-    { kDex2MplClass, 0, "", "class", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyRequired,
-      "   -class=class1,class2,clss3\n"
-      "                       : emit only these classes", "dex2mpl", {} },
-    { kDex2MplClasslist, 0, "", "classlist", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyRequired,
-      "   -classlist=classlistfile\n"
-      "                       : emit only classes in file\n"
-      "                       : one class name each line", "dex2mpl", {} },
-    { kExcludeClasslist, 0, "", "exclude_classlist",
-      mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyRequired,
-      "   -exclude_classlist=exclude_classlistfile\n"
-      "                       : exclude classes in file\n", "dex2mpl", {} },
-    { kIncludeClasslist, 0, "", "include_classlist",
-      mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyRequired,
-      "   -include_classlist=include_classlistfile\n"
-      "                       : include classes in file\n", "dex2mpl", {} },
-    { kFunc, 0, "", "func", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyRequired,
-      "   -func=func1,func2,func\n"
-      "                       : emit only these functions", "dex2mpl", {} },
-    { kFunlist, 0, "", "funclist", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyRequired,
-      "   -funclist=funclistfile\n"
-      "                       : emit only functions in file\n"
-      "                       : one function name each line", "dex2mpl", {} },
-    { kDex2MplInlineFunclist, 0, "", "inlinefunclist",
-      mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyRequired,
-      "   -inlinefunclist=funclistfile\n"
-      "                       : hot functions for inline candidate \n"
-      "                       : one function name each line", "dex2mpl", {} },
-    { kExtraFields, 0, "", "extrafields", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyRequired,
-      "   -extrafields=extrafieldsfile\n"
-      "                       : one field each line, in format:\n"
-      "                       : class, name, type, attributes", "dex2mpl", {} },
-    { kEmitCxxHeader, 0, "", "emitcxxheader", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyRequired,
-      "   -emitcxxheader=filename\n"
-      "                       : emit to file 'filename' c/c++ struct/class defs\n"
-      "                       : for classes listed in classlistfile;\n"
-      "                       : it requires classlistfile given by -classlist", "dex2mpl", {} },
-    { kLitatter, 0, "", "litattr", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyRequired,
-      "   -litattr=<attr>     : <attr>=s (for fstatic),w (for weak), "
-      "                       :        g (for global)\n"
-      "                       : set how literal\n"
-      "                       : strings are stored. Weak is default.", "dex2mpl", {} },
-    { kLitProfile, 0, "", "litprofile", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyRequired,
-      "   -litprofile=litprofilefile\n"
-      "                       : optimize based on literal profiling data", "dex2mpl", {} },
-    { kSkipFieldlist, 0, "", "skipfieldlist", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyRequired,
-      "   -skipfieldlist=fieldlistfile\n"
-      "                       : skip static field initialization in file", "dex2mpl", {} },
-    { kLib, 0, "", "lib", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyRequired,
-      "   -lib=libname        : library name", "dex2mpl", {} },
-    { kUnknown, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-      "===== options =====", "dex2mpl", {} },
-
-    // OPTION
-    // BINARYMPLT, UNICODE, OPTION, kMinupdate, kSkipCodeAnal
-    { kBinarymplt, 0, "asciimplt", "", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -asciimplt          : create an ascii mplt instead of binary", "dex2mpl", {} },
-    { kUnicode, 0, "", "unicode", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyRequired,
-      "   -unicode=n          : n=8,16,32; default 16", "dex2mpl", {} },
-    { kDex2MplOption, 0, "", "option", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyRequired,
-      "   -option=m           : option bit values\n"
-      "                         CHECKMERGE            1\n"
-      "                         CHECKTIME             2\n"
-      "                         CHECKASSERTION        4\n"
-      "                         ENABLEANNOTATION      8\n"
-      "                         SKIP1MERGE           16\n"
-      "                         FORCEEMITCODE        32\n"
-      "                         DUMPCLASSDEPONLY     64\n"
-      "                         USEPARENTFIELDS     128\n"
-      "                         NOPARENTFIELDS      256\n"
-      "                         SORTFIELDS          512", "dex2mpl", {} },
-    { kMinupdate, 0, "", "minupdate", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -minupdate          : check if mplt is updated,\n"
-      "                       : if not, skip mplt output.", "dex2mpl", {} },
-    { kSkipCodeAnal, 0, "", "skip-codeanal", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -skip-codeanal      : skip ProcessClasses in check process", "dex2mpl", {} },
-    { kMultiso, 0, "", "multiso", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -multiso            : enable multi so", "dex2mpl", {} },
-    { kMultisoMergeMpl, 0, "", "multisoMergeMpl", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyRequired,
-      "   -multisoMergeMpl=classes2.mplt,classes3.mplt,classes999.mplt \n"
-      "                       : file list represent this [files].mpl should merge. \n"
-      "                       : this example indicates classes2.mpl, classes3.mpl\n"
-      "                       : and classes999.mpl will be merge", "dex2mpl", {} },
-    // OPTION (EMIT)
-    // EMITCLOSURE, EMITTRACE, EMITMOREDEXINFO, EMITCLINIT, EMITCLASSDUMPER,
-    { kEmitClosure, 0, "", "emitclosure", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -emitclosure        : emit related class list in fileinfo", "dex2mpl", {} },
-    { kEmitTrace, 0, "", "emittrace", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -emittrace          : emit trace of enter/leave functions", "dex2mpl", {} },
-    { kEmitMoredexinfo, 0, "", "emitmoredexinfo", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -emitmoredexinfo    : emit more dex info entries", "dex2mpl", {} },
-    { kEmitClinit, 0, "", "emitclinit", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -emitclinit         : insert clinit by checking static variables", "dex2mpl", {} },
-    { kEmitClassDumper, 0, "", "emitclassdumper", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -emitclassdumper    : emit functions to dump classes", "dex2mpl", {} },
-
-    // OPTION (NATIVE)
-    // NONATIVEMETHODDEF, NATIVESETRET, NATIVESETWEAK,
-    { kNonativeMethodDef, 0, "", "nonativemethoddef",
-      mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -nonativemethoddef  : don't generate body for native method", "dex2mpl", {} },
-    { kNativeSetret, 0, "", "nativesetret", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -nativesetret       : insert default return for native method", "dex2mpl", {} },
-    { kNativeSetweak, 0, "", "nativesetweak", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -nativesetweak      : mark weak for native method", "dex2mpl", {} },
-
-    // OPTION (GEN)
-    // GENCLASSDEFONLY, GENRTINTERFACECALL, GENJAVAFUNCMAP, GENDEDAULTFUNCH,
-    // GENDEDAULTFUNCC,
-    { kGenClassDefonly, 0, "", "t", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -t                  : create foo.mplt class header file", "dex2mpl", {} },
-    { kGenrtInterfaceCall, 0, "", "genrtinterfacecall",
-      mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -genrtinterfacecall : generate intrinsic for interface call", "dex2mpl", {} },
-    { kGenJavaFuncMap, 0, "", "genjavafuncmap", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -genjavafuncmap     : generate map for java native\n"
-      "                       : function mangled names", "dex2mpl", {} },
-    { kGendeDaultFunch, 0, "", "gendefaultfunch", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -gendefaultfunch    : generate default header files\n"
-      "                       : for the functions in funclist", "dex2mpl", {} },
-    { kGendeDaultFuncc, 0, "", "gendefaultfuncc", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -gendefaultfuncc    : generate default c files\n"
-      "                       : for the functions in funclist", "dex2mpl", {} },
-
-    // OPTION (STATIC)
-    // GETSTATICFIELDS, STATICFIELDMAP, COLLECTCLINIT, ZEROCOSTCLINIT,
-    { kGetStaticFields, 0, "", "getstaticfields", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -getstaticfields    : emit static fields", "dex2mpl", {} },
-    { kStaticFieldMap, 0, "", "genstaticfieldmap",
-      mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -genstaticfieldmap  : generate map for static fields", "dex2mpl", {} },
-    { kCollectClinit, 0, "", "collectclinit", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -collectclinit      : through static variables", "dex2mpl", {} },
-    { kZeroCostClinit, 0, "", "zerocostclinit",
-      mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyOptional,  // Notes: zero or one
-      "   -zerocostclinit     : use zero-cost clinit", "dex2mpl", {} },
-
-    // OPTION (CONTROL)
-    // NOPTYREF, NOCOMMENT, NOGCMALLOC, KEEPDEXNAME, ADDBARRIER, INSERTLITERAL, SKIPKH,
-    // FUNCCLOSURE, EXTRAOBJFIELDS, CONTAINERPRAGMA, CVTNAME, REFINECATCH
-    { kNoptrRef, 0, "", "noref", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -noref              : do NOT use primary type PTY_ref", "dex2mpl", {} },
-    { kNocomment, 0, "", "nocomment", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -nocomment          : not emit comment statements", "dex2mpl", {} },
-    { kNoGcmalloc, 0, "", "nogcmalloc", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -nogcmalloc         : do NOT generate GCMalloc,\n"
-      "                       : generate regular malloc instead", "dex2mpl", {} },
-    { kKeepDexname, 0, "", "oldname", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -oldname            : use old name scheme", "dex2mpl", {} },
-    { kAddBarrier, 0, "", "addbarrier", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -addbarrier         : add barrier when needed", "dex2mpl", {} },
-    { kInsertLiteral, 0, "", "insertliteral", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -insertliteral      : enable literal profiling", "dex2mpl", {} },
-    { KAllHotLiteral, 0, "", "allhotliteral", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -allhotliteral      : enable all literal hot", "dex2mpl", {} },
-    { kFuncClosure, 0, "", "funcclosure", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -funcclosure        : use closure to expand the function list", "dex2mpl", {} },
-    { kExtraObjfields, 0, "", "extraobjfields",
-      mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -extraobjfields     : insert two extra fields,\n"
-      "                       : itab and vtab, into Object", "dex2mpl", {} },
-    { kContainerPragma, 0, "", "containerpragma",
-      mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -containerpragma    : save container pragma for ALIAS vars in mplt", "dex2mpl", {} },
-    { kCvtName, 0, "", "cvtname", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -cvtname            : convert to maple names in funclist file", "dex2mpl", {} },
-    { kFastDataFlow, 0, "", "fast-dataflow",
-      mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -fast-dataflow      : use fast dataflow algorithm", "dex2mpl", {} },
-    { kDataFlowAlgorithm, 0, "", "dataflow-algorithm",
-      mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyRequired,
-      "   -dataflow-algorithm=xxx\n"
-      "                       : xxx is algorithm name\n"
-      "                       : iterative \n"
-      "                       : multilevel (default)", "dex2mpl", {} },
-    { kRefineCatch, 0, "", "refine-catch", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -refine-catch       : refine catch will remove exception def for exception edge", "dex2mpl", {} },
-    { kUseFullJavaFileName, 0, "", "usefulljavafilename",
-      mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -usefulljavafilename\n"
-      "                       : usefulljavafilename will record full java source file name in .mpl", "dex2mpl", {} },
-    // OPTION (OTHER)
-    // BETA, MAXID, MINID, DISABLE_STRFAC
-    { kBeta, 0, "", "beta", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -beta               : code that needs further work, \n"
-      "                       : used to pass around partial work.", "dex2mpl", {} },
-    { kMaxID, 0, "", "maxid", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNumeric,
-      "   -maxid              :", "dex2mpl", {} },
-    { kMinID, 0, "", "minid", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNumeric,
-      "   -minid              :", "dex2mpl", {} },
-    { kDisableStrFac, 0, "", "disable-strfac", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-    "   -disable-strfac     : disable StringFactory replace.", "dex2mpl", {} },
-    // OPITIMIZATION
-    // OPTCHECKCASTOFF, OPTEMITSTMT, OPTSTATISTIC,
-    { kUnknown, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
-      "===== OPTIMIZATION options =====", "dex2mpl", {} },
-    { kOptCheckCastoff, 0, "", "optcheckcastoff", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -optcheckcastoff    : turn off CHECK_CAST optimization,\n"
-        "                       : replace with a retype.", "dex2mpl", {} },
-    { kOptEmitStmt, 0, "", "optemitstmt", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -optemitstmt        : emit stmts during optimization.", "dex2mpl", {} },
-    { kOptStatistic, 0, "", "optstatistic", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyNone,
-      "   -optstatistic       : dump optimization statistic info.", "dex2mpl", {} },
-    { kOptSwitchDisable, 0, "", "opt-switch-disable", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -opt-switch-disable\n"
-      "                       : turn off switch-combination optimization", "dex2mpl", {} },
-
-    // CHECKTOOL
-    // CHECKTOOL, CHECK_INVOKE, INVOKE_CHECKLIST, CHECK_INCOMPLETE
-    { kUnknown, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
-      "===== CHECKTOOL options =====", "dex2mpl", {} },
-    { kChecktool, 0, "", "checktool", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -checktool          : enable check tool.", "dex2mpl", {} },
-    { kCheckInvoke, 0, "", "check-invoke", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -check-invoke       : check call graph by invokeList.", "dex2mpl", {} },
-    { kInvokeChecklist, 0, "", "invoke-checklist",
-      mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyRequired,
-      "   -invoke-checklist=invoke.list\n"
-      "                       : invoke check list file name.", "dex2mpl", {} },
-    { kCheckIncomplete, 0, "", "check-incomplete", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -check-incomplete   : check incomplete type.", "dex2mpl", {} },
-    { kIncompleteWhiteList, 0, "", "incomplete-whitelist",
-      mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyRequired,
-      "   -incomplete-whitelist=incomplete.list\n"
-      "                       : white list file for incomplete check.", "dex2mpl", {} },
-    { kIncompleteWhiteListAuto, 0, "", "incomplete-whitelist-auto",
-      mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -incomplete-whitelist-auto\n"
-      "                       : auto add incomplete type info whitelist", "dex2mpl", {} },
-    { kIncompleteDetail, 0, "", "incomplete-detail", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -incomplete-detail  : dump incomplete detail.\n", "dex2mpl", {} },
-    { kCheckStaticString, 0, "", "staticstringcheck", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -staticstringcheck  : check static string usage.", "dex2mpl", {} },
-    { kAddInterpreterInfo, 0, "", "add-interpreter-info", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone,
-      "   -add-interpreter-info  : add interpreter info.", "dex2mpl", {} },
-    // APK_OPTION
-    // BLACKLIST_INVOKE, GENSTRINGFIELDVALUE, ORINCATCH,
-    { kUnknown, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
-      "===== apk use only options =====", "dex2mpl", {} },
-    { kGenstringFieldValue, 0, "", "gen-stringfieldvalue",
-      mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -gen-stringfieldvalue \n"
-      "                       : generate _PTR_C_STR_ for string field with value.\n", "dex2mpl", {} },
-    { kBlacklistInvoke, 0, "", "blacklist-invoke",
-      mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyRequired,
-      "   -blacklist-invoke=xxx.list\n"
-      "                       : invoke blacklist file.", "dex2mpl", {} },
-    { kRcFieldattrWhiteList, 0, "", "rc-fieldattr-whitelist",
-      mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyRequired,
-      "   -rc-fieldattr-whitelist=file.list\n"
-      "                       : RC fieldattr whitelist file name.", "dex2mpl", {} },
-    { kDexCatch, 0, "", "dexcatch", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -dexcatch           : use dex catch exception list.", "dex2mpl", {} },
-    { kAntiProguardFieldName, 0, "", "anti-proguard-info-fieldname",
-      mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyRequired,
-      "   -anti-proguard-info-fieldname=xxx.info\n"
-      "                       : fieldname anti-proguard info file name (generated by gendeps)", "dex2mpl", {} },
-    { kDex2mplDecouple, 0, "", "decouple", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -decouple           : enable decouple", "dex2mpl", {} },
-    { kDex2mplAntiProguardAuto, 0, "", "anti-proguard-auto",
-      mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -anti-proguard-auto : enable auto anti-proguard for field name\n"
-      "                         this option will disable -anti-proguard-info-fieldname", "dex2mpl", {} },
-    // Hidden API
-    { kHiddenApi, 0, "", "hiddenapi", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -hiddenapi          : enable hiddenapi.", "dex2mpl", {} },
-    { kHiddenApiBlackList, 0, "", "hiddenapi-blacklist",
-      mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyRequired,
-      "   -hiddenapi-blacklist=xxx.list\n"
-      "                       : hiddenapi-blacklist file name.", "dex2mpl", {} },
-    { kHiddenApiGreyList, 0, "", "hiddenapi-greylist",
-      mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyRequired,
-      "   -hiddenapi-greylist=xxx.list\n"
-      "                       : hiddenapi-greylist file name.", "dex2mpl", {} },
-    { kHiddenApiDex, 0, "", "hiddenapidex", mapleOption::kBuildTypeExperimental, mapleOption::kArgCheckPolicyRequired,
-      "   -hiddenapidex=xxx.list\n"
-      "                       : hiddenapidex list.", "dex2mpl", {} },
-    // DAI 2.0
-    { kUnknown, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
-      "===== DAI =====", "dex2mpl", {} },
-    { kDex2mplDeferredVisit, 0, "", "deferred-visit", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -deferred-visit     : generate deferred MCC call for undefined type", "dex2mpl", {} },
-    { kDeferredVisitWhiteList, 0, "", "deferred-visit-whitelist",
-      mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyRequired,
-      "   -deferred-visit-whitelist\n"
-      "                       : whitelist file used to generate deferred visit.\n"
-      "                       : each line represents a field or method name in format\n"
-      "                       :   ClassName|FieldName|FieldTypeName\n"
-      "                       :   ClassName|MethodName|MethodSignatureName\n"
-      "                       : all names are in dex format", "dex2mpl", {} },
-    { kDeferredVisitStatic, 0, "",
-      "deferred-visit-static", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNumeric,
-      "   -deferred-visit-static=mode\n"
-      "                       : set the mode of DAI for static visit\n"
-      "                           0: disable\n"
-      "                           1: for static visit which is undefined\n"
-      "                           2: for static visit which is undefined or has different dex/mpl class",
-      "dex2mpl", {} },
-    { kDeferredVisitCount, 0, "", "deferred-visit-count",
-      mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -deferred-visit-count\n"
-      "                       : count the DAI visit", "dex2mpl", {} },
-
-    // opcode statistics
-    { kUnknown, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
-      "===== Opcode Statistics =====", "dex2mpl", {} },
-    { kStatOpStatic, 0, "", "stat-op-static", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNone,
-      "   -stat-op-static     : count the numbers of static opcode in different catagories", "dex2mpl", {} },
-
-    // MULTITHREAD
-    // PIDNUM,
-    { kUnknown, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
-      "===== MULTITHREAD options =====", "dex2mpl", {} },
-    { kPidnum, 0, "", "j", mapleOption::kBuildTypeProduct, mapleOption::kArgCheckPolicyNumeric,
-      "   -jn                 : using n processes to run the task in parallel", "dex2mpl", {} },
-
-    // DEBUG
-    // DEBUG_DUMP_OPTION, DEBUGLEVEL, DEXVERSION, DUMPINCOMPLETE,
-    // DUMPDATAFLOW, DUMPCLASSDEPONLY, DUMPCFG,
-    { kUnknown, 0, "", "", mapleOption::kBuildTypeDebug, mapleOption::kArgCheckPolicyUnknown,
-      "===== DEBUG options =====", "dex2mpl", {} },
-    { kDebugDumpOption, 0, "", "dump-option", mapleOption::kBuildTypeDebug, mapleOption::kArgCheckPolicyNone,
-      "   -dump-option        : dump command line options.n", "dex2mpl", {} },
-    { kDebugLevel, 0, "", "d", mapleOption::kBuildTypeDebug, mapleOption::kArgCheckPolicyNumeric,
-      "   -d=n                : debug print level n=1,2,3,...\n"
-      "                       : (only in debug version)", "dex2mpl", {} },
-    { kDexVersion, 0, "", "dex_version", mapleOption::kBuildTypeDebug, mapleOption::kArgCheckPolicyNone,
-      "   -dex_version        : display dex file version", "dex2mpl", {} },
-    { kDumpIncomplete, 0, "", "dump-incomplete", mapleOption::kBuildTypeDebug, mapleOption::kArgCheckPolicyNone,
-      "   -dump-incomplete    : dump incomplete type messages.", "dex2mpl", {} },
-    { kDumpDataflow, 0, "", "dumpdataflow", mapleOption::kBuildTypeDebug, mapleOption::kArgCheckPolicyNone,
-      "   -dumpdataflow       : dump dataflow analysis info\n"
-      "                       : (reaching definition).", "dex2mpl", {} },
-    { kDumpClassdepOnly, 0, "", "dumpclassdeponly", mapleOption::kBuildTypeDebug, mapleOption::kArgCheckPolicyNone,
-      "   -dumpclassdeponly   : same as -option=DUMPCLASSDEPONLY", "dex2mpl", {} },
-    { kDex2mplDumpCFG, 0, "", "dumpcfg", mapleOption::kBuildTypeDebug, mapleOption::kArgCheckPolicyNone,
-      "   -dumpcfg            : dump cfg", "dex2mpl", {} },
-    { kHelpEnd, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyUnknown,
-      "=============================================", "dex2mpl", {} },
-    { kUnknown, 0, "", "", mapleOption::kBuildTypeAll, mapleOption::kArgCheckPolicyNone, "", "dex2mpl", {} }};
-} // namespace maple
-#endif // MAPLE_DEX2MPL_OPTION_H
diff --git a/src/mapleall/maple_driver/include/maple_driver.h b/src/mapleall/maple_driver/include/maple_driver.h
new file mode 100644
index 0000000000000000000000000000000000000000..b3382a426992ce46b48652cf83f1ab5ca997af69
--- /dev/null
+++ b/src/mapleall/maple_driver/include/maple_driver.h
@@ -0,0 +1,372 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * 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 v2 for more details.
+ */
+#ifndef MAPLE_DRIVER_INCLUDE_MAPLE_DRIVER_H
+#define MAPLE_DRIVER_INCLUDE_MAPLE_DRIVER_H
+
+#include "cl_parser.h"
+#include "error_code.h"
+#include "file_utils.h"
+#include "mpl_options.h"
+#include "version.h"
+
+#include <string>
+#include <unordered_map>
+
+std::string GetCommonOptionsStr(const std::vector<cl::OptionInterface *> &exclude);
+void PrintMpl2mplMeCgCommand(const std::string *inputFile, bool isBeforeParse);
+void PrintCombCompilerCommand(const std::string &input);
+
+extern const std::vector<cl::OptionInterface *> extraExclude;
+extern const std::vector<cl::OptionInterface *> printExclude;
+
+namespace maple {
+
+extern const std::string kBinNameNone;
+extern const std::string kBinNameJbc2mpl;
+extern const std::string kBinNameCpp2mpl;
+extern const std::string kBinNameClang;
+extern const std::string kBinNameDex2mpl;
+extern const std::string kBinNameMplipa;
+extern const std::string kBinNameMe;
+extern const std::string kBinNameMpl2mpl;
+extern const std::string kBinNameMplcg;
+extern const std::string kBinNameMapleComb;
+extern const std::string kBinNameMapleCombWrp;
+extern const std::string kMachine;
+extern const std::string kVendor;
+extern const std::string kOperatingSystem;
+extern const std::string kLdFlag;
+extern const std::string kGccFlag;
+extern const std::string kGppFlag;
+extern const std::string kAsFlag;
+extern const std::string kInputPhase;
+extern const std::string kBinNameLd;
+extern const std::string kBinNameAs;
+extern const std::string kBinNameGcc;
+extern const std::string kBinNameGpp;
+
+enum InputFileType {
+  kFileTypeNone,
+  kFileTypeClass,
+  kFileTypeJar,
+  kFileTypeAst,
+  kFileTypeCpp,
+  kFileTypeC,
+  kFileTypeDex,
+  kFileTypeMpl,
+  kFileTypeVtableImplMpl,
+  kFileTypeS,
+  kFileTypeObj,
+  kFileTypeBpl,
+  kFileTypeMeMpl,
+  kFileTypeMbc,
+  kFileTypeLmbc,
+};
+
+enum RunMode {
+  kAutoRun,
+  kCustomRun,
+  kUnkownRun
+};
+
+struct DrvOptions {
+  SafetyCheckMode npeCheckMode = SafetyCheckMode::kNoCheck;
+  SafetyCheckMode boundaryCheckMode = SafetyCheckMode::kNoCheck;
+  bool generalRegOnly = false;
+};
+
+class Compiler;
+
+class InputInfo {
+public:
+  explicit InputInfo(const std::string &inputFile)
+      : inputFile(inputFile) {
+    inputFileType = GetInputFileType(inputFile);
+
+    inputName = FileUtils::GetFileName(inputFile, true);
+    inputFolder = FileUtils::GetFileFolder(inputFile);
+    outputFolder = inputFolder;
+    outputName = FileUtils::GetFileName(inputFile, false);
+    fullOutput = outputFolder + outputName;
+  }
+
+  ~InputInfo() = default;
+  static InputFileType GetInputFileType(const std::string &inputFile) {
+    InputFileType fileType = InputFileType::kFileTypeNone;
+    std::string extensionName = FileUtils::GetFileExtension(inputFile);
+    if (extensionName == "class") {
+      fileType = InputFileType::kFileTypeClass;
+    }
+    else if (extensionName == "dex") {
+      fileType = InputFileType::kFileTypeDex;
+    }
+    else if (extensionName == "c") {
+      fileType = InputFileType::kFileTypeC;
+    }
+    else if (extensionName == "cpp") {
+      fileType = InputFileType::kFileTypeCpp;
+    }
+    else if (extensionName == "ast") {
+      fileType = InputFileType::kFileTypeAst;
+    }
+    else if (extensionName == "jar") {
+      fileType = InputFileType::kFileTypeJar;
+    }
+    else if (extensionName == "mpl" || extensionName == "bpl") {
+      if (inputFile.find("VtableImpl") == std::string::npos) {
+        if (inputFile.find(".me.mpl") != std::string::npos) {
+          fileType = InputFileType::kFileTypeMeMpl;
+        } else {
+          fileType = extensionName == "mpl" ? InputFileType::kFileTypeMpl : InputFileType::kFileTypeBpl;
+        }
+      } else {
+        fileType = InputFileType::kFileTypeVtableImplMpl;
+      }
+    } else if (extensionName == "s") {
+      fileType = InputFileType::kFileTypeS;
+    } else if (extensionName == "o") {
+      fileType = InputFileType::kFileTypeObj;
+    } else if (extensionName == "mbc") {
+      fileType = InputFileType::kFileTypeMbc;
+    } else if (extensionName == "lmbc") {
+      fileType = InputFileType::kFileTypeLmbc;
+    }
+
+    return fileType;
+  }
+
+  InputFileType GetInputFileType() const {
+    return inputFileType;
+  }
+
+  const std::string &GetInputFile() const {
+    return inputFile;
+  }
+
+  const std::string &GetOutputFolder() const {
+    return outputFolder;
+  }
+
+  const std::string &GetOutputName() const {
+    return outputName;
+  }
+
+  const std::string &GetFullOutputName() const {
+    return fullOutput;
+  }
+
+private:
+  std::string inputFile = "";
+  InputFileType inputFileType = InputFileType::kFileTypeNone;
+
+  std::string inputName = "";
+  std::string inputFolder = "";
+  std::string outputName = "";
+  std::string outputFolder = "";
+  std::string fullOutput = "";
+};
+
+class Action {
+public:
+  Action(const std::string &tool, const InputInfo *const inputInfo)
+      : inputInfo(inputInfo), tool(tool) {}
+
+  Action(const std::string &tool, const InputInfo *const inputInfo,
+         std::unique_ptr<Action> &inAction)
+      : inputInfo(inputInfo), tool(tool)  {
+    inputActions.push_back(std::move(inAction));
+  }
+
+  Action(const std::string &tool, std::vector<std::unique_ptr<Action>> &inActions,
+         const InputInfo *const inputInfo)
+      : inputInfo(inputInfo), tool(tool)  {
+    for (auto &inAction : inActions) {
+      linkInputFiles.push_back(inAction->GetInputFile());
+    }
+
+    std::move(begin(inActions), end(inActions), std::back_inserter(inputActions));
+  }
+
+  ~Action() = default;
+
+  const std::string &GetTool() const {
+    return tool;
+  }
+
+  const std::string &GetInputFile() const {
+    return inputInfo->GetInputFile();
+  }
+
+  const std::string &GetOutputFolder() const {
+    return inputInfo->GetOutputFolder();
+  }
+
+  const std::string &GetOutputName() const {
+    return inputInfo->GetOutputName();
+  }
+
+  const std::string &GetFullOutputName() const {
+    return inputInfo->GetFullOutputName();
+  }
+
+  InputFileType GetInputFileType() const {
+    return inputInfo->GetInputFileType();
+  }
+
+  const std::vector<std::string> &GetLinkFiles() const {
+    return linkInputFiles;
+  }
+
+  const std::vector<std::unique_ptr<Action>> &GetInputActions() const {
+    return inputActions;
+  }
+
+  Compiler *GetCompiler() const {
+    return compilerTool;
+  }
+
+  void SetCompiler(Compiler *compiler) {
+    compilerTool = compiler;
+  }
+
+  bool IsItFirstRealAction() const {
+    /* First action is always "Input".
+     * But first real  action will be a tool from kMapleCompilers.
+     */
+    if (inputActions.size() > 0 && inputActions[0]->tool == "input") {
+      return true;
+    }
+    return false;
+  }
+
+  std::vector<std::string> internalTools;
+
+private:
+  const InputInfo *inputInfo;
+
+  std::string tool = "";
+  std::string exeFolder = "";
+  std::vector<std::string> linkInputFiles;
+
+  Compiler *compilerTool = nullptr;
+
+  /* This vector contains a links to previous actions in Action tree */
+  std::vector<std::unique_ptr<Action>> inputActions;
+};
+
+class MplDriver {
+ public:
+  using ExeOptMapType = std::unordered_map<std::string, std::deque<std::string>>;
+  using RootActionsType = std::vector<std::unique_ptr<Action>>;
+
+  /* singleton */
+  static MplDriver &GetMplDriver();
+
+  // must not be copyable
+  MplDriver(const MplDriver &) = delete;
+  MplDriver &operator=(const MplDriver &) = delete;
+
+  ErrorCode Processing();
+  cl::OptionCategory *GetCategory(const std::string &tool) const;
+  ErrorCode UpdateExeOptions(const std::string &exeName,
+                             MplOption mplOptions[], unsigned int length);
+
+  std::string GetVersion() {
+#ifdef ANDROID
+    const std::string version = "MapleDriver " +
+      std::to_string(Version::GetMajorVersion()) + "." +
+      std::to_string(Version::GetMinorVersion()) + " 20190929";
+#else
+    const std::string version = "Maple Version : " + Version::GetVersionStr();
+#endif
+    return version;
+  }
+
+  ExeOptMapType &GetExeOptions() {
+    return exeOptions;
+  }
+
+  const std::string &GetExeFolder() const {
+    return exeFolder;
+  }
+
+  const RootActionsType &GetActions() const {
+    return rootActions;
+  }
+
+  RunMode GetRunMode() const {
+    return runMode;
+  }
+
+  const std::vector<std::string> &GetTools() const {
+    return tools;
+  }
+
+  const std::vector<std::string> &GetInputFiles() const {
+    return inputFiles;
+  }
+
+  const std::vector<std::string> &GetSaveFiles() const {
+    return saveFiles;
+  }
+
+  DrvOptions drvOptions;
+
+ private:
+  MplDriver() = default;
+
+  ErrorCode HandleEarlyOptions();
+  void HandleExtraOptions();
+  ErrorCode HandleOptions();
+  ErrorCode CheckInputFiles();
+  ErrorCode DecideRunningPhases();
+  ErrorCode DecideRunningPhases(const std::vector<std::string> &runExes);
+  std::unique_ptr<Action> DecideRunningPhasesByType(const InputInfo *const inputInfo,
+                                                    bool isMultipleFiles);
+  ErrorCode MFCreateActionByExe(const std::string &exe, std::unique_ptr<Action> &currentAction,
+                                const InputInfo *const inputInfo, bool &wasWrpCombCompilerCreated);
+  ErrorCode SFCreateActionByExe(const std::string &exe, std::unique_ptr<Action> &currentAction,
+                                const InputInfo *const inputInfo, bool &isCombCompiler);
+  void DumpActionTree(const Action &action, int indents) const;
+  void DumpActionTree() const;
+  void UpdateTools(const std::string &args);
+  void UpdateExeOptions(const std::string &options, const std::string &tool);
+  ErrorCode UpdateExeOptions(const std::string &args);
+  InputInfo *AllocateInputInfo(const std::string &inputFile);
+
+  RunMode runMode = RunMode::kUnkownRun;
+
+  std::vector<std::string> inputFiles;
+  std::string exeFolder;
+
+  /* exeOptions is used to forward options to necessary tool.
+   * As example: --ld-opt="opt1 opt2" will be forwarded to linker */
+  ExeOptMapType exeOptions;
+
+  /* It contains compilation steps for current compiler run.
+   * If user sets the tools with --run=tool1:tool2:etc, it containts these tools.
+   * Or it can be automatically filled in DecideRunningPhasesByType */
+  std::vector<std::string> tools;
+
+  /* Do not remove temporary files that are set in saveFiles */
+  std::vector<std::string> saveFiles;
+
+  std::vector<std::unique_ptr<InputInfo>> inputInfos;
+  RootActionsType rootActions;
+};
+
+} // namespace maple
+
+#endif  // MAPLE_DRIVER_INCLUDE_MPL_OPTIONS_H
diff --git a/src/mapleall/maple_driver/include/mpl_options.h b/src/mapleall/maple_driver/include/mpl_options.h
index e0bcb3cf624ad96e2fba0ef7745d0dfc27f8ad86..a10961f455f6c2d2e526c946400f1072321831fe 100644
--- a/src/mapleall/maple_driver/include/mpl_options.h
+++ b/src/mapleall/maple_driver/include/mpl_options.h
@@ -14,53 +14,22 @@
  */
 #ifndef MAPLE_DRIVER_INCLUDE_MPL_OPTIONS_H
 #define MAPLE_DRIVER_INCLUDE_MPL_OPTIONS_H
-#include <iterator>
-#include <map>
-#include <set>
-#include <stdio.h>
-#include <string>
-#include <tuple>
-#include <vector>
-#include <memory>
-#include <unordered_set>
-#include <unordered_map>
-#include "file_utils.h"
-#include "option_parser.h"
 #include "mpl_logging.h"
-#include "mir_module.h"
 
-namespace maple {
-enum InputFileType {
-  kFileTypeNone,
-  kFileTypeClass,
-  kFileTypeJar,
-  kFileTypeAst,
-  kFileTypeCpp,
-  kFileTypeC,
-  kFileTypeDex,
-  kFileTypeMpl,
-  kFileTypeVtableImplMpl,
-  kFileTypeS,
-  kFileTypeObj,
-  kFileTypeBpl,
-  kFileTypeMeMpl,
-  kFileTypeMbc,
-  kFileTypeLmbc,
-};
+#include <memory>
+#include <string>
 
-enum OptimizationLevel {
-  kO0,
-  kO1,
-  kO2,
-  kCLangO0,
-  kCLangO2,
+namespace mapleOption {
+enum Level {
+  kLevelZero = 0,
+  kLevelOne = 1,
+  kLevelTwo = 2,
+  kLevelThree = 3,
+  kLevelFour = 4
 };
+} // namespace mapleOption
 
-enum RunMode {
-  kAutoRun,
-  kCustomRun,
-  kUnkownRun
-};
+namespace maple {
 
 enum SafetyCheckMode {
   kNoCheck,
@@ -69,183 +38,6 @@ enum SafetyCheckMode {
   kDynamicCheckSilent
 };
 
-class Compiler;
-
-class InputInfo {
-public:
-  explicit InputInfo(const std::string &inputFile)
-      : inputFile(inputFile) {
-    inputFileType = GetInputFileType(inputFile);
-
-    inputName = FileUtils::GetFileName(inputFile, true);
-    inputFolder = FileUtils::GetFileFolder(inputFile);
-    outputFolder = inputFolder;
-    outputName = FileUtils::GetFileName(inputFile, false);
-    fullOutput = outputFolder + outputName;
-  }
-
-  ~InputInfo() = default;
-  static InputFileType GetInputFileType(const std::string &inputFile) {
-    InputFileType fileType = InputFileType::kFileTypeNone;
-    std::string extensionName = FileUtils::GetFileExtension(inputFile);
-    if (extensionName == "class") {
-      fileType = InputFileType::kFileTypeClass;
-    }
-    else if (extensionName == "dex") {
-      fileType = InputFileType::kFileTypeDex;
-    }
-    else if (extensionName == "c") {
-      fileType = InputFileType::kFileTypeC;
-    }
-    else if (extensionName == "cpp") {
-      fileType = InputFileType::kFileTypeCpp;
-    }
-    else if (extensionName == "ast") {
-      fileType = InputFileType::kFileTypeAst;
-    }
-    else if (extensionName == "jar") {
-      fileType = InputFileType::kFileTypeJar;
-    }
-    else if (extensionName == "mpl" || extensionName == "bpl") {
-      if (inputFile.find("VtableImpl") == std::string::npos) {
-        if (inputFile.find(".me.mpl") != std::string::npos) {
-          fileType = InputFileType::kFileTypeMeMpl;
-        } else {
-          fileType = extensionName == "mpl" ? InputFileType::kFileTypeMpl : InputFileType::kFileTypeBpl;
-        }
-      } else {
-        fileType = InputFileType::kFileTypeVtableImplMpl;
-      }
-    } else if (extensionName == "s") {
-      fileType = InputFileType::kFileTypeS;
-    } else if (extensionName == "o") {
-      fileType = InputFileType::kFileTypeObj;
-    } else if (extensionName == "mbc") {
-      fileType = InputFileType::kFileTypeMbc;
-    } else if (extensionName == "lmbc") {
-      fileType = InputFileType::kFileTypeLmbc;
-    }
-
-    return fileType;
-  }
-
-  InputFileType GetInputFileType() const {
-    return inputFileType;
-  }
-
-  const std::string &GetInputFile() const {
-    return inputFile;
-  }
-
-  const std::string &GetOutputFolder() const {
-    return outputFolder;
-  }
-
-  const std::string &GetOutputName() const {
-    return outputName;
-  }
-
-  const std::string &GetFullOutputName() const {
-    return fullOutput;
-  }
-
-private:
-  std::string inputFile = "";
-  InputFileType inputFileType = InputFileType::kFileTypeNone;
-
-  std::string inputName = "";
-  std::string inputFolder = "";
-  std::string outputName = "";
-  std::string outputFolder = "";
-  std::string fullOutput = "";
-};
-
-class Action {
-public:
-  Action(const std::string &tool, const InputInfo *const inputInfo)
-      : inputInfo(inputInfo), tool(tool) {}
-
-  Action(const std::string &tool, const InputInfo *const inputInfo,
-         std::unique_ptr<Action> &inAction)
-      : inputInfo(inputInfo), tool(tool)  {
-    inputActions.push_back(std::move(inAction));
-  }
-
-  Action(const std::string &tool, std::vector<std::unique_ptr<Action>> &inActions,
-         const InputInfo *const inputInfo)
-      : inputInfo(inputInfo), tool(tool)  {
-    for (auto &inAction : inActions) {
-      linkInputFiles.push_back(inAction->GetInputFile());
-    }
-
-    std::move(begin(inActions), end(inActions), std::back_inserter(inputActions));
-  }
-
-  ~Action() = default;
-
-  const std::string &GetTool() const {
-    return tool;
-  }
-
-  const std::string &GetInputFile() const {
-    return inputInfo->GetInputFile();
-  }
-
-  const std::string &GetOutputFolder() const {
-    return inputInfo->GetOutputFolder();
-  }
-
-  const std::string &GetOutputName() const {
-    return inputInfo->GetOutputName();
-  }
-
-  const std::string &GetFullOutputName() const {
-    return inputInfo->GetFullOutputName();
-  }
-
-  InputFileType GetInputFileType() const {
-    return inputInfo->GetInputFileType();
-  }
-
-  const std::vector<std::string> &GetLinkFiles() const {
-    return linkInputFiles;
-  }
-
-  const std::vector<std::unique_ptr<Action>> &GetInputActions() const {
-    return inputActions;
-  }
-
-  Compiler *GetCompiler() const {
-    return compilerTool;
-  }
-
-  void SetCompiler(Compiler *compiler) {
-    compilerTool = compiler;
-  }
-
-  bool IsItFirstRealAction() const {
-    /* First action is always "Input".
-     * But first real  action will be a tool from kMapleCompilers.
-     */
-    if (inputActions.size() > 0 && inputActions[0]->tool == "input") {
-      return true;
-    }
-    return false;
-  }
-
-private:
-  const InputInfo *inputInfo;
-
-  std::string tool = "";
-  std::string exeFolder = "";
-  std::vector<std::string> linkInputFiles;
-
-  Compiler *compilerTool = nullptr;
-
-  /* This vector contains a links to previous actions in Action tree */
-  std::vector<std::unique_ptr<Action>> inputActions;
-};
-
 class MplOption {
  public:
   MplOption(){needRootPath = false;}
@@ -291,205 +83,5 @@ struct DefaultOption {
   uint32_t length = 0;
 };
 
-class MplOptions {
- public:
-  MplOptions() = default;
-  MplOptions(const MplOptions &options) = delete;
-  MplOptions &operator=(const MplOptions &options) = delete;
-  ~MplOptions() = default;
-
-  int Parse(int argc, char **argv);
-
-  const std::map<std::string, std::deque<mapleOption::Option>> &GetExeOptions() const {
-    return exeOptions;
-  }
-
-  const std::string &GetInputFiles() const {
-    return inputFiles;
-  }
-
-  const std::string &GetExeFolder() const {
-    return exeFolder;
-  }
-
-  const OptimizationLevel &GetOptimizationLevel() const {
-    return optimizationLevel;
-  }
-
-  const std::string &GetMpltFile() const {
-    return mpltFile;
-  }
-
-  const std::string &GetPartO2List() const {
-    return partO2List;
-  }
-
-  const RunMode &GetRunMode() const {
-    return runMode;
-  }
-
-  bool HasSetDefaultLevel() const {
-    return setDefaultLevel;
-  }
-
-  bool HasSetSaveTmps() const {
-    return isSaveTmps;
-  }
-
-  const std::vector<std::string> &GetSaveFiles() const {
-    return saveFiles;
-  }
-
-  const std::vector<std::string> &GetSplitsInputFiles() const {
-    return splitsInputFiles;
-  }
-
-  const std::vector<std::string> &GetRunningExes() const {
-    return runningExes;
-  }
-
-  const std::vector<std::string> &GetSelectedExes() const {
-    return selectedExes;
-  }
-
-  bool HasSetDebugFlag() const {
-    return debugFlag;
-  }
-
-  bool WithDwarf() const {
-    return withDwarf;
-  }
-
-  bool HasSetTimePhases() const {
-    return timePhases;
-  }
-
-  bool HasSetGenMeMpl() const {
-    return genMeMpl;
-  }
-
-  bool HasSetGenMapleBC() const {
-    return genMapleBC;
-  }
-
-  bool HasSetGenLMBC() const {
-    return genLMBC;
-  }
-
-  bool HasSetGenOnlyObj() const {
-    return genObj;
-  }
-
-  bool HasSetRunMaplePhase() const {
-    return runMaplePhaseOnly;
-  }
-
-  bool HasSetGenVtableImpl() const {
-    return genVtableImpl;
-  }
-
-  bool HasSetGeneralRegOnly() const {
-    return generalRegOnly;
-  }
-
-  SafetyCheckMode GetNpeCheckMode() const {
-    return npeCheckMode;
-  }
-
-  bool IsNpeCheckAll() const {
-    return isNpeCheckAll;
-  }
-
-  SafetyCheckMode GetBoundaryCheckMode() const {
-   return boundaryCheckMode;
-  }
-
-  const std::vector<std::unique_ptr<Action>> &GetActions() const {
-    return rootActions;
-  }
-
-  const std::deque<mapleOption::Option> &GetOptions() const {
-    return optionParser->GetOptions();
-  }
-
-  bool IsSafeRegion() const {
-    return safeRegion;
-  }
-
-  ErrorCode AppendCombOptions(MIRSrcLang srcLang);
-  ErrorCode AppendMplcgOptions(MIRSrcLang srcLang);
-  std::string GetInputFileNameForPrint(const Action * const action) const;
-  void PrintCommand(const Action * const action);
-  void connectOptStr(std::string &optionStr, const std::string &exeName, bool &firstComb, std::string &runStr);
-  std::string GetCommonOptionsStr() const;
-  void PrintDetailCommand(const Action * const action, bool isBeforeParse);
-  inline void PrintDetailCommand(bool isBeforeParse) {
-    PrintDetailCommand(nullptr, isBeforeParse);
-  }
- private:
-  bool Init(const std::string &inputFile);
-  ErrorCode HandleGeneralOptions();
-  ErrorCode DecideRunType();
-  ErrorCode DecideRunningPhases();
-  ErrorCode DecideRunningPhases(const std::vector<std::string> &runExes);
-  std::unique_ptr<Action> DecideRunningPhasesByType(const InputInfo *const inputInfo, bool isMultipleFiles);
-  ErrorCode MFCreateActionByExe(const std::string &exe, std::unique_ptr<Action> &currentAction,
-                                const InputInfo *const inputInfo, bool &wasWrpCombCompilerCreated);
-  ErrorCode SFCreateActionByExe(const std::string &exe, std::unique_ptr<Action> &currentAction,
-                                const InputInfo *const inputInfo, bool &isCombCompiler);
-  ErrorCode CheckInputFileValidity();
-  ErrorCode CheckFileExits();
-  ErrorCode AddOption(const mapleOption::Option &option);
-  InputInfo *AllocateInputInfo(const std::string &inputFile);
-  ErrorCode UpdatePhaseOption(const std::string &args, const std::string &exeName);
-  ErrorCode UpdateExtraOptionOpt(const std::string &args);
-  ErrorCode AppendDefaultOptions(const std::string &exeName, MplOption mplOptions[], unsigned int length);
-  void DumpAppendedOptions(const std::string &exeName, const MplOption mplOptions[],
-                           unsigned int length) const;
-  void UpdateRunningExe(const std::string &args);
-  void DumpActionTree(const Action &action, int idents) const;
-  void DumpActionTree() const;
-  std::unique_ptr<mapleOption::OptionParser> optionParser = nullptr;
-  std::map<std::string, std::vector<mapleOption::Option>> options = {};
-  std::map<std::string, std::deque<mapleOption::Option>> exeOptions = {};
-  std::string inputFiles = "";
-  std::string exeFolder = "";
-  std::string mpltFile = "";
-  std::string meOptArgs = "";
-  std::string mpl2mplOptArgs = "";
-  std::string mplcgOptArgs = "";
-  OptimizationLevel optimizationLevel = OptimizationLevel::kO0;
-  RunMode runMode = RunMode::kUnkownRun;
-  bool setDefaultLevel = false;
-  bool isSaveTmps = false;
-  std::vector<std::string> saveFiles = {};
-  std::vector<std::string> splitsInputFiles = {};
-  std::vector<std::string> runningExes = {};
-  std::vector<std::string> selectedExes = {};
-  bool optForSize = false;
-  bool isWithIpa = false;
-  std::ostringstream printExtraOptStr;
-  bool debugFlag = false;
-  bool withDwarf = false;
-  bool timePhases = false;
-  bool genObj = false;
-  bool genMeMpl = false;
-  bool genMapleBC = false;
-  bool genLMBC = false;
-  bool runMaplePhaseOnly = true;
-  bool genVtableImpl = false;
-  bool hasPrinted = false;
-  bool generalRegOnly = false;
-  bool isDriverPhasesDumpCmd = false;
-  unsigned int helpLevel = mapleOption::kBuildTypeDefault;
-  std::string partO2List = "";
-  SafetyCheckMode npeCheckMode = SafetyCheckMode::kNoCheck;
-  bool isNpeCheckAll = false;
-  SafetyCheckMode boundaryCheckMode = SafetyCheckMode::kNoCheck;
-  bool safeRegion = false;
-
-  std::vector<std::unique_ptr<InputInfo>> inputInfos;
-  std::vector<std::unique_ptr<Action>> rootActions;
-};
 }  // namespace maple
 #endif  // MAPLE_DRIVER_INCLUDE_MPL_OPTIONS_H
diff --git a/src/mapleall/maple_driver/include/option_descriptor.h b/src/mapleall/maple_driver/include/option_descriptor.h
deleted file mode 100644
index c68ff769a7e4df28e4581a359570eafaed42de66..0000000000000000000000000000000000000000
--- a/src/mapleall/maple_driver/include/option_descriptor.h
+++ /dev/null
@@ -1,175 +0,0 @@
-/*
- * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
- *
- * OpenArkCompiler is licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *
- *     http://license.coscl.org.cn/MulanPSL2
- *
- * 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 v2 for more details.
- */
-#ifndef MAPLE_OPTION_DESCRIPTOR_H
-#define MAPLE_OPTION_DESCRIPTOR_H
-#include <vector>
-#include <map>
-#include <string>
-#include <algorithm>
-
-namespace mapleOption {
-enum BuildType {
-  kBuildTypeDefault, // Print usages of all levels
-  kBuildTypeProduct,
-  kBuildTypeExperimental,
-  kBuildTypeDebug,
-  kBuildTypeAll // Will be printed in all levels
-};
-
-enum ArgCheckPolicy {
-  kArgCheckPolicyUnknown,
-  kArgCheckPolicyNone,
-  kArgCheckPolicyOptional,
-  kArgCheckPolicyRequired,
-  kArgCheckPolicyNumeric,
-  kArgCheckPolicyBool
-};
-
-enum OptionPrefixType {
-  shortOptPrefix,
-  longOptPrefix,
-  undefinedOpt,
-};
-
-constexpr size_t kMaxExtraOptions = 10;
-
-struct Descriptor {
-  // Unique option index
-  const size_t index;
-
-  // Unique option type
-  const int type;
-
-  // Short form option key
-  const std::string shortOption;
-
-  // Long form option key
-  const std::string longOption;
-
-  // The option can be seen in which build type.
-  const BuildType enableBuildType;
-
-  // Should we have a parameter?
-  const ArgCheckPolicy checkPolicy;
-
-  // Help info
-  const std::string help;
-
-  const std::string exeName;
-
-  // option key mapping to target tool
-  const std::vector<std::string> extras;
-
-  bool IsEnabledForCurrentBuild() const {
-    switch (enableBuildType) {
-      case BuildType::kBuildTypeDefault:
-        return true;
-      case BuildType::kBuildTypeProduct:
-        return true;
-      case BuildType::kBuildTypeExperimental:
-        return true;
-      case BuildType::kBuildTypeDebug:
-        return true;
-      case BuildType::kBuildTypeAll:
-        return true;
-      default:
-        // should never reach
-        return true;
-    }
-  }
-};
-
-class Option {
- public:
-  Option(const Descriptor &desc, const std::string &optionKey, const std::string &args)
-      : descriptor(desc), optionKey(optionKey), args(args) {}
-
-  Option(const Descriptor &desc, const std::string &optionKey,
-         const std::string &args, OptionPrefixType prefixType,
-         bool isEqualPrefix)
-      : descriptor(desc), optionKey(optionKey), args(args),
-        prefixType(prefixType), isEqualPrefix(isEqualPrefix) {}
-
-  ~Option() = default;
-
-  std::string GetPrefix() const;
-
-  size_t Index() const {
-    return descriptor.index;
-  }
-
-  int Type() const {
-    return descriptor.type;
-  }
-
-  const std::string &GetExeName() const {
-    return descriptor.exeName;
-  }
-
-  OptionPrefixType GetPrefixType() const {
-    return prefixType;
-  }
-
-  bool CheckEqualPrefix() const {
-    return isEqualPrefix;
-  }
-
-  const std::string &Args() const {
-    return args;
-  }
-
-  const std::string &OptionKey() const {
-    return optionKey;
-  }
-
-  const Descriptor &GetDescriptor() const {
-    return descriptor;
-  }
-
-  bool HasExtra() const {
-    return (descriptor.extras.size() > 0);
-  }
-
-  std::vector<std::string> GetExtras() const {
-    auto ret = std::vector<std::string>();
-    size_t 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;
-  OptionPrefixType prefixType = undefinedOpt;
-  bool isEqualPrefix = false; // whether option contains "=", like -op=-value
-};
-
-enum EnabledIndex {
-  kDisable,
-  kEnable
-};
-}  // namespace mapleOption
-#endif // MAPLE_OPTION_DESCRIPTOR_H
diff --git a/src/mapleall/maple_driver/include/option_parser.h b/src/mapleall/maple_driver/include/option_parser.h
deleted file mode 100644
index c556c0d2b0d823eddacda5c21a0eff7e3f43567c..0000000000000000000000000000000000000000
--- a/src/mapleall/maple_driver/include/option_parser.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
- *
- * OpenArkCompiler is licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *
- *     http://license.coscl.org.cn/MulanPSL2
- *
- * 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 v2 for more details.
- */
-#ifndef MAPLE_UTIL_INCLUDE_OPTION_PARSER_H
-#define MAPLE_UTIL_INCLUDE_OPTION_PARSER_H
-#include <deque>
-#include <map>
-#include <string>
-#include <string_view>
-#include <vector>
-#include "error_code.h"
-#include "option_descriptor.h"
-#include "driver_option_common.h"
-
-namespace mapleOption {
-
-OptionPrefixType DetectOptPrefix(std::string_view opt);
-std::pair<maple::ErrorCode, std::string_view> ExtractKey(std::string_view opt,
-                                                         OptionPrefixType prefix);
-
-/* This structure is used to aggregate option information during option parsing.
- * It's a string view from original input command line string. */
-struct Arg {
-  explicit Arg(const std::string_view &arg) : rawArg(arg) {}
-  std::string_view rawArg; /* full option, like "--key=value"  */
-  std::string_view key; /* Extracted key, like "--key" */
-  std::string_view val; /* Extracted value, like "value" */
-  OptionPrefixType prefixType = undefinedOpt;
-  bool isEqualOpt = false; /* indicates whether the parsed option contained "=" symbol.
-                              For options like --key=value, it's true. For options like --key value, it's false */
-};
-
-class OptionParser {
- public:
-  OptionParser() = default;
-  ~OptionParser() = default;
-
-  void RegisteUsages(const maple::MapleDriverOptionBase &base);
-  void RegisteUsages(const Descriptor usage[]);
-
-  maple::ErrorCode Parse(int argc, char **argv, const std::string exeName = "driver");
-
-  maple::ErrorCode HandleInputArgs(std::vector<Arg> &inputArgs, const std::string &exeName,
-                                   std::deque<mapleOption::Option> &inputOption, bool isAllOption = false);
-
-  const std::deque<Option> &GetOptions() const {
-    return options;
-  }
-
-  const std::vector<std::string> &GetNonOptions() const {
-    return nonOptionsArgs;
-  }
-
-  int GetNonOptionsCount() const {
-    return nonOptionsArgs.size();
-  }
-
-  void InsertExtraUsage(const Descriptor &usage);
-
-  void CreateNoOption(const Descriptor &usage);
-
-  bool SetOption(const std::string &key, const std::string &value, const std::string &exeName,
-                 std::deque<mapleOption::Option> &exeOption);
-  void PrintUsage(const std::string &helpType, const uint32_t helpLevel = kBuildTypeDefault) const;
-
- private:
-
-  struct UsageWrp {
-    UsageWrp(const Descriptor &desc, const OptionPrefixType &type) : desc(desc), type(type) {};
-    Descriptor desc;
-    OptionPrefixType type;
-  };
-
-  bool HandleKeyValue(const Arg &arg, std::deque<mapleOption::Option> &inputOption,
-                      const std::string &exeName);
-  bool CheckOpt(std::vector<Arg> &inputArgs, size_t &argsIndex,
-                std::deque<mapleOption::Option> &inputOption,
-                const std::string &exeName);
-  bool CheckJoinedOption(Arg &arg,
-                         std::deque<mapleOption::Option> &inputOption,
-                         const std::string &exeName);
-  void InsertOption(const std::string &opt, const Descriptor &usage,
-                    OptionPrefixType optPrefix) {
-    if (usage.IsEnabledForCurrentBuild()) {
-      (void)usages.insert(make_pair(opt, UsageWrp(usage, optPrefix)));
-    }
-  }
-
-  std::vector<Descriptor> rawUsages;
-  /* std::less comparator is used to mix string and string_view as map keys */
-  std::multimap<std::string, UsageWrp, std::less<>> usages;
-  std::deque<Option> options;
-  std::vector<std::string> nonOptionsArgs;
-};
-enum MatchedIndex {
-  kMatchNone,
-  kMatchShortOpt,
-  kMatchLongOpt
-};
-enum Level {
-  kLevelZero = 0,
-  kLevelOne = 1,
-  kLevelTwo = 2,
-  kLevelThree = 3,
-  kLevelFour = 4
-};
-}  // namespace mapleOption
-#endif  // MAPLE_UTIL_INCLUDE_OPTION_PARSER_H
diff --git a/src/mapleall/maple_driver/src/as_compiler.cpp b/src/mapleall/maple_driver/src/as_compiler.cpp
index b057f8ac2e1d966001dba84d4c01a6e69c8c8dba..99a379a71aec33dda40bace911842b8f98388d55 100644
--- a/src/mapleall/maple_driver/src/as_compiler.cpp
+++ b/src/mapleall/maple_driver/src/as_compiler.cpp
@@ -17,7 +17,7 @@
 #include "default_options.def"
 
 namespace maple {
-std::string AsCompiler::GetBinPath(const MplOptions&) const {
+std::string AsCompiler::GetBinPath() const {
 #ifdef ANDROID
   return "prebuilts/gcc/linux-x86/aarch64/aarch64-linux-android-4.9/bin/";
 #else
@@ -34,7 +34,7 @@ const std::string &AsCompiler::GetTool() const {
   return kAsFlag;
 }
 
-DefaultOption AsCompiler::GetDefaultOptions(const MplOptions &options, const Action &action) const {
+DefaultOption AsCompiler::GetDefaultOptions(const Action &action) const {
   uint32_t len = sizeof(kAsDefaultOptions) / sizeof(MplOption);
   DefaultOption defaultOptions = { std::make_unique<MplOption[]>(len), len };
 
@@ -49,24 +49,29 @@ DefaultOption AsCompiler::GetDefaultOptions(const MplOptions &options, const Act
     defaultOptions.mplOptions[i].SetValue(
         FileUtils::AppendMapleRootIfNeeded(defaultOptions.mplOptions[i].GetNeedRootPath(),
                                            defaultOptions.mplOptions[i].GetValue(),
-                                           options.GetExeFolder()));
+                                           MplDriver::GetMplDriver().GetExeFolder()));
   }
   return defaultOptions;
 }
 
-std::string AsCompiler::GetInputFileName(const MplOptions&, const Action &action) const {
+std::string AsCompiler::GetInputFileName(const Action &action) const {
   return action.GetFullOutputName() + ".s";
 }
 
-void AsCompiler::GetTmpFilesToDelete(const MplOptions&, const Action &action,
+void AsCompiler::GetTmpFilesToDelete(const Action &action,
                                      std::vector<std::string> &tempFiles) const {
   tempFiles.push_back(action.GetFullOutputName() + ".o");
 }
 
-std::unordered_set<std::string> AsCompiler::GetFinalOutputs(const MplOptions&,
-                                                            const Action &action) const {
+std::unordered_set<std::string> AsCompiler::GetFinalOutputs(const Action &action) const {
   auto finalOutputs = std::unordered_set<std::string>();
   (void)finalOutputs.insert(action.GetFullOutputName() + ".o");
   return finalOutputs;
 }
+
+void AsCompiler::AppendOutputOption(std::vector<MplOption> &finalOptions,
+                                    const std::string &name) const {
+  finalOptions.emplace_back("-o", name);
+}
+
 }  // namespace maple
diff --git a/src/mapleall/maple_driver/src/clang_compiler.cpp b/src/mapleall/maple_driver/src/clang_compiler.cpp
index e5924a388c0079449e22e5bdccf661eea644f012..7cbfdd800a0c0df3a31935badd6f9c5394271012 100644
--- a/src/mapleall/maple_driver/src/clang_compiler.cpp
+++ b/src/mapleall/maple_driver/src/clang_compiler.cpp
@@ -17,11 +17,12 @@
 #include <memory>
 #include "compiler.h"
 #include "file_utils.h"
+#include "maple_driver.h"
 #include "mpl_timer.h"
 #include "default_options.def"
 
 namespace maple {
-std::string ClangCompiler::GetBinPath(const MplOptions&) const{
+std::string ClangCompiler::GetBinPath() const{
   return FileUtils::SafeGetenv(kMapleRoot) + "/tools/bin/";
 }
 
@@ -61,7 +62,7 @@ static uint32_t FillSpecialDefaulOpt(std::unique_ptr<MplOption[]> &opt,
   return additionalLen;
 }
 
-DefaultOption ClangCompiler::GetDefaultOptions(const MplOptions &options, const Action &action) const {
+DefaultOption ClangCompiler::GetDefaultOptions(const Action &action) const {
   DefaultOption defaultOptions;
   uint32_t fullLen = 0;
   uint32_t defaultLen = 0;
@@ -86,20 +87,25 @@ DefaultOption ClangCompiler::GetDefaultOptions(const MplOptions &options, const
     defaultOptions.mplOptions[i].SetValue(
         FileUtils::AppendMapleRootIfNeeded(defaultOptions.mplOptions[i].GetNeedRootPath(),
                                            defaultOptions.mplOptions[i].GetValue(),
-                                           options.GetExeFolder()));
+                                           MplDriver::GetMplDriver().GetExeFolder()));
   }
   return defaultOptions;
 }
 
-void ClangCompiler::GetTmpFilesToDelete(const MplOptions&, const Action &action,
+void ClangCompiler::GetTmpFilesToDelete(const Action &action,
                                         std::vector<std::string> &tempFiles) const {
   tempFiles.push_back(action.GetFullOutputName() + ".ast");
 }
 
-std::unordered_set<std::string> ClangCompiler::GetFinalOutputs(const MplOptions&,
-                                                               const Action &action) const {
+std::unordered_set<std::string> ClangCompiler::GetFinalOutputs(const Action &action) const {
   std::unordered_set<std::string> finalOutputs;
   (void)finalOutputs.insert(action.GetFullOutputName() + ".ast");
   return finalOutputs;
 }
+
+void ClangCompiler::AppendOutputOption(std::vector<MplOption> &finalOptions,
+                                       const std::string &name) const {
+  finalOptions.emplace_back("-o", name);
+}
+
 }
diff --git a/src/mapleall/maple_driver/src/compiler.cpp b/src/mapleall/maple_driver/src/compiler.cpp
index 99366805981bcf26992ecdaecdbc25e96bf674d0..8f55c89c8fe73713487c74edd459ef30e88b81fc 100644
--- a/src/mapleall/maple_driver/src/compiler.cpp
+++ b/src/mapleall/maple_driver/src/compiler.cpp
@@ -13,23 +13,27 @@
  * See the Mulan PSL v2 for more details.
  */
 #include "compiler.h"
-#include <cstdlib>
+#include "driver_options.h"
 #include "file_utils.h"
+#include "maple_driver.h"
 #include "safe_exe.h"
 #include "mpl_timer.h"
 
+#include <cstdlib>
+#include <string>
+#include <unordered_map>
+
 namespace maple {
 using namespace mapleOption;
 
-int Compiler::Exe(const MplOptions &mplOptions,
-                  const std::vector<MplOption> &options) const {
+int Compiler::Exe(const std::vector<MplOption> &options) const {
   std::ostringstream ostrStream;
-  ostrStream << GetBinPath(mplOptions) << GetBinName();
+  ostrStream << GetBinPath() << GetBinName();
   std::string binPath = ostrStream.str();
   return SafeExe::Exe(binPath, options);
 }
 
-std::string Compiler::GetBinPath(const MplOptions &mplOptions) const {
+std::string Compiler::GetBinPath() const {
 #ifdef MAPLE_PRODUCT_EXECUTABLE  // build flag -DMAPLE_PRODUCT_EXECUTABLE
   std::string binPath = std::string(MAPLE_PRODUCT_EXECUTABLE);
   if (binPath.empty()) {
@@ -38,22 +42,22 @@ std::string Compiler::GetBinPath(const MplOptions &mplOptions) const {
     binPath = binPath + kFileSeperatorChar;
   }
 #else
-  std::string binPath = mplOptions.GetExeFolder();
+  std::string binPath = MplDriver::GetMplDriver().GetExeFolder();
 #endif
   return binPath;
 }
 
-ErrorCode Compiler::Compile(MplOptions &options, const Action &action,
+ErrorCode Compiler::Compile(const Action &action,
                             std::unique_ptr<MIRModule>&) {
   MPLTimer timer = MPLTimer();
   LogInfo::MapleLogger() << "Starting " << GetName() << '\n';
   timer.Start();
 
-  std::vector<MplOption> generatedOptions = MakeOption(options, action);
+  std::vector<MplOption> generatedOptions = MakeOption(action);
   if (generatedOptions.empty()) {
     return kErrorInvalidParameter;
   }
-  if (Exe(options, generatedOptions) != 0) {
+  if (Exe(generatedOptions) != 0) {
     return kErrorCompileFail;
   }
   timer.Stop();
@@ -61,14 +65,13 @@ ErrorCode Compiler::Compile(MplOptions &options, const Action &action,
   return kErrorNoError;
 }
 
-std::vector<MplOption> Compiler::MakeOption(const MplOptions &options,
-                                            const Action &action) const {
+std::vector<MplOption> Compiler::MakeOption(const Action &action) const {
   std::vector<MplOption> finalOptions;
-  std::vector<MplOption> defaultOptions = MakeDefaultOptions(options, action);
+  std::vector<MplOption> defaultOptions = MakeDefaultOptions(action);
 
-  AppendInputsAsOptions(finalOptions, options, action);
-  AppendDefaultOptions(finalOptions, defaultOptions, options.HasSetDebugFlag());
-  AppendExtraOptions(finalOptions, options, options.HasSetDebugFlag());
+  AppendInputsAsOptions(finalOptions, action);
+  AppendDefaultOptions(finalOptions, defaultOptions, opts::debug);
+  AppendExtraOptions(finalOptions, opts::debug, action);
 
   return finalOptions;
 }
@@ -91,38 +94,51 @@ void Compiler::AppendDefaultOptions(std::vector<MplOption> &finalOptions,
 }
 
 void Compiler::AppendExtraOptions(std::vector<MplOption> &finalOptions,
-                                  const MplOptions &options, bool isDebug) const {
+                                  bool isDebug, const Action &action) const {
   const std::string &binName = GetTool();
-  auto exeOption = options.GetExeOptions().find(binName);
-  if (exeOption == options.GetExeOptions().end()) {
-    return;
+  auto &drv = MplDriver::GetMplDriver();
+
+  if (isDebug) {
+    LogInfo::MapleLogger() << Compiler::GetName() << " Extra Options: ";
   }
 
-  for (const Option &opt : exeOption->second) {
-    std::string prefix = opt.GetPrefix();
-    const std::string &baseKey = opt.OptionKey();
-    const std::string key = prefix + baseKey;
-    const std::string &value  = opt.Args();
-
-    /* Default behaviour: extra options do not replace default options,
-     * because it can be some additional option with the same key.
-     * For example: we can have some default -isystem SYSTEM pathes option.
-     * And if some additional -isystem SYSTEM pathes is added, it's not correct
-     * to replace them (SYSTEM pathes msut be extended (not replaced)).
-     * If you need to replace some special option, check and replace it here */
-    if (baseKey == "o") {
-      ReplaceOrInsertOption(finalOptions, key, value);
-    } else {
-      (void)finalOptions.emplace_back(MplOption(key, value));
+  /* Append options setting by: --run=binName --option="-opt1 -opt2" */
+  auto &exeOptions = drv.GetExeOptions();
+  auto it = exeOptions.find(binName);
+  if (it != exeOptions.end()) {
+    for (auto &opt : it->second) {
+      finalOptions.emplace_back(opt, "");
+      if (isDebug) {
+        LogInfo::MapleLogger() << opt << " ";
+      }
     }
   }
 
-  if (isDebug) {
-    LogInfo::MapleLogger() << Compiler::GetName() << " Extra Options: ";
-    for (const Option &opt : exeOption->second) {
-      LogInfo::MapleLogger() << opt.OptionKey() << " "
-                             << opt.Args();
+  cl::OptionCategory *category = drv.GetCategory(binName);
+  ASSERT(category != nullptr, "Undefined tool: %s", binName.data());
+
+  /* Append options setting directly for special category. Example: --verbose */
+  for (const auto &opt : category->GetEnabledOptions()) {
+    for (const auto &val : opt->GetRawValues()) {
+      finalOptions.emplace_back(opt->GetName(), val);
+      if (isDebug) {
+        LogInfo::MapleLogger() << opt->GetName() << " " << val << " ";
+      }
+    }
+  }
+
+  /* output file can not be specified for several last actions. As exaple:
+   * If last actions are assembly tool for 2 files (to get file1.o, file2.o),
+   * we can not have one output name for them. */
+  if (opts::output.IsEnabledByUser() && drv.GetActions().size() == 1) {
+    /* Set output file for last compilation tool */
+    if (&action == drv.GetActions()[0].get()) {
+      /* the tool may not support "-o" for output option */
+      AppendOutputOption(finalOptions, opts::output.GetValue());
     }
+  }
+
+  if (isDebug) {
     LogInfo::MapleLogger() << '\n';
   }
 }
@@ -143,9 +159,9 @@ void Compiler::ReplaceOrInsertOption(std::vector<MplOption> &finalOptions,
 }
 
 void Compiler::AppendInputsAsOptions(std::vector<MplOption> &finalOptions,
-                                     const MplOptions &mplOptions, const Action &action) const {
+                                     const Action &action) const {
   std::vector<std::string> splittedInputFileNames;
-  std::string inputFileNames = GetInputFileName(mplOptions, action);
+  std::string inputFileNames = GetInputFileName(action);
   StringUtils::Split(inputFileNames, splittedInputFileNames, ' ');
 
   for (auto &inputFileName : splittedInputFileNames) {
@@ -153,9 +169,8 @@ void Compiler::AppendInputsAsOptions(std::vector<MplOption> &finalOptions,
   }
 }
 
-std::vector<MplOption> Compiler::MakeDefaultOptions(const MplOptions &options,
-                                                    const Action &action) const {
-  DefaultOption rawDefaultOptions = GetDefaultOptions(options, action);
+std::vector<MplOption> Compiler::MakeDefaultOptions(const Action &action) const {
+  DefaultOption rawDefaultOptions = GetDefaultOptions(action);
   std::vector<MplOption> defaultOptions;
   if (rawDefaultOptions.mplOptions != nullptr) {
     for (uint32_t i = 0; i < rawDefaultOptions.length; ++i) {
diff --git a/src/mapleall/maple_driver/src/compiler_factory.cpp b/src/mapleall/maple_driver/src/compiler_factory.cpp
index 94eb28162945940aa745494483c827acc6036e74..084d782c5efea50ca90a76a7c09513faa2932c7b 100644
--- a/src/mapleall/maple_driver/src/compiler_factory.cpp
+++ b/src/mapleall/maple_driver/src/compiler_factory.cpp
@@ -14,7 +14,9 @@
  */
 #include "compiler_factory.h"
 #include <regex>
+#include "driver_options.h"
 #include "file_utils.h"
+#include "maple_driver.h"
 #include "string_utils.h"
 #include "mpl_logging.h"
 
@@ -67,24 +69,34 @@ void CompilerFactory::Insert(const std::string &name, Compiler *value) {
   (void)supportedCompilers.insert(make_pair(name, value));
 }
 
-ErrorCode CompilerFactory::DeleteTmpFiles(const MplOptions &mplOptions,
-                                          const std::vector<std::string> &tempFiles) const {
+ErrorCode CompilerFactory::DeleteTmpFiles(const std::vector<std::string> &tempFiles,
+                                          const std::vector<std::string> &saveFiles,
+                                          const std::vector<std::string> &inputFiles,
+                                          const MplDriver::RootActionsType &actions) const {
   int ret = 0;
   for (const std::string &tmpFile : tempFiles) {
     bool isSave = false;
-    for (auto saveFile : mplOptions.GetSaveFiles()) {
+    for (auto &saveFile : saveFiles) {
       if (!saveFile.empty() && std::regex_match(tmpFile, std::regex(StringUtils::Replace(saveFile, "*", ".*?")))) {
         isSave = true;
         break;
       }
     }
-    if (!isSave && mplOptions.GetInputFiles().find(tmpFile) == std::string::npos /* not input */) {
+
+    bool isInputFile = false;
+    for (auto &inFile : inputFiles) {
+      if (inFile == tmpFile) {
+        isInputFile = true;
+      }
+    }
+
+    if (!isSave && !isInputFile /* not input */) {
       bool isNeedRemove = true;
       /* If we compile several files we can have several last Actions,
        * so we need to NOT remove output files for each last Action.
        */
-      for (auto &lastAction : mplOptions.GetActions()) {
-        auto finalOutputs = lastAction->GetCompiler()->GetFinalOutputs(mplOptions, *lastAction);
+      for (auto &lastAction : actions) {
+        auto finalOutputs = lastAction->GetCompiler()->GetFinalOutputs(*lastAction);
         /* do not remove output files */
         if (finalOutputs.find(tmpFile) != finalOutputs.end()) {
           isNeedRemove = false;
@@ -99,7 +111,7 @@ ErrorCode CompilerFactory::DeleteTmpFiles(const MplOptions &mplOptions,
   return ret == 0 ? kErrorNoError : kErrorFileNotFound;
 }
 
-ErrorCode CompilerFactory::Compile(MplOptions &mplOptions) {
+ErrorCode CompilerFactory::Compile(const MplDriver::RootActionsType &rootActions) {
   if (compileFinished) {
     LogInfo::MapleLogger() <<
         "Failed! Compilation has been completed in previous time and multi-instance compilation is not supported\n";
@@ -112,7 +124,7 @@ ErrorCode CompilerFactory::Compile(MplOptions &mplOptions) {
     LogInfo::MapleLogger() << "Failed! Compiler is null." << "\n";
     return kErrorCompileFail;
   }
-  ErrorCode ret = compilerSelector->Select(supportedCompilers, mplOptions, actions);
+  ErrorCode ret = compilerSelector->Select(supportedCompilers, rootActions, actions);
   if (ret != kErrorNoError) {
     return ret;
   }
@@ -128,25 +140,27 @@ ErrorCode CompilerFactory::Compile(MplOptions &mplOptions) {
       return kErrorToolNotFound;
     }
 
-    ret = compiler->Compile(mplOptions, *action, this->theModule);
+    ret = compiler->Compile(*action, this->theModule);
     if (ret != kErrorNoError) {
       return ret;
     }
   }
-  if (mplOptions.HasSetDebugFlag()) {
-    mplOptions.PrintDetailCommand(false);
+
+  if (opts::debug) {
+    PrintMpl2mplMeCgCommand(nullptr, false);
   }
-  // Compiler finished
-  compileFinished = true;
 
-  if (!mplOptions.HasSetSaveTmps() || !mplOptions.GetSaveFiles().empty()) {
+  auto &drv = MplDriver::GetMplDriver();
+  if (!opts::saveTempOpt.IsEnabledByUser()) {
     std::vector<std::string> tmpFiles;
 
-    for (auto *action : actions) {
-      action->GetCompiler()->GetTmpFilesToDelete(mplOptions, *action, tmpFiles);
+    for (auto &action : actions) {
+      action->GetCompiler()->GetTmpFilesToDelete(*action, tmpFiles);
     }
 
-    ret = DeleteTmpFiles(mplOptions, tmpFiles);
+    ret = DeleteTmpFiles(tmpFiles, drv.GetSaveFiles(),
+                         drv.GetInputFiles(), drv.GetActions());
   }
+
   return ret;
 }
diff --git a/src/mapleall/maple_driver/src/compiler_selector.cpp b/src/mapleall/maple_driver/src/compiler_selector.cpp
index 87e3fc327ebc6b5a67fdd1e4385c42572a3d5668..f49903014cddc36487182647abd321916eb55974 100644
--- a/src/mapleall/maple_driver/src/compiler_selector.cpp
+++ b/src/mapleall/maple_driver/src/compiler_selector.cpp
@@ -25,23 +25,7 @@ Compiler *CompilerSelectorImpl::FindCompiler(const SupportedCompilers &compilers
   return nullptr;
 }
 
-ErrorCode CompilerSelectorImpl::InsertCompilerIfNeeded(std::vector<Compiler*> &selected,
-                                                       const SupportedCompilers &compilers,
-                                                       const std::string &name) const {
-  Compiler *compiler = FindCompiler(compilers, name);
-  if (compiler != nullptr) {
-    if (std::find(selected.cbegin(), selected.cend(), compiler) == selected.cend()) {
-      selected.push_back(compiler);
-    }
-    return kErrorNoError;
-  }
-
-  LogInfo::MapleLogger(kLlErr) << name << " not found!!!" << '\n';
-  return kErrorToolNotFound;
-}
-
 ErrorCode CompilerSelectorImpl::Select(const SupportedCompilers &supportedCompilers,
-                                       const MplOptions &mplOptions,
                                        Action &action,
                                        std::vector<Action*> &selectedActions) const {
   ErrorCode ret = kErrorNoError;
@@ -49,7 +33,7 @@ ErrorCode CompilerSelectorImpl::Select(const SupportedCompilers &supportedCompil
   /* Traverse Action tree recursively and select compilers in
    * "from leaf(clang) to root(ld)" order */
   for (const std::unique_ptr<Action> &a : action.GetInputActions()) {
-    ret = Select(supportedCompilers, mplOptions, *a, selectedActions);
+    ret = Select(supportedCompilers, *a, selectedActions);
     if (ret != kErrorNoError) {
       return ret;
     }
@@ -77,12 +61,11 @@ ErrorCode CompilerSelectorImpl::Select(const SupportedCompilers &supportedCompil
 }
 
 ErrorCode CompilerSelectorImpl::Select(const SupportedCompilers &supportedCompilers,
-                                       const MplOptions &mplOptions,
+                                       const MplDriver::RootActionsType& actions,
                                        std::vector<Action*> &selectedActions) const {
-  ErrorCode ret;
 
-  for (const std::unique_ptr<Action> &action : mplOptions.GetActions()) {
-    ret = Select(supportedCompilers, mplOptions, *action, selectedActions);
+  for (const std::unique_ptr<Action> &action : actions) {
+    ErrorCode ret = Select(supportedCompilers, *action, selectedActions);
     if (ret != kErrorNoError) {
       return ret;
     }
diff --git a/src/mapleall/maple_driver/src/cpp2mpl_compiler.cpp b/src/mapleall/maple_driver/src/cpp2mpl_compiler.cpp
index ffb863baa26d915932bb4cc5779de3fd2b2b78ab..a496108b360d0948d68e93b7329c79779be1b375 100644
--- a/src/mapleall/maple_driver/src/cpp2mpl_compiler.cpp
+++ b/src/mapleall/maple_driver/src/cpp2mpl_compiler.cpp
@@ -15,11 +15,12 @@
 #include <cstdlib>
 #include "compiler.h"
 #include "file_utils.h"
+#include "maple_driver.h"
 #include "mpl_logging.h"
 #include "default_options.def"
 
 namespace maple {
-std::string Cpp2MplCompiler::GetBinPath(const MplOptions&) const{
+std::string Cpp2MplCompiler::GetBinPath() const{
   return FileUtils::SafeGetenv(kMapleRoot) + "/output/" +
       FileUtils::SafeGetenv("MAPLE_BUILD_TYPE") + "/bin/";
 }
@@ -28,7 +29,7 @@ const std::string &Cpp2MplCompiler::GetBinName() const {
   return kBinNameCpp2mpl;
 }
 
-std::string Cpp2MplCompiler::GetInputFileName(const MplOptions &, const Action &action) const {
+std::string Cpp2MplCompiler::GetInputFileName(const Action &action) const {
   if (action.IsItFirstRealAction()) {
     return action.GetInputFile();
   }
@@ -41,7 +42,7 @@ std::string Cpp2MplCompiler::GetInputFileName(const MplOptions &, const Action &
   return action.GetOutputFolder() + outputName + ".ast";
 }
 
-DefaultOption Cpp2MplCompiler::GetDefaultOptions(const MplOptions &options, const Action&) const {
+DefaultOption Cpp2MplCompiler::GetDefaultOptions(const Action&) const {
   uint32_t len = sizeof(kCpp2MplDefaultOptionsForAst) / sizeof(MplOption);
   DefaultOption defaultOptions = { std::make_unique<MplOption[]>(len), len };
 
@@ -53,22 +54,27 @@ DefaultOption Cpp2MplCompiler::GetDefaultOptions(const MplOptions &options, cons
     defaultOptions.mplOptions[i].SetValue(
         FileUtils::AppendMapleRootIfNeeded(defaultOptions.mplOptions[i].GetNeedRootPath(),
                                            defaultOptions.mplOptions[i].GetValue(),
-                                           options.GetExeFolder()));
+                                           MplDriver::GetMplDriver().GetExeFolder()));
     }
     return defaultOptions;
 }
 
-void Cpp2MplCompiler::GetTmpFilesToDelete(const MplOptions&, const Action &action,
+void Cpp2MplCompiler::GetTmpFilesToDelete(const Action &action,
                                           std::vector<std::string> &tempFiles) const {
   tempFiles.push_back(action.GetFullOutputName() + ".mpl");
   tempFiles.push_back(action.GetFullOutputName() + ".mplt");
 }
 
-std::unordered_set<std::string> Cpp2MplCompiler::GetFinalOutputs(const MplOptions&,
-                                                                 const Action &action) const {
+std::unordered_set<std::string> Cpp2MplCompiler::GetFinalOutputs(const Action &action) const {
   std::unordered_set<std::string> finalOutputs;
   (void)finalOutputs.insert(action.GetFullOutputName() + ".mpl");
   (void)finalOutputs.insert(action.GetFullOutputName() + ".mplt");
   return finalOutputs;
 }
+
+void Cpp2MplCompiler::AppendOutputOption(std::vector<MplOption> &finalOptions,
+                                         const std::string &name) const {
+  finalOptions.emplace_back("-o", name);
+}
+
 }  // namespace maple
diff --git a/src/mapleall/maple_driver/src/dex2mpl_compiler.cpp b/src/mapleall/maple_driver/src/dex2mpl_compiler.cpp
index 543b5396aef7987ba8b9ae9f768fab52585882ce..501a663380dda558bcd448b6a13639067a376723 100644
--- a/src/mapleall/maple_driver/src/dex2mpl_compiler.cpp
+++ b/src/mapleall/maple_driver/src/dex2mpl_compiler.cpp
@@ -14,25 +14,28 @@
  */
 #include "compiler.h"
 #include "default_options.def"
-#include <memory>
+#include "driver_options.h"
+#include "maple_driver.h"
 #ifdef INTERGRATE_DRIVER
 #include "dex2mpl_runner.h"
 #include "mir_function.h"
 #endif
 
+#include <memory>
+
 namespace maple {
 const std::string &Dex2MplCompiler::GetBinName() const {
   return kBinNameDex2mpl;
 }
 
-DefaultOption Dex2MplCompiler::GetDefaultOptions(const MplOptions &options, const Action&) const {
+DefaultOption Dex2MplCompiler::GetDefaultOptions(const Action&) const {
   uint32_t len = 0;
   MplOption *kDex2mplDefaultOptions = nullptr;
 
-  if (options.GetOptimizationLevel() == kO0 && options.HasSetDefaultLevel()) {
+  if (opts::o0) {
     len = sizeof(kDex2mplDefaultOptionsO0) / sizeof(MplOption);
     kDex2mplDefaultOptions = kDex2mplDefaultOptionsO0;
-  } else if (options.GetOptimizationLevel() == kO2 && options.HasSetDefaultLevel()) {
+  } else if (opts::o2) {
     len = sizeof(kDex2mplDefaultOptionsO2) / sizeof(MplOption);
     kDex2mplDefaultOptions = kDex2mplDefaultOptionsO2;
   }
@@ -50,214 +53,42 @@ DefaultOption Dex2MplCompiler::GetDefaultOptions(const MplOptions &options, cons
     defaultOptions.mplOptions[i].SetValue(
         FileUtils::AppendMapleRootIfNeeded(defaultOptions.mplOptions[i].GetNeedRootPath(),
                                            defaultOptions.mplOptions[i].GetValue(),
-                                           options.GetExeFolder()));
+                                           MplDriver::GetMplDriver().GetExeFolder()));
   }
   return defaultOptions;
 }
 
-void Dex2MplCompiler::GetTmpFilesToDelete(const MplOptions&, const Action &action,
+void Dex2MplCompiler::GetTmpFilesToDelete(const Action &action,
                                           std::vector<std::string> &tempFiles) const {
   tempFiles.push_back(action.GetFullOutputName() + ".mpl");
   tempFiles.push_back(action.GetFullOutputName() + ".mplt");
 }
 
-std::unordered_set<std::string> Dex2MplCompiler::GetFinalOutputs(const MplOptions&,
-                                                                 const Action &action) const {
+std::unordered_set<std::string> Dex2MplCompiler::GetFinalOutputs(const Action &action) const {
   auto finalOutputs = std::unordered_set<std::string>();
   (void)finalOutputs.insert(action.GetFullOutputName() + ".mpl");
   (void)finalOutputs.insert(action.GetFullOutputName() + ".mplt");
   return finalOutputs;
 }
 
-#ifdef INTERGRATE_DRIVER
-void Dex2MplCompiler::PostDex2Mpl(std::unique_ptr<MIRModule> &theModule) const {
-  // for each function
-  for (auto *func : theModule->GetFunctionList()) {
-    if (func == nullptr) {
-      continue;
-    }
-
-    MIRSymbolTable *symTab = func->GetSymTab();
-    // for each symbol
-    for (size_t i = 0; i != symTab->GetSymbolTableSize(); ++i) {
-      MIRSymbol *currSymbol = symTab->GetSymbolFromStIdx(i);
-      if (currSymbol == nullptr) {
-        continue;
-      }
-      // (1) replace void ptr with void ref
-      if (theModule->IsJavaModule() && currSymbol->GetType() == GlobalTables::GetTypeTable().GetVoidPtr()) {
-        MIRType *voidRef = GlobalTables::GetTypeTable().GetOrCreatePointerType(
-            *GlobalTables::GetTypeTable().GetVoid(), PTY_ref);
-        currSymbol->SetTyIdx(voidRef->GetTypeIndex());
-      }
-      // (2) replace String ref with String ptr if symbol's name starts with "L_STR"
-      if (currSymbol->GetType()->GetKind() == kTypePointer && currSymbol->GetName().find("L_STR") == 0) {
-        MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(currSymbol->GetTyIdx());
-        auto *ptrTy = static_cast<MIRPtrType *>(ty->CopyMIRTypeNode());
-        ASSERT(ptrTy != nullptr, "null ptr check");
-        ptrTy->SetPrimType(PTY_ptr);
-        TyIdx newTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(ptrTy);
-        delete ptrTy;
-        currSymbol->SetTyIdx(newTyIdx);
-      }
-    }
-
-    // (3) reset pregIndex of pregTab if function has body
-    if (func->GetBody() != nullptr) {
-      uint32 maxPregNo = 0;
-      for (uint32 i = 0; i < func->GetFormalCount(); ++i) {
-        MIRSymbol *formalSt = func->GetFormal(i);
-        if (formalSt->IsPreg()) {
-          // no special register appears in the formals
-          uint32 pRegNo = static_cast<uint32>(formalSt->GetPreg()->GetPregNo());
-          if (pRegNo > maxPregNo) {
-            maxPregNo = pRegNo;
-          }
-        }
-      }
-      if (func->GetPregTab() == nullptr) {
-        continue;
-      }
-      func->GetPregTab()->SetIndex(maxPregNo + 1);
-    }
-  }
-
-  // (4) fix unmatched MIRConst type of global symbols
-  for (size_t i = 0; i != GlobalTables::GetGsymTable().GetSymbolTableSize(); ++i) {
-    MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(i);
-    if (symbol == nullptr || !symbol->IsConst()) {
-      continue;
-    }
-    TyIdx stTyIdx = symbol->GetTyIdx();
-    if (stTyIdx == 0) {
-      continue;
-    }
-    MIRType *stType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(stTyIdx);
-    MIRConst *mirConst = symbol->GetKonst();
-
-    if (mirConst == nullptr || mirConst->GetKind() != kConstInt) {
-      continue;
-    }
-    if (static_cast<MIRIntConst*>(mirConst)->GetValue() != 0) {
-      continue;
-    }
-    MIRType &valueType = mirConst->GetType();
-    if (valueType.GetTypeIndex() != stTyIdx) {
-      auto *newIntConst = theModule->GetMemPool()->New<MIRIntConst>(0, *stType);
-      symbol->SetValue({newIntConst});
-    }
-  }
-
-  // (5) remove type attr `rcunowned` of local symbol in rclocalunowned function specified by dex2mpl
-  for (auto *func : theModule->GetFunctionList()) {
-    if (func == nullptr || !func->GetAttr(FUNCATTR_rclocalunowned)) {
-      continue;
-    }
-    MIRSymbolTable *symTab = func->GetSymTab();
-    for (size_t i = 0; i != symTab->GetSymbolTableSize(); ++i) {
-      MIRSymbol *symbol = symTab->GetSymbolFromStIdx(i);
-      if (symbol == nullptr) {
-        continue;
-      }
-      if (symbol->GetAttr(ATTR_rcunowned)) {
-        symbol->ResetAttr(ATTR_rcunowned);
-      }
-    }
-  }
-
-  // 1: MIRStructType::isImported has different meaning for dex2mpl and binary mplt importer.
-  // for dex2mpl, `isImported` means whether a type is imported from mplt file instead of dex file, so all types from
-  // mplt are marked imported. But for binary mplt importer, `isImported` means whether a type is loaded successfully,
-  // so only complete types are marked imported.
-  // The workaround is to reset `isImported` according to the completeness of a type.
-  for (MIRType *type : GlobalTables::GetTypeTable().GetTypeTable()) {
-    if (type == nullptr) {
-      continue;
-    }
-    MIRTypeKind typeKind = type->GetKind();
-    if (typeKind == kTypeStructIncomplete || typeKind == kTypeClassIncomplete || typeKind == kTypeInterfaceIncomplete) {
-      auto *structType = static_cast<MIRStructType*>(type);
-      structType->SetIsImported(false);
-    } else if (typeKind == kTypeClass || typeKind == kTypeInterface) {
-      auto *structType = static_cast<MIRStructType*>(type);
-      structType->SetIsImported(true);
-    }
-  }
-}
-#endif
+void Dex2MplCompiler::PrintCommand(const Action &action) const {
+  auto &drv = MplDriver::GetMplDriver();
 
-void Dex2MplCompiler::PrintCommand(const MplOptions &options, const Action &action) const {
   std::string runStr = "--run=";
   std::string optionStr = "--option=\"";
   std::string connectSym = "";
-  if (options.GetExeOptions().find(kBinNameDex2mpl) != options.GetExeOptions().end()) {
+  if (drv.GetExeOptions().find(kBinNameDex2mpl) != drv.GetExeOptions().end()) {
     runStr += "dex2mpl";
-    auto inputDex2mplOptions = options.GetExeOptions().find(kBinNameDex2mpl);
+    auto inputDex2mplOptions = drv.GetExeOptions().find(kBinNameDex2mpl);
     for (auto &opt : inputDex2mplOptions->second) {
-      connectSym = opt.Args() != "" ? "=" : "";
-      optionStr += " --" + opt.OptionKey() + connectSym + opt.Args();
+      optionStr += " --" + opt;
     }
   }
   optionStr += "\"";
-  LogInfo::MapleLogger() << "Starting:" << options.GetExeFolder() << "maple " << runStr << " " << optionStr
-                         << " --infile " << GetInputFileName(options, action) << '\n';
-}
 
-#ifdef INTERGRATE_DRIVER
-bool Dex2MplCompiler::MakeDex2mplOptions(const MplOptions &options) {
-  Dex2mplOptions &dex2mplOptions = Dex2mplOptions::GetInstance();
-  dex2mplOptions.LoadDefault();
-  auto it = options.GetExeOptions().find(kBinNameDex2mpl);
-  if (it == options.GetExeOptions().end()) {
-    LogInfo::MapleLogger() << "no dex2mpl input options\n";
-    return false;
-  }
-  bool result = dex2mplOptions.SolveOptions(it->second, options.HasSetDebugFlag());
-  if (result == false) {
-    LogInfo::MapleLogger() << "Meet error dex2mpl options\n";
-    return false;
-  }
-  return true;
+  LogInfo::MapleLogger() << "Starting:" << drv.GetExeFolder() << "maple "
+                         << runStr << " " << optionStr
+                         << " --infile " << GetInputFileName(action) << '\n';
 }
 
-ErrorCode Dex2MplCompiler::Compile(MplOptions &options, const Action &action,
-                                   std::unique_ptr<MIRModule> &theModule) {
-  Dex2mplOptions &dex2mplOptions = Dex2mplOptions::GetInstance();
-  bool result = MakeDex2mplOptions(options);
-  if (!result) {
-    return ErrorCode::kErrorCompileFail;
-  }
-  // .dex
-  std::string dexFileName = action.GetInputFile();
-  theModule = std::make_unique<MIRModule>(dexFileName);
-
-  const auto &runningExes = options.GetRunningExes();
-  bool isDex2mplFinalExe = (runningExes[runningExes.size() - 1] == kBinNameDex2mpl);
-  std::unique_ptr<Dex2mplRunner> dex2mpl = std::make_unique<Dex2mplRunner>(dexFileName, dex2mplOptions,
-      std::move(theModule), options.HasSetSaveTmps(), isDex2mplFinalExe);
-  if (dex2mpl == nullptr) {
-    ERR(kLncErr, "new Dex2mplRunner failed.");
-    return ErrorCode::kErrorCompileFail;
-  }
-  LogInfo::MapleLogger() << "Starting dex2mpl" << '\n';
-  int ret = dex2mpl->Init();
-  if (ret != 0) {
-    return ErrorCode::kErrorCompileFail;
-  }
-  ret = dex2mpl->Run();
-  if (ret != 0) {
-    ERR(kLncErr, "(ToIDEUser)dex2mpl failed.");
-    return ErrorCode::kErrorCompileFail;
-  }
-  // Check that whether the kBinNameDex2mpl is the final compiler
-  // If not, we need to call PostDex2Mpl() to deal with some differences in theModule to
-  // adapt to the needs of maplecomb
-  if (runningExes[runningExes.size() - 1] != kBinNameDex2mpl) {
-    dex2mpl->MoveMirModule(theModule);
-    PostDex2Mpl(theModule);
-  }
-  PrintCommand(options, action);
-  return ErrorCode::kErrorNoError;
-}
-#endif
 }  // namespace maple
diff --git a/src/mapleall/maple_driver/src/driver_option_common.cpp b/src/mapleall/maple_driver/src/driver_option_common.cpp
deleted file mode 100644
index 7d8b27ebe9cfb4ec4f53a7a1031be3745754066d..0000000000000000000000000000000000000000
--- a/src/mapleall/maple_driver/src/driver_option_common.cpp
+++ /dev/null
@@ -1,620 +0,0 @@
-/*
- * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
- *
- * OpenArkCompiler is licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *
- *     http://license.coscl.org.cn/MulanPSL2
- *
- * 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 v2 for more details.
- */
-#include "driver_option_common.h"
-
-namespace {
-using namespace maple;
-using namespace mapleOption;
-const mapleOption::Descriptor kUsages[] = {
-  // index, type, shortOption, longOption, enableBuildType, checkPolicy, help, exeName, extra bins
-  { kUnknown,
-    0,
-    "",
-    "",
-    kBuildTypeAll,
-    kArgCheckPolicyNone,
-    "USAGE: maple [options]\n\n"
-    "  Example 1: <Maple bin path>/maple --run=me:mpl2mpl:mplcg --option=\"[MEOPT]:[MPL2MPLOPT]:[MPLCGOPT]\"\n"
-    "                                    --mplt=MPLTPATH inputFile.mpl\n"
-    "  Example 2: <Maple bin path>/maple -O2 --mplt=mpltPath inputFile.dex\n\n"
-    "==============================\n"
-    "  Options:\n",
-    "driver",
-    {} },
-  { kHelp,
-    0,
-    "h",
-    "help",
-    kBuildTypeProduct,
-    kArgCheckPolicyOptional,
-    "  -h --help [COMPILERNAME]    \tPrint usage and exit.\n"
-    "                              \tTo print the help info of specified compiler,\n"
-    "                              \tyou can use jbc2mpl, me, mpl2mpl, mplcg... as the COMPILERNAME\n"
-    "                              \teg: --help=mpl2mpl\n",
-    "driver",
-    {} },
-  { kVersion,
-    0,
-    "",
-    "version",
-    kBuildTypeProduct,
-    kArgCheckPolicyOptional,
-    "  --version [command]         \tPrint version and exit.\n",
-    "driver",
-    {} },
-  { kInFile,
-    0,
-    "",
-    "infile",
-    kBuildTypeProduct,
-    kArgCheckPolicyRequired,
-    "  --infile file1,file2,file3  \tInput files.\n",
-    "driver",
-    {} },
-  { kInMplt,
-    0,
-    "",
-    "mplt",
-    kBuildTypeProduct,
-    kArgCheckPolicyRequired,
-    "  --mplt=file1,file2,file3    \tImport mplt files.\n",
-    "driver",
-    { "jbc2mpl",
-      "dex2mpl"
-    } },
-  { kOptimization0,
-    0,
-    "O0",
-    "",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  -O0                         \tNo optimization.\n",
-    "driver",
-    {} },
-  { kOptimization1,
-    0,
-    "O1",
-    "",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNone,
-    "  -O1                         \tDo some optimization.\n",
-    "driver",
-    {} },
-  { kOptimization2,
-    0,
-    "O2",
-    "",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  -O2                         \tDo more optimization. (Default)\n",
-    "driver",
-    {"hir2mpl"} },
-  { kOptimizationS,
-      0,
-      "Os",
-      "",
-      kBuildTypeProduct,
-      kArgCheckPolicyNone,
-      "  -Os                         \tOptimize for size, based on O2.\n",
-      "driver",
-      {"hir2mpl"} },
-  { kPartO2,
-    0,
-    "",
-    "partO2",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --partO2               \tSet func list for O2\n",
-    "driver",
-    {} },
-  { kWithIpa,
-    kEnable,
-    "",
-    "with-ipa",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --with-ipa                  \tRun IPA when building\n"
-    "  --no-with-ipa               \n",
-    "driver",
-    {} },
-  { kVerify,
-    kEnable,
-    "",
-    "verify",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNone,
-    "  --verify                    \tVerify mpl file\n",
-    "driver",
-    { "dex2mpl", "mpl2mpl" } },
-  { kJbc2mplOpt,
-    0,
-    "",
-    "jbc2mpl-opt",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --jbc2mpl-opt               \tSet options for jbc2mpl\n",
-    "driver",
-    {} },
-  { kCpp2mplOpt,
-    0,
-    "",
-    "hir2mpl-opt",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --hir2mpl-opt               \tSet options for hir2mpl\n",
-    "driver",
-    {} },
-  { kAsOpt,
-    0,
-    "",
-    "as-opt",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "--as-opt                      \tSet options for as\n",
-    "driver",
-    {} },
-  { kLdOpt,
-    0,
-    "",
-    "ld-opt",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "--ld-opt                      \tSet options for ld\n",
-    "driver",
-    {} },
-  { kDex2mplOpt,
-    0,
-    "",
-    "dex2mpl-opt",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --dex2mpl-opt               \tSet options for dex2mpl\n",
-    "driver",
-    {} },
-  { kMplipaOpt,
-    0,
-    "",
-    "mplipa-opt",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --mplipa-opt                \tSet options for mplipa\n",
-    "driver",
-    {} },
-  { kMplcgOpt,
-    0,
-    "",
-    "mplcg-opt",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --mplcg-opt                  \tSet options for mplcg\n",
-    "driver",
-    {} },
-  { kDecoupleStatic,
-    kEnable,
-    "",
-    "decouple-static",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --decouple-static           \tdecouple the static method and field\n"
-    "  --no-decouple-static        \tDon't decouple the static method and field\n",
-    "driver",
-    { "dex2mpl", "me", "mpl2mpl" } },
-  { kProfilePath,
-    0,
-    "",
-    "profile",
-    kBuildTypeProduct,
-    kArgCheckPolicyRequired,
-    "  --profile                   \tFor PGO optimization\n"
-    "                              \t--profile=list_file\n",
-    "driver",
-    { "dex2mpl", "mpl2mpl", "mplcg" } },
-  { kProfileGen,
-    kEnable,
-    "",
-    "profileGen",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --profileGen                \tGenerate profile data for static languages\n",
-    "driver",
-    { "me", "mpl2mpl", "mplcg" } },
-  { kProfileUse,
-    kEnable,
-    "",
-    "profileUse",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --profileUse                \tOptimize static languages with profile data\n",
-    "driver",
-    { "me", "mpl2mpl", "mplcg" } },
-  { kGCOnly,
-    kEnable,
-    "",
-    "gconly",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --gconly                     \tMake gconly is enable\n"
-    "  --no-gconly                  \tDon't make gconly is enable\n",
-    "driver",
-    {
-      "dex2mpl", "me", "mpl2mpl",
-      "mplcg"
-    } },
-  { kBigEndian,
-    kEnable,
-    "Be",
-    "BigEndian",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --BigEndian/--Be                     \tUsing BigEndian\n"
-    "  --no-BigEndian/ --no-Be              \tUsing LittleEndian\n",
-    "driver",
-    {
-      "me", "mpl2mpl",
-      "mplcg"
-    } },
-  { kMeOpt,
-    0,
-    "",
-    "me-opt",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --me-opt                    \tSet options for me\n",
-    "driver",
-    {} },
-  { kMpl2MplOpt,
-    0,
-    "",
-    "mpl2mpl-opt",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --mpl2mpl-opt               \tSet options for mpl2mpl\n",
-    "driver",
-    {} },
-  { kSaveTemps,
-    0,
-    "",
-    "save-temps",
-    kBuildTypeProduct,
-    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",
-    "driver",
-    {} },
-  { kRun,
-    0,
-    "",
-    "run",
-    kBuildTypeProduct,
-    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",
-    "driver",
-    {} },
-  { kOption,
-    0,
-    "",
-    "option",
-    kBuildTypeProduct,
-    kArgCheckPolicyRequired,
-    "  --option=\"opt1:opt2\"      \tOptions for each executable,\n"
-    "                              \tseparated by \":\".\n"
-    "                              \tThe sequence must match the sequence in\n"
-    "                              \t--run.\n",
-    "driver",
-    {} },
-  { kTimePhases,
-    0,
-    "time-phases",
-    "",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNone,
-    "  -time-phases                \tTiming phases and print percentages\n",
-    "driver",
-    {} },
-  { kGenMeMpl,
-    0,
-    "",
-    "genmempl",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --genmempl                  \tGenerate me.mpl file\n",
-    "driver",
-    {} },
-  { kGenMapleBC,
-    0,
-    "",
-    "genmaplebc",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --genmaplebc                \tGenerate .mbc file\n",
-    "driver",
-    {} },
-  { kGenLMBC,
-    0,
-    "",
-    "genlmbc",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --genlmbc                   \tGenerate .lmbc file\n",
-    "driver",
-    {} },
-  { kGenObj,
-    kEnable,
-    "c",
-    "",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  -c                          \tCompile or assemble the source files, but do not link.\n",
-    "driver",
-    {}  },
-  { kGenVtableImpl,
-    0,
-    "",
-    "genVtableImpl",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --genVtableImpl             \tGenerate VtableImpl.mpl file\n",
-    "driver",
-    {} },
-  { kVerbose,
-    kEnable,
-    "",
-    "verbose",
-    kBuildTypeDebug,
-    kArgCheckPolicyBool,
-    "  -verbose                    \t: print informations\n",
-    "driver",
-    { "jbc2mpl", "hir2mpl", "me", "mpl2mpl", "mplcg" } },
-  { kAllDebug,
-    0,
-    "",
-    "debug",
-    kBuildTypeDebug,
-    kArgCheckPolicyNone,
-    "  --debug                     \tPrint debug info.\n",
-    "driver",
-    {} },
-  { kWithDwarf,
-    0,
-    "g",
-    "",
-    kBuildTypeDebug,
-    kArgCheckPolicyNone,
-    "  -g                          \t: with dwarf\n",
-    "driver",
-    {} },
-  { kHelpLevel,
-    0,
-    "",
-    "level",
-    kBuildTypeProduct,
-    kArgCheckPolicyNumeric,
-    "  --level=NUM                 \tPrint the help info of specified level.\n"
-    "                              \tNUM=0: All options (Default)\n"
-    "                              \tNUM=1: Product options\n"
-    "                              \tNUM=2: Experimental options\n"
-    "                              \tNUM=3: Debug options\n",
-    "driver",
-    {} },
-  { kNpeNoCheck,
-    0,
-    "",
-    "no-npe-check",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --no-npe-check              \tDisable null pointer check (Default)\n",
-    "driver",
-    {} },
-  { kNpeStaticCheck,
-    0,
-    "",
-    "npe-check-static",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --npe-check-static          \tEnable null pointer static check only\n",
-    "driver",
-    {} },
-  { kNpeDynamicCheck,
-    0,
-    "",
-    "npe-check-dynamic",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --npe-check-dynamic         \tEnable null pointer dynamic check with static warning\n",
-    "driver",
-    {} },
-  { kNpeDynamicCheckSilent,
-    0,
-    "",
-    "npe-check-dynamic-silent",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --npe-check-dynamic-silent  \tEnable null pointer dynamic without static warning\n",
-    "driver",
-    {} },
-  { kNpeDynamicCheckAll,
-    0,
-    "",
-    "npe-check-dynamic-all",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --npe-check-dynamic-all     \tKeep dynamic check before dereference, used with --npe-check-dynamic* options\n",
-    "driver",
-    {} },
-  { kBoundaryNoCheck,
-    0,
-    "",
-    "no-boundary-check",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --no-boundary-check         \tDisable boundary check (Default)\n",
-    "driver",
-    {} },
-  { kBoundaryStaticCheck,
-    0,
-    "",
-    "boundary-check-static",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --boundary-check-static     \tEnable boundary static check\n",
-    "driver",
-    {} },
-  { kBoundaryDynamicCheck,
-    0,
-    "",
-    "boundary-check-dynamic",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --boundary-check-dynamic    \tEnable boundary dynamic check with static warning\n",
-    "driver",
-    {} },
-  { kBoundaryDynamicCheckSilent,
-    0,
-    "",
-    "boundary-check-dynamic-silent",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --boundary-check-dynamic-silent  \tEnable boundary dynamic check without static warning\n",
-    "driver",
-    {} },
-  { kSafeRegionOption,
-      0,
-      "",
-      "safe-region",
-      kBuildTypeProduct,
-      kArgCheckPolicyNone,
-      "  --safe-region \tEnable safe region\n",
-      "driver",
-      {} },
-  { kMaplePrintPhases,
-    0,
-    "maple-print-phases",
-    "maple-print-phases",
-    kBuildTypeAll,
-    kArgCheckPolicyOptional,
-    "  -maple-print-phases         \tPrint Driver Phases.\n  --maple-print-phases\n",
-    "driver",
-    {} },
-  { kLdStatic,
-    0,
-    "static",
-    "static",
-    kBuildTypeAll,
-    kArgCheckPolicyNone,
-    "  -static                     \tForce the linker to link a program statically\n",
-    "driver",
-    {"ld"} },
-  { kLdLib,
-    0,
-    "l",
-    "",
-    kBuildTypeAll,
-    kArgCheckPolicyRequired,
-    "  -l <lib>                    \tLinks with a library file\n",
-    "driver",
-    {"ld"} },
-  { kLdLibPath,
-    0,
-    "L",
-    "",
-    kBuildTypeAll,
-    kArgCheckPolicyRequired,
-    "  -L <libpath>                \tAdd directory to library search path\n",
-    "driver",
-    {"ld"} },
-  { kClangMacro,
-    0,
-    "D",
-    "",
-    kBuildTypeAll,
-    kArgCheckPolicyRequired,
-    "  -D <macro>=<value>          \tDefine <macro> to <value> (or 1 if <value> omitted)\n",
-    "driver",
-    {"clang"} },
-  { kClangMacro,
-    0,
-    "U",
-    "",
-    kBuildTypeAll,
-    kArgCheckPolicyRequired,
-    "  -U <macro>                  \tUndefine macro <macro>\n",
-    "driver",
-    {"clang"} },
-  { kClangInclude,
-    0,
-    "I",
-    "",
-    kBuildTypeAll,
-    kArgCheckPolicyRequired,
-    "  -I <dir>                    \tAdd directory to include search path\n",
-    "driver",
-    {"clang"} },
-  { kClangISystem,
-    0,
-    "isystem",
-    "",
-    kBuildTypeAll,
-    kArgCheckPolicyRequired,
-    "  -isystem <dir>              \tAdd directory to SYSTEM include search path\n",
-    "driver",
-    {"clang"} },
-  { kMaplePhaseOnly,
-    kEnable,
-    "",
-    "maple-phase",
-    kBuildTypeAll,
-    kArgCheckPolicyBool,
-    "  --maple-phase               \tRun maple phase only\n  --no-maple-phase\n",
-    "driver",
-    {} },
-  { kMapleOut,
-    0,
-    "o",
-    "",
-    kBuildTypeAll,
-    kArgCheckPolicyRequired,
-    "  -o <outfile>                \tPlace the output into <file>\n",
-    "driver",
-    {} },
-  { kUnknown,
-    0,
-    "",
-    "",
-    kBuildTypeAll,
-    kArgCheckPolicyNone,
-    "",
-    "driver",
-    {} }
-};
-}  // namepsace
-
-namespace maple {
-using namespace mapleOption;
-DriverOptionCommon &DriverOptionCommon::GetInstance() {
-  static DriverOptionCommon instance;
-  return instance;
-}
-
-DriverOptionCommon::DriverOptionCommon() {
-  CreateUsages(kUsages);
-}
-}  // namespace maple
diff --git a/src/mapleall/maple_driver/src/driver_options.cpp b/src/mapleall/maple_driver/src/driver_options.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..99e93e1f8ea7b1ea83ab58bc1a69f8c2fd5cb233
--- /dev/null
+++ b/src/mapleall/maple_driver/src/driver_options.cpp
@@ -0,0 +1,303 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * 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 v2 for more details.
+ */
+
+#include "driver_options.h"
+#include "cl_option.h"
+
+#include <stdint.h>
+#include <string>
+
+namespace opts {
+
+/* ##################### BOOL Options ############################################################### */
+
+cl::Option<bool> version({"--version", "-v"},
+                         "  --version [command]         \tPrint version and exit.\n",
+                         {driverCategory});
+
+cl::Option<bool> o0({"--O0", "-O0"},
+                    "  -O0                         \tNo optimization.\n",
+                    {driverCategory});
+
+cl::Option<bool> o1({"--O1", "-O1"},
+                    "  -O1                         \tDo some optimization.\n",
+                    {driverCategory});
+
+cl::Option<bool> o2({"--O2", "-O2"},
+                    "  -O2                         \tDo more optimization. (Default)\n",
+                    {driverCategory});
+
+cl::Option<bool> os({"--Os", "-Os"},
+                    "  -Os                         \tOptimize for size, based on O2.\n",
+                    {driverCategory, hir2mplCategory});
+
+cl::Option<bool> verify({"--verify"},
+                        "  --verify                    \tVerify mpl file\n",
+                        {driverCategory, dex2mplCategory, mpl2mplCategory});
+
+cl::Option<bool> decoupleStatic({"--decouple-static", "-decouple-static"},
+                                "  --decouple-static           \tdecouple the static method and field\n"
+                                "  --no-decouple-static        \tDon't decouple the static method and field\n",
+                                {driverCategory, dex2mplCategory, meCategory, mpl2mplCategory},
+                                cl::DisableWith("--no-decouple-static"));
+
+cl::Option<bool> bigendian({"-Be", "--BigEndian"},
+                           "  --BigEndian/--Be                     \tUsing BigEndian\n"
+                           "  --no-BigEndian/ --no-Be              \tUsing LittleEndian\n",
+                           {driverCategory, meCategory, mpl2mplCategory, cgCategory},
+                           cl::DisableWith("--no-BigEndian"));
+
+cl::Option<bool> gconly({"--gconly", "-gconly"},
+                        "  --gconly                     \tMake gconly is enable\n"
+                        "  --no-gconly                  \tDon't make gconly is enable\n",
+                        {driverCategory, dex2mplCategory, meCategory,
+                         mpl2mplCategory, cgCategory},
+                        cl::DisableWith("--no-gconly"));
+
+cl::Option<bool> timePhase({"-time-phases"},
+                           "  -time-phases                \tTiming phases and print percentages\n",
+                           {driverCategory});
+
+cl::Option<bool> genMeMpl({"--genmempl"},
+                          "  --genmempl                  \tGenerate me.mpl file\n",
+                          {driverCategory});
+
+cl::Option<bool> compileWOLink({"-c"},
+                               "  -c                          \tCompile the source files without linking\n",
+                               {driverCategory});
+
+cl::Option<bool> genVtable({"--genVtableImpl"},
+                           "  --genVtableImpl             \tGenerate VtableImpl.mpl file\n",
+                           {driverCategory});
+
+cl::Option<bool> verbose({"-verbose"},
+                         "  -verbose                    \t: print informations\n",
+                         {driverCategory, jbc2mplCategory, hir2mplCategory,
+                          meCategory, mpl2mplCategory, cgCategory});
+
+cl::Option<bool> debug({"--debug"},
+                       "  --debug                     \tPrint debug info.\n",
+                       {driverCategory});
+
+cl::Option<bool> withDwarf({"-g"},
+                           "  --debug                     \tPrint debug info.\n",
+                           {driverCategory});
+
+cl::Option<bool> npeNoCheck({"--no-npe-check"},
+                            "  --no-npe-check              \tDisable null pointer check (Default)\n",
+                            {driverCategory});
+
+cl::Option<bool> npeStaticCheck({"--npe-check-static"},
+                                "  --npe-check-static          \tEnable null pointer static check only\n",
+                                {driverCategory});
+
+cl::Option<bool> npeDynamicCheck({"--npe-check-dynamic"},
+                                 "  --npe-check-dynamic         \tEnable null pointer dynamic check with static warning\n",
+                                 {driverCategory});
+
+cl::Option<bool> npeDynamicCheckSilent({"--npe-check-dynamic-silent"},
+                                       "  --npe-check-dynamic-silent  \tEnable null pointer dynamic without static warning\n",
+                                       {driverCategory});
+
+cl::Option<bool> npeDynamicCheckAll({"--npe-check-dynamic-all"},
+                                    "  --npe-check-dynamic-all     \tKeep dynamic check before dereference, used with --npe-check-dynamic* options\n",
+                                    {driverCategory});
+
+cl::Option<bool> boundaryNoCheck({"--no-boundary-check"},
+                                 "  --no-boundary-check         \tDisable boundary check (Default)\n",
+                                 {driverCategory});
+
+cl::Option<bool> boundaryStaticCheck({"--boundary-check-static"},
+                                     "  --boundary-check-static     \tEnable boundary static check\n",
+                                     {driverCategory});
+
+cl::Option<bool> boundaryDynamicCheck({"--boundary-check-dynamic"},
+                                      "  --boundary-check-dynamic    \tEnable boundary dynamic check with static warning\n",
+                                      {driverCategory});
+
+cl::Option<bool> boundaryDynamicCheckSilent({"--boundary-check-dynamic-silent"},
+                                            "  --boundary-check-dynamic-silent  \tEnable boundary dynamic check without static warning\n",
+                                            {driverCategory});
+
+cl::Option<bool> safeRegionOption({"--safe-region"},
+                                  "  --safe-region \tEnable safe region\n",
+                                  {driverCategory});
+
+cl::Option<bool> printDriverPhases({"--print-driver-phases"},
+                                   "  --print-driver-phases         \tPrint Driver Phases\n",
+                                   {driverCategory});
+
+cl::Option<bool> ldStatic({"-static"},
+                          "  -static                     \tForce the linker to link a program statically\n",
+                          {driverCategory, ldCategory});
+
+cl::Option<bool> maplePhase({"--maple-phase"},
+                            "  --maple-phase               \tRun maple phase only\n  --no-maple-phase\n",
+                            {driverCategory},
+                            cl::DisableWith("--no-maple-phase"),
+                            cl::Init(true));
+
+cl::Option<bool> genMapleBC({"--genmaplebc"},
+                            "  --genmaplebc                \tGenerate .mbc file\n",
+                            {driverCategory});
+
+cl::Option<bool> genLMBC({"--genlmbc"},
+                         "  --genlmbc                \tGenerate .lmbc file\n",
+                         {driverCategory});
+
+cl::Option<bool> profileGen({"--profileGen"},
+                            "  --profileGen                \tGenerate profile data for static languages\n",
+                            {driverCategory, meCategory, mpl2mplCategory, cgCategory});
+
+cl::Option<bool> profileUse({"--profileUse"},
+                            "  --profileUse                \tOptimize static languages with profile data\n",
+                            {driverCategory, meCategory, mpl2mplCategory, cgCategory});
+
+/* ##################### STRING Options ############################################################### */
+
+cl::Option<std::string> help({"--help", "-h"},
+                             "  --help                   \tPrint help\n",
+                             {driverCategory},
+                             cl::optionalValue);
+
+cl::Option<std::string> infile({"--infile"},
+                               "  --infile file1,file2,file3  \tInput files.\n",
+                               {driverCategory});
+
+cl::Option<std::string> mplt({"--mplt", "-mplt"},
+                             "  --mplt=file1,file2,file3    \tImport mplt files.\n",
+                             {driverCategory, dex2mplCategory, jbc2mplCategory});
+
+cl::Option<std::string> partO2({"--partO2"},
+                               "  --partO2               \tSet func list for O2\n",
+                               {driverCategory});
+
+cl::List<std::string> jbc2mplOpt({"--jbc2mpl-opt"},
+                                 "  --jbc2mpl-opt               \tSet options for jbc2mpl\n",
+                                 {driverCategory});
+
+cl::List<std::string> hir2mplOpt({"--hir2mpl-opt"},
+                                 "  --hir2mpl-opt               \tSet options for hir2mpl\n",
+                                 {driverCategory});
+
+cl::List<std::string> clangOpt({"--clang-opt"},
+                               "  --clang-opt               \tSet options for clang as AST generator\n",
+                               {driverCategory});
+
+cl::List<std::string> asOpt({"--as-opt"},
+                            "  --as-opt                      \tSet options for as\n",
+                            {driverCategory});
+
+cl::List<std::string> ldOpt({"--ld-opt"},
+                            "  --ld-opt                      \tSet options for ld\n",
+                            {driverCategory});
+
+cl::List<std::string> dex2mplOpt({"--dex2mpl-opt"},
+                                 "  --dex2mpl-opt                      \tSet options for dex2mpl\n",
+                                 {driverCategory});
+
+cl::List<std::string> mplipaOpt({"--mplipa-opt"},
+                                "  --mplipa-opt                      \tSet options for mplipa\n",
+                                {driverCategory});
+
+cl::List<std::string> mplcgOpt({"--mplcg-opt"},
+                               "  --mplcg-opt                      \tSet options for mplcg\n",
+                               {driverCategory});
+
+cl::List<std::string> meOpt({"--me-opt"},
+                            "  --me-opt                      \tSet options for me\n",
+                            {driverCategory});
+
+cl::List<std::string> mpl2mplOpt({"--mpl2mpl-opt"},
+                                 "  --mpl2mpl-opt                      \tSet options for mpl2mpl\n",
+                                 {driverCategory});
+
+cl::Option<std::string> profile({"--profile"},
+                                "  --profile                   \tFor PGO optimization\n"
+                                "                              \t--profile=list_file\n",
+                                {driverCategory, dex2mplCategory, mpl2mplCategory, cgCategory});
+
+cl::Option<std::string> run({"--run"},
+                            "  --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",
+                            {driverCategory});
+
+cl::Option<std::string> optionOpt({"--option"},
+                                  "  --option=\"opt1:opt2\"      \tOptions for each executable,\n"
+                                  "                              \tseparated by \":\".\n"
+                                  "                              \tThe sequence must match the sequence in\n"
+                                  "                              \t--run.\n",
+                                  {driverCategory});
+
+cl::List<std::string> ldLib({"-l"},
+                            "  -l <lib>                    \tLinks with a library file\n",
+                            {driverCategory, ldCategory},
+                            cl::joinedValue);
+
+cl::List<std::string> ldLibPath({"-L"},
+                                "  -L <libpath>                \tAdd directory to library search path\n",
+                                {driverCategory, ldCategory},
+                                cl::joinedValue);
+
+cl::List<std::string> enableMacro({"-D"},
+                                  "  -D <macro>=<value>          \tDefine <macro> to <value> (or 1 if <value> omitted)\n",
+                                  {driverCategory, clangCategory},
+                                  cl::joinedValue);
+
+cl::List<std::string> disableMacro({"-U"},
+                                   "  -U <macro>                  \tUndefine macro <macro>\n",
+                                   {driverCategory, clangCategory},
+                                   cl::joinedValue);
+
+cl::List<std::string> includeDir({"-I"},
+                                 "  -I <dir>                    \tAdd directory to include search path\n",
+                                 {driverCategory, clangCategory},
+                                 cl::joinedValue);
+
+cl::List<std::string> includeSystem({"--isystem"},
+                                    "  -isystem <dir>              \tAdd directory to SYSTEM include search path\n",
+                                    {driverCategory, clangCategory},
+                                    cl::joinedValue);
+
+cl::Option<std::string> output({"-o"},
+                               "  -o <outfile>                \tPlace the output into <file>\n",
+                               {driverCategory},
+                               cl::Init("a.out"));
+
+cl::Option<std::string> saveTempOpt({"--save-temps"},
+                                    "  --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",
+                                    {driverCategory},
+                                    cl::optionalValue);
+
+/* ##################### DIGITAL Options ############################################################### */
+
+cl::Option<uint32_t> helpLevel({"--level"},
+                               "  --level=NUM                 \tPrint the help info of specified level.\n"
+                               "                              \tNUM=0: All options (Default)\n"
+                               "                              \tNUM=1: Product options\n"
+                               "                              \tNUM=2: Experimental options\n"
+                               "                              \tNUM=3: Debug options\n",
+                               {driverCategory});
+
+/* #################################################################################################### */
+
+} /* namespace opts */
diff --git a/src/mapleall/maple_driver/src/ipa_compiler.cpp b/src/mapleall/maple_driver/src/ipa_compiler.cpp
index 939facc8e20326e3db6add3ed2459148619d4eea..d56fe107f3ac2c627ab6e681381410d898173da4 100644
--- a/src/mapleall/maple_driver/src/ipa_compiler.cpp
+++ b/src/mapleall/maple_driver/src/ipa_compiler.cpp
@@ -14,17 +14,18 @@
  */
 #include "compiler.h"
 #include "default_options.def"
+#include "driver_options.h"
 
 namespace maple {
 const std::string &IpaCompiler::GetBinName() const {
   return kBinNameMplipa;
 }
 
-DefaultOption IpaCompiler::GetDefaultOptions(const MplOptions &options, const Action&) const {
+DefaultOption IpaCompiler::GetDefaultOptions(const Action&) const {
   uint32_t len = 0;
   MplOption *kMplipaDefaultOptions = nullptr;
 
-  if (options.GetOptimizationLevel() == kO2 && options.HasSetDefaultLevel()) {
+  if (opts::o2) {
     len = sizeof(kMplipaDefaultOptionsO2) / sizeof(MplOption);
     kMplipaDefaultOptions = kMplipaDefaultOptionsO2;
   }
@@ -42,12 +43,12 @@ DefaultOption IpaCompiler::GetDefaultOptions(const MplOptions &options, const Ac
     defaultOptions.mplOptions[i].SetValue(
         FileUtils::AppendMapleRootIfNeeded(defaultOptions.mplOptions[i].GetNeedRootPath(),
                                            defaultOptions.mplOptions[i].GetValue(),
-                                           options.GetExeFolder()));
+                                           MplDriver::GetMplDriver().GetExeFolder()));
   }
   return defaultOptions;
 }
 
-std::string IpaCompiler::GetInputFileName(const MplOptions&, const Action &action) const {
+std::string IpaCompiler::GetInputFileName(const Action &action) const {
   return action.GetFullOutputName() + ".mpl";
 }
 }  // namespace maple
diff --git a/src/mapleall/maple_driver/src/jbc2mpl_compiler.cpp b/src/mapleall/maple_driver/src/jbc2mpl_compiler.cpp
index 0eb12728279b4e5d0d9211fac12b35de4486f5e2..17f512fb519363cbafd741d915e7fa00a64ac4dd 100644
--- a/src/mapleall/maple_driver/src/jbc2mpl_compiler.cpp
+++ b/src/mapleall/maple_driver/src/jbc2mpl_compiler.cpp
@@ -21,18 +21,17 @@ const std::string &Jbc2MplCompiler::GetBinName() const {
   return kBinNameJbc2mpl;
 }
 
-DefaultOption Jbc2MplCompiler::GetDefaultOptions(const MplOptions&, const Action&) const {
+DefaultOption Jbc2MplCompiler::GetDefaultOptions(const Action&) const {
   return DefaultOption();
 }
 
-void Jbc2MplCompiler::GetTmpFilesToDelete(const MplOptions&, const Action &action,
+void Jbc2MplCompiler::GetTmpFilesToDelete(const Action &action,
                                           std::vector<std::string> &tempFiles) const {
   tempFiles.push_back(action.GetFullOutputName() + ".mpl");
   tempFiles.push_back(action.GetFullOutputName() + ".mplt");
 }
 
-std::unordered_set<std::string> Jbc2MplCompiler::GetFinalOutputs(const MplOptions&,
-                                                                 const Action &action) const {
+std::unordered_set<std::string> Jbc2MplCompiler::GetFinalOutputs(const Action &action) const {
   std::unordered_set<std::string> finalOutputs;
   (void)finalOutputs.insert(action.GetFullOutputName() + ".mpl");
   (void)finalOutputs.insert(action.GetFullOutputName() + ".mplt");
diff --git a/src/mapleall/maple_driver/src/jbc2mpl_options.cpp b/src/mapleall/maple_driver/src/jbc2mpl_options.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..bd464590cf5c47ddd05e417a98e8618a4bcb4fc2
--- /dev/null
+++ b/src/mapleall/maple_driver/src/jbc2mpl_options.cpp
@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * 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 v2 for more details.
+ */
+
+#include "driver_options.h"
+#include "cl_option.h"
+
+#include <cstdint>
+#include <stdint.h>
+#include <string>
+
+namespace opts::jbc2mpl {
+
+cl::Option<bool> useStringFactory({"--use-string-factory"},
+                                  "  -use-string-factory    : Replace String.<init> by StringFactory call",
+                                  {jbc2mplCategory});
+
+cl::Option<std::string> out({"-o", "--out"},
+                            "  -o, -out output.mpl    : output mpl name",
+                            {jbc2mplCategory});
+
+cl::Option<std::string> inclass({"--inclass", "-inclass"},
+                                "  -inclass file1.class,file2.class\n",
+                                {jbc2mplCategory});
+
+cl::Option<std::string> injar({"--injar ", "-injar"},
+                              "  -injar file1.jar,file2.jar\n"
+                              "                         : input jar files",
+                              {jbc2mplCategory});
+
+cl::Option<std::string> mplt({"--mplt ", "-mplt"},
+                              "  -mplt file1.mplt,file2.mplt\n"
+                              "                         : import mplt files",
+                              {jbc2mplCategory});
+
+cl::Option<std::string> apkmplt({"--apkmplt ", "-apkmplt"},
+                                "  -apkmplt file1.mplt,file2.mplt\n"
+                                "                         : import apk mplt files",
+                                {jbc2mplCategory});
+
+cl::Option<std::string> outClassXML({"--out-classXML ", "-out-classXML"},
+                                    "  -out-classXML classes.xml\n"
+                                    "                         : output class in XML",
+                                    {jbc2mplCategory});
+
+cl::Option<std::string> outPath({"--output ", "-output"},
+                                "  -output path           : output path",
+                                {jbc2mplCategory});
+
+cl::Option<bool> mpltOnly({"-t"},
+                          "  -t                     : Generate mplt only",
+                          {jbc2mplCategory});
+
+cl::Option<bool> asciimplt({"-asciimplt", "--asciimplt"},
+                           "  -asciimplt             : Generate ascii mplt",
+                           {jbc2mplCategory});
+
+cl::Option<std::string> litprofile({"-litprofile", "--litprofile"},
+                                   "  -litprofile=litprofilefile\n"
+                                   "                         : optimize based on literal profiling data",
+                                   {jbc2mplCategory});
+
+cl::Option<std::string> sameName({"-same-name", "--same-name"},
+                                 "  -same-name=strategy\n"
+                                 "                         : strategy when type with the same name\n"
+                                 "                         : strategy list\n"
+                                 "                         :   ERROR:    print error and stop compiling (default)\n"
+                                 "                         :   USELIB:   use first imported by sequence apkmplt-mplt-class/jar\n"
+                                 "                         :   USEINPUT: use definition in class/jar",
+                                 {jbc2mplCategory});
+
+cl::Option<bool> enableTypeinfer({"-enable-typeinfer", "--enable-typeinfer"},
+                                 "  -enable-typeinfer      : enable type infer operation",
+                                 {jbc2mplCategory});
+
+cl::Option<uint32_t> dumpLevel({"-dump-level", "--dump-level"},
+                               "  -dump-level            : dump level",
+                               {jbc2mplCategory});
+
+cl::Option<bool> dumpTime({"-dump-time", "--dump-time"},
+                          "  -dump-time             : dump time",
+                          {jbc2mplCategory});
+
+cl::Option<bool> dumpPolymorphic({"-dump-polymorphic", "--dump-polymorphic"},
+                                 "  -dump-polymorphic      : dump polymorphic methods",
+                                 {jbc2mplCategory});
+
+cl::Option<std::string> debugJbcfuncname({"-debug-jbcfuncname", "--debug-jbcfuncname"},
+                                         "  -debug-jbcfuncname=funcName\n"
+                                         "                         : debug jbc func name",
+                                         {jbc2mplCategory});
+
+cl::Option<bool> debugDumpJbcfuncCfg({"-debug-dump-jbcfunc-cfg", "--debug-dump-jbcfunc-cfg"},
+                                     "  -debug-dump-jbcfunc-cfg\n"
+                                     "                         : debug dump jbc func cfg",
+                                     {jbc2mplCategory});
+
+cl::Option<std::string> debugDumpJbcfuncLocalvar({"-debug-dump-jbcfunc-localvar", "--debug-dump-jbcfunc-localvar"},
+                                                 "  -debug-dump-jbcfunc-localvar\n"
+                                                 "                         : debug dump jbc func local variable info",
+                                                 {jbc2mplCategory});
+
+cl::Option<bool> debugDumpDefuncStmt({"-debug-dump-fefunc-stmt", "--debug-dump-fefunc-stmt"},
+                                     "  -debug-dump-fefunc-stmt\n"
+                                     "                         : debug dump fe func stmt",
+                                     {jbc2mplCategory});
+
+cl::Option<bool> debugDumpFefuncCfg({"-debug-dump-fefunc-cfg", "--debug-dump-fefunc-cfg"},
+                                    "  -debug-dump-fefunc-cfg\n"
+                                    "                         : debug dump fe func cfg",
+                                    {jbc2mplCategory});
+
+cl::Option<bool> debugDumpDefuncDataflow({"-debug-dump-fefunc-dataflow", "--debug-dump-fefunc-dataflow"},
+                                         "  -debug-dump-fefunc-dataflow\n"
+                                         "                         : debug dump fe func dataflow",
+                                         {jbc2mplCategory});
+
+} /* namespace opts::jbc2mpl */
diff --git a/src/mapleall/maple_driver/src/ld_compiler.cpp b/src/mapleall/maple_driver/src/ld_compiler.cpp
index 2b54bf739f4b1c35c8ff8c8584fe6bfccf5fb78d..bbc0968745d574edd95035c1bf1be9144d617102 100644
--- a/src/mapleall/maple_driver/src/ld_compiler.cpp
+++ b/src/mapleall/maple_driver/src/ld_compiler.cpp
@@ -15,9 +15,10 @@
 #include "compiler.h"
 #include "file_utils.h"
 #include "default_options.def"
+#include "maple_driver.h"
 
 namespace maple {
-std::string LdCompiler::GetBinPath(const MplOptions&) const {
+std::string LdCompiler::GetBinPath() const {
 #ifdef ANDROID
   return "prebuilts/gcc/linux-x86/aarch64/aarch64-linux-android-4.9/bin/";
 #else
@@ -35,7 +36,7 @@ const std::string &LdCompiler::GetTool() const {
   return kLdFlag;
 }
 
-DefaultOption LdCompiler::GetDefaultOptions(const MplOptions &options, const Action&) const {
+DefaultOption LdCompiler::GetDefaultOptions(const Action&) const {
   uint32_t len = sizeof(kLdDefaultOptions) / sizeof(MplOption);
   DefaultOption defaultOptions = { std::make_unique<MplOption[]>(len), len };
 
@@ -47,12 +48,12 @@ DefaultOption LdCompiler::GetDefaultOptions(const MplOptions &options, const Act
     defaultOptions.mplOptions[i].SetValue(
         FileUtils::AppendMapleRootIfNeeded(defaultOptions.mplOptions[i].GetNeedRootPath(),
                                            defaultOptions.mplOptions[i].GetValue(),
-                                           options.GetExeFolder()));
+                                           MplDriver::GetMplDriver().GetExeFolder()));
   }
   return defaultOptions;
 }
 
-std::string LdCompiler::GetInputFileName(const MplOptions&, const Action &action) const {
+std::string LdCompiler::GetInputFileName(const Action &action) const {
     std::string files;
 
     bool isFirstEntry = true;
@@ -68,4 +69,10 @@ std::string LdCompiler::GetInputFileName(const MplOptions&, const Action &action
     }
     return files;
 }
+
+void LdCompiler::AppendOutputOption(std::vector<MplOption> &finalOptions,
+                                    const std::string &name) const {
+  finalOptions.emplace_back("-o", name);
+}
+
 }  // namespace maple
diff --git a/src/mapleall/maple_driver/src/maple.cpp b/src/mapleall/maple_driver/src/maple.cpp
index 5cd1655cc48051ec0926cc8375e21f1155dd836b..90e34be5fcee57755235a1023d032afb6fd04453 100644
--- a/src/mapleall/maple_driver/src/maple.cpp
+++ b/src/mapleall/maple_driver/src/maple.cpp
@@ -13,18 +13,140 @@
  * See the Mulan PSL v2 for more details.
  */
 #include "compiler_factory.h"
+#include "driver_options.h"
 #include "error_code.h"
+#include "maple_driver.h"
 #include "mpl_options.h"
 #include "mpl_logging.h"
+#include <string>
+#include <vector>
 
 using namespace maple;
 
-int main(int argc, char **argv) {
-  MplOptions mplOptions;
-  int ret = mplOptions.Parse(argc, argv);
-  if (ret == kErrorNoError) {
-    ret = CompilerFactory::GetInstance().Compile(mplOptions);
+const std::vector<cl::OptionInterface *> extraExclude = { &opts::run,
+                                                          &opts::optionOpt,
+                                                          &opts::infile,
+                                                          &opts::mpl2mplOpt,
+                                                          &opts::meOpt,
+                                                          &opts::mplcgOpt };
+
+const std::vector<cl::OptionInterface *> printExclude = { &opts::run,
+                                                          &opts::optionOpt,
+                                                          &opts::infile };
+
+std::string GetCommonOptionsStr(const std::vector<cl::OptionInterface *> &exclude) {
+  std::string driverOptions;
+  for (auto const &opt : driverCategory.GetEnabledOptions()) {
+    if (!(std::find(std::begin(exclude), std::end(exclude), opt) != std::end(exclude))) {
+      for (const auto &val : opt->GetRawValues()) {
+        driverOptions += opt->GetName() + " " + val + " ";
+      }
+    }
   }
-  PrintErrorMessage(ret);
+
+  return driverOptions;
+}
+
+void ConnectOptStr(std::string &optionStr, const std::string &exeName,
+                   bool &firstComb, std::string &runStr) {
+  std::string connectSym = "";
+  auto &drv = MplDriver::GetMplDriver();
+
+  if (drv.GetExeOptions().find(exeName) != drv.GetExeOptions().end()) {
+    if (!firstComb) {
+      runStr += (":" + exeName);
+      optionStr += ":";
+    } else {
+      runStr += exeName;
+      firstComb = false;
+    }
+    auto it = drv.GetExeOptions().find(exeName);
+    for (auto &opt : it->second) {
+      optionStr += (" " + opt);
+    }
+  }
+}
+
+void PrintMpl2mplMeCgCommand(const std::string *inputFile, bool isBeforeParse) {
+  auto &drv = MplDriver::GetMplDriver();
+  if (drv.GetExeOptions().find(kBinNameMe) == drv.GetExeOptions().end() &&
+      drv.GetExeOptions().find(kBinNameMpl2mpl) == drv.GetExeOptions().end() &&
+      drv.GetExeOptions().find(kBinNameMplcg) == drv.GetExeOptions().end()) {
+    return;
+  }
+  std::string runStr = "--run=";
+  std::string optionStr;
+  optionStr += "--option=\"";
+  bool firstComb = true;
+
+  ConnectOptStr(optionStr, kBinNameMe, firstComb, runStr);
+  ConnectOptStr(optionStr, kBinNameMpl2mpl, firstComb, runStr);
+  ConnectOptStr(optionStr, kBinNameMplcg, firstComb, runStr);
+  optionStr += "\"";
+
+  std::string driverOptions = GetCommonOptionsStr(extraExclude);
+  std::string inputs;
+  if (inputFile == nullptr) {
+    for (const auto &in : MplDriver::GetMplDriver().GetInputFiles()) {
+      inputs += " " + in;
+    }
+    inputFile = &inputs;
+  }
+
+  std::string state = (isBeforeParse == true) ? "Starting: " : "Finihsed: ";
+  LogInfo::MapleLogger() << state << drv.GetExeFolder() << "maple "
+                         << runStr << " " << optionStr << " "
+                         << driverOptions << " " << *inputFile << '\n';
+}
+
+void PrintCombCompilerCommand(const std::string &input) {
+  auto &drv = MplDriver::GetMplDriver();
+
+  std::string optionStr;
+  std::string runStr = "--run=";
+
+  if (drv.GetRunMode() == kCustomRun) {
+    PrintMpl2mplMeCgCommand(&input, true);
+    return;
+  }
+
+  /* For kAutoRun */
+  if (opts::o0) {
+    optionStr = " -O0";
+  } else if (opts::o1) {
+    optionStr = " -O1";
+  } else if (opts::o2) {
+    optionStr = " -O0";
+  } else if (opts::os) {
+    optionStr = " -Os";
+  }
+
+  LogInfo::MapleLogger() << "Starting: " << drv.GetExeFolder() << "maple "
+                         << optionStr << " " << GetCommonOptionsStr(printExclude)
+                         << " " << input << '\n';
+}
+
+int DriverProcessing(int argc, char **argv) {
+  cl::CommandLine::GetCommandLine().Parse(argc, argv);
+  auto &drv = MplDriver::GetMplDriver();
+
+  auto ret = drv.Processing();
+  if (ret != kErrorNoError) {
+    PrintErrorMessage(ret);
+    return 0;
+  }
+
+  auto &compilerFactory = CompilerFactory::GetInstance();
+  ret = compilerFactory.Compile(drv.GetActions());
+  if (ret != kErrorNoError) {
+    PrintErrorMessage(ret);
+    return 0;
+  }
+
+  return 0;
+}
+
+int main(int argc, char **argv) {
+  int ret = DriverProcessing(argc, argv);
   return ret;
 }
diff --git a/src/mapleall/maple_driver/src/maple_comb_compiler.cpp b/src/mapleall/maple_driver/src/maple_comb_compiler.cpp
index 64623f455f034954b92817d02b3aeca0e9c8ee0f..aba774a441ae1e89d852a5a51d08fdcf45d55936 100644
--- a/src/mapleall/maple_driver/src/maple_comb_compiler.cpp
+++ b/src/mapleall/maple_driver/src/maple_comb_compiler.cpp
@@ -12,20 +12,36 @@
  * FIT FOR A PARTICULAR PURPOSE.
  * See the Mulan PSL v2 for more details.
  */
-#include <iterator>
-#include <algorithm>
+
 #include "compiler.h"
+#include "error_code.h"
+#include "maple_driver.h"
+#include "mpl_options.h"
 #include "string_utils.h"
 #include "mpl_logging.h"
+#include "driver_options.h"
 #include "driver_runner.h"
 #include "inline.h"
 #include "me_phase_manager.h"
 #include "constantfold.h"
 
+#include <iterator>
+#include <algorithm>
+#include <string>
+
+#include "default_options.def"
+
+namespace {
+  template<typename TContainer, typename TData>
+  bool Contains(const TContainer &container, const TData &data) {
+    return (std::find(std::begin(container), std::end(container), data) != container.end());
+  };
+}
+
 namespace maple {
 using namespace mapleOption;
 
-std::string MapleCombCompiler::GetInputFileName(const MplOptions &, const Action &action) const {
+std::string MapleCombCompiler::GetInputFileName(const Action &action) const {
   if (action.IsItFirstRealAction()) {
     return action.GetInputFile();
   }
@@ -38,7 +54,7 @@ std::string MapleCombCompiler::GetInputFileName(const MplOptions &, const Action
   return action.GetFullOutputName() + ".mpl";
 }
 
-void MapleCombCompiler::GetTmpFilesToDelete(const MplOptions&, const Action &action,
+void MapleCombCompiler::GetTmpFilesToDelete(const Action &action,
                                             std::vector<std::string> &tempFiles) const {
   std::string filePath;
   filePath = action.GetFullOutputName() + ".data.muid";
@@ -57,157 +73,249 @@ void MapleCombCompiler::GetTmpFilesToDelete(const MplOptions&, const Action &act
   }
 }
 
-std::unordered_set<std::string> MapleCombCompiler::GetFinalOutputs(const MplOptions&,
-                                                                   const Action &action) const {
+std::unordered_set<std::string> MapleCombCompiler::GetFinalOutputs(const Action &action) const {
   std::unordered_set<std::string> finalOutputs;
   (void)finalOutputs.insert(action.GetFullOutputName() + ".VtableImpl.mpl");
   return finalOutputs;
 }
 
-void MapleCombCompiler::PrintCommand(const MplOptions &options, const Action &action) const {
+void MapleCombCompiler::PrintCommand(const Action &action) const {
+  auto &drv = MplDriver::GetMplDriver();
+
   std::string runStr = "--run=";
   std::ostringstream optionStr;
   optionStr << "--option=\"";
   std::string connectSym = "";
   bool firstComb = false;
-  if (options.GetExeOptions().find(kBinNameMe) != options.GetExeOptions().end()) {
+
+  if (drv.GetExeOptions().find(kBinNameMe) != drv.GetExeOptions().end()) {
     runStr += "me";
-    auto it = options.GetExeOptions().find(kBinNameMe);
-    for (const mapleOption::Option &opt : it->second) {
-      connectSym = !opt.Args().empty() ? "=" : "";
-      auto prefixStr = opt.GetPrefix();
-      optionStr << " " << prefixStr << opt.OptionKey() << connectSym << opt.Args();
+    auto it = drv.GetExeOptions().find(kBinNameMe);
+
+    for (auto &opt : it->second) {
+      optionStr << " " << opt;
     }
+
     firstComb = true;
   }
-  if (options.GetExeOptions().find(kBinNameMpl2mpl) != options.GetExeOptions().end()) {
+
+  if (drv.GetExeOptions().find(kBinNameMpl2mpl) != drv.GetExeOptions().end()) {
     if (firstComb) {
       runStr += ":mpl2mpl";
       optionStr << ":";
     } else {
       runStr += "mpl2mpl";
     }
-    auto it = options.GetExeOptions().find(kBinNameMpl2mpl);
-    for (const mapleOption::Option &opt : it->second) {
-      connectSym = !opt.Args().empty() ? "=" : "";
-      auto prefixStr = opt.GetPrefix();
-      optionStr << " " << prefixStr << opt.OptionKey() << connectSym << opt.Args();
+    auto it = drv.GetExeOptions().find(kBinNameMpl2mpl);
+    for (auto &opt : it->second) {
+      optionStr << " " << opt;
     }
   }
 
-  std::string driverOptions = options.GetCommonOptionsStr();
-
+  std::string driverOptions = GetCommonOptionsStr(extraExclude);
   optionStr << "\"";
-  LogInfo::MapleLogger() << "Starting:" << options.GetExeFolder() << "maple " << runStr << " " << optionStr.str() << " "
-                         << driverOptions << " " << GetInputFileName(options, action) << '\n';
+  LogInfo::MapleLogger() << "Starting:" << drv.GetExeFolder() << "maple "
+                         << runStr << " " << optionStr.str() << " "
+                         << driverOptions << " " << GetInputFileName(action) << '\n';
 }
 
-ErrorCode MapleCombCompiler::MakeMeOptions(const MplOptions &options, DriverRunner &runner) {
-  auto it = std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(), kBinNameMe);
-  if (it == options.GetRunningExes().end()) {
-    return kErrorNoError;
-  }
+ErrorCode MapleCombCompiler::MakeMeOptions(DriverRunner &runner) {
   MeOption &meOption = MeOption::GetInstance();
-  auto itOpt = options.GetExeOptions().find(kBinNameMe);
-  if (itOpt == options.GetExeOptions().end()) {
-    LogInfo::MapleLogger() << "no me input options\n";
-    return kErrorCompileFail;
+  auto &drv = MplDriver::GetMplDriver();
+
+  auto itOpt = drv.GetExeOptions().find(kBinNameMe);
+  if (itOpt != drv.GetExeOptions().end()) {
+    const auto &meOptions = itOpt->second;
+    const std::deque<std::string_view> strMeOptions(meOptions.begin(), meOptions.end());
+    cl::CommandLine::GetCommandLine().HandleInputArgs(strMeOptions, meCategory);
+  } else {
+    cl::CommandLine::GetCommandLine().HandleInputArgs({}, meCategory);
   }
-  bool result = meOption.SolveOptions(itOpt->second, options.HasSetDebugFlag());
+
+  for (auto &arg : cl::CommandLine::GetCommandLine().badCLArgs) {
+    if (!FileUtils::IsFileExists(arg.first)) {
+      LogInfo::MapleLogger() << "Unknown option for me tool: " << arg.first << "\n";
+      return kErrorInvalidParameter;
+    }
+  }
+
+  bool result = meOption.SolveOptions(opts::debug);
   if (result == false) {
     LogInfo::MapleLogger() << "Meet error me options\n";
     return kErrorCompileFail;
   }
-  MeOption::generalRegOnly = options.HasSetGeneralRegOnly();
-  MeOption::npeCheckMode = options.GetNpeCheckMode();
-  MeOption::isNpeCheckAll = options.IsNpeCheckAll();
-  MeOption::boundaryCheckMode = options.GetBoundaryCheckMode();
-  MeOption::safeRegionMode = options.IsSafeRegion();
+
+  /* generalRegOnly is set as WA: if generalRegOnly is set for mplcg, it should be set for me too */
+  MeOption::generalRegOnly = drv.drvOptions.generalRegOnly;
+
+  /* npeCheckMode and boundaryCheckMode can not be handled by option directly
+   * because these modes are enums dependent from several options */
+  MeOption::npeCheckMode = drv.drvOptions.npeCheckMode;
+  MeOption::boundaryCheckMode = drv.drvOptions.boundaryCheckMode;
+
+  MeOption::isNpeCheckAll = opts::npeDynamicCheckAll;
+  MeOption::safeRegionMode = opts::safeRegionOption;
+
   // Set me options for driver runner
   runner.SetMeOptions(&MeOption::GetInstance());
+
   return kErrorNoError;
 }
 
-ErrorCode MapleCombCompiler::MakeMpl2MplOptions(const MplOptions &options, DriverRunner &runner) {
-  auto it = std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(), kBinNameMpl2mpl);
-  if (it == options.GetRunningExes().end()) {
-    return kErrorNoError;
-  }
+ErrorCode MapleCombCompiler::MakeMpl2MplOptions(DriverRunner &runner) {
   auto &mpl2mplOption = Options::GetInstance();
-  auto itOption = options.GetExeOptions().find(kBinNameMpl2mpl);
-  if (itOption == options.GetExeOptions().end()) {
-    LogInfo::MapleLogger() << "no mpl2mpl input options\n";
-    return kErrorCompileFail;
+  auto &drv = MplDriver::GetMplDriver();
+
+  auto itOpt = drv.GetExeOptions().find(kBinNameMpl2mpl);
+  if (itOpt != drv.GetExeOptions().end()) {
+    const auto &mplOptions = itOpt->second;
+    const std::deque<std::string_view> strMplOptions(mplOptions.begin(), mplOptions.end());
+    cl::CommandLine::GetCommandLine().HandleInputArgs(strMplOptions, mpl2mplCategory);
+  } else {
+    cl::CommandLine::GetCommandLine().HandleInputArgs({}, mpl2mplCategory);
   }
-  bool result = mpl2mplOption.SolveOptions(itOption->second, options.HasSetDebugFlag());
+
+  for (auto &arg : cl::CommandLine::GetCommandLine().badCLArgs) {
+    if (!FileUtils::IsFileExists(arg.first)) {
+      LogInfo::MapleLogger() << "Unknown option for mpl2mpl tool: " << arg.first << "\n";
+      return kErrorInvalidParameter;
+    }
+  }
+
+  bool result = mpl2mplOption.SolveOptions(opts::debug);
   if (result == false) {
     LogInfo::MapleLogger() << "Meet error mpl2mpl options\n";
     return kErrorCompileFail;
   }
+
   // Set mpl2mpl options for driver runner
   runner.SetMpl2mplOptions(&Options::GetInstance());
   return kErrorNoError;
 }
 
-std::string MapleCombCompiler::DecideOutExe(const MplOptions &options) {
-  std::string printOutExe = "";
-  auto &selectExes = options.GetSelectedExes();
-  if (selectExes[selectExes.size() - 1] == kBinNameMapleComb) {
-    auto it = std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(), kBinNameMpl2mpl);
-    if (it != options.GetRunningExes().end()) {
-      printOutExe = kBinNameMpl2mpl;
-      return printOutExe;
+ErrorCode MapleCombCompiler::AppendCombOptions(MIRSrcLang srcLang) {
+  ErrorCode ret = kErrorNoError;
+  auto &drv = MplDriver::GetMplDriver();
+
+  if (opts::o0) {
+    ret = drv.UpdateExeOptions(kBinNameMe, kMeDefaultOptionsO0,
+                               sizeof(kMeDefaultOptionsO0) / sizeof(MplOption));
+    if (ret != kErrorNoError) {
+      return ret;
+    }
+    if (srcLang != kSrcLangC) {
+      ret = drv.UpdateExeOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO0,
+                                 sizeof(kMpl2MplDefaultOptionsO0) / sizeof(MplOption));
+    } else {
+      ret = drv.UpdateExeOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO0ForC,
+                                 sizeof(kMpl2MplDefaultOptionsO0ForC) / sizeof(MplOption));
+    }
+
+    if (ret != kErrorNoError) {
+      return ret;
+    }
+  } else if (opts::o2) {
+    if (srcLang != kSrcLangC) {
+      ret = drv.UpdateExeOptions(kBinNameMe, kMeDefaultOptionsO2,
+                                 sizeof(kMeDefaultOptionsO2) / sizeof(MplOption));
+      if (ret != kErrorNoError) {
+        return ret;
+      }
+      ret = drv.UpdateExeOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO2,
+                                 sizeof(kMpl2MplDefaultOptionsO2) / sizeof(MplOption));
+    } else {
+      ret = drv.UpdateExeOptions(kBinNameMe, kMeDefaultOptionsO2ForC,
+                                 sizeof(kMeDefaultOptionsO2ForC) / sizeof(MplOption));
+      if (ret != kErrorNoError) {
+        return ret;
+      }
+      ret = drv.UpdateExeOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO2ForC,
+                                 sizeof(kMpl2MplDefaultOptionsO2ForC) / sizeof(MplOption));
     }
-    it = std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(), kBinNameMe);
-    if (it != options.GetRunningExes().end()) {
-      printOutExe = kBinNameMe;
-      return printOutExe;
+    if (ret != kErrorNoError) {
+      return ret;
     }
+  } else if (opts::os) {
+    if (srcLang == kSrcLangJava) {
+      return kErrorNotImplement;
+    }
+
+    ret = drv.UpdateExeOptions(kBinNameMe, kMeDefaultOptionsOs,
+                               sizeof(kMeDefaultOptionsOs) / sizeof(MplOption));
+    if (ret != kErrorNoError) {
+      return ret;
+    }
+    ret = drv.UpdateExeOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsOs,
+                               sizeof(kMpl2MplDefaultOptionsOs) / sizeof(MplOption));
   }
-  return selectExes[selectExes.size() - 1];
+
+  return ret;
 }
 
-ErrorCode MapleCombCompiler::Compile(MplOptions &options, const Action &action,
+const std::string &MapleCombCompiler::DecideOutExe() const {
+  const auto &tools = MplDriver::GetMplDriver().GetTools();
+
+  const std::string *lastMplTool = &kBinNameMe;
+  for (const auto &tool : tools) {
+    if (tool == kBinNameMpl2mpl) {
+      lastMplTool = &kBinNameMpl2mpl;
+    } else if (tool == kBinNameMplcg) {
+      lastMplTool = &kBinNameMplcg;
+    }
+  }
+
+  return *lastMplTool;
+}
+
+ErrorCode MapleCombCompiler::Compile(const Action &action,
                                      std::unique_ptr<MIRModule> &theModule) {
-  std::string fileName = GetInputFileName(options, action);
+  std::string fileName = GetInputFileName(action);
   bool fileParsed = true;
   if (theModule == nullptr) {
     theModule = std::make_unique<MIRModule>(fileName);
     fileParsed = false;
   }
-  options.PrintCommand(&action);
+
+  PrintCombCompilerCommand(fileName);
+
   LogInfo::MapleLogger() << "Starting maplecomb\n";
-  theModule->InitPartO2List(options.GetPartO2List());
-  DriverRunner runner(theModule.get(), options.GetSelectedExes(), action.GetInputFileType(), fileName,
-                      fileName, fileName, options.WithDwarf(), fileParsed,
-                      options.HasSetTimePhases(), options.HasSetGenVtableImpl(),
-                      options.HasSetGenMeMpl(), options.HasSetGenMapleBC(),
-                      options.HasSetGenLMBC());
-  ErrorCode ret = kErrorNoError;
+  theModule->InitPartO2List(opts::partO2);
+  DriverRunner runner(theModule.get(), action.internalTools, action.GetInputFileType(), fileName,
+                      fileName, fileName, opts::withDwarf, fileParsed,
+                      opts::timePhase, opts::genVtable, opts::genMeMpl,
+                      opts::genMapleBC, opts::genLMBC);
 
   MIRParser parser(*theModule);
   MIRSrcLang srcLang = kSrcLangUnknown;
-  ret = runner.ParseSrcLang(srcLang);
+  ErrorCode ret = runner.ParseSrcLang(srcLang);
   if (ret != kErrorNoError) {
     return ret;
   }
   theModule->SetSrcLang(srcLang);
 
   // Add running phases and default options according to the srcLang (only for auto mode)
-  ret = options.AppendCombOptions(theModule->GetSrcLang());
-  if (ret != kErrorNoError) {
-    return ret;
+  if (MplDriver::GetMplDriver().GetRunMode() != RunMode::kCustomRun) {
+    ret = AppendCombOptions(theModule->GetSrcLang());
+    if (ret != kErrorNoError) {
+      return ret;
+    }
   }
 
-  ret = MakeMeOptions(options, runner);
-  if (ret != kErrorNoError) {
-    return ret;
+  if (Contains(action.internalTools, kBinNameMe)) {
+    ret = MakeMeOptions(runner);
+    if (ret != kErrorNoError) {
+      return ret;
+    }
   }
-  ret = MakeMpl2MplOptions(options, runner);
-  if (ret != kErrorNoError) {
-    return ret;
+
+  if (Contains(action.internalTools, kBinNameMpl2mpl)) {
+    ret = MakeMpl2MplOptions(runner);
+    if (ret != kErrorNoError) {
+      return ret;
+    }
   }
-  runner.SetPrintOutExe(DecideOutExe(options));
+
+  runner.SetPrintOutExe(DecideOutExe());
 
   // Parse the input file
   ret = runner.ParseInput();
@@ -215,8 +323,8 @@ ErrorCode MapleCombCompiler::Compile(MplOptions &options, const Action &action,
     return ret;
   }
 
-  if (options.HasSetDebugFlag()) {
-    PrintCommand(options, action);
+  if (opts::debug) {
+    PrintCommand(action);
   }
   ErrorCode nErr = runner.Run();
   return nErr;
diff --git a/src/mapleall/maple_driver/src/maple_comb_compiler_wrapper.cpp b/src/mapleall/maple_driver/src/maple_comb_compiler_wrapper.cpp
index 92974c88292b85af4fea7775fe61ef8ba099d66c..184c59cf2008aa5d36ce9e6281079a0163fdc886 100644
--- a/src/mapleall/maple_driver/src/maple_comb_compiler_wrapper.cpp
+++ b/src/mapleall/maple_driver/src/maple_comb_compiler_wrapper.cpp
@@ -13,6 +13,7 @@
  * See the Mulan PSL v2 for more details.
  */
 #include "compiler.h"
+#include "driver_options.h"
 #include "types_def.h"
 #include <vector>
 
@@ -26,67 +27,21 @@ const std::string &MapleCombCompilerWrp::GetBinName() const {
   return kTmpBin;
 }
 
-std::string MapleCombCompilerWrp::GetBinPath(const MplOptions&) const {
+std::string MapleCombCompilerWrp::GetBinPath() const {
   return FileUtils::SafeGetenv(kMapleRoot) + "/output/" +
       FileUtils::SafeGetenv("MAPLE_BUILD_TYPE") + "/bin/";
 }
 
-DefaultOption MapleCombCompilerWrp::GetDefaultOptions(const MplOptions &mplOptions,
-                                                      const Action&) const {
-  auto options = mplOptions.GetOptions();
-  std::vector<Option *> tmpOptions;
-
-  uint32 optForWrapperCnt = 0;
-  for (Option &opt : options) {
-    auto desc = opt.GetDescriptor();
-    if (desc.exeName == "driver" ||
-        desc.exeName == "mpl2mpl" ||
-        desc.exeName == "mplcg" ||
-        desc.exeName == "me") {
-      ++optForWrapperCnt;
-      tmpOptions.push_back(&opt);
-    }
-  }
+DefaultOption MapleCombCompilerWrp::GetDefaultOptions(const Action&) const {
 
   /* need to add --maple-phase option to run only maple phase.
    * linker will be called as separated step (AsCompiler).
    */
-  uint32 additionalOption = 1;
-  DefaultOption defaultOptions = { std::make_unique<MplOption[]>(optForWrapperCnt + additionalOption),
-                                   optForWrapperCnt + additionalOption };
-
-  /* Set additional option */
-  defaultOptions.mplOptions[0].SetKey("--maple-phase");
-
-  for (unsigned int tmpOpInd = 0, defOptInd = additionalOption;
-       tmpOpInd < optForWrapperCnt; ++tmpOpInd) {
-
-    if (tmpOptions[tmpOpInd]->OptionKey() == "no-maple-phase") {
-      defaultOptions.length--;
-      continue;
-    }
-
-    std::string strOpt = tmpOptions[tmpOpInd]->GetPrefix();
-    if (!tmpOptions[tmpOpInd]->OptionKey().empty()) {
-      strOpt += tmpOptions[tmpOpInd]->OptionKey();
-    }
-
-    if (!tmpOptions[tmpOpInd]->Args().empty()) {
-      if (tmpOptions[tmpOpInd]->CheckEqualPrefix() == true) {
-        strOpt += "=";
-      } else {
-        strOpt += " ";
-      }
-      strOpt += tmpOptions[tmpOpInd]->Args();
-    }
-
-    defaultOptions.mplOptions[defOptInd++].SetKey(strOpt);
-  }
-
-  return defaultOptions;
+  opts::maplePhase.SetValue(true);
+  return DefaultOption();
 }
 
-std::string MapleCombCompilerWrp::GetInputFileName(const MplOptions &, const Action &action) const {
+std::string MapleCombCompilerWrp::GetInputFileName(const Action &action) const {
   if (action.IsItFirstRealAction()) {
     return action.GetInputFile();
   }
@@ -102,13 +57,12 @@ std::string MapleCombCompilerWrp::GetInputFileName(const MplOptions &, const Act
   return fullOutput + ".mpl";
 }
 
-void MapleCombCompilerWrp::GetTmpFilesToDelete(const MplOptions&, const Action &action,
+void MapleCombCompilerWrp::GetTmpFilesToDelete(const Action &action,
                                                std::vector<std::string> &tempFiles) const {
   tempFiles.push_back(action.GetFullOutputName() + ".s");
 }
 
-std::unordered_set<std::string> MapleCombCompilerWrp::GetFinalOutputs(const MplOptions&,
-                                                                      const Action &action) const {
+std::unordered_set<std::string> MapleCombCompilerWrp::GetFinalOutputs(const Action &action) const {
   std::unordered_set<std::string> finalOutputs;
   (void)finalOutputs.insert(action.GetFullOutputName() + ".s");
   return finalOutputs;
diff --git a/src/mapleall/maple_driver/src/maple_driver.cpp b/src/mapleall/maple_driver/src/maple_driver.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..a751bed0978dd5a415b28aacd3ad19f87b3f22ad
--- /dev/null
+++ b/src/mapleall/maple_driver/src/maple_driver.cpp
@@ -0,0 +1,650 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * 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 v2 for more details.
+ */
+
+#include "compiler.h"
+#include "compiler_factory.h"
+#include "driver_options.h"
+#include "error_code.h"
+#include "file_utils.h"
+#include "maple_driver.h"
+#include "mpl_options.h"
+#include <string>
+#include <vector>
+
+namespace maple {
+
+const std::string kBinNameNone = "";
+const std::string kBinNameJbc2mpl = "jbc2mpl";
+const std::string kBinNameCpp2mpl = "hir2mpl";
+const std::string kBinNameClang = "clang";
+const std::string kBinNameDex2mpl = "dex2mpl";
+const std::string kBinNameMplipa = "mplipa";
+const std::string kBinNameMe = "me";
+const std::string kBinNameMpl2mpl = "mpl2mpl";
+const std::string kBinNameMplcg = "mplcg";
+const std::string kBinNameMapleComb = "maplecomb";
+const std::string kBinNameMapleCombWrp = "maplecombwrp";
+const std::string kMachine = "aarch64-";
+const std::string kVendor = "unknown-";
+const std::string kOperatingSystem = "linux-gnu-";
+const std::string kLdFlag = "ld";
+const std::string kGccFlag = "gcc";
+const std::string kGppFlag = "g++";
+const std::string kAsFlag = "as";
+const std::string kInputPhase = "input";
+const std::string kBinNameLd = kMachine + kOperatingSystem + kLdFlag;
+const std::string kBinNameAs = kMachine + kOperatingSystem + kAsFlag;
+const std::string kBinNameGcc = kMachine + kOperatingSystem + kGccFlag;
+const std::string kBinNameGpp = kMachine + kOperatingSystem + kGppFlag;
+
+/* tool -> OptionCategory map: ld -> ldCategory, me -> meCategory and etc... */
+static std::unordered_map<std::string, cl::OptionCategory *> exeCategories =
+  {
+   {"maple", &driverCategory},
+   {maple::kBinNameClang, &clangCategory},
+   {maple::kBinNameCpp2mpl, &hir2mplCategory},
+   {maple::kBinNameMpl2mpl, &mpl2mplCategory},
+   {maple::kBinNameMe, &meCategory},
+   {maple::kBinNameMplcg, &cgCategory},
+   {maple::kAsFlag, &asCategory},
+   {maple::kLdFlag, &ldCategory},
+   {maple::kBinNameDex2mpl, &dex2mplCategory},
+   {maple::kBinNameJbc2mpl, &jbc2mplCategory},
+   {maple::kBinNameMplipa, &ipaCategory}
+  };
+
+/* Debug option */
+static cl::Option<bool> woinput({"--woinput"}, "", cl::hide);
+
+MplDriver &MplDriver::GetMplDriver() {
+  static MplDriver mplDriver;
+  return mplDriver;
+}
+
+cl::OptionCategory *MplDriver::GetCategory(const std::string &tool) const {
+  auto it = exeCategories.find(tool);
+  if (it == exeCategories.end()) {
+    return nullptr;
+  }
+
+  return it->second;
+}
+
+void MplDriver::DumpActionTree(const Action &action, int indents) const {
+  for (const std::unique_ptr<Action> &a : action.GetInputActions()) {
+    DumpActionTree(*a, indents + 1);
+  }
+
+  if (indents != 0) {
+    LogInfo::MapleLogger() << "|";
+    /* print indents */
+    for (int i = 0; i < indents; ++i) {
+      LogInfo::MapleLogger() << "-";
+    }
+  }
+
+  if (action.GetTool() == kInputPhase) {
+    LogInfo::MapleLogger() << action.GetTool() << " " << action.GetInputFile() << '\n';
+  } else {
+    LogInfo::MapleLogger() << action.GetTool() << '\n';
+  }
+}
+
+void MplDriver::DumpActionTree() const {
+  for (auto &rNode : rootActions) {
+    DumpActionTree(*rNode, 0);
+  }
+}
+
+void MplDriver::UpdateTools(const std::string &args) {
+  std::vector<std::string> argTools;
+  StringUtils::Split(args, argTools, ':');
+  for (auto &tool : argTools) {
+    if (!tool.empty()) {
+      tools.push_back(tool);
+    }
+  }
+}
+
+ErrorCode MplDriver::UpdateExeOptions(const std::string &exeName,
+                                      MplOption mplOptions[], unsigned int length) {
+  for (unsigned int i = 0; i < length; ++i) {
+    mplOptions[i].SetValue(FileUtils::AppendMapleRootIfNeeded(mplOptions[i].GetNeedRootPath(),
+                                                              mplOptions[i].GetValue(), GetExeFolder()));
+    auto &key = mplOptions[i].GetKey();
+    auto &val = mplOptions[i].GetValue();
+
+    if (!val.empty()) {
+      exeOptions[exeName].push_front(val);
+    }
+    if (!key.empty()) {
+      exeOptions[exeName].push_front(key);
+    }
+  }
+
+  return kErrorNoError;
+}
+
+void MplDriver::UpdateExeOptions(const std::string &options, const std::string &tool) {
+  std::vector<std::string> splittedOptions;
+  StringUtils::Split(options, splittedOptions, ' ');
+
+  for (auto &opt : splittedOptions) {
+    if (!opt.empty()) {
+      exeOptions[tool].push_back(opt);
+    }
+  }
+}
+
+ErrorCode MplDriver::UpdateExeOptions(const std::string &args) {
+  std::vector<std::string> options;
+  StringUtils::Split(args, options, ':');
+
+  /* The number of a tools and options for them must be the same */
+  if (options.size() != tools.size()) {
+    LogInfo::MapleLogger(kLlErr) << "The --run and --option are not matched, please check them."
+                                 << "(Too many or too few)\n";
+    return kErrorInvalidParameter;
+  }
+
+  auto tool = tools.begin();
+  for (auto &opt : options) {
+    UpdateExeOptions(opt, *tool);
+    ++tool;
+  }
+
+  return kErrorNoError;
+}
+
+ErrorCode MplDriver::CheckInputFiles() {
+  auto &badArgs = cl::CommandLine::GetCommandLine().badCLArgs;
+
+  /* Set input files with --infile="file1 file2" option */
+  if (opts::infile.IsEnabledByUser()) {
+    if (StringUtils::Trim(opts::infile).empty()) {
+      return kErrorFileNotFound;
+    }
+
+    std::vector<std::string> splitsInputFiles;
+    StringUtils::Split(opts::infile, splitsInputFiles, ',');
+
+    /* inputInfo describes each input file for driver */
+    for (auto &inFile : splitsInputFiles) {
+      if (FileUtils::IsFileExists(inFile)) {
+        inputFiles.push_back(inFile);
+        inputInfos.push_back(std::make_unique<InputInfo>(inFile));
+      }
+    }
+  }
+
+  /* Set input files directly: maple file1 file2 */
+  else {
+    for (auto &arg : badArgs) {
+      if (FileUtils::IsFileExists(arg.first)) {
+        inputFiles.push_back(arg.first);
+        inputInfos.push_back(std::make_unique<InputInfo>(arg.first));
+      }
+    }
+  }
+
+  if (inputFiles.empty()) {
+    return kErrorFileNotFound;
+  }
+
+  return kErrorNoError;
+}
+
+std::unique_ptr<Action> MplDriver::DecideRunningPhasesByType(const InputInfo *const inputInfo,
+                                                             bool isMultipleFiles) {
+  InputFileType inputFileType = inputInfo->GetInputFileType();
+  std::unique_ptr<Action> currentAction = std::make_unique<Action>(kInputPhase, inputInfo);
+  std::unique_ptr<Action> newAction;
+
+  bool isNeedMapleComb = true;
+  bool isNeedMplcg = true;
+  bool isNeedAs = true;
+  switch (inputFileType) {
+    case InputFileType::kFileTypeC:
+    case InputFileType::kFileTypeCpp:
+      newAction = std::make_unique<Action>(kBinNameClang, inputInfo, currentAction);
+      currentAction = std::move(newAction);
+      [[clang::fallthrough]];
+    case InputFileType::kFileTypeAst:
+      tools.push_back(kBinNameCpp2mpl);
+      newAction = std::make_unique<Action>(kBinNameCpp2mpl, inputInfo, currentAction);
+      currentAction = std::move(newAction);
+      break;
+    case InputFileType::kFileTypeJar:
+      // fall-through
+    case InputFileType::kFileTypeClass:
+      tools.push_back(kBinNameJbc2mpl);
+      newAction = std::make_unique<Action>(kBinNameJbc2mpl, inputInfo, currentAction);
+      currentAction = std::move(newAction);
+      isNeedAs = false;
+      break;
+    case InputFileType::kFileTypeDex:
+      tools.push_back(kBinNameDex2mpl);
+      newAction = std::make_unique<Action>(kBinNameDex2mpl, inputInfo, currentAction);
+      currentAction = std::move(newAction);
+      isNeedAs = false;
+      break;
+    case InputFileType::kFileTypeMpl:
+      break;
+    case InputFileType::kFileTypeMeMpl:
+    case InputFileType::kFileTypeVtableImplMpl:
+      isNeedMapleComb = false;
+      break;
+    case InputFileType::kFileTypeS:
+      isNeedMplcg = false;
+      isNeedMapleComb = false;
+      break;
+    case InputFileType::kFileTypeBpl:
+      break;
+    case InputFileType::kFileTypeObj:
+      isNeedMplcg = false;
+      isNeedMapleComb = false;
+      isNeedAs = false;
+      break;
+    case InputFileType::kFileTypeNone:
+      return nullptr;
+      break;
+    default:
+      return nullptr;
+      break;
+  }
+
+  if (opts::maplePhase) {
+    isNeedAs = false;
+  }
+
+  if (isNeedMapleComb) {
+    if (isMultipleFiles) {
+      newAction = std::make_unique<Action>(kBinNameMapleCombWrp, inputInfo, currentAction);
+      currentAction = std::move(newAction);
+    } else {
+      newAction = std::make_unique<Action>(kBinNameMapleComb, inputInfo, currentAction);
+      currentAction = std::move(newAction);
+    }
+
+    currentAction->internalTools.push_back(kBinNameMe);
+    currentAction->internalTools.push_back(kBinNameMpl2mpl);
+    tools.push_back(kBinNameMe);
+    tools.push_back(kBinNameMpl2mpl);
+  }
+  if (isNeedMplcg && !isMultipleFiles) {
+    tools.push_back(kBinNameMplcg);
+    newAction = std::make_unique<Action>(kBinNameMplcg, inputInfo, currentAction);
+    currentAction = std::move(newAction);
+  }
+
+  if (isNeedAs == true) {
+    tools.push_back(kAsFlag);
+    newAction = std::make_unique<Action>(kAsFlag, inputInfo, currentAction);
+    currentAction = std::move(newAction);
+  }
+
+  if (!opts::compileWOLink) {
+    tools.push_back(kLdFlag);
+    /* "Linking step" Action can have several inputActions.
+     * Each inputAction links to previous Actions to create the action tree.
+     * For linking step, inputActions are all assembly actions.
+     * Linking step Action is created outside this function because
+     * we must create all assembly actions (for all input files) before.
+     */
+  }
+
+  return currentAction;
+}
+
+InputInfo *MplDriver::AllocateInputInfo(const std::string &inputFile) {
+  auto inputInfo = std::make_unique<InputInfo>(inputFile);
+  InputInfo *ret = inputInfo.get();
+
+  inputInfos.push_back(std::move(inputInfo));
+
+  /* inputInfo continue to exist in inputInfos vector of unique_ptr so we can return raw pointer */
+  return ret;
+}
+
+ErrorCode MplDriver::DecideRunningPhases() {
+  ErrorCode ret = kErrorNoError;
+  std::vector<std::unique_ptr<Action>> linkActions;
+  std::unique_ptr<Action> lastAction;
+
+  bool isMultipleFiles = (inputInfos.size() > 1);
+
+  for (auto &inputInfo : inputInfos) {
+    CHECK_FATAL(inputInfo != nullptr, "InputInfo must be created!!");
+
+    lastAction = DecideRunningPhasesByType(inputInfo.get(), isMultipleFiles);
+
+    /* TODO: Add a message interface for correct exit with compilation error. And use it here
+     * instead of CHECK_FATAL.
+     */
+    CHECK_FATAL(lastAction != nullptr, "Incorrect input file type: %s",
+                inputInfo->GetInputFile().c_str());
+
+    if ((lastAction->GetTool() == kAsFlag && !opts::compileWOLink) ||
+        lastAction->GetTool() == kInputPhase) {
+      /* 1. For linking step, inputActions are all assembly actions;
+       * 2. If we try to link with maple driver, inputActions are all kInputPhase objects;
+       */
+      linkActions.push_back(std::move(lastAction));
+    } else {
+      rootActions.push_back(std::move(lastAction));
+    }
+  }
+
+  if (!linkActions.empty()) {
+    /* "a.out" is the default output file name - fix if it's needed  */
+    auto currentAction = std::make_unique<Action>(kLdFlag, linkActions, AllocateInputInfo("a.out"));
+    rootActions.push_back(std::move(currentAction));
+  }
+
+  return ret;
+}
+
+ErrorCode MplDriver::MFCreateActionByExe(const std::string &exe, std::unique_ptr<Action> &currentAction,
+                                         const InputInfo *const inputInfo, bool &wasWrpCombCompilerCreated) {
+  ErrorCode ret = kErrorNoError;
+
+  if (exe == kBinNameMe || exe == kBinNameMpl2mpl || exe == kBinNameMplcg) {
+    if (wasWrpCombCompilerCreated == false) {
+      auto newAction = std::make_unique<Action>(kBinNameMapleCombWrp, inputInfo, currentAction);
+      currentAction = std::move(newAction);
+      wasWrpCombCompilerCreated = true;
+    } else {
+      return ret;
+    }
+    currentAction->internalTools.push_back(exe);
+  }
+
+  else {
+    auto newAction = std::make_unique<Action>(exe, inputInfo, currentAction);
+    currentAction = std::move(newAction);
+  }
+
+  return ret;
+}
+
+ErrorCode MplDriver::SFCreateActionByExe(const std::string &exe, std::unique_ptr<Action> &currentAction,
+                                          const InputInfo *const inputInfo, bool &isCombCompiler) {
+  ErrorCode ret = kErrorNoError;
+
+  if (exe == kBinNameMe || exe == kBinNameMpl2mpl) {
+    if (isCombCompiler == false) {
+      auto newAction = std::make_unique<Action>(kBinNameMapleComb, inputInfo, currentAction);
+      currentAction = std::move(newAction);
+      isCombCompiler = true;
+      currentAction->internalTools.push_back(exe);
+    } else {
+      currentAction->internalTools.push_back(exe);
+      return ret;
+    }
+  }
+
+  else {
+    auto newAction = std::make_unique<Action>(exe, inputInfo, currentAction);
+    currentAction = std::move(newAction);
+  }
+
+  return ret;
+}
+
+ErrorCode MplDriver::DecideRunningPhases(const std::vector<std::string> &runExes) {
+  ErrorCode ret = kErrorNoError;
+
+  bool isMultipleFiles = (inputInfos.size() > 1);
+
+  for (auto &inputInfo : inputInfos) {
+    CHECK_FATAL(inputInfo != nullptr, "InputInfo must be created!!");
+    /* MplOption is owner of all InputInfos. MplOption is alive during compilation,
+     * so we can use raw pointer inside an Action.
+     */
+    const InputInfo *const rawInputInfo = inputInfo.get();
+
+    bool isCombCompiler = false;
+    bool wasWrpCombCompilerCreated = false;
+
+    auto currentAction = std::make_unique<Action>(kInputPhase, inputInfo.get());
+
+    for (const auto &exe : runExes) {
+      if (isMultipleFiles == true) {
+        ret = MFCreateActionByExe(exe, currentAction, rawInputInfo, wasWrpCombCompilerCreated);
+        if (ret != kErrorNoError) {
+          return ret;
+        }
+      } else {
+        ret = SFCreateActionByExe(exe, currentAction, rawInputInfo, isCombCompiler);
+        if (ret != kErrorNoError) {
+          return ret;
+        }
+      }
+    }
+
+    rootActions.push_back(std::move(currentAction));
+  }
+
+  return ret;
+}
+
+ErrorCode MplDriver::HandleEarlyOptions() {
+  if (opts::version) {
+    LogInfo::MapleLogger() << GetVersion() << "\n";
+    return kErrorExitHelp;
+  }
+
+  if (opts::printDriverPhases) {
+    DumpActionTree();
+    return kErrorExitHelp;
+  }
+
+  if (opts::help.IsEnabledByUser()) {
+    if (auto it = exeCategories.find(opts::help.GetValue()); it != exeCategories.end()) {
+      cl::CommandLine::GetCommandLine().HelpPrinter(*it->second);
+    } else {
+      maple::LogInfo::MapleLogger() << "USAGE: maple [options]\n\n"
+        "  Example 1: <Maple bin path>/maple --run=me:mpl2mpl:mplcg "
+        "--option=\"[MEOPT]:[MPL2MPLOPT]:[MPLCGOPT]\"\n"
+        "                                    --mplt=MPLTPATH inputFile.mpl\n"
+        "  Example 2: <Maple bin path>/maple -O2 --mplt=mpltPath inputFile.dex\n\n"
+        "==============================\n"
+        "  Options:\n";
+      cl::CommandLine::GetCommandLine().HelpPrinter();
+    }
+    return kErrorExitHelp;
+  }
+
+  if (opts::o0.IsEnabledByUser() ||
+      opts::o1.IsEnabledByUser() ||
+      opts::o2.IsEnabledByUser() ||
+      opts::os.IsEnabledByUser()) {
+
+    if (opts::run.IsEnabledByUser()) {
+      /* -Ox and --run should not appear at the same time */
+      LogInfo::MapleLogger(kLlErr) << "Cannot set auto mode and run mode at the same time!\n";
+      return kErrorInvalidParameter;
+    } else {
+      runMode = RunMode::kAutoRun;
+    }
+  } else if (opts::run.IsEnabledByUser()) {
+    runMode = RunMode::kCustomRun;
+
+    UpdateTools(opts::run);
+    if (!opts::optionOpt.GetValue().empty()) {
+      if (UpdateExeOptions(opts::optionOpt) != kErrorNoError) {
+        return kErrorInvalidParameter;
+      }
+    }
+  } else {
+    runMode = RunMode::kAutoRun;
+    opts::o0.SetValue(true); // enable default -O0
+  }
+
+  return kErrorNoError;
+}
+
+void MplDriver::HandleExtraOptions() {
+  for (const auto &val : opts::clangOpt.GetValues()) {
+    UpdateExeOptions(val, kBinNameClang);
+  }
+
+  for (const auto &val : opts::hir2mplOpt.GetValues()) {
+    UpdateExeOptions(val, kBinNameCpp2mpl);
+  }
+
+  for (const auto &val : opts::mpl2mplOpt.GetValues()) {
+    UpdateExeOptions(val, kBinNameMpl2mpl);
+  }
+
+  for (const auto &val : opts::meOpt.GetValues()) {
+    UpdateExeOptions(val, kBinNameMe);
+  }
+
+  for (const auto &val : opts::mplcgOpt.GetValues()) {
+    UpdateExeOptions(val, kBinNameMplcg);
+  }
+
+  for (const auto &val : opts::asOpt.GetValues()) {
+    UpdateExeOptions(val, kAsFlag);
+  }
+
+  for (const auto &val : opts::ldOpt.GetValues()) {
+    UpdateExeOptions(val, kLdFlag);
+  }
+
+  for (const auto &val : opts::dex2mplOpt.GetValues()) {
+    UpdateExeOptions(val, kBinNameDex2mpl);
+  }
+
+  for (const auto &val : opts::jbc2mplOpt.GetValues()) {
+    UpdateExeOptions(val, kBinNameJbc2mpl);
+  }
+
+  for (const auto &val : opts::mplipaOpt.GetValues()) {
+    UpdateExeOptions(val, kBinNameMplipa);
+  }
+
+  // A workaround to pass --general-reg-only from the cg options to global options
+  auto it = exeOptions.find(kBinNameMplcg);
+  if (it != exeOptions.end()) {
+    std::string regOnlyOpt("general-reg-only");
+    for (const auto &opt : it->second) {
+      if (opt == regOnlyOpt) {
+        drvOptions.generalRegOnly = true;
+        break;
+      }
+    }
+  }
+}
+
+ErrorCode MplDriver::HandleOptions() {
+  if (opts::output.IsEnabledByUser() && MplDriver::GetMplDriver().GetActions().size() > 1) {
+    LogInfo::MapleLogger(kLlErr) << "Cannot specify -o when generating multiple output\n";
+    return kErrorInvalidParameter;
+  }
+
+  if (opts::saveTempOpt.IsEnabledByUser()) {
+    opts::genMeMpl.SetValue(true);
+    opts::genVtable.SetValue(true);
+    StringUtils::Split(opts::saveTempOpt, saveFiles, ',');
+  }
+
+  if (!opts::safeRegionOption) {
+    if (opts::npeNoCheck) {
+      drvOptions.npeCheckMode = SafetyCheckMode::kNoCheck;
+    }
+
+    if (opts::npeStaticCheck) {
+      drvOptions.npeCheckMode = SafetyCheckMode::kStaticCheck;
+    }
+
+    if (opts::boundaryNoCheck) {
+      drvOptions.npeCheckMode = SafetyCheckMode::kNoCheck;
+    }
+
+    if (opts::boundaryStaticCheck) {
+      drvOptions.npeCheckMode = SafetyCheckMode::kStaticCheck;
+    }
+  } else { /* safeRegionOption is eanbled */
+    drvOptions.npeCheckMode = SafetyCheckMode::kDynamicCheck;
+    drvOptions.boundaryCheckMode = SafetyCheckMode::kDynamicCheck;
+  }
+
+
+  if (opts::npeDynamicCheck) {
+    drvOptions.npeCheckMode = SafetyCheckMode::kDynamicCheck;
+  }
+
+  if (opts::npeDynamicCheckSilent) {
+    drvOptions.npeCheckMode = SafetyCheckMode::kDynamicCheckSilent;
+  }
+
+  if (opts::boundaryDynamicCheck) {
+    drvOptions.boundaryCheckMode = SafetyCheckMode::kDynamicCheck;
+  }
+
+  if (opts::boundaryDynamicCheckSilent) {
+    drvOptions.boundaryCheckMode = SafetyCheckMode::kDynamicCheckSilent;
+  }
+
+  HandleExtraOptions();
+
+  return kErrorNoError;
+}
+
+ErrorCode MplDriver::Processing() {
+  exeFolder = FileUtils::GetFileFolder(FileUtils::GetExecutable());
+
+  ErrorCode ret = HandleEarlyOptions();
+  if (ret != kErrorNoError) {
+    return ret;
+  }
+
+  /* Check whether the input files were valid */
+  if (!woinput) {
+    ret = CheckInputFiles();
+    if (ret != kErrorNoError) {
+      return ret;
+    }
+  }
+
+  // Decide runningExes for default options(O0, O2) by input files
+  if (runMode != RunMode::kCustomRun) {
+    ret = DecideRunningPhases();
+    if (ret != kErrorNoError) {
+      return ret;
+    }
+  } else { // kCustomRun
+    /* kCustomRun run mode is set if --run=tool1:tool2 option is used.
+     * This Option is parsed on DecideRunType step. DecideRunType fills runningExes vector.
+     * DecideRunningPhases(runningExes) creates ActionsTree in kCustomRun mode.
+     * Maybe we can create Actions tree in DecideRunType in order to not use runningExes?
+    */
+    ret = DecideRunningPhases(tools);
+    if (ret != kErrorNoError) {
+      return ret;
+    }
+  }
+
+  ret = HandleOptions();
+  if (ret != kErrorNoError) {
+    return ret;
+  }
+
+  return kErrorNoError;
+}
+
+} // namespace maple
diff --git a/src/mapleall/maple_driver/src/mpl_options.cpp b/src/mapleall/maple_driver/src/mpl_options.cpp
deleted file mode 100644
index fd682d7957a822ea974698b1a7fdcef5cfaaf7bf..0000000000000000000000000000000000000000
--- a/src/mapleall/maple_driver/src/mpl_options.cpp
+++ /dev/null
@@ -1,1027 +0,0 @@
-/*
- * Copyright (c) [2019-2021] Huawei Technologies Co.,Ltd.All rights reserved.
- *
- * OpenArkCompiler is licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *
- *     http://license.coscl.org.cn/MulanPSL2
- *
- * 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 v2 for more details.
- */
-#include "mpl_options.h"
-#include <memory>
-#include <string>
-#include <vector>
-#include <algorithm>
-#include "compiler.h"
-#include "compiler_factory.h"
-#include "file_utils.h"
-#include "mpl_logging.h"
-#include "option_parser.h"
-#include "string_utils.h"
-#include "version.h"
-#include "default_options.def"
-#include "driver_option_common.h"
-#ifdef INTERGRATE_DRIVER
-#include "dex2mpl_options.h"
-#else
-#include "maple_dex2mpl_option.h"
-#endif
-#include "ipa_option.h"
-#include "jbc2mpl_option.h"
-#include "as_option.h"
-#include "ld_option.h"
-#include "cpp2mpl_option.h"
-#include "me_option.h"
-#include "option.h"
-#include "cg_option.h"
-
-namespace maple {
-using namespace mapleOption;
-using namespace maplebe;
-
-#ifdef ANDROID
-const std::string kMapleDriverVersion = "MapleDriver " + std::to_string(Version::GetMajorVersion()) + "." +
-                                        std::to_string(Version::GetMinorVersion()) + " 20190929";
-#else
-const std::string kMapleDriverVersion = "Maple Version : " + Version::GetVersionStr();
-#endif
-
-const std::vector<std::string> kMapleCompilers = { "jbc2mpl", "hir2mpl",
-    "dex2mpl", "mplipa", "as", "ld",
-    "me", "mpl2mpl", "mplcg", "clang"};
-
-int MplOptions::Parse(int argc, char **argv) {
-  optionParser.reset(new OptionParser());
-  optionParser->RegisteUsages(DriverOptionCommon::GetInstance());
-#ifdef INTERGRATE_DRIVER
-  optionParser->RegisteUsages(Dex2mplOptions::GetInstance());
-#else
-  optionParser->RegisteUsages(dex2mplUsage);
-#endif
-  optionParser->RegisteUsages(IpaOption::GetInstance());
-  optionParser->RegisteUsages(jbcUsage);
-  optionParser->RegisteUsages(cppUsage);
-  optionParser->RegisteUsages(ldUsage);
-  optionParser->RegisteUsages(asUsage);
-  optionParser->RegisteUsages(Options::GetInstance());
-  optionParser->RegisteUsages(MeOption::GetInstance());
-  optionParser->RegisteUsages(CGOptions::GetInstance());
-  exeFolder = FileUtils::GetFileFolder(FileUtils::GetExecutable());
-  int ret = optionParser->Parse(argc, argv);
-  if (ret != kErrorNoError) {
-    return ret;
-  }
-  // We should recognize O0, O2 and run options firstly to decide the real options
-  ret = DecideRunType();
-  if (ret != kErrorNoError) {
-    return ret;
-  }
-
-  // Set default as O0
-  if (runMode == RunMode::kUnkownRun) {
-    optimizationLevel = kO0;
-    runMode = RunMode::kAutoRun;
-  }
-  // Make sure in Auto mode
-  if (runMode != RunMode::kCustomRun) {
-    setDefaultLevel = true;
-  }
-
-  // Check whether the input files were valid
-  ret = CheckInputFileValidity();
-  if (ret != kErrorNoError) {
-    return ret;
-  }
-
-  // Decide runningExes for default options(O0, O2) by input files
-  if (runMode != RunMode::kCustomRun) {
-    ret = DecideRunningPhases();
-    if (ret != kErrorNoError) {
-      return ret;
-    }
-  } else { // kCustomRun
-    /* kCustomRun run mode is set if --run=tool1:tool2 option is used.
-     * This Option is parsed on DecideRunType step. DecideRunType fills runningExes vector.
-     * DecideRunningPhases(runningExes) creates ActionsTree in kCustomRun mode.
-     * Maybe we can create Actions tree in DecideRunType in order to not use runningExes?
-    */
-    ret = static_cast<int>(DecideRunningPhases(runningExes));
-    if (ret != kErrorNoError) {
-      return ret;
-    }
-  }
-
-  // Handle other options
-  ret = HandleGeneralOptions();
-  if (ret != kErrorNoError) {
-    return ret;
-  }
-  // Check whether the file was readable
-  ret = CheckFileExits();
-
-  if (isDriverPhasesDumpCmd) {
-    DumpActionTree();
-    return static_cast<int>(kErrorExitHelp);
-  }
-
-  return ret;
-}
-
-ErrorCode MplOptions::HandleGeneralOptions() {
-  ErrorCode ret = kErrorNoError;
-
-  const std::string *updatedOptToolName = nullptr;
-  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(), helpLevel);
-            return kErrorExitHelp;
-          }
-        }
-        optionParser->PrintUsage("driver", helpLevel);
-        return kErrorExitHelp;
-      }
-      case kVersion: {
-        LogInfo::MapleLogger() << kMapleDriverVersion << "\n";
-        return kErrorExitHelp;
-      }
-      case kProfileGen: {
-        exeOptions[kBinNameMe].push_back(opt);
-        exeOptions[kBinNameMpl2mpl].push_back(opt);
-        continue;
-      }
-      case kDex2mplOpt:
-        updatedOptToolName = &kBinNameDex2mpl;
-        break;
-      case kAsOpt:
-        updatedOptToolName = &kBinNameAs;
-        break;
-      case kCpp2mplOpt:
-        updatedOptToolName = &kBinNameCpp2mpl;
-        break;
-      case kJbc2mplOpt:
-        updatedOptToolName = &kBinNameJbc2mpl;
-        break;
-      case kMplipaOpt:
-        updatedOptToolName = &kBinNameMplipa;
-        break;
-      case kMeOpt:
-        updatedOptToolName = &kBinNameMe;
-        printExtraOptStr << " --me-opt=" << "\"" << opt.Args() << "\"";
-        break;
-      case kMpl2MplOpt:
-        updatedOptToolName = &kBinNameMpl2mpl;
-        printExtraOptStr << " --mpl2mpl-opt=" << "\"" << opt.Args() << "\"";
-        break;
-      case kMplcgOpt:
-        updatedOptToolName = &kBinNameMplcg;
-        printExtraOptStr << " --mplcg-opt=" << "\"" << opt.Args() << "\"";
-        break;
-      case kLdOpt:
-        updatedOptToolName = &kLdFlag;
-        break;
-      case kTimePhases:
-        timePhases = true;
-        break;
-      case kGenMeMpl:
-        genMeMpl = true;
-        break;
-      case kGenMapleBC:
-        genMapleBC = true;
-        break;
-      case kGenLMBC:
-        genLMBC = true;
-        break;
-      case kGenVtableImpl:
-        genVtableImpl = true;
-        break;
-      case kSaveTemps:
-        isSaveTmps = true;
-        genMeMpl = true;
-        genVtableImpl = true;
-        StringUtils::Split(opt.Args(), saveFiles, ',');
-        break;
-      case kOption:
-        if (UpdateExtraOptionOpt(opt.Args()) != kErrorNoError) {
-          return kErrorInvalidParameter;
-        }
-        break;
-      case kInMplt:
-        mpltFile = opt.Args();
-        break;
-      case kAllDebug:
-        debugFlag = true;
-        break;
-      case kMaplePrintPhases:
-        isDriverPhasesDumpCmd = true;
-        break;
-      case kWithDwarf:
-        withDwarf = true;
-        break;
-      case kPartO2:
-        partO2List = opt.Args();
-        break;
-      case kNpeNoCheck:
-        if (!safeRegion) {
-          npeCheckMode = SafetyCheckMode::kNoCheck;
-        }
-        break;
-      case kNpeStaticCheck:
-        if (!safeRegion) {
-          npeCheckMode = SafetyCheckMode::kStaticCheck;
-        }
-        break;
-      case kNpeDynamicCheck:
-        npeCheckMode = SafetyCheckMode::kDynamicCheck;
-        break;
-      case kNpeDynamicCheckSilent:
-        npeCheckMode = SafetyCheckMode::kDynamicCheckSilent;
-        break;
-      case kNpeDynamicCheckAll:
-        isNpeCheckAll = true;
-        break;
-      case kBoundaryNoCheck:
-        if (!safeRegion) {
-          boundaryCheckMode = SafetyCheckMode::kNoCheck;
-        }
-        break;
-      case kBoundaryStaticCheck:
-        if (!safeRegion) {
-          boundaryCheckMode = SafetyCheckMode::kStaticCheck;
-        }
-        break;
-      case kBoundaryDynamicCheck:
-        boundaryCheckMode = SafetyCheckMode::kDynamicCheck;
-        break;
-      case kBoundaryDynamicCheckSilent:
-        boundaryCheckMode = SafetyCheckMode::kDynamicCheckSilent;
-        break;
-      case kSafeRegionOption:
-        safeRegion = true;
-        npeCheckMode = SafetyCheckMode::kDynamicCheck;
-        boundaryCheckMode = SafetyCheckMode::kDynamicCheck;
-        break;
-      case kMapleOut:
-        CHECK_FATAL(!(rootActions[0]->GetTool().empty()),
-                    "rootActions must be set as last compilation step\n");
-        /* Add -o <out> option to last compilation step */
-        exeOptions[rootActions[0]->GetTool()].push_back(opt);
-        break;
-      default:
-        // I do not care
-        break;
-    }
-
-    if (updatedOptToolName != nullptr) {
-      ret = UpdatePhaseOption(opt.Args(), *updatedOptToolName);
-      if (ret != kErrorNoError) {
-        return ret;
-      }
-      updatedOptToolName = nullptr;
-    }
-
-    ret = AddOption(opt);
-  }
-
-  // A workaround to pass --general-reg-only from the cg options to global options
-  auto it = exeOptions.find("mplcg");
-  if (it != exeOptions.end()) {
-    std::string regOnlyOpt("general-reg-only");
-    for (const auto &opt : it->second) {
-      if (opt.OptionKey() == regOnlyOpt) {
-        generalRegOnly = true;
-        break;
-      }
-    }
-  }
-
-  return ret;
-}
-
-ErrorCode MplOptions::DecideRunType() {
-  ErrorCode ret = kErrorNoError;
-  bool runModeConflict = false;
-  for (auto opt : optionParser->GetOptions()) {
-    switch (opt.Index()) {
-      case kOptimization0:
-        if (runMode == RunMode::kCustomRun) {  // O0 and run should not appear at the same time
-          runModeConflict = true;
-        } else {
-          runMode = RunMode::kAutoRun;
-          optimizationLevel = kO0;
-        }
-        break;
-      case kOptimization2:
-      case kOptimizationS:
-        if (runMode == RunMode::kCustomRun) {  // O0 and run should not appear at the same time
-          runModeConflict = true;
-        } else {
-          runMode = RunMode::kAutoRun;
-          optimizationLevel = kO2;
-        }
-        if (opt.Index() == kOptimizationS) {
-          optForSize = true;
-        }
-        break;
-      case kWithIpa:
-        isWithIpa = (opt.Type() == kEnable);
-        break;
-      case kGenObj:
-        genObj = true;
-        break;
-      case kMaplePhaseOnly:
-        runMaplePhaseOnly = (opt.Type() == kEnable) ? true : false;
-        break;
-      case kRun:
-        if (runMode == RunMode::kAutoRun) {    // O0 and run should not appear at the same time
-          runModeConflict = true;
-        } else {
-          runMode = RunMode::kCustomRun;
-          UpdateRunningExe(opt.Args());
-        }
-        break;
-      case kInFile: {
-        if (!Init(opt.Args())) {
-          return kErrorInitFail;
-        }
-        break;
-      }
-      case kHelpLevel:
-        helpLevel = static_cast<unsigned int>(std::stoul(opt.Args()));
-        break;
-      default:
-        break;
-    }
-  }
-  if (runModeConflict) {
-    LogInfo::MapleLogger(kLlErr) << "Cannot set auto mode and run mode at the same time!\n";
-    ret = kErrorInvalidParameter;
-  }
-  return ret;
-}
-
-std::unique_ptr<Action> MplOptions::DecideRunningPhasesByType(const InputInfo *const inputInfo,
-                                                              bool isMultipleFiles) {
-  InputFileType inputFileType = inputInfo->GetInputFileType();
-  std::unique_ptr<Action> currentAction = std::make_unique<Action>(kInputPhase, inputInfo);
-  std::unique_ptr<Action> newAction;
-
-  bool isNeedMapleComb = true;
-  bool isNeedMplcg = true;
-  bool isNeedAs = true;
-  switch (inputFileType) {
-    case InputFileType::kFileTypeC:
-    case InputFileType::kFileTypeCpp:
-      UpdateRunningExe(kBinNameClang);
-      newAction = std::make_unique<Action>(kBinNameClang, inputInfo, currentAction);
-      currentAction = std::move(newAction);
-      [[clang::fallthrough]];
-    case InputFileType::kFileTypeAst:
-      UpdateRunningExe(kBinNameCpp2mpl);
-      newAction = std::make_unique<Action>(kBinNameCpp2mpl, inputInfo, currentAction);
-      currentAction = std::move(newAction);
-      break;
-    case InputFileType::kFileTypeJar:
-      // fall-through
-    case InputFileType::kFileTypeClass:
-      UpdateRunningExe(kBinNameJbc2mpl);
-      newAction = std::make_unique<Action>(kBinNameJbc2mpl, inputInfo, currentAction);
-      currentAction = std::move(newAction);
-      isNeedAs = false;
-      break;
-    case InputFileType::kFileTypeDex:
-      UpdateRunningExe(kBinNameDex2mpl);
-      newAction = std::make_unique<Action>(kBinNameDex2mpl, inputInfo, currentAction);
-      currentAction = std::move(newAction);
-      isNeedAs = false;
-      break;
-    case InputFileType::kFileTypeMpl:
-      break;
-    case InputFileType::kFileTypeMeMpl:
-    case InputFileType::kFileTypeVtableImplMpl:
-      isNeedMapleComb = false;
-      break;
-    case InputFileType::kFileTypeS:
-      isNeedMplcg = false;
-      isNeedMapleComb = false;
-      break;
-    case InputFileType::kFileTypeBpl:
-      break;
-    case InputFileType::kFileTypeObj:
-      isNeedMplcg = false;
-      isNeedMapleComb = false;
-      isNeedAs = false;
-      break;
-    case InputFileType::kFileTypeNone:
-      return nullptr;
-      break;
-    default:
-      return nullptr;
-      break;
-  }
-
-  if (runMaplePhaseOnly == true) {
-    isNeedAs = false;
-  }
-
-  if (isNeedMapleComb) {
-    if (isMultipleFiles) {
-      selectedExes.push_back(kBinNameMapleCombWrp);
-      newAction = std::make_unique<Action>(kBinNameMapleCombWrp, inputInfo, currentAction);
-      currentAction = std::move(newAction);
-    } else {
-      selectedExes.push_back(kBinNameMapleComb);
-      newAction = std::make_unique<Action>(kBinNameMapleComb, inputInfo, currentAction);
-      currentAction = std::move(newAction);
-    }
-  }
-  if (isNeedMplcg && !isMultipleFiles) {
-    selectedExes.push_back(kBinNameMplcg);
-    runningExes.push_back(kBinNameMplcg);
-    newAction = std::make_unique<Action>(kBinNameMplcg, inputInfo, currentAction);
-    currentAction = std::move(newAction);
-  }
-
-  if (isNeedAs == true) {
-    UpdateRunningExe(kAsFlag);
-    newAction = std::make_unique<Action>(kAsFlag, inputInfo, currentAction);
-    currentAction = std::move(newAction);
-  }
-
-  if (!HasSetGenOnlyObj()) {
-    UpdateRunningExe(kLdFlag);
-    /* "Linking step" Action can have several inputActions.
-     * Each inputAction links to previous Actions to create the action tree.
-     * For linking step, inputActions are all assembly actions.
-     * Linking step Action is created outside this function because
-     * we must create all assembly actions (for all input files) before.
-     */
-  }
-
-  return currentAction;
-}
-
-ErrorCode MplOptions::DecideRunningPhases() {
-  ErrorCode ret = kErrorNoError;
-  std::vector<std::unique_ptr<Action>> linkActions;
-  std::unique_ptr<Action> lastAction;
-
-  bool isMultipleFiles = (inputInfos.size() > 1);
-
-  for (auto &inputInfo : inputInfos) {
-    CHECK_FATAL(inputInfo != nullptr, "InputInfo must be created!!");
-
-    lastAction = DecideRunningPhasesByType(inputInfo.get(), isMultipleFiles);
-
-    /* TODO: Add a message interface for correct exit with compilation error. And use it here
-     * instead of CHECK_FATAL.
-     */
-    CHECK_FATAL(lastAction != nullptr, "Incorrect input file type: %s",
-                inputInfo->GetInputFile().c_str());
-
-    if ((lastAction->GetTool() == kAsFlag && !HasSetGenOnlyObj()) ||
-        lastAction->GetTool() == kInputPhase) {
-      /* 1. For linking step, inputActions are all assembly actions;
-       * 2. If we try to link with maple driver, inputActions are all kInputPhase objects;
-       */
-      linkActions.push_back(std::move(lastAction));
-    } else {
-      rootActions.push_back(std::move(lastAction));
-    }
-  }
-
-  if (!linkActions.empty()) {
-    /* "a.out" is the default output file name - fix if it's needed  */
-    auto currentAction = std::make_unique<Action>(kLdFlag, linkActions, AllocateInputInfo("a.out"));
-    rootActions.push_back(std::move(currentAction));
-  }
-
-  return ret;
-}
-
-ErrorCode MplOptions::MFCreateActionByExe(const std::string &exe, std::unique_ptr<Action> &currentAction,
-                                          const InputInfo *const inputInfo, bool &wasWrpCombCompilerCreated) {
-  ErrorCode ret = kErrorNoError;
-
-  if (exe == kBinNameMe || exe == kBinNameMpl2mpl || exe == kBinNameMplcg) {
-    if (wasWrpCombCompilerCreated == false) {
-      auto newAction = std::make_unique<Action>(kBinNameMapleCombWrp, inputInfo, currentAction);
-      currentAction = std::move(newAction);
-      wasWrpCombCompilerCreated = true;
-    } else {
-      return ret;
-    }
-  }
-
-  else {
-    auto newAction = std::make_unique<Action>(exe, inputInfo, currentAction);
-    currentAction = std::move(newAction);
-  }
-
-  return ret;
-}
-
-ErrorCode MplOptions::SFCreateActionByExe(const std::string &exe, std::unique_ptr<Action> &currentAction,
-                                          const InputInfo *const inputInfo, bool &isCombCompiler) {
-  ErrorCode ret = kErrorNoError;
-
-  if (exe == kBinNameMe || exe == kBinNameMpl2mpl) {
-    if (isCombCompiler == false) {
-      auto newAction = std::make_unique<Action>(kBinNameMapleComb, inputInfo, currentAction);
-      currentAction = std::move(newAction);
-      isCombCompiler = true;
-    } else {
-      return ret;
-    }
-  }
-
-  else {
-    auto newAction = std::make_unique<Action>(exe, inputInfo, currentAction);
-    currentAction = std::move(newAction);
-  }
-
-  return ret;
-}
-
-ErrorCode MplOptions::DecideRunningPhases(const std::vector<std::string> &runExes) {
-  ErrorCode ret = kErrorNoError;
-
-  bool isMultipleFiles = (inputInfos.size() > 1);
-
-  for (auto &inputInfo : inputInfos) {
-    CHECK_FATAL(inputInfo != nullptr, "InputInfo must be created!!");
-    /* MplOption is owner of all InputInfos. MplOption is alive during compilation,
-     * so we can use raw pointer inside an Action.
-     */
-    const InputInfo *const rawInputInfo = inputInfo.get();
-
-    bool isCombCompiler = false;
-    bool wasWrpCombCompilerCreated = false;
-
-    auto currentAction = std::make_unique<Action>(kInputPhase, inputInfo.get());
-
-    for (const auto &exe : runExes) {
-      if (isMultipleFiles == true) {
-        ret = MFCreateActionByExe(exe, currentAction, rawInputInfo, wasWrpCombCompilerCreated);
-        if (ret != kErrorNoError) {
-          return ret;
-        }
-      } else {
-        ret = SFCreateActionByExe(exe, currentAction, rawInputInfo, isCombCompiler);
-        if (ret != kErrorNoError) {
-          return ret;
-        }
-      }
-    }
-
-    rootActions.push_back(std::move(currentAction));
-  }
-
-  return ret;
-}
-
-void MplOptions::DumpActionTree() const {
-  for (auto &rNode : rootActions) {
-    DumpActionTree(*rNode, 0);
-  }
-}
-
-void MplOptions::DumpActionTree(const Action &action, int indents) const {
-  for (const std::unique_ptr<Action> &a : action.GetInputActions()) {
-    DumpActionTree(*a, indents + 1);
-  }
-
-  if (indents != 0) {
-    LogInfo::MapleLogger() << "|";
-    /* print indents */
-    for (int i = 0; i < indents; ++i) {
-      LogInfo::MapleLogger() << "-";
-    }
-  }
-
-  if (action.GetTool() == kInputPhase) {
-    LogInfo::MapleLogger() << action.GetTool() << " " << action.GetInputFile() << '\n';
-  } else {
-    LogInfo::MapleLogger() << action.GetTool() << '\n';
-  }
-}
-
-ErrorCode MplOptions::CheckInputFileValidity() {
-  // Get input fileName
-  if (optionParser->GetNonOptionsCount() <= 0) {
-    return kErrorNoError;
-  }
-  std::ostringstream optionString;
-  const std::vector<std::string> &inputs = optionParser->GetNonOptions();
-  for (size_t i = 0; i < inputs.size(); ++i) {
-    if (i == 0) {
-      optionString << inputs[i];
-    } else {
-      optionString <<  "," << inputs[i];
-    }
-  }
-  if (!Init(optionString.str())) {
-    return kErrorInitFail;
-  }
-  return kErrorNoError;
-}
-
-ErrorCode MplOptions::CheckFileExits() {
-  ErrorCode ret = kErrorNoError;
-  if (inputFiles == "") {
-    LogInfo::MapleLogger(kLlErr) << "Forgot to input files?\n";
-    return ErrorCode::kErrorInitFail;
-  }
-  for (auto fileName : splitsInputFiles) {
-    std::ifstream infile;
-    infile.open(fileName);
-    if (infile.fail()) {
-      LogInfo::MapleLogger(kLlErr) << "Cannot open input file " << fileName << '\n';
-      ret = kErrorFileNotFound;
-      infile.close();
-      return ret;
-    }
-    infile.close();
-  }
-  return ret;
-}
-
-ErrorCode MplOptions::AddOption(const mapleOption::Option &option) {
-  if (!option.HasExtra()) {
-    if (option.GetExeName() == "driver") {
-      /* If it doesn't have extra options and it's a common option for driver,
-       * set this option in exeOptions as "driver"" to use this info in debug print.
-       */
-      exeOptions[option.GetExeName()].push_back(option);
-    }
-    return kErrorNoError;
-  }
-
-  for (const auto &exeName : option.GetExtras()) {
-
-    /* extras field in Descriptor allows to register an option in additional tool.
-     * If extras exeName == driver name ("driver"), it means that this option
-     * is registered outside the driver, but this option can be used by the driver.
-     * In this case the tool is set in Descriptor.exeName (not in Descriptor.extras).
-     * And Descriptor.extras=="driver" shows only that this option can be handled by the driver.
-     */
-    const std::string &exe = (exeName == "driver") ? option.GetExeName() : exeName;
-
-    auto iter = std::find(runningExes.begin(), runningExes.end(), exe);
-    if (iter == runningExes.end()) {
-      continue;
-    }
-    // For compilers, such as me, mpl2mpl
-    exeOptions[exe].push_back(option);
-  }
-  return kErrorNoError;
-}
-
-std::string MplOptions::GetCommonOptionsStr() const {
-  static DriverOptionIndex exclude[] = { kRun, kOption, kInFile, kMeOpt, kMpl2MplOpt, kMplcgOpt };
-
-  std::string driverOptions;
-  auto it = exeOptions.find("driver");
-  if (it != exeOptions.end()) {
-    for (const mapleOption::Option &opt : it->second) {
-      if (!(std::find(std::begin(exclude), std::end(exclude), opt.Index()) != std::end(exclude))) {
-        std::string prefix = opt.GetPrefix();
-        auto connectSym = !opt.Args().empty() ? "=" : "";
-        driverOptions += " " + prefix + opt.OptionKey() + connectSym + opt.Args();
-      }
-    }
-  }
-
-  return driverOptions;
-}
-
-InputInfo *MplOptions::AllocateInputInfo(const std::string &inputFile) {
-  auto inputInfo = std::make_unique<InputInfo>(inputFile);
-  InputInfo *ret = inputInfo.get();
-
-  inputInfos.push_back(std::move(inputInfo));
-
-  /* inputInfo continue to exist in inputInfos vector of unique_ptr so we can return raw pointer */
-  return ret;
-}
-
-bool MplOptions::Init(const std::string &inputFile) {
-  if (StringUtils::Trim(inputFile).empty()) {
-    return false;
-  }
-  inputFiles = inputFile;
-  StringUtils::Split(inputFile, splitsInputFiles, ',');
-
-  /* inputInfo describes each input file for driver */
-  for (auto &inFile : splitsInputFiles) {
-    inputInfos.push_back(std::make_unique<InputInfo>(inFile));
-  }
-
-  return true;
-}
-
-ErrorCode MplOptions::AppendCombOptions(MIRSrcLang srcLang) {
-  ErrorCode ret = kErrorNoError;
-  if (runMode == RunMode::kCustomRun) {
-    return ret;
-  }
-  if (optimizationLevel == kO0) {
-    ret = AppendDefaultOptions(kBinNameMe, kMeDefaultOptionsO0, sizeof(kMeDefaultOptionsO0) / sizeof(MplOption));
-    if (ret != kErrorNoError) {
-      return ret;
-    }
-    if (srcLang != kSrcLangC) {
-      ret = AppendDefaultOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO0,
-                                 sizeof(kMpl2MplDefaultOptionsO0) / sizeof(MplOption));
-    } else {
-      ret = AppendDefaultOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO0ForC,
-                                 sizeof(kMpl2MplDefaultOptionsO0ForC) / sizeof(MplOption));
-    }
-
-    if (ret != kErrorNoError) {
-      return ret;
-    }
-  } else if (optimizationLevel == kO2) {
-    if (isWithIpa) {
-      UpdateRunningExe(kBinNameMplipa);
-    }
-    if (optForSize) {
-      if (srcLang == kSrcLangJava) {
-        return kErrorNotImplement;
-      }
-      ret = AppendDefaultOptions(kBinNameMe, kMeDefaultOptionsOs,
-                                 sizeof(kMeDefaultOptionsOs) / sizeof(MplOption));
-      if (ret != kErrorNoError) {
-        return ret;
-      }
-      ret = AppendDefaultOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsOs,
-                                 sizeof(kMpl2MplDefaultOptionsOs) / sizeof(MplOption));
-    } else {
-      if (srcLang != kSrcLangC) {
-        ret = AppendDefaultOptions(kBinNameMe, kMeDefaultOptionsO2,
-                                   sizeof(kMeDefaultOptionsO2) / sizeof(MplOption));
-        if (ret != kErrorNoError) {
-          return ret;
-        }
-        ret = AppendDefaultOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO2,
-                                   sizeof(kMpl2MplDefaultOptionsO2) / sizeof(MplOption));
-      } else {
-        ret = AppendDefaultOptions(kBinNameMe, kMeDefaultOptionsO2ForC,
-                                   sizeof(kMeDefaultOptionsO2ForC) / sizeof(MplOption));
-        if (ret != kErrorNoError) {
-          return ret;
-        }
-        ret = AppendDefaultOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO2ForC,
-                                   sizeof(kMpl2MplDefaultOptionsO2ForC) / sizeof(MplOption));
-      }
-    }
-    if (ret != kErrorNoError) {
-      return ret;
-    }
-  }
-
-  return ret;
-}
-
-ErrorCode MplOptions::AppendMplcgOptions(MIRSrcLang srcLang) {
-  ErrorCode ret = kErrorNoError;
-  if (runMode == RunMode::kCustomRun) {
-    return ret;
-  }
-  if (optimizationLevel == kO0) {
-    if (srcLang != kSrcLangC) {
-      ret = AppendDefaultOptions(kBinNameMplcg, kMplcgDefaultOptionsO0,
-                                 sizeof(kMplcgDefaultOptionsO0) / sizeof(MplOption));
-    } else {
-      ret = AppendDefaultOptions(kBinNameMplcg, kMplcgDefaultOptionsO0ForC,
-                                 sizeof(kMplcgDefaultOptionsO0ForC) / sizeof(MplOption));
-    }
-  } else if (optimizationLevel == kO2) {
-    if (optForSize) {
-      if (srcLang == kSrcLangJava) {
-        return kErrorNotImplement;
-      }
-      ret = AppendDefaultOptions(kBinNameMplcg, kMplcgDefaultOptionsOs,
-                                 sizeof(kMplcgDefaultOptionsOs) / sizeof(MplOption));
-    } else {
-      if (srcLang != kSrcLangC) {
-        ret = AppendDefaultOptions(kBinNameMplcg, kMplcgDefaultOptionsO2,
-                                   sizeof(kMplcgDefaultOptionsO2) / sizeof(MplOption));
-      } else {
-        ret = AppendDefaultOptions(kBinNameMplcg, kMplcgDefaultOptionsO2ForC,
-                                   sizeof(kMplcgDefaultOptionsO2ForC) / sizeof(MplOption));
-      }
-    }
-  }
-  if (ret != kErrorNoError) {
-    return ret;
-  }
-
-  return ret;
-}
-
-void MplOptions::DumpAppendedOptions(const std::string &exeName,
-                                     const MplOption mplOptions[], unsigned int length) const {
-  LogInfo::MapleLogger() << exeName << " Default Options: ";
-  for (size_t i = 0; i < length; ++i) {
-    LogInfo::MapleLogger() << mplOptions[i].GetKey() << " "
-                           << mplOptions[i].GetValue() << " ";
-  }
-  LogInfo::MapleLogger() << "\n";
-
-  auto &exeOption = exeOptions.at(exeName);
-  LogInfo::MapleLogger() << exeName << " Extra Options: ";
-  for (auto &opt : exeOption) {
-    LogInfo::MapleLogger() << opt.OptionKey() << " "
-                           << opt.Args() << " ";
-  }
-  LogInfo::MapleLogger() << "\n";
-}
-
-ErrorCode MplOptions::AppendDefaultOptions(const std::string &exeName, MplOption mplOptions[], unsigned int length) {
-  auto &exeOption = exeOptions[exeName];
-
-  if (HasSetDebugFlag()) {
-    DumpAppendedOptions(exeName, mplOptions, length);
-  }
-
-  for (size_t i = 0; i < length; ++i) {
-    mplOptions[i].SetValue(FileUtils::AppendMapleRootIfNeeded(mplOptions[i].GetNeedRootPath(), mplOptions[i].GetValue(),
-                                                              exeFolder));
-    bool ret = optionParser->SetOption(mplOptions[i].GetKey(), mplOptions[i].GetValue(), exeName, exeOption);
-    if (!ret) {
-      return kErrorInvalidParameter;
-    }
-  }
-  auto iter = std::find(runningExes.begin(), runningExes.end(), exeName);
-  if (iter == runningExes.end()) {
-    runningExes.push_back(exeName);
-  }
-  return kErrorNoError;
-}
-
-ErrorCode MplOptions::UpdatePhaseOption(const std::string &args, const std::string &exeName) {
-
-  const std::string *exe = &exeName;
-  /* TODO: maplecomb combines mpl2mpl and me tools, this if-hack to detect them. Fix it. */
-  if (exeName == kBinNameMe || exeName == kBinNameMpl2mpl) {
-    exe = (inputInfos.size() > 1) ? &kBinNameMapleCombWrp : &kBinNameMapleComb;
-  }
-
-  auto iter = std::find(selectedExes.begin(), selectedExes.end(), *exe);
-  if (iter == runningExes.end()) {
-    LogInfo::MapleLogger(kLlErr) << "Cannot find phase " << exeName << '\n';
-    return kErrorExit;
-  }
-
-  std::vector<Arg> inputArgs;
-  StringUtils::SplitSV(args, inputArgs, ' ');
-
-  auto &exeOption = exeOptions[exeName];
-  ErrorCode ret = optionParser->HandleInputArgs(inputArgs, exeName, exeOption);
-  if (ret != kErrorNoError) {
-    return ret;
-  }
-  return ret;
-}
-
-ErrorCode MplOptions::UpdateExtraOptionOpt(const std::string &args) {
-  std::vector<std::string> temp;
-#ifdef _WIN32
-  // Paths on windows may contain such string like "C:/", then it would be confused with the split symbol ":"
-  StringUtils::Split(args, temp, ';');
-#else
-  StringUtils::Split(args, temp, ':');
-#endif
-  if (temp.size() != runningExes.size()) {
-    // parameter not match ignore
-    LogInfo::MapleLogger(kLlErr) << "The --run and --option are not matched, please check them."
-                                 << "(Too many or too few ':'?)"
-                                 << '\n';
-    return kErrorInvalidParameter;
-  }
-  auto settingExe = runningExes.begin();
-  for (const auto &tempIt : temp) {
-    ErrorCode ret = UpdatePhaseOption(tempIt, *settingExe);
-    if (ret != kErrorNoError) {
-      return ret;
-    }
-    ++settingExe;
-  }
-  return kErrorNoError;
-}
-
-void MplOptions::UpdateRunningExe(const std::string &args) {
-  std::vector<std::string> results;
-  StringUtils::Split(args, results, ':');
-  for (size_t i = 0; i < results.size(); ++i) {
-    auto iter = std::find(runningExes.begin(), runningExes.end(), results[i]);
-    if (iter == runningExes.end()) {
-      runningExes.push_back(results[i]);
-      selectedExes.push_back(results[i]);
-    }
-  }
-}
-
-std::string MplOptions::GetInputFileNameForPrint(const Action * const action) const {
-  if (!runningExes.empty()) {
-    if (runningExes[0] == kBinNameMe || runningExes[0] == kBinNameMpl2mpl
-        || runningExes[0] == kBinNameMplcg) {
-      return inputFiles;
-    }
-  }
-
-  if (action == nullptr) {
-    return GetInputFiles();
-  }
-
-  if (action->GetInputFileType() == InputFileType::kFileTypeVtableImplMpl) {
-    return action->GetFullOutputName() + ".VtableImpl.mpl";
-  }
-  if (action->GetInputFileType() == InputFileType::kFileTypeBpl) {
-    return action->GetFullOutputName() + ".bpl";
-  }
-  return action->GetFullOutputName() + ".mpl";
-}
-
-void MplOptions::PrintCommand(const Action * const action) {
-  if (hasPrinted) {
-    return;
-  }
-  std::ostringstream optionStr;
-  if (runMode == RunMode::kAutoRun) {
-    if (optimizationLevel == kO0) {
-      optionStr << " -O0";
-    } else if (optimizationLevel == kO2) {
-      if (optForSize) {
-        optionStr << " -Os";
-      } else {
-        optionStr << " -O2";
-      }
-    }
-
-    std::string driverOptions = GetCommonOptionsStr();
-    auto inputs = (action == nullptr) ? GetInputFiles() : GetInputFileNameForPrint(action);
-
-    LogInfo::MapleLogger() << "Starting:" << exeFolder << "maple " << optionStr.str() << " "
-                           << printExtraOptStr.str() << driverOptions << " " << inputs << '\n';
-  }
-  if (runMode == RunMode::kCustomRun) {
-    PrintDetailCommand(action, true);
-  }
-  hasPrinted = true;
-}
-
-void MplOptions::connectOptStr(std::string &optionStr, const std::string &exeName, bool &firstComb,
-                               std::string &runStr) {
-  std::string connectSym = "";
-  if (exeOptions.find(exeName) != exeOptions.end()) {
-    if (!firstComb) {
-      runStr += (":" + exeName);
-      optionStr += ":";
-    } else {
-      runStr += exeName;
-      firstComb = false;
-    }
-    auto it = exeOptions.find(exeName);
-    for (const mapleOption::Option &opt : it->second) {
-      connectSym = !opt.Args().empty() ? "=" : "";
-      auto prefixStr = opt.GetPrefix();
-      optionStr += (" " + prefixStr + opt.OptionKey() + connectSym + opt.Args());
-    }
-  }
-}
-
-void MplOptions::PrintDetailCommand(const Action * const action, bool isBeforeParse) {
-  if (exeOptions.find(kBinNameMe) == exeOptions.end() && exeOptions.find(kBinNameMpl2mpl) == exeOptions.end()
-      && exeOptions.find(kBinNameMplcg) == exeOptions.end()) {
-    return;
-  }
-  std::string runStr = "--run=";
-  std::string optionStr;
-  optionStr += "--option=\"";
-  bool firstComb = true;
-  connectOptStr(optionStr, kBinNameMe, firstComb, runStr);
-  connectOptStr(optionStr, kBinNameMpl2mpl, firstComb, runStr);
-  connectOptStr(optionStr, kBinNameMplcg, firstComb, runStr);
-  optionStr += "\"";
-
-  std::string driverOptions = GetCommonOptionsStr();
-  auto inputs = (action == nullptr) ? GetInputFiles() : GetInputFileNameForPrint(action);
-
-  if (isBeforeParse) {
-    LogInfo::MapleLogger() << "Starting:" << exeFolder << "maple " << runStr << " " << optionStr << " "
-                           << printExtraOptStr.str() << driverOptions << " " << inputs << '\n';
-  } else {
-    LogInfo::MapleLogger() << "Finished:" << exeFolder << "maple " << runStr << " " << optionStr << " "
-                           << driverOptions << " " << inputs << '\n';
-  }
-}
-} // namespace maple
diff --git a/src/mapleall/maple_driver/src/mplcg_compiler.cpp b/src/mapleall/maple_driver/src/mplcg_compiler.cpp
index bbbb200323b12c7a80db45f959e5b9a1b085617f..24e02efdaf930eee8274106ed52f64e8f7fc8a19 100644
--- a/src/mapleall/maple_driver/src/mplcg_compiler.cpp
+++ b/src/mapleall/maple_driver/src/mplcg_compiler.cpp
@@ -15,6 +15,9 @@
 #include <cstdlib>
 #include "compiler.h"
 #include "default_options.def"
+#include "driver_options.h"
+#include "error_code.h"
+#include "maple_driver.h"
 #include "mpl_logging.h"
 #include "mpl_timer.h"
 #include "driver_runner.h"
@@ -23,42 +26,11 @@ namespace maple {
 using namespace maplebe;
 using namespace mapleOption;
 
-DefaultOption MplcgCompiler::GetDefaultOptions(const MplOptions &options, const Action&) const {
-  uint32_t len = 0;
-  MplOption *kMplcgDefaultOptions = nullptr;
-
-  if (options.GetOptimizationLevel() == kO0 && options.HasSetDefaultLevel()) {
-    len = sizeof(kMplcgDefaultOptionsO0) / sizeof(MplOption);
-    kMplcgDefaultOptions = kMplcgDefaultOptionsO0;
-  } else if (options.GetOptimizationLevel() == kO2 && options.HasSetDefaultLevel()) {
-    len = sizeof(kMplcgDefaultOptionsO2) / sizeof(MplOption);
-    kMplcgDefaultOptions = kMplcgDefaultOptionsO2;
-  }
-
-  if (kMplcgDefaultOptions == nullptr) {
-    return DefaultOption();
-  }
-
-  DefaultOption defaultOptions = { std::make_unique<MplOption[]>(len), len };
-  for (uint32_t i = 0; i < len; ++i) {
-    defaultOptions.mplOptions[i] = kMplcgDefaultOptions[i];
-  }
-
-  for (uint32_t i = 0; i < defaultOptions.length; ++i) {
-    defaultOptions.mplOptions[i].SetValue(
-        FileUtils::AppendMapleRootIfNeeded(defaultOptions.mplOptions[i].GetNeedRootPath(),
-                                           defaultOptions.mplOptions[i].GetValue(),
-                                           options.GetExeFolder()));
-  }
-  return defaultOptions;
-}
-
 const std::string &MplcgCompiler::GetBinName() const {
   return kBinNameMplcg;
 }
 
-std::string MplcgCompiler::GetInputFile(const MplOptions &, const Action &action,
-                                        const MIRModule *md) const {
+std::string MplcgCompiler::GetInputFile(const Action &action, const MIRModule *md) const {
   if (action.IsItFirstRealAction()) {
     return action.GetInputFile();
   }
@@ -74,62 +46,106 @@ std::string MplcgCompiler::GetInputFile(const MplOptions &, const Action &action
   return action.GetOutputFolder() + outputName + ".VtableImpl.mpl";
 }
 
-void MplcgCompiler::SetOutputFileName(const MplOptions &options, const Action &action, const MIRModule &md) {
+void MplcgCompiler::SetOutputFileName(const Action &action, const MIRModule &md) {
   if (md.GetSrcLang() == kSrcLangC) {
     baseName = action.GetFullOutputName();
   } else {
-    baseName = action.GetOutputFolder() + FileUtils::GetFileName(GetInputFile(options, action, &md), false);
+    baseName = action.GetOutputFolder() + FileUtils::GetFileName(GetInputFile(action, &md), false);
   }
   outputFile = baseName + ".s";
 }
 
-void MplcgCompiler::PrintMplcgCommand(const MplOptions &options, const Action &action,
-                                      const MIRModule &md) const {
+void MplcgCompiler::PrintMplcgCommand(const Action &action, const MIRModule &md) const {
+  auto &drv = MplDriver::GetMplDriver();
+
   std::string runStr = "--run=";
   std::string optionStr = "--option=\"";
   std::string connectSym = "";
-  if (options.GetExeOptions().find(kBinNameMplcg) != options.GetExeOptions().end()) {
+  if (drv.GetExeOptions().find(kBinNameMplcg) != drv.GetExeOptions().end()) {
     runStr += "mplcg";
-    auto it = options.GetExeOptions().find(kBinNameMplcg);
-    if (it == options.GetExeOptions().end()) {
+    auto it = drv.GetExeOptions().find(kBinNameMplcg);
+    if (it == drv.GetExeOptions().end()) {
       return;
     }
-    for (const mapleOption::Option &opt : it->second) {
-      connectSym = !opt.Args().empty() ? "=" : "";
-      auto prefixStr = opt.GetPrefix();
-      optionStr += (" " + prefixStr + opt.OptionKey() + connectSym + opt.Args());
+    for (auto &opt : it->second) {
+      optionStr += (" " + opt);
     }
   }
   optionStr += "\"";
 
-  std::string driverOptions = options.GetCommonOptionsStr();
-
-  LogInfo::MapleLogger() << "Starting:" << options.GetExeFolder() << "maple " << runStr << " " << optionStr << " "
-                         << driverOptions << " --infile " << GetInputFile(options, action, &md) << '\n';
+  std::string driverOptions = GetCommonOptionsStr(extraExclude);
+  LogInfo::MapleLogger() << "Starting:" << drv.GetExeFolder() << "maple "
+                         << runStr << " " << optionStr << " " << driverOptions
+                         << " --infile " << GetInputFile(action, &md) << '\n';
 }
 
-ErrorCode MplcgCompiler::MakeCGOptions(const MplOptions &options) {
-  auto it = std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(), kBinNameMplcg);
-  if (it == options.GetRunningExes().end()) {
-    return kErrorNoError;
+ErrorCode MplcgCompiler::AppendMplcgOptions(MIRSrcLang srcLang) {
+  ErrorCode ret = kErrorNoError;
+  auto &drv = MplDriver::GetMplDriver();
+
+  if (opts::o0) {
+    if (srcLang != kSrcLangC) {
+      ret = drv.UpdateExeOptions(kBinNameMplcg, kMplcgDefaultOptionsO0,
+                                 sizeof(kMplcgDefaultOptionsO0) / sizeof(MplOption));
+    } else {
+      ret = drv.UpdateExeOptions(kBinNameMplcg, kMplcgDefaultOptionsO0ForC,
+                                 sizeof(kMplcgDefaultOptionsO0ForC) / sizeof(MplOption));
+    }
+  } else if (opts::o2) {
+    if (srcLang != kSrcLangC) {
+      ret = drv.UpdateExeOptions(kBinNameMplcg, kMplcgDefaultOptionsO2,
+                                 sizeof(kMplcgDefaultOptionsO2) / sizeof(MplOption));
+    } else {
+      ret = drv.UpdateExeOptions(kBinNameMplcg, kMplcgDefaultOptionsO2ForC,
+                                 sizeof(kMplcgDefaultOptionsO2ForC) / sizeof(MplOption));
+    }
+  } else if (opts::os) {
+    if (srcLang == kSrcLangJava) {
+      return kErrorNotImplement;
+    }
+    ret = drv.UpdateExeOptions(kBinNameMplcg, kMplcgDefaultOptionsOs,
+                               sizeof(kMplcgDefaultOptionsOs) / sizeof(MplOption));
   }
+
+  if (ret != kErrorNoError) {
+    return ret;
+  }
+
+  return ret;
+}
+
+ErrorCode MplcgCompiler::MakeCGOptions() {
+  auto &drv = MplDriver::GetMplDriver();
   CGOptions &cgOption = CGOptions::GetInstance();
   cgOption.SetOption(CGOptions::kDefaultOptions);
+
 #if DEBUG
   /* for convinence .loc is generated by default for debug maple compiler */
   cgOption.SetOption(CGOptions::kWithLoc);
 #endif
   /* use maple flags to set cg flags */
-  if (options.WithDwarf()) {
+  if (opts::withDwarf) {
     cgOption.SetOption(CGOptions::kWithDwarf);
   }
   cgOption.SetGenerateFlags(CGOptions::kDefaultGflags);
-  auto itOpt = options.GetExeOptions().find(kBinNameMplcg);
-  if (itOpt == options.GetExeOptions().end()) {
-    LogInfo::MapleLogger() << "no mplcg input options\n";
-    return kErrorCompileFail;
+
+  auto itOpt = drv.GetExeOptions().find(kBinNameMplcg);
+  if (itOpt != drv.GetExeOptions().end()) {
+    const auto &cgOptions = itOpt->second;
+    const std::deque<std::string_view> strCgOptions(cgOptions.begin(), cgOptions.end());
+    cl::CommandLine::GetCommandLine().HandleInputArgs(strCgOptions, cgCategory);
+  } else {
+    cl::CommandLine::GetCommandLine().HandleInputArgs({}, cgCategory);
+  }
+
+  for (auto &arg : cl::CommandLine::GetCommandLine().badCLArgs) {
+    if (!FileUtils::IsFileExists(arg.first)) {
+      LogInfo::MapleLogger() << "Unknown option for mpl2mpl tool: " << arg.first << "\n";
+      return kErrorInvalidParameter;
+    }
   }
-  bool result = cgOption.SolveOptions(itOpt->second, options.HasSetDebugFlag());
+
+  bool result = cgOption.SolveOptions(opts::debug);
   if (result == false) {
     LogInfo::MapleLogger() << "Meet error mplcg options\n";
     return kErrorCompileFail;
@@ -137,12 +153,12 @@ ErrorCode MplcgCompiler::MakeCGOptions(const MplOptions &options) {
   return kErrorNoError;
 }
 
-ErrorCode MplcgCompiler::GetMplcgOptions(MplOptions &options, const Action &action,
+ErrorCode MplcgCompiler::GetMplcgOptions(const Action &action,
                                          const MIRModule *theModule) {
   ErrorCode ret;
-  if (options.GetRunMode() == kAutoRun) {
+  if (MplDriver::GetMplDriver().GetRunMode() == kAutoRun) {
     if (theModule == nullptr) {
-      std::string fileName = GetInputFile(options, action, theModule);
+      std::string fileName = GetInputFile(action, theModule);
       MIRModule module(fileName);
       std::unique_ptr<MIRParser> theParser;
       theParser.reset(new MIRParser(module));
@@ -151,39 +167,42 @@ ErrorCode MplcgCompiler::GetMplcgOptions(MplOptions &options, const Action &acti
       if (!parsed) {
         return kErrorCompileFail;
       }
-      ret = options.AppendMplcgOptions(srcLang);
+      ret = AppendMplcgOptions(srcLang);
       if (ret != kErrorNoError) {
         return kErrorCompileFail;
       }
     } else {
-      ret = options.AppendMplcgOptions(theModule->GetSrcLang());
+      ret = AppendMplcgOptions(theModule->GetSrcLang());
       if (ret != kErrorNoError) {
         return kErrorCompileFail;
       }
     }
   }
 
-  ret = MakeCGOptions(options);
+  ret = MakeCGOptions();
   return ret;
 }
 
-ErrorCode MplcgCompiler::Compile(MplOptions &options, const Action &action,
+ErrorCode MplcgCompiler::Compile(const Action &action,
                                  std::unique_ptr<MIRModule> &theModule) {
-  ErrorCode ret = GetMplcgOptions(options, action, theModule.get());
+  ErrorCode ret = GetMplcgOptions(action, theModule.get());
   if (ret != kErrorNoError) {
     return kErrorCompileFail;
   }
   CGOptions &cgOption = CGOptions::GetInstance();
-  std::string fileName = GetInputFile(options, action, theModule.get());
+  std::string fileName = GetInputFile(action, theModule.get());
   bool fileRead = true;
   if (theModule == nullptr) {
     MPLTimer timer;
     timer.Start();
     fileRead = false;
     theModule = std::make_unique<MIRModule>(fileName);
-    theModule->SetWithMe(
-        std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(),
-                  kBinNameMe) != options.GetRunningExes().end());
+
+    /* NOTE: We can use action to find me tool in compilations steps */
+    auto &drv = MplDriver::GetMplDriver();
+    theModule->SetWithMe(std::find(drv.GetTools().begin(),
+                                   drv.GetTools().end(),
+                                   kBinNameMe) != drv.GetTools().end());
     if (action.GetInputFileType() != kFileTypeBpl &&
         action.GetInputFileType() != kFileTypeMbc &&
         action.GetInputFileType() != kFileTypeLmbc) {
@@ -212,17 +231,19 @@ ErrorCode MplcgCompiler::Compile(MplOptions &options, const Action &action,
     timer.Stop();
     LogInfo::MapleLogger() << "Mplcg Parser consumed " << timer.ElapsedMilliseconds() << "ms\n";
   }
-  SetOutputFileName(options, action, *theModule);
+  SetOutputFileName(action, *theModule);
   theModule->SetInputFileName(fileName);
   LogInfo::MapleLogger() << "Starting mplcg\n";
-  DriverRunner runner(theModule.get(), options.GetSelectedExes(), action.GetInputFileType(), fileName,
-                      options.WithDwarf(), fileRead, options.HasSetTimePhases());
-  if (options.HasSetDebugFlag()) {
-    PrintMplcgCommand(options, action, *theModule);
+  DriverRunner runner(theModule.get(), action.internalTools,
+                      action.GetInputFileType(), fileName,
+                      opts::withDwarf, fileRead, opts::timePhase);
+  if (opts::debug) {
+    PrintMplcgCommand(action, *theModule);
   }
   runner.SetPrintOutExe(kBinNameMplcg);
   runner.SetCGInfo(&cgOption, fileName);
   runner.ProcessCGPhase(outputFile, baseName);
+
   return kErrorNoError;
 }
 }  // namespace maple
diff --git a/src/mapleall/maple_driver/src/option_parser.cpp b/src/mapleall/maple_driver/src/option_parser.cpp
deleted file mode 100644
index d969d5be651a8ed87fbc9995a2853210de1407c2..0000000000000000000000000000000000000000
--- a/src/mapleall/maple_driver/src/option_parser.cpp
+++ /dev/null
@@ -1,466 +0,0 @@
-/*
- * Copyright (c) [2020] Huawei Technologies Co.,Ltd.All rights reserved.
- *
- * OpenArkCompiler is licensed under Mulan PSL v2.
- * You can use this software according to the terms and conditions of the Mulan PSL v2.
- * You may obtain a copy of Mulan PSL v2 at:
- *
- *     http://license.coscl.org.cn/MulanPSL2
- *
- * 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 v2 for more details.
- */
-#include "option_parser.h"
-#include <regex>
-#include <iostream>
-#include <cstring>
-#include <string>
-#include <string_view>
-#include "error_code.h"
-#include "mpl_logging.h"
-#include "driver_option_common.h"
-#include "option_descriptor.h"
-
-using namespace maple;
-using namespace mapleOption;
-
-namespace mapleOption {
-
-static std::map<OptionPrefixType, std::string_view> prefixInfo = {
-  {shortOptPrefix, "-"},
-  {longOptPrefix, "--"},
-  {undefinedOpt, ""}
-};
-
-OptionPrefixType DetectOptPrefix(std::string_view opt) {
-  if (opt.substr(0, 2) == "--") {
-    return longOptPrefix;
-  } else if (opt.substr(0, 1) == "-") {
-    return shortOptPrefix;
-  } else {
-    return undefinedOpt;
-  }
-}
-
-/* NOTE: return value will be a part of input string_view */
-std::pair<maple::ErrorCode, std::string_view> ExtractKey(std::string_view opt,
-                                                         OptionPrefixType prefix) {
-  auto optStr = prefixInfo.find(prefix);
-  ASSERT(optStr != prefixInfo.end(), "Incorrect prefix");
-
-  size_t index = optStr->second.size();
-  if (opt.size() <= index) {
-    return std::make_pair(kErrorInvalidParameter, opt);
-  }
-
-  if (opt.substr(0, index) != optStr->second) {
-    return std::make_pair(kErrorInvalidParameter, opt);
-  }
-
-  auto key = opt.substr(index);
-  return {kErrorNoError, key};
-}
-
-}
-
-static bool IsOptionForCurrentTool(const Descriptor &desc, const std::string_view &exeName) {
-  if (desc.exeName == exeName) {
-    return true;
-  }
-
-  /* external tool can register options for the driver with "extras" field in the descriptor.
-   * As example: mplcg registers --omit-frame-pointer, --fpic and another options with this way.
-   * So if it can find "driver" in "extras", it's possible option for the driver.
-   */
-  auto &extra = desc.extras;
-  if (exeName == "driver" &&
-      (std::find(std::begin(extra), std::end(extra), exeName) != std::end(extra))) {
-    return true;
-  }
-
-  return false;
-}
-
-void OptionParser::InsertExtraUsage(const Descriptor &usage) {
-  unsigned int index = 0;
-  while (index < kMaxExtraOptions && index < usage.extras.size()) {
-    Descriptor tempUsage = { usage.index,
-                             usage.type,
-                             usage.shortOption,
-                             usage.longOption,
-                             usage.enableBuildType,
-                             usage.checkPolicy,
-                             usage.help,
-                             usage.extras[index],
-                             {} };
-    if (usage.shortOption != "") {
-      InsertOption(usage.shortOption, tempUsage, shortOptPrefix);
-    }
-    if (usage.longOption != "") {
-      InsertOption(usage.longOption, tempUsage, longOptPrefix);
-    }
-    rawUsages.push_back(tempUsage);
-    ++index;
-  }
-}
-
-void OptionParser::CreateNoOption(const Descriptor &usage) {
-  std::string longOpt = "";
-  std::string shortOpt = "";
-  std::string newHelpInfo = "";
-  if (usage.shortOption != "") {
-    std::ostringstream optionString;
-    optionString << "no-" << usage.shortOption; // Generate short option: no-opt
-    shortOpt = optionString.str();
-  }
-  if (usage.longOption != "") {
-    std::ostringstream optionString;
-    optionString << "no-" << usage.longOption; // Generate long option: no-opt
-    longOpt = optionString.str();
-  }
-  Descriptor tempUsage = { usage.index,
-                           kDisable, // Change to disable
-                           (usage.shortOption != "") ? shortOpt : "",
-                           (usage.longOption != "") ? longOpt : "",
-                           usage.enableBuildType,
-                           usage.checkPolicy,
-                           "",
-                           usage.exeName,
-                           usage.extras };
-  if (usage.shortOption != "") {
-    InsertOption(shortOpt, tempUsage, shortOptPrefix);
-  }
-  if (usage.longOption != "") {
-    InsertOption(longOpt, tempUsage, longOptPrefix);
-  }
-  // Insert usage for extra options
-  InsertExtraUsage(tempUsage);
-}
-
-void OptionParser::RegisteUsages(const MapleDriverOptionBase &base) {
-  for (auto &usage : base.GetUsageVec()) {
-    if (usage.help == "") {
-      continue;
-    }
-    rawUsages.push_back(usage);
-    if (usage.shortOption != "") {
-      InsertOption(usage.shortOption, usage, shortOptPrefix);
-    }
-    if (usage.longOption != "") {
-      InsertOption(usage.longOption, usage, longOptPrefix);
-    }
-    // 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 != ""; ++i) {
-    rawUsages.push_back(usage[i]);
-    if (usage[i].shortOption != "") {
-      InsertOption(usage[i].shortOption, usage[i], shortOptPrefix);
-    }
-    if (usage[i].longOption != "") {
-      InsertOption(usage[i].longOption, usage[i], longOptPrefix);
-    }
-    // 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 std::string &helpType, const uint32_t helpLevel) const {
-  for (size_t i = 0; i < rawUsages.size(); ++i) {
-
-    auto contains = [](const auto &container, const auto &data) {
-      return (std::find(std::begin(container), std::end(container), data) != container.end());
-    };
-    bool isOptionForCurrentTool = (rawUsages[i].exeName == helpType ||
-                                   (helpType == "driver" && contains(rawUsages[i].extras, helpType)));
-
-    if (rawUsages[i].help != "" && rawUsages[i].IsEnabledForCurrentBuild() && isOptionForCurrentTool) {
-      if (helpLevel != kBuildTypeDefault &&
-          (rawUsages[i].enableBuildType != helpLevel && rawUsages[i].enableBuildType != kBuildTypeAll)) {
-        continue;
-      }
-      LogInfo::MapleLogger() << rawUsages[i].help << '\n';
-    }
-  }
-}
-
-bool OptionParser::HandleKeyValue(const Arg &arg, std::deque<mapleOption::Option> &inputOption,
-                                  const std::string &exeName) {
-  auto &key = arg.key;
-  auto &value = arg.val;
-
-  if (key.empty()) {
-    LogInfo::MapleLogger(kLlErr) << "Cannot recognize " << value << '\n';
-    return false;
-  }
-  auto IsValueValid = [&]()-> bool {
-    if (value.empty()) {
-      LogInfo::MapleLogger(kLlErr) << "Option " << key << " requires an argument." << '\n';
-      return false;
-    }
-    return true;
-  };
-  size_t count = usages.count(key);
-  auto item = usages.find(key);
-
-  /* Skip option if:
-   * 1. Prefix is not matched.
-   * 2. Option is registered for different tool. Descriptor.exeName shows a tool
-   *    registering for current option.
-   *    Special case: extras field in Descriptor allows to register an option in additional tool.
-   *    If extras exeName == driver name ("driver"), it means that this option
-   *    is registered outside the driver, but this option can be used by the driver.
-   *    It checks here too.
-   */
-
-  /* TODO: Add prefix type check (item->second.type != arg.prefixType) after CI tests reworking.
-   * CI tests must use correct prefixes. */
-  while (count > 0 && (IsOptionForCurrentTool(item->second.desc, exeName) != true)) {
-    ++item;
-    --count;
-  }
-  if (count == 0) {
-    LogInfo::MapleLogger(kLlErr) << "Unknown Option: " << key << '\n';
-    return false;
-  }
-  switch (item->second.desc.checkPolicy) {
-    case kArgCheckPolicyUnknown:
-      LogInfo::MapleLogger(kLlErr) << "Unknown option " << key << '\n';
-      return false;
-    case kArgCheckPolicyNone:
-    case kArgCheckPolicyOptional:
-      break;
-    case kArgCheckPolicyRequired: {
-      if (!IsValueValid()) {
-        return false;
-      }
-      break;
-    }
-    case kArgCheckPolicyNumeric: {
-      if (!IsValueValid()) {
-        return false;
-      }
-      std::regex rx("^(-|)[0-9]+\\b");
-      bool isNumeric = std::regex_match(value.begin(), value.end(), rx);
-      if (!isNumeric) {
-        LogInfo::MapleLogger(kLlErr) << "Option " << key << " requires a numeric argument." << '\n';
-        return false;
-      }
-      break;
-    }
-    default:
-      break;
-  }
-  inputOption.emplace_back(item->second.desc, std::string(key), std::string(value),
-                           arg.prefixType, arg.isEqualOpt);
-  return true;
-}
-
-bool OptionParser::SetOption(const std::string &rawKey, const std::string &value, const std::string &exeName,
-                             std::deque<mapleOption::Option> &exeOption) {
-  /* TODO: This method looks almost identical to OptionParser::HandleKeyValue.
-   * So it's good idea to refactor it to use OptionParser::HandleKeyValue to reduce code duplication.
-   */
-
-  if (rawKey.empty()) {
-    LogInfo::MapleLogger(kLlErr) << "Invalid key" << '\n';
-    PrintUsage("driver");
-    return false;
-  }
-
-  ErrorCode err;
-  std::string_view key;
-  auto prefixType = DetectOptPrefix(rawKey);
-  std::tie(err, key) = ExtractKey(rawKey, prefixType);
-  if (err != kErrorNoError) {
-    return false;
-  }
-
-  int count = usages.count(key);
-  auto item = usages.find(key);
-  while (count > 0) {
-    if (item->second.desc.exeName != exeName) {
-      ++item;
-      --count;
-      continue;
-    }
-    switch (item->second.desc.checkPolicy) {
-      case kArgCheckPolicyNone:
-      case kArgCheckPolicyOptional:
-        break;
-      case kArgCheckPolicyRequired:
-        if (value.empty()) {
-          LogInfo::MapleLogger(kLlErr) << "Option " << key << " requires an argument." << '\n';
-          return false;
-        }
-        break;
-      default:
-        break;
-    }
-    break;
-  }
-  exeOption.emplace_front(item->second.desc, std::string(key), value, prefixType, false);
-  return true;
-}
-
-bool OptionParser::CheckJoinedOption(Arg &arg,
-                                     std::deque<mapleOption::Option> &inputOption,
-                                     const std::string &exeName) {
-  auto &option = arg.key;
-
-  /* TODO: Add special field in Descriptor to check only joined usages */
-  for (auto usage : usages) {
-    /* Joined Option (like -DMACRO) can be detected as substring (-D) in the option string */
-    if (option.find(usage.first) == 0) {
-      arg.val = option.substr(usage.first.size());
-      arg.key = option.substr(0, usage.first.size());
-      return HandleKeyValue(arg, inputOption, exeName);
-    }
-  }
-
-  LogInfo::MapleLogger(kLlErr) << "Unknown Option: " << arg.rawArg << '\n';
-  return false;
-}
-
-bool OptionParser::CheckOpt(std::vector<Arg> &inputArgs, size_t &argsIndex,
-                            std::deque<mapleOption::Option> &inputOption,
-                            const std::string &exeName) {
-  ASSERT(argsIndex < inputArgs.size(), "Incorrect argsIndex in OptionParser::CheckOpt");
-  auto &arg = inputArgs[argsIndex];
-  auto &option = arg.key;
-
-  size_t pos = option.find('=');
-  if (pos != std::string::npos) {
-    /* option like --key=value */
-    ASSERT(pos > 0, "option should not begin with symbol '='");
-    arg.isEqualOpt = true;
-
-    /* To handle joined option, we must have full (not splitted key),
-     * because joined option splitting is different:
-     * As example for -Dkey=value: default splitting key="Dkey" value="value",
-     * Joined option splitting key="D" value="key=value"
-     */
-    std::string_view tmpKey = option.substr(0, pos);
-    auto item = usages.find(tmpKey);
-    if (item == usages.end()) {
-      /* It can be joined option, like: -DMACRO=VALUE */
-      argsIndex++;
-      return CheckJoinedOption(arg, inputOption, exeName);
-    }
-
-    arg.val = option.substr(pos + 1);
-    arg.key = tmpKey;
-
-    argsIndex++;
-    return HandleKeyValue(arg, inputOption, exeName);
-  }
-
-  /* option like "--key value" or "--key" */
-  else {
-    auto item = usages.find(option);
-    if (item != usages.end()) {
-      if (item->second.desc.checkPolicy == kArgCheckPolicyRequired ||
-          item->second.desc.checkPolicy == kArgCheckPolicyNumeric) {
-        /* option like "--key value", so we need to check value as next argument */
-        argsIndex++;
-        if (argsIndex >= inputArgs.size() ||
-            inputArgs[argsIndex].rawArg.empty()) {
-          /* Something wrong: Value is missed */
-          LogInfo::MapleLogger(kLlErr) << "Last option must be a value for option: " << option << '\n';
-          return false;
-        }
-
-        arg.val = inputArgs[argsIndex].rawArg;
-        /* Check: option like "--key value", so "value" must not contain any prefix (--value is incorrect) */
-        auto prefixType = DetectOptPrefix(arg.val);
-        if (prefixType != undefinedOpt) {
-          LogInfo::MapleLogger(kLlErr) << "Incorrect value=" << arg.val << " for option=" << option << '\n';
-          return false;
-        }
-      }
-
-      argsIndex++;
-      return HandleKeyValue(arg, inputOption, exeName);
-    } else {
-      /* It can be joined option, like: -DMACRO */
-      argsIndex++;
-      return CheckJoinedOption(arg, inputOption, exeName);;
-    }
-  }
-  return true;
-}
-
-ErrorCode OptionParser::HandleInputArgs(std::vector<Arg> &inputArgs, const std::string &exeName,
-                                        std::deque<mapleOption::Option> &inputOption, bool isAllOption) {
-  ErrorCode ret = kErrorNoError;
-  for (size_t argsIndex = 0; argsIndex < inputArgs.size();) {
-    auto &arg = inputArgs[argsIndex];
-    auto &rawArg = arg.rawArg;
-    if (rawArg == "") {
-      argsIndex++;
-      continue;
-    }
-
-    arg.prefixType = DetectOptPrefix(rawArg);
-    std::tie(ret, arg.key) = ExtractKey(rawArg, arg.prefixType);
-    if (ret != kErrorNoError) {
-      return ret;
-    }
-
-    if (arg.prefixType != undefinedOpt) {
-      /* options prefix is matched -> Try to detect and handle the option */
-      bool wasOptHandled = CheckOpt(inputArgs, argsIndex, inputOption, exeName);
-      if (!wasOptHandled) {
-        LogInfo::MapleLogger(kLlErr) << "Unknown Option: " << arg.rawArg << '\n';
-        return kErrorInvalidParameter;
-      }
-    } else {
-      /* if it's not an option, it can be input file */
-      argsIndex++;
-      if (isAllOption) {
-        nonOptionsArgs.emplace_back(arg.key);
-      }
-    }
-  }
-  return kErrorNoError;
-}
-
-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) {
-    PrintUsage(exeName);
-    LogInfo::MapleLogger(kLlErr) << "No input files!" << '\n';
-    return kErrorInitFail;
-  }
-  // transform char* to string
-  std::vector<Arg> inputArgs;
-  while (argc != 0 && *argv != nullptr) {
-    inputArgs.emplace_back(*argv);
-    ++argv;
-    --argc;
-  }
-  ErrorCode ret = HandleInputArgs(inputArgs, exeName, options, true);
-  return ret;
-}
-
-std::string Option::GetPrefix() const {
-  auto it = prefixInfo.find(prefixType);
-  ASSERT(it != prefixInfo.end(), "Prefix must be initialized!!");
-  return std::string(it->second);
-}
diff --git a/src/mapleall/maple_ipa/BUILD.gn b/src/mapleall/maple_ipa/BUILD.gn
index c4b868217296eab966a2245462109df3b70862d3..a26687d646861bcafbc86794b012ccda4c39db65 100755
--- a/src/mapleall/maple_ipa/BUILD.gn
+++ b/src/mapleall/maple_ipa/BUILD.gn
@@ -29,7 +29,6 @@ src_libmplipa = [
   "src/old/ipa_escape_analysis.cpp",
   "src/old/do_ipa_escape_analysis.cpp",
   "src/old/ea_connection_graph.cpp",
-  "src/old/ipa_option.cpp",
   "src/ipa_side_effect.cpp",
   "src/ipa_phase_manager.cpp",
   "src/prop_return_null.cpp",
diff --git a/src/mapleall/maple_ipa/include/old/ipa_option.h b/src/mapleall/maple_ipa/include/old/ipa_option.h
index dfde1f5c4922ef64432cdaae072105eaa75c97ff..70ddbebb4b11dd7e0bb218fdfbf48667b2912af8 100644
--- a/src/mapleall/maple_ipa/include/old/ipa_option.h
+++ b/src/mapleall/maple_ipa/include/old/ipa_option.h
@@ -19,14 +19,14 @@
 #include <algorithm>
 #include "mir_parser.h"
 #include "opcode_info.h"
-#include "option_parser.h"
+#include "mpl_options.h"
 #include "option.h"
 #include "inline.h"
 #include "bin_mpl_export.h"
 #include "me_phase_manager.h"
 
 namespace maple {
-class IpaOption : public maple::MapleDriverOptionBase {
+class IpaOption {
  public:
   static IpaOption &GetInstance();
 
@@ -68,4 +68,4 @@ class MeFuncPM2 : public MeFuncPM {
   void DoPhasesPopulate(const MIRModule &m) override;
 };
 }  // namespace maple
-#endif // MAPLE_IPA_OPTION_H
\ No newline at end of file
+#endif // MAPLE_IPA_OPTION_H
diff --git a/src/mapleall/maple_ipa/src/old/ipa_option.cpp b/src/mapleall/maple_ipa/src/old/ipa_option.cpp
index 822b38f562b9895135d64174d3d049bad4135f7e..bd4fb0d17bb9d213fa048d0d7b4758f6d4cc3bc5 100644
--- a/src/mapleall/maple_ipa/src/old/ipa_option.cpp
+++ b/src/mapleall/maple_ipa/src/old/ipa_option.cpp
@@ -13,7 +13,6 @@
  * See the Mulan PSL v2 for more details.
  */
 #include "ipa_option.h"
-#include "driver_option_common.h"
 #include "mpl_logging.h"
 
 namespace maple {
diff --git a/src/mapleall/maple_ir/BUILD.gn b/src/mapleall/maple_ir/BUILD.gn
index 315e565a19663dc0f131bfedaedb3e23c054ba79..91984bee38b99ecd378238eaee7fadcd4435d757 100755
--- a/src/mapleall/maple_ir/BUILD.gn
+++ b/src/mapleall/maple_ir/BUILD.gn
@@ -44,6 +44,7 @@ src_libmplir = [
   "src/mir_type.cpp",
   "src/opcode_info.cpp",
   "src/option.cpp",
+  "src/mpl2mpl_options.cpp",
   "src/parser.cpp",
   "src/mir_parser.cpp",
   "src/mir_pragma.cpp",
@@ -69,9 +70,9 @@ static_library("libmplir") {
   output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
   deps = [
     "${MAPLEALL_ROOT}/maple_driver:libdriver_option",
-    "${MAPLEALL_ROOT}/maple_driver:liboption_parser",
     "${MAPLEALL_ROOT}/maple_phase:libmplphase",
     "${MAPLEALL_ROOT}/maple_util:libmplutil",
+    "${MAPLEALL_ROOT}/maple_util:libcommandline",
   ]
 }
 
@@ -80,7 +81,6 @@ executable("irbuild") {
   include_dirs = include_directories
   deps = [
     ":libmplir",
-    "${MAPLEALL_ROOT}/maple_driver:liboption_parser",
     "${MAPLEALL_ROOT}/maple_phase:libmplphase",
     "${MAPLEALL_ROOT}/maple_phase:libmplphase",
     "${MAPLEALL_ROOT}/maple_util:libmplutil",
@@ -97,7 +97,6 @@ executable("mpldbg") {
   include_dirs = include_directories
   deps = [
     ":libmplir",
-    "${MAPLEALL_ROOT}/maple_driver:liboption_parser",
     "${MAPLEALL_ROOT}/maple_phase:libmplphase",
     "${MAPLEALL_ROOT}/maple_util:libmplutil",
     "${MAPLEALL_ROOT}/mempool:libmempool",
diff --git a/src/mapleall/maple_ir/include/mpl2mpl_options.h b/src/mapleall/maple_ir/include/mpl2mpl_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..6998d73a46c3f994f584c97dd8dd513cd7da15d6
--- /dev/null
+++ b/src/mapleall/maple_ir/include/mpl2mpl_options.h
@@ -0,0 +1,108 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * 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 v2 for more details.
+ */
+
+#ifndef MAPLE_IR_INCLUDE_MPL2MPL_OPTION_H
+#define MAPLE_IR_INCLUDE_MPL2MPL_OPTION_H
+
+#include "cl_option.h"
+#include "cl_parser.h"
+
+#include <bits/stdint-uintn.h>
+#include <stdint.h>
+#include <string>
+
+namespace opts::mpl2mpl {
+
+extern cl::Option<std::string> dumpPhase;
+extern cl::Option<std::string> skipPhase;
+extern cl::Option<std::string> skipFrom;
+extern cl::Option<std::string> skipAfter;
+extern cl::Option<std::string> dumpFunc;
+extern cl::Option<bool> quiet;
+extern cl::Option<bool> maplelinker;
+extern cl::Option<bool> regnativefunc;
+extern cl::Option<bool> inlineWithProfile;
+extern cl::Option<bool> inlineOpt;
+extern cl::Option<bool> ipaClone;
+extern cl::Option<std::string> noInlineFunc;
+extern cl::Option<std::string> importFileList;
+extern cl::Option<bool> crossModuleInline;
+extern cl::Option<uint32_t> inlineSmallFunctionThreshold;
+extern cl::Option<uint32_t> inlineHotFunctionThreshold;
+extern cl::Option<uint32_t> inlineRecursiveFunctionThreshold;
+extern cl::Option<uint32_t> inlineDepth;
+extern cl::Option<uint32_t> inlineModuleGrow;
+extern cl::Option<uint32_t> inlineColdFuncThresh;
+extern cl::Option<uint32_t> profileHotCount;
+extern cl::Option<uint32_t> profileColdCount;
+extern cl::Option<uint32_t> profileHotRate;
+extern cl::Option<uint32_t> profileColdRate;
+extern cl::Option<bool> nativewrapper;
+extern cl::Option<bool> regnativeDynamicOnly;
+extern cl::Option<std::string> staticBindingList;
+extern cl::Option<bool> dumpBefore;
+extern cl::Option<bool> dumpAfter;
+extern cl::Option<bool> dumpMuid;
+extern cl::Option<bool> emitVtableImpl;
+
+#if MIR_JAVA
+extern cl::Option<bool> skipvirtual;
+#endif
+
+extern cl::Option<bool> userc;
+extern cl::Option<bool> strictNaiveRc;
+extern cl::Option<bool> rcOpt1;
+extern cl::Option<bool> nativeopt;
+extern cl::Option<bool> o0;
+extern cl::Option<bool> o2;
+extern cl::Option<bool> os;
+extern cl::Option<std::string> criticalNative;
+extern cl::Option<std::string> fastNative;
+extern cl::Option<bool> nodot;
+extern cl::Option<bool> genIrProfile;
+extern cl::Option<bool> profileTest;
+extern cl::Option<bool> barrier;
+extern cl::Option<std::string> nativeFuncPropertyFile;
+extern cl::Option<bool> maplelinkerNolocal;
+extern cl::Option<uint32_t> buildApp;
+extern cl::Option<bool> partialAot;
+extern cl::Option<uint32_t> decoupleInit;
+extern cl::Option<std::string> sourceMuid;
+extern cl::Option<bool> deferredVisit;
+extern cl::Option<bool> deferredVisit2;
+extern cl::Option<bool> decoupleSuper;
+extern cl::Option<bool> genDecoupleVtab;
+extern cl::Option<bool> profileFunc;
+extern cl::Option<std::string> dumpDevirtual;
+extern cl::Option<std::string> readDevirtual;
+extern cl::Option<bool> usewhiteclass;
+extern cl::Option<std::string> appPackageName;
+extern cl::Option<std::string> checkClInvocation;
+extern cl::Option<bool> dumpClInvocation;
+extern cl::Option<uint32_t> warning;
+extern cl::Option<bool> lazyBinding;
+extern cl::Option<bool> hotFix;
+extern cl::Option<bool> compactMeta;
+extern cl::Option<bool> genPGOReport;
+extern cl::Option<uint32_t> inlineCache;
+extern cl::Option<bool> noComment;
+extern cl::Option<bool> rmnousefunc;
+extern cl::Option<bool> sideeffect;
+extern cl::Option<bool> dumpIPA;
+extern cl::Option<bool> wpaa;
+
+}
+
+#endif /* MAPLE_IR_INCLUDE_OPTION_H */
diff --git a/src/mapleall/maple_ir/include/option.h b/src/mapleall/maple_ir/include/option.h
index 05abab257f72c41e51d7c316a6387ac46b4c49e6..8e7a0570a124c6ba15863f9f7dcbc45cc6a60a8a 100644
--- a/src/mapleall/maple_ir/include/option.h
+++ b/src/mapleall/maple_ir/include/option.h
@@ -17,23 +17,18 @@
 #include <string>
 #include <vector>
 
-#include "driver_option_common.h"
 #include "mempool.h"
 #include "mempool_allocator.h"
-#include "option_descriptor.h"
 #include "parser_opt.h"
 #include "types_def.h"
 
 namespace maple {
-class Options : public MapleDriverOptionBase {
+class Options {
  public:
   static Options &GetInstance();
 
-  Options();
-
   bool ParseOptions(int argc, char **argv, std::string &fileName) const;
-
-  bool SolveOptions(const std::deque<mapleOption::Option> &opts, bool isDebug) const;
+  bool SolveOptions(bool isDebug) const;
   ~Options() = default;
 
   void DumpOptions() const;
@@ -173,7 +168,6 @@ class Options : public MapleDriverOptionBase {
   static bool wpaa;
 
  private:
-  void DecideMpl2MplRealLevel(const std::deque<mapleOption::Option> &inputOptions) const;
   std::vector<std::string> phaseSeq;
 };
 }  // namespace maple
diff --git a/src/mapleall/maple_ir/src/mpl2mpl_options.cpp b/src/mapleall/maple_ir/src/mpl2mpl_options.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..824a5989b1fa52ba40cb862402ac33859309b0f7
--- /dev/null
+++ b/src/mapleall/maple_ir/src/mpl2mpl_options.cpp
@@ -0,0 +1,414 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * 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 v2 for more details.
+ */
+
+#include "driver_options.h"
+
+#include <bits/stdint-uintn.h>
+#include <stdint.h>
+#include <string>
+
+namespace opts::mpl2mpl {
+
+cl::Option<std::string> dumpPhase({"--dump-phase"},
+                                  "  --dump-phase                \tEnable debug trace for specified phase (can only specify once)\n"
+                                  "                              \t--dump-phase=PHASENAME\n",
+                                  {mpl2mplCategory});
+
+cl::Option<std::string> skipPhase({"--skip-phase"},
+                                  "  --skip-phase                \tSkip the phase when adding it to phase manager\n"
+                                  "                              \t--skip-phase=PHASENAME\n",
+                                  {mpl2mplCategory});
+
+cl::Option<std::string> skipFrom({"--skip-from"},
+                                 "  --skip-from                 \tSkip all remaining phases including PHASENAME\n"
+                                 "                              \t--skip-from=PHASENAME\n",
+                                 {mpl2mplCategory});
+
+cl::Option<std::string> skipAfter({"--skip-after"},
+                                  "  --skip-after                \tSkip all remaining phases after PHASENAME\n"
+                                  "                              \t--skip-after=PHASENAME\n",
+                                  {mpl2mplCategory});
+
+cl::Option<std::string> dumpFunc({"--dump-func"},
+                                 "  --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",
+                                 {mpl2mplCategory});
+
+cl::Option<bool> quiet({"--quiet"},
+                       "  --quiet                     \tDisable brief trace messages with phase/function names\n"
+                       "  --no-quiet                  \tEnable brief trace messages with phase/function names\n",
+                       {mpl2mplCategory},
+                       cl::DisableWith("--no-quiet"));
+
+cl::Option<bool> maplelinker({"--maplelinker"},
+                             "  --maplelinker               \tGenerate MUID symbol tables and references\n"
+                             "  --no-maplelinker            \tDon't Generate MUID symbol tables and references\n",
+                             {mpl2mplCategory},
+                             cl::DisableWith("--no-maplelinker"));
+
+cl::Option<bool> regnativefunc({"--regnativefunc"},
+                               "  --regnativefunc             \tGenerate native stub function to support JNI registration and calling\n"
+                               "  --no-regnativefunc          \tDisable regnativefunc\n",
+                               {mpl2mplCategory},
+                               cl::DisableWith("--no-regnativefunc"));
+
+cl::Option<bool> inlineWithProfile({"--inline-with-profile"},
+                                   "  --inline-with-profile       \tEnable profile-based inlining\n"
+                                   "  --no-inline-with-profile    \tDisable profile-based inlining\n",
+                                   {mpl2mplCategory},
+                                   cl::DisableWith("--no-inline-with-profile"));
+
+cl::Option<bool> inlineOpt({"--inline"},
+                           "  --inline                    \tEnable function inlining\n"
+                           "  --no-inline                 \tDisable function inlining\n",
+                           {mpl2mplCategory},
+                           cl::DisableWith("--no-inline"));
+
+cl::Option<bool> ipaClone({"--ipa-clone"},
+                          "  --ipa-clone                 \tEnable ipa constant_prop and clone\n"
+                          "  --no-ipa-clone              \tDisable ipa constant_prop and clone\n",
+                          {mpl2mplCategory},
+                           cl::DisableWith("--no-ipa-clone"));
+
+cl::Option<std::string> noInlineFunc({"--no-inlinefunclist"},
+                                     "  --no-inlinefunclist=list    \tDo not inline function in this list\n",
+                                     {mpl2mplCategory});
+
+cl::Option<std::string> importFileList({"--importfilelist"},
+                                       "  --importfilelist=list    \tImport there files to do cross module analysis\n",
+                                       {mpl2mplCategory});
+
+cl::Option<bool> crossModuleInline({"--cross-module-inline"},
+                                   "  --cross-module-inline       \tEnable cross-module inlining\n"
+                                   "  --no-cross-module-inline    \tDisable cross-module inlining\n",
+                                   {mpl2mplCategory},
+                                   cl::DisableWith("--no-cross-module-inline"));
+
+cl::Option<uint32_t> inlineSmallFunctionThreshold({"--inline-small-function-threshold"},
+                                                  "  --inline-small-function-threshold=15            \tThreshold for inlining small function\n",
+                                                  {mpl2mplCategory});
+
+cl::Option<uint32_t> inlineHotFunctionThreshold({"--inline-hot-function-threshold"},
+                                                "  --inline-hot-function-threshold=30              \tThreshold for inlining hot function\n",
+                                                {mpl2mplCategory});
+
+cl::Option<uint32_t> inlineRecursiveFunctionThreshold({"--inline-recursive-function-threshold"},
+                                                      "  --inline-recursive-function-threshold=15              \tThreshold for inlining recursive function\n",
+                                                      {mpl2mplCategory});
+
+cl::Option<uint32_t> inlineDepth({"--inline-depth"},
+                                 "  --inline-depth=8              \tMax call graph depth for inlining\n",
+                                 {mpl2mplCategory});
+
+cl::Option<uint32_t> inlineModuleGrow({"--inline-module-growth"},
+                                      "  --inline-module-growth=100000                   \tThreshold for maxmium code size growth rate (10%)\n",
+                                      {mpl2mplCategory});
+
+cl::Option<uint32_t> inlineColdFuncThresh({"--inline-cold-function-threshold"},
+                                          "  --inline-cold-function-threshold=3              \tThreshold for inlining hot function\n",
+                                          {mpl2mplCategory});
+
+cl::Option<uint32_t> profileHotCount({"--profile-hot-count"},
+                                     "  --profile-hot-count=1000    \tA count is regarded as hot if it exceeds this number\n",
+                                     {mpl2mplCategory});
+
+cl::Option<uint32_t> profileColdCount({"--profile-cold-count"},
+                                      "  --profile-cold-count=10     \tA count is regarded as cold if it is below this number\n",
+                                      {mpl2mplCategory});
+
+cl::Option<uint32_t> profileHotRate({"--profile-hot-rate"},
+                                    "  --profile-hot-rate=500000   \tA count is regarded as hot if it is in the largest 50%\n",
+                                    {mpl2mplCategory});
+
+cl::Option<uint32_t> profileColdRate({"--profile-cold-rate"},
+                                     "  --profile-cold-rate=900000  \tA count is regarded as cold if it is in the smallest 10%\n",
+                                     {mpl2mplCategory});
+
+cl::Option<bool> nativewrapper({"--nativewrapper"},
+                               "  --nativewrapper             \tGenerate native wrappers [default]\n",
+                               {mpl2mplCategory},
+                               cl::DisableWith("--no-nativewrapper"));
+
+cl::Option<bool> regnativeDynamicOnly({"--regnative-dynamic-only"},
+                                      "  --regnative-dynamic-only    \tOnly Generate dynamic register code, Report Fatal Msg if no implemented\n"
+                                      "  --no-regnative-dynamic-only \tDisable regnative-dynamic-only\n",
+                                      {mpl2mplCategory},
+                                      cl::DisableWith("--no-regnative-dynamic-only"));
+
+cl::Option<std::string> staticBindingList({"--static-binding-list"},
+                                          "  --static-bindig-list        \tOnly Generate static binding function in file configure list\n"
+                                          "                              \t--static-bindig-list=file\n",
+                                          {mpl2mplCategory});
+
+cl::Option<bool> dumpBefore({"--dump-before"},
+                            "  --dump-before               \tDo extra IR dump before the specified phase\n"
+                            "  --no-dump-before            \tDon't extra IR dump before the specified phase\n",
+                            {mpl2mplCategory},
+                            cl::DisableWith("--no-dump-before"));
+
+cl::Option<bool> dumpAfter({"--dump-after"},
+                           "  --dump-after                \tDo extra IR dump after the specified phase\n"
+                           "  --no-dump-after             \tDon't extra IR dump after the specified phase\n",
+                           {mpl2mplCategory},
+                           cl::DisableWith("--no-dump-after"));
+
+cl::Option<bool> dumpMuid({"--dump-muid"},
+                          "  --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",
+                          {mpl2mplCategory},
+                          cl::DisableWith("--no-dump-muid"));
+
+cl::Option<bool> emitVtableImpl({"--emitVtableImpl"},
+                                "  --emitVtableImpl            \tgenerate VtableImpl file\n"
+                                "  --no-emitVtableImpl         \tDon't generate VtableImpl file\n",
+                                {mpl2mplCategory},
+                                cl::DisableWith("--no-emitVtableImpl"));
+
+#if MIR_JAVA
+cl::Option<bool> skipvirtual({"--skipvirtual"},
+                             "  --skipvirtual\n"
+                             "  --no-skipvirtual\n",
+                             {mpl2mplCategory},
+                             cl::DisableWith("--no-skipvirtual"));
+#endif
+
+cl::Option<bool> userc({"--userc"},
+                       "  --userc                     \tEnable reference counting [default]\n"
+                       "  --no-userc                  \tDisable reference counting [default]\n",
+                       {mpl2mplCategory},
+                       cl::DisableWith("--no-userc"));
+
+cl::Option<bool> strictNaiveRc({"--strict-naiverc"},
+                               "  --strict-naiverc            \tStrict Naive RC mode, assume no unsafe multi-thread read/write racing\n"
+                               "  --no-strict-naiverc         \tDisable strict-naiverc\n",
+                               {mpl2mplCategory},
+                               cl::DisableWith("--no-strict-naiverc"));
+
+cl::Option<bool> rcOpt1({"--rc-opt1"},
+                        "  --rc-opt1                   \tEnable RC optimization1 [default]\n",
+                        {mpl2mplCategory},
+                        cl::DisableWith("--no-rc-opt1"));
+
+cl::Option<bool> nativeopt({"--nativeopt"},
+                           "  --nativeopt                 \tEnable native opt\n"
+                           "  --no-nativeopt              \tDisable native opt\n",
+                           {mpl2mplCategory},
+                           cl::DisableWith("--no-nativeopt"));
+
+cl::Option<bool> o0({"-O0", "--O0"},
+                    "  -O0                         \tDo some optimization.\n",
+                    {mpl2mplCategory});
+
+cl::Option<bool> o2({"-O2", "--O2"},
+                    "  -O2                         \tDo some optimization.\n",
+                    {mpl2mplCategory});
+
+cl::Option<bool> os({"-Os", "--Os"},
+                    "  -Os                         \tOptimize for size, based on O2.\n",
+                    {mpl2mplCategory});
+
+cl::Option<std::string> criticalNative({"--CriticalNative"},
+                                       "  --CriticalNative            \tFor CriticalNative optimization\n"
+                                       "                              \t--CriticalNative=list_file\n",
+                                       {mpl2mplCategory});
+
+cl::Option<std::string> fastNative({"--FastNative"},
+                                   "  --FastNative                \tFor FastNative optimization\n"
+                                   "                              \t--FastNative=list_file\n",
+                                   {mpl2mplCategory});
+
+cl::Option<bool> nodot({"--nodot"},
+                       "  --nodot                     \tDisable dot file generation from cfg\n"
+                       "  --no-nodot                  \tEnable dot file generation from cfg\n",
+                       {mpl2mplCategory},
+                       cl::DisableWith("--no-nodot"));
+
+cl::Option<bool> genIrProfile({"--ir-profile-gen"},
+                              "  --ir-profile-gen              \tGen IR level Profile\n"
+                              "  --no-ir-profile-gen           \tDisable Gen IR level Profile\n",
+                              {mpl2mplCategory},
+                              cl::DisableWith("--no-ir-profile-gen"));
+
+cl::Option<bool> profileTest({"--profile-test"},
+                             "  --profile-test              \tprofile test\n"
+                             "  --no-profile-test           \tDisable profile test\n",
+                             {mpl2mplCategory},
+                             cl::DisableWith("--no-profile-test"));
+
+cl::Option<bool> barrier({"--barrier"},
+                         "  --barrier                   \tEnable barrier insertion instead of RC insertion\n"
+                         "  --no-barrier                \tDisable barrier insertion instead of RC insertion\n",
+                         {mpl2mplCategory},
+                         cl::DisableWith("--no-barrier"));
+
+cl::Option<std::string> nativeFuncPropertyFile({"--nativefunc-property-list"},
+                                               "  --nativefunc-property-list  \tGenerate native binding function stub\n"
+                                               "                              \t--nativefunc-property-list=file\n",
+                                               {mpl2mplCategory});
+
+cl::Option<bool> maplelinkerNolocal({"--maplelinker-nolocal"},
+                                    "  --maplelinker-nolocal       \tDo not turn functions into local when maple linker is on\n"
+                                    "  --no-maplelinker-nolocal\n",
+                                    {mpl2mplCategory},
+                                    cl::DisableWith("--no-maplelinker-nolocal"));
+
+cl::Option<uint32_t> buildApp({"--build-app"},
+                              "  --build-app[=0,1,2]         \tbuild the app dex 0:off, 1:method1, 2:method2, ignore:method1\n",
+                              {mpl2mplCategory},
+                              cl::optionalValue, cl::Init(1));
+
+cl::Option<bool> partialAot({"--partialAot"},
+                            "  --partialAot               \tenerate the detailed information for the partialAot\n",
+                            {mpl2mplCategory},
+                            cl::optionalValue);
+
+cl::Option<uint32_t> decoupleInit({"--decouple-init"},
+                                  "  --decouple-init          \tdecouple the constructor method\n",
+                                  {mpl2mplCategory},
+                                  cl::optionalValue, cl::Init(1));
+
+cl::Option<std::string> sourceMuid({"--source-muid"},
+                                   "  --source-muid=""            \tWrite the source file muid into the mpl file\n",
+                                   {mpl2mplCategory},
+                                   cl::optionalValue);
+
+cl::Option<bool> deferredVisit({"--deferred-visit"},
+                               "  --deferred-visit            \tGenerate deferred MCC call for undefined type\n"
+                               "  --no-deferred-visit         \tDont't generate deferred MCC call for undefined type\n",
+                               {mpl2mplCategory},
+                               cl::DisableWith("--no-deferred-visit"));
+
+cl::Option<bool> deferredVisit2({"--deferred-visit2"},
+                                "  --deferred-visit2           \tGenerate deferred MCC call(DAI2.0) for undefined type\n"
+                                "  --no-deferred-visit2        \tDon't generate deferred MCC call(DAI2.0) for undefined type\n",
+                                {mpl2mplCategory},
+                                cl::DisableWith("--no-deferred-visit2"));
+
+cl::Option<bool> decoupleSuper({"--decouple-super"},
+                               "  --decouple-super            \tGenerate deferred MCC call for undefined type\n"
+                               "  --no-decouple-super         \tDon't generate deferred MCC call for undefined type\n",
+                               {mpl2mplCategory},
+                               cl::DisableWith("--no-decouple-super"));
+
+cl::Option<bool> genDecoupleVtab({"--gen-decouple-vtab"},
+                                 "  --gen-decouple-vtab         \tGenerate the whole and complete vtab and itab\n"
+                                 "  --no-gen-decouple-vtab      \tDon't generate the whole and complete vtab and itab\n",
+                                 {mpl2mplCategory},
+                                 cl::DisableWith("--no-gen-decouple-vtab"));
+
+cl::Option<bool> profileFunc({"--profile-func"},
+                             "  --profile-func              \tProfile function usage\n"
+                             "  --no-profile-func           \tDisable profile function usage\n",
+                             {mpl2mplCategory},
+                             cl::DisableWith("--no-profile-func"));
+
+cl::Option<std::string> dumpDevirtual({"--dump-devirtual-list"},
+                                      "  --dump-devirtual-list       \tDump candidates of devirtualization into a specified file\n"
+                                      "                              \t--dump-devirtual-list=\n",
+                                      {mpl2mplCategory});
+
+cl::Option<std::string> readDevirtual({"--read-devirtual-list"},
+                                      "  --read-devirtual-list       \tRead in candidates of devirtualization from\n"
+                                      "                              \t a specified file and perform devirtualization\n"
+                                      "                              \t--read-devirtual-list=\n",
+                                      {mpl2mplCategory});
+
+cl::Option<bool> usewhiteclass({"--usewhiteclass"},
+                               "  --usewhiteclass             \tEnable use preloaded class list to reducing clinit check\n"
+                               "  --no-usewhiteclass          \tDisable use preloaded class list to reducing clinit check\n",
+                               {mpl2mplCategory},
+                               cl::DisableWith("--no-usewhiteclass"));
+
+cl::Option<std::string> appPackageName({"--app-package-name"},
+                                       "  --app-package-name          \tSet APP package name\n"
+                                       "                              \t--app-package-name=package_name\n",
+                                       {mpl2mplCategory},
+                                       cl::optionalValue);
+
+cl::Option<std::string> checkClInvocation({"--check_cl_invocation"},
+                                          "  --check_cl_invocation       \tFor classloader invocation checking\n"
+                                          "                              \t--check_cl_invocation=list_file\n",
+                                          {mpl2mplCategory});
+
+cl::Option<bool> dumpClInvocation({"--dump_cl_invocation"},
+                                  "  --dump_cl_invocation        \tFor classloader invocation dumping.\n"
+                                  "                              \tWork only if already set --check_cl_invocation\n"
+                                  "  --no-dump_cl_invocation     \tDisable dump_cl_invocation\n",
+                                  {mpl2mplCategory},
+                                  cl::DisableWith("--no-dump_cl_invocation"));
+
+cl::Option<uint32_t> warning({"--warning"},
+                             "  --warning=level             \t--warning=level\n",
+                             {mpl2mplCategory});
+
+cl::Option<bool> lazyBinding({"--lazy-binding"},
+                             "  --lazy-binding              \tBind class symbols lazily[default off]\n"
+                             "  --no-lazy-binding           \tDon't bind class symbols lazily\n",
+                             {mpl2mplCategory},
+                             cl::DisableWith("--no-lazy-binding"));
+
+cl::Option<bool> hotFix({"--hot-fix"},
+                        "  --hot-fix                   \tOpen for App hot fix[default off]\n"
+                        "  --no-hot-fix                \tDon't open for App hot fix\n",
+                        {mpl2mplCategory},
+                        cl::DisableWith("--no-hot-fix"));
+
+cl::Option<bool> compactMeta({"--compact-meta"},
+                             "  --compact-meta              \tEnable compact method and field meta\n"
+                             "  --no-compact-meta           \tDisable compact method and field meta\n",
+                             {mpl2mplCategory},
+                             cl::DisableWith("--no-compact-meta"));
+
+cl::Option<bool> genPGOReport({"--gen-pgo-report"},
+                              "  --gen-pgo-report            \tDisplay pgo report\n"
+                              "  --no-gen-pgo-report\n",
+                              {mpl2mplCategory},
+                              cl::DisableWith("--no-gen-pgo-report"));
+
+cl::Option<uint32_t> inlineCache({"--inlineCache"},
+                                 "  --inlineCache            \tbuild inlineCache 0,1,2,3\n",
+                                 {mpl2mplCategory},
+                                 cl::optionalValue, cl::Init(0));
+
+cl::Option<bool> noComment({"--no-comment"},
+                           "  --no-comment             \tbuild inlineCache 0:off, 1:open\n",
+                           {mpl2mplCategory});
+
+cl::Option<bool> rmnousefunc({"--rmnousefunc"},
+                             "  --rmnousefunc            \tEnable remove no-used file-static function\n"
+                             "  --no-rmnousefunc         \tDisable remove no-used file-static function\n",
+                             {mpl2mplCategory},
+                             cl::DisableWith("--no-rmnousefunc"));
+
+cl::Option<bool> sideeffect({"--sideeffect"},
+                            "  --sideeffect      \tIPA: analysis sideeffect\n"
+                            "  --no-sideeffect          \n",
+                            {mpl2mplCategory},
+                            cl::DisableWith("--no-sideeffect"));
+
+cl::Option<bool> dumpIPA({"--dump-ipa"},
+                         "  --dump-ipa      \tIPA: dump\n"
+                         "  --no-dump-ipa          \n",
+                         {mpl2mplCategory},
+                         cl::DisableWith("--no-dump-ipa"));
+
+cl::Option<bool> wpaa({"--wpaa"},
+                      "  --wpaa      \tWhole Program Alias Analysis\n"
+                      "  --no-wpaa          \n",
+                      {mpl2mplCategory},
+                      cl::DisableWith("--no-wpaa"));
+
+}
diff --git a/src/mapleall/maple_ir/src/option.cpp b/src/mapleall/maple_ir/src/option.cpp
index fccdbc2922b4dae06cd6ef58b5f29b920fa5b46c..e6b084ec47f894045b10774303bad54949d29914 100644
--- a/src/mapleall/maple_ir/src/option.cpp
+++ b/src/mapleall/maple_ir/src/option.cpp
@@ -12,12 +12,17 @@
  * FIT FOR A PARTICULAR PURPOSE.
  * See the Mulan PSL v2 for more details.
  */
+#include "cl_option.h"
+#include "driver_options.h"
+#include "file_utils.h"
+#include "mpl2mpl_options.h"
 #include "option.h"
 #include <iostream>
+#include <fstream>
 #include <cstring>
 #include <cctype>
 #include "mpl_logging.h"
-#include "option_parser.h"
+#include "mpl_options.h"
 
 namespace maple {
 using namespace mapleOption;
@@ -116,1220 +121,206 @@ bool Options::sideEffect = false;
 bool Options::dumpIPA = false;
 bool Options::wpaa = false;  // whole program alias analysis
 
-enum OptionIndex {
-  kMpl2MplDumpPhase = kCommonOptionEnd + 1,
-  kMpl2MplSkipPhase,
-  kMpl2MplSkipFrom,
-  kMpl2MplSkipAfter,
-  kMpl2MplDumpFunc,
-  kMpl2MplQuiet,
-  kMpl2MplStubJniFunc,
-  kMpl2MplSkipVirtual,
-  kRegNativeDynamicOnly,
-  kRegNativeStaticBindingList,
-  kNativeWrapper,
-  kMpl2MplDumpBefore,
-  kMpl2MplDumpAfter,
-  kMpl2MplMapleLinker,
-  kMplnkDumpMuid,
-  kEmitVtableImpl,
-  kInlineWithProfile,
-  kInlineWithoutProfile,
-  kMpl2MplUseInline,
-  kMpl2MplEnableIPAClone,
-  kMpl2MplNoInlineFuncList,
-  kImportFileList,
-  kMpl2MplUseCrossModuleInline,
-  kInlineSmallFunctionThreshold,
-  kInlineHotFunctionThreshold,
-  kInlineRecursiveFunctionThreshold,
-  kInlineDepth,
-  kInlineModuleGrowth,
-  kInlineColdFunctionThreshold,
-  kProfileHotCount,
-  kProfileColdCount,
-  kProfileHotRate,
-  kProfileColdRate,
-  // Ready to be deleted.
-  kMpl2MplUseRc,
-  kMpl2MplStrictNaiveRc,
-  kRcOpt1,
-  kMpl2MplNoReflec,  // not used
-  kMpl2MplStubFunc,  // not used
-  kMpl2MplNativeOpt,
-  kMpl2MplOptL0,
-  kMpl2MplOptL2,
-  kMpl2MplOptLs,  // optimize for size
-  kMpl2MplNoDot,
-  kGenIRProfile,
-  kProfileTest,
-  kCriticalnative,
-  kFastnative,
-  kMpl2MplBarrier,
-  kNativeFuncPropertyFile,
-  kMplnkNoLocal,
-  kBuildApp,
-  kPartialAot,
-  kSourceMuid,
-  kDeferredVisit,
-  kDeferredVisit2,
-  kDecoupleSuper,
-  kGenVtabAndItabForDecouple,
-  kProfileFunc,
-  kDumpDevirtual,
-  kReadDevirtual,
-  kPreloadedClass,
-  kAppPackageName,
-  kCheckClInvocation,
-  kDumpClInvocation,
-  kMpl2MplWarnLevel,
-  kMpl2MplLazyBinding,
-  kMpl2MplHotFix,
-  kMpl2MplCompactMeta,
-  kGenPGOReport,
-  kInlineCache,
-  kNoComment,
-  kRmNoUseFunc,
-  kSideEffect,
-  kDumpIPA,
-  kWPAA
-};
-
-const Descriptor kUsage[] = {
-  { kMpl2MplDumpPhase,
-    0,
-    "",
-    "dump-phase",
-    kBuildTypeDebug,
-    kArgCheckPolicyRequired,
-    "  --dump-phase                \tEnable debug trace for specified phase (can only specify once)\n"
-    "                              \t--dump-phase=PHASENAME\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplSkipPhase,
-    0,
-    "",
-    "skip-phase",
-    kBuildTypeProduct,
-    kArgCheckPolicyRequired,
-    "  --skip-phase                \tSkip the phase when adding it to phase manager\n"
-    "                              \t--skip-phase=PHASENAME\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplSkipFrom,
-    0,
-    "",
-    "skip-from",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --skip-from                 \tSkip all remaining phases including PHASENAME\n"
-    "                              \t--skip-from=PHASENAME\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplSkipAfter,
-    0,
-    "",
-    "skip-after",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --skip-after                \tSkip all remaining phases after PHASENAME\n"
-    "                              \t--skip-after=PHASENAME\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplDumpFunc,
-    0,
-    "",
-    "dump-func",
-    kBuildTypeDebug,
-    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,
-    "",
-    "quiet",
-    kBuildTypeProduct,
-    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,
-    "",
-    "maplelinker",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --maplelinker               \tGenerate MUID symbol tables and references\n"
-    "  --no-maplelinker            \tDon't Generate MUID symbol tables and references\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplStubJniFunc,
-    kEnable,
-    "",
-    "regnativefunc",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --regnativefunc             \tGenerate native stub function to support JNI registration and calling\n"
-    "  --no-regnativefunc          \tDisable regnativefunc\n",
-    "mpl2mpl",
-    {} },
-  { kInlineWithProfile,
-    kEnable,
-    "",
-    "inline-with-profile",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --inline-with-profile       \tEnable profile-based inlining\n"
-    "  --no-inline-with-profile    \tDisable profile-based inlining\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplUseInline,
-    kEnable,
-    "",
-    "inline",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --inline                    \tEnable function inlining\n"
-    "  --no-inline                 \tDisable function inlining\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplEnableIPAClone,
-    kEnable,
-    "",
-    "ipa-clone",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --ipa-clone                 \tEnable ipa constant_prop and clone\n"
-    "  --no-ipa-clone              \tDisable ipa constant_prop and clone\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplNoInlineFuncList,
-    0,
-    "",
-    "no-inlinefunclist",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --no-inlinefunclist=list    \tDo not inline function in this list\n",
-    "mpl2mpl",
-    {} },
-  { kImportFileList,
-    0,
-    "",
-    "importfilelist",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --importfilelist=list    \tImport there files to do cross module analysis\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplUseCrossModuleInline,
-    kEnable,
-    "",
-    "cross-module-inline",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --cross-module-inline       \tEnable cross-module inlining\n"
-    "  --no-cross-module-inline    \tDisable cross-module inlining\n",
-    "mpl2mpl",
-    {} },
-  { kInlineSmallFunctionThreshold,
-    0,
-    "",
-    "inline-small-function-threshold",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --inline-small-function-threshold=15            \tThreshold for inlining small function\n",
-    "mpl2mpl",
-    {} },
-  { kInlineHotFunctionThreshold,
-    0,
-    "",
-    "inline-hot-function-threshold",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --inline-hot-function-threshold=30              \tThreshold for inlining hot function\n",
-    "mpl2mpl",
-    {} },
-  { kInlineRecursiveFunctionThreshold,
-    0,
-    "",
-    "inline-recursive-function-threshold",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --inline-recursive-function-threshold=15              \tThreshold for inlining recursive function\n",
-    "mpl2mpl",
-    {} },
-  { kInlineDepth,
-    0,
-    "",
-    "inline-depth",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --inline-depth=8              \tMax call graph depth for inlining\n",
-    "mpl2mpl",
-    {} },
-  { kInlineModuleGrowth,
-    0,
-    "",
-    "inline-module-growth",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --inline-module-growth=100000                   \tThreshold for maxmium code size growth rate (10%)\n",
-    "mpl2mpl",
-    {} },
-  { kInlineColdFunctionThreshold,
-    0,
-    "",
-    "inline-cold-function-threshold",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --inline-cold-function-threshold=3              \tThreshold for inlining hot function\n",
-    "mpl2mpl",
-    {} },
-  { kProfileHotCount,
-    0,
-    "",
-    "profile-hot-count",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --profile-hot-count=1000    \tA count is regarded as hot if it exceeds this number\n",
-    "mpl2mpl",
-    {} },
-  { kProfileColdCount,
-    0,
-    "",
-    "profile-cold-count",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --profile-cold-count=10     \tA count is regarded as cold if it is below this number\n",
-    "mpl2mpl",
-    {} },
-  { kProfileHotRate,
-    0,
-    "",
-    "profile-hot-rate",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --profile-hot-rate=500000   \tA count is regarded as hot if it is in the largest 50%\n",
-    "mpl2mpl",
-    {} },
-  { kProfileColdRate,
-    0,
-    "",
-    "profile-cold-rate",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --profile-cold-rate=900000  \tA count is regarded as cold if it is in the smallest 10%\n",
-    "mpl2mpl",
-    {} },
-  { kNativeWrapper,
-    kEnable,
-    "",
-    "nativewrapper",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --nativewrapper             \tGenerate native wrappers [default]\n",
-    "mpl2mpl",
-    {} },
-  { kRegNativeDynamicOnly,
-    kEnable,
-    "",
-    "regnative-dynamic-only",
-    kBuildTypeProduct,
-    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,
-    "",
-    "static-binding-list",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --static-bindig-list        \tOnly Generate static binding function in file configure list\n"
-    "                              \t--static-bindig-list=file\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplDumpBefore,
-    kEnable,
-    "",
-    "dump-before",
-    kBuildTypeDebug,
-    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,
-    "",
-    "dump-after",
-    kBuildTypeDebug,
-    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,
-    "",
-    "dump-muid",
-    kBuildTypeDebug,
-    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,
-    "",
-    "emitVtableImpl",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --emitVtableImpl            \tgenerate VtableImpl file\n"
-    "  --no-emitVtableImpl         \tDon't generate VtableImpl file\n",
-    "mpl2mpl",
-    {} },
-#if MIR_JAVA
-  { kMpl2MplSkipVirtual,
-    kEnable,
-    "",
-    "skipvirtual",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --skipvirtual\n"
-    "  --no-skipvirtual\n",
-    "mpl2mpl",
-    {} },
-#endif
-  { kMpl2MplUseRc,
-    kEnable,
-    "",
-    "userc",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --userc                     \tEnable reference counting [default]\n"
-    "  --no-userc                  \tDisable reference counting [default]\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplStrictNaiveRc,
-    kEnable,
-    "",
-    "strict-naiverc",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --strict-naiverc            \tStrict Naive RC mode, assume no unsafe multi-thread read/write racing\n"
-    "  --no-strict-naiverc         \tDisable strict-naiverc\n",
-    "mpl2mpl",
-    {} },
-  { kRcOpt1,
-    kEnable,
-    "",
-    "rc-opt1",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNone,
-    "  --rc-opt1                   \tEnable RC optimization1 [default]\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplNativeOpt,
-    kEnable,
-    "",
-    "nativeopt",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --nativeopt                 \tEnable native opt\n"
-    "  --no-nativeopt              \tDisable native opt\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplOptL0,
-    0,
-    "O0",
-    "",
-    kBuildTypeProduct,
-    kArgCheckPolicyOptional,
-    "  -O0                         \tDo some optimization.\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplOptL2,
-    0,
-    "O2",
-    "",
-    kBuildTypeProduct,
-    kArgCheckPolicyOptional,
-    "  -O2                         \tDo some optimization.\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplOptLs,
-    0,
-    "Os",
-    "",
-    kBuildTypeProduct,
-    kArgCheckPolicyOptional,
-    "  -Os                         \tOptimize for size, based on O2.\n",
-    "mpl2mpl",
-    {} },
-  { kCriticalnative,
-    0,
-    "",
-    "CriticalNative",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --CriticalNative            \tFor CriticalNative optimization\n"
-    "                              \t--CriticalNative=list_file\n",
-    "mpl2mpl",
-    {} },
-  { kFastnative,
-    0,
-    "",
-    "FastNative",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --FastNative                \tFor FastNative optimization\n"
-    "                              \t--FastNative=list_file\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplNoDot,
-    kEnable,
-    "",
-    "nodot",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --nodot                     \tDisable dot file generation from cfg\n"
-    "  --no-nodot                  \tEnable dot file generation from cfg\n",
-    "mpl2mpl",
-    {} },
-  { kGenIRProfile,
-    kEnable,
-    "",
-    "ir-profile-gen",
-    mapleOption::BuildType::kBuildTypeExperimental,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --ir-profile-gen              \tGen IR level Profile\n"
-    "  --no-ir-profile-gen           \tDisable Gen IR level Profile\n",
-    "mpl2mpl",
-    {} },
-  { kProfileTest,
-    kEnable,
-    "",
-    "profile-test",
-    mapleOption::BuildType::kBuildTypeExperimental,
-    mapleOption::ArgCheckPolicy::kArgCheckPolicyBool,
-    "  --profile-test              \tprofile test\n"
-    "  --no-profile-test           \tDisable profile test\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplBarrier,
-    kEnable,
-    "",
-    "barrier",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --barrier                   \tEnable barrier insertion instead of RC insertion\n"
-    "  --no-barrier                \tDisable barrier insertion instead of RC insertion\n",
-    "mpl2mpl",
-    {} },
-  { kNativeFuncPropertyFile,
-    0,
-    "",
-    "nativefunc-property-list",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --nativefunc-property-list  \tGenerate native binding function stub\n"
-    "                              \t--nativefunc-property-list=file\n",
-    "mpl2mpl",
-    {} },
-  { kMplnkNoLocal,
-    kEnable,
-    "",
-    "maplelinker-nolocal",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --maplelinker-nolocal       \tDo not turn functions into local when maple linker is on\n"
-    "  --no-maplelinker-nolocal\n",
-    "mpl2mpl",
-    {} },
-  { kBuildApp,
-    0,
-    "",
-    "build-app",
-    kBuildTypeProduct,
-    kArgCheckPolicyOptional,
-    "  --build-app[=0,1,2]         \tbuild the app dex 0:off, 1:method1, 2:method2, ignore:method1\n",
-    "mpl2mpl",
-    {} },
-  { kPartialAot,
-    0,
-    "",
-    "partialAot",
-    kBuildTypeProduct,
-    kArgCheckPolicyOptional,
-    "  --partialAot               \tenerate the detailed information for the partialAot\n",
-    "mpl2mpl",
-    {} },
-  { kDecoupleInit,
-    0,
-    "",
-    "decouple-init",
-    kBuildTypeProduct,
-    kArgCheckPolicyOptional,
-    "  --decouple-init          \tdecouple the constructor method\n",
-    "mpl2mpl",
-    {} },
-  { kSourceMuid,
-    0,
-    "",
-    "source-muid",
-    kBuildTypeProduct,
-    kArgCheckPolicyOptional,
-    "  --source-muid=""            \tWrite the source file muid into the mpl file\n",
-    "mpl2mpl",
-    {} },
-  { kDeferredVisit,
-    kEnable,
-    "",
-    "deferred-visit",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --deferred-visit            \tGenerate deferred MCC call for undefined type\n"
-    "  --no-deferred-visit         \tDont't generate deferred MCC call for undefined type\n",
-    "mpl2mpl",
-    {} },
-  { kDeferredVisit2,
-    kEnable,
-    "",
-    "deferred-visit2",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --deferred-visit2           \tGenerate deferred MCC call(DAI2.0) for undefined type\n"
-    "  --no-deferred-visit2        \tDon't generate deferred MCC call(DAI2.0) for undefined type\n",
-    "mpl2mpl",
-    {} },
-  { kDecoupleSuper,
-    kEnable,
-    "",
-    "decouple-super",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --decouple-super            \tGenerate deferred MCC call for undefined type\n"
-    "  --no-decouple-super         \tDon't generate deferred MCC call for undefined type\n",
-    "mpl2mpl",
-    {} },
-  { kGenVtabAndItabForDecouple,
-    kEnable,
-    "",
-    "gen-decouple-vtab",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --gen-decouple-vtab         \tGenerate the whole and complete vtab and itab\n"
-    "  --no-gen-decouple-vtab      \tDon't generate the whole and complete vtab and itab\n",
-    "mpl2mpl",
-    {} },
-  { kProfileFunc,
-    kEnable,
-    "",
-    "profile-func",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --profile-func              \tProfile function usage\n"
-    "  --no-profile-func           \tDisable profile function usage\n",
-    "mpl2mpl",
-    {} },
-  { kDumpDevirtual,
-    0,
-    "",
-    "dump-devirtual-list",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --dump-devirtual-list       \tDump candidates of devirtualization into a specified file\n"
-    "                              \t--dump-devirtual-list=\n",
-    "mpl2mpl",
-    {} },
-  { kReadDevirtual,
-    0,
-    "",
-    "read-devirtual-list",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --read-devirtual-list       \tRead in candidates of devirtualization from\n"
-    "                              \t a specified file and perform devirtualization\n"
-    "                              \t--read-devirtual-list=\n",
-    "mpl2mpl",
-    {} },
-  { kPreloadedClass,
-    kEnable,
-    "",
-    "usewhiteclass",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --usewhiteclass             \tEnable use preloaded class list to reducing clinit check\n"
-    "  --no-usewhiteclass          \tDisable use preloaded class list to reducing clinit check\n",
-    "mpl2mpl",
-    {} },
-  { kAppPackageName,
-    0,
-    "",
-    "app-package-name",
-    kBuildTypeExperimental,
-    kArgCheckPolicyOptional,
-    "  --app-package-name          \tSet APP package name\n"
-    "                              \t--app-package-name=package_name\n",
-    "mpl2mpl",
-    {} },
-  { kCheckClInvocation,
-    0,
-    "",
-    "check_cl_invocation",
-    kBuildTypeProduct,
-    kArgCheckPolicyRequired,
-    "  --check_cl_invocation       \tFor classloader invocation checking\n"
-    "                              \t--check_cl_invocation=list_file\n",
-    "mpl2mpl",
-    {} },
-  { kDumpClInvocation,
-    kEnable,
-    "",
-    "dump_cl_invocation",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --dump_cl_invocation        \tFor classloader invocation dumping.\n"
-    "                              \tWork only if already set --check_cl_invocation\n"
-    "  --no-dump_cl_invocation     \tDisable dump_cl_invocation\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplWarnLevel,
-    0,
-    "",
-    "warning",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNumeric,
-    "  --warning=level             \t--warning=level\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplLazyBinding,
-    kEnable,
-    "",
-    "lazy-binding",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --lazy-binding              \tBind class symbols lazily[default off]\n"
-    "  --no-lazy-binding           \tDon't bind class symbols lazily\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplHotFix,
-    kEnable,
-    "",
-    "hot-fix",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --hot-fix                   \tOpen for App hot fix[default off]\n"
-    "  --no-hot-fix                \tDon't open for App hot fix\n",
-    "mpl2mpl",
-    {} },
-  { kMpl2MplCompactMeta,
-    kEnable,
-    "",
-    "compact-meta",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --compact-meta              \tEnable compact method and field meta\n"
-    "  --no-compact-meta           \tDisable compact method and field meta\n",
-    "mpl2mpl",
-    {} },
-  { kGenPGOReport,
-    kEnable,
-    "",
-    "gen-pgo-report",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --gen-pgo-report            \tDisplay pgo report\n"
-    "  --no-gen-pgo-report\n",
-    "mpl2mpl",
-    {} },
-  { kInlineCache,
-    0,
-    "",
-    "inlineCache",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --inlineCache            \tbuild inlineCache 0:off, 1:open\n"
-    "  --no-inlineCache\n",
-    "mpl2mpl",
-    {} },
-  { kNoComment,
-    0,
-    "",
-    "no-comment",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --no-comment             \tbuild inlineCache 0:off, 1:open\n",
-    "mpl2mpl",
-    {} },
-  { kRmNoUseFunc,
-    kEnable,
-    "",
-    "rmnousefunc",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --rmnousefunc            \tEnable remove no-used file-static function\n"
-    "  --no-rmnousefunc         \tDisable remove no-used file-static function\n",
-    "mpl2mpl",
-    {} },
-  { kSideEffect,
-    kEnable,
-    "",
-    "sideeffect",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --sideeffect      \tIPA: analysis sideeffect\n"
-    "  --no-sideeffect          \n",
-    "mpl2mpl",
-    {} },
-  { kDumpIPA,
-    kEnable,
-    "",
-    "dump-ipa",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --dump-ipa      \tIPA: dump\n"
-    "  --no-dump-ipa          \n",
-    "mpl2mpl",
-    {} },
-  { kWPAA,
-    kEnable,
-    "",
-    "wpaa",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --wpaa      \tWhole Program Alias Analysis\n"
-    "  --no-wpaa          \n",
-    "mpl2mpl",
-    {} },
-  { kUnknown,
-    0,
-    "",
-    "",
-    kBuildTypeAll,
-    kArgCheckPolicyNone,
-    "",
-    "mpl2mpl",
-    {} }
-};
-
 Options &Options::GetInstance() {
   static Options instance;
   return instance;
 }
 
-Options::Options() {
-  CreateUsages(kUsage);
-}
-
-void Options::DecideMpl2MplRealLevel(const std::deque<mapleOption::Option> &inputOptions) const {
-  int realLevel = -1;
-  for (const mapleOption::Option &opt : inputOptions) {
-    switch (opt.Index()) {
-      case kMpl2MplOptL0:
-        realLevel = static_cast<int>(kLevelZero);
-        break;
-      case kMpl2MplOptL2:
-        realLevel = static_cast<int>(kLevelTwo);
-        break;
-      case kMpl2MplOptLs:
-        optForSize = true;
-        realLevel = static_cast<int>(kLevelTwo);
-        break;
-      default:
-        break;
+bool Options::SolveOptions(bool isDebug) const {
+  for (const auto &opt : mpl2mplCategory.GetEnabledOptions()) {
+    std::string printOpt;
+    if (isDebug) {
+      for (const auto &val : opt->GetRawValues()) {
+        printOpt += opt->GetName() + " " + val + " ";
+      }
+      LogInfo::MapleLogger() << "mpl2mpl options: " << printOpt << '\n';
     }
   }
-  if (realLevel == kLevelTwo) {
-    O2 = true;
-    usePreg = true;
+
+  cl::CopyIfEnabled(dumpBefore, opts::mpl2mpl::dumpBefore);
+  cl::CopyIfEnabled(dumpAfter, opts::mpl2mpl::dumpAfter);
+  cl::CopyIfEnabled(dumpFunc, opts::mpl2mpl::dumpFunc);
+
+  // quiet can be set from verbose in driver
+  cl::CopyIfEnabled(quiet, !opts::verbose, opts::verbose);
+  cl::CopyIfEnabled(quiet, opts::mpl2mpl::quiet);
+
+  cl::CopyIfEnabled(dumpPhase, opts::mpl2mpl::dumpPhase);
+  cl::CopyIfEnabled(skipPhase, opts::mpl2mpl::skipPhase);
+  cl::CopyIfEnabled(skipFrom, opts::mpl2mpl::skipFrom);
+  cl::CopyIfEnabled(skipAfter, opts::mpl2mpl::skipAfter);
+
+  cl::CopyIfEnabled(regNativeDynamicOnly, opts::mpl2mpl::regnativeDynamicOnly);
+  cl::CopyIfEnabled(staticBindingList, opts::mpl2mpl::staticBindingList);
+  cl::CopyIfEnabled(regNativeFunc, opts::mpl2mpl::regnativefunc);
+  cl::CopyIfEnabled(nativeWrapper, opts::mpl2mpl::nativewrapper);
+  cl::CopyIfEnabled(inlineWithProfile, opts::mpl2mpl::inlineWithProfile);
+  cl::CopyIfEnabled(useInline, opts::mpl2mpl::inlineOpt);
+  cl::CopyIfEnabled(enableIPAClone, opts::mpl2mpl::ipaClone);
+  cl::CopyIfEnabled(noInlineFuncList, opts::mpl2mpl::noInlineFunc);
+  cl::CopyIfEnabled(importFileList, opts::mpl2mpl::importFileList);
+  cl::CopyIfEnabled(useCrossModuleInline, opts::mpl2mpl::crossModuleInline);
+
+  cl::CopyIfEnabled(inlineSmallFunctionThreshold, opts::mpl2mpl::inlineSmallFunctionThreshold);
+  cl::CopyIfEnabled(inlineHotFunctionThreshold, opts::mpl2mpl::inlineHotFunctionThreshold);
+  cl::CopyIfEnabled(inlineRecursiveFunctionThreshold, opts::mpl2mpl::inlineRecursiveFunctionThreshold);
+  cl::CopyIfEnabled(inlineDepth, opts::mpl2mpl::inlineDepth);
+  cl::CopyIfEnabled(inlineModuleGrowth, opts::mpl2mpl::inlineModuleGrow);
+  cl::CopyIfEnabled(inlineColdFunctionThreshold, opts::mpl2mpl::inlineColdFuncThresh);
+  cl::CopyIfEnabled(profileHotCount, opts::mpl2mpl::profileHotCount);
+  cl::CopyIfEnabled(profileColdCount, opts::mpl2mpl::profileColdCount);
+  cl::CopyIfEnabled(profileHotRate, opts::mpl2mpl::profileHotRate);
+  cl::CopyIfEnabled(profileColdRate, opts::mpl2mpl::profileColdRate);
+
+  cl::CopyIfEnabled(dumpMuidFile, opts::mpl2mpl::dumpMuid);
+  if (opts::mpl2mpl::maplelinker) {
+    mapleLinker = opts::mpl2mpl::maplelinker;
+    dumpMuidFile = true; // quiet is overwrited by maplelinker option
   }
-}
 
-bool Options::SolveOptions(const std::deque<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 kMpl2MplDumpAfter:
-        dumpAfter = (opt.Type() == kEnable);
-        break;
-      case kMpl2MplDumpFunc:
-        dumpFunc = opt.Args();
-        break;
-      case kMpl2MplQuiet:
-        quiet = (opt.Type() == kEnable);
-        break;
-      case kVerbose:
-        quiet = (opt.Type() == kEnable) ? false : true;
-        break;
-      case kMpl2MplDumpPhase:
-        dumpPhase = opt.Args();
-        break;
-      case kMpl2MplSkipPhase:
-        skipPhase = opt.Args();
-        break;
-      case kMpl2MplSkipFrom:
-        skipFrom = opt.Args();
-        break;
-      case kMpl2MplSkipAfter:
-        skipAfter = opt.Args();
-        break;
-      case kRegNativeDynamicOnly:
-        regNativeDynamicOnly = (opt.Type() == kEnable);
-        break;
-      case kRegNativeStaticBindingList:
-        staticBindingList = opt.Args();
-        break;
-      case kMpl2MplStubJniFunc:
-        regNativeFunc = (opt.Type() == kEnable);
-        break;
-      case kNativeWrapper:
-        nativeWrapper = (opt.Type() == kEnable);
-        break;
-      case kInlineWithProfile:
-        inlineWithProfile = (opt.Type() == kEnable);
-        break;
-      case kMpl2MplUseInline:
-        useInline = (opt.Type() == kEnable);
-        break;
-      case kMpl2MplEnableIPAClone:
-        enableIPAClone = (opt.Type() == kEnable);
-        break;
-      case kMpl2MplNoInlineFuncList:
-        noInlineFuncList = opt.Args();
-        break;
-      case kImportFileList:
-        importFileList = opt.Args();
-        break;
-      case kMpl2MplUseCrossModuleInline:
-        useCrossModuleInline = (opt.Type() == kEnable);
-        break;
-      case kInlineSmallFunctionThreshold:
-        if (opt.Args().empty()) {
-          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --inline-small-function-threshold\n";
-          result = false;
-        } else {
-          inlineSmallFunctionThreshold = static_cast<uint32>(std::stoul(opt.Args()));
-        }
-        break;
-      case kInlineHotFunctionThreshold:
-        if (opt.Args().empty()) {
-          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --inline-hot-function-threshold\n";
-          result = false;
-        } else {
-          inlineHotFunctionThreshold = static_cast<uint32>(std::stoul(opt.Args()));
-        }
-        break;
-      case kInlineRecursiveFunctionThreshold:
-        if (opt.Args().empty()) {
-          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --inline-recursive-function-threshold\n";
-          result = false;
-        } else {
-          inlineRecursiveFunctionThreshold = static_cast<uint32>(std::stoul(opt.Args()));
-        }
-        break;
-      case kInlineDepth:
-        if (opt.Args().empty()) {
-          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --inline-depth\n";
-          result = false;
-        } else {
-          inlineDepth = static_cast<uint32>(std::stoul(opt.Args()));
-        }
-        break;
-      case kInlineModuleGrowth:
-        if (opt.Args().empty()) {
-          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --inline-module-growth\n";
-          result = false;
-        } else {
-          inlineModuleGrowth = static_cast<uint32>(std::stoul(opt.Args()));
-        }
-        break;
-      case kInlineColdFunctionThreshold:
-        if (opt.Args().empty()) {
-          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --inline-cold-function-threshold\n";
-          result = false;
-        } else {
-          inlineColdFunctionThreshold = static_cast<uint32>(std::stoul(opt.Args()));
-        }
-        break;
-      case kProfileHotCount:
-        if (opt.Args().empty()) {
-          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --profile-hot-count\n";
-          result = false;
-        } else {
-          profileHotCount = static_cast<uint32>(std::stoul(opt.Args()));
-        }
-        break;
-      case kProfileColdCount:
-        if (opt.Args().empty()) {
-          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --profile-cold-count\n";
-          result = false;
-        } else {
-          profileColdCount = static_cast<uint32>(std::stoul(opt.Args()));
-        }
-        break;
-      case kProfileHotRate:
-        if (opt.Args().empty()) {
-          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --profile-hot-rate\n";
-          result = false;
-        } else {
-          profileHotRate = static_cast<uint32>(std::stoul(opt.Args()));
-        }
-        break;
-      case kProfileColdRate:
-        if (opt.Args().empty()) {
-          LogInfo::MapleLogger(kLlErr) << "expecting not empty for --profile-cold-rate\n";
-          result = false;
-        } else {
-          profileColdRate = static_cast<uint32>(std::stoul(opt.Args()));
-        }
-        break;
-      case kMpl2MplMapleLinker:
-        mapleLinker = (opt.Type() == kEnable);
-        dumpMuidFile = (opt.Type() == kEnable);
-        if (isDebug) {
-          LogInfo::MapleLogger() << "--sub options: dumpMuidFile " << dumpMuidFile << '\n';
-        }
-        break;
-      case kMplnkDumpMuid:
-        dumpMuidFile = (opt.Type() == kEnable);
-        break;
-      case kEmitVtableImpl:
-        emitVtableImpl = (opt.Type() == kEnable);
-        break;
+  cl::CopyIfEnabled(emitVtableImpl, opts::mpl2mpl::emitVtableImpl);
 #if MIR_JAVA
-      case kMpl2MplSkipVirtual:
-        skipVirtualMethod = (opt.Type() == kEnable);
-        break;
+  cl::CopyIfEnabled(skipVirtualMethod, opts::mpl2mpl::skipvirtual);
 #endif
-      case kMpl2MplUseRc:
-        noRC = (opt.Type() == kDisable);
-        break;
-      case kMpl2MplStrictNaiveRc:
-        strictNaiveRC = (opt.Type() == kEnable);
-        break;
-      case kGCOnly:
-        gcOnly = (opt.Type() == kEnable);
-        break;
-      case kBigEndian:
-        bigEndian = (opt.Type() == kEnable);
-        break;
-      case kRcOpt1:
-        rcOpt1 = (opt.Type() == kEnable);
-        break;
-      case kMpl2MplNativeOpt:
-        nativeOpt = (opt.Type() == kEnable);
-        break;
-      case kMpl2MplOptL2:
-      case kMpl2MplOptLs:
-        // Already handled above in DecideMpl2MplRealLevel
-        break;
-      case kCriticalnative:
-        criticalNativeFile = opt.Args();
-        break;
-      case kFastnative:
-        fastNativeFile = opt.Args();
-        break;
-      case kMpl2MplNoDot:
-        noDot = (opt.Type() == kEnable);
-        break;
-      case kGenIRProfile:
-        genIRProfile = (opt.Type() == kEnable);
-        break;
-      case kProfileTest:
-        profileTest = (opt.Type() == kEnable);
-        break;
-      case kMpl2MplBarrier:
-        barrier =  (opt.Type() == kEnable);
-        break;
-      case kNativeFuncPropertyFile:
-        nativeFuncPropertyFile = opt.Args();
-        break;
-      case kMplnkNoLocal:
-        mapleLinkerTransformLocal = (opt.Type() == kDisable);
-        break;
-      case kDeferredVisit:
-        deferredVisit =  (opt.Type() == kEnable);
-        break;
-      case kDeferredVisit2:
-        deferredVisit = (opt.Type() == kEnable);
-        deferredVisit2 = (opt.Type() == kEnable);
-        if (isDebug) {
-          LogInfo::MapleLogger() << "--sub options: deferredVisit " << deferredVisit << '\n';
-          LogInfo::MapleLogger() << "--sub options: deferredVisit2 " << deferredVisit2 << '\n';
-        }
-        break;
-      case kDecoupleSuper:
-        decoupleSuper = (opt.Type() == kEnable);
-        break;
-      case kBuildApp:
-        if (opt.Args().empty()) {
-          buildApp = 1;
-        } else if (opt.Args().size() == 1 &&
-                   (opt.Args()[0] == '0' || opt.Args()[0] == '1' || opt.Args()[0] == '2')) {
-          buildApp = static_cast<uint32>(std::stoul(opt.Args()));
-        } else {
-          LogInfo::MapleLogger(kLlErr) << "expecting 0,1,2 or empty for --build-app\n";
-          result = false;
-        }
-        break;
-      case kSourceMuid:
-        sourceMuid = opt.Args();
-        break;
-      case kDecoupleStatic:
-        decoupleStatic = (opt.Type() == kEnable);
-        (opt.Type() == kEnable) ? (buildApp = 1) : (buildApp = 0);
-        break;
-      case kPartialAot:
-        partialAot = (opt.Type() == kEnable);
-        break;
-      case kDecoupleInit:
-        if (opt.Args().empty()) {
-          decoupleInit = Options::kConservativeDecouple;
-          decoupleStatic = true;
-          buildApp = Options::kConservativeDecouple;
-        } else if (opt.Args().size() == 1 && (opt.Args()[0] == '0' || opt.Args()[0] == '1' || opt.Args()[0] == '2')) {
-          decoupleInit = static_cast<uint32>(std::stoi(opt.Args()));
-          decoupleStatic = true;
-          buildApp = Options::kConservativeDecouple;
-        } else {
-          std::cerr << "expecting 0,1,2 or empty for --decouple-init\n";
-          result = false;
-        }
-        break;
-      case kGenVtabAndItabForDecouple:
-        genVtabAndItabForDecouple = (opt.Type() == kEnable);
-        break;
-      case kProfileFunc:
-        profileFunc = (opt.Type() == kEnable);
-        break;
-      case kDumpDevirtual:
-        dumpDevirtualList = opt.Args();
-        break;
-      case kReadDevirtual:
-        readDevirtualList = opt.Args();
-        break;
-      case kPreloadedClass:
-        usePreloadedClass = (opt.Type() == kEnable);
-        break;
-      case kProfilePath:
-        profile = opt.Args();
-        break;
-      case kProfileGen:
-        if (O2) {
-          LogInfo::MapleLogger(kLlErr) << "profileGen requires no optimization\n";
-          result = false;
-        } else {
-          profileGen = true;
-        }
-        break;
-      case kProfileUse:
-        profileUse = true;
-        break;
-      case kAppPackageName:
-        appPackageName = opt.Args();
-        break;
-      case kCheckClInvocation:
-        classLoaderInvocationList = opt.Args();
-        break;
-      case kDumpClInvocation:
-        dumpClassLoaderInvocation = (opt.Type() == kEnable);
-        break;
-      case kMpl2MplWarnLevel:
-        warningLevel = static_cast<uint32>(std::stoul(opt.Args()));
-        break;
-      case kMpl2MplLazyBinding:
-        lazyBinding = (opt.Type() == kEnable);
-        break;
-      case kMpl2MplHotFix:
-        hotFix = (opt.Type() == kEnable);
-        break;
-      case kMpl2MplCompactMeta:
-        compactMeta = (opt.Type() == kEnable);
-        break;
-      case kGenPGOReport:
-        genPGOReport = (opt.Type() == kEnable);
-        break;
-      case kVerify:
-        verify = (opt.Type() == kEnable);
-        break;
-      case kInlineCache:
-        if (opt.Args().empty()) {
-          inlineCache = 0;
-        } else if (opt.Args().size() == 1 && (opt.Args()[0] == '0' ||
-                                              opt.Args()[0] == '1' ||
-                                              opt.Args()[0] == '2' ||
-                                              opt.Args()[0] == '3')) {
-          inlineCache = static_cast<uint32>(std::stoi(opt.Args()));
-        } else {
-          LogInfo::MapleLogger(kLlErr) << "expecting 0,1,2,3 or empty for --inlineCache\n";
-          result = false;
-        }
-        break;
-      case kNoComment:
-        noComment = true;
-        break;
-      case kRmNoUseFunc:
-        rmNoUseFunc = (opt.Type() == kEnable);
-        break;
-      case kSideEffect:
-        sideEffect = (opt.Type() == kEnable);
-        break;
-      case kDumpIPA:
-        dumpIPA = (opt.Type() == kEnable);
-        break;
-      case kWPAA:
-        wpaa = (opt.Type() == kEnable);
-        break;
-      default:
-        WARN(kLncWarn, "input invalid key for mpl2mpl " + opt.OptionKey());
-        break;
+  cl::CopyIfEnabled(noRC, opts::mpl2mpl::userc);
+  cl::CopyIfEnabled(strictNaiveRC, opts::mpl2mpl::strictNaiveRc);
+
+  cl::CopyIfEnabled(gcOnly, opts::gconly);
+  cl::CopyIfEnabled(bigEndian, opts::bigendian);
+  cl::CopyIfEnabled(rcOpt1, opts::mpl2mpl::rcOpt1);
+  cl::CopyIfEnabled(nativeOpt, opts::mpl2mpl::nativeopt);
+  cl::CopyIfEnabled(criticalNativeFile, opts::mpl2mpl::criticalNative);
+  cl::CopyIfEnabled(fastNativeFile, opts::mpl2mpl::fastNative);
+  cl::CopyIfEnabled(noDot, opts::mpl2mpl::nodot);
+  cl::CopyIfEnabled(genIRProfile, opts::mpl2mpl::genIrProfile);
+  cl::CopyIfEnabled(profileTest, opts::mpl2mpl::profileTest);
+  cl::CopyIfEnabled(barrier, opts::mpl2mpl::barrier);
+  cl::CopyIfEnabled(nativeFuncPropertyFile, opts::mpl2mpl::nativeFuncPropertyFile);
+  cl::CopyIfEnabled(mapleLinkerTransformLocal, opts::mpl2mpl::maplelinkerNolocal);
+  cl::CopyIfEnabled(deferredVisit, opts::mpl2mpl::deferredVisit);
+
+  if (opts::mpl2mpl::deferredVisit.IsEnabledByUser()) {
+    deferredVisit = true;
+    deferredVisit2 = true;
+    if (isDebug) {
+      LogInfo::MapleLogger() << "--sub options: deferredVisit " << deferredVisit << '\n';
+      LogInfo::MapleLogger() << "--sub options: deferredVisit2 " << deferredVisit2 << '\n';
+    }
+  }
+
+  cl::CopyIfEnabled(decoupleSuper, opts::mpl2mpl::decoupleSuper);
+
+  if (opts::mpl2mpl::buildApp.IsEnabledByUser()) {
+    if (opts::mpl2mpl::buildApp != 0 &&
+        opts::mpl2mpl::buildApp != 1 &&
+        opts::mpl2mpl::buildApp != 2) {
+      LogInfo::MapleLogger(kLlErr) << "expecting 0,1,2 or empty for --build-app\n";
+      return false;
+    }
+    buildApp = opts::mpl2mpl::buildApp;
+  }
+
+  cl::CopyIfEnabled(sourceMuid, opts::mpl2mpl::sourceMuid);
+  if (opts::decoupleStatic.IsEnabledByUser()) {
+    decoupleStatic = opts::decoupleStatic;
+    buildApp = (opts::decoupleStatic == true) ? 1 : 0;
+  }
+
+  cl::CopyIfEnabled(partialAot, opts::mpl2mpl::partialAot);
+
+  if (opts::mpl2mpl::decoupleInit.IsEnabledByUser()) {
+    if (opts::mpl2mpl::decoupleInit != 0 &&
+        opts::mpl2mpl::decoupleInit != 1 &&
+        opts::mpl2mpl::decoupleInit != 2) {
+      std::cerr << "expecting 0,1,2 or empty for --decouple-init\n";
+      return false;
+    }
+
+    decoupleInit = opts::mpl2mpl::decoupleInit;
+    decoupleStatic = true;
+    buildApp = 1;
+  }
+
+  cl::CopyIfEnabled(genVtabAndItabForDecouple, opts::mpl2mpl::genDecoupleVtab);
+  cl::CopyIfEnabled(profileFunc, opts::mpl2mpl::profileFunc);
+  cl::CopyIfEnabled(dumpDevirtualList, opts::mpl2mpl::dumpDevirtual);
+  cl::CopyIfEnabled(readDevirtualList, opts::mpl2mpl::readDevirtual);
+  cl::CopyIfEnabled(usePreloadedClass, opts::mpl2mpl::usewhiteclass);
+  cl::CopyIfEnabled(profile, opts::profile);
+
+  cl::CopyIfEnabled(appPackageName, opts::mpl2mpl::appPackageName);
+  cl::CopyIfEnabled(classLoaderInvocationList, opts::mpl2mpl::checkClInvocation);
+  cl::CopyIfEnabled(dumpClassLoaderInvocation, opts::mpl2mpl::dumpClInvocation);
+  cl::CopyIfEnabled(warningLevel, opts::mpl2mpl::warning);
+  cl::CopyIfEnabled(lazyBinding, opts::mpl2mpl::lazyBinding);
+  cl::CopyIfEnabled(hotFix, opts::mpl2mpl::hotFix);
+  cl::CopyIfEnabled(compactMeta, opts::mpl2mpl::compactMeta);
+  cl::CopyIfEnabled(genPGOReport, opts::mpl2mpl::genPGOReport);
+
+  cl::CopyIfEnabled(verify, opts::verify);
+
+  if (opts::mpl2mpl::inlineCache) {
+    if (opts::mpl2mpl::inlineCache != 0 &&
+        opts::mpl2mpl::inlineCache != 1 &&
+        opts::mpl2mpl::inlineCache != 2 &&
+        opts::mpl2mpl::inlineCache != 3) {
+      LogInfo::MapleLogger(kLlErr) << "expecting 0,1,2,3 or empty for --inlineCache\n";
+      return false;
     }
+
+    inlineCache = opts::mpl2mpl::inlineCache;
   }
-  return result;
+
+  cl::CopyIfEnabled(noComment, opts::mpl2mpl::noComment);
+  cl::CopyIfEnabled(rmNoUseFunc, opts::mpl2mpl::rmnousefunc);
+  cl::CopyIfEnabled(sideEffect, opts::mpl2mpl::sideeffect);
+
+  if (opts::mpl2mpl::o2 || opts::mpl2mpl::os) {
+    if (opts::mpl2mpl::os) {
+      optForSize = true;
+    }
+    O2 = true;
+    usePreg = true;
+  }
+
+  cl::CopyIfEnabled(dumpIPA, opts::mpl2mpl::dumpIPA);
+  cl::CopyIfEnabled(wpaa, opts::mpl2mpl::wpaa);
+
+  return true;
 }
 
 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);
+  cl::CommandLine::GetCommandLine().Parse(argc, (char **)argv, mpl2mplCategory);
+
+  bool result = SolveOptions(false);
   if (!result) {
-    return result;
+    return false;
   }
-  if (optionParser.GetNonOptionsCount() != 1) {
+
+  auto &badArgs = cl::CommandLine::GetCommandLine().badCLArgs;
+  int count = 0;
+  for (auto &arg : badArgs) {
+    if (FileUtils::IsFileExists(arg.first)) {
+      count++;
+      fileName = arg.first;
+    }
+  }
+
+  if (count != 1) {
     LogInfo::MapleLogger(kLlErr) << "expecting one .mpl file as last argument, found: ";
-    for (const auto &optionArg : optionParser.GetNonOptions()) {
-      LogInfo::MapleLogger(kLlErr) << optionArg << " ";
+    for (const auto &optionArg : badArgs) {
+      LogInfo::MapleLogger(kLlErr) << optionArg.first << " ";
     }
     LogInfo::MapleLogger(kLlErr) << "\n";
-    result = false;
+    return false;
   }
 
-  if (result) {
-    fileName = optionParser.GetNonOptions().front();
 #ifdef DEBUG_OPTION
     LogInfo::MapleLogger() << "mpl file : " << fileName << "\t";
     DumpOptions();
 #endif
-  }
-  return result;
+
+  return true;
 }
 
 void Options::DumpOptions() const {
diff --git a/src/mapleall/maple_me/BUILD.gn b/src/mapleall/maple_me/BUILD.gn
index bdc24d533e7a6c054582f5f0d605bcfae5b4a05d..1051bf1e4f8f52234c0e80c2ccac931e8bff6789 100755
--- a/src/mapleall/maple_me/BUILD.gn
+++ b/src/mapleall/maple_me/BUILD.gn
@@ -61,6 +61,7 @@ src_libmplme = [
   "src/me_scalar_analysis.cpp",
   "src/me_loop_unrolling.cpp",
   "src/me_option.cpp",
+  "src/me_options.cpp",
   "src/me_phase_manager.cpp",
   "src/me_prop.cpp",
   "src/copy_prop.cpp",
diff --git a/src/mapleall/maple_me/include/me_option.h b/src/mapleall/maple_me/include/me_option.h
index c1c581958940e00ab50346054c44855614a4ebe5..e6e0062d8202a35a45c1b6e020c1e6e88d6d1fc9 100644
--- a/src/mapleall/maple_me/include/me_option.h
+++ b/src/mapleall/maple_me/include/me_option.h
@@ -20,19 +20,15 @@
 #include "mempool_allocator.h"
 #include "mpl_options.h"
 #include "types_def.h"
-#include "driver_option_common.h"
-#include "option_parser.h"
+#include "mpl_options.h"
 
 namespace maple {
-class MeOption : public MapleDriverOptionBase {
+class MeOption {
  public:
   static MeOption &GetInstance();
-
-  MeOption();
-
   ~MeOption() = default;
 
-  bool SolveOptions(const std::deque<mapleOption::Option> &opts, bool isDebug);
+  bool SolveOptions(bool isDebug);
 
   void ParseOptions(int argc, char **argv, std::string &fileName);
 
@@ -201,8 +197,6 @@ class MeOption : public MapleDriverOptionBase {
   static bool mplToolStrict;
   static bool skipVirtualMethod;
 #endif
- private:
-  void DecideMeRealLevel(const std::deque<mapleOption::Option> &inputOptions) const;
 };
 
 #ifndef DEBUGFUNC
diff --git a/src/mapleall/maple_me/include/me_options.h b/src/mapleall/maple_me/include/me_options.h
new file mode 100644
index 0000000000000000000000000000000000000000..d0f6c77c5e1ac675bb2af3f35cf9362b82b35350
--- /dev/null
+++ b/src/mapleall/maple_me/include/me_options.h
@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * 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 v2 for more details.
+ */
+
+#ifndef MAPLE_ME_INCLUDE_ME_OPTIONS_H
+#define MAPLE_ME_INCLUDE_ME_OPTIONS_H
+
+#include "cl_option.h"
+#include "cl_parser.h"
+#include "types_def.h"
+
+#include <cstdint>
+#include <string>
+
+namespace opts::me {
+
+extern cl::Option<bool> help;
+extern cl::Option<bool> o1;
+extern cl::Option<bool> o2;
+extern cl::Option<bool> os;
+extern cl::Option<bool> o3;
+extern cl::Option<std::string> refusedcheck;
+extern cl::Option<std::string> range;
+extern cl::Option<std::string> dumpPhases;
+extern cl::Option<std::string> skipPhases;
+extern cl::Option<std::string> dumpFunc;
+extern cl::Option<bool> quiet;
+extern cl::Option<bool> nodot;
+extern cl::Option<bool> userc;
+extern cl::Option<bool> strictNaiverc;
+extern cl::Option<std::string> skipFrom;
+extern cl::Option<std::string> skipAfter;
+extern cl::Option<bool> calleeHasSideEffect;
+extern cl::Option<bool> ubaa;
+extern cl::Option<bool> tbaa;
+extern cl::Option<bool> ddaa;
+extern cl::Option<uint8_t> aliasAnalysisLevel;
+extern cl::Option<bool> stmtnum;
+extern cl::Option<bool> rclower;
+extern cl::Option<bool> gconlyopt;
+extern cl::Option<bool> usegcbar;
+extern cl::Option<bool> regnativefunc;
+extern cl::Option<bool> warnemptynative;
+extern cl::Option<bool> dumpBefore;
+extern cl::Option<bool> dumpAfter;
+extern cl::Option<bool> realcheckcast;
+extern cl::Option<uint32_t> eprelimit;
+extern cl::Option<uint32_t> eprepulimit;
+extern cl::Option<uint32_t> stmtprepulimit;
+extern cl::Option<uint32_t> lprelimit;
+extern cl::Option<uint32_t> lprepulimit;
+extern cl::Option<uint32_t> pregrenamelimit;
+extern cl::Option<uint32_t> rename2preglimit;
+extern cl::Option<uint32_t> proplimit;
+extern cl::Option<uint32_t> copyproplimit;
+extern cl::Option<uint32_t> delrcpulimit;
+extern cl::Option<uint32_t> profileBbHotRate;
+extern cl::Option<uint32_t> profileBbColdRate;
+extern cl::Option<bool> ignoreipa;
+extern cl::Option<bool> aggressiveABCO;
+extern cl::Option<bool> commonABCO;
+extern cl::Option<bool> conservativeABCO;
+extern cl::Option<bool> epreincluderef;
+extern cl::Option<bool> eprelocalrefvar;
+extern cl::Option<bool> eprelhsivar;
+extern cl::Option<bool> dsekeepref;
+extern cl::Option<bool> propbase;
+extern cl::Option<bool> propiloadref;
+extern cl::Option<bool> propglobalref;
+extern cl::Option<bool> propfinaliloadref;
+extern cl::Option<bool> propiloadrefnonparm;
+extern cl::Option<bool> lessthrowalias;
+extern cl::Option<bool> nodelegaterc;
+extern cl::Option<bool> nocondbasedrc;
+extern cl::Option<bool> subsumrc;
+extern cl::Option<bool> performFSAA;
+extern cl::Option<bool> strengthreduction;
+extern cl::Option<bool> sradd;
+extern cl::Option<bool> lftr;
+extern cl::Option<bool> ivopts;
+extern cl::Option<bool> checkcastopt;
+extern cl::Option<bool> parmtoptr;
+extern cl::Option<bool> nullcheckpre;
+extern cl::Option<bool> clinitpre;
+extern cl::Option<bool> dassignpre;
+extern cl::Option<bool> assign2finalpre;
+extern cl::Option<bool> regreadatreturn;
+extern cl::Option<bool> propatphi;
+extern cl::Option<bool> propduringbuild;
+extern cl::Option<bool> propwithinverse;
+extern cl::Option<bool> nativeopt;
+extern cl::Option<bool> optdirectcall;
+extern cl::Option<bool> enableEa;
+extern cl::Option<bool> lprespeculate;
+extern cl::Option<bool> lpre4address;
+extern cl::Option<bool> lpre4largeint;
+extern cl::Option<bool> spillatcatch;
+extern cl::Option<bool> placementrc;
+extern cl::Option<bool> lazydecouple;
+extern cl::Option<bool> mergestmts;
+extern cl::Option<bool> generalRegOnly;
+extern cl::Option<std::string> inlinefunclist;
+extern cl::Option<uint32_t> threads;
+extern cl::Option<bool> ignoreInferredRetType;
+extern cl::Option<bool> meverify;
+extern cl::Option<uint32_t> dserunslimit;
+extern cl::Option<uint32_t> hdserunslimit;
+extern cl::Option<uint32_t> hproprunslimit;
+extern cl::Option<uint32_t> sinklimit;
+extern cl::Option<uint32_t> sinkPUlimit;
+extern cl::Option<bool> loopvec;
+extern cl::Option<bool> seqvec;
+extern cl::Option<bool> layoutwithpredict;
+extern cl::Option<uint32_t> veclooplimit;
+extern cl::Option<uint32_t> ivoptslimit;
+extern cl::Option<std::string> acquireFunc;
+extern cl::Option<std::string> releaseFunc;
+extern cl::Option<bool> toolonly;
+extern cl::Option<bool> toolstrict;
+extern cl::Option<bool> skipvirtual;
+extern cl::Option<uint32_t> warning;
+extern cl::Option<uint8_t> remat;
+extern cl::Option<bool> unifyrets;
+extern cl::Option<bool> lfo;
+
+}
+
+#endif /* MAPLE_ME_INCLUDE_ME_OPTIONS_H */
diff --git a/src/mapleall/maple_me/src/me_option.cpp b/src/mapleall/maple_me/src/me_option.cpp
index 1a3df75f8844e29425c2d766d1c1e8c0961af678..23403feae1a6c0de3c209c505d0b3a8910033f08 100644
--- a/src/mapleall/maple_me/src/me_option.cpp
+++ b/src/mapleall/maple_me/src/me_option.cpp
@@ -12,11 +12,15 @@
  * FIT FOR A PARTICULAR PURPOSE.
  * See the Mulan PSL v2 for more details.
  */
+#include "driver_options.h"
+#include "file_utils.h"
 #include "me_option.h"
+#include "me_options.h"
+#include <fstream>
 #include <iostream>
 #include <cstring>
 #include "mpl_logging.h"
-#include "option_parser.h"
+#include "mpl_options.h"
 #include "string_utils.h"
 
 namespace maple {
@@ -139,1262 +143,36 @@ bool MeOption::mplToolStrict = false;
 bool MeOption::skipVirtualMethod = false;
 #endif
 
-enum OptionIndex {
-  kMeHelp = kCommonOptionEnd + 1,
-  kMeDumpPhases,
-  kMeSkipPhases,
-  kMeDumpFunc,
-  kMeQuiet,
-  kMeNoDot,
-  kMeUseRc,
-  kMeStrictNaiveRc,
-  kMeStubJniFunc,
-  kMeToolOnly,
-  kMeToolStrict,
-  kMeSkipVirtual,
-  kMeNativeOpt,
-  kMeSkipFrom,
-  kMeSkipAfter,
-  kSetCalleeHasSideEffect,
-  kUnionBasedAA,
-  kTBAA,
-  kDDAA,
-  kAliasAnalysisLevel,
-  kStmtNum,
-  kRcLower,
-  kNoRcLower,
-  kGCOnlyOpt,
-  kNoGcbar,
-  kUseGcbar,
-  kWarnNativefunc,
-  kMeDumpBefore,
-  kMeDumpAfter,
-  kRealCheckcast,
-  kMeAcquireFunc,
-  kMeReleaseFunc,
-  kMeWarnLevel,
-  kMeOptL1,
-  kMeOptL2,
-  kMeOptLs, // optimize for size
-  kMeOptL3,
-  kRefUsedCheck,
-  kMeRange,
-  kEpreLimit,
-  kEprepuLimit,
-  kStmtPrepuLimit,
-  kLpreLimit,
-  kLprepulLimit,
-  kPregreNameLimit,
-  kRename2pregLimit,
-  kPropLimit,
-  kCopyPropLimit,
-  kDelrcpuLimit,
-  kProfileBBHotRate,
-  kProfileBBColdRate,
-  kIgnoreIpa,
-  kAggressiveABCO,
-  kCommonABCO,
-  kConservativeABCO,
-  kEpreIncludeRef,
-  kNoEpreIncludeRef,
-  kEpreLocalRefVar,
-  kNoEpreLocalRefVar,
-  kEprelhSivar,
-  kDseKeepRef,
-  kNoDseKeepRef,
-  kPropBase,
-  kNopropiLoadRef,
-  kPropiLoadRef,
-  kPropGloablRef,
-  kPropfinalIloadRef,
-  kPropIloadRefnonparm,
-  kLessThrowAlias,
-  kNodeLegateRc,
-  kNocondBasedRc,
-  kCheckCastOpt,
-  kNoCheckCastOpt,
-  kParmToptr,
-  kNullcheckPre,
-  kClinitPre,
-  kDassignPre,
-  kAssign2finalPre,
-  kSubsumRC,
-  kPerformFSAA,
-  kStrengthReduction,
-  kSRAdd,
-  kLFTR,
-  kIVOPTS,
-  kRegReadAtReturn,
-  kProPatphi,
-  kNoProPatphi,
-  kPropDuringBuild,
-  kPropWithInverse,
-  kOptInterfaceCall,
-  kNoOptInterfaceCall,
-  kOptVirtualCall,
-  kOptDirectCall,
-  kEnableEa,
-  kLpreSpeculate,
-  kNoLpreSpeculate,
-  kLpre4Address,
-  kNoLpre4Address,
-  kLpre4LargeInt,
-  kNoLpre4LargeInt,
-  kSpillatCatch,
-  kPlacementRC,
-  kNoPlacementRC,
-  kLazyDecouple,
-  kEaTransRef,
-  kEaTransAlloc,
-  kMergeStmts,
-  kMeGeneralRegOnly,
-  kMeInlineHint,
-  kMeThreads,
-  kMeIgnoreInferredRetType,
-  kMeVerify,
-  kDseRunsLimit,
-  kHdseRunsLimit,
-  kHpropRunsLimit,
-  kSinkLimit,
-  kSinkPULimit,
-  kLoopVec,
-  kSeqVec,
-  kEnableLFO,
-  kRematLevel,
-  kLayoutWithPredict,
-  kvecLoops,
-  kIvoptsLimit,
-  kUnifyRets,
-};
+bool MeOption::SolveOptions(bool isDebug) {
 
-const Descriptor kUsage[] = {
-  { kMeHelp,
-    0,
-    "h",
-    "help",
-    kBuildTypeExperimental,
-    kArgCheckPolicyOptional,
-    "  -h --help                   \tPrint usage and exit.Available command names:\n"
-    "                              \tme\n",
-    "me",
-    {} },
-  { kMeOptL1,
-    0,
-    "O1",
-    "",
-    kBuildTypeProduct,
-    kArgCheckPolicyOptional,
-    "  -O1                         \tDo some optimization.\n",
-    "me",
-    {} },
-  { kMeOptL2,
-    0,
-    "O2",
-    "",
-    kBuildTypeProduct,
-    kArgCheckPolicyOptional,
-    "  -O2                         \tDo some optimization.\n",
-    "me",
-    {} },
-  { kMeOptLs,
-    0,
-    "Os",
-    "",
-    kBuildTypeProduct,
-    kArgCheckPolicyOptional,
-    "  -Os                         \tOptimize for size, based on O2.\n",
-    "me",
-    {} },
-  { kMeOptL3,
-    0,
-    "O3",
-    "",
-    kBuildTypeProduct,
-    kArgCheckPolicyOptional,
-    "  -O3                         \tDo aggressive optimizations.\n",
-    "me",
-    {} },
-  { kRefUsedCheck,
-    0,
-    "",
-    "refusedcheck",
-    kBuildTypeProduct,
-    kArgCheckPolicyRequired,
-    "  --refusedcheck=FUNCNAME,...    \tEnable ref check used in func in the comma separated list, * means all func.\n",
-    "me",
-    {} },
-  { kMeRange,
-    0,
-    "",
-    "range",
-    kBuildTypeDebug,
-    kArgCheckPolicyRequired,
-    "  --range                     \tOptimize only functions in the range [NUM0, NUM1]\n"
-    "                              \t--range=NUM0,NUM1\n",
-    "me",
-    {} },
-  { kMeDumpPhases,
-    0,
-    "",
-    "dump-phases",
-    kBuildTypeDebug,
-    kArgCheckPolicyRequired,
-    "  --dump-phases               \tEnable debug trace for specified phases in the comma separated list\n"
-    "                              \t--dump-phases=PHASENAME,...\n",
-    "me",
-    {} },
-  { kMeSkipPhases,
-    0,
-    "",
-    "skip-phases",
-    kBuildTypeDebug,
-    kArgCheckPolicyRequired,
-    "  --skip-phases               \tSkip the phases specified in the comma separated list\n"
-    "                              \t--skip-phases=PHASENAME,...\n",
-    "me",
-    {} },
-  { kMeDumpFunc,
-    0,
-    "",
-    "dump-func",
-    kBuildTypeDebug,
-    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,
-    "",
-    "quiet",
-    kBuildTypeProduct,
-    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,
-    "",
-    "nodot",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --nodot                     \tDisable dot file generation from cfg\n"
-    "  --no-nodot                  \tEnable dot file generation from cfg\n",
-    "me",
-    {} },
-  { kMeUseRc,
-    kEnable,
-    "",
-    "userc",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --userc                     \tEnable reference counting [default]\n"
-    "  --no-userc                  \tDisable reference counting [default]\n",
-    "me",
-    {} },
-  { kMeStrictNaiveRc,
-    kEnable,
-    "",
-    "strict-naiverc",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --strict-naiverc            \tStrict Naive RC mode, assume no unsafe multi-thread read/write racing\n"
-    "  --no-strict-naiverc         \tDisable Strict Naive RC mode, assume no unsafe multi-thread read/write racing\n",
-    "me",
-    {} },
-  { kMeSkipFrom,
-    0,
-    "",
-    "skip-from",
-    kBuildTypeDebug,
-    kArgCheckPolicyRequired,
-    "  --skip-from                 \tSkip the rest phases from PHASENAME(included)\n"
-    "                              \t--skip-from=PHASENAME\n",
-    "me",
-    {} },
-  { kMeSkipAfter,
-    0,
-    "",
-    "skip-after",
-    kBuildTypeDebug,
-    kArgCheckPolicyRequired,
-    "  --skip-after                \tSkip the rest phases after PHASENAME(excluded)\n"
-    "                              \t--skip-after=PHASENAME\n",
-    "me",
-    {} },
-  { kSetCalleeHasSideEffect,
-    kEnable,
-    "",
-    "setCalleeHasSideEffect",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --setCalleeHasSideEffect    \tSet all the callees have side effect\n"
-    "  --no-setCalleeHasSideEffect \tNot set all the callees have side effect\n",
-    "me",
-    {} },
-  {kUnionBasedAA,
-   kEnable,
-   "",
-   "ubaa",
-   kBuildTypeExperimental,
-   kArgCheckPolicyBool,
-    "  --ubaa                      \tEnable UnionBased alias analysis\n"
-    "  --no-ubaa                   \tDisable UnionBased alias analysis\n",
-   "me",
-   {} },
-  { kTBAA,
-    kEnable,
-    "",
-    "tbaa",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --tbaa                      \tEnable type-based alias analysis\n"
-    "  --no-tbaa                   \tDisable type-based alias analysis\n",
-    "me",
-    {} },
-  { kDDAA,
-    kEnable,
-    "",
-    "ddaa",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --ddaa                      \tEnable demand driven alias analysis\n"
-    "  --no-ddaa                   \tDisable demand driven alias analysis\n",
-    "me",
-    {} },
-  { kAliasAnalysisLevel,
-    0,
-    "",
-    "aliasAnalysisLevel",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --aliasAnalysisLevel        \tSet level of alias analysis. \n"
-    "                              \t0: most conservative;\n"
-    "                              \t1: Union-based alias analysis; 2: type-based alias analysis;\n"
-    "                              \t3: Union-based and type-based alias analysis\n"
-    "                              \t--aliasAnalysisLevel=NUM\n",
-    "me",
-    {} },
-  { kStmtNum,
-    kEnable,
-    "",
-    "stmtnum",
-    kBuildTypeExperimental,
-    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,
-    "",
-    "rclower",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --rclower                   \tEnable rc lowering\n"
-    "  --no-rclower                \tDisable rc lowering\n",
-    "me",
-    {} },
-  { kGCOnlyOpt,
-    kEnable,
-    "gconlyopt",
-    "",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --gconlyopt                     \tEnable write barrier optimization in gconly\n"
-    "  --no-gconlyopt                  \tDisable write barrier optimization in gconly\n",
-    "me",
-    {} },
-  { kUseGcbar,
-    kEnable,
-    "",
-    "usegcbar",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --usegcbar                  \tEnable GC barriers\n"
-    "  --no-usegcbar               \tDisable GC barriers\n",
-    "me",
-    {} },
-  { kMeStubJniFunc,
-    kEnable,
-    "",
-    "regnativefunc",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --regnativefunc             \tGenerate native stub function to support JNI registration and calling\n"
-    "  --no-regnativefunc          \tDon't generate native stub function to support JNI registration and calling\n",
-    "me",
-    {} },
-  { kWarnNativefunc,
-    kEnable,
-    "",
-    "warnemptynative",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --warnemptynative           \tGenerate warning and abort unimplemented native function\n"
-    "  --no-warnemptynative        \tDon't generate warning and abort unimplemented native function\n",
-    "me",
-    {} },
-  { kMeDumpBefore,
-    kEnable,
-    "",
-    "dump-before",
-    kBuildTypeDebug,
-    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,
-    "",
-    "dump-after",
-    kBuildTypeDebug,
-    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",
-    {} },
-  { kRealCheckcast,
-    kEnable,
-    "",
-    "realcheckcast",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --realcheckcast\n"
-    "  --no-realcheckcast\n",
-    "me",
-    {} },
-  { kEpreLimit,
-    0,
-    "",
-    "eprelimit",
-    kBuildTypeDebug,
-    kArgCheckPolicyRequired,
-    "  --eprelimit                 \tApply EPRE optimization only for the first NUM expressions\n"
-    "                              \t--eprelimit=NUM\n",
-    "me",
-    {} },
-  { kEprepuLimit,
-    0,
-    "",
-    "eprepulimit",
-    kBuildTypeDebug,
-    kArgCheckPolicyRequired,
-    "  --eprepulimit               \tApply EPRE optimization only for the first NUM PUs\n"
-    "                              \t--eprepulimit=NUM\n",
-    "me",
-    {} },
-  { kStmtPrepuLimit,
-    0,
-    "",
-    "stmtprepulimit",
-    kBuildTypeDebug,
-    kArgCheckPolicyRequired,
-    "  --stmtprepulimit            \tApply STMTPRE optimization only for the first NUM PUs\n"
-    "                              \t--stmtprepulimit=NUM\n",
-    "me",
-    {} },
-  { kLpreLimit,
-    0,
-    "",
-    "lprelimit",
-    kBuildTypeDebug,
-    kArgCheckPolicyRequired,
-    "  --lprelimit                 \tApply LPRE optimization only for the first NUM variables\n"
-    "                              \t--lprelimit=NUM\n",
-    "me",
-    {} },
-  { kLprepulLimit,
-    0,
-    "",
-    "lprepulimit",
-    kBuildTypeDebug,
-    kArgCheckPolicyRequired,
-    "  --lprepulimit               \tApply LPRE optimization only for the first NUM PUs\n"
-    "                              \t--lprepulimit=NUM\n",
-    "me",
-    {} },
-  { kPregreNameLimit,
-    0,
-    "",
-    "pregrenamelimit",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --pregrenamelimit           \tApply Preg Renaming optimization only up to NUM times\n"
-    "                              \t--pregrenamelimit=NUM\n",
-    "me",
-    {} },
-  { kRename2pregLimit,
-    0,
-    "",
-    "rename2preglimit",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --rename2preglimit          \tApply Rename-to-Preg optimization only up to NUM times\n"
-    "                              \t--rename2preglimit=NUM\n",
-    "me",
-    {} },
-  { kPropLimit,
-    0,
-    "",
-    "proplimit",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --proplimit             \tApply propagation only up to NUM times in each hprop invocation\n"
-    "                              \t--proplimit=NUM\n",
-    "me",
-    {} },
-  { kCopyPropLimit,
-    0,
-    "",
-    "copyproplimit",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --copyproplimit             \tApply copy propagation only up to NUM times\n"
-    "                              \t--copyproplimit=NUM\n",
-    "me",
-    {} },
-  { kDelrcpuLimit,
-    0,
-    "",
-    "delrcpulimit",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --delrcpulimit              \tApply DELEGATERC optimization only for the first NUM PUs\n"
-    "                              \t--delrcpulimit=NUM\n",
-    "me",
-    {} },
-  { kProfileBBHotRate,
-    0,
-    "",
-    "profile-bb-hot-rate",
-    kBuildTypeAll,
-    kArgCheckPolicyRequired,
-    "  --profile-bb-hot-rate=10   \tA count is regarded as hot if it is in the largest 10%\n",
-    "me",
-    {} },
-  { kProfileBBColdRate,
-    0,
-    "",
-    "profile-bb-cold-rate",
-    kBuildTypeAll,
-    kArgCheckPolicyRequired,
-    "  --profile-bb-cold-rate=99  \tA count is regarded as cold if it is in the smallest 1%\n",
-    "me",
-    {} },
-  { kIgnoreIpa,
-    kEnable,
-    "",
-    "ignoreipa",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --ignoreipa                 \tIgnore information provided by interprocedural analysis\n"
-    "  --no-ignoreipa              \tDon't ignore information provided by interprocedural analysis\n",
-    "me",
-    {} },
-  { kAggressiveABCO,
-    kEnable,
-    "",
-    "aggressiveABCO",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --aggressiveABCO                 \tEnable aggressive array boundary check optimization\n"
-    "  --no-aggressiveABCO              \tDon't enable aggressive array boundary check optimization\n",
-    "me",
-    {} },
-  { kCommonABCO,
-    kEnable,
-    "",
-    "commonABCO",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --commonABCO                 \tEnable aggressive array boundary check optimization\n"
-    "  --no-commonABCO              \tDon't enable aggressive array boundary check optimization\n",
-    "me",
-    {} },
-  { kConservativeABCO,
-    kEnable,
-    "",
-    "conservativeABCO",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --conservativeABCO                 \tEnable aggressive array boundary check optimization\n"
-    "  --no-conservativeABCO              \tDon't enable aggressive array boundary check optimization\n",
-    "me",
-    {} },
-  { kEpreIncludeRef,
-    kEnable,
-    "",
-    "epreincluderef",
-    kBuildTypeExperimental,
-    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,
-    "",
-    "eprelocalrefvar",
-    kBuildTypeExperimental,
-    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,
-    "",
-    "eprelhsivar",
-    kBuildTypeExperimental,
-    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",
-    {} },
-  { kDseKeepRef,
-    kEnable,
-    "",
-    "dsekeepref",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --dsekeepref                \tPreverse dassign of local var that are of ref type to anywhere\n"
-    "  --no-dsekeepref             \tDon't preverse dassign of local var that are of ref type to anywhere\n",
-    "me",
-    {} },
-  { kPropBase,
-    kEnable,
-    "",
-    "propbase",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --propbase                  \tApply copy propagation that can change the base of indirect memory accesses\n"
-    "  --no-propbase               \tDon't apply copy propagation\n",
-    "me",
-    {} },
-  { kPropiLoadRef,
-    kEnable,
-    "",
-    "propiloadref",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --propiloadref              \tAllow copy propagating iloads that are of ref type to anywhere\n"
-    "  --no-propiloadref           \tDon't aAllow copy propagating iloads that are of ref type to anywhere\n",
-    "me",
-    {} },
-  { kPropGloablRef,
-    kEnable,
-    "",
-    "propglobalref",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --propglobalref             \tAllow copy propagating global that are of ref type to anywhere\n"
-    "  --no-propglobalref          \tDon't allow copy propagating global that are of ref type to anywhere\n",
-    "me",
-    {} },
-  { kPropfinalIloadRef,
-    kEnable,
-    "",
-    "propfinaliloadref",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --propfinaliloadref         \tAllow copy propagating iloads of\n"
-    "                              \tfinal fields that are of ref type to anywhere\n"
-    "  --no-propfinaliloadref      \tDisable propfinaliloadref\n",
-    "me",
-    {} },
-  { kPropIloadRefnonparm,
-    kEnable,
-    "",
-    "propiloadrefnonparm",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --propiloadrefnonparm       \tAllow copy propagating iloads that are of ref type to\n"
-    "                              \tanywhere except actual parameters\n"
-    "  --no-propiloadrefnonparm    \tDisbale propiloadref\n",
-    "me",
-    {} },
-  { kLessThrowAlias,
-    kEnable,
-    "",
-    "lessthrowalias",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --lessthrowalias            \tHandle aliases at java throw statements more accurately\n"
-    "  --no-lessthrowalias         \tDisable lessthrowalias\n",
-    "me",
-    {} },
-  { kNodeLegateRc,
-    kEnable,
-    "",
-    "nodelegaterc",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --nodelegateerc             \tDo not apply RC delegation to local object reference pointers\n"
-    "  --no-nodelegateerc          \tDisable nodelegateerc\n",
-    "me",
-    {} },
-  { kNocondBasedRc,
-    kEnable,
-    "",
-    "nocondbasedrc",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --nocondbasedrc             \tDo not apply condition-based RC optimization to\n"
-    "                              \tlocal object reference pointers\n"
-    "  --no-nocondbasedrc          \tDisable nocondbasedrc\n",
-    "me",
-    {} },
-  { kSubsumRC,
-    kEnable,
-    "",
-    "subsumrc",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --subsumrc               \tDelete decrements for localrefvars whose live range is just in\n"
-    "                           \tanother which point to the same obj\n"
-    "  --no-subsumrc            \tDisable subsumrc\n",
-    "me",
-    {} },
-  { kPerformFSAA,
-    kEnable,
-    "",
-    "performFSAA",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --performFSAA            \tPerform flow sensitive alias analysis\n"
-    "  --no-performFSAA         \tDisable flow sensitive alias analysis\n",
-    "me",
-    {} },
-  { kStrengthReduction,
-    kEnable,
-    "",
-    "strengthreduction",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --strengthreduction      \tPerform strength reduction\n"
-    "  --no-strengthreduction   \tDisable strength reduction\n",
-    "me",
-    {} },
-  { kSRAdd,
-    kEnable,
-    "",
-    "sradd",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --sradd                   \tPerform strength reduction for OP_add/sub\n"
-    "  --no-sradd                \tDisable strength reduction for OP_add/sub\n",
-    "me",
-    {} },
-  { kLFTR,
-    kEnable,
-    "",
-    "lftr",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --lftr                   \tPerform linear function test replacement\n"
-    "  --no-lftr                \tDisable linear function test replacement\n",
-    "me",
-    {} },
-  { kIVOPTS,
-    kEnable,
-    "",
-    "ivopts",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --ivopts                   \tPerform induction variables optimization\n"
-    "  --no-ivopts                \tDisable induction variables optimization\n",
-    "me",
-    {} },
-  { kCheckCastOpt,
-    kEnable,
-    "",
-    "checkcastopt",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --checkcastopt             \tApply template--checkcast optimization \n"
-    "  --no-checkcastopt          \tDisable checkcastopt \n",
-    "me",
-    {} },
-  { kParmToptr,
-    kEnable,
-    "",
-    "parmtoptr",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --parmtoptr                 \tAllow rcoptlocals to change actual parameters from ref to ptr type\n"
-    "  --no-parmtoptr              \tDisable parmtoptr\n",
-    "me",
-    {} },
-  { kNullcheckPre,
-    kEnable,
-    "",
-    "nullcheckpre",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --nullcheckpre              \tTurn on partial redundancy elimination of null pointer checks\n"
-    "  --no-nullcheckpre           \tDisable nullcheckpre\n",
-    "me",
-    {} },
-  { kClinitPre,
-    kEnable,
-    "",
-    "clinitpre",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --clinitpre                 \tTurn on partial redundancy elimination of class initialization checks\n"
-    "  --no-clinitpre              \tDisable clinitpre\n",
-    "me",
-    {} },
-  { kDassignPre,
-    kEnable,
-    "",
-    "dassignpre",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --dassignpre                \tTurn on partial redundancy elimination of assignments to scalar variables\n"
-    "  --no-dassignpre             \tDisable dassignpre\n",
-    "me",
-    {} },
-  { kAssign2finalPre,
-    kEnable,
-    "",
-    "assign2finalpre",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --assign2finalpre           \tTurn on partial redundancy elimination of assignments to final variables\n"
-    "  --no-assign2finalpre        \tDisable assign2finalpre\n",
-    "me",
-    {} },
-  { kRegReadAtReturn,
-    kEnable,
-    "",
-    "regreadatreturn",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --regreadatreturn           \tAllow register promotion to promote the operand of return statements\n"
-    "  --no-regreadatreturn        \tDisable regreadatreturn\n",
-    "me",
-    {} },
-  { kProPatphi,
-    kEnable,
-    "",
-    "propatphi",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --propatphi                 \tEnable copy propagation across phi nodes\n"
-    "  --no-propatphi              \tDisable propatphi\n",
-    "me",
-    {} },
-  { kPropDuringBuild,
-    kEnable,
-    "",
-    "propduringbuild",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --propduringbuild           \tEnable copy propagation when building HSSA\n"
-    "  --no-propduringbuild        \tDisable propduringbuild\n",
-    "me",
-    {} },
-  { kPropWithInverse,
-    kEnable,
-    "",
-    "propwithinverse",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --propwithinverse           \tEnable copy propagation across statements with inverse functions"
-    "  --no-propwithinverse        \tDisable copy propagation across statements with inverse functions\n",
-    "me",
-    {} },
-  { kMeNativeOpt,
-    kEnable,
-    "",
-    "nativeopt",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --nativeopt              \tEnable native opt\n"
-    "  --no-nativeopt           \tDisable native opt\n",
-    "me",
-    {} },
-  { kOptDirectCall,
-    kEnable,
-    "",
-    "optdirectcall",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --optdirectcall             \tEnable redundancy elimination of directcalls\n"
-    "  --no-optdirectcall          \tDisable optdirectcall\n",
-    "me",
-    {} },
-  { kEnableEa,
-    kEnable,
-    "",
-    "enable-ea",
-    kBuildTypeProduct,
-    kArgCheckPolicyBool,
-    "  --enable-ea                 \tEnable escape analysis\n"
-    "  --no-enable-ea              \tDisable escape analysis\n",
-    "me",
-    {} },
-  { kLpreSpeculate,
-    kEnable,
-    "",
-    "lprespeculate",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --lprespeculate             \tEnable speculative code motion in LPRE phase\n"
-    "  --no-lprespeculate          \tDisable speculative code motion in LPRE phase\n",
-    "me",
-    {} },
-  { kLpre4Address,
-    kEnable,
-    "",
-    "lpre4address",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --lpre4address              \tEnable register promotion of addresses in LPRE phase\n"
-    "  --no-lpre4address           \tDisable register promotion of addresses in LPRE phase\n",
-    "me",
-    {} },
-  { kLpre4LargeInt,
-    kEnable,
-    "",
-    "lpre4largeint",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --lpre4largeint             \tEnable register promotion of large integers in LPRE phase\n"
-    "  --no-lpre4largeint          \tDisable register promotion of large integers in LPRE phase\n",
-    "me",
-    {} },
-  { kSpillatCatch,
-    kEnable,
-    "",
-    "spillatcatch",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --spillatcatch              \tMinimize upward exposed preg usage in catch blocks\n"
-    "  --no-spillatcatch           \tDisable spillatcatch\n",
-    "me",
-    {} },
-  { kPlacementRC,
-    kEnable,
-    "",
-    "placementrc",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --placementrc               \tInsert RC decrements for localrefvars using\n"
-    "                              \tthe placement optimization approach\n"
-    "  --no-placementrc            \tInsert RC decrements for localrefvars using\n",
-    "me",
-    {} },
-  { kLazyDecouple,
-    kEnable,
-    "",
-    "lazydecouple",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --lazydecouple              \tDo optimized for lazy Decouple\n"
-    "  --no-lazydecouple           \tDo not optimized for lazy Decouple\n",
-    "me",
-    {} },
-  { kMergeStmts,
-    kEnable,
-    "",
-    "mergestmts",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --mergestmts                \tTurn on statment merging optimization\n"
-    "  --no-mergestmts             \tDisable mergestmts\n",
-    "me",
-    {} },
-  { kMeGeneralRegOnly,
-      0,
-      "",
-      "general-reg-only",
-      kBuildTypeExperimental,
-      kArgCheckPolicyBool,
-      "  --general-reg-only        \tME will avoid generate fp type when enable general-reg-only\n"
-      "  --no-general-reg-only     \tDisable general-reg-only\n",
-      "me",
-      {} },
-  { kMeInlineHint,
-    0,
-    "",
-    "inlinefunclist",
-    kBuildTypeProduct,
-    kArgCheckPolicyRequired,
-    "  --inlinefunclist            \tInlining related configuration\n"
-    "                              \t--inlinefunclist=\n",
-    "me",
-    {} },
-  { kMeThreads,
-    0,
-    "",
-    "threads",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNumeric,
-    "  --threads=n                 \tOptimizing me functions using n threads\n"
-    "                              \tIf n >= 2, ignore-inferred-return-type will be enabled default\n",
-    "me",
-    {} },
-  { kMeIgnoreInferredRetType,
-    kEnable,
-    "",
-    "ignore-inferred-ret-type",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --ignore-inferred-ret-type  \tIgnore func return type inferred by ssadevirt\n"
-    "  --no-ignore-inferred-ret-type\tDo not ignore func return type inferred by ssadevirt\n",
-    "me",
-    {} },
-  { kMeVerify,
-    kEnable,
-    "",
-    "meverify",
-    kBuildTypeProduct,
-    kArgCheckPolicyNone,
-    "  --meverify                       \tenable meverify features\n",
-    "me",
-    {}},
-  { kDseRunsLimit,
-    0,
-    "",
-    "dserunslimit",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNumeric,
-    "  --dserunslimit=n            \tControl number of times dse phase can be run\n"
-    "                              \t--dserunslimit=NUM\n",
-    "me",
-    {} },
-  { kHdseRunsLimit,
-    0,
-    "",
-    "hdserunslimit",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNumeric,
-    "  --hdserunslimit=n           \tControl number of times hdse phase can be run\n"
-    "                              \t--hdserunslimit=NUM\n",
-    "me",
-    {} },
-  { kHpropRunsLimit,
-    0,
-    "",
-    "hproprunslimit",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNumeric,
-    "  --hproprunslimit=n          \tControl number of times hprop phase can be run\n"
-    "                              \t--hproprunslimit=NUM\n",
-    "me",
-    {} },
-  { kSinkLimit,
-    0,
-    "",
-    "sinklimit",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNumeric,
-    "  --sinklimit=n          \tControl number of stmts sink-phase can sink\n"
-    "                              \t--sinklimit=NUM\n",
-    "me",
-    {} },
-  { kSinkPULimit,
-    0,
-    "",
-    "sinkPUlimit",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNumeric,
-    "  --sinkPUlimit=n          \tControl number of function sink-phase can be run\n"
-    "                              \t--sinkPUlimit=NUM\n",
-    "me",
-    {} },
-  { kLoopVec,
-    kEnable,
-    "",
-    "loopvec",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --loopvec                   \tEnable auto loop vectorization\n"
-    "  --no-loopvec                \tDisable auto loop vectorization\n",
-    "me",
-    {} },
-  { kSeqVec,
-    kEnable,
-    "",
-    "seqvec",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --seqvec                   \tEnable auto sequencial vectorization\n"
-    "  --no-seqvec                \tDisable auto sequencial vectorization\n",
-    "me",
-    {} },
-  { kEnableLFO,
-    kEnable,
-    "",
-    "lfo",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --lfo                   \tEnable LFO framework\n"
-    "  --no-lfo                \tDisable LFO framework\n",
-    "me",
-    {} },
-  { kLayoutWithPredict,
-    kEnable,
-    "",
-    "layoutwithpredict",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --layoutwithpredict        \tEnable optimizing output layout using branch prediction\n"
-    "  --no-layoutwithpredict     \tDisable optimizing output layout using branch prediction\n",
-    "me",
-    {} },
-  { kvecLoops,
-    0,
-    "",
-    "veclooplimit",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --veclooplimit             \tApply vectorize loops only up to NUM \n"
-    "                              \t--veclooplimit=NUM\n",
-    "me",
-    {} },
-  { kIvoptsLimit,
-    0,
-    "",
-    "ivoptslimit",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --ivoptslimit              \tApply ivopts only up to NUM loops \n"
-    "                              \t--ivoptslimit=NUM\n",
-    "me",
-    {} },
-#if MIR_JAVA
-  { kMeAcquireFunc,
-    0,
-    "",
-    "acquire-func",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --acquire-func              \t--acquire-func=FUNCNAME\n",
-    "me",
-    {} },
-  { kMeReleaseFunc,
-    0,
-    "",
-    "release-func",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --release-func              \t--release-func=FUNCNAME\n",
-    "me",
-    {} },
-  { kMeToolOnly,
-    kEnable,
-    "",
-    "toolonly",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --toolonly\n"
-    "  --no-toolonly\n",
-    "me",
-    {} },
-  { kMeToolStrict,
-    kEnable,
-    "",
-    "toolstrict",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --toolstrict\n"
-    "  --no-toolstrict\n",
-    "me",
-    {} },
-  { kMeSkipVirtual,
-    kEnable,
-    "",
-    "skipvirtual",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --skipvirtual\n"
-    "  --no-skipvirtual\n",
-    "me",
-    {} },
-  { kMeWarnLevel,
-    0,
-    "",
-    "warning",
-    kBuildTypeExperimental,
-    kArgCheckPolicyNumeric,
-    "  --warning=level             \t--warning=level\n",
-    "me",
-    {} },
-  { kRematLevel,
-    0,
-    "",
-    "remat",
-    kBuildTypeExperimental,
-    kArgCheckPolicyRequired,
-    "  --remat                     \tEnable rematerialization during register allocation\n"
-    "                              \t     0: no rematerialization (default)\n"
-    "                              \t  >= 1: rematerialize constants\n"
-    "                              \t  >= 2: rematerialize addresses\n"
-    "                              \t  >= 3: rematerialize local dreads\n"
-    "                              \t  >= 4: rematerialize global dreads\n",
-    "me",
-    {} },
-  { kUnifyRets,
-    kEnable,
-    "",
-    "unifyrets",
-    kBuildTypeExperimental,
-    kArgCheckPolicyBool,
-    "  --unifyrets                   \tEnable return blocks unification\n"
-    "  --no-unifyrets                \tDisable return blocks unification\n",
-    "me",
-    {} },
-#endif
-  { kUnknown,
-    0,
-    "",
-    "",
-    kBuildTypeAll,
-    kArgCheckPolicyNone,
-    "",
-    "me",
-    {} }
-};
-
-void MeOption::DecideMeRealLevel(const std::deque<mapleOption::Option> &inputOptions) const {
-  int realLevel = -1;
-  for (const mapleOption::Option &opt : inputOptions) {
-    switch (opt.Index()) {
-      case kMeOptL1:
-        realLevel = static_cast<int>(kLevelOne);
-        break;
-      case kMeOptL2:
-        realLevel = static_cast<int>(kLevelTwo);
-        break;
-      case kMeOptLs:
-        optForSize = true;
-        realLevel = static_cast<int>(kLevelTwo);
-        break;
-      case kMeOptL3:
-        optForSize = false;
-        realLevel = static_cast<int>(kLevelThree);
-        break;
-      default:
-        break;
+  for (const auto &opt : meCategory.GetEnabledOptions()) {
+    std::string printOpt;
+    if (isDebug) {
+      for (const auto &val : opt->GetRawValues()) {
+        printOpt += opt->GetName() + " " + val + " ";
+      }
+      LogInfo::MapleLogger() << "me options: " << printOpt << '\n';
     }
   }
-  if (realLevel == kLevelOne) {
+
+  if (opts::me::o1) {
     optLevel = kLevelOne;
-  } else if (realLevel == kLevelTwo) {
+  }
+
+  if (opts::me::o2 || opts::me::os) {
+    if (opts::me::os) {
+      optForSize = true;
+    }
     optLevel = kLevelTwo;
     // Turn the followings ON only at O2
     optDirectCall = true;
     placementRC = true;
     subsumRC = true;
     epreIncludeRef = true;
-  } else if (realLevel == kLevelThree) {
+  }
+
+  if (opts::me::o3) {
+    optForSize = true;
     optLevel = kLevelThree;
     // turn on as O2
     optDirectCall = true;
@@ -1402,419 +180,225 @@ void MeOption::DecideMeRealLevel(const std::deque<mapleOption::Option> &inputOpt
     subsumRC = true;
     epreIncludeRef = true;
   }
-}
 
-bool MeOption::SolveOptions(const std::deque<mapleOption::Option> &opts, bool isDebug) {
-  DecideMeRealLevel(opts);
-  if (isDebug) {
-    LogInfo::MapleLogger() << "Real Me level:" << std::to_string(optLevel) << "\n";
+  if (opts::me::skipPhases.IsEnabledByUser()) {
+    SplitSkipPhases(opts::me::skipPhases);
+  }
+
+  if (opts::me::refusedcheck.IsEnabledByUser()) {
+    SplitPhases(opts::me::refusedcheck, checkRefUsedInFuncs);
   }
-  bool result = true;
-  for (const mapleOption::Option &opt : opts) {
+
+  if (opts::me::range.IsEnabledByUser()) {
+    useRange = true;
+    bool ret = GetRange(opts::me::range);
+    if (ret == false) {
+      return ret;
+    }
+  }
+
+  cl::CopyIfEnabled(dumpBefore, opts::me::dumpBefore);
+  cl::CopyIfEnabled(dumpAfter, opts::me::dumpAfter);
+  cl::CopyIfEnabled(isBigEndian, opts::bigendian);
+
+  cl::CopyIfEnabled(dumpFunc, opts::me::dumpFunc);
+  cl::CopyIfEnabled(skipFrom, opts::me::skipFrom);
+  cl::CopyIfEnabled(skipAfter, opts::me::skipAfter);
+
+  if (opts::me::dumpPhases.IsEnabledByUser()) {
+    SplitPhases(opts::me::dumpPhases, dumpPhases);
+  }
+
+  cl::CopyIfEnabled(quiet, opts::me::quiet);
+  cl::CopyIfEnabled(quiet, !opts::verbose, opts::verbose);
+
+  cl::CopyIfEnabled(setCalleeHasSideEffect, opts::me::calleeHasSideEffect);
+  cl::CopyIfEnabled(unionBasedAA, opts::me::ubaa);
+  cl::CopyIfEnabled(tbaa, opts::me::tbaa);
+  cl::CopyIfEnabled(ddaa, opts::me::ddaa);
+
+  if (opts::me::aliasAnalysisLevel.IsEnabledByUser()) {
+    aliasAnalysisLevel = opts::me::aliasAnalysisLevel;
+    if (aliasAnalysisLevel > kLevelThree) {
+      aliasAnalysisLevel = kLevelThree;
+    }
+
+    switch (aliasAnalysisLevel) {
+    case kLevelThree:
+      setCalleeHasSideEffect = false;
+      unionBasedAA = true;
+      tbaa = true;
+      break;
+    case kLevelZero:
+      setCalleeHasSideEffect = true;
+      unionBasedAA = false;
+      tbaa = false;
+      break;
+    case kLevelOne:
+      setCalleeHasSideEffect = false;
+      unionBasedAA = true;
+      tbaa = false;
+      break;
+    case kLevelTwo:
+      setCalleeHasSideEffect = false;
+      unionBasedAA = false;
+      tbaa = true;
+      break;
+    default:
+      break;
+    }
+
+    if (isDebug) {
+      LogInfo::MapleLogger() << "--sub options: setCalleeHasSideEffect "
+                             << setCalleeHasSideEffect << '\n';
+      LogInfo::MapleLogger() << "--sub options: ubaa " << unionBasedAA << '\n';
+      LogInfo::MapleLogger() << "--sub options: tbaa " << tbaa << '\n';
+    }
+  }
+
+  cl::CopyIfEnabled(rcLowering, opts::me::rclower);
+  cl::CopyIfEnabled(rcLowering, !opts::me::userc, opts::me::userc);
+  cl::CopyIfEnabled(lazyDecouple, opts::me::lazydecouple);
+  cl::CopyIfEnabled(strictNaiveRC, opts::me::strictNaiverc);
+
+  if (opts::gconly.IsEnabledByUser()) {
+    gcOnly = opts::me::gconlyopt;
+    propIloadRef = opts::me::gconlyopt;
     if (isDebug) {
-      LogInfo::MapleLogger() << "Me options: " << opt.Index() << " " << opt.OptionKey() << " " << opt.Args() << '\n';
+      LogInfo::MapleLogger() << "--sub options: propIloadRef " << propIloadRef << '\n';
+      LogInfo::MapleLogger() << "--sub options: propGlobalRef " << propGlobalRef << '\n';
     }
-    switch (opt.Index()) {
-      case kMeSkipPhases:
-        SplitSkipPhases(opt.Args());
-        break;
-      case kMeOptL1:
-      case kMeOptL2:
-      case kMeOptLs:
-      case kMeOptL3:
-        // Already handled above in DecideMeRealLevel
-        break;
-      case kRefUsedCheck:
-        SplitPhases(opt.Args(), checkRefUsedInFuncs);
-        break;
-      case kMeRange:
-        useRange = true;
-        result = GetRange(opt.Args());
-        break;
-      case kMeDumpBefore:
-        dumpBefore = (opt.Type() == kEnable);
-        break;
-      case kMeDumpAfter:
-        dumpAfter = (opt.Type() == kEnable);
-        break;
-      case kBigEndian:
-        isBigEndian = (opt.Type() == kEnable);
-        break;
-      case kMeDumpFunc:
-        dumpFunc = opt.Args();
-        break;
-      case kMeSkipFrom:
-        skipFrom = opt.Args();
-        break;
-      case kMeSkipAfter:
-        skipAfter = opt.Args();
-        break;
-      case kMeDumpPhases:
-        SplitPhases(opt.Args(), dumpPhases);
-        break;
-      case kMeQuiet:
-        quiet = (opt.Type() == kEnable);
-        break;
-      case kVerbose:
-        quiet = (opt.Type() == kEnable) ? false : true;
-        break;
-      case kProfileGen:
-        if (optLevel != kLevelZero) {
-          WARN(kLncWarn, "profileGen requires no optimization");
-          result = false;
-        }
-        break;
-      case kSetCalleeHasSideEffect:
-        setCalleeHasSideEffect = (opt.Type() == kEnable);
-        break;
-      case kUnionBasedAA:
-        unionBasedAA = (opt.Type() == kEnable);
-        break;
-      case kTBAA:
-        tbaa = (opt.Type() == kEnable);
-        break;
-      case kDDAA: {
-        ddaa = (opt.Type() == kEnable);
-        break;
+  }
+
+  cl::CopyIfEnabled(gcOnlyOpt, opts::me::gconlyopt);
+
+  cl::CopyIfEnabled(noGCBar, !opts::me::usegcbar, opts::me::usegcbar);
+  cl::CopyIfEnabled(realCheckCast, opts::me::realcheckcast);
+  cl::CopyIfEnabled(noDot, opts::me::nodot);
+  cl::CopyIfEnabled(stmtNum, opts::me::stmtnum);
+  cl::CopyIfEnabled(regNativeFunc, opts::me::regnativefunc);
+  cl::CopyIfEnabled(warnNativeFunc, opts::me::warnemptynative);
+
+  cl::CopyIfEnabled(epreLimit, opts::me::eprelimit);
+  cl::CopyIfEnabled(eprePULimit, opts::me::eprepulimit);
+  cl::CopyIfEnabled(stmtprePULimit, opts::me::stmtprepulimit);
+  cl::CopyIfEnabled(lpreLimit, opts::me::lprelimit);
+  cl::CopyIfEnabled(lprePULimit, opts::me::lprepulimit);
+  cl::CopyIfEnabled(pregRenameLimit, opts::me::pregrenamelimit);
+  cl::CopyIfEnabled(rename2pregLimit, opts::me::rename2preglimit);
+  cl::CopyIfEnabled(propLimit, opts::me::proplimit);
+  cl::CopyIfEnabled(copyPropLimit, opts::me::copyproplimit);
+  cl::CopyIfEnabled(delRcPULimit, opts::me::delrcpulimit);
+  cl::CopyIfEnabled(profileBBHotRate, opts::me::profileBbHotRate);
+  cl::CopyIfEnabled(profileBBColdRate, opts::me::profileBbColdRate);
+  cl::CopyIfEnabled(ignoreIPA, opts::me::ignoreipa);
+  cl::CopyIfEnabled(aggressiveABCO, opts::me::aggressiveABCO);
+  cl::CopyIfEnabled(commonABCO, opts::me::commonABCO);
+  cl::CopyIfEnabled(conservativeABCO, opts::me::conservativeABCO);
+  cl::CopyIfEnabled(epreIncludeRef, opts::me::epreincluderef);
+  cl::CopyIfEnabled(epreLocalRefVar, opts::me::eprelocalrefvar);
+  cl::CopyIfEnabled(epreLHSIvar, opts::me::eprelhsivar);
+  cl::CopyIfEnabled(dseKeepRef, opts::me::dsekeepref);
+  cl::CopyIfEnabled(lessThrowAlias, opts::me::lessthrowalias);
+  cl::CopyIfEnabled(propBase, opts::me::propbase);
+
+  if (opts::me::propiloadref.IsEnabledByUser()) {
+    propIloadRef = opts::me::propiloadref;
+    if (opts::me::propiloadref) {
+      propIloadRefNonParm = false;  // to override previous -propIloadRefNonParm
+    }
+
+    if (isDebug) {
+      LogInfo::MapleLogger() << "--sub options: propIloadRefNonParm " << propIloadRefNonParm << '\n';
+    }
+  }
+
+  cl::CopyIfEnabled(propGlobalRef, opts::me::propglobalref);
+  cl::CopyIfEnabled(propFinaliLoadRef, opts::me::propfinaliloadref);
+
+  if (opts::me::propiloadrefnonparm.IsEnabledByUser()) {
+    propIloadRefNonParm = opts::me::propiloadrefnonparm;
+    propIloadRef = propIloadRefNonParm;
+
+    if (isDebug) {
+      LogInfo::MapleLogger() << "--sub options: propIloadRef " << propIloadRef << '\n';
+    }
+  }
+
+  cl::CopyIfEnabled(noDelegateRC, opts::me::nodelegaterc);
+  cl::CopyIfEnabled(noCondBasedRC, opts::me::nocondbasedrc);
+  cl::CopyIfEnabled(checkCastOpt, opts::me::checkcastopt);
+  cl::CopyIfEnabled(parmToPtr, opts::me::parmtoptr);
+  cl::CopyIfEnabled(nullCheckPre, opts::me::nullcheckpre);
+  cl::CopyIfEnabled(clinitPre, opts::me::clinitpre);
+  cl::CopyIfEnabled(dassignPre, opts::me::dassignpre);
+  cl::CopyIfEnabled(mergeStmts, opts::me::mergestmts);
+  cl::CopyIfEnabled(generalRegOnly, opts::me::generalRegOnly);
+  cl::CopyIfEnabled(assign2FinalPre, opts::me::assign2finalpre);
+  cl::CopyIfEnabled(regreadAtReturn, opts::me::regreadatreturn);
+  cl::CopyIfEnabled(propAtPhi, opts::me::propatphi);
+  cl::CopyIfEnabled(propDuringBuild, opts::me::propduringbuild);
+  cl::CopyIfEnabled(propWithInverse, opts::me::propwithinverse);
+  cl::CopyIfEnabled(nativeOpt, opts::me::nativeopt);
+  cl::CopyIfEnabled(optDirectCall, opts::me::optdirectcall);
+  cl::CopyIfEnabled(enableEA, opts::me::enableEa);
+  cl::CopyIfEnabled(lpreSpeculate, opts::me::lprespeculate);
+  cl::CopyIfEnabled(lpre4Address, opts::me::lpre4address);
+  cl::CopyIfEnabled(lpre4LargeInt, opts::me::lpre4largeint);
+  cl::CopyIfEnabled(spillAtCatch, opts::me::spillatcatch);
+
+  if (opts::me::placementrc.IsEnabledByUser()) {
+    placementRC = opts::me::placementrc;
+    if (placementRC == false) {
+      subsumRC = false;
+      epreIncludeRef = false;
+      if (isDebug) {
+        LogInfo::MapleLogger() << "--sub options: subsumRC " << subsumRC << '\n';
+        LogInfo::MapleLogger() << "--sub options: epreIncludeRef " << epreIncludeRef << '\n';
       }
-      case kAliasAnalysisLevel:
-        aliasAnalysisLevel = static_cast<uint8>(std::stoul(opt.Args(), nullptr));
-        if (aliasAnalysisLevel > kLevelThree) {
-          aliasAnalysisLevel = kLevelThree;
-        }
-        switch (aliasAnalysisLevel) {
-          case kLevelThree:
-            setCalleeHasSideEffect = false;
-            unionBasedAA = true;
-            tbaa = true;
-            break;
-          case kLevelZero:
-            setCalleeHasSideEffect = true;
-            unionBasedAA = false;
-            tbaa = false;
-            break;
-          case kLevelOne:
-            setCalleeHasSideEffect = false;
-            unionBasedAA = true;
-            tbaa = false;
-            break;
-          case kLevelTwo:
-            setCalleeHasSideEffect = false;
-            unionBasedAA = false;
-            tbaa = true;
-            break;
-          default:
-            break;
-        }
-        if (isDebug) {
-          LogInfo::MapleLogger() << "--sub options: setCalleeHasSideEffect "
-                                 << setCalleeHasSideEffect << '\n';
-          LogInfo::MapleLogger() << "--sub options: ubaa " << unionBasedAA << '\n';
-          LogInfo::MapleLogger() << "--sub options: tbaa " << tbaa << '\n';
-        }
-        break;
-      case kRcLower:
-        rcLowering = (opt.Type() == kEnable);
-        break;
-      case kMeUseRc:
-        noRC = (opt.Type() == kDisable);
-        break;
-      case kLazyDecouple:
-        lazyDecouple = (opt.Type() == kEnable);
-        break;
-      case kMeStrictNaiveRc:
-        strictNaiveRC = (opt.Type() == kEnable);
-        break;
-      case kGCOnly:
-        gcOnly = (opt.Type() == kEnable);
-        propIloadRef = (opt.Type() == kEnable);
-        if (isDebug) {
-          LogInfo::MapleLogger() << "--sub options: propIloadRef " << propIloadRef << '\n';
-          LogInfo::MapleLogger() << "--sub options: propGlobalRef " << propGlobalRef << '\n';
-        }
-        break;
-      case kGCOnlyOpt:
-        gcOnlyOpt = (opt.Type() == kEnable);
-        break;
-      case kUseGcbar:
-        noGCBar = (opt.Type() == kEnable) ? false : true;
-        break;
-      case kRealCheckcast:
-        realCheckCast = (opt.Type() == kEnable);
-        break;
-      case kMeNoDot:
-        noDot = (opt.Type() == kEnable);
-        break;
-      case kStmtNum:
-        stmtNum = (opt.Type() == kEnable);
-        break;
-      case kMeStubJniFunc:
-        regNativeFunc = (opt.Type() == kEnable);
-        break;
-      case kWarnNativefunc:
-        warnNativeFunc = (opt.Type() == kEnable);
-        break;
-      case kEpreLimit:
-        epreLimit = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kEprepuLimit:
-        eprePULimit = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kStmtPrepuLimit:
-        stmtprePULimit = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kLpreLimit:
-        lpreLimit = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kLprepulLimit:
-        lprePULimit = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kPregreNameLimit:
-        pregRenameLimit = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kRename2pregLimit:
-        rename2pregLimit = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kPropLimit:
-        propLimit = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kCopyPropLimit:
-        copyPropLimit = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kDelrcpuLimit:
-        delRcPULimit = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kProfileBBHotRate:
-        profileBBHotRate = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kProfileBBColdRate:
-        profileBBColdRate = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kIgnoreIpa:
-        ignoreIPA = (opt.Type() == kEnable);
-        break;
-      case kAggressiveABCO:
-        aggressiveABCO = (opt.Type() == kEnable);
-        break;
-      case kCommonABCO:
-        commonABCO = (opt.Type() == kEnable);
-        break;
-      case kConservativeABCO:
-        conservativeABCO = (opt.Type() == kEnable);
-        break;
-      case kEpreIncludeRef:
-        epreIncludeRef = (opt.Type() == kEnable);
-        break;
-      case kEpreLocalRefVar:
-        epreLocalRefVar = (opt.Type() == kEnable);
-        break;
-      case kEprelhSivar:
-        epreLHSIvar = (opt.Type() == kEnable);
-        break;
-      case kDseKeepRef:
-        dseKeepRef = (opt.Type() == kEnable);
-        break;
-      case kLessThrowAlias:
-        lessThrowAlias = (opt.Type() == kEnable);
-        break;
-      case kPropBase:
-        propBase = (opt.Type() == kEnable);
-        break;
-      case kPropiLoadRef:
-        propIloadRef = (opt.Type() == kEnable);
-        if (opt.Type() == kEnable) {
-          propIloadRefNonParm = false;  // to override previous -propIloadRefNonParm
-        }
-        if (isDebug) {
-          LogInfo::MapleLogger() << "--sub options: propIloadRefNonParm " << propIloadRefNonParm << '\n';
-        }
-        break;
-      case kPropGloablRef:
-        propGlobalRef = (opt.Type() == kEnable);
-        break;
-      case kPropfinalIloadRef:
-        propFinaliLoadRef = (opt.Type() == kEnable);
-        break;
-      case kPropIloadRefnonparm:
-        propIloadRefNonParm = (opt.Type() == kEnable);
-        propIloadRef = (opt.Type() == kEnable);
-        if (isDebug) {
-          LogInfo::MapleLogger() << "--sub options: propIloadRef " << propIloadRef << '\n';
-        }
-        break;
-      case kNodeLegateRc:
-        noDelegateRC = (opt.Type() == kEnable);
-        break;
-      case kNocondBasedRc:
-        noCondBasedRC = (opt.Type() == kEnable);
-        break;
-      case kCheckCastOpt:
-        checkCastOpt = (opt.Type() == kEnable);
-        break;
-      case kParmToptr:
-        parmToPtr = (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 kMergeStmts:
-        mergeStmts = (opt.Type() == kEnable);
-        break;
-      case kMeGeneralRegOnly:
-        generalRegOnly = (opt.Type() == kEnable);
-        break;
-      case kAssign2finalPre:
-        assign2FinalPre = (opt.Type() == kEnable);
-        break;
-      case kRegReadAtReturn:
-        regreadAtReturn = (opt.Type() == kEnable);
-        break;
-      case kProPatphi:
-        propAtPhi = (opt.Type() == kEnable);
-        break;
-      case kPropDuringBuild:
-        propDuringBuild = (opt.Type() == kEnable);
-        break;
-      case kPropWithInverse:
-        propWithInverse = (opt.Type() == kEnable);
-        break;
-      case kMeNativeOpt:
-        nativeOpt = (opt.Type() == kEnable);
-        break;
-      case kOptDirectCall:
-        optDirectCall = (opt.Type() == kEnable);
-        break;
-      case kEnableEa:
-        enableEA = (opt.Type() == kEnable);
-        break;
-      case kLpreSpeculate:
-        lpreSpeculate = (opt.Type() == kEnable);
-        break;
-      case kLpre4Address:
-        lpre4Address = (opt.Type() == kEnable);
-        break;
-      case kLpre4LargeInt:
-        lpre4LargeInt = (opt.Type() == kEnable);
-        break;
-      case kSpillatCatch:
-        spillAtCatch = (opt.Type() == kEnable);
-        break;
-      case kPlacementRC:
-        placementRC = (opt.Type() == kEnable);
-        if (opt.Type() == kDisable) {
-          subsumRC = false;
-          epreIncludeRef = false;
-          if (isDebug) {
-            LogInfo::MapleLogger() << "--sub options: subsumRC " << subsumRC << '\n';
-            LogInfo::MapleLogger() << "--sub options: epreIncludeRef " << epreIncludeRef << '\n';
-          }
-        }
-        break;
-      case kSubsumRC:
-        subsumRC = (opt.Type() == kEnable);
-        epreIncludeRef = (opt.Type() == kEnable);
-        break;
-      case kPerformFSAA:
-        performFSAA = (opt.Type() == kEnable);
-        break;
-      case kStrengthReduction:
-        strengthReduction = (opt.Type() == kEnable);
-        break;
-      case kSRAdd:
-        srForAdd = (opt.Type() == kEnable);
-        break;
-      case kLFTR:
-        doLFTR = (opt.Type() == kEnable);
-        break;
-      case kIVOPTS:
-        ivopts = (opt.Type() == kEnable);
-        break;
-      case kMeInlineHint:
-        inlineFuncList = opt.Args();
-        break;
-      case kDecoupleStatic:
-        decoupleStatic = (opt.Type() == kEnable);
-        break;
-      case kMeThreads:
-        threads = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kMeIgnoreInferredRetType:
-        ignoreInferredRetType = (opt.Type() == kEnable);
-        break;
-      case kMeVerify:
-        meVerify = (opt.Type() == kEnable);
-        break;
-      case kDseRunsLimit:
-        dseRunsLimit = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kHdseRunsLimit:
-        hdseRunsLimit = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kHpropRunsLimit:
-        hpropRunsLimit = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kSinkLimit:
-        sinkLimit = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kSinkPULimit:
-        sinkPULimit = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kLoopVec:
-        loopVec = (opt.Type() == kEnable);
-        break;
-      case kSeqVec:
-        seqVec = (opt.Type() == kEnable);
-        break;
-      case kEnableLFO:
-        enableLFO = (opt.Type() == kEnable);
-        break;
-      case kRematLevel:
-        rematLevel = static_cast<uint8>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kLayoutWithPredict:
-        layoutWithPredict = (opt.Type() == kEnable);
-        break;
-      case kvecLoops:
-        vecLoopLimit = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kIvoptsLimit:
-        ivoptsLimit = static_cast<uint32>(std::stoul(opt.Args(), nullptr));
-        break;
-      case kUnifyRets:
-        unifyRets = (opt.Type() == kEnable);
-        break;
-#if MIR_JAVA
-      case kMeAcquireFunc:
-        acquireFuncName = opt.Args();
-        break;
-      case kMeReleaseFunc:
-        releaseFuncName = opt.Args();
-        break;
-      case kMeWarnLevel:
-        warningLevel = static_cast<uint32>(std::stoul(opt.Args()));
-        break;
-      case kMeToolOnly:
-        mplToolOnly = (opt.Type() == kEnable);
-        break;
-      case kMeToolStrict:
-        mplToolStrict = (opt.Type() == kEnable);
-        break;
-      case kMeSkipVirtual:
-        skipVirtualMethod = (opt.Type() == kEnable);
-        break;
-#endif
-      default:
-        WARN(kLncWarn, "input invalid key for me " + opt.OptionKey());
-        break;
     }
   }
-  return result;
+
+  if (opts::me::subsumrc.IsEnabledByUser()) {
+    subsumRC = opts::me::subsumrc;
+    epreIncludeRef = opts::me::subsumrc;
+  }
+
+  cl::CopyIfEnabled(performFSAA, opts::me::performFSAA);
+  cl::CopyIfEnabled(strengthReduction, opts::me::strengthreduction);
+  cl::CopyIfEnabled(srForAdd, opts::me::sradd);
+  cl::CopyIfEnabled(doLFTR, opts::me::lftr);
+  cl::CopyIfEnabled(ivopts, opts::me::ivopts);
+  cl::CopyIfEnabled(inlineFuncList, opts::me::inlinefunclist);
+
+  cl::CopyIfEnabled(decoupleStatic, opts::decoupleStatic);
+  cl::CopyIfEnabled(threads, opts::me::threads);
+  cl::CopyIfEnabled(ignoreInferredRetType, opts::me::ignoreInferredRetType);
+  cl::CopyIfEnabled(meVerify, opts::me::meverify);
+  cl::CopyIfEnabled(dseRunsLimit, opts::me::dserunslimit);
+  cl::CopyIfEnabled(hdseRunsLimit, opts::me::hdserunslimit);
+  cl::CopyIfEnabled(hpropRunsLimit, opts::me::hproprunslimit);
+  cl::CopyIfEnabled(sinkLimit, opts::me::sinklimit);
+  cl::CopyIfEnabled(sinkPULimit, opts::me::sinkPUlimit);
+  cl::CopyIfEnabled(loopVec, opts::me::loopvec);
+  cl::CopyIfEnabled(seqVec, opts::me::seqvec);
+  cl::CopyIfEnabled(enableLFO, opts::me::lfo);
+  cl::CopyIfEnabled(rematLevel, opts::me::remat);
+  cl::CopyIfEnabled(layoutWithPredict, opts::me::layoutwithpredict);
+  cl::CopyIfEnabled(vecLoopLimit, opts::me::veclooplimit);
+  cl::CopyIfEnabled(ivoptsLimit, opts::me::ivoptslimit);
+  cl::CopyIfEnabled(unifyRets, opts::me::unifyrets);
+
+#if MIR_JAVA
+  cl::CopyIfEnabled(acquireFuncName, opts::me::acquireFunc);
+  cl::CopyIfEnabled(releaseFuncName, opts::me::releaseFunc);
+  cl::CopyIfEnabled(warningLevel, opts::me::warning);
+  cl::CopyIfEnabled(mplToolOnly, opts::me::toolonly);
+  cl::CopyIfEnabled(mplToolStrict, opts::me::toolstrict);
+  cl::CopyIfEnabled(skipVirtualMethod, opts::me::skipvirtual);
+#endif /* MIR_JAVA */
+
+  return true;
 }
 
 MeOption &MeOption::GetInstance() {
@@ -1822,29 +406,32 @@ MeOption &MeOption::GetInstance() {
   return instance;
 }
 
-MeOption::MeOption() {
-  CreateUsages(kUsage);
-}
-
 void MeOption::ParseOptions(int argc, char **argv, std::string &fileName) {
-  OptionParser optionParser;
-  optionParser.RegisteUsages(DriverOptionCommon::GetInstance());
-  optionParser.RegisteUsages(MeOption::GetInstance());
-  int ret = optionParser.Parse(argc, argv, "me");
-  CHECK_FATAL(ret == kErrorNoError, "option parser error");
-  bool result = SolveOptions(optionParser.GetOptions(), false);
+  cl::CommandLine::GetCommandLine().Parse(argc, (char **)argv, meCategory);
+  bool result = SolveOptions(false);
   if (!result) {
     return;
   }
-  if (optionParser.GetNonOptionsCount() != 1) {
+
+  auto &badArgs = cl::CommandLine::GetCommandLine().badCLArgs;
+
+  int count = 0;
+  for (auto &arg : badArgs) {
+    if (FileUtils::IsFileExists(arg.first)) {
+      count++;
+      fileName = arg.first;
+    }
+  }
+
+  if (count != 1) {
     LogInfo::MapleLogger() << "expecting one .mpl file as last argument, found: ";
-    for (std::string optionArg : optionParser.GetNonOptions()) {
-      LogInfo::MapleLogger() << optionArg << " ";
+    for (const auto &optionArg : badArgs) {
+      LogInfo::MapleLogger() << optionArg.first << " ";
     }
     LogInfo::MapleLogger() << '\n';
     CHECK_FATAL(false, "option parser error");
   }
-  fileName = optionParser.GetNonOptions().front();
+
 #ifdef DEBUG_OPTION
   LogInfo::MapleLogger() << "mpl file : " << fileName << "\t";
 #endif
diff --git a/src/mapleall/maple_me/src/me_options.cpp b/src/mapleall/maple_me/src/me_options.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..09b3300742459f086f764ff1f3f42d42ac602610
--- /dev/null
+++ b/src/mapleall/maple_me/src/me_options.cpp
@@ -0,0 +1,633 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * 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 v2 for more details.
+ */
+
+#include "driver_options.h"
+
+#include <bits/stdint-uintn.h>
+#include <stdint.h>
+#include <string>
+
+namespace opts::me {
+
+cl::Option<bool> help({"--help", "-h"},
+                      "  -h --help                   \tPrint usage and exit.Available command names:\n"
+                      "                              \tme\n", {meCategory});
+
+cl::Option<bool> o1({"--O1", "-O1"},
+                    "  -O1                         \tDo some optimization.\n",
+                    {meCategory});
+
+cl::Option<bool> o2({"--O2", "-O2"},
+                    "  -O2                         \tDo some optimization.\n",
+                    {meCategory});
+
+cl::Option<bool> os({"--Os", "-Os"},
+                    "  -Os                         \tOptimize for size, based on O2.\n",
+                    {meCategory});
+
+cl::Option<bool> o3({"--O3", "-O3"},
+                    "  -O3                         \tDo aggressive optimizations.\n",
+                    {meCategory});
+
+cl::Option<std::string> refusedcheck({"--refusedcheck"},
+                                     "  --refusedcheck=FUNCNAME,...    \tEnable ref check used in func in the comma separated list, * means all func.\n",
+                                     {meCategory});
+
+cl::Option<std::string> range({"--range"},
+                              "  --range                     \tOptimize only functions in the range [NUM0, NUM1]\n"
+                              "                              \t--range=NUM0,NUM1\n",
+                              {meCategory});
+
+cl::Option<std::string> dumpPhases({"--dump-phases"},
+                                   "  --dump-phases               \tEnable debug trace for specified phases in the comma separated list\n"
+                                   "                              \t--dump-phases=PHASENAME,...\n",
+                                   {meCategory});
+
+cl::Option<std::string> skipPhases({"--skip-phases"},
+                                   "  --skip-phases               \tSkip the phases specified in the comma separated list\n"
+                                   "                              \t--skip-phases=PHASENAME,...\n",
+                                   {meCategory});
+
+cl::Option<std::string> dumpFunc({"--dump-func"},
+                                 "  --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",
+                                 {meCategory});
+
+cl::Option<bool> quiet({"--quiet"},
+                       "  --quiet                     \tDisable brief trace messages with phase/function names\n"
+                       "  --no-quiet                  \tEnable brief trace messages with phase/function names\n",
+                       {meCategory},
+                       cl::DisableWith("--no-quiet"));
+
+cl::Option<bool> nodot({"--nodot"},
+                       "  --nodot                     \tDisable dot file generation from cfg\n"
+                       "  --no-nodot                  \tEnable dot file generation from cfg\n",
+                       {meCategory},
+                       cl::DisableWith("--no-nodot"));
+
+cl::Option<bool> userc({"--userc"},
+                       "  --userc                     \tEnable reference counting [default]\n"
+                       "  --no-userc                  \tDisable reference counting [default]\n",
+                       {meCategory},
+                       cl::DisableWith("--no-userc"));
+
+cl::Option<bool> strictNaiverc({"--strict-naiverc"},
+                               "  --strict-naiverc            \tStrict Naive RC mode, assume no unsafe multi-thread read/write racing\n"
+                               "  --no-strict-naiverc         \tDisable Strict Naive RC mode, assume no unsafe multi-thread read/write racing\n",
+                               {meCategory},
+                               cl::DisableWith("--no-strict-naiverc"));
+
+cl::Option<std::string> skipFrom({"--skip-from"},
+                                 "  --skip-from                 \tSkip the rest phases from PHASENAME(included)\n"
+                                 "                              \t--skip-from=PHASENAME\n",
+                                 {meCategory});
+
+cl::Option<std::string> skipAfter({"--skip-after"},
+                                  "  --skip-after                \tSkip the rest phases after PHASENAME(excluded)\n"
+                                  "                              \t--skip-after=PHASENAME\n",
+                                  {meCategory});
+
+cl::Option<bool> calleeHasSideEffect({"--setCalleeHasSideEffect"},
+                                     "  --setCalleeHasSideEffect    \tSet all the callees have side effect\n"
+                                     "  --no-setCalleeHasSideEffect \tNot set all the callees have side effect\n",
+                                     {meCategory},
+                                     cl::DisableWith("--no-setCalleeHasSideEffect"));
+
+cl::Option<bool> ubaa({"--ubaa"},
+                      "  --ubaa                      \tEnable UnionBased alias analysis\n"
+                      "  --no-ubaa                   \tDisable UnionBased alias analysis\n",
+                      {meCategory},
+                      cl::DisableWith("--no-ubaa"));
+
+cl::Option<bool> tbaa({"--tbaa"},
+                      "  --tbaa                      \tEnable type-based alias analysis\n"
+                      "  --no-tbaa                   \tDisable type-based alias analysis\n",
+                      {meCategory},
+                      cl::DisableWith("--no-tbaa"));
+
+cl::Option<bool> ddaa({"--ddaa"},
+                      "  --ddaa                      \tEnable demand driven alias analysis\n"
+                      "  --no-ddaa                   \tDisable demand driven alias analysis\n",
+                      {meCategory},
+                      cl::DisableWith("--no-ddaa"));
+
+cl::Option<uint8_t> aliasAnalysisLevel({"--aliasAnalysisLevel"},
+                                       "  --aliasAnalysisLevel        \tSet level of alias analysis. \n"
+                                       "                              \t0: most conservative;\n"
+                                       "                              \t1: Union-based alias analysis; 2: type-based alias analysis;\n"
+                                       "                              \t3: Union-based and type-based alias analysis\n"
+                                       "                              \t--aliasAnalysisLevel=NUM\n",
+                                       {meCategory});
+
+cl::Option<bool> stmtnum({"--stmtnum"},
+                         "  --stmtnum                   \tPrint MeStmt index number in IR dump\n"
+                         "  --no-stmtnum                \tDon't print MeStmt index number in IR dump\n",
+                         {meCategory},
+                         cl::DisableWith("--no-stmtnum"));
+
+cl::Option<bool> rclower({"--rclower"},
+                         "  --rclower                   \tEnable rc lowering\n"
+                         "  --no-rclower                \tDisable rc lowering\n",
+                         {meCategory},
+                         cl::DisableWith("--no-rclower"));
+
+cl::Option<bool> gconlyopt({"--gconlyopt"},
+                           "  --gconlyopt                     \tEnable write barrier optimization in gconly\n"
+                           "  --no-gconlyopt                  \tDisable write barrier optimization in gconly\n",
+                           {meCategory},
+                           cl::DisableWith("--no-gconlyopt"));
+
+cl::Option<bool> usegcbar({"--usegcbar"},
+                          "  --usegcbar                  \tEnable GC barriers\n"
+                          "  --no-usegcbar               \tDisable GC barriers\n",
+                          {meCategory},
+                          cl::DisableWith("--no-usegcbar"));
+
+cl::Option<bool> regnativefunc({"--regnativefunc"},
+                               "  --regnativefunc             \tGenerate native stub function to support JNI registration and calling\n"
+                               "  --no-regnativefunc          \tDon't generate native stub function to support JNI registration and calling\n",
+                               {meCategory},
+                               cl::DisableWith("--no-regnativefunc"));
+
+cl::Option<bool> warnemptynative({"--warnemptynative"},
+                                 "  --warnemptynative           \tGenerate warning and abort unimplemented native function\n"
+                                 "  --no-warnemptynative        \tDon't generate warning and abort unimplemented native function\n",
+                                 {meCategory},
+                                 cl::DisableWith("--no-warnemptynative"));
+
+cl::Option<bool> dumpBefore({"--dump-before"},
+                            "  --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",
+                            {meCategory},
+                            cl::DisableWith("--no-dump-before"));
+
+cl::Option<bool> dumpAfter({"--dump-after"},
+                           "  --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",
+                           {meCategory},
+                           cl::DisableWith("--no-dump-after"));
+
+cl::Option<bool> realcheckcast({"--realcheckcast"},
+                               "  --realcheckcast\n"
+                               "  --no-realcheckcast\n",
+                               {meCategory},
+                               cl::DisableWith("--no-realcheckcast"));
+
+cl::Option<uint32_t> eprelimit({"--eprelimit"},
+                               "  --eprelimit                 \tApply EPRE optimization only for the first NUM expressions\n"
+                               "                              \t--eprelimit=NUM\n",
+                               {meCategory});
+
+cl::Option<uint32_t> eprepulimit({"--eprepulimit"},
+                                 "  --eprepulimit               \tApply EPRE optimization only for the first NUM PUs\n"
+                                 "                              \t--eprepulimit=NUM\n",
+                                 {meCategory});
+
+cl::Option<uint32_t> stmtprepulimit({"--stmtprepulimit"},
+                                    "  --stmtprepulimit            \tApply STMTPRE optimization only for the first NUM PUs\n"
+                                    "                              \t--stmtprepulimit=NUM\n",
+                                    {meCategory});
+
+cl::Option<uint32_t> lprelimit({"--lprelimit"},
+                               "  --lprelimit                 \tApply LPRE optimization only for the first NUM variables\n"
+                               "                              \t--lprelimit=NUM\n",
+                               {meCategory});
+
+cl::Option<uint32_t> lprepulimit({"--lprepulimit"},
+                                 "  --lprepulimit               \tApply LPRE optimization only for the first NUM PUs\n"
+                                 "                              \t--lprepulimit=NUM\n",
+                                 {meCategory});
+
+cl::Option<uint32_t> pregrenamelimit({"--pregrenamelimit"},
+                                     "  --pregrenamelimit           \tApply Preg Renaming optimization only up to NUM times\n"
+                                     "                              \t--pregrenamelimit=NUM\n",
+                                     {meCategory});
+
+cl::Option<uint32_t> rename2preglimit({"--rename2preglimit"},
+                                      "  --rename2preglimit          \tApply Rename-to-Preg optimization only up to NUM times\n"
+                                      "                              \t--rename2preglimit=NUM\n",
+                                      {meCategory});
+
+cl::Option<uint32_t> proplimit({"--proplimit"},
+                               "  --proplimit             \tApply propagation only up to NUM times in each hprop invocation\n"
+                               "                              \t--proplimit=NUM\n",
+                               {meCategory});
+
+cl::Option<uint32_t> copyproplimit({"--copyproplimit"},
+                                   "  --copyproplimit             \tApply copy propagation only up to NUM times\n"
+                                   "                              \t--copyproplimit=NUM\n",
+                                   {meCategory});
+
+cl::Option<uint32_t> delrcpulimit({"--delrcpulimit"},
+                                  "  --delrcpulimit              \tApply DELEGATERC optimization only for the first NUM PUs\n"
+                                  "                              \t--delrcpulimit=NUM\n",
+                                  {meCategory});
+
+cl::Option<uint32_t> profileBbHotRate({"--profile-bb-hot-rate"},
+                                      "  --profile-bb-hot-rate=10   \tA count is regarded as hot if it is in the largest 10%\n",
+                                      {meCategory});
+
+cl::Option<uint32_t> profileBbColdRate({"--profile-bb-cold-rate"},
+                                       "  --profile-bb-cold-rate=99  \tA count is regarded as cold if it is in the smallest 1%\n",
+                                       {meCategory});
+
+cl::Option<bool> ignoreipa({"--ignoreipa"},
+                           "  --ignoreipa                 \tIgnore information provided by interprocedural analysis\n"
+                           "  --no-ignoreipa              \tDon't ignore information provided by interprocedural analysis\n",
+                           {meCategory},
+                           cl::DisableWith("--no-ignoreipa"));
+
+cl::Option<bool> aggressiveABCO({"--aggressiveABCO"},
+                                "  --aggressiveABCO                 \tEnable aggressive array boundary check optimization\n"
+                                "  --no-aggressiveABCO              \tDon't enable aggressive array boundary check optimization\n",
+                                {meCategory},
+                                cl::DisableWith("--no-aggressiveABCO"));
+
+cl::Option<bool> commonABCO({"--commonABCO"},
+                            "  --commonABCO                 \tEnable aggressive array boundary check optimization\n"
+                            "  --no-commonABCO              \tDon't enable aggressive array boundary check optimization\n",
+                            {meCategory},
+                            cl::DisableWith("--no-commonABCO"));
+
+cl::Option<bool> conservativeABCO({"--conservativeABCO"},
+                                  "  --conservativeABCO                 \tEnable aggressive array boundary check optimization\n"
+                                  "  --no-conservativeABCO              \tDon't enable aggressive array boundary check optimization\n",
+                                  {meCategory},
+                                  cl::DisableWith("--no-conservativeABCO"));
+
+cl::Option<bool> epreincluderef({"--epreincluderef"},
+                                "  --epreincluderef            \tInclude ref-type expressions when performing epre optimization\n"
+                                "  --no-epreincluderef         \tDon't include ref-type expressions when performing epre optimization\n",
+                                {meCategory},
+                                cl::DisableWith("--no-epreincluderef"));
+
+cl::Option<bool> eprelocalrefvar({"--eprelocalrefvar"},
+                                 "  --eprelocalrefvar           \tThe EPRE phase will create new localrefvars when appropriate\n"
+                                 "  --no-eprelocalrefvar        \tDisable the EPRE phase create new localrefvars when appropriate\n",
+                                 {meCategory},
+                                 cl::DisableWith("--no-eprelocalrefvar"));
+
+cl::Option<bool> eprelhsivar({"--eprelhsivar"},
+                             "  --eprelhsivar               \tThe EPRE phase will consider iassigns when optimizing ireads\n"
+                             "  --no-eprelhsivar            \tDisable the EPRE phase consider iassigns when optimizing ireads\n",
+                             {meCategory},
+                             cl::DisableWith("--no-eprelhsivar"));
+
+cl::Option<bool> dsekeepref({"--dsekeepref"},
+                            "  --dsekeepref                \tPreverse dassign of local var that are of ref type to anywhere\n"
+                            "  --no-dsekeepref             \tDon't preverse dassign of local var that are of ref type to anywhere\n",
+                            {meCategory},
+                            cl::DisableWith("--no-dsekeepref"));
+
+cl::Option<bool> propbase({"--propbase"},
+                          "  --propbase                  \tApply copy propagation that can change the base of indirect memory accesses\n"
+                          "  --no-propbase               \tDon't apply copy propagation\n",
+                          {meCategory},
+                          cl::DisableWith("--no-propbase"));
+
+cl::Option<bool> propiloadref({"--propiloadref"},
+                              "  --propiloadref              \tAllow copy propagating iloads that are of ref type to anywhere\n"
+                              "  --no-propiloadref           \tDon't aAllow copy propagating iloads that are of ref type to anywhere\n",
+                              {meCategory},
+                              cl::DisableWith("--no-propiloadref"));
+
+cl::Option<bool> propglobalref({"--propglobalref"},
+                               "  --propglobalref             \tAllow copy propagating global that are of ref type to anywhere\n"
+                               "  --no-propglobalref          \tDon't allow copy propagating global that are of ref type to anywhere\n",
+                               {meCategory},
+                               cl::DisableWith("--no-propglobalref"));
+
+cl::Option<bool> propfinaliloadref({"--propfinaliloadref"},
+                                   "  --propfinaliloadref         \tAllow copy propagating iloads of\n"
+                                   "                              \tfinal fields that are of ref type to anywhere\n"
+                                   "  --no-propfinaliloadref      \tDisable propfinaliloadref\n",
+                                   {meCategory},
+                                   cl::DisableWith("--no-propfinaliloadref"));
+
+cl::Option<bool> propiloadrefnonparm({"--propiloadrefnonparm"},
+                                     "  --propiloadrefnonparm       \tAllow copy propagating iloads that are of ref type to\n"
+                                     "                              \tanywhere except actual parameters\n"
+                                     "  --no-propiloadrefnonparm    \tDisbale propiloadref\n",
+                                     {meCategory},
+                                     cl::DisableWith("--no-propiloadrefnonparm"));
+
+cl::Option<bool> lessthrowalias({"--lessthrowalias"},
+                                "  --lessthrowalias            \tHandle aliases at java throw statements more accurately\n"
+                                "  --no-lessthrowalias         \tDisable lessthrowalias\n",
+                                {meCategory},
+                                cl::DisableWith("--no-lessthrowalias"));
+
+cl::Option<bool> nodelegaterc({"--nodelegaterc"},
+                              "  --nodelegateerc             \tDo not apply RC delegation to local object reference pointers\n"
+                              "  --no-nodelegateerc          \tDisable nodelegateerc\n",
+                              {meCategory},
+                              cl::DisableWith("--no-nodelegateerc"));
+
+cl::Option<bool> nocondbasedrc({"--nocondbasedrc"},
+                               "  --nocondbasedrc             \tDo not apply condition-based RC optimization to\n"
+                               "                              \tlocal object reference pointers\n"
+                               "  --no-nocondbasedrc          \tDisable nocondbasedrc\n",
+                               {meCategory},
+                               cl::DisableWith("--no-nocondbasedrc"));
+
+cl::Option<bool> subsumrc({"--subsumrc"},
+                          "  --subsumrc               \tDelete decrements for localrefvars whose live range is just in\n"
+                          "                           \tanother which point to the same obj\n"
+                          "  --no-subsumrc            \tDisable subsumrc\n",
+                          {meCategory},
+                          cl::DisableWith("--no-subsumrc"));
+
+cl::Option<bool> performFSAA({"--performFSAA"},
+                             "  --performFSAA            \tPerform flow sensitive alias analysis\n"
+                             "  --no-performFSAA         \tDisable flow sensitive alias analysis\n",
+                             {meCategory},
+                             cl::DisableWith("--no-performFSAA"));
+
+cl::Option<bool> strengthreduction({"--strengthreduction"},
+                                   "  --strengthreduction      \tPerform strength reduction\n"
+                                   "  --no-strengthreduction   \tDisable strength reduction\n",
+                                   {meCategory},
+                                   cl::DisableWith("--no-strengthreduction"));
+
+cl::Option<bool> sradd({"--sradd"},
+                       "  --sradd                   \tPerform strength reduction for OP_add/sub\n"
+                       "  --no-sradd                \tDisable strength reduction for OP_add/sub\n",
+                       {meCategory},
+                       cl::DisableWith("--no-sradd"));
+
+cl::Option<bool> lftr({"--lftr"},
+                      "  --lftr                   \tPerform linear function test replacement\n"
+                      "  --no-lftr                \tDisable linear function test replacement\n",
+                      {meCategory},
+                      cl::DisableWith("--no-lftr"));
+
+cl::Option<bool> ivopts({"--ivopts"},
+                        "  --ivopts                   \tPerform induction variables optimization\n"
+                        "  --no-ivopts                \tDisable induction variables optimization\n",
+                        {meCategory},
+                        cl::DisableWith("--no-ivopts"));
+
+cl::Option<bool> checkcastopt({"--checkcastopt"},
+                              "  --checkcastopt             \tApply template--checkcast optimization \n"
+                              "  --no-checkcastopt          \tDisable checkcastopt \n",
+                              {meCategory},
+                              cl::DisableWith("--no-checkcastopt"));
+
+cl::Option<bool> parmtoptr({"--parmtoptr"},
+                           "  --parmtoptr                 \tAllow rcoptlocals to change actual parameters from ref to ptr type\n"
+                           "  --no-parmtoptr              \tDisable parmtoptr\n",
+                           {meCategory},
+                           cl::DisableWith("--no-parmtoptr"));
+
+cl::Option<bool> nullcheckpre({"--nullcheckpre"},
+                              "  --nullcheckpre              \tTurn on partial redundancy elimination of null pointer checks\n"
+                              "  --no-nullcheckpre           \tDisable nullcheckpre\n",
+                              {meCategory},
+                              cl::DisableWith("--no-nullcheckpre"));
+
+cl::Option<bool> clinitpre({"--clinitpre"},
+                           "  --clinitpre                 \tTurn on partial redundancy elimination of class initialization checks\n"
+                           "  --no-clinitpre              \tDisable clinitpre\n",
+                           {meCategory},
+                           cl::DisableWith("--no-clinitpre"));
+
+cl::Option<bool> dassignpre({"--dassignpre"},
+                            "  --dassignpre                \tTurn on partial redundancy elimination of assignments to scalar variables\n"
+                            "  --no-dassignpre             \tDisable dassignpre\n",
+                            {meCategory},
+                            cl::DisableWith("--no-dassignpre"));
+
+cl::Option<bool> assign2finalpre({"--assign2finalpre"},
+                                 "  --assign2finalpre           \tTurn on partial redundancy elimination of assignments to final variables\n"
+                                 "  --no-assign2finalpre        \tDisable assign2finalpre\n",
+                                 {meCategory},
+                                 cl::DisableWith("--no-assign2finalpre"));
+
+cl::Option<bool> regreadatreturn({"--regreadatreturn"},
+                                 "  --regreadatreturn           \tAllow register promotion to promote the operand of return statements\n"
+                                 "  --no-regreadatreturn        \tDisable regreadatreturn\n",
+                                 {meCategory},
+                                 cl::DisableWith("--no-regreadatreturn"));
+
+cl::Option<bool> propatphi({"--propatphi"},
+                           "  --propatphi                 \tEnable copy propagation across phi nodes\n"
+                           "  --no-propatphi              \tDisable propatphi\n",
+                           {meCategory},
+                           cl::DisableWith("--no-propatphi"));
+
+cl::Option<bool> propduringbuild({"--propduringbuild"},
+                                 "  --propduringbuild           \tEnable copy propagation when building HSSA\n"
+                                 "  --no-propduringbuild        \tDisable propduringbuild\n",
+                                 {meCategory},
+                                 cl::DisableWith("--no-propduringbuild"));
+
+cl::Option<bool> propwithinverse({"--propwithinverse"},
+                                 "  --propwithinverse           \tEnable copy propagation across statements with inverse functions"
+                                 "  --no-propwithinverse        \tDisable copy propagation across statements with inverse functions\n",
+                                 {meCategory},
+                                 cl::DisableWith(""));
+
+cl::Option<bool> nativeopt({"--nativeopt"},
+                           "  --nativeopt              \tEnable native opt\n"
+                           "  --no-nativeopt           \tDisable native opt\n",
+                           {meCategory},
+                           cl::DisableWith("--no-nativeopt"));
+
+cl::Option<bool> optdirectcall({"--optdirectcall"},
+                               "  --optdirectcall             \tEnable redundancy elimination of directcalls\n"
+                               "  --no-optdirectcall          \tDisable optdirectcall\n",
+                               {meCategory},
+                               cl::DisableWith("--no-optdirectcall"));
+
+cl::Option<bool> enableEa({"--enable-ea"},
+                           "  --enable-ea                 \tEnable escape analysis\n"
+                           "  --no-enable-ea              \tDisable escape analysis\n",
+                          {meCategory},
+                           cl::DisableWith("--no-enable-ea"));
+
+cl::Option<bool> lprespeculate({"--lprespeculate"},
+                               "  --lprespeculate             \tEnable speculative code motion in LPRE phase\n"
+                               "  --no-lprespeculate          \tDisable speculative code motion in LPRE phase\n",
+                               {meCategory},
+                               cl::DisableWith("--no-lprespeculate"));
+
+cl::Option<bool> lpre4address({"--lpre4address"},
+                              "  --lpre4address              \tEnable register promotion of addresses in LPRE phase\n"
+                              "  --no-lpre4address           \tDisable register promotion of addresses in LPRE phase\n",
+                              cl::DisableWith("--no-lpre4address"));
+
+cl::Option<bool> lpre4largeint({"--lpre4largeint"},
+                               "  --lpre4largeint             \tEnable register promotion of large integers in LPRE phase\n"
+                               "  --no-lpre4largeint          \tDisable register promotion of large integers in LPRE phase\n",
+                               {meCategory},
+                               cl::DisableWith("--no-lpre4largeint"));
+
+cl::Option<bool> spillatcatch({"--spillatcatch"},
+                              "  --spillatcatch              \tMinimize upward exposed preg usage in catch blocks\n"
+                              "  --no-spillatcatch           \tDisable spillatcatch\n",
+                              {meCategory},
+                              cl::DisableWith("--no-spillatcatch"));
+
+cl::Option<bool> placementrc({"--placementrc"},
+                             "  --placementrc               \tInsert RC decrements for localrefvars using\n"
+                             "                              \tthe placement optimization approach\n"
+                             "  --no-placementrc            \tInsert RC decrements for localrefvars using\n",
+                             {meCategory},
+                             cl::DisableWith("--no-placementrc"));
+
+cl::Option<bool> lazydecouple({"--lazydecouple"},
+                              "  --lazydecouple              \tDo optimized for lazy Decouple\n"
+                              "  --no-lazydecouple           \tDo not optimized for lazy Decouple\n",
+                              {meCategory},
+                              cl::DisableWith("--no-lazydecouple"));
+
+cl::Option<bool> mergestmts({"--mergestmts"},
+                            "  --mergestmts                \tTurn on statment merging optimization\n"
+                            "  --no-mergestmts             \tDisable mergestmts\n",
+                            {meCategory},
+                            cl::DisableWith("--no-mergestmts"));
+
+cl::Option<bool> generalRegOnly({"--general-reg-only"},
+                                "  --general-reg-only        \tME will avoid generate fp type when enable general-reg-only\n"
+                                "  --no-general-reg-only     \tDisable general-reg-only\n",
+                                {meCategory});
+
+cl::Option<std::string> inlinefunclist({"--inlinefunclist"},
+                                       "  --inlinefunclist            \tInlining related configuration\n"
+                                       "                              \t--inlinefunclist=\n",
+                                       {meCategory});
+
+cl::Option<uint32_t> threads({"--threads"},
+                             "  --threads=n                 \tOptimizing me functions using n threads\n"
+                             "                              \tIf n >= 2, ignore-inferred-return-type will be enabled default\n",
+                             {meCategory});
+
+cl::Option<bool> ignoreInferredRetType({"--ignore-inferred-ret-type"},
+                                       "  --ignore-inferred-ret-type  \tIgnore func return type inferred by ssadevirt\n"
+                                       "  --no-ignore-inferred-ret-type\tDo not ignore func return type inferred by ssadevirt\n",
+                                       {meCategory},
+                                       cl::DisableWith("--no-ignore-inferred-ret-type"));
+
+cl::Option<bool> meverify({"--meverify"},
+                          "  --meverify                       \tenable meverify features\n",
+                          {meCategory},
+                          cl::DisableWith("--no-meverify"));
+
+cl::Option<uint32_t> dserunslimit({"--dserunslimit"},
+                                  "  --dserunslimit=n            \tControl number of times dse phase can be run\n"
+                                  "                              \t--dserunslimit=NUM\n",
+                                  {meCategory});
+
+cl::Option<uint32_t> hdserunslimit({"--hdserunslimit"},
+                                   "  --hdserunslimit=n           \tControl number of times hdse phase can be run\n"
+                                   "                              \t--hdserunslimit=NUM\n",
+                                   {meCategory});
+
+cl::Option<uint32_t> hproprunslimit({"--hproprunslimit"},
+                                    "  --hproprunslimit=n          \tControl number of times hprop phase can be run\n"
+                                    "                              \t--hproprunslimit=NUM\n",
+                                    {meCategory});
+
+cl::Option<uint32_t> sinklimit({"--sinklimit"},
+                               "  --sinklimit=n          \tControl number of stmts sink-phase can sink\n"
+                               "                              \t--sinklimit=NUM\n",
+                               {meCategory});
+
+cl::Option<uint32_t> sinkPUlimit({"--sinkPUlimit"},
+                                 "  --sinkPUlimit=n          \tControl number of function sink-phase can be run\n"
+                                 "                              \t--sinkPUlimit=NUM\n",
+                                 {meCategory});
+
+cl::Option<bool> loopvec({"--loopvec"},
+                         "  --loopvec                   \tEnable auto loop vectorization\n"
+                         "  --no-loopvec                \tDisable auto loop vectorization\n",
+                         {meCategory},
+                         cl::DisableWith("--no-loopvec"));
+
+cl::Option<bool> seqvec({"--seqvec"},
+                        "  --seqvec                   \tEnable auto sequencial vectorization\n"
+                        "  --no-seqvec                \tDisable auto sequencial vectorization\n",
+                        {meCategory},
+                        cl::DisableWith("--no-seqvec"));
+
+cl::Option<bool> layoutwithpredict({"--layoutwithpredict"},
+                                   "  --layoutwithpredict        \tEnable optimizing output layout using branch prediction\n"
+                                   "  --no-layoutwithpredict     \tDisable optimizing output layout using branch prediction\n",
+                                   {meCategory},
+                                   cl::DisableWith("--no-layoutwithpredict"));
+
+cl::Option<uint32_t> veclooplimit({"--veclooplimit"},
+                                  "  --veclooplimit             \tApply vectorize loops only up to NUM \n"
+                                  "                              \t--veclooplimit=NUM\n",
+                                  {meCategory});
+
+cl::Option<uint32_t> ivoptslimit({"--ivoptslimit"},
+                                 "  --ivoptslimit              \tApply ivopts only up to NUM loops \n"
+                                 "                              \t--ivoptslimit=NUM\n",
+                                 {meCategory});
+
+cl::Option<std::string> acquireFunc({"--acquire-func"},
+                                    "  --acquire-func              \t--acquire-func=FUNCNAME\n",
+                                    {meCategory});
+
+cl::Option<std::string> releaseFunc({"--release-func"},
+                                     "  --release-func              \t--release-func=FUNCNAME\n",
+                                    {meCategory});
+
+cl::Option<bool> toolonly({"--toolonly"},
+                          "  --toolonly\n"
+                          "  --no-toolonly\n",
+                          {meCategory},
+                          cl::DisableWith("--no-toolonly"));
+
+cl::Option<bool> toolstrict({"--toolstrict"},
+                            "  --toolstrict\n"
+                            "  --no-toolstrict\n",
+                            {meCategory},
+                            cl::DisableWith("--no-toolstrict"));
+
+cl::Option<bool> skipvirtual({"--skipvirtual"},
+                             "  --skipvirtual\n"
+                             "  --no-skipvirtual\n",
+                             {meCategory},
+                             cl::DisableWith("--no-skipvirtual"));
+
+cl::Option<uint32_t> warning({"--warning"},
+                             "  --warning=level             \t--warning=level\n",
+                             {meCategory});
+
+cl::Option<uint8_t> remat({"--remat"},
+                          "  --remat                     \tEnable rematerialization during register allocation\n"
+                          "                              \t     0: no rematerialization (default)\n"
+                          "                              \t  >= 1: rematerialize constants\n"
+                          "                              \t  >= 2: rematerialize addresses\n"
+                          "                              \t  >= 3: rematerialize local dreads\n"
+                          "                              \t  >= 4: rematerialize global dreads\n",
+                          {meCategory});
+
+cl::Option<bool> unifyrets({"--unifyrets"},
+                           "  --unifyrets                   \tEnable return blocks unification\n"
+                           "  --no-unifyrets                \tDisable return blocks unification\n",
+                           {meCategory},
+                           cl::DisableWith("--no-unifyrets"));
+
+cl::Option<bool> lfo({"--lfo"},
+                     "  --lfo                   \tEnable LFO framework\n"
+                     "  --no-lfo                \tDisable LFO framework\n",
+                     {meCategory},
+                     cl::DisableWith("--no-lfo"));
+
+}
diff --git a/src/mapleall/maple_me/src/me_side_effect.cpp b/src/mapleall/maple_me/src/me_side_effect.cpp
index ad493a9e014b82c3411bbfca8b7dc9ca8a24ba55..37194b360204db3cfc668f4e5e376a96cd4e02b2 100644
--- a/src/mapleall/maple_me/src/me_side_effect.cpp
+++ b/src/mapleall/maple_me/src/me_side_effect.cpp
@@ -18,7 +18,6 @@
 #include "me_ir.h"
 #include "me_irmap.h"
 #include "me_phase_manager.h"
-#include "ipa_option.h"
 
 // IPA sideeffect analysis
 // Default value:
diff --git a/src/mapleall/maple_util/BUILD.gn b/src/mapleall/maple_util/BUILD.gn
index a8501227e904a4c0d43efa1f9af8373d4117808e..b7ab3f311222e50c6f2dbaf429b25465cfd0b4f0 100755
--- a/src/mapleall/maple_util/BUILD.gn
+++ b/src/mapleall/maple_util/BUILD.gn
@@ -23,6 +23,7 @@ src_libmplutil = [
   "src/mpl_timer.cpp",
   "src/profile.cpp",
   "src/string_utils.cpp",
+  "src/file_utils.cpp",
   "src/error_code.cpp",
   "src/thread_env.cpp",
 ]
diff --git a/src/mapleall/maple_util/include/cl_option.h b/src/mapleall/maple_util/include/cl_option.h
index ba7365b8d61175529b20c9455cd6dc102aa9e1aa..d9b50b4f9e00106b81246779639f66fd3339feb6 100644
--- a/src/mapleall/maple_util/include/cl_option.h
+++ b/src/mapleall/maple_util/include/cl_option.h
@@ -17,8 +17,11 @@
 
 #include "cl_parser.h"
 
+#include <any>
 #include <cassert>
 #include <cstdint>
+#include <deque>
+#include <functional>
 #include <map>
 #include <memory>
 #include <string>
@@ -27,6 +30,16 @@
 
 namespace cl {
 
+template <typename T>
+constexpr inline bool digitalCheck = (std::is_same_v<std::uint8_t, T> ||
+                                      std::is_same_v<std::uint16_t, T> ||
+                                      std::is_same_v<std::uint32_t, T> ||
+                                      std::is_same_v<std::uint64_t, T> ||
+                                      std::is_same_v<std::int64_t, T> ||
+                                      std::is_same_v<std::int32_t, T> ||
+                                      std::is_same_v<std::int16_t, T> ||
+                                      std::is_same_v<std::int8_t, T>);
+
 /* is key VALUE needed ? */
 enum class ValueExpectedType {
   kValueOptional, /* "--key VALUE" and "--key" are allowed */
@@ -40,6 +53,12 @@ enum class ValueJoinedType {
   kValueJoined,      /* joined option (like -DMACRO) is allowed */
 };
 
+/* is option visible from Help ? */
+enum class OptionVisibilityType {
+  kVisibleOption, /* an Option will be visible in Help */
+  kHidedOption    /* an Option will be NOT visible in Help */
+};
+
 /* These constexpr are needed to use short name in option description, like this:
  * cl::Option<int32_t> option({"--option"}, "Description", optionalValue);
  * instead of:
@@ -50,6 +69,8 @@ constexpr ValueExpectedType requiredValue = ValueExpectedType::kValueRequired;
 constexpr ValueExpectedType disallowedValue = ValueExpectedType::kValueDisallowed;
 constexpr ValueJoinedType joinedValue = ValueJoinedType::kValueJoined;
 constexpr ValueJoinedType separatedValue = ValueJoinedType::kValueSeparated;
+constexpr OptionVisibilityType visible = OptionVisibilityType::kVisibleOption;
+constexpr OptionVisibilityType hide = OptionVisibilityType::kHidedOption;
 
 /* Initializer is used to set default value for an option */
 template <typename T> struct Init {
@@ -66,17 +87,35 @@ struct DisableWith {
   explicit DisableWith(const std::string &val) : disableWith(val) {}
 };
 
+class OptionWrp {
+public:
+  template <typename T>
+  /* implicit */ OptionWrp(T v) : val(v) {}
+
+  template <typename T>
+  operator T() {
+    T *pval = std::any_cast<T>(&val);
+    assert(pval);
+    return *pval;
+  }
+
+  std::any val;
+};
+
 /* Interface for templated Option class */
 class OptionInterface {
  public:
   virtual ~OptionInterface() = default;
 
   virtual RetCode Parse(ssize_t &argsIndex,
-                        const std::vector<std::string_view> &args, KeyArg &keyArg) = 0;
+                        const std::deque<std::string_view> &args, KeyArg &keyArg) = 0;
+  virtual void Clear() = 0;
+  virtual std::vector<std::string> GetRawValues() = 0;
+  virtual OptionWrp GetCommonValue() const = 0;
 
   void FinalizeInitialization(const std::vector<std::string> &optnames,
                               const std::string &descr,
-                              const std::vector<OptionCategory *> &optionCategories);
+                              const std::vector<std::reference_wrapper<OptionCategory>> &optionCategories);
 
   bool IsEnabledByUser() const {
     return isEnabledByUser;
@@ -90,15 +129,25 @@ class OptionInterface {
     return (valueJoined == ValueJoinedType::kValueJoined);
   }
 
+  bool IsVisibleOption() const {
+    return (visibleOption == OptionVisibilityType::kVisibleOption);
+  }
+
   const std::string &GetDisabledName() const {
     return disableWith;
   }
 
+  virtual std::string GetName() const {
+    assert(names.size() > 0);
+    return names[0];
+  }
+
   const std::string &GetDescription() const {
     return optDescription;
   }
 
-  std::vector<std::string> rawValues; // Value not converted to template T type
+  std::string rawKey;
+  std::vector<OptionCategory *> optCategories; // The option is registred in these categories
 
  protected:
   std::vector<std::string> names; // names of the option
@@ -109,6 +158,7 @@ class OptionInterface {
 
   ValueExpectedType valueExpected = ValueExpectedType::kValueRequired;  // whether the value is expected
   ValueJoinedType valueJoined = ValueJoinedType::kValueSeparated;     // Joined option like -DMACRO
+  OptionVisibilityType visibleOption = OptionVisibilityType::kVisibleOption; // Visible in Help
 };
 
 /* Option class describes command line option */
@@ -131,7 +181,7 @@ class Option : public OptionInterface {
   template <typename... ArgsT>
   explicit Option(const std::vector<std::string> &optnames,
                   const std::string &descr,
-                  const std::vector<OptionCategory *> &optionCategories,
+                  const std::vector<std::reference_wrapper<OptionCategory>> &optionCategories,
                   const ArgsT &... args) {
     /* It's needed to avoid empty Apply() */
     if constexpr (sizeof...(ArgsT) > 0) {
@@ -152,13 +202,11 @@ class Option : public OptionInterface {
     return GetValue();
   }
 
-  RetCode Parse(ssize_t &argsIndex, const std::vector<std::string_view> &args,
+  RetCode Parse(ssize_t &argsIndex, const std::deque<std::string_view> &args,
                 KeyArg &keyArg) override {
     RetCode err = RetCode::noError;
-    if constexpr(std::is_same_v<std::uint32_t, T> ||
-                 std::is_same_v<std::uint64_t, T> ||
-                 std::is_same_v<std::int32_t, T> ||
-                 std::is_same_v<std::int64_t, T>) {
+    auto &key = args[argsIndex];
+    if constexpr(digitalCheck<T>) {
       err = ParseDigit(argsIndex, args, keyArg);
     } else if constexpr(std::is_same_v<std::string, T>) {
       err = ParseString(argsIndex, args, keyArg);
@@ -171,18 +219,80 @@ class Option : public OptionInterface {
 
     if (err == RetCode::noError) {
       isEnabledByUser = true;
+      rawKey = key;
     }
     return err;
   }
 
+  void Clear() override {
+    if (defaultValue.isSet) {
+      value = defaultValue.defaultValue;
+    } else {
+      if constexpr(digitalCheck<T>) {
+        value = 0;
+      } else if constexpr(std::is_same_v<std::string, T>) {
+        value = "";
+      } else if constexpr(std::is_same_v<bool, T>) {
+        value = false;
+      } else {
+        /* Type dependent static_assert. Simple static_assert(false") does not work */
+        static_assert(false && sizeof(T), "T not supported");
+      }
+    }
+
+    isEnabledByUser = false;
+  }
+
+  std::vector<std::string> GetRawValues() override {
+    std::vector<std::string> rawVals;
+    FillVal(value, rawVals);
+    return rawVals;
+  }
+
+  std::string GetName() const override {
+    if constexpr (std::is_same_v<bool, T>) {
+      assert(names.size() > 0);
+      return ((value == true) ? names[0] : this->GetDisabledName());
+    } else {
+      return OptionInterface::GetName();
+    }
+  }
+
   const T &GetValue() const {
     return value;
   }
 
-  void SetValue(const T &val) {
+  OptionWrp GetCommonValue() const override {
+    return value;
+  }
+
+  virtual void SetValue(const T &val) {
     value = val;
   }
 
+ protected:
+  RetCode ParseDigit(ssize_t &argsIndex, const std::deque<std::string_view> &args, KeyArg &keyArg);
+  RetCode ParseString(ssize_t &argsIndex, const std::deque<std::string_view> &args, KeyArg &keyArg);
+  RetCode ParseBool(ssize_t &argsIndex, const std::deque<std::string_view> &args);
+
+  void FillVal(const T &val, std::vector<std::string> &vals) {
+    if constexpr(digitalCheck<T>) {
+      vals.emplace_back(std::to_string(val));
+    } else if constexpr (std::is_same_v<std::string, T>) {
+      vals.emplace_back(val);
+    } else if constexpr (std::is_same_v<bool, T>) {
+      vals.emplace_back("");
+    } else {
+      /* Type dependent static_assert. Simple static_assert(false") does not work */
+      static_assert(false && sizeof(T), "T not supported");
+    }
+  }
+
+  struct DefaultValue {
+    T defaultValue;
+    bool isSet = false;
+  } defaultValue;
+
  private:
   /* To apply input arguments in any order */
   template <typename ArgT, typename... ArgsT>
@@ -191,6 +301,8 @@ class Option : public OptionInterface {
       SetExpectingAttribute(arg);
     } else if constexpr (std::is_same_v<ValueJoinedType, ArgT>) {
       SetJoinAttribute(arg);
+    } else if constexpr (std::is_same_v<OptionVisibilityType, ArgT>) {
+      SetVisibilityAttribute(arg);
     } else if constexpr (std::is_same_v<DisableWith, ArgT>) {
       SetDisablingAttribute(arg);
     } else {
@@ -203,13 +315,11 @@ class Option : public OptionInterface {
     }
   }
 
-  RetCode ParseDigit(ssize_t &argsIndex, const std::vector<std::string_view> &args, KeyArg &keyArg);
-  RetCode ParseString(ssize_t &argsIndex, const std::vector<std::string_view> &args, KeyArg &keyArg);
-  RetCode ParseBool(ssize_t &argsIndex, const std::vector<std::string_view> &args);
-
   template <typename InitT>
   void SetDefaultAttribute(const Init<InitT> &initializer) {
-    value = initializer.defaultVal;
+    SetValue(initializer.defaultVal);
+    defaultValue.isSet = true;
+    defaultValue.defaultValue = value;
   }
 
   void SetExpectingAttribute(ValueExpectedType value) {
@@ -220,6 +330,10 @@ class Option : public OptionInterface {
     valueJoined = value;
   }
 
+  void SetVisibilityAttribute(OptionVisibilityType value) {
+    visibleOption = value;
+  }
+
   void SetDisablingAttribute(const DisableWith &value) {
     disableWith = value.disableWith;
   }
@@ -249,6 +363,73 @@ bool operator==(const char *arg, Option<T>& opt) {
   return opt == arg;
 }
 
+template <typename T>
+void CopyIfEnabled(T &dst, cl::Option<T> &src) {
+  if (src.IsEnabledByUser()) {
+    dst = src;
+  }
+}
+
+template <typename T>
+void CopyIfEnabled(T &dst, const T &src, cl::Option<T> &opt) {
+  if (opt.IsEnabledByUser()) {
+    dst = src;
+  }
+}
+
+template <typename T>
+class List : public Option<T> {
+public:
+  // options must not be copyable and assignment
+  List(const List &) = delete;
+  List &operator=(const List &) = delete;
+
+  /* variadic template is used to apply any number of options parameters in any order */
+  template <typename... ArgsT>
+  explicit List(const std::vector<std::string> &optnames,
+                const std::string &descr,
+                const ArgsT &... args) : Option<T>(optnames, descr, args...) {};
+
+  template <typename... ArgsT>
+  explicit List(const std::vector<std::string> &optnames,
+                const std::string &descr,
+                const std::vector<std::reference_wrapper<OptionCategory>> &optionCategories,
+                const ArgsT &... args) : Option<T>(optnames, descr, optionCategories, args...) {};
+
+  void Clear() override {
+    values.clear();
+    if (this->defaultValue.isSet) {
+      SetValue(this->defaultValue.defaultValue);
+    }
+    this->isEnabledByUser = false;
+  }
+
+  void SetValue(const T &val) override {
+    values.push_back(val);
+  }
+
+  const T &GetValue() const {
+    static_assert(false && sizeof(T), "GetValue must be not used for List");
+    return T();
+  }
+
+  const std::vector<T> &GetValues() const {
+    return values;
+  }
+
+  std::vector<std::string> GetRawValues() override {
+    std::vector<std::string> rawVals;
+    for (const auto &val : values) {
+      this->FillVal(val, rawVals);
+    }
+
+    return rawVals;
+  }
+
+private:
+  std::vector<T> values;
+};
+
 }
 
 #endif /* MAPLE_UTIL_INCLUDE_OPTION_H */
diff --git a/src/mapleall/maple_util/include/cl_parser.h b/src/mapleall/maple_util/include/cl_parser.h
index f0b41d733bd175998a32f610cbc76bcb5298f0de..bc419494acc48fb9aa8c171353f0b29c05cfec13 100644
--- a/src/mapleall/maple_util/include/cl_parser.h
+++ b/src/mapleall/maple_util/include/cl_parser.h
@@ -19,7 +19,9 @@
 #include <string>
 #include <string_view>
 #include <unordered_map>
+#include <unordered_set>
 #include <vector>
+#include <deque>
 
 namespace cl {
 
@@ -52,6 +54,21 @@ struct KeyArg {
 struct OptionCategory {
   OptionsMapType options;
   OptionsMapType joinedOptions;
+  std::vector<OptionInterface *> registredOptions;
+
+  void AddEnabledOption(OptionInterface *opt) {
+    if (enabledOptionsSet.find(opt) == enabledOptionsSet.end()) {
+      enabledOptionsSet.insert(opt);
+      enabledOptions.push_back(opt);
+    }
+  }
+
+  const std::vector<OptionInterface *> &GetEnabledOptions() {
+    return enabledOptions;
+  }
+
+ private:
+  std::unordered_set<OptionInterface *> enabledOptionsSet;
   std::vector<OptionInterface *> enabledOptions;
 };
 
@@ -69,31 +86,61 @@ class CommandLine {
     return Parse(argc, argv, defaultCategory);
   }
 
-  RetCode HandleInputArgs(const std::vector<std::string_view> &args,
+  RetCode HandleInputArgs(const std::deque<std::string_view> &args,
                           OptionCategory &optCategory);
   void Register(const std::vector<std::string> &optNames, OptionInterface &opt,
                 OptionCategory &optCategory);
 
+  void Clear(OptionCategory &optCategory);
+  void Clear() {
+    return Clear(defaultCategory);
+  }
+
+  void BashCompletionPrinter(const OptionCategory &optCategory) const;
+  void BashCompletionPrinter() const {
+    return BashCompletionPrinter(defaultCategory);
+  }
+
+  void HelpPrinter(const OptionCategory &optCategory) const;
+  void HelpPrinter() const {
+    return HelpPrinter(defaultCategory);
+  }
+
   std::vector<std::pair<std::string, RetCode>> badCLArgs;
   OptionCategory defaultCategory;
 
+  /* NOTE: categories must be constructed before options.
+   * It's the reason why they are inside CommandLine.
+   * Looks like ugly architecture, but we need it */
+  cl::OptionCategory clangCategory;
+  cl::OptionCategory hir2mplCategory;
+  cl::OptionCategory mpl2mplCategory;
+  cl::OptionCategory meCategory;
+  cl::OptionCategory cgCategory;
+  cl::OptionCategory asCategory;
+  cl::OptionCategory ldCategory;
+
+  cl::OptionCategory dex2mplCategory;
+  cl::OptionCategory jbc2mplCategory;
+  cl::OptionCategory ipaCategory;
+
  private:
   CommandLine() = default;
 
   OptionInterface *CheckJoinedOption(KeyArg &keyArg, OptionCategory &optCategory);
   RetCode ParseJoinedOption(ssize_t &argsIndex,
-                            const std::vector<std::string_view> &args,
+                            const std::deque<std::string_view> &args,
                             KeyArg &keyArg, OptionCategory &optCategory);
   RetCode ParseOption(ssize_t &argsIndex,
-                      const std::vector<std::string_view> &args,
+                      const std::deque<std::string_view> &args,
                       KeyArg &keyArg, OptionCategory &optCategory,
                       OptionInterface *opt);
   RetCode ParseEqualOption(ssize_t &argsIndex,
-                           const std::vector<std::string_view> &args,
+                           const std::deque<std::string_view> &args,
                            KeyArg &keyArg, OptionCategory &optCategory,
                            const OptionsMapType &optMap, ssize_t pos);
   RetCode ParseSimpleOption(ssize_t &argsIndex,
-                            const std::vector<std::string_view> &args,
+                            const std::deque<std::string_view> &args,
                             KeyArg &keyArg, OptionCategory &optCategory,
                             const OptionsMapType &optMap);
 };
diff --git a/src/mapleall/maple_driver/include/file_utils.h b/src/mapleall/maple_util/include/file_utils.h
similarity index 96%
rename from src/mapleall/maple_driver/include/file_utils.h
rename to src/mapleall/maple_util/include/file_utils.h
index 921d3fa489d81d1ebf354c25da3e344a19fada5c..141fca9d9a9d3bbc186fe99bbe949e90dd8185b3 100644
--- a/src/mapleall/maple_driver/include/file_utils.h
+++ b/src/mapleall/maple_util/include/file_utils.h
@@ -31,6 +31,7 @@ class FileUtils {
   static std::string GetFileFolder(const std::string &filePath);
   static std::string GetExecutable();
   static int Remove(const std::string &filePath);
+  static bool IsFileExists(const std::string &filePath);
   static std::string AppendMapleRootIfNeeded(bool needRootPath, const std::string &path,
                                              const std::string &defaultRoot = "." + kFileSeperatorStr);
 };
diff --git a/src/mapleall/maple_driver/include/safe_exe.h b/src/mapleall/maple_util/include/safe_exe.h
similarity index 100%
rename from src/mapleall/maple_driver/include/safe_exe.h
rename to src/mapleall/maple_util/include/safe_exe.h
diff --git a/src/mapleall/maple_util/src/cl_option.cpp b/src/mapleall/maple_util/src/cl_option.cpp
index 477891bc28c6d3c9e1936ae07fb2f2ac54d739f6..fa9510aedb6438f56777b50a13697af070c0e242 100644
--- a/src/mapleall/maple_util/src/cl_option.cpp
+++ b/src/mapleall/maple_util/src/cl_option.cpp
@@ -21,7 +21,7 @@ using namespace cl;
 
 void OptionInterface::FinalizeInitialization(const std::vector<std::string> &optnames,
                                              const std::string &descr,
-                                             const std::vector<OptionCategory *> &optionCategories) {
+                                             const std::vector<std::reference_wrapper<OptionCategory>> &optionCategories) {
   optDescription = descr;
   auto &cl = CommandLine::GetCommandLine();
 
@@ -31,7 +31,7 @@ void OptionInterface::FinalizeInitialization(const std::vector<std::string> &opt
     cl.Register(optnames, *this, cl.defaultCategory);
   } else {
     for (auto &cat : optionCategories) {
-      cl.Register(optnames, *this, *cat);
+      cl.Register(optnames, *this, cat.get());
     }
   }
 }
diff --git a/src/mapleall/maple_util/src/cl_option_parser.cpp b/src/mapleall/maple_util/src/cl_option_parser.cpp
index adaecd48d85e14fb1e483554379e20ccabd76130..8db521b4974d9bdefd8b3227f10af59d76a15c0a 100644
--- a/src/mapleall/maple_util/src/cl_option_parser.cpp
+++ b/src/mapleall/maple_util/src/cl_option_parser.cpp
@@ -44,7 +44,7 @@ bool IsPrefixDetected(std::string_view opt) {
 /* NOTE: Returning ssize_t parameter is used to show how many command line arguments
  * handled with this key. argsIndex must be incremented with this parameter outside of ExtractValue. */
 std::pair<RetCode, ssize_t> ExtractValue(ssize_t argsIndex,
-                                         const std::vector<std::string_view> &args,
+                                         const std::deque<std::string_view> &args,
                                          const OptionInterface &opt, KeyArg &keyArg) {
   /* The option like "--key= " does not contain a value after equal symbol */
   if (keyArg.isEqualOpt == true && keyArg.val.empty()) {
@@ -89,7 +89,7 @@ std::pair<RetCode, ssize_t> ExtractValue(ssize_t argsIndex,
  * ################################################################ */
 
 template <> RetCode Option<bool>::ParseBool(ssize_t &argsIndex,
-                                            const std::vector<std::string_view> &args) {
+                                            const std::deque<std::string_view> &args) {
   /* DisabledName should set it to false, like --fno-omit-framepointer vs --fomit-framepointer */
   SetValue(GetDisabledName() != args[argsIndex]);
 
@@ -99,7 +99,7 @@ template <> RetCode Option<bool>::ParseBool(ssize_t &argsIndex,
 
 /* NOTE: argsIndex must be incremented only if option is handled successfully */
 template <> RetCode Option<std::string>::ParseString(ssize_t &argsIndex,
-                                                     const std::vector<std::string_view> &args,
+                                                     const std::deque<std::string_view> &args,
                                                      KeyArg &keyArg) {
   RetCode err = RetCode::noError;
   ssize_t indexIncCnt = 0;
@@ -121,15 +121,13 @@ template <> RetCode Option<std::string>::ParseString(ssize_t &argsIndex,
     return RetCode::unnecessaryValue;
   }
 
-  if (IsPrefixDetected(keyArg.val)) {
-    if (ExpectedVal() == ValueExpectedType::kValueRequired) {
-      return RetCode::valueEmpty;
-    }
+  /* --key --value is allowed only for kValueRequired case  */
+  if (IsPrefixDetected(keyArg.val) && !keyArg.isEqualOpt &&
+      ExpectedVal() == ValueExpectedType::kValueOptional) {
     ++argsIndex;
     return RetCode::noError;
   }
 
-  rawValues.emplace_back(keyArg.val);
   SetValue(std::string(keyArg.val));
 
   argsIndex += 1 + indexIncCnt; // 1 for key, indexIncCnt for Key Value from ExtractValue
@@ -139,13 +137,9 @@ template <> RetCode Option<std::string>::ParseString(ssize_t &argsIndex,
 /* NOTE: argsIndex must be incremented only if option is handled successfully */
 template <typename T>
 RetCode Option<T>::ParseDigit(ssize_t &argsIndex,
-                              const std::vector<std::string_view> &args,
+                              const std::deque<std::string_view> &args,
                               KeyArg &keyArg) {
-  constexpr bool u64Type = std::is_same<T, uint64_t>::value;
-  constexpr bool u32Type = std::is_same<T, uint32_t>::value;
-  constexpr bool i64Type = std::is_same<T, int64_t>::value;
-  constexpr bool i32Type = std::is_same<T, int32_t>::value;
-  static_assert(u64Type || u32Type || i64Type || i32Type, "Expected (u)intXX types");
+  static_assert(digitalCheck<T>, "Expected (u)intXX types");
 
   RetCode err = RetCode::noError;
   ssize_t indexIncCnt = 0;
@@ -177,7 +171,6 @@ RetCode Option<T>::ParseDigit(ssize_t &argsIndex,
     return RetCode::incorrectValue;
   }
 
-  rawValues.emplace_back(keyArg.val);
   SetValue(dig);
 
   argsIndex += 1 + indexIncCnt; // 1 for key, indexIncCnt for Key Value from ExtractValue
@@ -185,7 +178,11 @@ RetCode Option<T>::ParseDigit(ssize_t &argsIndex,
 }
 
 /* Needed to describe OptionType<>::Parse template in this .cpp file */
+template class cl::Option<uint8_t>;
+template class cl::Option<uint16_t>;
 template class cl::Option<uint32_t>;
 template class cl::Option<uint64_t>;
+template class cl::Option<int8_t>;
+template class cl::Option<int16_t>;
 template class cl::Option<int32_t>;
 template class cl::Option<int64_t>;
diff --git a/src/mapleall/maple_util/src/cl_parser.cpp b/src/mapleall/maple_util/src/cl_parser.cpp
index 4631bdd51f78de655bdbffbd7be51febcbfbdc60..34efc883d1da3614fcdef43ddca761dfc0eef808 100644
--- a/src/mapleall/maple_util/src/cl_parser.cpp
+++ b/src/mapleall/maple_util/src/cl_parser.cpp
@@ -18,6 +18,7 @@
 #include "mpl_logging.h"
 
 #include <cstddef>
+#include <deque>
 #include <iostream>
 #include <string>
 #include <string_view>
@@ -48,7 +49,7 @@ OptionInterface *CommandLine::CheckJoinedOption(KeyArg &keyArg, OptionCategory &
 }
 
 RetCode CommandLine::ParseJoinedOption(ssize_t &argsIndex,
-                                       const std::vector<std::string_view> &args,
+                                       const std::deque<std::string_view> &args,
                                        KeyArg &keyArg, OptionCategory &optCategory) {
   OptionInterface *option = CheckJoinedOption(keyArg, optCategory);
   if (option != nullptr) {
@@ -56,7 +57,11 @@ RetCode CommandLine::ParseJoinedOption(ssize_t &argsIndex,
     if (err != RetCode::noError) {
       return err;
     }
-    optCategory.enabledOptions.push_back(option);
+
+    /* Set Option in all categories registering for this option */
+    for (auto &category : option->optCategories) {
+      category->AddEnabledOption(option);
+    }
   } else {
     return RetCode::notRegistered;
   }
@@ -65,20 +70,24 @@ RetCode CommandLine::ParseJoinedOption(ssize_t &argsIndex,
 }
 
 RetCode CommandLine::ParseOption(ssize_t &argsIndex,
-                                 const std::vector<std::string_view> &args,
+                                 const std::deque<std::string_view> &args,
                                  KeyArg &keyArg, OptionCategory &optCategory,
                                  OptionInterface *opt) {
   RetCode err = opt->Parse(argsIndex, args, keyArg);
   if (err != RetCode::noError) {
     return err;
   }
-  optCategory.enabledOptions.push_back(opt);
+
+  /* Set Option in all categories registering for this option */
+  for (auto &category : opt->optCategories) {
+    category->AddEnabledOption(opt);
+  }
 
   return RetCode::noError;
 }
 
 RetCode CommandLine::ParseEqualOption(ssize_t &argsIndex,
-                                      const std::vector<std::string_view> &args,
+                                      const std::deque<std::string_view> &args,
                                       KeyArg &keyArg, OptionCategory &optCategory,
                                       const OptionsMapType &optMap, ssize_t pos) {
   keyArg.isEqualOpt = true;
@@ -102,7 +111,7 @@ RetCode CommandLine::ParseEqualOption(ssize_t &argsIndex,
 }
 
 RetCode CommandLine::ParseSimpleOption(ssize_t &argsIndex,
-                                       const std::vector<std::string_view> &args,
+                                       const std::deque<std::string_view> &args,
                                        KeyArg &keyArg, OptionCategory &optCategory,
                                        const OptionsMapType &optMap) {
   keyArg.isEqualOpt = false;
@@ -118,7 +127,7 @@ RetCode CommandLine::ParseSimpleOption(ssize_t &argsIndex,
   }
 }
 
-RetCode CommandLine::HandleInputArgs(const std::vector<std::string_view> &args,
+RetCode CommandLine::HandleInputArgs(const std::deque<std::string_view> &args,
                                      OptionCategory &optCategory) {
   RetCode err = RetCode::noError;
 
@@ -181,7 +190,7 @@ RetCode CommandLine::Parse(int argc, char **argv, OptionCategory &optCategory) {
     return RetCode::noError;
   }
 
-  std::vector<std::string_view> args;
+  std::deque<std::string_view> args;
   while (argc != 0 && *argv != nullptr) {
     args.emplace_back(*argv);
     ++argv;
@@ -198,7 +207,7 @@ void CommandLine::Register(const std::vector<std::string> &optNames,
       continue;
     }
 
-    ASSERT(optCategory.options.count(optName) == 0, "Duplicated options name");
+    ASSERT(optCategory.options.count(optName) == 0, "Duplicated options name %s", optName.data());
     optCategory.options.emplace(optName, &opt);
 
     if (opt.IsJoinedValPermitted()) {
@@ -208,7 +217,30 @@ void CommandLine::Register(const std::vector<std::string> &optNames,
 
   auto disabledWith = opt.GetDisabledName();
   if (!disabledWith.empty()) {
-    ASSERT(optCategory.options.count(disabledWith) == 0, "Duplicated options name");
+    ASSERT(optCategory.options.count(disabledWith) == 0, "Duplicated options name %s", disabledWith.data());
     optCategory.options.emplace(disabledWith, &opt);
   }
+
+  optCategory.registredOptions.push_back(&opt);
+  opt.optCategories.push_back(&optCategory);
+}
+
+void CommandLine::Clear(OptionCategory &optCategory) {
+  for (auto &opt : optCategory.registredOptions) {
+    opt->Clear();
+  }
+}
+
+void CommandLine::BashCompletionPrinter(const OptionCategory &optCategory) const {
+  for (auto &opt : optCategory.options) {
+    maple::LogInfo::MapleLogger() << opt.first << '\n';
+  }
+}
+
+void CommandLine::HelpPrinter(const OptionCategory &optCategory) const {
+  for (auto &opt : optCategory.registredOptions) {
+    if (opt->IsVisibleOption()) {
+      maple::LogInfo::MapleLogger() << opt->GetDescription() << '\n';
+    }
+  }
 }
diff --git a/src/mapleall/maple_driver/src/file_utils.cpp b/src/mapleall/maple_util/src/file_utils.cpp
similarity index 96%
rename from src/mapleall/maple_driver/src/file_utils.cpp
rename to src/mapleall/maple_util/src/file_utils.cpp
index a2d9ea466bde09cfe6c0d3892ff52ae3fa46fef9..2c8777c1e3c652284dc90a19933b52ac1d22a597 100644
--- a/src/mapleall/maple_driver/src/file_utils.cpp
+++ b/src/mapleall/maple_util/src/file_utils.cpp
@@ -15,6 +15,7 @@
 #include <cstdio>
 #include <cstring>
 #include <climits>
+#include <filesystem>
 #include <unistd.h>
 #include "file_utils.h"
 #include "string_utils.h"
@@ -135,6 +136,11 @@ int FileUtils::Remove(const std::string &filePath) {
   return remove(filePath.c_str());
 }
 
+bool FileUtils::IsFileExists(const std::string &filePath) {
+  /* TODO: Use std::filesystrem::exists */
+  return std::filesystem::exists(filePath);
+}
+
 std::string FileUtils::AppendMapleRootIfNeeded(bool needRootPath, const std::string &path,
                                                const std::string &defaultRoot) {
   if (!needRootPath) {
diff --git a/src/mapleall/mempool/BUILD.gn b/src/mapleall/mempool/BUILD.gn
index 42ccad8d7cf5cfd16745641dbe1361106e59b7ae..a3c99f4261ed69610b53362c32236992aa8268cd 100644
--- a/src/mapleall/mempool/BUILD.gn
+++ b/src/mapleall/mempool/BUILD.gn
@@ -25,7 +25,6 @@ executable("MemPool") {
 
   deps = [
     ":libmempool",
-    "${MAPLEALL_ROOT}/maple_driver:liboption_parser",
     "${MAPLEALL_ROOT}/maple_util:libmplutil",
     "${THIRD_PARTY_ROOT}/bounds_checking_function:libHWSecureC",
   ]
diff --git a/src/mapleall/test/BUILD.gn b/src/mapleall/test/BUILD.gn
index 5552b9fc28580c4da3b7d84a05aa0554c6012ccc..c76eca762b9e616c93f4770838ed4d30eb1da4ce 100644
--- a/src/mapleall/test/BUILD.gn
+++ b/src/mapleall/test/BUILD.gn
@@ -18,15 +18,13 @@ cflags_cc -= [
   "-Werror",
 ]
 
-include_directories = [
-  "${MAPLE_ROOT}/tools/gtest_lib/include",
-  "${MAPLEALL_ROOT}/maple_util/include",
-]
-src_mapleallUT = [ "cl_ut_test.cpp" ]
+executable("UTCL") {
+  sources = [ "cl_ut_test.cpp" ]
+  include_dirs = [
+    "${MAPLE_ROOT}/tools/gtest_lib/include",
+    "${MAPLEALL_ROOT}/maple_util/include",
+  ]
 
-executable("mapleallUT") {
-  sources = src_mapleallUT
-  include_dirs = include_directories
   output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
 
   deps = [
@@ -44,3 +42,32 @@ executable("mapleallUT") {
   ]
 }
 
+executable("UTDriver") {
+  sources = [ "mpl_driver_ut_test.cpp" ]
+  include_dirs = [
+    "${MAPLE_ROOT}/tools/gtest_lib/include",
+    "${MAPLEALL_ROOT}/maple_util/include",
+    "${MAPLEALL_ROOT}/maple_driver/include",
+    "${MAPLEALL_ROOT}/maple_ir/include",
+    "${MAPLEALL_ROOT}/mempool/include",
+    "${THIRD_PARTY_ROOT}/bounds_checking_function/include"
+  ]
+
+  output_dir = "${root_out_dir}/lib/${HOST_ARCH}"
+
+  deps = [
+    "${MAPLEALL_ROOT}/maple_util:libmplutil",
+    "${MAPLEALL_ROOT}/maple_util:libcommandline",
+    "${MAPLEALL_ROOT}/maple_driver:libdriver",
+    "${MAPLEALL_ROOT}/maple_driver:libdriver_option",
+    "${THIRD_PARTY_ROOT}/bounds_checking_function:libHWSecureC",
+  ]
+
+  libs = [
+    "${MAPLE_ROOT}/tools/gtest_lib/lib/libgmock.a",
+    "${MAPLE_ROOT}/tools/gtest_lib/lib/libgmock_main.a",
+    "${MAPLE_ROOT}/tools/gtest_lib/lib/libgtest.a",
+    "${MAPLE_ROOT}/tools/gtest_lib/lib/libgtest_main.a",
+    "pthread",
+  ]
+}
diff --git a/src/mapleall/test/cl_ut_test.cpp b/src/mapleall/test/cl_ut_test.cpp
index 7505200ee596594efaf088d74c00ef0810e8c3d0..7b652f861b081702b17c87cbfceab451c2e74772 100644
--- a/src/mapleall/test/cl_ut_test.cpp
+++ b/src/mapleall/test/cl_ut_test.cpp
@@ -17,6 +17,7 @@
 #include <iostream>
 #include <string>
 #include <string_view>
+#include <vector>
 
 #include "cl_option.h"
 #include "cl_parser.h"
@@ -44,9 +45,19 @@ bool operator==(const std::string &str, const UTCLType &opt) {
   return ret;
 }
 
+template <>
+void cl::Option<UTCLType>::Clear() {
+  value.data = "";
+}
+
+template <>
+std::vector<std::string> cl::Option<UTCLType>::GetRawValues() {
+  return std::vector<std::string>();
+}
+
 template <>
 cl::RetCode cl::Option<UTCLType>::Parse(ssize_t &argsIndex,
-                                        const std::vector<std::string_view> &args,
+                                        const std::deque<std::string_view> &args,
                                         KeyArg &keyArg) {
   utCLTypeChecker = true;
   RetCode err = cl::RetCode::noError;
@@ -87,6 +98,9 @@ namespace testopts {
 
   cl::Option<std::string> testStr({"--str"}, "");
 
+  cl::Option<uint8_t> testUint8({"--uint8"}, "");
+  cl::Option<uint16_t> testUint16({"--uint16"}, "");
+
   cl::Option<int32_t> testInt32({"--int32"}, "");
   cl::Option<uint32_t> testUint32({"--uint32"}, "");
 
@@ -111,12 +125,24 @@ namespace testopts {
   cl::Option<int32_t> optVal({"--optval"}, "", cl::optionalValue, cl::Init(-42));
   cl::Option<int32_t> woVal({"--woval"}, "", cl::disallowedValue, cl::Init(-42));
 
-  cl::Option<bool> cat1Opt1({"--c1opt1"}, "", {&testCategory1});
-  cl::Option<bool> cat12Opt({"--c12opt"}, "", {&testCategory1, &testCategory2});
+  cl::Option<bool> cat1Opt1({"--c1opt1"}, "", {testCategory1});
+  cl::Option<bool> cat12Opt({"--c12opt"}, "", {testCategory1, testCategory2});
 
   cl::Option<UTCLType> uttype({"--uttype"}, "");
 
   cl::Option<bool> desc({"--desc"}, "It's test description");
+
+  cl::Option<bool> dup({"--dup"}, "");
+
+  cl::List<std::string> vecString({"--vecstr"}, "");
+  cl::List<uint32_t> vecDig({"--vecdig"}, "");
+  cl::List<bool> vecBool({"--vecbool"}, "", cl::DisableWith("--no-vecbool"));
+
+  cl::List<std::string> vecStringDef({"--vecstrdef"}, "", cl::Init("Default"));
+  cl::List<uint32_t> vecDigDef({"--vecdigdef"}, "", cl::Init(100));
+  cl::List<bool> vecBoolDef({"--vecbooldef"}, "", cl::DisableWith("--no-vecbooldef"), cl::Init(true));
+
+  cl::Option<std::string> common({"--common"}, "");
 } // namespace testopts
 
 /* ################# "Enable/Disable Boolean Options" Test ###############
@@ -211,6 +237,8 @@ TEST(clOptions, digitTestMaxVal) {
   // create command line
   const char *argv[] = {
     "CLTest", // program name
+    "--uint8", "255",
+    "--uint16", "65535",
     "--int32", "2147483647",
     "--uint32", "4294967295",
     "--int64", "9223372036854775807",
@@ -221,6 +249,12 @@ TEST(clOptions, digitTestMaxVal) {
   auto err = cl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
   ASSERT_EQ(err, cl::RetCode::noError);
 
+  uint8_t uint8Dig = testopts::testUint8;
+  ASSERT_EQ(uint8Dig, (1 << 8) - 1);
+
+  uint16_t uint16Dig = testopts::testUint16;
+  ASSERT_EQ(uint16Dig, (1 << 16) - 1);
+
   int32_t int32Dig = testopts::testInt32;
   ASSERT_EQ(int32Dig, INT_MAX);
 
@@ -360,6 +394,8 @@ TEST(clOptions, digitTestOutOfRange2) {
   const char *argv[] = {
     "CLTest", // program name
     "--uint32", "4294967296",
+    "--uint16", "65536",
+    "--uint8", "256",
     nullptr};
   int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
 
@@ -367,11 +403,19 @@ TEST(clOptions, digitTestOutOfRange2) {
   ASSERT_EQ(err, cl::RetCode::parsingErr);
 
   auto &badArgs = cl::CommandLine::GetCommandLine().badCLArgs;
-  ASSERT_EQ(badArgs.size(), 2);
+  ASSERT_EQ(badArgs.size(), 6);
   ASSERT_EQ(badArgs[0].first, "--uint32");
   ASSERT_EQ(badArgs[1].first, "4294967296");
+  ASSERT_EQ(badArgs[2].first, "--uint16");
+  ASSERT_EQ(badArgs[3].first, "65536");
+  ASSERT_EQ(badArgs[4].first, "--uint8");
+  ASSERT_EQ(badArgs[5].first, "256");
   ASSERT_EQ(badArgs[0].second, cl::RetCode::outOfRange);
   ASSERT_EQ(badArgs[1].second, cl::RetCode::notRegistered);
+  ASSERT_EQ(badArgs[2].second, cl::RetCode::outOfRange);
+  ASSERT_EQ(badArgs[3].second, cl::RetCode::notRegistered);
+  ASSERT_EQ(badArgs[4].second, cl::RetCode::outOfRange);
+  ASSERT_EQ(badArgs[5].second, cl::RetCode::notRegistered);
 }
 
 TEST(clOptions, digitTestOutOfRange3) {
@@ -854,8 +898,6 @@ TEST(clOptions, ownOptionType3) {
  * ####################################################################### */
 
 TEST(clOptions, duplicatedOptions) {
-
-  cl::Option<bool> dup({"--dup"}, "");
   EXPECT_DEATH(cl::Option<bool> dup2({"--dup"}, ""), "");
 }
 
@@ -865,3 +907,100 @@ TEST(clOptions, duplicatedOptions) {
 TEST(clOptions, description) {
   ASSERT_EQ(testopts::desc.GetDescription(), "It's test description");
 }
+
+/* ##################### Check cl::list ##################################
+ * ####################################################################### */
+
+TEST(clOptions, optList1) {
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--vecstr", "data1",
+    "--vecstr", "data2",
+    "--vecstr", "data3",
+    "--vecdig", "10",
+    "--vecdig", "20",
+    "--vecbool", "--no-vecbool", "--vecbool",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = cl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, cl::RetCode::noError);
+
+  auto strVals = testopts::vecString.GetValues();
+  ASSERT_EQ(strVals.size(), 3);
+  ASSERT_EQ(strVals[0], "data1");
+  ASSERT_EQ(strVals[1], "data2");
+  ASSERT_EQ(strVals[2], "data3");
+
+  auto digVals = testopts::vecDig.GetValues();
+  ASSERT_EQ(digVals.size(), 2);
+  ASSERT_EQ(digVals[0], 10);
+  ASSERT_EQ(digVals[1], 20);
+
+  auto boolVals = testopts::vecBool.GetValues();
+  ASSERT_EQ(boolVals.size(), 3);
+  ASSERT_EQ(boolVals[0], true);
+  ASSERT_EQ(boolVals[1], false);
+  ASSERT_EQ(boolVals[2], true);
+
+  cl::CommandLine::GetCommandLine().Clear(); // to clear previous test data
+
+  ASSERT_EQ(testopts::vecBool.GetValues().size(), 0);
+  ASSERT_EQ(testopts::vecDig.GetValues().size(), 0);
+  ASSERT_EQ(testopts::vecString.GetValues().size(), 0);
+}
+
+TEST(clOptions, optList2) {
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--vecstrdef", "data1",
+    "--vecdigdef", "10",
+    "--vecbooldef", "--no-vecbooldef",
+    nullptr };
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  ASSERT_EQ(testopts::vecBoolDef.GetValues().size(), 1);
+  ASSERT_EQ(testopts::vecDigDef.GetValues().size(), 1);
+  ASSERT_EQ(testopts::vecStringDef.GetValues().size(), 1);
+
+  ASSERT_EQ(testopts::vecDigDef.GetValues()[0], 100);
+  ASSERT_EQ(testopts::vecBoolDef.GetValues()[0], true);
+  ASSERT_EQ(testopts::vecStringDef.GetValues()[0], "Default");
+
+  auto err = cl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, cl::RetCode::noError);
+
+  ASSERT_EQ(testopts::vecStringDef.GetValues().size(), 2);
+  ASSERT_EQ(testopts::vecDigDef.GetValues().size(), 2);
+  ASSERT_EQ(testopts::vecBoolDef.GetValues().size(), 3);
+
+  ASSERT_EQ(testopts::vecStringDef.GetValues()[1], "data1");
+  ASSERT_EQ(testopts::vecDigDef.GetValues()[1], 10);
+  ASSERT_EQ(testopts::vecBoolDef.GetValues()[1], true);
+  ASSERT_EQ(testopts::vecBoolDef.GetValues()[2], false);
+
+  cl::CommandLine::GetCommandLine().Clear(); // to clear previous test data
+  ASSERT_EQ(testopts::vecStringDef.GetValues().size(), 1);
+  ASSERT_EQ(testopts::vecDigDef.GetValues().size(), 1);
+  ASSERT_EQ(testopts::vecBoolDef.GetValues().size(), 1);
+}
+
+/* ##################### "GetCommonValue from interface" check ###########
+ * ####################################################################### */
+TEST(clOptions, common) {
+  // create command line
+  const char *argv[] = {
+    "CLTest", // program name
+    "--common", "datacommon",
+    nullptr };
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = cl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, cl::RetCode::noError);
+
+  cl::OptionInterface *commonOpt = &testopts::common;
+  std::string val = commonOpt->GetCommonValue();
+  ASSERT_EQ(val, "datacommon");
+}
diff --git a/src/mapleall/test/mpl_driver_ut_test.cpp b/src/mapleall/test/mpl_driver_ut_test.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..5b226b76f90bae39c58f9002deeab9ac08242df8
--- /dev/null
+++ b/src/mapleall/test/mpl_driver_ut_test.cpp
@@ -0,0 +1,126 @@
+/*
+ * Copyright (c) [2022] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * 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 v2 for more details.
+ */
+
+#include "error_code.h"
+#include "maple_driver.h"
+#include "driver_options.h"
+
+#include "gtest/gtest.h"
+
+TEST(MplDriver, OptForwarding1) {
+  // create command line
+  const char *argv[] = {
+    "maple", // program name
+    "--woinput",
+    "--clang-opt=-opt1  -opt2 -opt3",
+    "--hir2mpl-opt=-hir2mpl",
+    "--mpl2mpl-opt=-mpl2mpl",
+    "--me-opt=-me",
+    "--mplcg-opt=-mplcg",
+    "--as-opt=-as",
+    "--ld-opt=-ld",
+    "--dex2mpl-opt=-dex",
+    "--jbc2mpl-opt=-jbc",
+    "--mplipa-opt=-ipa",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  auto err = cl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, cl::RetCode::noError);
+
+  auto &drv = maple::MplDriver::GetMplDriver();
+  auto drvErr = drv.Processing();
+  ASSERT_EQ(drvErr, maple::kErrorNoError);
+
+  auto &exeOptions = drv.GetExeOptions();
+  ASSERT_EQ(1, exeOptions.count(maple::kBinNameClang));
+  ASSERT_EQ(3, exeOptions[maple::kBinNameClang].size());
+  ASSERT_EQ("-opt1", exeOptions[maple::kBinNameClang][0]);
+  ASSERT_EQ("-opt2", exeOptions[maple::kBinNameClang][1]);
+  ASSERT_EQ("-opt3", exeOptions[maple::kBinNameClang][2]);
+
+  ASSERT_EQ(1, exeOptions.count(maple::kBinNameCpp2mpl));
+  ASSERT_EQ(1, exeOptions[maple::kBinNameCpp2mpl].size());
+  ASSERT_EQ("-hir2mpl", exeOptions[maple::kBinNameCpp2mpl][0]);
+
+  ASSERT_EQ(1, exeOptions.count(maple::kBinNameMpl2mpl));
+  ASSERT_EQ(1, exeOptions[maple::kBinNameMpl2mpl].size());
+  ASSERT_EQ("-mpl2mpl", exeOptions[maple::kBinNameMpl2mpl][0]);
+
+  ASSERT_EQ(1, exeOptions.count(maple::kBinNameMe));
+  ASSERT_EQ(1, exeOptions[maple::kBinNameMe].size());
+  ASSERT_EQ("-me", exeOptions[maple::kBinNameMe][0]);
+
+  ASSERT_EQ(1, exeOptions.count(maple::kBinNameMplcg));
+  ASSERT_EQ(1, exeOptions[maple::kBinNameMplcg].size());
+  ASSERT_EQ("-mplcg", exeOptions[maple::kBinNameMplcg][0]);
+
+  ASSERT_EQ(1, exeOptions.count(maple::kAsFlag));
+  ASSERT_EQ(1, exeOptions[maple::kAsFlag].size());
+  ASSERT_EQ("-as", exeOptions[maple::kAsFlag][0]);
+
+  ASSERT_EQ(1, exeOptions.count(maple::kLdFlag));
+  ASSERT_EQ(1, exeOptions[maple::kLdFlag].size());
+  ASSERT_EQ("-ld", exeOptions[maple::kLdFlag][0]);
+
+  ASSERT_EQ(1, exeOptions.count(maple::kBinNameDex2mpl));
+  ASSERT_EQ(1, exeOptions[maple::kBinNameDex2mpl].size());
+  ASSERT_EQ("-dex", exeOptions[maple::kBinNameDex2mpl][0]);
+
+  ASSERT_EQ(1, exeOptions.count(maple::kBinNameJbc2mpl));
+  ASSERT_EQ(1, exeOptions[maple::kBinNameJbc2mpl].size());
+  ASSERT_EQ("-jbc", exeOptions[maple::kBinNameJbc2mpl][0]);
+
+  ASSERT_EQ(1, exeOptions.count(maple::kBinNameMplipa));
+  ASSERT_EQ(1, exeOptions[maple::kBinNameMplipa].size());
+  ASSERT_EQ("-ipa", exeOptions[maple::kBinNameMplipa][0]);
+}
+
+TEST(MplDriver, OptForwarding2) {
+  // create command line
+  const char *argv[] = {
+    "maple", // program name
+    "--woinput",
+    "--run=clang:hir2mpl:me",
+    "--option=-opt1  -opt2 -opt3:-opt4 -opt5 : -opt6",
+    nullptr};
+  int argc = (sizeof(argv) / sizeof(argv[0])) - 1;
+
+  cl::CommandLine::GetCommandLine().Clear(); // to clear previous test data
+  auto err = cl::CommandLine::GetCommandLine().Parse(argc, (char **)argv);
+  ASSERT_EQ(err, cl::RetCode::noError);
+
+  auto &drv = maple::MplDriver::GetMplDriver();
+  auto &exeOptions = drv.GetExeOptions();
+  exeOptions.clear(); // to clear previous test data
+
+  auto drvErr = drv.Processing();
+  ASSERT_EQ(drvErr, maple::kErrorNoError);
+
+  ASSERT_EQ(1, exeOptions.count(maple::kBinNameClang));
+  ASSERT_EQ(3, exeOptions[maple::kBinNameClang].size());
+  ASSERT_EQ("-opt1", exeOptions[maple::kBinNameClang][0]);
+  ASSERT_EQ("-opt2", exeOptions[maple::kBinNameClang][1]);
+  ASSERT_EQ("-opt3", exeOptions[maple::kBinNameClang][2]);
+
+  ASSERT_EQ(1, exeOptions.count(maple::kBinNameCpp2mpl));
+  ASSERT_EQ(2, exeOptions[maple::kBinNameCpp2mpl].size());
+  ASSERT_EQ("-opt4", exeOptions[maple::kBinNameCpp2mpl][0]);
+  ASSERT_EQ("-opt5", exeOptions[maple::kBinNameCpp2mpl][1]);
+
+  ASSERT_EQ(1, exeOptions.count(maple::kBinNameMe));
+  ASSERT_EQ(1, exeOptions[maple::kBinNameMe].size());
+  ASSERT_EQ("-opt6", exeOptions[maple::kBinNameMe][0]);
+}