diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl
index 456b855bb4c98a194f0bdbce712314e7c43a9549..f7000f932d2769f9713ae547c7058165593eceab 100755
Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ
diff --git a/src/bin/maple b/src/bin/maple
index 1dd03cc9609bb2460bf8f3730358bf46a65586d2..bc4e7069b186dd7c068242374936a03362d27a23 100755
Binary files a/src/bin/maple and b/src/bin/maple differ
diff --git a/src/bin/mplcg b/src/bin/mplcg
index cc26b18e65b84173b4a2dd65a86e9745a4094cb3..00bd1de0e75e57651111ec31f5eee4588a08137c 100755
Binary files a/src/bin/mplcg and b/src/bin/mplcg differ
diff --git a/src/deplibs/libmaple_driverutil.a b/src/deplibs/libmaple_driverutil.a
index 68d099810f58575d672ee6d354d20c646a2ee09a..e7ed9ada8cbf8d944897469537d96fdd75205d58 100644
Binary files a/src/deplibs/libmaple_driverutil.a and b/src/deplibs/libmaple_driverutil.a differ
diff --git a/src/deplibs/libmplutil.a b/src/deplibs/libmplutil.a
index f43e2b5a08bd05134220d390c307a52f7f79001e..f2539a47899715949c506f88a6ddbe893fd7a074 100644
Binary files a/src/deplibs/libmplutil.a and b/src/deplibs/libmplutil.a differ
diff --git a/src/maple_driver/include/mpl_options.h b/src/maple_driver/include/mpl_options.h
index 7c3c09b9f5780cbce62a9b9f9b481b456f5d0d50..0b994ee211d4d4e157c35f17d9ada52281a0d0c5 100644
--- a/src/maple_driver/include/mpl_options.h
+++ b/src/maple_driver/include/mpl_options.h
@@ -188,6 +188,19 @@ class MplOptions {
   }
 
  private:
+  bool Init(const std::string &inputFile);
+  ErrorCode HandleGeneralOptions();
+  ErrorCode DecideRunType();
+  ErrorCode DecideRunningPhases();
+  ErrorCode CheckInputFileValidity();
+  ErrorCode CheckFileExits();
+  void AddOption(const mapleOption::Option &option);
+  ErrorCode UpdatePhaseOption(const std::string &args, const std::string &exeName);
+  ErrorCode UpdateExtraOptionOpt(const std::string &args);
+  ErrorCode AppendDefaultCombOptions();
+  ErrorCode AppendDefaultCgOptions();
+  ErrorCode AppendDefaultOptions(const std::string &exeName, MplOption mplOptions[], unsigned int length);
+  void UpdateRunningExe(const std::string &args);
   std::unique_ptr<mapleOption::OptionParser> optionParser = nullptr;
   std::map<std::string, std::vector<mapleOption::Option>> options = {};
   std::map<std::string, std::vector<mapleOption::Option>> exeOptions = {};
@@ -211,19 +224,6 @@ class MplOptions {
   bool genMeMpl = false;
   bool genVtableImpl = false;
   bool verify = false;
-  bool Init(const std::string &inputFile);
-  ErrorCode HandleGeneralOptions();
-  ErrorCode DecideRunType();
-  ErrorCode DecideRunningPhases();
-  ErrorCode CheckInputFileValidity();
-  ErrorCode CheckFileExits();
-  void AddOption(const mapleOption::Option &option);
-  ErrorCode UpdatePhaseOption(const std::string &args, const std::string &exeName);
-  ErrorCode UpdateExtraOptionOpt(const std::string &args);
-  ErrorCode AppendDefaultCombOptions();
-  ErrorCode AppendDefaultCgOptions();
-  ErrorCode AppendDefaultOptions(const std::string &exeName, MplOption mplOptions[], unsigned int length);
-  void UpdateRunningExe(const std::string &args);
 };
 }  // namespace maple
 #endif  // MAPLE_DRIVER_INCLUDE_MPL_OPTIONS_H
