diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl
index 3afa3e8786d3b0bb111c0fd480ed71f5a3080481..32e63dcaad1927944d1a817bc66e15e76eadc632 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..dd405083d60af04723ca9e58b7873704ec1c1f72 100755
Binary files a/src/bin/maple and b/src/bin/maple 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/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/cg.h b/src/maple_be/include/cg/cg.h
index 4a95620af6039f1053828666c471f5a4c05f21af..a9bcf5bf9fd3cbfd38ae849b3a0dc6f8a05640c0 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();
diff --git a/src/maple_be/include/cg/cgfunc.h b/src/maple_be/include/cg/cgfunc.h
index 31f90329af438b67821c2d059634887caa2083af..4542a8578241b3eb552505331b835929242bb3c2 100644
--- a/src/maple_be/include/cg/cgfunc.h
+++ b/src/maple_be/include/cg/cgfunc.h
@@ -81,7 +81,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 {
@@ -745,6 +745,10 @@ class CGFunc {
     volReleaseInsn = insn;
   }
 
+  const MapleString &GetShortFuncName() const {
+    return shortFuncName;
+  }
+
   virtual InsnVisitor *NewInsnModifier() = 0;
 
  protected:
@@ -843,6 +847,7 @@ class CGFunc {
   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..60e27a1bc52e2639453b63ebdb39573fd7f11b3a 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;
   }
diff --git a/src/maple_be/src/be/lower.cpp b/src/maple_be/src/be/lower.cpp
index 510fff18ebd01b8834b16266553d478b522aadf1..15613a99cb7d9d0d976c9dee37708ee0704f280a 100644
--- a/src/maple_be/src/be/lower.cpp
+++ b/src/maple_be/src/be/lower.cpp
@@ -307,11 +307,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());
@@ -2178,7 +2178,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 +2649,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_cg.cpp b/src/maple_be/src/cg/aarch64/aarch64_cg.cpp
index b16e16b32cda9503d251e17e102e89970a095f80..1981aba3bf79fa6f332a2fbdee66e03e509f4ac6 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_cg.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_cg.cpp
@@ -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..9cfe5b3de365c56a4f8641af0dd4ed39e264f3f9 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp
@@ -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);
@@ -4885,7 +4885,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);
@@ -5149,8 +5149,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;
@@ -5948,7 +5947,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 +5978,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;
diff --git a/src/maple_be/src/cg/aarch64/aarch64_emitter.cpp b/src/maple_be/src/cg/aarch64/aarch64_emitter.cpp
index 17e14810da9c3d09cfb3dffdafff73b17c938c31..c19e750086588819d19b53fdf78e36ceaa4d0be8 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()) {
@@ -256,10 +256,10 @@ void AArch64Emitter::EmitBBHeaderLabel(const std::string &name, LabelIdx labIdx)
     currCG->IncreaseLabelOrderCnt();
   }
   if (currCG->GenerateVerboseAsm()) {
-    emitter.Emit(".Label.").Emit(name).Emit(".").Emit(labIdx).Emit(":\t//label order ").Emit(label.GetLabelOrder());
+    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)) {
@@ -333,7 +334,7 @@ void AArch64Emitter::Run() {
     }
     /* 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..54fbd59e60860b23db13e3b84d7630c1c752fad7 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]" */
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..5a59874ed5b2da032252395ba66590df16a171b3 100644
--- a/src/maple_be/src/cg/cg.cpp
+++ b/src/maple_be/src/cg/cg.cpp
@@ -256,4 +256,26 @@ 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);
+  if (funcName == "_3Cinit_3E") {
+    return "init";
+  }
+  if (funcName == "_3Cclinit_3E") {
+    return "clinit";
+  }
+  return funcName;
+}
 }  /* namespace maplebe */
diff --git a/src/maple_be/src/cg/cgfunc.cpp b/src/maple_be/src/cg/cgfunc.cpp
index c58641a92b3c768709168683705107cb4c727311..24955db108fc59e85aadbe4601fe9d5d1cf3ebd8 100644
--- a/src/maple_be/src/cg/cgfunc.cpp
+++ b/src/maple_be/src/cg/cgfunc.cpp
@@ -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,8 @@ CGFunc::CGFunc(MIRModule &mod, CG &cg, MIRFunction &mirFunc, BECommon &beCommon,
       beCommon(beCommon),
       funcScopeAllocator(&allocator),
       emitStVec(allocator.Adapter()),
-      loops(allocator.Adapter()) {
+      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/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..462de8cdbf84553115fe138326ca907f30a5efbc 100644
--- a/src/maple_driver/src/driver_runner.cpp
+++ b/src/maple_driver/src/driver_runner.cpp
@@ -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/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_ir/src/bin_mpl_export.cpp b/src/maple_ir/src/bin_mpl_export.cpp
index 081d011d38129db7dc39372f82f0fa90985e88d6..175047f39f698499300ac8cfc77f4b4a607b232d 100644
--- 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));
diff --git a/src/maple_ir/src/bin_mpl_import.cpp b/src/maple_ir/src/bin_mpl_import.cpp
index 059acecdeeb2d3954e8445e4c95b61bfbacabdfe..5f7f9b66f654b604914b71a6c25c4796a747d65a 100644
--- 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);
     }
@@ -746,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/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..e3c67d8565e9f23b74a05e53a43811eb2c9ffc6c 100644
--- a/src/maple_ir/src/mir_function.cpp
+++ b/src/maple_ir/src/mir_function.cpp
@@ -424,7 +424,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 +437,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 6f1b0944ae3c78848e6e5997bcad538e0cf2fa55..6e8f679f7aee23be5cd4577e0b6dcab5399463c3 100644
--- 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");
   }
@@ -637,7 +637,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 =
@@ -857,7 +857,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);
diff --git a/src/maple_ir/src/parser.cpp b/src/maple_ir/src/parser.cpp
index 6388a2bb522844d247e7785b678687280306adfb..0333f127eba4e9765eadb837db56e556b73b3a43 100644
--- a/src/maple_ir/src/parser.cpp
+++ b/src/maple_ir/src/parser.cpp
@@ -1559,7 +1559,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);
       }
@@ -1717,7 +1717,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 =
@@ -1741,10 +1741,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)) {
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/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_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_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/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/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/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..cdf090aeb134044e269edf1669d454bbb6387b01 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);
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();