diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl
index 3afa3e8786d3b0bb111c0fd480ed71f5a3080481..15c8d1af1876e38793f77a8556ff743209dcd0c7 100755
Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ
diff --git a/src/bin/maple b/src/bin/maple
index 8470a48470ea9e897df890931676b43170341217..f49494976a191bccfe97a5a419304cfd341cb4e8 100755
Binary files a/src/bin/maple and b/src/bin/maple differ
diff --git a/src/deplibs/libmplphase.a b/src/deplibs/libmplphase.a
index dbe5c974020e89e8671a46d3e2335b17d4ee7c02..a75aedde6f3cffa44eb0c0c83d8cca2a17e35c09 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 4dd33a87cbb6b3fed325d08939c28f7bebc38e2d..a5552ca88ff23b13f9e2389c545485b5e5d3bab2 100644
Binary files a/src/deplibs/libmplutil.a and b/src/deplibs/libmplutil.a differ
diff --git a/src/maple_be/include/be/becommon.h b/src/maple_be/include/be/becommon.h
index 0181d849ec419ca115c667dc11ac2c6f1dd068f3..fd069d0d135827ca61bfa3ba60d6d4fd4235632c 100644
--- a/src/maple_be/include/be/becommon.h
+++ b/src/maple_be/include/be/becommon.h
@@ -163,6 +163,15 @@ class BECommon {
     typeSizeTable.push_back(value);
   }
 
+  void AddTypeSizeAndAlign(TyIdx tyIdx, uint64 value) {
+    if (typeSizeTable.size() == tyIdx) {
+      typeSizeTable.push_back(value);
+      tableAlignTable.push_back(value);
+    } else {
+      CHECK_FATAL(typeSizeTable.size() > tyIdx, "there are some types haven't set type size and align, %d");
+    }
+  }
+
   uint8 GetTypeAlign(uint32 idx) const {
     return tableAlignTable.at(idx);
   }
