diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl
index 84ea5241d5765e70afd9181db3473d5b74afedd8..9aab27b5e4782839dfe5ca2f58b8f2e11518aa24 100755
Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ
diff --git a/src/bin/maple b/src/bin/maple
index e03b0269da540e6d572e9e23c171b77f6829727e..a483a79c0bb8c35e55aafceeab73a4caaa819e1d 100755
Binary files a/src/bin/maple and b/src/bin/maple differ
diff --git a/src/bin/mplcg b/src/bin/mplcg
index 944794d30c14c2f68c9b38bc22928726a77b2563..eb23624789923fd2c6d1cbcf6493f63018f17885 100755
Binary files a/src/bin/mplcg and b/src/bin/mplcg differ
diff --git a/src/deplibs/libmaple_driverutil.a b/src/deplibs/libmaple_driverutil.a
index 1a92467cd373d11837d86aaefe8845d3655692a5..63349fa0f13814f279dc7685821101ef1aac7211 100644
Binary files a/src/deplibs/libmaple_driverutil.a and b/src/deplibs/libmaple_driverutil.a differ
diff --git a/src/deplibs/libmplutil.a b/src/deplibs/libmplutil.a
index 2bde69a30febfa1781cdffed942fc7fa84bcb4a8..3e790dba23889a214cb1ad93dac4e64dfc2e843e 100644
Binary files a/src/deplibs/libmplutil.a and b/src/deplibs/libmplutil.a differ
diff --git a/src/maple_driver/include/default_options.h b/src/maple_driver/defs/default_options.def
similarity index 100%
rename from src/maple_driver/include/default_options.h
rename to src/maple_driver/defs/default_options.def
diff --git a/src/maple_driver/include/compiler.h b/src/maple_driver/include/compiler.h
index 3e98a31229009ae18c731222e9c428507fe5078f..e5907770b33e673ae7e2edf1a4198e105e6fd63c 100644
--- a/src/maple_driver/include/compiler.h
+++ b/src/maple_driver/include/compiler.h
@@ -34,10 +34,10 @@ class Compiler {
  public:
   explicit Compiler(const std::string &name) : name(name) {}
 
-  virtual ~Compiler() {}
+  virtual ~Compiler() = default;
 
   virtual ErrorCode Compile(const MplOptions &options, MIRModulePtr &theModule);
-  inline const std::string &GetName() const {
+  const std::string &GetName() const {
     return name;
   }
 
@@ -45,9 +45,7 @@ class Compiler {
     return std::vector<std::string>();
   }
 
-  virtual void GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector<std::string> &tempFiles) const {
-    return;
-  }
+  virtual void GetTmpFilesToDelete(const MplOptions &mplOptions, std::vector<std::string> &tempFiles) const {}
 
   virtual const std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions) const {
     return std::unordered_set<std::string>();
@@ -62,11 +60,11 @@ class Compiler {
   }
 
   virtual const std::string GetInputFileName(const MplOptions &options) const {
-    std::string strOption = "";
+    std::ostringstream ss;
     for (auto const &inputFile : options.splitsInputFiles) {
-      strOption += " " + inputFile;
+      ss << " " << inputFile;
     }
-    return strOption;
+    return ss.str();
   }
 
   virtual const DefaultOption GetDefaultOptions(const MplOptions &options) {
@@ -74,7 +72,7 @@ class Compiler {
   }
 
   virtual void AppendExtraOptions(std::map<std::string, MplOption> &finalOptions,
-                                  std::map<std::string, std::vector<MplOption>> extraOptions) const;
+                                  const std::map<std::string, std::vector<MplOption>> &extraOptions) const;
   virtual const std::string AppendSpecialOption(const MplOptions &options, const std::string &optionStr) const {
     return optionStr;
   }
@@ -89,7 +87,7 @@ class Compiler {
   void AppendDefaultOptions(std::map<std::string, MplOption> &finalOptions,
                             const std::map<std::string, MplOption> &defaultOptions) const;
   void AppendUserOptions(std::map<std::string, MplOption> &finalOptions,
-                         const std::vector<mapleOption::Option> userOption) const;
+                         const std::vector<mapleOption::Option> &userOption) const;
   const std::map<std::string, MplOption> MakeDefaultOptions(const MplOptions &options);
   const int Exe(const MplOptions &mplOptions, const std::string &options) const;
   const std::string name;
diff --git a/src/maple_driver/include/compiler_factory.h b/src/maple_driver/include/compiler_factory.h
index 1a6a082206959bd3593b2a1d47ce8761bb12756f..ad3466cd0c35ae5e12cc6193cfe90988f9704b1d 100644
--- a/src/maple_driver/include/compiler_factory.h
+++ b/src/maple_driver/include/compiler_factory.h
@@ -14,12 +14,10 @@
  */
 #ifndef MAPLE_DRIVER_INCLUDE_COMPILER_FACTORY_H
 #define MAPLE_DRIVER_INCLUDE_COMPILER_FACTORY_H
-#include <unordered_map>
 #include <unordered_set>
 #include "compiler.h"
 #include "compiler_selector.h"
 #include "error_code.h"
-#include "supported_compilers.h"
 #include "mir_module.h"
 #include "mir_parser.h"
 
diff --git a/src/maple_driver/include/compiler_selector.h b/src/maple_driver/include/compiler_selector.h
index 0fd6b80a690f5ca7683389e04d3ba45100ec6ac6..05457ae96e6378c12b5a5c7f5f1053059bcdad70 100644
--- a/src/maple_driver/include/compiler_selector.h
+++ b/src/maple_driver/include/compiler_selector.h
@@ -18,9 +18,9 @@
 #include <vector>
 #include "compiler.h"
 #include "error_code.h"
-#include "supported_compilers.h"
 
 namespace maple {
+using SupportedCompilers = std::unordered_map<std::string, Compiler*>;
 class CompilerSelector {
  public:
   CompilerSelector() {}
@@ -43,7 +43,7 @@ class CompilerSelectorImpl : public CompilerSelector {
                          std::vector<Compiler*> &selected) const;
 
  private:
-  Compiler *FindCompiler(const SupportedCompilers &compilers, const std::string name) const;
+  Compiler *FindCompiler(const SupportedCompilers &compilers, const std::string &name) const;
   const ErrorCode InsertCompilerIfNeeded(std::vector<Compiler*> &selected, const SupportedCompilers &compilers,
                                          const std::string name) const;
 };
diff --git a/src/maple_driver/include/driver_runner.h b/src/maple_driver/include/driver_runner.h
index 729c2c4768b4dc754a87217e5dac7a9072692f73..cc5681b71fd0486ace1504e05796ecebc13015ba 100644
--- a/src/maple_driver/include/driver_runner.h
+++ b/src/maple_driver/include/driver_runner.h
@@ -19,6 +19,7 @@
 #include <string>
 #include "me_option.h"
 #include "interleaved_manager.h"
+#include "error_code.h"
 
 
 extern const char *kNoFile;
@@ -54,9 +55,9 @@ class DriverRunner final {
 
   ~DriverRunner() {}
 
-  int Run();
+  ErrorCode Run();
   void ReleaseOptions();
-  bool ParseInput(std::string outputFile, std::string oriBasename) const;
+  ErrorCode ParseInput(std::string outputFile, std::string oriBasename) const;
   bool VerifyModule(MIRModulePtr &mModule) const;
   void ProcessMpl2mplAndMePhases(std::string outputFile, std::string vtableImplFile) const;
 
diff --git a/src/maple_driver/include/file_utils.h b/src/maple_driver/include/file_utils.h
index c4924195f0e13d7d96d4cab4b15c4038eab15622..ecd0f7679f52763351c3f00e1ad7b615a1676e28 100644
--- a/src/maple_driver/include/file_utils.h
+++ b/src/maple_driver/include/file_utils.h
@@ -17,12 +17,12 @@
 #include <string>
 
 namespace FileSeperator {
-const static char kFileSeperatorLinuxStyleChar = '/';
-const static char kFileSeperatorWindowsStyleChar = '\\';
-const static char kFileSeperatorChar = kFileSeperatorLinuxStyleChar;
-const static std::string kFileSeperatorLinuxStyleStr = std::string(1, kFileSeperatorLinuxStyleChar);
-const static std::string kFileSeperatorWindowsStyleStr = std::string(1, kFileSeperatorWindowsStyleChar);
-const static std::string kFileSeperatorStr = kFileSeperatorLinuxStyleStr;
+const char kFileSeperatorLinuxStyleChar = '/';
+const char kFileSeperatorWindowsStyleChar = '\\';
+const char kFileSeperatorChar = kFileSeperatorLinuxStyleChar;
+const std::string kFileSeperatorLinuxStyleStr = std::string(1, kFileSeperatorLinuxStyleChar);
+const std::string kFileSeperatorWindowsStyleStr = std::string(1, kFileSeperatorWindowsStyleChar);
+const std::string kFileSeperatorStr = kFileSeperatorLinuxStyleStr;
 }  // namespace FileSeperator
 
 namespace maple {
diff --git a/src/maple_driver/include/mpl_options.h b/src/maple_driver/include/mpl_options.h
index 72e87d8e40204b47dc80fe53e98ef51d4ddd5bce..ef1719089dc981c7e5d2671be37724fe9c5d8f98 100644
--- a/src/maple_driver/include/mpl_options.h
+++ b/src/maple_driver/include/mpl_options.h
@@ -55,7 +55,7 @@ class MplOption {
   void init(const std::string &key, const std::string &value, const std::string &connectSymbol, bool isAppend,
             const std::string &appendSplit,
             bool needRootPath = false) {
-    CHECK_FATAL(!key.empty(), "key is empty");
+    CHECK_FATAL(!key.empty(), "MplOption got an empty key.");
 
     this->key = key;
     this->value = value;
@@ -68,32 +68,20 @@ class MplOption {
 
 struct DefaultOption {
   MplOption *mplOptions;
-  unsigned int length;
-};
-
-class UserOption : public std::map<std::string, std::vector<mapleOption::Option>> {
- public:
-  void Insert(const std::string &exeName, const mapleOption::Option &option) {
-    auto it = find(exeName);
-    if (it == end()) {
-      insert(make_pair(exeName, std::vector<mapleOption::Option>()));
-      it = find(exeName);
-    }
-    it->second.push_back(option);
-  }
+  uint32_t length;
 };
 
 class MplOptions {
  public:
   mapleOption::OptionParser *optionParser;
-  // may used future
-  UserOption options;
+  std::map<std::string, std::vector<mapleOption::Option>> options;
   std::map<std::string, std::vector<mapleOption::Option>> exeOptions;
   std::string inputFiles;
   std::string inputFolder;
   std::string outputFolder;
   std::string outputName;
   std::string exeFolder;
+  std::string optLevelStr;
   InputFileType inputFileType;
   OptimizationLevel optimizationLevel;
   bool setDefaultLevel;
@@ -111,13 +99,14 @@ class MplOptions {
   bool verify;
   MplOptions()
       : optionParser(nullptr),
-        options(UserOption()),
+        options({}),
         exeOptions({}),
         inputFiles(""),
         inputFolder(""),
         outputFolder(""),
         outputName("maple"),
         exeFolder(""),
+        optLevelStr(""),
         inputFileType(InputFileType::kNone),
         optimizationLevel(OptimizationLevel::kO2),
         setDefaultLevel(false),
@@ -145,6 +134,11 @@ class MplOptions {
 
  private:
   bool Init(const std::string &inputFile);
+  ErrorCode HandleGeneralOptions();
+  ErrorCode DecideRunType();
+  ErrorCode DecideRunningPhases();
+  ErrorCode CheckInputFileValidity();
+  ErrorCode CheckOptLevel(const std::string &inputOpt, const std::string &filterOpt);
   ErrorCode CheckFileExits();
   void AddOption(const mapleOption::Option &option);
   void UpdateOptLevel(OptimizationLevel level);
diff --git a/src/maple_driver/include/supported_compilers.h b/src/maple_driver/include/supported_compilers.h
deleted file mode 100644
index c8f85a7583fef2773ae88fb7f709e0e5db487816..0000000000000000000000000000000000000000
--- a/src/maple_driver/include/supported_compilers.h
+++ /dev/null
@@ -1,23 +0,0 @@
-/*
- * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
- *
- * OpenArkCompiler is licensed under the Mulan PSL v1.
- * You can use this software according to the terms and conditions of the Mulan PSL v1.
- * You may obtain a copy of Mulan PSL v1 at:
- *
- *     http://license.coscl.org.cn/MulanPSL
- *
- * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
- * FIT FOR A PARTICULAR PURPOSE.
- * See the Mulan PSL v1 for more details.
- */
-#ifndef MAPLE_DRIVER_INCLUDE_SUPPORTED_COMPILERS_H
-#define MAPLE_DRIVER_INCLUDE_SUPPORTED_COMPILERS_H
-#include <unordered_map>
-#include "compiler.h"
-
-namespace maple {
-using SupportedCompilers = std::unordered_map<std::string, Compiler*>;
-}
-#endif  // MAPLE_DRIVER_INCLUDE_SUPPORTED_COMPILERS_H
diff --git a/src/maple_driver/src/compiler.cpp b/src/maple_driver/src/compiler.cpp
index 5999575b970592d8026c3a6b8b7f640ee34b4195..a7082b81ca7114a59b5d3841a7f44206bbd66040 100644
--- a/src/maple_driver/src/compiler.cpp
+++ b/src/maple_driver/src/compiler.cpp
@@ -18,71 +18,69 @@
 #include "safe_exe.h"
 #include "mpl_timer.h"
 
-using namespace mapleOption;
 namespace maple {
+using namespace mapleOption;
 const int Compiler::Exe(const MplOptions &mplOptions, const std::string &options) const {
-  const std::string binPath = FileUtils::ConvertPathIfNeeded(this->GetBinPath(mplOptions) + this->GetBinName());
+  std::ostringstream ostrStream;
+  ostrStream << GetBinPath(mplOptions) << GetBinName();
+  std::string binPath = FileUtils::ConvertPathIfNeeded(ostrStream.str());
   return SafeExe::Exe(binPath, options);
 }
 
 const std::string Compiler::GetBinPath(const MplOptions &mplOptions) const {
-  std::string binPath;
 #ifdef MAPLE_PRODUCT_EXECUTABLE  // build flag -DMAPLE_PRODUCT_EXECUTABLE
-  binPath = std::string(MAPLE_PRODUCT_EXECUTABLE);
+  std::string binPath = std::string(MAPLE_PRODUCT_EXECUTABLE);
   if (binPath.empty()) {
     binPath = mplOptions.exeFolder;
   } else {
     binPath = binPath + FileSeperator::kFileSeperatorChar;
   }
 #else
-  binPath = mplOptions.exeFolder;
+  std::string binPath = mplOptions.exeFolder;
 #endif
   return binPath;
 }
 
 ErrorCode Compiler::Compile(const MplOptions &options, MIRModulePtr &theModule) {
   MPLTimer timer = MPLTimer();
-  LogInfo::MapleLogger() << "Starting " << this->GetName() << std::endl;
+  LogInfo::MapleLogger() << "Starting " << GetName() << std::endl;
   timer.Start();
-  std::string strOption = this->MakeOption(options);
+  std::string strOption = MakeOption(options);
   if (strOption.empty()) {
     return ErrorCode::kErrorInvalidParameter;
   }
-  if (this->Exe(options, strOption) != 0) {
+  if (Exe(options, strOption) != 0) {
     return ErrorCode::kErrorCompileFail;
   }
   timer.Stop();
-  LogInfo::MapleLogger() << (this->GetName() + " consumed ") << timer.Elapsed() << "s" << std::endl;
+  LogInfo::MapleLogger() << (GetName() + " consumed ") << timer.Elapsed() << "s" << std::endl;
   return ErrorCode::kErrorNoError;
 }
 
 const std::string Compiler::MakeOption(const MplOptions &options) {
   std::map<std::string, MplOption> finalOptions;
-  auto defaultOptions = this->MakeDefaultOptions(options);
-  this->AppendDefaultOptions(finalOptions, defaultOptions);
-  for (auto binName : this->GetBinNames()) {
+  auto defaultOptions = MakeDefaultOptions(options);
+  AppendDefaultOptions(finalOptions, defaultOptions);
+  for (auto binName : GetBinNames()) {
     auto userOption = options.options.find(binName);
     if (userOption != options.options.end()) {
-      this->AppendUserOptions(finalOptions, userOption->second);
+      AppendUserOptions(finalOptions, userOption->second);
     }
   }
-  this->AppendExtraOptions(finalOptions, options.extras);
-  std::string strOption = "";
+  AppendExtraOptions(finalOptions, options.extras);
+  std::ostringstream strOption;
   for (auto finalOption : finalOptions) {
-    strOption += " " + finalOption.first + finalOption.second.connectSymbol + finalOption.second.value;
+    strOption << " " << finalOption.first << finalOption.second.connectSymbol << finalOption.second.value;
     if (options.debugFlag) {
       LogInfo::MapleLogger() << Compiler::GetName() << " options: " << finalOption.first << " "
                              << finalOption.second.value << std::endl;
     }
   }
-  strOption = this->AppendOptimization(options, strOption);
-  strOption = this->AppendSpecialOption(options, strOption);
-  strOption += " " + this->GetInputFileName(options);
+  strOption << " " << this->GetInputFileName(options);
   if (options.debugFlag) {
-    LogInfo::MapleLogger() << Compiler::GetName() << " input files: " << this->GetInputFileName(options) << std::endl;
+    LogInfo::MapleLogger() << Compiler::GetName() << " input files: " << GetInputFileName(options) << std::endl;
   }
-  strOption = FileUtils::ConvertPathIfNeeded(strOption);
-  return strOption;
+  return FileUtils::ConvertPathIfNeeded(strOption.str());
 }
 
 void Compiler::AppendDefaultOptions(std::map<std::string, MplOption> &finalOptions,
@@ -93,8 +91,8 @@ void Compiler::AppendDefaultOptions(std::map<std::string, MplOption> &finalOptio
 }
 
 void Compiler::AppendUserOptions(std::map<std::string, MplOption> &finalOptions,
-                                 const std::vector<Option> userOptions) const {
-  for (auto binName : this->GetBinNames()) {
+                                 const std::vector<Option> &userOptions) const {
+  for (auto &binName : GetBinNames()) {
     for (auto userOption : userOptions) {
       auto extra = userOption.FindExtra(binName);
       if (extra != nullptr) {
@@ -105,21 +103,21 @@ void Compiler::AppendUserOptions(std::map<std::string, MplOption> &finalOptions,
 }
 
 void Compiler::AppendExtraOptions(std::map<std::string, MplOption> &finalOptions,
-                                  std::map<std::string, std::vector<MplOption>> extraOptions) const {
-  auto binNames = this->GetBinNames();
-  for (auto binNamesIt : binNames) {
+                                  const std::map<std::string, std::vector<MplOption>> &extraOptions) const {
+  auto binNames = GetBinNames();
+  for (auto &binNamesIt : binNames) {
     auto extras = extraOptions.find(binNamesIt);
     if (extras == extraOptions.end()) {
       continue;
     }
-    for (auto secondExtras : extras->second) {
+    for (auto &secondExtras : extras->second) {
       AppendOptions(finalOptions, secondExtras.key, secondExtras.value, secondExtras.connectSymbol);
     }
   }
 }
 
 const std::map<std::string, MplOption> Compiler::MakeDefaultOptions(const MplOptions &options) {
-  auto rawDefaultOptions = this->GetDefaultOptions(options);
+  auto rawDefaultOptions = GetDefaultOptions(options);
   std::map<std::string, MplOption> defaultOptions;
   if (rawDefaultOptions.mplOptions != nullptr) {
     for (unsigned int i = 0; i < rawDefaultOptions.length; i++) {
diff --git a/src/maple_driver/src/compiler_factory.cpp b/src/maple_driver/src/compiler_factory.cpp
index 2ffadcf93c72104bc0ba135f6d3dde543a11c2f9..b320661d4c93933ce3969c9008d338c696b6a03b 100644
--- a/src/maple_driver/src/compiler_factory.cpp
+++ b/src/maple_driver/src/compiler_factory.cpp
@@ -24,6 +24,7 @@ using namespace maple;
   do {                                       \
     Insert((NAME), new (CLASSNAME)((NAME))); \
   } while (0);
+
 CompilerFactory &CompilerFactory::GetInstance() {
   static CompilerFactory instance;
   return instance;
@@ -45,7 +46,7 @@ CompilerFactory::~CompilerFactory() {
       delete it->second;
       it->second = nullptr;
     }
-    it++;
+    ++it;
   }
   supportedCompilers.clear();
   if (compilerSelector != nullptr) {
@@ -82,18 +83,23 @@ ErrorCode CompilerFactory::DeleteTmpFiles(const MplOptions &mplOptions, const st
 }
 
 ErrorCode CompilerFactory::Compile(const MplOptions &mplOptions) {
-  auto compilers = std::vector<Compiler*>();
+  std::vector<Compiler*> compilers;
   auto ret = compilerSelector->Select(supportedCompilers, mplOptions, compilers);
-  if (ret == ErrorCode::kErrorNoError) {
-    for (auto compiler : compilers) {
-      ret = compiler->Compile(mplOptions, this->theModule);
-      if (ret != ErrorCode::kErrorNoError) {
-        return ret;
-      }
-    }
-  } else {
+  if (ret != ErrorCode::kErrorNoError) {
     return ret;
   }
+
+  for (auto compiler : compilers) {
+    if (compiler == nullptr) {
+      LogInfo::MapleLogger() << "Failed! Compiler is null." << "\n";
+      return ErrorCode::kErrorCompileFail;
+    }
+    ret = compiler->Compile(mplOptions, this->theModule);
+    if (ret != ErrorCode::kErrorNoError) {
+      return ret;
+    }
+  }
+
   if (!mplOptions.isSaveTmps || !mplOptions.saveFiles.empty()) {
     auto tmpFiles = std::vector<std::string>();
     for (auto compiler : compilers) {
diff --git a/src/maple_driver/src/compiler_selector.cpp b/src/maple_driver/src/compiler_selector.cpp
index 2ffd7b261d1da6716650f5c9aa8baea3c1271743..1f14f8a987e771c8ab81c701035818d63cdccfe7 100644
--- a/src/maple_driver/src/compiler_selector.cpp
+++ b/src/maple_driver/src/compiler_selector.cpp
@@ -13,12 +13,11 @@
  * See the Mulan PSL v1 for more details.
  */
 #include "compiler_selector.h"
-#include "mpl_logging.h"
-
 #include <algorithm>
+#include "mpl_logging.h"
 
 namespace maple {
-Compiler *CompilerSelectorImpl::FindCompiler(const SupportedCompilers &compilers, const std::string name) const {
+Compiler *CompilerSelectorImpl::FindCompiler(const SupportedCompilers &compilers, const std::string &name) const {
   auto compiler = compilers.find(name);
   if (compiler != compilers.end()) {
     return compiler->second;
@@ -34,11 +33,11 @@ const ErrorCode CompilerSelectorImpl::InsertCompilerIfNeeded(std::vector<Compile
     if (std::find(selected.cbegin(), selected.cend(), compiler) == selected.cend()) {
       selected.push_back(compiler);
     }
+    return ErrorCode::kErrorNoError;
   } else {
     LogInfo::MapleLogger(kLlErr) << name << " not found!!!" << std::endl;
     return ErrorCode::kErrorToolNotFound;
   }
-  return ErrorCode::kErrorNoError;
 }
 
 const ErrorCode CompilerSelectorImpl::Select(const SupportedCompilers &supportedCompilers, const MplOptions &mplOptions,
diff --git a/src/maple_driver/src/driver_runner.cpp b/src/maple_driver/src/driver_runner.cpp
index 5c30a831a0c9f10cce3d79545b783ab71a797e7f..572c3a335ee80e53044aeda424348d0f56fc6719 100644
--- a/src/maple_driver/src/driver_runner.cpp
+++ b/src/maple_driver/src/driver_runner.cpp
@@ -56,15 +56,14 @@ const char *kMe = "me";
   }
 
 namespace maple {
-int DriverRunner::Run() {
-  CHECK_MODULE(1);
+ErrorCode DriverRunner::Run() {
+  CHECK_MODULE(ErrorCode::kErrorExit);
 
   if (exeNames.empty()) {
     LogInfo::MapleLogger() << "Fatal error: no exe specified" << std::endl;
-    return 1;
+    return ErrorCode::kErrorExit;
   }
 
-  int ret = 0;
   printOutExe = exeNames[exeNames.size() - 1];
 
   // Prepare output file
@@ -73,9 +72,9 @@ int DriverRunner::Run() {
   std::string originBaseName = baseName;
   std::string outputFile = baseName.append(GetPostfix());
 
-  bool parsed = ParseInput(outputFile, originBaseName);
+  ErrorCode ret = ParseInput(outputFile, originBaseName);
 
-  if (parsed) {
+  if (ret == ErrorCode::kErrorNoError) {
     if (mpl2mplOptions || meOptions) {
       std::string vtableImplFile = originBaseName;
       vtableImplFile.append(".VtableImpl.mpl");
@@ -84,10 +83,10 @@ int DriverRunner::Run() {
     }
 
   } else {
-    ret = 1;
+    return ErrorCode::kErrorExit;
   }
 
-  return ret;
+  return ErrorCode::kErrorNoError;
 }
 
 void DriverRunner::ReleaseOptions() {
@@ -116,22 +115,24 @@ std::string DriverRunner::GetPostfix() const {
   return postFix;
 }
 
-bool DriverRunner::ParseInput(std::string outputFile, std::string originBaseName) const {
-  CHECK_MODULE(1);
+ErrorCode DriverRunner::ParseInput(std::string outputFile, std::string originBaseName) const {
+  CHECK_MODULE(ErrorCode::kErrorExit);
 
   LogInfo::MapleLogger() << "Starting parse input" << std::endl;
   MPLTimer timer;
   timer.Start();
 
   MIRParser parser(*theModule);
+  ErrorCode ret = ErrorCode::kErrorNoError;
   bool parsed = parser.ParseMIR(0, 0, false, true);
   if (!parsed) {
+    ret = ErrorCode::kErrorExit;
     parser.EmitError(outputFile);
   }
   timer.Stop();
   LogInfo::MapleLogger() << "Parse consumed " << timer.Elapsed() << "s" << std::endl;
 
-  return parsed;
+  return ret;
 }
 
 bool DriverRunner::VerifyModule(MIRModulePtr &mModule) const {
diff --git a/src/maple_driver/src/file_utils.cpp b/src/maple_driver/src/file_utils.cpp
index f435e8d997e24df91f8f04b96674647a79f08ab8..08d56430211e0914614626f3efd994dfe2b2bf4f 100644
--- a/src/maple_driver/src/file_utils.cpp
+++ b/src/maple_driver/src/file_utils.cpp
@@ -46,16 +46,16 @@ const int FileUtils::Remove(const std::string &filePath) {
 }
 
 const std::string FileUtils::AppendMapleRootIfNeeded(bool needRootPath, const std::string &path,
-                                                     const std::string& defaultRoot) {
+                                                     const std::string &defaultRoot) {
   if (!needRootPath) {
     return path;
   }
-  std::stringstream strStream;
+  std::ostringstream ostrStream;
   if (getenv(kMapleRoot) == nullptr) {
-    strStream << defaultRoot << path;
+    ostrStream << defaultRoot << path;
   } else {
-    strStream << getenv(kMapleRoot) << FileSeperator::kFileSeperatorStr << path;
+    ostrStream << getenv(kMapleRoot) << FileSeperator::kFileSeperatorStr << path;
   }
-  return strStream.str();
+  return ostrStream.str();
 }
 }  // namespace maple
diff --git a/src/maple_driver/src/jbc2mpl_compiler.cpp b/src/maple_driver/src/jbc2mpl_compiler.cpp
index a4b6dfa3528640aaf4ca87abc4f3045deddecd9a..6cd6d04f05853be81d20ba5c57efa9183d69aecf 100644
--- a/src/maple_driver/src/jbc2mpl_compiler.cpp
+++ b/src/maple_driver/src/jbc2mpl_compiler.cpp
@@ -14,7 +14,7 @@
  */
 #include <cstdlib>
 #include "compiler.h"
-#include "default_options.h"
+#include "default_options.def"
 
 namespace maple {
 const std::string Jbc2MplCompiler::GetBinName() const {
diff --git a/src/maple_driver/src/maple_comb_compiler.cpp b/src/maple_driver/src/maple_comb_compiler.cpp
index 3a78d90a0e1ae440eee190e961bc94e8f8d4f7c3..b32730844c5b03ea12ec9d76509426860d29597f 100644
--- a/src/maple_driver/src/maple_comb_compiler.cpp
+++ b/src/maple_driver/src/maple_comb_compiler.cpp
@@ -20,7 +20,7 @@
 #include "mpl_logging.h"
 #include "driver_runner.h"
 
-using namespace maple;
+namespace maple {
 using namespace mapleOption;
 
 const std::string MapleCombCompiler::GetInputFileName(const MplOptions &options) const {
@@ -255,7 +255,7 @@ ErrorCode MapleCombCompiler::Compile(const MplOptions &options, MIRModulePtr &th
   PrintCommand(options);
   DriverRunner runner(theModule, options.runningExes, mpl2mplOptions, fileName, meOptions, fileName, fileName, optMp,
                       options.timePhases, options.genMemPl);
-  int nErr = runner.Run();
+  ErrorCode nErr = runner.Run();
 
   if (mpl2mplOptions != nullptr) {
     delete mpl2mplOptions;
@@ -266,5 +266,6 @@ ErrorCode MapleCombCompiler::Compile(const MplOptions &options, MIRModulePtr &th
     meOptions = nullptr;
   }
   mempoolctrler.DeleteMemPool(optMp);
-  return nErr == 0 ? ErrorCode::kErrorNoError : ErrorCode::kErrorCompileFail;
+  return nErr;
 }
+}  // namespace maple
\ No newline at end of file
diff --git a/src/maple_driver/src/mpl_options.cpp b/src/maple_driver/src/mpl_options.cpp
index f059b031ee328503d60f82ea75398c4aed8bbd93..96dd47f2f55cc6e18a17846b936d4861b902b963 100644
--- a/src/maple_driver/src/mpl_options.cpp
+++ b/src/maple_driver/src/mpl_options.cpp
@@ -22,8 +22,8 @@
 #include "option_parser.h"
 #include "string_utils.h"
 #include "usages.h"
-#include "default_options.h"
 #include "version.h"
+#include "default_options.def"
 
 using namespace mapleOption;
 
@@ -34,46 +34,44 @@ int MplOptions::Parse(int argc, char **argv) {
   this->optionParser = new OptionParser(USAGES);
   exeFolder = FileUtils::GetFileFolder(*argv);
   int ret = optionParser->Parse(argc, argv);
-  bool isOptLevelO0 = false;
-  bool isOptLevelO2 = false;
   if (ret != ErrorCode::kErrorNoError) {
     return ErrorCode::kErrorInvalidParameter;
   }
   // We should recognize O0, O2 and run options firstly to decide the real options
-  for (auto opt : optionParser->GetOptions()) {
-    switch (opt.Index()) {
-      case kOptimization0:
-        isOptLevelO0 = true;
-        isOptLevelO2 = false;
-        break;
-      case kRun:
-        this->UpdateRunningExe(opt.Args());
-        break;
-      default:
-        break;
-    }
+  ret = DecideRunType();
+  if (ret != ErrorCode::kErrorNoError) {
+    return ret;
   }
-  // Set Default options as O0
-  if (runningExes.size() == 0 && isOptLevelO0 == false && isOptLevelO2 == false) {
-    isOptLevelO0 = true;
-    isOptLevelO2 = false;
+
+  // Set default as O0
+  if (optLevelStr == "") {
+    optLevelStr = "O0";
   }
-  // Set O0 options
-  if (isOptLevelO0 == true) {
-    this->UpdateOptLevel(kO0);
-    this->setDefaultLevel = true;
-    this->UpdateRunningExe("jbc2mpl");
-    ret = AppendDefaultOptions(kBinNameMe, kMeDefaultOptionsO0, sizeof(kMeDefaultOptionsO0) / sizeof(MplOption));
-    if (ret != ErrorCode::kErrorNoError) {
-      return ret;
-    }
-    ret = AppendDefaultOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO0,
-                               sizeof(kMpl2MplDefaultOptionsO0) / sizeof(MplOption));
+
+  // Check whether the input files are Valid
+  ret = CheckInputFileValidity();
+  if (ret != ErrorCode::kErrorNoError) {
+    return ret;
+  }
+
+  // Decide runningExes for default options(O0, O2) by input files
+  if (optLevelStr != "run") {
+    ret = DecideRunningPhases();
     if (ret != ErrorCode::kErrorNoError) {
       return ret;
     }
-    this->UpdateRunningExe("mplcg");
   }
+
+  // Handle other options
+  ret = HandleGeneralOptions();
+  if (ret != ErrorCode::kErrorNoError) {
+    return ret;
+  }
+  return ret;
+}
+
+ErrorCode MplOptions::HandleGeneralOptions() {
+  ErrorCode ret = ErrorCode::kErrorNoError;
   for (auto opt : optionParser->GetOptions()) {
     switch (opt.Index()) {
       case kHelp: {
@@ -102,18 +100,6 @@ int MplOptions::Parse(int argc, char **argv) {
       case kMpl2MplHelp:
         optionParser->PrintUsage("mpl2mpl");
         return ErrorCode::kErrorExitHelp;
-      case kInFile: {
-        if (!Init(opt.Args())) {
-          return ErrorCode::kErrorInitFail;
-        } else {
-          // Check whether the file was readable
-          ret = CheckFileExits();
-          if (ret != ErrorCode::kErrorNoError) {
-            return ret;
-          }
-        }
-        break;
-      }
       case kCombTimePhases:
         this->timePhases = true;
         this->printCommandStr += " -time-phases";
@@ -149,8 +135,98 @@ int MplOptions::Parse(int argc, char **argv) {
         // I do not care
         break;
     }
-    this->AddOption(opt);
+    AddOption(opt);
+  }
+  return ret;
+}
+
+ErrorCode MplOptions::DecideRunType() {
+  ErrorCode ret = ErrorCode::kErrorNoError;
+  for (auto opt : optionParser->GetOptions()) {
+    switch (opt.Index()) {
+      case kOptimization0:
+        ret = CheckOptLevel("O0", "run"); // O0 and run should not appear at the same time
+        if (ret != ErrorCode::kErrorNoError) {
+          return ErrorCode::kErrorInvalidParameter;
+        }
+        optLevelStr = "O0";
+        break;
+      case kRun:
+        ret = CheckOptLevel("run", "O0"); // O0(O2) and run should not appear at the same time
+        if (ret != ErrorCode::kErrorNoError) {
+          return ErrorCode::kErrorInvalidParameter;
+        }
+        ret = CheckOptLevel("run", "O2");
+        if (ret != ErrorCode::kErrorNoError) {
+          return ErrorCode::kErrorInvalidParameter;
+        }
+        optLevelStr = "run";
+        this->UpdateRunningExe(opt.Args());
+        break;
+      case kInFile: {
+        if (!Init(opt.Args())) {
+          return ErrorCode::kErrorInitFail;
+        } else {
+          // Check whether the file was readable
+          ret = CheckFileExits();
+          if (ret != ErrorCode::kErrorNoError) {
+            return ret;
+          }
+        }
+        break;
+      }
+      default:
+        break;
+    }
+  }
+  return ret;
+}
+
+ErrorCode MplOptions::DecideRunningPhases() {
+  ErrorCode ret = ErrorCode::kErrorNoError;
+  bool isNeedMapleComb = true;
+  bool isNeedMplcg = true;
+  switch (inputFileType) {
+    case InputFileType::kJar:
+    case InputFileType::kClass:
+      this->UpdateRunningExe("jbc2mpl");
+      break;
+    case InputFileType::kMpl:
+      break;
+    case InputFileType::kVtableImplMpl:
+      isNeedMapleComb = false;
+      break;
+    case InputFileType::kS:
+      isNeedMplcg = false;
+      break;
+    case InputFileType::kNone:
+      break;
+    default:
+      break;
+  }
+  if (isNeedMapleComb) {
+    if (optLevelStr == "O0") {
+      ret = AppendDefaultOptions(kBinNameMe, kMeDefaultOptionsO0, sizeof(kMeDefaultOptionsO0) / sizeof(MplOption));
+      if (ret != ErrorCode::kErrorNoError) {
+        return ret;
+      }
+      ret = AppendDefaultOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO0,
+                                 sizeof(kMpl2MplDefaultOptionsO0) / sizeof(MplOption));
+      if (ret != ErrorCode::kErrorNoError) {
+        return ret;
+      }
+    }
   }
+  if (isNeedMplcg) {
+    if (optLevelStr == "O0") {
+      this->UpdateRunningExe("mplcg");
+    }
+  }
+  return ret;
+}
+
+ErrorCode MplOptions::CheckInputFileValidity() {
+  ErrorCode ret = ErrorCode::kErrorNoError;
   // Get input fileName
   if (optionParser->GetNonOptionsCount() > 0) {
     std::string optionString;
@@ -169,20 +245,22 @@ int MplOptions::Parse(int argc, char **argv) {
       ret = CheckFileExits();
     }
   }
-  // Set Default options as O0
-  if (runningExes.size() == 0) {
-    this->UpdateOptLevel(kO0);
-    this->setDefaultLevel = true;
-    this->UpdateRunningExe("dex2mpl");
-    ret = AppendDefaultOptions(kBinNameMe, kMeDefaultOptionsO0,
-                               sizeof(kMeDefaultOptionsO0) / sizeof(MplOption));
-    ret = AppendDefaultOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO0,
-                               sizeof(kMpl2MplDefaultOptionsO0) / sizeof(MplOption));
-    this->UpdateRunningExe("mplcg");
+  if (this->inputFiles == "") {
+    LogInfo::MapleLogger(kLlErr) << "Forget to input file? " << "\n";
+    return ErrorCode::kErrorInitFail;
   }
   return ret;
 }
 
+ErrorCode MplOptions::CheckOptLevel(const std::string &inputOpt, const std::string &filterOpt) {
+  if (optLevelStr == filterOpt) {
+    LogInfo::MapleLogger(kLlErr) << "Cannot Set " << inputOpt << " and "
+                                 << filterOpt << "at the same time!" << "\n";
+    return ErrorCode::kErrorInvalidParameter;
+  }
+  return ErrorCode::kErrorNoError;
+}
+
 ErrorCode MplOptions::CheckFileExits() {
   ErrorCode ret = ErrorCode::kErrorNoError;
   for (auto fileName : splitsInputFiles) {
@@ -199,8 +277,12 @@ ErrorCode MplOptions::CheckFileExits() {
 
 void MplOptions::AddOption(const mapleOption::Option &option) {
   if (option.HasExtra()) {
-    for (auto extra : option.GetExtras()) {
-      options.Insert(extra.exeName, option);
+    for (auto &extra : option.GetExtras()) {
+      auto iter = std::find(this->runningExes.begin(), this->runningExes.end(), extra.exeName);
+      if (iter == this->runningExes.end()) {
+        continue;
+      }
+      options[extra.exeName].push_back(option);
     }
   }
 }
diff --git a/src/maple_driver/src/mplcg_compiler.cpp b/src/maple_driver/src/mplcg_compiler.cpp
index 69d4e7c36f83690925c60a2a115e4f3d067c3d56..6d463adc92d322d26a50fe89a94503e2302e5768 100644
--- a/src/maple_driver/src/mplcg_compiler.cpp
+++ b/src/maple_driver/src/mplcg_compiler.cpp
@@ -14,7 +14,7 @@
  */
 #include <cstdlib>
 #include "compiler.h"
-#include "default_options.h"
+#include "default_options.def"
 
 
 using namespace maple;
diff --git a/src/maple_ipa/include/module_phase.h b/src/maple_ipa/include/module_phase.h
index c51a36eae40148dceb2dfda586116f98e497a394..a1d8cbe8736dc667a75d87e06ecf378e4a73f601 100644
--- a/src/maple_ipa/include/module_phase.h
+++ b/src/maple_ipa/include/module_phase.h
@@ -28,7 +28,7 @@ enum ModulePhaseID {
   kMoPhaseMax
 };
 
-class ModulePhase;
+class ModulePhase;  // circular dependency exists, no other choice
 using ModuleResultMgr = AnalysisResultManager<MIRModule, ModulePhaseID, ModulePhase>;
 class ModulePhase : public Phase {
  public:
diff --git a/src/maple_ir/include/all_attributes.def b/src/maple_ir/include/all_attributes.def
index c7e59cf1044151faf3fe77a97ca9ee159617f791..e456a4fc75290df090c6cafddc1c4a7aa5b21659 100644
--- a/src/maple_ir/include/all_attributes.def
+++ b/src/maple_ir/include/all_attributes.def
@@ -12,66 +12,66 @@
  * FIT FOR A PARTICULAR PURPOSE.
  * See the Mulan PSL v1 for more details.
  */
-/* all possible attribute names from typeattrs.def, funcattrs.def and fieldattrs.def */
-  ATTR(const)
-  ATTR(final)
-  ATTR(generic)
-  ATTR(implicit)
-  ATTR(private)
-  ATTR(protected)
-  ATTR(public)
-  ATTR(static)
-  ATTR(synthetic)
-  ATTR(used)
-#ifdef FUNC_ATTR
-  ATTR(bridge)
-  ATTR(constructor)
-  ATTR(critical_native)
-  ATTR(declared_synchronized)
-  ATTR(default)
-  ATTR(destructor)
-  ATTR(delete)
-  ATTR(fast_native)
-  ATTR(inline)
-  ATTR(native)
-  ATTR(strict)
-  ATTR(varargs)
-  ATTR(virtual)
-  ATTR(nosideeffect)
-  ATTR(pure)
-  ATTR(noexcept)
-  ATTR(nouseeffect)
-  ATTR(nodefeffect)
-  ATTR(noret_newly_alloc_obj)
-  ATTR(nothrow_exception)
-  ATTR(noprivate_useeffect)
-  ATTR(noprivate_defeffect)
-  ATTR(ipaseen)
-  ATTR(rclocalunowned)
-  ATTR(callersensitive)
-#endif
-#if defined(FUNC_ATTR) || defined(TYPE_ATTR)
-  ATTR(abstract)
-  ATTR(extern)
-  ATTR(interface)
-  ATTR(local)
-  ATTR(optimized)
-  ATTR(synchronized)
-  ATTR(weak)
-#endif
-#if defined(TYPE_ATTR) || defined(FIELD_ATTR)
-#include "memory_order_attrs.def"
-  ATTR(enum)
-  ATTR(restrict)
-  ATTR(transient)
-  ATTR(volatile)
-  ATTR(rcunowned)
-  ATTR(rcweak)
-#endif
-#ifdef TYPE_ATTR
-  ATTR(annotation)
-  ATTR(readonly)
-  ATTR(verified)
-  ATTR(localrefvar)
-  ATTR(rcunownedthis)
-#endif
+/* all possible attribute names from typeattrs.def, funcattrs.def and fieldattrs.def */
+  ATTR(const)
+  ATTR(final)
+  ATTR(generic)
+  ATTR(implicit)
+  ATTR(private)
+  ATTR(protected)
+  ATTR(public)
+  ATTR(static)
+  ATTR(synthetic)
+  ATTR(used)
+#ifdef FUNC_ATTR
+  ATTR(bridge)
+  ATTR(constructor)
+  ATTR(critical_native)
+  ATTR(declared_synchronized)
+  ATTR(default)
+  ATTR(destructor)
+  ATTR(delete)
+  ATTR(fast_native)
+  ATTR(inline)
+  ATTR(native)
+  ATTR(strict)
+  ATTR(varargs)
+  ATTR(virtual)
+  ATTR(nosideeffect)
+  ATTR(pure)
+  ATTR(noexcept)
+  ATTR(nodefargeffect)
+  ATTR(nodefeffect)
+  ATTR(noret_newly_alloc_obj)
+  ATTR(nothrow_exception)
+  ATTR(noprivate_useeffect)
+  ATTR(noprivate_defeffect)
+  ATTR(ipaseen)
+  ATTR(rclocalunowned)
+  ATTR(callersensitive)
+#endif
+#if defined(FUNC_ATTR) || defined(TYPE_ATTR)
+  ATTR(abstract)
+  ATTR(extern)
+  ATTR(interface)
+  ATTR(local)
+  ATTR(optimized)
+  ATTR(synchronized)
+  ATTR(weak)
+#endif
+#if defined(TYPE_ATTR) || defined(FIELD_ATTR)
+#include "memory_order_attrs.def"
+  ATTR(enum)
+  ATTR(restrict)
+  ATTR(transient)
+  ATTR(volatile)
+  ATTR(rcunowned)
+  ATTR(rcweak)
+#endif
+#ifdef TYPE_ATTR
+  ATTR(annotation)
+  ATTR(readonly)
+  ATTR(verified)
+  ATTR(localrefvar)
+  ATTR(rcunownedthis)
+#endif
diff --git a/src/maple_ir/include/intrinsics.h b/src/maple_ir/include/intrinsics.h
index ea739024abd4a2d4bb8b2bfdf47238818052c1b4..d72c17e41c640d1cf6bd01cc57cc62ecadb53c0b 100644
--- a/src/maple_ir/include/intrinsics.h
+++ b/src/maple_ir/include/intrinsics.h
@@ -85,8 +85,8 @@ static constexpr uint32 INTRNISPURE = 1U << kIntrnIsPure;
 static constexpr uint32 INTRNNEVERRETURN = 1U << kIntrnNeverReturn;
 static constexpr uint32 INTRNATOMIC = 1U << kIntrnIsAtomic;
 static constexpr uint32 INTRNISRC = 1U << kIntrnIsRC;
-class MIRType;
-class MIRModule;
+class MIRType;  // circular dependency exists, no other choice
+class MIRModule;  // circular dependency exists, no other choice
 struct IntrinDesc {
   static constexpr int kMaxArgsNum = 7;
   const char *name;
diff --git a/src/maple_ir/include/lexer.h b/src/maple_ir/include/lexer.h
index 6c5d23375c3c8990bc4e4e212ed8e676600f832e..9a2e5bff46e5b9dc9230b4bf97cc4814cb2c82fa 100644
--- a/src/maple_ir/include/lexer.h
+++ b/src/maple_ir/include/lexer.h
@@ -22,7 +22,7 @@
 #include "mir_module.h"
 
 namespace maple {
-class MIRParser;
+class MIRParser;  // circular dependency exists, no other choice
 class MIRLexer {
   friend MIRParser;
 
diff --git a/src/maple_ir/include/mir_const.h b/src/maple_ir/include/mir_const.h
index 2452ddae848dc64750db64524eddc4072eea11be..bdabc733d60fd788b924f49ed3a69f5e60c16921 100644
--- a/src/maple_ir/include/mir_const.h
+++ b/src/maple_ir/include/mir_const.h
@@ -18,10 +18,10 @@
 #include "mir_type.h"
 
 namespace maple {
-class MIRConst;
+class MIRConst;  // circular dependency exists, no other choice
 using MIRConstPtr = MIRConst*;
 #if MIR_FEATURE_FULL
-class MIRSymbol;
+class MIRSymbol;  // circular dependency exists, no other choice
 enum MIRConstKind {
   kConstInvalid,
   kConstInt,
@@ -260,7 +260,7 @@ class MIRStrConst : public MIRConst {
 
   void Dump() const;
   bool operator==(MIRConst &rhs) const;
-  UStrIdx GetValue() {
+  UStrIdx GetValue() const {
     return value;
   }
 
diff --git a/src/maple_ir/include/mir_function.h b/src/maple_ir/include/mir_function.h
index 1c3d5dc69fef4dd441e11d35b762ad5e61ab7b82..3d1466d5aaf7bad6f01e1ced708a8c6f8d3c849b 100644
--- a/src/maple_ir/include/mir_function.h
+++ b/src/maple_ir/include/mir_function.h
@@ -52,13 +52,13 @@ constexpr uint8 kDefEffect = 0x80;
 constexpr uint8 kUseEffect = 0x40;
 constexpr uint8 kIpaSeen = 0x20;
 constexpr uint8 kPureFunc = 0x10;
-constexpr uint8 kNoUseEffect = 0x8;
+constexpr uint8 kNoDefArgEffect = 0x8;
 constexpr uint8 kNoDefEffect = 0x4;
 constexpr uint8 kNoRetNewlyAllocObj = 0x2;
 constexpr uint8 kNoThrowException = 0x1;
 
-class MeFunction;
-class EAConnectionGraph;
+class MeFunction;  // circular dependency exists, no other choice
+class EAConnectionGraph;  // circular dependency exists, no other choice
 class MIRFunction {
  public:
   MIRFunction(MIRModule *mod, const StIdx sidx)
@@ -279,9 +279,9 @@ class MIRFunction {
     if ((se & kPureFunc) == kPureFunc) {
       funcAttrs.SetAttr(FUNCATTR_pure);
     }
-    // NoUseEffect
-    if ((se & kNoUseEffect) == kNoUseEffect) {
-      funcAttrs.SetAttr(FUNCATTR_nouseeffect);
+    // NoDefArgEffect
+    if ((se & kNoDefArgEffect) == kNoDefArgEffect) {
+      funcAttrs.SetAttr(FUNCATTR_nodefargeffect);
     }
     // NoDefEffect
     if ((se & kNoDefEffect) == kNoDefEffect) {
@@ -351,8 +351,8 @@ class MIRFunction {
     return funcAttrs.GetAttr(FUNCATTR_local);
   }
 
-  bool IsNoUseEffect() const {
-    return funcAttrs.GetAttr(FUNCATTR_nouseeffect);
+  bool IsNoDefArgEffect() const {
+    return funcAttrs.GetAttr(FUNCATTR_nodefargeffect);
   }
 
   bool IsNoDefEffect() const {
@@ -387,8 +387,8 @@ class MIRFunction {
     funcAttrs.SetAttr(FUNCATTR_varargs);
   }
 
-  void SetNoUseEffect() {
-    funcAttrs.SetAttr(FUNCATTR_nouseeffect);
+  void SetNoDefArgEffect() {
+    funcAttrs.SetAttr(FUNCATTR_nodefargeffect);
   }
 
   void SetNoDefEffect() {
@@ -419,8 +419,8 @@ class MIRFunction {
     funcAttrs.SetAttr(FUNCATTR_pure);
   }
 
-  void UnsetNoUseEffect() {
-    funcAttrs.SetAttr(FUNCATTR_nouseeffect, true);
+  void UnsetNoDefArgEffect() {
+    funcAttrs.SetAttr(FUNCATTR_nodefargeffect, true);
   }
 
   void UnsetNoDefEffect() {
diff --git a/src/maple_ir/include/mir_module.h b/src/maple_ir/include/mir_module.h
index 2f577b1758ffd5ceb44c8da123770458a3cd50a7..de81e162085d0d708993e7fe1b69ddf4ad4a8b63 100644
--- a/src/maple_ir/include/mir_module.h
+++ b/src/maple_ir/include/mir_module.h
@@ -29,9 +29,9 @@
 #endif  // MIR_FEATURE_FULL
 
 namespace maple {
-class CallInfo;
-class MIRModule;
-class MIRBuilder;
+class CallInfo;  // circular dependency exists, no other choice
+class MIRModule;  // circular dependency exists, no other choice
+class MIRBuilder;  // circular dependency exists, no other choice
 using MIRModulePtr = MIRModule*;
 using MIRBuilderPtr = MIRBuilder*;
 
@@ -56,16 +56,16 @@ static inline uint32 BlockSize2BitVectorSize(uint32 blkSize) {
 }
 
 #if MIR_FEATURE_FULL
-class MIRType;
-class MIRFunction;
-class MIRSymbol;
-class MIRSymbolTable;
-class MIRFloatConst;
-class MIRDoubleConst;
-class MIRBuilder;
-class DebugInfo;
-class BinaryMplt;
-class EAConnectionGraph;
+class MIRType;  // circular dependency exists, no other choice
+class MIRFunction;  // circular dependency exists, no other choice
+class MIRSymbol;  // circular dependency exists, no other choice
+class MIRSymbolTable;  // circular dependency exists, no other choice
+class MIRFloatConst;  // circular dependency exists, no other choice
+class MIRDoubleConst;  // circular dependency exists, no other choice
+class MIRBuilder;  // circular dependency exists, no other choice
+class DebugInfo;  // circular dependency exists, no other choice
+class BinaryMplt;  // circular dependency exists, no other choice
+class EAConnectionGraph;  // circular dependency exists, no other choice
 using MIRInfoPair = std::pair<GStrIdx, uint32>;
 using MIRInfoVector = MapleVector<MIRInfoPair>;
 using MIRDataPair = std::pair<GStrIdx, std::vector<uint8>>;
diff --git a/src/maple_ir/include/mir_nodes.h b/src/maple_ir/include/mir_nodes.h
index f2c1b2c526a05a57143411569f2750fcd77007e9..a04244c2f3c8028204707be7df9ef34e8eaa2800 100644
--- a/src/maple_ir/include/mir_nodes.h
+++ b/src/maple_ir/include/mir_nodes.h
@@ -25,8 +25,8 @@
 #include "ptr_list_ref.h"
 
 namespace maple {
-class MIRPregTable;
-class TypeTable;
+class MIRPregTable;  // circular dependency exists, no other choice
+class TypeTable;  // circular dependency exists, no other choice
 
 struct RegFieldPair {
  public:
diff --git a/src/maple_ir/include/mir_pragma.h b/src/maple_ir/include/mir_pragma.h
index f46df422d90fc9d471b42ed26c032314e3c9537f..a37727ec29798a877894b92a7fe8484909c04564 100644
--- a/src/maple_ir/include/mir_pragma.h
+++ b/src/maple_ir/include/mir_pragma.h
@@ -21,12 +21,12 @@
 #include "mempool_allocator.h"
 
 namespace maple {
-class MIRModule;
-class MIRType;
-class MIRFunction;
-class MIRSymbol;
-class MIRSymbolTable;
-class MIRTypeNameTable;
+class MIRModule;  // circular dependency exists, no other choice
+class MIRType;  // circular dependency exists, no other choice
+class MIRFunction;  // circular dependency exists, no other choice
+class MIRSymbol;  // circular dependency exists, no other choice
+class MIRSymbolTable;  // circular dependency exists, no other choice
+class MIRTypeNameTable;  // circular dependency exists, no other choice
 enum PragmaKind {
   kPragmaUnknown,
   kPragmaClass,
diff --git a/src/maple_ir/include/mir_type.h b/src/maple_ir/include/mir_type.h
index 9f07b5226ef9a6f1c5f49eacfbf646214bb47853..feefc4d60df07d37ce3486a9084ce5758e9d83a8 100644
--- a/src/maple_ir/include/mir_type.h
+++ b/src/maple_ir/include/mir_type.h
@@ -26,7 +26,7 @@
 namespace maple {
 constexpr int kTypeHashLength = 12289;  // hash length for mirtype, ref: planetmath.org/goodhashtableprimes
 
-class FieldAttrs;
+class FieldAttrs;  // circular dependency exists, no other choice
 using TyIdxFieldAttrPair = std::pair<TyIdx, FieldAttrs>;
 using FieldPair = std::pair<GStrIdx, TyIdxFieldAttrPair>;
 using FieldVector = std::vector<FieldPair>;
diff --git a/src/maple_ir/src/parser.cpp b/src/maple_ir/src/parser.cpp
index 13db3f2cd0af9c17ad53abd58a424cd54a8931a5..1aceae9718407733078d4fc776201569c82c6537 100644
--- a/src/maple_ir/src/parser.cpp
+++ b/src/maple_ir/src/parser.cpp
@@ -1869,8 +1869,8 @@ bool MIRParser::ParseFunction(uint32 fileIdx) {
       if (func->IsNoThrowException()) {
         funcAttrs.SetAttr(FUNCATTR_nothrow_exception);
       }
-      if (func->IsNoUseEffect()) {
-        funcAttrs.SetAttr(FUNCATTR_nouseeffect);
+      if (func->IsNoDefArgEffect()) {
+        funcAttrs.SetAttr(FUNCATTR_nodefargeffect);
       }
       if (func->IsNoPrivateUseEffect()) {
         funcAttrs.SetAttr(FUNCATTR_noprivate_useeffect);
diff --git a/src/maple_me/include/bb.h b/src/maple_me/include/bb.h
index 13b08a45a985dd1d8e66d1cd58001a6b620a28c6..f7ca07282e31df7b0b33384e2bae64e44362ee18 100644
--- a/src/maple_me/include/bb.h
+++ b/src/maple_me/include/bb.h
@@ -18,12 +18,12 @@
 #include "ssa.h"
 
 namespace maple {
-class VersionSt;
-class OriginalSt;
-class MeStmt;
-class MeVarPhiNode;
-class MeRegPhiNode;
-class IRMap;
+class VersionSt;  // circular dependency exists, no other choice
+class OriginalSt;  // circular dependency exists, no other choice
+class MeStmt;  // circular dependency exists, no other choice
+class MeVarPhiNode;  // circular dependency exists, no other choice
+class MeRegPhiNode;  // circular dependency exists, no other choice
+class IRMap;  // circular dependency exists, no other choice
 enum BBKind {
   kBBUnknown,  // uninitialized
   kBBCondGoto,
diff --git a/src/maple_me/include/me_function.h b/src/maple_me/include/me_function.h
index 38e808c031f6ad2e299660a51991460f38d2ffd0..d267ec48d6aefb52b1b2746b53ce06aadf75a1aa 100644
--- a/src/maple_me/include/me_function.h
+++ b/src/maple_me/include/me_function.h
@@ -28,8 +28,8 @@
 #include "me_ssa.h"
 
 namespace maple {
-class MeCFG;
-class MeIRMap;
+class MeCFG;  // circular dependency exists, no other choice
+class MeIRMap;  // circular dependency exists, no other choice
 #if DEBUG
 extern MIRModule *globalMIRModule;
 extern MeFunction *globalFunc;
diff --git a/src/maple_me/include/me_ir.h b/src/maple_me/include/me_ir.h
index bae657562c160cf878ff542d11bba049225bf3f8..be464bb9364cfb983931d72e0eeb8b4be70fca67 100644
--- a/src/maple_me/include/me_ir.h
+++ b/src/maple_me/include/me_ir.h
@@ -18,15 +18,15 @@
 #include "orig_symbol.h"
 
 namespace maple {
-class BB;
-class PhiNode;
-class MeStmt;
-class IRMap;
-class SSATab;
-class VarMeExpr;
-class RegMeExpr;
-class OriginalSt;
-class Dominance;
+class BB;  // circular dependency exists, no other choice
+class PhiNode;  // circular dependency exists, no other choice
+class MeStmt;  // circular dependency exists, no other choice
+class IRMap;  // circular dependency exists, no other choice
+class SSATab;  // circular dependency exists, no other choice
+class VarMeExpr;  // circular dependency exists, no other choice
+class RegMeExpr;  // circular dependency exists, no other choice
+class OriginalSt;  // circular dependency exists, no other choice
+class Dominance;  // circular dependency exists, no other choice
 using MeStmtPtr = MeStmt*;
 enum MeExprOp : std::uint8_t {
   kMeOpUnknown,
@@ -179,9 +179,9 @@ enum MeDefBy {
   kDefByMustDef,  // only applies to callassigned and its siblings
 };
 
-class ChiMeNode;      // forward decl
-class MustDefMeNode;  // forward decl
-class IassignMeStmt;  // forward decl
+class ChiMeNode;  // circular dependency exists, no other choice
+class MustDefMeNode;  // circular dependency exists, no other choice
+class IassignMeStmt;  // circular dependency exists, no other choice
 
 // represant dread
 class VarMeExpr final : public MeExpr {
diff --git a/src/maple_me/include/me_phase.h b/src/maple_me/include/me_phase.h
index 2c035d0720caff228c5d9f06fed922a8e137c7c5..2aa4f9650deff0740fdae8332f103b61df9df919 100644
--- a/src/maple_me/include/me_phase.h
+++ b/src/maple_me/include/me_phase.h
@@ -30,8 +30,8 @@ enum MePhaseID {
   kMePhaseMax
 };
 
-class MeFuncPhase;
-class MeFunction;
+class MeFuncPhase;  // circular dependency exists, no other choice
+class MeFunction;  // circular dependency exists, no other choice
 using MeFuncResultMgr = AnalysisResultManager<MeFunction, MePhaseID, MeFuncPhase>;
 class MeFuncPhase : public Phase {
  public:
diff --git a/src/maple_me/include/orig_symbol.h b/src/maple_me/include/orig_symbol.h
index f3735a5130562af00d4bd2631286faffdeac2d32..a2b7eeba8c81a1b534c101673c20a47b26086b09 100644
--- a/src/maple_me/include/orig_symbol.h
+++ b/src/maple_me/include/orig_symbol.h
@@ -24,7 +24,7 @@
 // symbol occurring in the code of the program being optimized.
 namespace maple {
 constexpr int kInitVersion = 0;
-class VarMeExpr;
+class VarMeExpr;  // circular dependency exists, no other choice
 class OriginalSt {
  public:
   OriginalSt(OStIdx index, MapleAllocator &alloc, bool local, bool isFormal, FieldID fieldIDPara)
diff --git a/src/maple_me/include/ssa.h b/src/maple_me/include/ssa.h
index 54ab62007c44b7a1e5942588e17fb15ada79ce44..9083508389977261a3f89d9940cb8f5a0cba883c 100644
--- a/src/maple_me/include/ssa.h
+++ b/src/maple_me/include/ssa.h
@@ -19,11 +19,11 @@
 #include "mir_nodes.h"
 
 namespace maple {
-class BB;
-class VersionSt;
-class OriginalStTable;
-class VersionStTable;
-class SSATab;
+class BB;  // circular dependency exists, no other choice
+class VersionSt;  // circular dependency exists, no other choice
+class OriginalStTable;  // circular dependency exists, no other choice
+class VersionStTable;  // circular dependency exists, no other choice
+class SSATab;  // circular dependency exists, no other choice
 class PhiNode {
  public:
   PhiNode(MapleAllocator &alloc, VersionSt &vsym) : result(&vsym), phiOpnds(kNumOpnds, nullptr, alloc.Adapter()) {
diff --git a/src/maple_me/include/ssa_mir_nodes.h b/src/maple_me/include/ssa_mir_nodes.h
index 5fef3af46a705d2411f739eec1c29e4af3ef6cc0..b7ad07432389abe0a20f83d3b7e032e4e5163100 100644
--- a/src/maple_me/include/ssa_mir_nodes.h
+++ b/src/maple_me/include/ssa_mir_nodes.h
@@ -389,8 +389,28 @@ class StmtsSSAPart {
 
   ~StmtsSSAPart() = default;
 
-  AccessSSANodes *SSAPartOf(const StmtNode &s) {
-    return ssaPart[s.GetStmtID()];
+  AccessSSANodes *SSAPartOf(const StmtNode &stmt) {
+    return ssaPart[stmt.GetStmtID()];
+  }
+
+  bool HasMayDef(const StmtNode &stmt) {
+    return kOpcodeInfo.HasSSADef(stmt.GetOpCode()) && !GetMayDefNodesOf(stmt).empty();
+  }
+
+  MapleMap<OStIdx, MayDefNode> &GetMayDefNodesOf(const StmtNode &stmt) {
+    return ssaPart[stmt.GetStmtID()]->GetMayDefNodes();
+  }
+
+  MapleMap<OStIdx, MayUseNode> &GetMayUseNodesOf(const StmtNode &stmt) {
+    return ssaPart[stmt.GetStmtID()]->GetMayUseNodes();
+  }
+
+  MapleVector<MustDefNode> &GetMustDefNodesOf(const StmtNode &stmt) {
+    return ssaPart[stmt.GetStmtID()]->GetMustDefNodes();
+  }
+
+  VersionSt *GetAssignedVarOf(const StmtNode &stmt) {
+    return ssaPart[stmt.GetStmtID()]->GetSSAVar();
   }
 
   template <class T>
@@ -516,20 +536,7 @@ class RegreadSSANode : public RegreadNode {
 };
 
 void GenericSSAPrint(MIRModule &mod, const StmtNode &stmtNode, int32 indent, StmtsSSAPart &stmtsSSAPart);
-void SSAGenericInsertMayUseNode(const StmtNode &stmtNode, VersionSt &usesym, StmtsSSAPart &stmtsSSAPart);
-void SSAGenericInsertMayDefNode(const StmtNode &stmtNode, VersionSt &vst, StmtNode &s, StmtsSSAPart &stmtsSSAPart);
-MapleMap<OStIdx, MayUseNode> &SSAGenericGetMayUseNode(const StmtNode &stmtNode, StmtsSSAPart &stmtsSSAPart);
-MapleMap<OStIdx, MayDefNode> &SSAGenericGetMayDefNodes(const StmtNode &stmtNode, StmtsSSAPart &stmtsSSAPart);
 MapleMap<OStIdx, MayDefNode> *SSAGenericGetMayDefsFromVersionSt(VersionSt &sym, StmtsSSAPart &stmtsSSAPart);
-MapleVector<MustDefNode> &SSAGenericGetMustDefNode(const StmtNode &stmtNode, StmtsSSAPart &stmtsSSAPart);
-bool HasMayUseDefPart(const StmtNode &stmtNode);
-bool HasMayDefPart(const StmtNode &stmtNode);
-bool HasMayUsePart(const StmtNode &stmtNode);
 bool HasMayUseOpnd(const BaseNode &baseNode, SSATab &func);
-bool HasMayDef(const StmtNode &stmtNode, SSATab &func);
-inline bool HasMallocOpnd(const BaseNode &x) {
-  return x.GetOpCode() == OP_malloc || x.GetOpCode() == OP_gcmalloc || x.GetOpCode() == OP_gcmallocjarray ||
-         x.GetOpCode() == OP_alloca;
-}
 }  // namespace maple
 #endif  // MAPLE_ME_INCLUDE_SSA_MIR_NODES_H
diff --git a/src/maple_me/include/ver_symbol.h b/src/maple_me/include/ver_symbol.h
index d594db0607655e79e140906ff8fd6d4fec748d33..b557cba21da6d551cc7133cfa31c08a6c0fe0c80 100644
--- a/src/maple_me/include/ver_symbol.h
+++ b/src/maple_me/include/ver_symbol.h
@@ -23,12 +23,12 @@
 struct BBId;
 
 namespace maple {
-class BB;
-class PhiNode;
-class MayDefNode;
-class MustDefNode;
-class VersionStTable;
-class OriginalSt;
+class BB;  // circular dependency exists, no other choice
+class PhiNode;  // circular dependency exists, no other choice
+class MayDefNode;  // circular dependency exists, no other choice
+class MustDefNode;  // circular dependency exists, no other choice
+class VersionStTable;  // circular dependency exists, no other choice
+class OriginalSt;  // circular dependency exists, no other choice
 class VersionSt {
  public:
   enum DefType {
diff --git a/src/maple_me/src/alias_class.cpp b/src/maple_me/src/alias_class.cpp
index 2808ae2df404e0a50880806cecccc054ece953c4..74bd589072cc9980acf41add9509275ac3e03a6a 100644
--- a/src/maple_me/src/alias_class.cpp
+++ b/src/maple_me/src/alias_class.cpp
@@ -157,7 +157,7 @@ AliasElem *AliasClass::CreateAliasElemsExpr(BaseNode &expr) {
 
 // when a mustDef is a pointer, set its pointees' notAllDefsSeen flag to true
 void AliasClass::SetNotAllDefsSeenForMustDefs(const StmtNode &callas) {
-  MapleVector<MustDefNode> &mustDefs = SSAGenericGetMustDefNode(callas, ssaTab.GetStmtsSSAPart());
+  MapleVector<MustDefNode> &mustDefs = ssaTab.GetStmtsSSAPart().GetMustDefNodesOf(callas);
   for (MustDefNode mustDef : mustDefs) {
     AliasElem *aliasElem = FindOrCreateAliasElem(*mustDef.GetResult()->GetOrigSt());
     aliasElem->SetNextLevNotAllDefsSeen(true);
@@ -170,7 +170,7 @@ void AliasClass::ApplyUnionForDassignCopy(const AliasElem &lhsAe, const AliasEle
     ae->SetNextLevNotAllDefsSeen(true);
     return;
   }
-  if (!IsPotentialAddress(rhs.GetPrimType()) || HasMallocOpnd(rhs) ||
+  if (!IsPotentialAddress(rhs.GetPrimType()) || kOpcodeInfo.NotPure(rhs.GetOpCode()) ||
       (rhs.GetOpCode() == OP_addrof && IsReadOnlyOst(rhsAe->GetOriginalSt()))) {
     return;
   }
@@ -204,7 +204,7 @@ void AliasClass::ApplyUnionForCopies(StmtNode &stmt) {
       ASSERT(stmt.Opnd(0) != nullptr, "nullptr check");
       AliasElem *rhsAe = CreateAliasElemsExpr(*stmt.Opnd(0));
       // LHS
-      OriginalSt *ost = ssaTab.GetStmtsSSAPart().SSAPartOf(stmt)->GetSSAVar()->GetOrigSt();
+      OriginalSt *ost = ssaTab.GetStmtsSSAPart().GetAssignedVarOf(stmt)->GetOrigSt();
       AliasElem *lhsAe = FindOrCreateAliasElem(*ost);
       ASSERT(lhsAe != nullptr, "aliaselem of lhs should not be null");
       ApplyUnionForDassignCopy(*lhsAe, rhsAe, *stmt.Opnd(0));
@@ -660,7 +660,7 @@ void AliasClass::InsertMayUseReturn(const StmtNode &stmt) {
   CollectMayUseFromNADS(mayUseOsts);
   // 2. collect mayUses caused by globals_affected_by_call.
   CollectMayUseFromGlobalsAffectedByCalls(mayUseOsts);
-  MapleMap<OStIdx, MayUseNode> &mayUseNodes = SSAGenericGetMayUseNode(stmt, ssaTab.GetStmtsSSAPart());
+  MapleMap<OStIdx, MayUseNode> &mayUseNodes = ssaTab.GetStmtsSSAPart().GetMayUseNodesOf(stmt);
   InsertMayUseNode(mayUseOsts, mayUseNodes);
 }
 
@@ -697,14 +697,14 @@ void AliasClass::InsertReturnOpndMayUse(const StmtNode &stmt) {
         }
       }
       // insert mayUses
-      MapleMap<OStIdx, MayUseNode> &mayUseNodes = SSAGenericGetMayUseNode(stmt, ssaTab.GetStmtsSSAPart());
+      MapleMap<OStIdx, MayUseNode> &mayUseNodes = ssaTab.GetStmtsSSAPart().GetMayUseNodesOf(stmt);
       InsertMayUseNode(mayUseOsts, mayUseNodes);
     }
   }
 }
 
 void AliasClass::InsertMayUseAll(const StmtNode &stmt) {
-  MapleMap<OStIdx, MayUseNode> &mayUseNodes = SSAGenericGetMayUseNode(stmt, ssaTab.GetStmtsSSAPart());
+  MapleMap<OStIdx, MayUseNode> &mayUseNodes = ssaTab.GetStmtsSSAPart().GetMayUseNodesOf(stmt);
   for (AliasElem *ae : id2Elem) {
     if (ae->GetOriginalSt().GetIndirectLev() >= 0 && !ae->GetOriginalSt().IsPregOst()) {
       mayUseNodes.insert(std::make_pair(
@@ -715,9 +715,7 @@ void AliasClass::InsertMayUseAll(const StmtNode &stmt) {
 }
 
 void AliasClass::CollectMayDefForDassign(const StmtNode &stmt, std::set<OriginalSt*> &mayDefOsts) {
-  MayDefPartWithVersionSt *theSSAPart =
-      static_cast<MayDefPartWithVersionSt*>(ssaTab.GetStmtsSSAPart().SSAPartOf(stmt));
-  AliasElem *lhsAe = osym2Elem.at(theSSAPart->GetSSAVar()->GetOrigIdx().idx);
+  AliasElem *lhsAe = osym2Elem.at(ssaTab.GetStmtsSSAPart().GetAssignedVarOf(stmt)->GetOrigIdx().idx);
   ASSERT(lhsAe != nullptr, "aliaselem of lhs should not be null");
   if (lhsAe->GetClassSet() != nullptr) {
     for (unsigned int elemID : *(lhsAe->GetClassSet())) {
@@ -743,7 +741,7 @@ void AliasClass::InsertMayDefNode(std::set<OriginalSt*> &mayDefOsts, MapleMap<OS
 void AliasClass::InsertMayDefDassign(StmtNode &stmt, BBId bbID) {
   std::set<OriginalSt*> mayDefOsts;
   CollectMayDefForDassign(stmt, mayDefOsts);
-  MapleMap<OStIdx, MayDefNode> &mayDefNodes = SSAGenericGetMayDefNodes(stmt, ssaTab.GetStmtsSSAPart());
+  MapleMap<OStIdx, MayDefNode> &mayDefNodes = ssaTab.GetStmtsSSAPart().GetMayDefNodesOf(stmt);
   InsertMayDefNode(mayDefOsts, mayDefNodes, stmt, bbID);
 }
 
@@ -806,7 +804,7 @@ void AliasClass::InsertMayDefNodeExcludeFinalOst(std::set<OriginalSt*> &mayDefOs
 void AliasClass::InsertMayDefIassign(StmtNode &stmt, BBId bbID) {
   std::set<OriginalSt*> mayDefOsts;
   CollectMayDefForIassign(stmt, mayDefOsts);
-  MapleMap<OStIdx, MayDefNode> &mayDefNodes = SSAGenericGetMayDefNodes(stmt, ssaTab.GetStmtsSSAPart());
+  MapleMap<OStIdx, MayDefNode> &mayDefNodes = ssaTab.GetStmtsSSAPart().GetMayDefNodesOf(stmt);
   if (mayDefOsts.size() == 1) {
     InsertMayDefNode(mayDefOsts, mayDefNodes, stmt, bbID);
   } else {
@@ -859,7 +857,7 @@ void AliasClass::InsertMayDefUseSyncOps(StmtNode &stmt, BBId bbID) {
 
 // collect mayDefs caused by mustDefs
 void AliasClass::CollectMayDefForMustDefs(const StmtNode &stmt, std::set<OriginalSt*> &mayDefOsts) {
-  MapleVector<MustDefNode> &mustDefs = SSAGenericGetMustDefNode(stmt, ssaTab.GetStmtsSSAPart());
+  MapleVector<MustDefNode> &mustDefs = ssaTab.GetStmtsSSAPart().GetMustDefNodesOf(stmt);
   for (MustDefNode mustDef : mustDefs) {
     VersionSt *vst = mustDef.GetResult();
     OriginalSt *ost = vst->GetOrigSt();
@@ -991,14 +989,14 @@ void AliasClass::InsertMayDefUseIntrncall(StmtNode &stmt, BBId bbID) {
 }
 
 void AliasClass::InsertMayDefUseClinitCheck(IntrinsiccallNode &stmt, BBId bbID) {
-  MayDefMayUsePart *theSSAPart = static_cast<MayDefMayUsePart*>(ssaTab.GetStmtsSSAPart().SSAPartOf(stmt));
+  MapleMap<OStIdx, MayDefNode> &mayDefNodes = ssaTab.GetStmtsSSAPart().GetMayDefNodesOf(stmt);
   for (OStIdx ostIdx : globalsMayAffectedByClinitCheck) {
     AliasElem *ae = osym2Elem[ostIdx.idx];
     OriginalSt &ostOfAE = ae->GetOriginalSt();
     std::string typeNameOfOst = ostOfAE.GetMIRSymbol()->GetName();
     std::string typeNameOfStmt = GlobalTables::GetTypeTable().GetTypeFromTyIdx(stmt.GetTyIdx())->GetName();
     if (typeNameOfOst.find(typeNameOfStmt) != std::string::npos) {
-      theSSAPart->GetMayDefNodes().insert(std::make_pair(
+      mayDefNodes.insert(std::make_pair(
           ostOfAE.GetIndex(),
           MayDefNode(ssaTab.GetVersionStTable().GetVersionStFromID(ostOfAE.GetZeroVersionIndex()), &stmt)));
     }
diff --git a/src/maple_me/src/me_ssa.cpp b/src/maple_me/src/me_ssa.cpp
index c8f932a56e126735e5c763df586fbb211a768a95..99a5124d9a97ad553197f38164f6db11d89c0355 100644
--- a/src/maple_me/src/me_ssa.cpp
+++ b/src/maple_me/src/me_ssa.cpp
@@ -63,8 +63,8 @@ void MeSSA::CollectDefBBs(std::map<OStIdx, std::set<BBId>> &ostDefBBs) {
   for (auto bIt = func->valid_begin(); bIt != eIt; ++bIt) {
     auto *bb = *bIt;
     for (auto &stmt : bb->GetStmtNodes()) {
-      if (HasMayDefPart(stmt)) {
-        MapleMap<OStIdx, MayDefNode> &mayDefs = SSAGenericGetMayDefNodes(stmt, GetSSATab()->GetStmtsSSAPart());
+      if (kOpcodeInfo.HasSSADef(stmt.GetOpCode())) {
+        MapleMap<OStIdx, MayDefNode> &mayDefs = GetSSATab()->GetStmtsSSAPart().GetMayDefNodesOf(stmt);
         MapleMap<OStIdx, MayDefNode>::iterator iter;
         for (iter = mayDefs.begin(); iter != mayDefs.end(); ++iter) {
           const OriginalSt *ost = func->GetMeSSATab()->GetOriginalStFromID(iter->first);
@@ -78,7 +78,7 @@ void MeSSA::CollectDefBBs(std::map<OStIdx, std::set<BBId>> &ostDefBBs) {
           }
         }
         if (stmt.GetOpCode() == OP_dassign || stmt.GetOpCode() == OP_maydassign) {
-          VersionSt *vst = GetSSATab()->GetStmtsSSAPart().SSAPartOf(stmt)->GetSSAVar();
+          VersionSt *vst = GetSSATab()->GetStmtsSSAPart().GetAssignedVarOf(stmt);
           OriginalSt *ost = vst->GetOrigSt();
           if (ost != nullptr && (!ost->IsFinal() || func->GetMirFunc()->IsConstructor())) {
             ostDefBBs[vst->GetOrigIdx()].insert(bb->GetBBId());
@@ -86,7 +86,7 @@ void MeSSA::CollectDefBBs(std::map<OStIdx, std::set<BBId>> &ostDefBBs) {
         }
       }
       if (kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) {  // Needs to handle mustDef in callassigned stmt
-        MapleVector<MustDefNode> &mustDefs = SSAGenericGetMustDefNode(stmt, GetSSATab()->GetStmtsSSAPart());
+        MapleVector<MustDefNode> &mustDefs = GetSSATab()->GetStmtsSSAPart().GetMustDefNodesOf(stmt);
         MapleVector<MustDefNode>::iterator iter;
         for (iter = mustDefs.begin(); iter != mustDefs.end(); ++iter) {
           OriginalSt *ost = iter->GetResult()->GetOrigSt();
@@ -208,7 +208,7 @@ bool MeSSA::VerifySSA() const {
     for (auto &stmt : bb->GetStmtNodes()) {
       opcode = stmt.GetOpCode();
       if (opcode == OP_dassign || opcode == OP_regassign) {
-        VersionSt *verSt = func->GetMeSSATab()->GetStmtsSSAPart().SSAPartOf(stmt)->GetSSAVar();
+        VersionSt *verSt = func->GetMeSSATab()->GetStmtsSSAPart().GetAssignedVarOf(stmt);
         CHECK_FATAL(verSt != nullptr && verSt->GetIndex() < vtableSize, "runtime check error");
       }
       for (size_t i = 0; i < stmt.NumOpnds(); i++) {
diff --git a/src/maple_me/src/ssa.cpp b/src/maple_me/src/ssa.cpp
index dcc4214b1a8bb4e0967e848911a35f151f14bda1..470d013347d40ae8180ff2182c8ee8baf8191f15 100644
--- a/src/maple_me/src/ssa.cpp
+++ b/src/maple_me/src/ssa.cpp
@@ -80,8 +80,8 @@ void SSA::RenameDefs(StmtNode &stmt, BB &defBB) {
     newVersionSym->SetDassignNode(static_cast<DassignNode*>(&stmt));
     theSSAPart->SetSSAVar(*newVersionSym);
   }
-  if (HasMayDefPart(stmt)) {
-    MapleMap<OStIdx, MayDefNode> &mayDefList = SSAGenericGetMayDefNodes(stmt, ssaTab->GetStmtsSSAPart());
+  if (kOpcodeInfo.HasSSADef(stmt.GetOpCode())) {
+    MapleMap<OStIdx, MayDefNode> &mayDefList = ssaTab->GetStmtsSSAPart().GetMayDefNodesOf(stmt);
     for (auto it = mayDefList.begin(); it != mayDefList.end(); it++) {
       MayDefNode &mayDef = it->second;
       VersionSt *vsym = mayDef.GetResult();
@@ -98,7 +98,7 @@ void SSA::RenameDefs(StmtNode &stmt, BB &defBB) {
 void SSA::RenameMustDefs(const StmtNode &stmt, BB &defBB) {
   Opcode opcode = stmt.GetOpCode();
   if (kOpcodeInfo.IsCallAssigned(opcode)) {
-    MapleVector<MustDefNode> &mustDefs = SSAGenericGetMustDefNode(stmt, ssaTab->GetStmtsSSAPart());
+    MapleVector<MustDefNode> &mustDefs = ssaTab->GetStmtsSSAPart().GetMustDefNodesOf(stmt);
     for (MustDefNode &mustDefNode : mustDefs) {
       VersionSt *newVersionSym = CreateNewVersion(*mustDefNode.GetResult(), defBB);
       mustDefNode.SetResult(newVersionSym);
@@ -117,8 +117,7 @@ void SSA::RenameMayUses(BaseNode &node) {
     iread.SetSSAVar(vstStacks[vsym->GetOrigIdx().idx]->top());
     return;
   }
-  MapleMap<OStIdx, MayUseNode> &mayUseList =
-      SSAGenericGetMayUseNode(static_cast<StmtNode&>(node), ssaTab->GetStmtsSSAPart());
+  MapleMap<OStIdx, MayUseNode> &mayUseList = ssaTab->GetStmtsSSAPart().GetMayUseNodesOf(static_cast<StmtNode&>(node));
   MapleMap<OStIdx, MayUseNode>::iterator it = mayUseList.begin();
   for (; it != mayUseList.end(); it++) {
     MayUseNode &mayuse = it->second;
@@ -137,25 +136,20 @@ void SSA::RenameExpr(BaseNode &expr) {
     return;
   } else if (expr.GetOpCode() == OP_regread) {
     RegreadSSANode &regNode = static_cast<RegreadSSANode&>(expr);
-    if (regNode.GetRegIdx() < 0) {
-      return;
-    }
     VersionSt *vsym = regNode.GetSSAVar();
     ASSERT(vsym->GetOrigIdx().idx < vstStacks.size(), "index out of range in SSA::RenameExpr");
     regNode.SetSSAVar(vstStacks[vsym->GetOrigIdx().idx]->top());
     return;
   } else if (expr.GetOpCode() == OP_iread) {
     RenameMayUses(expr);
-    RenameExpr(*expr.Opnd(0));
-  } else {
-    for (size_t i = 0; i < expr.NumOpnds(); i++) {
-      RenameExpr(*expr.Opnd(i));
-    }
+  }
+  for (size_t i = 0; i < expr.NumOpnds(); i++) {
+    RenameExpr(*expr.Opnd(i));
   }
 }
 
 void SSA::RenameUses(StmtNode &stmt) {
-  if (HasMayUsePart(stmt)) {
+  if (kOpcodeInfo.HasSSAUse(stmt.GetOpCode())) {
     RenameMayUses(stmt);
   }
   for (int i = 0; i < stmt.NumOpnds(); i++) {
diff --git a/src/maple_me/src/ssa_mir_nodes.cpp b/src/maple_me/src/ssa_mir_nodes.cpp
index d9942b00f1707193d1e83bff0e3d3c8a1350eb95..132c0573086d2533b32c4e6d7a0b358cf821706a 100644
--- a/src/maple_me/src/ssa_mir_nodes.cpp
+++ b/src/maple_me/src/ssa_mir_nodes.cpp
@@ -19,22 +19,6 @@
 #include "ssa_tab.h"
 
 namespace maple {
-bool HasMayUseDefPart(const StmtNode &stmtNode) {
-  Opcode op = stmtNode.GetOpCode();
-  return kOpcodeInfo.IsCall(op) || op == OP_syncenter || op == OP_syncexit;
-}
-
-bool HasMayDefPart(const StmtNode &stmtNode) {
-  Opcode op = stmtNode.GetOpCode();
-  return op == OP_iassign || op == OP_dassign || op == OP_maydassign || HasMayUseDefPart(stmtNode);
-}
-
-bool HasMayUsePart(const StmtNode &stmtNode) {
-  Opcode op = stmtNode.GetOpCode();
-  return op == OP_iread || op == OP_throw || op == OP_gosub || op == OP_retsub || op == OP_return ||
-         HasMayUseDefPart(stmtNode);
-}
-
 void GenericSSAPrint(MIRModule &mod, const StmtNode &stmtNode, int32 indent, StmtsSSAPart &stmtsSSAPart) {
   stmtNode.Dump(mod, indent);
   // print SSAPart
@@ -69,7 +53,7 @@ void GenericSSAPrint(MIRModule &mod, const StmtNode &stmtNode, int32 indent, Stm
         ssaPart->DumpMayUseNodes(mod);
         ssaPart->DumpMustDefNodes(mod);
         ssaPart->DumpMayDefNodes(mod);
-      } else if (HasMayUseDefPart(stmtNode)) {
+      } else if (kOpcodeInfo.HasSSADef(op) && kOpcodeInfo.HasSSAUse(op)) {
         ssaPart->DumpMayUseNodes(mod);
         mod.GetOut() << '\n';
         ssaPart->DumpMayDefNodes(mod);
@@ -79,24 +63,6 @@ void GenericSSAPrint(MIRModule &mod, const StmtNode &stmtNode, int32 indent, Stm
   }
 }
 
-void SSAGenericInsertMayUseNode(const StmtNode &stmtNode, VersionSt &mayUse, StmtsSSAPart &stmtsSSAPart) {
-  MapleMap<OStIdx, MayUseNode> &mayUseNodes = SSAGenericGetMayUseNode(stmtNode, stmtsSSAPart);
-  mayUseNodes.insert(std::make_pair(mayUse.GetOrigSt()->GetIndex(), MayUseNode(&mayUse)));
-}
-
-MapleMap<OStIdx, MayUseNode> &SSAGenericGetMayUseNode(const StmtNode &stmtNode, StmtsSSAPart &stmtsSSAPart) {
-  return stmtsSSAPart.SSAPartOf(stmtNode)->GetMayUseNodes();
-}
-
-void SSAGenericInsertMayDefNode(const StmtNode &stmtNode, VersionSt &vst, StmtNode &s, StmtsSSAPart &stmtsSSAPart) {
-  MapleMap<OStIdx, MayDefNode> &mayDefNodes = SSAGenericGetMayDefNodes(stmtNode, stmtsSSAPart);
-  mayDefNodes.insert(std::make_pair(vst.GetOrigSt()->GetIndex(), MayDefNode(&vst, &s)));
-}
-
-MapleMap<OStIdx, MayDefNode> &SSAGenericGetMayDefNodes(const StmtNode &stmtNode, StmtsSSAPart &stmtsSSAPart) {
-  return stmtsSSAPart.SSAPartOf(stmtNode)->GetMayDefNodes();
-}
-
 static MapleMap<OStIdx, MayDefNode> *SSAGenericGetMayDefsFromVersionSt(VersionSt &vst, StmtsSSAPart &stmtsSSAPart,
                                                                        std::unordered_set<VersionSt*> &visited) {
   if (vst.IsInitVersion() || visited.find(&vst) != visited.end()) {
@@ -114,7 +80,7 @@ static MapleMap<OStIdx, MayDefNode> *SSAGenericGetMayDefsFromVersionSt(VersionSt
     }
   } else if (vst.GetDefType() == VersionSt::kMayDef) {
     MayDefNode *maydef = vst.GetMayDef();
-    return &SSAGenericGetMayDefNodes(*maydef->GetStmt(), stmtsSSAPart);
+    return &stmtsSSAPart.GetMayDefNodesOf(*maydef->GetStmt());
   }
   return nullptr;
 }
@@ -124,14 +90,10 @@ MapleMap<OStIdx, MayDefNode> *SSAGenericGetMayDefsFromVersionSt(VersionSt &sym,
   return SSAGenericGetMayDefsFromVersionSt(sym, stmtsSSAPart, visited);
 }
 
-MapleVector<MustDefNode> &SSAGenericGetMustDefNode(const StmtNode &stmtNode, StmtsSSAPart &stmtsSSAPart) {
-  return stmtsSSAPart.SSAPartOf(stmtNode)->GetMustDefNodes();
-}
-
 bool HasMayUseOpnd(const BaseNode &baseNode, SSATab &func) {
   const StmtNode &stmtNode = static_cast<const StmtNode&>(baseNode);
-  if (HasMayUsePart(stmtNode)) {
-    MapleMap<OStIdx, MayUseNode> &mayUses = SSAGenericGetMayUseNode(stmtNode, func.GetStmtsSSAPart());
+  if (kOpcodeInfo.HasSSAUse(stmtNode.GetOpCode())) {
+    MapleMap<OStIdx, MayUseNode> &mayUses = func.GetStmtsSSAPart().GetMayUseNodesOf(stmtNode);
     if (!mayUses.empty()) {
       return true;
     }
@@ -143,14 +105,4 @@ bool HasMayUseOpnd(const BaseNode &baseNode, SSATab &func) {
   }
   return false;
 }
-
-bool HasMayDef(const StmtNode &stmtNode, SSATab &func) {
-  if (HasMayDefPart(stmtNode)) {
-    MapleMap<OStIdx, MayDefNode> &mayDefs = SSAGenericGetMayDefNodes(stmtNode, func.GetStmtsSSAPart());
-    if (!mayDefs.empty()) {
-      return true;
-    }
-  }
-  return false;
-}
 }  // namespace maple
diff --git a/src/mempool/include/mempool.h b/src/mempool/include/mempool.h
index 82f32a8862e6cbddd5c37590562f746526cbe8ac..dac5ace2277590a8fe53db957813b17e74beede3 100644
--- a/src/mempool/include/mempool.h
+++ b/src/mempool/include/mempool.h
@@ -33,7 +33,7 @@ constexpr bool TRUE = true;
 #endif
 
 // Class declaration
-class MemPool;
+class MemPool;  // circular dependency exists, no other choice
 // Memory Pool controller class
 class MemPoolCtrler {
   friend MemPool;
diff --git a/src/mempool/include/mempool_allocator.h b/src/mempool/include/mempool_allocator.h
index 419c7d32e4d197527fb7e7c9fa4f41d64e122dda..cabf7e15e7b404d00679c12f7d561da7eda185d5 100644
--- a/src/mempool/include/mempool_allocator.h
+++ b/src/mempool/include/mempool_allocator.h
@@ -28,7 +28,7 @@
 
 namespace maple {
 template <typename T>
-class MapleAllocatorAdapter;
+class MapleAllocatorAdapter;  // circular dependency exists, no other choice
 class MapleAllocator {
  public:
   explicit MapleAllocator(MemPool *m) : memPool(m) {}
@@ -56,7 +56,7 @@ class MapleAllocator {
 };  // MapleAllocator
 
 template <typename T>
-class MapleAllocatorAdapter;
+class MapleAllocatorAdapter;  // circular dependency exists, no other choice
 template <typename T>
 using MapleQueue = std::deque<T, MapleAllocatorAdapter<T>>;
 template <typename T>
diff --git a/src/mpl2mpl/include/class_hierarchy.h b/src/mpl2mpl/include/class_hierarchy.h
index 6f45868f5bd62b091b903402520adb91fb3ed540..8c347f0b041a08cc3f7160b0ddbcde6c5b42e943 100644
--- a/src/mpl2mpl/include/class_hierarchy.h
+++ b/src/mpl2mpl/include/class_hierarchy.h
@@ -18,7 +18,7 @@
 #include "module_phase.h"
 
 namespace maple {
-class KlassHierarchy;
+class KlassHierarchy;  // circular dependency exists, no other choice
 // should be consistent with runtime
 static constexpr uint32 kClassPrim = 0x0001;
 static constexpr uint32 kClassArray = 0x0002;
diff --git a/src/mpl2mpl/src/reflection_analysis.cpp b/src/mpl2mpl/src/reflection_analysis.cpp
index e38b6d9e3e29dfb1aebcdbc1def6b95c38b39113..4f9c8dccc22badaba5c361c8b93b9fad9169050c 100644
--- a/src/mpl2mpl/src/reflection_analysis.cpp
+++ b/src/mpl2mpl/src/reflection_analysis.cpp
@@ -43,7 +43,6 @@ std::string ReflectionAnalysis::strTabStartHot = std::string(1, '\0');
 std::string ReflectionAnalysis::strTabBothHot = std::string(1, '\0');
 std::string ReflectionAnalysis::strTabRunHot = std::string(1, '\0');
 bool ReflectionAnalysis::strTabInited = false;
-
 int ReflectionAnalysis::GetDeflateStringIdx(const std::string &subStr) {
   return FindOrInsertReflectString("0!" + subStr);
 }