diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl
index 7c5dbc84aa841beae787cbc82efbe94acc66d758..e75d02a25af445e0e0f09cd6817b80a24a946e06 100755
Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ
diff --git a/src/bin/maple b/src/bin/maple
index b828723bf7cc78ac12c6026ab4030a5e0895efc7..da07cd0c7ea1d1a23c25b58d90423b1713d4b0af 100755
Binary files a/src/bin/maple and b/src/bin/maple differ
diff --git a/src/bin/mplcg b/src/bin/mplcg
index 9b29f4f34e1f7b732182967bee15368ec9dbd33c..682212700691f38f1ac57ae123b056a04bc4828b 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 258ef445011ea1095e52bae1c65a97686afc9e92..fe4cf6462bc044da716079c257603c20f8d69122 100644
Binary files a/src/deplibs/libmaple_driverutil.a and b/src/deplibs/libmaple_driverutil.a differ
diff --git a/src/deplibs/libmplphase.a b/src/deplibs/libmplphase.a
index fd6b0a1bdcd5b97ae979593e213859e2d855f818..02fa626330d35878ef13f701d14ed16782b29f8a 100644
Binary files a/src/deplibs/libmplphase.a and b/src/deplibs/libmplphase.a differ
diff --git a/src/deplibs/libmplutil.a b/src/deplibs/libmplutil.a
index f4a6b0b90d736c2a26aea749e1040d190c66cb70..ed68378bc7b23d0f2c8ac207a8f8bb9e93b58883 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 4c6fcb40a9c98d6f597b476f96c77be149700ca1..012aff7fe461bb4d45dbf28d6011cf257eaeac11 100644
--- a/src/maple_driver/include/mpl_options.h
+++ b/src/maple_driver/include/mpl_options.h
@@ -146,6 +146,7 @@ class MplOptions {
   ErrorCode CheckFileExits();
   void AddOption(const mapleOption::Option &option);
   void UpdateOptLevel(OptimizationLevel level);
+  ErrorCode UpdatePhaseOption(const std::string &args, const std::string &exeName);
   ErrorCode UpdateExtraOptionOpt(const std::string &args);
   ErrorCode AppendDefaultOptions(const std::string &exeName, MplOption mplOptions[], unsigned int length);
   void UpdateRunningExe(const std::string &args);
diff --git a/src/maple_driver/include/usages.h b/src/maple_driver/include/usages.h
index 0bc6acf3bb2937890d1333fe985bc376ba59d676..8aec6f877312c1480fe1b5d3fb2a7e5e72006209 100644
--- a/src/maple_driver/include/usages.h
+++ b/src/maple_driver/include/usages.h
@@ -23,6 +23,8 @@ enum OptionIndex {
   kInFile,
   kInMplt,
   kOptimization0,
+  kMeOpt,
+  kMpl2MplOpt,
   kSaveTemps,
   kRun,
   kOption,
@@ -156,6 +158,30 @@ const static mapleOption::Descriptor USAGES[] = {
     "  -O0                         \tNo optimization.\n",
     "all",
     { { nullptr } } },
+  { kMeOpt,
+    0,
+    nullptr,
+    "me-opt",
+    nullptr,
+    false,
+    nullptr,
+    mapleOption::BuildType::kBuildTypeAll,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --me-opt                    \tSet options for me\n",
+    "all",
+    { { nullptr } } },
+  { kMpl2MplOpt,
+    0,
+    nullptr,
+    "mpl2mpl-opt",
+    nullptr,
+    false,
+    nullptr,
+    mapleOption::BuildType::kBuildTypeAll,
+    mapleOption::ArgCheckPolicy::kArgCheckPolicyNone,
+    "  --mpl2mpl-opt               \tSet options for mpl2mpl\n",
+    "all",
+    { { nullptr } } },
   { kSaveTemps,
     0,
     nullptr,
diff --git a/src/maple_driver/src/maple_comb_compiler.cpp b/src/maple_driver/src/maple_comb_compiler.cpp
index 6770dd273af8143b3d8b31a853b4133be13bc180..d8ffccb7ce052e7fad077937789ad647098e3867 100644
--- a/src/maple_driver/src/maple_comb_compiler.cpp
+++ b/src/maple_driver/src/maple_comb_compiler.cpp
@@ -113,26 +113,26 @@ MeOption *MapleCombCompiler::MakeMeOptions(const MplOptions &options, maple::Mem
         break;
       case kAliasAnalysisLevel:
         meOption->aliasAnalysisLevel = std::stoul(opt.Args(), nullptr);
-        if (meOption->aliasAnalysisLevel > MeOption::LEVEL_THREE) {
-          meOption->aliasAnalysisLevel = MeOption::LEVEL_THREE;
+        if (meOption->aliasAnalysisLevel > MeOption::kLevelThree) {
+          meOption->aliasAnalysisLevel = MeOption::kLevelThree;
         }
         switch (meOption->aliasAnalysisLevel) {
-          case MeOption::LEVEL_THREE:
+          case MeOption::kLevelThree:
             meOption->setCalleeHasSideEffect = false;
             meOption->noSteensgaard = false;
             meOption->noTBAA = false;
             break;
-          case MeOption::LEVEL_ZERO:
+          case MeOption::kLevelZero:
             meOption->setCalleeHasSideEffect = true;
             meOption->noSteensgaard = true;
             meOption->noTBAA = true;
             break;
-          case MeOption::LEVEL_ONE:
+          case MeOption::kLevelOne:
             meOption->setCalleeHasSideEffect = false;
             meOption->noSteensgaard = false;
             meOption->noTBAA = true;
             break;
-          case MeOption::LEVEL_TWO:
+          case MeOption::kLevelTwo:
             meOption->setCalleeHasSideEffect = false;
             meOption->noSteensgaard = true;
             meOption->noTBAA = false;
diff --git a/src/maple_driver/src/mpl_options.cpp b/src/maple_driver/src/mpl_options.cpp
index ab1261a38470f1d2a725c2ab3456f2958a7989d6..6cf30057bb3d07887ca07562897396779b468e1c 100644
--- a/src/maple_driver/src/mpl_options.cpp
+++ b/src/maple_driver/src/mpl_options.cpp
@@ -84,6 +84,18 @@ int MplOptions::Parse(int argc, char **argv) {
         INFO(kLncInfo, kMapleDriverVersion);
         return ErrorCode::kErrorExitHelp;
       }
+      case kMeOpt:
+        ret = UpdatePhaseOption(opt.Args(), kBinNameMe);
+        if (ret != ErrorCode::kErrorNoError) {
+          return ret;
+        }
+        break;
+      case kMpl2MplOpt:
+        ret = UpdatePhaseOption(opt.Args(), kBinNameMpl2mpl);
+        if (ret != ErrorCode::kErrorNoError) {
+          return ret;
+        }
+        break;
       case kMeHelp:
         optionParser->PrintUsage("me");
         return ErrorCode::kErrorExitHelp;
@@ -253,6 +265,30 @@ ErrorCode MplOptions::AppendDefaultOptions(const std::string &exeName, MplOption
   return ErrorCode::kErrorNoError;
 }
 
+ErrorCode MplOptions::UpdatePhaseOption(const std::string &args, const std::string &exeName) {
+  std::vector<std::string> tmpArgs;
+  // Split options with ' '
+  StringUtils::Split(args, tmpArgs, ' ');
+  auto &exeOption = exeOptions[exeName];
+  ErrorCode ret = optionParser->HandleInputArgs(tmpArgs, exeName, exeOption);
+  if (ret != ErrorCode::kErrorNoError) {
+    return ret;
+  }
+  // Fill extraOption
+  // For compiler bins called by system()
+  auto &extraOption = extras[exeName];
+  for (size_t i = 0; i < exeOption.size(); i++) {
+    MplOption mplOption;
+    if (exeOption[i].Args() != "") {
+      mplOption.init("-" + exeOption[i].OptionKey(), exeOption[i].Args(), "=", false, "");
+    } else {
+      mplOption.init("-" + exeOption[i].OptionKey(), "", " ", false, "");
+    }
+    extraOption.push_back(mplOption);
+  }
+  return ret;
+}
+
 ErrorCode MplOptions::UpdateExtraOptionOpt(const std::string &args) {
   std::vector<std::string> temp;
   StringUtils::Split(args, temp, ':');
@@ -264,27 +300,10 @@ ErrorCode MplOptions::UpdateExtraOptionOpt(const std::string &args) {
   }
   auto settingExe = runningExes.begin();
   for (const auto &tempIt : temp) {
-    std::vector<std::string> tmpArgs;
-    // Split options with ' '
-    StringUtils::Split(tempIt, tmpArgs, ' ');
-    auto &exeOption = exeOptions[*settingExe];
-    ErrorCode ret = optionParser->HandleInputArgs(tmpArgs, *settingExe, exeOption);
+    ErrorCode ret = UpdatePhaseOption(tempIt, *settingExe);
     if (ret != ErrorCode::kErrorNoError) {
       return ret;
     }
-    // Fill extraOption
-    // For compiler bins called by system()
-    auto &extraOption = extras[*settingExe];
-    for (size_t i = 0; i < exeOption.size(); i++) {
-      MplOption mplOption;
-      if (exeOption[i].Args() != "") {
-        mplOption.init("-" + exeOption[i].OptionKey(), exeOption[i].Args(), "=", false, "");
-      } else {
-        mplOption.init("-" + exeOption[i].OptionKey(), "", " ", false, "");
-      }
-      extraOption.push_back(mplOption);
-    }
-
     settingExe++;
   }
   return ErrorCode::kErrorNoError;
diff --git a/src/maple_ir/include/bin_mpl_import.h b/src/maple_ir/include/bin_mpl_import.h
index 270be3ec9215cf9d9d7a777185f55c9dc4a35178..22fde151c9411d4daabd60fb71b5114e501b8589 100644
--- a/src/maple_ir/include/bin_mpl_import.h
+++ b/src/maple_ir/include/bin_mpl_import.h
@@ -43,7 +43,7 @@ class BinaryMplImport {
     }
   }
 
-  uint64 GetBufI() {
+  uint64 GetBufI() const {
     return bufI;
   }
 
@@ -51,16 +51,16 @@ class BinaryMplImport {
     bufI = bufIVal;
   }
 
-  bool IsBufEmpty() {
+  bool IsBufEmpty() const {
     return buf.empty();
   }
 
-  size_t GetBufSize() {
+  size_t GetBufSize() const {
     return buf.size();
   }
 
-  int32 GetContent(int64 key) {
-    return content[key];
+  int32 GetContent(int64 key) const {
+    return content.at(key);
   }
 
   void SetImported(bool importedVal) {
@@ -107,7 +107,6 @@ class BinaryMplImport {
   void ImportInterfaceTypeData(MIRInterfaceType &type);
   PUIdx ImportFunction();
   MIRSymbol *InSymbol(MIRFunction *func);
-  void InWord(int64 targetTag, uint8 **typeTagged, uint16 frameSize);
   void ReadFileAt(const std::string &modid, int32 offset);
   uint8 Read();
   int32 ReadInt();
diff --git a/src/maple_ir/include/global_tables.h b/src/maple_ir/include/global_tables.h
index f3713daa5c48eb9c15355670c0752943927c300c..523d7ebae90095686d77e6bf7879f23f3f4d57e1 100644
--- a/src/maple_ir/include/global_tables.h
+++ b/src/maple_ir/include/global_tables.h
@@ -24,13 +24,9 @@
 #include "mir_module.h"
 #include "name_mangler.h"
 #include "mir_type.h"
+#include "mir_const.h"
 
 namespace maple {
-class MIRType;
-class TypeAttrs;
-class FieldAttrs;
-class MIRStructType;
-class MIRArrayType;
 using TyIdxFieldAttrPair = std::pair<TyIdx, FieldAttrs>;
 using FieldPair = std::pair<GStrIdx, TyIdxFieldAttrPair>;
 using FieldVector = std::vector<FieldPair>;
@@ -461,7 +457,6 @@ class FunctionTable {
   std::vector<MIRFunction*> funcTable;  // index is PUIdx
 };
 
-class MIRSymbol;
 class GSymbolTable {
  public:
   GSymbolTable();
@@ -528,7 +523,6 @@ class GSymbolTable {
   std::vector<MIRSymbol*> symbolTable;  // map symbol idx to symbol node
 };
 
-class MIRConst;
 class ConstPool {
  public:
   std::unordered_map<std::u16string, MIRSymbol*> &GetConstU16StringPool() {
diff --git a/src/maple_ir/include/java_eh_lower.h b/src/maple_ir/include/java_eh_lower.h
index cb65627a3da4fc4d14e672033c50dc5caaf86545..8a56eeb450b0d988d80bc0efcbb6e2a29889fb3d 100644
--- a/src/maple_ir/include/java_eh_lower.h
+++ b/src/maple_ir/include/java_eh_lower.h
@@ -35,15 +35,14 @@ class JavaEHLowerer : public FuncOptimizeImpl {
   void ProcessFunc(MIRFunction *func) override;
 
  private:
-  BlockNode *DoLowerBlock(BlockNode*);
-  BaseNode *DoLowerExpr(BaseNode*, BlockNode*);
-  BaseNode *DoLowerDiv(BinaryNode*, BlockNode*);
+  BlockNode *DoLowerBlock(BlockNode&);
+  BaseNode *DoLowerExpr(BaseNode&, BlockNode&);
+  BaseNode *DoLowerDiv(BinaryNode&, BlockNode&);
+  void DoLowerBoundaryCheck(IntrinsiccallNode&, BlockNode&);
   BaseNode *DoLowerRem(BinaryNode *expr, BlockNode *blkNode) {
-    return DoLowerDiv(expr, blkNode);
+    return DoLowerDiv(*expr, *blkNode);
   }
 
-  void DoLowerBoundaryCheck(IntrinsiccallNode&, BlockNode&);
-
   uint32 divSTIndex;  // The index of divide operand and result.
   bool useRegTmp;     // Use register to save temp variable or not.
 };
diff --git a/src/maple_ir/include/lexer.h b/src/maple_ir/include/lexer.h
index d23a57a8e326cd01b6d5844dd1571cbdfb4096a3..6c5d23375c3c8990bc4e4e212ed8e676600f832e 100644
--- a/src/maple_ir/include/lexer.h
+++ b/src/maple_ir/include/lexer.h
@@ -135,8 +135,8 @@ class MIRLexer {
     return curIdx < currentLineSize ? line[curIdx] : 0;
   }
 
-  void SetFile(std::ifstream *file) {
-    airFile = file;
+  void SetFile(std::ifstream &file) {
+    airFile = &file;
   }
 
   std::ifstream *GetFile() const {
diff --git a/src/maple_ir/include/mir_function.h b/src/maple_ir/include/mir_function.h
index c3227c8c5fd5edd747b034f086d6b56a1a954d8b..5570831c8c428e91febdaea390c8cbf15a00b259 100644
--- a/src/maple_ir/include/mir_function.h
+++ b/src/maple_ir/include/mir_function.h
@@ -26,8 +26,6 @@
 
 
 namespace maple {
-class BlockNode;
-class SrcPosition;
 enum MIRFuncProp {
   kFuncPropNone,
   kFuncPropHasCall,      // the function has call
@@ -101,7 +99,7 @@ class MIRFunction {
     eacg = nullptr;
   }
 
-  ~MIRFunction() {}
+  ~MIRFunction() = default;
 
   void Init() {
     // Initially allocate symTab and pregTab on the module mempool for storing
@@ -498,8 +496,8 @@ class MIRFunction {
     return flag & FUNCNEVERRETURN;
   }
 
-  void SetReturnStruct(MIRType *retType) {
-    switch (retType->GetKind()) {
+  void SetReturnStruct(MIRType &retType) {
+    switch (retType.GetKind()) {
       case kTypeUnion:
       case kTypeStruct:
       case kTypeStructIncomplete:
@@ -539,7 +537,7 @@ class MIRFunction {
     return classTyIdx.GetIdx();
   }
 
-  MIRType *GetNodeType(BaseNode *node);
+  MIRType *GetNodeType(BaseNode &node);
   void SetUpGDBEnv();
   void ResetGDBEnv();
   MemPool *GetCodeMempool() {
diff --git a/src/maple_ir/include/mir_nodes.h b/src/maple_ir/include/mir_nodes.h
index 27cbb40d70ae7b7847e150456f8d31fd21e64dab..456af1a8b9271600889fb53e45098d5a554a431d 100644
--- a/src/maple_ir/include/mir_nodes.h
+++ b/src/maple_ir/include/mir_nodes.h
@@ -1129,13 +1129,13 @@ class ArrayNode : public NaryNode {
     return nd;
   }
 
-  MIRType *GetArrayType(TypeTable *tt) const;
+  MIRType *GetArrayType(TypeTable &tt) const;
 
   BaseNode *GetIndex(size_t i) {
     return Opnd(i + 1);
   }
 
-  BaseNode *GetDim(const MIRModule *mod, TypeTable *tt, int i);
+  BaseNode *GetDim(const MIRModule &mod, TypeTable &tt, int i);
   BaseNode *GetBase() {
     return Opnd(0);
   }
@@ -1173,7 +1173,7 @@ class AddrofNode : public BaseNode {
 
   virtual void Dump(const MIRModule &mod, int32 indent) const;
   bool Verify() const;
-  bool CheckNode(const MIRModule *mod) const;
+  bool CheckNode(const MIRModule &mod) const;
 
   AddrofNode *CloneTree(MapleAllocator &allocator) const {
     return allocator.GetMemPool()->New<AddrofNode>(*this);
@@ -1395,8 +1395,8 @@ class StmtNode : public BaseNode, public PtrListNodeBase<StmtNode> {
   void DumpBase(const MIRModule &mod, int32 indent) const;
   void Dump(const MIRModule &mod, int32 indent) const;
   void Dump(const MIRModule &mod) const;
-  void InsertAfterThis(StmtNode *pos);
-  void InsertBeforeThis(StmtNode *pos);
+  void InsertAfterThis(StmtNode &pos);
+  void InsertBeforeThis(StmtNode &pos);
 
   virtual StmtNode *CloneTree(MapleAllocator &allocator) const {
     StmtNode *s = allocator.GetMemPool()->New<StmtNode>(*this);
@@ -2141,16 +2141,16 @@ class BlockNode : public StmtNode {
   }
 
   void AddStatement(StmtNode *stmt);
-  void AppendStatementsFromBlock(BlockNode *blk);
+  void AppendStatementsFromBlock(BlockNode &blk);
   void InsertFirst(StmtNode *stmt);  // Insert stmt as the first
   void InsertLast(StmtNode *stmt);   // Insert stmt as the last
-  void ReplaceStmtWithBlock(StmtNode *stmtNode, BlockNode *blk);
+  void ReplaceStmtWithBlock(StmtNode *stmtNode, BlockNode &blk);
   void ReplaceStmt1WithStmt2(StmtNode *stmtNode1, StmtNode *stmtNode2);
   void RemoveStmt(StmtNode *stmtNode2);
   void InsertBefore(StmtNode *stmtNode1, StmtNode *stmtNode2);  // Insert ss2 before ss1 in current block.
   void InsertAfter(StmtNode *stmtNode1, StmtNode *stmtNode2);   // Insert ss2 after ss1 in current block.
-  void InsertBlockAfter(BlockNode *inblock,
-                        StmtNode *stmt1);  // insert all the stmts in inblock to the current block after stmt1
+  // insert all the stmts in inblock to the current block after stmt1
+  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;
@@ -2172,8 +2172,8 @@ class BlockNode : public StmtNode {
     return blk;
   }
 
-  BlockNode *CloneTreeWithSrcPosition(const MIRModule *mod) {
-    MapleAllocator &allocator = mod->GetCurFuncCodeMPAllocator();
+  BlockNode *CloneTreeWithSrcPosition(const MIRModule &mod) {
+    MapleAllocator &allocator = mod.GetCurFuncCodeMPAllocator();
     BlockNode *blk = allocator.GetMemPool()->New<BlockNode>();
     blk->SetStmtID(stmtIDNext++);
     for (auto &stmt : stmtNodeList) {
diff --git a/src/maple_ir/include/mir_parser.h b/src/maple_ir/include/mir_parser.h
index 2f04a3629a3de8978a2dc06d43e2a2e671c8350d..8b0232a9128f7c8a444c2c9957fa265e89f771eb 100644
--- a/src/maple_ir/include/mir_parser.h
+++ b/src/maple_ir/include/mir_parser.h
@@ -41,6 +41,7 @@ class MIRParser {
         paramParseLocalType(false),
         paramIsIPA(false),
         paramIsComb(false),
+        paramTokenKind(kTkInvalid),
         paramOpForStmt(kOpUndef),
         paramTokenKindForStmt(kTkInvalid),
         paramCurrFuncForParseStmtBlock(nullptr) {}
diff --git a/src/maple_ir/include/mir_pragma.h b/src/maple_ir/include/mir_pragma.h
index 97e587f460d1072c127e96496eba92a8dab4d9bf..f46df422d90fc9d471b42ed26c032314e3c9537f 100644
--- a/src/maple_ir/include/mir_pragma.h
+++ b/src/maple_ir/include/mir_pragma.h
@@ -70,8 +70,8 @@ enum PragmaValueType {
 
 class MIRPragmaElement {
  public:
-  explicit MIRPragmaElement(MIRModule *m)
-      : nameStrIdx(0), typeStrIdx(0), valueType(kValueNull), subElemVec(m->GetMPAllocator().Adapter()) {
+  explicit MIRPragmaElement(MIRModule &m)
+      : nameStrIdx(0), typeStrIdx(0), valueType(kValueNull), subElemVec(m.GetMPAllocator().Adapter()) {
     val.u = 0;
     subElemVec.clear();
   }
@@ -175,15 +175,15 @@ class MIRPragmaElement {
 
 class MIRPragma {
  public:
-  explicit MIRPragma(MIRModule *m)
-      : mod(m),
+  explicit MIRPragma(MIRModule &m)
+      : mod(&m),
         pragmaKind(kPragmaUnknown),
         visibility(0),
         strIdx(0),
         tyIdx(0),
         tyIdxEx(0),
         paramNum(-1),
-        elementVec(m->GetMPAllocator().Adapter()) {}
+        elementVec(m.GetMPAllocator().Adapter()) {}
 
   ~MIRPragma() = default;
   MIRPragmaElement *GetPragmaElemFromSignature(const std::string &signature);
diff --git a/src/maple_ir/include/mir_preg.h b/src/maple_ir/include/mir_preg.h
index 023db68511e48af6dc416271c74cd17a9d956192..8b9ef231fbd9154102d104c360f1b77874f88825 100755
--- a/src/maple_ir/include/mir_preg.h
+++ b/src/maple_ir/include/mir_preg.h
@@ -124,19 +124,19 @@ class MIRPregTable {
     return idx;
   }
 
-  PregIdx CreateRefPreg(MIRType *mirType) {
-    ASSERT(mirType->GetPrimType() == PTY_ref, "only ref type needed");
-    PregIdx idx = CreatePreg(mirType->GetPrimType());
-    pregTable[idx]->SetMIRType(mirType);
+  PregIdx CreateRefPreg(MIRType &mirType) {
+    ASSERT(mirType.GetPrimType() == PTY_ref, "only ref type needed");
+    PregIdx idx = CreatePreg(mirType.GetPrimType());
+    pregTable[idx]->SetMIRType(&mirType);
     return idx;
   }
 
-  PregIdx CreateRefPreg(MIRPreg *mirPreg) {
+  PregIdx CreateRefPreg(MIRPreg &mirPreg) {
     uint32 index = pregIndex++;
-    MIRPreg *preg = mAllocator->GetMemPool()->New<MIRPreg>(index, mirPreg->GetMIRType());
-    preg->SetPrimType(mirPreg->GetPrimType());
-    preg->SetMIRType(mirPreg->GetMIRType());
-    preg->SetNeedRC(mirPreg->NeedRC());
+    MIRPreg *preg = mAllocator->GetMemPool()->New<MIRPreg>(index, mirPreg.GetMIRType());
+    preg->SetPrimType(mirPreg.GetPrimType());
+    preg->SetMIRType(mirPreg.GetMIRType());
+    preg->SetNeedRC(mirPreg.NeedRC());
     PregIdx idx = pregTable.size();
     ASSERT(idx < 0xffff, "will has problem if over 16 bits");
     pregTable.push_back(preg);
diff --git a/src/maple_ir/include/mir_symbol.h b/src/maple_ir/include/mir_symbol.h
index 34a5cc97b156d7bb3902cfe272252f96d0c4022b..2900cbd469ab011dd6a69b9f8ad1ac4daf0f79df 100644
--- a/src/maple_ir/include/mir_symbol.h
+++ b/src/maple_ir/include/mir_symbol.h
@@ -398,7 +398,6 @@ class MIRSymbol {
   static GStrIdx reflectClassNameIdx;
   static GStrIdx reflectMethodNameIdx;
   static GStrIdx reflectFieldNameIdx;
-
 };
 
 class MIRSymbolTable {
@@ -408,7 +407,7 @@ class MIRSymbolTable {
     symbolTable.push_back(static_cast<MIRSymbol*>(nullptr));
   }
 
-  ~MIRSymbolTable() {}
+  ~MIRSymbolTable() = default;
 
   bool IsValidIdx(uint32 idx) const {
     return idx < symbolTable.size();
@@ -432,15 +431,15 @@ class MIRSymbolTable {
   bool AddStOutside(MIRSymbol *sym) {
     sym->SetStIdx(StIdx(sym->GetScopeIdx(), symbolTable.size()));
     symbolTable.push_back(sym);
-    return AddToStringSymbolMap(sym);
+    return AddToStringSymbolMap(*sym);
   }
 
-  bool AddToStringSymbolMap(const MIRSymbol *st) {
-    GStrIdx strIdx = st->GetNameStrIdx();
+  bool AddToStringSymbolMap(const MIRSymbol &st) {
+    GStrIdx strIdx = st.GetNameStrIdx();
     if (strIdxToStIdxMap[strIdx].FullIdx() != 0) {
       return false;
     }
-    strIdxToStIdxMap[strIdx] = st->GetStIdx();
+    strIdxToStIdxMap[strIdx] = st.GetStIdx();
     return true;
   }
 
diff --git a/src/maple_ir/include/mir_type.h b/src/maple_ir/include/mir_type.h
index 50b6f9f3325d4df8d0be2bbc9ab07d1d756160ab..4c12c4e483e81933645d710ad3427ccf695368b3 100644
--- a/src/maple_ir/include/mir_type.h
+++ b/src/maple_ir/include/mir_type.h
@@ -516,7 +516,7 @@ class MIRType {
             (typeKind == kTypeInterfaceIncomplete));
   }
 
-  virtual bool ValidateClassOrInterface(const char *className, bool noWarning);
+  virtual bool ValidateClassOrInterface(const std::string &className, bool noWarning);
   const std::string &GetName(void) const;
   virtual std::string GetMplTypeName() const;
   virtual std::string GetCompactMplTypeName() const;
diff --git a/src/maple_ir/src/bin_mpl_import.cpp b/src/maple_ir/src/bin_mpl_import.cpp
index 85eff3cd4e67cd94a97bb108aa27e38ee0adbcfc..5c5329444f33c6c5d4b622f57276083816d89b1c 100644
--- a/src/maple_ir/src/bin_mpl_import.cpp
+++ b/src/maple_ir/src/bin_mpl_import.cpp
@@ -217,7 +217,7 @@ UStrIdx BinaryMplImport::ImportUsrStr() {
 }
 
 MIRPragmaElement *BinaryMplImport::ImportPragmaElement() {
-  MIRPragmaElement *element = mod.GetMemPool()->New<MIRPragmaElement>(&mod);
+  MIRPragmaElement *element = mod.GetMemPool()->New<MIRPragmaElement>(mod);
   element->SetNameStrIdx(ImportStr());
   element->SetTypeStrIdx(ImportStr());
   element->SetType((PragmaValueType)ReadNum());
@@ -235,7 +235,7 @@ MIRPragmaElement *BinaryMplImport::ImportPragmaElement() {
 }
 
 MIRPragma *BinaryMplImport::ImportPragma() {
-  MIRPragma *p = mod.GetMemPool()->New<MIRPragma>(&mod);
+  MIRPragma *p = mod.GetMemPool()->New<MIRPragma>(mod);
   p->SetKind(static_cast<PragmaKind>(ReadNum()));
   p->SetVisibility(ReadNum());
   p->SetStrIdx(ImportStr());
@@ -312,7 +312,7 @@ void BinaryMplImport::UpdateMethodSymbols() {
     ASSERT(fn != nullptr, "fn is null");
     MIRFuncType *funcType = static_cast<MIRFuncType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(sym->GetTyIdx()));
     fn->SetMIRFuncType(funcType);
-    fn->SetReturnStruct(GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetRetTyIdx()));
+    fn->SetReturnStruct(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetRetTyIdx()));
   }
 }
 
@@ -693,7 +693,8 @@ MIRType &BinaryMplImport::InsertInTypeTables(MIRType &type) {
       GlobalTables::GetTypeTable().SetTypeWithTyIdx(prevTyIdx, type.CopyMIRTypeNode());
       resultTypePtr = GlobalTables::GetTypeTable().GetTypeFromTyIdx(prevTyIdx);
       if (!IsIncomplete(*resultTypePtr)) {
-        GlobalTables::GetTypeNameTable().SetGStrIdxToTyIdx(resultTypePtr->GetNameStrIdx(), resultTypePtr->GetTypeIndex());
+        GlobalTables::GetTypeNameTable().SetGStrIdxToTyIdx(resultTypePtr->GetNameStrIdx(),
+                                                           resultTypePtr->GetTypeIndex());
       }
     }
   } else {
diff --git a/src/maple_ir/src/mir_builder.cpp b/src/maple_ir/src/mir_builder.cpp
index 8b890935533635ead647a0b6a1ebe9fc2731ff2a..cde82168232646965239e71df1f9347483f2c3e6 100644
--- a/src/maple_ir/src/mir_builder.cpp
+++ b/src/maple_ir/src/mir_builder.cpp
@@ -323,7 +323,7 @@ MIRSymbol *MIRBuilder::GetOrCreateLocalDecl(const std::string &str, const TyIdx
   MIRSymbol *st = symbolTable.CreateSymbol(kScopeLocal);
   st->SetNameStrIdx(strIdx);
   st->SetTyIdx(tyIdx);
-  (void)symbolTable.AddToStringSymbolMap(st);
+  (void)symbolTable.AddToStringSymbolMap(*st);
   return st;
 }
 
@@ -352,7 +352,7 @@ MIRSymbol *MIRBuilder::CreateLocalDecl(const std::string &str, const MIRType &ty
   MIRSymbol *st = symbolTable->CreateSymbol(kScopeLocal);
   st->SetNameStrIdx(stridx);
   st->SetTyIdx(type.GetTypeIndex());
-  (void)symbolTable->AddToStringSymbolMap(st);
+  (void)symbolTable->AddToStringSymbolMap(*st);
   st->SetStorageClass(kScAuto);
   st->SetSKind(kStVar);
   return st;
@@ -596,7 +596,7 @@ MIRSymbol *MIRBuilder::CreateSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind mCla
   st->SetNameStrIdx(strIdx);
   st->SetTyIdx(tyIdx);
   if (func) {
-    (void)func->GetSymTab()->AddToStringSymbolMap(st);
+    (void)func->GetSymTab()->AddToStringSymbolMap(*st);
   } else {
     (void)GlobalTables::GetGsymTable().AddToStringSymbolMap(*st);
   }
@@ -638,7 +638,7 @@ MIRFunction *MIRBuilder::CreateFunction(const std::string &name, const MIRType &
     argSymbol->SetTyIdx(ty->GetTypeIndex());
     argSymbol->SetStorageClass(kScFormal);
     argSymbol->SetSKind(kStVar);
-    (void)fn->GetSymTab()->AddToStringSymbolMap(argSymbol);
+    (void)fn->GetSymTab()->AddToStringSymbolMap(*argSymbol);
     fn->AddFormal(argSymbol);
     funcVecType.push_back(ty->GetTypeIndex());
     funcVecAttrs.push_back(TypeAttrs());
diff --git a/src/maple_ir/src/mir_function.cpp b/src/maple_ir/src/mir_function.cpp
index e642b58b2e15223e883dba272fbbd63663258318..024c5fdcab3dbd88403ecbf72c111086a1301249 100644
--- a/src/maple_ir/src/mir_function.cpp
+++ b/src/maple_ir/src/mir_function.cpp
@@ -37,10 +37,7 @@ void MIRFunction::Dump(bool withoutBody) {
   // class and interface decls.  these has nothing in formals
   // they do have paramtypelist_. this can not skip ones without args
   // but for them at least the func decls are valid
-  if (GetParamSize() != formals.size()) {
-    return;
-  }
-  if (GetAttr(FUNCATTR_optimized)) {
+  if (GetParamSize() != formals.size() || GetAttr(FUNCATTR_optimized)) {
     return;
   }
   // save the module's curfunction and set it to the one currently Dump()ing
@@ -48,8 +45,7 @@ void MIRFunction::Dump(bool withoutBody) {
   module->SetCurFunction(this);
   MIRSymbol *fnSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(symbolTableIdx.Idx());
   ASSERT(fnSt != nullptr, "fnSt MIRSymbol is null");
-  LogInfo::MapleLogger() << "func "
-                         << "&" << fnSt->GetName();
+  LogInfo::MapleLogger() << "func " << "&" << fnSt->GetName();
   funcAttrs.DumpAttributes();
   if (module->GetFlavor() < kMmpl) {
     LogInfo::MapleLogger() << " (";
@@ -286,14 +282,13 @@ MIRSymbol *MIRFunction::GetLocalOrGlobalSymbol(const StIdx &idx, bool checkFirst
                        : GlobalTables::GetGsymTable().GetSymbolFromStidx(idx.Idx(), checkFirst);
 }
 
-MIRType *MIRFunction::GetNodeType(BaseNode *node) {
-  ASSERT(node != nullptr, "node cannot be nullptr");
-  if (node->GetOpCode() == OP_dread) {
-    MIRSymbol *sym = GetLocalOrGlobalSymbol(static_cast<DreadNode*>(node)->GetStIdx());
+MIRType *MIRFunction::GetNodeType(BaseNode &node) {
+  if (node.GetOpCode() == OP_dread) {
+    MIRSymbol *sym = GetLocalOrGlobalSymbol(static_cast<DreadNode&>(node).GetStIdx());
     return GlobalTables::GetTypeTable().GetTypeFromTyIdx(sym->GetTyIdx());
-  } else if (node->GetOpCode() == OP_regread) {
-    RegreadNode *nodeReg = static_cast<RegreadNode*>(node);
-    MIRPreg *pReg = GetPregTab()->PregFromPregIdx(nodeReg->GetRegIdx());
+  } else if (node.GetOpCode() == OP_regread) {
+    RegreadNode &nodeReg = static_cast<RegreadNode&>(node);
+    MIRPreg *pReg = GetPregTab()->PregFromPregIdx(nodeReg.GetRegIdx());
     if (pReg->GetPrimType() == PTY_ref) {
       return pReg->GetMIRType();
     }
diff --git a/src/maple_ir/src/mir_lower.cpp b/src/maple_ir/src/mir_lower.cpp
index ae16c8f0fcedc1e2ed164f0b1fdb877a7444f409..34fd6d6a5d571d2a1efbe71b0440f2a094a9585d 100644
--- a/src/maple_ir/src/mir_lower.cpp
+++ b/src/maple_ir/src/mir_lower.cpp
@@ -47,7 +47,7 @@ BlockNode *MIRLower::LowerIfStmt(IfStmtNode &ifStmt, bool recursive) {
     (void)mirModule.CurFunction()->GetLabelTab()->AddToStringLabelMap(lableIdx);
     brFalseStmt->SetOffset(lableIdx);
     blk->AddStatement(brFalseStmt);
-    blk->AppendStatementsFromBlock(ifStmt.GetThenPart());
+    blk->AppendStatementsFromBlock(*ifStmt.GetThenPart());
     LabelNode *lableStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
     lableStmt->SetLabelIdx(lableIdx);
     blk->AddStatement(lableStmt);
@@ -62,7 +62,7 @@ BlockNode *MIRLower::LowerIfStmt(IfStmtNode &ifStmt, bool recursive) {
     mirModule.CurFunction()->GetLabelTab()->AddToStringLabelMap(lableIdx);
     brTrueStmt->SetOffset(lableIdx);
     blk->AddStatement(brTrueStmt);
-    blk->AppendStatementsFromBlock(ifStmt.GetElsePart());
+    blk->AppendStatementsFromBlock(*ifStmt.GetElsePart());
     LabelNode *lableStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
     lableStmt->SetLabelIdx(lableIdx);
     blk->AddStatement(lableStmt);
@@ -80,7 +80,7 @@ BlockNode *MIRLower::LowerIfStmt(IfStmtNode &ifStmt, bool recursive) {
     (void)mirModule.CurFunction()->GetLabelTab()->AddToStringLabelMap(lIdx);
     brFalseStmt->SetOffset(lIdx);
     blk->AddStatement(brFalseStmt);
-    blk->AppendStatementsFromBlock(ifStmt.GetThenPart());
+    blk->AppendStatementsFromBlock(*ifStmt.GetThenPart());
     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");
@@ -96,7 +96,7 @@ BlockNode *MIRLower::LowerIfStmt(IfStmtNode &ifStmt, bool recursive) {
     LabelNode *lableStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
     lableStmt->SetLabelIdx(lIdx);
     blk->AddStatement(lableStmt);
-    blk->AppendStatementsFromBlock(ifStmt.GetElsePart());
+    blk->AppendStatementsFromBlock(*ifStmt.GetElsePart());
     if (fallThroughFromThen) {
       lableStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
       lableStmt->SetLabelIdx(gotoLableIdx);
@@ -129,7 +129,7 @@ BlockNode *MIRLower::LowerWhileStmt(WhileStmtNode &whileStmt) {
   LabelNode *lableStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
   lableStmt->SetLabelIdx(bodyLableIdx);
   blk->AddStatement(lableStmt);
-  blk->AppendStatementsFromBlock(whileStmt.GetBody());
+  blk->AppendStatementsFromBlock(*whileStmt.GetBody());
   CondGotoNode *brTrueStmt = mirModule.CurFuncCodeMemPool()->New<CondGotoNode>(OP_brtrue);
   brTrueStmt->SetOpnd(whileStmt.Opnd()->CloneTree(mirModule.GetCurFuncCodeMPAllocator()));
   brTrueStmt->SetOffset(bodyLableIdx);
@@ -182,7 +182,7 @@ BlockNode *MIRLower::LowerDoloopStmt(DoloopNode &doloop) {
   LabelNode *labelStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
   labelStmt->SetLabelIdx(bodyLabelIdx);
   blk->AddStatement(labelStmt);
-  blk->AppendStatementsFromBlock(doloop.GetDoBody());
+  blk->AppendStatementsFromBlock(*doloop.GetDoBody());
   if (doloop.IsPreg()) {
     PregIdx regIdx = (PregIdx)doloop.GetDoVarStIdx().FullIdx();
     MIRPreg *mirPreg = mirModule.CurFunction()->GetPregTab()->PregFromPregIdx(regIdx);
@@ -234,7 +234,7 @@ BlockNode *MIRLower::LowerDowhileStmt(WhileStmtNode &doWhileStmt) {
   LabelNode *labelStmt = mirModule.CurFuncCodeMemPool()->New<LabelNode>();
   labelStmt->SetLabelIdx(lIdx);
   blk->AddStatement(labelStmt);
-  blk->AppendStatementsFromBlock(doWhileStmt.GetBody());
+  blk->AppendStatementsFromBlock(*doWhileStmt.GetBody());
   CondGotoNode *brTrueStmt = mirModule.CurFuncCodeMemPool()->New<CondGotoNode>(OP_brtrue);
   brTrueStmt->SetOpnd(doWhileStmt.Opnd());
   brTrueStmt->SetOffset(lIdx);
@@ -257,21 +257,21 @@ BlockNode *MIRLower::LowerBlock(BlockNode &block) {
       case OP_if:
         tmp = LowerIfStmt(static_cast<IfStmtNode&>(*stmt), true);
         ASSERT(tmp != nullptr, "null ptr check");
-        newBlock->AppendStatementsFromBlock(tmp);
+        newBlock->AppendStatementsFromBlock(*tmp);
         break;
       case OP_while:
-        newBlock->AppendStatementsFromBlock(LowerWhileStmt(static_cast<WhileStmtNode&>(*stmt)));
+        newBlock->AppendStatementsFromBlock(*LowerWhileStmt(static_cast<WhileStmtNode&>(*stmt)));
         break;
       case OP_dowhile:
-        newBlock->AppendStatementsFromBlock(LowerDowhileStmt(static_cast<WhileStmtNode&>(*stmt)));
+        newBlock->AppendStatementsFromBlock(*LowerDowhileStmt(static_cast<WhileStmtNode&>(*stmt)));
         break;
       case OP_doloop:
-        newBlock->AppendStatementsFromBlock(LowerDoloopStmt(static_cast<DoloopNode&>(*stmt)));
+        newBlock->AppendStatementsFromBlock(*LowerDoloopStmt(static_cast<DoloopNode&>(*stmt)));
         break;
       case OP_block:
         tmp = LowerBlock(static_cast<BlockNode&>(*stmt));
         ASSERT(tmp != nullptr, "null ptr check ");
-        newBlock->AppendStatementsFromBlock(tmp);
+        newBlock->AppendStatementsFromBlock(*tmp);
         break;
       default:
         newBlock->AddStatement(stmt);
diff --git a/src/maple_ir/src/mir_nodes.cpp b/src/maple_ir/src/mir_nodes.cpp
index 1cb5d966683a529a635879ddeafabd3b33bc2247..2778fd5cb23c837fbbc34cd85ac30c71de96f656 100644
--- a/src/maple_ir/src/mir_nodes.cpp
+++ b/src/maple_ir/src/mir_nodes.cpp
@@ -63,9 +63,8 @@ bool BaseNode::MayThrowException() {
   return false;
 }
 
-bool AddrofNode::CheckNode(const MIRModule *mod) const {
-  ASSERT(mod != nullptr, "mod is null");
-  MIRSymbol *st = mod->CurFunction()->GetLocalOrGlobalSymbol(GetStIdx());
+bool AddrofNode::CheckNode(const MIRModule &mod) const {
+  MIRSymbol *st = mod.CurFunction()->GetLocalOrGlobalSymbol(GetStIdx());
   MIRType *ty = st->GetType();
   switch (ty->GetKind()) {
     case kTypeScalar: {
@@ -141,9 +140,8 @@ void BlockNode::AddStatement(StmtNode *stmt) {
   stmtNodeList.push_back(stmt);
 }
 
-void BlockNode::AppendStatementsFromBlock(BlockNode *blk) {
-  ASSERT(blk != nullptr, "null ptr check");
-  stmtNodeList.splice(stmtNodeList.end(), blk->GetStmtNodes());
+void BlockNode::AppendStatementsFromBlock(BlockNode &blk) {
+  stmtNodeList.splice(stmtNodeList.end(), blk.GetStmtNodes());
 }
 
 /// Insert stmt as the first
@@ -158,10 +156,10 @@ void BlockNode::InsertLast(StmtNode *stmt) {
   stmtNodeList.push_back(stmt);
 }
 
-void BlockNode::ReplaceStmtWithBlock(StmtNode *stmtNode, BlockNode *blk) {
-  stmtNodeList.splice(stmtNode, blk->GetStmtNodes());
+void BlockNode::ReplaceStmtWithBlock(StmtNode *stmtNode, BlockNode &blk) {
+  stmtNodeList.splice(stmtNode, blk.GetStmtNodes());
   stmtNodeList.erase(stmtNode);
-  stmtNode->SetNext(blk->GetLast()->GetNext());
+  stmtNode->SetNext(blk.GetLast()->GetNext());
 }
 
 void BlockNode::ReplaceStmt1WithStmt2(StmtNode *stmtNode1, StmtNode *stmtNode2) {
@@ -194,10 +192,10 @@ void BlockNode::InsertAfter(StmtNode *stmtNode1, StmtNode *stmtNode2) {
 }
 
 // insert all the stmts in inblock to the current block after stmt1
-void BlockNode::InsertBlockAfter(BlockNode *inblock, StmtNode *stmt1) {
+void BlockNode::InsertBlockAfter(BlockNode &inblock, StmtNode *stmt1) {
   ASSERT(stmt1 != nullptr, "null ptr check");
-  ASSERT(!inblock->IsEmpty(), "NYI");
-  stmtNodeList.splice(stmt1, inblock->GetStmtNodes());
+  ASSERT(!inblock.IsEmpty(), "NYI");
+  stmtNodeList.splice(stmt1, inblock.GetStmtNodes());
 }
 
 void BaseNode::DumpBase(const MIRModule &mod, int32 indent) const {
@@ -415,16 +413,16 @@ void NaryNode::Dump(const MIRModule &mod, int32 indent) const {
   NaryOpnds::Dump(mod, indent);
 }
 
-MIRType *ArrayNode::GetArrayType(TypeTable *tt) const {
-  MIRPtrType *pointType = MIR_DYN_CAST(tt->GetTypeFromTyIdx(tyIdx), MIRPtrType*);
+MIRType *ArrayNode::GetArrayType(TypeTable &tt) const {
+  MIRPtrType *pointType = MIR_DYN_CAST(tt.GetTypeFromTyIdx(tyIdx), MIRPtrType*);
   ASSERT(pointType != nullptr, "expect array type pointer");
-  return tt->GetTypeFromTyIdx(pointType->GetPointedTyIdx());
+  return tt.GetTypeFromTyIdx(pointType->GetPointedTyIdx());
 }
 
-BaseNode *ArrayNode::GetDim(const MIRModule *mod, TypeTable *tt, int i) {
+BaseNode *ArrayNode::GetDim(const MIRModule &mod, TypeTable &tt, int i) {
   MIRArrayType *arrayType = static_cast<MIRArrayType*>(GetArrayType(tt));
-  MIRConst *mirConst = mod->CurFuncCodeMemPool()->New<MIRConst>(tt->GetTypeFromTyIdx(arrayType->GetElemTyIdx()));
-  return mod->CurFuncCodeMemPool()->New<ConstvalNode>(mirConst);
+  MIRConst *mirConst = mod.CurFuncCodeMemPool()->New<MIRConst>(tt.GetTypeFromTyIdx(arrayType->GetElemTyIdx()));
+  return mod.CurFuncCodeMemPool()->New<ConstvalNode>(mirConst);
 }
 
 void ArrayNode::Dump(const MIRModule &mod, int32 indent) const {
@@ -576,25 +574,23 @@ StmtNode *StmtNode::GetRealNext() {
 }
 
 // insert this before pos
-void StmtNode::InsertAfterThis(StmtNode *pos) {
-  ASSERT(pos != nullptr, "null ptr check");
-  this->SetNext(pos);
-  if (pos->GetPrev()) {
-    this->SetPrev(pos->GetPrev());
-    pos->GetPrev()->SetNext(this);
+void StmtNode::InsertAfterThis(StmtNode &pos) {
+  this->SetNext(&pos);
+  if (pos.GetPrev()) {
+    this->SetPrev(pos.GetPrev());
+    pos.GetPrev()->SetNext(this);
   }
-  pos->SetPrev(this);
+  pos.SetPrev(this);
 }
 
 // insert stmtnode after pos
-void StmtNode::InsertBeforeThis(StmtNode *pos) {
-  ASSERT(pos != nullptr, "null ptr check");
-  this->SetPrev(pos);
-  if (pos->GetNext()) {
-    this->SetNext(pos->GetNext());
-    pos->GetNext()->SetPrev(this);
+void StmtNode::InsertBeforeThis(StmtNode &pos) {
+  this->SetPrev(&pos);
+  if (pos.GetNext()) {
+    this->SetNext(pos.GetNext());
+    pos.GetNext()->SetPrev(this);
   }
-  pos->SetNext(this);
+  pos.SetNext(this);
 }
 
 void DassignNode::Dump(const MIRModule &mod, int32 indent) const {
@@ -1033,7 +1029,7 @@ void BlockNode::Dump(const MIRModule &mod, int32 indent, const MIRSymbolTable *t
   // output puid for debugging purpose
   if (isFuncbody) {
     mod.CurFunction()->DumpFuncBody(indent);
-    if (theSymTab != nullptr) {
+    if (theSymTab != nullptr && thePregTab != nullptr) {
       // print the locally declared type names
       for (auto it : mod.CurFunction()->GetGStrIdxToTyIdxMap()) {
         const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(it.first);
@@ -1094,8 +1090,8 @@ void CommentNode::Dump(const MIRModule &mod, int32 indent) const {
 }
 
 // mirnode verification support
-bool ExcludeSmallIntTypeVerify(const BaseNode *opnd) {
-  switch (opnd->GetPrimType()) {
+bool ExcludeSmallIntTypeVerify(const BaseNode &opnd) {
+  switch (opnd.GetPrimType()) {
     case PTY_u1:
     case PTY_i8:
     case PTY_u8:
@@ -1108,22 +1104,21 @@ bool ExcludeSmallIntTypeVerify(const BaseNode *opnd) {
   return true;
 }
 
-bool ArithTypeVerify(const BaseNode *opnd) {
-  ASSERT(opnd != nullptr, "null ptr check");
+bool ArithTypeVerify(const BaseNode &opnd) {
   bool verifyResult = ExcludeSmallIntTypeVerify(opnd);
   if (!verifyResult) {
     LogInfo::MapleLogger() << "\n#Error:u1,i8,u8,i16,u16 should not be used as types of arithmetic operations\n";
-    opnd->Dump(*theModule);
+    opnd.Dump(*theModule);
   }
   return verifyResult;
 }
 
-inline bool ReadTypeVerify(const BaseNode *opnd) {
+inline bool ReadTypeVerify(const BaseNode &opnd) {
   bool verifyResult = ExcludeSmallIntTypeVerify(opnd);
   if (!verifyResult) {
     LogInfo::MapleLogger()
         << "\n#Error:u1,i8,u8,i16,u16 should not be used as result types for dread/iread/regread/ireadoff/ireadfpoff\n";
-    opnd->Dump(*theModule);
+    opnd.Dump(*theModule);
   }
   return verifyResult;
 }
@@ -1179,10 +1174,8 @@ inline bool BinaryTypeVerify(PrimType ptyp) {
   return ArithResTypeVerify(ptyp) || IsPrimitiveDynType(ptyp);
 }
 
-inline bool BinaryGenericVerify(const BaseNode *bOpnd0, const BaseNode *bOpnd1) {
-  ASSERT(bOpnd0 != nullptr, "null ptr check");
-  ASSERT(bOpnd1 != nullptr, "null ptr check");
-  return bOpnd0->Verify() && bOpnd1->Verify() && ArithTypeVerify(bOpnd0) && ArithTypeVerify(bOpnd1);
+inline bool BinaryGenericVerify(const BaseNode &bOpnd0, const BaseNode &bOpnd1) {
+  return bOpnd0.Verify() && bOpnd1.Verify() && ArithTypeVerify(bOpnd0) && ArithTypeVerify(bOpnd1);
 }
 
 inline bool CompareTypeVerify(PrimType pType) {
@@ -1205,8 +1198,8 @@ enum PTYGroup {
   kPTYGOthers
 };
 
-uint8 GetCompGroupID(const BaseNode *opnd) {
-  switch (opnd->GetPrimType()) {
+uint8 GetCompGroupID(const BaseNode &opnd) {
+  switch (opnd.GetPrimType()) {
     case PTY_i32:
     case PTY_u32:
     case PTY_a32:
@@ -1244,18 +1237,18 @@ uint8 GetCompGroupID(const BaseNode *opnd) {
   Refer to C11 Language Specification.
   $ 6.3.1.8 Usual arithmetic conversions
  */
-bool CompatibleTypeVerify(const BaseNode *opnd1, const BaseNode *opnd2) {
+bool CompatibleTypeVerify(const BaseNode &opnd1, const BaseNode &opnd2) {
   uint8 groupID1 = GetCompGroupID(opnd1);
   uint8 groupID2 = GetCompGroupID(opnd2);
-  Opcode opCode2 = opnd2->GetOpCode();
+  Opcode opCode2 = opnd2.GetOpCode();
   bool verifyResult = groupID1 == groupID2;
   if (opCode2 == OP_gcmallocjarray || opCode2 == OP_gcpermallocjarray) {
     verifyResult = groupID1 == kPTYGi32u32a32;
   }
   if (!verifyResult) {
     LogInfo::MapleLogger() << "\n#Error:incompatible operand types :\n";
-    opnd1->Dump(*theModule);
-    opnd2->Dump(*theModule);
+    opnd1.Dump(*theModule);
+    opnd2.Dump(*theModule);
   }
   return verifyResult;
 }
@@ -1400,7 +1393,7 @@ inline bool BinaryStrictSignVerify0(const BaseNode *bOpnd0, const BaseNode *bOpn
 }
 
 bool BinaryStrictSignVerify1(const BaseNode *bOpnd0, const BaseNode *bOpnd1, const BaseNode *res) {
-  if (GetCompGroupID(res) == kPTYGDynall) {
+  if (GetCompGroupID(*res) == kPTYGDynall) {
     return BinaryStrictSignVerify0(bOpnd0, res) && BinaryStrictSignVerify0(bOpnd1, res) &&
            BinaryStrictSignVerify0(bOpnd0, bOpnd1);
   }
@@ -1424,11 +1417,11 @@ bool UnaryNode::Verify() const {
   }
   bool opndTypeVerf = true;
   if (GetOpCode() != OP_lnot) {
-    opndTypeVerf = ArithTypeVerify(uOpnd);
+    opndTypeVerf = ArithTypeVerify(*uOpnd);
   }
   // When an opcode only specifies one type, check for compatibility
   // between the operands and the result-type.
-  bool compVerf = CompatibleTypeVerify(uOpnd, this);
+  bool compVerf = CompatibleTypeVerify(*uOpnd, *this);
   bool opndExprVerf = uOpnd->Verify();
   return resTypeVerf && opndTypeVerf && compVerf && opndExprVerf;
 }
@@ -1450,7 +1443,7 @@ bool TypeCvtNode::Verify() const {
 
 bool IreadNode::Verify() const {
   bool addrExprVerf = Opnd()->Verify();
-  bool pTypeVerf = ReadTypeVerify(this);
+  bool pTypeVerf = ReadTypeVerify(*this);
   bool structVerf = true;
   if (GetTypeKind(tyIdx) != kTypePointer) {
     LogInfo::MapleLogger() << "\n#Error:<type> must be a pointer type\n";
@@ -1491,24 +1484,24 @@ bool IreadNode::Verify() const {
 }
 
 bool RegreadNode::Verify() const {
-  bool pTypeVerf = ReadTypeVerify(this);
+  bool pTypeVerf = ReadTypeVerify(*this);
   return pTypeVerf;
 }
 
 bool IreadoffNode::Verify() const {
-  bool pTypeVerf = ReadTypeVerify(this);
+  bool pTypeVerf = ReadTypeVerify(*this);
   return pTypeVerf;
 }
 
 bool IreadFPoffNode::Verify() const {
-  bool pTypeVerf = ReadTypeVerify(this);
+  bool pTypeVerf = ReadTypeVerify(*this);
   return pTypeVerf;
 }
 
 bool ExtractbitsNode::Verify() const {
   bool opndExprVerf = Opnd()->Verify();
-  bool opndTypeVerf = ArithTypeVerify(Opnd());
-  bool compVerf = CompatibleTypeVerify(Opnd(), this);
+  bool opndTypeVerf = ArithTypeVerify(*Opnd());
+  bool compVerf = CompatibleTypeVerify(*Opnd(), *this);
   bool resTypeVerf = UnaryTypeVerify0(GetPrimType());
   constexpr int kNumBitsInByte = 8;
   bool opnd0SizeVerf = (kNumBitsInByte * GetPrimTypeSize(Opnd()->GetPrimType()) >= bitsSize);
@@ -1520,7 +1513,7 @@ bool ExtractbitsNode::Verify() const {
 }
 
 bool BinaryNode::Verify() const {
-  bool opndsVerf = BinaryGenericVerify(GetBOpnd(0), GetBOpnd(1));
+  bool opndsVerf = BinaryGenericVerify(*GetBOpnd(0), *GetBOpnd(1));
   bool resTypeVerf = BinaryTypeVerify(GetPrimType());
   if (!resTypeVerf && theModule->IsCModule()) {
     if ((IsAddress(GetBOpnd(0)->GetPrimType()) && !IsAddress(GetBOpnd(1)->GetPrimType())) ||
@@ -1543,8 +1536,8 @@ bool BinaryNode::Verify() const {
            "be in [i32,u32,i64,u64,f32,f64,dynamic-type]\n";
     this->Dump(*theModule);
   }
-  bool comp0Verf = CompatibleTypeVerify(GetBOpnd(0), this);
-  bool comp1Verf = CompatibleTypeVerify(GetBOpnd(1), this);
+  bool comp0Verf = CompatibleTypeVerify(*GetBOpnd(0), *this);
+  bool comp1Verf = CompatibleTypeVerify(*GetBOpnd(1), *this);
   bool signVerf = true;
   bool typeVerf = resTypeVerf && comp0Verf && comp1Verf;
   if (typeVerf) {
@@ -1561,8 +1554,8 @@ bool BinaryNode::Verify() const {
 }
 
 bool CompareNode::Verify() const {
-  bool opndsVerf = BinaryGenericVerify(GetBOpnd(0), GetBOpnd(1));
-  bool compVerf = CompatibleTypeVerify(GetBOpnd(0), GetBOpnd(1));
+  bool opndsVerf = BinaryGenericVerify(*GetBOpnd(0), *GetBOpnd(1));
+  bool compVerf = CompatibleTypeVerify(*GetBOpnd(0), *GetBOpnd(1));
   bool resTypeVerf = CompareTypeVerify(GetPrimType());
   if (!resTypeVerf) {
     this->Dump(*theModule);
@@ -1579,7 +1572,7 @@ bool CompareNode::Verify() const {
 }
 
 bool DepositbitsNode::Verify() const {
-  bool opndsVerf = BinaryGenericVerify(GetBOpnd(0), GetBOpnd(1));
+  bool opndsVerf = BinaryGenericVerify(*GetBOpnd(0), *GetBOpnd(1));
   bool resTypeVerf = IntTypeVerify(GetPrimType());
   constexpr int kNumBitsInByte = 8;
   bool opnd0SizeVerf = (kNumBitsInByte * GetPrimTypeSize(GetBOpnd(0)->GetPrimType()) >= bitsSize);
@@ -1594,8 +1587,8 @@ bool IntrinsicopNode::Verify() const {
 }
 
 bool TernaryNode::Verify() const {
-  bool comp1Verf = CompatibleTypeVerify(topnd[1], this);
-  bool comp2Verf = CompatibleTypeVerify(topnd[2], this);
+  bool comp1Verf = CompatibleTypeVerify(*topnd[1], *this);
+  bool comp2Verf = CompatibleTypeVerify(*topnd[2], *this);
   bool opnd0TypeVerf = IsPrimitiveInteger(topnd[0]->GetPrimType());
   if (!opnd0TypeVerf) {
     LogInfo::MapleLogger() << "\n#Error:select-opnd0 must be of integer type\n";
@@ -1637,7 +1630,7 @@ bool AddrofNode::Verify() const {
   bool pTypeVerf = true;
   bool structVerf = IsStructureVerify(fieldID, GetStIdx());
   if (GetOpCode() == OP_dread) {
-    pTypeVerf = ReadTypeVerify(this);
+    pTypeVerf = ReadTypeVerify(*this);
     if (fieldID == 0 && IsStructureTypeKind(GetTypeKind(GetStIdx()))) {
       if (GetPrimType() != PTY_agg) {
         pTypeVerf = false;
@@ -1703,19 +1696,19 @@ bool IassignNode::Verify() const {
 bool IassignoffNode::Verify() const {
   bool addrVerf = GetBOpnd(0)->Verify();
   bool rhsVerf = GetBOpnd(1)->Verify();
-  bool compVerf = CompatibleTypeVerify(this, GetBOpnd(1));
+  bool compVerf = CompatibleTypeVerify(*this, *GetBOpnd(1));
   return addrVerf && rhsVerf && compVerf;
 }
 
 bool IassignFPoffNode::Verify() const {
   bool rhsVerf = Opnd()->Verify();
-  bool compVerf = CompatibleTypeVerify(this, Opnd());
+  bool compVerf = CompatibleTypeVerify(*this, *Opnd());
   return rhsVerf && compVerf;
 }
 
 bool RegassignNode::Verify() const {
   bool rhsVerf = Opnd()->Verify();
-  bool compVerf = CompatibleTypeVerify(this, Opnd());
+  bool compVerf = CompatibleTypeVerify(*this, *Opnd());
   return rhsVerf && compVerf;
 }
 
@@ -1739,7 +1732,7 @@ bool SwitchNode::Verify() const {
 }
 
 bool BinaryStmtNode::Verify() const {
-  return GetBOpnd(0)->Verify() && GetBOpnd(1)->Verify() && CompatibleTypeVerify(GetBOpnd(0), GetBOpnd(1)) &&
+  return GetBOpnd(0)->Verify() && GetBOpnd(1)->Verify() && CompatibleTypeVerify(*GetBOpnd(0), *GetBOpnd(1)) &&
          BinaryStrictSignVerify0(GetBOpnd(0), GetBOpnd(1));
 }
 
diff --git a/src/maple_ir/src/mir_parser.cpp b/src/maple_ir/src/mir_parser.cpp
index 1e62afb2fffe0a11a00030e912f95416c1736769..dce2eed889666f6cc29044d8816fa9528eb89e54 100644
--- a/src/maple_ir/src/mir_parser.cpp
+++ b/src/maple_ir/src/mir_parser.cpp
@@ -1453,7 +1453,7 @@ bool MIRParser::ParseStmtBlockForVar(TokenKind stmtTK) {
   if (!ParseDeclareVar(*st)) {
     return false;
   }
-  if (!fn->GetSymTab()->AddToStringSymbolMap(st)) {
+  if (!fn->GetSymTab()->AddToStringSymbolMap(*st)) {
     Error("duplicate declare symbol parse function ");
     return false;
   }
@@ -1810,7 +1810,7 @@ bool MIRParser::ParseExprDread(BaseNodePtr &expr) {
   } else {
     dexpr->SetFieldID(0);
   }
-  if (!dexpr->CheckNode(&mod)) {
+  if (!dexpr->CheckNode(mod)) {
     Error("dread is not legal");
     return false;
   }
diff --git a/src/maple_ir/src/mir_pragma.cpp b/src/maple_ir/src/mir_pragma.cpp
index 438aa157b5a62e9f79f7c10a189c55f2ca0f4a4d..17074c4047308ecf18f52529d4d6bebd69e8aebf 100644
--- a/src/maple_ir/src/mir_pragma.cpp
+++ b/src/maple_ir/src/mir_pragma.cpp
@@ -19,6 +19,17 @@
 #include "printing.h"
 #include "maple_string.h"
 
+namespace  {
+enum Status {
+  kStop = 0,
+  kStartWithSubvec = 1,
+  kNormalTypeStrEndWithSemicolon = 2,
+  kNormalTypeStrEndWithSubvecNeedSemicolon = 3,
+  kEndWithSubvec = 4,
+  kIgnoreAndContinue = 5
+};
+}
+
 namespace maple {
 static std::string GetKind(PragmaValueType kind) {
   switch (kind) {
@@ -75,7 +86,7 @@ static std::string GetKind(PragmaValueType kind) {
 //     start         end    start        end
 static void GetTypeStr(const std::string &str, uint32 &start, uint32 &end, uint32 &status) {
   uint32 i = start;
-  status = 0;
+  status = kStop;
   while (str[i] == '[') {
     i++;
   }
@@ -91,7 +102,7 @@ static void GetTypeStr(const std::string &str, uint32 &start, uint32 &end, uint3
     case 'F':
     case 'D':
     case 'V':
-      status = 2;
+      status = kNormalTypeStrEndWithSemicolon;
       end = i + 1;
       break;
     case 'L':
@@ -99,11 +110,11 @@ static void GetTypeStr(const std::string &str, uint32 &start, uint32 &end, uint3
       // Lfoo; or Lfoo<...>;
       while (i < str.length()) {
         if (str[i] == ';') {
-          status = 2;
+          status = kNormalTypeStrEndWithSemicolon;
           end = i + 1;
           break;
         } else if (str[i] == '<') {
-          status = 3;
+          status = kNormalTypeStrEndWithSubvecNeedSemicolon;
           end = i;
           break;
         } else {
@@ -112,16 +123,16 @@ static void GetTypeStr(const std::string &str, uint32 &start, uint32 &end, uint3
       }
       break;
     case '<':
-      status = 1;
+      status = kStartWithSubvec;
       end = i + 1;
       break;
     case '>':
-      status = 4;
+      status = kEndWithSubvec;
       end = i + 1;
       break;
     case ';':
       // continue cases
-      status = 5;
+      status = kIgnoreAndContinue;
       end = i + 1;
       break;
     default:
@@ -136,7 +147,7 @@ MIRPragmaElement *MIRPragma::GetPragmaElemFromSignature(const std::string &signa
     return nullptr;
   }
   std::stack<MIRPragmaElement*> elemStack;
-  MIRPragmaElement *elem = mod->GetMemPool()->New<MIRPragmaElement>(mod);
+  MIRPragmaElement *elem = mod->GetMemPool()->New<MIRPragmaElement>(*mod);
   elem->SetType(kValueArray);
   elemStack.push(elem);
   uint32 status = 0;
@@ -149,38 +160,38 @@ MIRPragmaElement *MIRPragma::GetPragmaElemFromSignature(const std::string &signa
     GetTypeStr(signature, start, end, status);
     // status: 0:stop/1:start_subvec/2:normal/3:normal+';'/4:end_subvec/5:ignore_and_continue
     switch (status) {
-      case 0:
+      case kStop:
         return elem;
-      case 1: {
-        MIRPragmaElement *etmp = mod->GetMemPool()->New<MIRPragmaElement>(mod);
+      case kStartWithSubvec: {
+        MIRPragmaElement *etmp = mod->GetMemPool()->New<MIRPragmaElement>(*mod);
         etmp->SetType(kValueArray);
         elemStack.top()->PushSubElemVec(*etmp);
         elemStack.push(etmp);
         break;
       }
-      case 2: {
-        MIRPragmaElement *etmp = mod->GetMemPool()->New<MIRPragmaElement>(mod);
+      case kNormalTypeStrEndWithSemicolon: {
+        MIRPragmaElement *etmp = mod->GetMemPool()->New<MIRPragmaElement>(*mod);
         etmp->SetType(kValueType);
         std::string typeStr = signature.substr(start, end - start);
         etmp->SetU64Val(static_cast<uint64>(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeStr).GetIdx()));
         elemStack.top()->PushSubElemVec(*etmp);
         break;
       }
-      case 3: {
-        MIRPragmaElement *etmp = mod->GetMemPool()->New<MIRPragmaElement>(mod);
+      case kNormalTypeStrEndWithSubvecNeedSemicolon: {
+        MIRPragmaElement *etmp = mod->GetMemPool()->New<MIRPragmaElement>(*mod);
         etmp->SetType(kValueType);
         std::string typeStr = signature.substr(start, end - start) + ";";
         etmp->SetU64Val(static_cast<uint64>(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(typeStr).GetIdx()));
         elemStack.top()->PushSubElemVec(*etmp);
         break;
       }
-      case 4:
+      case kEndWithSubvec:
         if (elemStack.empty()) {  // Invalid annotation signature format
           return nullptr;
         }
         elemStack.pop();
         break;
-      case 5:
+      case kIgnoreAndContinue:
         break;
       default:
         ASSERT(false, "unexpected status");
diff --git a/src/maple_ir/src/mir_type.cpp b/src/maple_ir/src/mir_type.cpp
index 4170e7de63129e9aa6bc064ff4ad17917dc99af1..6f1da7719eb63db64978835507cba597eda3224e 100644
--- a/src/maple_ir/src/mir_type.cpp
+++ b/src/maple_ir/src/mir_type.cpp
@@ -310,17 +310,17 @@ const std::string &MIRType::GetName(void) const {
   return GlobalTables::GetStrTable().GetStringFromStrIdx(nameStrIdx);
 }
 
-bool MIRType::ValidateClassOrInterface(const char *className, bool noWarning) {
+bool MIRType::ValidateClassOrInterface(const std::string &className, bool noWarning) {
   if (primType == maple::PTY_agg && (typeKind == maple::kTypeClass || typeKind == maple::kTypeInterface) &&
       nameStrIdx.GetIdx()) {
     return true;
   } else {
     if (!noWarning) {
-      int len = strlen(className);
+      int len = className.size();
       constexpr int minClassNameLen = 4;
       constexpr char suffix[] = "_3B";
       int suffixLen = std::strlen(suffix);
-      if (len > minClassNameLen && strncmp(className + len - suffixLen, suffix, suffixLen) == 0) {
+      if (len > minClassNameLen && strncmp(className.c_str() + len - suffixLen, suffix, suffixLen) == 0) {
         LogInfo::MapleLogger(kLlErr) << "error: missing proper mplt file for " << className << std::endl;
       } else {
         LogInfo::MapleLogger(kLlErr) << "internal error: type is not java class or interface "
@@ -650,9 +650,9 @@ FieldID MIRClassType::GetLastFieldID() const {
   return fieldID;
 }
 
-static void DumpClassOrInterfaceInfo(const MIRStructType *type, int indent) {
-  const std::vector<MIRInfoPair> &info = type->GetInfo();
-  std::vector<bool> infoIsString = type->GetIsStringInfo();
+static void DumpClassOrInterfaceInfo(const MIRStructType &type, int indent) {
+  const std::vector<MIRInfoPair> &info = type.GetInfo();
+  std::vector<bool> infoIsString = type.GetIsStringInfo();
   size_t size = info.size();
   for (size_t i = 0; i < size; i++) {
     LogInfo::MapleLogger() << std::endl;
@@ -956,7 +956,7 @@ void MIRClassType::Dump(int indent, bool dontUseName) const {
     LogInfo::MapleLogger() << " ";
   }
   LogInfo::MapleLogger() << "{";
-  DumpClassOrInterfaceInfo(this, indent);
+  DumpClassOrInterfaceInfo(*this, indent);
   bool hasFieldMethodOrInterface = !(fields.empty() && parentFields.empty() && staticFields.empty() &&
                                      methods.empty() && interfacesImplemented.empty());
   DumpInfoPragmaStaticValue(info, pragmaVec, staticValue, indent, hasFieldMethodOrInterface);
@@ -988,7 +988,7 @@ void MIRInterfaceType::Dump(int indent, bool dontUseName) const {
     LogInfo::MapleLogger() << " ";
   }
   LogInfo::MapleLogger() << " {";
-  DumpClassOrInterfaceInfo(this, indent);
+  DumpClassOrInterfaceInfo(*this, indent);
   bool hasFieldOrMethod = !(fields.empty() && staticFields.empty() && parentFields.empty() && methods.empty());
   DumpInfoPragmaStaticValue(info, pragmaVec, staticValue, indent, hasFieldOrMethod);
   DumpFieldsAndMethods(indent, !methods.empty());
diff --git a/src/maple_ir/src/parser.cpp b/src/maple_ir/src/parser.cpp
index 59616455cb88db2d870fb787c8100cf385b075d6..aa58ef73090c4923aefd586f7ea7c9ff09bc2aaf 100644
--- a/src/maple_ir/src/parser.cpp
+++ b/src/maple_ir/src/parser.cpp
@@ -348,7 +348,7 @@ bool MIRParser::ParseBitFieldType(TyIdx &fieldTyIdx) {
     return false;
   }
   ASSERT(lexer.GetTheIntVal() <= 0xFFU, "lexer.theIntVal is larger than max uint8 bitsize value.");
-  uint8 bitSize = lexer.GetTheIntVal() & 0xFFU;
+  uint8 bitSize = static_cast<uint8>(lexer.GetTheIntVal()) & 0xFFU;
   PrimType primType = GetPrimitiveType(lexer.NextToken());
   if (primType == kPtyInvalid) {
     Error("expect primitive type but get ");
@@ -452,7 +452,7 @@ bool MIRParser::ParsePragmaElementForArray(MIRPragmaElement &elem) {
     return false;
   }
   for (int64 i = 0; i < size; i++) {
-    MIRPragmaElement *e0 = mod.GetMemPool()->New<MIRPragmaElement>(&mod);
+    MIRPragmaElement *e0 = mod.GetMemPool()->New<MIRPragmaElement>(mod);
     tk = lexer.NextToken();
     if (!ParsePragmaElement(*e0)) {
       Error("parsing pragma error type ");
@@ -499,7 +499,7 @@ bool MIRParser::ParsePragmaElementForAnnotation(MIRPragmaElement &elem) {
     return false;
   }
   for (int i = 0; i < size; i++) {
-    MIRPragmaElement *e0 = mod.GetMemPool()->New<MIRPragmaElement>(&mod);
+    MIRPragmaElement *e0 = mod.GetMemPool()->New<MIRPragmaElement>(mod);
     tk = lexer.NextToken();
     if (tk != TK_label) {
       Error("parsing pragma error: expecting @ but get ");
@@ -522,7 +522,7 @@ bool MIRParser::ParsePragmaElementForAnnotation(MIRPragmaElement &elem) {
 }
 
 bool MIRParser::ParsePragma(MIRStructType &type) {
-  MIRPragma *p = mod.GetMemPool()->New<MIRPragma>(&mod);
+  MIRPragma *p = mod.GetMemPool()->New<MIRPragma>(mod);
   p->SetVisibility(lexer.GetTheIntVal());
   TokenKind tk = lexer.NextToken();
 
@@ -562,7 +562,7 @@ bool MIRParser::ParsePragma(MIRStructType &type) {
   }
   tk = lexer.NextToken();
   while (tk != kTkRbrace) {
-    MIRPragmaElement *e = mod.GetMemPool()->New<MIRPragmaElement>(&mod);
+    MIRPragmaElement *e = mod.GetMemPool()->New<MIRPragmaElement>(mod);
     e->SetNameStrIdx(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName()));
     tk = lexer.NextToken();
     if (!ParsePragmaElement(*e)) {
@@ -759,7 +759,7 @@ bool MIRParser::ParseFields(MIRStructType &type) {
     // tyIdx does not work. Calling EqualTo does not work either.
     MIRFuncType *funcType = static_cast<MIRFuncType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcTyidx));
     fn->SetMIRFuncType(funcType);
-    fn->SetReturnStruct(GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetRetTyIdx()));
+    fn->SetReturnStruct(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(funcType->GetRetTyIdx()));
     funcSymbol->SetTyIdx(funcTyidx);
     MethodPair p = MethodPair(funcSymbol->GetStIdx(), TyidxFuncAttrPair(funcTyidx, FuncAttrs(tA)));
     type.GetMethods().push_back(p);
@@ -1769,7 +1769,7 @@ bool MIRParser::ParsePrototype(MIRFunction &func, MIRSymbol &funcSymbol, TyIdx &
           Error("ParseFunction expect scalar value");
           return false;
         }
-        (void)func.GetSymTab()->AddToStringSymbolMap(symbol);
+        (void)func.GetSymTab()->AddToStringSymbolMap(*symbol);
         func.AddFormal(symbol);
         vecType.push_back(symbol->GetTyIdx());
         vecAttrs.push_back(symbol->GetAttrs());
@@ -1786,7 +1786,7 @@ bool MIRParser::ParsePrototype(MIRFunction &func, MIRSymbol &funcSymbol, TyIdx &
     return false;
   }
   MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
-  func.SetReturnStruct(retType);
+  func.SetReturnStruct(*retType);
   MIRType *funcType =
       GlobalTables::GetTypeTable().GetOrCreateFunctionType(mod, tyIdx, vecType, vecAttrs, varArgs, true);
   funcTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(funcType);
@@ -2205,7 +2205,7 @@ static void GenJStringType(MIRModule &module) {
 bool MIRParser::ParseMIR(std::ifstream &mplfile) {
   std::ifstream *origFile = lexer.GetFile();
   // parse mplfile
-  lexer.SetFile(&mplfile);
+  lexer.SetFile(mplfile);
   // try to read the first line
   if (lexer.ReadALine() < 0) {
     lexer.lineNum = 0;
@@ -2215,7 +2215,7 @@ bool MIRParser::ParseMIR(std::ifstream &mplfile) {
   // for optimized functions file
   bool status = ParseMIR(0, kParseOptFunc);
   // restore airFile
-  lexer.SetFile(origFile);
+  lexer.SetFile(*origFile);
   return status;
 }
 
@@ -2690,7 +2690,7 @@ bool MIRParser::ParseMPLT(std::ifstream &mpltFile, const std::string &importFile
   // set up to read next line from the import file
   lexer.curIdx = 0;
   lexer.currentLineSize = 0;
-  lexer.SetFile(&mpltFile);
+  lexer.SetFile(mpltFile);
   lexer.lineNum = 0;
   mod.SetFileName(importFileName);
   bool atEof = false;
@@ -2729,7 +2729,7 @@ bool MIRParser::ParseMPLT(std::ifstream &mpltFile, const std::string &importFile
   lexer.curIdx = 0;  // to force reading new line
   lexer.currentLineSize = 0;
   lexer.lineNum = lineNumSave;
-  lexer.SetFile(airFileSave);
+  lexer.SetFile(*airFileSave);
   mod.SetFileName(modFileNameSave);
   return true;
 }
@@ -2781,7 +2781,7 @@ bool MIRParser::ParsePrototypeRemaining(MIRFunction &func, std::vector<TyIdx> &v
         Error("ParseFunction expect scalar value");
         return false;
       }
-      (void)func.GetSymTab()->AddToStringSymbolMap(symbol);
+      (void)func.GetSymTab()->AddToStringSymbolMap(*symbol);
     }
     func.AddFormal(symbol);
     vecTyIdx.push_back(symbol->GetTyIdx());
diff --git a/src/maple_me/include/bb.h b/src/maple_me/include/bb.h
index 5b5cba747e6159149a713f098e22645019e5a462..cbc7f657bd7a4ffc690cec711c8b54986c3c188c 100644
--- a/src/maple_me/include/bb.h
+++ b/src/maple_me/include/bb.h
@@ -224,14 +224,14 @@ class BB {
   void SetFirstMe(MeStmt *stmt);
   void SetLastMe(MeStmt *stmt);
   bool IsInList(const MapleVector<BB*> &bbList) const;
-  bool IsPredBB(const BB *bb) const {
+  bool IsPredBB(const BB &bb) const {
     // if this is a pred of bb return true;
     // otherwise return false;
-    return IsInList(bb->pred);
+    return IsInList(bb.pred);
   }
 
-  bool IsSuccBB(const BB *bb) const {
-    return IsInList(bb->succ);
+  bool IsSuccBB(const BB &bb) const {
+    return IsInList(bb.succ);
   }
 
   void AddSuccBB(BB *succPara) {
diff --git a/src/maple_me/include/me_option.h b/src/maple_me/include/me_option.h
index 8b0a8813ed4421fe5ac390aa207ca8cecab1298a..c697cbdb231e4444679dae108a8caf2fded1a751 100644
--- a/src/maple_me/include/me_option.h
+++ b/src/maple_me/include/me_option.h
@@ -31,10 +31,10 @@ class MeOption {
   static bool DumpPhase(const std::string &phase);
   static std::unordered_set<std::string> dumpPhases;
   enum Level {
-    LEVEL_ZERO = 0,
-    LEVEL_ONE = 1,
-    LEVEL_TWO = 2,
-    LEVEL_THREE = 3
+    kLevelZero = 0,
+    kLevelOne = 1,
+    kLevelTwo = 2,
+    kLevelThree = 3
   };
   static bool dumpAfter;
   static constexpr int kRangeArrayLen = 2;
diff --git a/src/maple_me/src/func_emit.cpp b/src/maple_me/src/func_emit.cpp
index 40a72913479803dfd899b5b0232a48061bef91ba..9f729b6d6f0d943656d342ba9568a52c89f43e40 100644
--- a/src/maple_me/src/func_emit.cpp
+++ b/src/maple_me/src/func_emit.cpp
@@ -34,12 +34,13 @@ void FuncEmit::EmitLabelForBB(MIRFunction &func, BB &bb) const {
     }
     // "first" points to the first non-comment statement, or nullptr
     if (first != nullptr) {
-      label->InsertAfterThis(first);
+      label->InsertAfterThis(*first);
       if (first == bb.GetStmtNodes().begin().d()) {
         bb.SetFirst(label);
       }
     } else {
-      label->InsertBeforeThis(firstPrev);
+      ASSERT(firstPrev != nullptr, "check func's stmt");
+      label->InsertBeforeThis(*firstPrev);
       if (firstPrev == bb.GetStmtNodes().rbegin().base().d()) {
         bb.SetLast(label);
       }
@@ -81,7 +82,7 @@ void FuncEmit::EmitBeforeHSSA(MIRFunction &func, const MapleVector<BB*> &bbList)
       /* generate op_endtry andd added to next, it could be in an empty bb. */
       StmtNode *endtry = func.GetCodeMempool()->New<StmtNode>(OP_endtry);
       CHECK_FATAL(lastStmt != nullptr, "EmitBeforeHSSA: shouldn't insert before a null stmt");
-      endtry->InsertBeforeThis(lastStmt);
+      endtry->InsertBeforeThis(*lastStmt);
       lastStmt = endtry;
     }
   }
diff --git a/src/maple_me/src/irmap.cpp b/src/maple_me/src/irmap.cpp
index 8966c4402736dfc8994945d23b43ae1a0dfc4ae1..6cd3758c7325994b9fda03029a5e3a0cd20a2b87 100644
--- a/src/maple_me/src/irmap.cpp
+++ b/src/maple_me/src/irmap.cpp
@@ -148,7 +148,7 @@ RegMeExpr *IRMap::CreateRefRegMeExpr(const MIRSymbol &mirSt) {
   MIRType *sttype = mirSt.GetType();
   PrimType ptyp = sttype->GetPrimType();
   ASSERT(ptyp == PTY_ref, "only PTY_ref needed");
-  PregIdx regidx = mirfunc->GetPregTab()->CreateRefPreg(sttype);
+  PregIdx regidx = mirfunc->GetPregTab()->CreateRefPreg(*sttype);
   ASSERT(regidx <= 0xffff, "register oversized");
   MIRPreg *preg = mirfunc->GetPregTab()->PregFromPregIdx(regidx);
   if (!mirSt.IgnoreRC()) {
@@ -174,7 +174,7 @@ RegMeExpr *IRMap::CreateRegMeExpr(PrimType ptyp) {
 
 RegMeExpr *IRMap::CreateRegRefMeExpr(MIRType &mirType) {
   MIRFunction *mirfunc = mirModule.CurFunction();
-  PregIdx regidx = mirfunc->GetPregTab()->CreateRefPreg(&mirType);
+  PregIdx regidx = mirfunc->GetPregTab()->CreateRefPreg(mirType);
   ASSERT(regidx <= 0xffff, "register oversized");
   OriginalSt *oSt = ssaTab.GetOriginalStTable().CreatePregOriginalSt(regidx, mirfunc->GetPuidx());
   RegMeExpr *regreadexpr = NewInPool<RegMeExpr>(exprID++, regidx, mirfunc->GetPuidx(), oSt->GetIndex(), 0);
diff --git a/src/maple_phase/include/phase_impl.h b/src/maple_phase/include/phase_impl.h
index 10563a095729abb64d03f87da598aa5890b59303..4c09a9f2ff04e32b026adfdd8f96ff51e58456f9 100644
--- a/src/maple_phase/include/phase_impl.h
+++ b/src/maple_phase/include/phase_impl.h
@@ -42,9 +42,9 @@ class FuncOptimizeImpl {
     module->SetCurFunction(func);
   }
 
-  virtual void ProcessBlock(StmtNode *stmt);
+  virtual void ProcessBlock(StmtNode &stmt);
   // Each phase needs to implement its own ProcessStmt
-  virtual void ProcessStmt(StmtNode *stmt) {}
+  virtual void ProcessStmt(StmtNode &stmt) {}
 
   KlassHierarchy *klassHierarchy = nullptr;
   MIRFunction *currFunc = nullptr;
diff --git a/src/maple_util/include/string_utils.h b/src/maple_util/include/string_utils.h
index ecf7013d158ebe090b0e3d8515af38c44077c6df..d8803374c665defd6d68c883d7438a6dd54b77da 100644
--- a/src/maple_util/include/string_utils.h
+++ b/src/maple_util/include/string_utils.h
@@ -29,7 +29,7 @@ class StringUtils {
       return;
     }
 
-    std::stringstream strStream(src);
+    std::stringstream strStream(src + delim);
     std::string item;
     while (std::getline(strStream, item, delim)) {
       container.emplace_back(item);
diff --git a/src/mpl2mpl/include/java_intrn_lowering.h b/src/mpl2mpl/include/java_intrn_lowering.h
index 5cbf901aedbfcfe329ae70369aa620421aca998d..4337ffff678fcf92bf68f61095a79cd1151305ac 100644
--- a/src/mpl2mpl/include/java_intrn_lowering.h
+++ b/src/mpl2mpl/include/java_intrn_lowering.h
@@ -30,7 +30,7 @@ class JavaIntrnLowering : public FuncOptimizeImpl {
   }
 
  private:
-  void ProcessStmt(StmtNode *stmt) override;
+  void ProcessStmt(StmtNode &stmt) override;
   void ProcessJavaIntrnMerge(StmtNode &assignNode, const IntrinsicopNode &intrinNode);
   BaseNode *JavaIntrnMergeToCvtType(PrimType dtyp, PrimType styp, BaseNode *src);
   void ProcessJavaIntrnFillNewArray(IntrinsiccallNode &intrinCall);
diff --git a/src/mpl2mpl/include/reflection_analysis.h b/src/mpl2mpl/include/reflection_analysis.h
index 40097032f4b0d2eea6ec15a5f6e9ba7dbff70dab..4cb4aa727d5b9d4a001d481bb7e29925797b9732 100644
--- a/src/mpl2mpl/include/reflection_analysis.h
+++ b/src/mpl2mpl/include/reflection_analysis.h
@@ -216,9 +216,9 @@ static constexpr uint64 kMethodAbstract = 0x00000010;
     break;
 class ReflectionAnalysis : public AnalysisResult {
  public:
-  static void GenStrTab(MIRModule *mirmodule);
+  static void GenStrTab(MIRModule &mirmodule);
   static uint32 FindOrInsertRepeatString(const std::string &str, bool isHot = false, uint8 hotType = kLayoutUnused);
-  static BaseNode *GenClassInfoAddr(BaseNode *obj, MIRBuilder *builder);
+  static BaseNode *GenClassInfoAddr(BaseNode *obj, MIRBuilder &builder);
   ReflectionAnalysis(MIRModule *mod, MemPool *memPool, KlassHierarchy *kh, MIRBuilder &builder)
       : AnalysisResult(memPool),
         mirModule(mod),
@@ -279,26 +279,26 @@ class ReflectionAnalysis : public AnalysisResult {
   MIRSymbol *GetSymbol(const std::string &name, TyIdx tyIdx);
   MIRSymbol *CreateSymbol(GStrIdx strIdx, TyIdx tyIdx);
   MIRSymbol *GetSymbol(GStrIdx strIdx, TyIdx tyIdx);
-  void GenClassMetaData(Klass *klass);
-  std::string GetAnnoValueWithoutArray(const MIRPragmaElement *annoElem);
+  void GenClassMetaData(Klass &klass);
+  std::string GetAnnoValueWithoutArray(const MIRPragmaElement &annoElem);
   void CompressHighFrequencyStr(std::string &s);
   std::string GetArrayValue(MapleVector<MIRPragmaElement*> subElemVector, bool isSN = false);
   std::string GetAnnotationValue(MapleVector<MIRPragmaElement*> subElemVector, GStrIdx typeStrIdx);
-  MIRSymbol *GenSuperClassMetaData(const Klass *klass, std::list<Klass*> superClassList);
-  MIRSymbol *GenFieldsMetaData(const Klass *klass);
-  MIRSymbol *GenMethodsMetaData(const Klass *klass);
-  static void GenMetadataType(MIRModule *mirModule);
-  static MIRType *GetRefFieldType(MIRBuilder *mirBuilder);
-  static TyIdx GenMetaStructType(MIRModule *mirModule, MIRStructType &metaType, const std::string &str);
+  MIRSymbol *GenSuperClassMetaData(const Klass &klass, std::list<Klass*> superClassList);
+  MIRSymbol *GenFieldsMetaData(const Klass &klass);
+  MIRSymbol *GenMethodsMetaData(const Klass &klass);
+  static void GenMetadataType(MIRModule &mirModule);
+  static MIRType *GetRefFieldType(MIRBuilder &mirBuilder);
+  static TyIdx GenMetaStructType(MIRModule &mirModule, MIRStructType &metaType, const std::string &str);
   int64 GetHashIndex(const std::string &strname);
-  static void GenHotClassNameString(const Klass *klass);
+  static void GenHotClassNameString(const Klass &klass);
   uint32 FindOrInsertReflectString(const std::string &str);
   static void InitReflectString();
   int64 BKDRHash(const std::string &strname, uint32 seed);
   void GenClassHashMetaData();
   void MarkWeakMethods();
   void Run();
-  bool VtableFunc(const MIRFunction *func) const;
+  bool VtableFunc(const MIRFunction &func) const;
   void GenPrimitiveClass();
   bool RootClassDefined();  // wether current module defines root classes
   void GenAllMethodHash(std::vector<std::pair<MethodPair*, int>> &methodInfoVec,
diff --git a/src/mpl2mpl/include/vtable_analysis.h b/src/mpl2mpl/include/vtable_analysis.h
index 7ec004a0dd0c6670a2899e3ca2005abe9bfc2149..7e1283c25db26e8452227fc4ab820eec12ecd7f9 100644
--- a/src/mpl2mpl/include/vtable_analysis.h
+++ b/src/mpl2mpl/include/vtable_analysis.h
@@ -32,33 +32,31 @@ class VtableAnalysis : public FuncOptimizeImpl {
  public:
   VtableAnalysis(MIRModule *mod, KlassHierarchy *kh, bool dump);
   ~VtableAnalysis() {}
-
+  static std::string DecodeBaseNameWithType(const MIRFunction &func);
   void ProcessFunc(MIRFunction *func) override;
   FuncOptimizeImpl *Clone() override {
     return new (std::nothrow) VtableAnalysis(*this);
   }
 
-  static std::string DecodeBaseNameWithType(const MIRFunction *func);
-
  private:
   std::unordered_map<PUIdx, int> puidxToVtabIndex;
   MIRType *voidPtrType;
   MIRIntConst *zeroConst;
   MIRIntConst *oneConst;
-  bool IsVtableCandidate(const MIRFunction *func) const;
-  bool CheckOverrideForCrossPackage(const MIRFunction *baseMethod, const MIRFunction *currMethod) const;
-  void AddMethodToTable(MethodPtrVector &methodTable, MethodPair *methodpair);
-  void GenVtableList(const Klass *klass);
+  bool IsVtableCandidate(const MIRFunction &func) const;
+  bool CheckOverrideForCrossPackage(const MIRFunction &baseMethod, const MIRFunction &currMethod) const;
+  void AddMethodToTable(MethodPtrVector &methodTable, MethodPair &methodpair);
+  void GenVtableList(const Klass &klass);
   void DumpVtableList(const Klass *klass) const;
-  void GenTableSymbol(const std::string &prefix, const std::string klassName, MIRAggConst *newconst);
-  void GenVtableDefinition(const Klass *klass);
-  void GenItableDefinition(const Klass *klass);
+  void GenTableSymbol(const std::string &prefix, const std::string klassName, MIRAggConst &newconst);
+  void GenVtableDefinition(const Klass &klass);
+  void GenItableDefinition(const Klass &klass);
 
   BaseNode *GenVtabItabBaseAddr(BaseNode *obj, bool isVirtual);
-  void ReplaceVirtualInvoke(CallNode *stmt);
-  void ReplaceInterfaceInvoke(CallNode *stmt);
-  void ReplaceSuperclassInvoke(CallNode *stmt);
-  void ReplacePolymorphicInvoke(CallNode *stmt);
+  void ReplaceVirtualInvoke(CallNode &stmt);
+  void ReplaceInterfaceInvoke(CallNode &stmt);
+  void ReplaceSuperclassInvoke(CallNode &stmt);
+  void ReplacePolymorphicInvoke(CallNode &stmt);
 };
 
 class DoVtableAnalysis : public ModulePhase {
diff --git a/src/mpl2mpl/include/vtable_impl.h b/src/mpl2mpl/include/vtable_impl.h
index 7c7a65ef33c8b50a9c3c987194251cc04a5546ad..aecd7cea4e4fa527ef4230b8fc252604621b7191 100644
--- a/src/mpl2mpl/include/vtable_impl.h
+++ b/src/mpl2mpl/include/vtable_impl.h
@@ -41,7 +41,7 @@ class VtableImpl : public FuncOptimizeImpl {
   MIRModule *mirModule;
   KlassHierarchy *klassHierarchy;
   MIRFunction *mccItabFunc;
-  void ReplaceResolveInterface(StmtNode *stmt, const ResolveFuncNode *resolveNode);
+  void ReplaceResolveInterface(StmtNode &stmt, const ResolveFuncNode &resolveNode);
 };
 
 class DoVtableImpl : public ModulePhase {
diff --git a/src/mpl2mpl/src/class_hierarchy.cpp b/src/mpl2mpl/src/class_hierarchy.cpp
index c0f13d3965d27a157f6352cf5d59a80dbddf0776..924b1097f32481940591ae4eda187c6377876e09 100644
--- a/src/mpl2mpl/src/class_hierarchy.cpp
+++ b/src/mpl2mpl/src/class_hierarchy.cpp
@@ -584,19 +584,21 @@ void KlassHierarchy::TagThrowableKlasses() {
   }
 }
 
-static void CollectImplInterfaces(const Klass *klass, std::set<Klass*> &implInterfaceSet) {
-  for (Klass *superKlass : klass->GetSuperKlasses()) {
+static void CollectImplInterfaces(const Klass &klass, std::set<Klass*> &implInterfaceSet) {
+  for (Klass *superKlass : klass.GetSuperKlasses()) {
     if (implInterfaceSet.find(superKlass) == implInterfaceSet.end()) {
+      ASSERT(superKlass != nullptr, "null ptr check!");
       if (superKlass->IsInterface()) {
         implInterfaceSet.insert(superKlass);
       }
-      CollectImplInterfaces(superKlass, implInterfaceSet);
+      CollectImplInterfaces(*superKlass, implInterfaceSet);
     }
   }
-  for (Klass *interfaceKlass : klass->GetImplInterfaces()) {
+  for (Klass *interfaceKlass : klass.GetImplInterfaces()) {
     if (implInterfaceSet.find(interfaceKlass) == implInterfaceSet.end()) {
       implInterfaceSet.insert(interfaceKlass);
-      CollectImplInterfaces(interfaceKlass, implInterfaceSet);
+      ASSERT(interfaceKlass != nullptr, "null ptr check!");
+      CollectImplInterfaces(*interfaceKlass, implInterfaceSet);
     }
   }
 }
@@ -604,10 +606,10 @@ static void CollectImplInterfaces(const Klass *klass, std::set<Klass*> &implInte
 void KlassHierarchy::UpdateImplementedInterfaces() {
   for (auto const &pair : strIdx2KlassMap) {
     Klass *klass = pair.second;
-    ASSERT(klass, "null ptr check");
+    ASSERT(klass != nullptr, "null ptr check");
     if (!klass->IsInterface()) {
       std::set<Klass*> implInterfaceSet;
-      CollectImplInterfaces(klass, implInterfaceSet);
+      CollectImplInterfaces(*klass, implInterfaceSet);
       for (auto interface : implInterfaceSet) {
         // Add missing parent interface to class link
         interface->AddImplKlass(klass);
@@ -791,7 +793,7 @@ MIRType *WKTypes::javalangrefAccessibleObject;
 MIRType *WKTypes::javalangrefMember;
 MIRType *WKTypes::javalangrefField;
 MIRType *WKTypes::javalangrefConstructor;
-inline static MIRType *GetMIRTypeFromName(const char *name) {
+inline static MIRType *GetMIRTypeFromName(const std::string &name) {
   GStrIdx gStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(NameMangler::GetInternalNameLiteral(name));
   return GlobalTables::GetTypeTable().GetTypeFromTyIdx(GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(gStrIdx));
 }
diff --git a/src/mpl2mpl/src/java_eh_lower.cpp b/src/mpl2mpl/src/java_eh_lower.cpp
index 795283a97cfd5a4f4135b6c622954a95fecda238..2c0abaa2b17a093dc75dfb2249a849d7fbdd2fa1 100644
--- a/src/mpl2mpl/src/java_eh_lower.cpp
+++ b/src/mpl2mpl/src/java_eh_lower.cpp
@@ -35,35 +35,35 @@ JavaEHLowerer::JavaEHLowerer(MIRModule *mod, KlassHierarchy *kh, bool dump) : Fu
   divSTIndex = 0;
 }
 
-BaseNode *JavaEHLowerer::DoLowerDiv(BinaryNode *expr, BlockNode *blknode) {
-  PrimType ptype = expr->GetPrimType();
+BaseNode *JavaEHLowerer::DoLowerDiv(BinaryNode &expr, BlockNode &blknode) {
+  PrimType ptype = expr.GetPrimType();
   MIRBuilder *mirBuilder = GetModule()->GetMIRBuilder();
   MIRFunction *func = GetModule()->CurFunction();
   if (IsPrimitiveInteger(ptype)) {
     // Store divopnd to a tmp st if not a leaf node.
-    BaseNode *divOpnd = expr->Opnd(1);
+    BaseNode *divOpnd = expr.Opnd(1);
     if (!divOpnd->IsLeaf()) {
       std::string opnd1name(strDivOpnd);
       opnd1name.append(std::to_string(divSTIndex));
       if (useRegTmp) {
         PregIdx pregIdx = func->GetPregTab()->CreatePreg(ptype);
         RegassignNode *regassDivnode = mirBuilder->CreateStmtRegassign(ptype, pregIdx, divOpnd);
-        blknode->AddStatement(regassDivnode);
+        blknode.AddStatement(regassDivnode);
         divOpnd = mirBuilder->CreateExprRegread(ptype, pregIdx);
       } else {
         MIRSymbol *divOpndSymbol = mirBuilder->CreateSymbol(TyIdx(ptype), opnd1name.c_str(), kStVar, kScAuto,
                                                             GetModule()->CurFunction(), kScopeLocal);
         DassignNode *dssDivNode = mirBuilder->CreateStmtDassign(*divOpndSymbol, 0, divOpnd);
-        blknode->AddStatement(dssDivNode);
+        blknode.AddStatement(dssDivNode);
         divOpnd = mirBuilder->CreateExprDread(*divOpndSymbol);
       }
-      expr->SetBOpnd(divOpnd, 1);
+      expr.SetBOpnd(divOpnd, 1);
     }
     BaseNode *retExprNode = nullptr;
     StmtNode *divStmt = nullptr;
     if (useRegTmp) {
       PregIdx resPregIdx = func->GetPregTab()->CreatePreg(ptype);
-      divStmt = mirBuilder->CreateStmtRegassign(ptype, resPregIdx, expr);
+      divStmt = mirBuilder->CreateStmtRegassign(ptype, resPregIdx, &expr);
       retExprNode = GetModule()->GetMIRBuilder()->CreateExprRegread(ptype, resPregIdx);
     } else {
       std::string resName(strDivRes);
@@ -71,7 +71,7 @@ BaseNode *JavaEHLowerer::DoLowerDiv(BinaryNode *expr, BlockNode *blknode) {
       MIRSymbol *divResSymbol = mirBuilder->CreateSymbol(TyIdx(ptype), resName.c_str(), kStVar, kScAuto,
                                                          GetModule()->CurFunction(), kScopeLocal);
       // Put expr result to dssnode.
-      divStmt = mirBuilder->CreateStmtDassign(*divResSymbol, 0, expr);
+      divStmt = mirBuilder->CreateStmtDassign(*divResSymbol, 0, &expr);
       retExprNode = GetModule()->GetMIRBuilder()->CreateExprDread(*divResSymbol, 0);
     }
     // Check if the second operand of the div expression is 0.
@@ -80,42 +80,40 @@ BaseNode *JavaEHLowerer::DoLowerDiv(BinaryNode *expr, BlockNode *blknode) {
                                                          *GlobalTables::GetTypeTable().GetTypeFromTyIdx((TyIdx)ptype),
                                                          divOpnd, mirBuilder->CreateIntConst(0, ptype));
     IfStmtNode *ifStmtNode = mirBuilder->CreateStmtIf(cmpNode);
-    blknode->AddStatement(ifStmtNode);
+    blknode.AddStatement(ifStmtNode);
     // Call the MCC_ThrowArithmeticException() that will never return.
     MapleVector<BaseNode*> args(GetModule()->GetMIRBuilder()->GetCurrentFuncCodeMpAllocator()->Adapter());
     IntrinsiccallNode *intrinCallNode = mirBuilder->CreateStmtIntrinsicCall(INTRN_JAVA_THROW_ARITHMETIC, args);
     ifStmtNode->GetThenPart()->AddStatement(intrinCallNode);
-    blknode->AddStatement(divStmt);
+    blknode.AddStatement(divStmt);
     // Make dread from the divresst and return it as new expression for this function.
     return retExprNode;
   } else {
-    return expr;
+    return &expr;
   }
 }
 
-BaseNode *JavaEHLowerer::DoLowerExpr(BaseNode *expr, BlockNode *curblk) {
-  ASSERT(expr != nullptr, "null ptr check!");
-  for (size_t i = 0; i < expr->NumOpnds(); i++) {
-    expr->SetOpnd(DoLowerExpr(expr->Opnd(i), curblk), i);
+BaseNode *JavaEHLowerer::DoLowerExpr(BaseNode &expr, BlockNode &curblk) {
+  for (size_t i = 0; i < expr.NumOpnds(); i++) {
+    expr.SetOpnd(DoLowerExpr(*(expr.Opnd(i)), curblk), i);
   }
-  switch (expr->GetOpCode()) {
+  switch (expr.GetOpCode()) {
     case OP_div: {
-      return DoLowerDiv(static_cast<BinaryNode*>(expr), curblk);
+      return DoLowerDiv(*(static_cast<BinaryNode*>(&expr)), curblk);
     }
     case OP_rem: {
-      return DoLowerRem(static_cast<BinaryNode*>(expr), curblk);
+      return DoLowerRem(static_cast<BinaryNode*>(&expr), &curblk);
     }
     default:
-      return expr;
+      return &expr;
   }
 }
 
 void JavaEHLowerer::DoLowerBoundaryCheck(IntrinsiccallNode &intrincall, BlockNode &newblk) {
   const size_t intrincallNopndSize = intrincall.GetNopndSize();
   CHECK_FATAL(intrincallNopndSize > 0, "null ptr check");
-  BaseNode *opnd0 = intrincall.GetNopndAt(0);
   CondGotoNode *brFalseStmt = GetModule()->CurFuncCodeMemPool()->New<CondGotoNode>(OP_brfalse);
-  brFalseStmt->SetOpnd(DoLowerExpr(opnd0, &newblk));
+  brFalseStmt->SetOpnd(DoLowerExpr(*(intrincall.GetNopndAt(0)), newblk));
   brFalseStmt->SetSrcPos(intrincall.GetSrcPos());
   LabelIdx lbidx = GetModule()->CurFunction()->GetLabelTab()->CreateLabel();
   GetModule()->CurFunction()->GetLabelTab()->AddToStringLabelMap(lbidx);
@@ -131,20 +129,22 @@ void JavaEHLowerer::DoLowerBoundaryCheck(IntrinsiccallNode &intrincall, BlockNod
   newblk.AddStatement(labStmt);
 }
 
-BlockNode *JavaEHLowerer::DoLowerBlock(BlockNode *block) {
+BlockNode *JavaEHLowerer::DoLowerBlock(BlockNode &block) {
   BlockNode *newBlock = GetModule()->CurFuncCodeMemPool()->New<BlockNode>();
-  if (!block->GetFirst()) {
+  StmtNode *nextStmt = block.GetFirst();
+  if (nextStmt == nullptr) {
     return newBlock;
   }
-  StmtNode *nextStmt = block->GetFirst();
+
   do {
     StmtNode *stmt = nextStmt;
     nextStmt = stmt->GetNext();
     stmt->SetNext(nullptr);
+
     switch (stmt->GetOpCode()) {
       case OP_switch: {
         SwitchNode *switchNode = static_cast<SwitchNode*>(stmt);
-        switchNode->SetSwitchOpnd(DoLowerExpr(switchNode->GetSwitchOpnd(), newBlock));
+        switchNode->SetSwitchOpnd(DoLowerExpr(*(switchNode->GetSwitchOpnd()), *newBlock));
         newBlock->AddStatement(switchNode);
         break;
       }
@@ -152,10 +152,10 @@ BlockNode *JavaEHLowerer::DoLowerBlock(BlockNode *block) {
         IfStmtNode *ifStmtNode = static_cast<IfStmtNode*>(stmt);
         BlockNode *thenPart = ifStmtNode->GetThenPart();
         BlockNode *elsePart = ifStmtNode->GetElsePart();
-        ifStmtNode->SetOpnd(DoLowerExpr(ifStmtNode->Opnd(), newBlock));
-        ifStmtNode->SetThenPart(DoLowerBlock(thenPart));
+        ifStmtNode->SetOpnd(DoLowerExpr(*(ifStmtNode->Opnd()), *newBlock));
+        ifStmtNode->SetThenPart(DoLowerBlock(*thenPart));
         if (elsePart != nullptr) {
-          ifStmtNode->SetElsePart(DoLowerBlock(elsePart));
+          ifStmtNode->SetElsePart(DoLowerBlock(*elsePart));
         }
         newBlock->AddStatement(ifStmtNode);
         break;
@@ -164,29 +164,29 @@ BlockNode *JavaEHLowerer::DoLowerBlock(BlockNode *block) {
       case OP_dowhile: {
         WhileStmtNode *whileStmtNode = static_cast<WhileStmtNode*>(stmt);
         BaseNode *testOpnd = whileStmtNode->Opnd(0);
-        whileStmtNode->SetOpnd(DoLowerExpr(testOpnd, newBlock));
-        whileStmtNode->SetBody(DoLowerBlock(whileStmtNode->GetBody()));
+        whileStmtNode->SetOpnd(DoLowerExpr(*testOpnd, *newBlock));
+        whileStmtNode->SetBody(DoLowerBlock(*(whileStmtNode->GetBody())));
         newBlock->AddStatement(whileStmtNode);
         break;
       }
       case OP_doloop: {
         DoloopNode *doLoopNode = static_cast<DoloopNode*>(stmt);
-        doLoopNode->SetStartExpr(DoLowerExpr(doLoopNode->GetStartExpr(), newBlock));
-        doLoopNode->SetContExpr(DoLowerExpr(doLoopNode->GetCondExpr(), newBlock));
-        doLoopNode->SetIncrExpr(DoLowerExpr(doLoopNode->GetIncrExpr(), newBlock));
-        doLoopNode->SetDoBody(DoLowerBlock(doLoopNode->GetDoBody()));
+        doLoopNode->SetStartExpr(DoLowerExpr(*(doLoopNode->GetStartExpr()), *newBlock));
+        doLoopNode->SetContExpr(DoLowerExpr(*(doLoopNode->GetCondExpr()), *newBlock));
+        doLoopNode->SetIncrExpr(DoLowerExpr(*(doLoopNode->GetIncrExpr()), *newBlock));
+        doLoopNode->SetDoBody(DoLowerBlock(*(doLoopNode->GetDoBody())));
         newBlock->AddStatement(doLoopNode);
         break;
       }
       case OP_block: {
-        BlockNode *tmp = DoLowerBlock(static_cast<BlockNode*>(stmt));
+        BlockNode *tmp = DoLowerBlock(*(static_cast<BlockNode*>(stmt)));
         CHECK_FATAL(tmp, "null ptr check");
         newBlock->AddStatement(tmp);
         break;
       }
       case OP_throw: {
         UnaryStmtNode *tstmt = static_cast<UnaryStmtNode*>(stmt);
-        BaseNode *opnd0 = DoLowerExpr(tstmt->Opnd(0), newBlock);
+        BaseNode *opnd0 = DoLowerExpr(*(tstmt->Opnd(0)), *newBlock);
         if (opnd0->GetOpCode() == OP_constval) {
           CHECK_FATAL(IsPrimitiveInteger(opnd0->GetPrimType()), "must be integer or something wrong");
           MIRIntConst *intConst = static_cast<MIRIntConst*>(static_cast<ConstvalNode*>(opnd0)->GetConstVal());
@@ -213,7 +213,7 @@ BlockNode *JavaEHLowerer::DoLowerBlock(BlockNode *block) {
       }
       default: {
         for (size_t i = 0; i < stmt->NumOpnds(); i++) {
-          stmt->SetOpnd(DoLowerExpr(stmt->Opnd(i), newBlock), i);
+          stmt->SetOpnd(DoLowerExpr(*(stmt->Opnd(i)), *newBlock), i);
         }
         newBlock->AddStatement(stmt);
         break;
@@ -229,7 +229,7 @@ void JavaEHLowerer::ProcessFunc(MIRFunction *func) {
     return;
   }
   divSTIndex = 0;  // Init it to 0.
-  BlockNode *newBody = DoLowerBlock(func->GetBody());
+  BlockNode *newBody = DoLowerBlock(*(func->GetBody()));
   func->SetBody(newBody);
 }
 }  // namespace maple
diff --git a/src/mpl2mpl/src/java_intrn_lowering.cpp b/src/mpl2mpl/src/java_intrn_lowering.cpp
index 84339e502d70a4e082a3c36d506742509cad09ae..c55c9c2ae8629d629630a58c8c43b14886f37be2 100644
--- a/src/mpl2mpl/src/java_intrn_lowering.cpp
+++ b/src/mpl2mpl/src/java_intrn_lowering.cpp
@@ -25,42 +25,39 @@
 //    Turn it into a jarray malloc and jarray element-wise assignment
 
 namespace maple {
-inline bool IsConstvalZero(BaseNode *n) {
-  return (n->GetOpCode() == OP_constval && static_cast<ConstvalNode*>(n)->GetConstVal()->IsZero());
+inline bool IsConstvalZero(BaseNode &n) {
+  return (n.GetOpCode() == OP_constval && static_cast<ConstvalNode*>(&n)->GetConstVal()->IsZero());
 }
 
 JavaIntrnLowering::JavaIntrnLowering(MIRModule *mod, KlassHierarchy *kh, bool dump) : FuncOptimizeImpl(mod, kh, dump) {
 }
 
 
-void JavaIntrnLowering::ProcessStmt(StmtNode *stmt) {
-  if (stmt == nullptr) {
-    return;
-  }
-  Opcode opcode = stmt->GetOpCode();
+void JavaIntrnLowering::ProcessStmt(StmtNode &stmt) {
+  Opcode opcode = stmt.GetOpCode();
   switch (opcode) {
     case OP_dassign:
     case OP_regassign: {
       BaseNode *rhs = nullptr;
       if (opcode == OP_dassign) {
-        DassignNode *dassign = static_cast<DassignNode*>(stmt);
-        rhs = dassign->GetRHS();
+        DassignNode &dassign = static_cast<DassignNode&>(stmt);
+        rhs = dassign.GetRHS();
       } else {
-        RegassignNode *regassign = static_cast<RegassignNode*>(stmt);
-        rhs = regassign->GetRHS();
+        RegassignNode &regassign = static_cast<RegassignNode&>(stmt);
+        rhs = regassign.GetRHS();
       }
       if (rhs != nullptr && rhs->GetOpCode() == OP_intrinsicop) {
         IntrinsicopNode *intrinNode = static_cast<IntrinsicopNode*>(rhs);
         if (intrinNode->GetIntrinsic() == INTRN_JAVA_MERGE) {
-          ProcessJavaIntrnMerge(*stmt, *intrinNode);
+          ProcessJavaIntrnMerge(stmt, *intrinNode);
         }
       }
       break;
     }
     case OP_intrinsiccallwithtypeassigned: {
-      IntrinsiccallNode *intrinCall = static_cast<IntrinsiccallNode*>(stmt);
-      if (intrinCall->GetIntrinsic() == INTRN_JAVA_FILL_NEW_ARRAY) {
-        ProcessJavaIntrnFillNewArray(*intrinCall);
+      IntrinsiccallNode &intrinCall = static_cast<IntrinsiccallNode&>(stmt);
+      if (intrinCall.GetIntrinsic() == INTRN_JAVA_FILL_NEW_ARRAY) {
+        ProcessJavaIntrnFillNewArray(intrinCall);
       }
       break;
     }
@@ -134,7 +131,7 @@ BaseNode *JavaIntrnLowering::JavaIntrnMergeToCvtType(PrimType destType, PrimType
       // or contanst propagation before CG. We may revisit this decision later.
     } else if (GetPrimTypeBitSize(srcType) < GetPrimTypeBitSize(destType)) {
       return builder->CreateExprTypeCvt(OP_cvt, *toType, *fromType, src);
-    } else if (IsConstvalZero(src)) {
+    } else if (IsConstvalZero(*src)) {
       return builder->CreateIntConst(0, destType);
     } else {
       CHECK_FATAL(false, "NYI. Don't know what to do");
diff --git a/src/mpl2mpl/src/muid_replacement.cpp b/src/mpl2mpl/src/muid_replacement.cpp
index f49efebf91e4f415ac7488a1f5061ae8a3930ee6..5b35603785328cecc3ec7dfea9e0c6198453c0a3 100644
--- a/src/mpl2mpl/src/muid_replacement.cpp
+++ b/src/mpl2mpl/src/muid_replacement.cpp
@@ -1151,7 +1151,9 @@ void MUIDReplacement::GenericTables() {
   // When MapleLinker is enabled, MUIDReplacement becomes the last
   // phase that updates the reflection string table, thus the table
   // is emitted here.
-  ReflectionAnalysis::GenStrTab(GetModule());
+  MIRModule *mirModule = GetModule();
+  ASSERT(mirModule != nullptr, "null ptr check!");
+  ReflectionAnalysis::GenStrTab(*mirModule);
   // Replace undef entries in vtab/itab/reflectionMetaData
   for (Klass *klass : klassHierarchy->GetTopoSortedKlasses()) {
     ReplaceDataTable(SUPERCLASSINFO_PREFIX_STR + klass->GetKlassName());
diff --git a/src/mpl2mpl/src/native_stub_func.cpp b/src/mpl2mpl/src/native_stub_func.cpp
index c89437766ae08ec1d3d6a21991f32c5ae79e73f1..56d92dc2363372dea526acda38746b87c60cd7b3 100644
--- a/src/mpl2mpl/src/native_stub_func.cpp
+++ b/src/mpl2mpl/src/native_stub_func.cpp
@@ -673,7 +673,9 @@ void GenericNativeStubFunc::Finish() {
   }
   if (!Options::mapleLinker) {
     // If use maplelinker, we postpone this generation to MUIDReplacement
-    ReflectionAnalysis::GenStrTab(GetModule());
+    MIRModule *mirModule = GetModule();
+    ASSERT(mirModule != nullptr, "null ptr check!");
+    ReflectionAnalysis::GenStrTab(*mirModule);
   }
 }
 }  // namespace maple
diff --git a/src/mpl2mpl/src/reflection_analysis.cpp b/src/mpl2mpl/src/reflection_analysis.cpp
index 24383f1aa2dd373882fd42b7c146056c82150e88..d2adeae4403cf35ee896dec5c5f9100b2d0615f8 100644
--- a/src/mpl2mpl/src/reflection_analysis.cpp
+++ b/src/mpl2mpl/src/reflection_analysis.cpp
@@ -94,21 +94,23 @@ uint32 ReflectionAnalysis::FindOrInsertRepeatString(const std::string &str, bool
   return FirstFindOrInsertRepeatString(str, isHot, hotType);
 }
 
-BaseNode *ReflectionAnalysis::GenClassInfoAddr(BaseNode *obj, MIRBuilder *builder) {
-  GenMetadataType(builder->GetMirModule());
+BaseNode *ReflectionAnalysis::GenClassInfoAddr(BaseNode *obj, MIRBuilder &builder) {
+  MIRModule *mirModule = builder.GetMirModule();
+  ASSERT(mirModule != nullptr, "null ptr check!");
+  GenMetadataType(*mirModule);
   MIRClassType *objectType = static_cast<MIRClassType*>(WKTypes::Util::GetJavaLangObjectType());
   BaseNode *classinfoAddress = nullptr;
   if (objectType != nullptr && objectType->GetKind() != kTypeClassIncomplete) {
-    classinfoAddress = builder->CreateExprIread(*GlobalTables::GetTypeTable().GetRef(),
-                                                *GlobalTables::GetTypeTable().GetOrCreatePointerType(*objectType),
-                                                OBJ_KLASS_FIELDID, obj);
+    classinfoAddress = builder.CreateExprIread(*GlobalTables::GetTypeTable().GetRef(),
+                                               *GlobalTables::GetTypeTable().GetOrCreatePointerType(*objectType),
+                                               OBJ_KLASS_FIELDID, obj);
   } else {
     // If java.lang.Object type is not defined, fall back to use the classinfo struct to retrieve the first field.
     MIRStructType *classMetadataType = static_cast<MIRStructType*>(
         GlobalTables::GetTypeTable().GetTypeFromTyIdx(ReflectionAnalysis::classMetadataTyIdx));
-    classinfoAddress = builder->CreateExprIread(*GlobalTables::GetTypeTable().GetRef(),
-                                                *GlobalTables::GetTypeTable().GetOrCreatePointerType(*classMetadataType),
-                                                METADATA_KLASS_FIELDID, obj);
+    classinfoAddress = builder.CreateExprIread(*GlobalTables::GetTypeTable().GetRef(),
+                                               *GlobalTables::GetTypeTable().GetOrCreatePointerType(*classMetadataType),
+                                               METADATA_KLASS_FIELDID, obj);
   }
   return classinfoAddress;
 }
@@ -177,9 +179,9 @@ uint32 GetFieldModifier(FieldAttrs fa) {
          (static_cast<unsigned char>(fa.GetAttr(FLDATTR_rcweak)) << (kModifierRCWeak - 1));
 }
 
-uint32 GetClassAccessFlags(MIRClassType *classType) {
+uint32 GetClassAccessFlags(MIRClassType &classType) {
   int32 accessFlag = 0;
-  for (MIRPragma *prag : classType->GetPragmVec()) {
+  for (MIRPragma *prag : classType.GetPragmVec()) {
     if (prag->GetKind() == kPragmaClass) {
       MapleVector<MIRPragmaElement*> elemVector = prag->GetElementVector();
       for (MIRPragmaElement *elem : elemVector) {
@@ -191,21 +193,21 @@ uint32 GetClassAccessFlags(MIRClassType *classType) {
       }
     }
   }
-  size_t size = classType->GetInfo().size();
+  size_t size = classType.GetInfo().size();
   for (size_t i = 0; i < size; i++) {
-    if (GlobalTables::GetStrTable().GetStringFromStrIdx(classType->GetInfoElemt(i).first) == kINFOAccessFlags) {
-      return classType->GetInfoElemt(i).second;
+    if (GlobalTables::GetStrTable().GetStringFromStrIdx(classType.GetInfoElemt(i).first) == kINFOAccessFlags) {
+      return classType.GetInfoElemt(i).second;
     }
   }
   return 0;
 }
 
 bool ReflectionAnalysis::IsStaticClass(MIRClassType &classType) {
-  return GetClassAccessFlags(&classType) & 0x00000008;  // #  Modifier_Static 0x00000008;
+  return GetClassAccessFlags(classType) & 0x00000008;  // #  Modifier_Static 0x00000008;
 }
 
 bool ReflectionAnalysis::IsPrivateClass(MIRClassType &classType) {
-  return GetClassAccessFlags(&classType) & 0x00000002;  // #  Modifier_Private 0x00000002;
+  return GetClassAccessFlags(classType) & 0x00000002;  // #  Modifier_Private 0x00000002;
 }
 
 static inline GStrIdx GetOrCreateGStrIdxFromName(const std::string &name) {
@@ -279,8 +281,8 @@ uint32 ReflectionAnalysis::GetTypeNameIdxFromType(MIRType &type, const Klass &kl
     case kTypePointer: {
       MIRType *ptype = static_cast<MIRPtrType*>(&type)->GetPointedType();
       if (ptype->GetKind() == kTypeArray || ptype->GetKind() == kTypeJArray) {
-        CHECK_FATAL(dynamic_cast<MIRJarrayType*>(ptype) != nullptr, "null ptr check");
-        std::string javaName = dynamic_cast<MIRJarrayType*>(ptype)->GetJavaName();
+        CHECK_FATAL(static_cast<MIRJarrayType*>(ptype) != nullptr, "null ptr check");
+        std::string javaName = static_cast<MIRJarrayType*>(ptype)->GetJavaName();
         std::string klassJavaDescriptor;
         NameMangler::DecodeMapleNameToJavaDescriptor(javaName, klassJavaDescriptor);
         typeNameIdx = FindOrInsertReflectString(klassJavaDescriptor);
@@ -498,14 +500,14 @@ void ReflectionAnalysis::CompressHighFrequencyStr(std::string &s) {
   }
 }
 
-bool ReflectionAnalysis::VtableFunc(const MIRFunction *func) const {
-  return (func->GetAttr(FUNCATTR_virtual) && !func->GetAttr(FUNCATTR_private) && !func->GetAttr(FUNCATTR_static));
+bool ReflectionAnalysis::VtableFunc(const MIRFunction &func) const {
+  return (func.GetAttr(FUNCATTR_virtual) && !func.GetAttr(FUNCATTR_private) && !func.GetAttr(FUNCATTR_static));
 }
 
-bool RtRetentionPolicyCheck(const MIRSymbol *clInfo) {
+bool RtRetentionPolicyCheck(const MIRSymbol &clInfo) {
   GStrIdx stridx;
   MIRClassType *annoType =
-      static_cast<MIRClassType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(clInfo->GetTyIdx()));
+      static_cast<MIRClassType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(clInfo.GetTyIdx()));
   for (MIRPragma *p : annoType->GetPragmVec()) {
     if (GlobalTables::GetStrTable().GetStringFromStrIdx(
             GlobalTables::GetTypeTable().GetTypeFromTyIdx(p->GetTyIdx())->GetNameStrIdx()) ==
@@ -529,7 +531,7 @@ int16 ReflectionAnalysis::GetMethodInVtabIndex(const Klass &klass, const MIRFunc
   MIRSymbol *vtableSymbol = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
       GlobalTables::GetStrTable().GetStrIdxFromName(VTAB_PREFIX_STR + klass.GetKlassName()));
   if (klass.IsClass() && vtableSymbol != nullptr) {
-    MIRAggConst *vtableConst = dynamic_cast<MIRAggConst*>(vtableSymbol->GetKonst());
+    MIRAggConst *vtableConst = static_cast<MIRAggConst*>(vtableSymbol->GetKonst());
     for (MIRConstPtr &node : vtableConst->GetConstVec()) {
       if (node->GetKind() == kConstAddrofFunc) {
         MIRAddroffuncConst *addr = static_cast<MIRAddroffuncConst*>(node);
@@ -650,8 +652,8 @@ struct HashCodeComparator {
   }
 };
 
-MIRSymbol *ReflectionAnalysis::GenMethodsMetaData(const Klass *klass) {
-  MIRClassType *classType = klass->GetMIRClassType();
+MIRSymbol *ReflectionAnalysis::GenMethodsMetaData(const Klass &klass) {
+  MIRClassType *classType = klass.GetMIRClassType();
   if (!classType || classType->GetMethods().empty()) {
     return nullptr;
   }
@@ -679,7 +681,7 @@ MIRSymbol *ReflectionAnalysis::GenMethodsMetaData(const Klass *klass) {
     MIRAggConst *newconst = mirModule->GetMemPool()->New<MIRAggConst>(mirModule, methodsInfoType);
     uint32 fieldID = 1;
     uint32 flag = 0;
-    if (!VtableFunc(func)) {
+    if (!VtableFunc(*func)) {
       flag |= kMethodNotVirtual;
     }
     if (func->GetBaseFuncNameWithTypeStrIdx() == finalizeMethod) {
@@ -692,7 +694,7 @@ MIRSymbol *ReflectionAnalysis::GenMethodsMetaData(const Klass *klass) {
     flag |= (hash << kNoHashBits);  // hash 10 bit
     // @method_in_vtable_index
     uint32 methodInVtabIndex = 0u;
-    methodInVtabIndex = static_cast<uint32>(static_cast<int32>(GetMethodInVtabIndex(*klass, *func)));
+    methodInVtabIndex = static_cast<uint32>(static_cast<int32>(GetMethodInVtabIndex(klass, *func)));
     methodInVtabIndex &= 0xFFFF;
     mirBuilder.AddIntFieldConst(*methodsInfoType, *newconst, fieldID++, methodInVtabIndex);
 
@@ -705,7 +707,7 @@ MIRSymbol *ReflectionAnalysis::GenMethodsMetaData(const Klass *klass) {
     // @modifier
     uint32 mod = GetMethodModifier(func->GetFuncAttrs());
     // Add default attribute.
-    if (klass->IsInterface() && !func->GetAttr(FUNCATTR_abstract) && !func->GetAttr(FUNCATTR_static)) {
+    if (klass.IsInterface() && !func->GetAttr(FUNCATTR_abstract) && !func->GetAttr(FUNCATTR_static)) {
       mod |= (1 << (kModDefault));
     }
     mirBuilder.AddIntFieldConst(*methodsInfoType, *newconst, fieldID++, mod);
@@ -736,13 +738,13 @@ MIRSymbol *ReflectionAnalysis::GenMethodsMetaData(const Klass *klass) {
     aggconst->GetConstVec().push_back(newconst);
   }
   MIRSymbol *methodsArraySt =
-      GetOrCreateSymbol(NameMangler::kMethodsInfoPrefixStr + klass->GetKlassName(), arraytype->GetTypeIndex(), true);
+      GetOrCreateSymbol(NameMangler::kMethodsInfoPrefixStr + klass.GetKlassName(), arraytype->GetTypeIndex(), true);
   methodsArraySt->SetStorageClass(kScFstatic);
   methodsArraySt->SetKonst(aggconst);
   return methodsArraySt;
 }
 
-MIRSymbol *ReflectionAnalysis::GenSuperClassMetaData(const Klass *klass, std::list<Klass*> superClassList) {
+MIRSymbol *ReflectionAnalysis::GenSuperClassMetaData(const Klass &klass, std::list<Klass*> superClassList) {
   size_t size = superClassList.size();
   MIRStructType *superclassMetadataType =
       static_cast<MIRStructType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(superclassMetadataTyIdx));
@@ -755,7 +757,7 @@ MIRSymbol *ReflectionAnalysis::GenSuperClassMetaData(const Klass *klass, std::li
     aggconst->GetConstVec().push_back(newconst);
   }
   MIRSymbol *superclassArraySt =
-      GetOrCreateSymbol(SUPERCLASSINFO_PREFIX_STR + klass->GetKlassName(), arrayType->GetTypeIndex(), true);
+      GetOrCreateSymbol(SUPERCLASSINFO_PREFIX_STR + klass.GetKlassName(), arrayType->GetTypeIndex(), true);
   // Direct access to superclassinfo is only possible within a .so.
   superclassArraySt->SetStorageClass(kScFstatic);
   superclassArraySt->SetKonst(aggconst);
@@ -778,8 +780,8 @@ static void ConvertFieldName(std::string &fieldname, bool staticfield) {
   fieldname = NameMangler::DecodeName(fieldname);
 }
 
-MIRSymbol *ReflectionAnalysis::GenFieldsMetaData(const Klass *klass) {
-  MIRClassType *classType = klass->GetMIRClassType();
+MIRSymbol *ReflectionAnalysis::GenFieldsMetaData(const Klass &klass) {
+  MIRClassType *classType = klass.GetMIRClassType();
   FieldVector fields = classType->GetFields();
   FieldVector staticFields = classType->GetStaticFields();
   ASSERT(fields.size() < fields.max_size() - staticFields.size(), "size too large");
@@ -825,7 +827,7 @@ MIRSymbol *ReflectionAnalysis::GenFieldsMetaData(const Klass *klass) {
     }
     j++;
   }
-  ASSERT(i == size, "In class %s: %d fields seen, BUT %d fields declared", klass->GetKlassName().c_str(), i, size);
+  ASSERT(i == size, "In class %s: %d fields seen, BUT %d fields declared", klass.GetKlassName().c_str(), i, size);
   int idx = 0;
   for (auto &fieldinfo : fieldinfoVec) {
     std::vector<uint8> fieldsCompactLeb128Vec;
@@ -858,7 +860,7 @@ MIRSymbol *ReflectionAnalysis::GenFieldsMetaData(const Klass *klass) {
       mirBuilder.AddAddrofFieldConst(*fieldsInfoType, *newconst, fieldID++, *gvarSt);
     } else {
       // Offset of the instance field, we fill the index of fields here and let CG to fill in.
-      MIRClassType *mirClassType = klass->GetMIRClassType();
+      MIRClassType *mirClassType = klass.GetMIRClassType();
       ASSERT(mirClassType != nullptr, "GetMIRClassType() returns null");
       FieldID fldID = mirBuilder.GetStructFieldIDFromNameAndTypeParentFirstFoundInChild(
           *mirClassType, originFieldname.c_str(), fieldP.second.first);
@@ -870,7 +872,7 @@ MIRSymbol *ReflectionAnalysis::GenFieldsMetaData(const Klass *klass) {
     ConvertFieldName(fieldname, staticfield);
     uint32 fieldname32Idx = FindOrInsertReflectString(fieldname);
     uint32 typeNameIdx = 0u;
-    typeNameIdx = GetTypeNameIdxFromType(*ty, *klass, fieldname);
+    typeNameIdx = GetTypeNameIdxFromType(*ty, klass, fieldname);
     // @flag
     uint16 hash = GetFieldHash(fieldHashvec, fieldP);
     uint16 flag = (hash << kNoHashBits);  // Hash 10 bit.
@@ -890,13 +892,13 @@ MIRSymbol *ReflectionAnalysis::GenFieldsMetaData(const Klass *klass) {
     uint32 annotationIdx = GetAnnoCstrIndex(idxNumMap, annoArr);
     mirBuilder.AddIntFieldConst(*fieldsInfoType, *newconst, fieldID++, annotationIdx);
     //  @declaring class
-    MIRSymbol *dklassSt = GetOrCreateSymbol(CLASSINFO_PREFIX_STR + klass->GetKlassName(), classMetadataTyIdx);
+    MIRSymbol *dklassSt = GetOrCreateSymbol(CLASSINFO_PREFIX_STR + klass.GetKlassName(), classMetadataTyIdx);
     mirBuilder.AddAddrofFieldConst(*fieldsInfoType, *newconst, fieldID++, *dklassSt);
     aggconst->GetConstVec().push_back(newconst);
     idx++;
   }
   MIRSymbol *fieldsArraySt =
-      GetOrCreateSymbol(NameMangler::kFieldsInfoPrefixStr + klass->GetKlassName(), arraytype->GetTypeIndex(), true);
+      GetOrCreateSymbol(NameMangler::kFieldsInfoPrefixStr + klass.GetKlassName(), arraytype->GetTypeIndex(), true);
   fieldsArraySt->SetStorageClass(kScFstatic);
   fieldsArraySt->SetKonst(aggconst);
   return fieldsArraySt;
@@ -999,11 +1001,12 @@ std::string ReflectionAnalysis::GetArrayValue(MapleVector<MIRPragmaElement*> sub
       annoArray += oss4.str();
       annoArray += '!';
       for (MIRPragmaElement *annoElem : subsubelemVector) {
+        ASSERT(annoElem != nullptr, "null ptr check!");
         annoArray += GlobalTables::GetStrTable().GetStringFromStrIdx(annoElem->GetNameStrIdx());
         annoArray += '!';
         annoArray += std::to_string(annoElem->GetType());
         annoArray += '!';
-        annoArray += GetAnnoValueWithoutArray(annoElem);
+        annoArray += GetAnnoValueWithoutArray(*annoElem);
         annoArray += '!';
       }
     } else if (NeedFourBytes(arrayElem->GetType())) {
@@ -1050,24 +1053,24 @@ std::string ReflectionAnalysis::GetArrayValue(MapleVector<MIRPragmaElement*> sub
   return annoArray;
 }
 
-std::string ReflectionAnalysis::GetAnnoValueWithoutArray(const MIRPragmaElement *annoElem) {
+std::string ReflectionAnalysis::GetAnnoValueWithoutArray(const MIRPragmaElement &annoElem) {
   std::ostringstream oss;
   std::string tmp, annoArray;
   GStrIdx stridx;
-  if (NeedFourBytes(annoElem->GetType())) {
-    annoArray += std::to_string(annoElem->GetI32Val());
-  } else if (annoElem->GetType() == kValueFloat) {
-    annoArray += std::to_string(annoElem->GetFloatVal());
-  } else if (annoElem->GetType() == kValueDouble) {
-    annoArray += std::to_string(annoElem->GetDoubleVal());
-  } else if (annoElem->GetType() == kValueLong) {
-    annoArray += std::to_string(annoElem->GetI64Val());
-  } else if (annoElem->GetType() == kValueBoolean || annoElem->GetType() == kValueChar) {
-    annoArray += std::to_string(annoElem->GetU64Val());
-  } else if (annoElem->GetType() == kValueArray) {
-    annoArray += GetArrayValue(annoElem->GetSubElemVec());
+  if (NeedFourBytes(annoElem.GetType())) {
+    annoArray += std::to_string(annoElem.GetI32Val());
+  } else if (annoElem.GetType() == kValueFloat) {
+    annoArray += std::to_string(annoElem.GetFloatVal());
+  } else if (annoElem.GetType() == kValueDouble) {
+    annoArray += std::to_string(annoElem.GetDoubleVal());
+  } else if (annoElem.GetType() == kValueLong) {
+    annoArray += std::to_string(annoElem.GetI64Val());
+  } else if (annoElem.GetType() == kValueBoolean || annoElem.GetType() == kValueChar) {
+    annoArray += std::to_string(annoElem.GetU64Val());
+  } else if (annoElem.GetType() == kValueArray) {
+    annoArray += GetArrayValue(annoElem.GetSubElemVec());
   } else {
-    stridx.SetIdx(annoElem->GetU64Val());
+    stridx.SetIdx(annoElem.GetU64Val());
     annoArray += GlobalTables::GetStrTable().GetStringFromStrIdx(stridx);
   }
   return annoArray;
@@ -1087,16 +1090,16 @@ int64 ReflectionAnalysis::GetHashIndex(const std::string &strname) {
   return BKDRHash(strname, hashSeed);
 }
 
-void ReflectionAnalysis::GenHotClassNameString(const Klass *klass) {
-  MIRClassType *classType = klass->GetMIRClassType();
+void ReflectionAnalysis::GenHotClassNameString(const Klass &klass) {
+  MIRClassType *classType = klass.GetMIRClassType();
   if (!classType->IsLocal()) {
     // External class.
     return;
   }
-  if (!klass->HasNativeMethod()) {
+  if (!klass.HasNativeMethod()) {
     return;  // It's a cold class, we don't care.
   }
-  std::string klassName = klass->GetKlassName();
+  std::string klassName = klass.GetKlassName();
   std::string klassJavaDescriptor;
   NameMangler::DecodeMapleNameToJavaDescriptor(klassName, klassJavaDescriptor);
   (void)ReflectionAnalysis::FindOrInsertRepeatString(klassJavaDescriptor, true);  // Always used.
@@ -1125,9 +1128,8 @@ MIRSymbol *ReflectionAnalysis::GetClinitFuncSymbol(const Klass &klass) {
   return clinitFuncSymbol;
 }
 
-void ReflectionAnalysis::GenClassMetaData(Klass *klass) {
-  ASSERT(klass != nullptr, "null ptr check!");
-  MIRClassType *classType = klass->GetMIRClassType();
+void ReflectionAnalysis::GenClassMetaData(Klass &klass) {
+  MIRClassType *classType = klass.GetMIRClassType();
   ASSERT(classType != nullptr, "null ptr check!");
   if (!classType->IsLocal()) {
     // External class.
@@ -1135,7 +1137,7 @@ void ReflectionAnalysis::GenClassMetaData(Klass *klass) {
   }
 
 
-  std::string klassName = klass->GetKlassName();
+  std::string klassName = klass.GetKlassName();
   reflectionMuidStr += klassName;
   std::string klassJavaDescriptor;
   NameMangler::DecodeMapleNameToJavaDescriptor(klassName, klassJavaDescriptor);
@@ -1155,7 +1157,7 @@ void ReflectionAnalysis::GenClassMetaData(Klass *klass) {
   // @iFields: All instance fields.
   int numOfFields = 0;
   bool hasAdded = false;
-  if (klass->GetKlassName() == NameMangler::GetInternalNameLiteral(kJavaLangObjectStr)) {
+  if (klass.GetKlassName() == NameMangler::GetInternalNameLiteral(kJavaLangObjectStr)) {
     const GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
         kFieldsInfoPrefixStr + NameMangler::GetInternalNameLiteral(kJavaLangObjectStr));
     MIRSymbol *fieldsSt = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(stridx);
@@ -1187,7 +1189,7 @@ void ReflectionAnalysis::GenClassMetaData(Klass *klass) {
   // @superclass: Super class and a list of implemented interfaces.
   std::list<Klass*> superClassList;
   bool missingSuper = false;
-  for (Klass *superClass : klass->GetSuperKlasses()) {
+  for (Klass *superClass : klass.GetSuperKlasses()) {
     superClassList.push_back(superClass);
   }
   for (TyIdx const kTyIdx : classType->GetInerfaceImplemented()) {
@@ -1204,7 +1206,7 @@ void ReflectionAnalysis::GenClassMetaData(Klass *klass) {
     }
   }
   if (missingSuper) {
-    LogInfo::MapleLogger(kLlErr) << "Error: Missing interface for " << klass->GetKlassName() << std::endl;
+    LogInfo::MapleLogger(kLlErr) << "Error: Missing interface for " << klass.GetKlassName() << std::endl;
     CHECK_FATAL(0, "Missing interface");
   }
   size_t superClassSize = superClassList.size();
@@ -1223,14 +1225,14 @@ void ReflectionAnalysis::GenClassMetaData(Klass *klass) {
   // Do annotation.
   std::string annoArray;
   std::map<int, int> idxNumMap;
-  GeneAnnotation(idxNumMap, annoArray, *classType, kPragmaClass, klass->GetKlassName(), invalidIdx);
+  GeneAnnotation(idxNumMap, annoArray, *classType, kPragmaClass, klass.GetKlassName(), invalidIdx);
   bool isAnonymous = IsAnonymousClass(annoArray);
-  CheckPrivateInnerAndNoSubClass(*klass, annoArray);
+  CheckPrivateInnerAndNoSubClass(klass, annoArray);
 
 #ifndef USE_32BIT_REF
   // @flag
   // Array class and primitive class is not generated by compiler.
-  uint32 flag = klass->GetFlag(kClassHasFinalizer | CLASS_REFERENCE | kClassFinalizerreferenceSentinel);
+  uint32 flag = klass.GetFlag(kClassHasFinalizer | CLASS_REFERENCE | kClassFinalizerreferenceSentinel);
   flag = isAnonymous ? (flag | kClassIsanonymousclass) : flag;
   mirBuilder.AddIntFieldConst(*classMetadataROType, *newconst, fieldID++, flag);
   // @numofsuperclasses
@@ -1240,19 +1242,19 @@ void ReflectionAnalysis::GenClassMetaData(Klass *klass) {
   mirBuilder.AddIntFieldConst(*classMetadataROType, *newconst, fieldID++, 0);
 #endif  // USE_32BIT_REF
   // @modifier: For class fill ClassAccessFlags.
-  uint32 modifier = GetClassAccessFlags(classType);
+  uint32 modifier = GetClassAccessFlags(*classType);
   mirBuilder.AddIntFieldConst(*classMetadataROType, *newconst, fieldID++, modifier);
   // @annotation: Set annotation field.
   SetAnnoFieldConst(*classMetadataROType, *newconst, fieldID++, idxNumMap, annoArray);
   // @ClinitFuncAddr
-  MIRSymbol *clinitFuncSym = GetClinitFuncSymbol(*klass);
+  MIRSymbol *clinitFuncSym = GetClinitFuncSymbol(klass);
   if (clinitFuncSym != nullptr) {
     mirBuilder.AddAddroffuncFieldConst(*classMetadataROType, *newconst, fieldID++, *clinitFuncSym);
   } else {
     mirBuilder.AddIntFieldConst(*classMetadataROType, *newconst, fieldID++, 0);
   }
   MIRSymbol *classMetadataROSymbolType =
-      GetOrCreateSymbol(CLASSINFO_RO_PREFIX_STR + klass->GetKlassName(), classMetadataRoTyIdx, true);
+      GetOrCreateSymbol(CLASSINFO_RO_PREFIX_STR + klass.GetKlassName(), classMetadataRoTyIdx, true);
   classMetadataROSymbolType->SetStorageClass(kScFstatic);
   classMetadataROSymbolType->SetKonst(newconst);
   // Class Metadata definition start here.
@@ -1271,7 +1273,7 @@ void ReflectionAnalysis::GenClassMetaData(Klass *klass) {
 #ifdef USE_32BIT_REF
   // @flag
   // Array class and primitive class is not generated by compiler.
-  uint32 flag = klass->GetFlag(kClassHasFinalizer | CLASS_REFERENCE | kClassFinalizerreferenceSentinel);
+  uint32 flag = klass.GetFlag(kClassHasFinalizer | CLASS_REFERENCE | kClassFinalizerreferenceSentinel);
   flag = isAnonymous ? (flag | kClassIsanonymousclass) : flag;
   mirBuilder.AddIntFieldConst(*classMetadataType, *newconst, fieldID++, flag);
   // @numofsuperclasses
@@ -1279,7 +1281,7 @@ void ReflectionAnalysis::GenClassMetaData(Klass *klass) {
   mirBuilder.AddIntFieldConst(*classMetadataType, *newconst, fieldID++, superClassSize);
 #endif  // USE_32BIT_REF
   // @itab
-  GStrIdx strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(ITAB_PREFIX_STR + klass->GetKlassName());
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(ITAB_PREFIX_STR + klass.GetKlassName());
   if (strIdx != 0) {
     MIRSymbol *itableSymbolType = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx);
     mirBuilder.AddAddrofFieldConst(*classMetadataType, *newconst, fieldID++, *itableSymbolType);
@@ -1287,7 +1289,7 @@ void ReflectionAnalysis::GenClassMetaData(Klass *klass) {
     mirBuilder.AddIntFieldConst(*classMetadataType, *newconst, fieldID++, 0);
   }
   // @vtab
-  strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(VTAB_PREFIX_STR + klass->GetKlassName());
+  strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(VTAB_PREFIX_STR + klass.GetKlassName());
   if (strIdx != 0) {
     MIRSymbol *vtableSymbolType = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx);
     mirBuilder.AddAddrofFieldConst(*classMetadataType, *newconst, fieldID++, *vtableSymbolType);
@@ -1295,9 +1297,9 @@ void ReflectionAnalysis::GenClassMetaData(Klass *klass) {
     mirBuilder.AddIntFieldConst(*classMetadataType, *newconst, fieldID++, 0);
   }
   // @gctib
-  MIRSymbol *gctibSt = GetOrCreateSymbol(GCTIB_PREFIX_STR + klass->GetKlassName(),
+  MIRSymbol *gctibSt = GetOrCreateSymbol(GCTIB_PREFIX_STR + klass.GetKlassName(),
                                          GlobalTables::GetTypeTable().GetVoidPtr()->GetTypeIndex(), false);
-  if (klass->GetKlassName() != NameMangler::GetInternalNameLiteral(kJavaLangObjectStr)) {
+  if (klass.GetKlassName() != NameMangler::GetInternalNameLiteral(kJavaLangObjectStr)) {
     // Direct access to gctib is only possible within a .so, for most classes.
     gctibSt->SetStorageClass(kScFstatic);
   }
@@ -1306,7 +1308,7 @@ void ReflectionAnalysis::GenClassMetaData(Klass *klass) {
   mirBuilder.AddAddrofFieldConst(*classMetadataType, *newconst, fieldID++, *classMetadataROSymbolType);
   // Set default value to class initialization state.
   // If this class and its parents do not have clinit, we do not clinit-check for this class.
-  if (klassh->NeedClinitCheckRecursively(*klass)) {
+  if (klassh->NeedClinitCheckRecursively(klass)) {
     MIRType *ptrType = GlobalTables::GetTypeTable().GetPtr();
     MIRSymbol *classInitProtectRegion = mirBuilder.GetOrCreateSymbol(
         ptrType->GetTypeIndex(), kClassInitProtectRegionStr, kStVar, kScExtern, nullptr, kScopeGlobal, true);
@@ -1319,7 +1321,7 @@ void ReflectionAnalysis::GenClassMetaData(Klass *klass) {
     mirBuilder.AddAddrofFieldConst(*classMetadataType, *newconst, fieldID++, *classInfo);
   }
   // Finally generate class metadata here.
-  MIRSymbol *classSt = GetOrCreateSymbol(CLASSINFO_PREFIX_STR + klass->GetKlassName(), classMetadataTyIdx, true);
+  MIRSymbol *classSt = GetOrCreateSymbol(CLASSINFO_PREFIX_STR + klass.GetKlassName(), classMetadataTyIdx, true);
   classSt->SetKonst(newconst);
   classTab.push_back(classSt);
 }
@@ -1365,7 +1367,7 @@ void ReflectionAnalysis::GeneAnnotation(std::map<int, int> &idxNumMap, std::stri
       MIRSymbol *clInfo = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
           GlobalTables::GetTypeTable().GetTypeFromTyIdx(prag->GetTyIdx())->GetNameStrIdx());
       if (clInfo != nullptr) {
-        if (!RtRetentionPolicyCheck(clInfo)) {
+        if (!RtRetentionPolicyCheck(*clInfo)) {
           continue;
         }
       }
@@ -1449,12 +1451,12 @@ bool ReflectionAnalysis::IsAnonymousClass(const std::string &annotationString) {
   return false;
 }
 
-TyIdx ReflectionAnalysis::GenMetaStructType(MIRModule *mirModule, MIRStructType &metatype, const std::string &str) {
+TyIdx ReflectionAnalysis::GenMetaStructType(MIRModule &mirModule, MIRStructType &metatype, const std::string &str) {
   const GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(str);
   TyIdx tyidx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&metatype);
   // Global?
-  mirModule->GetTypeNameTab()->SetGStrIdxToTyIdx(stridx, tyidx);
-  mirModule->PushbackTypeDefOrder(stridx);
+  mirModule.GetTypeNameTab()->SetGStrIdxToTyIdx(stridx, tyidx);
+  mirModule.PushbackTypeDefOrder(stridx);
   const size_t globalTypeTableSize = GlobalTables::GetTypeTable().GetTypeTable().size();
   CHECK_FATAL(globalTypeTableSize > tyidx.GetIdx(), "null ptr check");
   if (GlobalTables::GetTypeTable().GetTypeTable()[tyidx.GetIdx()]->GetNameStrIdx() == 0) {
@@ -1463,7 +1465,7 @@ TyIdx ReflectionAnalysis::GenMetaStructType(MIRModule *mirModule, MIRStructType
   return tyidx;
 }
 
-MIRType *ReflectionAnalysis::GetRefFieldType(MIRBuilder *mirbuilder) {
+MIRType *ReflectionAnalysis::GetRefFieldType(MIRBuilder &mirbuilder) {
 #ifdef USE_32BIT_REF
   return GlobalTables::GetTypeTable().GetUInt32();
 #else
@@ -1471,13 +1473,11 @@ MIRType *ReflectionAnalysis::GetRefFieldType(MIRBuilder *mirbuilder) {
 #endif  // USE_32BIT_REF
 }
 
-void ReflectionAnalysis::GenMetadataType(MIRModule *mirModule) {
-  if (classMetadataTyIdx != 0)
-  // Types have been generated.
-  {
+void ReflectionAnalysis::GenMetadataType(MIRModule &mirModule) {
+  if (classMetadataTyIdx != 0) { // Types have been generated.
     return;
   }
-  MIRBuilder &mirBuilder = *(mirModule->GetMIRBuilder());
+  MIRBuilder &mirBuilder = *(mirModule.GetMIRBuilder());
   // ClassMetaType
   MIRType *typeU8 = GlobalTables::GetTypeTable().GetUInt8();
   MIRType *typeU16 = GlobalTables::GetTypeTable().GetUInt16();
@@ -1487,7 +1487,7 @@ void ReflectionAnalysis::GenMetadataType(MIRModule *mirModule) {
   MIRType *typeU64 = GlobalTables::GetTypeTable().GetUInt64();
   MIRType *typeVoidPtr = GlobalTables::GetTypeTable().GetVoidPtr();
   MIRStructType classMetadataType(kTypeStruct);
-  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kShadowStr, *GetRefFieldType(&mirBuilder));
+  GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kShadowStr, *GetRefFieldType(mirBuilder));
   GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kMonitorStr, *typeI32);
   GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kClassloaderStr, *typeU16);
   GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kObjsizeStr, *typeU16);
@@ -1563,7 +1563,7 @@ void ReflectionAnalysis::GenMetadataType(MIRModule *mirModule) {
 #endif  // USE_32BIT_REF
   GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kFieldnameStr, *typeU32);
   GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kAnnotationStr, *typeU32);
-  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kDeclaringclassStr, *GetRefFieldType(&mirBuilder));
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kDeclaringclassStr, *GetRefFieldType(mirBuilder));
   fieldsInfoTyIdx = GenMetaStructType(mirModule, fieldInfoType, kFieldInfoTypeName);
   // FieldInfoType Compact.
   MIRStructType fieldInfoCompactType(kTypeStruct);
@@ -1625,17 +1625,17 @@ static void ReflectionAnalysisGenStrTab(MIRModule *mirModule, const std::string
   strtabSt->SetKonst(strtabAggconst);
 }
 
-void ReflectionAnalysis::GenStrTab(MIRModule *mirModule) {
+void ReflectionAnalysis::GenStrTab(MIRModule &mirModule) {
   // Hot string tab.
-  std::string hotStrtabName = NameMangler::kReflectionStartHotStrtabPrefixStr + mirModule->GetFileNameAsPostfix();
-  ReflectionAnalysisGenStrTab(mirModule, strTabStartHot, hotStrtabName);
-  hotStrtabName = NameMangler::kReflectionBothHotStrTabPrefixStr + mirModule->GetFileNameAsPostfix();
-  ReflectionAnalysisGenStrTab(mirModule, strTabBothHot, hotStrtabName);
-  hotStrtabName = NameMangler::kReflectionRunHotStrtabPrefixStr + mirModule->GetFileNameAsPostfix();
-  ReflectionAnalysisGenStrTab(mirModule, strTabRunHot, hotStrtabName);
+  std::string hotStrtabName = NameMangler::kReflectionStartHotStrtabPrefixStr + mirModule.GetFileNameAsPostfix();
+  ReflectionAnalysisGenStrTab(&mirModule, strTabStartHot, hotStrtabName);
+  hotStrtabName = NameMangler::kReflectionBothHotStrTabPrefixStr + mirModule.GetFileNameAsPostfix();
+  ReflectionAnalysisGenStrTab(&mirModule, strTabBothHot, hotStrtabName);
+  hotStrtabName = NameMangler::kReflectionRunHotStrtabPrefixStr + mirModule.GetFileNameAsPostfix();
+  ReflectionAnalysisGenStrTab(&mirModule, strTabRunHot, hotStrtabName);
   // Cold string tab.
-  std::string strtabName = NameMangler::kReflectionStrtabPrefixStr + mirModule->GetFileNameAsPostfix();
-  ReflectionAnalysisGenStrTab(mirModule, strTab, strtabName);
+  std::string strtabName = NameMangler::kReflectionStrtabPrefixStr + mirModule.GetFileNameAsPostfix();
+  ReflectionAnalysisGenStrTab(&mirModule, strTab, strtabName);
 }
 
 void ReflectionAnalysis::MarkWeakMethods() {
@@ -1662,17 +1662,18 @@ void ReflectionAnalysis::MarkWeakMethods() {
 
 void ReflectionAnalysis::Run() {
   MarkWeakMethods();
-  GenMetadataType(mirModule);
+  GenMetadataType(*mirModule);
   const MapleVector<Klass*> &klasses = klassh->GetTopoSortedKlasses();
   if (raDebug) {
     LogInfo::MapleLogger(kLlErr) << "========= Gen Class: Total " << klasses.size() << " ========" << std::endl;
   }
   // Cluster classname together in reflection string table to improve the locality.
   for (Klass *klass : klasses) {
-    GenHotClassNameString(klass);
+    ASSERT(klass != nullptr, "null ptr check!");
+    GenHotClassNameString(*klass);
   }
   for (Klass *klass : klasses) {
-    GenClassMetaData(klass);
+    GenClassMetaData(*klass);
     // Collect the full information about the classmetadata.
     reflectionMuidStr = GetMUID(reflectionMuidStr).ToStr();
   }
diff --git a/src/mpl2mpl/src/vtable_analysis.cpp b/src/mpl2mpl/src/vtable_analysis.cpp
index 2dfe874953efcb554d444c9ed3fa3c8c8d289b41..715fe32d23c1000a0780807edfdaa6e58fbe0eef 100644
--- a/src/mpl2mpl/src/vtable_analysis.cpp
+++ b/src/mpl2mpl/src/vtable_analysis.cpp
@@ -32,11 +32,12 @@ VtableAnalysis::VtableAnalysis(MIRModule *mod, KlassHierarchy *kh, bool dump) :
   zeroConst = GetModule()->GetMemPool()->New<MIRIntConst>(0, voidPtrType);
   oneConst = GetModule()->GetMemPool()->New<MIRIntConst>(1, voidPtrType);
   for (Klass *klass : klassHierarchy->GetTopoSortedKlasses()) {
-    GenVtableList(klass);
+    ASSERT(klass != nullptr, "null ptr check!");
+    GenVtableList(*klass);
     if (klass->IsClass() && klass->GetMIRStructType()->IsLocal()) {
       // We generate itable/vtable definition in the same place where the class is defined
-      GenVtableDefinition(klass);
-      GenItableDefinition(klass);
+      GenVtableDefinition(*klass);
+      GenItableDefinition(*klass);
     }
     if (trace) {
       DumpVtableList(klass);
@@ -44,62 +45,65 @@ VtableAnalysis::VtableAnalysis(MIRModule *mod, KlassHierarchy *kh, bool dump) :
   }
 }
 
-bool VtableAnalysis::IsVtableCandidate(const MIRFunction *func) const {
-  return (func->GetAttr(FUNCATTR_virtual) && !func->GetAttr(FUNCATTR_private) && !func->GetAttr(FUNCATTR_static));
+bool VtableAnalysis::IsVtableCandidate(const MIRFunction &func) const {
+  return (func.GetAttr(FUNCATTR_virtual) && !func.GetAttr(FUNCATTR_private) && !func.GetAttr(FUNCATTR_static));
 }
 
 // Return true if virtual functions can be set override relationship cross package
-bool VtableAnalysis::CheckOverrideForCrossPackage(const MIRFunction *baseMethod, const MIRFunction *currMethod) const {
-  const std::string &baseClassName = baseMethod->GetBaseClassName();
+bool VtableAnalysis::CheckOverrideForCrossPackage(const MIRFunction &baseMethod, const MIRFunction &currMethod) const {
+  const std::string &baseClassName = baseMethod.GetBaseClassName();
   size_t basePos = baseClassName.rfind(NameMangler::kPackageNameSplitterStr);
   std::string basePackageName = (basePos != std::string::npos) ? baseClassName.substr(0, basePos) : "";
-  const std::string &currClassName = currMethod->GetBaseClassName();
+  const std::string &currClassName = currMethod.GetBaseClassName();
   size_t currPos = currClassName.rfind(NameMangler::kPackageNameSplitterStr);
   std::string currPackageName = (currPos != std::string::npos) ? currClassName.substr(0, currPos) : "";
   // For the corss package inheritance, only if the base func is declared
   // as either 'public' or 'protected', we shall set override relationship.
-  return ((currPackageName == basePackageName) || baseMethod->GetAttr(FUNCATTR_public) ||
-          baseMethod->GetAttr(FUNCATTR_protected));
+  return ((currPackageName == basePackageName) || baseMethod.GetAttr(FUNCATTR_public) ||
+          baseMethod.GetAttr(FUNCATTR_protected));
 }
 
 // If the method is not in method_table yet, add it in, otherwise update it.
 // Note: the method to add should already pass VtableCandidate test
-void VtableAnalysis::AddMethodToTable(MethodPtrVector &methodTable, MethodPair *methodpair) {
-  MIRFunction *method = builder->GetFunctionFromStidx(methodpair->first);
+void VtableAnalysis::AddMethodToTable(MethodPtrVector &methodTable, MethodPair &methodpair) {
+  MIRFunction *method = builder->GetFunctionFromStidx(methodpair.first);
+  ASSERT(method != nullptr, "null ptr check!");
   GStrIdx stridx = method->GetBaseFuncNameWithTypeStrIdx();
   for (size_t i = 0; i < methodTable.size(); i++) {
     MIRFunction *currFunc = builder->GetFunctionFromStidx(methodTable[i]->first);
+    ASSERT(currFunc != nullptr, "null ptr check!");
     GStrIdx currStridx = currFunc->GetBaseFuncNameWithTypeStrIdx();
     if (stridx == currStridx) {
-      if (CheckOverrideForCrossPackage(currFunc, method)) {
+      if (CheckOverrideForCrossPackage(*currFunc, *method)) {
         // only update when it's not an abstract method
         if (!method->IsAbstract()) {
-          methodTable[i] = methodpair;
+          methodTable[i] = &methodpair;
         }
         return;
       }
     }
   }
-  methodTable.push_back(methodpair);
+  methodTable.push_back(&methodpair);
 }
 
-void VtableAnalysis::GenVtableList(const Klass *klass) {
-  if (klass->IsInterface()) {
-    MIRInterfaceType *iType = klass->GetMIRInterfaceType();
+void VtableAnalysis::GenVtableList(const Klass &klass) {
+  if (klass.IsInterface()) {
+    MIRInterfaceType *iType = klass.GetMIRInterfaceType();
     // add in methods from parent interfaces, note interfaces can declare/define same methods
-    for (const Klass *parentKlass : klass->GetSuperKlasses()) {
+    for (const Klass *parentKlass : klass.GetSuperKlasses()) {
       MIRInterfaceType *parentInterfaceType = parentKlass->GetMIRInterfaceType();
       for (MethodPair *methodPair : parentInterfaceType->GetVTableMethods()) {
-        AddMethodToTable(iType->GetVTableMethods(), methodPair);
+        ASSERT(methodPair != nullptr, "null ptr check!");
+        AddMethodToTable(iType->GetVTableMethods(), *methodPair);
       }
     }
     // add in methods from this interface, note it can override methods of parents
     for (MethodPair &methodPair : iType->GetMethods()) {
-      AddMethodToTable(iType->GetVTableMethods(), &methodPair);
+      AddMethodToTable(iType->GetVTableMethods(), methodPair);
     }
   } else {  // it's a class
-    MIRClassType *curType = klass->GetMIRClassType();
-    Klass *superKlass = klass->GetSuperKlass();
+    MIRClassType *curType = klass.GetMIRClassType();
+    Klass *superKlass = klass.GetSuperKlass();
     // prepare vtable_methods
     // first is vtable from parents. since it's single inheritance, we copy it directly
     if (superKlass != nullptr) {
@@ -137,8 +141,9 @@ void VtableAnalysis::GenVtableList(const Klass *klass) {
     // then methods defined in this class
     for (MethodPair &methodpair : curType->GetMethods()) {
       MIRFunction *curMethod = builder->GetFunctionFromStidx(methodpair.first);
-      if (IsVtableCandidate(curMethod)) {
-        AddMethodToTable(curType->GetVTableMethods(), &methodpair);
+      ASSERT(curMethod != nullptr, "null ptr check!");
+      if (IsVtableCandidate(*curMethod)) {
+        AddMethodToTable(curType->GetVTableMethods(), methodpair);
       }
       // Optimization: mark private methods as local
       if (curType->IsLocal() && curMethod->IsPrivate() && !curMethod->IsConstructor()) {
@@ -153,9 +158,10 @@ void VtableAnalysis::GenVtableList(const Klass *klass) {
   }
 }
 
-void VtableAnalysis::GenVtableDefinition(const Klass *klass) {
-  MIRStructType *curType = klass->GetMIRStructType();
+void VtableAnalysis::GenVtableDefinition(const Klass &klass) {
+  MIRStructType *curType = klass.GetMIRStructType();
   MIRAggConst *newconst = GetModule()->GetMemPool()->New<MIRAggConst>(GetModule(), voidPtrType);
+  ASSERT(newconst != nullptr, "null ptr check!");
   for (MethodPair *methodPair : curType->GetVTableMethods()) {
     MIRFunction *vtabMethod = builder->GetFunctionFromStidx(methodPair->first);
     AddroffuncNode *addrofFuncNode = builder->CreateExprAddroffunc(vtabMethod->GetPuidx(), GetModule()->GetMemPool());
@@ -173,30 +179,31 @@ void VtableAnalysis::GenVtableDefinition(const Klass *klass) {
   if (newconst->GetConstVec().empty()) {
     newconst->GetConstVec().push_back(zeroConst);
   }
-  GenTableSymbol(VTAB_PREFIX_STR, klass->GetKlassName(), newconst);
+  GenTableSymbol(VTAB_PREFIX_STR, klass.GetKlassName(), *newconst);
 }
 
-std::string VtableAnalysis::DecodeBaseNameWithType(const MIRFunction *func) {
-  std::string baseName = NameMangler::DecodeName(func->GetBaseFuncName().c_str());
-  std::string signatureName = NameMangler::DecodeName(func->GetSignature().c_str());
+std::string VtableAnalysis::DecodeBaseNameWithType(const MIRFunction &func) {
+  std::string baseName = NameMangler::DecodeName(func.GetBaseFuncName().c_str());
+  std::string signatureName = NameMangler::DecodeName(func.GetSignature().c_str());
   ReflectionAnalysis::ConvertMethodSig(signatureName);
   std::string baseNameWithType = baseName + "|" + signatureName;
   return baseNameWithType;
 }
 
-void VtableAnalysis::GenItableDefinition(const Klass *klass) {
-  MIRStructType *curType = klass->GetMIRStructType();
+void VtableAnalysis::GenItableDefinition(const Klass &klass) {
+  MIRStructType *curType = klass.GetMIRStructType();
   std::set<GStrIdx> signatureVisited;
   std::vector<MIRFunction*> firstItabVec(kItabFirstHashSize, nullptr);
   std::vector<bool> firstConflictFlag(kItabFirstHashSize, false);
   std::vector<MIRFunction*> firstConflictList;
   bool itabContainsMethod = false;
-  for (Klass *implInterface : klass->GetImplInterfaces()) {
+  for (Klass *implInterface : klass.GetImplInterfaces()) {
     CHECK_FATAL(implInterface->IsInterface(), "implInterface must be interface");
     MIRInterfaceType *interfaceType = implInterface->GetMIRInterfaceType();
     for (MethodPair &methodPair : interfaceType->GetMethods()) {
       MIRFunction *interfaceMethod = builder->GetFunctionFromStidx(methodPair.first);
-      int64 hashCode = GetHashIndex(DecodeBaseNameWithType(interfaceMethod).c_str());
+      ASSERT(interfaceMethod != nullptr, "null ptr check!");
+      int64 hashCode = GetHashIndex(DecodeBaseNameWithType(*interfaceMethod).c_str());
       GStrIdx interfaceMethodStridx = interfaceMethod->GetBaseFuncNameWithTypeStrIdx();
       if (signatureVisited.find(interfaceMethodStridx) == signatureVisited.end()) {
         signatureVisited.insert(interfaceMethodStridx);
@@ -215,7 +222,7 @@ void VtableAnalysis::GenItableDefinition(const Klass *klass) {
         }
       }
       CHECK_FATAL(vtabMethod, "Interface method %s is not implemented in class %s", interfaceMethod->GetName().c_str(),
-                  klass->GetKlassName().c_str());
+                  klass.GetKlassName().c_str());
       if (!vtabMethod->IsAbstract()) {
         itabContainsMethod = true;
         if (!firstItabVec[hashCode] && !firstConflictFlag[hashCode]) {
@@ -241,7 +248,8 @@ void VtableAnalysis::GenItableDefinition(const Klass *klass) {
   std::vector<MIRFunction*> secondConflictList;
   uint32 count = 0;
   for (MIRFunction *func : firstConflictList) {
-    uint32 secondHashCode = GetSecondHashIndex(DecodeBaseNameWithType(func).c_str());
+    ASSERT(func != nullptr, "null ptr check!");
+    uint32 secondHashCode = GetSecondHashIndex(DecodeBaseNameWithType(*func).c_str());
     if (!secondItab[secondHashCode] && !secondConflictFlag[secondHashCode]) {
       secondItab[secondHashCode] = func;
       count++;
@@ -266,6 +274,7 @@ void VtableAnalysis::GenItableDefinition(const Klass *klass) {
   }
   // Create the first-level itable, which is directly accessed as an array
   MIRAggConst *firstItabEmitArray = GetModule()->GetMemPool()->New<MIRAggConst>(GetModule(), voidPtrType);
+  ASSERT(firstItabEmitArray != nullptr, "null ptr check!");
   for (MIRFunction *func : firstItabVec) {
     if (func != nullptr) {
       firstItabEmitArray->GetConstVec().push_back(
@@ -295,24 +304,25 @@ void VtableAnalysis::GenItableDefinition(const Klass *klass) {
       }
     }
     for (MIRFunction *func : secondConflictList) {
-      const std::string &signatureName = DecodeBaseNameWithType(func);
+      ASSERT(func !=  nullptr, "null ptr check!");
+      const std::string &signatureName = DecodeBaseNameWithType(*func);
       uint32 nameIdx = ReflectionAnalysis::FindOrInsertRepeatString(signatureName);
       secondItabEmitArray->GetConstVec().push_back(GetModule()->GetMemPool()->New<MIRIntConst>(nameIdx, voidPtrType));
       secondItabEmitArray->GetConstVec().push_back(
           GetModule()->GetMemPool()->New<MIRAddroffuncConst>(func->GetPuidx(), voidPtrType));
     }
     // Create the second-level itable, in which hashcode is looked up by binary searching
-    GenTableSymbol(ITAB_CONFLICT_PREFIX_STR, klass->GetKlassName(), secondItabEmitArray);
+    GenTableSymbol(ITAB_CONFLICT_PREFIX_STR, klass.GetKlassName(), *secondItabEmitArray);
     // push the conflict symbol to the first-level itable
     StIdx symIdx = GlobalTables::GetGsymTable().GetStIdxFromStrIdx(
-        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(ITAB_CONFLICT_PREFIX_STR + klass->GetKlassName()));
+        GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(ITAB_CONFLICT_PREFIX_STR + klass.GetKlassName()));
     firstItabEmitArray->GetConstVec().push_back(GetModule()->GetMemPool()->New<MIRAddrofConst>(symIdx, 0, voidPtrType));
   }
-  GenTableSymbol(ITAB_PREFIX_STR, klass->GetKlassName(), firstItabEmitArray);
+  GenTableSymbol(ITAB_PREFIX_STR, klass.GetKlassName(), *firstItabEmitArray);
 }
 
-void VtableAnalysis::GenTableSymbol(const std::string &prefix, const std::string klassName, MIRAggConst *newconst) {
-  size_t arraySize = newconst->GetConstVec().size();
+void VtableAnalysis::GenTableSymbol(const std::string &prefix, const std::string klassName, MIRAggConst &newconst) {
+  size_t arraySize = newconst.GetConstVec().size();
   MIRArrayType *arrayType = GlobalTables::GetTypeTable().GetOrCreateArrayType(*voidPtrType, arraySize);
   MIRSymbol *vtabSt = builder->CreateGlobalDecl((prefix + klassName).c_str(), arrayType);
   if (klassName == NameMangler::GetInternalNameLiteral(NameMangler::kJavaLangObjectStr)) {
@@ -320,7 +330,7 @@ void VtableAnalysis::GenTableSymbol(const std::string &prefix, const std::string
   } else {
     vtabSt->SetStorageClass(kScFstatic);
   }
-  vtabSt->SetKonst(newconst);
+  vtabSt->SetKonst(&newconst);
 }
 
 void VtableAnalysis ::DumpVtableList(const Klass *klass) const {
@@ -342,19 +352,19 @@ void VtableAnalysis::ProcessFunc(MIRFunction *func) {
     next = stmt->GetNext();
     switch (stmt->GetOpCode()) {
       case OP_virtualcallassigned: {
-        ReplaceVirtualInvoke(static_cast<CallNode*>(stmt));
+        ReplaceVirtualInvoke(*(static_cast<CallNode*>(stmt)));
         break;
       }
       case OP_interfacecallassigned: {
-        ReplaceInterfaceInvoke(static_cast<CallNode*>(stmt));
+        ReplaceInterfaceInvoke(*(static_cast<CallNode*>(stmt)));
         break;
       }
       case OP_superclasscallassigned: {
-        ReplaceSuperclassInvoke(static_cast<CallNode*>(stmt));
+        ReplaceSuperclassInvoke(*(static_cast<CallNode*>(stmt)));
         break;
       }
       case OP_polymorphiccallassigned: {
-        ReplacePolymorphicInvoke(static_cast<CallNode*>(stmt));
+        ReplacePolymorphicInvoke(*(static_cast<CallNode*>(stmt)));
         break;
       }
       default:
@@ -364,10 +374,10 @@ void VtableAnalysis::ProcessFunc(MIRFunction *func) {
   }
 }
 
-void VtableAnalysis::ReplaceSuperclassInvoke(CallNode *stmt) {
+void VtableAnalysis::ReplaceSuperclassInvoke(CallNode &stmt) {
   // Because the virtual method may be inherited from its parent, we need to find
   // the actual method target.
-  MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(stmt->GetPUIdx());
+  MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(stmt.GetPUIdx());
   Klass *klass = klassHierarchy->GetKlassFromFunc(callee);
 
   CHECK_FATAL(klass != nullptr, "Klass not found");
@@ -384,7 +394,7 @@ void VtableAnalysis::ReplaceSuperclassInvoke(CallNode *stmt) {
   if (!cands || cands->size() == 0) {
     if (klass->IsClass() || klass->IsInterface()) {
       LogInfo::MapleLogger() << "warning: func " << callee->GetName() << " is not found in SuperInvoke!" << std::endl;
-      stmt->SetOpCode(OP_callassigned);
+      stmt.SetOpCode(OP_callassigned);
       return;
     }
   }
@@ -393,23 +403,24 @@ void VtableAnalysis::ReplaceSuperclassInvoke(CallNode *stmt) {
               callee->GetBaseFuncNameWithType().c_str(), klass->GetKlassName().c_str());
   MIRFunction *actualMIRFunc = cands->at(0);
   CHECK_FATAL(actualMIRFunc, "Can not find the implementation of %s", callee->GetName().c_str());
-  stmt->SetOpCode(OP_callassigned);
-  stmt->SetPUIdx(actualMIRFunc->GetPuidx());
+  stmt.SetOpCode(OP_callassigned);
+  stmt.SetPUIdx(actualMIRFunc->GetPuidx());
   GetModule()->addSuperCall(actualMIRFunc->GetName());
 }
 
-void VtableAnalysis::ReplacePolymorphicInvoke(CallNode *stmt) {
+void VtableAnalysis::ReplacePolymorphicInvoke(CallNode &stmt) {
   IntrinsiccallNode *intrinCall =
       GetModule()->CurFuncCodeMemPool()->New<IntrinsiccallNode>(*GetModule(), OP_xintrinsiccallassigned);
   intrinCall->SetIntrinsic(INTRN_JAVA_POLYMORPHIC_CALL);
-  intrinCall->SetNumOpnds(stmt->GetNumOpnds());
-  intrinCall->SetReturnVec(stmt->GetReturnVec());
-  intrinCall->SetNOpnd(stmt->GetNopnd());
-  currFunc->GetBody()->ReplaceStmt1WithStmt2(stmt, intrinCall);
+  intrinCall->SetNumOpnds(stmt.GetNumOpnds());
+  intrinCall->SetReturnVec(stmt.GetReturnVec());
+  intrinCall->SetNOpnd(stmt.GetNopnd());
+  currFunc->GetBody()->ReplaceStmt1WithStmt2(&stmt, intrinCall);
 }
 
 BaseNode *VtableAnalysis::GenVtabItabBaseAddr(BaseNode *obj, bool isVirtual) {
-  BaseNode *classInfoAddress = ReflectionAnalysis::GenClassInfoAddr(obj, builder);
+  ASSERT(builder != nullptr, "null ptr check!");
+  BaseNode *classInfoAddress = ReflectionAnalysis::GenClassInfoAddr(obj, *builder);
   MIRStructType *classMetadataType = static_cast<MIRStructType*>(
       GlobalTables::GetTypeTable().GetTypeFromTyIdx(ReflectionAnalysis::GetClassMetaDataTyIdx()));
   return builder->CreateExprIread(*voidPtrType, *GlobalTables::GetTypeTable().GetOrCreatePointerType(*classMetadataType),
@@ -417,8 +428,9 @@ BaseNode *VtableAnalysis::GenVtabItabBaseAddr(BaseNode *obj, bool isVirtual) {
 }
 
 
-void VtableAnalysis::ReplaceVirtualInvoke(CallNode *stmt) {
-  MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(stmt->GetPUIdx());
+void VtableAnalysis::ReplaceVirtualInvoke(CallNode &stmt) {
+  MIRFunction *callee = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(stmt.GetPUIdx());
+  ASSERT(callee != nullptr, "null ptr check!");
   CHECK_FATAL(callee->GetParamSize() != 0, "container check");
   MIRPtrType *firstFormalArgType = static_cast<MIRPtrType*>(callee->GetNthParamType(0));
   MIRType *pointedType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(firstFormalArgType->GetPointedTyIdx());
@@ -432,10 +444,11 @@ void VtableAnalysis::ReplaceVirtualInvoke(CallNode *stmt) {
     structType = klassFromFuncDependCallee->GetMIRStructType();
   }
   size_t entryOffset = SIZE_MAX;
-  if (puidxToVtabIndex.find(stmt->GetPUIdx()) != puidxToVtabIndex.end() && puidxToVtabIndex[stmt->GetPUIdx()] >= 0) {
-    entryOffset = puidxToVtabIndex[stmt->GetPUIdx()];
+  if (puidxToVtabIndex.find(stmt.GetPUIdx()) != puidxToVtabIndex.end() && puidxToVtabIndex[stmt.GetPUIdx()] >= 0) {
+    entryOffset = puidxToVtabIndex[stmt.GetPUIdx()];
   } else {
     GStrIdx calleeStridx = callee->GetBaseFuncNameWithTypeStrIdx();
+    ASSERT(structType != nullptr, "null ptr check!");
     for (size_t id1 = 0; id1 < structType->GetVTableMethods().size(); id1++) {
       MIRFunction *vtableMethod = builder->GetFunctionFromStidx(structType->GetVTableMethods()[id1]->first);
       if (calleeStridx == vtableMethod->GetBaseFuncNameWithTypeStrIdx()) {
@@ -449,28 +462,28 @@ void VtableAnalysis::ReplaceVirtualInvoke(CallNode *stmt) {
                 callee->GetName().c_str(), currFunc->GetName().c_str());
   }
   BaseNode *offsetNode = builder->CreateIntConst(entryOffset * kTabEntrySize, PTY_u32);
-  CHECK_FATAL(!stmt->GetNopnd().empty(), "container check");
-  BaseNode *tabBaseAddress = GenVtabItabBaseAddr(stmt->GetNopndAt(0), true);
+  CHECK_FATAL(!stmt.GetNopnd().empty(), "container check");
+  BaseNode *tabBaseAddress = GenVtabItabBaseAddr(stmt.GetNopndAt(0), true);
   BaseNode *addrNode =
       builder->CreateExprBinary(OP_add, *GlobalTables::GetTypeTable().GetPtr(), tabBaseAddress, offsetNode);
   BaseNode *readFuncPtr = builder->CreateExprIread(
       *GlobalTables::GetTypeTable().GetCompactPtr(),
       *GlobalTables::GetTypeTable().GetOrCreatePointerType(*GlobalTables::GetTypeTable().GetCompactPtr()), 0, addrNode);
-  stmt->SetOpCode(OP_virtualicallassigned);
-  stmt->GetNopnd().insert(stmt->GetNopnd().begin(), readFuncPtr);
-  stmt->SetNumOpnds(stmt->GetNumOpnds() + 1);
+  stmt.SetOpCode(OP_virtualicallassigned);
+  stmt.GetNopnd().insert(stmt.GetNopnd().begin(), readFuncPtr);
+  stmt.SetNumOpnds(stmt.GetNumOpnds() + 1);
 }
 
 
-void VtableAnalysis::ReplaceInterfaceInvoke(CallNode *stmt) {
-  CHECK_FATAL(stmt->GetNopnd().empty() == false, "container check");
-  BaseNode *tabBaseAddress = GenVtabItabBaseAddr(stmt->GetNopndAt(0), false);
+void VtableAnalysis::ReplaceInterfaceInvoke(CallNode &stmt) {
+  CHECK_FATAL(stmt.GetNopnd().empty() == false, "container check");
+  BaseNode *tabBaseAddress = GenVtabItabBaseAddr(stmt.GetNopndAt(0), false);
   MemPool *currentFuncMp = builder->GetCurrentFuncCodeMp();
   ResolveFuncNode *resolveNode = currentFuncMp->New<ResolveFuncNode>(
-      OP_resolveinterfacefunc, GlobalTables::GetTypeTable().GetCompactPtr()->GetPrimType(), stmt->GetPUIdx(),
+      OP_resolveinterfacefunc, GlobalTables::GetTypeTable().GetCompactPtr()->GetPrimType(), stmt.GetPUIdx(),
       tabBaseAddress, builder->GetConstUInt32(0));
-  stmt->SetOpCode(OP_interfaceicallassigned);
-  stmt->GetNopnd().insert(stmt->GetNopnd().begin(), resolveNode);
-  stmt->SetNumOpnds(stmt->GetNumOpnds() + 1);
+  stmt.SetOpCode(OP_interfaceicallassigned);
+  stmt.GetNopnd().insert(stmt.GetNopnd().begin(), resolveNode);
+  stmt.SetNumOpnds(stmt.GetNumOpnds() + 1);
 }
 }  // namespace maple
diff --git a/src/mpl2mpl/src/vtable_impl.cpp b/src/mpl2mpl/src/vtable_impl.cpp
index 80637b42d8e6b0ce48c2bfbc63d5824640ec05b5..c40d0c0b5e2511241bfa22b0ca472267398130f4 100644
--- a/src/mpl2mpl/src/vtable_impl.cpp
+++ b/src/mpl2mpl/src/vtable_impl.cpp
@@ -41,8 +41,9 @@ void VtableImpl::ProcessFunc(MIRFunction *func) {
       case OP_regassign: {
         RegassignNode *regassign = static_cast<RegassignNode*>(stmt);
         BaseNode *rhs = regassign->Opnd();
+        ASSERT(rhs != nullptr, "null ptr check!");
         if (rhs->GetOpCode() == maple::OP_resolveinterfacefunc) {
-          ReplaceResolveInterface(stmt, static_cast<ResolveFuncNode*>(rhs));
+          ReplaceResolveInterface(*stmt, *(static_cast<ResolveFuncNode*>(rhs)));
         }
         break;
       }
@@ -68,8 +69,9 @@ void VtableImpl::ProcessFunc(MIRFunction *func) {
       case OP_icallassigned: {
         IcallNode *icall = static_cast<IcallNode*>(stmt);
         BaseNode *firstParm = icall->GetNopndAt(0);
+        ASSERT(firstParm != nullptr, "null ptr check!");
         if (firstParm->GetOpCode() == maple::OP_resolveinterfacefunc) {
-          ReplaceResolveInterface(stmt, static_cast<ResolveFuncNode*>(firstParm));
+          ReplaceResolveInterface(*stmt, *(static_cast<ResolveFuncNode*>(firstParm)));
         }
         break;
       }
@@ -98,14 +100,15 @@ void VtableImpl::ProcessFunc(MIRFunction *func) {
 }
 
 
-void VtableImpl::ReplaceResolveInterface(StmtNode *stmt, const ResolveFuncNode *resolveNode) {
-  std::string signature = VtableAnalysis::DecodeBaseNameWithType(
-      GlobalTables::GetFunctionTable().GetFunctionFromPuidx(resolveNode->GetPuIdx()));
+void VtableImpl::ReplaceResolveInterface(StmtNode &stmt, const ResolveFuncNode &resolveNode) {
+  MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(resolveNode.GetPuIdx());
+  ASSERT(func != nullptr, "null ptr check!");
+  std::string signature = VtableAnalysis::DecodeBaseNameWithType(*func);
   int64 hashCode = GetHashIndex(signature.c_str());
   PregIdx pregItabAddress = currFunc->GetPregTab()->CreatePreg(PTY_ptr);
   RegassignNode *itabAddressAssign =
-      builder->CreateStmtRegassign(PTY_ptr, pregItabAddress, resolveNode->GetTabBaseAddr());
-  currFunc->GetBody()->InsertBefore(stmt, itabAddressAssign);
+      builder->CreateStmtRegassign(PTY_ptr, pregItabAddress, resolveNode.GetTabBaseAddr());
+  currFunc->GetBody()->InsertBefore(&stmt, itabAddressAssign);
   // read funcvalue
   MIRType *compactPtrType = GlobalTables::GetTypeTable().GetCompactPtr();
   PrimType compactPtrPrim = compactPtrType->GetPrimType();
@@ -116,7 +119,7 @@ void VtableImpl::ReplaceResolveInterface(StmtNode *stmt, const ResolveFuncNode *
       *compactPtrType, *GlobalTables::GetTypeTable().GetOrCreatePointerType(*compactPtrType), 0, addrNode);
   PregIdx pregFuncPtr = currFunc->GetPregTab()->CreatePreg(compactPtrPrim);
   RegassignNode *funcPtrAssign = builder->CreateStmtRegassign(compactPtrPrim, pregFuncPtr, readFuncPtr);
-  currFunc->GetBody()->InsertBefore(stmt, funcPtrAssign);
+  currFunc->GetBody()->InsertBefore(&stmt, funcPtrAssign);
   // In case not found in the fast path, fall to the slow path
   uint64 secondHashCode = GetSecondHashIndex(signature.c_str());
   MapleAllocator *currentFuncMpAllocator = builder->GetCurrentFuncCodeMpAllocator();
@@ -137,12 +140,12 @@ void VtableImpl::ReplaceResolveInterface(StmtNode *stmt, const ResolveFuncNode *
                                                    builder->CreateIntConst(0, compactPtrPrim));
   IfStmtNode *ifStmt = static_cast<IfStmtNode*>(builder->CreateStmtIf(checkExpr));
   ifStmt->GetThenPart()->AddStatement(mccCallStmt);
-  currFunc->GetBody()->InsertBefore(stmt, ifStmt);
-  if (stmt->GetOpCode() == OP_regassign) {
-    RegassignNode *regAssign = static_cast<RegassignNode*>(stmt);
+  currFunc->GetBody()->InsertBefore(&stmt, ifStmt);
+  if (stmt.GetOpCode() == OP_regassign) {
+    RegassignNode *regAssign = static_cast<RegassignNode*>(&stmt);
     regAssign->SetOpnd(builder->CreateExprRegread(compactPtrPrim, pregFuncPtr));
   } else {
-    IcallNode *icall = static_cast<IcallNode*>(stmt);
+    IcallNode *icall = static_cast<IcallNode*>(&stmt);
     const size_t nopndSize = icall->GetNopndSize();
     CHECK_FATAL(nopndSize > 0, "container check");
     icall->SetNOpndAt(0, builder->CreateExprRegread(compactPtrPrim, pregFuncPtr));