diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl
index 738f1e6dda59c390ef23eefcc092af2b82af794b..5a3ad1d9cfe829a035b09703a36bf29d8f485876 100755
Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ
diff --git a/src/bin/maple b/src/bin/maple
index aa6fcd3a8a2540a79b634399a2c1922c74a648c2..87516866c76d802dad61307c33ff3ba789ca9297 100755
Binary files a/src/bin/maple and b/src/bin/maple differ
diff --git a/src/bin/mplcg b/src/bin/mplcg
index ea02b38f0bef7d55b145b979c8c012c80b400cd6..e3d4fb10670f6f6a9de533ca095c692d4e405bb8 100755
Binary files a/src/bin/mplcg and b/src/bin/mplcg differ
diff --git a/src/maple_driver/include/compiler.h b/src/maple_driver/include/compiler.h
index 313827e2a0e4e3b0e264272189ac6fff86b6ff4d..312ff96038680e6705b5736b7b42c61200c98359 100644
--- a/src/maple_driver/include/compiler.h
+++ b/src/maple_driver/include/compiler.h
@@ -53,11 +53,11 @@ class Compiler {
   }
 
   virtual std::string GetInputFileName(const MplOptions &options) const {
-    std::ostringstream ss;
-    for (auto const &inputFile : options.GetSplitsInputFiles()) {
-      ss << " " << inputFile;
+    std::ostringstream stream;
+    for (const auto &inputFile : options.GetSplitsInputFiles()) {
+      stream << " " << inputFile;
     }
-    return ss.str();
+    return stream.str();
   }
 
   virtual DefaultOption GetDefaultOptions(const MplOptions &options) {
@@ -74,7 +74,7 @@ class Compiler {
     return std::vector<std::string>();
   }
 
-  const bool CanAppendOptimization(const std::string &optionStr) const;
+  bool CanAppendOptimization(const std::string &optionStr) const;
 
  private:
   const std::string name;
@@ -121,8 +121,8 @@ class MapleCombCompiler : public Compiler {
  private:
   std::string realRunningExe;
   std::unordered_set<std::string> GetFinalOutputs(const MplOptions &mplOptions) const override;
-  MeOption *MakeMeOptions(const MplOptions &options, MemPool &optmp);
-  Options *MakeMpl2MplOptions(const MplOptions &options, MemPool &optmp);
+  MeOption *MakeMeOptions(const MplOptions &options, MemPool &memPool);
+  Options *MakeMpl2MplOptions(const MplOptions &options, MemPool &memPool);
 };
 
 class MplcgCompiler : public Compiler {
diff --git a/src/maple_driver/include/usages.h b/src/maple_driver/include/usages.h
index dc72a0e4fde6e3318e19b8dd9572e38d0315df4c..a00ad36e4910abe54fe611e7b5e37d1ac597421d 100644
--- a/src/maple_driver/include/usages.h
+++ b/src/maple_driver/include/usages.h
@@ -79,6 +79,9 @@ enum OptionIndex : uint64 {
   kCGMapleLinker,
 };
 
-enum EnabledIndex { kDisable, kEnable };
+enum EnabledIndex {
+  kDisable,
+  kEnable
+};
 }  // namespace maple
 #endif  // MAPLE_DRIVER_INCLUDE_USAGES_H
diff --git a/src/maple_driver/src/compiler.cpp b/src/maple_driver/src/compiler.cpp
index 0b40e0042f8886d66f63dad385cf72d4d2b01e76..0144cea02d04cffde032b40368c1e9ac483b45c5 100644
--- a/src/maple_driver/src/compiler.cpp
+++ b/src/maple_driver/src/compiler.cpp
@@ -68,7 +68,7 @@ std::string Compiler::MakeOption(const MplOptions &options) {
   std::map<std::string, MplOption> finalOptions;
   auto defaultOptions = MakeDefaultOptions(options);
   AppendDefaultOptions(finalOptions, defaultOptions);
-  for (auto binName : GetBinNames()) {
+  for (const auto &binName : GetBinNames()) {
     auto userOption = options.GetOptions().find(binName);
     if (userOption != options.GetOptions().end()) {
       AppendUserOptions(finalOptions, userOption->second);
@@ -76,7 +76,7 @@ std::string Compiler::MakeOption(const MplOptions &options) {
   }
   AppendExtraOptions(finalOptions, options.GetExtras());
   std::ostringstream strOption;
-  for (auto finalOption : finalOptions) {
+  for (const auto &finalOption : finalOptions) {
     strOption << " " << finalOption.first << finalOption.second.GetconnectSymbol() << finalOption.second.GetValue();
     if (options.HasSetDebugFlag()) {
       LogInfo::MapleLogger() << Compiler::GetName() << " options: " << finalOption.first << " "
@@ -92,15 +92,15 @@ std::string Compiler::MakeOption(const MplOptions &options) {
 
 void Compiler::AppendDefaultOptions(std::map<std::string, MplOption> &finalOptions,
                                     const std::map<std::string, MplOption> &defaultOptions) const {
-  for (auto defaultIt : defaultOptions) {
+  for (const auto &defaultIt : defaultOptions) {
     finalOptions.insert(make_pair(defaultIt.first, defaultIt.second));
   }
 }
 
 void Compiler::AppendUserOptions(std::map<std::string, MplOption> &finalOptions,
                                  const std::vector<Option> &userOptions) const {
-  for (auto &binName : GetBinNames()) {
-    for (auto userOption : userOptions) {
+  for (const auto &binName : GetBinNames()) {
+    for (const auto &userOption : userOptions) {
       auto extra = userOption.FindExtra(binName);
       if (extra != nullptr) {
         AppendOptions(finalOptions, extra->optionKey, userOption.Args(), userOption.ConnectSymbol(binName));
@@ -112,12 +112,12 @@ void Compiler::AppendUserOptions(std::map<std::string, MplOption> &finalOptions,
 void Compiler::AppendExtraOptions(std::map<std::string, MplOption> &finalOptions,
                                   const std::map<std::string, std::vector<MplOption>> &extraOptions) const {
   auto binNames = GetBinNames();
-  for (auto &binNamesIt : binNames) {
+  for (const auto &binNamesIt : binNames) {
     auto extras = extraOptions.find(binNamesIt);
     if (extras == extraOptions.end()) {
       continue;
     }
-    for (auto &secondExtras : extras->second) {
+    for (const auto &secondExtras : extras->second) {
       AppendOptions(finalOptions, secondExtras.GetKey(), secondExtras.GetValue(), secondExtras.GetconnectSymbol());
     }
   }
@@ -127,7 +127,7 @@ std::map<std::string, MplOption> Compiler::MakeDefaultOptions(const MplOptions &
   auto rawDefaultOptions = GetDefaultOptions(options);
   std::map<std::string, MplOption> defaultOptions;
   if (rawDefaultOptions.mplOptions != nullptr) {
-    for (unsigned int i = 0; i < rawDefaultOptions.length; i++) {
+    for (unsigned int i = 0; i < rawDefaultOptions.length; ++i) {
       defaultOptions.insert(std::make_pair(rawDefaultOptions.mplOptions[i].GetKey(), rawDefaultOptions.mplOptions[i]));
     }
   }
@@ -150,7 +150,7 @@ void Compiler::AppendOptions(std::map<std::string, MplOption> &finalOptions, con
   }
 }
 
-const bool Compiler::CanAppendOptimization(const std::string &optionStr) const {
+bool Compiler::CanAppendOptimization(const std::string &optionStr) const {
   // there're some issues for passing -Ox to each component, let users determine self.
   return false;
 }
diff --git a/src/maple_driver/src/maple_comb_compiler.cpp b/src/maple_driver/src/maple_comb_compiler.cpp
index 283cf175795697cd00a5b8f51494b08c3bd5b8d5..d9a28748a04d23aa40b44180d1e701758e50a946 100644
--- a/src/maple_driver/src/maple_comb_compiler.cpp
+++ b/src/maple_driver/src/maple_comb_compiler.cpp
@@ -46,7 +46,7 @@ void MapleCombCompiler::PrintCommand(const MplOptions &options) const {
   if (options.GetExeOptions().find(kBinNameMe) != options.GetExeOptions().end()) {
     runStr += "me";
     auto inputMeOptions = options.GetExeOptions().find(kBinNameMe);
-    for (auto &opt : inputMeOptions->second) {
+    for (const auto &opt : inputMeOptions->second) {
       connectSym = opt.Args() != "" ? "=" : "";
       optionStr += " --" + opt.OptionKey() + connectSym + opt.Args();
     }
@@ -60,7 +60,7 @@ void MapleCombCompiler::PrintCommand(const MplOptions &options) const {
       runStr += "mpl2mpl";
     }
     auto inputMpl2mplOptions = options.GetExeOptions().find(kBinNameMpl2mpl);
-    for (auto &opt : inputMpl2mplOptions->second) {
+    for (const auto &opt : inputMpl2mplOptions->second) {
       connectSym = opt.Args() != "" ? "=" : "";
       optionStr += " --" + opt.OptionKey() + connectSym + opt.Args();
     }
@@ -77,7 +77,7 @@ MeOption *MapleCombCompiler::MakeMeOptions(const MplOptions &options, maple::Mem
     LogInfo::MapleLogger() << "no me input options" << '\n';
     return meOption;
   }
-  for (auto &opt : inputMeOptions->second) {
+  for (const auto &opt : inputMeOptions->second) {
     if (options.HasSetDebugFlag()) {
       LogInfo::MapleLogger() << "Me options: " << opt.Index() << " " << opt.OptionKey() << " " << opt.Args()
                              << '\n';
diff --git a/src/maple_driver/src/mplcg_compiler.cpp b/src/maple_driver/src/mplcg_compiler.cpp
index cf91afc60ebff09c48e2862f0872accda4586073..f2fff89df72b7f7394bd6298013e2b0bcdffee44 100644
--- a/src/maple_driver/src/mplcg_compiler.cpp
+++ b/src/maple_driver/src/mplcg_compiler.cpp
@@ -16,7 +16,6 @@
 #include "compiler.h"
 #include "default_options.def"
 
-
 using namespace maple;
 
 DefaultOption MplcgCompiler::GetDefaultOptions(const MplOptions &options) {
diff --git a/src/maple_ipa/include/interleaved_manager.h b/src/maple_ipa/include/interleaved_manager.h
index 5797e3b9b7424daf781e633bbd6e0c9a46911e90..ae7e3d4bef96329658b84cb63822d435cbc8f633 100644
--- a/src/maple_ipa/include/interleaved_manager.h
+++ b/src/maple_ipa/include/interleaved_manager.h
@@ -20,17 +20,17 @@
 namespace maple {
 class InterleavedManager {
  public:
-  InterleavedManager(MemPool *memPool, MIRModule *mirm, std::string input, bool timer)
+  InterleavedManager(MemPool *memPool, MIRModule *module, const std::string &input, bool timer)
       : allocator(memPool),
-        mirModule(*mirm),
+        mirModule(*module),
         phaseManagers(allocator.Adapter()),
         supportPhaseManagers(allocator.Adapter()),
         meInput(input),
         timePasses(timer) {}
 
-  InterleavedManager(MemPool *memPool, MIRModule *mirm)
+  InterleavedManager(MemPool *memPool, MIRModule *module)
       : allocator(memPool),
-        mirModule(*mirm),
+        mirModule(*module),
         phaseManagers(allocator.Adapter()),
         supportPhaseManagers(allocator.Adapter()),
         timePasses(false) {}
@@ -42,7 +42,7 @@ class InterleavedManager {
     }
   }
 
-  const MapleAllocator *GetMemAllocator() {
+  const MapleAllocator *GetMemAllocator() const {
     return &allocator;
   }
 
@@ -56,7 +56,7 @@ class InterleavedManager {
   void Run();
   void IPARun(MeFuncPhaseManager&);
 
-  PhaseManager *AccessPhaseManager(int i) const {
+  const PhaseManager *AccessPhaseManager(int i) const {
     return phaseManagers.at(i);
   }
 
diff --git a/src/maple_ipa/include/module_phase_manager.h b/src/maple_ipa/include/module_phase_manager.h
index 6a96573638c9d607e3f83bca2fba6faa52c954ec..7568fab44e93194ba06e5d07c4fe2b149d0350a9 100644
--- a/src/maple_ipa/include/module_phase_manager.h
+++ b/src/maple_ipa/include/module_phase_manager.h
@@ -42,7 +42,6 @@ class ModulePhaseManager : public PhaseManager {
     } else {
       arModuleMgr = memPool->New<ModuleResultMgr>(GetMemAllocator());
     }
-    timePhases = false;
   }
 
   ~ModulePhaseManager() = default;
@@ -64,7 +63,7 @@ class ModulePhaseManager : public PhaseManager {
   void Emit(const std::string &passName);
 
  private:
-  bool timePhases;
+  bool timePhases = false;
   MIRModule &mirModule;
   ModuleResultMgr *arModuleMgr; // module level analysis result
 };
diff --git a/src/maple_ipa/src/interleaved_manager.cpp b/src/maple_ipa/src/interleaved_manager.cpp
index 0259296aee57ec1968e368813b9a985ffffd06ce..6821e05ca789daa5deaf7dc5d9f98ffd02feb799 100644
--- a/src/maple_ipa/src/interleaved_manager.cpp
+++ b/src/maple_ipa/src/interleaved_manager.cpp
@@ -23,8 +23,7 @@
 #include "mempool.h"
 #include "phase_manager.h"
 
-using namespace maple;
-
+namespace maple {
 
 void InterleavedManager::AddPhases(const std::vector<std::string> &phases, bool isModulePhase, bool timePhases,
                                    bool genMpl) {
@@ -63,42 +62,42 @@ void InterleavedManager::Run() {
     if (pm == nullptr) {
       continue;
     }
-    if (dynamic_cast<MeFuncPhaseManager*>(pm)) {
-      MeFuncPhaseManager *fpm = static_cast<MeFuncPhaseManager*>(pm);
-      unsigned long rangeNum = 0;
-      MapleVector<MIRFunction*> *compList;
-      if (!mirModule.GetCompilationList().empty()) {
-        if ((mirModule.GetCompilationList().size() != mirModule.GetFunctionList().size() &&
-             mirModule.GetCompilationList().size() !=
-                 mirModule.GetFunctionList().size() - mirModule.GetOptFuncsSize())) {
-          ASSERT(false, "should be equal");
-        }
-        compList = &mirModule.GetCompilationList();
-      } else {
-        compList = &mirModule.GetFunctionList();
+    if (!dynamic_cast<MeFuncPhaseManager*>(pm)) {
+      pm->Run();
+      continue;
+    }
+    MeFuncPhaseManager *fpm = static_cast<MeFuncPhaseManager*>(pm);
+    unsigned long rangeNum = 0;
+    MapleVector<MIRFunction*> *compList;
+    if (!mirModule.GetCompilationList().empty()) {
+      if ((mirModule.GetCompilationList().size() != mirModule.GetFunctionList().size()) &&
+          (mirModule.GetCompilationList().size() !=
+           mirModule.GetFunctionList().size() - mirModule.GetOptFuncsSize())) {
+        ASSERT(false, "should be equal");
+      }
+      compList = &mirModule.GetCompilationList();
+    } else {
+      compList = &mirModule.GetFunctionList();
+    }
+    for (auto *func : *compList) {
+      if (MeOption::useRange && (rangeNum < MeOption::range[0] || rangeNum > MeOption::range[1])) {
+        ++rangeNum;
+        continue;
       }
-      for (auto *func : *compList) {
-        if (MeOption::useRange && (rangeNum < MeOption::range[0] || rangeNum > MeOption::range[1])) {
-          ++rangeNum;
-          continue;
-        }
-        if (func->GetBody() == nullptr) {
-          ++rangeNum;
-          continue;
-        }
-        if (fpm->GetPhaseSequence()->empty()) {
-          continue;
-        }
-        mirModule.SetCurFunction(func);
-        // lower, create BB and build cfg
-        fpm->Run(func, rangeNum, meInput);
+      if (func->GetBody() == nullptr) {
         ++rangeNum;
+        continue;
       }
-      if (fpm->GetGenMeMpl()) {
-        mirModule.Emit("comb.me.mpl");
+      if (fpm->GetPhaseSequence()->empty()) {
+        continue;
       }
-    } else {
-      pm->Run();
+      mirModule.SetCurFunction(func);
+      // lower, create BB and build cfg
+      fpm->Run(func, rangeNum, meInput);
+      ++rangeNum;
+    }
+    if (fpm->GetGenMeMpl()) {
+      mirModule.Emit("comb.me.mpl");
     }
   }
 }
@@ -108,7 +107,7 @@ void InterleavedManager::DumpTimers() {
   std::vector<std::pair<std::string, time_t>> timeVec;
   long total = 0;
   LogInfo::MapleLogger() << "=================== TIMEPHASES =================\n";
-  for (auto manager : phaseManagers) {
+  for (auto *manager : phaseManagers) {
     long temp = manager->DumpTimers();
     total += temp;
     timeVec.push_back(std::pair<std::string, time_t>(manager->GetMgrName(), temp));
@@ -154,3 +153,4 @@ const PhaseManager *InterleavedManager::GetSupportPhaseManager(const std::string
 
   return nullptr;
 }
+}
diff --git a/src/maple_ir/include/bin_mpl_export.h b/src/maple_ir/include/bin_mpl_export.h
index 24d85cdf1734a062a08313760b15d0cb8ceb0f3b..2513f80c163ca12289bd22b7a8f1ba36a7f8e70a 100644
--- a/src/maple_ir/include/bin_mpl_export.h
+++ b/src/maple_ir/include/bin_mpl_export.h
@@ -120,7 +120,7 @@ class BinaryMplExport {
 
  private:
   MIRModule &mod;
-  size_t bufI;
+  size_t bufI = 0;
   std::vector<uint8> buf;
   std::unordered_map<GStrIdx, int64, GStrIdxHash> gStrMark;
   std::unordered_map<MIRFunction*, int64> funcMark;
diff --git a/src/maple_ir/include/bin_mpl_import.h b/src/maple_ir/include/bin_mpl_import.h
index 876c9de8b91a0e3b10942bacb6412ffbf6de7708..d8fb475b4ad202de06427c01444393bc4bfb1b51 100644
--- a/src/maple_ir/include/bin_mpl_import.h
+++ b/src/maple_ir/include/bin_mpl_import.h
@@ -24,12 +24,9 @@ class BinaryMplImport {
   using CallSite = std::pair<CallInfo*, PUIdx>;
 
  public:
+  explicit BinaryMplImport(MIRModule &md) : mod(md), mirBuilder(&md) {}
   BinaryMplImport &operator=(const BinaryMplImport&) = delete;
   BinaryMplImport(const BinaryMplImport&) = delete;
-  explicit BinaryMplImport(MIRModule &md) : mod(md), mirBuilder(&md) {
-    imported = true;
-    bufI = 0;
-  }
 
   virtual ~BinaryMplImport() {
     for (MIRStructType *structPtr : tmpStruct) {
@@ -46,7 +43,6 @@ class BinaryMplImport {
   uint64 GetBufI() const {
     return bufI;
   }
-
   void SetBufI(uint64 bufIVal) {
     bufI = bufIVal;
   }
@@ -54,7 +50,6 @@ class BinaryMplImport {
   bool IsBufEmpty() const {
     return buf.empty();
   }
-
   size_t GetBufSize() const {
     return buf.size();
   }
@@ -116,10 +111,13 @@ class BinaryMplImport {
   int32 GetIPAFileIndex(std::string &name);
 
  private:
-  uint64 bufI;
+  void SkipTotalSize();
+  void ImportFieldsOfStructType(FieldVector &fields, uint32 methodSize);
+
+  bool imported = true;  // used only by irbuild to convert to ascii
+  uint64 bufI = 0;
   std::vector<uint8> buf;
   std::map<int64, int32> content;
-  bool imported;  // used only by irbuild to convert to ascii
   MIRModule &mod;
   MIRBuilder mirBuilder;
   std::vector<GStrIdx> gStrTab;
@@ -134,9 +132,6 @@ class BinaryMplImport {
   std::map<TyIdx, TyIdx> typeDefIdxMap;  // map previous declared tyIdx
   std::vector<bool> definedLabels;
   std::string importFileName;
-
-  void SkipTotalSize();
-  void ImportFieldsOfStructType(FieldVector &fields, uint32 methodSize);
 };
 }  // namespace maple
 #endif  // MAPLE_IR_INCLUDE_BIN_MPL_IMPORT_H
diff --git a/src/maple_ir/include/metadata_layout.h b/src/maple_ir/include/metadata_layout.h
index 2f697fe05add3cba1b2141167311097a492dbeab..50d776f319778c2ee118166121d5ad2282707901 100644
--- a/src/maple_ir/include/metadata_layout.h
+++ b/src/maple_ir/include/metadata_layout.h
@@ -147,6 +147,7 @@ struct ClassMetadataRO {
 };
 
 static constexpr size_t PageSize = 4096;
+extern "C" uint8_t classInitProtectRegion[];
 
 // Note there is no state to indicate a class is already initialized.
 // Any state beyond listed below is treated as initialized.
diff --git a/src/maple_ir/include/mir_nodes.h b/src/maple_ir/include/mir_nodes.h
index db9a3206fe7438415bba811e6c3ad9fb38659179..0ac46b93bb5224795e0d8d9cd49fb1d94c35095f 100644
--- a/src/maple_ir/include/mir_nodes.h
+++ b/src/maple_ir/include/mir_nodes.h
@@ -101,7 +101,7 @@ class BaseNode {
 
   void Dump(const MIRModule &mod) const {
     Dump(mod, 0);
-    LogInfo::MapleLogger() << std::endl;
+    LogInfo::MapleLogger() << '\n';
   }
 
   virtual uint8 SizeOfInstr() const {
@@ -109,8 +109,8 @@ class BaseNode {
   }
 
   const char *GetOpName() const;
-  bool MayThrowException(void);
-  virtual uint8 NumOpnds(void) const {
+  bool MayThrowException();
+  virtual uint8 NumOpnds() const {
     return numOpnds;
   }
 
@@ -202,33 +202,33 @@ class UnaryNode : public BaseNode {
   virtual ~UnaryNode() = default;
 
   void DumpOpnd(const MIRModule &mod, int32 indent) const;
-  void Dump(const MIRModule &mod, int32 indent) const;
-  bool Verify() const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
+  bool Verify() const override;
 
-  UnaryNode *CloneTree(MapleAllocator &allocator) const {
-    UnaryNode *nd = allocator.GetMemPool()->New<UnaryNode>(*this);
+  UnaryNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *nd = allocator.GetMemPool()->New<UnaryNode>(*this);
     nd->SetOpnd(uOpnd->CloneTree(allocator), 0);
     return nd;
   }
 
-  BaseNode *Opnd(size_t i = 0) const {
+  BaseNode *Opnd(size_t i = 0) const override {
     ASSERT(i == 0, "Invalid operand idx in UnaryNode");
     return uOpnd;
   }
 
-  uint8 NumOpnds() const {
+  uint8 NumOpnds() const override {
     return 1;
   }
 
-  void SetOpnd(BaseNode *node, size_t i = 0) {
+  void SetOpnd(BaseNode *node, size_t i = 0) override {
     uOpnd = node;
   }
 
-  bool IsLeaf() const {
+  bool IsLeaf() const override {
     return false;
   }
 
-  bool IsUnaryNode() const {
+  bool IsUnaryNode() const override {
     return true;
   }
 
@@ -251,12 +251,12 @@ class TypeCvtNode : public UnaryNode {
   bool Verify() const;
 
   TypeCvtNode *CloneTree(MapleAllocator &allocator) const {
-    TypeCvtNode *nd = allocator.GetMemPool()->New<TypeCvtNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<TypeCvtNode>(*this);
     nd->SetOpnd(Opnd(0)->CloneTree(allocator), 0);
     return nd;
   }
 
-  PrimType FromType(void) const {
+  PrimType FromType() const {
     return fromPrimType;
   }
 
@@ -282,7 +282,7 @@ class RetypeNode : public TypeCvtNode {
   void Dump(const MIRModule &mod, int32 indent) const;
 
   RetypeNode *CloneTree(MapleAllocator &allocator) const {
-    RetypeNode *nd = allocator.GetMemPool()->New<RetypeNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<RetypeNode>(*this);
     nd->SetOpnd(Opnd()->CloneTree(allocator));
     return nd;
   }
@@ -318,7 +318,7 @@ class ExtractbitsNode : public UnaryNode {
   bool Verify() const;
 
   ExtractbitsNode *CloneTree(MapleAllocator &allocator) const {
-    ExtractbitsNode *nd = allocator.GetMemPool()->New<ExtractbitsNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<ExtractbitsNode>(*this);
     nd->SetOpnd(Opnd()->CloneTree(allocator));
     return nd;
   }
@@ -352,10 +352,10 @@ class GCMallocNode : public BaseNode {
 
   ~GCMallocNode() = default;
 
-  void Dump(const MIRModule &mod, int32 indent) const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
 
-  GCMallocNode *CloneTree(MapleAllocator &allocator) const {
-    GCMallocNode *nd = allocator.GetMemPool()->New<GCMallocNode>(*this);
+  GCMallocNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *nd = allocator.GetMemPool()->New<GCMallocNode>(*this);
     return nd;
   }
 
@@ -391,7 +391,7 @@ class JarrayMallocNode : public UnaryNode {
   void Dump(const MIRModule &mod, int32 indent) const;
 
   JarrayMallocNode *CloneTree(MapleAllocator &allocator) const {
-    JarrayMallocNode *nd = allocator.GetMemPool()->New<JarrayMallocNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<JarrayMallocNode>(*this);
     nd->SetOpnd(Opnd()->CloneTree(allocator));
     return nd;
   }
@@ -425,7 +425,7 @@ class IreadNode : public UnaryNode {
   bool Verify() const;
 
   IreadNode *CloneTree(MapleAllocator &allocator) const {
-    IreadNode *nd = allocator.GetMemPool()->New<IreadNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<IreadNode>(*this);
     nd->SetOpnd(Opnd()->CloneTree(allocator));
     return nd;
   }
@@ -477,7 +477,7 @@ class IreadoffNode : public UnaryNode {
   bool Verify() const;
 
   IreadoffNode *CloneTree(MapleAllocator &allocator) const {
-    IreadoffNode *nd = allocator.GetMemPool()->New<IreadoffNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<IreadoffNode>(*this);
     nd->SetOpnd(Opnd()->CloneTree(allocator));
     return nd;
   }
@@ -502,11 +502,11 @@ class IreadFPoffNode : public BaseNode {
 
   ~IreadFPoffNode() = default;
 
-  void Dump(const MIRModule &mod, int32 indent) const;
-  bool Verify() const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
+  bool Verify() const override;
 
-  IreadFPoffNode *CloneTree(MapleAllocator &allocator) const {
-    IreadFPoffNode *nd = allocator.GetMemPool()->New<IreadFPoffNode>(*this);
+  IreadFPoffNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *nd = allocator.GetMemPool()->New<IreadFPoffNode>(*this);
     return nd;
   }
 
@@ -555,12 +555,12 @@ class BinaryNode : public BaseNode, public BinaryOpnds {
 
   ~BinaryNode() = default;
 
-  void Dump(const MIRModule &mod, int32 indent) const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
   void Dump(const MIRModule &mod) const;
-  bool Verify() const;
+  bool Verify() const override;
 
-  BinaryNode *CloneTree(MapleAllocator &allocator) const {
-    BinaryNode *nd = allocator.GetMemPool()->New<BinaryNode>(*this);
+  BinaryNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *nd = allocator.GetMemPool()->New<BinaryNode>(*this);
     nd->SetBOpnd(GetBOpnd(0)->CloneTree(allocator), 0);
     nd->SetBOpnd(GetBOpnd(1)->CloneTree(allocator), 1);
     return nd;
@@ -581,25 +581,25 @@ class BinaryNode : public BaseNode, public BinaryOpnds {
     }
   }
 
-  BaseNode *Opnd(size_t i) const {
+  BaseNode *Opnd(size_t i) const override {
     ASSERT(i < kOperandNumBinary, "invalid operand idx in BinaryNode");
     ASSERT(i >= 0, "invalid operand idx in BinaryNode");
     return GetBOpnd(i);
   }
 
-  uint8 NumOpnds() const {
+  uint8 NumOpnds() const override {
     return kOperandNumBinary;
   }
 
-  void SetOpnd(BaseNode *node, size_t i = 0) {
+  void SetOpnd(BaseNode *node, size_t i = 0) override {
     SetBOpnd(node, i);
   }
 
-  bool IsLeaf() const {
+  bool IsLeaf() const override {
     return false;
   }
 
-  bool IsBinaryNode() const {
+  bool IsBinaryNode() const override {
     return true;
   }
 };
@@ -620,7 +620,7 @@ class CompareNode : public BinaryNode {
   bool Verify() const;
 
   CompareNode *CloneTree(MapleAllocator &allocator) const {
-    CompareNode *nd = allocator.GetMemPool()->New<CompareNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<CompareNode>(*this);
     nd->SetBOpnd(GetBOpnd(0)->CloneTree(allocator), 0);
     nd->SetBOpnd(GetBOpnd(1)->CloneTree(allocator), 1);
     return nd;
@@ -653,7 +653,7 @@ class DepositbitsNode : public BinaryNode {
   bool Verify() const;
 
   DepositbitsNode *CloneTree(MapleAllocator &allocator) const {
-    DepositbitsNode *nd = allocator.GetMemPool()->New<DepositbitsNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<DepositbitsNode>(*this);
     nd->SetBOpnd(GetBOpnd(0)->CloneTree(allocator), 0);
     nd->SetBOpnd(GetBOpnd(1)->CloneTree(allocator), 1);
     return nd;
@@ -699,7 +699,7 @@ class ResolveFuncNode : public BinaryNode {
   void Dump(const MIRModule &mod, int32 indent) const;
 
   ResolveFuncNode *CloneTree(MapleAllocator &allocator) const {
-    ResolveFuncNode *nd = allocator.GetMemPool()->New<ResolveFuncNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<ResolveFuncNode>(*this);
     nd->SetBOpnd(GetBOpnd(0)->CloneTree(allocator), 0);
     nd->SetBOpnd(GetBOpnd(1)->CloneTree(allocator), 1);
     return nd;
@@ -751,7 +751,7 @@ class TernaryNode : public BaseNode {
   bool Verify() const override;
 
   TernaryNode *CloneTree(MapleAllocator &allocator) const override {
-    TernaryNode *nd = allocator.GetMemPool()->New<TernaryNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<TernaryNode>(*this);
     nd->topnd[0] = topnd[0]->CloneTree(allocator);
     nd->topnd[1] = topnd[1]->CloneTree(allocator);
     nd->topnd[2] = topnd[2]->CloneTree(allocator);
@@ -845,7 +845,7 @@ class NaryNode : public BaseNode, public NaryOpnds {
   virtual void Dump(const MIRModule &mod, int32 indent) const override;
 
   NaryNode *CloneTree(MapleAllocator &allocator) const override {
-    NaryNode *nd = allocator.GetMemPool()->New<NaryNode>(allocator, *this);
+    auto *nd = allocator.GetMemPool()->New<NaryNode>(allocator, *this);
     for (size_t i = 0; i < GetNopndSize(); i++) {
       nd->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator));
     }
@@ -907,7 +907,7 @@ class IntrinsicopNode : public NaryNode {
   bool Verify() const;
 
   IntrinsicopNode *CloneTree(MapleAllocator &allocator) const {
-    IntrinsicopNode *nd = allocator.GetMemPool()->New<IntrinsicopNode>(allocator, *this);
+    auto *nd = allocator.GetMemPool()->New<IntrinsicopNode>(allocator, *this);
     for (size_t i = 0; i < GetNopndSize(); i++) {
       nd->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator));
     }
@@ -946,9 +946,9 @@ class ConstvalNode : public BaseNode {
 
   ConstvalNode(PrimType typ, MIRConst *constv) : BaseNode(OP_constval, typ, 0), constVal(constv) {}
   ~ConstvalNode() = default;
-  void Dump(const MIRModule &mod, int32 indent) const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
 
-  ConstvalNode *CloneTree(MapleAllocator &allocator) const {
+  ConstvalNode *CloneTree(MapleAllocator &allocator) const override {
     return allocator.GetMemPool()->New<ConstvalNode>(*this);
   }
 
@@ -978,9 +978,9 @@ class ConststrNode : public BaseNode {
 
   ~ConststrNode() = default;
 
-  void Dump(const MIRModule &mod, int32 indent) const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
 
-  ConststrNode *CloneTree(MapleAllocator &allocator) const {
+  ConststrNode *CloneTree(MapleAllocator &allocator) const override {
     return allocator.GetMemPool()->New<ConststrNode>(*this);
   }
 
@@ -1006,9 +1006,9 @@ class Conststr16Node : public BaseNode {
 
   ~Conststr16Node() = default;
 
-  void Dump(const MIRModule &mod, int32 indent) const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
 
-  Conststr16Node *CloneTree(MapleAllocator &allocator) const {
+  Conststr16Node *CloneTree(MapleAllocator &allocator) const override {
     return allocator.GetMemPool()->New<Conststr16Node>(*this);
   }
 
@@ -1034,10 +1034,10 @@ class SizeoftypeNode : public BaseNode {
 
   ~SizeoftypeNode() = default;
 
-  void Dump(const MIRModule &mod, int32 indent) const;
-  bool Verify() const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
+  bool Verify() const override;
 
-  SizeoftypeNode *CloneTree(MapleAllocator &allocator) const {
+  SizeoftypeNode *CloneTree(MapleAllocator &allocator) const override {
     return allocator.GetMemPool()->New<SizeoftypeNode>(*this);
   }
 
@@ -1064,9 +1064,9 @@ class FieldsDistNode : public BaseNode {
 
   ~FieldsDistNode() = default;
 
-  void Dump(const MIRModule &mod, int32 indent) const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
 
-  FieldsDistNode *CloneTree(MapleAllocator &allocator) const {
+  FieldsDistNode *CloneTree(MapleAllocator &allocator) const override {
     return allocator.GetMemPool()->New<FieldsDistNode>(*this);
   }
 
@@ -1130,13 +1130,13 @@ class ArrayNode : public NaryNode {
   bool Verify() const;
   bool IsSameBase(ArrayNode*);
 
-  uint8 NumOpnds(void) const {
+  uint8 NumOpnds() const {
     ASSERT(numOpnds == GetNopndSize(), "ArrayNode has wrong numOpnds field");
     return GetNopndSize();
   }
 
   ArrayNode *CloneTree(MapleAllocator &allocator) const {
-    ArrayNode *nd = allocator.GetMemPool()->New<ArrayNode>(allocator, *this);
+    auto *nd = allocator.GetMemPool()->New<ArrayNode>(allocator, *this);
     for (size_t i = 0; i < GetNopndSize(); i++) {
       nd->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator));
     }
@@ -1187,11 +1187,11 @@ class AddrofNode : public BaseNode {
 
   ~AddrofNode() = default;
 
-  virtual void Dump(const MIRModule &mod, int32 indent) const;
-  bool Verify() const;
+  virtual void Dump(const MIRModule &mod, int32 indent) const override;
+  bool Verify() const override;
   bool CheckNode(const MIRModule &mod) const;
 
-  AddrofNode *CloneTree(MapleAllocator &allocator) const {
+  AddrofNode *CloneTree(MapleAllocator &allocator) const override {
     return allocator.GetMemPool()->New<AddrofNode>(*this);
   }
 
@@ -1235,10 +1235,10 @@ class RegreadNode : public BaseNode {
 
   ~RegreadNode() = default;
 
-  virtual void Dump(const MIRModule &mod, int32 indent) const;
-  bool Verify() const;
+  virtual void Dump(const MIRModule &mod, int32 indent) const override;
+  bool Verify() const override;
 
-  RegreadNode *CloneTree(MapleAllocator &allocator) const {
+  RegreadNode *CloneTree(MapleAllocator &allocator) const override {
     return allocator.GetMemPool()->New<RegreadNode>(*this);
   }
 
@@ -1261,10 +1261,10 @@ class AddroffuncNode : public BaseNode {
 
   ~AddroffuncNode() = default;
 
-  void Dump(const MIRModule &mod, int32 indent) const;
-  bool Verify() const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
+  bool Verify() const override;
 
-  AddroffuncNode *CloneTree(MapleAllocator &allocator) const {
+  AddroffuncNode *CloneTree(MapleAllocator &allocator) const override {
     return allocator.GetMemPool()->New<AddroffuncNode>(*this);
   }
 
@@ -1288,10 +1288,10 @@ class AddroflabelNode : public BaseNode {
 
   ~AddroflabelNode() = default;
 
-  void Dump(const MIRModule &mod, int32 indent) const;
-  bool Verify() const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
+  bool Verify() const override;
 
-  AddroflabelNode *CloneTree(MapleAllocator &allocator) const {
+  AddroflabelNode *CloneTree(MapleAllocator &allocator) const override {
     return allocator.GetMemPool()->New<AddroflabelNode>(*this);
   }
 
@@ -1403,19 +1403,19 @@ class StmtNode : public BaseNode, public PtrListNodeBase<StmtNode> {
 
   virtual ~StmtNode() = default;
 
-  void DumpBase(const MIRModule &mod, int32 indent) const;
-  void Dump(const MIRModule &mod, int32 indent) const;
+  void DumpBase(const MIRModule &mod, int32 indent) const override;
+  void Dump(const MIRModule &mod, int32 indent) const override;
   void Dump(const MIRModule &mod) const;
   void InsertAfterThis(StmtNode &pos);
   void InsertBeforeThis(StmtNode &pos);
 
-  virtual StmtNode *CloneTree(MapleAllocator &allocator) const {
-    StmtNode *s = allocator.GetMemPool()->New<StmtNode>(*this);
+  virtual StmtNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *s = allocator.GetMemPool()->New<StmtNode>(*this);
     s->SetStmtID(stmtIDNext++);
     return s;
   }
 
-  virtual bool Verify() const {
+  virtual bool Verify() const override {
     return true;
   }
 
@@ -1502,7 +1502,7 @@ class IassignNode : public StmtNode {
   bool Verify() const override;
 
   IassignNode *CloneTree(MapleAllocator &allocator) const override {
-    IassignNode *bn = allocator.GetMemPool()->New<IassignNode>(*this);
+    auto *bn = allocator.GetMemPool()->New<IassignNode>(*this);
     bn->SetStmtID(stmtIDNext++);
     bn->SetOpnd(addrExpr->CloneTree(allocator), 0);
     bn->SetRHS(rhs->CloneTree(allocator));
@@ -1546,10 +1546,10 @@ class GotoNode : public StmtNode {
 
   ~GotoNode() = default;
 
-  void Dump(const MIRModule &mod, int32 indent) const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
 
-  GotoNode *CloneTree(MapleAllocator &allocator) const {
-    GotoNode *g = allocator.GetMemPool()->New<GotoNode>(*this);
+  GotoNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *g = allocator.GetMemPool()->New<GotoNode>(*this);
     g->SetStmtID(stmtIDNext++);
     return g;
   }
@@ -1576,10 +1576,10 @@ class JsTryNode : public StmtNode {
 
   ~JsTryNode() = default;
 
-  void Dump(const MIRModule &mod, int32 indent) const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
 
-  JsTryNode *CloneTree(MapleAllocator &allocator) const {
-    JsTryNode *t = allocator.GetMemPool()->New<JsTryNode>(*this);
+  JsTryNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *t = allocator.GetMemPool()->New<JsTryNode>(*this);
     t->SetStmtID(stmtIDNext++);
     return t;
   }
@@ -1618,7 +1618,7 @@ class TryNode : public StmtNode {
   TryNode &operator=(const TryNode &node) = delete;
   ~TryNode() = default;
 
-  void Dump(const MIRModule &mod, int32 indent) const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
   void Dump(const MIRModule &mod) const;
 
   LabelIdx GetOffset(size_t i) const {
@@ -1660,8 +1660,8 @@ class TryNode : public StmtNode {
     offsets.insert(a, b, c);
   }
 
-  TryNode *CloneTree(MapleAllocator &allocator) const {
-    TryNode *nd = allocator.GetMemPool()->New<TryNode>(allocator);
+  TryNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *nd = allocator.GetMemPool()->New<TryNode>(allocator);
     nd->SetStmtID(stmtIDNext++);
     for (size_t i = 0; i < offsets.size(); i++) {
       nd->AddOffset(offsets[i]);
@@ -1687,7 +1687,7 @@ class CatchNode : public StmtNode {
   CatchNode &operator=(const CatchNode &node) = delete;
   ~CatchNode() = default;
 
-  void Dump(const MIRModule &mod, int32 indent) const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
   void Dump(const MIRModule &mod) const;
 
   TyIdx GetExceptionTyIdxVecElement(size_t i) const {
@@ -1716,8 +1716,8 @@ class CatchNode : public StmtNode {
     exceptionTyIdxVec.push_back(idx);
   }
 
-  CatchNode *CloneTree(MapleAllocator &allocator) const {
-    CatchNode *j = allocator.GetMemPool()->New<CatchNode>(allocator);
+  CatchNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *j = allocator.GetMemPool()->New<CatchNode>(allocator);
     j->SetStmtID(stmtIDNext++);
     for (uint32 i = 0; i < Size(); i++) {
       j->PushBack(GetExceptionTyIdxVecElement(i));
@@ -1758,11 +1758,11 @@ class SwitchNode : public StmtNode {
   SwitchNode &operator=(const SwitchNode &node) = delete;
   ~SwitchNode() = default;
 
-  void Dump(const MIRModule &mod, int32 indent) const;
-  bool Verify() const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
+  bool Verify() const override;
 
-  SwitchNode *CloneTree(MapleAllocator &allocator) const {
-    SwitchNode *nd = allocator.GetMemPool()->New<SwitchNode>(allocator, *this);
+  SwitchNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *nd = allocator.GetMemPool()->New<SwitchNode>(allocator, *this);
     nd->SetSwitchOpnd(switchOpnd->CloneTree(allocator));
     for (size_t i = 0; i < switchTable.size(); i++) {
       nd->InsertCasePair(switchTable[i]);
@@ -1770,12 +1770,12 @@ class SwitchNode : public StmtNode {
     return nd;
   }
 
-  BaseNode *Opnd(size_t i) const {
+  BaseNode *Opnd(size_t i) const override {
     ASSERT(i == 0, "it is not same as original");
     return switchOpnd;
   }
 
-  void SetOpnd(BaseNode *node, size_t i = 0) {
+  void SetOpnd(BaseNode *node, size_t i = 0) override {
     ASSERT(i == 0, "it is not same as original");
     switchOpnd = node;
   }
@@ -1854,10 +1854,10 @@ class MultiwayNode : public StmtNode {
   MultiwayNode &operator=(const MultiwayNode &node) = delete;
   ~MultiwayNode() = default;
 
-  void Dump(const MIRModule &mod, int32 indent) const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
 
-  MultiwayNode *CloneTree(MapleAllocator &allocator) const {
-    MultiwayNode *nd = allocator.GetMemPool()->New<MultiwayNode>(allocator, *this);
+  MultiwayNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *nd = allocator.GetMemPool()->New<MultiwayNode>(allocator, *this);
     nd->multiWayOpnd = static_cast<BaseNode*>(multiWayOpnd->CloneTree(allocator));
     for (size_t i = 0; i < multiWayTable.size(); i++) {
       BaseNode *node = multiWayTable[i].first->CloneTree(allocator);
@@ -1867,7 +1867,7 @@ class MultiwayNode : public StmtNode {
     return nd;
   }
 
-  BaseNode *Opnd(size_t i) const {
+  BaseNode *Opnd(size_t i) const override {
     return *(&multiWayOpnd + static_cast<uint32>(i));
   }
 
@@ -1917,13 +1917,13 @@ class UnaryStmtNode : public StmtNode {
   }
 
   UnaryStmtNode *CloneTree(MapleAllocator &allocator) const override {
-    UnaryStmtNode *nd = allocator.GetMemPool()->New<UnaryStmtNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<UnaryStmtNode>(*this);
     nd->SetStmtID(stmtIDNext++);
     nd->SetOpnd(uOpnd->CloneTree(allocator));
     return nd;
   }
 
-  bool IsLeaf(void) const override {
+  bool IsLeaf() const override {
     return false;
   }
 
@@ -1969,13 +1969,13 @@ class DassignNode : public UnaryStmtNode {
   bool Verify() const override;
 
   DassignNode *CloneTree(MapleAllocator &allocator) const override {
-    DassignNode *nd = allocator.GetMemPool()->New<DassignNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<DassignNode>(*this);
     nd->SetStmtID(stmtIDNext++);
     nd->SetOpnd(Opnd()->CloneTree(allocator));
     return nd;
   }
 
-  uint8 NumOpnds(void) const override {
+  uint8 NumOpnds() const override {
     return 1;
   }
 
@@ -2031,7 +2031,7 @@ class RegassignNode : public UnaryStmtNode {
   bool Verify() const override;
 
   RegassignNode *CloneTree(MapleAllocator &allocator) const override {
-    RegassignNode *nd = allocator.GetMemPool()->New<RegassignNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<RegassignNode>(*this);
     nd->SetStmtID(stmtIDNext++);
     nd->SetOpnd(Opnd()->CloneTree(allocator));
     return nd;
@@ -2079,7 +2079,7 @@ class CondGotoNode : public UnaryStmtNode {
   }
 
   CondGotoNode *CloneTree(MapleAllocator &allocator) const {
-    CondGotoNode *nd = allocator.GetMemPool()->New<CondGotoNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<CondGotoNode>(*this);
     nd->SetStmtID(stmtIDNext++);
     nd->SetOpnd(Opnd()->CloneTree(allocator));
     return nd;
@@ -2113,7 +2113,7 @@ class RangeGotoNode : public UnaryStmtNode {
   void Dump(const MIRModule &mod, int32 indent) const;
   bool Verify() const;
   RangeGotoNode *CloneTree(MapleAllocator &allocator) const {
-    RangeGotoNode *nd = allocator.GetMemPool()->New<RangeGotoNode>(allocator, *this);
+    auto *nd = allocator.GetMemPool()->New<RangeGotoNode>(allocator, *this);
     nd->SetOpnd(Opnd()->CloneTree(allocator));
     for (size_t i = 0; i < rangegotoTable.size(); i++) {
       nd->rangegotoTable.push_back(rangegotoTable[i]);
@@ -2170,14 +2170,14 @@ class BlockNode : public StmtNode {
   void InsertBlockAfter(BlockNode &inblock, StmtNode *stmt1);
   void Dump(const MIRModule &mod, int32 indent, const MIRSymbolTable *theSymTab, MIRPregTable *thePregTab,
             bool withInfo, bool isFuncbody) const;
-  bool Verify() const;
+  bool Verify() const override;
 
-  void Dump(const MIRModule &mod, int32 indent) const {
+  void Dump(const MIRModule &mod, int32 indent) const override {
     Dump(mod, indent, nullptr, nullptr, false, false);
   }
 
-  BlockNode *CloneTree(MapleAllocator &allocator) const {
-    BlockNode *blk = allocator.GetMemPool()->New<BlockNode>();
+  BlockNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *blk = allocator.GetMemPool()->New<BlockNode>();
     blk->SetStmtID(stmtIDNext++);
     for (auto &stmt : stmtNodeList) {
       StmtNode *newStmt = static_cast<StmtNode*>(stmt.CloneTree(allocator));
@@ -2191,7 +2191,7 @@ class BlockNode : public StmtNode {
 
   BlockNode *CloneTreeWithSrcPosition(const MIRModule &mod) {
     MapleAllocator &allocator = mod.GetCurFuncCodeMPAllocator();
-    BlockNode *blk = allocator.GetMemPool()->New<BlockNode>();
+    auto *blk = allocator.GetMemPool()->New<BlockNode>();
     blk->SetStmtID(stmtIDNext++);
     for (auto &stmt : stmtNodeList) {
       StmtNode *newStmt = static_cast<StmtNode*>(stmt.CloneTree(allocator));
@@ -2260,7 +2260,7 @@ class IfStmtNode : public UnaryStmtNode {
   bool Verify() const;
 
   IfStmtNode *CloneTree(MapleAllocator &allocator) const {
-    IfStmtNode *nd = allocator.GetMemPool()->New<IfStmtNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<IfStmtNode>(*this);
     nd->SetStmtID(stmtIDNext++);
     nd->SetOpnd(Opnd()->CloneTree(allocator));
     nd->thenPart = thenPart->CloneTree(allocator);
@@ -2300,7 +2300,7 @@ class IfStmtNode : public UnaryStmtNode {
     elsePart = node;
   }
 
-  uint8 NumOpnds(void) const {
+  uint8 NumOpnds() const {
     return numOpnds;
   }
 
@@ -2322,7 +2322,7 @@ class WhileStmtNode : public UnaryStmtNode {
   bool Verify() const;
 
   WhileStmtNode *CloneTree(MapleAllocator &allocator) const {
-    WhileStmtNode *nd = allocator.GetMemPool()->New<WhileStmtNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<WhileStmtNode>(*this);
     nd->SetStmtID(stmtIDNext++);
     nd->SetOpnd(Opnd()->CloneTree(allocator));
     nd->body = body->CloneTree(allocator);
@@ -2357,11 +2357,11 @@ class DoloopNode : public StmtNode {
   ~DoloopNode() = default;
 
   void DumpDoVar(const MIRModule &mod) const;
-  void Dump(const MIRModule &mod, int32 indent) const;
-  bool Verify() const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
+  bool Verify() const override;
 
-  DoloopNode *CloneTree(MapleAllocator &allocator) const {
-    DoloopNode *nd = allocator.GetMemPool()->New<DoloopNode>(*this);
+  DoloopNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *nd = allocator.GetMemPool()->New<DoloopNode>(*this);
     nd->SetStmtID(stmtIDNext++);
     nd->SetStartExpr(startExpr->CloneTree(allocator));
     nd->SetContExpr(GetCondExpr()->CloneTree(allocator));
@@ -2422,7 +2422,7 @@ class DoloopNode : public StmtNode {
     return doBody;
   }
 
-  BaseNode *Opnd(size_t i) const {
+  BaseNode *Opnd(size_t i) const override {
     if (i == 0) {
       return startExpr;
     }
@@ -2435,11 +2435,11 @@ class DoloopNode : public StmtNode {
     return *(&doBody + i - 3);
   }
 
-  uint8 NumOpnds() const {
+  uint8 NumOpnds() const override {
     return kOperandNumDoloop;
   }
 
-  void SetOpnd(BaseNode *node, size_t i) {
+  void SetOpnd(BaseNode *node, size_t i) override {
     if (i == 0) {
       startExpr = node;
     }
@@ -2499,14 +2499,14 @@ class ForeachelemNode : public StmtNode {
     return loopBody;
   }
 
-  uint8 NumOpnds(void) const {
+  uint8 NumOpnds() const {
     return numOpnds;
   }
 
   void Dump(const MIRModule &mod, int32 indent) const;
 
   ForeachelemNode *CloneTree(MapleAllocator &allocator) const {
-    ForeachelemNode *nd = allocator.GetMemPool()->New<ForeachelemNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<ForeachelemNode>(*this);
     nd->SetStmtID(stmtIDNext++);
     nd->SetLoopBody(loopBody->CloneTree(allocator));
     return nd;
@@ -2528,7 +2528,7 @@ class BinaryStmtNode : public StmtNode, public BinaryOpnds {
   void Dump(const MIRModule &mod, int32 indent) const;
   virtual bool Verify() const;
   BinaryStmtNode *CloneTree(MapleAllocator &allocator) const {
-    BinaryStmtNode *nd = allocator.GetMemPool()->New<BinaryStmtNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<BinaryStmtNode>(*this);
     nd->SetStmtID(stmtIDNext++);
     nd->SetBOpnd(GetBOpnd(0)->CloneTree(allocator), 0);
     nd->SetBOpnd(GetBOpnd(1)->CloneTree(allocator), 1);
@@ -2572,7 +2572,7 @@ class IassignoffNode : public BinaryStmtNode {
   bool Verify() const;
 
   IassignoffNode *CloneTree(MapleAllocator &allocator) const {
-    IassignoffNode *nd = allocator.GetMemPool()->New<IassignoffNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<IassignoffNode>(*this);
     nd->SetStmtID(stmtIDNext++);
     nd->SetBOpnd(GetBOpnd(0)->CloneTree(allocator), 0);
     nd->SetBOpnd(GetBOpnd(1)->CloneTree(allocator), 1);
@@ -2608,7 +2608,7 @@ class IassignFPoffNode : public UnaryStmtNode {
   bool Verify() const;
 
   IassignFPoffNode *CloneTree(MapleAllocator &allocator) const {
-    IassignFPoffNode *nd = allocator.GetMemPool()->New<IassignFPoffNode>(*this);
+    auto *nd = allocator.GetMemPool()->New<IassignFPoffNode>(*this);
     nd->SetStmtID(stmtIDNext++);
     nd->SetOpnd(Opnd()->CloneTree(allocator));
     return nd;
@@ -2643,11 +2643,11 @@ class NaryStmtNode : public StmtNode, public NaryOpnds {
   NaryStmtNode &operator=(const NaryStmtNode &node) = delete;
   ~NaryStmtNode() = default;
 
-  void Dump(const MIRModule &mod, int32 indent) const;
-  virtual bool Verify() const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
+  virtual bool Verify() const override;
 
-  NaryStmtNode *CloneTree(MapleAllocator &allocator) const {
-    NaryStmtNode *nd = allocator.GetMemPool()->New<NaryStmtNode>(allocator, *this);
+  NaryStmtNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *nd = allocator.GetMemPool()->New<NaryStmtNode>(allocator, *this);
     for (size_t i = 0; i < GetNopndSize(); i++) {
       nd->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator));
     }
@@ -2655,16 +2655,16 @@ class NaryStmtNode : public StmtNode, public NaryOpnds {
     return nd;
   }
 
-  BaseNode *Opnd(size_t i) const {
+  BaseNode *Opnd(size_t i) const override {
     return GetNopndAt(i);
   }
 
-  void SetOpnd(BaseNode *node, size_t i) {
+  void SetOpnd(BaseNode *node, size_t i) override {
     ASSERT(i < GetNopnd().size(), "array index out of range");
     SetNOpndAt(i, node);
   }
 
-  uint8 NumOpnds() const {
+  uint8 NumOpnds() const override {
     ASSERT(numOpnds == GetNopndSize(), "NaryStmtNode has wrong numOpnds field");
     return GetNopndSize();
   }
@@ -2729,7 +2729,7 @@ class CallNode : public NaryStmtNode {
   const MIRSymbol *GetCallReturnSymbol(const MIRModule &mod) const;
 
   CallNode *CloneTree(MapleAllocator &allocator) const {
-    CallNode *nd = allocator.GetMemPool()->New<CallNode>(allocator, *this);
+    auto *nd = allocator.GetMemPool()->New<CallNode>(allocator, *this);
     for (size_t i = 0; i < GetNopndSize(); i++) {
       nd->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator));
     }
@@ -2783,7 +2783,7 @@ class CallNode : public NaryStmtNode {
     returnValues = vec;
   }
 
-  uint8 NumOpnds(void) const {
+  uint8 NumOpnds() const {
     ASSERT(numOpnds == GetNopndSize(), "CallNode has wrong numOpnds field");
     return GetNopndSize();
   }
@@ -2831,7 +2831,7 @@ class IcallNode : public NaryStmtNode {
   bool Verify() const;
   MIRType *GetCallReturnType();
   IcallNode *CloneTree(MapleAllocator &allocator) const {
-    IcallNode *nd = allocator.GetMemPool()->New<IcallNode>(allocator, *this);
+    auto *nd = allocator.GetMemPool()->New<IcallNode>(allocator, *this);
     for (size_t i = 0; i < GetNopndSize(); i++) {
       nd->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator));
     }
@@ -2862,7 +2862,7 @@ class IcallNode : public NaryStmtNode {
     returnValues = vec;
   }
 
-  uint8 NumOpnds(void) const {
+  uint8 NumOpnds() const {
     ASSERT(numOpnds == GetNopndSize(), "IcallNode has wrong numOpnds field");
     return GetNopndSize();
   }
@@ -2913,7 +2913,7 @@ class IntrinsiccallNode : public NaryStmtNode {
   MIRType *GetCallReturnType();
 
   IntrinsiccallNode *CloneTree(MapleAllocator &allocator) const {
-    IntrinsiccallNode *nd = allocator.GetMemPool()->New<IntrinsiccallNode>(allocator, *this);
+    auto *nd = allocator.GetMemPool()->New<IntrinsiccallNode>(allocator, *this);
     for (size_t i = 0; i < GetNopndSize(); i++) {
       nd->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator));
     }
@@ -2952,7 +2952,7 @@ class IntrinsiccallNode : public NaryStmtNode {
     returnValues = vec;
   }
 
-  uint8 NumOpnds(void) const {
+  uint8 NumOpnds() const {
     ASSERT(numOpnds == GetNopndSize(), "IntrinsiccallNode has wrong numOpnds field");
     return GetNopndSize();
   }
@@ -3003,7 +3003,7 @@ class CallinstantNode : public CallNode {
   }
 
   CallinstantNode *CloneTree(MapleAllocator &allocator) const {
-    CallinstantNode *nd = allocator.GetMemPool()->New<CallinstantNode>(allocator, *this);
+    auto *nd = allocator.GetMemPool()->New<CallinstantNode>(allocator, *this);
     for (size_t i = 0; i < GetNopndSize(); i++) {
       nd->GetNopnd().push_back(GetNopndAt(i)->CloneTree(allocator));
     }
@@ -3045,10 +3045,10 @@ class LabelNode : public StmtNode {
 
   ~LabelNode() = default;
 
-  void Dump(const MIRModule &mod, int32 indent) const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
 
-  LabelNode *CloneTree(MapleAllocator &allocator) const {
-    LabelNode *l = allocator.GetMemPool()->New<LabelNode>(*this);
+  LabelNode *CloneTree(MapleAllocator &allocator) const override {
+    auto *l = allocator.GetMemPool()->New<LabelNode>(*this);
     l->SetStmtID(stmtIDNext++);
     return l;
   }
@@ -3089,7 +3089,7 @@ class CommentNode : public StmtNode {
   void Dump(const MIRModule &mod, int32 indent) const;
 
   CommentNode *CloneTree(MapleAllocator &allocator) const {
-    CommentNode *c = allocator.GetMemPool()->New<CommentNode>(allocator, *this);
+    auto *c = allocator.GetMemPool()->New<CommentNode>(allocator, *this);
     return c;
   }
 
diff --git a/src/maple_ir/include/mir_parser.h b/src/maple_ir/include/mir_parser.h
index 3d4be69a8036a6d2dc0f9b43d3d1a339ed62dc50..95918e9033867414c4b10da84432963926db27ee 100644
--- a/src/maple_ir/include/mir_parser.h
+++ b/src/maple_ir/include/mir_parser.h
@@ -68,7 +68,7 @@ class MIRParser {
   Opcode GetOpFromToken(TokenKind tk) const;
   bool IsStatement(TokenKind tk) const;
   PrimType GetPrimitiveType(TokenKind tk) const;
-  MIRIntrinsicID GetIntrinsicId(TokenKind tk) const;
+  MIRIntrinsicID GetIntrinsicID(TokenKind tk) const;
   bool ParseScalarValue(MIRConstPtr&, MIRType&);
   bool ParseConstAddrLeafExpr(MIRConstPtr&, MIRType&);
   bool ParseInitValue(MIRConstPtr&, TyIdx);
@@ -92,7 +92,7 @@ class MIRParser {
   bool ParseFields(MIRStructType &type);
   bool ParseStructType(TyIdx &styIdx);
   bool ParseClassType(TyIdx &tyIdx);
-  bool ParseInterfaceType(TyIdx &tyIdx);
+  bool ParseInterfaceType(TyIdx &sTyIdx);
   bool ParseDefinedTypename(TyIdx &tyIdx, MIRTypeKind kind = kTypeUnknown);
   bool ParseTypeParam(TyIdx &tyIdx);
   bool ParsePointType(TyIdx &tyIdx);
diff --git a/src/maple_ir/include/mir_pragma.h b/src/maple_ir/include/mir_pragma.h
index 35bbfae6c20130bb7f99b238428907c336adb9ba..5a01b1cf5425292c7fbb2285e2e0ff264f549a2a 100644
--- a/src/maple_ir/include/mir_pragma.h
+++ b/src/maple_ir/include/mir_pragma.h
@@ -255,8 +255,8 @@ class MIRPragma {
     tyIdxEx = idx;
   }
 
-  void SetParamNum(int32 paramnum) {
-    paramNum = paramnum;
+  void SetParamNum(int32 num) {
+    paramNum = num;
   }
 
  private:
diff --git a/src/maple_ir/include/mir_symbol.h b/src/maple_ir/include/mir_symbol.h
index c0ea0fd306cb6bcef2b8fa66bf728703b20093de..21ffe33304db7c26cf6467605c114f2810e7b283 100644
--- a/src/maple_ir/include/mir_symbol.h
+++ b/src/maple_ir/include/mir_symbol.h
@@ -21,7 +21,6 @@
 constexpr int kScopeLocal = 2;   // the default scope level for function variables
 constexpr int kScopeGlobal = 1;  // the scope level for global variables
 
-
 namespace maple {
 enum MIRSymKind {
   kStInvalid,
@@ -98,7 +97,7 @@ class MIRSymbol {
     this->tyIdx = tyIdx;
   }
 
-  const TyIdx GetTyIdx() const {
+  TyIdx GetTyIdx() const {
     return tyIdx;
   }
 
@@ -380,9 +379,9 @@ class MIRSymbol {
 class MIRSymbolTable {
  public:
   explicit MIRSymbolTable(MapleAllocator &allocator)
-      : mAllocator(allocator), strIdxToStIdxMap(mAllocator.Adapter()), symbolTable(mAllocator.Adapter()) {
-    symbolTable.push_back(nullptr);
-  }
+      : mAllocator(allocator),
+        strIdxToStIdxMap(mAllocator.Adapter()),
+        symbolTable({ nullptr }, mAllocator.Adapter()) {}
 
   ~MIRSymbolTable() = default;
 
@@ -425,13 +424,14 @@ class MIRSymbolTable {
 
   StIdx GetStIdxFromStrIdx(GStrIdx idx) const {
     auto it = strIdxToStIdxMap.find(idx);
-    if (it == strIdxToStIdxMap.end()) {
-      return StIdx();
-    }
-    return it->second;
+    return (it == strIdxToStIdxMap.end()) ? StIdx() : it->second;
+  }
+
+  MIRSymbol *GetSymbolFromStrIdx(GStrIdx idx, bool checkFirst = false) {
+    return GetSymbolFromStIdx(GetStIdxFromStrIdx(idx).Idx(), checkFirst);
   }
 
-  MIRSymbol *GetSymbolFromStrIdx(GStrIdx idx, bool checkFirst = false) const {
+  const MIRSymbol *GetSymbolFromStrIdx(GStrIdx idx, bool checkFirst = false) const {
     return GetSymbolFromStIdx(GetStIdxFromStrIdx(idx).Idx(), checkFirst);
   }
 
diff --git a/src/maple_ir/include/printing.h b/src/maple_ir/include/printing.h
index fbe7443347a87359fd481eabb67ca10b551bb1b9..85f92ab0c7b511e31de2cd5f95fa55b24d56f755 100644
--- a/src/maple_ir/include/printing.h
+++ b/src/maple_ir/include/printing.h
@@ -18,7 +18,7 @@
 #include "types_def.h"
 
 namespace maple {
-extern void PrintIndentation(int32 indent);
+void PrintIndentation(int32 indent);
 void PrintString(const std::string &str);
 }  // namespace maple
 #endif  // MAPLE_IR_INCLUDE_PRINTING_H
diff --git a/src/maple_ir/src/bin_mpl_export.cpp b/src/maple_ir/src/bin_mpl_export.cpp
index 96337769b6b0f75eb47e13eb4ca7b72d0ebc18ad..6fbbb9c5650627be917e542e1844db6b803221ee 100644
--- a/src/maple_ir/src/bin_mpl_export.cpp
+++ b/src/maple_ir/src/bin_mpl_export.cpp
@@ -292,7 +292,6 @@ namespace maple {
 int BinaryMplExport::typeMarkOffset = 0;
 
 BinaryMplExport::BinaryMplExport(MIRModule &md) : mod(md) {
-  bufI = 0;
   Init();
   InitOutputConstFactory();
   InitOutputTypeFactory();
diff --git a/src/maple_ir/src/global_tables.cpp b/src/maple_ir/src/global_tables.cpp
index 806418457847cd81226f493ef0f7141f79b8ecac..3437a786d72e43e10e0e43b62566c53b7363a3c5 100644
--- a/src/maple_ir/src/global_tables.cpp
+++ b/src/maple_ir/src/global_tables.cpp
@@ -285,11 +285,11 @@ bool GSymbolTable::RemoveFromStringSymbolMap(const MIRSymbol &st) {
   return false;
 }
 
-void GSymbolTable::Dump(bool islocal, int32 indent) const {
+void GSymbolTable::Dump(bool isLocal, int32 indent) const {
   for (size_t i = 1; i < symbolTable.size(); ++i) {
     const MIRSymbol *symbol = symbolTable[i];
     if (symbol != nullptr) {
-      symbol->Dump(module, islocal, indent);
+      symbol->Dump(module, isLocal, indent);
     }
   }
 }
diff --git a/src/maple_ir/src/mir_const.cpp b/src/maple_ir/src/mir_const.cpp
index 614c23df5ce16963d6c853478974225feffe9510..19f2d92f2af845302f406ca2d3f73d072d2d36ec 100644
--- a/src/maple_ir/src/mir_const.cpp
+++ b/src/maple_ir/src/mir_const.cpp
@@ -71,7 +71,7 @@ bool MIRAddrofConst::operator==(MIRConst &rhs) const {
   if (&GetType() != &rhs.GetType()) {
     return false;
   }
-  return (stIdx == rhsA.stIdx && fldID == rhsA.fldID);
+  return (stIdx == rhsA.stIdx) && (fldID == rhsA.fldID);
 }
 
 void MIRAddroffuncConst::Dump() const {
@@ -89,7 +89,7 @@ bool MIRAddroffuncConst::operator==(MIRConst &rhs) const {
     return false;
   }
   auto &rhsAf = static_cast<MIRAddroffuncConst&>(rhs);
-  return (&GetType() == &rhs.GetType() && puIdx == rhsAf.puIdx);
+  return (&GetType() == &rhs.GetType()) && (puIdx == rhsAf.puIdx);
 }
 
 bool MIRLblConst::operator==(MIRConst &rhs) const {
@@ -223,7 +223,7 @@ bool MIRStrConst::operator==(MIRConst &rhs) const {
     return false;
   }
   auto &rhsCs = static_cast<MIRStrConst&>(rhs);
-  return (&rhs.GetType() == &GetType() && value == rhsCs.value);
+  return (&rhs.GetType() == &GetType()) && (value == rhsCs.value);
 }
 
 MIRStr16Const::MIRStr16Const(const std::u16string &str, MIRType &type)
@@ -249,7 +249,7 @@ bool MIRStr16Const::operator==(MIRConst &rhs) const {
     return false;
   }
   auto &rhsCs = static_cast<MIRStr16Const&>(rhs);
-  return (&GetType() == &rhs.GetType() && value == rhsCs.value);
+  return (&GetType() == &rhs.GetType()) && (value == rhsCs.value);
 }
 }  // namespace maple
 #endif  // MIR_FEATURE_FULL
diff --git a/src/maple_ir/src/mir_lower.cpp b/src/maple_ir/src/mir_lower.cpp
index e3e0ce0192494f3e2947e8563c8380d014ee4415..163251d350793ab69f1f7a57c63c6edfdedc5ae5 100644
--- a/src/maple_ir/src/mir_lower.cpp
+++ b/src/maple_ir/src/mir_lower.cpp
@@ -36,14 +36,14 @@ LabelIdx MIRLower::CreateCondGotoStmt(Opcode op, BlockNode &blk, const IfStmtNod
 }
 
 void MIRLower::CreateBrFalseStmt(BlockNode &blk, const IfStmtNode &ifStmt) {
-  LabelIdx labelIdx =CreateCondGotoStmt(OP_brfalse, blk, ifStmt);
+  LabelIdx labelIdx = CreateCondGotoStmt(OP_brfalse, blk, ifStmt);
   LabelNode *lableStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
   lableStmt->SetLabelIdx(labelIdx);
   blk.AddStatement(lableStmt);
 }
 
 void MIRLower::CreateBrTrueStmt(BlockNode &blk, const IfStmtNode &ifStmt) {
-  LabelIdx labelIdx =CreateCondGotoStmt(OP_brtrue, blk, ifStmt);
+  LabelIdx labelIdx = CreateCondGotoStmt(OP_brtrue, blk, ifStmt);
   LabelNode *lableStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
   lableStmt->SetLabelIdx(labelIdx);
   blk.AddStatement(lableStmt);
@@ -51,7 +51,7 @@ void MIRLower::CreateBrTrueStmt(BlockNode &blk, const IfStmtNode &ifStmt) {
 
 
 void MIRLower::CreateBrFalseAndGotoStmt(BlockNode &blk, const IfStmtNode &ifStmt) {
-  LabelIdx labelIdx =CreateCondGotoStmt(OP_brfalse, blk, ifStmt);
+  LabelIdx labelIdx = CreateCondGotoStmt(OP_brfalse, blk, ifStmt);
   ASSERT(ifStmt.GetThenPart()->GetLast()->GetOpCode() != OP_brtrue, "then or else block should not end with brtrue");
   ASSERT(ifStmt.GetThenPart()->GetLast()->GetOpCode() != OP_brfalse,
          "then or else block should not end with brfalse");
diff --git a/src/maple_ir/src/mir_module.cpp b/src/maple_ir/src/mir_module.cpp
index 8ebc0aa6e43ccae5c6de3faf9ffbb8687b9d26c9..d2ac7cc9e11b4f8c32eaa744fccf2d5efc5984ba 100644
--- a/src/maple_ir/src/mir_module.cpp
+++ b/src/maple_ir/src/mir_module.cpp
@@ -295,7 +295,6 @@ void MIRModule::Emit(const std::string &outFileName) const {
   }
   // Restore cout's buffer.
   LogInfo::MapleLogger().rdbuf(backup);
-  file.close();
 }
 
 void MIRModule::DumpFunctionList(bool skipBody) const {
@@ -325,7 +324,6 @@ void MIRModule::OutputFunctionListAsciiMpl(const std::string &phaseName) {
   DumpGlobalArraySymbol();
   DumpFunctionList();
   LogInfo::MapleLogger().rdbuf(backup);  // restore cout's buffer
-  mplFile.close();
 }
 
 void MIRModule::DumpToFile(const std::string &fileNameStr, bool emitStructureType) const {
@@ -358,7 +356,6 @@ void MIRModule::DumpInlineCandidateToFile(const std::string &fileNameStr) const
   }
   // Restore cout's buffer.
   LogInfo::MapleLogger().rdbuf(backup);
-  file.close();
 }
 
 // This is not efficient. Only used in debug mode for now.
@@ -398,7 +395,6 @@ void MIRModule::DumpClassToFile(const std::string &path) const {
     LogInfo::MapleLogger() << '\n';
     /* restore cout */
     LogInfo::MapleLogger().rdbuf(backup);
-    mplFile.close();
   }
 }
 
@@ -435,7 +431,6 @@ void MIRModule::OutputAsciiMpl(const std::string &phaseName, bool emitStructureT
   LogInfo::MapleLogger().rdbuf(mplFile.rdbuf());  // change cout's buffer to that of file
   Dump(emitStructureType);
   LogInfo::MapleLogger().rdbuf(backup);  // restore cout's buffer
-  mplFile.close();
 }
 
 uint32 MIRModule::GetFileinfo(GStrIdx strIdx) const {
diff --git a/src/maple_ir/src/mir_nodes.cpp b/src/maple_ir/src/mir_nodes.cpp
index 462eac9a1a90f726593e7d0bfd0927745cdfdf39..05bbfd857142dda31ae0f1365b1d32262cca9526 100644
--- a/src/maple_ir/src/mir_nodes.cpp
+++ b/src/maple_ir/src/mir_nodes.cpp
@@ -46,12 +46,12 @@ bool BaseNode::MayThrowException() {
     if (GetOpCode() != OP_array) {
       return true;
     }
-    ArrayNode *arry = static_cast<ArrayNode*>(this);
+    auto *arry = static_cast<ArrayNode*>(this);
     if (arry->GetBoundsCheck()) {
       return true;
     }
   } else if (GetOpCode() == OP_intrinsicop) {
-    IntrinsicopNode *inNode = static_cast<IntrinsicopNode*>(this);
+    auto *inNode = static_cast<IntrinsicopNode*>(this);
     if (inNode->GetIntrinsic() == INTRN_JAVA_ARRAY_LENGTH) {
       return true;
     }
@@ -88,7 +88,7 @@ bool AddrofNode::CheckNode(const MIRModule &mod) const {
       if (GetFieldID() == 0) {
         return GetPrimType() == PTY_agg;
       } else {
-        MIRStructType *structType = static_cast<MIRStructType*>(ty);
+        auto *structType = static_cast<MIRStructType*>(ty);
         TyIdx ftyidx = structType->GetFieldTyIdx(fieldID);
         MIRType *subType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ftyidx);
         MIRTypeKind subKind = subType->GetKind();
@@ -103,7 +103,7 @@ bool AddrofNode::CheckNode(const MIRModule &mod) const {
       if (fieldID == 0) {
         return GetPrimType() == PTY_agg;
       } else {
-        MIRClassType *classType = static_cast<MIRClassType*>(ty);
+        auto *classType = static_cast<MIRClassType*>(ty);
         MIRType *subType = classType->GetFieldType(fieldID);
         MIRTypeKind subKind = subType->GetKind();
         return (subKind == kTypeBitField && VerifyPrimType(subType->GetPrimType(), GetPrimType())) ||
@@ -117,7 +117,7 @@ bool AddrofNode::CheckNode(const MIRModule &mod) const {
       if (fieldID == 0) {
         return GetPrimType() == PTY_agg;
       } else {
-        MIRInterfaceType *interfaceType = static_cast<MIRInterfaceType*>(ty);
+        auto *interfaceType = static_cast<MIRInterfaceType*>(ty);
         MIRType *subty = interfaceType->GetFieldType(fieldID);
         MIRTypeKind subKind = subty->GetKind();
         return (subKind == kTypeBitField && VerifyPrimType(subty->GetPrimType(), GetPrimType())) ||
@@ -212,7 +212,7 @@ void CatchNode::Dump(const MIRModule &mod, int32 indent) const {
     LogInfo::MapleLogger() << " ";
     GlobalTables::GetTypeTable().GetTypeFromTyIdx(exceptionTyIdxVec[i])->Dump(indent + 1);
   }
-  LogInfo::MapleLogger() << " }" << std::endl;
+  LogInfo::MapleLogger() << " }\n";
 }
 
 void CatchNode::Dump(const MIRModule &mod) const {
@@ -295,10 +295,10 @@ void BinaryOpnds::Dump(const MIRModule &mod, int32 indent) const {
     LogInfo::MapleLogger() << ", ";
     bOpnd[1]->Dump(mod, 0);
   } else {
-    LogInfo::MapleLogger() << std::endl;
+    LogInfo::MapleLogger() << '\n';
     PrintIndentation(indent + 1);
     bOpnd[0]->Dump(mod, indent + 1);
-    LogInfo::MapleLogger() << "," << std::endl;
+    LogInfo::MapleLogger() << ",\n";
     PrintIndentation(indent + 1);
     bOpnd[1]->Dump(mod, indent + 1);
   }
@@ -330,10 +330,10 @@ void DepositbitsNode::Dump(const MIRModule &mod, int32 indent) const {
     LogInfo::MapleLogger() << ", ";
     GetBOpnd(1)->Dump(mod, 0);
   } else {
-    LogInfo::MapleLogger() << std::endl;
+    LogInfo::MapleLogger() << '\n';
     PrintIndentation(indent + 1);
     GetBOpnd(0)->Dump(mod, indent + 1);
-    LogInfo::MapleLogger() << "," << std::endl;
+    LogInfo::MapleLogger() << ",\n";
     PrintIndentation(indent + 1);
     GetBOpnd(1)->Dump(mod, indent + 1);
   }
@@ -350,13 +350,13 @@ void TernaryNode::Dump(const MIRModule &mod, int32 indent) const {
     LogInfo::MapleLogger() << ", ";
     topnd[2]->Dump(mod, 0);
   } else {
-    LogInfo::MapleLogger() << std::endl;
+    LogInfo::MapleLogger() << '\n';
     PrintIndentation(indent + 1);
     topnd[0]->Dump(mod, indent + 1);
-    LogInfo::MapleLogger() << "," << std::endl;
+    LogInfo::MapleLogger() << ",\n";
     PrintIndentation(indent + 1);
     topnd[1]->Dump(mod, indent + 1);
-    LogInfo::MapleLogger() << "," << std::endl;
+    LogInfo::MapleLogger() << ",\n";
     PrintIndentation(indent + 1);
     topnd[2]->Dump(mod, indent + 1);
   }
@@ -385,11 +385,11 @@ void NaryOpnds::Dump(const MIRModule &mod, int32 indent) const {
         GetNopndAt(i)->Dump(mod, 0);
       }
     } else {
-      LogInfo::MapleLogger() << std::endl;
+      LogInfo::MapleLogger() << '\n';
       PrintIndentation(indent + 1);
       GetNopndAt(0)->Dump(mod, indent + 1);
       for (size_t i = 1; i < GetNopndSize(); i++) {
-        LogInfo::MapleLogger() << "," << std::endl;
+        LogInfo::MapleLogger() << ",\n";
         PrintIndentation(indent + 1);
         GetNopndAt(i)->Dump(mod, indent + 1);
       }
@@ -422,8 +422,8 @@ MIRType *ArrayNode::GetArrayType(const TypeTable &tt) const {
 }
 
 BaseNode *ArrayNode::GetDim(const MIRModule &mod, const TypeTable &tt, int i) const {
-  MIRArrayType *arrayType = static_cast<MIRArrayType*>(GetArrayType(tt));
-  MIRConst *mirConst = mod.CurFuncCodeMemPool()->New<MIRConst>(*tt.GetTypeFromTyIdx(arrayType->GetElemTyIdx()));
+  auto *arrayType = static_cast<MIRArrayType*>(GetArrayType(tt));
+  auto *mirConst = mod.CurFuncCodeMemPool()->New<MIRConst>(*tt.GetTypeFromTyIdx(arrayType->GetElemTyIdx()));
   return mod.CurFuncCodeMemPool()->New<ConstvalNode>(mirConst);
 }
 
@@ -547,7 +547,7 @@ void AddroflabelNode::Dump(const MIRModule &mod, int32 indent) const {
 void StmtNode::DumpBase(const MIRModule &mod, int32 indent) const {
   if (srcPosition.FileNum() != 0 && srcPosition.LineNum() != 0 && srcPosition.LineNum() != lastPrintedLineNum &&
       mod.CurFunction()->WithLocInfo()) {
-    LogInfo::MapleLogger() << "LOC " << srcPosition.FileNum() << " " << srcPosition.LineNum() << std::endl;
+    LogInfo::MapleLogger() << "LOC " << srcPosition.FileNum() << " " << srcPosition.LineNum() << '\n';
     lastPrintedLineNum = srcPosition.LineNum();
   }
   PrintIndentation(indent);
@@ -556,7 +556,7 @@ void StmtNode::DumpBase(const MIRModule &mod, int32 indent) const {
 
 void StmtNode::Dump(const MIRModule &mod, int32 indent) const {
   StmtNode::DumpBase(mod, indent);
-  LogInfo::MapleLogger() << std::endl;
+  LogInfo::MapleLogger() << '\n';
 }
 
 void StmtNode::Dump(const MIRModule &mod) const {
@@ -606,7 +606,7 @@ void DassignNode::Dump(const MIRModule &mod, int32 indent) const {
   } else {
     LogInfo::MapleLogger() << "/*empty-rhs*/";
   }
-  LogInfo::MapleLogger() << ")" << std::endl;
+  LogInfo::MapleLogger() << ")\n";
 }
 
 void RegassignNode::Dump(const MIRModule &mod, int32 indent) const {
@@ -633,7 +633,7 @@ void RegassignNode::Dump(const MIRModule &mod, int32 indent) const {
   }
   LogInfo::MapleLogger() << " (";
   UnaryStmtNode::Opnd()->Dump(mod, indent + 1);
-  LogInfo::MapleLogger() << ")" << std::endl;
+  LogInfo::MapleLogger() << ")\n";
 }
 
 void IassignNode::Dump(const MIRModule &mod, int32 indent) const {
@@ -647,36 +647,36 @@ void IassignNode::Dump(const MIRModule &mod, int32 indent) const {
     LogInfo::MapleLogger() << ", ";
     rhs->Dump(mod, 0);
   } else {
-    LogInfo::MapleLogger() << std::endl;
+    LogInfo::MapleLogger() << '\n';
     PrintIndentation(indent + 1);
     addrExpr->Dump(mod, indent + 1);
-    LogInfo::MapleLogger() << ", " << std::endl;
+    LogInfo::MapleLogger() << ", \n";
     PrintIndentation(indent + 1);
     rhs->Dump(mod, indent + 1);
   }
-  LogInfo::MapleLogger() << ")" << std::endl;
+  LogInfo::MapleLogger() << ")\n";
 }
 
 void IassignoffNode::Dump(const MIRModule &mod, int32 indent) const {
   StmtNode::DumpBase(mod, indent);
   LogInfo::MapleLogger() << " " << GetPrimTypeName(GetPrimType()) << " " << offset;
   BinaryOpnds::Dump(mod, indent);
-  LogInfo::MapleLogger() << std::endl;
+  LogInfo::MapleLogger() << '\n';
 }
 
 void IassignFPoffNode::Dump(const MIRModule &mod, int32 indent) const {
   StmtNode::DumpBase(mod, indent);
   LogInfo::MapleLogger() << " " << GetPrimTypeName(GetPrimType()) << " " << offset;
   DumpOpnd(mod, indent);
-  LogInfo::MapleLogger() << std::endl;
+  LogInfo::MapleLogger() << '\n';
 }
 
 void GotoNode::Dump(const MIRModule &mod, int32 indent) const {
   StmtNode::DumpBase(mod, indent);
   if (offset == 0) {
-    LogInfo::MapleLogger() << std::endl;
+    LogInfo::MapleLogger() << '\n';
   } else {
-    LogInfo::MapleLogger() << " @" << mod.CurFunction()->GetLabelName((LabelIdx)offset) << std::endl;
+    LogInfo::MapleLogger() << " @" << mod.CurFunction()->GetLabelName((LabelIdx)offset) << '\n';
   }
 }
 
@@ -688,9 +688,9 @@ void JsTryNode::Dump(const MIRModule &mod, int32 indent) const {
     LogInfo::MapleLogger() << " @" << mod.CurFunction()->GetLabelName((LabelIdx)catchOffset);
   }
   if (finallyOffset == 0) {
-    LogInfo::MapleLogger() << " 0" << std::endl;
+    LogInfo::MapleLogger() << " 0\n";
   } else {
-    LogInfo::MapleLogger() << " @" << mod.CurFunction()->GetLabelName((LabelIdx)finallyOffset) << std::endl;
+    LogInfo::MapleLogger() << " @" << mod.CurFunction()->GetLabelName((LabelIdx)finallyOffset) << '\n';
   }
 }
 
@@ -701,7 +701,7 @@ void TryNode::Dump(const MIRModule &mod, int32 indent) const {
     int64 offset = offsets[i];
     LogInfo::MapleLogger() << " @" << mod.CurFunction()->GetLabelName((LabelIdx)offset);
   }
-  LogInfo::MapleLogger() << " }" << std::endl;
+  LogInfo::MapleLogger() << " }\n";
 }
 
 void TryNode::Dump(const MIRModule &mod) const {
@@ -713,7 +713,7 @@ void CondGotoNode::Dump(const MIRModule &mod, int32 indent) const {
   LogInfo::MapleLogger() << " @" << mod.CurFunction()->GetLabelName((LabelIdx)offset);
   LogInfo::MapleLogger() << " (";
   Opnd()->Dump(mod, indent);
-  LogInfo::MapleLogger() << ")" << std::endl;
+  LogInfo::MapleLogger() << ")\n";
 }
 
 void SwitchNode::Dump(const MIRModule &mod, int32 indent) const {
@@ -726,12 +726,12 @@ void SwitchNode::Dump(const MIRModule &mod, int32 indent) const {
     LogInfo::MapleLogger() << ") @" << mod.CurFunction()->GetLabelName(defaultLabel) << " {";
   }
   for (auto it = switchTable.begin(); it != switchTable.end(); it++) {
-    LogInfo::MapleLogger() << std::endl;
+    LogInfo::MapleLogger() << '\n';
     PrintIndentation(indent + 1);
     LogInfo::MapleLogger() << std::hex << "0x" << (it)->first << std::dec;
     LogInfo::MapleLogger() << ": goto @" << mod.CurFunction()->GetLabelName((it)->second);
   }
-  LogInfo::MapleLogger() << " }" << std::endl;
+  LogInfo::MapleLogger() << " }\n";
 }
 
 void RangeGotoNode::Dump(const MIRModule &mod, int32 indent) const {
@@ -740,12 +740,12 @@ void RangeGotoNode::Dump(const MIRModule &mod, int32 indent) const {
   Opnd()->Dump(mod, indent);
   LogInfo::MapleLogger() << ") " << tagOffset << " {";
   for (auto it = rangegotoTable.begin(); it != rangegotoTable.end(); it++) {
-    LogInfo::MapleLogger() << std::endl;
+    LogInfo::MapleLogger() << '\n';
     PrintIndentation(indent + 1);
     LogInfo::MapleLogger() << std::hex << "0x" << (it)->first << std::dec;
     LogInfo::MapleLogger() << ": goto @" << mod.CurFunction()->GetLabelName((it)->second);
   }
-  LogInfo::MapleLogger() << " }" << std::endl;
+  LogInfo::MapleLogger() << " }\n";
 }
 
 void MultiwayNode::Dump(const MIRModule &mod, int32 indent) const {
@@ -758,13 +758,13 @@ void MultiwayNode::Dump(const MIRModule &mod, int32 indent) const {
     LogInfo::MapleLogger() << ") @" << mod.CurFunction()->GetLabelName(defaultLabel) << " {";
   }
   for (auto it = multiWayTable.begin(); it != multiWayTable.end(); it++) {
-    LogInfo::MapleLogger() << std::endl;
+    LogInfo::MapleLogger() << '\n';
     PrintIndentation(indent);
     LogInfo::MapleLogger() << " (";
     it->first->Dump(mod, indent + 1);
     LogInfo::MapleLogger() << "): goto @" << mod.CurFunction()->GetLabelName((it)->second);
   }
-  LogInfo::MapleLogger() << " }" << std::endl;
+  LogInfo::MapleLogger() << " }\n";
 }
 
 void UnaryStmtNode::DumpOpnd(const MIRModule &mod, int indent) const {
@@ -779,7 +779,7 @@ void UnaryStmtNode::Dump(const MIRModule &mod, int32 indent) const {
   if (uOpnd) {
     uOpnd->Dump(mod, indent);
   }
-  LogInfo::MapleLogger() << ")" << std::endl;
+  LogInfo::MapleLogger() << ")\n";
 }
 
 void UnaryStmtNode::Dump(const MIRModule &mod) const {
@@ -807,12 +807,12 @@ void IfStmtNode::Dump(const MIRModule &mod, int32 indent) const {
   thenPart->Dump(mod, indent);
   if (elsePart) {
     PrintIndentation(indent);
-    LogInfo::MapleLogger() << "else {" << std::endl;
+    LogInfo::MapleLogger() << "else {\n";
     for (auto &stmt : elsePart->GetStmtNodes()) {
       stmt.Dump(mod, indent + 1);
     }
     PrintIndentation(indent);
-    LogInfo::MapleLogger() << "}" << std::endl;
+    LogInfo::MapleLogger() << "}\n";
   }
 }
 
@@ -824,14 +824,14 @@ void WhileStmtNode::Dump(const MIRModule &mod, int32 indent) const {
     LogInfo::MapleLogger() << ")";
     body->Dump(mod, indent);
   } else {  // OP_dowhile
-    LogInfo::MapleLogger() << " {" << std::endl;
+    LogInfo::MapleLogger() << " {\n";
     for (auto &stmt : body->GetStmtNodes()) {
       stmt.Dump(mod, indent + 1);
     }
     PrintIndentation(indent);
     LogInfo::MapleLogger() << "} (";
     Opnd()->Dump(mod, indent);
-    LogInfo::MapleLogger() << ")" << std::endl;
+    LogInfo::MapleLogger() << ")\n";
   }
 }
 
@@ -839,10 +839,10 @@ void DoloopNode::DumpDoVar(const MIRModule &mod) const {
   if (isPreg) {
     LogInfo::MapleLogger() << " %"
                            << mod.CurFunction()->GetPregTab()->PregFromPregIdx(doVarStIdx.FullIdx())->GetPregNo()
-                           << " (" << std::endl;
+                           << " (\n";
   } else {
     const MIRSymbol *st = mod.CurFunction()->GetLocalOrGlobalSymbol(doVarStIdx);
-    LogInfo::MapleLogger() << " %" << st->GetName().c_str() << " (" << std::endl;
+    LogInfo::MapleLogger() << " %" << st->GetName().c_str() << " (\n";
   }
 }
 
@@ -851,10 +851,10 @@ void DoloopNode::Dump(const MIRModule &mod, int32 indent) const {
   DumpDoVar(mod);
   PrintIndentation(indent + 1);
   startExpr->Dump(mod, indent + 1);
-  LogInfo::MapleLogger() << "," << std::endl;
+  LogInfo::MapleLogger() << ",\n";
   PrintIndentation(indent + 1);
   condExpr->Dump(mod, indent + 1);
-  LogInfo::MapleLogger() << "," << std::endl;
+  LogInfo::MapleLogger() << ",\n";
   PrintIndentation(indent + 1);
   incrExpr->Dump(mod, indent + 1);
   LogInfo::MapleLogger() << ")";
@@ -876,7 +876,7 @@ void ForeachelemNode::Dump(const MIRModule &mod, int32 indent) const {
 void BinaryStmtNode::Dump(const MIRModule &mod, int32 indent) const {
   StmtNode::DumpBase(mod, indent);
   BinaryOpnds::Dump(mod, indent);
-  LogInfo::MapleLogger() << std::endl;
+  LogInfo::MapleLogger() << '\n';
 }
 
 void AssertStmtNode::Dump(const MIRModule &mod, int32 indent) const {
@@ -886,13 +886,13 @@ void AssertStmtNode::Dump(const MIRModule &mod, int32 indent) const {
 void NaryStmtNode::Dump(const MIRModule &mod, int32 indent) const {
   StmtNode::DumpBase(mod, indent);
   NaryOpnds::Dump(mod, indent);
-  LogInfo::MapleLogger() << std::endl;
+  LogInfo::MapleLogger() << '\n';
 }
 
 void DumpCallReturns(const MIRModule &mod, CallReturnVector nrets, int32 indent) {
   const MIRFunction *mirFunc = mod.CurFunction();
   if (nrets.empty()) {
-    LogInfo::MapleLogger() << " {}" << std::endl;
+    LogInfo::MapleLogger() << " {}\n";
     return;
   } else if (nrets.size() == 1) {
     StIdx stIdx = nrets.begin()->first;
@@ -903,7 +903,7 @@ void DumpCallReturns(const MIRModule &mod, CallReturnVector nrets, int32 indent)
       uint16 fieldID = regFieldPair.GetFieldID();
       LogInfo::MapleLogger() << " { dassign ";
       LogInfo::MapleLogger() << (stIdx.Islocal() ? "%" : "$");
-      LogInfo::MapleLogger() << st->GetName() << " " << fieldID << " }" << std::endl;
+      LogInfo::MapleLogger() << st->GetName() << " " << fieldID << " }\n";
       return;
     } else {
       PregIdx16 regIdx = regFieldPair.GetPregIdx();
@@ -911,11 +911,11 @@ void DumpCallReturns(const MIRModule &mod, CallReturnVector nrets, int32 indent)
       ASSERT(mirPreg != nullptr, "mirPreg is null");
       LogInfo::MapleLogger() << " { regassign";
       LogInfo::MapleLogger() << " " << GetPrimTypeName(mirPreg->GetPrimType());
-      LogInfo::MapleLogger() << " %" << mirPreg->GetPregNo() << "}" << std::endl;
+      LogInfo::MapleLogger() << " %" << mirPreg->GetPregNo() << "}\n";
       return;
     }
   }
-  LogInfo::MapleLogger() << " {" << std::endl;
+  LogInfo::MapleLogger() << " {\n";
   for (auto it = nrets.begin(); it != nrets.end(); it++) {
     PrintIndentation(indent + 2);
     StIdx stIdx = (it)->first;
@@ -926,18 +926,18 @@ void DumpCallReturns(const MIRModule &mod, CallReturnVector nrets, int32 indent)
       const MIRSymbol *st = mirFunc->GetLocalOrGlobalSymbol(stIdx);
       ASSERT(st != nullptr, "st is null");
       LogInfo::MapleLogger() << (stIdx.Islocal() ? " %" : " $");
-      LogInfo::MapleLogger() << st->GetName() << " " << fieldID << std::endl;
+      LogInfo::MapleLogger() << st->GetName() << " " << fieldID << '\n';
     } else {
       PregIdx16 regidx = regFieldPair.GetPregIdx();
       const MIRPreg *mirPreg = mirFunc->GetPregItem(static_cast<PregIdx>(regidx));
       ASSERT(mirPreg != nullptr, "mirPreg is null");
       LogInfo::MapleLogger() << "regassign"
                              << " " << GetPrimTypeName(mirPreg->GetPrimType());
-      LogInfo::MapleLogger() << " %" << mirPreg->GetPregNo() << std::endl;
+      LogInfo::MapleLogger() << " %" << mirPreg->GetPregNo() << '\n';
     }
   }
   PrintIndentation(indent + 1);
-  LogInfo::MapleLogger() << "}" << std::endl;
+  LogInfo::MapleLogger() << "}\n";
 }
 
 MIRType *CallNode::GetCallReturnType() {
@@ -979,7 +979,7 @@ void CallNode::Dump(const MIRModule &mod, int32 indent, bool newline) const {
   if (kOpcodeInfo.IsCallAssigned(GetOpCode())) {
     DumpCallReturns(mod, this->GetReturnVec(), indent);
   } else if (newline) {
-    LogInfo::MapleLogger() << std::endl;
+    LogInfo::MapleLogger() << '\n';
   }
 }
 
@@ -993,7 +993,7 @@ void IcallNode::Dump(const MIRModule &mod, int32 indent, bool newline) const {
   if (kOpcodeInfo.IsCallAssigned(GetOpCode())) {
     DumpCallReturns(mod, this->returnValues, indent);
   } else if (newline) {
-    LogInfo::MapleLogger() << std::endl;
+    LogInfo::MapleLogger() << '\n';
   }
 }
 
@@ -1019,7 +1019,7 @@ void IntrinsiccallNode::Dump(const MIRModule &mod, int32 indent, bool newline) c
   if (kOpcodeInfo.IsCallAssigned(GetOpCode())) {
     DumpCallReturns(mod, this->GetReturnVec(), indent);
   } else if (newline) {
-    LogInfo::MapleLogger() << std::endl;
+    LogInfo::MapleLogger() << '\n';
   }
 }
 
@@ -1029,21 +1029,21 @@ void CallinstantNode::Dump(const MIRModule &mod, int32 indent, bool newline) con
   LogInfo::MapleLogger() << " &" << func->GetName();
   MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(instVecTyIdx);
   LogInfo::MapleLogger() << "<";
-  MIRInstantVectorType *instVecType = static_cast<MIRInstantVectorType*>(ty);
+  auto *instVecType = static_cast<MIRInstantVectorType*>(ty);
   instVecType->Dump(indent);
   LogInfo::MapleLogger() << ">";
   NaryOpnds::Dump(mod, indent);
   if (kOpcodeInfo.IsCallAssigned(GetOpCode())) {
     DumpCallReturns(mod, this->GetReturnVec(), indent);
   } else if (newline) {
-    LogInfo::MapleLogger() << std::endl;
+    LogInfo::MapleLogger() << '\n';
   }
 }
 
 void BlockNode::Dump(const MIRModule &mod, int32 indent, const MIRSymbolTable *theSymTab, MIRPregTable *thePregTab,
                      bool withInfo, bool isFuncbody) const {
   if (!withInfo) {
-    LogInfo::MapleLogger() << " {" << std::endl;
+    LogInfo::MapleLogger() << " {\n";
   }
   // output puid for debugging purpose
   if (isFuncbody) {
@@ -1060,13 +1060,13 @@ void BlockNode::Dump(const MIRModule &mod, int32 indent, const MIRSymbolTable *t
         } else {
           type->Dump(indent + 2);
         }
-        LogInfo::MapleLogger() << std::endl;
+        LogInfo::MapleLogger() << '\n';
       }
       // print the locally declared variables
       theSymTab->Dump(true, indent + 1);
       thePregTab->DumpRef(indent + 1);
     }
-    LogInfo::MapleLogger() << std::endl;
+    LogInfo::MapleLogger() << '\n';
     for (std::pair<GStrIdx, MIRAliasVars> it : mod.CurFunction()->GetAliasVarMap()) {
       LogInfo::MapleLogger() << "ALIAS %" << GlobalTables::GetStrTable().GetStringFromStrIdx(it.first) << " %"
                              << GlobalTables::GetStrTable().GetStringFromStrIdx(it.second.memPoolStrIdx) << " ";
@@ -1074,25 +1074,25 @@ void BlockNode::Dump(const MIRModule &mod, int32 indent, const MIRSymbolTable *t
       if (it.second.sigStrIdx.GetIdx()) {
         LogInfo::MapleLogger() << " \"" << GlobalTables::GetStrTable().GetStringFromStrIdx(it.second.sigStrIdx) << "\"";
       }
-      LogInfo::MapleLogger() << std::endl;
+      LogInfo::MapleLogger() << '\n';
     }
   }
   if (srcPosition.FileNum() != 0 && srcPosition.LineNum() != 0 && srcPosition.LineNum() != lastPrintedLineNum &&
       mod.CurFunction()->WithLocInfo()) {
-    LogInfo::MapleLogger() << "LOC " << srcPosition.FileNum() << " " << srcPosition.LineNum() << std::endl;
+    LogInfo::MapleLogger() << "LOC " << srcPosition.FileNum() << " " << srcPosition.LineNum() << '\n';
     lastPrintedLineNum = srcPosition.LineNum();
   }
   for (auto &stmt : GetStmtNodes()) {
     stmt.Dump(mod, indent + 1);
   }
   PrintIndentation(indent);
-  LogInfo::MapleLogger() << "}" << std::endl;
+  LogInfo::MapleLogger() << "}\n";
 }
 
 void LabelNode::Dump(const MIRModule &mod, int32 indent) const {
   if (srcPosition.FileNum() != 0 && srcPosition.LineNum() != 0 && srcPosition.LineNum() != lastPrintedLineNum &&
       mod.CurFunction()->WithLocInfo()) {
-    LogInfo::MapleLogger() << "LOC " << srcPosition.FileNum() << " " << srcPosition.LineNum() << std::endl;
+    LogInfo::MapleLogger() << "LOC " << srcPosition.FileNum() << " " << srcPosition.LineNum() << '\n';
     lastPrintedLineNum = srcPosition.LineNum();
   }
   LogInfo::MapleLogger() << "@" << mod.CurFunction()->GetLabelName(labelIdx) << " ";
@@ -1101,11 +1101,11 @@ void LabelNode::Dump(const MIRModule &mod, int32 indent) const {
 void CommentNode::Dump(const MIRModule &mod, int32 indent) const {
   if (srcPosition.FileNum() != 0 && srcPosition.LineNum() != 0 && srcPosition.LineNum() != lastPrintedLineNum &&
       mod.CurFunction()->WithLocInfo()) {
-    LogInfo::MapleLogger() << "LOC " << srcPosition.FileNum() << " " << srcPosition.LineNum() << std::endl;
+    LogInfo::MapleLogger() << "LOC " << srcPosition.FileNum() << " " << srcPosition.LineNum() << '\n';
     lastPrintedLineNum = srcPosition.LineNum();
   }
   PrintIndentation(indent);
-  LogInfo::MapleLogger() << "#" << comment << std::endl;
+  LogInfo::MapleLogger() << "#" << comment << '\n';
 }
 
 // mirnode verification support
@@ -1301,7 +1301,7 @@ inline MIRTypeKind GetTypeKind(TyIdx tyIdx) {
 inline MIRType *GetPointedMIRType(TyIdx tyIdx) {
   MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
   CHECK_FATAL(type->GetKind() == kTypePointer, "TyIdx: %d is not pointer type", tyIdx.GetIdx());
-  MIRPtrType *ptrType = static_cast<MIRPtrType*>(type);
+  auto *ptrType = static_cast<MIRPtrType*>(type);
   return ptrType->GetPointedType();
 }
 
@@ -1318,19 +1318,19 @@ bool GetFieldType(MIRSrcLang srcLang, const MIRStructType *structType, FieldID t
   // For Java module class, find targetFid in inheritance chain firstly
   if (srcLang == kSrcLangJava) {
     if (structType->GetKind() == kTypeClass || structType->GetKind() == kTypeClassIncomplete) {
-      const MIRClassType *classType = static_cast<const MIRClassType*>(structType);
+      const auto *classType = static_cast<const MIRClassType*>(structType);
       std::stack<MIRStructType*> inheritChain;
       TyIdx parentTyIdx = classType->GetParentTyIdx();
       while (parentTyIdx.GetIdx() > 0) {
-        MIRStructType *parentType =
+        auto *parentType =
             static_cast<MIRStructType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentTyIdx));
         inheritChain.push(parentType);
         parentTyIdx = static_cast<MIRClassType*>(parentType)->GetParentTyIdx();
       }
       targetFid -= inheritChain.size();
       while (!inheritChain.empty()) {
-        MIRClassType *curClassType = static_cast<MIRClassType*>(inheritChain.top());
-        if (0 < static_cast<uint32>(targetFid) && static_cast<uint32>(targetFid) <= curClassType->GetFieldsSize()) {
+        auto *curClassType = static_cast<MIRClassType*>(inheritChain.top());
+        if (static_cast<uint32>(targetFid) > 0 && static_cast<uint32>(targetFid) <= curClassType->GetFieldsSize()) {
           tid = curClassType->GetFieldsElemt(targetFid - 1).second.first;
           return true;
         } else {
@@ -1338,7 +1338,7 @@ bool GetFieldType(MIRSrcLang srcLang, const MIRStructType *structType, FieldID t
         }
         inheritChain.pop();
       }
-      if (0 < static_cast<uint32>(targetFid) && static_cast<uint32>(targetFid) <= classType->GetFieldsSize()) {
+      if (static_cast<uint32>(targetFid) > 0 && static_cast<uint32>(targetFid) <= classType->GetFieldsSize()) {
         tid = classType->GetFieldsElemt(targetFid - 1).second.first;
         return true;
       }
@@ -1488,7 +1488,7 @@ bool IreadNode::Verify() const {
       LogInfo::MapleLogger() << "\n#Error:If field-id is not 0, then type must specify pointer to a structure\n";
     } else {
       MIRType *type = GetPointedMIRType(tyIdx);
-      MIRStructType *stty = static_cast<MIRStructType*>(type);
+      auto *stty = static_cast<MIRStructType*>(type);
       if (GetOpCode() == OP_iread && stty->GetFieldsSize() != 0) {
         if (IsStructureTypeKind(GetFieldTypeKind(stty, fieldID))) {
           if (GetPrimType() != PTY_agg) {
@@ -1659,7 +1659,7 @@ bool AddrofNode::Verify() const {
     if (fieldID != 0 && structVerf) {
       const MIRSymbol *var = theModule->CurFunction()->GetLocalOrGlobalSymbol(GetStIdx());
       MIRType *type = var->GetType();
-      MIRStructType *stty = static_cast<MIRStructType*>(type);
+      auto *stty = static_cast<MIRStructType*>(type);
       if (IsStructureTypeKind(GetFieldTypeKind(stty, fieldID))) {
         if (GetPrimType() != PTY_agg) {
           pTypeVerf = false;
diff --git a/src/maple_ir/src/mir_parser.cpp b/src/maple_ir/src/mir_parser.cpp
index 95c59205c5acc3da0080456ad63775edede152d5..df1a3e9ea0af67674ff46a62d01226f0567ad447 100644
--- a/src/maple_ir/src/mir_parser.cpp
+++ b/src/maple_ir/src/mir_parser.cpp
@@ -882,7 +882,7 @@ bool MIRParser::ParseStmtIntrinsiccall(StmtNodePtr &stmt, bool isAssigned) {
   auto *intrnCallNode = mod.CurFuncCodeMemPool()->New<IntrinsiccallNode>(mod, o);
   lexer.NextToken();
   if (o == !isAssigned ? OP_intrinsiccall : OP_intrinsiccallassigned) {
-    intrnCallNode->SetIntrinsic(GetIntrinsicId(lexer.GetTokenKind()));
+    intrnCallNode->SetIntrinsic(GetIntrinsicID(lexer.GetTokenKind()));
   } else {
     intrnCallNode->SetIntrinsic(static_cast<MIRIntrinsicID>(lexer.GetTheIntVal()));
   }
@@ -935,7 +935,7 @@ bool MIRParser::ParseStmtIntrinsiccallwithtype(StmtNodePtr &stmt, bool isAssigne
     return false;
   }
   intrnCallNode->SetTyIdx(tyIdx);
-  intrnCallNode->SetIntrinsic(GetIntrinsicId(lexer.GetTokenKind()));
+  intrnCallNode->SetIntrinsic(GetIntrinsicID(lexer.GetTokenKind()));
   lexer.NextToken();
   MapleVector<BaseNode*> opndsVec(mod.CurFuncCodeMemPoolAllocator()->Adapter());
   if (!ParseExprNaryOperand(opndsVec)) {
@@ -2545,7 +2545,7 @@ bool MIRParser::ParseExprArray(BaseNodePtr &expr) {
 }
 
 bool MIRParser::ParseIntrinsicId(IntrinsicopNode &intrnOpNode) {
-  MIRIntrinsicID intrinId = GetIntrinsicId(lexer.GetTokenKind());
+  MIRIntrinsicID intrinId = GetIntrinsicID(lexer.GetTokenKind());
   if (intrinId <= INTRN_UNDEFINED || intrinId >= INTRN_LAST) {
     Error("wrong intrinsic id ");
     return false;
diff --git a/src/maple_ir/src/mir_symbol.cpp b/src/maple_ir/src/mir_symbol.cpp
index 4c06fb8ee64db74dcc1675f59471d0a7004e385e..27465360fb99179a281f39ef2fec4a6e897b09de 100644
--- a/src/maple_ir/src/mir_symbol.cpp
+++ b/src/maple_ir/src/mir_symbol.cpp
@@ -319,7 +319,7 @@ void MIRSymbol::DumpAsLiteralVar(int32 indent) const {
 
 void MIRSymbolTable::Dump(bool isLocal, int32 indent, bool printDeleted) const {
   size_t size = symbolTable.size();
-  for (size_t i = 0; i < size; i++) {
+  for (size_t i = 0; i < size; ++i) {
     MIRSymbol *symbol = symbolTable[i];
     if (symbol == nullptr) {
       continue;
@@ -364,7 +364,7 @@ bool MIRLabelTable::AddToStringLabelMap(LabelIdx labelIdx) {
 
 void MIRPregTable::DumpRef(int32 indent) {
   MapleVector<MIRPreg*> &pRegTable = pregTable;
-  for (size_t i = 1; i < pRegTable.size(); i++) {
+  for (size_t i = 1; i < pRegTable.size(); ++i) {
     MIRPreg *mirPReg = pRegTable[i];
     if (mirPReg->GetPrimType() != PTY_ref) {
       continue;
diff --git a/src/maple_ir/src/parser.cpp b/src/maple_ir/src/parser.cpp
index 46e36e55260e4b94dddf6880996384edfb2e3b5b..17e6f3f51348d4e293cbb98e175272f604048d23 100644
--- a/src/maple_ir/src/parser.cpp
+++ b/src/maple_ir/src/parser.cpp
@@ -76,8 +76,7 @@ PregIdx MIRParser::LookupOrCreatePregIdx(uint32 pregNo, bool isRef, MIRFunction
     if (pregNo > maxPregNo) {
       maxPregNo = pregNo;
     }
-    MIRPreg *preg = nullptr;
-    preg = CreateMirPreg(pregNo);
+    MIRPreg *preg = CreateMirPreg(pregNo);
     if (isRef) {
       preg->SetPrimType(PTY_ref);
     }
@@ -108,8 +107,8 @@ inline bool IsPowerOf2(uint64 num) {
 Opcode MIRParser::GetOpFromToken(TokenKind tk) const {
   switch (tk) {
 #define OPCODE(X, Y, Z, S) \
-  case TK_##X:             \
-    return OP_##X;
+    case TK_##X:             \
+      return OP_##X;
 #include "opcodes.def"
 #undef OPCODE
     default:
@@ -133,8 +132,8 @@ PrimType MIRParser::GetPrimitiveType(TokenKind tk) const {
 #define LOAD_ALGO_PRIMARY_TYPE
   switch (tk) {
 #define PRIMTYPE(P) \
-  case TK_##P:      \
-    return PTY_##P;
+    case TK_##P:      \
+      return PTY_##P;
 #include "prim_types.def"
 #undef PRIMTYPE
     default:
@@ -142,7 +141,7 @@ PrimType MIRParser::GetPrimitiveType(TokenKind tk) const {
   }
 }
 
-MIRIntrinsicID MIRParser::GetIntrinsicId(TokenKind tk) const {
+MIRIntrinsicID MIRParser::GetIntrinsicID(TokenKind tk) const {
   switch (tk) {
     default:
 #define DEF_MIR_INTRINSIC(P, NAME, INTRN_CLASS, RETURN_TYPE, ...) \
@@ -156,8 +155,8 @@ MIRIntrinsicID MIRParser::GetIntrinsicId(TokenKind tk) const {
 void MIRParser::Error(const std::string &str) {
   std::stringstream strStream;
   const std::string &lexName = lexer.GetName();
-  int curidx = lexer.GetCurIdx() - lexName.length() + 1;
-  strStream << "line: " << lexer.GetLineNum() << ":" << curidx << ":";
+  int curIdx = lexer.GetCurIdx() - lexName.length() + 1;
+  strStream << "line: " << lexer.GetLineNum() << ":" << curIdx << ":";
   message += strStream.str();
   message += str;
   message += ": ";
@@ -178,8 +177,8 @@ const std::string &MIRParser::GetError() {
 void MIRParser::Warning(const std::string &str) {
   std::stringstream strStream;
   const std::string &lexName = lexer.GetName();
-  int curidx = lexer.GetCurIdx() - lexName.length() + 1;
-  strStream << "  >> warning line: " << lexer.GetLineNum() << ":" << curidx << ":";
+  int curIdx = lexer.GetCurIdx() - lexName.length() + 1;
+  strStream << "  >> warning line: " << lexer.GetLineNum() << ":" << curIdx << ":";
   warningMessage += strStream.str();
   warningMessage += str;
   warningMessage += "\n";
@@ -195,11 +194,11 @@ bool MIRParser::ParseSpecialReg(PregIdx &pRegIdx) {
   int32 retValSize = strlen(kLexerStringRetval);
   if (strncmp(lexName.c_str(), kLexerStringRetval, retValSize) == 0 && (lexSize > retValSize) &&
       isdigit(lexName[retValSize])) {
-    int32 retvalNo = lexName[retValSize] - '0';
+    int32 retValNo = lexName[retValSize] - '0';
     for (int32 i = retValSize + 1; (i < lexSize) && isdigit(lexName[i]); i++) {
-      retvalNo = retvalNo * 10 + lexName[i] - '0';
+      retValNo = retValNo * 10 + lexName[i] - '0';
     }
-    pRegIdx = -kSregRetval0 - retvalNo;
+    pRegIdx = -kSregRetval0 - retValNo;
     lexer.NextToken();
     return true;
   }
@@ -452,7 +451,7 @@ bool MIRParser::ParsePragmaElementForArray(MIRPragmaElement &elem) {
     return false;
   }
   for (int64 i = 0; i < size; i++) {
-    MIRPragmaElement *e0 = mod.GetMemPool()->New<MIRPragmaElement>(mod);
+    auto *e0 = mod.GetMemPool()->New<MIRPragmaElement>(mod);
     tk = lexer.NextToken();
     if (!ParsePragmaElement(*e0)) {
       Error("parsing pragma error type ");
@@ -499,7 +498,7 @@ bool MIRParser::ParsePragmaElementForAnnotation(MIRPragmaElement &elem) {
     return false;
   }
   for (int i = 0; i < size; i++) {
-    MIRPragmaElement *e0 = mod.GetMemPool()->New<MIRPragmaElement>(mod);
+    auto *e0 = mod.GetMemPool()->New<MIRPragmaElement>(mod);
     tk = lexer.NextToken();
     if (tk != TK_label) {
       Error("parsing pragma error: expecting @ but get ");
@@ -522,7 +521,7 @@ bool MIRParser::ParsePragmaElementForAnnotation(MIRPragmaElement &elem) {
 }
 
 bool MIRParser::ParsePragma(MIRStructType &type) {
-  MIRPragma *p = mod.GetMemPool()->New<MIRPragma>(mod);
+  auto *p = mod.GetMemPool()->New<MIRPragma>(mod);
   p->SetVisibility(lexer.GetTheIntVal());
   TokenKind tk = lexer.NextToken();
 
@@ -562,7 +561,7 @@ bool MIRParser::ParsePragma(MIRStructType &type) {
   }
   tk = lexer.NextToken();
   while (tk != kTkRbrace) {
-    MIRPragmaElement *e = mod.GetMemPool()->New<MIRPragmaElement>(mod);
+    auto *e = mod.GetMemPool()->New<MIRPragmaElement>(mod);
     e->SetNameStrIdx(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName()));
     tk = lexer.NextToken();
     if (!ParsePragmaElement(*e)) {
@@ -737,7 +736,7 @@ bool MIRParser::ParseFields(MIRStructType &type) {
     maple::MIRBuilder mirBuilder(&mod);
     MIRSymbol *funcSymbol = mirBuilder.CreateSymbol(TyIdx(0), strIdx, kStFunc, kScText, nullptr, kScopeGlobal);
     ASSERT(funcSymbol != nullptr, "Failed to create MIRSymbol");
-    MIRFunction *fn = mod.GetMemPool()->New<MIRFunction>(&mod, funcSymbol->GetStIdx());
+    auto *fn = mod.GetMemPool()->New<MIRFunction>(&mod, funcSymbol->GetStIdx());
     fn->Init();
     fn->SetPuidx(GlobalTables::GetFunctionTable().GetFuncTable().size());
     GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn);
@@ -752,16 +751,16 @@ bool MIRParser::ParseFields(MIRStructType &type) {
       // Skip attribute checking
       fn->SetFuncAttrs(tA);
     }
-    TyIdx funcTyidx;
-    if (!ParseFuncType(funcTyidx)) {
+    TyIdx funcTyIdx;
+    if (!ParseFuncType(funcTyIdx)) {
       return false;
     }
     // tyIdx does not work. Calling EqualTo does not work either.
-    MIRFuncType *funcType = static_cast<MIRFuncType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcTyidx));
+    auto *funcType = static_cast<MIRFuncType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcTyIdx));
     fn->SetMIRFuncType(funcType);
     fn->SetReturnStruct(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetRetTyIdx()));
-    funcSymbol->SetTyIdx(funcTyidx);
-    MethodPair p = MethodPair(funcSymbol->GetStIdx(), TyidxFuncAttrPair(funcTyidx, FuncAttrs(tA)));
+    funcSymbol->SetTyIdx(funcTyIdx);
+    MethodPair p = MethodPair(funcSymbol->GetStIdx(), TyidxFuncAttrPair(funcTyIdx, FuncAttrs(tA)));
     type.GetMethods().push_back(p);
     tk = lexer.GetTokenKind();
     if (tk == kTkComa) {
@@ -780,21 +779,20 @@ bool MIRParser::ParseFields(MIRStructType &type) {
   // interfaces_implemented
   while (tk == kTkGname) {
     tk = lexer.NextToken();
-    if ((tk == kTkComa || tk == kTkRbrace) &&
-        (tyKind == kTypeClass || tyKind == kTypeClassIncomplete)) {
-      MIRClassType *classType = static_cast<MIRClassType*>(&type);
+    if ((tk == kTkComa || tk == kTkRbrace) && (tyKind == kTypeClass || tyKind == kTypeClassIncomplete)) {
+      auto *classType = static_cast<MIRClassType*>(&type);
       std::string nameStr = lexer.GetName();
       GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(nameStr);
-      TyIdx tyidx = mod.GetTypeNameTab()->GetTyIdxFromGStrIdx(strIdx);
-      if (tyidx == 0) {
+      TyIdx tyIdx = mod.GetTypeNameTab()->GetTyIdxFromGStrIdx(strIdx);
+      if (tyIdx == 0) {
         MIRInterfaceType interfaceType(kTypeInterfaceIncomplete);
         interfaceType.SetNameStrIdx(strIdx);
-        tyidx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&interfaceType);
-        mod.AddClass(tyidx);
-        mod.AddExternStructType(tyidx);
-        mod.GetTypeNameTab()->SetGStrIdxToTyIdx(strIdx, tyidx);
+        tyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&interfaceType);
+        mod.AddClass(tyIdx);
+        mod.AddExternStructType(tyIdx);
+        mod.GetTypeNameTab()->SetGStrIdxToTyIdx(strIdx, tyIdx);
       }
-      classType->GetInterfaceImplemented().push_back(tyidx);
+      classType->GetInterfaceImplemented().push_back(tyIdx);
     }
     if (tk == kTkComa) {
       tk = lexer.NextToken();
@@ -886,7 +884,7 @@ bool MIRParser::ParseClassType(TyIdx &styidx) {
   return true;
 }
 
-bool MIRParser::ParseInterfaceType(TyIdx &styidx) {
+bool MIRParser::ParseInterfaceType(TyIdx &sTyIdx) {
   MIRTypeKind tkind = (lexer.GetTokenKind() == TK_interface) ? kTypeInterface : kTypeInterfaceIncomplete;
   std::vector<TyIdx> parents;
   TokenKind tk = lexer.NextToken();
@@ -905,26 +903,26 @@ bool MIRParser::ParseInterfaceType(TyIdx &styidx) {
   if (!ParseFields(interfaceType)) {
     return false;
   }
-  if (styidx != 0) {
-    MIRType *prevType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(styidx);
+  if (sTyIdx != 0) {
+    MIRType *prevType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(sTyIdx);
     ASSERT(prevType->GetKind() == kTypeInterface || prevType->GetKind() == kTypeInterfaceIncomplete,
            "type kind should be consistent.");
     if (static_cast<MIRInterfaceType*>(prevType)->IsIncomplete() && !(interfaceType.IsIncomplete())) {
       interfaceType.SetNameStrIdx(prevType->GetNameStrIdx());
-      interfaceType.SetTypeIndex(styidx);
-      GlobalTables::GetTypeTable().SetTypeWithTyIdx(styidx, interfaceType.CopyMIRTypeNode());
+      interfaceType.SetTypeIndex(sTyIdx);
+      GlobalTables::GetTypeTable().SetTypeWithTyIdx(sTyIdx, interfaceType.CopyMIRTypeNode());
     }
   } else {
-    styidx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&interfaceType);
+    sTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&interfaceType);
     // set up classTyIdx for methods
     for (size_t i = 0; i < interfaceType.GetMethods().size(); i++) {
-      StIdx stidx = interfaceType.GetMethodsElement(i).first;
-      MIRSymbol *st = GlobalTables::GetGsymTable().GetSymbolFromStidx(stidx.Idx());
+      StIdx stIdx = interfaceType.GetMethodsElement(i).first;
+      MIRSymbol *st = GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx());
       ASSERT(st != nullptr, "st is null");
       ASSERT(st->GetSKind() == kStFunc, "unexpected st->sKind");
-      st->GetFunction()->SetClassTyIdx(styidx);
+      st->GetFunction()->SetClassTyIdx(sTyIdx);
     }
-    mod.AddClass(styidx);
+    mod.AddClass(sTyIdx);
   }
   lexer.NextToken();
   return true;
@@ -969,9 +967,9 @@ bool MIRParser::ParseVarTypeAttrs(MIRSymbol &st) {
     switch (lexer.GetTokenKind()) {
 #define TYPE_ATTR
 #define ATTR(X)            \
-  case TK_##X:             \
-    st.SetAttr(ATTR_##X); \
-    break;
+      case TK_##X:             \
+        st.SetAttr(ATTR_##X); \
+        break;
 #include "all_attributes.def"
 #undef ATTR
 #undef TYPE_ATTR
@@ -994,9 +992,9 @@ bool MIRParser::ParseTypeAttrs(TypeAttrs &attrs) {
     switch (lexer.GetTokenKind()) {
 #define TYPE_ATTR
 #define ATTR(X)            \
-  case TK_##X:             \
-    attrs.SetAttr(ATTR_##X); \
-    break;
+      case TK_##X:             \
+        attrs.SetAttr(ATTR_##X); \
+        break;
 #include "all_attributes.def"
 #undef ATTR
 #undef TYPE_ATTR
@@ -1018,9 +1016,9 @@ bool MIRParser::ParseFieldAttrs(FieldAttrs &attrs) {
     switch (lexer.GetTokenKind()) {
 #define FIELD_ATTR
 #define ATTR(X)               \
-  case TK_##X:                \
-    attrs.SetAttr(FLDATTR_##X); \
-    break;
+      case TK_##X:                \
+        attrs.SetAttr(FLDATTR_##X); \
+        break;
 #include "all_attributes.def"
 #undef ATTR
 #undef FIELD_ATTR
@@ -1043,9 +1041,9 @@ bool MIRParser::ParseFuncAttrs(FuncAttrs &attrs) {
     switch (lexer.GetTokenKind()) {
 #define FUNC_ATTR
 #define ATTR(X)                \
-  case TK_##X:                 \
-    attrs.SetAttr(FUNCATTR_##X); \
-    break;
+      case TK_##X:                 \
+        attrs.SetAttr(FUNCATTR_##X); \
+        break;
 #include "all_attributes.def"
 #undef ATTR
 #undef FUNC_ATTR
@@ -1069,8 +1067,8 @@ bool MIRParser::ParsePrimType(TyIdx &tyIdx) {
 }
 
 bool MIRParser::ParseTypeParam(TyIdx &definedTyIdx) {
-  GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
-  MIRTypeParam typeParm(stridx);
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+  MIRTypeParam typeParm(strIdx);
   definedTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&typeParm);
   lexer.NextToken();
   return true;
@@ -1090,7 +1088,7 @@ bool MIRParser::ParseDefinedTypename(TyIdx &definedTyIdx, MIRTypeKind kind) {
   TyIdx prevTypeIdx(0);
   if (definedTyIdx.GetIdx()) {
     MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(definedTyIdx);
-    MIRStructType *stype = dynamic_cast<MIRStructType*>(type);
+    auto *stype = dynamic_cast<MIRStructType*>(type);
     if (stype != nullptr) {
       // check whether need to update from incomplete class to interface
       if (stype->GetKind() == kind) {
@@ -1372,7 +1370,7 @@ void MIRParser::FixupForwardReferencedTypeByMap() {
   for (size_t i = 1; i < GlobalTables::GetTypeTable().GetTypeTable().size(); i++) {
     MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(i));
     if (type->GetKind() == kTypePointer) {
-      MIRPtrType *ptrType = static_cast<MIRPtrType*>(type);
+      auto *ptrType = static_cast<MIRPtrType*>(type);
       std::map<TyIdx, TyIdx>::iterator it = typeDefIdxMap.find(ptrType->GetPointedTyIdx());
       if (it != typeDefIdxMap.end()) {
         ptrType->SetPointedTyIdx(it->second);
@@ -1382,7 +1380,7 @@ void MIRParser::FixupForwardReferencedTypeByMap() {
                type->GetKind() == kTypeClassIncomplete || type->GetKind() == kTypeInterface ||
                type->GetKind() == kTypeInterfaceIncomplete) {
       if (type->GetKind() == kTypeClass || type->GetKind() == kTypeClassIncomplete) {
-        MIRClassType *classType = static_cast<MIRClassType*>(type);
+        auto *classType = static_cast<MIRClassType*>(type);
         std::map<TyIdx, TyIdx>::iterator it = typeDefIdxMap.find(classType->GetParentTyIdx());
         if (it != typeDefIdxMap.end()) {
           classType->SetParentTyIdx(it->second);
@@ -1394,7 +1392,7 @@ void MIRParser::FixupForwardReferencedTypeByMap() {
           }
         }
       } else if (type->GetKind() == kTypeInterface || type->GetKind() == kTypeInterfaceIncomplete) {
-        MIRInterfaceType *interfaceType = static_cast<MIRInterfaceType*>(type);
+        auto *interfaceType = static_cast<MIRInterfaceType*>(type);
         for (uint32 j = 0; j < interfaceType->GetParentsTyIdx().size(); j++) {
           std::map<TyIdx, TyIdx>::iterator it = typeDefIdxMap.find(interfaceType->GetParentsElementTyIdx(j));
           if (it != typeDefIdxMap.end()) {
@@ -1402,7 +1400,7 @@ void MIRParser::FixupForwardReferencedTypeByMap() {
           }
         }
       }
-      MIRStructType *structType = static_cast<MIRStructType*>(type);
+      auto *structType = static_cast<MIRStructType*>(type);
       for (uint32 j = 0; j < structType->GetFieldsSize(); j++) {
         TyIdx fieldTyIdx = structType->GetElemTyIdx(j);
         std::map<TyIdx, TyIdx>::iterator it = typeDefIdxMap.find(fieldTyIdx);
@@ -2000,8 +1998,8 @@ bool MIRParser::ParseInitValue(MIRConstPtr &theConst, TyIdx tyIdx) {
             for (uint16 i = 1; i < arrayType.GetDim(); i++) {
               sizeSubArray.push_back(arrayType.GetSizeArrayItem(i));
             }
-            MIRArrayType subArraytype(elemType->GetTypeIndex(), sizeSubArray);
-            TyIdx arrayTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&subArraytype);
+            MIRArrayType subArrayType(elemType->GetTypeIndex(), sizeSubArray);
+            TyIdx arrayTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&subArrayType);
             if (!ParseInitValue(subConst, arrayTyIdx)) {
               Error("initializaton value wrong when parsing sub array ");
               return false;
@@ -2092,7 +2090,7 @@ bool MIRParser::ParseInitValue(MIRConstPtr &theConst, TyIdx tyIdx) {
   return true;
 }
 
-bool MIRParser::ParseFuncInfo(void) {
+bool MIRParser::ParseFuncInfo() {
   if (lexer.GetTokenKind() != kTkLbrace) {
     Error("expect left brace after funcinfo but get ");
     return false;
@@ -2188,15 +2186,15 @@ uint8 *MIRParser::ParseWordsInfo(uint32 size) {
 
 static void GenJStringType(MIRModule &module) {
   MIRStructType metaClassType(kTypeStructIncomplete);
-  GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("dummy");
-  metaClassType.GetFields().push_back(FieldPair(stridx, TyIdxFieldAttrPair(TyIdx(PTY_ref), FieldAttrs())));
-  stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("__class_meta__");
-  TyIdx tyidx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&metaClassType);
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("dummy");
+  metaClassType.GetFields().push_back(FieldPair(strIdx, TyIdxFieldAttrPair(TyIdx(PTY_ref), FieldAttrs())));
+  strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("__class_meta__");
+  TyIdx tyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&metaClassType);
   // Global
-  module.GetTypeNameTab()->SetGStrIdxToTyIdx(stridx, tyidx);
+  module.GetTypeNameTab()->SetGStrIdxToTyIdx(strIdx, tyIdx);
   ASSERT(GlobalTables::GetTypeTable().GetTypeTable().empty() == false, "container check");
-  if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyidx)->GetNameStrIdx() == 0) {
-    GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyidx)->SetNameStrIdx(stridx);
+  if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->GetNameStrIdx() == 0) {
+    GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx)->SetNameStrIdx(strIdx);
   }
 }
 
@@ -2505,15 +2503,15 @@ bool MIRParser::ParseMIRForFileInfo() {
   }
   TokenKind tk = lexer.NextToken();
   while (tk == TK_label) {
-    GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
     tk = lexer.NextToken();
     if (tk == kTkIntconst) {
       uint32 fieldVal = lexer.GetTheIntVal();
-      mod.PushFileInfoPair(MIRInfoPair(stridx, fieldVal));
+      mod.PushFileInfoPair(MIRInfoPair(strIdx, fieldVal));
       mod.PushFileInfoIsString(false);
     } else if (tk == kTkString) {
       GStrIdx litStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
-      mod.PushFileInfoPair(MIRInfoPair(stridx, litStrIdx.GetIdx()));
+      mod.PushFileInfoPair(MIRInfoPair(strIdx, litStrIdx.GetIdx()));
       mod.PushFileInfoIsString(true);
     } else {
       Error("illegal value after fileInfo field name at ");
@@ -2543,15 +2541,15 @@ bool MIRParser::ParseMIRForFileData() {
   }
   TokenKind tk = lexer.NextToken();
   while (tk == TK_label) {
-    GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+    GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
     tk = lexer.NextToken();
     std::vector<uint8> data;
     while (tk == kTkIntconst) {
-      uint32 fieldval = lexer.GetTheIntVal();
-      data.push_back(fieldval);
+      uint32 fieldVal = lexer.GetTheIntVal();
+      data.push_back(fieldVal);
       tk = lexer.NextToken();
     }
-    mod.PushbackFileData(MIRDataPair(stridx, data));
+    mod.PushbackFileData(MIRDataPair(strIdx, data));
     if (tk == kTkComa) {
       tk = lexer.NextToken();
     } else if (tk == kTkRbrace) {
@@ -2574,11 +2572,11 @@ bool MIRParser::ParseMIRForSrcFileInfo() {
   }
   TokenKind tk = lexer.NextToken();
   while (tk == kTkIntconst) {
-    uint32 fieldval = lexer.GetTheIntVal();
+    uint32 fieldVal = lexer.GetTheIntVal();
     tk = lexer.NextToken();
     if (tk == kTkString) {
-      GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
-      mod.PushbackFileInfo(MIRInfoPair(stridx, fieldval));
+      GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+      mod.PushbackFileInfo(MIRInfoPair(strIdx, fieldVal));
     } else {
       Error("illegal value after srcfileinfo field name at ");
       return false;
@@ -2625,7 +2623,6 @@ bool MIRParser::ParseMIRForImport() {
         FATAL(kLncFatal, "cannot open MPLT file: %s\n", importFileName.c_str());
       }
       bool failedParse = !ParseMPLT(mpltFile, importFileName);
-      mpltFile.close();
       if (failedParse) {  // parse the mplt file
         return false;
       }
@@ -2638,7 +2635,6 @@ bool MIRParser::ParseMIRForImport() {
         FATAL(kLncFatal, "cannot open MPLT file: %s\n", importFileName.c_str());
       }
       bool failedParse = !ParseMPLT(mpltFile, importFileName);
-      mpltFile.close();
       if (failedParse) {  // parse the mplt file
         return false;
       }
diff --git a/src/maple_ir/src/printing.cpp b/src/maple_ir/src/printing.cpp
index 782933bab92d3cc1ee7a691325a514396d5a91d5..10d6bef899a25fa9428aefb9b4f754a6daba9ddb 100644
--- a/src/maple_ir/src/printing.cpp
+++ b/src/maple_ir/src/printing.cpp
@@ -17,10 +17,9 @@
 #include "mir_module.h"
 #include "types_def.h"
 
-constexpr int kIndentunit = 2;  // number of blank chars of each indentation
-
 namespace maple {
-std::string const kBlankString = "                                                                                ";
+const std::string kBlankString = "                                                                                ";
+constexpr int kIndentunit = 2;  // number of blank chars of each indentation
 
 void PrintIndentation(int32 indent) {
   int64 indentAmount = static_cast<int64>(indent) * kIndentunit;
diff --git a/src/maple_me/include/alias_analysis_table.h b/src/maple_me/include/alias_analysis_table.h
index 25e8d8b7baa0e5ad595c707a50a8a75c1faae53e..2ed17ac37c4a0460a5fca5c4e97b28acfba1b6dc 100644
--- a/src/maple_me/include/alias_analysis_table.h
+++ b/src/maple_me/include/alias_analysis_table.h
@@ -33,14 +33,12 @@ class AliasAnalysisTable {
   OriginalSt *GetPrevLevelNode(const OriginalSt &ost);
   MapleVector<OriginalSt*> *GetNextLevelNodes(const OriginalSt &ost);
   OriginalSt *FindOrCreateAddrofSymbolOriginalSt(OriginalSt &ost);
-  OriginalSt *FindOrCreateExtraLevSymOrRegOriginalSt(OriginalSt &ost, TyIdx ptyidx, FieldID fld);
   OriginalSt *FindOrCreateExtraLevOriginalSt(OriginalSt &ost, TyIdx ptyidx, FieldID fld);
-  OriginalSt *FindExtraLevOriginalSt(const MapleVector<OriginalSt*> &nextLevelOsts, FieldID fld);
-  OriginalSt *FindOrCreateDiffFieldOriginalSt(OriginalSt &ost, FieldID fld);
-  OriginalSt *FindDiffFieldOriginalSt(const OriginalSt &ost, FieldID fld);
   ~AliasAnalysisTable() = default;
 
  private:
+  OriginalSt *FindOrCreateExtraLevSymOrRegOriginalSt(OriginalSt &ost, TyIdx ptyidx, FieldID fld);
+  OriginalSt *FindExtraLevOriginalSt(const MapleVector<OriginalSt*> &nextLevelOsts, FieldID fld);
   SSATab &ssaTab;
   MapleAllocator alloc;
   MIRModule &mirModule;
diff --git a/src/maple_me/include/alias_class.h b/src/maple_me/include/alias_class.h
index f5cf1074cc64ba316f5fc0ff1a93bf4460559402..7bf49e13aeb5f22f715c701c983baa6d36e6e0d8 100644
--- a/src/maple_me/include/alias_class.h
+++ b/src/maple_me/include/alias_class.h
@@ -210,7 +210,7 @@ class AliasClass : public AnalysisResult {
   bool IsEquivalentField(TyIdx tyIdxA, FieldID fldA, TyIdx tyIdxB, FieldID fldB) const;
   void CollectMayDefForIassign(StmtNode &stmt, std::set<OriginalSt*> &mayDefOsts);
   void InsertMayDefNodeExcludeFinalOst(std::set<OriginalSt*> &mayDefOsts, MapleMap<OStIdx, MayDefNode> &mayDefNodes,
-                                       StmtNode &stmt, BBId bbid);
+                                       StmtNode &stmt);
   void InsertMayDefIassign(StmtNode &stmt, BBId bbid);
   void InsertMayDefUseSyncOps(StmtNode &stmt, BBId bbid);
   void InsertMayUseNodeExcludeFinalOst(const std::set<OriginalSt*> &mayUseOsts,
diff --git a/src/maple_me/include/me_option.h b/src/maple_me/include/me_option.h
index 6c118f6abc17812152f22da48a05be166447da51..18be4d30e5b4cd2c8b3c0a6a80e5bc470a69513b 100644
--- a/src/maple_me/include/me_option.h
+++ b/src/maple_me/include/me_option.h
@@ -25,9 +25,10 @@ class MeOption {
  public:
   explicit MeOption(MemPool &memPool) : optionAlloc(&memPool) {}
 
-  void ParseOptions(int argc, char **argv, std::string &fileName);
   ~MeOption() = default;
 
+  void ParseOptions(int argc, char **argv, std::string &fileName);
+
   static bool DumpPhase(const std::string &phase);
   static std::unordered_set<std::string> dumpPhases;
   enum Level {
@@ -70,7 +71,7 @@ class MeOption {
 #ifndef DEBUGFUNC
 #define DEBUGFUNC(f)                                                       \
   (MeOption::dumpPhases.find(PhaseName()) != MeOption::dumpPhases.end() && \
-   (MeOption::dumpFunc.compare("*") == 0 || f->GetName().find(MeOption::dumpFunc) != std::string::npos))
+   (MeOption::dumpFunc.compare("*") == 0 || (f)->GetName().find(MeOption::dumpFunc) != std::string::npos))
 #endif
 }  // namespace maple
 #endif  // MAPLE_ME_INCLUDE_ME_OPTION_H
diff --git a/src/maple_me/include/me_phase.h b/src/maple_me/include/me_phase.h
index 2aa4f9650deff0740fdae8332f103b61df9df919..198920ad126bbcc38b81711c61ca9baaba1d407d 100644
--- a/src/maple_me/include/me_phase.h
+++ b/src/maple_me/include/me_phase.h
@@ -37,8 +37,6 @@ class MeFuncPhase : public Phase {
  public:
   explicit MeFuncPhase(MePhaseID id) : Phase() {
     phaseID = id;
-    prevPhaseName = ""; // init prev_phasename is nullptr
-    isCFGChanged = false;
   }
 
   virtual ~MeFuncPhase() = default;
@@ -76,8 +74,8 @@ class MeFuncPhase : public Phase {
 
  private:
   MePhaseID phaseID;
-  std::string prevPhaseName; // used in filename for emit
-  bool isCFGChanged;         // is this phase changed CFG
+  std::string prevPhaseName = ""; // used in filename for emit, init prev_phasename as nullptr
+  bool isCFGChanged = false;      // is this phase changed CFG
 };
 }  // namespace maple
 #endif  // MAPLE_ME_INCLUDE_ME_PHASE_H
diff --git a/src/maple_me/include/me_ssa.h b/src/maple_me/include/me_ssa.h
index 9922eee9ce34c6bcdc882d42790c0b92fe52b0bc..78d56e2a4b1930f0a105b927a9f1884c48a0b31e 100644
--- a/src/maple_me/include/me_ssa.h
+++ b/src/maple_me/include/me_ssa.h
@@ -29,10 +29,10 @@ class MeSSA : public SSA, public AnalysisResult {
   ~MeSSA() = default;
 
   void BuildSSA();
-  bool VerifySSA() const;
+  void VerifySSA() const;
 
  private:
-  bool VerifySSAOpnd(const BaseNode &node) const;
+  void VerifySSAOpnd(const BaseNode &node) const;
   void CollectDefBBs(std::map<OStIdx, std::set<BBId>> &ostDefBBs);
   void InsertPhiNode();
   void RenameBB(BB&);
diff --git a/src/maple_me/include/orig_symbol.h b/src/maple_me/include/orig_symbol.h
index 4fc4c1a5acca356ddc5b02ae3251632e211389a5..608ea8b7a9dee8a050fe0a8294cf69445495dedb 100644
--- a/src/maple_me/include/orig_symbol.h
+++ b/src/maple_me/include/orig_symbol.h
@@ -340,8 +340,8 @@ class OriginalStTable {
   // malloc info to virtual variables in original table. this only exists for no-original variables.
   MapleMap<std::pair<BaseNode*, uint32>, OStIdx> malloc2Ost;
   MapleMap<uint32, OStIdx> thisField2Ost;  // field of this_memory to virtual variables in original table.
-  OStIdx virtuaLostUnkownMem;
-  OStIdx virtuaLostConstMem;
+  OStIdx virtuaLostUnkownMem{ 0 };
+  OStIdx virtuaLostConstMem{ 0 };
 };
 }  // namespace maple
 
diff --git a/src/maple_me/src/alias_analysis_table.cpp b/src/maple_me/src/alias_analysis_table.cpp
index 32d15aff1848fd9dadaeac7d8ee2f5dd4f66c2b8..190f7ee79ccf84cd854ab8c3b7edfa86ecda545f 100644
--- a/src/maple_me/src/alias_analysis_table.cpp
+++ b/src/maple_me/src/alias_analysis_table.cpp
@@ -116,53 +116,4 @@ OriginalSt *AliasAnalysisTable::FindExtraLevOriginalSt(const MapleVector<Origina
   }
   return nullptr;
 }
-
-OriginalSt *AliasAnalysisTable::FindOrCreateDiffFieldOriginalSt(OriginalSt &ost, FieldID fld) {
-  OriginalSt *parentOst = prevLevelNode[ost.GetIndex()];
-  if (parentOst == nullptr) {
-    ASSERT(ost.IsSymbolOst(), "only SymbolOriginalSt expected");
-    parentOst = FindOrCreateAddrofSymbolOriginalSt(ost);
-  }
-  MapleVector<OriginalSt*> *nextLevelOsts = GetNextLevelNodes(ost);
-  OriginalSt *nextLevOst = FindExtraLevOriginalSt(*nextLevelOsts, fld);
-  if (nextLevOst != nullptr) {
-    return nextLevOst;
-  }
-
-  // create a new node
-  TyIdxFieldAttrPair nextLevFieldPair;
-  if (parentOst->GetTyIdx() != 0) {
-    MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentOst->GetTyIdx());
-    if (mirType->GetKind() == kTypePointer) {
-      MIRPtrType *ptType = static_cast<MIRPtrType*>(mirType);
-      nextLevFieldPair = ptType->GetPointedTyIdxFldAttrPairWithFieldID(fld);
-    }
-  }
-  OriginalStTable *originalStTab = &(ssaTab.GetOriginalStTable());
-  if (parentOst->IsSymbolOst()) {
-    nextLevOst = memPool->New<OriginalSt>(originalStTab->Size(), *parentOst->GetMIRSymbol(),
-                                          parentOst->GetPuIdx(), fld, originalStTab->GetAlloc());
-    originalStTab->GetOriginalStVector().push_back(nextLevOst);
-    ASSERT(parentOst->GetIndirectLev() < INT8_MAX, "boundary check");
-    nextLevOst->SetIndirectLev(parentOst->GetIndirectLev() + 1);
-    prevLevelNode.insert(std::make_pair(nextLevOst->GetIndex(), parentOst));
-    nextLevOst->SetTyIdx(nextLevFieldPair.first);
-    bool isFinal = nextLevFieldPair.second.GetAttr(FLDATTR_final) && !mirModule.CurFunction()->IsConstructor();
-    nextLevOst->SetIsFinal(isFinal);
-    ASSERT(!GlobalTables::GetTypeTable().GetTypeTable().empty(), "container check");
-    if (GlobalTables::GetTypeTable().GetTypeFromTyIdx(parentOst->GetTyIdx())->PointsToConstString()) {
-      nextLevOst->SetIsFinal(true);
-    }
-    nextLevOst->SetIsPrivate(nextLevFieldPair.second.GetAttr(FLDATTR_private));
-    nextLevelOsts->push_back(nextLevOst);
-    return nextLevOst;
-  }
-  return nullptr;
-}
-
-OriginalSt *AliasAnalysisTable::FindDiffFieldOriginalSt(const OriginalSt &ost, FieldID fld) {
-  OriginalSt *parentOst = prevLevelNode[ost.GetIndex()];
-  MapleVector<OriginalSt*> *nextLevelOsts = GetNextLevelNodes(*parentOst);
-  return FindExtraLevOriginalSt(*nextLevelOsts, fld);
-}
 }  // namespace maple
diff --git a/src/maple_me/src/alias_class.cpp b/src/maple_me/src/alias_class.cpp
index 5060e248a0b382ac75e183872dc899552b9b4c9d..cb1ae2be7c3bafefe2cb519b13e445047e1085c8 100644
--- a/src/maple_me/src/alias_class.cpp
+++ b/src/maple_me/src/alias_class.cpp
@@ -201,12 +201,12 @@ void AliasClass::ApplyUnionForCopies(StmtNode &stmt) {
     case OP_dassign:
     case OP_regassign: {
       // RHS
-      ASSERT(stmt.Opnd(0) != nullptr, "nullptr check");
+      ASSERT_NOT_NULL(stmt.Opnd(0));
       AliasElem *rhsAe = CreateAliasElemsExpr(*stmt.Opnd(0));
       // LHS
       OriginalSt *ost = ssaTab.GetStmtsSSAPart().GetAssignedVarOf(stmt)->GetOrigSt();
       AliasElem *lhsAe = FindOrCreateAliasElem(*ost);
-      ASSERT(lhsAe != nullptr, "aliaselem of lhs should not be null");
+      ASSERT_NOT_NULL(lhsAe);
       ApplyUnionForDassignCopy(*lhsAe, rhsAe, *stmt.Opnd(0));
       return;
     }
@@ -790,7 +790,7 @@ void AliasClass::CollectMayDefForIassign(StmtNode &stmt, std::set<OriginalSt*> &
 }
 
 void AliasClass::InsertMayDefNodeExcludeFinalOst(std::set<OriginalSt*> &mayDefOsts,
-                                                 MapleMap<OStIdx, MayDefNode> &mayDefNodes, StmtNode &stmt, BBId bbID) {
+                                                 MapleMap<OStIdx, MayDefNode> &mayDefNodes, StmtNode &stmt) {
   for (OriginalSt *mayDefOst : mayDefOsts) {
     if (!mayDefOst->IsFinal()) {
       mayDefNodes.insert(std::make_pair(
@@ -807,7 +807,7 @@ void AliasClass::InsertMayDefIassign(StmtNode &stmt, BBId bbID) {
   if (mayDefOsts.size() == 1) {
     InsertMayDefNode(mayDefOsts, mayDefNodes, stmt, bbID);
   } else {
-    InsertMayDefNodeExcludeFinalOst(mayDefOsts, mayDefNodes, stmt, bbID);
+    InsertMayDefNodeExcludeFinalOst(mayDefOsts, mayDefNodes, stmt);
   }
   ASSERT(!mayDefNodes.empty(), "AliasClass::InsertMayUseIassign(): iassign cannot have empty maydef");
 }
@@ -942,12 +942,12 @@ void AliasClass::InsertMayDefUseCall(StmtNode &stmt, BBId bbID, bool hasSideEffe
   InsertMayUseNode(mayDefUseOstsB, theSSAPart->GetMayUseNodes());
   // insert may def node, if the callee has side-effect.
   if (hasSideEffect) {
-    InsertMayDefNodeExcludeFinalOst(mayDefUseOstsB, theSSAPart->GetMayDefNodes(), stmt, bbID);
+    InsertMayDefNodeExcludeFinalOst(mayDefUseOstsB, theSSAPart->GetMayDefNodes(), stmt);
     if (kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) {
       // 4. insert mayDefs caused by the mustDefs
       std::set<OriginalSt*> mayDefOstsC;
       CollectMayDefForMustDefs(stmt, mayDefOstsC);
-      InsertMayDefNodeExcludeFinalOst(mayDefOstsC, theSSAPart->GetMayDefNodes(), stmt, bbID);
+      InsertMayDefNodeExcludeFinalOst(mayDefOstsC, theSSAPart->GetMayDefNodes(), stmt);
     }
   }
 }
@@ -977,13 +977,13 @@ void AliasClass::InsertMayDefUseIntrncall(StmtNode &stmt, BBId bbID) {
   CollectMayUseFromGlobalsAffectedByCalls(mayDefUseOsts);
   InsertMayUseNodeExcludeFinalOst(mayDefUseOsts, theSSAPart->GetMayUseNodes());
   if (!intrinDesc->HasNoSideEffect() || calleeHasSideEffect) {
-    InsertMayDefNodeExcludeFinalOst(mayDefUseOsts, theSSAPart->GetMayDefNodes(), stmt, bbID);
+    InsertMayDefNodeExcludeFinalOst(mayDefUseOsts, theSSAPart->GetMayDefNodes(), stmt);
   }
   if (kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) {
     // 3. insert maydefs caused by the mustdefs
     std::set<OriginalSt*> mayDefOsts;
     CollectMayDefForMustDefs(stmt, mayDefOsts);
-    InsertMayDefNodeExcludeFinalOst(mayDefOsts, theSSAPart->GetMayDefNodes(), stmt, bbID);
+    InsertMayDefNodeExcludeFinalOst(mayDefOsts, theSSAPart->GetMayDefNodes(), stmt);
   }
 }
 
diff --git a/src/maple_me/src/irmap.cpp b/src/maple_me/src/irmap.cpp
index 27f4746b7f4e6ffeb51c47f5a024cbeda9b49f68..2ca194a81f663928a86d4121c613e5c7ebed01aa 100644
--- a/src/maple_me/src/irmap.cpp
+++ b/src/maple_me/src/irmap.cpp
@@ -524,8 +524,8 @@ MeStmt *IRMap::BuildMeStmt(StmtNode &stmt) {
   }
 
   auto func = CreateProductFunction<MeStmtFactory>(stmt.GetOpCode());
-  ASSERT(func != nullptr, "NYI");
-  return func != nullptr ? func(this, stmt, *ssaPart) : nullptr;
+  CHECK_FATAL(func != nullptr, "func nullptr check");
+  return func(this, stmt, *ssaPart);
 }
 
 void IRMap::BuildMuList(MapleMap<OStIdx, MayUseNode> &mayuseList, MapleMap<OStIdx, VarMeExpr*> &mulist) {
diff --git a/src/maple_me/src/me_bb_layout.cpp b/src/maple_me/src/me_bb_layout.cpp
index 64e603d5185fd76cd10c910b1e14a6df90b3c135..dab7510d73147c9ca3ebb9c30e05d5f600c82cbd 100644
--- a/src/maple_me/src/me_bb_layout.cpp
+++ b/src/maple_me/src/me_bb_layout.cpp
@@ -183,50 +183,30 @@ bool BBLayout::BBCanBeMoved(const BB &fromBB, const BB &toAfterBB) const {
 // Return true if bb1 and bb2 has the branch conditon.such as
 // bb1 : brfalse (a > 3)  bb2: brfalse (a > 3)/ brtrue (a <= 3)
 bool BBLayout::HasSameBranchCond(BB &bb1, BB &bb2) const {
-  if (func.GetIRMap() != nullptr) {
-    CondGotoMeStmt &meStmt1 = static_cast<CondGotoMeStmt&>(bb1.GetMeStmts().back());
-    CondGotoMeStmt &meStmt2 = static_cast<CondGotoMeStmt&>(bb2.GetMeStmts().back());
-    MeExpr *expr1 = meStmt1.GetOpnd();
-    MeExpr *expr2 = meStmt2.GetOpnd();
-    // Compare the opcode:  brtrue/brfalse
-    if (!(meStmt1.GetOp() == meStmt2.GetOp() && expr1->GetOp() == expr2->GetOp()) &&
-        !(meStmt1.GetOp() == GetOppositeOp(meStmt2.GetOp()) && expr1->GetOp() == GetOppositeOp(expr2->GetOp()))) {
-      return false;
-    }
-    if (!(expr1->GetMeOp() == expr2->GetMeOp() && expr1->GetMeOp() == kMeOpOp)) {
-      return false;
-    }
-    OpMeExpr *opMeExpr1 = static_cast<OpMeExpr*>(expr1);
-    OpMeExpr *opMeExpr2 = static_cast<OpMeExpr*>(expr2);
-    // Compare the two operands to make sure they are both equal.
-    if (opMeExpr1->GetOpnd(0) != opMeExpr2->GetOpnd(0)) {
-      return false;
-    }
-    // If one side is const, assume it is always the rhs.
-    if ((opMeExpr1->GetOpnd(1) != opMeExpr2->GetOpnd(1)) &&
-        !(opMeExpr1->GetOpnd(1)->IsZero() && opMeExpr2->GetOpnd(1)->IsZero())) {
-      return false;
-    }
-  } else {
-    CondGotoNode &stmt1 = static_cast<CondGotoNode&>(bb1.GetStmtNodes().back());
-    CondGotoNode &stmt2 = static_cast<CondGotoNode&>(bb2.GetStmtNodes().back());
-    if (stmt1.GetOpCode() != stmt2.GetOpCode() && stmt1.GetOpCode() != GetOppositeOp(stmt2.GetOpCode())) {
-      return false;
-    }
-    BaseNode *expr1 = stmt1.Opnd();
-    BaseNode *expr2 = stmt2.Opnd();
-    if (expr1->GetOpCode() != expr2->GetOpCode() && expr1->GetOpCode() != GetOppositeOp(expr2->GetOpCode())) {
-      return false;
-    }
-    if (stmt1.GetOpCode() == stmt2.GetOpCode()) {
-      if (expr1->GetOpCode() != expr2->GetOpCode()) {
-        return false;
-      }
-    } else {
-      if (expr1->GetOpCode() != GetOppositeOp(expr2->GetOpCode())) {
-        return false;
-      }
-    }
+  if(func.GetIRMap() == nullptr) {
+    return false;
+  }
+  CondGotoMeStmt &meStmt1 = static_cast<CondGotoMeStmt&>(bb1.GetMeStmts().back());
+  CondGotoMeStmt &meStmt2 = static_cast<CondGotoMeStmt&>(bb2.GetMeStmts().back());
+  MeExpr *expr1 = meStmt1.GetOpnd();
+  MeExpr *expr2 = meStmt2.GetOpnd();
+  // Compare the opcode:  brtrue/brfalse
+  if (!(meStmt1.GetOp() == meStmt2.GetOp() && expr1->GetOp() == expr2->GetOp()) &&
+      !(meStmt1.GetOp() == GetOppositeOp(meStmt2.GetOp()) && expr1->GetOp() == GetOppositeOp(expr2->GetOp()))) {
+    return false;
+  }
+  if (!(expr1->GetMeOp() == expr2->GetMeOp() && expr1->GetMeOp() == kMeOpOp)) {
+    return false;
+  }
+  OpMeExpr *opMeExpr1 = static_cast<OpMeExpr*>(expr1);
+  OpMeExpr *opMeExpr2 = static_cast<OpMeExpr*>(expr2);
+  // Compare the two operands to make sure they are both equal.
+  if (opMeExpr1->GetOpnd(0) != opMeExpr2->GetOpnd(0)) {
+    return false;
+  }
+  // If one side is const, assume it is always the rhs.
+  if ((opMeExpr1->GetOpnd(1) != opMeExpr2->GetOpnd(1)) &&
+      !(opMeExpr1->GetOpnd(1)->IsZero() && opMeExpr2->GetOpnd(1)->IsZero())) {
     return false;
   }
   return true;
diff --git a/src/maple_me/src/me_cfg.cpp b/src/maple_me/src/me_cfg.cpp
index 752f2fab6da062aefea4ca61d9cceff552062cff..45ce059af908acf509bb93346c3c6b6610793473 100644
--- a/src/maple_me/src/me_cfg.cpp
+++ b/src/maple_me/src/me_cfg.cpp
@@ -860,7 +860,6 @@ void MeCFG::DumpToFile(const std::string &prefix, bool dumpInStrs) const {
   }
   cfgFile << "}\n";
   cfgFile.flush();
-  cfgFile.close();
   LogInfo::MapleLogger().rdbuf(coutBuf);
 }
 }  // namespace maple
diff --git a/src/maple_me/src/me_function.cpp b/src/maple_me/src/me_function.cpp
index 179d0c76f465b9d88cac1d1985a23efaded140cf..07224214447cace6a58f2173be0b3c062d530701 100644
--- a/src/maple_me/src/me_function.cpp
+++ b/src/maple_me/src/me_function.cpp
@@ -703,8 +703,8 @@ void MeFunction::SCCTopologicalSort(std::vector<SCCOfBBs*> &sccNodes) {
 
   // Top-down iterates all nodes
   for (size_t i = 0; i < sccTopologicalVec.size(); ++i) {
-    SCCOfBBs *scc = sccTopologicalVec[i];
-    for (SCCOfBBs *succ : scc->GetSucc()) {
+    SCCOfBBs *sccBB = sccTopologicalVec[i];
+    for (SCCOfBBs *succ : sccBB->GetSucc()) {
       if (InQueue.find(succ) == InQueue.end()) {
         // successor has not been visited
         bool predAllVisited = true;
diff --git a/src/maple_me/src/me_option.cpp b/src/maple_me/src/me_option.cpp
index 4795bf9c4fd1e3343e30eb3a7863c51b74c1ec28..fe6872b298a2ecb2d84752aa9c83647393facd47 100644
--- a/src/maple_me/src/me_option.cpp
+++ b/src/maple_me/src/me_option.cpp
@@ -19,7 +19,7 @@
 #include "option_parser.h"
 #include "string_utils.h"
 
-using namespace maple;
+namespace maple {
 using namespace mapleOption;
 
 std::unordered_set<std::string> MeOption::dumpPhases = {};
@@ -68,3 +68,4 @@ bool MeOption::DumpPhase(const std::string &phase) {
   }
   return ((dumpPhases.find(phase) != dumpPhases.end()) || (dumpPhases.find("*") != dumpPhases.end()));
 }
+} // namespace maple
\ No newline at end of file
diff --git a/src/maple_me/src/me_phase_manager.cpp b/src/maple_me/src/me_phase_manager.cpp
index 7558852267a38e2fc054ae85f8101be53558f935..23b0b67c00bcb94cc6bd131b8d2192e9c4c7ff54 100644
--- a/src/maple_me/src/me_phase_manager.cpp
+++ b/src/maple_me/src/me_phase_manager.cpp
@@ -40,31 +40,31 @@ void MeFuncPhaseManager::RunFuncPhase(MeFunction *func, MeFuncPhase *phase) {
   }
   // 3. tracetime(phase.id())
   // 4. run: skip mplme phase except "emit" if no cfg in MeFunction
-  AnalysisResult *r = nullptr;
+  AnalysisResult *analysisRes = nullptr;
   MePhaseID phaseID = phase->GetPhaseId();
   if ((func->NumBBs() > 0) || (phaseID == MeFuncPhase_EMIT)) {
-    r = phase->Run(func, &arFuncManager, modResMgr);
-    phase->ReleaseMemPool(r == nullptr ? nullptr : r->GetMempool());
+    analysisRes = phase->Run(func, &arFuncManager, modResMgr);
+    phase->ReleaseMemPool(analysisRes == nullptr ? nullptr : analysisRes->GetMempool());
   }
-  if (r != nullptr) {
+  if (analysisRes != nullptr) {
     // if phase is an analysis Phase, add result to arm
-    arFuncManager.AddResult(phase->GetPhaseId(), *func, *r);
+    arFuncManager.AddResult(phase->GetPhaseId(), *func, *analysisRes);
   }
 }
 
 void MeFuncPhaseManager::RegisterFuncPhases() {
   // register all Funcphases defined in me_phases.def
-#define FUNCTPHASE(id, mephase)                                               \
+#define FUNCTPHASE(id, mePhase)                                               \
   do {                                                                        \
-    void *buf = GetMemAllocator()->GetMemPool()->Malloc(sizeof(mephase(id))); \
+    void *buf = GetMemAllocator()->GetMemPool()->Malloc(sizeof(mePhase(id))); \
     CHECK_FATAL(buf != nullptr, "null ptr check");                            \
-    RegisterPhase(id, *(new (buf) mephase(id)));                              \
+    RegisterPhase(id, *(new (buf) mePhase(id)));                              \
   } while (0);
-#define FUNCAPHASE(id, mephase)                                                    \
+#define FUNCAPHASE(id, mePhase)                                                    \
   do {                                                                             \
-    void *buf = GetMemAllocator()->GetMemPool()->Malloc(sizeof(mephase(id)));      \
+    void *buf = GetMemAllocator()->GetMemPool()->Malloc(sizeof(mePhase(id)));      \
     CHECK_FATAL(buf != nullptr, "null ptr check");                                 \
-    RegisterPhase(id, *(new (buf) mephase(id)));                                   \
+    RegisterPhase(id, *(new (buf) mePhase(id)));                                   \
     arFuncManager.AddAnalysisPhase(id, (static_cast<MeFuncPhase*>(GetPhase(id)))); \
   } while (0);
 #include "me_phases.def"
diff --git a/src/maple_me/src/me_ssa.cpp b/src/maple_me/src/me_ssa.cpp
index 19d0871bddb7000b7bb2d67da1c2af14cc46cfe2..418ff81325c7d444172e18672968094bab4a15f1 100644
--- a/src/maple_me/src/me_ssa.cpp
+++ b/src/maple_me/src/me_ssa.cpp
@@ -178,27 +178,28 @@ void MeSSA::RenameBB(BB &bb) {
   }
 }
 
-bool MeSSA::VerifySSAOpnd(const BaseNode &node) const {
+void MeSSA::VerifySSAOpnd(const BaseNode &node) const {
   Opcode op = node.GetOpCode();
   size_t vtableSize = func->GetMeSSATab()->GetVersionStTable().GetVersionStVectorSize();
   if (op == OP_dread || op == OP_addrof) {
     const auto &addrOfSSANode = static_cast<const AddrofSSANode&>(node);
     const VersionSt *verSt = addrOfSSANode.GetSSAVar();
     CHECK_FATAL(verSt->GetIndex() < vtableSize, "runtime check error");
-    return true;
-  } else if (op == OP_regread) {
+    return;
+  }
+  if (op == OP_regread) {
     const auto &regNode = static_cast<const RegreadSSANode&>(node);
     const VersionSt *verSt = regNode.GetSSAVar();
     CHECK_FATAL(verSt->GetIndex() < vtableSize, "runtime check error");
-    return true;
+    return;
   }
+
   for (size_t i = 0; i < node.NumOpnds(); ++i) {
     VerifySSAOpnd(*node.Opnd(i));
   }
-  return true;
 }
 
-bool MeSSA::VerifySSA() const {
+void MeSSA::VerifySSA() const {
   size_t vtableSize = func->GetMeSSATab()->GetVersionStTable().GetVersionStVectorSize();
   auto eIt = func->valid_end();
   for (auto bIt = func->valid_begin(); bIt != eIt; ++bIt) {
@@ -211,11 +212,10 @@ bool MeSSA::VerifySSA() const {
         CHECK_FATAL(verSt != nullptr && verSt->GetIndex() < vtableSize, "runtime check error");
       }
       for (size_t i = 0; i < stmt.NumOpnds(); ++i) {
-        CHECK_FATAL(VerifySSAOpnd(*stmt.Opnd(i)), "runtime check error");
+        VerifySSAOpnd(*stmt.Opnd(i));
       }
     }
   }
-  return true;
 }
 
 AnalysisResult *MeDoSSA::Run(MeFunction *func, MeFuncResultMgr *funcResMgr, ModuleResultMgr *moduleResMgr) {
diff --git a/src/maple_me/src/orig_symbol.cpp b/src/maple_me/src/orig_symbol.cpp
index f07ae8b01526e13a65d76a666d307649c74c600b..bf51773dfb3964a08b538aa23440b19ac8e53bc7 100644
--- a/src/maple_me/src/orig_symbol.cpp
+++ b/src/maple_me/src/orig_symbol.cpp
@@ -48,20 +48,16 @@ void OriginalSt::Dump() const {
 OriginalStTable::OriginalStTable(MemPool &memPool, MIRModule &mod)
     : alloc(&memPool),
       mirModule(mod),
-      originalStVector(alloc.Adapter()),
+      originalStVector({ nullptr }, alloc.Adapter()),
       mirSt2Ost(alloc.Adapter()),
       preg2Ost(alloc.Adapter()),
       pType2Ost(std::less<TyIdx>(), alloc.Adapter()),
       malloc2Ost(alloc.Adapter()),
-      thisField2Ost(std::less<uint32>(), alloc.Adapter()),
-      virtuaLostUnkownMem(0),
-      virtuaLostConstMem(0) {
-  originalStVector.push_back(nullptr);
-}
+      thisField2Ost(std::less<uint32>(), alloc.Adapter()) {}
 
 void OriginalStTable::Dump() {
   mirModule.GetOut() << "==========original st table===========\n";
-  for (size_t i = 1; i < Size(); i++) {
+  for (size_t i = 1; i < Size(); ++i) {
     const OriginalSt *verst = GetOriginalStFromID(OStIdx(i));
     verst->Dump();
   }
@@ -105,9 +101,11 @@ OriginalSt *OriginalStTable::CreateSymbolOriginalSt(MIRSymbol &mirst, PUIdx pidx
 
 OriginalSt *OriginalStTable::CreatePregOriginalSt(PregIdx regidx, PUIdx pidx) {
   OriginalSt *ost = alloc.GetMemPool()->New<OriginalSt>(originalStVector.size(), regidx, pidx, alloc);
-  ost->SetTyIdx((regidx < 0)
-                    ? TyIdx(PTY_unknown)
-                    : GlobalTables::GetTypeTable().GetPrimType(ost->GetMIRPreg()->GetPrimType())->GetTypeIndex());
+  if (regidx < 0) {
+    ost->SetTyIdx(TyIdx(PTY_unknown));
+  } else {
+    ost->SetTyIdx(GlobalTables::GetTypeTable().GetPrimType(ost->GetMIRPreg()->GetPrimType())->GetTypeIndex());
+  }
   originalStVector.push_back(ost);
   preg2Ost[regidx] = ost->GetIndex();
   return ost;
@@ -117,10 +115,9 @@ OriginalSt *OriginalStTable::FindSymbolOriginalSt(MIRSymbol &mirst) {
   MapleUnorderedMap<const MIRSymbol*, OStIdx>::iterator it = mirSt2Ost.find(&mirst);
   if (it == mirSt2Ost.end()) {
     return nullptr;
-  } else {
-    CHECK_FATAL(it->second.idx < originalStVector.size(),
-                "index out of range in OriginalStTable::FindSymbolOriginalSt");
-    return originalStVector[it->second.idx];
   }
+  CHECK_FATAL(it->second.idx < originalStVector.size(),
+              "index out of range in OriginalStTable::FindSymbolOriginalSt");
+  return originalStVector[it->second.idx];
 }
 }  // namespace maple
diff --git a/src/maple_me/src/ver_symbol.cpp b/src/maple_me/src/ver_symbol.cpp
index 912e7b46c5111faf1e48321f6299605c047214fa..325b7028444d97fb46692fe9ece67e6acb8359d2 100644
--- a/src/maple_me/src/ver_symbol.cpp
+++ b/src/maple_me/src/ver_symbol.cpp
@@ -69,7 +69,7 @@ VersionSt *VersionStTable::FindOrCreateVersionSt(OriginalSt *ost, size_t version
 void VersionStTable::Dump(MIRModule *mod) const {
   ASSERT(mod != nullptr, "nullptr check");
   LogInfo::MapleLogger() << "=======version st table entries=======\n";
-  for (size_t i = 1; i < versionStVector.size(); i++) {
+  for (size_t i = 1; i < versionStVector.size(); ++i) {
     const VersionSt *vst = versionStVector[i];
     vst->Dump(mod);
     if (vst->GetVersion() > 0) {
diff --git a/src/mempool/include/mempool.h b/src/mempool/include/mempool.h
index d2b9a7622b5b3f608146a4225995fcab559dcf5f..0a2d392df720c8da4b0cdcb7a45f85d6cb906ddf 100644
--- a/src/mempool/include/mempool.h
+++ b/src/mempool/include/mempool.h
@@ -39,7 +39,7 @@ class MemPoolCtrler {
   friend MemPool;
 
  public:  // Methods
-  MemPoolCtrler() {}
+  MemPoolCtrler() = default;
 
   ~MemPoolCtrler();
 
@@ -49,10 +49,6 @@ class MemPoolCtrler {
     return memPools.empty();
   }
 
-  unsigned GetMempoolSize() const {
-    return memPools.size();
-  }
-
  private:  // Methods
   struct MemBlock {
     unsigned int available;  // Available memory size
@@ -104,6 +100,7 @@ class MemPool {
   template <class T, typename... Arguments>
   T *New(Arguments &&... args) {
     void *p = Malloc(sizeof(T));
+    CHECK_FATAL(p != nullptr, "ERROR: New error");
     p = new (p) T(std::forward<Arguments>(args)...);  // Call constructor
     return static_cast<T*>(p);
   }
@@ -112,6 +109,7 @@ class MemPool {
   template <class T>
   T *NewArray(unsigned int num) {
     void *p = Malloc(sizeof(T) * num);
+    CHECK_FATAL(p != nullptr, "ERROR: NewArray error");
     p = new (p) T[num];
     return static_cast<T*>(p);
   }
@@ -119,6 +117,7 @@ class MemPool {
 #define BitsAlign(size) (((size) + 7) & (0xFFFFFFF8))
 #define MemBlockFirstPtr(x) \
   static_cast<void*>((reinterpret_cast<char*>(x)) + BitsAlign(sizeof(MemPoolCtrler::MemBlock)))
+
  private:                                         // constants
   static constexpr size_t kMinBlockSize = 0x800;  // Minimum BlockSize is 2K
   static constexpr size_t kMemBlockOverhead = (BitsAlign(sizeof(MemPoolCtrler::MemBlock)));
diff --git a/src/mempool/include/mempool_allocator.h b/src/mempool/include/mempool_allocator.h
index a2d5a47afd39889059ad8e3e74e8023afee85ec6..1ad5bf6ac965c35c047f4f21592e6445a00dfabf 100644
--- a/src/mempool/include/mempool_allocator.h
+++ b/src/mempool/include/mempool_allocator.h
@@ -32,8 +32,7 @@ class MapleAllocatorAdapter;  // circular dependency exists, no other choice
 class MapleAllocator {
  public:
   explicit MapleAllocator(MemPool *m) : memPool(m) {}
-
-  virtual ~MapleAllocator() {}
+  virtual ~MapleAllocator() = default;
 
   // Get adapter for use in STL containers. See arena_containers.h .
   MapleAllocatorAdapter<void> Adapter();
@@ -149,9 +148,9 @@ class MapleAllocatorAdapter<void> {
   ~MapleAllocatorAdapter() = default;
 
  private:
-  MapleAllocator *mapleAllocator;
   template <typename U>
   friend class MapleAllocatorAdapter;
+  MapleAllocator *mapleAllocator;
 };
 
 template <typename T>
@@ -204,11 +203,11 @@ class MapleAllocatorAdapter {
   }
 
  private:
-  MapleAllocator *mapleAllocator;
   template <typename U>
   friend class MapleAllocatorAdapter;
   template <typename U>
   friend bool operator==(const MapleAllocatorAdapter<U> &lhs, const MapleAllocatorAdapter<U> &rhs);
+  MapleAllocator *mapleAllocator;
 };
 
 template <typename T>