diff --git a/src/maple_driver/src/mpl_options.cpp b/src/maple_driver/src/mpl_options.cpp
index 016d7564617d35dd3312fa99be8ed9cf1aa9dab2..104a32aeb11eb6609085d5001a8bc39391533351 100644
--- a/src/maple_driver/src/mpl_options.cpp
+++ b/src/maple_driver/src/mpl_options.cpp
@@ -1011,23 +1011,23 @@ ErrorCode MplOptions::DecideRunningPhases() {
 }
 
 ErrorCode MplOptions::CheckInputFileValidity() {
-  ErrorCode ret = ErrorCode::kErrorNoError;
   // Get input fileName
-  if (optionParser->GetNonOptionsCount() > 0) {
-    std::string optionString;
-    const std::vector<std::string> inputs = optionParser->GetNonOptions();
-    for (size_t i = 0; i < inputs.size(); i++) {
-      if (i == 0) {
-        optionString = inputs[i];
-      } else {
-        optionString = optionString + "," + inputs[i];
-      }
-    }
-    if (!Init(optionString)) {
-      ret = ErrorCode::kErrorInitFail;
+  if (optionParser->GetNonOptionsCount() <= 0) {
+    return ErrorCode::kErrorNoError;
+  }
+  std::ostringstream optionString;
+  const std::vector<std::string> &inputs = optionParser->GetNonOptions();
+  for (size_t i = 0; i < inputs.size(); ++i) {
+    if (i == 0) {
+      optionString << inputs[i];
+    } else {
+      optionString <<  "," << inputs[i];
     }
   }
-  return ret;
+  if (!Init(optionString.str())) {
+    return ErrorCode::kErrorInitFail;
+  }
+  return ErrorCode::kErrorNoError;
 }
 
 ErrorCode MplOptions::CheckFileExits() {
@@ -1049,14 +1049,15 @@ ErrorCode MplOptions::CheckFileExits() {
 }
 
 void MplOptions::AddOption(const mapleOption::Option &option) {
-  if (option.HasExtra()) {
-    for (auto &extra : option.GetExtras()) {
-      auto iter = std::find(runningExes.begin(), runningExes.end(), extra.exeName);
-      if (iter == runningExes.end()) {
-        continue;
-      }
-      options[extra.exeName].push_back(option);
+  if (!option.HasExtra()) {
+    return;
+  }
+  for (const auto &extra : option.GetExtras()) {
+    auto iter = std::find(runningExes.begin(), runningExes.end(), extra.exeName);
+    if (iter == runningExes.end()) {
+      continue;
     }
+    options[extra.exeName].push_back(option);
   }
 }
 
@@ -1130,7 +1131,7 @@ ErrorCode MplOptions::AppendDefaultCgOptions() {
 
 ErrorCode MplOptions::AppendDefaultOptions(const std::string &exeName, MplOption mplOptions[], unsigned int length) {
   auto &exeOption = exeOptions[exeName];
-  for (size_t i = 0; i < length; i++) {
+  for (size_t i = 0; i < length; ++i) {
     bool ret = optionParser->SetOption(mplOptions[i].GetKey(), mplOptions[i].GetValue(), exeName, exeOption);
     if (!ret) {
       return ErrorCode::kErrorInvalidParameter;
@@ -1160,7 +1161,7 @@ ErrorCode MplOptions::UpdatePhaseOption(const std::string &args, const std::stri
   // Fill extraOption
   // For compiler bins called by system()
   auto &extraOption = extras[exeName];
-  for (size_t i = 0; i < exeOption.size(); i++) {
+  for (size_t i = 0; i < exeOption.size(); ++i) {
     if (exeOption[i].Args() != "") {
       MplOption mplOption("-" + exeOption[i].OptionKey(), exeOption[i].Args(), "=", false, "");
       extraOption.push_back(mplOption);
@@ -1187,7 +1188,7 @@ ErrorCode MplOptions::UpdateExtraOptionOpt(const std::string &args) {
     if (ret != ErrorCode::kErrorNoError) {
       return ret;
     }
-    settingExe++;
+    ++settingExe;
   }
   return ErrorCode::kErrorNoError;
 }
@@ -1195,7 +1196,7 @@ ErrorCode MplOptions::UpdateExtraOptionOpt(const std::string &args) {
 void MplOptions::UpdateRunningExe(const std::string &args) {
   std::vector<std::string> results;
   StringUtils::Split(args, results, ':');
-  for (size_t i = 0; i < results.size(); i++) {
+  for (size_t i = 0; i < results.size(); ++i) {
     auto iter = std::find(runningExes.begin(), runningExes.end(), results[i].c_str());
     if (iter == runningExes.end()) {
       runningExes.push_back(results[i]);
diff --git a/src/maple_ipa/include/module_phase_manager.h b/src/maple_ipa/include/module_phase_manager.h
index 477f004498c50c1ed3ad917aae31fb2fc4572dc7..6b1f0c1b48d7141a1b9acf7295cad289821a02ae 100644
--- a/src/maple_ipa/include/module_phase_manager.h
+++ b/src/maple_ipa/include/module_phase_manager.h
@@ -30,7 +30,7 @@ class DoKlassHierarchy : public ModulePhase {
     return "classhierarchy";
   }
 
-  virtual ~DoKlassHierarchy() {};
+  virtual ~DoKlassHierarchy() = default;
 };
 
 class ModulePhaseManager : public PhaseManager {
@@ -45,7 +45,7 @@ class ModulePhaseManager : public PhaseManager {
     timePhases = false;
   }
 
-  ~ModulePhaseManager() {}
+  ~ModulePhaseManager() = default;
 
   // register all module phases defined in module_phases.def
   void RegisterModulePhases();
diff --git a/src/maple_ipa/src/interleaved_manager.cpp b/src/maple_ipa/src/interleaved_manager.cpp
index cff0314566bb3e7b3592dce6dd2378433add8103..0259296aee57ec1968e368813b9a985ffffd06ce 100644
--- a/src/maple_ipa/src/interleaved_manager.cpp
+++ b/src/maple_ipa/src/interleaved_manager.cpp
@@ -19,8 +19,6 @@
 
 #include "module_phase.h"
 #include "mir_function.h"
-#include "mir_module.h"
-#include "me_function.h"
 #include "me_option.h"
 #include "mempool.h"
 #include "phase_manager.h"
@@ -81,11 +79,11 @@ void InterleavedManager::Run() {
       }
       for (auto *func : *compList) {
         if (MeOption::useRange && (rangeNum < MeOption::range[0] || rangeNum > MeOption::range[1])) {
-          rangeNum++;
+          ++rangeNum;
           continue;
         }
         if (func->GetBody() == nullptr) {
-          rangeNum++;
+          ++rangeNum;
           continue;
         }
         if (fpm->GetPhaseSequence()->empty()) {
@@ -94,7 +92,7 @@ void InterleavedManager::Run() {
         mirModule.SetCurFunction(func);
         // lower, create BB and build cfg
         fpm->Run(func, rangeNum, meInput);
-        rangeNum++;
+        ++rangeNum;
       }
       if (fpm->GetGenMeMpl()) {
         mirModule.Emit("comb.me.mpl");
diff --git a/src/maple_ipa/src/module_phase_manager.cpp b/src/maple_ipa/src/module_phase_manager.cpp
index f9e0fc07250f7d892d256154e7f4700560a7ef52..1500a956fec090fff96e35bde347719d253f3059 100644
--- a/src/maple_ipa/src/module_phase_manager.cpp
+++ b/src/maple_ipa/src/module_phase_manager.cpp
@@ -55,7 +55,7 @@ void ModulePhaseManager::RegisterModulePhases() {
     MemPool *memPool = GetMemPool();                                               \
     ModulePhase *phase = new (memPool->Malloc(sizeof(modphase(id)))) modphase(id); \
     CHECK_FATAL(phase != nullptr, "null ptr check ");                              \
-    RegisterPhase(id, *phase);                                                      \
+    RegisterPhase(id, *phase);                                                     \
     arModuleMgr->AddAnalysisPhase(id, phase);                                      \
   } while (0);
 #define MODTPHASE(id, modphase)                                                    \
@@ -63,7 +63,7 @@ void ModulePhaseManager::RegisterModulePhases() {
     MemPool *memPool = GetMemPool();                                               \
     ModulePhase *phase = new (memPool->Malloc(sizeof(modphase(id)))) modphase(id); \
     CHECK_FATAL(phase != nullptr, "null ptr check ");                              \
-    RegisterPhase(id, *phase);                                                      \
+    RegisterPhase(id, *phase);                                                     \
   } while (0);
 #include "module_phases.def"
 #undef MODAPHASE
@@ -80,7 +80,7 @@ void ModulePhaseManager::RunModulePhases() const {}
 
 void ModulePhaseManager::Run() {
   int phaseIndex = 0;
-  for (auto it = PhaseSequenceBegin(); it != PhaseSequenceEnd(); it++, ++phaseIndex) {
+  for (auto it = PhaseSequenceBegin(); it != PhaseSequenceEnd(); ++it, ++phaseIndex) {
     PhaseID id = GetPhaseId(it);
     ModulePhase *p = static_cast<ModulePhase*>(GetPhase(id));
     MIR_ASSERT(p);
diff --git a/src/maple_ir/include/mir_module.h b/src/maple_ir/include/mir_module.h
index de81e162085d0d708993e7fe1b69ddf4ad4a8b63..cd61c6f712103da0eb3431d0c426c5ca82317ec7 100644
--- a/src/maple_ir/include/mir_module.h
+++ b/src/maple_ir/include/mir_module.h
@@ -78,7 +78,7 @@ struct EncodedValue {
 class MIRTypeNameTable {
  public:
   explicit MIRTypeNameTable(MapleAllocator &allocator)
-      : mAllocator(allocator), gStrIdxToTyIdxMap(std::less<GStrIdx>(), mAllocator.Adapter()) {}
+      : gStrIdxToTyIdxMap(std::less<GStrIdx>(), allocator.Adapter()) {}
 
   ~MIRTypeNameTable() = default;
 
@@ -102,7 +102,6 @@ class MIRTypeNameTable {
     return gStrIdxToTyIdxMap.size();
   }
  private:
-  MapleAllocator &mAllocator;
   MapleMap<GStrIdx, TyIdx> gStrIdxToTyIdxMap;
 };
 
@@ -110,10 +109,9 @@ class MIRModule {
  public:
   using CallSite = std::pair<CallInfo*, PUIdx>;
 
+  explicit MIRModule(const std::string &fn = "");
   MIRModule(MIRModule &p) = delete;
   MIRModule &operator=(const MIRModule &module) = delete;
-
-  explicit MIRModule(const std::string &fn = "");
   ~MIRModule();
 
   const MemPool *GetMemPool() const {
@@ -153,8 +151,8 @@ class MIRModule {
   const MapleVector<std::string> &GetImportedMplt() const {
     return importedMplt;
   }
-  void PushbackImportedMplt(std::string importFileName) {
-    importedMplt.push_back(std::move(importFileName));
+  void PushbackImportedMplt(const std::string &importFileName) {
+    importedMplt.push_back(importFileName);
   }
 
   MIRTypeNameTable *GetTypeNameTab() {
@@ -187,13 +185,13 @@ class MIRModule {
     someSymbolNeedForwDecl = s;
   }
 
-  MIRFunction *CurFunction(void) const {
+  MIRFunction *CurFunction() const {
     return curFunction;
   }
 
-  MemPool *CurFuncCodeMemPool(void) const;
-  MapleAllocator *CurFuncCodeMemPoolAllocator(void) const;
-  MapleAllocator &GetCurFuncCodeMPAllocator(void) const;
+  MemPool *CurFuncCodeMemPool() const;
+  MapleAllocator *CurFuncCodeMemPoolAllocator() const;
+  MapleAllocator &GetCurFuncCodeMPAllocator() const;
   void AddExternStructType(TyIdx tyIdx);
   void AddExternStructType(const MIRType *t);
   void AddSymbol(StIdx stIdx);
@@ -212,7 +210,7 @@ class MIRModule {
   void DumpClassToFile(const std::string &path) const;
   void DumpFunctionList(bool skipBody = false) const;
   void DumpGlobalArraySymbol() const;
-  void Emit(const std::string &outfileName) const;
+  void Emit(const std::string &outFileName) const;
   uint32 GetAndIncFloatNum() {
     return floatNum++;
   }
@@ -270,8 +268,8 @@ class MIRModule {
     puIdxFieldInitializedMap[puIdx] = fieldIDSet;
   }
 
-  MapleSet<FieldID> *GetPUIdxFieldInitializedMapItem(PUIdx first) {
-    return puIdxFieldInitializedMap[first];
+  MapleSet<FieldID> *GetPUIdxFieldInitializedMapItem(PUIdx key) {
+    return puIdxFieldInitializedMap[key];
   }
 
   std::ostream &GetOut() {
@@ -285,8 +283,8 @@ class MIRModule {
   const std::string &GetEntryFuncName() const {
     return entryFuncName;
   }
-  void SetEntryFuncName(std::string entryFunctionName) {
-    entryFuncName = std::move(entryFunctionName);
+  void SetEntryFuncName(const std::string &entryFunctionName) {
+    entryFuncName = entryFunctionName;
   }
 
   TyIdx GetThrowableTyIdx() const {
@@ -323,14 +321,14 @@ class MIRModule {
   void PushFileInfoPair(MIRInfoPair pair) {
     fileInfo.push_back(pair);
   }
-  void SetFileInfo(MIRInfoVector fileInf) {
+  void SetFileInfo(const MIRInfoVector &fileInf) {
     fileInfo = fileInf;
   }
 
   const MapleVector<bool> &GetFileInfoIsString() const {
     return fileInfoIsString;
   }
-  void SetFileInfoIsString(MapleVector<bool> fileInfoIsStr) {
+  void SetFileInfoIsString(const MapleVector<bool> &fileInfoIsStr) {
     fileInfoIsString = fileInfoIsStr;
   }
   void PushFileInfoIsString(bool isString) {
@@ -340,7 +338,7 @@ class MIRModule {
   const MIRDataVector &GetFileData() const {
     return fileData;
   }
-  void PushbackFileData(MIRDataPair pair) {
+  void PushbackFileData(const MIRDataPair &pair) {
     fileData.push_back(pair);
   }
 
diff --git a/src/maple_ir/include/mir_nodes.h b/src/maple_ir/include/mir_nodes.h
index 7ef9d8f86b55d9f48589330a0c30577afc433ae4..db9a3206fe7438415bba811e6c3ad9fb38659179 100644
--- a/src/maple_ir/include/mir_nodes.h
+++ b/src/maple_ir/include/mir_nodes.h
@@ -1441,6 +1441,10 @@ class StmtNode : public BaseNode, public PtrListNodeBase<StmtNode> {
 
   StmtNode *GetRealNext() const;
 
+  virtual BaseNode *GetRHS() const {
+    return nullptr;
+  }
+
  protected:
   SrcPosition srcPosition;
 
@@ -1475,18 +1479,18 @@ class IassignNode : public StmtNode {
     fieldID = fid;
   }
 
-  BaseNode *Opnd(size_t i) const {
+  BaseNode *Opnd(size_t i) const override {
     if (i == 0) {
       return addrExpr;
     }
     return rhs;
   }
 
-  uint8 NumOpnds() const {
+  uint8 NumOpnds() const override {
     return kOperandNumBinary;
   }
 
-  void SetOpnd(BaseNode *node, size_t i) {
+  void SetOpnd(BaseNode *node, size_t i) override {
     if (i == 0) {
       addrExpr = node;
     } else {
@@ -1494,10 +1498,10 @@ class IassignNode : public StmtNode {
     }
   }
 
-  void Dump(const MIRModule &mod, int32 indent) const;
-  bool Verify() const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
+  bool Verify() const override;
 
-  IassignNode *CloneTree(MapleAllocator &allocator) const {
+  IassignNode *CloneTree(MapleAllocator &allocator) const override {
     IassignNode *bn = allocator.GetMemPool()->New<IassignNode>(*this);
     bn->SetStmtID(stmtIDNext++);
     bn->SetOpnd(addrExpr->CloneTree(allocator), 0);
@@ -1518,7 +1522,7 @@ class IassignNode : public StmtNode {
     addrExpr = exp;
   }
 
-  BaseNode *GetRHS() const {
+  BaseNode *GetRHS() const override {
     return rhs;
   }
 
@@ -1904,26 +1908,26 @@ class UnaryStmtNode : public StmtNode {
 
   virtual ~UnaryStmtNode() = default;
 
-  void Dump(const MIRModule &mod, int32 indent) const;
+  void Dump(const MIRModule &mod, int32 indent) const override;
   void Dump(const MIRModule &mod) const;
   void DumpOpnd(const MIRModule &mod, int32 indent) const;
 
-  bool Verify() const {
+  bool Verify() const  override {
     return uOpnd->Verify();
   }
 
-  UnaryStmtNode *CloneTree(MapleAllocator &allocator) const {
+  UnaryStmtNode *CloneTree(MapleAllocator &allocator) const override {
     UnaryStmtNode *nd = allocator.GetMemPool()->New<UnaryStmtNode>(*this);
     nd->SetStmtID(stmtIDNext++);
     nd->SetOpnd(uOpnd->CloneTree(allocator));
     return nd;
   }
 
-  bool IsLeaf(void) const {
+  bool IsLeaf(void) const override {
     return false;
   }
 
-  virtual BaseNode *GetRHS() const {
+  BaseNode *GetRHS() const override {
     return Opnd(0);
   }
 
@@ -1931,12 +1935,12 @@ class UnaryStmtNode : public StmtNode {
     this->SetOpnd(rhs, 0);
   }
 
-  BaseNode *Opnd(size_t i = 0) const {
+  BaseNode *Opnd(size_t i = 0) const override {
     ASSERT(i == 0, "Unary operand");
     return uOpnd;
   }
 
-  void SetOpnd(BaseNode *node, size_t i = 0) {
+  void SetOpnd(BaseNode *node, size_t i = 0) override {
     ASSERT(i == 0, "Unary operand");
     uOpnd = node;
   }
@@ -1961,17 +1965,17 @@ class DassignNode : public UnaryStmtNode {
 
   ~DassignNode() = 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;
 
-  DassignNode *CloneTree(MapleAllocator &allocator) const {
+  DassignNode *CloneTree(MapleAllocator &allocator) const override {
     DassignNode *nd = allocator.GetMemPool()->New<DassignNode>(*this);
     nd->SetStmtID(stmtIDNext++);
     nd->SetOpnd(Opnd()->CloneTree(allocator));
     return nd;
   }
 
-  uint8 NumOpnds(void) const {
+  uint8 NumOpnds(void) const override {
     return 1;
   }
 
@@ -1984,11 +1988,11 @@ class DassignNode : public UnaryStmtNode {
     return (stIdx == dread->GetStIdx());
   }
 
-  BaseNode *GetRHS() const {
+  BaseNode *GetRHS() const override {
     return UnaryStmtNode::GetRHS();
   }
 
-  void SetRHS(BaseNode *rhs) {
+  void SetRHS(BaseNode *rhs) override {
     UnaryStmtNode::SetOpnd(rhs, 0);
   }
 
@@ -2023,21 +2027,21 @@ class RegassignNode : public UnaryStmtNode {
 
   ~RegassignNode() = 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;
 
-  RegassignNode *CloneTree(MapleAllocator &allocator) const {
+  RegassignNode *CloneTree(MapleAllocator &allocator) const override {
     RegassignNode *nd = allocator.GetMemPool()->New<RegassignNode>(*this);
     nd->SetStmtID(stmtIDNext++);
     nd->SetOpnd(Opnd()->CloneTree(allocator));
     return nd;
   }
 
-  BaseNode *GetRHS() const {
+  BaseNode *GetRHS() const override {
     return UnaryStmtNode::GetRHS();
   }
 
-  void SetRHS(BaseNode *rhs) {
+  void SetRHS(BaseNode *rhs) override {
     UnaryStmtNode::SetOpnd(rhs, 0);
   }
 
@@ -2722,6 +2726,7 @@ class CallNode : public NaryStmtNode {
   virtual void Dump(const MIRModule &mod, int32 indent, bool newline) const;
   bool Verify() const;
   MIRType *GetCallReturnType();
+  const MIRSymbol *GetCallReturnSymbol(const MIRModule &mod) const;
 
   CallNode *CloneTree(MapleAllocator &allocator) const {
     CallNode *nd = allocator.GetMemPool()->New<CallNode>(allocator, *this);
diff --git a/src/maple_ir/include/opcode_info.h b/src/maple_ir/include/opcode_info.h
index c558a163aefa7af1aeed134eb9f09444d5b7c125..3629f9d4ad15d250e347aeccb927116c0e2bdb10 100644
--- a/src/maple_ir/include/opcode_info.h
+++ b/src/maple_ir/include/opcode_info.h
@@ -133,6 +133,10 @@ class OpcodeTable {
     return o == OP_brtrue || o == OP_brfalse;
   }
 
+  bool AssignActualVar(Opcode o) const {
+    ASSERT(o < kOpLast, "invalid opcode");
+    return o == OP_dassign || o == OP_regassign;
+  }
  private:
   OpcodeDesc table[kOpLast];
 };
diff --git a/src/maple_ir/src/mir_module.cpp b/src/maple_ir/src/mir_module.cpp
index 0b22d828b0bfdd834df15572e104e15fd6eb002a..8ebc0aa6e43ccae5c6de3faf9ffbb8687b9d26c9 100644
--- a/src/maple_ir/src/mir_module.cpp
+++ b/src/maple_ir/src/mir_module.cpp
@@ -57,20 +57,18 @@ MIRModule::MIRModule(const std::string &fn)
 
 MIRModule::~MIRModule() {
   memPoolCtrler.DeleteMemPool(memPool);
-  if (binMplt) {
-    delete binMplt;
-  }
+  delete binMplt;
 }
 
-MemPool *MIRModule::CurFuncCodeMemPool(void) const {
+MemPool *MIRModule::CurFuncCodeMemPool() const {
   return CurFunction()->GetCodeMempool();
 }
 
-MapleAllocator *MIRModule::CurFuncCodeMemPoolAllocator(void) const {
+MapleAllocator *MIRModule::CurFuncCodeMemPoolAllocator() const {
   return &curFunction->GetCodeMempoolAllocator();
 }
 
-MapleAllocator &MIRModule::GetCurFuncCodeMPAllocator(void) const {
+MapleAllocator &MIRModule::GetCurFuncCodeMPAllocator() const {
   return curFunction->GetCodeMPAllocator();
 }
 
@@ -98,18 +96,18 @@ void MIRModule::AddSymbol(const MIRSymbol *s) {
 
 void MIRModule::DumpGlobals(bool emitStructureType) const {
   if (flavor != kFlavorUnknown) {
-    LogInfo::MapleLogger() << "flavor " << flavor << std::endl;
+    LogInfo::MapleLogger() << "flavor " << flavor << '\n';
   }
   if (srcLang != kSrcLangUnknown) {
-    LogInfo::MapleLogger() << "srclang " << srcLang << std::endl;
+    LogInfo::MapleLogger() << "srclang " << srcLang << '\n';
   }
-  LogInfo::MapleLogger() << "id " << id << std::endl;
+  LogInfo::MapleLogger() << "id " << id << '\n';
   if (globalMemSize != 0) {
-    LogInfo::MapleLogger() << "globalmemsize " << globalMemSize << std::endl;
+    LogInfo::MapleLogger() << "globalmemsize " << globalMemSize << '\n';
   }
   if (globalBlkMap != nullptr) {
     LogInfo::MapleLogger() << "globalmemmap = [ ";
-    uint32 *p = reinterpret_cast<uint32*>(globalBlkMap);
+    auto *p = reinterpret_cast<uint32*>(globalBlkMap);
     LogInfo::MapleLogger() << std::hex;
     while (p < reinterpret_cast<uint32*>(globalBlkMap + globalMemSize)) {
       LogInfo::MapleLogger() << std::hex << "0x" << *p << " ";
@@ -119,21 +117,21 @@ void MIRModule::DumpGlobals(bool emitStructureType) const {
   }
   if (globalWordsTypeTagged != nullptr) {
     LogInfo::MapleLogger() << "globalwordstypetagged = [ ";
-    uint32 *p = reinterpret_cast<uint32*>(globalWordsTypeTagged);
+    auto *p = reinterpret_cast<uint32*>(globalWordsTypeTagged);
     LogInfo::MapleLogger() << std::hex;
     while (p < reinterpret_cast<uint32*>(globalWordsTypeTagged + BlockSize2BitVectorSize(globalMemSize))) {
       LogInfo::MapleLogger() << std::hex << "0x" << *p << " ";
-      p++;
+      ++p;
     }
     LogInfo::MapleLogger() << std::dec << "]\n";
   }
   if (globalWordsRefCounted != nullptr) {
     LogInfo::MapleLogger() << "globalwordsrefcounted = [ ";
-    uint32 *p = reinterpret_cast<uint32*>(globalWordsRefCounted);
+    auto *p = reinterpret_cast<uint32*>(globalWordsRefCounted);
     LogInfo::MapleLogger() << std::hex;
     while (p < reinterpret_cast<uint32*>(globalWordsRefCounted + BlockSize2BitVectorSize(globalMemSize))) {
       LogInfo::MapleLogger() << std::hex << "0x" << *p << " ";
-      p++;
+      ++p;
     }
     LogInfo::MapleLogger() << std::dec << "]\n";
   }
@@ -141,24 +139,23 @@ void MIRModule::DumpGlobals(bool emitStructureType) const {
   if (!importFiles.empty()) {
     // Output current module's mplt on top, imported ones at below
     for (auto it = importFiles.rbegin(); it != importFiles.rend(); it++) {
-      LogInfo::MapleLogger() << "import \"" << GlobalTables::GetStrTable().GetStringFromStrIdx(*it) << "\""
-                             << std::endl;
+      LogInfo::MapleLogger() << "import \"" << GlobalTables::GetStrTable().GetStringFromStrIdx(*it) << "\"\n";
     }
   }
   if (!importPaths.empty()) {
     size_t size = importPaths.size();
-    for (size_t i = 0; i < size; i++) {
+    for (size_t i = 0; i < size; ++i) {
       LogInfo::MapleLogger() << "importpath \"" << GlobalTables::GetStrTable().GetStringFromStrIdx(importPaths[i])
-                             << "\"" << std::endl;
+                             << "\"\n";
     }
   }
   if (entryFuncName.length()) {
-    LogInfo::MapleLogger() << "entryfunc &" << entryFuncName << std::endl;
+    LogInfo::MapleLogger() << "entryfunc &" << entryFuncName << '\n';
   }
   if (!fileInfo.empty()) {
     LogInfo::MapleLogger() << "fileinfo {\n";
     size_t size = fileInfo.size();
-    for (size_t i = 0; i < size; i++) {
+    for (size_t i = 0; i < size; ++i) {
       LogInfo::MapleLogger() << "  @" << GlobalTables::GetStrTable().GetStringFromStrIdx(fileInfo[i].first) << " ";
       if (!fileInfoIsString[i]) {
         LogInfo::MapleLogger() << "0x" << std::hex << fileInfo[i].second;
@@ -178,9 +175,9 @@ void MIRModule::DumpGlobals(bool emitStructureType) const {
     LogInfo::MapleLogger() << "srcfileinfo {\n";
     size_t size = srcFileInfo.size();
     size_t i = 0;
-    for (auto it : srcFileInfo) {
-      LogInfo::MapleLogger() << "  " << it.second;
-      LogInfo::MapleLogger() << " \"" << GlobalTables::GetStrTable().GetStringFromStrIdx(it.first) << "\"";
+    for (auto infoElem : srcFileInfo) {
+      LogInfo::MapleLogger() << "  " << infoElem.second;
+      LogInfo::MapleLogger() << " \"" << GlobalTables::GetStrTable().GetStringFromStrIdx(infoElem.first) << "\"";
       if (i++ < size - 1) {
         LogInfo::MapleLogger() << ",\n";
       } else {
@@ -191,10 +188,10 @@ void MIRModule::DumpGlobals(bool emitStructureType) const {
   if (!fileData.empty()) {
     LogInfo::MapleLogger() << "filedata {\n";
     size_t size = fileData.size();
-    for (size_t i = 0; i < size; i++) {
+    for (size_t i = 0; i < size; ++i) {
       LogInfo::MapleLogger() << "  @" << GlobalTables::GetStrTable().GetStringFromStrIdx(fileData[i].first) << " ";
       size_t dataSize = fileData[i].second.size();
-      for (size_t j = 0; j < dataSize; j++) {
+      for (size_t j = 0; j < dataSize; ++j) {
         uint8 data = fileData[i].second[j];
         LogInfo::MapleLogger() << "0x" << std::hex << static_cast<uint32>(data);
         if (j < dataSize - 1) {
@@ -215,16 +212,18 @@ void MIRModule::DumpGlobals(bool emitStructureType) const {
       const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(*it);
       MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
       ASSERT(type != nullptr, "type should not be nullptr here");
-      MIRStructType *structType = dynamic_cast<MIRStructType*>(type);
-      if (structType != nullptr && !emitStructureType) {
+      bool isStructType = type->IsStructType();
+      if (isStructType) {
+        auto *structType = static_cast<MIRStructType*>(type);
         // still emit what in extern_structtype_set_
-        if (externStructTypeSet.find(structType->GetTypeIndex()) == externStructTypeSet.end()) {
+        if (!emitStructureType && externStructTypeSet.find(structType->GetTypeIndex()) == externStructTypeSet.end()) {
+          continue;
+        }
+        if (structType->IsImported()) {
           continue;
         }
       }
-      if (structType != nullptr && structType->IsImported()) {
-        continue;
-      }
+
       LogInfo::MapleLogger() << "type $" << name << " ";
       if (type->GetKind() == kTypeByName) {
         LogInfo::MapleLogger() << "void";
@@ -237,7 +236,7 @@ void MIRModule::DumpGlobals(bool emitStructureType) const {
     }
     if (someSymbolNeedForwDecl) {
       // an extra pass thru the global symbol table to print forward decl
-      for (auto sit = symbolSet.begin(); sit != symbolSet.end(); sit++) {
+      for (auto sit = symbolSet.begin(); sit != symbolSet.end(); ++sit) {
         MIRSymbol *s = GlobalTables::GetGsymTable().GetSymbolFromStidx((*sit).Idx());
         if (s->IsNeedForwDecl()) {
           s->Dump(false, 0, true);
@@ -245,7 +244,7 @@ void MIRModule::DumpGlobals(bool emitStructureType) const {
       }
     }
     // dump javaclass and javainterface first
-    for (auto sit = symbolDefOrder.begin(); sit != symbolDefOrder.end(); sit++) {
+    for (auto sit = symbolDefOrder.begin(); sit != symbolDefOrder.end(); ++sit) {
       MIRSymbol *s = GlobalTables::GetGsymTable().GetSymbolFromStidx((*sit).Idx());
       if (!s->IsJavaClassInterface()) {
         continue;
@@ -255,7 +254,7 @@ void MIRModule::DumpGlobals(bool emitStructureType) const {
         s->Dump(false, 0);
       }
     }
-    for (auto sit = symbolDefOrder.begin(); sit != symbolDefOrder.end(); sit++) {
+    for (auto sit = symbolDefOrder.begin(); sit != symbolDefOrder.end(); ++sit) {
       MIRSymbol *s = GlobalTables::GetGsymTable().GetSymbolFromStidx((*sit).Idx());
       CHECK_FATAL(s != nullptr, "nullptr check");
       if (s->IsJavaClassInterface()) {
@@ -274,23 +273,22 @@ void MIRModule::Dump(bool emitStructureType) const {
 }
 
 void MIRModule::DumpGlobalArraySymbol() const {
-  MapleSet<StIdx>::iterator sit = symbolSet.begin();
-  for (; sit != symbolSet.end(); sit++) {
-    MIRSymbol *s = GlobalTables::GetGsymTable().GetSymbolFromStidx((*sit).Idx());
-    MIRType *sType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(s->GetTyIdx());
-    if (sType == nullptr || sType->GetKind() != kTypeArray) {
+  for (StIdx stIdx : symbolSet) {
+    MIRSymbol *symbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(stIdx.Idx());
+    MIRType *symbolType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(symbol->GetTyIdx());
+    if (symbolType == nullptr || symbolType->GetKind() != kTypeArray) {
       continue;
     }
-    s->Dump(false, 0);
+    symbol->Dump(false, 0);
   }
 }
 
-void MIRModule::Emit(const std::string &outfileName) const {
+void MIRModule::Emit(const std::string &outFileName) const {
   std::ofstream file;
   // Change cout's buffer to file.
   std::streambuf *backup = LogInfo::MapleLogger().rdbuf();
   LogInfo::MapleLogger().rdbuf(file.rdbuf());
-  file.open(outfileName.c_str(), std::ios::trunc);
+  file.open(outFileName.c_str(), std::ios::trunc);
   DumpGlobals();
   for (MIRFunction *mirFunc : functionList) {
     mirFunc->Dump();
@@ -301,8 +299,8 @@ void MIRModule::Emit(const std::string &outfileName) const {
 }
 
 void MIRModule::DumpFunctionList(bool skipBody) const {
-  for (auto it = functionList.begin(); it != functionList.end(); it++) {
-    (*it)->Dump(skipBody);
+  for (MIRFunction *func : functionList) {
+    func->Dump(skipBody);
   }
 }
 
@@ -328,7 +326,6 @@ void MIRModule::OutputFunctionListAsciiMpl(const std::string &phaseName) {
   DumpFunctionList();
   LogInfo::MapleLogger().rdbuf(backup);  // restore cout's buffer
   mplFile.close();
-  return;
 }
 
 void MIRModule::DumpToFile(const std::string &fileNameStr, bool emitStructureType) const {
@@ -355,9 +352,9 @@ void MIRModule::DumpInlineCandidateToFile(const std::string &fileNameStr) const
   std::streambuf *backup = LogInfo::MapleLogger().rdbuf();
   LogInfo::MapleLogger().rdbuf(file.rdbuf());
   file.open(fileNameStr.c_str(), std::ios::trunc);
-  for (auto it = optimizedFuncs.begin(); it != optimizedFuncs.end(); it++) {
-    (*it)->SetWithLocInfo(false);
-    (*it)->Dump();
+  for (auto *func : optimizedFuncs) {
+    func->SetWithLocInfo(false);
+    func->Dump();
   }
   // Restore cout's buffer.
   LogInfo::MapleLogger().rdbuf(backup);
@@ -366,7 +363,7 @@ void MIRModule::DumpInlineCandidateToFile(const std::string &fileNameStr) const
 
 // This is not efficient. Only used in debug mode for now.
 const std::string &MIRModule::GetFileNameFromFileNum(uint32 fileNum) const {
-  GStrIdx nameIdx = GStrIdx(0);
+  GStrIdx nameIdx(0);
   for (auto &info : srcFileInfo) {
     if (info.second == fileNum) {
       nameIdx = info.first;
@@ -382,7 +379,7 @@ void MIRModule::DumpClassToFile(const std::string &path) const {
   for (auto it : typeNameTab->GetGStrIdxToTyIdxMap()) {
     const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(it.first);
     MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(it.second);
-    std::string outClassFile = name.c_str();
+    std::string outClassFile(name);
     /* replace class name / with - */
     std::replace(outClassFile.begin(), outClassFile.end(), '/', '-');
     outClassFile.insert(0, spath);
@@ -398,7 +395,7 @@ void MIRModule::DumpClassToFile(const std::string &path) const {
     } else {
       type->Dump(1);
     }
-    LogInfo::MapleLogger() << std::endl;
+    LogInfo::MapleLogger() << '\n';
     /* restore cout */
     LogInfo::MapleLogger().rdbuf(backup);
     mplFile.close();
@@ -406,8 +403,7 @@ void MIRModule::DumpClassToFile(const std::string &path) const {
 }
 
 MIRFunction *MIRModule::FindEntryFunction() {
-  for (size_t i = 0; i < functionList.size(); i++) {
-    MIRFunction *currFunc = functionList[i];
+  for (MIRFunction *currFunc : functionList) {
     if (currFunc->GetName() == entryFuncName) {
       entryFunc = currFunc;
       return currFunc;
@@ -421,7 +417,7 @@ MIRFunction *MIRModule::FindEntryFunction() {
 // stem from this->fileName appended with phasename
 void MIRModule::OutputAsciiMpl(const std::string &phaseName, bool emitStructureType) {
   std::string fileStem;
-  std::string::size_type lastDot = fileName.find_last_of(".");
+  std::string::size_type lastDot = fileName.find_last_of('.');
   if (lastDot == std::string::npos) {
     fileStem = fileName.append(phaseName);
   } else {
@@ -440,14 +436,12 @@ void MIRModule::OutputAsciiMpl(const std::string &phaseName, bool emitStructureT
   Dump(emitStructureType);
   LogInfo::MapleLogger().rdbuf(backup);  // restore cout's buffer
   mplFile.close();
-  return;
 }
 
 uint32 MIRModule::GetFileinfo(GStrIdx strIdx) const {
-  size_t size = fileInfo.size();
-  for (size_t i = 0; i < size; i++) {
-    if (fileInfo[i].first == strIdx) {
-      return fileInfo[i].second;
+  for (auto &infoElem : fileInfo) {
+    if (infoElem.first == strIdx) {
+      return infoElem.second;
     }
   }
   ASSERT(false, "should not be here");
@@ -462,13 +456,12 @@ std::string MIRModule::GetFileNameAsPostfix() const {
     fileNameStr += GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(fileNameIdx));
   } else {
     // option 2: src file name removing ext name.
-    ASSERT(fileNameStr.find_last_of(".") != fileNameStr.npos, "not found .");
-    fileNameStr += fileNameStr.substr(0, fileNameStr.find_last_of("."));
+    ASSERT(fileNameStr.find_last_of('.') != fileNameStr.npos, "not found.");
+    fileNameStr += fileNameStr.substr(0, fileNameStr.find_last_of('.'));
   }
-  for (uint32 i = 0; i < fileNameStr.length(); ++i) {
-    char c = fileNameStr[i];
+  for (char &c : fileNameStr) {
     if (!isalpha(c) && !isdigit(c) && c != '_' && c != '$') {
-      fileNameStr[i] = '_';
+      c = '_';
     }
   }
   return fileNameStr;
@@ -476,12 +469,10 @@ std::string MIRModule::GetFileNameAsPostfix() const {
 
 void MIRModule::AddClass(TyIdx t) {
   classList.insert(t.GetIdx());
-  return;
 }
 
 void MIRModule::RemoveClass(TyIdx t) {
   classList.erase(t.GetIdx());
-  return;
 }
 
 #endif  // MIR_FEATURE_FULL
diff --git a/src/maple_ir/src/mir_nodes.cpp b/src/maple_ir/src/mir_nodes.cpp
index b58913b9fbe1335ca4d2485db12a01136cb40e31..462eac9a1a90f726593e7d0bfd0927745cdfdf39 100644
--- a/src/maple_ir/src/mir_nodes.cpp
+++ b/src/maple_ir/src/mir_nodes.cpp
@@ -948,6 +948,23 @@ MIRType *CallNode::GetCallReturnType() {
   MIRFunction *mirFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
   return mirFunc->GetReturnType();
 }
+const MIRSymbol *CallNode::GetCallReturnSymbol(const MIRModule &mod) const {
+  if (!kOpcodeInfo.IsCallAssigned(GetOpCode())) {
+    return nullptr;
+  }
+  const CallReturnVector &nrets = this->GetReturnVec();
+  if (nrets.size() == 1) {
+    StIdx stIdx = nrets.begin()->first;
+    RegFieldPair regFieldPair = nrets.begin()->second;
+    if (!regFieldPair.IsReg()) {
+      const MIRFunction *mirFunc = mod.CurFunction();;
+      const MIRSymbol *st = mirFunc->GetLocalOrGlobalSymbol(stIdx);
+      return st;
+    }
+  }
+  return nullptr;
+}
+
 
 void CallNode::Dump(const MIRModule &mod, int32 indent, bool newline) const {
   StmtNode::DumpBase(mod, indent);
diff --git a/src/maple_me/include/me_builder.h b/src/maple_me/include/me_builder.h
index e2f41abbb82313567020d8c520ac77f4af117ade..f8884227895d169f29e10050b8ac4ddbf335c798 100644
--- a/src/maple_me/include/me_builder.h
+++ b/src/maple_me/include/me_builder.h
@@ -25,10 +25,14 @@ class MeBuilder {
 
   virtual ~MeBuilder() = default;
 
-  MeExpr *CreateMeExpr(int32 exprId, MeExpr &meExpr) const;
+  MeExpr &CreateMeExpr(int32 exprId, MeExpr &meExpr) const;
   MeExpr *BuildMeExpr(BaseNode &mirNode) const;
   VarMeExpr *BuildVarMeExpr(int32 exprID, OStIdx oStIdx, size_t vStIdx, PrimType pType, FieldID fieldID) const;
 
+  UnaryMeStmt &BuildUnaryMeStmt(Opcode op, MeExpr &opnd, BB &bb, const SrcPosition &src) const;
+  UnaryMeStmt &BuildUnaryMeStmt(Opcode op, MeExpr &opnd, BB &bb) const;
+  UnaryMeStmt &BuildUnaryMeStmt(Opcode op, MeExpr &opnd) const;
+
  private:
   template<class T, typename... Arguments>
   T *NewInPool(Arguments&&... args) const {
diff --git a/src/maple_me/include/me_ir.h b/src/maple_me/include/me_ir.h
index bb86cbe02b2348efb23aca79fe1d9b56f94bcf99..70dd96063ca1844a9f2e29170d5e98e56c60b3d0 100644
--- a/src/maple_me/include/me_ir.h
+++ b/src/maple_me/include/me_ir.h
@@ -2121,6 +2121,8 @@ class CallMeStmt : public NaryMeStmt, public MuChiMePart, public AssignedPart {
     return callee->GetReturnType();
   }
 
+  const MIRFunction &GetTargetFunction() const;
+  MIRFunction &GetTargetFunction();
   StmtNode &EmitStmt(SSATab &ssatab);
 
   void SetCallReturn(MeExpr&);
diff --git a/src/maple_me/include/me_option.h b/src/maple_me/include/me_option.h
index c697cbdb231e4444679dae108a8caf2fded1a751..d222812627e1b8d08811bdf9b10f51e08b5b8350 100644
--- a/src/maple_me/include/me_option.h
+++ b/src/maple_me/include/me_option.h
@@ -15,10 +15,10 @@
 #ifndef MAPLE_ME_INCLUDE_ME_OPTION_H
 #define MAPLE_ME_INCLUDE_ME_OPTION_H
 #include <vector>
+#include <string>
 #include "mempool.h"
 #include "mempool_allocator.h"
 #include "types_def.h"
-#include <string>
 
 namespace maple {
 class MeOption {
@@ -69,7 +69,7 @@ class MeOption {
 };
 
 #ifndef DEBUGFUNC
-#define DEBUGFUNC(f)                                                         \
+#define DEBUGFUNC(f)                                                       \
   (MeOption::dumpPhases.find(PhaseName()) != MeOption::dumpPhases.end() && \
    (MeOption::dumpFunc.compare("*") == 0 || f->GetName().find(MeOption::dumpFunc) != std::string::npos))
 #endif
diff --git a/src/maple_me/include/me_phase_manager.h b/src/maple_me/include/me_phase_manager.h
index 38c7f5041d9f0b4d8b77f0533fb51f76cf5d3dfc..349efa0820af9be0bf359d744af9d99168dbbfcf 100644
--- a/src/maple_me/include/me_phase_manager.h
+++ b/src/maple_me/include/me_phase_manager.h
@@ -30,13 +30,8 @@ class MeFuncPhaseManager : public PhaseManager {
  public:
   MeFuncPhaseManager(MemPool *memPool, MIRModule &mod, ModuleResultMgr *mrm = nullptr)
       : PhaseManager(*memPool, "mephase"),
-        arFuncManager(GetMemAllocator()),
         mirModule(mod),
-        modResMgr(mrm),
-        mePhaseType(kMePhaseInvalid),
-        genMeMpl(false),
-        timePhases(false),
-        ipa(false) {}
+        modResMgr(mrm) {}
 
   ~MeFuncPhaseManager() {
     arFuncManager.InvalidAllResults();
@@ -90,13 +85,13 @@ class MeFuncPhaseManager : public PhaseManager {
 
  private:
   /* analysis phase result manager */
-  MeFuncResultMgr arFuncManager;
+  MeFuncResultMgr arFuncManager{GetMemAllocator()};
   MIRModule &mirModule;
   ModuleResultMgr *modResMgr;
-  MePhaseType mePhaseType;
-  bool genMeMpl;
-  bool timePhases;
-  bool ipa;
+  MePhaseType mePhaseType = kMePhaseInvalid;
+  bool genMeMpl = false;
+  bool timePhases = false;
+  bool ipa = false;
 };
 }  // namespace maple
 #endif  // MAPLE_ME_INCLUDE_ME_PHASE_MANAGER_H
diff --git a/src/maple_me/include/me_ssa_update.h b/src/maple_me/include/me_ssa_update.h
index d361a463e2471714f7e64b435cb34829e764265f..782ec89b45c74babbf1557663126f42604304ea7 100644
--- a/src/maple_me/include/me_ssa_update.h
+++ b/src/maple_me/include/me_ssa_update.h
@@ -40,11 +40,11 @@ class MeSSAUpdate {
  private:
   void GetIterDomFrontier(const BB &bb, MapleSet<BBId> &dfSet, std::vector<bool> &visitedMap);
   void InsertPhis();
-  void RenamePhi(BB &bb);
+  void RenamePhi(const BB &bb);
   MeExpr *RenameExpr(MeExpr &meExpr, bool &changed);
-  void RenameStmts(BB &bb);
-  void RenamePhiOpndsInSucc(BB &bb);
-  void RenameBB(BB &bb);
+  void RenameStmts(const BB &bb);
+  void RenamePhiOpndsInSucc(const BB &bb);
+  void RenameBB(const BB &bb);
   MeFunction &func;
   IRMap &irMap;
   SSATab &ssaTab;
diff --git a/src/maple_me/include/orig_symbol.h b/src/maple_me/include/orig_symbol.h
index 0c6edf658f525925eb61cda89624f4049da84eaa..4fc4c1a5acca356ddc5b02ae3251632e211389a5 100644
--- a/src/maple_me/include/orig_symbol.h
+++ b/src/maple_me/include/orig_symbol.h
@@ -150,6 +150,10 @@ class OriginalSt {
     return (ostType == kPregOst);
   }
 
+  bool IsSpecialPreg() const {
+    return ostType == kPregOst && symOrPreg.pregIdx < 0;
+  }
+
   int8 GetIndirectLev() const {
     return indirectLev;
   }
diff --git a/src/maple_me/include/ver_symbol.h b/src/maple_me/include/ver_symbol.h
index 12c6244e30a02cac2a1c1db28e904a36ed3fdfbf..4615de2409f0f664441ed4b37a4acbf3e400885c 100644
--- a/src/maple_me/include/ver_symbol.h
+++ b/src/maple_me/include/ver_symbol.h
@@ -29,11 +29,11 @@ class MayDefNode;  // circular dependency exists, no other choice
 class MustDefNode;  // circular dependency exists, no other choice
 class VersionStTable;  // circular dependency exists, no other choice
 class OriginalSt;  // circular dependency exists, no other choice
+constexpr size_t kInvalidVersionID = static_cast<size_t>(-1);
 class VersionSt {
  public:
   enum DefType {
-    kDassign,
-    kRegassign,
+    kAssign,
     kPhi,
     kMayDef,
     kMustDef
@@ -103,24 +103,16 @@ class VersionSt {
     this->ost = ost;
   }
 
-  const DassignNode *GetDassignNode() const {
-    return defStmt.dassign;
-  }
-  DassignNode *GetDassignNode() {
-    return defStmt.dassign;
-  }
-  void SetDassignNode(DassignNode *dassignNode) {
-    defStmt.dassign = dassignNode;
+  const StmtNode *GetAssignNode() const {
+    return defStmt.assign;
   }
 
-  RegassignNode *GetRegassignNode() {
-    return defStmt.regassign;
+  StmtNode *GetAssignNode() {
+    return defStmt.assign;
   }
-  const RegassignNode *GetRegassignNode() const {
-    return defStmt.regassign;
-  }
-  void SetRegassignNode(RegassignNode *regAssignNode) {
-    defStmt.regassign = regAssignNode;
+
+  void SetAssignNode(StmtNode *assignNode) {
+    defStmt.assign = assignNode;
   }
 
   const PhiNode *GetPhi() const {
@@ -173,11 +165,10 @@ class VersionSt {
   int version;      // starts from 0 for each symbol
   OriginalSt *ost;  // the index of related originalst in originalst_table
   BB *defBB = nullptr;
-  DefType defType = kDassign;
+  DefType defType = kAssign;
 
   union DefStmt {
-    DassignNode *dassign;
-    RegassignNode *regassign;
+    StmtNode *assign;
     PhiNode *phi;
     MayDefNode *mayDef;
     MustDefNode *mustDef;
diff --git a/src/maple_me/src/irmap.cpp b/src/maple_me/src/irmap.cpp
index 672f3f81cee0505312ea7c5bb6cacec0080668f7..5a2f853c4524d3f9b92701c91ae5b318c76219c8 100644
--- a/src/maple_me/src/irmap.cpp
+++ b/src/maple_me/src/irmap.cpp
@@ -627,12 +627,8 @@ MeExpr *IRMap::HashMeExpr(MeExpr &meExpr) {
   }
 
   if (resultExpr == nullptr) {
-    resultExpr = meBuilder.CreateMeExpr(exprID++, meExpr);
-    if (resultExpr != nullptr) {
-      PutToBucket(hidx, *resultExpr);
-    }
+    resultExpr = &meBuilder.CreateMeExpr(exprID++, meExpr);
   }
-
   return resultExpr;
 }
 
diff --git a/src/maple_me/src/irmap_emit.cpp b/src/maple_me/src/irmap_emit.cpp
index 4290e9b201d9fe6623504a8f4a2d3be6db7a96bb..4be2c74333a2e3b76e7dc85a7f3ecb0915fd0a46 100644
--- a/src/maple_me/src/irmap_emit.cpp
+++ b/src/maple_me/src/irmap_emit.cpp
@@ -328,6 +328,14 @@ StmtNode &IassignMeStmt::EmitStmt(SSATab &ssaTab) {
   return *iassignNode;
 }
 
+const MIRFunction &CallMeStmt::GetTargetFunction() const {
+  return *GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+}
+
+MIRFunction &CallMeStmt::GetTargetFunction() {
+  return *GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+}
+
 StmtNode &CallMeStmt::EmitStmt(SSATab &ssaTab) {
   if (GetOp() != OP_icall && GetOp() != OP_icallassigned) {
     CallNode *callNode =
diff --git a/src/maple_me/src/me_builder.cpp b/src/maple_me/src/me_builder.cpp
index 526d6b6c81cbb6955f1e9a6ce96e09b9336e6d46..94048273ab77f9d5c26cd6b63ae5242fe6441853 100644
--- a/src/maple_me/src/me_builder.cpp
+++ b/src/maple_me/src/me_builder.cpp
@@ -19,7 +19,7 @@
 namespace maple {
 using MeExprBuildFactory = FunctionFactory<Opcode, MeExpr*, const MeBuilder*, BaseNode&>;
 
-MeExpr *MeBuilder::CreateMeExpr(int32 exprId, MeExpr &meExpr) const {
+MeExpr &MeBuilder::CreateMeExpr(int32 exprId, MeExpr &meExpr) const {
   MeExpr *resultExpr = nullptr;
   switch (meExpr.GetMeOp()) {
     case kMeOpIvar:
@@ -59,16 +59,13 @@ MeExpr *MeBuilder::CreateMeExpr(int32 exprId, MeExpr &meExpr) const {
       resultExpr = New<GcmallocMeExpr>(exprId, static_cast<GcmallocMeExpr&>(meExpr).GetTyIdx());
       break;
     default:
-      ASSERT(false, "not yet implement");
-      return nullptr;
+      CHECK_FATAL(false, "not yet implement");
   }
-  if (resultExpr != nullptr) {
-    resultExpr->InitBase(meExpr.GetOp(), meExpr.GetPrimType(), meExpr.GetNumOpnds());
-    if (meExpr.GetMeOp() == kMeOpOp || meExpr.GetMeOp() == kMeOpNary) {
-      resultExpr->UpdateDepth();
-    }
+  resultExpr->InitBase(meExpr.GetOp(), meExpr.GetPrimType(), meExpr.GetNumOpnds());
+  if (meExpr.GetMeOp() == kMeOpOp || meExpr.GetMeOp() == kMeOpNary) {
+    resultExpr->UpdateDepth();
   }
-  return resultExpr;
+  return *resultExpr;
 }
 
 VarMeExpr *MeBuilder::BuildVarMeExpr(int32 exprID, OStIdx oStIdx, size_t vStIdx,
@@ -218,6 +215,24 @@ MeExpr *MeBuilder::BuildNaryMeExprForIntrinsicWithType(BaseNode &mirNode) const
   return &meExpr;
 }
 
+UnaryMeStmt &MeBuilder::BuildUnaryMeStmt(Opcode op, MeExpr &opnd, BB &bb, const SrcPosition &src) const {
+  UnaryMeStmt &unaryMeStmt = BuildUnaryMeStmt(op, opnd, bb);
+  unaryMeStmt.SetSrcPos(src);
+  return unaryMeStmt;
+}
+
+UnaryMeStmt &MeBuilder::BuildUnaryMeStmt(Opcode op, MeExpr &opnd, BB &bb) const {
+  UnaryMeStmt &unaryMeStmt = BuildUnaryMeStmt(op, opnd);
+  unaryMeStmt.SetBB(&bb);
+  return unaryMeStmt;
+}
+
+UnaryMeStmt &MeBuilder::BuildUnaryMeStmt(Opcode op, MeExpr &opnd) const {
+  UnaryMeStmt &unaryMeStmt = *New<UnaryMeStmt>(op);
+  unaryMeStmt.SetMeStmtOpndValue(&opnd);
+  return unaryMeStmt;
+}
+
 void MeBuilder::InitMeExprBuildFactory() const {
   RegisterFactoryFunction<MeExprBuildFactory>(OP_addrof, &MeBuilder::BuildAddrofMeExpr);
   RegisterFactoryFunction<MeExprBuildFactory>(OP_addroffunc, &MeBuilder::BuildAddroffuncMeExpr);
diff --git a/src/maple_me/src/me_cfg.cpp b/src/maple_me/src/me_cfg.cpp
index 7c382acca679c749fc921a79e64afbba4d9650f0..e5803b21ae3ea78aba142e82d770734f1661a580 100644
--- a/src/maple_me/src/me_cfg.cpp
+++ b/src/maple_me/src/me_cfg.cpp
@@ -295,16 +295,8 @@ void MeCFG::FixMirCFG() {
       for (StmtNode *stmt = to_ptr(bb->GetStmtNodes().begin()); stmt != nullptr; stmt = stmt->GetNext()) {
         const MIRSymbol *sym = nullptr;
         if (kOpcodeInfo.IsCallAssigned(stmt->GetOpCode())) {
-          CallNode *cnode = static_cast<CallNode *>(stmt);
-          CallReturnVector &nrets = cnode->GetReturnVec();
-          if (nrets.size() != 0) {
-            ASSERT(nrets.size() == 1, "Single Ret value for now.");
-            StIdx stidx = nrets[0].first;
-            RegFieldPair regfieldpair = nrets[0].second;
-            if (!regfieldpair.IsReg()) {
-              sym = func.GetMirFunc()->GetLocalOrGlobalSymbol(stidx);
-            }
-          }
+          CallNode *cNode = static_cast<CallNode *>(stmt);
+          sym = cNode->GetCallReturnSymbol(func.GetMIRModule());
         } else if (stmt->GetOpCode() == OP_dassign) {
           DassignNode *dassStmt = static_cast<DassignNode*>(stmt);
           // exclude the case a = b;
@@ -316,7 +308,7 @@ void MeCFG::FixMirCFG() {
         if (sym == nullptr || sym->GetType()->GetPrimType() != PTY_ref || !sym->IsLocal()) {
           continue;
         }
-        if (FindUse(*stmt, sym->GetStIdx())) {
+        if (kOpcodeInfo.IsCallAssigned(stmt->GetOpCode()) || FindUse(*stmt, sym->GetStIdx())) {
           func.GetMirFunc()->IncTempCount();
           std::string tempStr = std::string("tempRet").append(std::to_string(func.GetMirFunc()->GetTempCount()));
           MIRBuilder *builder = func.GetMirFunc()->GetModule()->GetMIRBuilder();
@@ -358,46 +350,45 @@ void MeCFG::FixMirCFG() {
     }
     if (bb->GetAttributes(kBBAttrIsTry)) {
       for (auto &splitPoint : bb->GetStmtNodes()) {
+        const MIRSymbol *sym = nullptr;
         StmtNode *nextStmt = splitPoint.GetNext();
-        if (nextStmt != nullptr &&
-            (nextStmt->GetOpCode() == OP_dassign || kOpcodeInfo.IsCallAssigned(nextStmt->GetOpCode()))) {
-          const MIRSymbol *sym = nullptr;
+        if (kOpcodeInfo.IsCallAssigned(splitPoint.GetOpCode())) {
+          CallNode *cNode = static_cast<CallNode*>(&splitPoint);
+          sym = cNode->GetCallReturnSymbol(func.GetMIRModule());
+        } else {
+          if (nextStmt == nullptr ||
+              (nextStmt->GetOpCode() != OP_dassign && !kOpcodeInfo.IsCallAssigned(nextStmt->GetOpCode()))) {
+            continue;
+          }
           if (nextStmt->GetOpCode() == OP_dassign) {
             DassignNode *dassignStmt = static_cast<DassignNode*>(nextStmt);
             const StIdx stIdx = dassignStmt->GetStIdx();
             sym = func.GetMirFunc()->GetLocalOrGlobalSymbol(stIdx);
           } else {
             CallNode *cNode = static_cast<CallNode*>(nextStmt);
-            CallReturnVector &nrets = cNode->GetReturnVec();
-            if (!nrets.empty()) {
-              ASSERT(nrets.size() == 1, "Single Ret value for now.");
-              StIdx stIdx = nrets[0].first;
-              RegFieldPair regFieldPair = nrets[0].second;
-              if (!regFieldPair.IsReg()) {
-                sym = func.GetMirFunc()->GetLocalOrGlobalSymbol(stIdx);
-              }
-            }
-          }
-          if (sym == nullptr || sym->GetType()->GetPrimType() != PTY_ref || !sym->IsLocal()) {
-            continue;
+            sym = cNode->GetCallReturnSymbol(func.GetMIRModule());
           }
-          if (HasNoOccBetween(*bb->GetStmtNodes().begin().d(), *nextStmt, sym->GetStIdx())) {
-            continue;
-          }
-          BB &newBB = func.SplitBB(*bb, splitPoint);
-          // because SplitBB will insert a bb, we need update bIt & eIt
-          auto newBBIt = std::find(func.cbegin(), func.cend(), bb);
-          bIt = build_filter_iterator(
-              newBBIt, std::bind(FilterNullPtr<MapleVector<BB*>::const_iterator>, std::placeholders::_1, func.end()));
-          eIt = func.valid_end();
-          for (size_t si = 0; si < newBB.GetSucc().size(); si++) {
-            BB *sucBB = newBB.GetSucc(si);
-            if (sucBB->GetAttributes(kBBAttrIsCatch)) {
-              bb->AddSuccBB(sucBB);
-            }
+        }
+        if (sym == nullptr || sym->GetType()->GetPrimType() != PTY_ref || !sym->IsLocal()) {
+          continue;
+        }
+        if (!kOpcodeInfo.IsCallAssigned(splitPoint.GetOpCode()) &&
+            HasNoOccBetween(*bb->GetStmtNodes().begin().d(), *nextStmt, sym->GetStIdx())) {
+          continue;
+        }
+        BB &newBB = func.SplitBB(*bb, splitPoint);
+        // because SplitBB will insert a bb, we need update bIt & eIt
+        auto newBBIt = std::find(func.cbegin(), func.cend(), bb);
+        bIt = build_filter_iterator(
+            newBBIt, std::bind(FilterNullPtr<MapleVector<BB*>::const_iterator>, std::placeholders::_1, func.end()));
+        eIt = func.valid_end();
+        for (size_t si = 0; si < newBB.GetSucc().size(); si++) {
+          BB *sucBB = newBB.GetSucc(si);
+          if (sucBB->GetAttributes(kBBAttrIsCatch)) {
+            bb->AddSuccBB(sucBB);
           }
-          break;
         }
+        break;
       }
     }
     // removing outgoing exception edge from normal return bb
diff --git a/src/maple_me/src/me_function.cpp b/src/maple_me/src/me_function.cpp
index 3a4b1112ae31c8f2fe40ad811bc4e7f6afa8cea3..ad404e5ffd5095dccd5907079c155c7ec4cf382c 100644
--- a/src/maple_me/src/me_function.cpp
+++ b/src/maple_me/src/me_function.cpp
@@ -414,7 +414,9 @@ void MeFunction::Prepare(unsigned long rangeNum) {
   RemoveEhEdgesInSyncRegion();
   theCFG = memPool->New<MeCFG>(*this);
   theCFG->BuildMirCFG();
-  theCFG->FixMirCFG();
+  if (MeOption::optLevel > MeOption::kLevelZero) {
+    theCFG->FixMirCFG();
+  }
   theCFG->VerifyLabels();
   theCFG->UnreachCodeAnalysis();
   theCFG->WontExitAnalysis();
diff --git a/src/maple_me/src/me_ir.cpp b/src/maple_me/src/me_ir.cpp
index b41e61cd79fd3d345d8ff6da1816535855e69f78..0fb9e5fc932f64986ab55a83a3191308b088fad2 100644
--- a/src/maple_me/src/me_ir.cpp
+++ b/src/maple_me/src/me_ir.cpp
@@ -1338,8 +1338,8 @@ bool MeExpr::PointsToSomethingThatNeedsIncRef() {
       MeStmt *baseStmt = var->GetDefMustDef().GetBase();
       if (baseStmt->GetOp() == OP_callassigned) {
         CallMeStmt *call = static_cast<CallMeStmt*>(baseStmt);
-        MIRFunction *callFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(call->GetPUIdx());
-        if (callFunc->GetName() == "MCC_GetOrInsertLiteral") {
+        MIRFunction &callFunc = call->GetTargetFunction();
+        if (callFunc.GetName() == "MCC_GetOrInsertLiteral") {
           return false;
         }
       }
diff --git a/src/maple_me/src/me_phase_manager.cpp b/src/maple_me/src/me_phase_manager.cpp
index 62abe63c52934df61cbf9e037af0b5565abec298..5ccb1b20f4396da38d4bc66bfaaea0c36e4f2279 100644
--- a/src/maple_me/src/me_phase_manager.cpp
+++ b/src/maple_me/src/me_phase_manager.cpp
@@ -58,13 +58,13 @@ void MeFuncPhaseManager::RegisterFuncPhases() {
   do {                                                                        \
     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)                                                    \
   do {                                                                             \
     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"
@@ -73,7 +73,7 @@ void MeFuncPhaseManager::RegisterFuncPhases() {
 }
 
 void MeFuncPhaseManager::AddPhasesNoDefault(const std::vector<std::string> &phases) {
-  for (size_t i = 0; i < phases.size(); i++) {
+  for (size_t i = 0; i < phases.size(); ++i) {
     PhaseManager::AddPhase(phases[i]);
   }
   ASSERT(phases.size() == GetPhaseSequence()->size(), "invalid phase name");
@@ -130,7 +130,7 @@ void MeFuncPhaseManager::Run(MIRFunction *mirFunc, uint64 rangeNum, const std::s
   /* each function level phase */
   bool dumpFunc = FuncFilter(MeOption::dumpFunc, func.GetName());
   size_t phaseIndex = 0;
-  for (auto it = PhaseSequenceBegin(); it != PhaseSequenceEnd(); it++, ++phaseIndex) {
+  for (auto it = PhaseSequenceBegin(); it != PhaseSequenceEnd(); ++it, ++phaseIndex) {
     PhaseID id = GetPhaseId(it);
     MeFuncPhase *p = static_cast<MeFuncPhase*>(GetPhase(id));
     p->SetPreviousPhaseName(phaseName); /* prev phase name is for filename used in emission after phase */
@@ -168,7 +168,7 @@ void MeFuncPhaseManager::Run(MIRFunction *mirFunc, uint64 rangeNum, const std::s
     MeFunction function(&mirModule, mirFunc, funcMP, versMemPool, meInput);
     function.PartialInit(true);
     function.Prepare(rangeNum);
-    for (auto it = PhaseSequenceBegin(); it != PhaseSequenceEnd(); it++) {
+    for (auto it = PhaseSequenceBegin(); it != PhaseSequenceEnd(); ++it) {
       PhaseID id = GetPhaseId(it);
       MeFuncPhase *p = static_cast<MeFuncPhase*>(GetPhase(id));
       if (p == changeCFGPhase) {
diff --git a/src/maple_me/src/me_rc_lowering.cpp b/src/maple_me/src/me_rc_lowering.cpp
index 30313fe8a548cbb50e7bc72f0790dc1ed2fb35ac..b125fbe4cbe0721870681f032874cc4221ce093d 100644
--- a/src/maple_me/src/me_rc_lowering.cpp
+++ b/src/maple_me/src/me_rc_lowering.cpp
@@ -206,7 +206,7 @@ void RCLowering::HandleAssignMeStmtRHS(MeStmt &stmt) {
 
 void RCLowering::HandleCallAssignedMeStmt(MeStmt &stmt, MeExpr *pendingDec) {
   MapleVector<MustDefMeNode> *mustDefs = stmt.GetMustDefList();
-  ASSERT(mustDefs != nullptr, "null ptr check");
+  ASSERT_NOT_NULL(mustDefs);
 
   BB *bb = stmt.GetBB();
   CHECK_FATAL(bb != nullptr, "bb null ptr check");
@@ -242,8 +242,8 @@ void RCLowering::IntroduceRegRetIntoCallAssigned(MeStmt &stmt) {
   RegMeExpr *curTmp = irMap.CreateRegMeExpr(PTY_ref);
   stmt.GetMustDefList()->push_back(MustDefMeNode(curTmp, &stmt));
   std::vector<MeExpr*> opnds = { curTmp };
-  IntrinsiccallMeStmt *decrefCall = CreateRCIntrinsic(INTRN_MCCDecRef, stmt, opnds);
-  stmt.GetBB()->InsertMeStmtAfter(&stmt, decrefCall);
+  IntrinsiccallMeStmt *decRefCall = CreateRCIntrinsic(INTRN_MCCDecRef, stmt, opnds);
+  stmt.GetBB()->InsertMeStmtAfter(&stmt, decRefCall);
 }
 
 void RCLowering::HandleRetOfCallAssignedMeStmt(MeStmt &stmt, MeExpr &pendingDec) {
@@ -251,10 +251,10 @@ void RCLowering::HandleRetOfCallAssignedMeStmt(MeStmt &stmt, MeExpr &pendingDec)
   CHECK_FATAL(bb != nullptr, "bb null ptr check");
   RegassignMeStmt *backup = irMap.CreateRegassignMeStmt(*irMap.CreateRegMeExpr(PTY_ref), pendingDec, *bb);
   std::vector<MeExpr*> opnds = { backup->GetRegLHS() };
-  IntrinsiccallMeStmt *decrefCall = CreateRCIntrinsic(INTRN_MCCDecRef, stmt, opnds);
+  IntrinsiccallMeStmt *decRefCall = CreateRCIntrinsic(INTRN_MCCDecRef, stmt, opnds);
   if (!dynamic_cast<CallMeStmt*>(&stmt)) {
     bb->InsertMeStmtBefore(&stmt, backup);
-    bb->InsertMeStmtAfter(&stmt, decrefCall);
+    bb->InsertMeStmtAfter(&stmt, decRefCall);
   } else {
     /*
      * simple optimization for callassign
@@ -264,7 +264,7 @@ void RCLowering::HandleRetOfCallAssignedMeStmt(MeStmt &stmt, MeExpr &pendingDec)
     RegMeExpr *curTmp = irMap.CreateRegMeExpr(PTY_ref);
     MeStmt *regToVar = irMap.CreateDassignMeStmt(*stmt.GetAssignedLHS(), *curTmp, *bb);
     stmt.GetMustDefList()->front().UpdateLHS(*curTmp);
-    bb->InsertMeStmtAfter(&stmt, decrefCall);
+    bb->InsertMeStmtAfter(&stmt, decRefCall);
     bb->InsertMeStmtAfter(&stmt, regToVar);
     bb->InsertMeStmtAfter(&stmt, backup);
   }
@@ -400,7 +400,7 @@ bool RCLowering::IsInitialized(IvarMeExpr &ivar) {
     return true;
   }
   MIRType *baseType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivar.GetTyIdx());
-  ASSERT(dynamic_cast<MIRPtrType*>(baseType) != nullptr, "unexpected type");
+  ASSERT(baseType->IsMIRPtrType(), "unexpect type");
   auto *ptype = static_cast<MIRPtrType*>(baseType)->GetPointedType();
   auto *classType = dynamic_cast<MIRClassType*>(ptype);
   return classType == nullptr || !classType->IsOwnField(fieldID);
@@ -411,7 +411,7 @@ void RCLowering::HandleAssignMeStmtIvarLHS(MeStmt &stmt) {
   IvarMeExpr *lhsInner = iassign.GetLHSVal();
   FieldID fieldID = lhsInner->GetFieldID();
   MIRType *baseType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(lhsInner->GetTyIdx());
-  ASSERT(dynamic_cast<MIRPtrType*>(baseType) != nullptr, "unexpected type");
+  ASSERT(baseType->IsMIRPtrType(), "unexpect type");
   auto *ptype = static_cast<MIRPtrType*>(baseType)->GetPointedType();
   auto *classType = dynamic_cast<MIRClassType*>(ptype);
   // skip RC operation if the field is unowned
@@ -508,7 +508,7 @@ void RCLowering::InitializedObjectFields(MeStmt &stmt) {
     return;
   }
   auto &call = static_cast<CallMeStmt&>(stmt);
-  MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(call.GetPUIdx());
+  MIRFunction &callee = call.GetTargetFunction();
   if (call.NumMeStmtOpnds() == 0 || call.GetOpnd(0)->GetMeOp() != kMeOpVar) {
     return;
   }
@@ -517,7 +517,7 @@ void RCLowering::InitializedObjectFields(MeStmt &stmt) {
   bool hasNotInitialized = initializedFields.find(firstOpnd) == initializedFields.end();
   bool inInitializedMap =
       mirModule.GetPuIdxFieldInitializedMap().find(call.GetPUIdx()) != mirModule.GetPuIdxFieldInitializedMap().end();
-  if (callee->IsConstructor() && isNew && hasNotInitialized && inInitializedMap) {
+  if (callee.IsConstructor() && isNew && hasNotInitialized && inInitializedMap) {
     initializedFields[firstOpnd] = mirModule.GetPUIdxFieldInitializedMapItem(call.GetPUIdx());
   } else {
     for (auto iter : call.GetOpnds()) {
@@ -638,13 +638,13 @@ void RCLowering::HandleReturnFormal(RetMeStmt &ret) {
   auto *retVar = static_cast<VarMeExpr*>(ret.GetOpnd(0));
   CHECK_FATAL(retVar != nullptr, "retVal null ptr check");
   std::vector<MeExpr*> opnds = { retVar };
-  IntrinsiccallMeStmt *increfStmt = CreateRCIntrinsic(INTRN_MCCIncRef, ret, opnds, true);
-  ret.SetOpnd(0, increfStmt->GetMustDefList()->front().GetLHS());
+  IntrinsiccallMeStmt *incRefStmt = CreateRCIntrinsic(INTRN_MCCIncRef, ret, opnds, true);
+  ret.SetOpnd(0, incRefStmt->GetMustDefList()->front().GetLHS());
   IntrinsiccallMeStmt *cleanup = FindCleanupIntrinsic(ret);
   if (cleanup == nullptr) {
-    bb->InsertMeStmtBefore(&ret, increfStmt);
+    bb->InsertMeStmtBefore(&ret, incRefStmt);
   } else {
-    bb->InsertMeStmtAfter(cleanup, increfStmt);
+    bb->InsertMeStmtAfter(cleanup, incRefStmt);
   }
 }
 
@@ -675,7 +675,7 @@ void RCLowering::HandleReturnReg(RetMeStmt &ret) {
   }
   if (regRet->GetDefBy() == kDefByStmt && regRet->GetDefStmt()->GetOp() == OP_regassign) {
     MeExpr *rhs = regRet->GetDefStmt()->GetRHS();
-    ASSERT(rhs != nullptr, "null ptr check");
+    ASSERT_NOT_NULL(rhs);
     if (rhs->GetOp() == OP_gcmalloc || rhs->GetOp() == OP_gcmallocjarray) {
       return;
     }
@@ -781,8 +781,8 @@ void RCLowering::HandleArguments() {
 
     for (auto *stmt : rets) {
       std::vector<MeExpr*> opnds = { argVar };
-      IntrinsiccallMeStmt *decrefCall = CreateRCIntrinsic(INTRN_MCCDecRef, *stmt, opnds);
-      stmt->GetBB()->InsertMeStmtBefore(stmt, decrefCall);
+      IntrinsiccallMeStmt *decRefCall = CreateRCIntrinsic(INTRN_MCCDecRef, *stmt, opnds);
+      stmt->GetBB()->InsertMeStmtBefore(stmt, decRefCall);
     }
   }
 }
@@ -829,7 +829,7 @@ VarMeExpr *RCLowering::CreateNewTmpVarMeExpr(bool isLocalRefVar) {
 
 AnalysisResult *MeDoRCLowering::Run(MeFunction *func, MeFuncResultMgr *funcResMgr, ModuleResultMgr *moduleResMgr) {
   auto *kh = static_cast<KlassHierarchy*>(moduleResMgr->GetAnalysisResult(MoPhase_CHA, &func->GetMIRModule()));
-  ASSERT(kh != nullptr, "KlassHierarchy has problem");
+  ASSERT_NOT_NULL(kh);
   if (func->GetIRMap() == nullptr) {
     auto *hmap = static_cast<MeIRMap*>(funcResMgr->GetAnalysisResult(MeFuncPhase_IRMAP, func));
     CHECK_FATAL(hmap != nullptr, "hssamap has problem");
diff --git a/src/maple_me/src/me_ssa.cpp b/src/maple_me/src/me_ssa.cpp
index 79d55739dede4f8b301dee6b488810104834aeec..b92ff249baf400cb149357f6d40a27e398c2ccd4 100644
--- a/src/maple_me/src/me_ssa.cpp
+++ b/src/maple_me/src/me_ssa.cpp
@@ -63,36 +63,37 @@ void MeSSA::CollectDefBBs(std::map<OStIdx, std::set<BBId>> &ostDefBBs) {
   for (auto bIt = func->valid_begin(); bIt != eIt; ++bIt) {
     auto *bb = *bIt;
     for (auto &stmt : bb->GetStmtNodes()) {
-      if (kOpcodeInfo.HasSSADef(stmt.GetOpCode())) {
-        MapleMap<OStIdx, MayDefNode> &mayDefs = GetSSATab()->GetStmtsSSAPart().GetMayDefNodesOf(stmt);
-        MapleMap<OStIdx, MayDefNode>::iterator iter;
-        for (iter = mayDefs.begin(); iter != mayDefs.end(); ++iter) {
-          const OriginalSt *ost = func->GetMeSSATab()->GetOriginalStFromID(iter->first);
-          if (ost != nullptr && (!ost->IsFinal() || func->GetMirFunc()->IsConstructor())) {
+      if (!kOpcodeInfo.HasSSADef(stmt.GetOpCode())) {
+        continue;
+      }
+      MapleMap<OStIdx, MayDefNode> &mayDefs = GetSSATab()->GetStmtsSSAPart().GetMayDefNodesOf(stmt);
+      for (auto iter = mayDefs.begin(); iter != mayDefs.end(); ++iter) {
+        const OriginalSt *ost = func->GetMeSSATab()->GetOriginalStFromID(iter->first);
+        if (ost != nullptr && (!ost->IsFinal() || func->GetMirFunc()->IsConstructor())) {
+          ostDefBBs[iter->first].insert(bb->GetBBId());
+        } else if (stmt.GetOpCode() == OP_intrinsiccallwithtype) {
+          auto &inNode = static_cast<IntrinsiccallNode&>(stmt);
+          if (inNode.GetIntrinsic() == INTRN_JAVA_CLINIT_CHECK) {
             ostDefBBs[iter->first].insert(bb->GetBBId());
-          } else if (stmt.GetOpCode() == OP_intrinsiccallwithtype) {
-            auto &inNode = static_cast<IntrinsiccallNode&>(stmt);
-            if (inNode.GetIntrinsic() == INTRN_JAVA_CLINIT_CHECK) {
-              ostDefBBs[iter->first].insert(bb->GetBBId());
-            }
           }
         }
-        if (stmt.GetOpCode() == OP_dassign || stmt.GetOpCode() == OP_maydassign) {
-          VersionSt *vst = GetSSATab()->GetStmtsSSAPart().GetAssignedVarOf(stmt);
-          OriginalSt *ost = vst->GetOrigSt();
-          if (ost != nullptr && (!ost->IsFinal() || func->GetMirFunc()->IsConstructor())) {
-            ostDefBBs[vst->GetOrigIdx()].insert(bb->GetBBId());
-          }
+      }
+      if (stmt.GetOpCode() == OP_dassign || stmt.GetOpCode() == OP_maydassign) {
+        VersionSt *vst = GetSSATab()->GetStmtsSSAPart().GetAssignedVarOf(stmt);
+        OriginalSt *ost = vst->GetOrigSt();
+        if (ost != nullptr && (!ost->IsFinal() || func->GetMirFunc()->IsConstructor())) {
+          ostDefBBs[vst->GetOrigIdx()].insert(bb->GetBBId());
         }
       }
-      if (kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) {  // Needs to handle mustDef in callassigned stmt
-        MapleVector<MustDefNode> &mustDefs = GetSSATab()->GetStmtsSSAPart().GetMustDefNodesOf(stmt);
-        MapleVector<MustDefNode>::iterator iter;
-        for (iter = mustDefs.begin(); iter != mustDefs.end(); ++iter) {
-          OriginalSt *ost = iter->GetResult()->GetOrigSt();
-          if (ost != nullptr && (!ost->IsFinal() || func->GetMirFunc()->IsConstructor())) {
-            ostDefBBs[ost->GetIndex()].insert(bb->GetBBId());
-          }
+      // Needs to handle mustDef in callassigned stmt
+      if (!kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) {
+        continue;
+      }
+      MapleVector<MustDefNode> &mustDefs = GetSSATab()->GetStmtsSSAPart().GetMustDefNodesOf(stmt);
+      for (auto iter = mustDefs.begin(); iter != mustDefs.end(); ++iter) {
+        OriginalSt *ost = iter->GetResult()->GetOrigSt();
+        if (ost != nullptr && (!ost->IsFinal() || func->GetMirFunc()->IsConstructor())) {
+          ostDefBBs[ost->GetIndex()].insert(bb->GetBBId());
         }
       }
     }
diff --git a/src/maple_me/src/me_ssa_update.cpp b/src/maple_me/src/me_ssa_update.cpp
index ebd8706655d5a13de2602f2d29ad402394a9b0eb..50557df6e7c9bdc8ee311e1aad32718c8280a70b 100644
--- a/src/maple_me/src/me_ssa_update.cpp
+++ b/src/maple_me/src/me_ssa_update.cpp
@@ -47,7 +47,7 @@ void MeSSAUpdate::InsertPhis() {
     for (const auto &bbId : dfSet) {
       // insert a phi node
       BB *bb = func.GetBBFromID(bbId);
-      ASSERT(bb != nullptr, "null ptr check");
+      ASSERT_NOT_NULL(bb);
       auto phiListIt = bb->GetMevarPhiList().find(it->first);
       if (phiListIt != bb->GetMevarPhiList().end()) {
         phiListIt->second->SetIsLive(true);
@@ -63,21 +63,22 @@ void MeSSAUpdate::InsertPhis() {
   }
 }
 
-void MeSSAUpdate::RenamePhi(BB &bb) {
+void MeSSAUpdate::RenamePhi(const BB &bb) {
   for (auto it1 = renameStacks.begin(); it1 != renameStacks.end(); ++it1) {
     auto it2 = bb.GetMevarPhiList().find(it1->first);
-    if (it2 != bb.GetMevarPhiList().end()) {
-      // if there is existing phi result node
-      MeVarPhiNode *phi = it2->second;
-      phi->SetIsLive(true);  // always make it live, for correctness
-      if (phi->GetLHS() == nullptr) {
-        // create a new VarMeExpr defined by this phi
-        VarMeExpr *newVar = irMap.CreateNewVarMeExpr(it2->first, PTY_ref, 0);
-        phi->UpdateLHS(*newVar);
-        it1->second->push(newVar);  // push the stack
-      } else {
-        it1->second->push(phi->GetLHS());  // push the stack
-      }
+    if (it2 == bb.GetMevarPhiList().end()) {
+      continue;
+    }
+    // if there is existing phi result node
+    MeVarPhiNode *phi = it2->second;
+    phi->SetIsLive(true);  // always make it live, for correctness
+    if (phi->GetLHS() == nullptr) {
+      // create a new VarMeExpr defined by this phi
+      VarMeExpr *newVar = irMap.CreateNewVarMeExpr(it2->first, PTY_ref, 0);
+      phi->UpdateLHS(*newVar);
+      it1->second->push(newVar);  // push the stack
+    } else {
+      it1->second->push(phi->GetLHS());  // push the stack
     }
   }
 }
@@ -155,7 +156,7 @@ MeExpr *MeSSAUpdate::RenameExpr(MeExpr &meExpr, bool &changed) {
   }
 }
 
-void MeSSAUpdate::RenameStmts(BB &bb) {
+void MeSSAUpdate::RenameStmts(const BB &bb) {
   for (auto &stmt : bb.GetMeStmts()) {
     // rename the expressions
     bool changed = false;
@@ -195,7 +196,7 @@ void MeSSAUpdate::RenameStmts(BB &bb) {
   }
 }
 
-void MeSSAUpdate::RenamePhiOpndsInSucc(BB &bb) {
+void MeSSAUpdate::RenamePhiOpndsInSucc(const BB &bb) {
   for (BB *succ : bb.GetSucc()) {
     // find index of bb in succ_bb->pred_[]
     size_t index = 0;
@@ -221,7 +222,7 @@ void MeSSAUpdate::RenamePhiOpndsInSucc(BB &bb) {
   }
 }
 
-void MeSSAUpdate::RenameBB(BB &bb) {
+void MeSSAUpdate::RenameBB(const BB &bb) {
   // for recording stack height on entering this BB, to pop back to same height
   // when backing up the dominator tree
   std::map<OStIdx, uint32> origStackSize((std::less<OStIdx>()));
diff --git a/src/maple_me/src/ssa.cpp b/src/maple_me/src/ssa.cpp
index 444770ff96dbc7552221083bd7700fd8455a19d0..07d3e36c000ebbb8fea3713386fd674a0a17a37b 100644
--- a/src/maple_me/src/ssa.cpp
+++ b/src/maple_me/src/ssa.cpp
@@ -36,7 +36,8 @@ void SSA::InitRenameStack(OriginalStTable &oTable, size_t bbSize, VersionStTable
 VersionSt *SSA::CreateNewVersion(VersionSt &vSym, BB &defBB) {
   CHECK_FATAL(vSym.GetVersion() == 0, "rename before?");
   // volatile variables will keep zero version.
-  if (vSym.GetOrigSt()->IsVolatile()) {
+  OriginalSt *oSt = vSym.GetOrigSt();
+  if (oSt->IsVolatile() || oSt->IsSpecialPreg()) {
     return &vSym;
   }
   CHECK_FATAL(vSym.GetOrigIdx().idx < vstVersions.size(), "index out of range in SSA::CreateNewVersion");
@@ -62,26 +63,15 @@ void SSA::RenamePhi(BB &bb) {
 
 void SSA::RenameDefs(StmtNode &stmt, BB &defBB) {
   Opcode opcode = stmt.GetOpCode();
-  if (opcode == OP_regassign) {
-    RegassignNode &regNode = static_cast<RegassignNode&>(stmt);
-    if (regNode.GetRegIdx() < 0) {
-      return;
-    }
-    AccessSSANodes *theSSAPart = ssaTab->GetStmtsSSAPart().SSAPartOf(stmt);
-    VersionSt *newVersionSym = CreateNewVersion(*(theSSAPart->GetSSAVar()), defBB);
-    newVersionSym->SetDefType(VersionSt::kRegassign);
-    newVersionSym->SetRegassignNode(&regNode);
-    theSSAPart->SetSSAVar(*newVersionSym);
-    return;
-  } else if (opcode == OP_dassign) {
-    AccessSSANodes *theSSAPart = ssaTab->GetStmtsSSAPart().SSAPartOf(stmt);
+  AccessSSANodes *theSSAPart = ssaTab->GetStmtsSSAPart().SSAPartOf(stmt);
+  if (kOpcodeInfo.AssignActualVar(opcode)) {
     VersionSt *newVersionSym = CreateNewVersion(*theSSAPart->GetSSAVar(), defBB);
-    newVersionSym->SetDefType(VersionSt::kDassign);
-    newVersionSym->SetDassignNode(static_cast<DassignNode*>(&stmt));
+    newVersionSym->SetDefType(VersionSt::kAssign);
+    newVersionSym->SetAssignNode(&stmt);
     theSSAPart->SetSSAVar(*newVersionSym);
   }
-  if (kOpcodeInfo.HasSSADef(stmt.GetOpCode())) {
-    MapleMap<OStIdx, MayDefNode> &mayDefList = ssaTab->GetStmtsSSAPart().GetMayDefNodesOf(stmt);
+  if (kOpcodeInfo.HasSSADef(opcode)) {
+    MapleMap<OStIdx, MayDefNode> &mayDefList = theSSAPart->GetMayDefNodes();
     for (auto it = mayDefList.begin(); it != mayDefList.end(); it++) {
       MayDefNode &mayDef = it->second;
       VersionSt *vSym = mayDef.GetResult();
diff --git a/src/maple_me/src/ver_symbol.cpp b/src/maple_me/src/ver_symbol.cpp
index 760c5fea50be24e5ad39491064bc1a95cb7b1de2..912e7b46c5111faf1e48321f6299605c047214fa 100644
--- a/src/maple_me/src/ver_symbol.cpp
+++ b/src/maple_me/src/ver_symbol.cpp
@@ -24,8 +24,8 @@ void VersionSt::DumpDefStmt(const MIRModule *mod) const {
     return;
   }
   switch (defType) {
-    case kDassign:
-      defStmt.dassign->Dump(*mod, 0);
+    case kAssign:
+      defStmt.assign->Dump(*mod, 0);
       return;
     case kPhi:
       defStmt.phi->Dump(mod);
@@ -36,8 +36,6 @@ void VersionSt::DumpDefStmt(const MIRModule *mod) const {
     case kMustDef:
       defStmt.mustDef->Dump(mod);
       return;
-    case kRegassign:
-      defStmt.dassign->Dump(*mod, 0);
     default:
       ASSERT(false, "not yet implement");
   }
diff --git a/src/maple_phase/include/phase.h b/src/maple_phase/include/phase.h
index 49ba47e515c3a2954ebd1eb7e0fd83ebff66f19e..45fc92b1f5118002b06ecbfc458d368bae1d478e 100644
--- a/src/maple_phase/include/phase.h
+++ b/src/maple_phase/include/phase.h
@@ -41,7 +41,7 @@ class AnalysisResult {
     memPoolCtrler.DeleteMemPool(memPool);
   }
 
-  virtual ~AnalysisResult() {}
+  virtual ~AnalysisResult() = default;
 
  private:
   MemPool *memPool;
@@ -60,7 +60,7 @@ class Phase {
   MemPool *NewMemPool() {
     std::string phaseName = PhaseName();
     ASSERT(!phaseName.empty(), "PhaseName should not be empty");
-    memPoolCount++;
+    ++memPoolCount;
     std::string memPoolName = phaseName + " MemPool " + std::to_string(memPoolCount);
     MemPool *memPool = memPoolCtrler.NewMemPool(memPoolName.c_str());
     memPools.push_back(memPool);
@@ -80,7 +80,7 @@ class Phase {
     memPools.shrink_to_fit();
   }
 
-  virtual ~Phase(){};
+  virtual ~Phase() = default;
 
  private:
   unsigned int memPoolCount = 0;
@@ -145,14 +145,14 @@ class AnalysisResultManager {
 
   void InvalidIRbaseAnalysisResult(UnitIR &ir) {
     PhaseIDT id;
-    for (auto it = analysisPhases.begin(); it != analysisPhases.end(); it++) {
+    for (auto it = analysisPhases.begin(); it != analysisPhases.end(); ++it) {
       id = it->first;
       InvalidAnalysisResult(id, &ir);
     }
   }
 
   void InvalidAllResults() {
-    for (auto it = analysisResults.begin(); it != analysisResults.end(); it++) {
+    for (auto it = analysisResults.begin(); it != analysisResults.end(); ++it) {
       AnalysisResult *r = it->second;
       ASSERT(r != nullptr, "r is null in AnalysisResultManager::InvalidAllResults");
       r->EraseMemPool();
diff --git a/src/maple_phase/include/phase_manager.h b/src/maple_phase/include/phase_manager.h
index 39bf9360889575f01771eecb27375f6eb9e3bae6..257e5b13bbe8fade685427cbeb5e2a079c5e2268 100644
--- a/src/maple_phase/include/phase_manager.h
+++ b/src/maple_phase/include/phase_manager.h
@@ -28,10 +28,10 @@ class PhaseManager {
         phaseSequences(allocator.Adapter()),
         phaseTimers(allocator.Adapter()) {}
 
-  virtual ~PhaseManager() {}
+  virtual ~PhaseManager() = default;
 
   void AddPhase(const std::string &pname) {
-    for (auto it = RegPhaseBegin(); it != RegPhaseEnd(); it++) {
+    for (auto it = RegPhaseBegin(); it != RegPhaseEnd(); ++it) {
       if (GetPhaseName(it) == pname) {
         phaseSequences.push_back(GetPhaseId(it));
         phaseTimers.push_back(0);
@@ -46,7 +46,7 @@ class PhaseManager {
   }
 
   Phase *GetPhaseFromName(const std::string &pname) {
-    for (auto it = RegPhaseBegin(); it != RegPhaseEnd(); it++) {
+    for (auto it = RegPhaseBegin(); it != RegPhaseEnd(); ++it) {
       if (GetPhaseName(it) == pname) {
         return GetPhase(GetPhaseId(it));
       }
@@ -121,12 +121,11 @@ class PhaseManager {
   }
 
   bool ExistPhase(const std::string &name) {
-    for (auto it = RegPhaseBegin(); it != RegPhaseEnd(); it++) {
+    for (auto it = RegPhaseBegin(); it != RegPhaseEnd(); ++it) {
       if (GetPhaseName(it) == name) {
         return true;
       }
     }
-
     return false;
   }
 
diff --git a/src/maple_util/include/mpl_logging.h b/src/maple_util/include/mpl_logging.h
index bb7f31181e92e1de177b7c55634f5e5d97ec737c..12992b8dd65c56a0e0eee97c313699ae6e5f8a60 100644
--- a/src/maple_util/include/mpl_logging.h
+++ b/src/maple_util/include/mpl_logging.h
@@ -134,6 +134,7 @@
 
 namespace maple {
 extern class LogInfo logInfo;
+extern class LogInfo &log;
 
 enum LogLevel { kLlDbg, kLlLog, kLlInfo, kLlWarn, kLlErr, kLlFatal, kLlMax };
 
@@ -153,6 +154,8 @@ class LogInfo {
  public:
   LogInfo() : outStream(stdout), outMode(kLmComplex) {}
   LogInfo(const LogInfo &p) = delete;
+  static std::ostream &Info();
+  static std::ostream &Err();
   LogInfo &operator=(const LogInfo &p) = delete;
 
   ~LogInfo() {
diff --git a/src/maple_util/include/name_mangler.h b/src/maple_util/include/name_mangler.h
index f245df8871daa7d3ba15c89ba44e26340760f3d2..1ac9a706b22186b21abfdd9f407363236fc2c712 100644
--- a/src/maple_util/include/name_mangler.h
+++ b/src/maple_util/include/name_mangler.h
@@ -103,6 +103,8 @@ static constexpr const char kDecoupleOption[] = "__decouple_option";
 static constexpr const char kDecoupleStr[] = "__decouple";
 static constexpr const char kCompilerVersionNum[] = "__compilerVersionNum";
 static constexpr const char kCompilerVersionNumStr[] = "__compilerVersionNumTab";
+static constexpr const char kSourceMuid[] = "__sourceMuid";
+static constexpr const char kSourceMuidSectionStr[] = "__sourceMuidTab";
 
 static constexpr const char kStaticFieldNamePrefixStr[] = "__static_field_name";
 static constexpr const char kPackageNameSplitterStr[] = "_2F";
@@ -132,6 +134,8 @@ static constexpr const char kFunctionProfileTabPrefixStr[] = "__muid_profile_fun
 
 static constexpr const char kBindingProtectedRegionStr[] = "__BindingProtectRegion__";
 
+static constexpr const char kClassNamePrefixStr[] = "L";
+static constexpr const char kClassMethodSplitterStr[] = "_3B";
 // Serve as a global flag to indicate whether frequent strings have been compressed
 extern bool doCompression;