diff --git a/src/maple_be/include/be/lower.h b/src/maple_be/include/be/lower.h
index 5b8267cd8a30cb91e909fa57c114f390a6989250..4572d5c1773a745652bb30bc0ef38d6e31d66c31 100644
--- a/src/maple_be/include/be/lower.h
+++ b/src/maple_be/include/be/lower.h
@@ -34,7 +34,7 @@ class CGLowerer {
   enum Option : uint64 {
     kUndefined = 0,
     kGenEh = 1ULL << 0,
-    kVerboseAsm = 1ULL << 1,
+    kVerboseCG = 1ULL << 1,
   };
 
   using BuiltinFunctionID = uint32;
@@ -49,15 +49,15 @@ class CGLowerer {
     SetCurrentFunc(func);
   }
 
-  CGLowerer(MIRModule &mod, BECommon &common, bool genEh, bool verboseAsm)
+  CGLowerer(MIRModule &mod, BECommon &common, bool genEh, bool verboseCG)
       : mirModule(mod),
         beCommon(common) {
     OptionFlag option = 0;
     if (genEh) {
       option |= kGenEh;
     }
-    if (verboseAsm) {
-      option |= kVerboseAsm;
+    if (verboseCG) {
+      option |= kVerboseCG;
     }
     SetOptions(option);
     mirBuilder = mod.GetMIRBuilder();
@@ -226,7 +226,7 @@ class CGLowerer {
   }
 
   bool ShouldAddAdditionalComment() const {
-    return (options & kVerboseAsm) != 0;
+    return (options & kVerboseCG) != 0;
   }
 
   bool GenerateExceptionHandlingCode() const {
diff --git a/src/maple_be/include/cg/aarch64/aarch64_cg.h b/src/maple_be/include/cg/aarch64/aarch64_cg.h
index 09ed286994f23ba53660eb32f7b6a16951ad7d1e..5fb7dad36895094bc357c92f552fba28ad66237b 100644
--- a/src/maple_be/include/cg/aarch64/aarch64_cg.h
+++ b/src/maple_be/include/cg/aarch64/aarch64_cg.h
@@ -119,8 +119,8 @@ class AArch64CG : public CG {
   ~AArch64CG() override = default;
 
   CGFunc *CreateCGFunc(MIRModule &mod, MIRFunction &mirFunc, BECommon &bec, MemPool &memPool,
-                       MapleAllocator &mallocator) override {
-    return memPool.New<AArch64CGFunc>(mod, *this, mirFunc, bec, memPool, mallocator);
+                       MapleAllocator &mallocator, uint32 funcId) override {
+    return memPool.New<AArch64CGFunc>(mod, *this, mirFunc, bec, memPool, mallocator, funcId);
   }
 
   const std::unordered_map<std::string, std::vector<std::string>> &GetCyclePatternMap() const {
diff --git a/src/maple_be/include/cg/aarch64/aarch64_cgfunc.h b/src/maple_be/include/cg/aarch64/aarch64_cgfunc.h
index 84aaf981c8bba37e81908354d64e10b43b36a337..faab49b6388ede0b0472d4a63b9c1739914f48dc 100644
--- a/src/maple_be/include/cg/aarch64/aarch64_cgfunc.h
+++ b/src/maple_be/include/cg/aarch64/aarch64_cgfunc.h
@@ -26,8 +26,9 @@
 namespace maplebe {
 class AArch64CGFunc : public CGFunc {
  public:
-  AArch64CGFunc(MIRModule &mod, CG &c, MIRFunction &f, BECommon &b, MemPool &memPool, MapleAllocator &mallocator)
-      : CGFunc(mod, c, f, b, memPool, mallocator),
+  AArch64CGFunc(MIRModule &mod, CG &c, MIRFunction &f, BECommon &b,
+      MemPool &memPool, MapleAllocator &mallocator, uint32 funcId)
+      : CGFunc(mod, c, f, b, memPool, mallocator, funcId),
         calleeSavedRegs(mallocator.Adapter()),
         formalRegList(mallocator.Adapter()),
         phyRegOperandTable(std::less<AArch64RegOperand>(), mallocator.Adapter()),
diff --git a/src/maple_be/include/cg/aarch64/aarch64_insn.h b/src/maple_be/include/cg/aarch64/aarch64_insn.h
index 0127e84295b945ce447cf557f68f6dbae4aef491..5c36c0405707946a58cab350f30b8f65f79094c4 100644
--- a/src/maple_be/include/cg/aarch64/aarch64_insn.h
+++ b/src/maple_be/include/cg/aarch64/aarch64_insn.h
@@ -84,7 +84,7 @@ class AArch64Insn : public Insn {
       Operand *opnd1 = opnds[1];
       CHECK_FATAL(opnd1 != nullptr, "opnd1 is null!");
       auto *stImmOpnd = static_cast<StImmOperand*>(opnd1);
-      return StringUtils::StartsWith(stImmOpnd->GetName(), NameMangler::kDecoupleStaticValueStr);
+      return StringUtils::StartsWith(stImmOpnd->GetName(), namemangler::kDecoupleStaticValueStr);
     }
     return false;
   }
diff --git a/src/maple_be/include/cg/cfi.def b/src/maple_be/include/cg/cfi.def
index 85ede3e259877dc2b1e54c61b05111d936896081..2c361aa64d2d69f53b53af4067d51cbf8d2da196 100644
--- a/src/maple_be/include/cg/cfi.def
+++ b/src/maple_be/include/cg/cfi.def
@@ -49,5 +49,5 @@ CFI_DEFINE( val_encoded_addr,     , 3, Register,    Immediate, StImmediate )
 
 ARM_DIRECTIVES_DEFINE( save,      , 1, List,        Undef,     Undef )
 ARM_DIRECTIVES_DEFINE( vsave,     , 1, List,        Undef,     Undef )
-ARM_DIRECTIVES_DEFINE( setfp,     , 2, Register,    Immediate, Undef )
+ARM_DIRECTIVES_DEFINE( setfp,     , 3, Register,    Register, Immediate )
 ARM_DIRECTIVES_DEFINE( pad,       , 1, Immediate,   Undef,     Undef )
diff --git a/src/maple_be/include/cg/cfi.h b/src/maple_be/include/cg/cfi.h
index 697efd6e1548ef7a1c97b42f9063b4dab9da10c0..35bf6dc1c2d364004a276416eba83acbf29cc1d1 100644
--- a/src/maple_be/include/cg/cfi.h
+++ b/src/maple_be/include/cg/cfi.h
@@ -63,6 +63,10 @@ class CfiInsn : public maplebe::Insn {
   CfiInsn(MemPool &memPool, maplebe::MOperator op, maplebe::Operand &opnd0, maplebe::Operand &opnd1)
       : Insn(memPool, op, opnd0, opnd1) {}
 
+  CfiInsn(MemPool &memPool, maplebe::MOperator op, maplebe::Operand &opnd0, maplebe::Operand &opnd1,
+      maplebe::Operand &opnd2)
+      : Insn(memPool, op, opnd0, opnd1, opnd2) {}
+
   CfiInsn(const CfiInsn &originalInsn, MemPool &memPool) : Insn(memPool, originalInsn.mOp) {
     InitWithOriginalInsn(originalInsn, memPool);
   }
diff --git a/src/maple_be/include/cg/cg.h b/src/maple_be/include/cg/cg.h
index 4a95620af6039f1053828666c471f5a4c05f21af..2a3e7805b30998c476261ff49e0786cc35e9df10 100644
--- a/src/maple_be/include/cg/cg.h
+++ b/src/maple_be/include/cg/cg.h
@@ -104,7 +104,7 @@ class CG {
         labelOrderCnt(0),
         cgOption(cgOptions),
         instrumentationFunction(nullptr) {
-    const std::string &internalNameLiteral = NameMangler::GetInternalNameLiteral(NameMangler::kJavaLangObjectStr);
+    const std::string &internalNameLiteral = namemangler::GetInternalNameLiteral(namemangler::kJavaLangObjectStr);
     GStrIdx strIdxFromName = GlobalTables::GetStrTable().GetStrIdxFromName(internalNameLiteral);
     isLibcore = (GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdxFromName) != nullptr);
     DefineDebugTraceFunctions();
@@ -113,6 +113,7 @@ class CG {
   virtual ~CG();
   void GenExtraTypeMetadata(const std::string &classListFileName, const std::string &outputBaseName);
   void GenPrimordialObjectList(const std::string &outputBaseName);
+  const std::string ExtractFuncName(const std::string &str);
 
   template <typename I>
   Insn &BuildInstruction(MOperator opCode) {
@@ -189,7 +190,7 @@ class CG {
     return *insn;
   }
 
-  virtual CGFunc *CreateCGFunc(MIRModule &mod, MIRFunction&, BECommon&, MemPool&, MapleAllocator&) = 0;
+  virtual CGFunc *CreateCGFunc(MIRModule &mod, MIRFunction&, BECommon&, MemPool&, MapleAllocator&, uint32) = 0;
 
   bool IsExclusiveEH() const {
     return CGOptions::IsExclusiveEH();
@@ -211,6 +212,10 @@ class CG {
     return cgOption.GenerateVerboseAsm();
   }
 
+  bool GenerateVerboseCG() const {
+    return cgOption.GenerateVerboseCG();
+  }
+
   bool DoPrologueEpilogue() const {
     return cgOption.DoPrologueEpilogue();
   }
diff --git a/src/maple_be/include/cg/cg_option.h b/src/maple_be/include/cg/cg_option.h
index 05a5e55b8b3c5c12e44ba89a70c84047134fdbfb..2339424f483ff5b0a213430c2e94c05e22664b27 100644
--- a/src/maple_be/include/cg/cg_option.h
+++ b/src/maple_be/include/cg/cg_option.h
@@ -45,6 +45,7 @@ class CGOptions : public MapleDriverOptionBase {
     kGenYieldPoint = 1ULL << 9,
     kGenLocalRc = 1ULL << 10,
     kProEpilogueOpt = 1ULL << 11,
+    kVerboseCG = 1ULL << 12,
     kDebugFriendly = 1ULL << 20,
     kWithLoc = 1ULL << 21,
     kWithDwarf = 1ULL << 22,
@@ -193,6 +194,10 @@ class CGOptions : public MapleDriverOptionBase {
     return (options & kVerboseAsm) != 0;
   }
 
+  bool GenerateVerboseCG() const {
+    return (options & kVerboseCG) != 0;
+  }
+
   bool GenerateDebugFriendlyCode() const {
     return true;
   }
diff --git a/src/maple_be/include/cg/cg_phases.def b/src/maple_be/include/cg/cg_phases.def
index 64801d456f00ada544a2abe0e8a8354e9ccaccce..f2205fedce53cdf4645f21ea7551c2119fbdf101 100644
--- a/src/maple_be/include/cg/cg_phases.def
+++ b/src/maple_be/include/cg/cg_phases.def
@@ -13,6 +13,9 @@
  * See the Mulan PSL v1 for more details.
  */
 FUNCAPHASE(kCGFuncPhaseLIVE, CgDoLiveAnalysis)
+#ifdef TARGARM32
+FUNCAPHASE(kCGFuncPhaseLIVERANGE, CgDoLrAnalysis)
+#endif  /* TARGARM32 */
 FUNCAPHASE(kCGFuncPhaseREACHDEF, CgDoReachingDefinition)
 FUNCAPHASE(kCGFuncPhaseCLEARRDINFO, CgDoClearRDInfo)
 FUNCAPHASE(kCGFuncPhaseLOOP, CgDoLoopAnalysis)
diff --git a/src/maple_be/include/cg/cgfunc.h b/src/maple_be/include/cg/cgfunc.h
index 31f90329af438b67821c2d059634887caa2083af..cda973749246e22308c139eae5728420e6c19651 100644
--- a/src/maple_be/include/cg/cgfunc.h
+++ b/src/maple_be/include/cg/cgfunc.h
@@ -71,6 +71,9 @@ class SpillMemOperandSet {
   MapleSet<MemOperand*, MemOpndCmp> reuseSpillLocMem;
 };
 
+#if TARGARM32
+class LiveRange;
+#endif  /* TARGARM32 */
 constexpr uint32 kVRegisterNumber = 80;
 class CGFunc {
  public:
@@ -81,7 +84,7 @@ class CGFunc {
   };
 
   CGFunc(MIRModule &mod, CG &cg, MIRFunction &mirFunc, BECommon &beCommon, MemPool &memPool,
-         MapleAllocator &mallocator);
+         MapleAllocator &mallocator, uint32 funcId);
   virtual ~CGFunc();
 
   const std::string &GetName() const {
@@ -649,6 +652,32 @@ class CGFunc {
     loops.push_back(&loop);
   }
 
+#if TARGARM32
+  MapleVector<BB*> &GetSortedBBs() {
+    return sortedBBs;
+  }
+
+  const MapleVector<BB*> &GetSortedBBs() const {
+    return sortedBBs;
+  }
+
+  void SetSortedBBs(MapleVector<BB*> &bbVec) {
+    sortedBBs = bbVec;
+  }
+
+  MapleVector<LiveRange*> &GetLrVec() {
+    return lrVec;
+  }
+
+  const MapleVector<LiveRange*> &GetLrVec() const {
+    return lrVec;
+  }
+
+  void SetLrVec(MapleVector<LiveRange*> &newLrVec) {
+    lrVec = newLrVec;
+  }
+#endif  /* TARGARM32 */
+
   CGCFG *GetTheCFG() {
     return theCFG;
   }
@@ -745,6 +774,10 @@ class CGFunc {
     volReleaseInsn = insn;
   }
 
+  const MapleString &GetShortFuncName() const {
+    return shortFuncName;
+  }
+
   virtual InsnVisitor *NewInsnModifier() = 0;
 
  protected:
@@ -839,10 +872,15 @@ class CGFunc {
   MemLayout *memLayout = nullptr;
   MapleAllocator *funcScopeAllocator;
   MapleVector<MIRSymbol*> emitStVec;  /* symbol that needs to be emit as a local symbol. i.e, switch table */
+#if TARGARM32
+  MapleVector<BB*> sortedBBs;
+  MapleVector<LiveRange*> lrVec;
+#endif  /* TARGARM32 */
   MapleVector<CGFuncLoops*> loops;
   CGCFG *theCFG = nullptr;
   uint32 nextSpillLocation = 0;
   static constexpr int kRegIncrStepLen = 80; /* reg number increate step length */
+  const MapleString shortFuncName;
 };  /* class CGFunc */
 
 CGFUNCPHASE(CgDoLayoutSF, "layoutstackframe")
diff --git a/src/maple_be/include/cg/operand.h b/src/maple_be/include/cg/operand.h
index 6330c9c8d95ed1265c5abef0f246b6ceee69a026..d029d14d874e1203f976cb5846c50cc0660ba756 100644
--- a/src/maple_be/include/cg/operand.h
+++ b/src/maple_be/include/cg/operand.h
@@ -614,6 +614,7 @@ class LabelOperand : public Operand {
   LabelIdx GetLabelIndex() const {
     return labelIndex;
   }
+
   const std::string GetParentFunc() const {
     return parentFunc;
   }
@@ -673,6 +674,10 @@ class ListOperand : public Operand {
 
   ~ListOperand() override = default;
 
+  void PopOpnd() {
+    opndList.pop_back();
+  }
+
   void PushOpnd(RegOperand &opnd) {
     opndList.push_back(&opnd);
   }
diff --git a/src/maple_be/src/be/lower.cpp b/src/maple_be/src/be/lower.cpp
index 510fff18ebd01b8834b16266553d478b522aadf1..627704202467c44ccb2d26955295b5bdb88f20b1 100644
--- a/src/maple_be/src/be/lower.cpp
+++ b/src/maple_be/src/be/lower.cpp
@@ -110,8 +110,8 @@ void CGLowerer::RegisterExternalLibraryFunctions() {
     if (retTy->GetPrimType() == PTY_dynany) {
       retTy = GlobalTables::GetTypeTable().GetPtr();
     }
-    func->SetReturnTyIdx(retTy->GetTypeIndex());
 
+    std::vector<MIRSymbol*> formals;
     for (uint32 j = 0; extFnDescrs[i].argTypes[j] != kPtyInvalid; ++j) {
       PrimType primTy = extFnDescrs[i].argTypes[j];
       MIRType *argTy = GlobalTables::GetTypeTable().GetPrimType(primTy);
@@ -132,8 +132,12 @@ void CGLowerer::RegisterExternalLibraryFunctions() {
       argSt->SetStorageClass(kScFormal);
       argSt->SetSKind(kStVar);
       func->GetSymTab()->AddToStringSymbolMap(*argSt);
-      func->AddArgument(argSt);
+      formals.push_back(argSt);
     }
+    func->UpdateFuncTypeAndFormalsAndReturnType(formals, retTy->GetTypeIndex(), false);
+    auto *funcType = func->GetMIRFuncType();
+    ASSERT(funcType != nullptr, "null ptr check");
+    beCommon.AddTypeSizeAndAlign(funcType->GetTypeIndex(), GetPrimTypeSize(funcType->GetPrimType()));
     extFuncs.push_back(std::pair<ExtFuncT, PUIdx>(id, func->GetPuidx()));
   }
 }
@@ -307,11 +311,11 @@ BaseNode *CGLowerer::LowerArrayForLazyBiding(BaseNode &baseNode, BaseNode &offse
   if (parent.GetOpCode() == OP_iread && (baseNode.GetOpCode() == maple::OP_addrof)) {
     const MIRSymbol *st =
         mirModule.CurFunction()->GetLocalOrGlobalSymbol(static_cast<AddrofNode&>(baseNode).GetStIdx());
-    if (StringUtils::StartsWith(st->GetName(), NameMangler::kDecoupleStaticValueStr) ||
-        ((StringUtils::StartsWith(st->GetName(), NameMangler::kMuidFuncUndefTabPrefixStr) ||
-          StringUtils::StartsWith(st->GetName(), NameMangler::kMuidFuncDefTabPrefixStr) ||
-          StringUtils::StartsWith(st->GetName(), NameMangler::kMuidDataDefTabPrefixStr) ||
-          StringUtils::StartsWith(st->GetName(), NameMangler::kMuidDataUndefTabPrefixStr)) &&
+    if (StringUtils::StartsWith(st->GetName(), namemangler::kDecoupleStaticValueStr) ||
+        ((StringUtils::StartsWith(st->GetName(), namemangler::kMuidFuncUndefTabPrefixStr) ||
+          StringUtils::StartsWith(st->GetName(), namemangler::kMuidFuncDefTabPrefixStr) ||
+          StringUtils::StartsWith(st->GetName(), namemangler::kMuidDataDefTabPrefixStr) ||
+          StringUtils::StartsWith(st->GetName(), namemangler::kMuidDataUndefTabPrefixStr)) &&
          CGOptions::IsLazyBinding())) {
       /* for decouple static or lazybinding def/undef tables, replace it with intrinsic */
       MapleVector<BaseNode*> args(mirBuilder->GetCurrentFuncCodeMpAllocator()->Adapter());
@@ -829,7 +833,7 @@ BlockNode *CGLowerer::GenBlockNode(StmtNode &newCall, const CallReturnVector &p2
       }
     }
     blk->ResetBlock();
-    /* if VerboseAsm, insert a comment */
+    /* if VerboseCG, insert a comment */
     if (ShouldAddAdditionalComment()) {
       CommentNode *cmnt = mirModule.CurFuncCodeMemPool()->New<CommentNode>(mirModule);
       cmnt->SetComment(kOpcodeInfo.GetName(opcode));
@@ -868,9 +872,19 @@ BlockNode *CGLowerer::LowerCallAssignedStmt(StmtNode &stmt) {
     }
     case OP_intrinsiccallassigned:
     case OP_xintrinsiccallassigned: {
-      auto &origCall = static_cast<IntrinsiccallNode&>(stmt);
-      newCall = GenIntrinsiccallNode(stmt, funcCalled, handledAtLowerLevel, origCall);
-      p2nRets = &origCall.GetReturnVec();
+      IntrinsiccallNode &intrincall = static_cast<IntrinsiccallNode&>(stmt);
+      if (intrincall.GetIntrinsic() == INTRN_JAVA_POLYMORPHIC_CALL) {
+        BaseNode *contextClassArg = GetBaseNodeFromCurFunc(*mirModule.CurFunction(), false);
+        constexpr int kContextIdx = 4; /* stable index in MCC_DexPolymorphicCall, never out of range */
+        intrincall.InsertOpnd(contextClassArg, kContextIdx);
+
+        BaseNode *firstArg = intrincall.GetNopndAt(0);
+        BaseNode *baseVal = mirBuilder->CreateExprBinary(OP_add, *GlobalTables::GetTypeTable().GetPtr(), firstArg,
+                                                         mirBuilder->CreateIntConst(1, PTY_ref));
+        intrincall.SetNOpndAt(0, baseVal);
+      }
+      newCall = GenIntrinsiccallNode(stmt, funcCalled, handledAtLowerLevel, intrincall);
+      p2nRets = &intrincall.GetReturnVec();
       break;
     }
     case OP_intrinsiccallwithtypeassigned: {
@@ -1215,17 +1229,17 @@ void CGLowerer::LowerEntry(MIRFunction &func) {
     MIRType *pointType = beCommon.BeGetOrCreatePointerType(*func.GetReturnType());
 
     retSt->SetTyIdx(pointType->GetTypeIndex());
-    MapleVector<MIRSymbol*> formals(mirModule.GetMPAllocator().Adapter());
+    std::vector<MIRSymbol*> formals;
     formals.push_back(retSt);
     for (uint32 i = 0; i < func.GetFormalCount(); ++i) {
       auto formal = func.GetFormal(i);
       formals.push_back(formal);
     }
-    func.ClearArguments();
-    for (MapleVector<MIRSymbol*>::iterator it = formals.begin(); it != formals.end(); ++it) {
-      func.AddArgument(*it);
-    }
-    func.SetReturnTyIdx(GlobalTables::GetTypeTable().GetTypeTable().at(static_cast<int>(PTY_void))->GetTypeIndex());
+
+    func.UpdateFuncTypeAndFormalsAndReturnType(formals, TyIdx(PTY_void), true);
+    auto *funcType = func.GetMIRFuncType();
+    ASSERT(funcType != nullptr, "null ptr check");
+    beCommon.AddTypeSizeAndAlign(funcType->GetTypeIndex(), GetPrimTypeSize(funcType->GetPrimType()));
   }
 }
 
@@ -1420,7 +1434,8 @@ MIRFunction *CGLowerer::RegisterFunctionVoidStarToVoid(BuiltinFunctionID id, con
   argSt->SetStorageClass(kScFormal);
   argSt->SetSKind(kStVar);
   func->GetSymTab()->AddToStringSymbolMap(*argSt);
-  func->AddArgument(argSt);
+  std::vector<MIRSymbol*> formals;
+  formals.push_back(argSt);
   if ((name == "MCC_SyncEnterFast0") || (name == "MCC_SyncEnterFast1") ||
       (name == "MCC_SyncEnterFast2") || (name == "MCC_SyncEnterFast3") ||
       (name == "MCC_SyncExitFast")) {
@@ -1430,8 +1445,13 @@ MIRFunction *CGLowerer::RegisterFunctionVoidStarToVoid(BuiltinFunctionID id, con
     argStMatch->SetStorageClass(kScFormal);
     argStMatch->SetSKind(kStVar);
     func->GetSymTab()->AddToStringSymbolMap(*argStMatch);
-    func->AddArgument(argStMatch);
+    formals.push_back(argStMatch);
   }
+  func->UpdateFuncTypeAndFormalsAndReturnType(formals, GlobalTables::GetTypeTable().GetVoid()->GetTypeIndex(),
+                                              false);
+  auto *funcType = func->GetMIRFuncType();
+  ASSERT(funcType != nullptr, "null ptr check");
+  beCommon.AddTypeSizeAndAlign(funcType->GetTypeIndex(), GetPrimTypeSize(funcType->GetPrimType()));
 
   builtinFuncIDs.push_back(std::pair<BuiltinFunctionID, PUIdx>(id, func->GetPuidx()));
   return func;
@@ -1446,7 +1466,6 @@ void CGLowerer::RegisterBuiltIns() {
                                                         GlobalTables::GetTypeTable().GetVoid()->GetTypeIndex());
     MIRSymbol *funcSym = func->GetFuncSymbol();
     funcSym->SetStorageClass(kScExtern);
-
     /* return type */
     MIRType *retTy = desc.GetReturnType();
     CHECK_FATAL(retTy != nullptr, "retTy should not be nullptr");
@@ -1454,8 +1473,8 @@ void CGLowerer::RegisterBuiltIns() {
     if (retTy->GetPrimType() == PTY_dynany) {
       retTy = GlobalTables::GetTypeTable().GetPtr();
     }
-    func->SetReturnTyIdx(retTy->GetTypeIndex());
 
+    std::vector<MIRSymbol*> formals;
     const std::string params[IntrinDesc::kMaxArgsNum] = { "p0", "p1", "p2", "p3", "p4", "p5" };
     for (uint32 j = 0; j < IntrinDesc::kMaxArgsNum; ++j) {
       MIRType *argTy = desc.GetArgType(j);
@@ -1472,8 +1491,12 @@ void CGLowerer::RegisterBuiltIns() {
       argSt->SetStorageClass(kScFormal);
       argSt->SetSKind(kStVar);
       func->GetSymTab()->AddToStringSymbolMap(*argSt);
-      func->AddArgument(argSt);
+      formals.push_back(argSt);
     }
+    func->UpdateFuncTypeAndFormalsAndReturnType(formals, retTy->GetTypeIndex(), false);
+    auto *funcType = func->GetMIRFuncType();
+    ASSERT(funcType != nullptr, "null ptr check");
+    beCommon.AddTypeSizeAndAlign(funcType->GetTypeIndex(), GetPrimTypeSize(funcType->GetPrimType()));
 
     builtinFuncIDs.push_back(std::pair<BuiltinFunctionID, PUIdx>(id, func->GetPuidx()));
   }
@@ -2178,7 +2201,7 @@ BaseNode *CGLowerer::GetClassInfoExprFromRuntime(const std::string &classInfo) {
   BaseNode *arg1 = nullptr;
   /* classname */
   std::string klassJavaDescriptor;
-  NameMangler::DecodeMapleNameToJavaDescriptor(classInfo, klassJavaDescriptor);
+  namemangler::DecodeMapleNameToJavaDescriptor(classInfo, klassJavaDescriptor);
   UStrIdx classNameStrIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(klassJavaDescriptor);
   arg1 = mirModule.GetMemPool()->New<ConststrNode>(classNameStrIdx);
   arg1->SetPrimType(PTY_ptr);
@@ -2649,7 +2672,7 @@ void CGLowerer::LowerJarrayMalloc(const StmtNode &stmt, const JarrayMallocNode &
     args.push_back(mirBuilder->CreateIntConst(elemSize, PTY_u32));  /* elem_size */
     args.push_back(node.Opnd(0));                                   /* n_elems */
     std::string klassJavaDescriptor;
-    NameMangler::DecodeMapleNameToJavaDescriptor(klassName, klassJavaDescriptor);
+    namemangler::DecodeMapleNameToJavaDescriptor(klassName, klassJavaDescriptor);
     UStrIdx classNameStrIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(klassJavaDescriptor);
     ConststrNode *classNameExpr = mirModule.GetMemPool()->New<ConststrNode>(classNameStrIdx);
     classNameExpr->SetPrimType(PTY_ptr);
diff --git a/src/maple_be/src/cg/aarch64/aarch64_args.cpp b/src/maple_be/src/cg/aarch64/aarch64_args.cpp
index 87784959bfc78ee632d6b738e55d9b41c4df3fd2..9f1ea5517e098590d976fe0750c46184876c5715 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_args.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_args.cpp
@@ -111,7 +111,7 @@ void AArch64MoveRegArgs::GenerateStpInsn(const ArgInfo &firstArgInfo, const ArgI
                                                                    *baseOpnd, nullptr, &offsetOpnd, firstArgInfo.sym);
   }
   Insn &pushInsn = aarchCGFunc->GetCG()->BuildInstruction<AArch64Insn>(mOp, regOpnd, regOpnd2, *memOpnd);
-  if (aarchCGFunc->GetCG()->GenerateVerboseAsm()) {
+  if (aarchCGFunc->GetCG()->GenerateVerboseCG()) {
     std::string argName = firstArgInfo.sym->GetName() + " " + secondArgInfo.sym->GetName();
     pushInsn.SetComment(std::string("store param: ").append(argName));
   }
@@ -147,7 +147,7 @@ void AArch64MoveRegArgs::GenerateStrInsn(ArgInfo &argInfo) {
 
   MOperator mOp = aarchCGFunc->PickStInsn(argInfo.symSize * kBitsPerByte, argInfo.mirTy->GetPrimType());
   Insn &insn = aarchCGFunc->GetCG()->BuildInstruction<AArch64Insn>(mOp, regOpnd, *memOpnd);
-  if (aarchCGFunc->GetCG()->GenerateVerboseAsm()) {
+  if (aarchCGFunc->GetCG()->GenerateVerboseCG()) {
     insn.SetComment(std::string("store param: ").append(argInfo.sym->GetName()));
   }
   aarchCGFunc->GetCurBB()->AppendInsn(insn);
@@ -222,7 +222,7 @@ void AArch64MoveRegArgs::LoadStackArgsToVReg(MIRSymbol &mirSym) {
   Insn &insn = aarchCGFunc->GetCG()->BuildInstruction<AArch64Insn>(
       aarchCGFunc->PickLdInsn(GetPrimTypeBitSize(stype), stype), dstRegOpnd, memOpnd);
 
-  if (aarchCGFunc->GetCG()->GenerateVerboseAsm()) {
+  if (aarchCGFunc->GetCG()->GenerateVerboseCG()) {
     std::string key = "param: %%";
     key += std::to_string(mirSym.GetPreg()->GetPregNo());
     ASSERT(mirSym.GetStorageClass() == kScFormal, "vreg parameters should be kScFormal type.");
@@ -247,7 +247,7 @@ void AArch64MoveRegArgs::MoveArgsToVReg(const PLocInfo &ploc, MIRSymbol &mirSym)
   MOperator mOp = aarchCGFunc->PickMovInsn(srcBitSize, regType);
 
   Insn &insn = aarchCGFunc->GetCG()->BuildInstruction<AArch64Insn>(mOp, dstRegOpnd, srcRegOpnd);
-  if (aarchCGFunc->GetCG()->GenerateVerboseAsm()) {
+  if (aarchCGFunc->GetCG()->GenerateVerboseCG()) {
     std::string key = "param: %%";
     key += std::to_string(mirSym.GetPreg()->GetPregNo());
     insn.SetComment(key);
diff --git a/src/maple_be/src/cg/aarch64/aarch64_cg.cpp b/src/maple_be/src/cg/aarch64/aarch64_cg.cpp
index b16e16b32cda9503d251e17e102e89970a095f80..6d6f6ae18ba113f991192ee49a8de67822efa32f 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_cg.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_cg.cpp
@@ -167,7 +167,7 @@ void AArch64CG::FindOrCreateRepresentiveSym(std::vector<uint64> &bitmapWords, ui
   GCTIBKey *key = memPool->New<GCTIBKey>(allocator, rcHeader, bitmapWords);
   const std::string &gcTIBName = GCTIB_PREFIX_STR + name;
   MapleUnorderedMap<GCTIBKey*, GCTIBPattern*, Hasher, EqualFn>::const_iterator iter = keyPatternMap.find(key);
-  if (iter == keyPatternMap.end()) {
+  if (iter == keyPatternMap.end() || gcTIBName.compare("MCC_GCTIB__Ljava_2Flang_2FObject_3B") == 0) {
     /* Emit the GCTIB label for the class */
     GCTIBPattern *ptn = memPool->New<GCTIBPattern>(*key, *memPool);
 
@@ -181,7 +181,7 @@ void AArch64CG::FindOrCreateRepresentiveSym(std::vector<uint64> &bitmapWords, ui
     std::string ptnString = "\t.type " + ptn->GetName() + ", %object\n" + "\t.data\n" + "\t.align 3\n";
 
     MIRSymbol *gcTIBSymbol = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
-        GlobalTables::GetStrTable().GetStrIdxFromName(NameMangler::GetInternalNameLiteral(gcTIBName)));
+        GlobalTables::GetStrTable().GetStrIdxFromName(namemangler::GetInternalNameLiteral(gcTIBName)));
     if (gcTIBSymbol != nullptr && gcTIBSymbol->GetStorageClass() == kScFstatic) {
       ptnString += "\t.local ";
     } else {
diff --git a/src/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp b/src/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp
index 6bd0b759985759a80333e7fc44f0953bb3079a1b..eb0ad3c398604570ea4fc628af390e2fb2aad545 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp
@@ -201,7 +201,7 @@ void AArch64CGFunc::SelectLoadAcquire(Operand &dest, PrimType dtype, Operand &sr
   }
 
   std::string key;
-  if (isDirect && GetCG()->GenerateVerboseAsm()) {
+  if (isDirect && GetCG()->GenerateVerboseCG()) {
     const MIRSymbol *sym = static_cast<AArch64MemOperand*>(&src)->GetSymbol();
     if (sym != nullptr) {
       MIRStorageClass sc = sym->GetStorageClass();
@@ -219,7 +219,7 @@ void AArch64CGFunc::SelectLoadAcquire(Operand &dest, PrimType dtype, Operand &sr
   /* Check if the right load-acquire instruction is available. */
   if (mOp != MOP_undef) {
     Insn &insn = GetCG()->BuildInstruction<AArch64Insn>(mOp, dest, *newSrc);
-    if (isDirect && GetCG()->GenerateVerboseAsm()) {
+    if (isDirect && GetCG()->GenerateVerboseCG()) {
       insn.SetComment(key);
     }
     GetCurBB()->AppendInsn(insn);
@@ -230,7 +230,7 @@ void AArch64CGFunc::SelectLoadAcquire(Operand &dest, PrimType dtype, Operand &sr
       PrimType itype = (stype == PTY_f32) ? PTY_i32 : PTY_i64;
       RegOperand &regOpnd = CreateRegisterOperandOfType(itype);
       Insn &insn = GetCG()->BuildInstruction<AArch64Insn>(PickLdInsn(ssize, itype, memOrd), regOpnd, *newSrc);
-      if (isDirect && GetCG()->GenerateVerboseAsm()) {
+      if (isDirect && GetCG()->GenerateVerboseCG()) {
         insn.SetComment(key);
       }
       GetCurBB()->AppendInsn(insn);
@@ -241,7 +241,7 @@ void AArch64CGFunc::SelectLoadAcquire(Operand &dest, PrimType dtype, Operand &sr
       ASSERT((ssize == k8BitSize) || (ssize == k16BitSize), "Just checking");
       PrimType utype = (ssize == k8BitSize) ? PTY_u8 : PTY_u16;
       Insn &insn = GetCG()->BuildInstruction<AArch64Insn>(PickLdInsn(ssize, utype, memOrd), dest, *newSrc);
-      if (isDirect && GetCG()->GenerateVerboseAsm()) {
+      if (isDirect && GetCG()->GenerateVerboseCG()) {
         insn.SetComment(key);
       }
       GetCurBB()->AppendInsn(insn);
@@ -272,7 +272,7 @@ void AArch64CGFunc::SelectStoreRelease(Operand &dest, PrimType dtype, Operand &s
   }
 
   std::string key;
-  if (isDirect && GetCG()->GenerateVerboseAsm()) {
+  if (isDirect && GetCG()->GenerateVerboseCG()) {
     const MIRSymbol *sym = static_cast<AArch64MemOperand*>(&dest)->GetSymbol();
     if (sym != nullptr) {
       MIRStorageClass sc = sym->GetStorageClass();
@@ -290,7 +290,7 @@ void AArch64CGFunc::SelectStoreRelease(Operand &dest, PrimType dtype, Operand &s
   /* Check if the right store-release instruction is available. */
   if (mOp != MOP_undef) {
     Insn &insn = GetCG()->BuildInstruction<AArch64Insn>(mOp, src, *newDest);
-    if (isDirect && GetCG()->GenerateVerboseAsm()) {
+    if (isDirect && GetCG()->GenerateVerboseCG()) {
       insn.SetComment(key);
     }
     GetCurBB()->AppendInsn(insn);
@@ -303,7 +303,7 @@ void AArch64CGFunc::SelectStoreRelease(Operand &dest, PrimType dtype, Operand &s
     mOp = (stype == PTY_f32) ? MOP_xvmovrs : MOP_xvmovrd;
     GetCurBB()->AppendInsn(GetCG()->BuildInstruction<AArch64Insn>(mOp, regOpnd, src));
     Insn &insn = GetCG()->BuildInstruction<AArch64Insn>(PickStInsn(dsize, itype, memOrd), regOpnd, *newDest);
-    if (isDirect && GetCG()->GenerateVerboseAsm()) {
+    if (isDirect && GetCG()->GenerateVerboseCG()) {
       insn.SetComment(key);
     }
     GetCurBB()->AppendInsn(insn);
@@ -435,7 +435,7 @@ void AArch64CGFunc::SelectCopyMemOpnd(Operand &dest, PrimType dtype, uint32 dsiz
     insn = &GetCG()->BuildInstruction<AArch64Insn>(PickLdInsn(ssize, stype), dest, src);
   }
 
-  if (GetCG()->GenerateVerboseAsm()) {
+  if (GetCG()->GenerateVerboseCG()) {
     const MIRSymbol *symSecond = static_cast<AArch64MemOperand*>(&src)->GetSymbol();
     if (symSecond != nullptr) {
       std::string key;
@@ -864,7 +864,7 @@ void AArch64CGFunc::SelectDassign(StIdx stIdx, FieldID fieldId, PrimType rhsPTyp
     mOp = PickStInsn(GetPrimTypeBitSize(ptyp), ptyp);
     Insn &insn = GetCG()->BuildInstruction<AArch64Insn>(mOp, stOpnd, *memOpnd);
 
-    if (GetCG()->GenerateVerboseAsm()) {
+    if (GetCG()->GenerateVerboseCG()) {
       const MIRSymbol *symSecond = static_cast<AArch64MemOperand*>(memOpnd)->GetSymbol();
       if (symSecond != nullptr) {
         std::string key;
@@ -893,7 +893,7 @@ void AArch64CGFunc::SelectAssertNull(UnaryStmtNode &stmt) {
   auto &mem = CreateMemOpnd(baseReg, 0, k32BitSize);
   Insn &loadRef = GetCG()->BuildInstruction<AArch64Insn>(MOP_wldr, zwr, mem);
   loadRef.SetDoNotRemove(true);
-  if (GetCG()->GenerateVerboseAsm()) {
+  if (GetCG()->GenerateVerboseCG()) {
     loadRef.SetComment("null pointer check");
   }
   GetCurBB()->AppendInsn(loadRef);
@@ -1362,7 +1362,7 @@ void AArch64CGFunc::SelectAddrof(Operand &result, StImmOperand &stImm) {
     }
 
     SelectAdd(result, *GetBaseReg(*symLoc), *offset, PTY_u64);
-    if (GetCG()->GenerateVerboseAsm()) {
+    if (GetCG()->GenerateVerboseCG()) {
       /* Add a comment */
       Insn *insn = GetCurBB()->GetLastInsn();
       std::string comm = "local/formal var: ";
@@ -1413,7 +1413,7 @@ Operand *AArch64CGFunc::SelectAddrof(AddrofNode &expr) {
      * adrp    x1, _PTR__cinf_Ljava_2Flang_2FSystem_3B
      * ldr     x1, [x1, #:lo12:_PTR__cinf_Ljava_2Flang_2FSystem_3B]
      */
-    std::string ptrName = NameMangler::kPtrPrefixStr + symbol->GetName();
+    std::string ptrName = namemangler::kPtrPrefixStr + symbol->GetName();
     MIRType *ptrType = GlobalTables::GetTypeTable().GetPtr();
     symbol = GetMirModule().GetMIRBuilder()->GetOrCreateGlobalDecl(ptrName, *ptrType);
     symbol->SetStorageClass(kScFstatic);
@@ -2827,18 +2827,15 @@ void AArch64CGFunc::SelectMinOrMax(bool isMin, Operand &resOpnd, Operand &opnd0,
   bool is64Bits = (dsize == k64BitSize);
   if (IsPrimitiveInteger(primType)) {
     RegOperand &regOpnd0 = LoadIntoRegister(opnd0, primType);
-    Operand *newOpnd1 = &opnd1;
-    if ((opnd1.GetKind() != Operand::kOpdImmediate) && (opnd1.GetKind() != Operand::kOpdOffset)) {
-      newOpnd1 = &LoadIntoRegister(opnd1, primType);
-    }
-    SelectAArch64Cmp(regOpnd0, *newOpnd1, true, dsize);
+    Operand &regOpnd1 = LoadIntoRegister(opnd1, primType);
+    SelectAArch64Cmp(regOpnd0, regOpnd1, true, dsize);
     Operand &newResOpnd = LoadIntoRegister(resOpnd, primType);
     if (isMin) {
       CondOperand &cc = IsSignedInteger(primType) ? GetCondOperand(CC_LT) : GetCondOperand(CC_LO);
-      SelectAArch64Select(newResOpnd, regOpnd0, *newOpnd1, cc, true, dsize);
+      SelectAArch64Select(newResOpnd, regOpnd0, regOpnd1, cc, true, dsize);
     } else {
       CondOperand &cc = IsSignedInteger(primType) ? GetCondOperand(CC_GT) : GetCondOperand(CC_HI);
-      SelectAArch64Select(newResOpnd, regOpnd0, *newOpnd1, cc, true, dsize);
+      SelectAArch64Select(newResOpnd, regOpnd0, regOpnd1, cc, true, dsize);
     }
   } else if (IsPrimitiveFloat(primType)) {
     RegOperand &regOpnd0 = LoadIntoRegister(opnd0, primType);
@@ -3945,7 +3942,7 @@ void AArch64CGFunc::GenerateYieldpoint(BB &bb) {
   auto &wzr = AArch64RegOperand::Get32bitZeroRegister();
   auto &pollingPage = CreateMemOpnd(RYP, 0, k32BitSize);
   auto &yieldPoint = GetCG()->BuildInstruction<AArch64Insn>(MOP_wldr, wzr, pollingPage);
-  if (GetCG()->GenerateVerboseAsm()) {
+  if (GetCG()->GenerateVerboseCG()) {
     yieldPoint.SetComment("yieldpoint");
   }
   bb.AppendInsn(yieldPoint);
@@ -4624,7 +4621,7 @@ Operand *AArch64CGFunc::SelectClearStackCallParam(const AddrofNode &expr, int64
   }
   offsetValue = offset->GetValue();
   SelectAdd(result, *GetBaseReg(*symLoc), *offset, PTY_u64);
-  if (GetCG()->GenerateVerboseAsm()) {
+  if (GetCG()->GenerateVerboseCG()) {
     /* Add a comment */
     Insn *insn = GetCurBB()->GetLastInsn();
     std::string comm = "local/formal var: ";
@@ -4885,7 +4882,7 @@ void AArch64CGFunc::IntrinsifyStringIndexOf(AArch64ListOperand &srcOpnds, const
   auto iter = opnds.begin();
   RegOperand *srcString = *iter;
   RegOperand *patternString = *(++iter);
-  GStrIdx gStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(NameMangler::kJavaLangStringStr);
+  GStrIdx gStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(namemangler::kJavaLangStringStr);
   MIRType *type =
       GlobalTables::GetTypeTable().GetTypeFromTyIdx(GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(gStrIdx));
   auto stringType = static_cast<MIRStructType*>(type);
@@ -4936,7 +4933,7 @@ void AArch64CGFunc::SelectCall(CallNode &callNode) {
   MIRSymbol *fsym = GetFunction().GetLocalOrGlobalSymbol(fn->GetStIdx(), false);
   MIRType *retType = fn->GetReturnType();
 
-  if (GetCG()->GenerateVerboseAsm()) {
+  if (GetCG()->GenerateVerboseCG()) {
     const std::string &comment = fsym->GetName();
     GetCurBB()->AppendInsn(CreateCommentInsn(comment));
   }
@@ -5149,8 +5146,7 @@ LabelOperand &AArch64CGFunc::GetOrCreateLabelOperand(LabelIdx labIdx) {
   if (it != hashLabelOpndTable.end()) {
     return *(it->second);
   }
-  MIRSymbol *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(GetFunction().GetStIdx().Idx());
-  const char *funcName = MapleString(funcSt->GetName(), memPool).c_str();
+  const char *funcName = GetShortFuncName().c_str();
   LabelOperand *res = memPool->New<LabelOperand>(funcName, labIdx);
   hashLabelOpndTable[labIdx] = res;
   return *res;
@@ -5431,7 +5427,7 @@ void AArch64CGFunc::SelectLibCall(const std::string &funcName, std::vector<Opera
   MIRType *retType = GlobalTables::GetTypeTable().GetTypeTable().at(static_cast<int32>(primType));
   st->SetTyIdx(GetBecommon().BeGetOrCreateFunctionType(retType->GetTypeIndex(), vec, vecAt)->GetTypeIndex());
 
-  if (GetCG()->GenerateVerboseAsm()) {
+  if (GetCG()->GenerateVerboseCG()) {
     const std::string &comment = "lib call : " + funcName;
     GetCurBB()->AppendInsn(CreateCommentInsn(comment));
   }
@@ -5948,7 +5944,7 @@ void AArch64CGFunc::SelectMPLProfCounterInc(IntrinsiccallNode &intrnNode) {
   vReg1.SetRegNotBBLocal();
   static MIRSymbol *bbProfileTab = nullptr;
   if (!bbProfileTab) {
-    std::string bbProfileName = NameMangler::kBBProfileTabPrefixStr + GetMirModule().GetFileNameAsPostfix();
+    std::string bbProfileName = namemangler::kBBProfileTabPrefixStr + GetMirModule().GetFileNameAsPostfix();
     bbProfileTab = GetMirModule().GetMIRBuilder()->GetGlobalDecl(bbProfileName);
     CHECK_FATAL(bbProfileTab != nullptr, "expect bb profile tab");
   }
@@ -5979,7 +5975,7 @@ void AArch64CGFunc::SelectMPLClinitCheck(IntrinsiccallNode &intrnNode) {
     ASSERT(symbol->GetName().find(CLASSINFO_PREFIX_STR) == 0, "must be a symbol with __classinfo__");
 
     if (!symbol->IsMuidDataUndefTab()) {
-      std::string ptrName = NameMangler::kPtrPrefixStr + symbol->GetName();
+      std::string ptrName = namemangler::kPtrPrefixStr + symbol->GetName();
       MIRType *ptrType = GlobalTables::GetTypeTable().GetPtr();
       symbol = GetMirModule().GetMIRBuilder()->GetOrCreateGlobalDecl(ptrName, *ptrType);
       bClinitSeperate = true;
@@ -6024,7 +6020,7 @@ void AArch64CGFunc::SelectMPLClinitCheck(IntrinsiccallNode &intrnNode) {
 void AArch64CGFunc::SelectIntrinCall(IntrinsiccallNode &intrinsiccallNode) {
   MIRIntrinsicID intrinsic = intrinsiccallNode.GetIntrinsic();
 
-  if (GetCG()->GenerateVerboseAsm()) {
+  if (GetCG()->GenerateVerboseCG()) {
     std::string comment = GetIntrinsicName(intrinsic);
     GetCurBB()->AppendInsn(CreateCommentInsn(comment));
   }
diff --git a/src/maple_be/src/cg/aarch64/aarch64_ebo.cpp b/src/maple_be/src/cg/aarch64/aarch64_ebo.cpp
index 9fd8f0fef8ee834893e4d4104f6ea6e11b369599..d740650cb60e4f4207a1342cc69fd68a0ecf09e9 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_ebo.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_ebo.cpp
@@ -440,21 +440,6 @@ bool AArch64Ebo::SimplifyConstOperand(Insn &insn, const MapleVector<Operand*> &o
     if (op->IsMemoryAccessOperand()) {
       op = &(insn.GetOperand(kInsnSecondOpnd));
     }
-  } else if (bothConstant) {
-    /* special orr insn :
-     * orr resOp, imm1, 0
-     * =======>
-     * mov resOp, #0 */
-    if ((insn.GetMachineOpcode() == MOP_wiorrri12) || (insn.GetMachineOpcode() == MOP_xiorrri13) ||
-        (insn.GetMachineOpcode() == MOP_xiorri13r) || (insn.GetMachineOpcode() == MOP_wiorri12r)) {
-      immOpnd = static_cast<AArch64ImmOperand*>(op1);
-      op = op0;
-      if (op->IsMemoryAccessOperand()) {
-        op = &(insn.GetOperand(kInsnSecondOpnd));
-      }
-    } else {
-      return false;
-    }
   } else if (bothConstant) {
     /* i) special orr insn, one of imm is 0:
      * orr resOp, imm1, #0  |  orr resOp, #0, imm1
@@ -469,21 +454,16 @@ bool AArch64Ebo::SimplifyConstOperand(Insn &insn, const MapleVector<Operand*> &o
         (insn.GetMachineOpcode() == MOP_xiorri13r) || (insn.GetMachineOpcode() == MOP_wiorri12r)) {
       AArch64ImmOperand *immOpnd0 = static_cast<AArch64ImmOperand*>(op0);
       AArch64ImmOperand *immOpnd1 = static_cast<AArch64ImmOperand*>(op1);
-      if (immOpnd0->IsZero() && immOpnd1->IsZero()) {
-        immOpnd = immOpnd0;
-        op = op0;
-      } else if (immOpnd0->IsZero()) {
-        immOpnd = immOpnd0;
+      immOpnd = immOpnd1;
+      op = op0;
+      if (immOpnd0->IsZero()) {
         op = op1;
-      } else if (immOpnd1->IsZero()) {
-        immOpnd = immOpnd1;
-        op = op0;
-      } else {
-        return false;
-      }
-      if (op->IsMemoryAccessOperand()) {
-        op = &(insn.GetOperand(kInsnSecondOpnd));
+        immOpnd = immOpnd0;
       }
+      MOperator mOp = opndSize == k64BitSize ? MOP_xmovri64 : MOP_xmovri32;
+      Insn &newInsn = cgFunc->GetCG()->BuildInstruction<AArch64Insn>(mOp, *res, *op);
+      bb->ReplaceInsn(insn, newInsn);
+      return true;
     } else {
       return false;
     }
diff --git a/src/maple_be/src/cg/aarch64/aarch64_emitter.cpp b/src/maple_be/src/cg/aarch64/aarch64_emitter.cpp
index 17e14810da9c3d09cfb3dffdafff73b17c938c31..9c3f22b58173450e8ec8ac36e1d9aca7027c92d1 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_emitter.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_emitter.cpp
@@ -81,20 +81,20 @@ void AArch64Emitter::EmitFastLSDA() {
   CG *currCG = cgFunc->GetCG();
 
   Emitter *emitter = currCG->GetEmitter();
-  const std::string &funcName = cgFunc->GetFunction().GetName();
+  const std::string &funcName = std::string(cgFunc->GetShortFuncName().c_str());
   /*
    * .word 0xFFFFFFFF
    * .word .Label.LTest_3B_7C_3Cinit_3E_7C_28_29V3-func_start_label
    */
   emitter->Emit("\t.word 0xFFFFFFFF\n");
-  emitter->Emit("\t.word .Label." + funcName + ".");
+  emitter->Emit("\t.word .L." + funcName + ".");
   if (aarchCGFunc->NeedCleanup()) {
     emitter->Emit(cgFunc->GetCleanupLabel()->GetLabelIdx());
   } else {
     ASSERT(!cgFunc->GetExitBBsVec().empty(), "exitbbsvec is empty in AArch64Emitter::EmitFastLSDA");
     emitter->Emit(cgFunc->GetExitBB(0)->GetLabIdx());
   }
-  emitter->Emit("-.Label." + funcName + ".")
+  emitter->Emit("-.L." + funcName + ".")
       .Emit(cgFunc->GetStartLabel()->GetLabelIdx())
       .Emit("\n");
   emitter->IncreaseJavaInsnCount();
@@ -112,7 +112,7 @@ void AArch64Emitter::EmitFullLSDA() {
   emitter->Emit("\t.align 2\n");
   /* emit LSDA header */
   LSDAHeader *lsdaHeader = ehFunc->GetLSDAHeader();
-  const std::string &funcName = cgFunc->GetFunction().GetName();
+  const std::string &funcName = std::string(cgFunc->GetShortFuncName().c_str());
   emitter->EmitStmtLabel(funcName, lsdaHeader->GetLSDALabel()->GetLabelIdx());
   emitter->Emit("\t.byte ").Emit(lsdaHeader->GetLPStartEncoding()).Emit("\n");
   emitter->Emit("\t.byte ").Emit(lsdaHeader->GetTTypeEncoding()).Emit("\n");
@@ -159,8 +159,8 @@ void AArch64Emitter::EmitFullLSDA() {
         emitter->EmitLabelPair(funcName, cleaupCode);
       } else if (cgFunc->GetFunction().IsJava()) {
         ASSERT(!cgFunc->GetExitBBsVec().empty(), "exitbbsvec is empty in AArch64Emitter::EmitFullLSDA");
-        emitter->Emit(".Label." + funcName).Emit(".").Emit(cgFunc->GetExitBB(0)->GetLabIdx());
-        emitter->Emit(" - .Label." + funcName).Emit(".").Emit(cgFunc->GetStartLabel()->GetLabelIdx()).Emit("\n");
+        emitter->Emit(".L." + funcName).Emit(".").Emit(cgFunc->GetExitBB(0)->GetLabIdx());
+        emitter->Emit(" - .L." + funcName).Emit(".").Emit(cgFunc->GetStartLabel()->GetLabelIdx()).Emit("\n");
       } else {
         emitter->Emit("0\n");
       }
@@ -196,8 +196,8 @@ void AArch64Emitter::EmitFullLSDA() {
       emitter->EmitLabelPair(funcName, cleaupCode);
     } else {
       ASSERT(!cgFunc->GetExitBBsVec().empty(), "exitbbsvec is empty in AArch64Emitter::EmitFullLSDA");
-      emitter->Emit(".Label." + funcName).Emit(".").Emit(cgFunc->GetExitBB(0)->GetLabIdx());
-      emitter->Emit(" - .Label." + funcName).Emit(".").Emit(cgFunc->GetStartLabel()->GetLabelIdx()).Emit("\n");
+      emitter->Emit(".L." + funcName).Emit(".").Emit(cgFunc->GetExitBB(0)->GetLabIdx());
+      emitter->Emit(" - .L." + funcName).Emit(".").Emit(cgFunc->GetStartLabel()->GetLabelIdx()).Emit("\n");
     }
     emitter->Emit("\t.uleb128 0\n");
     if (!cgFunc->GetFunction().IsJava()) {
@@ -255,11 +255,11 @@ void AArch64Emitter::EmitBBHeaderLabel(const std::string &name, LabelIdx labIdx)
     label.SetLabelOrder(currCG->GetLabelOrderCnt());
     currCG->IncreaseLabelOrderCnt();
   }
-  if (currCG->GenerateVerboseAsm()) {
-    emitter.Emit(".Label.").Emit(name).Emit(".").Emit(labIdx).Emit(":\t//label order ").Emit(label.GetLabelOrder());
+  if (currCG->GenerateVerboseCG()) {
+    emitter.Emit(".L.").Emit(name).Emit(".").Emit(labIdx).Emit(":\t//label order ").Emit(label.GetLabelOrder());
     emitter.Emit("\n");
   } else {
-    emitter.Emit(".Label.").Emit(name).Emit(".").Emit(labIdx).Emit(":\n");
+    emitter.Emit(".L.").Emit(name).Emit(".").Emit(labIdx).Emit(":\n");
   }
 }
 
@@ -287,13 +287,14 @@ void AArch64Emitter::Run() {
   EmitMethodDesc(emitter);
   /* emit java code to the java section. */
   if (cgFunc->GetFunction().IsJava()) {
-    std::string sectionName = NameMangler::kMuidJavatextPrefixStr;
+    std::string sectionName = namemangler::kMuidJavatextPrefixStr;
     emitter.Emit("\t.section  ." + sectionName + ",\"ax\"\n");
   } else {
     emitter.Emit("\t.text\n");
   }
   emitter.Emit("\t.align 2\n");
   MIRSymbol *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(cgFunc->GetFunction().GetStIdx().Idx());
+  const std::string &funcName = std::string(cgFunc->GetShortFuncName().c_str());
 
 
   if (funcSt->GetFunction()->GetAttr(FUNCATTR_weak)) {
@@ -328,12 +329,12 @@ void AArch64Emitter::Run() {
   }
   /* emit instructions */
   FOR_ALL_BB(bb, aarchCGFunc) {
-    if (currCG->GenerateVerboseAsm()) {
+    if (currCG->GenerateVerboseCG()) {
       emitter.Emit("#    freq:").Emit(bb->GetFrequency()).Emit("\n");
     }
     /* emit bb headers */
     if (bb->GetLabIdx() != 0) {
-      EmitBBHeaderLabel(funcSt->GetName(), bb->GetLabIdx());
+      EmitBBHeaderLabel(funcName, bb->GetLabIdx());
     }
 
     FOR_BB_INSNS(insn, bb) {
@@ -354,11 +355,9 @@ void AArch64Emitter::Run() {
       emitter.IncreaseJavaInsnCount();
     } else if (ehFunc->NeedFullLSDA()) {
       LSDAHeader *lsdaHeader = ehFunc->GetLSDAHeader();
-      MIRSymbol *funcSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(cgFunc->GetFunction().GetStIdx().Idx());
-      const std::string &funcName = funcSymbol->GetName();
       /*  .word .Label.lsda_label-func_start_label */
-      emitter.Emit("\t.word .Label." + funcName).Emit(".").Emit(lsdaHeader->GetLSDALabel()->GetLabelIdx());
-      emitter.Emit("-.Label." + funcName).Emit(".").Emit(cgFunc->GetStartLabel()->GetLabelIdx()).Emit("\n");
+      emitter.Emit("\t.word .L." + funcName).Emit(".").Emit(lsdaHeader->GetLSDALabel()->GetLabelIdx());
+      emitter.Emit("-.L." + funcName).Emit(".").Emit(cgFunc->GetStartLabel()->GetLabelIdx()).Emit("\n");
       emitter.IncreaseJavaInsnCount();
     } else if (ehFunc->NeedFastLSDA()) {
       EmitFastLSDA();
@@ -427,7 +426,7 @@ void AArch64Emitter::Run() {
     for (size_t i = 0; i < arrayConst->GetConstVec().size(); i++) {
       MIRLblConst *lblConst = safe_cast<MIRLblConst>(arrayConst->GetConstVecItem(i));
       CHECK_FATAL(lblConst != nullptr, "null ptr check");
-      emitter.Emit("\t.quad\t.Label." + funcSt->GetName()).Emit(".").Emit(lblConst->GetValue());
+      emitter.Emit("\t.quad\t.L." + funcName).Emit(".").Emit(lblConst->GetValue());
       emitter.Emit(" - " + st->GetName() + "\n");
       emitter.IncreaseJavaInsnCount(kQuadInsnCount);
     }
diff --git a/src/maple_be/src/cg/aarch64/aarch64_insn.cpp b/src/maple_be/src/cg/aarch64/aarch64_insn.cpp
index be41bcc1c0d1a967fb1af767d7b452ef8cdc2085..4a2e79ac4f5f0f7ce92ffe51733928b8e48f8810 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_insn.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_insn.cpp
@@ -650,7 +650,7 @@ void AArch64Insn::EmitClinit(const CG &cg, Emitter &emitter) const {
     emitter.Emit("\tadrp\t");
     opnd0->Emit(emitter, prop0);
     emitter.Emit(",");
-    emitter.Emit(NameMangler::kPtrPrefixStr + stImmOpnd->GetName());
+    emitter.Emit(namemangler::kPtrPrefixStr + stImmOpnd->GetName());
     emitter.Emit("\n");
 
     /* ldr     x3, [x3, #:lo12:_PTR__cinf_Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicInteger_3B] */
@@ -659,7 +659,7 @@ void AArch64Insn::EmitClinit(const CG &cg, Emitter &emitter) const {
     emitter.Emit(", [");
     opnd0->Emit(emitter, prop0);
     emitter.Emit(", #:lo12:");
-    emitter.Emit(NameMangler::kPtrPrefixStr + stImmOpnd->GetName());
+    emitter.Emit(namemangler::kPtrPrefixStr + stImmOpnd->GetName());
     emitter.Emit("]\n");
   }
   /* emit "ldr  x0,[x0,#48]" */
@@ -871,7 +871,7 @@ void AArch64Insn::Emit(const CG &cg, Emitter &emitter) const {
   emitter.SetCurrentMOP(mOp);
   const AArch64MD *md = &AArch64CG::kMd[mOp];
 
-  if (!cg.GenerateVerboseAsm() && mOp == MOP_comment) {
+  if (!cg.GenerateVerboseAsm() && !cg.GenerateVerboseCG() && mOp == MOP_comment) {
     return;
   }
 
@@ -1023,10 +1023,10 @@ void AArch64Insn::Emit(const CG &cg, Emitter &emitter) const {
       emitter.IncreaseJavaInsnCount(kLazyBindingRoutineInsnCount);
     }
   }
-  if (cg.GenerateVerboseAsm()) {
-    MapleString comment = GetComment();
-    if (comment.c_str() != nullptr && strlen(comment.c_str()) > 0) {
-      emitter.Emit("\t\t// ").Emit(comment.c_str());
+  if (cg.GenerateVerboseCG() || (cg.GenerateVerboseAsm() && mOp == MOP_comment)) {
+    const char *comment = GetComment().c_str();
+    if (comment != nullptr && strlen(comment) > 0) {
+      emitter.Emit("\t\t// ").Emit(comment);
     }
   }
 
diff --git a/src/maple_be/src/cg/aarch64/aarch64_proepilog.cpp b/src/maple_be/src/cg/aarch64/aarch64_proepilog.cpp
index 444ad8b2ba32b237237fa23eef9814d8c142c298..074ef4585c6fde07f44984f38d6de1755ec2b1b9 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_proepilog.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_proepilog.cpp
@@ -325,7 +325,7 @@ Insn &AArch64GenProEpilog::CreateAndAppendInstructionForAllocateCallFrame(int64
 void AArch64GenProEpilog::AppendInstructionAllocateCallFrame(AArch64reg reg0, AArch64reg reg1, RegType rty) {
   auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
   CG *currCG = cgFunc.GetCG();
-  if (currCG->GenerateVerboseAsm()) {
+  if (currCG->GenerateVerboseCG()) {
     cgFunc.GetCurBB()->AppendInsn(aarchCGFunc.CreateCommentInsn("allocate activation frame"));
   }
 
@@ -413,7 +413,7 @@ void AArch64GenProEpilog::AppendInstructionAllocateCallFrame(AArch64reg reg0, AA
 void AArch64GenProEpilog::AppendInstructionAllocateCallFrameDebug(AArch64reg reg0, AArch64reg reg1, RegType rty) {
   auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
   CG *currCG = cgFunc.GetCG();
-  if (currCG->GenerateVerboseAsm()) {
+  if (currCG->GenerateVerboseCG()) {
     cgFunc.GetCurBB()->AppendInsn(aarchCGFunc.CreateCommentInsn("allocate activation frame for debugging"));
   }
 
@@ -502,7 +502,7 @@ void AArch64GenProEpilog::GeneratePushRegs() {
   AArch64reg intRegFirstHalf = kRinvalid;
   AArch64reg fpRegFirstHalf = kRinvalid;
 
-  if (currCG->GenerateVerboseAsm()) {
+  if (currCG->GenerateVerboseCG()) {
     cgFunc.GetCurBB()->AppendInsn(aarchCGFunc.CreateCommentInsn("save callee-saved registers"));
   }
 
@@ -517,7 +517,7 @@ void AArch64GenProEpilog::GeneratePushRegs() {
     AppendInstructionAllocateCallFrameDebug(RFP, RLR, kRegTyInt);
   }
 
-  if (currCG->GenerateVerboseAsm()) {
+  if (currCG->GenerateVerboseCG()) {
     cgFunc.GetCurBB()->AppendInsn(aarchCGFunc.CreateCommentInsn("copy SP to FP"));
   }
   Operand &spOpnd = aarchCGFunc.GetOrCreatePhysicalRegisterOperand(RSP, k64BitSize, kRegTyInt);
@@ -596,7 +596,7 @@ void AArch64GenProEpilog::AppendInstructionStackCheck(AArch64reg reg, RegType rt
   auto &wzr = AArch64RegOperand::Get32bitZeroRegister();
   auto &refX16 = aarchCGFunc.CreateMemOpnd(reg, 0, k64BitSize);
   auto &soeInstr = currCG->BuildInstruction<AArch64Insn>(MOP_wldr, wzr, refX16);
-  if (currCG->GenerateVerboseAsm()) {
+  if (currCG->GenerateVerboseCG()) {
     soeInstr.SetComment("soerror");
   }
   soeInstr.SetDoNotRemove(true);
@@ -627,7 +627,7 @@ void AArch64GenProEpilog::GenerateProlog(BB &bb) {
   } else {
     int32 stackFrameSize = static_cast<AArch64MemLayout*>(cgFunc.GetMemlayout())->RealStackFrameSize();
     if (stackFrameSize > 0) {
-      if (currCG->GenerateVerboseAsm()) {
+      if (currCG->GenerateVerboseCG()) {
         cgFunc.GetCurBB()->AppendInsn(aarchCGFunc.CreateCommentInsn("allocate activation frame"));
       }
       Operand &immOpnd = aarchCGFunc.CreateImmOperand(stackFrameSize, k32BitSize, true);
@@ -636,7 +636,7 @@ void AArch64GenProEpilog::GenerateProlog(BB &bb) {
       int32 offset = stackFrameSize;
       (void)InsertCFIDefCfaOffset(offset, *(cgFunc.GetCurBB()->GetLastInsn()));
     }
-    if (currCG->GenerateVerboseAsm()) {
+    if (currCG->GenerateVerboseCG()) {
       cgFunc.GetCurBB()->AppendInsn(aarchCGFunc.CreateCommentInsn("copy SP to FP"));
     }
     int64 argsToStkPassSize = cgFunc.GetMemlayout()->SizeOfArgsToStackPass();
@@ -859,7 +859,7 @@ void AArch64GenProEpilog::GeneratePopRegs() {
   AArch64reg intRegFirstHalf = kRinvalid;
   AArch64reg fpRegFirstHalf = kRinvalid;
 
-  if (currCG->GenerateVerboseAsm()) {
+  if (currCG->GenerateVerboseCG()) {
     cgFunc.GetCurBB()->AppendInsn(aarchCGFunc.CreateCommentInsn("restore callee-saved registers"));
   }
 
@@ -980,7 +980,7 @@ void AArch64GenProEpilog::GenerateEpilog(BB &bb) {
   } else {
     int32 stackFrameSize = static_cast<AArch64MemLayout*>(cgFunc.GetMemlayout())->RealStackFrameSize();
     if (stackFrameSize > 0) {
-      if (currCG->GenerateVerboseAsm()) {
+      if (currCG->GenerateVerboseCG()) {
         cgFunc.GetCurBB()->AppendInsn(aarchCGFunc.CreateCommentInsn("pop up activation frame"));
       }
 
diff --git a/src/maple_be/src/cg/aarch64/aarch64_yieldpoint.cpp b/src/maple_be/src/cg/aarch64/aarch64_yieldpoint.cpp
index d78a3609632ddb8d072bb58070f62c37a41343af..e1f9564dd7a6f1c04dde9cb6784c2fccd40e4209 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_yieldpoint.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_yieldpoint.cpp
@@ -52,49 +52,11 @@ void AArch64YieldPointInsertion::InsertYieldPoint() {
    * for BBs after firstbb.
    */
   for (BB *bb = aarchCGFunc->GetFirstBB()->GetNext(); bb != nullptr; bb = bb->GetNext()) {
-    if (Globals::GetInstance()->GetOptimLevel() > 0) {
-      /* insert a yieldpoint before the last jump instruction of a goto BB. */
-      if (bb->IsBackEdgeDest()) {
-        aarchCGFunc->GetDummyBB()->ClearInsns();
-        aarchCGFunc->GenerateYieldpoint(*aarchCGFunc->GetDummyBB());
-        bb->InsertAtBeginning(*aarchCGFunc->GetDummyBB());
-        continue;
-      }
-    } else {
-      /* when -O0, there is no backedge info available. */
-      if ((bb->GetKind() == BB::kBBGoto) && (bb->GetLastInsn() != nullptr) && bb->GetLastInsn()->IsBranch()) {
-        aarchCGFunc->GetDummyBB()->ClearInsns();
-        aarchCGFunc->GenerateYieldpoint(*aarchCGFunc->GetDummyBB());
-        bb->InsertAtBeginning(*aarchCGFunc->GetDummyBB());
-        continue;
-      }
-      /*
-       * insert yieldpoint for empty loop (CondGoto backward),
-       * aka. last instruction jump to the top of the BB.
-       */
-      if (bb->GetLastInsn() != nullptr && bb->GetLastInsn()->IsBranch()) {
-        /* the jump instruction. */
-        Insn *jump = bb->GetLastInsn();
-        /* skip if no jump target. */
-        if (jump->GetOpndNum() == 0) {
-          continue;
-        }
-        /* get the jump target operand. */
-        Operand *op = jump->GetOpnd(jump->GetOpndNum() - 1);
-        /* last operand not found or not a label operand. */
-        if (op == nullptr || !op->IsLabel() || !op->IsLabelOpnd()) {
-          continue;
-        }
-        /* the label operand of the jump instruction. */
-        LabelOperand *label = static_cast<LabelOperand*>(op);
-        if (label->GetLabelIndex() != bb->GetLabIdx()) {
-          continue;
-        }
-        /* insert yieldpoint before jump instruction. */
-        aarchCGFunc->GetDummyBB()->ClearInsns();
-        aarchCGFunc->GenerateYieldpoint(*aarchCGFunc->GetDummyBB());
-        bb->InsertAtBeginning(*aarchCGFunc->GetDummyBB());
-      }
+    /* insert a yieldpoint at beginning if BB is BackEdgeDest. */
+    if (bb->IsBackEdgeDest()) {
+      aarchCGFunc->GetDummyBB()->ClearInsns();
+      aarchCGFunc->GenerateYieldpoint(*aarchCGFunc->GetDummyBB());
+      bb->InsertAtBeginning(*aarchCGFunc->GetDummyBB());
     }
   }
 }
diff --git a/src/maple_be/src/cg/cg.cpp b/src/maple_be/src/cg/cg.cpp
index af4cf45d2dc1931ad9420f65592683070f9d6825..64cc3a34411434c6532a020c77f082535abf407a 100644
--- a/src/maple_be/src/cg/cg.cpp
+++ b/src/maple_be/src/cg/cg.cpp
@@ -256,4 +256,30 @@ std::vector<int64> CG::GetReferenceOffsets64(const BECommon &beCommon, MIRStruct
 
   return result;
 }
+
+
+const std::string CG::ExtractFuncName(const std::string &str) {
+  /* 3: length of "_7C" */
+  size_t offset = 3;
+  size_t pos1 = str.find("_7C");
+  if (pos1 == std::string::npos) {
+    return str;
+  }
+  size_t pos2 = str.find("_7C", pos1 + offset);
+  if (pos2 == std::string::npos) {
+    return str;
+  }
+  std::string funcName = str.substr(pos1 + offset, pos2 - pos1 - offset);
+  /* avoid funcName like __LINE__ and __FILE__ which will be resolved by assembler */
+  if (funcName.find("__") != std::string::npos) {
+    return str;
+  }
+  if (funcName == "_3Cinit_3E") {
+    return "init";
+  }
+  if (funcName == "_3Cclinit_3E") {
+    return "clinit";
+  }
+  return funcName;
+}
 }  /* namespace maplebe */
diff --git a/src/maple_be/src/cg/cg_option.cpp b/src/maple_be/src/cg/cg_option.cpp
index 7395c1cdbde07a2091076ee2aef4b3bae6893037..c5a87b6cd8ff8a96045d8da57e0c26ada650a3bb 100644
--- a/src/maple_be/src/cg/cg_option.cpp
+++ b/src/maple_be/src/cg/cg_option.cpp
@@ -84,6 +84,7 @@ enum OptionIndex : uint64 {
   kPie,
   kPic,
   kCGVerbose,
+  kCGVerboseCG,
   kCGMapleLinker,
   kCgen,
   kEbo,
@@ -175,6 +176,16 @@ const Descriptor kUsage[] = {
     "  --no-verbose-asm\n",
     "mplcg",
     {} },
+  { kCGVerboseCG,
+    kEnable,
+    "",
+    "verbose-cg",
+    kBuildTypeProduct,
+    kArgCheckPolicyBool,
+    "  --verbose-cg               \tAdd comments to cg output\n"
+    "  --no-verbose-cg\n",
+    "mplcg",
+    {} },
   { kCGMapleLinker,
     kEnable,
     "",
@@ -800,6 +811,10 @@ bool CGOptions::SolveOptions(const std::vector<Option> &opts, bool isDebug) {
         (opt.Type() == kEnable) ? SetOption(CGOptions::kVerboseAsm)
                                 : ClearOption(CGOptions::kVerboseAsm);
         break;
+      case kCGVerboseCG:
+        (opt.Type() == kEnable) ? SetOption(CGOptions::kVerboseCG)
+                                : ClearOption(CGOptions::kVerboseCG);
+        break;
       case kCGMapleLinker:
         (opt.Type() == kEnable) ? EnableMapleLinker() : DisableMapleLinker();
         break;
diff --git a/src/maple_be/src/cg/cg_phasemanager.cpp b/src/maple_be/src/cg/cg_phasemanager.cpp
index 0ba991c0594538fa73cbb6be7a543e79d91da82d..92f2938ccba85749c14b3f14c27dda99d5b5eb79 100644
--- a/src/maple_be/src/cg/cg_phasemanager.cpp
+++ b/src/maple_be/src/cg/cg_phasemanager.cpp
@@ -105,6 +105,7 @@ void CgFuncPhaseManager::AddPhases(std::vector<std::string> &phases) {
         ADDPHASE("cfgo");
       }
 
+#if TARGAARCH64
       if (JAVALANG && CGOptions::DoStoreLoadOpt()) {
         ADDPHASE("storeloadopt");
       }
@@ -116,6 +117,7 @@ void CgFuncPhaseManager::AddPhases(std::vector<std::string> &phases) {
       if ((JAVALANG && CGOptions::DoStoreLoadOpt()) || CGOptions::DoGlobalOpt()) {
         ADDPHASE("clearrdinfo");
       }
+#endif
 
       if (CGOptions::DoPrePeephole()) {
         ADDPHASE("prepeephole1");
diff --git a/src/maple_be/src/cg/cgfunc.cpp b/src/maple_be/src/cg/cgfunc.cpp
index c58641a92b3c768709168683705107cb4c727311..3a28aa461b8b6f04d5a2f56e746a32490e861a76 100644
--- a/src/maple_be/src/cg/cgfunc.cpp
+++ b/src/maple_be/src/cg/cgfunc.cpp
@@ -609,7 +609,7 @@ void HandleMembar(StmtNode &stmt, CGFunc &cgFunc) {
 }
 
 void HandleComment(StmtNode &stmt, CGFunc &cgFunc) {
-  if (cgFunc.GetCG()->GenerateVerboseAsm()) {
+  if (cgFunc.GetCG()->GenerateVerboseAsm() || cgFunc.GetCG()->GenerateVerboseCG()) {
     cgFunc.SelectComment(static_cast<CommentNode&>(stmt));
   }
 }
@@ -653,7 +653,7 @@ void InitHandleStmtFactory() {
 }
 
 CGFunc::CGFunc(MIRModule &mod, CG &cg, MIRFunction &mirFunc, BECommon &beCommon, MemPool &memPool,
-               MapleAllocator &allocator)
+               MapleAllocator &allocator, uint32 funcId)
     : vRegTable(allocator.Adapter()),
       vRegOperandTable(std::less<regno_t>(), allocator.Adapter()),
       pRegSpillMemOperands(std::less<PregIdx>(), allocator.Adapter()),
@@ -670,7 +670,12 @@ CGFunc::CGFunc(MIRModule &mod, CG &cg, MIRFunction &mirFunc, BECommon &beCommon,
       beCommon(beCommon),
       funcScopeAllocator(&allocator),
       emitStVec(allocator.Adapter()),
-      loops(allocator.Adapter()) {
+#if TARGARM32
+      sortedBBs(allocator.Adapter()),
+      lrVec(allocator.Adapter()),
+#endif  /* TARGARM32 */
+      loops(allocator.Adapter()),
+      shortFuncName(cg.ExtractFuncName(mirFunc.GetName()) + "." + std::to_string(funcId), &memPool) {
   mirModule.SetCurFunction(&func);
   dummyBB = CreateNewBB();
   vRegCount = firstMapleIrVRegNO + func.GetPregTab()->Size();
diff --git a/src/maple_be/src/cg/ebo.cpp b/src/maple_be/src/cg/ebo.cpp
index 5e675ebcd3f15d7560d4f967e42ba294a25bfcb9..cbb604b3f53da6026274312e03a97547fdec324c 100644
--- a/src/maple_be/src/cg/ebo.cpp
+++ b/src/maple_be/src/cg/ebo.cpp
@@ -1075,7 +1075,9 @@ can_be_removed:
     insnInfo->bb = nullptr;
     for (uint32 i = 0; i < resNum; i++) {
       opndInfo = insnInfo->result[i];
-      ASSERT(opndInfo != nullptr, "null ptr check");
+      if (opndInfo == nullptr) {
+        continue;
+      }
       if (opndInfo->redefined && (opndInfo->same != nullptr)) {
         OpndInfo *next = opndInfo->same;
         next->redefined = true;
diff --git a/src/maple_be/src/cg/emit.cpp b/src/maple_be/src/cg/emit.cpp
index be48740f9bd7488ee8f85d9421c4fc2d59ed0346..bbfdb4ad4faeaa5eebfd3478efc937ed58158757 100644
--- a/src/maple_be/src/cg/emit.cpp
+++ b/src/maple_be/src/cg/emit.cpp
@@ -21,7 +21,7 @@
 #include "muid_replacement.h"
 #include "metadata_layout.h"
 #include "string_utils.h"
-using namespace NameMangler;
+using namespace namemangler;
 
 namespace {
 using namespace maple;
@@ -63,7 +63,7 @@ using namespace maple;
 using namespace cfi;
 
 void Emitter::EmitLabelRef(const std::string &name, LabelIdx labIdx) {
-  outStream << ".Label." << name << "." << labIdx;
+  outStream << ".L." << name << "." << labIdx;
 }
 
 void Emitter::EmitStmtLabel(const std::string &name, LabelIdx labIdx) {
@@ -73,8 +73,8 @@ void Emitter::EmitStmtLabel(const std::string &name, LabelIdx labIdx) {
 
 void Emitter::EmitLabelPair(const std::string &name, const LabelPair &pairLabel) {
   ASSERT(pairLabel.GetEndOffset() || pairLabel.GetStartOffset(), "NYI");
-  outStream << ".Label." << name << "." << pairLabel.GetEndOffset()->GetLabelIdx() << " - "
-            << ".Label." << name << "." << pairLabel.GetStartOffset()->GetLabelIdx() << "\n";
+  outStream << ".L." << name << "." << pairLabel.GetEndOffset()->GetLabelIdx() << " - "
+            << ".L." << name << "." << pairLabel.GetStartOffset()->GetLabelIdx() << "\n";
 }
 
 AsmLabel Emitter::GetTypeAsmInfoName(PrimType primType) const {
@@ -928,7 +928,7 @@ MIRAddroffuncConst *Emitter::GetAddroffuncConst(const MIRSymbol &mirSymbol, MIRA
       innerFuncAddr = safe_cast<MIRAddroffuncConst>(funcAddrConst);
     } else if (funcAddrConst->GetKind() == kConstInt) {
       /* def table index, replaced by def table for lazybinding. */
-      std::string funcDefTabName = NameMangler::kMuidFuncDefTabPrefixStr + cg->GetMIRModule()->GetFileNameAsPostfix();
+      std::string funcDefTabName = namemangler::kMuidFuncDefTabPrefixStr + cg->GetMIRModule()->GetFileNameAsPostfix();
       MIRSymbol *funDefTabSy = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
           GlobalTables::GetStrTable().GetStrIdxFromName(funcDefTabName));
       MIRAggConst &funDefTabAggConst = static_cast<MIRAggConst&>(*funDefTabSy->GetKonst());
@@ -1309,7 +1309,7 @@ void Emitter::EmitConstantTable(const MIRSymbol &mirSymbol, MIRConst &mirConst,
         EmitIntConst(mirSymbol, aggConst, itabConflictIndex, strIdx2Type, i);
       }
     } else if (elemConst->GetType().GetKind() == kTypeArray || elemConst->GetType().GetKind() == kTypeStruct) {
-      if (StringUtils::StartsWith(mirSymbol.GetName(), NameMangler::kOffsetTabStr) && (i == 0 || i == 1)) {
+      if (StringUtils::StartsWith(mirSymbol.GetName(), namemangler::kOffsetTabStr) && (i == 0 || i == 1)) {
         // EmitOffsetValueTable
 #ifdef USE_32BIT_REF
         Emit("\t.long\t");
@@ -1317,9 +1317,9 @@ void Emitter::EmitConstantTable(const MIRSymbol &mirSymbol, MIRConst &mirConst,
         Emit("\t.quad\t");
 #endif
         if (i == 0) {
-          Emit(NameMangler::kVtabOffsetTabStr + cg->GetMIRModule()->GetFileNameAsPostfix() + " - .\n");
+          Emit(namemangler::kVtabOffsetTabStr + cg->GetMIRModule()->GetFileNameAsPostfix() + " - .\n");
         } else {
-          Emit(NameMangler::kFieldOffsetTabStr + cg->GetMIRModule()->GetFileNameAsPostfix() + " - .\n");
+          Emit(namemangler::kFieldOffsetTabStr + cg->GetMIRModule()->GetFileNameAsPostfix() + " - .\n");
         }
       } else {
         EmitConstantTable(mirSymbol, *elemConst, strIdx2Type);
@@ -1555,7 +1555,7 @@ void Emitter::GetHotAndColdMetaSymbolInfo(const std::vector<MIRSymbol*> &mirSymb
     CHECK_FATAL(prefixStr.length() < mirSymbol->GetName().length(), "string length check");
     std::string name = mirSymbol->GetName().substr(prefixStr.length());
     std::string klassJavaDescriptor;
-    NameMangler::DecodeMapleNameToJavaDescriptor(name, klassJavaDescriptor);
+    namemangler::DecodeMapleNameToJavaDescriptor(name, klassJavaDescriptor);
     if (isHot && !forceCold) {
       hotFieldInfoSymbolVec.push_back(mirSymbol);
     } else {
@@ -1745,10 +1745,10 @@ void Emitter::EmitGlobalVariable() {
     } else if (mirSymbol->GetName().find(kLocalClassInfoStr) == 0) {
       localClassInfoVec.push_back(mirSymbol);
       continue;
-    } else if (StringUtils::StartsWith(mirSymbol->GetName(), NameMangler::kDecoupleStaticKeyStr)) {
+    } else if (StringUtils::StartsWith(mirSymbol->GetName(), namemangler::kDecoupleStaticKeyStr)) {
       staticDecoupleKeyVec.push_back(mirSymbol);
       continue;
-    } else if (StringUtils::StartsWith(mirSymbol->GetName(), NameMangler::kDecoupleStaticValueStr)) {
+    } else if (StringUtils::StartsWith(mirSymbol->GetName(), namemangler::kDecoupleStaticValueStr)) {
       staticDecoupleValueVec.push_back(mirSymbol);
       continue;
     } else if (mirSymbol->IsLiteral()) {
@@ -2291,12 +2291,12 @@ void Emitter::EmitHexUnsigned(uint64 num) {
 #define str(s) #s
 
 void Emitter::EmitDIHeader() {
-  Emit("\t.section ." + std::string(NameMangler::kMuidJavatextPrefixStr) + ",\"ax\"\n");
+  Emit("\t.section ." + std::string(namemangler::kMuidJavatextPrefixStr) + ",\"ax\"\n");
   Emit(".L" XSTR(TEXT_BEGIN) ":\n");
 }
 
 void Emitter::EmitDIFooter() {
-  Emit("\t.section ." + std::string(NameMangler::kMuidJavatextPrefixStr) + ",\"ax\"\n");
+  Emit("\t.section ." + std::string(namemangler::kMuidJavatextPrefixStr) + ",\"ax\"\n");
   Emit(".L" XSTR(TEXT_END) ":\n");
 }
 
@@ -2313,7 +2313,7 @@ void Emitter::EmitHugeSoRoutines(bool lastRoutine) {
     return;
   }
   for (auto &target : hugeSoTargets) {
-    Emit("\t.section ." + std::string(NameMangler::kMuidJavatextPrefixStr) + ",\"ax\"\n");
+    Emit("\t.section ." + std::string(namemangler::kMuidJavatextPrefixStr) + ",\"ax\"\n");
     Emit("\t.align 2\n");
     std::string routineName = target + HugeSoPostFix();
     Emit("\t.type\t" + routineName + ", %function\n");
@@ -2333,7 +2333,7 @@ void ImmOperand::Dump() const {
 
 void LabelOperand::Emit(Emitter &emitter, const OpndProp *opndProp) const {
   (void)opndProp;
-  emitter.Emit(".Label.").Emit(parentFunc).Emit(".").Emit(labelIndex);
+  emitter.Emit(".L.").Emit(parentFunc).Emit(".").Emit(labelIndex);
 }
 
 void LabelOperand::Dump() const {
diff --git a/src/maple_driver/src/driver_runner.cpp b/src/maple_driver/src/driver_runner.cpp
index c323067d0d10eae35a12b61c8c709141f750b15e..26c15218a422ad85a318006c3477b86bcf355324 100644
--- a/src/maple_driver/src/driver_runner.cpp
+++ b/src/maple_driver/src/driver_runner.cpp
@@ -332,7 +332,7 @@ CG *DriverRunner::CreateCGAndBeCommon(const std::string &outputFile, const std::
 void DriverRunner::RunCGFunctions(CG &cg, CgFuncPhaseManager &cgfpm) const {
   MIRLower mirLowerer(*theModule, nullptr);
   mirLowerer.Init();
-  CGLowerer theLowerer(*theModule, *beCommon, cg.GenerateExceptionHandlingCode(), cg.GenerateVerboseAsm());
+  CGLowerer theLowerer(*theModule, *beCommon, cg.GenerateExceptionHandlingCode(), cg.GenerateVerboseCG());
   theLowerer.RegisterBuiltIns();
   theLowerer.RegisterExternalLibraryFunctions();
   theLowerer.SetCheckLoadStore(CGOptions::IsCheckArrayStore());
@@ -343,6 +343,7 @@ void DriverRunner::RunCGFunctions(CG &cg, CgFuncPhaseManager &cgfpm) const {
 
 
   unsigned long rangeNum = 0;
+  uint32 countFuncId = 0;
   for (auto it = theModule->GetFunctionList().begin(); it != theModule->GetFunctionList().end(); ++it) {
     MIRFunction *mirFunc = *it;
     if (mirFunc->GetBody() == nullptr) {
@@ -377,7 +378,8 @@ void DriverRunner::RunCGFunctions(CG &cg, CgFuncPhaseManager &cgfpm) const {
     MapleAllocator funcScopeAllocator(funcMp);
 
     // Create CGFunc
-    CGFunc *cgFunc = cg.CreateCGFunc(*theModule, *mirFunc, *beCommon, *funcMp, funcScopeAllocator);
+    mirFunc->SetPuidxOrigin(++countFuncId);
+    CGFunc *cgFunc = cg.CreateCGFunc(*theModule, *mirFunc, *beCommon, *funcMp, funcScopeAllocator, countFuncId);
     CHECK_FATAL(cgFunc != nullptr, "nullptr check");
     CG::SetCurCGFunc(*cgFunc);
 
diff --git a/src/maple_ipa/include/module_phases.def b/src/maple_ipa/include/module_phases.def
index 2e78edcf3a05a274cea190ac5e1c197d18219432..ddecb1390f61501fb551a9b9b42a563afcad1af1 100644
--- a/src/maple_ipa/include/module_phases.def
+++ b/src/maple_ipa/include/module_phases.def
@@ -20,6 +20,7 @@ MODAPHASE(MoPhase_CALLGRAPH_ANALYSIS, DoCallGraph)
 MODTPHASE(MoPhase_GENNATIVESTUBFUNC, DoGenerateNativeStubFunc)
 MODAPHASE(MoPhase_VTABLEANALYSIS, DoVtableAnalysis)
 MODAPHASE(MoPhase_REFLECTIONANALYSIS, DoReflectionAnalysis)
+MODAPHASE(MoPhase_ANNOTATIONANALYSIS, DoAnnotationAnalysis)
 MODTPHASE(MoPhase_VTABLEIMPL, DoVtableImpl)
 MODTPHASE(MoPhase_JAVAINTRNLOWERING, DoJavaIntrnLowering)
 MODTPHASE(MoPhase_JAVAEHLOWER, JavaEHLowererPhase)
diff --git a/src/maple_ipa/include/retype.h b/src/maple_ipa/include/retype.h
index 456524adcfdc781cc77678c255bf0638f74e6919..670a5ab713a934673a98f263a45cf6fd630cd34a 100644
--- a/src/maple_ipa/include/retype.h
+++ b/src/maple_ipa/include/retype.h
@@ -25,13 +25,15 @@ class Retype {
 
   virtual ~Retype() {}
 
-  void ReplaceRetypeExpr(const BaseNode &opnd) const;
-  void RetypeStmt(MIRFunction &func) const;
-  void DoRetype() const;
+  void ReplaceRetypeExpr(const BaseNode &opnd);
+  void RetypeStmt(MIRFunction &func);
+  void DoRetype();
 
  private:
   MIRModule *mirModule;
   MapleAllocator allocator;
+  std::map<GStrIdx, MIRAliasVars> reg2varGenericInfo;
+  void TransmitGenericInfo(MIRFunction &func, StmtNode &stmt);
 };
 }  // namespace maple
 #endif  // MAPLE_IPA_INCLUDE_RETYPE_H
diff --git a/src/maple_ipa/src/callgraph.cpp b/src/maple_ipa/src/callgraph.cpp
index 44b9865e705c9413dda19e1aa4567db10b17eea5..afbfe8162f669ec4e6e881dfa201e42cd738955f 100644
--- a/src/maple_ipa/src/callgraph.cpp
+++ b/src/maple_ipa/src/callgraph.cpp
@@ -328,7 +328,7 @@ CGNode *CallGraph::GetOrGenCGNode(PUIdx puIdx, bool isVcall, bool isIcall) {
     MIRFunction *mirFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
     Klass *klass = nullptr;
     if (StringUtils::StartsWith(mirFunc->GetBaseClassName(), JARRAY_PREFIX_STR)) { // Array
-      klass = klassh->GetKlassFromName(NameMangler::kJavaLangObjectStr);
+      klass = klassh->GetKlassFromName(namemangler::kJavaLangObjectStr);
     } else {
       klass = klassh->GetKlassFromStrIdx(mirFunc->GetBaseClassNameStrIdx());
     }
@@ -371,7 +371,7 @@ CGNode *CallGraph::GetOrGenCGNode(PUIdx puIdx, bool isVcall, bool isIcall) {
   if (isIcall && !node->IsIcallCandidatesValid()) {
     Klass *CallerKlass = nullptr;
     if (StringUtils::StartsWith(CurFunction()->GetBaseClassName(), JARRAY_PREFIX_STR)) { // Array
-      CallerKlass = klassh->GetKlassFromName(NameMangler::kJavaLangObjectStr);
+      CallerKlass = klassh->GetKlassFromName(namemangler::kJavaLangObjectStr);
     } else {
       CallerKlass = klassh->GetKlassFromStrIdx(CurFunction()->GetBaseClassNameStrIdx());
     }
@@ -382,7 +382,7 @@ CGNode *CallGraph::GetOrGenCGNode(PUIdx puIdx, bool isVcall, bool isIcall) {
     MIRFunction *mirFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
     Klass *klass = nullptr;
     if (StringUtils::StartsWith(mirFunc->GetBaseClassName(), JARRAY_PREFIX_STR)) {  // Array
-      klass = klassh->GetKlassFromName(NameMangler::kJavaLangObjectStr);
+      klass = klassh->GetKlassFromName(namemangler::kJavaLangObjectStr);
     } else {
       klass = klassh->GetKlassFromStrIdx(mirFunc->GetBaseClassNameStrIdx());
     }
@@ -466,7 +466,7 @@ void CallGraph::HandleBody(MIRFunction &func, BlockNode &body, CGNode &node, uin
                     calleePUIdx = method->GetPuidx();
                   } else {
                     std::string funcName = klass->GetKlassName();
-                    funcName.append((NameMangler::kNameSplitterStr));
+                    funcName.append((namemangler::kNameSplitterStr));
                     funcName.append(calleefuncT->GetBaseFuncNameWithType());
                     MIRFunction *methodT = mirBuilder->GetOrCreateFunction(funcName, (TyIdx) (PTY_void));
                     methodT->SetBaseClassNameStrIdx(klass->GetKlassNameStrIdx());
@@ -637,9 +637,9 @@ void IPODevirtulize::SearchDefInClinit(const Klass &klass) {
     }
   }
   std::string typeName = klass.GetKlassName();
-  typeName.append(NameMangler::kClinitSuffix);
+  typeName.append(namemangler::kClinitSuffix);
   GStrIdx clinitFuncGstridx =
-      GlobalTables::GetStrTable().GetStrIdxFromName(NameMangler::GetInternalNameLiteral(typeName));
+      GlobalTables::GetStrTable().GetStrIdxFromName(namemangler::GetInternalNameLiteral(typeName));
   if (clinitFuncGstridx == 0u) {
     return;
   }
@@ -701,7 +701,7 @@ void IPODevirtulize::SearchDefInClinit(const Klass &klass) {
       case OP_callassigned: {
         CallNode *callNode = static_cast<CallNode*>(stmt);
         MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode->GetPUIdx());
-        if (calleeFunc->GetName().find(NameMangler::kClinitSubStr, 0) != std::string::npos ||
+        if (calleeFunc->GetName().find(namemangler::kClinitSubStr, 0) != std::string::npos ||
             calleeFunc->GetName().find("MCC_", 0) == 0) {
           // ignore all side effect of initizlizor
           continue;
@@ -751,7 +751,7 @@ void IPODevirtulize::SearchDefInMemberMethods(const Klass &klass) {
   }
   std::vector<MIRFunction*> initMethods;
   std::string typeName = klass.GetKlassName();
-  typeName.append(NameMangler::kCinitStr);
+  typeName.append(namemangler::kCinitStr);
   for (MIRFunction *const &method : klass.GetMethods()) {
     if (!strncmp(method->GetName().c_str(), typeName.c_str(), typeName.length())) {
       initMethods.push_back(method);
@@ -799,7 +799,7 @@ void IPODevirtulize::SearchDefInMemberMethods(const Klass &klass) {
         case OP_callassigned: {
           CallNode *callNode = static_cast<CallNode*>(stmt);
           MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode->GetPUIdx());
-          if (calleeFunc->GetName().find(NameMangler::kClinitSubStr, 0) != std::string::npos) {
+          if (calleeFunc->GetName().find(namemangler::kClinitSubStr, 0) != std::string::npos) {
             // ignore all side effect of initizlizor
             continue;
           }
diff --git a/src/maple_ipa/src/clone.cpp b/src/maple_ipa/src/clone.cpp
index 316b9510242c6e6dcdc5a04fc1f807067e2b8a18..8fc5174c60d3464f790631d8d8b7f4644ea8e324 100644
--- a/src/maple_ipa/src/clone.cpp
+++ b/src/maple_ipa/src/clone.cpp
@@ -46,8 +46,8 @@ std::string ReplaceRetIgnored::GenerateNewFullName(const MIRFunction &originalFu
   const std::string &oldSignature = originalFunc.GetSignature();
   auto retPos = oldSignature.find("_29");
   constexpr auto retPosIndex = 3;
-  return std::string(originalFunc.GetBaseClassName()).append(NameMangler::kNameSplitterStr).
-      append(GenerateNewBaseName(originalFunc)).append(NameMangler::kNameSplitterStr).
+  return std::string(originalFunc.GetBaseClassName()).append(namemangler::kNameSplitterStr).
+      append(GenerateNewBaseName(originalFunc)).append(namemangler::kNameSplitterStr).
       append(oldSignature.substr(0, retPos + retPosIndex)).append("V");
 }
 
@@ -100,7 +100,7 @@ MIRFunction *Clone::CloneFunction(MIRFunction &originalFunction, const std::stri
   std::string fullName = originalFunction.GetBaseClassName();
   const std::string &signature = originalFunction.GetSignature();
   fullName = fullName.append(
-      NameMangler::kNameSplitterStr).append(newBaseFuncName).append(NameMangler::kNameSplitterStr).append(signature);
+      namemangler::kNameSplitterStr).append(newBaseFuncName).append(namemangler::kNameSplitterStr).append(signature);
   MIRFunction *newFunc =
       dexBuilder.CreateFunction(fullName, *retType, argument, false, originalFunction.GetBody() != nullptr);
   CHECK_FATAL(newFunc != nullptr, "create cloned function failed");
diff --git a/src/maple_ipa/src/module_phase_manager.cpp b/src/maple_ipa/src/module_phase_manager.cpp
index d7b96915bfd753087b7989d214f14df74c0c0721..3df676ec5d6f705424ca3dec9a965b6f9acd77eb 100644
--- a/src/maple_ipa/src/module_phase_manager.cpp
+++ b/src/maple_ipa/src/module_phase_manager.cpp
@@ -24,6 +24,7 @@
 #include "native_stub_func.h"
 #include "vtable_analysis.h"
 #include "reflection_analysis.h"
+#include "annotation_analysis.h"
 #include "vtable_impl.h"
 #include "java_intrn_lowering.h"
 #include "java_eh_lower.h"
diff --git a/src/maple_ipa/src/retype.cpp b/src/maple_ipa/src/retype.cpp
index b89437398aa2c7c6e00df7bad5ef0418f435825c..99ec7d9bb8e5bd93d5ca8a01b44930cadb1594ec 100644
--- a/src/maple_ipa/src/retype.cpp
+++ b/src/maple_ipa/src/retype.cpp
@@ -17,7 +17,8 @@
 #include <algorithm>
 
 namespace maple {
-void Retype::ReplaceRetypeExpr(const BaseNode &expr) const {
+class AnnotationType;
+void Retype::ReplaceRetypeExpr(const BaseNode &expr) {
   if (expr.NumOpnds() == 0) {
     return;
   }
@@ -31,7 +32,35 @@ void Retype::ReplaceRetypeExpr(const BaseNode &expr) const {
   }
 }
 
-void Retype::RetypeStmt(MIRFunction &func) const {
+void Retype::TransmitGenericInfo(MIRFunction &func, StmtNode &stmt) {
+  if (stmt.GetOpCode() != OP_dassign) {
+    return;
+  }
+  DassignNode &dassignNode = static_cast<DassignNode&>(stmt);
+  BaseNode *rhs = static_cast<DassignNode&>(stmt).GetRHS();
+  if (!rhs->IsLeaf()) {
+    return;
+  }
+  GStrIdx lhsNameStrIdx = func.GetLocalOrGlobalSymbol(dassignNode.GetStIdx())->GetNameStrIdx();
+  GStrIdx rhsNameStrIdx = func.GetLocalOrGlobalSymbol(static_cast<AddrofNode*>(rhs)->GetStIdx())->GetNameStrIdx();
+  const MapleMap<GStrIdx, MIRAliasVars> &map = func.GetAliasVarMap();
+  if (reg2varGenericInfo.find(lhsNameStrIdx) == reg2varGenericInfo.end() ||
+      reg2varGenericInfo[lhsNameStrIdx].sigStrIdx == 0) {
+    return;
+  }
+  if (reg2varGenericInfo.find(rhsNameStrIdx) != reg2varGenericInfo.end() &&
+      reg2varGenericInfo[rhsNameStrIdx].sigStrIdx != 0) {
+    return;
+  }
+  MIRAliasVars aliasVar = reg2varGenericInfo[lhsNameStrIdx];
+  aliasVar.memPoolStrIdx = rhsNameStrIdx;
+  if (map.find(rhsNameStrIdx) != map.end() && map.at(rhsNameStrIdx).memPoolStrIdx != rhsNameStrIdx) {
+    CHECK_FATAL(false, "must be");
+  }
+  func.SetAliasVarMap(rhsNameStrIdx, aliasVar);
+}
+
+void Retype::RetypeStmt(MIRFunction &func) {
   if (func.IsEmpty()) {
     return;
   }
@@ -43,6 +72,7 @@ void Retype::RetypeStmt(MIRFunction &func) const {
       BaseNode *opnd = stmt.Opnd(i);
       if (opnd->GetOpCode() == OP_retype) {
         stmt.SetOpnd(opnd->Opnd(0), i);
+        TransmitGenericInfo(func, stmt);
         continue;
       } else {
         ReplaceRetypeExpr(*opnd);
@@ -51,12 +81,18 @@ void Retype::RetypeStmt(MIRFunction &func) const {
   }
 }
 
-void Retype::DoRetype() const {
+void Retype::DoRetype() {
   for (MIRFunction *func : mirModule->GetFunctionList()) {
     if (func->IsEmpty()) {
       continue;
     }
+    for (auto pair : func->GetAliasVarMap()) {
+      GStrIdx varNameStrIdx = pair.first;
+      GStrIdx regNameStrIdx = pair.second.memPoolStrIdx;
+      reg2varGenericInfo[regNameStrIdx] = pair.second;
+    }
     RetypeStmt(*func);
+    reg2varGenericInfo.clear();
   }
 }
 }  // namespace maple
diff --git a/src/maple_ir/include/metadata_layout.h b/src/maple_ir/include/metadata_layout.h
index 7c750babfafc66f7a6618f056d9df17400945409..491509be78437d83e02df77365407cda8d75263f 100644
--- a/src/maple_ir/include/metadata_layout.h
+++ b/src/maple_ir/include/metadata_layout.h
@@ -214,14 +214,14 @@ struct MByteRef32 {
 };
 
 // MethodMeta defined in methodmeta.h
-// FieldMeta  defined in FieldMeta.h
+// FieldMeta  defined in fieldmeta.h
 // MethodDesc contains MethodMetadata and stack map
 struct MethodDesc {
   // relative offset for method metadata relative to current PC.
   // method metadata is in compact format if this offset is odd.
   uint32_t metadataOffset;
 
-  uint16_t localRefOffset;
+  int16_t localRefOffset;
   uint16_t localRefNumber;
 
   // stack map for a methed might be placed here
diff --git a/src/maple_ir/include/mir_builder.h b/src/maple_ir/include/mir_builder.h
index 53e5ccec923ace2aea11d42ec3b99efebb74e4d1..17387205bd847e63a55c3514e2ac4eccd3ab3143 100644
--- a/src/maple_ir/include/mir_builder.h
+++ b/src/maple_ir/include/mir_builder.h
@@ -205,6 +205,7 @@ class MIRBuilder {
   UnaryNode *CreateExprUnary(Opcode opcode, const MIRType &type, BaseNode *opnd);
   GCMallocNode *CreateExprGCMalloc(Opcode opcode, const MIRType &ptype, const MIRType &type);
   JarrayMallocNode *CreateExprJarrayMalloc(Opcode opcode, const MIRType &ptype, const MIRType &type, BaseNode *opnd);
+  TypeCvtNode *CreateExprTypeCvt(Opcode o, PrimType toPrimType, PrimType fromPrimType, BaseNode &opnd);
   TypeCvtNode *CreateExprTypeCvt(Opcode o, const MIRType &type, const MIRType &fromtype, BaseNode *opnd);
   ExtractbitsNode *CreateExprExtractbits(Opcode o, const MIRType &type, uint32 bOffset, uint32 bSize, BaseNode *opnd);
   RetypeNode *CreateExprRetype(const MIRType &type, const MIRType &fromType, BaseNode *opnd);
diff --git a/src/maple_ir/include/mir_function.h b/src/maple_ir/include/mir_function.h
index b3be8edded0493811d54d46130707e825507f4ed..1d2775b7b79ce618e8d6ae8c105c6efcdc4ecca1 100644
--- a/src/maple_ir/include/mir_function.h
+++ b/src/maple_ir/include/mir_function.h
@@ -143,41 +143,28 @@ class MIRFunction {
     CHECK_FATAL(funcType != nullptr, "funcType is nullptr");
     return funcType->GetParamTypeList().size();
   }
+
   const MapleVector<TyIdx> &GetParamTypes() const {
     CHECK_FATAL(funcType != nullptr, "funcType is nullptr");
     return funcType->GetParamTypeList();
   }
+
   TyIdx GetNthParamTyIdx(size_t i) const {
     ASSERT(i < funcType->GetParamTypeList().size(), "array index out of range");
     return funcType->GetParamTypeList()[i];
   }
+
   const MIRType *GetNthParamType(size_t i) const;
   MIRType *GetNthParamType(size_t i);
-  const TypeAttrs &GetNthParamAttr(size_t i) const {
-    CHECK_FATAL(funcType != nullptr, "funcType is nullptr");
-    ASSERT(i < funcType->GetParamAttrsList().size(), "array index out of range");
-    return funcType->GetNthParamAttrs(i);
-  }
 
-  void SetNthParamAttr(size_t i, TypeAttrs attrs) {
-    CHECK_FATAL(funcType != nullptr, "funcType is nullptr");
-    ASSERT(i < funcType->GetParamAttrsList().size(), "array index out of range");
-    funcType->SetNthParamAttrs(i, attrs);
-  }
-
-  void SetNthParamAttrKind(size_t i, AttrKind x) const {
-    CHECK_FATAL(funcType != nullptr, "funcType is nullptr");
-    CHECK_FATAL(i < funcType->GetParamAttrsList().size(), "array index out of range");
-    funcType->GetNthParamAttrs(i).SetAttr(x);
-  }
-
-  void AddArgument(MIRSymbol *symbol) {
-    formals.push_back(symbol);
-    CHECK_FATAL(funcType != nullptr, "funcType is nullptr");
-    funcType->GetParamTypeList().push_back(symbol->GetTyIdx());
-    funcType->GetParamAttrsList().push_back(symbol->GetAttrs());
+  const TypeAttrs &GetNthParamAttr(size_t i) const {
+    ASSERT(i < formals.size(), "array index out of range");
+    return formals[i]->GetAttrs();
   }
 
+  void UpdateFuncTypeAndFormals(const std::vector<MIRSymbol*> &symbols, bool clearOldArgs = false);
+  void UpdateFuncTypeAndFormalsAndReturnType(const std::vector<MIRSymbol*> &symbols, TyIdx retTyIdx,
+                                             bool clearOldArgs = false);
   LabelIdx GetOrCreateLableIdxFromName(const std::string &name);
   GStrIdx GetLabelStringIndex(LabelIdx labelIdx) const {
     CHECK_FATAL(labelTab != nullptr, "labelTab is nullptr");
@@ -450,30 +437,11 @@ class MIRFunction {
   TyIdx GetInferredReturnTyIdx() const {
     return inferredReturnTyIdx;
   }
+
   void SetInferredReturnTyIdx(TyIdx tyIdx) {
     inferredReturnTyIdx = tyIdx;
   }
 
-  const MapleVector<TyIdx> &GetArgumentsTyIdx() const {
-    return argumentsTyIdx;
-  }
-  void ClearArgumentsTyIdx() {
-    argumentsTyIdx.clear();
-  }
-  TyIdx GetArgumentsTyIdxItem(size_t i) const {
-    ASSERT(i < argumentsTyIdx.size(), "array index out of range");
-    return argumentsTyIdx.at(i);
-  }
-  size_t GetArgumentsTyIdxSize() const {
-    return argumentsTyIdx.size();
-  }
-
-  const MapleVector<TypeAttrs> &GetArgumentsAttrs() const {
-    return argumentsAttrs;
-  }
-  void ClearArgumentsAttrs() {
-    argumentsAttrs.clear();
-  }
   bool HaveTypeNameTab() {
     return typeNameTab != nullptr;
   }
@@ -786,6 +754,41 @@ class MIRFunction {
     return codeMemPoolAllocator;
   }
 
+  void AddFuncGenericDeclare(GenericDeclare *g) {
+    genericDeclare.push_back(g);
+  }
+
+  void AddFuncGenericArg(AnnotationType *a) {
+    genericArg.push_back(a);
+  }
+
+  void AddFuncGenericRet(AnnotationType *r) {
+    genericRet = r;
+  }
+
+  void AddFuncLocalGenericVar(GStrIdx str, AnnotationType *at) {
+    genericLocalVar[str] = at;
+  }
+
+  MapleVector<GenericDeclare*> &GetFuncGenericDeclare() {
+    return genericDeclare;
+  }
+
+  MapleVector<AnnotationType*> &GetFuncGenericArg() {
+    return genericArg;
+  }
+
+  AnnotationType *GetFuncGenericRet() {
+    return genericRet;
+  }
+
+  AnnotationType *GetFuncLocalGenericVar(GStrIdx str) {
+    if (genericLocalVar.find(str) == genericLocalVar.end()) {
+      return nullptr;
+    }
+    return genericLocalVar[str];
+  }
+
 
   void AddProfileDesc(uint64 hash, uint32 start, uint32 end) {
     profileDesc = module->GetMemPool()->New<IRProfileDesc>(hash, start, end);
@@ -805,14 +808,16 @@ class MIRFunction {
   PUIdx puIdxOrigin = 0;     // the original puIdx when initial generation
   StIdx symbolTableIdx;  // the symbol table index of this function
   MIRFuncType *funcType = nullptr;
-  TyIdx returnTyIdx{0};                // the declared return type of this function
-  TyIdx inferredReturnTyIdx{0};        // the actual return type of of this function (may be a
+  TyIdx inferredReturnTyIdx{0};     // the actual return type of of this function (may be a
                                     // subclass of the above). 0 means can not be inferred.
-  TyIdx classTyIdx{0};                 // class/interface type this function belongs to
+  TyIdx classTyIdx{0};              // class/interface type this function belongs to
   MapleVector<MIRSymbol*> formals{module->GetMPAllocator().Adapter()};  // formal parameter symbols of this function
   MapleSet<MIRSymbol*> retRefSym{module->GetMPAllocator().Adapter()};
-  MapleVector<TyIdx> argumentsTyIdx{module->GetMPAllocator().Adapter()};  // arguments types of this function
-  MapleVector<TypeAttrs> argumentsAttrs{module->GetMPAllocator().Adapter()};
+
+  MapleVector<GenericDeclare*> genericDeclare{module->GetMPAllocator().Adapter()};
+  MapleVector<AnnotationType*> genericArg{module->GetMPAllocator().Adapter()};
+  MapleMap<GStrIdx, AnnotationType*> genericLocalVar{module->GetMPAllocator().Adapter()};
+  AnnotationType *genericRet = nullptr;
 
   MIRSymbolTable *symTab = nullptr;
   MIRTypeNameTable *typeNameTab = nullptr;
@@ -882,6 +887,7 @@ class MIRFunction {
   GStrIdx signatureStrIdx{0};
 
   void DumpFlavorLoweredThanMmpl() const;
+  MIRFuncType *ReconstructFormals(const std::vector<MIRSymbol*> &symbols, bool clearOldArgs);
 };
 }  // namespace maple
 #endif  // MAPLE_IR_INCLUDE_MIR_FUNCTION_H
diff --git a/src/maple_ir/include/mir_module.h b/src/maple_ir/include/mir_module.h
index 06db828bbb7155986ac7ccb4380b99d265851745..2098bcf1cd1cf6adc3e3ddaf91ed4bc1655c1e9a 100644
--- a/src/maple_ir/include/mir_module.h
+++ b/src/maple_ir/include/mir_module.h
@@ -137,6 +137,12 @@ class MIRModule {
   const MapleAllocator &GetMPAllocator() const {
     return memPoolAllocator;
   }
+
+  void ChangePragmaMemPool(MemPool *newPragma) {
+    pragmaMemPool = newPragma;
+    pragmaMemPoolAllocator.SetMemPool(newPragma);
+  }
+
   MapleAllocator &GetMPAllocator() {
     return memPoolAllocator;
   }
diff --git a/src/maple_ir/include/mir_nodes.h b/src/maple_ir/include/mir_nodes.h
index 51ffa35e17d319471de39160c16f715b26b9cfc8..1789f2ed1973dbb9632f67ee4c8c2c5605acb39c 100644
--- a/src/maple_ir/include/mir_nodes.h
+++ b/src/maple_ir/include/mir_nodes.h
@@ -2703,6 +2703,18 @@ class NaryStmtNode : public StmtNode, public NaryOpnds {
     }
     SetNumOpnds(GetNopndSize());
   }
+
+  void InsertOpnd(BaseNode *node, size_t idx) {
+    if (node == nullptr || idx > GetNopndSize()) {
+      return;
+    }
+    auto begin = GetNopnd().begin();
+    for (size_t i = 0; i < idx; ++i) {
+      ++begin;
+    }
+    GetNopnd().insert(begin, node);
+    SetNumOpnds(GetNopndSize());
+  }
 };
 
 class ReturnValuePart {
diff --git a/src/maple_ir/include/mir_type.h b/src/maple_ir/include/mir_type.h
index b81301a4d893d0e1dd1e3ecbd2988ca1eebb18ef..9e20926f9dea8a44769184fab7b3d9ed50ef3110 100755
--- a/src/maple_ir/include/mir_type.h
+++ b/src/maple_ir/include/mir_type.h
@@ -537,12 +537,15 @@ class MIRPtrType : public MIRType {
   void SetPointedTyIdx(TyIdx idx) {
     pointedTyIdx = idx;
   }
+
   TypeAttrs &GetTypeAttrs() {
     return typeAttrs;
   }
+
   const TypeAttrs &GetTypeAttrs() const {
     return typeAttrs;
   }
+
   void SetTypeAttrs(TypeAttrs attrs) {
     typeAttrs = attrs;
   }
@@ -557,9 +560,9 @@ class MIRPtrType : public MIRType {
   TyIdx GetPointedTyIdxWithFieldID(FieldID fieldID) const;
   size_t GetHashIndex() const override {
     constexpr uint8 idxShift = 4;
-    constexpr uint8 flagShift = 3;
+    constexpr uint8 attrShift = 3;
     size_t hIdx = (static_cast<size_t>(pointedTyIdx) << idxShift) + (typeKind << kShiftNumOfTypeKind);
-    hIdx += (typeAttrs.GetAttrFlag() << flagShift) + typeAttrs.GetAlignValue();
+    hIdx += (typeAttrs.GetAttrFlag() << attrShift) + typeAttrs.GetAlignValue();
     return hIdx % kTypeHashLength;
   }
 
@@ -707,7 +710,9 @@ using MethodPair = std::pair<StIdx, TyidxFuncAttrPair>;
 using MethodVector = std::vector<MethodPair>;
 using MethodPtrVector = std::vector<MethodPair*>;
 using MIREncodedArray = std::vector<EncodedValue>;
-
+class GenericDeclare;
+class AnnotationType;
+class GenericType;
 // used by kTypeStruct, kTypeStructIncomplete, kTypeUnion
 class MIRStructType : public MIRType {
  public:
@@ -987,6 +992,36 @@ class MIRStructType : public MIRType {
     CHECK_FATAL(false, "can not use GetPragmaVec");
   }
 
+  std::vector<GenericDeclare*>& GetGenericDeclare() {
+    return genericDeclare;
+  }
+
+  void AddClassGenericDeclare(GenericDeclare *gd) {
+    genericDeclare.push_back(gd);
+  }
+
+  void AddFieldGenericDeclare(GStrIdx g, AnnotationType *a) {
+    if (fieldGenericDeclare.find(g) != fieldGenericDeclare.end()) {
+      CHECK_FATAL(fieldGenericDeclare[g] == a, "MUST BE");
+    }
+    fieldGenericDeclare[g] = a;
+  }
+
+  AnnotationType *GetFieldGenericDeclare(GStrIdx g) {
+    if (fieldGenericDeclare.find(g) == fieldGenericDeclare.end()) {
+      return nullptr;
+    }
+    return fieldGenericDeclare[g];
+  }
+
+  void AddInheritaceGeneric(GenericType *a) {
+    inheritanceGeneric.push_back(a);
+  }
+
+  std::vector<GenericType*> &GetInheritanceGeneric() {
+    return inheritanceGeneric;
+  }
+
   virtual const MIREncodedArray &GetStaticValue() const {
     CHECK_FATAL(false, "can not use GetStaticValue");
   }
@@ -1026,6 +1061,9 @@ class MIRStructType : public MIRType {
   mutable bool hasVolatileField = false;     // for caching computed value
   mutable bool hasVolatileFieldSet = false;  // if true, just read hasVolatileField;
                                              // otherwise compute to initialize hasVolatileField
+  std::vector<GenericDeclare*> genericDeclare;
+  std::map<GStrIdx, AnnotationType*> fieldGenericDeclare;
+  std::vector<GenericType*> inheritanceGeneric;
  private:
   FieldPair TraverseToField(FieldID fieldID) const ;
   FieldPair TraverseToField(GStrIdx fieldStrIdx) const ;
diff --git a/src/maple_ir/src/bin_mpl_export.cpp b/src/maple_ir/src/bin_mpl_export.cpp
index 2545cbd2b81e50caa1697ab1688e2ea2a4176fac..175047f39f698499300ac8cfc77f4b4a607b232d 100755
--- a/src/maple_ir/src/bin_mpl_export.cpp
+++ b/src/maple_ir/src/bin_mpl_export.cpp
@@ -66,7 +66,7 @@ void OutputConstStr16(const MIRConst &constVal, BinaryMplExport &mplExport) {
   const auto &mirStr16 = static_cast<const MIRStr16Const&>(constVal);
   std::u16string str16 = GlobalTables::GetU16StrTable().GetStringFromStrIdx(mirStr16.GetValue());
   std::string str;
-  NameMangler::UTF16ToUTF8(str, str16);
+  namemangler::UTF16ToUTF8(str, str16);
   mplExport.WriteNum(str.length());
   for (char c : str) {
     mplExport.Write(static_cast<uint8>(c));
@@ -135,7 +135,6 @@ void OutputTypePointer(const MIRType &ty, BinaryMplExport &mplExport) {
   const auto &type = static_cast<const MIRPtrType&>(ty);
   mplExport.WriteNum(kBinKindTypePointer);
   mplExport.OutputTypeBase(type);
-  mplExport.OutputTypeAttrs(type.GetTypeAttrs());
   mplExport.OutputType(type.GetPointedTyIdx());
 }
 
diff --git a/src/maple_ir/src/bin_mpl_import.cpp b/src/maple_ir/src/bin_mpl_import.cpp
index 9146db1a863e9e460dfa7ffdc55fe83ae4ace969..5f7f9b66f654b604914b71a6c25c4796a747d65a 100755
--- a/src/maple_ir/src/bin_mpl_import.cpp
+++ b/src/maple_ir/src/bin_mpl_import.cpp
@@ -144,7 +144,7 @@ MIRConst *BinaryMplImport::ImportConst(MIRFunction *func) {
         ostr << Read();
       }
       std::u16string str16;
-      NameMangler::UTF8ToUTF16(str16, ostr.str());
+      namemangler::UTF8ToUTF16(str16, ostr.str());
       cs->SetStrIdx(GlobalTables::GetU16StrTable().GetOrCreateStrIdxFromName(str16));
       return memPool->New<MIRStr16Const>(cs->GetStrIdx(), *type);
     }
@@ -524,7 +524,6 @@ TyIdx BinaryMplImport::ImportType(bool forPointedType) {
       size_t idx = typTab.size();
       typTab.push_back(nullptr);
       ++ptrLev;
-      type.SetTypeAttrs(ImportTypeAttrs());
       type.SetPointedTyIdx(ImportType(true));
       --ptrLev;
       MIRType *origType = &InsertInTypeTables(type);
@@ -747,7 +746,7 @@ MIRType &BinaryMplImport::InsertInTypeTables(MIRType &type) {
 
 void BinaryMplImport::SetupEHRootType() {
   // setup eh root type with most recent Ljava_2Flang_2FObject_3B
-  GStrIdx gStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(NameMangler::kJavaLangObjectStr);
+  GStrIdx gStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(namemangler::kJavaLangObjectStr);
   if (gStrIdx == 0u) {
     return;
   }
diff --git a/src/maple_ir/src/global_tables.cpp b/src/maple_ir/src/global_tables.cpp
index 0afc789f7fca626bfe4ea390dda0f21764a4921d..ea4e7818c2dd7719e95b25fac586df8d755a0491 100755
--- a/src/maple_ir/src/global_tables.cpp
+++ b/src/maple_ir/src/global_tables.cpp
@@ -68,17 +68,18 @@ MIRType *TypeTable::CreateAndUpdateMirTypeNode(MIRType &pType) {
   nType->SetTypeIndex(TyIdx(typeTable.size()));
   typeTable.push_back(nType);
 
-  if (pType.IsMIRPtrType() && static_cast<MIRPtrType&>(pType).GetTypeAttrs() == TypeAttrs()) {
-    MIRPtrType &pty = static_cast<MIRPtrType&>(pType);
-    if (pty.GetPrimType() == PTY_ptr) {
-      ptrTypeMap[pty.GetPointedTyIdx()] = nType->GetTypeIndex();
-    } else {
-      refTypeMap[pty.GetPointedTyIdx()] = nType->GetTypeIndex();
+  if (pType.IsMIRPtrType()) {
+    auto &pty = static_cast<MIRPtrType&>(pType);
+    if (pty.GetTypeAttrs() == TypeAttrs()) {
+      if (pty.GetPrimType() == PTY_ptr) {
+        ptrTypeMap[pty.GetPointedTyIdx()] = nType->GetTypeIndex();
+      } else {
+        refTypeMap[pty.GetPointedTyIdx()] = nType->GetTypeIndex();
+      }
     }
   } else {
     typeHashTable.insert(nType);
   }
-
   return nType;
 }
 
diff --git a/src/maple_ir/src/mir_builder.cpp b/src/maple_ir/src/mir_builder.cpp
index d381f366f07aefaa517f68331964944f60caecb2..2b90e91257ad91beb8fc9c6afb37698067f49c2b 100644
--- a/src/maple_ir/src/mir_builder.cpp
+++ b/src/maple_ir/src/mir_builder.cpp
@@ -655,8 +655,12 @@ JarrayMallocNode *MIRBuilder::CreateExprJarrayMalloc(Opcode opcode, const MIRTyp
   return GetCurrentFuncCodeMp()->New<JarrayMallocNode>(opcode, pType.GetPrimType(), type.GetTypeIndex(), opnd);
 }
 
+TypeCvtNode *MIRBuilder::CreateExprTypeCvt(Opcode o, PrimType  toPrimType, PrimType fromPrimType, BaseNode &opnd) {
+  return GetCurrentFuncCodeMp()->New<TypeCvtNode>(o, toPrimType, fromPrimType, &opnd);
+}
+
 TypeCvtNode *MIRBuilder::CreateExprTypeCvt(Opcode o, const MIRType &type, const MIRType &fromType, BaseNode *opnd) {
-  return GetCurrentFuncCodeMp()->New<TypeCvtNode>(o, type.GetPrimType(), fromType.GetPrimType(), opnd);
+  return CreateExprTypeCvt(o, type.GetPrimType(), fromType.GetPrimType(), *opnd);
 }
 
 ExtractbitsNode *MIRBuilder::CreateExprExtractbits(Opcode o, const MIRType &type, uint32 bOffset, uint32 bSize,
diff --git a/src/maple_ir/src/mir_const.cpp b/src/maple_ir/src/mir_const.cpp
index f032343ac3edafa804f22f34056f5877566b08e6..9e80873b80b3e7fac7b05e855fdc4d7699dd67e0 100644
--- a/src/maple_ir/src/mir_const.cpp
+++ b/src/maple_ir/src/mir_const.cpp
@@ -271,7 +271,7 @@ void MIRStr16Const::Dump() const {
   std::u16string str16 = GlobalTables::GetU16StrTable().GetStringFromStrIdx(value);
   // UTF-16 string are dumped as UTF-8 string in mpl to keep the printable chars in ascii form
   std::string str;
-  NameMangler::UTF16ToUTF8(str, str16);
+  namemangler::UTF16ToUTF8(str, str16);
   PrintString(str);
 }
 
diff --git a/src/maple_ir/src/mir_function.cpp b/src/maple_ir/src/mir_function.cpp
index 0e1d04dc1bc295a00fc3acafdd0ff5cfaa559b2d..8bc0209832518119712853d39e192ede3af4e7aa 100644
--- a/src/maple_ir/src/mir_function.cpp
+++ b/src/maple_ir/src/mir_function.cpp
@@ -93,6 +93,38 @@ MIRType *MIRFunction::GetNthParamType(size_t i) {
   return const_cast<MIRType*>(const_cast<const MIRFunction*>(this)->GetNthParamType(i));
 }
 
+// reconstruct formals, and return a new MIRFuncType
+MIRFuncType *MIRFunction::ReconstructFormals(const std::vector<MIRSymbol*> &symbols, bool clearOldArgs) {
+  auto *newFuncType = static_cast<MIRFuncType*>(funcType->CopyMIRTypeNode());
+  if (clearOldArgs) {
+    formals.clear();
+    newFuncType->GetParamTypeList().clear();
+    newFuncType->GetParamAttrsList().clear();
+  }
+  for (auto *symbol : symbols) {
+    formals.push_back(symbol);
+    newFuncType->GetParamTypeList().push_back(symbol->GetTyIdx());
+    newFuncType->GetParamAttrsList().push_back(symbol->GetAttrs());
+  }
+  return newFuncType;
+}
+
+void MIRFunction::UpdateFuncTypeAndFormals(const std::vector<MIRSymbol*> &symbols, bool clearOldArgs) {
+  auto *newFuncType = ReconstructFormals(symbols, clearOldArgs);
+  auto newFuncTypeIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(newFuncType);
+  funcType = static_cast<MIRFuncType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(newFuncTypeIdx));
+  delete newFuncType;
+}
+
+void MIRFunction::UpdateFuncTypeAndFormalsAndReturnType(const std::vector<MIRSymbol*> &symbols, TyIdx retTyIdx,
+                                                        bool clearOldArgs) {
+  auto *newFuncType = ReconstructFormals(symbols, clearOldArgs);
+  newFuncType->SetRetTyIdx(retTyIdx);
+  auto newFuncTypeIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(newFuncType);
+  funcType = static_cast<MIRFuncType*>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(newFuncTypeIdx));
+  delete newFuncType;
+}
+
 LabelIdx MIRFunction::GetOrCreateLableIdxFromName(const std::string &name) {
   GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
   LabelIdx labelIdx = GetLabelTab()->GetLabelIdxFromStrIdx(strIdx);
@@ -210,8 +242,9 @@ void MIRFunction::DumpFlavorLoweredThanMmpl() const {
     constexpr int kIndent = 2;
     const MIRType *type = GetNthParamType(i);
     type->Dump(kIndent);
-    const TypeAttrs &attrs = GetNthParamAttr(i);
-    attrs.DumpAttributes();
+    if (symbol->GetAttr(ATTR_localrefvar)) {
+      LogInfo::MapleLogger() << " localrefvar";
+    }
     if (i != (argSize - 1)) {
       LogInfo::MapleLogger() << ", ";
     }
@@ -424,7 +457,7 @@ void MIRFunction::SetBaseClassFuncNames(GStrIdx strIdx) {
   uint32 width = 1;  // delimiter width
   size_t pos = name.find(delimiter);
   if (pos == std::string::npos) {
-    delimiter = NameMangler::kNameSplitterStr;
+    delimiter = namemangler::kNameSplitterStr;
     width = 3;  // delimiter width
     pos = name.find(delimiter);
     // make sure it is not __7C, but ___7C ok
@@ -437,9 +470,9 @@ void MIRFunction::SetBaseClassFuncNames(GStrIdx strIdx) {
     baseClassStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(className);
     std::string funcNameWithType = name.substr(pos + width, name.length() - pos - width);
     baseFuncWithTypeStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(funcNameWithType);
-    size_t index = name.find(NameMangler::kRigthBracketStr);
+    size_t index = name.find(namemangler::kRigthBracketStr);
     ASSERT(index != std::string::npos, "Invalid name, cannot find '_29' in name");
-    size_t posEnd = index + (std::string(NameMangler::kRigthBracketStr)).length();
+    size_t posEnd = index + (std::string(namemangler::kRigthBracketStr)).length();
     funcNameWithType = name.substr(pos + width, posEnd - pos - width);
     size_t newPos = name.find(delimiter, pos + width);
     while (newPos != std::string::npos && (name[newPos - 1] == '_' && name[newPos - 2] != '_')) {
diff --git a/src/maple_ir/src/mir_module.cpp b/src/maple_ir/src/mir_module.cpp
index 7314d7072222d10e6b1ec3a158f0162d51ce6403..a7a731b305d03b50d3101458771d2784bfa4e23e 100644
--- a/src/maple_ir/src/mir_module.cpp
+++ b/src/maple_ir/src/mir_module.cpp
@@ -498,7 +498,7 @@ uint32 MIRModule::GetFileinfo(GStrIdx strIdx) const {
 }
 
 std::string MIRModule::GetFileNameAsPostfix() const {
-  std::string fileNameStr = NameMangler::kFileNameSplitterStr;
+  std::string fileNameStr = namemangler::kFileNameSplitterStr;
   if (!fileInfo.empty()) {
     // option 1: file name in INFO
     uint32 fileNameIdx = GetFileinfo(GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("INFO_filename"));
diff --git a/src/maple_ir/src/mir_nodes.cpp b/src/maple_ir/src/mir_nodes.cpp
index 2bb1d39ca3aef7bbaf74f97ba50e7a7c4aba0023..7327a0bf056f95075ecc18e3535dd564e337feef 100644
--- a/src/maple_ir/src/mir_nodes.cpp
+++ b/src/maple_ir/src/mir_nodes.cpp
@@ -493,7 +493,7 @@ void Conststr16Node::Dump(int32) const {
   const std::u16string kStr16 = GlobalTables::GetU16StrTable().GetStringFromStrIdx(U16StrIdx(strIdx));
   // UTF-16 string are dumped as UTF-8 string in mpl to keep the printable chars in ascii form
   std::string str;
-  NameMangler::UTF16ToUTF8(str, kStr16);
+  namemangler::UTF16ToUTF8(str, kStr16);
   PrintString(str);
 }
 
diff --git a/src/maple_ir/src/mir_parser.cpp b/src/maple_ir/src/mir_parser.cpp
index f9127cfd51f0e1757bd0d5c6d171d1f7aab091c3..997381311aba9dd129d57497fc425262efe0128c 100644
--- a/src/maple_ir/src/mir_parser.cpp
+++ b/src/maple_ir/src/mir_parser.cpp
@@ -1924,7 +1924,7 @@ bool MIRParser::ParseExprConststr16(BaseNodePtr &expr) {
   // so we need to do a UTF8ToUTF16 conversion
   std::string str = lexer.GetName();
   std::u16string str16;
-  NameMangler::UTF8ToUTF16(str16, str);
+  namemangler::UTF8ToUTF16(str16, str);
   str16Const->SetStrIdx(GlobalTables::GetU16StrTable().GetOrCreateStrIdxFromName(str16));
   expr = str16Const;
   lexer.NextToken();
diff --git a/src/maple_ir/src/mir_symbol.cpp b/src/maple_ir/src/mir_symbol.cpp
index 0fd86d7f025791747afccb70b4486ec89c00ea97..f1cd189cbbba48d28359fd9ae9f4d705d51ae640 100644
--- a/src/maple_ir/src/mir_symbol.cpp
+++ b/src/maple_ir/src/mir_symbol.cpp
@@ -25,7 +25,7 @@
 #include "string_utils.h"
 
 namespace maple {
-using namespace NameMangler;
+using namespace namemangler;
 
 bool MIRSymbol::IsTypeVolatile(int fieldID) const {
   const MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(GetTyIdx());
@@ -273,7 +273,7 @@ bool MIRSymbol::IgnoreRC() const {
   GStrIdx strIdx = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pType->GetPointedTyIdx())->GetNameStrIdx();
   if (reflectClassNameIdx == 0u) {
     reflectClassNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
-        NameMangler::GetInternalNameLiteral("Ljava_2Flang_2FClass_3B"));
+        namemangler::GetInternalNameLiteral("Ljava_2Flang_2FClass_3B"));
   }
   return strIdx == reflectClassNameIdx;
 }
diff --git a/src/maple_ir/src/mir_type.cpp b/src/maple_ir/src/mir_type.cpp
index 0dece606c1786c955a217ba359d445677c7ed9b6..c7a17a1f33ff49f95654dca86af265d80e323ae5 100755
--- a/src/maple_ir/src/mir_type.cpp
+++ b/src/maple_ir/src/mir_type.cpp
@@ -518,7 +518,7 @@ const std::string &MIRJarrayType::GetJavaName() {
 MIRStructType *MIRJarrayType::GetParentType() {
   if (parentTyIdx == 0u) {
     GStrIdx jloStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(
-        NameMangler::GetInternalNameLiteral(NameMangler::kJavaLangObjectStr));
+        namemangler::GetInternalNameLiteral(namemangler::kJavaLangObjectStr));
     parentTyIdx = GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(jloStrIdx);
     ASSERT((parentTyIdx != 0u), "cannot find type for java.lang.Object");
   }
@@ -638,7 +638,7 @@ FieldID MIRClassType::GetFirstLocalFieldID() const {
 }
 
 const MIRClassType *MIRClassType::GetExceptionRootType() const {
-  GStrIdx ehTypeNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(NameMangler::kJavaLangObjectStr);
+  GStrIdx ehTypeNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(namemangler::kJavaLangObjectStr);
   const MIRClassType *subClassType = this;
   while (subClassType != nullptr && subClassType->nameStrIdx != ehTypeNameIdx) {
     subClassType =
@@ -858,7 +858,7 @@ static void DumpConstructorsAsCxx(MethodVector methods, int indent) {
     LogInfo::MapleLogger() << " */" << '\n';
     PrintIndentation(indent);
     LogInfo::MapleLogger() << "/* ";
-    LogInfo::MapleLogger() << NameMangler::DecodeName(
+    LogInfo::MapleLogger() << namemangler::DecodeName(
         GlobalTables::GetGsymTable().GetSymbolFromStidx(m.first.Idx())->GetName());
     LogInfo::MapleLogger() << " */" << '\n';
     PrintIndentation(indent);
@@ -1398,7 +1398,6 @@ bool MIRPtrType::IsPointedTypeVolatile(int fieldID) const {
   if (typeAttrs.GetAttr(ATTR_volatile)) {
     return true;
   }
-
   MIRType *pointedTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(GetPointedTyIdx());
   return pointedTy->IsVolatile(fieldID);
 }
diff --git a/src/maple_ir/src/parser.cpp b/src/maple_ir/src/parser.cpp
index 842908193554441d73e4062a5211ac097d725ede..8287f2c1b37c95922bc36255efd01871369757a6 100755
--- a/src/maple_ir/src/parser.cpp
+++ b/src/maple_ir/src/parser.cpp
@@ -1221,7 +1221,6 @@ bool MIRParser::ParsePointType(TyIdx &tyIdx) {
     Error("bad type attribute in pointer type specification");
     return false;
   }
-
   tyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&pointType);
   return true;
 }
@@ -1478,7 +1477,9 @@ bool MIRParser::ParseTypedef() {
     prevTyIdx = mod.GetTypeNameTab()->GetTyIdxFromGStrIdx(strIdx);
     if (prevTyIdx != 0u) {
       MIRType *prevType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(prevTyIdx);
-      CHECK_FATAL(prevType->IsStructType(), "type error");
+      if (!mod.IsCModule()) {
+        CHECK_FATAL(prevType->IsStructType(), "type error");
+      }
       prevStructType = static_cast<MIRStructType*>(prevType);
       if ((prevType->GetKind() != kTypeByName) && (prevStructType && !prevStructType->IsIncomplete())) {
         // allow duplicated type def if kKeepFirst is set which is the default
@@ -1564,7 +1565,7 @@ bool MIRParser::ParseTypedef() {
     if (mod.GetThrowableTyIdx() == 0u &&
         (ehType->GetKind() == kTypeClass || ehType->GetKind() == kTypeClassIncomplete)) {
       GStrIdx ehTypeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
-          NameMangler::GetInternalNameLiteral(NameMangler::kJavaLangObjectStr));
+          namemangler::GetInternalNameLiteral(namemangler::kJavaLangObjectStr));
       if (ehTypeNameIdx == ehType->GetNameStrIdx()) {
         mod.SetThrowableTyIdx(tyIdx);
       }
@@ -1722,7 +1723,7 @@ bool MIRParser::ParseDeclareVar(MIRSymbol &symbol) {
   if (symbol.GetStorageClass() == kScExtern && symbol.IsStatic()) {
     const std::string &staticFieldName = symbol.GetName();
     constexpr int kPosOffset = 3;
-    size_t pos = staticFieldName.find(NameMangler::kClassNameSplitterStr) + kPosOffset;
+    size_t pos = staticFieldName.find(namemangler::kClassNameSplitterStr) + kPosOffset;
     if (pos != 0 && pos != std::string::npos) {
       std::string className = staticFieldName.substr(0, pos);
       MIRSymbol *classSt =
@@ -1746,10 +1747,10 @@ bool MIRParser::ParseDeclareVar(MIRSymbol &symbol) {
     lexer.NextToken();
     bool allowEmpty = false;
     // allow empty initialization for vtable, itable, vtableOffsetTable and fieldOffsetTable
-    if (symbolStrName.find(VTAB_PREFIX_STR) == 0 || symbolStrName.find(NameMangler::kVtabOffsetTabStr) == 0 ||
-        symbolStrName.find(ITAB_PREFIX_STR) == 0 || symbolStrName.find(NameMangler::kFieldOffsetTabStr) == 0 ||
+    if (symbolStrName.find(VTAB_PREFIX_STR) == 0 || symbolStrName.find(namemangler::kVtabOffsetTabStr) == 0 ||
+        symbolStrName.find(ITAB_PREFIX_STR) == 0 || symbolStrName.find(namemangler::kFieldOffsetTabStr) == 0 ||
         symbolStrName.find(ITAB_CONFLICT_PREFIX_STR) == 0 ||
-        symbolStrName.find(NameMangler::kDecoupleStaticKeyStr) == 0) {
+        symbolStrName.find(namemangler::kDecoupleStaticKeyStr) == 0) {
       allowEmpty = true;
     }
     if (!ParseInitValue(mirConst, tyIdx, allowEmpty)) {
@@ -1831,8 +1832,8 @@ bool MIRParser::ParsePrototype(MIRFunction &func, MIRSymbol &funcSymbol, TyIdx &
   MIRType *retType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
   func.SetReturnStruct(*retType);
   MIRType *funcType =
-      GlobalTables::GetTypeTable().GetOrCreateFunctionType(mod, tyIdx, vecType, vecAttrs, varArgs, true);
-  funcTyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(funcType);
+      GlobalTables::GetTypeTable().GetOrCreateFunctionType(mod, tyIdx, vecType, vecAttrs, varArgs, false);
+  funcTyIdx = funcType->GetTypeIndex();
   funcSymbol.SetTyIdx(funcTyIdx);
   func.SetMIRFuncType(static_cast<MIRFuncType*>(funcType));
   return true;
@@ -1891,8 +1892,6 @@ bool MIRParser::ParseFunction(uint32 fileIdx) {
     // Skip attribute checking
     func = funcSymbol->GetFunction();
     func->ClearFormals();
-    func->ClearArgumentsTyIdx();
-    func->ClearArgumentsAttrs();
     func->Init();
     // update with current attr
     if (funcAttrs.GetAttrFlag()) {
@@ -2208,7 +2207,7 @@ bool MIRParser::ParseAlias(StmtNodePtr&) {
   }
   GStrIdx signStrIdx(0);
   if (lexer.GetTokenKind() == TK_string) {
-    // ignore the signature string
+    signStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
     lexer.NextToken();
   }
   MIRAliasVars aliasVar;
diff --git a/src/maple_me/include/bb.h b/src/maple_me/include/bb.h
index b68beef87fb836939fab85607a60d91542ab935c..ba588c4daf970a67791b1440f2d3fe6d32fd242c 100755
--- a/src/maple_me/include/bb.h
+++ b/src/maple_me/include/bb.h
@@ -357,6 +357,10 @@ class BB {
     pred[cnt] = pp;
   }
 
+  void PushBackSuccFreq(uint64 freq) {
+    return succFreq.push_back(freq);
+  }
+
   MapleVector<uint64> &GetSuccFreq() {
     return succFreq;
   }
diff --git a/src/maple_me/include/me_abco.h b/src/maple_me/include/me_abco.h
index 65b663360a073c73266bed8241b4b35e144e65e8..31247eb56e4f1a5385d9f7ed012f758da31d7d79 100755
--- a/src/maple_me/include/me_abco.h
+++ b/src/maple_me/include/me_abco.h
@@ -254,7 +254,9 @@ class MeABC {
   void DeleteABC();
   bool CleanABCInStmt(MeStmt &meStmt, NaryMeExpr &naryMeExpr);
   MeExpr *ReplaceArrayExpr(MeExpr &rhs, MeExpr &naryMeExpr, MeStmt *ivarStmt);
-
+  bool HasRelativeWithLength(MeExpr &meExpr);
+  bool ProveGreaterZ(MeExpr &weight);
+  void ReSolveEdge();
   Dominance *GetDominace() {
     return dom;
   }
@@ -291,6 +293,8 @@ class MeABC {
   std::map<MePhiNode*, std::vector<ScalarMeExpr*>> modifiedPhi;
   std::set<BB*> visitedBBs;
   std::set<MeStmt*> targetMeStmt;
+  // map<std::pair<a, b>, c>; a = b + c  b is relative with length, c is var weight
+  std::map<std::pair<MeExpr*, MeExpr*>, MeExpr*> unresolveEdge;
 };
 
 class MeDoABCOpt : public MeFuncPhase {
diff --git a/src/maple_me/include/me_inequality_graph.h b/src/maple_me/include/me_inequality_graph.h
index b9104c9dad91bbfa41f9ce49d84375ab53363099..266703c4b4f7312e4184e78b2dbcaba095ec7d26 100755
--- a/src/maple_me/include/me_inequality_graph.h
+++ b/src/maple_me/include/me_inequality_graph.h
@@ -353,6 +353,7 @@ class ABCD {
   ~ABCD() = default;
 
   bool DemandProve(const MeExpr &arrayNode, const MeExpr &idx);
+  bool DemandProve(ESSABaseNode &firstNode, ESSABaseNode &secondNode, EdgeType edgeType);
 
  private:
   using MeetFunction = ProveResult (*)(ProveResult, ProveResult);
@@ -376,7 +377,6 @@ class ABCD {
     return kReduced;
   }
 
-  bool DemandProve(ESSABaseNode &firstNode, ESSABaseNode &secondNode, EdgeType edgeType);
   ProveResult Prove(ESSABaseNode &a, ESSABaseNode &b, InequalEdge &e);
   ProveResult UpdateCacheResult(ESSABaseNode &a, ESSABaseNode &b, InequalEdge &e, MeetFunction meet);
   void PrintTracing() const;
diff --git a/src/maple_me/include/me_option.h b/src/maple_me/include/me_option.h
index a548710d3c5d0a140b16e1842a50f1e73782d45f..0f61d5b4175b4230367090c2038718f065ca3eac 100644
--- a/src/maple_me/include/me_option.h
+++ b/src/maple_me/include/me_option.h
@@ -74,6 +74,9 @@ class MeOption : public MapleDriverOptionBase {
   static uint32 profileBBHotRate;
   static uint32 profileBBColdRate;
   static bool ignoreIPA;
+  static bool aggressiveABCO;
+  static bool commonABCO;
+  static bool conservativeABCO;
   static bool epreIncludeRef;
   static bool epreLocalRefVar;
   static bool epreLHSIvar;
diff --git a/src/maple_me/src/alias_class.cpp b/src/maple_me/src/alias_class.cpp
index 7cd06895d94e1ba5efb7e55cb8f79ff6dd8c1753..023b031d3500760444564a0e140baef0cda6f025 100644
--- a/src/maple_me/src/alias_class.cpp
+++ b/src/maple_me/src/alias_class.cpp
@@ -466,8 +466,8 @@ bool AliasClass::AliasAccordingToType(TyIdx tyIdxA, TyIdx tyIdxB) {
       CHECK_NULL_FATAL(klassA);
       Klass *klassB = klassHierarchy->GetKlassFromTyIdx(mirTypeB->GetTypeIndex());
       CHECK_NULL_FATAL(klassB);
-      return (klassA == klassB || klassA->GetKlassName() == NameMangler::kJavaLangObjectStr ||
-              klassB->GetKlassName() == NameMangler::kJavaLangObjectStr ||
+      return (klassA == klassB || klassA->GetKlassName() == namemangler::kJavaLangObjectStr ||
+              klassB->GetKlassName() == namemangler::kJavaLangObjectStr ||
               klassHierarchy->IsSuperKlass(klassA, klassB) || klassHierarchy->IsSuperKlass(klassB, klassA));
     }
     case kTypePointer: {
diff --git a/src/maple_me/src/irmap_emit.cpp b/src/maple_me/src/irmap_emit.cpp
index ff5a0314c64c56856f530beb196f21e7c173a6be..938fb22db4c94bca2c1c01662cab3a661afa9e5f 100755
--- a/src/maple_me/src/irmap_emit.cpp
+++ b/src/maple_me/src/irmap_emit.cpp
@@ -185,6 +185,7 @@ BaseNode &OpMeExpr::EmitExpr(SSATab &ssaTab) {
     case OP_ceil:
     case OP_cvt:
     case OP_floor:
+    case OP_round:
     case OP_trunc: {
       auto *cvtNode = ssaTab.GetModule().CurFunction()->GetCodeMempool()->New<TypeCvtNode>(
           Opcode(GetOp()), PrimType(GetPrimType()));
diff --git a/src/maple_me/src/me_abco.cpp b/src/maple_me/src/me_abco.cpp
index 97c3f32ac8dd9d8ed37a68da1bfa8845bb94a780..aab83546c649e534bd288298a8e0a34ce23602e7 100755
--- a/src/maple_me/src/me_abco.cpp
+++ b/src/maple_me/src/me_abco.cpp
@@ -906,6 +906,9 @@ bool MeABC::BuildAssignInGraph(MeStmt &meStmt) {
         return true;
       }
       case OP_sub: {
+        if (MeOption::conservativeABCO) {
+          return false;
+        }
         CHECK_FATAL(opMeExpr->GetNumOpnds() == kNumOpnds, "must be");
         MeExpr *opnd1 = opMeExpr->GetOpnd(0);
         MeExpr *opnd2 = opMeExpr->GetOpnd(1);
@@ -917,6 +920,9 @@ bool MeABC::BuildAssignInGraph(MeStmt &meStmt) {
           if (opnd1->GetMeOp() == kMeOpConst && opnd2->GetMeOp() == kMeOpConst) {
             CHECK_FATAL(false, "consider this pattern");
           } else if (opnd2->GetMeOp() == kMeOpConst) {
+            if (!HasRelativeWithLength(*opnd1)) {
+              return false;
+            }
             ESSABaseNode *rhsNode = GetOrCreateRHSNode(*opnd1);
             AddUseDef(*opnd1);
             InequalEdge *pairEdge1 = inequalityGraph->AddEdge(*rhsNode, *lhsNode,
@@ -945,6 +951,9 @@ bool MeABC::BuildAssignInGraph(MeStmt &meStmt) {
             return false;
           }
           CHECK_FATAL(opnd2->GetMeOp() == kMeOpConst, "must be");
+          if (!HasRelativeWithLength(*opnd1)) {
+            return false;
+          }
           ESSABaseNode *rhsNode = GetOrCreateRHSNode(*opnd1);
           AddUseDef(*opnd1);
           InequalEdge *pairEdge1 = inequalityGraph->AddEdge(*rhsNode, *lhsNode,
@@ -967,6 +976,9 @@ bool MeABC::BuildAssignInGraph(MeStmt &meStmt) {
         CHECK_FATAL(false, "impossible");
       }
       case OP_add: {
+        if (MeOption::conservativeABCO) {
+          return false;
+        }
         CHECK_FATAL(opMeExpr->GetNumOpnds() == kNumOpnds, "must be");
         MeExpr *opnd1 = opMeExpr->GetOpnd(0);
         MeExpr *opnd2 = opMeExpr->GetOpnd(1);
@@ -975,12 +987,51 @@ bool MeABC::BuildAssignInGraph(MeStmt &meStmt) {
         }
         ESSAVarNode *lhsNode = inequalityGraph->GetOrCreateVarNode(*lhs);
         if (opnd1->GetMeOp() != kMeOpConst && opnd2->GetMeOp() != kMeOpConst) {
-          // support this pattern later
+          CHECK_FATAL(opnd1->GetMeOp() == kMeOpVar, "must be");
+          CHECK_FATAL(opnd2->GetMeOp() == kMeOpVar, "must be");
+          MeExpr *tmpVar = opnd2;
+          std::set<MePhiNode*> visitedPhi;
+          ConstMeExpr dummyExpr(kInvalidExprID, nullptr);
+          tmpVar = TryToResolveVar(*tmpVar, visitedPhi, dummyExpr, true);
+          if (tmpVar != nullptr && tmpVar != &dummyExpr) {
+            CHECK_FATAL(tmpVar->GetMeOp() == kMeOpConst, "must be");
+            if (!HasRelativeWithLength(*opnd1)) {
+              return false;
+            }
+            AddUseDef(*opnd1);
+            ESSABaseNode *rhsNode = GetOrCreateRHSNode(*opnd1);
+            InequalEdge *pairEdge1 = inequalityGraph->AddEdge(*rhsNode, *lhsNode,
+                static_cast<ConstMeExpr*>(tmpVar)->GetIntValue(), EdgeType::kUpper);
+            InequalEdge *pairEdge2 = inequalityGraph->AddEdge(*lhsNode, *rhsNode,
+                -static_cast<ConstMeExpr*>(tmpVar)->GetIntValue(), EdgeType::kUpper);
+            pairEdge1->SetPairEdge(*pairEdge2);
+            pairEdge2->SetPairEdge(*pairEdge1);
+            pairEdge1 = inequalityGraph->AddEdge(*lhsNode, *rhsNode,
+                -static_cast<ConstMeExpr*>(tmpVar)->GetIntValue(), EdgeType::kLower);
+            pairEdge2 = inequalityGraph->AddEdge(*rhsNode, *lhsNode,
+                static_cast<ConstMeExpr*>(tmpVar)->GetIntValue(), EdgeType::kLower);
+            pairEdge1->SetPairEdge(*pairEdge2);
+            pairEdge2->SetPairEdge(*pairEdge1);
+            return true;
+          }
+          if (HasRelativeWithLength(*opnd1)) {
+            unresolveEdge[std::make_pair(lhs, opnd1)] = opnd2;
+            AddUseDef(*opnd1);
+            AddUseDef(*opnd2);
+          }
+          if (HasRelativeWithLength(*opnd2)) {
+            unresolveEdge[std::make_pair(lhs, opnd2)] = opnd1;
+            AddUseDef(*opnd1);
+            AddUseDef(*opnd2);
+          }
           return false;
         }
         if (opnd1->GetMeOp() == kMeOpConst && opnd2->GetMeOp() == kMeOpConst) {
           CHECK_FATAL(false, "consider this pattern");
         } else if (opnd2->GetMeOp() == kMeOpConst) {
+          if (!HasRelativeWithLength(*opnd1)) {
+            return false;
+          }
           ESSABaseNode *rhsNode = GetOrCreateRHSNode(*opnd1);
           AddUseDef(*opnd1);
           InequalEdge *pairEdge1 = inequalityGraph->AddEdge(*rhsNode, *lhsNode,
@@ -997,6 +1048,9 @@ bool MeABC::BuildAssignInGraph(MeStmt &meStmt) {
           pairEdge2->SetPairEdge(*pairEdge1);
           return true;
         } else {
+          if (!HasRelativeWithLength(*opnd2)) {
+            return false;
+          }
           ESSABaseNode *rhsNode = GetOrCreateRHSNode(*opnd2);
           AddUseDef(*opnd2);
           InequalEdge *pairEdge1 = inequalityGraph->AddEdge(*rhsNode, *lhsNode,
@@ -1049,6 +1103,40 @@ bool MeABC::BuildAssignInGraph(MeStmt &meStmt) {
         (void)inequalityGraph->AddEdge(*lhsNode, *(inequalityGraph->GetOrCreateConstNode(0)), 0, EdgeType::kNone);
         return true;
       }
+      case OP_div: {
+        if (MeOption::conservativeABCO) {
+          return false;
+        }
+        CHECK_FATAL(opMeExpr->GetNumOpnds() == kNumOpnds, "must be");
+        MeExpr *opnd1 = opMeExpr->GetOpnd(0);
+        MeExpr *opnd2 = opMeExpr->GetOpnd(1);
+        if (!opnd1->IsLeaf() || !opnd2->IsLeaf()) {
+          return false;
+        }
+        if (opnd2->GetMeOp() == kMeOpConst) {
+          if (static_cast<ConstMeExpr*>(opnd2)->GetIntValue() > 0) {
+            if (HasRelativeWithLength(*opnd1)) {
+              unresolveEdge[std::make_pair(lhs, nullptr)] = opnd2;
+              AddUseDef(*opnd1);
+            }
+          }
+          return false;
+        }
+        MeExpr *varExpr = opnd2;
+        std::set<MePhiNode*> visitedPhi;
+        ConstMeExpr dummyExpr(kInvalidExprID, nullptr);
+        varExpr = TryToResolveVar(*varExpr, visitedPhi, dummyExpr, true);
+        if (varExpr != nullptr && varExpr != &dummyExpr) {
+          CHECK_FATAL(varExpr->GetMeOp() == kMeOpConst, "must be");
+          if (static_cast<ConstMeExpr*>(varExpr)->GetIntValue() > 0) {
+            if (HasRelativeWithLength(*opnd1)) {
+              unresolveEdge[std::make_pair(lhs, nullptr)] = opnd2;
+              AddUseDef(*opnd1);
+            }
+          }
+        }
+        return false;
+      }
       default:
         return false;
     }
@@ -1109,6 +1197,55 @@ bool MeABC::BuildAssignInGraph(MeStmt &meStmt) {
   }
 }
 
+bool MeABC::HasRelativeWithLength(MeExpr &meExpr) {
+  if (MeOption::aggressiveABCO) {
+    return true;
+  }
+  if (meExpr.GetMeOp() != kMeOpVar) {
+    return false;
+  }
+  auto *varOpnd1 = static_cast<VarMeExpr*>(&meExpr);
+  switch (varOpnd1->GetDefBy()) {
+    case kDefByStmt: {
+      MeStmt *meStmt = varOpnd1->GetDefStmt();
+      if (meStmt->GetOp() == OP_dassign) {
+        DassignMeStmt *dassignMeStmt = static_cast<DassignMeStmt*>(meStmt);
+        MeExpr *rhs = dassignMeStmt->GetRHS();
+        if (rhs->GetMeOp() == kMeOpVar) {
+          return HasRelativeWithLength(*rhs);
+        } else if (rhs->GetMeOp() == kMeOpOp && (rhs->GetOp() == OP_add || rhs->GetOp() == OP_sub)) {
+          auto *opMeExpr = static_cast<OpMeExpr*>(rhs);
+          CHECK_FATAL(opMeExpr->GetNumOpnds() == kNumOpnds, "must be");
+          MeExpr *opnd1 = opMeExpr->GetOpnd(0);
+          MeExpr *opnd2 = opMeExpr->GetOpnd(1);
+          return HasRelativeWithLength(*opnd1) || HasRelativeWithLength(*opnd2);
+        }
+      } else if (meStmt->GetOp() == OP_piassign) {
+        PiassignMeStmt *piMeStmt = static_cast<PiassignMeStmt*>(meStmt);
+        return HasRelativeWithLength(*piMeStmt->GetRHS());
+      }
+      break;
+    }
+    case kDefByChi: {
+      MeStmt *meStmt = varOpnd1->GetDefChi().GetBase();
+      MeExpr *rhs = meStmt->GetRHS();
+      if (rhs == nullptr || rhs->GetMeOp() != kMeOpNary) {
+        return false;
+      }
+      auto *nary = static_cast<NaryMeExpr*>(rhs);
+      if (nary->GetIntrinsic() != INTRN_JAVA_ARRAY_LENGTH) {
+        return false;
+      }
+      return true;
+    }
+    case kDefByPhi:
+    case kDefByNo:
+    case kDefByMustDef:
+      break;
+  }
+  return false;
+}
+
 bool MeABC::BuildStmtInGraph(MeStmt &meStmt) {
   bool validInsn = false;
   switch (meStmt.GetOp()) {
@@ -1195,6 +1332,34 @@ void MeABC::CollectCareInsns() {
   CHECK_FATAL(arrayNewChecks.size() == arrayChecks.size(), "must be");
 }
 
+bool MeABC::ProveGreaterZ(MeExpr &weight) {
+  ESSABaseNode &zNode = inequalityGraph->GetNode(0);
+  ESSABaseNode *idxNode = &(inequalityGraph->GetNode(weight));
+  bool lowerResult = prove->DemandProve(zNode, *idxNode, kLower);
+  return lowerResult;
+}
+
+void MeABC::ReSolveEdge() {
+  for (auto pair : unresolveEdge) {
+    MeExpr *weight = pair.second;
+    if (!inequalityGraph->HasNode(*weight)) {
+      continue;
+    }
+    if (ProveGreaterZ(*weight)) {
+      MeExpr *lhs = pair.first.first;
+      MeExpr *rhs = pair.first.second;
+      ESSAVarNode *lhsNode = inequalityGraph->GetOrCreateVarNode(*lhs);
+      ESSABaseNode *rhsNode = nullptr;
+      if (rhs != nullptr) {
+        rhsNode = GetOrCreateRHSNode(*rhs);
+      } else {
+        rhsNode = &(inequalityGraph->GetNode(0));
+      }
+      (void)inequalityGraph->AddEdge(*lhsNode, *rhsNode, 0, EdgeType::kNone);
+    }
+  }
+}
+
 void MeABC::BuildInequalityGraph() {
   for (size_t i = 0; i < carePoints.size(); ++i) {
     CarePoint *cp = carePoints[i];
@@ -1205,6 +1370,7 @@ void MeABC::BuildInequalityGraph() {
     }
   }
   inequalityGraph->ConnectTrivalEdge();
+  ReSolveEdge();
 }
 
 void MeABC::FindRedundantABC(MeStmt &meStmt, NaryMeExpr &naryMeExpr) {
@@ -1319,6 +1485,7 @@ void MeABC::InitNewStartPoint(MeStmt &meStmt, const NaryMeExpr &nMeExpr) {
   careMeStmts.clear();
   careMePhis.clear();
   carePoints.clear();
+  unresolveEdge.clear();
   inequalityGraph = std::make_unique<InequalityGraph>(*meFunc);
   CHECK_FATAL(inequalityGraph != nullptr, "inequalityGraph is nullptr");
   prove = std::make_unique<ABCD>(*inequalityGraph);
diff --git a/src/maple_me/src/me_builder.cpp b/src/maple_me/src/me_builder.cpp
index 258242f283d7acd29a2f38bd26d019d3c5f1c8a2..1f4ea7ba4b8705b3f4e003534195bf6ff4a01d29 100644
--- a/src/maple_me/src/me_builder.cpp
+++ b/src/maple_me/src/me_builder.cpp
@@ -256,6 +256,7 @@ bool MeBuilder::InitMeExprBuildFactory() {
   RegisterFactoryFunction<MeExprBuildFactory>(OP_ceil, &MeBuilder::BuildOpMeExprForTypeCvt);
   RegisterFactoryFunction<MeExprBuildFactory>(OP_cvt, &MeBuilder::BuildOpMeExprForTypeCvt);
   RegisterFactoryFunction<MeExprBuildFactory>(OP_floor, &MeBuilder::BuildOpMeExprForTypeCvt);
+  RegisterFactoryFunction<MeExprBuildFactory>(OP_round, &MeBuilder::BuildOpMeExprForTypeCvt);
   RegisterFactoryFunction<MeExprBuildFactory>(OP_trunc, &MeBuilder::BuildOpMeExprForTypeCvt);
   RegisterFactoryFunction<MeExprBuildFactory>(OP_retype, &MeBuilder::BuildOpMeExprForRetype);
   RegisterFactoryFunction<MeExprBuildFactory>(OP_abs, &MeBuilder::BuildOpMeExpr);
diff --git a/src/maple_me/src/me_bypath_eh.cpp b/src/maple_me/src/me_bypath_eh.cpp
index cb77b6d296b6f6e2b3de1f2fe1de0643a4ecd447..c1632fa7d7923506b6c73a7467a397d559ccecdb 100644
--- a/src/maple_me/src/me_bypath_eh.cpp
+++ b/src/maple_me/src/me_bypath_eh.cpp
@@ -269,7 +269,7 @@ void MeDoBypathEH::BypathException(MeFunction &func, const KlassHierarchy &kh) c
         auto *pType = static_cast<MIRPtrType*>(type);
         Klass *catchClass = nullptr;
         if (pType->GetPointedTyIdx() == PTY_void) {
-          catchClass = kh.GetKlassFromName(NameMangler::kJavaLangExceptionStr);
+          catchClass = kh.GetKlassFromName(namemangler::kJavaLangExceptionStr);
         } else {
           catchClass = kh.GetKlassFromTyIdx(pType->GetPointedTyIdx());
         }
diff --git a/src/maple_me/src/me_cfg.cpp b/src/maple_me/src/me_cfg.cpp
index ffd014f95be7d4f6dac8c3a819d75c66266a5ab9..0ec00b53dc6e67b8bed3e07c8b2d3e0c0880bde5 100755
--- a/src/maple_me/src/me_cfg.cpp
+++ b/src/maple_me/src/me_cfg.cpp
@@ -825,8 +825,9 @@ void MeCFG::DumpToFile(const std::string &prefix, bool dumpInStrs, bool dumpEdge
     if (bIt == func.common_exit()) {
       // specical case for common_exit_bb
       for (auto it = bb->GetPred().begin(); it != bb->GetPred().end(); ++it) {
-        cfgFile << "BB" << (*it)->GetBBId() << " -> "
-                << "BB" << bb->GetBBId() << "[style=dotted];\n";
+        dumpEdgeFreq ? cfgFile << "BB" << (*it)->GetBBId() << "_freq_" << (*it)->GetFrequency() << " -> " <<
+            "BB" << bb->GetBBId() << "_freq_" << bb->GetFrequency() << "[style=dotted];\n" :
+            cfgFile << "BB" << (*it)->GetBBId()<< " -> " << "BB" << bb->GetBBId() << "[style=dotted];\n";
       }
       continue;
     }
@@ -835,8 +836,9 @@ void MeCFG::DumpToFile(const std::string &prefix, bool dumpInStrs, bool dumpEdge
     }
 
     for (auto it = bb->GetSucc().begin(); it != bb->GetSucc().end(); ++it) {
-      cfgFile << "BB" << bb->GetBBId() << " -> "
-              << "BB" << (*it)->GetBBId();
+      dumpEdgeFreq ? cfgFile << "BB" << bb->GetBBId() << "_freq_" << bb->GetFrequency() << " -> " <<
+          "BB" << (*it)->GetBBId() << "_freq_" << (*it)->GetFrequency() :
+          cfgFile << "BB" << bb->GetBBId() << " -> " << "BB" << (*it)->GetBBId();
       if (bb == func.GetCommonEntryBB()) {
         cfgFile << "[style=dotted]";
         continue;
diff --git a/src/maple_me/src/me_ir.cpp b/src/maple_me/src/me_ir.cpp
index 07c0eb16ac57971f9788c42b94864cbb55548b50..c78285d043f630a5f63adbff4833e2ad25ce8eb0 100755
--- a/src/maple_me/src/me_ir.cpp
+++ b/src/maple_me/src/me_ir.cpp
@@ -1199,7 +1199,7 @@ void CallMeStmt::Dump(const IRMap *irMap) const {
   // target function name
   MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
   if (irMap->GetMIRModule().IsJavaModule()) {
-    LogInfo::MapleLogger() << NameMangler::DecodeName(func->GetName()) << '\n';
+    LogInfo::MapleLogger() << namemangler::DecodeName(func->GetName()) << '\n';
   } else {
     LogInfo::MapleLogger() << func->GetName() << '\n';
   }
diff --git a/src/maple_me/src/me_lower_globals.cpp b/src/maple_me/src/me_lower_globals.cpp
index bf6c2d11fb2434bc98f6755c1465caaba4a75357..2a664fc79521eff846ded557cf37a76ea9e91948 100644
--- a/src/maple_me/src/me_lower_globals.cpp
+++ b/src/maple_me/src/me_lower_globals.cpp
@@ -134,7 +134,7 @@ void MeLowerGlobals::Run() {
           continue;
         }
         if (GlobalTables::GetGsymTable().GetSymbolFromStrIdx(GlobalTables::GetStrTable().GetStrIdxFromName(
-          NameMangler::GetInternalNameLiteral(NameMangler::kJavaLangObjectStr))) != nullptr) {
+          namemangler::GetInternalNameLiteral(namemangler::kJavaLangObjectStr))) != nullptr) {
           continue;
         }
         auto &callStmt = static_cast<CallMeStmt&>(stmt);
diff --git a/src/maple_me/src/me_option.cpp b/src/maple_me/src/me_option.cpp
index f47aa7882ac16a7feed2e293e3e9d4d1908db0f7..a7de7333a5a2a71e55a22ed6d54055acf9d84f1c 100644
--- a/src/maple_me/src/me_option.cpp
+++ b/src/maple_me/src/me_option.cpp
@@ -36,6 +36,9 @@ bool MeOption::noDot = false;
 bool MeOption::stmtNum = false;
 uint8 MeOption::optLevel = 0;
 bool MeOption::ignoreIPA = true;
+bool MeOption::aggressiveABCO = false;
+bool MeOption::commonABCO = true;
+bool MeOption::conservativeABCO = false;
 bool MeOption::lessThrowAlias = true;
 bool MeOption::regreadAtReturn = true;
 bool MeOption::propBase = true;
@@ -98,6 +101,9 @@ enum OptionIndex {
   kDelrcpuLimit,
   kProfileBBHotRate,
   kProfileBBColdRate,
+  kAggressiveABCO,
+  kCommonABCO,
+  kConservativeABCO,
   kEpreIncludeRef,
   kNoEpreIncludeRef,
   kEpreLocalRefVar,
@@ -377,6 +383,36 @@ const Descriptor kUsage[] = {
     "  --profile-bb-cold-rate=99  \tA count is regarded as cold if it is in the smallest 1%\n",
     "me",
     {} },
+  { kAggressiveABCO,
+    kEnable,
+    "",
+    "aggressiveABCO",
+    kBuildTypeExperimental,
+    kArgCheckPolicyBool,
+    "  --aggressiveABCO                 \tEnable aggressive array boundary check optimization\n"
+    "  --no-aggressiveABCO              \tDon't enable aggressive array boundary check optimization\n",
+    "me",
+    {} },
+  { kCommonABCO,
+    kEnable,
+    "",
+    "commonABCO",
+    kBuildTypeExperimental,
+    kArgCheckPolicyBool,
+    "  --commonABCO                 \tEnable aggressive array boundary check optimization\n"
+    "  --no-commonABCO              \tDon't enable aggressive array boundary check optimization\n",
+    "me",
+    {} },
+  { kConservativeABCO,
+    kEnable,
+    "",
+    "conservativeABCO",
+    kBuildTypeExperimental,
+    kArgCheckPolicyBool,
+    "  --conservativeABCO                 \tEnable aggressive array boundary check optimization\n"
+    "  --no-conservativeABCO              \tDon't enable aggressive array boundary check optimization\n",
+    "me",
+    {} },
   { kEpreIncludeRef,
     kEnable,
     "",
@@ -603,6 +639,15 @@ bool MeOption::SolveOptions(const std::vector<mapleOption::Option> &opts, bool i
       case kProfileBBColdRate:
         profileBBColdRate = std::stoul(opt.Args(), nullptr);
         break;
+      case kAggressiveABCO:
+        aggressiveABCO = (opt.Type() == kEnable);
+        break;
+      case kCommonABCO:
+        commonABCO = (opt.Type() == kEnable);
+        break;
+      case kConservativeABCO:
+        conservativeABCO = (opt.Type() == kEnable);
+        break;
       case kEpreIncludeRef:
         epreIncludeRef = (opt.Type() == kEnable);
         break;
diff --git a/src/maple_me/src/me_profile_gen.cpp b/src/maple_me/src/me_profile_gen.cpp
index 34c5533a1be4b1051b86e577f706b8630517da28..d389adf7433de8a5aad4efc157e65829841b265f 100644
--- a/src/maple_me/src/me_profile_gen.cpp
+++ b/src/maple_me/src/me_profile_gen.cpp
@@ -57,7 +57,7 @@ void MeProfGen::Init() {
   }
   MIRArrayType &muidIdxArrayType =
       *GlobalTables::GetTypeTable().GetOrCreateArrayType(*GlobalTables::GetTypeTable().GetUInt32(), 0);
-  std::string bbProfileName = NameMangler::kBBProfileTabPrefixStr + func->GetMIRModule().GetFileNameAsPostfix();
+  std::string bbProfileName = namemangler::kBBProfileTabPrefixStr + func->GetMIRModule().GetFileNameAsPostfix();
   bbCounterTabSym = func->GetMIRModule().GetMIRBuilder()->CreateGlobalDecl(bbProfileName.c_str(), muidIdxArrayType);
   MIRAggConst *bbProfileTab = func->GetMIRModule().GetMemPool()->New<MIRAggConst>(
       func->GetMIRModule(), *GlobalTables::GetTypeTable().GetUInt32());
diff --git a/src/maple_me/src/me_rc_lowering.cpp b/src/maple_me/src/me_rc_lowering.cpp
index ad8c1338e9da9bd25fd3920981214bd7f2f444d0..2a89274ba25fb5e4d925c8ac183844d9a93a02d9 100644
--- a/src/maple_me/src/me_rc_lowering.cpp
+++ b/src/maple_me/src/me_rc_lowering.cpp
@@ -856,9 +856,6 @@ void RCLowering::HandleArguments() {
       incCall = CreateRCIntrinsic(INTRN_MCCIncRef, *firstMeStmt, opnds);
       firstBB->InsertMeStmtBefore(firstMeStmt, incCall);
     }
-    TypeAttrs typeAttr = mirFunc->GetNthParamAttr(i);
-    typeAttr.SetAttr(ATTR_localrefvar);
-    mirFunc->SetNthParamAttr(i, typeAttr);
     sym->SetLocalRefVar();
 
     for (auto *stmt : rets) {
diff --git a/src/maple_me/src/ssa_devirtual.cpp b/src/maple_me/src/ssa_devirtual.cpp
index f6e02438062227a88f8da262a4c17f08a03f7a8f..ccff6cbb5793f734152697599b5f56e35962ca00 100755
--- a/src/maple_me/src/ssa_devirtual.cpp
+++ b/src/maple_me/src/ssa_devirtual.cpp
@@ -89,7 +89,7 @@ void SSADevirtual::ReplaceCall(CallMeStmt &callStmt, const MIRFunction &targetFu
   if (SSADevirtual::debug) {
     MIRFunction &mirFunc = callStmt.GetTargetFunction();
     LogInfo::MapleLogger() << "[SSA-DEVIRT] " << kOpcodeInfo.GetTableItemAt(callStmt.GetOp()).name << " " <<
-        NameMangler::DecodeName(mirFunc.GetName());
+        namemangler::DecodeName(mirFunc.GetName());
   }
   if (callStmt.GetOp() == OP_virtualicall || callStmt.GetOp() == OP_virtualicallassigned ||
       callStmt.GetOp() == OP_interfaceicall || callStmt.GetOp() == OP_interfaceicallassigned) {
@@ -121,7 +121,7 @@ void SSADevirtual::ReplaceCall(CallMeStmt &callStmt, const MIRFunction &targetFu
   }
   if (SSADevirtual::debug) {
     LogInfo::MapleLogger() << "\t -> \t" << kOpcodeInfo.GetTableItemAt(callStmt.GetOp()).name << " " <<
-        NameMangler::DecodeName(targetFunc.GetName());
+        namemangler::DecodeName(targetFunc.GetName());
     if (NeedNullCheck(*receiver)) {
       LogInfo::MapleLogger() << " with null-check ";
     }
diff --git a/src/maple_util/include/namemangler.h b/src/maple_util/include/namemangler.h
index 8ad623d38156079fb982ff042ef1a829c01ee3da..e997b85743af4780d2a030b1d5bf3d283fb6569e 100644
--- a/src/maple_util/include/namemangler.h
+++ b/src/maple_util/include/namemangler.h
@@ -19,7 +19,7 @@
 
 // This is a general name mangler which is shared between maple compiler and runtime.
 // maple-compiler-specific data structure may NOT be used here.
-namespace NameMangler {
+namespace namemangler {
 #define TO_STR(s)  TO_STR2(s)
 #define TO_STR2(s) #s
 
@@ -194,6 +194,6 @@ int64_t  GetSleb128Decode(uint64_t val);
 size_t GetUleb128Size(uint64_t val);
 size_t GetSleb128Size(int32_t val);
 bool NeedConvertUTF16(const std::string &str8);
-} // namespace NameMangler
+} // namespace namemangler
 
 #endif
diff --git a/src/maple_util/src/profile.cpp b/src/maple_util/src/profile.cpp
index c204c7d57bfde3a074b0d0b0c9eac3e27a02b14f..94c86b029bfe70e68437bcf09c45195393d24f38 100644
--- a/src/maple_util/src/profile.cpp
+++ b/src/maple_util/src/profile.cpp
@@ -100,9 +100,9 @@ void Profile::ParseLiteral(const char *data, const char *end) {
 }
 
 std::string Profile::GetFunctionName(uint32 classIdx, uint32 methodIdx, uint32 sigIdx) const {
-  const std::string className = NameMangler::EncodeName(strMap.at(classIdx));
-  const std::string methodName = NameMangler::EncodeName(strMap.at(methodIdx));
-  const std::string sigName = NameMangler::EncodeName(strMap.at(sigIdx));
+  const std::string className = namemangler::EncodeName(strMap.at(classIdx));
+  const std::string methodName = namemangler::EncodeName(strMap.at(methodIdx));
+  const std::string sigName = namemangler::EncodeName(strMap.at(sigIdx));
   const std::string funcName = className + "_7C" + methodName + "_7C" + sigName;
   return funcName;
 }
diff --git a/src/mpl2mpl/BUILD.gn b/src/mpl2mpl/BUILD.gn
index 90bdf75c994eb11fa215a836645aab30009587c9..1d050a34f1590bfd8b442e863c12efbf11ab611a 100644
--- a/src/mpl2mpl/BUILD.gn
+++ b/src/mpl2mpl/BUILD.gn
@@ -38,6 +38,7 @@ src_libmpl2mpl = [
   "src/constantfold.cpp",
   "src/analyzector.cpp",
   "src/coderelayout.cpp",
+  "src/annotation_analysis.cpp",
 ]
 
 configs = [ "${MAPLEALL_ROOT}:mapleallcompilecfg" ]
diff --git a/src/mpl2mpl/include/annotation_analysis.h b/src/mpl2mpl/include/annotation_analysis.h
new file mode 100644
index 0000000000000000000000000000000000000000..101916fb0235f22451d8292e418fc5e4478b8fa5
--- /dev/null
+++ b/src/mpl2mpl/include/annotation_analysis.h
@@ -0,0 +1,297 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#ifndef MPL2MPL_INCLUDE_ANNOTATION_ANALYSIS_H
+#define MPL2MPL_INCLUDE_ANNOTATION_ANALYSIS_H
+#include "class_hierarchy.h"
+#include "namemangler.h"
+
+namespace maple {
+enum ATokenKind {
+  kEnd,
+  kChar,
+  kTemplateStart,
+  kTemplateEnd,
+  kAClassName,
+  kPrimeTypeName,
+  kTemplateName,
+  kExtend,
+  kSuper,
+  kArgumentStart,
+  kArgumentEnd,
+  kMatch,
+  kArray,
+  kString,
+  kSubClass,
+  kSemiComma
+};
+
+enum AKind {
+  kGenericType,
+  kGenericDeclare,
+  kGenericMatch,
+  kPrimeType,
+  kExtendType
+};
+
+enum EInfo {
+  kHierarchyExtend,
+  kHierarchyHSuper,
+  kArrayType
+};
+
+class AnnotationType {
+ public:
+  static int atime;
+  AnnotationType(AKind ak, GStrIdx strIdx) : id(atime++), kind(ak), typeName(strIdx) {}
+  ~AnnotationType() = default;
+  virtual const std::string GetName() const {
+    return GlobalTables::GetStrTable().GetStringFromStrIdx(typeName);
+  }
+
+  GStrIdx GetGStrIdx() {
+    return typeName;
+  }
+
+  AKind GetKind() const {
+    return kind;
+  }
+
+  int GetId() {
+    return id;
+  }
+
+  virtual void Dump();
+  virtual void ReWriteType(std::string &) {
+    CHECK_FATAL(false, "impossible");
+  }
+
+ protected:
+  int id;
+  AKind kind;
+  GStrIdx typeName;
+};
+
+class GenericDeclare;
+class GenericType : public AnnotationType {
+ public:
+  GenericType(GStrIdx strIdx, MIRType *ms, MapleAllocator &alloc)
+      :AnnotationType(kGenericType, strIdx),
+       mirStructType(ms),
+       GenericArg(alloc.Adapter()),
+       ArgOrder(alloc.Adapter()) {}
+  ~GenericType() = default;
+  void AddGenericPair(GenericDeclare *k, AnnotationType *v) {
+    GenericArg[k] = v;
+    ArgOrder.push_back(v);
+  }
+
+  MIRStructType *GetMIRStructType() {
+    if (mirStructType->IsInstanceOfMIRStructType()) {
+      return static_cast<MIRStructType*>(mirStructType);
+    }
+    CHECK_FATAL(false, "must be");
+    return nullptr;
+  }
+
+  MIRType *GetMIRType() {
+    return mirStructType;
+  }
+
+  virtual const std::string GetName() const override {
+    return mirStructType->GetMplTypeName();
+  }
+
+  MapleMap<GenericDeclare*, AnnotationType*> &GetGenericMap() {
+    return GenericArg;
+  }
+
+  MapleVector<AnnotationType*> &GetGenericArg() {
+    return ArgOrder;
+  }
+
+  virtual void Dump() override;
+  virtual void ReWriteType(std::string &subClass) override;
+ private:
+  MIRType *mirStructType;
+  MapleMap<GenericDeclare*, AnnotationType*> GenericArg;
+  MapleVector<AnnotationType*> ArgOrder;
+};
+
+class GenericDeclare : public AnnotationType {
+ public:
+  explicit GenericDeclare(GStrIdx strIdx)
+      :AnnotationType(kGenericDeclare, strIdx),
+       defaultType(nullptr) {}
+  ~GenericDeclare() = default;
+  AnnotationType *GetDefaultType() {
+    return defaultType;
+  }
+
+  void SetDefaultType(AnnotationType *gt) {
+    defaultType = gt;
+  }
+
+  std::string GetBelongToName() {
+    if (defKind == defByStruct) {
+      return belongsTo.structType->GetName();
+    } else {
+      return belongsTo.func->GetName();
+    }
+  }
+
+  virtual void Dump() override;
+
+  void SetBelongToStruct(MIRStructType *s) {
+    defKind = defByStruct;
+    belongsTo.structType = s;
+  }
+
+  void SetBelongToFunc(MIRFunction *f) {
+    defKind = defByFunc;
+    belongsTo.func = f;
+  }
+
+ private:
+  AnnotationType *defaultType;
+  union DefPoint {
+    MIRStructType *structType;
+    MIRFunction *func;
+  };
+  DefPoint belongsTo;
+  enum DefKind {
+    defByNone,
+    defByStruct,
+    defByFunc
+  };
+  DefKind defKind;
+};
+
+class ExtendGeneric: public AnnotationType {
+ public:
+  ExtendGeneric(AnnotationType *c, EInfo h) : AnnotationType(kExtendType, GStrIdx(0)), contains(c), eInfo(h) {
+    CHECK_FATAL(c->GetKind() != kGenericMatch, "must be");
+  }
+
+  virtual void Dump() override {
+    std::cout << (eInfo == kHierarchyExtend ? '+' : (eInfo == kArrayType ? '[' : '-'));
+    if (contains->GetKind() == kGenericDeclare) {
+      std::cout << "T" << contains->GetName() << ";";
+    } else {
+      contains->Dump();
+    }
+  }
+
+  EInfo GetExtendInfo() {
+    return eInfo;
+  }
+
+  AnnotationType *GetContainsGeneric() {
+    return contains;
+  }
+ private:
+  AnnotationType *contains;
+  EInfo eInfo;
+};
+
+class AnnotationParser {
+ public:
+  explicit AnnotationParser(std::string &s) : signature(s), curIndex(0) {}
+  ~AnnotationParser() = default;
+  ATokenKind GetNextToken(char *endC = nullptr);
+  GenericDeclare *GetOrCreateDeclare(GStrIdx gStrIdx, MemPool &mp, bool check = false, MIRStructType *sType = nullptr);
+  AnnotationType *GetOrCreateArrayType(AnnotationType *containsType, MemPool &pragmaMemPool);
+  void BackOne() {
+    --curIndex;
+  }
+
+  std::string GetCurIndexStr() {
+    return signature.substr(0, curIndex < signature.size() ? curIndex : signature.size());
+  }
+
+  void InitClassGenericDeclare(MemPool &pragmaMemPool, MIRStructType &mirStruct);
+  void InitFuncGenericDeclare(MemPool &pragmaMemPool, MIRFunction &mirFunc);
+  std::string GetNextClassName(bool forSubClass = false);
+  std::string GetCurStrToken() {
+    return curStrToken;
+  }
+
+  void ReplaceSignature(std::string &s) {
+    signature = s;
+    curIndex = 0;
+  }
+
+ private:
+  std::string &signature;
+  int curIndex;
+  std::map<GStrIdx, GenericDeclare*> created;
+  std::map<AnnotationType*, ExtendGeneric*> createdArrayType;
+  std::string curStrToken;
+};
+
+class AnnotationAnalysis : AnalysisResult {
+ public:
+  static char annoDeclare;
+  static char annoSemiColon;
+  AnnotationAnalysis(MIRModule *mod, MemPool *tmpMp, MemPool *pragmaMp, KlassHierarchy *kh)
+      : AnalysisResult(tmpMp),
+        mirModule(mod),
+        tmpAllocator(tmpMp),
+        pragmaMemPool(pragmaMp),
+        pragmaAllocator(pragmaMp),
+        klassH(kh) {
+          genericMatch = pragmaMp->New<AnnotationType>(kGenericMatch, GStrIdx(0));
+          GStrIdx strIdx = GlobalTables::GetStrTable().GetStrIdxFromName("Ljava_2Flang_2FObject_3B");
+          MIRType &classType = GetTypeFromTyIdx(GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(strIdx));
+          dummyObj = pragmaMp->New<GenericType>(strIdx, &static_cast<MIRStructType&>(classType), pragmaAllocator);
+        };
+  ~AnnotationAnalysis() = default;
+  void Run();
+ private:
+  void AnalysisAnnotation();
+  void AnnotationCleanUp();
+  void AnalysisAnnotationForClass(MIRPragma &classPragma);
+  void AnalysisAnnotationForVar(MIRPragma &varPragma, MIRStructType &structType);
+  void AnalysisAnnotationForFunc(MIRPragma &funcPragma, MIRStructType &structType);
+  AnnotationType *ReadInGenericType(AnnotationParser &aParser, MIRStructType *sType);
+  GenericDeclare *ReadInGenericDeclare(AnnotationParser &aParser, MIRStructType *mirStructType = nullptr);
+  std::string ReadInAllSubString(MIRPragma &classPragma);
+  void AAForClassInfo(MIRStructType &structType);
+  void AAForFuncVarInfo(MIRStructType &structType);
+  void AnalysisAnnotationForFuncLocalVar(MIRFunction &func, AnnotationParser &aParser, MIRStructType &structType);
+  void ByPassFollowingInfo(AnnotationParser &aParser, MIRStructType *sType);
+  MIRModule *mirModule;
+  MapleAllocator tmpAllocator;
+  MemPool *pragmaMemPool;
+  MapleAllocator pragmaAllocator;
+  KlassHierarchy *klassH;
+  std::set<MIRStructType*> analysised;
+  std::set<MIRFunction*> analysisedFunc;
+  AnnotationType *genericMatch;
+  GenericType *dummyObj;
+};
+
+class DoAnnotationAnalysis : public ModulePhase {
+ public:
+  explicit DoAnnotationAnalysis(ModulePhaseID id) : ModulePhase(id) {}
+
+  ~DoAnnotationAnalysis() = default;
+
+  AnalysisResult *Run(MIRModule *module, ModuleResultMgr *moduleResultMgr) override;
+  std::string PhaseName() const override {
+    return "annotationanalysis";
+  }
+};
+}
+#endif
diff --git a/src/mpl2mpl/include/gen_check_cast.h b/src/mpl2mpl/include/gen_check_cast.h
index f5962cd845a8ee312c42a8d18dc2e6bac0693618..fca8bd193d23160ca324bf425278173a91f1adc8 100644
--- a/src/mpl2mpl/include/gen_check_cast.h
+++ b/src/mpl2mpl/include/gen_check_cast.h
@@ -58,6 +58,8 @@ class DoCheckCastGeneration : public ModulePhase {
 
   AnalysisResult *Run(MIRModule *mod, ModuleResultMgr *mrm) override {
     OPT_TEMPLATE(CheckCastGenerator);
+    memPoolCtrler.DeleteMemPool(mod->GetPragmaMemPool());
+    mod->ChangePragmaMemPool(nullptr);
     return nullptr;
   }
 };
diff --git a/src/mpl2mpl/include/reflection_analysis.h b/src/mpl2mpl/include/reflection_analysis.h
old mode 100755
new mode 100644
index 479353a105eb94a4408552a4c8863fd558faad01..a02093e701bee6b92091ef4f1f69eeb4f0f924f9
--- a/src/mpl2mpl/include/reflection_analysis.h
+++ b/src/mpl2mpl/include/reflection_analysis.h
@@ -112,7 +112,7 @@ class ReflectionAnalysis : public AnalysisResult {
         classTab(allocator.Adapter()),
         isLibcore(false),
         isLazyBindingOrDecouple(false) {
-    Klass *objectKlass = kh->GetKlassFromLiteral(NameMangler::kJavaLangObjectStr);
+    Klass *objectKlass = kh->GetKlassFromLiteral(namemangler::kJavaLangObjectStr);
     if (objectKlass != nullptr && objectKlass->GetMIRStructType()->IsLocal()) {
       isLibcore = true;
     }
diff --git a/src/mpl2mpl/src/annotation_analysis.cpp b/src/mpl2mpl/src/annotation_analysis.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..6c73b3fc1a3736bc9926fb69f4720c47166dcb74
--- /dev/null
+++ b/src/mpl2mpl/src/annotation_analysis.cpp
@@ -0,0 +1,572 @@
+/*
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v1 for more details.
+ */
+#include "annotation_analysis.h"
+
+namespace maple {
+char AnnotationAnalysis::annoDeclare = ':';
+char AnnotationAnalysis::annoSemiColon = ';';
+int AnnotationType::atime = 0;
+MIRStructType *GetClassTypeFromName(std::string &className) {
+  GStrIdx strIdx = GlobalTables::GetStrTable().GetStrIdxFromName(className);
+  if (strIdx == 0) {
+    strIdx = GlobalTables::GetStrTable().GetStrIdxFromName("Ljava_2Flang_2FObject_3B");
+  }
+  TyIdx classTyIdx = GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(strIdx);
+  MIRType &classType = GetTypeFromTyIdx(classTyIdx);
+  return &static_cast<MIRStructType&>(classType);
+}
+
+void GenericDeclare::Dump() {
+  std::cout << GetName() << ":";
+  if (defaultType->GetKind() == kGenericDeclare) {
+    std::cout << "T" << defaultType->GetName() << ";";
+  } else if (defaultType->GetKind() == kGenericType) {
+    defaultType->Dump();
+  } else {
+    CHECK_FATAL(false, "must be");
+  }
+}
+
+void GenericType::Dump() {
+  std::string s = namemangler::DecodeName(GetName());
+  s.pop_back();
+  std::cout << s;
+  if (GenericArg.size()) {
+    std::cout << "<";
+    for (AnnotationType *real : ArgOrder) {
+      if (real->GetKind() == kGenericType) {
+        real->Dump();
+      } else if (real->GetKind() == kGenericDeclare) {
+        std::cout << "T" << real->GetName() << ";";
+      } else {
+        real->Dump();
+      }
+    }
+    std::cout << ">";
+  }
+  std::cout << ";";
+}
+
+void AnnotationType::Dump() {
+  if (kind == kGenericMatch) {
+    std::cout << "*";
+  } else {
+    std::cout << GetName();
+  }
+}
+
+void GenericType::ReWriteType(std::string &subClass) {
+  std::string className = mirStructType->GetName();
+  int ClassMethodSplitterStrSize = strlen(namemangler::kClassMethodSplitterStr);
+  className.replace(className.size() - ClassMethodSplitterStrSize, ClassMethodSplitterStrSize, subClass);
+  mirStructType = GetClassTypeFromName(className);
+  typeName = GlobalTables::GetStrTable().GetStrIdxFromName(className);
+  GenericArg.clear();
+  ArgOrder.clear();
+}
+
+GenericDeclare *AnnotationParser::GetOrCreateDeclare(GStrIdx gStrIdx, MemPool &mp, bool check, MIRStructType *sType) {
+  if (created.find(gStrIdx) != created.end()) {
+    return created[gStrIdx];
+  }
+  if (check) {
+    if (sType != nullptr) {
+      for (GenericDeclare *gd : sType->GetGenericDeclare()) {
+        if (gd->GetGStrIdx() == gStrIdx) {
+          return gd;
+        }
+      }
+    }
+    return nullptr;
+  }
+  GenericDeclare *gd = mp.New<GenericDeclare>(gStrIdx);
+  created[gStrIdx] = gd;
+  return gd;
+}
+
+ATokenKind AnnotationParser::GetNextToken(char *endC) {
+  if (curIndex == signature.size()) {
+    ++curIndex;
+    return kEnd;
+  }
+  CHECK_FATAL(curIndex < signature.size(), "must be");
+  if (endC == nullptr) {
+    switch (signature[curIndex++]) {
+      case '<':
+        return kTemplateStart;
+      case '>':
+        return kTemplateEnd;
+      case '(':
+        return kArgumentStart;
+      case ')':
+        return kArgumentEnd;
+      case '+':
+        return kExtend;
+      case '-':
+        return kSuper;
+      case '*':
+        return kMatch;
+      case '[':
+        return kArray;
+      case 'L':
+        return kAClassName;
+      case 'T':
+        return kTemplateName;
+      case 'I':
+      case 'Z':
+      case 'D':
+      case 'F':
+      case 'V':
+      case 'S':
+      case 'C':
+      case 'B':
+      case 'J':
+        curStrToken = signature[curIndex - 1];
+        return kPrimeTypeName;
+      case '.':
+        return kSubClass;
+      case ';':
+        return kSemiComma;
+      default:
+        curStrToken = signature[curIndex - 1];
+        return kChar;
+    }
+  }
+  size_t endPos = signature.find_first_of(endC, curIndex);
+  CHECK_FATAL(endPos != std::string::npos, "must be");
+  curStrToken = signature.substr(curIndex, endPos - curIndex);
+  curIndex = endPos + 1;
+  if (*endC == ':' && signature[endPos + 1] == ':') {
+    ++curIndex;
+  }
+  return kString;
+}
+
+// read until ; or <, whatever end of classname is ;
+std::string AnnotationParser::GetNextClassName(bool forSubClass) {
+  size_t pos1 = signature.find_first_of(';', curIndex);
+  size_t pos2 = signature.find_first_of('<', curIndex);
+  CHECK_FATAL(pos1 != pos2, "must be");
+  size_t pos = pos1 < pos2 ? pos1 : pos2;
+  curStrToken = signature.substr(curIndex - 1, pos - curIndex + 1);
+  curStrToken += ";";
+  curIndex = pos;
+  if (forSubClass) {
+    for (int i = 0; i < curStrToken.size(); ++i) {
+      if (curStrToken[i] == '.') {
+        curStrToken[i] = '$';
+      }
+    }
+  }
+  std::string className = namemangler::EncodeName(curStrToken);
+  return className;
+}
+
+void AnnotationParser::InitFuncGenericDeclare(MemPool &pragmaMemPool, MIRFunction &mirFunc) {
+  size_t declarePos = signature.find_first_of(':', curIndex);
+  size_t prev = 1;
+  size_t next = 0;
+  while (declarePos != std::string::npos) {
+    std::string declareName = signature.substr(prev, declarePos - prev);
+    if (declareName != "") {
+      GStrIdx gStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(declareName);
+      GenericDeclare *tmp = GetOrCreateDeclare(gStrIdx, pragmaMemPool);
+      tmp->SetBelongToFunc(&mirFunc);
+      mirFunc.AddFuncGenericDeclare(tmp);
+    }
+    if (signature[declarePos + 1] == ':') {
+      ++declarePos;
+    }
+    next = declarePos + 1;
+    declarePos = signature.find_first_of(':', next);
+    prev = signature.find_last_of (';', declarePos) + 1;
+  }
+}
+
+void AnnotationParser::InitClassGenericDeclare(MemPool &pragmaMemPool, MIRStructType &mirStruct) {
+  size_t declarePos = signature.find_first_of(':', curIndex);
+  size_t prev = 1;
+  size_t next = 0;
+  while (declarePos != std::string::npos) {
+    std::string declareName = signature.substr(prev, declarePos - prev);
+    if (declareName != "") {
+      GStrIdx gStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(declareName);
+      GenericDeclare *tmp = GetOrCreateDeclare(gStrIdx, pragmaMemPool);
+      tmp->SetBelongToStruct(&mirStruct);
+      mirStruct.AddClassGenericDeclare(tmp);
+    }
+    if (signature[declarePos + 1] == ':') {
+      ++declarePos;
+    }
+    next = declarePos + 1;
+    declarePos = signature.find_first_of(':', next);
+    prev = signature.find_last_of (';', declarePos) + 1;
+  }
+}
+
+void AnnotationAnalysis::AnnotationCleanUp() {
+  const MapleVector<Klass*> &klasses = klassH->GetTopoSortedKlasses();
+  for (Klass *klass : klasses) {
+    MIRStructType *mirStruct = klass->GetMIRStructType();
+    mirStruct->GetPragmaVec().clear();
+    mirStruct->GetPragmaVec().shrink_to_fit();
+  }
+  memPoolCtrler.DeleteMemPool(mirModule->GetPragmaMemPool());
+}
+
+void AnnotationAnalysis::ByPassFollowingInfo(AnnotationParser &aParser, MIRStructType *sType) {
+  ATokenKind t = aParser.GetNextToken();
+  if (t == kTemplateStart) {
+    t = aParser.GetNextToken();
+    while (t != kTemplateEnd) {
+      aParser.BackOne();
+      ReadInGenericType(aParser, sType);
+      t = aParser.GetNextToken();
+    }
+    CHECK_FATAL(t == kTemplateEnd, "must be");
+    t = aParser.GetNextToken();
+  }
+  while (t == kSubClass) {
+    std::string subClassName = aParser.GetNextClassName(true);
+    t = aParser.GetNextToken();
+    if (t == kTemplateStart) {
+      t = aParser.GetNextToken();
+      while (t != kTemplateEnd) {
+        aParser.BackOne();
+        ReadInGenericType(aParser, sType);
+        t = aParser.GetNextToken();
+      }
+      CHECK_FATAL(t == kTemplateEnd, "must be");
+      t = aParser.GetNextToken();
+    }
+  }
+  CHECK_FATAL(t == kSemiComma, "must be");
+}
+
+AnnotationType *AnnotationParser::GetOrCreateArrayType(AnnotationType *containsType, MemPool &pragmaMemPool) {
+  if (createdArrayType.find(containsType) != createdArrayType.end()) {
+    return createdArrayType[containsType];
+  }
+  ExtendGeneric *retType = pragmaMemPool.New<ExtendGeneric>(containsType, kArrayType);
+  createdArrayType[containsType] = retType;
+  return retType;
+}
+
+AnnotationType *AnnotationAnalysis::ReadInGenericType(AnnotationParser &aParser, MIRStructType *sType) {
+  ATokenKind tk = aParser.GetNextToken();
+  AnnotationType *retType = nullptr;
+  switch (tk) {
+    case kAClassName: {
+      std::string className = aParser.GetNextClassName();
+      GStrIdx gStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(className);
+      MIRStructType *mirStruct = GetClassTypeFromName(className);
+      if (mirStruct == nullptr) {
+        ByPassFollowingInfo(aParser, sType);
+        retType = dummyObj;
+        break;
+      }
+      std::vector<GenericDeclare*>& gdVector = mirStruct->GetGenericDeclare();
+      GenericType *gt = pragmaMemPool->New<GenericType>(gStrIdx, mirStruct, pragmaAllocator);
+      ATokenKind t = aParser.GetNextToken();
+      if (t == kTemplateStart) {
+        AAForClassInfo(*mirStruct);
+        for (int i = 0; i < gdVector.size(); ++i) {
+          AnnotationType *tmp = ReadInGenericType(aParser, sType);
+          gt->AddGenericPair(gdVector[i], tmp);
+        }
+        t = aParser.GetNextToken();
+        while (t != kTemplateEnd) {
+          aParser.BackOne();
+          ReadInGenericType(aParser, sType);
+          t = aParser.GetNextToken();
+        }
+        CHECK_FATAL(t == kTemplateEnd, "must be");
+        t = aParser.GetNextToken();
+      }
+      while (t == kSubClass) {
+        std::string subClassName = aParser.GetNextClassName(true);
+        gt->ReWriteType(subClassName);
+        t = aParser.GetNextToken();
+        if (t == kTemplateStart) {
+          AAForClassInfo(*gt->GetMIRStructType());
+          std::vector<GenericDeclare*>& gdTmpVector = gt->GetMIRStructType()->GetGenericDeclare();
+          for (int i = 0; i < gdTmpVector.size(); ++i) {
+            AnnotationType *tmp = ReadInGenericType(aParser, sType);
+            gt->AddGenericPair(gdTmpVector[i], tmp);
+          }
+          t = aParser.GetNextToken();
+          while (t != kTemplateEnd) {
+            aParser.BackOne();
+            ReadInGenericType(aParser, sType);
+            t = aParser.GetNextToken();
+          }
+          CHECK_FATAL(t == kTemplateEnd, "must be");
+          t = aParser.GetNextToken();
+        }
+      }
+      CHECK_FATAL(t == kSemiComma, "must be");
+      retType = gt;
+      break;
+    }
+    case kTemplateName: {
+      aParser.GetNextToken(&annoSemiColon);
+      GStrIdx s = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(aParser.GetCurStrToken());
+      retType = aParser.GetOrCreateDeclare(s, *pragmaMemPool, true, sType);
+      if (retType == nullptr) {
+        retType = dummyObj;
+      }
+      break;
+    }
+    case kExtend:
+      retType = ReadInGenericType(aParser, sType);
+      retType = pragmaMemPool->New<ExtendGeneric>(retType, kHierarchyExtend);
+      break;
+    case kSuper:
+      retType = ReadInGenericType(aParser, sType);
+      retType = pragmaMemPool->New<ExtendGeneric>(retType, kHierarchyHSuper);
+      break;
+    case kArray:
+      retType = ReadInGenericType(aParser, sType);
+      retType = aParser.GetOrCreateArrayType(retType, *pragmaMemPool);
+      break;
+    case kMatch:
+      return genericMatch;
+    case kPrimeTypeName: {
+      GStrIdx primeStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(aParser.GetCurStrToken());
+      retType = pragmaMemPool->New<AnnotationType>(kPrimeType, primeStrIdx);
+      break;
+    }
+    default:
+      CHECK_FATAL(false, "must be");
+  }
+  return retType;
+}
+
+GenericDeclare *AnnotationAnalysis::ReadInGenericDeclare(AnnotationParser &aParser, MIRStructType *mirStructType) {
+  aParser.GetNextToken(&annoDeclare);
+  GenericDeclare *gDeclare = nullptr;
+  if (aParser.GetCurStrToken() != "") {
+    GStrIdx gStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(aParser.GetCurStrToken());
+    gDeclare = aParser.GetOrCreateDeclare(gStrIdx, *pragmaMemPool, true, mirStructType);
+    CHECK_FATAL(gDeclare->GetDefaultType() == nullptr, "must be");
+  }
+  AnnotationType *at = ReadInGenericType(aParser, mirStructType);
+  if (gDeclare != nullptr) {
+    gDeclare->SetDefaultType(at);
+  }
+  return gDeclare;
+}
+
+std::string AnnotationAnalysis::ReadInAllSubString(MIRPragma &classPragma) {
+  GStrIdx gStrIdx;
+  std::string signature;
+  CHECK_FATAL(classPragma.GetElementVector().size() == 1, "must be");
+  for (MIRPragmaElement *pragmaElement : classPragma.GetElementVector()) {
+    CHECK_FATAL(pragmaElement->GetType() == kValueArray, "must be");
+    for (MIRPragmaElement *subPragmaEle : pragmaElement->GetSubElemVec()) {
+      CHECK_FATAL(subPragmaEle->GetType() == kValueString, "must be");
+      gStrIdx.reset(subPragmaEle->GetU64Val());
+      const std::string &str = GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx);
+      signature += str;
+    }
+  }
+  return signature;
+}
+
+void FunctionGenericDump(MIRFunction &func) {
+  if (func.GetFuncGenericDeclare().size()) {
+    std::cout << '<';
+    for (GenericDeclare *gd : func.GetFuncGenericDeclare()) {
+      gd->Dump();
+    }
+    std::cout << '>';
+  }
+  std::cout << '(';
+  for (AnnotationType *at : func.GetFuncGenericArg()) {
+    if (at->GetKind() == kGenericDeclare) {
+      std::cout << "T" << at->GetName() << ";";
+    } else {
+      at->Dump();
+    }
+  }
+  std::cout << ')';
+  AnnotationType *ret = func.GetFuncGenericRet();
+  if (ret->GetKind() == kGenericDeclare) {
+    std::cout << "T" << ret->GetName() << ";";
+  } else {
+    ret->Dump();
+  }
+  std::cout << std::endl;
+}
+
+void AnnotationAnalysis::AnalysisAnnotationForFuncLocalVar(MIRFunction &func, AnnotationParser &aParser,
+                                                           MIRStructType &structType) {
+  for (auto pair : func.GetAliasVarMap()) {
+    MIRAliasVars aliasVar = pair.second;
+    if (aliasVar.sigStrIdx) {
+      std::string newSig = GlobalTables::GetStrTable().GetStringFromStrIdx(aliasVar.sigStrIdx);
+      aParser.ReplaceSignature(newSig);
+      AnnotationType *var = ReadInGenericType(aParser, &structType);
+      func.AddFuncLocalGenericVar(aliasVar.memPoolStrIdx, var);
+    }
+  }
+}
+
+void AnnotationAnalysis::AnalysisAnnotationForFunc(MIRPragma &funcPragma, MIRStructType &structType) {
+  MIRSymbol *funcSymbol = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(funcPragma.GetStrIdx());
+  MIRFunction *func = funcSymbol->GetFunction();
+  analysisedFunc.insert(func);
+  CHECK_FATAL(func->GetFuncGenericDeclare().size() == 0, "must be");
+  CHECK_FATAL(func->GetFuncGenericArg().size() == 0, "must be");
+  std::string signature = ReadInAllSubString(funcPragma);
+  AnnotationParser aParser(signature);
+  ATokenKind tk = aParser.GetNextToken();
+  if (tk == kTemplateStart) {
+    aParser.InitFuncGenericDeclare(*pragmaMemPool, *func);
+    while (aParser.GetNextToken() != kTemplateEnd) {
+      aParser.BackOne();
+      ReadInGenericDeclare(aParser, &structType);
+    }
+    tk = aParser.GetNextToken();
+  }
+  CHECK_FATAL(tk == kArgumentStart, "must be");
+  tk = aParser.GetNextToken();
+  while (tk != kArgumentEnd) {
+    aParser.BackOne();
+    AnnotationType *arg = ReadInGenericType(aParser, &structType);
+    func->AddFuncGenericArg(arg);
+    tk = aParser.GetNextToken();
+  }
+  AnnotationType *ret = ReadInGenericType(aParser, &structType);
+  func->AddFuncGenericRet(ret);
+  AnalysisAnnotationForFuncLocalVar(*func, aParser, structType);
+}
+
+void AnnotationAnalysis::AnalysisAnnotationForVar(MIRPragma &varPragma, MIRStructType &structType) {
+  std::string signature = ReadInAllSubString(varPragma);
+  AnnotationParser aParser(signature);
+  ATokenKind tk = aParser.GetNextToken();
+  CHECK_FATAL(tk == kAClassName || tk == kTemplateName || tk == kArray, "must be");
+  aParser.BackOne();
+  AnnotationType *at = ReadInGenericType(aParser, &structType);
+  structType.AddFieldGenericDeclare(varPragma.GetStrIdx(), at);
+}
+
+void AnnotationAnalysis::AnalysisAnnotationForClass(MIRPragma &classPragma) {
+  TyIdx classTyIdx = GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(classPragma.GetStrIdx());
+  MIRType &classType = GetTypeFromTyIdx(classTyIdx);
+  CHECK_FATAL(classType.GetKind() == kTypeClass || classType.GetKind() == kTypeInterface, "must be");
+  std::string signature = ReadInAllSubString(classPragma);
+  AnnotationParser aParser(signature);
+  ATokenKind tk = aParser.GetNextToken();
+  if (tk != kTemplateStart) {
+    return;
+  }
+  aParser.InitClassGenericDeclare(*pragmaMemPool, static_cast<MIRStructType&>(classType));
+  while (aParser.GetNextToken() != kTemplateEnd) {
+    aParser.BackOne();
+    ReadInGenericDeclare(aParser);
+  }
+  while (aParser.GetNextToken() != kEnd) {
+    aParser.BackOne();
+    AnnotationType *at = ReadInGenericType(aParser, nullptr);
+    CHECK_FATAL(at->GetKind() == kGenericType, "must be");
+    if (static_cast<GenericType*>(at)->GetMIRStructType() != &classType) {
+      static_cast<MIRStructType&>(classType).AddInheritaceGeneric(static_cast<GenericType*>(at));
+    }
+  }
+  return;
+}
+
+void AnnotationAnalysis::AAForClassInfo(MIRStructType &structType) {
+  if (analysised.find(&structType) != analysised.end() || structType.IsIncomplete()) {
+    return;
+  }
+  analysised.insert(&structType);
+  std::vector<MIRPragma*> &pragmaVec = structType.GetPragmaVec();
+  for (MIRPragma *pragma : pragmaVec) {
+    MIRType *pragmaType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pragma->GetTyIdx());
+    if (pragmaType->GetName() != "Lark_2Fannotation_2FSignature_3B") {
+      continue;
+    }
+    if (pragma->GetKind() != kPragmaClass) {
+      continue;
+    }
+    AnalysisAnnotationForClass(*pragma);
+  }
+}
+
+void AnnotationAnalysis::AAForFuncVarInfo(MIRStructType &structType) {
+  std::vector<MIRPragma*> &pragmaVec = structType.GetPragmaVec();
+  for (MIRPragma *pragma : pragmaVec) {
+    MIRType *pragmaType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pragma->GetTyIdx());
+    if (pragmaType->GetName() != "Lark_2Fannotation_2FSignature_3B") {
+      continue;
+    }
+    if (pragma->GetKind() == kPragmaVar) {
+      AnalysisAnnotationForVar(*pragma, structType);
+    } else if (pragma->GetKind() == kPragmaFunc) {
+      AnalysisAnnotationForFunc(*pragma, structType);
+    }
+  }
+}
+
+void AnnotationAnalysis::AnalysisAnnotation() {
+  const MapleVector<Klass*> &klasses = klassH->GetTopoSortedKlasses();
+  for (Klass *klass : klasses) {
+    if (klass->IsInterfaceIncomplete() || klass->IsClassIncomplete()) {
+      continue;
+    }
+    MIRStructType *structType = klass->GetMIRStructType();
+    AAForClassInfo(*structType);
+  }
+  for (Klass *klass : klasses) {
+    if (klass->IsInterfaceIncomplete() || klass->IsClassIncomplete()) {
+      continue;
+    }
+    MIRStructType *structType = klass->GetMIRStructType();
+    AAForFuncVarInfo(*structType);
+  }
+  for (MIRFunction *func : mirModule->GetFunctionList()) {
+    if (func->IsEmpty() || analysisedFunc.find(func) != analysisedFunc.end()) {
+      continue;
+    }
+    MIRType *classType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(func->GetClassTyIdx());
+    if (classType == nullptr) {
+      continue;
+    }
+    std::string tmp;
+    AnnotationParser aParser(tmp);
+    AnalysisAnnotationForFuncLocalVar(*func, aParser, static_cast<MIRStructType&>(*classType));
+  }
+}
+
+void AnnotationAnalysis::Run() {
+  AnalysisAnnotation();
+  AnnotationCleanUp();
+}
+
+AnalysisResult *DoAnnotationAnalysis::Run(MIRModule *module, ModuleResultMgr *moduleResultMgr) {
+  MemPool *memPool = memPoolCtrler.NewMemPool("AnnotationAnalysis mempool");
+  MemPool *pragmaMemPool = memPoolCtrler.NewMemPool("New Pragma mempool");
+  auto *kh = static_cast<KlassHierarchy*>(moduleResultMgr->GetAnalysisResult(MoPhase_CHA, module));
+  ASSERT_NOT_NULL(kh);
+  AnnotationAnalysis AA(module, memPool, pragmaMemPool, kh);
+  AA.Run();
+  memPoolCtrler.DeleteMemPool(memPool);
+  module->ChangePragmaMemPool(pragmaMemPool);
+  return nullptr;
+}
+}
diff --git a/src/mpl2mpl/src/class_hierarchy.cpp b/src/mpl2mpl/src/class_hierarchy.cpp
index 03b532a2544267b3cbd17454d85804519ba14e8c..e27138bf5333a17b691f9065e1d32b56f0776187 100644
--- a/src/mpl2mpl/src/class_hierarchy.cpp
+++ b/src/mpl2mpl/src/class_hierarchy.cpp
@@ -326,7 +326,7 @@ Klass *KlassHierarchy::GetKlassFromName(const std::string &name) const {
 }
 
 Klass *KlassHierarchy::GetKlassFromLiteral(const std::string &name) const {
-  return GetKlassFromStrIdx(GlobalTables::GetStrTable().GetStrIdxFromName(NameMangler::GetInternalNameLiteral(name)));
+  return GetKlassFromStrIdx(GlobalTables::GetStrTable().GetStrIdxFromName(namemangler::GetInternalNameLiteral(name)));
 }
 
 
@@ -488,7 +488,7 @@ void KlassHierarchy::AddKlasses() {
     GStrIdx strIdx = type->GetNameStrIdx();
     Klass *klass = GetKlassFromStrIdx(strIdx);
     if (klass != nullptr) {
-      if (klass->GetKlassName().compare(NameMangler::kThrowClassStr) == 0) {
+      if (klass->GetKlassName().compare(namemangler::kThrowClassStr) == 0) {
         klass->SetExceptionKlass();
       }
       continue;
@@ -553,15 +553,15 @@ void KlassHierarchy::AddKlassRelationAndMethods() {
       MIRSymbol *funcSym = GlobalTables::GetGsymTable().GetSymbolFromStidx(methodPair.first.Idx());
       MIRFunction *method = funcSym->GetFunction();
       klass->AddMethod(method);
-      if (method->GetName().compare(klass->GetKlassName() + NameMangler::kClinitSuffix) == 0) {
+      if (method->GetName().compare(klass->GetKlassName() + namemangler::kClinitSuffix) == 0) {
         klass->SetClinit(method);
       }
     }
   }
   // Propagate isExceptionKlass flag
-  if (GetKlassFromLiteral(NameMangler::kThrowClassStr) != nullptr) {
-    ExceptionFlagProp(*GetKlassFromLiteral(NameMangler::kThrowClassStr));
-    CHECK_FATAL(GetKlassFromLiteral(NameMangler::kThrowClassStr)->IsExceptionKlass(), "must be exception class");
+  if (GetKlassFromLiteral(namemangler::kThrowClassStr) != nullptr) {
+    ExceptionFlagProp(*GetKlassFromLiteral(namemangler::kThrowClassStr));
+    CHECK_FATAL(GetKlassFromLiteral(namemangler::kThrowClassStr)->IsExceptionKlass(), "must be exception class");
   }
   if (GetKlassFromLiteral(kJavaLangNoMethodStr) != nullptr) {
     CHECK_FATAL(GetKlassFromLiteral(kJavaLangNoMethodStr)->IsExceptionKlass(), "must be exception class");
@@ -569,7 +569,7 @@ void KlassHierarchy::AddKlassRelationAndMethods() {
 }
 
 void KlassHierarchy::TagThrowableKlasses() {
-  Klass *throwable = GetKlassFromName(NameMangler::kThrowClassStr);
+  Klass *throwable = GetKlassFromName(namemangler::kThrowClassStr);
   if (throwable == nullptr) {
     return;
   }
@@ -707,7 +707,7 @@ void KlassHierarchy::MarkClassFlags() {
   AddClassFlag("Ljava_2Flang_2Fref_2FPhantomReference_3B", kClassPhantomreference);
   AddClassFlag("Ljava_2Flang_2Fref_2FFinalizerReference_3B", kClassFinalizereference);
   AddClassFlag("Ljava_2Flang_2Fref_2FFinalizerReference_24Sentinel_3B", kClassFinalizerreferenceSentinel);
-  Klass *klassObject = GetKlassFromLiteral(NameMangler::kJavaLangObjectStr);
+  Klass *klassObject = GetKlassFromLiteral(namemangler::kJavaLangObjectStr);
   GStrIdx finalize = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName("finalize_7C_28_29V");
   for (Klass *klass : topoWorkList) {
     if (klass == klassObject) {
@@ -810,12 +810,12 @@ MIRType *WKTypes::javaLangRefMember;
 MIRType *WKTypes::javaLangRefField;
 MIRType *WKTypes::javaLangRefConstructor;
 inline static MIRType *GetMIRTypeFromName(const std::string &name) {
-  GStrIdx gStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(NameMangler::GetInternalNameLiteral(name));
+  GStrIdx gStrIdx = GlobalTables::GetStrTable().GetStrIdxFromName(namemangler::GetInternalNameLiteral(name));
   return GlobalTables::GetTypeTable().GetTypeFromTyIdx(GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(gStrIdx));
 }
 
 void WKTypes::Init() {
-  javaLangObject = GetMIRTypeFromName(NameMangler::kJavaLangObjectStr);
+  javaLangObject = GetMIRTypeFromName(namemangler::kJavaLangObjectStr);
   javaLangString = GetMIRTypeFromName("Ljava_2Flang_2FString_3B");
   javaLangObjectSerializable = GetMIRTypeFromName("Ljava_2Fio_2FSerializable_3B");
   javaLangComparable = GetMIRTypeFromName("Ljava_2Flang_2FComparable_3B");
diff --git a/src/mpl2mpl/src/class_init.cpp b/src/mpl2mpl/src/class_init.cpp
index 215a45626ff8495512626c831baff4f7d40c9b3e..93e4f23a6832198881ed2bebb4ad041ea863feed 100644
--- a/src/mpl2mpl/src/class_init.cpp
+++ b/src/mpl2mpl/src/class_init.cpp
@@ -69,13 +69,13 @@ void ClassInit::ProcessFunc(MIRFunction *func) {
     selfClassName = GlobalTables::GetStrTable().GetStringFromStrIdx(selfClassType->GetNameStrIdx());
   } else {
     const std::string &funcName = func->GetName();
-    size_t pos = funcName.find(NameMangler::kNameSplitterStr);
+    size_t pos = funcName.find(namemangler::kNameSplitterStr);
     constexpr size_t prePos = 2;
     constexpr size_t ligalPos = 2;
     while (pos != std::string::npos &&
            (pos >= ligalPos && funcName[pos - 1] == '_' && funcName[pos - prePos] != '_')) {
       constexpr size_t nextPos = 3;
-      pos = funcName.find(NameMangler::kNameSplitterStr, pos + nextPos);
+      pos = funcName.find(namemangler::kNameSplitterStr, pos + nextPos);
     }
     selfClassName = funcName.substr(0, pos);
   }
@@ -161,7 +161,7 @@ void ClassInit::ProcessFunc(MIRFunction *func) {
 MIRSymbol *ClassInit::GetClassInfo(const std::string &classname) {
   const std::string &classInfoName = CLASSINFO_PREFIX_STR + classname;
   MIRType *classInfoType =
-      GlobalTables::GetTypeTable().GetOrCreateClassType(NameMangler::kClassMetadataTypeName, GetMIRModule());
+      GlobalTables::GetTypeTable().GetOrCreateClassType(namemangler::kClassMetadataTypeName, GetMIRModule());
   MIRSymbol *classInfo = builder->GetOrCreateGlobalDecl(classInfoName, *classInfoType);
   Klass *klass = klassHierarchy->GetKlassFromName(classname);
   if (klass == nullptr || !klass->GetMIRStructType()->IsLocal()) {
diff --git a/src/mpl2mpl/src/coderelayout.cpp b/src/mpl2mpl/src/coderelayout.cpp
index f85246f0f6548897ec9ec3d27c262c8ca411a9f4..179001226483f11d2d13f4147502853ae3f50f2d 100644
--- a/src/mpl2mpl/src/coderelayout.cpp
+++ b/src/mpl2mpl/src/coderelayout.cpp
@@ -213,7 +213,7 @@ MIRSymbol *CodeReLayout::GenStrSym(const std::string &str) {
   std::string newStr = str + '\0';
   MIRArrayType &strTabType = *GlobalTables::GetTypeTable().GetOrCreateArrayType(
       *GlobalTables::GetTypeTable().GetUInt8(), static_cast<uint32>(newStr.length()));
-  std::string strTabName = NameMangler::kStaticFieldNamePrefixStr + str;
+  std::string strTabName = namemangler::kStaticFieldNamePrefixStr + str;
   MIRSymbol *staticSym = builder->CreateGlobalDecl(strTabName, strTabType);
   MIRAggConst *strTabAggConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), strTabType);
   staticSym->SetStorageClass(kScFstatic);
@@ -275,7 +275,7 @@ void CodeReLayout::GenLayoutSym() {
     funcLayoutConst->PushBack(fieldConst);
     funcIdx += layoutCount[i];
   }
-  std::string funcLayoutSymName = NameMangler::kFunctionLayoutStr + GetMIRModule().GetFileNameAsPostfix();
+  std::string funcLayoutSymName = namemangler::kFunctionLayoutStr + GetMIRModule().GetFileNameAsPostfix();
   MIRSymbol *funcLayoutSym = builder->CreateGlobalDecl(funcLayoutSymName, arrayType);
   funcLayoutSym->SetKonst(funcLayoutConst);
   funcLayoutSym->SetStorageClass(kScFstatic);
diff --git a/src/mpl2mpl/src/gen_check_cast.cpp b/src/mpl2mpl/src/gen_check_cast.cpp
index 2b3cbf1f839de957945fea4de68563413613f78d..0324b27fcbf2ce3a4d00de602173b55c73cdad3b 100644
--- a/src/mpl2mpl/src/gen_check_cast.cpp
+++ b/src/mpl2mpl/src/gen_check_cast.cpp
@@ -45,7 +45,7 @@ void CheckCastGenerator::InitTypes() {
   const MIRType *javaLangObjectType = WKTypes::Util::GetJavaLangObjectType();
   CHECK_FATAL(javaLangObjectType != nullptr, "The pointerObjType in InitTypes is null!");
   pointerObjType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*javaLangObjectType);
-  classinfoType = GlobalTables::GetTypeTable().GetOrCreateClassType(NameMangler::kClassMetadataTypeName,
+  classinfoType = GlobalTables::GetTypeTable().GetOrCreateClassType(namemangler::kClassMetadataTypeName,
                                                                     GetMIRModule());
   pointerClassMetaType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*classinfoType);
 }
@@ -107,7 +107,7 @@ void CheckCastGenerator::GenCheckCast(StmtNode &stmt) {
 
   {
     if ((checkKlass != nullptr) && (checkKlass->GetKlassName() != "")) {
-      if (checkKlass->GetKlassName() == NameMangler::kJavaLangObjectStr) {
+      if (checkKlass->GetKlassName() == namemangler::kJavaLangObjectStr) {
         const size_t callNodeNopndSize1 = callNode->GetNopndSize();
         CHECK_FATAL(callNodeNopndSize1 > 0, "container check");
         if (callNode->GetNopndAt(0)->GetPrimType() != PTY_ref && callNode->GetNopndAt(0)->GetPrimType() != PTY_ptr) {
@@ -276,7 +276,7 @@ void CheckCastGenerator::GenAllCheckCast() {
 
 BaseNode *CheckCastGenerator::GetObjectShadow(BaseNode *opnd) {
   FieldID fieldID = builder->GetStructFieldIDFromFieldNameParentFirst(WKTypes::Util::GetJavaLangObjectType(),
-                                                                      NameMangler::kShadowClassName);
+                                                                      namemangler::kShadowClassName);
   BaseNode *ireadExpr =
       builder->CreateExprIread(*GlobalTables::GetTypeTable().GetPtr(), *pointerObjType, fieldID, opnd);
   return ireadExpr;
diff --git a/src/mpl2mpl/src/muid_replacement.cpp b/src/mpl2mpl/src/muid_replacement.cpp
old mode 100755
new mode 100644
index 725a2714d7419a9957ad0e6eeef82fa9c9bcf7b1..81c35dd6dba3a1b67a413e53de9414f42de11842
--- a/src/mpl2mpl/src/muid_replacement.cpp
+++ b/src/mpl2mpl/src/muid_replacement.cpp
@@ -55,7 +55,7 @@ MUID MUIDReplacement::mplMuid;
 
 MUIDReplacement::MUIDReplacement(MIRModule &mod, KlassHierarchy *kh, bool dump)
     : FuncOptimizeImpl(mod, kh, dump) {
-  isLibcore = (GetSymbolFromName(NameMangler::GetInternalNameLiteral(NameMangler::kJavaLangObjectStr)) != nullptr);
+  isLibcore = (GetSymbolFromName(namemangler::GetInternalNameLiteral(namemangler::kJavaLangObjectStr)) != nullptr);
   GenerateTables();
 }
 
@@ -245,7 +245,7 @@ void MUIDReplacement::CollectImplicitUndefClassInfo(StmtNode &stmt) {
         if (type->GetKind() == kTypeClass || type->GetKind() == kTypeInterface) {
           classTyVec.push_back(static_cast<MIRStructType*>(type));
         } else if (type == GlobalTables::GetTypeTable().GetVoid()) {
-          Klass *objectKlass = klassHierarchy->GetKlassFromLiteral(NameMangler::kJavaLangObjectStr);
+          Klass *objectKlass = klassHierarchy->GetKlassFromLiteral(namemangler::kJavaLangObjectStr);
           if (objectKlass != nullptr) {
             classTyVec.push_back(objectKlass->GetMIRStructType());
           }
@@ -431,32 +431,32 @@ void MUIDReplacement::GenerateFuncDefTable() {
     mplMuidStr += muid.ToStr();
   }
   if (!funcDefTabConst->GetConstVec().empty()) {
-    std::string funcDefTabName = NameMangler::kMuidFuncDefTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    std::string funcDefTabName = namemangler::kMuidFuncDefTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
     funcDefTabSym = builder->CreateGlobalDecl(funcDefTabName, arrayType);
     funcDefTabSym->SetKonst(funcDefTabConst);
     funcDefTabSym->SetStorageClass(kScFstatic);
   }
   if (!funcInfTabConst->GetConstVec().empty()) {
-    std::string funcInfTabName = NameMangler::kMuidFuncInfTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    std::string funcInfTabName = namemangler::kMuidFuncInfTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
     funcInfTabSym = builder->CreateGlobalDecl(funcInfTabName, funcInfArrayType);
     funcInfTabSym->SetKonst(funcInfTabConst);
     funcInfTabSym->SetStorageClass(kScFstatic);
   }
   if (!funcDefMuidTabConst->GetConstVec().empty()) {
-    std::string funcDefMuidTabName = NameMangler::kMuidFuncDefMuidTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    std::string funcDefMuidTabName = namemangler::kMuidFuncDefMuidTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
     funcDefMuidTabSym = builder->CreateGlobalDecl(funcDefMuidTabName, muidArrayType);
     funcDefMuidTabSym->SetKonst(funcDefMuidTabConst);
     funcDefMuidTabSym->SetStorageClass(kScFstatic);
   }
   if (!muidIdxTabConst->GetConstVec().empty()) {
-    std::string muidIdxTabName = NameMangler::kMuidFuncMuidIdxTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    std::string muidIdxTabName = namemangler::kMuidFuncMuidIdxTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
     funcMuidIdxTabSym = builder->CreateGlobalDecl(muidIdxTabName, muidIdxArrayType);
     funcMuidIdxTabSym->SetKonst(muidIdxTabConst);
     funcMuidIdxTabSym->SetStorageClass(kScFstatic);
   }
 
   if (!funcProfInfTabConst->GetConstVec().empty()) {
-    std::string profInfTabName = NameMangler::kFuncIRProfInfTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    std::string profInfTabName = namemangler::kFuncIRProfInfTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
     funcProfInfTabSym = builder->CreateGlobalDecl(profInfTabName, funcProfInfArrayType);
     funcProfInfTabSym->SetKonst(funcProfInfTabConst);
     funcProfInfTabSym->SetStorageClass(kScFstatic);
@@ -469,7 +469,7 @@ void MUIDReplacement::GenerateFuncDefTable() {
 void MUIDReplacement::ReplaceMethodMetaFuncAddr(MIRSymbol &funcSymbol, int64 index) {
   std::string symbolName = funcSymbol.GetName();
   MIRSymbol *methodAddrDataSt = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
-      GlobalTables::GetStrTable().GetStrIdxFromName(NameMangler::kMethodAddrDataPrefixStr + symbolName));
+      GlobalTables::GetStrTable().GetStrIdxFromName(namemangler::kMethodAddrDataPrefixStr + symbolName));
   CHECK_FATAL(methodAddrDataSt != nullptr, "methodAddrDataSt symbol is null.");
   MIRConst *mirConst = methodAddrDataSt->GetKonst();
   MIRAggConst *aggConst = safe_cast<MIRAggConst>(mirConst);
@@ -541,13 +541,13 @@ void MUIDReplacement::GenerateDataDefTable() {
     DumpMUIDFile(false);
   }
   if (!dataDefTabConst->GetConstVec().empty()) {
-    std::string dataDefTabName = NameMangler::kMuidDataDefTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    std::string dataDefTabName = namemangler::kMuidDataDefTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
     dataDefTabSym = builder->CreateGlobalDecl(dataDefTabName, arrayType);
     dataDefTabSym->SetKonst(dataDefTabConst);
     dataDefTabSym->SetStorageClass(kScFstatic);
   }
   if (!dataDefMuidTabConst->GetConstVec().empty()) {
-    std::string dataDefMuidTabName = NameMangler::kMuidDataDefMuidTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    std::string dataDefMuidTabName = namemangler::kMuidDataDefMuidTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
     dataDefMuidTabSym = builder->CreateGlobalDecl(dataDefMuidTabName, muidArrayType);
     dataDefMuidTabSym->SetKonst(dataDefMuidTabConst);
     dataDefMuidTabSym->SetStorageClass(kScFstatic);
@@ -557,7 +557,7 @@ void MUIDReplacement::GenerateDataDefTable() {
 void MUIDReplacement::ReplaceFieldMetaStaticAddr(const MIRSymbol &mirSymbol, uint32 index) {
   std::string symbolName = mirSymbol.GetName();
   MIRSymbol *fieldOffsetDataSt = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
-      GlobalTables::GetStrTable().GetStrIdxFromName(NameMangler::kFieldOffsetDataPrefixStr + symbolName));
+      GlobalTables::GetStrTable().GetStrIdxFromName(namemangler::kFieldOffsetDataPrefixStr + symbolName));
   if (fieldOffsetDataSt == nullptr) {
     if (trace) {
       LogInfo::MapleLogger() << "fieldOffsetDataSt is nullptr, symbolName=" << symbolName << "\n";
@@ -647,14 +647,14 @@ void MUIDReplacement::GenerateUnifiedUndefTable() {
     funcUndefMuidTabConst->PushBack(muidEntryConst);
   }
   if (!funcUndefTabConst->GetConstVec().empty()) {
-    std::string funcUndefTabName = NameMangler::kMuidFuncUndefTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    std::string funcUndefTabName = namemangler::kMuidFuncUndefTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
     funcUndefTabSym = builder->CreateGlobalDecl(funcUndefTabName, funcArrayType);
     funcUndefTabSym->SetKonst(funcUndefTabConst);
     funcUndefTabSym->SetStorageClass(kScFstatic);
   }
   if (!funcUndefMuidTabConst->GetConstVec().empty()) {
     std::string funcUndefMuidTabName =
-      NameMangler::kMuidFuncUndefMuidTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+      namemangler::kMuidFuncUndefMuidTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
     funcUndefMuidTabSym = builder->CreateGlobalDecl(funcUndefMuidTabName, funcMuidArrayType);
     funcUndefMuidTabSym->SetKonst(funcUndefMuidTabConst);
     funcUndefMuidTabSym->SetStorageClass(kScFstatic);
@@ -688,14 +688,14 @@ void MUIDReplacement::GenerateUnifiedUndefTable() {
     }
   }
   if (!dataUndefTabConst->GetConstVec().empty()) {
-    std::string dataUndefTabName = NameMangler::kMuidDataUndefTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    std::string dataUndefTabName = namemangler::kMuidDataUndefTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
     dataUndefTabSym = builder->CreateGlobalDecl(dataUndefTabName, dataArrayType);
     dataUndefTabSym->SetKonst(dataUndefTabConst);
     dataUndefTabSym->SetStorageClass(kScFstatic);
   }
   if (!dataUndefMuidTabConst->GetConstVec().empty()) {
     std::string dataUndefMuidTabName =
-      NameMangler::kMuidDataUndefMuidTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+      namemangler::kMuidDataUndefMuidTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
     dataUndefMuidTabSym = builder->CreateGlobalDecl(dataUndefMuidTabName, dataMuidArrayType);
     dataUndefMuidTabSym->SetKonst(dataUndefMuidTabConst);
     dataUndefMuidTabSym->SetStorageClass(kScFstatic);
@@ -745,7 +745,7 @@ void MUIDReplacement::GenerateRangeTable() {
     MIRAggConst *entryConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), rangeTabEntryType);
     uint32 fieldID = 1;
     if (i == RangeIdx::kGlobalRootlist) {
-      MIRSymbol *st = GetSymbolFromName(NameMangler::kGcRootList);
+      MIRSymbol *st = GetSymbolFromName(namemangler::kGcRootList);
       if (st == nullptr) {
         builder->AddIntFieldConst(rangeTabEntryType, *entryConst, fieldID++, 0);
         builder->AddIntFieldConst(rangeTabEntryType, *entryConst, fieldID++, 0);
@@ -781,7 +781,7 @@ void MUIDReplacement::GenerateRangeTable() {
     builder->AddIntFieldConst(rangeTabEntryType, *entryConst, fieldID++, i);
     rangeTabConst->PushBack(entryConst);
   }
-  std::string bbProfileName = NameMangler::kBBProfileTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+  std::string bbProfileName = namemangler::kBBProfileTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
   MIRSymbol *funcProfCounterTabSym = GetSymbolFromName(bbProfileName);
   std::vector<MIRSymbol*> irProfWorkList = {
     funcProfInfTabSym,
@@ -790,7 +790,7 @@ void MUIDReplacement::GenerateRangeTable() {
   InitRangeTabUseSym(irProfWorkList, rangeTabEntryType, *rangeTabConst);
   if (!rangeTabConst->GetConstVec().empty()) {
     rangeArrayType.SetSizeArrayItem(0, rangeTabConst->GetConstVec().size());
-    std::string rangeTabName = NameMangler::kMuidRangeTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+    std::string rangeTabName = namemangler::kMuidRangeTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
     rangeTabSym = builder->CreateGlobalDecl(rangeTabName, rangeArrayType);
     rangeTabSym->SetKonst(rangeTabConst);
     rangeTabSym->SetStorageClass(kScFstatic);
@@ -1078,7 +1078,7 @@ void MUIDReplacement::ReplaceDirectInvokeOrAddroffunc(MIRFunction &currentFunc,
   if (calleeFunc->GetBody() != nullptr) {
     // Local function is accessed through funcDefTab
     // Add a comment to store the original function name
-    std::string commentLabel = NameMangler::kMarkMuidFuncDefStr + calleeFunc->GetName();
+    std::string commentLabel = namemangler::kMarkMuidFuncDefStr + calleeFunc->GetName();
     currentFunc.GetBody()->InsertBefore(&stmt, builder->CreateStmtComment(commentLabel));
 
     std::string moduleName = GetMIRModule().GetFileNameAsPostfix();
@@ -1091,7 +1091,7 @@ void MUIDReplacement::ReplaceDirectInvokeOrAddroffunc(MIRFunction &currentFunc,
   } else {
     // External function is accessed through funcUndefTab
     // Add a comment to store the original function name
-    std::string commentLabel = NameMangler::kMarkMuidFuncUndefStr + calleeFunc->GetName();
+    std::string commentLabel = namemangler::kMarkMuidFuncUndefStr + calleeFunc->GetName();
     currentFunc.GetBody()->InsertBefore(&stmt, builder->CreateStmtComment(commentLabel));
 
     ASSERT(funcUndefTabSym != nullptr, "null ptr check!");
@@ -1375,7 +1375,7 @@ void MUIDReplacement::GenerateGlobalRootList() {
     MIRConst *constNode = GetMIRModule().GetMemPool()->New<MIRAddrofConst>(symbol->GetStIdx(), 0, ptrType);
     newConst->PushBack(constNode);
   }
-  std::string gcRootsName = NameMangler::kGcRootList;
+  std::string gcRootsName = namemangler::kGcRootList;
   if (!newConst->GetConstVec().empty()) {
     MIRSymbol *gcRootsSt = builder->CreateSymbol(newConst->GetType().GetTypeIndex(), gcRootsName, kStVar,
                                                  kScAuto, nullptr, kScopeGlobal);
@@ -1394,7 +1394,7 @@ void MUIDReplacement::GenerateCompilerVersionNum() {
   MIRConst *secondConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(Version::kMinorCompilerVersion, type);
   newConst->PushBack(firstConst);
   newConst->PushBack(secondConst);
-  std::string symName = NameMangler::kCompilerVersionNum + GetMIRModule().GetFileNameAsPostfix();
+  std::string symName = namemangler::kCompilerVersionNum + GetMIRModule().GetFileNameAsPostfix();
   MIRSymbol *versionNum = builder->CreateGlobalDecl(symName, arrayType);
   versionNum->SetKonst(newConst);
 }
@@ -1421,12 +1421,12 @@ void MUIDReplacement::GenerateTables() {
   }
   // Replace undef entries in vtab/itab/reflectionMetaData
   for (Klass *klass : klassHierarchy->GetTopoSortedKlasses()) {
-    ReplaceFieldTypeTable(NameMangler::kFieldsInfoPrefixStr + klass->GetKlassName());
+    ReplaceFieldTypeTable(namemangler::kFieldsInfoPrefixStr + klass->GetKlassName());
     ReplaceFuncTable(VTAB_PREFIX_STR + klass->GetKlassName());
     ReplaceFuncTable(ITAB_PREFIX_STR + klass->GetKlassName());
     ReplaceFuncTable(ITAB_CONFLICT_PREFIX_STR + klass->GetKlassName());
   }
-  ReplaceDataTable(NameMangler::kGcRootList);
+  ReplaceDataTable(namemangler::kGcRootList);
   GenerateCompilerVersionNum();
 }
 }  // namespace maple
diff --git a/src/mpl2mpl/src/native_stub_func.cpp b/src/mpl2mpl/src/native_stub_func.cpp
index 15465a5609d2380721727a403b3f8b8fe0c5ce6b..ca6d4265938d337f5d946b525bc8442ecdf8d6b2 100644
--- a/src/mpl2mpl/src/native_stub_func.cpp
+++ b/src/mpl2mpl/src/native_stub_func.cpp
@@ -29,7 +29,7 @@ namespace maple {
 NativeStubFuncGeneration::NativeStubFuncGeneration(MIRModule &mod, KlassHierarchy *kh, bool dump)
     : FuncOptimizeImpl(mod, kh, dump) {
   MIRType *jstrType = GlobalTables::GetTypeTable().GetOrCreateClassType(
-      NameMangler::GetInternalNameLiteral(NameMangler::kJavaLangStringStr), mod);
+      namemangler::GetInternalNameLiteral(namemangler::kJavaLangStringStr), mod);
   auto *jstrPointerType =
       static_cast<MIRPtrType*>(GlobalTables::GetTypeTable().GetOrCreatePointerType(*jstrType, PTY_ref));
   jstrPointerTypeIdx = jstrPointerType->GetTypeIndex();
@@ -44,7 +44,7 @@ MIRFunction &NativeStubFuncGeneration::GetOrCreateDefaultNativeFunc(MIRFunction
   if (Options::regNativeDynamicOnly && !(IsStaticBindingMethod(stubFunc.GetName()))) {
     return stubFunc;
   }
-  std::string nativeName = NameMangler::NativeJavaName(stubFunc.GetName().c_str());
+  std::string nativeName = namemangler::NativeJavaName(stubFunc.GetName().c_str());
   // No need to create a default function with exact arguments here
   MIRFunction *nativeFunc = builder->GetOrCreateFunction(nativeName, stubFunc.GetReturnTyIdx());
   ASSERT(nativeFunc != nullptr, "null ptr check!");
@@ -265,7 +265,7 @@ void NativeStubFuncGeneration::GenerateRegFuncTabEntryType() {
   MIRArrayType &arrayType =
       *GlobalTables::GetTypeTable().GetOrCreateArrayType(*GlobalTables::GetTypeTable().GetVoidPtr(), 0);
   regFuncTabConst = GetMIRModule().GetMemPool()->New<MIRAggConst>(GetMIRModule(), arrayType);
-  std::string regFuncTab = NameMangler::kRegJNIFuncTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+  std::string regFuncTab = namemangler::kRegJNIFuncTabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
   regFuncSymbol = builder->CreateSymbol(regFuncTabConst->GetType().GetTypeIndex(), regFuncTab, kStVar,
                                         kScGlobal, nullptr, kScopeGlobal);
 }
@@ -300,9 +300,9 @@ void NativeStubFuncGeneration::GenerateRegFuncTab() {
 
 void NativeStubFuncGeneration::GenerateRegTabEntry(const MIRFunction &func) {
   std::string tmp = func.GetName();
-  tmp = NameMangler::DecodeName(tmp);
+  tmp = namemangler::DecodeName(tmp);
   std::string base = func.GetBaseClassName();
-  base = NameMangler::DecodeName(base);
+  base = namemangler::DecodeName(base);
   if (tmp.length() > base.length() && tmp.find(base) != std::string::npos) {
     tmp.replace(tmp.find(base), base.length() + 1, "");
   }
@@ -394,14 +394,14 @@ void NativeStubFuncGeneration::GenerateRegisteredNativeFuncCall(MIRFunction &fun
       func.GetBody()->AddStatement(funcPtrAndOpAssign);
 #endif
       // Get find_native_func function
-      MIRFunction *findNativeFunc = builder->GetOrCreateFunction(NameMangler::kFindNativeFuncNoeh,
+      MIRFunction *findNativeFunc = builder->GetOrCreateFunction(namemangler::kFindNativeFuncNoeh,
                                                                  voidPointerType->GetTypeIndex());
       findNativeFunc->SetAttr(FUNCATTR_nosideeffect);
       // CallAssigned statement for unregistered situation
       CallNode *callGetFindNativeFunc = builder->CreateStmtCallRegassigned(findNativeFunc->GetPuidx(), dynamicStubOpnds,
                                                                            funcptrPreg, OP_callassigned);
       // Check return value of dynamic linking stub
-      MIRFunction *dummyNativeFunc = builder->GetOrCreateFunction(NameMangler::kDummyNativeFunc,
+      MIRFunction *dummyNativeFunc = builder->GetOrCreateFunction(namemangler::kDummyNativeFunc,
                                                                   voidPointerType->GetTypeIndex());
       dummyNativeFunc->SetAttr(FUNCATTR_nosideeffect);
       auto dummyFuncPreg = func.GetPregTab()->CreatePreg(PTY_ptr);
@@ -449,7 +449,7 @@ void NativeStubFuncGeneration::GenerateRegisteredNativeFuncCall(MIRFunction &fun
 #ifdef TARGAARCH64
       func.GetBody()->AddStatement(funcPtrAndOpAssign);
 #endif
-      MIRFunction *findNativeFunc = builder->GetOrCreateFunction(NameMangler::kFindNativeFunc,
+      MIRFunction *findNativeFunc = builder->GetOrCreateFunction(namemangler::kFindNativeFunc,
                                                                  voidPointerType->GetTypeIndex());
       findNativeFunc->SetAttr(FUNCATTR_nosideeffect);
       // CallAssigned statement for unregistered situation
@@ -480,7 +480,7 @@ void NativeStubFuncGeneration::GenerateRegisteredNativeFuncCall(MIRFunction &fun
   icall->SetNOpndAt(0, readFuncPtr);
   icall->SetRetTyIdx(nativeFunc.GetReturnTyIdx());
   // Check if funcptr is Invalid
-  MIRFunction *findNativeFunc = builder->GetOrCreateFunction(NameMangler::kFindNativeFunc,
+  MIRFunction *findNativeFunc = builder->GetOrCreateFunction(namemangler::kFindNativeFunc,
                                                              voidPointerType->GetTypeIndex());
   findNativeFunc->SetAttr(FUNCATTR_nosideeffect);
   // CallAssigned statement for unregistered situation
@@ -543,25 +543,25 @@ void NativeStubFuncGeneration::GenerateHelperFuncDecl() {
   MIRType *refType = GlobalTables::GetTypeTable().GetRef();
   // MRT_PendingException
   MRTCheckThrowPendingExceptionFunc =
-      builder->GetOrCreateFunction(NameMangler::kCheckThrowPendingExceptionFunc, voidType->GetTypeIndex());
+      builder->GetOrCreateFunction(namemangler::kCheckThrowPendingExceptionFunc, voidType->GetTypeIndex());
   CHECK_FATAL(MRTCheckThrowPendingExceptionFunc != nullptr, "MRTCheckThrowPendingExceptionFunc is null.");
   MRTCheckThrowPendingExceptionFunc->SetAttr(FUNCATTR_nosideeffect);
   MRTCheckThrowPendingExceptionFunc->SetBody(nullptr);
   // MRT_PreNativeCall
   ArgVector preArgs(GetMIRModule().GetMPAllocator().Adapter());
-  MRTPreNativeFunc = builder->CreateFunction(NameMangler::kPreNativeFunc, *voidPointerType, preArgs);
+  MRTPreNativeFunc = builder->CreateFunction(namemangler::kPreNativeFunc, *voidPointerType, preArgs);
   CHECK_FATAL(MRTPreNativeFunc != nullptr, "MRTPreNativeFunc is null.");
   MRTPreNativeFunc->SetBody(nullptr);
   // MRT_PostNativeCall
   ArgVector postArgs(GetMIRModule().GetMPAllocator().Adapter());
   postArgs.push_back(ArgPair("env", voidPointerType));
-  MRTPostNativeFunc = builder->CreateFunction(NameMangler::kPostNativeFunc, *voidType, postArgs);
+  MRTPostNativeFunc = builder->CreateFunction(namemangler::kPostNativeFunc, *voidType, postArgs);
   CHECK_FATAL(MRTPostNativeFunc != nullptr, "MRTPostNativeFunc is null.");
   MRTPostNativeFunc->SetBody(nullptr);
   // MRT_DecodeReference
   ArgVector decodeArgs(GetMIRModule().GetMPAllocator().Adapter());
   decodeArgs.push_back(ArgPair("obj", refType));
-  MRTDecodeRefFunc = builder->CreateFunction(NameMangler::kDecodeRefFunc, *refType, decodeArgs);
+  MRTDecodeRefFunc = builder->CreateFunction(namemangler::kDecodeRefFunc, *refType, decodeArgs);
   CHECK_FATAL(MRTDecodeRefFunc != nullptr, "MRTDecodeRefFunc is null.");
   MRTDecodeRefFunc->SetAttr(FUNCATTR_nosideeffect);
   MRTDecodeRefFunc->SetBody(nullptr);
@@ -576,12 +576,12 @@ void NativeStubFuncGeneration::GenerateHelperFuncDecl() {
   // MCC_CallSlowNativeExt
   ArgVector callExtArgs(GetMIRModule().GetMPAllocator().Adapter());
   callExtArgs.push_back(ArgPair("func", voidPointerType));
-  MRTCallSlowNativeExtFunc = builder->CreateFunction(NameMangler::kCallSlowNativeExt, *voidPointerType, callExtArgs);
+  MRTCallSlowNativeExtFunc = builder->CreateFunction(namemangler::kCallSlowNativeExt, *voidPointerType, callExtArgs);
   CHECK_FATAL(MRTCallSlowNativeExtFunc != nullptr, "MRTCallSlowNativeExtFunc is null.");
   MRTCallSlowNativeExtFunc->SetBody(nullptr);
   // MCC_SetReliableUnwindContext
   MCCSetReliableUnwindContextFunc =
-      builder->GetOrCreateFunction(NameMangler::kSetReliableUnwindContextFunc, voidType->GetTypeIndex());
+      builder->GetOrCreateFunction(namemangler::kSetReliableUnwindContextFunc, voidType->GetTypeIndex());
   CHECK_FATAL(MCCSetReliableUnwindContextFunc != nullptr, "MCCSetReliableUnwindContextFunc is null");
   MCCSetReliableUnwindContextFunc->SetAttr(FUNCATTR_nosideeffect);
   MCCSetReliableUnwindContextFunc->SetBody(nullptr);
@@ -590,7 +590,7 @@ void NativeStubFuncGeneration::GenerateHelperFuncDecl() {
 void NativeStubFuncGeneration::GenerateRegTable() {
   auto &arrayType = static_cast<MIRArrayType&>(regTableConst->GetType());
   arrayType.SetSizeArrayItem(0, regTableConst->GetConstVec().size());
-  std::string regJniTabName = NameMangler::kRegJNITabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
+  std::string regJniTabName = namemangler::kRegJNITabPrefixStr + GetMIRModule().GetFileNameAsPostfix();
   MIRSymbol *regJNISt = builder->CreateSymbol(regTableConst->GetType().GetTypeIndex(), regJniTabName, kStVar,
                                               kScGlobal, nullptr, kScopeGlobal);
   regJNISt->SetKonst(regTableConst);
@@ -615,7 +615,7 @@ bool NativeStubFuncGeneration::IsStaticBindingMethod(const std::string &methodNa
   if (!IsStaticBindingListMode()) {
     return false;
   }
-  return (staticBindingMethodsSet.find(NameMangler::NativeJavaName(methodName.c_str())) !=
+  return (staticBindingMethodsSet.find(namemangler::NativeJavaName(methodName.c_str())) !=
           staticBindingMethodsSet.end());
 }
 
diff --git a/src/mpl2mpl/src/reflection_analysis.cpp b/src/mpl2mpl/src/reflection_analysis.cpp
index cd12ade232d1cd01f6e91074a557090678b2c079..cf50eb7bb730bd2aeddcd28b9489eb1407c6d187 100755
--- a/src/mpl2mpl/src/reflection_analysis.cpp
+++ b/src/mpl2mpl/src/reflection_analysis.cpp
@@ -268,7 +268,7 @@ BaseNode *ReflectionAnalysis::GenClassInfoAddr(BaseNode *obj, MIRBuilder &builde
   return classinfoAddress;
 }
 
-const char *ReflectionAnalysis::klassPtrName = NameMangler::kShadowClassName;
+const char *ReflectionAnalysis::klassPtrName = namemangler::kShadowClassName;
 TyIdx ReflectionAnalysis::classMetadataTyIdx = TyIdx(0);
 TyIdx ReflectionAnalysis::classMetadataRoTyIdx = TyIdx(0);
 TyIdx ReflectionAnalysis::methodsInfoTyIdx = TyIdx(0);
@@ -357,7 +357,7 @@ bool ReflectionAnalysis::IsPrivateClass(const MIRClassType &classType) const {
 }
 
 static inline GStrIdx GetOrCreateGStrIdxFromName(const std::string &name) {
-  return GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(NameMangler::GetInternalNameLiteral(name));
+  return GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::GetInternalNameLiteral(name));
 }
 
 static bool IsFinalize(const std::string &funcName, const std::string &signature) {
@@ -426,14 +426,14 @@ uint32 ReflectionAnalysis::GetTypeNameIdxFromType(const MIRType &type, const Kla
         CHECK_NULL_FATAL(ptype);
         const std::string &javaName = static_cast<MIRJarrayType*>(ptype)->GetJavaName();
         std::string klassJavaDescriptor;
-        NameMangler::DecodeMapleNameToJavaDescriptor(javaName, klassJavaDescriptor);
+        namemangler::DecodeMapleNameToJavaDescriptor(javaName, klassJavaDescriptor);
         typeNameIdx = FindOrInsertReflectString(klassJavaDescriptor);
       } else if (ptype->GetKind() == kTypeByName || ptype->GetKind() == kTypeClass ||
                  ptype->GetKind() == kTypeInterface || ptype->GetKind() == kTypeClassIncomplete ||
                  ptype->GetKind() == kTypeInterfaceIncomplete || ptype->GetKind() == kTypeConstString) {
         std::string javaName = ptype->GetName();
         std::string klassJavaDescriptor;
-        NameMangler::DecodeMapleNameToJavaDescriptor(javaName, klassJavaDescriptor);
+        namemangler::DecodeMapleNameToJavaDescriptor(javaName, klassJavaDescriptor);
         typeNameIdx = FindOrInsertReflectString(klassJavaDescriptor);
       } else {
         CHECK_FATAL(false, "In class %s: field %s 's type is UNKNOWN", klass.GetKlassName().c_str(),
@@ -501,10 +501,10 @@ void ReflectionAnalysis::GenAllMethodHash(std::vector<std::pair<MethodPair*, int
     MIRSymbol *funcSym = GlobalTables::GetGsymTable().GetSymbolFromStidx(methodInfo.first->first.Idx());
     MIRFunction *func = funcSym->GetFunction();
     std::string baseName = func->GetBaseFuncName();
-    baseName = NameMangler::DecodeName(baseName);
+    baseName = namemangler::DecodeName(baseName);
     baseNameMap[func->GetBaseFuncNameStrIdx()] = baseName;
     std::string fullName = func->GetBaseFuncNameWithType();
-    fullName = NameMangler::DecodeName(fullName);
+    fullName = namemangler::DecodeName(fullName);
     fullNameMap[func->GetBaseFuncNameWithTypeStrIdx()] = fullName;
     CHECK_FATAL(fullName.find("|") != std::string::npos, "can not find |");
     std::string signature = fullName.substr(fullName.find("|") + 1);
@@ -540,7 +540,7 @@ uint16 GetFieldHash(const std::vector<std::pair<FieldPair, uint16>> &fieldV, con
 MIRSymbol *ReflectionAnalysis::GetOrCreateSymbol(const std::string &name, TyIdx tyIdx, bool needInit = false) {
   const GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
   MIRSymbol *st;
-  std::string symbolOfJavaLangString(NameMangler::kJavaLangStringStr);
+  std::string symbolOfJavaLangString(namemangler::kJavaLangStringStr);
   if (name == CLASSINFO_PREFIX_STR + symbolOfJavaLangString) {
     // Previous String Symbol have been generated in dex2mpl, so this Symbol won't create again here
     st = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx);
@@ -831,7 +831,7 @@ MIRSymbol *ReflectionAnalysis::GenMethodsMeta(const Klass &klass,
     GenMethodMeta(klass, methodsInfoType, *funcSym, *aggConst, idx++, baseNameMp, fullNameMp);
   }
   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;
@@ -850,7 +850,7 @@ MIRSymbol *ReflectionAnalysis::GenMethodAddrData(const MIRSymbol &funcSym) {
   if (!func->IsAbstract()) {
     mirBuilder.AddAddroffuncFieldConst(methodAddrType, *newconst, 1, funcSym);
     aggconst->GetConstVec().push_back(newconst);
-    methodAddrSt = GetOrCreateSymbol(NameMangler::kMethodAddrDataPrefixStr + func->GetName(),
+    methodAddrSt = GetOrCreateSymbol(namemangler::kMethodAddrDataPrefixStr + func->GetName(),
                                      methodAddrArrayType.GetTypeIndex(), true);
     methodAddrSt->SetStorageClass(kScFstatic);
     methodAddrSt->SetKonst(aggconst);
@@ -924,7 +924,7 @@ MIRSymbol *ReflectionAnalysis::GenFieldOffsetData(const Klass &klass, std::pair<
 
   FieldPair fieldP = fieldInfo.first;
   std::string originFieldname = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldP.first);
-  std::string fieldOffsetSymbolName = NameMangler::kFieldOffsetDataPrefixStr;
+  std::string fieldOffsetSymbolName = namemangler::kFieldOffsetDataPrefixStr;
   bool isStaticField = (fieldInfo.second == -1);
   if (isStaticField) {
     fieldOffsetSymbolName += originFieldname;
@@ -976,7 +976,7 @@ static void ConvertFieldName(std::string &fieldname, bool staticfield) {
   if (staticfield) {
     // Remove class name prefix.
     std::string decodeFieldName;
-    NameMangler::DecodeMapleNameToJavaDescriptor(fieldname, decodeFieldName);
+    namemangler::DecodeMapleNameToJavaDescriptor(fieldname, decodeFieldName);
     std::stringstream ss(decodeFieldName);
     std::string item;
     std::vector<std::string> res;
@@ -986,7 +986,7 @@ static void ConvertFieldName(std::string &fieldname, bool staticfield) {
     CHECK_FATAL(res.size() > 1, "fieldname not found");
     fieldname = res[StaticFieldName::kFieldName];
   } else {
-    fieldname = NameMangler::DecodeName(fieldname);
+    fieldname = namemangler::DecodeName(fieldname);
   }
 }
 
@@ -1072,7 +1072,7 @@ MIRSymbol *ReflectionAnalysis::GenFieldsMeta(const Klass &klass, std::vector<std
     GenFieldMeta(klass, fieldsInfoType, fieldInfo, *aggConst, idx++, fieldHashVec);
   }
   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;
@@ -1130,7 +1130,7 @@ void ReflectionAnalysis::ConvertMapleClassName(const std::string &mplClassName,
   // Convert classname end with _3B, 3 is strlen("_3B")
   unsigned int len = strlen(kClassSuffix);
   if (mplClassName.size() > len && mplClassName.rfind(kClassSuffix, mplClassName.size() - len) != std::string::npos) {
-    NameMangler::DecodeMapleNameToJavaDescriptor(mplClassName, javaDsp);
+    namemangler::DecodeMapleNameToJavaDescriptor(mplClassName, javaDsp);
   } else {
     javaDsp = mplClassName;
   }
@@ -1282,7 +1282,7 @@ void ReflectionAnalysis::GenAnnotation(std::map<int, int> &idxNumMap, std::strin
                                        std::map<int, int> *paramnumArray, int *paramIndex) {
   int annoNum = 0;
   for (MIRPragma *prag : classType.GetPragmaVec()) {
-    std::string cmpString = (paragKind == kPragmaVar) ? NameMangler::DecodeName(
+    std::string cmpString = (paragKind == kPragmaVar) ? namemangler::DecodeName(
         GlobalTables::GetStrTable().GetStringFromStrIdx(prag->GetStrIdx())) :
         GlobalTables::GetStrTable().GetStringFromStrIdx(prag->GetStrIdx());
     bool validTypeFlag = false;
@@ -1318,7 +1318,7 @@ void ReflectionAnalysis::GenAnnotation(std::map<int, int> &idxNumMap, std::strin
       for (MIRPragmaElement *elem : elemVector) {
         idxNumMap[annoNum - 1]++;
         std::string convertTmp =
-            NameMangler::DecodeName(GlobalTables::GetStrTable().GetStringFromStrIdx(elem->GetNameStrIdx()));
+            namemangler::DecodeName(GlobalTables::GetStrTable().GetStringFromStrIdx(elem->GetNameStrIdx()));
         idx = ReflectionAnalysis::FindOrInsertReflectString(convertTmp);
         annoArr += (annoDelimiterPrefix + std::to_string(idx) + annoDelimiter +
             std::to_string(elem->GetType()) + annoDelimiter);
@@ -1378,7 +1378,7 @@ void ReflectionAnalysis::GenHotClassNameString(const Klass &klass) {
   }
   std::string klassName = klass.GetKlassName();
   std::string klassJavaDescriptor;
-  NameMangler::DecodeMapleNameToJavaDescriptor(klassName, klassJavaDescriptor);
+  namemangler::DecodeMapleNameToJavaDescriptor(klassName, klassJavaDescriptor);
   (void)ReflectionAnalysis::FindOrInsertRepeatString(klassJavaDescriptor, true);  // Always used.
 }
 
@@ -1418,7 +1418,7 @@ void ReflectionAnalysis::GenClassMetaData(Klass &klass) {
   std::string klassName = klass.GetKlassName();
   reflectionMuidStr += klassName;
   std::string klassJavaDescriptor;
-  NameMangler::DecodeMapleNameToJavaDescriptor(klassName, klassJavaDescriptor);
+  namemangler::DecodeMapleNameToJavaDescriptor(klassName, klassJavaDescriptor);
   uint32 hashIndex = GetHashIndex(klassJavaDescriptor);
   if (kRADebug) {
     LogInfo::MapleLogger(kLlErr) << "========= Gen Class: " << klassJavaDescriptor
@@ -1434,9 +1434,9 @@ void ReflectionAnalysis::GenClassMetaData(Klass &klass) {
   // @iFields: All instance fields.
   uint32 numOfFields = 0;
   bool hasAdded = false;
-  if (klass.GetKlassName() == NameMangler::GetInternalNameLiteral(NameMangler::kJavaLangObjectStr)) {
+  if (klass.GetKlassName() == namemangler::GetInternalNameLiteral(namemangler::kJavaLangObjectStr)) {
     const GStrIdx stridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(
-        NameMangler::kFieldsInfoPrefixStr + NameMangler::GetInternalNameLiteral(NameMangler::kJavaLangObjectStr));
+        namemangler::kFieldsInfoPrefixStr + namemangler::GetInternalNameLiteral(namemangler::kJavaLangObjectStr));
     MIRSymbol *fieldsSt = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(stridx);
     if (fieldsSt != nullptr) {
       mirBuilder.AddAddrofFieldConst(classMetadataROType, *newConst, fieldID++, *fieldsSt);
@@ -1576,7 +1576,7 @@ void ReflectionAnalysis::GenClassMetaData(Klass &klass) {
   // @gctib
   MIRSymbol *gctibSt = GetOrCreateSymbol(GCTIB_PREFIX_STR + klass.GetKlassName(),
                                          GlobalTables::GetTypeTable().GetVoidPtr()->GetTypeIndex(), false);
-  if (klass.GetKlassName() != NameMangler::GetInternalNameLiteral(NameMangler::kJavaLangObjectStr)) {
+  if (klass.GetKlassName() != namemangler::GetInternalNameLiteral(namemangler::kJavaLangObjectStr)) {
     // Direct access to gctib is only possible within a .so, for most classes.
     gctibSt->SetStorageClass(kScFstatic);
   }
@@ -1687,7 +1687,7 @@ void ReflectionAnalysis::GenMetadataType(MIRModule &mirModule) {
   GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kClassinforoStr, *typeVoidPtr);
 #endif  // USE_32BIT_REF
   GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataType, kClinitbridgeStr, *typeVoidPtr);
-  classMetadataTyIdx = GenMetaStructType(mirModule, classMetadataType, NameMangler::kClassMetadataTypeName);
+  classMetadataTyIdx = GenMetaStructType(mirModule, classMetadataType, namemangler::kClassMetadataTypeName);
   MIRStructType classMetadataROType(kTypeStruct);
   GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataROType, kClassNameStr, *typeVoidPtr);
   GlobalTables::GetTypeTable().AddFieldToStructType(classMetadataROType, kIfieldsStr, *typeVoidPtr);
@@ -1787,7 +1787,7 @@ void ReflectionAnalysis::GenClassHashMetaData() {
   if (classTab.empty()) {
     return;
   }
-  std::string bucketName = NameMangler::kMuidClassMetadataBucketPrefixStr + module.GetFileNameAsPostfix();
+  std::string bucketName = namemangler::kMuidClassMetadataBucketPrefixStr + module.GetFileNameAsPostfix();
   size_t bucketArraySize = classTab.size();
   MIRArrayType &bucketArraytype = *GlobalTables::GetTypeTable().GetOrCreateArrayType(*type, bucketArraySize);
   MIRSymbol *bucketSt = GetOrCreateSymbol(bucketName, bucketArraytype.GetTypeIndex(), true);
@@ -1830,14 +1830,14 @@ static void ReflectionAnalysisGenStrTab(MIRModule &mirModule, const std::string
 
 void ReflectionAnalysis::GenStrTab(MIRModule &mirModule) {
   // Hot string tab.
-  std::string hotStrtabName = NameMangler::kReflectionStartHotStrtabPrefixStr + mirModule.GetFileNameAsPostfix();
+  std::string hotStrtabName = namemangler::kReflectionStartHotStrtabPrefixStr + mirModule.GetFileNameAsPostfix();
   ReflectionAnalysisGenStrTab(mirModule, strTabStartHot, hotStrtabName);
-  hotStrtabName = NameMangler::kReflectionBothHotStrTabPrefixStr + mirModule.GetFileNameAsPostfix();
+  hotStrtabName = namemangler::kReflectionBothHotStrTabPrefixStr + mirModule.GetFileNameAsPostfix();
   ReflectionAnalysisGenStrTab(mirModule, strTabBothHot, hotStrtabName);
-  hotStrtabName = NameMangler::kReflectionRunHotStrtabPrefixStr + mirModule.GetFileNameAsPostfix();
+  hotStrtabName = namemangler::kReflectionRunHotStrtabPrefixStr + mirModule.GetFileNameAsPostfix();
   ReflectionAnalysisGenStrTab(mirModule, strTabRunHot, hotStrtabName);
   // Cold string tab.
-  std::string strTabName = NameMangler::kReflectionStrtabPrefixStr + mirModule.GetFileNameAsPostfix();
+  std::string strTabName = namemangler::kReflectionStrtabPrefixStr + mirModule.GetFileNameAsPostfix();
   ReflectionAnalysisGenStrTab(mirModule, strTab, strTabName);
 }
 
@@ -1846,9 +1846,9 @@ void ReflectionAnalysis::MarkWeakMethods() {
     return;
   }
 
-  GStrIdx classNames[] = { GetOrCreateGStrIdxFromName(NameMangler::kJavaLangClassStr),
-                           GetOrCreateGStrIdxFromName(NameMangler::kJavaLangObjectStr),
-                           GetOrCreateGStrIdxFromName(NameMangler::kReflectionClassMethodStr),
+  GStrIdx classNames[] = { GetOrCreateGStrIdxFromName(namemangler::kJavaLangClassStr),
+                           GetOrCreateGStrIdxFromName(namemangler::kJavaLangObjectStr),
+                           GetOrCreateGStrIdxFromName(namemangler::kReflectionClassMethodStr),
                            GetOrCreateGStrIdxFromName(kReflectionReferencePrefixStr) };
   for (GStrIdx nameIdx : classNames) {
     Klass *klass = klassH->GetKlassFromStrIdx(nameIdx);
@@ -1889,12 +1889,6 @@ void ReflectionAnalysis::Run() {
   reflectionMuidStr.clear();
   reflectionMuidStr.shrink_to_fit();
   GenClassHashMetaData();
-  for (Klass *klass : klasses) {
-    MIRStructType *mirStruct = klass->GetMIRStructType();
-    mirStruct->GetPragmaVec().clear();
-    mirStruct->GetPragmaVec().shrink_to_fit();
-  }
-  memPoolCtrler.DeleteMemPool(mirModule->GetPragmaMemPool());
 }
 
 AnalysisResult *DoReflectionAnalysis::Run(MIRModule *module, ModuleResultMgr *moduleResultMgr) {
diff --git a/src/mpl2mpl/src/vtable_analysis.cpp b/src/mpl2mpl/src/vtable_analysis.cpp
index 90e51aa158542d036ae89e60e3a992b09e20f0d6..11ab1e13e46cc8fe45188b4765e66ec94c24fe0a 100644
--- a/src/mpl2mpl/src/vtable_analysis.cpp
+++ b/src/mpl2mpl/src/vtable_analysis.cpp
@@ -64,10 +64,10 @@ bool VtableAnalysis::CheckInterfaceSpecification(const Klass &baseKlass, const K
 bool VtableAnalysis::CheckOverrideForCrossPackage(const MIRFunction &baseMethod,
     const MIRFunction &currMethod) const {
   const std::string &baseClassName = baseMethod.GetBaseClassName();
-  size_t basePos = baseClassName.rfind(NameMangler::kPackageNameSplitterStr);
+  size_t basePos = baseClassName.rfind(namemangler::kPackageNameSplitterStr);
   std::string basePackageName = (basePos != std::string::npos) ? baseClassName.substr(0, basePos) : "";
   const std::string &currClassName = currMethod.GetBaseClassName();
-  size_t currPos = currClassName.rfind(NameMangler::kPackageNameSplitterStr);
+  size_t currPos = currClassName.rfind(namemangler::kPackageNameSplitterStr);
   std::string currPackageName = (currPos != std::string::npos) ? currClassName.substr(0, currPos) : "";
   // 1. For the cross package inheritance, only if the base func is declared
   // as either 'public' or 'protected', we shall set override relationship.
@@ -199,8 +199,8 @@ void VtableAnalysis::GenVtableDefinition(const Klass &klass) {
 }
 
 std::string VtableAnalysis::DecodeBaseNameWithType(const MIRFunction &func) {
-  const std::string &baseName = NameMangler::DecodeName(func.GetBaseFuncName());
-  std::string signatureName = NameMangler::DecodeName(func.GetSignature());
+  const std::string &baseName = namemangler::DecodeName(func.GetBaseFuncName());
+  std::string signatureName = namemangler::DecodeName(func.GetSignature());
   ReflectionAnalysis::ConvertMethodSig(signatureName);
   std::string baseNameWithType = baseName + "|" + signatureName;
   return baseNameWithType;
@@ -344,7 +344,7 @@ void VtableAnalysis::GenTableSymbol(const std::string &prefix, const std::string
   size_t arraySize = newConst.GetConstVec().size();
   MIRArrayType *arrayType = GlobalTables::GetTypeTable().GetOrCreateArrayType(*voidPtrType, arraySize);
   MIRSymbol *vtabSt = builder->CreateGlobalDecl(prefix + klassName, *arrayType);
-  if (klassName == NameMangler::GetInternalNameLiteral(NameMangler::kJavaLangObjectStr)) {
+  if (klassName == namemangler::GetInternalNameLiteral(namemangler::kJavaLangObjectStr)) {
     vtabSt->SetStorageClass(kScGlobal);
   } else {
     vtabSt->SetStorageClass(kScFstatic);
diff --git a/src/mplfe/common/src/fe_input_helper.cpp b/src/mplfe/common/src/fe_input_helper.cpp
index 8bf5fcbd7d8e354df108d0985876ad6334467883..e39878d45a99e9746007452425900321a9139f1c 100644
--- a/src/mplfe/common/src/fe_input_helper.cpp
+++ b/src/mplfe/common/src/fe_input_helper.cpp
@@ -104,7 +104,7 @@ void FEInputStructHelper::ProcessDeclSuperClassForJava() {
   ASSERT(superNames.size() <= 1, "there must be zero or one super class for java class: %s",
          GetStructNameOrin().c_str());
   if (superNames.size() == 1) {
-    std::string superNameMpl = NameMangler::EncodeName(superNames[0]);
+    std::string superNameMpl = namemangler::EncodeName(superNames[0]);
     bool isCreate = false;
     MIRStructType *superType = FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType(superNameMpl, false,
                                                                                            FETypeFlag::kSrcExtern,
@@ -137,7 +137,7 @@ void FEInputStructHelper::ProcessDeclImplements() {
   std::vector<std::string> interfaceNames = GetInterfaceNames();
   std::vector<MIRStructType*> interfaceTypes;
   for (const std::string &name : interfaceNames) {
-    std::string interfaceNameMpl = NameMangler::EncodeName(name);
+    std::string interfaceNameMpl = namemangler::EncodeName(name);
     bool isCreate = false;
     MIRStructType *interfaceType = FEManager::GetTypeManager().GetOrCreateClassOrInterfaceType(interfaceNameMpl, true,
                                                                                                FETypeFlag::kSrcExtern,
@@ -210,7 +210,7 @@ void FEInputStructHelper::ProcessDeclDefInfoSuperNameForJava() {
     return;
   }
   std::string superName = superNames.size() == 0 ? "unknown" : superNames[0];
-  std::string superNameMpl = NameMangler::EncodeName(superName);
+  std::string superNameMpl = namemangler::EncodeName(superName);
   GStrIdx superNameMplIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(superNameMpl.c_str());
   SET_CLASS_INFO_PAIR(mirStructType, "INFO_superclassname", superNameMplIdx.GetIdx(), true);
 }
@@ -223,7 +223,7 @@ void FEInputStructHelper::ProcessDeclDefInfoImplementNameForJava() {
   std::vector<std::string> implementNames = GetInterfaceNames();
   for (const std::string &name : implementNames) {
     if (!name.empty()) {
-      std::string nameMpl = NameMangler::EncodeName(name);
+      std::string nameMpl = namemangler::EncodeName(name);
       GStrIdx nameMplIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(nameMpl.c_str());
       SET_CLASS_INFO_PAIR(mirStructType, "INFO_implements", nameMplIdx.GetIdx(), true);
     }
diff --git a/src/mplfe/common/src/fe_java_string_manager.cpp b/src/mplfe/common/src/fe_java_string_manager.cpp
index 4ecf6d229acc47ce016531158c02c0b8b88e815a..d3d61a493e6034f52cc4c756994be9dcea5b8d92 100644
--- a/src/mplfe/common/src/fe_java_string_manager.cpp
+++ b/src/mplfe/common/src/fe_java_string_manager.cpp
@@ -65,7 +65,7 @@ MIRSymbol *FEJavaStringManager::GetLiteralPtrVar(const std::u16string &strU16) c
 
 MIRSymbol *FEJavaStringManager::CreateLiteralVar(MIRBuilder &mirBuilder, const std::string &str, bool isFieldValue) {
   std::u16string strU16;
-  (void)NameMangler::UTF8ToUTF16(strU16, str);
+  (void)namemangler::UTF8ToUTF16(strU16, str);
   return CreateLiteralVar(mirBuilder, strU16, isFieldValue);
 }
 
@@ -98,7 +98,7 @@ MIRSymbol *FEJavaStringManager::CreateLiteralVar(MIRBuilder &mirBuilder, const s
     (void)fieldValueSet.insert(literalVar);
   }
   if (isFieldValue || isHotLiteral) {
-    std::string literalGlobalPtrName = NameMangler::kPtrPrefixStr + literalGlobalName;
+    std::string literalGlobalPtrName = namemangler::kPtrPrefixStr + literalGlobalName;
     MIRSymbol *literalVarPtr = mirBuilder.GetOrCreateGlobalDecl(literalGlobalPtrName.c_str(), *typeString);
     literalVarPtr->SetStorageClass(literalVar->GetStorageClass());
     AddrofNode *expr = mirBuilder.CreateExprAddrof(0, *literalVar, module.GetMemPool());
@@ -113,7 +113,7 @@ MIRSymbol *FEJavaStringManager::CreateLiteralVar(MIRBuilder &mirBuilder, const s
 
 MIRSymbol *FEJavaStringManager::GetLiteralVar(const std::string &str) const {
   std::u16string strU16;
-  (void)NameMangler::UTF8ToUTF16(strU16, str);
+  (void)namemangler::UTF8ToUTF16(strU16, str);
   return GetLiteralVar(strU16);
 }
 
diff --git a/src/mplfe/common/src/fe_struct_elem_info.cpp b/src/mplfe/common/src/fe_struct_elem_info.cpp
index f52bd6ddd38622890d400622f3f34b2c571163bd..006b21ed53ab900e0865f633194a21a814951465 100644
--- a/src/mplfe/common/src/fe_struct_elem_info.cpp
+++ b/src/mplfe/common/src/fe_struct_elem_info.cpp
@@ -50,16 +50,16 @@ void FEStructElemInfo::Init() {
 
 void FEStructElemInfo::InitJava() {
   std::string fullNameMpl = GlobalTables::GetStrTable().GetStringFromStrIdx(fullNameIdx);
-  std::string fullNameJava = NameMangler::DecodeName(fullNameMpl);
+  std::string fullNameJava = namemangler::DecodeName(fullNameMpl);
   std::vector<std::string> names = FEUtils::Split(fullNameJava, '|');
   // 3 parts: ClassName|ElemName|Signature
   CHECK_FATAL(names.size() == 3, "invalid elem name %s", fullNameJava.c_str());
   // names[0]: structName
-  structNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(NameMangler::EncodeName(names[0]));
+  structNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(names[0]));
   // names[1]: elemName
-  elemNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(NameMangler::EncodeName(names[1]));
+  elemNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(names[1]));
   // names[2]: signature
-  signatureNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(NameMangler::EncodeName(names[2]));
+  signatureNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(names[2]));
 }
 
 // ---------- FEStructFieldInfo ----------
@@ -78,7 +78,7 @@ void FEStructFieldInfo::PrepareImpl(MIRBuilder &mirBuilder, bool argIsStatic) {
   }
   // Prepare
   const std::string &structName = GetStructName();
-  std::string rawName = structName + NameMangler::kNameSplitterStr + GetElemName();
+  std::string rawName = structName + namemangler::kNameSplitterStr + GetElemName();
   fieldNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(rawName);
   fieldID = static_cast<FieldID>(UINT32_MAX);
   MIRStructType *structType = FEManager::GetTypeManager().GetStructTypeFromName(structName);
@@ -91,7 +91,7 @@ void FEStructFieldInfo::PrepareImpl(MIRBuilder &mirBuilder, bool argIsStatic) {
   if (isDefined) {
     return;
   }
-  rawName = rawName + NameMangler::kNameSplitterStr + GetSignatureName();
+  rawName = rawName + namemangler::kNameSplitterStr + GetSignatureName();
   WARN(kLncErr, "use undefined %s field %s", argIsStatic ? "static" : "", rawName.c_str());
   isPrepared = true;
   isStatic = argIsStatic;
@@ -117,7 +117,7 @@ void FEStructFieldInfo::LoadFieldTypeJava() {
 void FEStructFieldInfo::PrepareStaticField(const MIRStructType &structType) {
   std::string ownerStructName = structType.GetName();
   const std::string &fieldName = GetElemName();
-  std::string fullName = ownerStructName + NameMangler::kNameSplitterStr + fieldName;
+  std::string fullName = ownerStructName + namemangler::kNameSplitterStr + fieldName;
   fieldNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fullName);
   isPrepared = true;
   isStatic = true;
@@ -143,7 +143,7 @@ bool FEStructFieldInfo::SearchStructFieldJava(MIRStructType &structType, MIRBuil
   GStrIdx nameIdx = elemNameIdx;
   if (argIsStatic) {
     // suppose anti-proguard is off
-    std::string fullName = structType.GetCompactMplTypeName() + NameMangler::kNameSplitterStr + GetElemName();
+    std::string fullName = structType.GetCompactMplTypeName() + namemangler::kNameSplitterStr + GetElemName();
     nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fullName);
   }
   const FieldVector &fields = argIsStatic ? structType.GetStaticFields() : structType.GetFields();
@@ -236,7 +236,7 @@ void FEStructMethodInfo::InitJavaPolymorphicWhiteList() {
   std::map<GStrIdx, std::set<GStrIdx>> &ans = javaPolymorphicWhiteList;
   StringTable<std::string, GStrIdx> &strTable = GlobalTables::GetStrTable();
   GStrIdx idxMethodHandle =
-      strTable.GetOrCreateStrIdxFromName(NameMangler::EncodeName("Ljava/lang/invoke/MethodHandle;"));
+      strTable.GetOrCreateStrIdxFromName(namemangler::EncodeName("Ljava/lang/invoke/MethodHandle;"));
   bool success = true;
   success = success && ans[idxMethodHandle].insert(strTable.GetOrCreateStrIdxFromName("invoke")).second;
   success = success && ans[idxMethodHandle].insert(strTable.GetOrCreateStrIdxFromName("invokeBasic")).second;
@@ -302,7 +302,7 @@ void FEStructMethodInfo::LoadMethodType() {
 
 void FEStructMethodInfo::LoadMethodTypeJava() {
   std::string signatureJava =
-      NameMangler::DecodeName(GlobalTables::GetStrTable().GetStringFromStrIdx(fullNameIdx));
+      namemangler::DecodeName(GlobalTables::GetStrTable().GetStringFromStrIdx(fullNameIdx));
   std::vector<std::string> typeNames = jbc::JBCUtil::SolveMethodSignature(signatureJava);
   CHECK_FATAL(typeNames.size() > 0, "invalid method signature: %s", signatureJava.c_str());
   // constructor check
@@ -347,8 +347,8 @@ bool FEStructMethodInfo::SearchStructMethodJava(MIRStructType &structType, MIRBu
   if (structType.IsIncomplete()) {
     return false;
   }
-  std::string fullName = structType.GetCompactMplTypeName() + NameMangler::kNameSplitterStr + GetElemName() +
-                         NameMangler::kNameSplitterStr + GetSignatureName();
+  std::string fullName = structType.GetCompactMplTypeName() + namemangler::kNameSplitterStr + GetElemName() +
+                         namemangler::kNameSplitterStr + GetSignatureName();
   GStrIdx nameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fullName);
   // PolymorphicCall Check
   if (CheckJavaPolymorphicCall()) {
diff --git a/src/mplfe/common/src/fe_utils_java.cpp b/src/mplfe/common/src/fe_utils_java.cpp
index c01223e06fe1b18318c13d09d103406fbc80f232..aaba70da2806af72a509de5b1f851b7bda2b807f 100644
--- a/src/mplfe/common/src/fe_utils_java.cpp
+++ b/src/mplfe/common/src/fe_utils_java.cpp
@@ -18,7 +18,7 @@
 namespace maple {
 std::vector<std::string> FEUtilJava::SolveMethodSignature(std::string signature, bool inMpl) {
   if (inMpl) {
-    signature = NameMangler::DecodeName(signature);
+    signature = namemangler::DecodeName(signature);
   }
   std::vector<std::string> ans;
   size_t pos1 = signature.find('(');
@@ -28,10 +28,10 @@ std::vector<std::string> FEUtilJava::SolveMethodSignature(std::string signature,
   }
   std::string paramTypeNames = signature.substr(pos1 + 1, pos2 - pos1 - 1);
   std::string retTypeName = signature.substr(pos2 + 1);
-  ans.push_back(inMpl ? NameMangler::EncodeName(retTypeName) : retTypeName);
+  ans.push_back(inMpl ? namemangler::EncodeName(retTypeName) : retTypeName);
   while (paramTypeNames.length() > 0) {
     std::string typeName = SolveParamNameInJavaFormat(paramTypeNames);
-    ans.push_back(inMpl ? NameMangler::EncodeName(typeName) : typeName);
+    ans.push_back(inMpl ? namemangler::EncodeName(typeName) : typeName);
     paramTypeNames = paramTypeNames.substr(typeName.length());
   }
   return ans;
diff --git a/src/mplfe/common/src/feir_stmt.cpp b/src/mplfe/common/src/feir_stmt.cpp
index 419c955a54b035b8b78cb9e572ce9446aea47f8f..1750c4912ca8a7187fba408da8de05a510bd5d98 100644
--- a/src/mplfe/common/src/feir_stmt.cpp
+++ b/src/mplfe/common/src/feir_stmt.cpp
@@ -320,7 +320,7 @@ FEStructMethodInfo &FEIRStmtJavaMultiANewArray::GetMethodInfoNewInstance() {
   }
   std::string methodNameJava = "Ljava/lang/reflect/Array;|newInstance|(Ljava/lang/Class;[I)Ljava/lang/Object;";
   GStrIdx methodNameIdx =
-      GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(NameMangler::EncodeName(methodNameJava));
+      GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(methodNameJava));
   methodInfoNewInstance = static_cast<FEStructMethodInfo*>(
       FEManager::GetTypeManager().RegisterStructMethodInfo(methodNameIdx, kSrcLangJava, true));
   return *methodInfoNewInstance;
diff --git a/src/mplfe/common/src/feir_type.cpp b/src/mplfe/common/src/feir_type.cpp
index d8ace12ecafad72a54dd61191e993c5d2f77a714..c4c3c6e1f40069ad6c198858ca5a26ca14fce963 100644
--- a/src/mplfe/common/src/feir_type.cpp
+++ b/src/mplfe/common/src/feir_type.cpp
@@ -205,7 +205,7 @@ void FEIRTypeDefault::LoadFromJavaTypeName(const std::string &typeName, bool inM
     }
   } else if (baseName[0] == 'L') {
     primType = PTY_ref;
-    baseName = inMpl ? baseName : NameMangler::EncodeName(baseName);
+    baseName = inMpl ? baseName : namemangler::EncodeName(baseName);
     typeNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(baseName);
   }
 }
diff --git a/src/mplfe/common/src/feir_type_helper.cpp b/src/mplfe/common/src/feir_type_helper.cpp
index 2cf06bfffc87bfc8f95ee3cd64fd27afe6274ec7..35b7b962212c51dc451481d69f2db8561447a8a2 100644
--- a/src/mplfe/common/src/feir_type_helper.cpp
+++ b/src/mplfe/common/src/feir_type_helper.cpp
@@ -35,7 +35,7 @@ UniqueFEIRType FEIRTypeHelper::CreateTypeByJavaName(const std::string typeName,
     newType = CreateTypeByJavaNamePrim(baseName[0], dim8);
     CHECK_FATAL(newType != nullptr, "unsupported java type name %s: ", typeName.c_str());
   } else if (baseName[0] == 'L') {
-    baseName = inMpl ? baseName : NameMangler::EncodeName(baseName);
+    baseName = inMpl ? baseName : namemangler::EncodeName(baseName);
     GStrIdx typeNameIdx = GlobalTables::GetStrTable().GetStrIdxFromName(baseName);
     if (typeNameIdx == 0) {
       newType = std::make_unique<FEIRTypeByName>(PTY_ref, baseName, dim8);
diff --git a/src/mplfe/jbc_input/src/jbc_attr_item.cpp b/src/mplfe/jbc_input/src/jbc_attr_item.cpp
index 6dc7f63485bc36771a9bf53678887a7247d296ae..26d401a3cb9f60d90ada848d1218272065fd96b6 100644
--- a/src/mplfe/jbc_input/src/jbc_attr_item.cpp
+++ b/src/mplfe/jbc_input/src/jbc_attr_item.cpp
@@ -23,7 +23,7 @@ inline GStrIdx GetOrCreateGStrIdx(const std::string &str) {
 }
 
 inline GStrIdx GetOrCreateGStrIdxWithMangler(const std::string &str) {
-  return GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(NameMangler::EncodeName(str));
+  return GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(str));
 }
 
 // ---------- ExceptionTableItem ----------
@@ -481,7 +481,7 @@ bool LocalVariableTableItem::PreProcessImpl(const JBCConstPool &constPool) {
     return false;
   }
   nameIdxMpl = GetOrCreateGStrIdx(constName->GetString());
-  feirType = FEManager::GetTypeManager().GetOrCreateFEIRTypeByName(NameMangler::EncodeName(constDesc->GetString()),
+  feirType = FEManager::GetTypeManager().GetOrCreateFEIRTypeByName(namemangler::EncodeName(constDesc->GetString()),
                                                                    GStrIdx(0), kSrcLangJava);
   return true;
 }
diff --git a/src/mplfe/jbc_input/src/jbc_class2fe_helper.cpp b/src/mplfe/jbc_input/src/jbc_class2fe_helper.cpp
index 6923b99186f2840e5d1dbe53c996a0cdafae84e2..f3a61f559c3e54940d830559ecae9b9b47b35a8a 100644
--- a/src/mplfe/jbc_input/src/jbc_class2fe_helper.cpp
+++ b/src/mplfe/jbc_input/src/jbc_class2fe_helper.cpp
@@ -158,14 +158,14 @@ bool JBCClassField2FEHelper::ProcessDeclWithContainerImpl(MapleAllocator &alloca
   name += fieldName;
   name += withType ? ("|" + typeName) : "";
   std::string fullName = klassName + "|" + fieldName + "|" + typeName;
-  GStrIdx idx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(NameMangler::EncodeName(name));
-  GStrIdx fullNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(NameMangler::EncodeName(fullName));
+  GStrIdx idx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(name));
+  GStrIdx fullNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(namemangler::EncodeName(fullName));
   FEStructElemInfo *elemInfo = FEManager::GetTypeManager().RegisterStructFieldInfo(fullNameIdx, kSrcLangJava,
                                                                                    field.IsStatic());
   elemInfo->SetDefined();
   elemInfo->SetFromDex();
   FieldAttrs attrs = AccessFlag2Attribute(field.GetAccessFlag());
-  std::string typeNameMpl = NameMangler::EncodeName(typeName);
+  std::string typeNameMpl = namemangler::EncodeName(typeName);
   MIRType *fieldType = FEManager::GetTypeManager().GetOrCreateTypeFromName(typeNameMpl, FETypeFlag::kSrcUnknown, true);
   ASSERT(fieldType != nullptr, "nullptr check for fieldType");
   mirFieldPair.first = idx;
@@ -261,7 +261,7 @@ std::string JBCClassMethod2FEHelper::GetMethodNameImpl(bool inMpl) const {
   std::string methodName = method.GetName(constPool);
   std::string descName = method.GetDescription(constPool);
   std::string fullName = klassName + "|" + methodName + "|" + descName;
-  return inMpl ? NameMangler::EncodeName(fullName) : fullName;
+  return inMpl ? namemangler::EncodeName(fullName) : fullName;
 }
 
 FuncAttrs JBCClassMethod2FEHelper::GetAttrsImpl() const {
diff --git a/src/mplfe/jbc_input/src/jbc_class_const.cpp b/src/mplfe/jbc_input/src/jbc_class_const.cpp
index c75b3bbeac4402d70c9c83c966ed2088a69e3c6a..f6a2406ad6977b3cd13afff13102d9c627076497 100644
--- a/src/mplfe/jbc_input/src/jbc_class_const.cpp
+++ b/src/mplfe/jbc_input/src/jbc_class_const.cpp
@@ -218,7 +218,7 @@ bool JBCConstClass::PreProcessImpl(const JBCConstPool &constPool) {
   const std::string &classNameInternal = constUTF8->GetString();
   nameOrin = JBCUtil::ClassInternalNameToFullName(classNameInternal);
   strIdxOrin = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(MapleStringToStd(nameOrin));
-  nameMpl = NameMangler::EncodeName(nameOrin.c_str());
+  nameMpl = namemangler::EncodeName(nameOrin.c_str());
   strIdxMpl = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(MapleStringToStd(nameMpl));
   static_cast<FEIRTypeDefault*>(feType)->LoadFromJavaTypeName(MapleStringToStd(nameMpl), true);
   return true;
@@ -301,7 +301,7 @@ bool JBCConstRef::PrepareFEStructElemInfo() {
   const std::string &className = constClass->GetClassNameOrin();
   const std::string &elemName = constNameAndType->GetName();
   const std::string &descName = constNameAndType->GetDesc();
-  std::string fullName = NameMangler::EncodeName(className + "|" + elemName + "|" + descName);
+  std::string fullName = namemangler::EncodeName(className + "|" + elemName + "|" + descName);
   GStrIdx fullNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fullName);
   if (tag == kConstFieldRef) {
     feStructElemInfo = FEManager::GetTypeManager().RegisterStructFieldInfo(fullNameIdx, kSrcLangJava, false);
@@ -465,7 +465,7 @@ bool JBCConstInvokeDynamic::PrepareFEStructElemInfo(const std::string &ownerClas
   const std::string &className = ownerClassName + "$DynamicCall$";
   const std::string &elemName = constNameAndType->GetName();
   const std::string &descName = constNameAndType->GetDesc();
-  std::string fullName = NameMangler::EncodeName(className + "|" + elemName + "|" + descName);
+  std::string fullName = namemangler::EncodeName(className + "|" + elemName + "|" + descName);
   GStrIdx fullNameIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(fullName);
   feStructElemInfo = FEManager::GetTypeManager().RegisterStructMethodInfo(fullNameIdx, kSrcLangJava, false);
   static_cast<FEStructMethodInfo*>(feStructElemInfo)->SetJavaDyamicCall();
diff --git a/test/maple_test/configs.py b/test/maple_test/configs.py
index 628e52505febde45ba54c6942f2343e1078e7b17..2549b75826e8c2bef6f20cb4d642fe45770a49c7 100644
--- a/test/maple_test/configs.py
+++ b/test/maple_test/configs.py
@@ -199,7 +199,7 @@ def parse_args():
         "fail_exit": args.fail_exit,
         "print_type": args.print_type,
         "progress": args.progress,
-        "fail_verbose": args.fail_verbose
+        "fail_verbose": args.fail_verbose,
     }
 
     test_suite_config = {
diff --git a/test/maple_test/task.py b/test/maple_test/task.py
index 45e1fa168e4fda780691aed6db2b2417f8085c3e..8cef13ba65548a49de5842cf80fea7b2564eb9a4 100644
--- a/test/maple_test/task.py
+++ b/test/maple_test/task.py
@@ -148,7 +148,7 @@ class TestSuiteTask:
         if user_config_set:
             run_config_set = user_config_set
         else:
-            run_config_set = list(top_dir.glob("**/*.cfg"))
+            run_config_set = [self.cfg_path]
 
         for cfg in run_config_set:
             if not cfg.exists():
@@ -297,11 +297,13 @@ class TestSuiteTask:
 
         postion, result = result
         case = self.task_set[postion[0]][postion[1]]
-        if result[0] != PASS:
-            output = {}
-            output["name"] = str(case)
-            output["cmd_list"] = ""
-            output["cmd_output"] = ""
+        output = {}
+        output["name"] = str(case)
+        output["cmd_list"] = ""
+        output["cmd_output"] = ""
+        if result[0] == PASS:
+            return
+        if result[0] != PASS and not isinstance(result[1], str):
             for cmd_result in result[1]:
                 output["cmd_output"] += cmd_template.format(**cmd_result)
             for cmd in case.commands[: len(result[1]) - 1]:
@@ -311,7 +313,10 @@ class TestSuiteTask:
             )
             for cmd in case.commands[len(result[1]) :]:
                 output["cmd_list"] += cmd_list_template.format(NOT_RUN, cmd)
-            print(output_template.format(**output))
+        else:
+            output["cmd_list"] = "Test case preparation failed, " + result[1] + "\n"
+            output["cmd_output"] = output["cmd_list"]
+        print(output_template.format(**output))
 
     def parallel_run_task(self, process_num):
         multiprocessing.freeze_support()
diff --git a/test/maple_test/test.py b/test/maple_test/test.py
index 9173a66417d9e527b526229bb252aede0006aa24..bfa32e6cd0299c50240c8a265e2959517ea39e92 100644
--- a/test/maple_test/test.py
+++ b/test/maple_test/test.py
@@ -145,11 +145,15 @@ class Result:
 
         if self.status == FAIL:
             failure = ElementTree.SubElement(case, "failure")
-            failure.text = "List of commands:\n"
-            for cmd in self.commands:
-                failure.text += "EXEC: {}\n".format(cmd)
-            failure.text += "----\n"
-            failure.text += self.command_result_to_text(self.commands_result[-1])
+            if isinstance(self.commands_result, str):
+                failure.text = "Test case preparation failed, "
+                failure.text += self.commands_result
+            else:
+                failure.text = "List of commands:\n"
+                for cmd in self.commands:
+                    failure.text += "EXEC: {}\n".format(cmd)
+                failure.text += "----\n"
+                failure.text += self.command_result_to_text(self.commands_result[-1])
         elif self.status == UNRESOLVED:
             skipped = ElementTree.SubElement(case, "skipped")
             skipped.text = "No valid command statement was found."