diff --git a/BUILD.gn b/BUILD.gn
index 1627e7ed69c728c252d5c27cb8395fd8aa2d2463..2a8bc19a8ca8639ae62c11dc24fea6cbe8fb58bb 100644
--- a/BUILD.gn
+++ b/BUILD.gn
@@ -14,19 +14,19 @@
 #
 group("maple") {
   deps = [
-    "${MAPLE_ROOT}/src:maple",
+    "${MAPLEALL_ROOT}:maple",
   ]
 }
 
 group("irbuild") {
   deps = [
-    "${MAPLE_ROOT}/src:irbuild",
+    "${MAPLEALL_ROOT}:irbuild",
   ]
 }
 
 group("mplfe") {
   deps = [
-    "${MAPLE_ROOT}/src:mplfe",
+    "${MPLFE_ROOT}:mplfe",
   ]
 }
 
diff --git a/build/config/BUILDCONFIG.gn b/build/config/BUILDCONFIG.gn
index 7b0a0272447bfd49c0334fb0f6a015bd9e37866d..a587a85778bd0435729dab252051b7b9166184b5 100644
--- a/build/config/BUILDCONFIG.gn
+++ b/build/config/BUILDCONFIG.gn
@@ -36,6 +36,7 @@ OPENSOURCE_OUTPUT = "${MAPLE_ROOT}/output"
 AST2MPL_ROOT= "${MAPLE_ROOT}/src/ast2mpl"
 IS_AST2MPL_EXISTS = getenv("IS_AST2MPL_EXISTS")
 MAPLEALL_ROOT = "${MAPLE_ROOT}/src"
+MPLFE_ROOT = "${MAPLE_ROOT}/src/mplfe"
 THIRD_PARTY_ROOT = "${MAPLE_ROOT}/src/third_party"
 
 # Put all built library files under lib
diff --git a/src/BUILD.gn b/src/BUILD.gn
index 6403e41afb00a8c86becc75e0a6b04cfc5338662..df5383bd8f6a3c1539ac70a3ee78dbcefad7cb93 100644
--- a/src/BUILD.gn
+++ b/src/BUILD.gn
@@ -52,12 +52,6 @@ group("irbuild") {
   ]
 }
 
-group("mplfe") {
-  deps = [
-    "${MAPLEALL_ROOT}/mplfe:mplfe",
-  ]
-}
-
 group("maplegen") {
   deps = [
     "${MAPLEALL_ROOT}/maple_be:maplegen",
diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl
index 5c8c49c614a8a67c30a2fb551cae7ceaf6f3e732..a43b06066043118a424f99594593b8d23e5121ed 100755
Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ
diff --git a/src/bin/maple b/src/bin/maple
index c14f4b856aeebb1fc61dd6c896ef9b9cbb194821..1325a895ee47d3899e033741176b33dd703d7f49 100755
Binary files a/src/bin/maple and b/src/bin/maple differ
diff --git a/src/deplibs/libmplphase.a b/src/deplibs/libmplphase.a
index 62b849b1a308b35f7930bfce3dc445bc56caeb21..88b01e34d3aa2c7c117f32a89e3671e38d08f322 100644
Binary files a/src/deplibs/libmplphase.a and b/src/deplibs/libmplphase.a differ
diff --git a/src/deplibs/libmplutil.a b/src/deplibs/libmplutil.a
index 29d0acf27c6212c040d864593169968d50e71d41..bf31a7baec611102050f3e8b51cca6ce0974c064 100644
Binary files a/src/deplibs/libmplutil.a and b/src/deplibs/libmplutil.a differ
diff --git a/src/maple_be/include/be/becommon.h b/src/maple_be/include/be/becommon.h
index 16e4fa1053cdebe3cf9f892c5a8464463a538c25..0803cf69aca88ae35019c4ef0dfde042f90086e1 100644
--- a/src/maple_be/include/be/becommon.h
+++ b/src/maple_be/include/be/becommon.h
@@ -163,7 +163,7 @@ class BECommon {
     typeSizeTable.emplace_back(value);
   }
 
-  void AddTypeSizeAndAlign(TyIdx tyIdx, uint64 value) {
+  void AddTypeSizeAndAlign(const TyIdx tyIdx, uint64 value) {
     if (typeSizeTable.size() == tyIdx) {
       typeSizeTable.emplace_back(value);
       tableAlignTable.emplace_back(value);
diff --git a/src/maple_be/include/cg/aarch64/aarch64_cg.h b/src/maple_be/include/cg/aarch64/aarch64_cg.h
index 5fb7dad36895094bc357c92f552fba28ad66237b..90fd94371a8edae6c979a55e89e712290018978a 100644
--- a/src/maple_be/include/cg/aarch64/aarch64_cg.h
+++ b/src/maple_be/include/cg/aarch64/aarch64_cg.h
@@ -28,7 +28,7 @@ class GCTIBKey {
  public:
   GCTIBKey(MapleAllocator &allocator, uint32 rcHeader, std::vector<uint64> &patternWords)
       : header(rcHeader), bitMapWords(allocator.Adapter()) {
-    bitMapWords.insert(bitMapWords.begin(), patternWords.begin(), patternWords.end());
+    (void)bitMapWords.insert(bitMapWords.begin(), patternWords.begin(), patternWords.end());
   }
 
   ~GCTIBKey() = default;
diff --git a/src/maple_be/include/cg/aarch64/aarch64_color_ra.h b/src/maple_be/include/cg/aarch64/aarch64_color_ra.h
index 7e3d5ced79644d9828f0968a654123ac295eb77c..1c801b68b48d9c269cf2676a53267c1bb3b1aaa9 100644
--- a/src/maple_be/include/cg/aarch64/aarch64_color_ra.h
+++ b/src/maple_be/include/cg/aarch64/aarch64_color_ra.h
@@ -448,7 +448,7 @@ class LiveRange {
   }
 
   void InsertElemToPrefs(regno_t regNO) {
-    prefs.insert(regNO);
+    (void)prefs.insert(regNO);
   }
 
   const MapleMap<uint32, LiveUnit*> &GetLuMap() const {
@@ -1151,7 +1151,7 @@ class GraphColorRegAllocator : public AArch64RegAllocator {
   bool IsUnconcernedReg(const RegOperand &regOpnd) const;
   LiveRange *NewLiveRange();
   void CalculatePriority(LiveRange &lr) const;
-  bool CreateLiveRangeHandleLocal(regno_t regNO, BB &bb, bool isDef);
+  bool CreateLiveRangeHandleLocal(regno_t regNO, const BB &bb, bool isDef);
   LiveRange *CreateLiveRangeAllocateAndUpdate(regno_t regNO, const BB &bb, bool isDef, uint32 currId);
   bool CreateLiveRange(regno_t regNO, BB &bb, bool isDef, uint32 currPoint, bool updateCount);
   bool SetupLiveRangeByOpHandlePhysicalReg(RegOperand &op, Insn &insn, regno_t regNO, bool isDef);
@@ -1206,7 +1206,7 @@ class GraphColorRegAllocator : public AArch64RegAllocator {
   MemOperand *GetReuseMem(uint32 vregNO, uint32 size, RegType regType);
   MemOperand *GetSpillMem(uint32 vregNO, bool isDest, Insn &insn, AArch64reg regNO, bool &isOutOfRange);
   bool SetAvailableSpillReg(std::unordered_set<regno_t> &cannotUseReg, LiveRange &lr, uint64 &usedRegMask);
-  void CollectCannotUseReg(std::unordered_set<regno_t> &cannotUseReg, LiveRange &lr, Insn &insn);
+  void CollectCannotUseReg(std::unordered_set<regno_t> &cannotUseReg, const LiveRange &lr, Insn &insn);
   regno_t PickRegForSpill(uint64 &usedRegMask, RegType regType, uint32 spillIdx, bool &needSpillLr);
   bool SetRegForSpill(LiveRange &lr, Insn &insn, uint32 spillIdx, uint64 &usedRegMask, bool isDef);
   bool GetSpillReg(Insn &insn, LiveRange &lr, uint32 &spillIdx, uint64 &usedRegMask, bool isDef);
@@ -1236,7 +1236,7 @@ class GraphColorRegAllocator : public AArch64RegAllocator {
   void ComputeBBForNewSplit(LiveRange &newLr, LiveRange &oldLr);
   void ClearLrBBFlags(const std::set<BB*, SortedBBCmpFunc> &member);
   void ComputeBBForOldSplit(LiveRange &newLr, LiveRange &oldLr);
-  bool LrCanBeColored(LiveRange &lr, BB &bbAdded, std::unordered_set<regno_t> &conflictRegs);
+  bool LrCanBeColored(const LiveRange &lr, const BB &bbAdded, std::unordered_set<regno_t> &conflictRegs);
   void MoveLrBBInfo(LiveRange &oldLr, LiveRange &newLr, BB &bb);
   bool ContainsLoop(const CGFuncLoops &loop, const std::set<CGFuncLoops*, CGFuncLoopCmp> &loops) const;
   void GetAllLrMemberLoops(LiveRange &lr, std::set<CGFuncLoops*, CGFuncLoopCmp> &loop);
diff --git a/src/maple_be/include/cg/aarch64/aarch64_insn.h b/src/maple_be/include/cg/aarch64/aarch64_insn.h
index 03e6f9547e5f66657167ec660eda5f4a0e7433e4..6de85b7f7310415faf0ddc166df75e53531cf400 100644
--- a/src/maple_be/include/cg/aarch64/aarch64_insn.h
+++ b/src/maple_be/include/cg/aarch64/aarch64_insn.h
@@ -155,7 +155,7 @@ class AArch64Insn : public Insn {
 
   uint32 GetLatencyType() const override;
 
-  bool CheckRefField(int32 opndIndex, bool isEmit) const;
+  bool CheckRefField(size_t opndIndex, bool isEmit) const;
 
  private:
   void CheckOpnd(Operand &opnd, OpndProp &mopd) const;
diff --git a/src/maple_be/include/cg/cgbb.h b/src/maple_be/include/cg/cgbb.h
index 2fa93935384353ab02aad66f35f6b4f56ea80867..aaabd1542e30b311130f17188f37e41de9503175 100644
--- a/src/maple_be/include/cg/cgbb.h
+++ b/src/maple_be/include/cg/cgbb.h
@@ -449,7 +449,7 @@ class BB {
     return liveInRegNO;
   }
   void InsertLiveInRegNO(regno_t arg) {
-    liveInRegNO.insert(arg);
+    (void)liveInRegNO.insert(arg);
   }
   void EraseLiveInRegNO(MapleSet<regno_t>::iterator it) {
     liveInRegNO.erase(it);
@@ -464,7 +464,7 @@ class BB {
     return liveOutRegNO;
   }
   void InsertLiveOutRegNO(regno_t arg) {
-    liveOutRegNO.insert(arg);
+    (void)liveOutRegNO.insert(arg);
   }
   void EraseLiveOutRegNO(MapleSet<regno_t>::iterator it) {
     liveOutRegNO.erase(it);
diff --git a/src/maple_be/include/cg/cgfunc.h b/src/maple_be/include/cg/cgfunc.h
index 17d304c512d48983ceb61c4cf74487291f290122..3604b99f6648472f6d3963267a16775069447d0a 100644
--- a/src/maple_be/include/cg/cgfunc.h
+++ b/src/maple_be/include/cg/cgfunc.h
@@ -51,7 +51,7 @@ class SpillMemOperandSet {
   virtual ~SpillMemOperandSet() = default;
 
   void Add(MemOperand &op) {
-    reuseSpillLocMem.insert(&op);
+    (void)reuseSpillLocMem.insert(&op);
   }
 
   void Remove(MemOperand &op) {
@@ -662,7 +662,7 @@ class CGFunc {
     return sortedBBs;
   }
 
-  void SetSortedBBs(MapleVector<BB*> &bbVec) {
+  void SetSortedBBs(const MapleVector<BB*> &bbVec) {
     sortedBBs = bbVec;
   }
 
@@ -674,7 +674,7 @@ class CGFunc {
     return lrVec;
   }
 
-  void SetLrVec(MapleVector<LiveRange*> &newLrVec) {
+  void SetLrVec(const MapleVector<LiveRange*> &newLrVec) {
     lrVec = newLrVec;
   }
 #endif  /* TARGARM32 */
diff --git a/src/maple_be/include/cg/datainfo.h b/src/maple_be/include/cg/datainfo.h
index bb374b9995e8f60ae3b8c148a3ed3dc77d012506..b4cc97e187f9a23c15fb63b5724434a6f57db538 100644
--- a/src/maple_be/include/cg/datainfo.h
+++ b/src/maple_be/include/cg/datainfo.h
@@ -140,7 +140,7 @@ class DataInfo {
     auto infoSize = static_cast<const int32>(info.size());
     for (int32 i = 0; i < infoSize; i++) {
       if (info[i] != 0ULL) {
-        index.insert(i);
+        (void)index.insert(i);
       }
     }
   }
@@ -162,7 +162,7 @@ class DataInfo {
         if (index == k64BitSize) {
           /* when the highest bit is 1, the shift operation will cause error, need special treatment. */
           result = i * kWordSize + (index - 1);
-          wordRes.insert(result);
+          (void)wordRes.insert(result);
           break;
         }
         if (firstTime) {
@@ -174,7 +174,7 @@ class DataInfo {
           baseWord = 0;
         }
         result += baseWord + offset;
-        wordRes.insert(result);
+        (void)wordRes.insert(result);
         word = word >> static_cast<uint64>(index);
       }
     }
diff --git a/src/maple_be/include/cg/ebo.h b/src/maple_be/include/cg/ebo.h
index 8485973d1556286fb30dd914e92e716aee8e020e..49bbed1c048da030242ca293aaf07836fb0a138a 100644
--- a/src/maple_be/include/cg/ebo.h
+++ b/src/maple_be/include/cg/ebo.h
@@ -145,7 +145,7 @@ class Ebo {
   bool HasAssignedReg(const Operand &opnd) const;
   bool IsOfSameClass(const Operand &op0, const Operand &op1) const;
   bool OpndAvailableInBB(const BB &bb, OpndInfo *info);
-  bool ForwardPropCheck(const Operand *opndReplace, OpndInfo &opndInfo, const Operand &opnd, Insn &insn);
+  bool ForwardPropCheck(const Operand *opndReplace, const OpndInfo &opndInfo, const Operand &opnd, Insn &insn);
   bool RegForwardCheck(Insn &insn, const Operand &opnd, const Operand *opndReplace, Operand &oldOpnd,
                        const OpndInfo *tmpInfo);
   bool IsNotVisited(const BB &bb) {
diff --git a/src/maple_be/include/cg/emit.h b/src/maple_be/include/cg/emit.h
index aad06eac189e7d655d336a613134995a460df7d6..b605ab7d79ce1f903ed334a1f9973801704481dc 100644
--- a/src/maple_be/include/cg/emit.h
+++ b/src/maple_be/include/cg/emit.h
@@ -253,7 +253,7 @@ class Emitter {
   }
 
   void InsertHugeSoTarget(const std::string &target) {
-    hugeSoTargets.insert(target);
+    (void)hugeSoTargets.insert(target);
   }
 #endif
 
diff --git a/src/maple_be/include/cg/loop.h b/src/maple_be/include/cg/loop.h
index 03ad0a5c392100575cc8ed748a7abb15ccfab8c2..5c8c864b6a348047978a9a6e69931dd67203ec76 100644
--- a/src/maple_be/include/cg/loop.h
+++ b/src/maple_be/include/cg/loop.h
@@ -64,13 +64,13 @@ class LoopHierarchy {
     return loopMembers.erase(it);
   }
   void InsertLoopMembers(BB &bb) {
-    loopMembers.insert(&bb);
+    (void)loopMembers.insert(&bb);
   }
   void InsertBackedge(BB &bb) {
-    backedge.insert(&bb);
+    (void)backedge.insert(&bb);
   }
   void InsertInnerLoops(LoopHierarchy &loop) {
-    innerLoops.insert(&loop);
+    (void)innerLoops.insert(&loop);
   }
   void SetHeader(BB &bb) {
     header = &bb;
diff --git a/src/maple_be/mdgen/include/mdlexer.h b/src/maple_be/mdgen/include/mdlexer.h
index 5445b2fd4385888b4fcfebe14a87b81af989f924..033a40b8787993724a1af35210683ee732cc6e55 100644
--- a/src/maple_be/mdgen/include/mdlexer.h
+++ b/src/maple_be/mdgen/include/mdlexer.h
@@ -31,9 +31,9 @@ class MDLexer {
   MDLexer() {
     keywords.clear();
     /* input can be improved */
-    keywords.insert(std::make_pair("Def", kMDDef));
-    keywords.insert(std::make_pair("Class", kMDClass));
-    keywords.insert(std::make_pair("DefType", kMDDefType));
+    (void)keywords.insert(std::make_pair("Def", kMDDef));
+    (void)keywords.insert(std::make_pair("Class", kMDClass));
+    (void)keywords.insert(std::make_pair("DefType", kMDDefType));
   };
   ~MDLexer() {
     if (mdFileInternal.is_open()) {
diff --git a/src/maple_be/mdgen/src/mdrecord.cpp b/src/maple_be/mdgen/src/mdrecord.cpp
index 88b0602b3cb3967fed816516deb503c565e7fdaa..22122490a0dfde06ceb25ee47124b4d61fa849ef 100644
--- a/src/maple_be/mdgen/src/mdrecord.cpp
+++ b/src/maple_be/mdgen/src/mdrecord.cpp
@@ -45,7 +45,7 @@ const MDObject &MDClass::GetOneMDObject(size_t index) const {
 
 void MDClass::AddClassMember(MDObject inputObj) {
   mdObjects.emplace_back(inputObj);
-  childObjNames.insert(inputObj.GetIdx());
+  (void)childObjNames.insert(inputObj.GetIdx());
 }
 
 bool MDClass::IsClassMember(unsigned int curIdx) const {
@@ -96,11 +96,11 @@ void MDClassRange::ModifyStrTyInTable(const std::string &inStr, RecordType newTy
 }
 
 void MDClassRange::AddDefinedType(unsigned int typesName, std::set<unsigned int> typesSet) {
-  definedTypes.insert(std::make_pair(typesName, typesSet));
+  (void)definedTypes.insert(std::make_pair(typesName, typesSet));
 }
 
 void MDClassRange::AddMDClass(MDClass curClass) {
-  allClasses.insert(std::make_pair(curClass.GetClassIdx(), curClass));
+  (void)allClasses.insert(std::make_pair(curClass.GetClassIdx(), curClass));
 }
 
 void MDClassRange::FillMDClass(unsigned int givenIdx, const MDObject &insertObj) {
diff --git a/src/maple_be/src/be/becommon.cpp b/src/maple_be/src/be/becommon.cpp
index 67d77c17c0c8e280666a37b4dc4cf286626794f4..b779b6d210324596b3852dda966c2d0b6321143d 100644
--- a/src/maple_be/src/be/becommon.cpp
+++ b/src/maple_be/src/be/becommon.cpp
@@ -26,7 +26,7 @@ using namespace maple;
 BECommon::BECommon(MIRModule &mod)
     : mirModule(mod),
       typeSizeTable(GlobalTables::GetTypeTable().GetTypeTable().size(), 0, mirModule.GetMPAllocator().Adapter()),
-      tableAlignTable(GlobalTables::GetTypeTable().GetTypeTable().size(), mirModule.IsCModule(),
+      tableAlignTable(GlobalTables::GetTypeTable().GetTypeTable().size(), static_cast<uint8>(mirModule.IsCModule()),
           mirModule.GetMPAllocator().Adapter()),
       structFieldCountTable(GlobalTables::GetTypeTable().GetTypeTable().size(),
                             0, mirModule.GetMPAllocator().Adapter()),
diff --git a/src/maple_be/src/be/lower.cpp b/src/maple_be/src/be/lower.cpp
index 056ef9bb52e0738ce85ae4829cd5922bda1dc830..4675920010c2bdfe9e471fea49509fa11fb0b5e3 100644
--- a/src/maple_be/src/be/lower.cpp
+++ b/src/maple_be/src/be/lower.cpp
@@ -273,10 +273,10 @@ BaseNode *CGLowerer::LowerArrayDim(ArrayNode &array, int32 dim) {
     BaseNode *mpyNode = mirModule.CurFuncCodeMemPool()->New<BinaryNode>(OP_mul);
     BaseNode *item = NodeConvert(array.GetPrimType(), *array.GetDim(mirModule, GlobalTables::GetTypeTable(), dim - 1));
     if (mirModule.IsCModule()) {
-      item = NodeConvert(array.GetPrimType(), *array.GetIndex(i));
+      item = NodeConvert(array.GetPrimType(), *array.GetIndex(static_cast<size_t>(static_cast<uint>(i))));
       int64 offsetSize = 1;
-      for (int j = i + 1; j < dim; j++) {
-        offsetSize *= arrayType->GetSizeArrayItem(j);
+      for (int32 j = i + 1; j < dim; ++j) {
+        offsetSize *= arrayType->GetSizeArrayItem(static_cast<uint32>(j));
       }
       MIRIntConst *offsetCst = mirModule.CurFuncCodeMemPool()->New<MIRIntConst>(
           offsetSize, *GlobalTables::GetTypeTable().GetTypeFromTyIdx(array.GetPrimType()));
@@ -1831,7 +1831,7 @@ StmtNode *CGLowerer::LowerIntrinsicopDassign(const DassignNode &dsNode,
   AddrofNode *addrofNode = mirBuilder->CreateAddrof(*dst, PTY_a32);
   MapleVector<BaseNode*> newOpnd(mirModule.CurFuncCodeMemPoolAllocator()->Adapter());
   newOpnd.emplace_back(addrofNode);
-  newOpnd.insert(newOpnd.end(), nOpnds.begin(), nOpnds.end());
+  (void)newOpnd.insert(newOpnd.end(), nOpnds.begin(), nOpnds.end());
   CallNode *callStmt = mirModule.CurFuncCodeMemPool()->New<CallNode>(mirModule, OP_call);
   callStmt->SetPUIdx(st->GetFunction()->GetPuidx());
   callStmt->SetNOpnd(newOpnd);
@@ -1890,7 +1890,7 @@ BaseNode *CGLowerer::LowerJavascriptIntrinsicop(IntrinsicopNode &intrinNode, con
     AddrofNode *addrofNode = mirBuilder->CreateAddrof(*tmpSt, PTY_a32);
     MapleVector<BaseNode*> newOpnd(mirModule.CurFuncCodeMemPoolAllocator()->Adapter());
     newOpnd.emplace_back(addrofNode);
-    newOpnd.insert(newOpnd.end(), nOpnds.begin(), nOpnds.end());
+    (void)newOpnd.insert(newOpnd.end(), nOpnds.begin(), nOpnds.end());
     CallNode *callStmt = mirModule.CurFuncCodeMemPool()->New<CallNode>(mirModule, OP_call);
     callStmt->SetPUIdx(st->GetFunction()->GetPuidx());
     callStmt->SetNOpnd(newOpnd);
diff --git a/src/maple_be/src/be/switch_lowerer.cpp b/src/maple_be/src/be/switch_lowerer.cpp
index a29029cff0af137babad8466411e28372d8dc5b4..89a2ad1958b3fddab0bcfcbd378b14e728f5ecc1 100644
--- a/src/maple_be/src/be/switch_lowerer.cpp
+++ b/src/maple_be/src/be/switch_lowerer.cpp
@@ -59,7 +59,8 @@ void SwitchLowerer::FindClusters(MapleVector<Cluster> &clusters) {
   while (i < length - kClusterSwitchCutoff) {
     for (int32 j = length - 1; j > i; --j) {
       float tmp1 = static_cast<float>(j - i);
-      float tmp2 = static_cast<float>(stmt->GetCasePair(j).first) - static_cast<float>(stmt->GetCasePair(i).first);
+      float tmp2 = static_cast<float>(stmt->GetCasePair(static_cast<size_t>(static_cast<uint>(j))).first) -
+          static_cast<float>(stmt->GetCasePair(static_cast<size_t>(static_cast<uint>(i))).first);
       if (((j - i) >= kClusterSwitchCutoff) &&
           (tmp2 < kMaxRangeGotoTableSize) &&
           ((tmp1 / tmp2) >= kClusterSwitchDensity)) {
diff --git a/src/maple_be/src/cg/aarch64/aarch64_cg.cpp b/src/maple_be/src/cg/aarch64/aarch64_cg.cpp
index c6b451f6ded3678c00e9618f6d0fca89b28737b9..91140af015926b0fa695448548417b4d219baf97 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_cg.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_cg.cpp
@@ -174,8 +174,8 @@ void AArch64CG::FindOrCreateRepresentiveSym(std::vector<uint64> &bitmapWords, ui
     if (gcTIBName.compare("MCC_GCTIB__Ljava_2Flang_2FObject_3B") == 0) {
       ptn->SetName("MCC_GCTIB__Ljava_2Flang_2FObject_3B");
     }
-    keyPatternMap.insert(std::make_pair(key, ptn));
-    symbolPatternMap.insert(std::make_pair(gcTIBName, ptn));
+    (void)keyPatternMap.insert(std::make_pair(key, ptn));
+    (void)symbolPatternMap.insert(std::make_pair(gcTIBName, ptn));
 
     /* Emit GCTIB pattern */
     std::string ptnString = "\t.type " + ptn->GetName() + ", %object\n" + "\t.data\n" + "\t.align 3\n";
@@ -221,7 +221,7 @@ void AArch64CG::FindOrCreateRepresentiveSym(std::vector<uint64> &bitmapWords, ui
       keyPatternMap[key] = ptn;
     }
   } else {
-    symbolPatternMap.insert(make_pair(gcTIBName, iter->second));
+    (void)symbolPatternMap.insert(make_pair(gcTIBName, iter->second));
   }
 }
 
diff --git a/src/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp b/src/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp
index bbd4eba2a29b96955a0fb15d14d01ec481b1e150..3a5f6597130bcfa7d80af1fa365df059aab8cf2b 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_cgfunc.cpp
@@ -1976,12 +1976,13 @@ void AArch64CGFunc::SelectAdd(Operand &resOpnd, Operand &opnd0, Operand &opnd1,
       if (!(immOpnd->IsInBitSize(kMaxImmVal12Bits, 0) ||
             immOpnd->IsInBitSize(kMaxImmVal12Bits, kMaxImmVal12Bits))) {
         /* process higher 12 bits */
-        ImmOperand &immOpnd2 = CreateImmOperand(static_cast<uint64>(immOpnd->GetValue()) >> kMaxImmVal12Bits,
-                                                immOpnd->GetSize(), immOpnd->IsSignedValue());
+        ImmOperand &immOpnd2 =
+            CreateImmOperand(static_cast<int64>(static_cast<uint64>(immOpnd->GetValue()) >> kMaxImmVal12Bits),
+                             immOpnd->GetSize(), immOpnd->IsSignedValue());
         mOpCode = is64Bits ? MOP_xaddrri24 : MOP_waddrri24;
         Insn &newInsn = GetCG()->BuildInstruction<AArch64Insn>(mOpCode, resOpnd, opnd0, immOpnd2, addSubLslOperand);
         GetCurBB()->AppendInsn(newInsn);
-        immOpnd->ModuloByPow2(kMaxImmVal12Bits);
+        immOpnd->ModuloByPow2(static_cast<int32>(kMaxImmVal12Bits));
         newOpnd0 = &resOpnd;
       }
       /* process lower 12  bits */
@@ -2077,12 +2078,13 @@ void AArch64CGFunc::SelectSub(Operand &resOpnd, Operand &opnd0, Operand &opnd1,
     if (!(immOpnd->IsInBitSize(kMaxImmVal12Bits, 0) ||
           immOpnd->IsInBitSize(kMaxImmVal12Bits, kMaxImmVal12Bits))) {
       /* process higher 12 bits */
-      ImmOperand &immOpnd2 = CreateImmOperand(static_cast<uint64>(immOpnd->GetValue()) >> kMaxImmVal12Bits,
-                                              immOpnd->GetSize(), immOpnd->IsSignedValue());
+      ImmOperand &immOpnd2 =
+          CreateImmOperand(static_cast<int64>(static_cast<uint64>(immOpnd->GetValue()) >> kMaxImmVal12Bits),
+                           immOpnd->GetSize(), immOpnd->IsSignedValue());
       mOpCode = is64Bits ? MOP_xsubrri24 : MOP_wsubrri24;
       Insn &newInsn = GetCG()->BuildInstruction<AArch64Insn>(mOpCode, resOpnd, *opnd0Bak, immOpnd2, addSubLslOperand);
       GetCurBB()->AppendInsn(newInsn);
-      immOpnd->ModuloByPow2(kMaxImmVal12Bits);
+      immOpnd->ModuloByPow2(static_cast<int64>(kMaxImmVal12Bits));
       opnd0Bak = &resOpnd;
     }
     /* process lower 12 bits */
@@ -5433,11 +5435,11 @@ void AArch64CGFunc::SelectLibCall(const std::string &funcName, std::vector<Opera
   std::vector<TyIdx> vec;
   std::vector<TypeAttrs> vecAt;
   for (size_t i = 1; i < opndVec.size(); ++i) {
-    vec.emplace_back(GlobalTables::GetTypeTable().GetTypeTable()[static_cast<int32>(primType)]->GetTypeIndex());
+    vec.emplace_back(GlobalTables::GetTypeTable().GetTypeTable()[static_cast<size_t>(primType)]->GetTypeIndex());
     vecAt.emplace_back(TypeAttrs());
   }
 
-  MIRType *retType = GlobalTables::GetTypeTable().GetTypeTable().at(static_cast<int32>(primType));
+  MIRType *retType = GlobalTables::GetTypeTable().GetTypeTable().at(static_cast<size_t>(primType));
   st->SetTyIdx(GetBecommon().BeGetOrCreateFunctionType(retType->GetTypeIndex(), vec, vecAt)->GetTypeIndex());
 
   if (GetCG()->GenerateVerboseCG()) {
@@ -5452,7 +5454,7 @@ void AArch64CGFunc::SelectLibCall(const std::string &funcName, std::vector<Opera
   AArch64ListOperand *srcOpnds = memPool->New<AArch64ListOperand>(*GetFuncScopeAllocator());
   for (size_t i = 1; i < opndVec.size(); ++i) {
     MIRType *ty;
-    ty = GlobalTables::GetTypeTable().GetTypeTable()[static_cast<uint32>(primType)];
+    ty = GlobalTables::GetTypeTable().GetTypeTable()[static_cast<size_t>(primType)];
     Operand *stOpnd = opndVec[i];
     if (stOpnd->GetKind() != Operand::kOpdRegister) {
       stOpnd = &SelectCopy(*stOpnd, primType, primType);
@@ -5565,8 +5567,9 @@ void AArch64CGFunc::SelectAddAfterInsn(Operand &resOpnd, Operand &opnd0, Operand
     if (!(immOpnd->IsInBitSize(kMaxImmVal12Bits, 0) ||
           immOpnd->IsInBitSize(kMaxImmVal12Bits, kMaxImmVal12Bits))) {
       /* process higher 12 bits */
-      ImmOperand &immOpnd2 = CreateImmOperand(static_cast<uint64>(immOpnd->GetValue()) >> kMaxImmVal12Bits,
-                                              immOpnd->GetSize(), immOpnd->IsSignedValue());
+      ImmOperand &immOpnd2 =
+          CreateImmOperand(static_cast<int64>(static_cast<uint64>(immOpnd->GetValue()) >> kMaxImmVal12Bits),
+                           immOpnd->GetSize(), immOpnd->IsSignedValue());
       mOpCode = is64Bits ? MOP_xaddrri24 : MOP_waddrri24;
       Insn &newInsn = GetCG()->BuildInstruction<AArch64Insn>(mOpCode, resOpnd, opnd0, immOpnd2, addSubLslOperand);
       if (isDest) {
@@ -5575,7 +5578,7 @@ void AArch64CGFunc::SelectAddAfterInsn(Operand &resOpnd, Operand &opnd0, Operand
         insn.GetBB()->InsertInsnBefore(insn, newInsn);
       }
       /* get lower 12 bits value */
-      immOpnd->ModuloByPow2(kMaxImmVal12Bits);
+      immOpnd->ModuloByPow2(static_cast<int32>(kMaxImmVal12Bits));
       newOpnd0 = &resOpnd;
     }
     /* process lower 12 bits value */
@@ -5668,7 +5671,7 @@ MemOperand *AArch64CGFunc::GetOrCreatSpillMem(regno_t vrNum) {
     if (it != reuseSpillLocMem.end()) {
       MemOperand *memOpnd = it->second->GetOne();
       if (memOpnd != nullptr) {
-        spillRegMemOperands.insert(std::pair<regno_t, MemOperand*>(vrNum, memOpnd));
+        (void)spillRegMemOperands.insert(std::pair<regno_t, MemOperand*>(vrNum, memOpnd));
         return memOpnd;
       }
     }
@@ -5678,7 +5681,7 @@ MemOperand *AArch64CGFunc::GetOrCreatSpillMem(regno_t vrNum) {
     AArch64OfstOperand *offsetOpnd = memPool->New<AArch64OfstOperand>(offset, k64BitSize);
     MemOperand *memOpnd = memPool->New<AArch64MemOperand>(AArch64MemOperand::kAddrModeBOi, dataSize, baseOpnd,
                                                           nullptr, offsetOpnd, nullptr);
-    spillRegMemOperands.insert(std::pair<regno_t, MemOperand*>(vrNum, memOpnd));
+    (void)spillRegMemOperands.insert(std::pair<regno_t, MemOperand*>(vrNum, memOpnd));
     return memOpnd;
   } else {
     return p->second;
@@ -5699,10 +5702,10 @@ MemOperand *AArch64CGFunc::GetPseudoRegisterSpillMemoryOperand(PregIdx i) {
   MemOperand &memOpnd = GetOrCreateMemOpnd(AArch64MemOperand::kAddrModeBOi, bitLen, &base, nullptr, &ofstOpnd, nullptr);
   if (IsImmediateOffsetOutOfRange(static_cast<AArch64MemOperand&>(memOpnd), bitLen)) {
     MemOperand &newMemOpnd = SplitOffsetWithAddInstruction(static_cast<AArch64MemOperand&>(memOpnd), bitLen);
-    pRegSpillMemOperands.insert(std::pair<PregIdx, MemOperand*>(i, &newMemOpnd));
+    (void)pRegSpillMemOperands.insert(std::pair<PregIdx, MemOperand*>(i, &newMemOpnd));
     return &newMemOpnd;
   }
-  pRegSpillMemOperands.insert(std::pair<PregIdx, MemOperand*>(i, &memOpnd));
+  (void)pRegSpillMemOperands.insert(std::pair<PregIdx, MemOperand*>(i, &memOpnd));
   return &memOpnd;
 }
 
diff --git a/src/maple_be/src/cg/aarch64/aarch64_color_ra.cpp b/src/maple_be/src/cg/aarch64/aarch64_color_ra.cpp
index 73bdbc0dc7a7b4d3d4088a28f95f58c27c73c678..6f9e877b23d9c5c2cb28c8a3b8dee2bdd989a14c 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_color_ra.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_color_ra.cpp
@@ -333,10 +333,10 @@ void GraphColorRegAllocator::InitFreeRegPool() {
     if (JAVALANG && AArch64Abi::IsSpillRegInRA(static_cast<AArch64reg>(regNO), needExtraSpillReg)) {
       if (AArch64isa::IsGPRegister(static_cast<AArch64reg>(regNO))) {
         /* Preset int spill registers */
-        intSpillRegSet.insert(regNO - R0);
+        (void)intSpillRegSet.insert(regNO - R0);
       } else {
         /* Preset float spill registers */
-        fpSpillRegSet.insert(regNO - V0);
+        (void)fpSpillRegSet.insert(regNO - V0);
       }
       continue;
     }
@@ -354,16 +354,16 @@ void GraphColorRegAllocator::InitFreeRegPool() {
         continue;
       }
       if (AArch64Abi::IsCalleeSavedReg(static_cast<AArch64reg>(regNO))) {
-        intCalleeRegSet.insert(regNO - R0);
+        (void)intCalleeRegSet.insert(regNO - R0);
       } else {
-        intCallerRegSet.insert(regNO - R0);
+        (void)intCallerRegSet.insert(regNO - R0);
       }
       ++intNum;
     } else {
       if (AArch64Abi::IsCalleeSavedReg(static_cast<AArch64reg>(regNO))) {
-        fpCalleeRegSet.insert(regNO - V0);
+        (void)fpCalleeRegSet.insert(regNO - V0);
       } else {
-        fpCallerRegSet.insert(regNO - V0);
+        (void)fpCallerRegSet.insert(regNO - V0);
       }
       ++fpNum;
     }
@@ -439,7 +439,7 @@ LiveRange *GraphColorRegAllocator::NewLiveRange() {
 }
 
 /* Create local info for LR.  return true if reg is not local. */
-bool GraphColorRegAllocator::CreateLiveRangeHandleLocal(regno_t regNO, BB &bb, bool isDef) {
+bool GraphColorRegAllocator::CreateLiveRangeHandleLocal(regno_t regNO, const BB &bb, bool isDef) {
   if (FindIn(bb.GetLiveInRegNO(), regNO) || FindIn(bb.GetLiveOutRegNO(), regNO)) {
     return true;
   }
@@ -508,7 +508,7 @@ bool GraphColorRegAllocator::CreateLiveRange(regno_t regNO, BB &bb, bool isDef,
   lr->SetRegNO(regNO);
   lr->SetIsNonLocal(isNonLocal);
   if (isDef) {
-    vregLive.erase(regNO);
+    (void)vregLive.erase(regNO);
 #ifdef OPTIMIZE_FOR_PROLOG
     if (updateCount) {
       if (lr->GetNumDefs() == 0) {
@@ -518,7 +518,7 @@ bool GraphColorRegAllocator::CreateLiveRange(regno_t regNO, BB &bb, bool isDef,
     }
 #endif  /* OPTIMIZE_FOR_PROLOG */
   } else {
-    vregLive.insert(regNO);
+    (void)vregLive.insert(regNO);
 #ifdef OPTIMIZE_FOR_PROLOG
     if (updateCount) {
       if (lr->GetNumUses() == 0) {
@@ -566,7 +566,7 @@ bool GraphColorRegAllocator::SetupLiveRangeByOpHandlePhysicalReg(RegOperand &reg
       lraInfo->SetDefCntElem(regNO, lraInfo->GetDefCntElem(regNO) + 1);
     }
   } else {
-    pregLive.insert(regNO);
+    (void)pregLive.insert(regNO);
     for (const auto &vregNO : vregLive) {
       if (IsUnconcernedReg(vregNO)) {
         continue;
@@ -631,12 +631,12 @@ void GraphColorRegAllocator::SetupLiveRangeByRegNO(regno_t liveOut, BB &bb, uint
     return;
   }
   if (liveOut >= kNArmRegisters) {
-    vregLive.insert(liveOut);
+    (void)vregLive.insert(liveOut);
     CreateLiveRange(liveOut, bb, false, currPoint, false);
     return;
   }
 
-  pregLive.insert(liveOut);
+  (void)pregLive.insert(liveOut);
   for (const auto &vregNO : vregLive) {
     LiveRange *lr = lrVec[vregNO];
     lr->InsertElemToPregveto(liveOut);
@@ -663,9 +663,9 @@ void GraphColorRegAllocator::ClassifyOperand(std::unordered_set<regno_t> &pregs,
   auto &regOpnd = static_cast<const RegOperand&>(opnd);
   regno_t regNO = regOpnd.GetRegisterNumber();
   if (regOpnd.IsPhysicalRegister()) {
-    pregs.insert(regNO);
+    (void)pregs.insert(regNO);
   } else {
-    vregs.insert(regNO);
+    (void)vregs.insert(regNO);
   }
 }
 
@@ -802,7 +802,7 @@ void GraphColorRegAllocator::ComputeLiveRangesUpdateIfInsnIsCall(const Insn &ins
     for (auto regOpnd : srcOpnds.GetOperands()) {
       ASSERT(!regOpnd->IsVirtualRegister(), "not be a virtual register");
       auto physicalReg = static_cast<AArch64reg>(regOpnd->GetRegisterNumber());
-      pregLive.insert(physicalReg);
+      (void)pregLive.insert(physicalReg);
     }
   }
 }
@@ -1211,9 +1211,9 @@ void GraphColorRegAllocator::AddCalleeUsed(regno_t regNO, RegType regType) {
   bool isCalleeReg = AArch64Abi::IsCalleeSavedReg(static_cast<AArch64reg>(regNO));
   if (isCalleeReg) {
     if (regType == kRegTyInt) {
-      intCalleeUsed.insert(regNO);
+      (void)intCalleeUsed.insert(regNO);
     } else {
-      fpCalleeUsed.insert(regNO);
+      (void)fpCalleeUsed.insert(regNO);
     }
   }
 }
@@ -1346,10 +1346,10 @@ void GraphColorRegAllocator::PruneLrForSplit(LiveRange &lr, BB &bb, bool remove,
   if (bb.GetLoop() != nullptr) {
     /* With a def in loop, cannot prune that loop */
     if (defNum > 0) {
-      defInLoop.insert(bb.GetLoop());
+      (void)defInLoop.insert(bb.GetLoop());
     }
     /* bb in loop, need to make sure of loop carried dependency */
-    candidateInLoop.insert(bb.GetLoop());
+    (void)candidateInLoop.insert(bb.GetLoop());
   }
   for (auto pred : bb.GetPreds()) {
     if (FindNotIn(bb.GetLoopPreds(), pred)) {
@@ -1371,7 +1371,7 @@ void GraphColorRegAllocator::FindBBSharedInSplit(LiveRange &lr, std::set<CGFuncL
     if (bb->GetLoop() != nullptr && FindIn(candidateInLoop, bb->GetLoop())) {
       auto lu = lr.FindInLuMap(bb->GetId());
       if (lu != lr.EndOfLuMap() && lu->second->GetDefNum() > 0) {
-        defInLoop.insert(bb->GetLoop());
+        (void)defInLoop.insert(bb->GetLoop());
       }
     }
   };
@@ -1396,7 +1396,7 @@ void GraphColorRegAllocator::ComputeBBForNewSplit(LiveRange &newLr, LiveRange &o
   /* If a bb has a def and is in a loop, store that info. */
   std::set<CGFuncLoops*, CGFuncLoopCmp> defInLoop;
   std::set<BB*, SortedBBCmpFunc> smember;
-  ForEachBBArrElem(newLr.GetBBMember(), [this, &smember](uint32 bbID) { smember.insert(bbVec[bbID]); });
+  ForEachBBArrElem(newLr.GetBBMember(), [this, &smember](uint32 bbID) { (void)smember.insert(bbVec[bbID]); });
   for (auto bbIt = smember.rbegin(); bbIt != smember.rend(); ++bbIt) {
     BB *bb = *bbIt;
     if (bb->GetInternalFlag1() != 0) {
@@ -1476,7 +1476,7 @@ void GraphColorRegAllocator::FindUseForSplit(LiveRange &lr, SplitBBInfo &bbInfo,
       bb->SetInternalFlag2(true);
       if (bb->GetLoop() != nullptr) {
         /* bb in loop, need to make sure of loop carried dependency */
-        candidateInLoop.insert(bb->GetLoop());
+        (void)candidateInLoop.insert(bb->GetLoop());
       }
     } else {
       /* found a ref, no more removal of bb and preds. */
@@ -1490,7 +1490,7 @@ void GraphColorRegAllocator::FindUseForSplit(LiveRange &lr, SplitBBInfo &bbInfo,
 
   /* With a def in loop, cannot prune that loop */
   if (bb->GetLoop() != nullptr && defNum > 0) {
-    defInLoop.insert(bb->GetLoop());
+    (void)defInLoop.insert(bb->GetLoop());
   }
 
   for (auto succ : bb->GetSuccs()) {
@@ -1536,7 +1536,7 @@ void GraphColorRegAllocator::ComputeBBForOldSplit(LiveRange &newLr, LiveRange &o
   bool remove = true;
 
   std::set<BB*, SortedBBCmpFunc> smember;
-  ForEachBBArrElem(origLr.GetBBMember(), [this, &smember](uint32 bbID) { smember.insert(bbVec[bbID]); });
+  ForEachBBArrElem(origLr.GetBBMember(), [this, &smember](uint32 bbID) { (void)smember.insert(bbVec[bbID]); });
   ClearLrBBFlags(smember);
   for (auto bb : smember) {
     if (bb->GetInternalFlag1() != 0) {
@@ -1573,7 +1573,8 @@ void GraphColorRegAllocator::ComputeBBForOldSplit(LiveRange &newLr, LiveRange &o
  *  Side effect : Adding the new forbidden regs from bbAdded into
  *                conflictRegs if the LR can still be colored.
  */
-bool GraphColorRegAllocator::LrCanBeColored(LiveRange &lr, BB &bbAdded, std::unordered_set<regno_t> &conflictRegs) {
+bool GraphColorRegAllocator::LrCanBeColored(const LiveRange &lr, const BB &bbAdded,
+                                            std::unordered_set<regno_t> &conflictRegs) {
   RegType type = lr.GetRegType();
 
   std::unordered_set<regno_t> newConflict;
@@ -1589,7 +1590,7 @@ bool GraphColorRegAllocator::LrCanBeColored(LiveRange &lr, BB &bbAdded, std::uno
     if (IsBitArrElemSet(conflictLr->GetBBMember(), bbAdded.GetId())) {
       regno_t confReg = conflictLr->GetAssignedRegNO();
       if ((confReg > 0) && FindNotIn(conflictRegs, confReg) && !lr.GetPregveto(confReg)) {
-        newConflict.insert(confReg);
+        (void)newConflict.insert(confReg);
       }
     } else if (conflictLr->GetSplitLr() != nullptr &&
                IsBitArrElemSet(conflictLr->GetSplitLr()->GetBBMember(), bbAdded.GetId())) {
@@ -1599,7 +1600,7 @@ bool GraphColorRegAllocator::LrCanBeColored(LiveRange &lr, BB &bbAdded, std::uno
        */
       regno_t confReg = conflictLr->GetSplitLr()->GetAssignedRegNO();
       if ((confReg > 0) && FindNotIn(conflictRegs, confReg) && !lr.GetPregveto(confReg)) {
-        newConflict.insert(confReg);
+        (void)newConflict.insert(confReg);
       }
     }
   };
@@ -1618,7 +1619,7 @@ bool GraphColorRegAllocator::LrCanBeColored(LiveRange &lr, BB &bbAdded, std::uno
 
   if (canColor) {
     for (auto regNO : newConflict) {
-      conflictRegs.insert(regNO);
+      (void)conflictRegs.insert(regNO);
     }
   }
 
@@ -1666,7 +1667,7 @@ void GraphColorRegAllocator::GetAllLrMemberLoops(LiveRange &lr, std::set<CGFuncL
     BB *bb = bbVec[bbID];
     CGFuncLoops *loop = bb->GetLoop();
     if (loop != nullptr) {
-      loops.insert(loop);
+      (void)loops.insert(loop);
     }
   };
   ForEachBBArrElem(lr.GetBBMember(), GetLrMemberFunc);
@@ -1716,7 +1717,7 @@ bool GraphColorRegAllocator::SplitLrFindCandidateLr(LiveRange &lr, LiveRange &ne
     LogInfo::MapleLogger() << "start split lr for vreg " << lr.GetRegNO() << "\n";
   }
   std::set<BB*, SortedBBCmpFunc> smember;
-  ForEachBBArrElem(lr.GetBBMember(), [&smember, this](uint32 bbID) { smember.insert(bbVec[bbID]); });
+  ForEachBBArrElem(lr.GetBBMember(), [&smember, this](uint32 bbID) { (void)smember.insert(bbVec[bbID]); });
   for (auto bb : smember) {
     if (!LrCanBeColored(lr, *bb, conflictRegs)) {
       break;
@@ -2356,7 +2357,7 @@ MemOperand *GraphColorRegAllocator::GetConsistentReuseMem(const uint64 *conflict
         break;
       }
       if (lrVec[regNO] != nullptr) {
-        sconflict.insert(lrVec[regNO]);
+        (void)sconflict.insert(lrVec[regNO]);
       }
     }
   }
@@ -2418,7 +2419,7 @@ MemOperand *GraphColorRegAllocator::GetReuseMem(uint32 vregNO, uint32 size, RegT
   auto updateMemOpnd = [&usedMemOpnd, this](regno_t regNO) {
     LiveRange *lrInner = lrVec[regNO];
     if (lrInner->GetSpillMem() != nullptr) {
-      usedMemOpnd.insert(lrInner->GetSpillMem());
+      (void)usedMemOpnd.insert(lrInner->GetSpillMem());
     }
   };
   ForEachRegArrElem(conflict, updateMemOpnd);
@@ -2649,11 +2650,12 @@ bool GraphColorRegAllocator::SetAvailableSpillReg(std::unordered_set<regno_t> &c
   return false;
 }
 
-void GraphColorRegAllocator::CollectCannotUseReg(std::unordered_set<regno_t> &cannotUseReg, LiveRange &lr, Insn &insn) {
+void GraphColorRegAllocator::CollectCannotUseReg(std::unordered_set<regno_t> &cannotUseReg, const LiveRange &lr,
+                                                 Insn &insn) {
   /* Find the bb in the conflict LR that actually conflicts with the current bb. */
   for (regno_t regNO = kRinvalid; regNO < kMaxRegNum; ++regNO) {
     if (lr.GetPregveto(regNO)) {
-      cannotUseReg.insert(regNO);
+      (void)cannotUseReg.insert(regNO);
     }
   }
   auto updateCannotUse = [&insn, &cannotUseReg, this](regno_t regNO) {
@@ -2667,7 +2669,7 @@ void GraphColorRegAllocator::CollectCannotUseReg(std::unordered_set<regno_t> &ca
           conflictLr->GetNumCall()) {
         return;
       }
-      cannotUseReg.insert(conflictLr->GetAssignedRegNO());
+      (void)cannotUseReg.insert(conflictLr->GetAssignedRegNO());
     }
   };
   ForEachRegArrElem(lr.GetBBConflict(), updateCannotUse);
@@ -2675,7 +2677,7 @@ void GraphColorRegAllocator::CollectCannotUseReg(std::unordered_set<regno_t> &ca
   BBAssignInfo *bbInfo = bbRegInfo[insn.GetBB()->GetId()];
   if (bbInfo != nullptr) {
     for (const auto &regMapPair : bbInfo->GetRegMap()) {
-      cannotUseReg.insert(regMapPair.second);
+      (void)cannotUseReg.insert(regMapPair.second);
     }
   }
 #endif  /* USE_LRA */
diff --git a/src/maple_be/src/cg/aarch64/aarch64_dependence.cpp b/src/maple_be/src/cg/aarch64/aarch64_dependence.cpp
index 1ad74e5b745ce22ea3ba76fa940591f9e336213f..36f404e7dd02f8d5f8f682f1c8d23c6daa538a01 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_dependence.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_dependence.cpp
@@ -292,7 +292,7 @@ void AArch64DepAnalysis::CombineDependence(DepNode &firstNode, DepNode &secondNo
     if (predLink->GetDepType() == kDependenceTypeTrue) {
       predLink->SetLatency(mad.GetLatency(*predLink->GetFrom().GetInsn(), *firstNode.GetInsn()));
     }
-    uniqueNodes.insert(&predLink->GetFrom());
+    (void)uniqueNodes.insert(&predLink->GetFrom());
   }
   for (auto predLink : secondNode.GetPreds()) {
     if (&predLink->GetFrom() != &firstNode) {
@@ -307,7 +307,7 @@ void AArch64DepAnalysis::CombineDependence(DepNode &firstNode, DepNode &secondNo
     if (succLink->GetDepType() == kDependenceTypeTrue) {
       succLink->SetLatency(mad.GetLatency(*succLink->GetFrom().GetInsn(), *firstNode.GetInsn()));
     }
-    uniqueNodes.insert(&(succLink->GetTo()));
+    (void)uniqueNodes.insert(&(succLink->GetTo()));
   }
   for (auto succLink : secondNode.GetSuccs()) {
     if (uniqueNodes.insert(&(succLink->GetTo())).second) {
@@ -520,7 +520,7 @@ void AArch64DepAnalysis::BuildDepsMemBar(Insn &insn) {
 /* A pseudo separator node depends all the other nodes. */
 void AArch64DepAnalysis::BuildDepsSeparator(DepNode &newSepNode, MapleVector<DepNode*> &nodes) {
   uint32 nextSepIndex = (separatorIndex + kMaxDependenceNum) < nodes.size() ? (separatorIndex + kMaxDependenceNum)
-                                                                            : nodes.size() - 1;
+                                                                            : static_cast<uint32>(nodes.size() - 1);
   newSepNode.ReservePreds(nextSepIndex - separatorIndex);
   newSepNode.ReserveSuccs(nextSepIndex - separatorIndex);
   for (uint32 i = separatorIndex; i < nextSepIndex; ++i) {
diff --git a/src/maple_be/src/cg/aarch64/aarch64_ebo.cpp b/src/maple_be/src/cg/aarch64/aarch64_ebo.cpp
index 1fec18814d533c98eb12edcf10d4e2eee6f2d8ca..24a0f53474a2c4601c3271ddc13222a59b3f3d69 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_ebo.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_ebo.cpp
@@ -736,7 +736,8 @@ bool AArch64Ebo::SpecialSequence(Insn &insn, const MapleVector<OpndInfo*> &origI
             auto &res1 = static_cast<RegOperand&>(insn1->GetOperand(kInsnFirstOpnd));
             if (RegistersIdentical(res1, *op1) && RegistersIdentical(res1, res2) &&
                 (GetOpndInfo(base2, -1) != nullptr) && !GetOpndInfo(base2, -1)->redefined) {
-              immVal = imm0Val + imm1.GetValue() + (static_cast<uint64>(immOpnd2.GetValue()) << kMaxImmVal12Bits);
+              immVal = imm0Val + imm1.GetValue() +
+                       static_cast<int64>(static_cast<uint64>(immOpnd2.GetValue()) << kMaxImmVal12Bits);
               op1 = &base2;
             } else {
               return false;
@@ -748,7 +749,8 @@ bool AArch64Ebo::SpecialSequence(Insn &insn, const MapleVector<OpndInfo*> &origI
           /* multiple of 4 and 8 */
           const int multiOfFour = 4;
           const int multiOfEight = 8;
-          is64bits = is64bits && (!static_cast<AArch64Insn&>(insn).CheckRefField(kInsnFirstOpnd, false));
+          is64bits = is64bits &&
+                     (!static_cast<AArch64Insn&>(insn).CheckRefField(static_cast<size_t>(kInsnFirstOpnd), false));
           if ((!is64bits && (immVal < kStrLdrImm32UpperBound) && (immVal % multiOfFour == 0)) ||
               (is64bits && (immVal < kStrLdrImm64UpperBound) && (immVal % multiOfEight == 0))) {
             /* Reserved physicalReg beforeRA */
diff --git a/src/maple_be/src/cg/aarch64/aarch64_emitter.cpp b/src/maple_be/src/cg/aarch64/aarch64_emitter.cpp
index 000278718e2ecafac1fa7f0473f6ed814859ac61..4358be285dbfb25f2e3253d424c3e30e22e685f3 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_emitter.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_emitter.cpp
@@ -71,8 +71,8 @@ void AArch64AsmEmitter::EmitMethodDesc(FuncEmitInfo &funcEmitInfo, Emitter &emit
   AArch64CGFunc &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
   IntrinsiccallNode *cleanEANode = aarchCGFunc.GetCleanEANode();
   if (cleanEANode != nullptr) {
-    refNum += cleanEANode->NumOpnds();
-    refOffset -= cleanEANode->NumOpnds() * kIntregBytelen;
+    refNum += static_cast<uint32>(cleanEANode->NumOpnds());
+    refOffset -= static_cast<int32>(cleanEANode->NumOpnds() * kIntregBytelen);
   }
   emitter.Emit("\t.short ").Emit(refOffset).Emit("\n");
   emitter.Emit("\t.short ").Emit(refNum).Emit("\n");
@@ -90,8 +90,8 @@ void AArch64AsmEmitter::EmitFastLSDA(FuncEmitInfo &funcEmitInfo) {
    * .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 .L." + funcName + ".");
+  (void)emitter->Emit("\t.word 0xFFFFFFFF\n");
+  (void)emitter->Emit("\t.word .L." + funcName + ".");
   if (aarchCGFunc.NeedCleanup()) {
     emitter->Emit(cgFunc.GetCleanupLabel()->GetLabelIdx());
   } else {
@@ -163,9 +163,9 @@ void AArch64AsmEmitter::EmitFullLSDA(FuncEmitInfo &funcEmitInfo) {
         cleaupCode.SetEndOffset(cgFunc.GetCleanupLabel());
         emitter->EmitLabelPair(funcName, cleaupCode);
       } else if (cgFunc.GetFunction().IsJava()) {
-        ASSERT(!cgFunc.GetExitBBsVec().empty(), "exitbbsvec is empty in AArch64AsmEmitter::EmitFullLSDA");
-        emitter->Emit(".L." + funcName).Emit(".").Emit(cgFunc.GetExitBB(0)->GetLabIdx());
-        emitter->Emit(" - .L." + funcName).Emit(".").Emit(cgFunc.GetStartLabel()->GetLabelIdx()).Emit("\n");
+        ASSERT(!cgFunc.GetExitBBsVec().empty(), "exitbbsvec is empty in AArch64Emitter::EmitFullLSDA");
+        (void)emitter->Emit(".L." + funcName).Emit(".").Emit(cgFunc.GetExitBB(0)->GetLabIdx());
+        (void)emitter->Emit(" - .L." + funcName).Emit(".").Emit(cgFunc.GetStartLabel()->GetLabelIdx()).Emit("\n");
       } else {
         emitter->Emit("0\n");
       }
@@ -201,8 +201,8 @@ void AArch64AsmEmitter::EmitFullLSDA(FuncEmitInfo &funcEmitInfo) {
       emitter->EmitLabelPair(funcName, cleaupCode);
     } else {
       ASSERT(!cgFunc.GetExitBBsVec().empty(), "exitbbsvec is empty in AArch64AsmEmitter::EmitFullLSDA");
-      emitter->Emit(".L." + funcName).Emit(".").Emit(cgFunc.GetExitBB(0)->GetLabIdx());
-      emitter->Emit(" - .L." + funcName).Emit(".").Emit(cgFunc.GetStartLabel()->GetLabelIdx()).Emit("\n");
+      (void)emitter->Emit(".L." + funcName).Emit(".").Emit(cgFunc.GetExitBB(0)->GetLabIdx());
+      (void)emitter->Emit(" - .L." + funcName).Emit(".").Emit(cgFunc.GetStartLabel()->GetLabelIdx()).Emit("\n");
     }
     emitter->Emit("\t.uleb128 0\n");
     if (!cgFunc.GetFunction().IsJava()) {
@@ -262,10 +262,10 @@ void AArch64AsmEmitter::EmitBBHeaderLabel(FuncEmitInfo &funcEmitInfo, const std:
     currCG->IncreaseLabelOrderCnt();
   }
   if (currCG->GenerateVerboseCG()) {
-    emitter.Emit(".L.").Emit(name).Emit(".").Emit(labIdx).Emit(":\t//label order ").Emit(label.GetLabelOrder());
+    (void)emitter.Emit(".L.").Emit(name).Emit(".").Emit(labIdx).Emit(":\t//label order ").Emit(label.GetLabelOrder());
     emitter.Emit("\n");
   } else {
-    emitter.Emit(".L.").Emit(name).Emit(".").Emit(labIdx).Emit(":\n");
+    (void)emitter.Emit(".L.").Emit(name).Emit(".").Emit(labIdx).Emit(":\n");
   }
 }
 
@@ -288,40 +288,40 @@ void AArch64AsmEmitter::Run(FuncEmitInfo &funcEmitInfo) {
   Emitter &emitter = *currCG->GetEmitter();
   // insert for  __cxx_global_var_init
   if (cgFunc.GetName() == "__cxx_global_var_init") {
-    emitter.Emit("\t.section\t.init_array,\"aw\"\n");
-    emitter.Emit("\t.quad\t").Emit(cgFunc.GetName()).Emit("\n");
+    (void)emitter.Emit("\t.section\t.init_array,\"aw\"\n");
+    (void)emitter.Emit("\t.quad\t").Emit(cgFunc.GetName()).Emit("\n");
   }
   emitter.Emit("\n");
   EmitMethodDesc(funcEmitInfo, emitter);
   /* emit java code to the java section. */
   if (cgFunc.GetFunction().IsJava()) {
     std::string sectionName = namemangler::kMuidJavatextPrefixStr;
-    emitter.Emit("\t.section  ." + sectionName + ",\"ax\"\n");
+    (void)emitter.Emit("\t.section  ." + sectionName + ",\"ax\"\n");
   } else {
-    emitter.Emit("\t.text\n");
+    (void)emitter.Emit("\t.text\n");
   }
-  emitter.Emit("\t.align 2\n");
+  (void)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());
 
 
   std::string funcStName = funcSt->GetName();
   if (funcSt->GetFunction()->GetAttr(FUNCATTR_weak)) {
-    emitter.Emit("\t.weak\t" + funcStName + "\n");
-    emitter.Emit("\t.hidden\t" + funcStName + "\n");
+    (void)emitter.Emit("\t.weak\t" + funcStName + "\n");
+    (void)emitter.Emit("\t.hidden\t" + funcStName + "\n");
   } else if (funcSt->GetFunction()->GetAttr(FUNCATTR_local)) {
-    emitter.Emit("\t.local\t" + funcStName + "\n");
+    (void)emitter.Emit("\t.local\t" + funcStName + "\n");
   } else {
     bool isExternFunction = false;
-    emitter.Emit("\t.globl\t").Emit(funcSt->GetName()).Emit("\n");
+    (void)emitter.Emit("\t.globl\t").Emit(funcSt->GetName()).Emit("\n");
     if (!currCG->GetMIRModule()->IsCModule() || !isExternFunction) {
-      emitter.Emit("\t.hidden\t").Emit(funcSt->GetName()).Emit("\n");
+      (void)emitter.Emit("\t.hidden\t").Emit(funcSt->GetName()).Emit("\n");
     }
   }
-  emitter.Emit("\t.type\t" + funcStName + ", %function\n");
+  (void)emitter.Emit("\t.type\t" + funcStName + ", %function\n");
   /* add these messege , solve the simpleperf tool error */
   EmitRefToMethodDesc(funcEmitInfo, emitter);
-  emitter.Emit(funcStName + ":\n");
+  (void)emitter.Emit(funcStName + ":\n");
   /* if the last  insn is call, then insert nop */
   bool found = false;
   FOR_ALL_BB_REV(bb, &aarchCGFunc) {
@@ -355,9 +355,9 @@ void AArch64AsmEmitter::Run(FuncEmitInfo &funcEmitInfo) {
   }
   if (CGOptions::IsMapleLinker()) {
     /* Emit a label for calculating method size */
-    emitter.Emit(".Label.end." + funcStName + ":\n");
+    (void)emitter.Emit(".Label.end." + funcStName + ":\n");
   }
-  emitter.Emit("\t.size\t" + funcStName + ", .-").Emit(funcStName + "\n");
+  (void)emitter.Emit("\t.size\t" + funcStName + ", .-").Emit(funcStName + "\n");
 
   EHFunc *ehFunc = cgFunc.GetEHFunc();
   /* emit LSDA */
@@ -368,8 +368,8 @@ void AArch64AsmEmitter::Run(FuncEmitInfo &funcEmitInfo) {
     } else if (ehFunc->NeedFullLSDA()) {
       LSDAHeader *lsdaHeader = ehFunc->GetLSDAHeader();
       /*  .word .Label.lsda_label-func_start_label */
-      emitter.Emit("\t.word .L." + funcName).Emit(".").Emit(lsdaHeader->GetLSDALabel()->GetLabelIdx());
-      emitter.Emit("-.L." + funcName).Emit(".").Emit(cgFunc.GetStartLabel()->GetLabelIdx()).Emit("\n");
+      (void)emitter.Emit("\t.word .L." + funcName).Emit(".").Emit(lsdaHeader->GetLSDALabel()->GetLabelIdx());
+      (void)emitter.Emit("-.L." + funcName).Emit(".").Emit(cgFunc.GetStartLabel()->GetLabelIdx()).Emit("\n");
       emitter.IncreaseJavaInsnCount();
     } else if (ehFunc->NeedFastLSDA()) {
       EmitFastLSDA(funcEmitInfo);
@@ -438,8 +438,8 @@ void AArch64AsmEmitter::Run(FuncEmitInfo &funcEmitInfo) {
     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.L." + funcName).Emit(".").Emit(lblConst->GetValue());
-      emitter.Emit(" - " + st->GetName() + "\n");
+      (void)emitter.Emit("\t.quad\t.L." + funcName).Emit(".").Emit(lblConst->GetValue());
+      (void)emitter.Emit(" - " + st->GetName() + "\n");
       emitter.IncreaseJavaInsnCount(kQuadInsnCount);
     }
   }
diff --git a/src/maple_be/src/cg/aarch64/aarch64_global.cpp b/src/maple_be/src/cg/aarch64/aarch64_global.cpp
index 94840512258340ffbb89f0e83e8ee205adabe0c3..62825e05d1baed6db1857ea79621e28f71aec82c 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_global.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_global.cpp
@@ -274,7 +274,7 @@ void ForwardPropPattern::Optimize(Insn &insn) {
         if (((useInsn->GetMachineOpcode() == MOP_xmovrr) || (useInsn->GetMachineOpcode() == MOP_wmovrr)) &&
             (static_cast<RegOperand&>(useInsn->GetOperand(kInsnSecondOpnd)).IsVirtualRegister()) &&
             (static_cast<RegOperand&>(useInsn->GetOperand(kInsnFirstOpnd)).IsVirtualRegister())) {
-          modifiedBB.insert(useInsn->GetBB());
+          (void)modifiedBB.insert(useInsn->GetBB());
         }
         cgFunc.GetRD()->InitGenUse(*useInsn->GetBB(), false);
       } else if (opnd.IsMemoryAccessOperand()) {
@@ -512,7 +512,7 @@ void BackPropPattern::Run() {
         if (!CheckCondition(*insn)) {
           continue;
         }
-        modifiedBB.insert(bb);
+        (void)modifiedBB.insert(bb);
         Optimize(*insn);
       }
       cgFunc.GetRD()->UpdateInOut(*bb);
@@ -727,7 +727,7 @@ uint32 RedundantUxtPattern::GetMaximumValidBit(Insn &insn, uint8 index, InsnSet
       continue;
     }
 
-    visitedInsn.insert(defInsn);
+    (void)visitedInsn.insert(defInsn);
     MOperator mOp = defInsn->GetMachineOpcode();
     if ((mOp == MOP_wmovrr) || (mOp == MOP_xmovrr)) {
       validBit = GetMaximumValidBit(*defInsn, 1, visitedInsn);
diff --git a/src/maple_be/src/cg/aarch64/aarch64_insn.cpp b/src/maple_be/src/cg/aarch64/aarch64_insn.cpp
index 7b2fbcc9d02ba9583f63e1f464e8c09f009395f4..42321b98af7daf9c4a024e068aa260ecadd79d9c 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_insn.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_insn.cpp
@@ -651,7 +651,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());
+    (void)emitter.Emit(namemangler::kPtrPrefixStr + stImmOpnd->GetName());
     emitter.Emit("\n");
 
     /* ldr     x3, [x3, #:lo12:_PTR__cinf_Ljava_2Futil_2Fconcurrent_2Fatomic_2FAtomicInteger_3B] */
@@ -660,7 +660,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());
+    (void)emitter.Emit(namemangler::kPtrPrefixStr + stImmOpnd->GetName());
     emitter.Emit("]\n");
   }
   /* emit "ldr  x0,[x0,#48]" */
@@ -1019,7 +1019,7 @@ void AArch64Insn::Emit(const CG &cg, Emitter &emitter) const {
     }
   }
 
-  bool isRefField = (opndSize == 0) ? false : CheckRefField(seq[0], true);
+  bool isRefField = (opndSize == 0) ? false : CheckRefField(static_cast<size_t>(static_cast<uint>(seq[0])), true);
   if (mOp != MOP_comment) {
     emitter.IncreaseJavaInsnCount();
   }
@@ -1075,7 +1075,7 @@ void AArch64Insn::Emit(const CG &cg, Emitter &emitter) const {
   if (cg.GenerateVerboseCG() || (cg.GenerateVerboseAsm() && mOp == MOP_comment)) {
     const char *comment = GetComment().c_str();
     if (comment != nullptr && strlen(comment) > 0) {
-      emitter.Emit("\t\t// ").Emit(comment);
+      (void)emitter.Emit("\t\t// ").Emit(comment);
     }
   }
 
@@ -1083,7 +1083,7 @@ void AArch64Insn::Emit(const CG &cg, Emitter &emitter) const {
 }
 
 /* set opnd0 ref-field flag, so we can emit the right register */
-bool AArch64Insn::CheckRefField(int32 opndIndex, bool isEmit) const {
+bool AArch64Insn::CheckRefField(size_t opndIndex, bool isEmit) const {
   if (IsAccessRefField() && AccessMem()) {
     Operand *opnd0 = opnds[opndIndex];
     if (opnd0->IsRegister()) {
diff --git a/src/maple_be/src/cg/aarch64/aarch64_peep.cpp b/src/maple_be/src/cg/aarch64/aarch64_peep.cpp
index 637ca7bc0cd4d8eeab71e8734729da390d66ae15..4128e3b2ac24b544592e454a12daa84b7854660e 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_peep.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_peep.cpp
@@ -2462,11 +2462,13 @@ void ComputationTreeAArch64::Run(BB &bb, Insn &insn) {
     if (lsl.GetShiftAmount() == lslShiftAmountCaseA) {
       sxtw = &aarch64CGFunc->CreateExtendShiftOperand(ExtendShiftOperand::kSXTW,
                                                       lslShiftAmountCaseA + 1, lslBitLenth);
-      imm = &aarch64CGFunc->CreateImmOperand(oriAddEnd + (1ULL << lslShiftAmountCaseA), kMaxImmVal12Bits, true);
+      imm = &aarch64CGFunc->CreateImmOperand(oriAddEnd + static_cast<int64>(1ULL << lslShiftAmountCaseA),
+                                             kMaxImmVal12Bits, true);
     } else if (lsl.GetShiftAmount() == lslShiftAmountCaseB) {
       sxtw = &aarch64CGFunc->CreateExtendShiftOperand(ExtendShiftOperand::kSXTW,
                                                       lslShiftAmountCaseB + 1, lslBitLenth);
-      imm = &aarch64CGFunc->CreateImmOperand(oriAddEnd + (1ULL << lslShiftAmountCaseB), kMaxImmVal12Bits, true);
+      imm = &aarch64CGFunc->CreateImmOperand(oriAddEnd + static_cast<int64>(1ULL << lslShiftAmountCaseB),
+                                             kMaxImmVal12Bits, true);
     }
     Insn &newInsn = cgFunc.GetCG()->BuildInstruction<AArch64Insn>(MOP_xxwaddrrre,
                                                                   sxtwInsn->GetOperand(kInsnFirstOpnd),
diff --git a/src/maple_be/src/cg/aarch64/aarch64_reaching.cpp b/src/maple_be/src/cg/aarch64/aarch64_reaching.cpp
index 48f906e0dcca49127195f8d1851b22749baacf67..9fec2c150fbaeaec352d6d58dd8ae723b02b2e54 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_reaching.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_reaching.cpp
@@ -244,7 +244,7 @@ void AArch64ReachingDefinition::FindRegDefInBB(uint32 regNO, BB &bb, InsnSet &de
 
     const AArch64MD *md = &AArch64CG::kMd[static_cast<AArch64Insn*>(insn)->GetMachineOpcode()];
     if (insn->IsCall() && IsCallerSavedReg(regNO)) {
-      defInsnSet.insert(insn);
+      (void)defInsnSet.insert(insn);
       continue;
     }
 
@@ -267,12 +267,12 @@ void AArch64ReachingDefinition::FindRegDefInBB(uint32 regNO, BB &bb, InsnSet &de
           if (memOpnd.GetAddrMode() == AArch64MemOperand::kAddrModeBOi &&
               (memOpnd.IsPostIndexed() || memOpnd.IsPreIndexed()) &&
               base->GetRegisterNumber() == regNO) {
-            defInsnSet.insert(insn);
+            (void)defInsnSet.insert(insn);
           }
         }
       } else if ((opnd.IsConditionCode() || opnd.IsRegister()) &&
                  (static_cast<RegOperand&>(opnd).GetRegisterNumber() == regNO)) {
-        defInsnSet.insert(insn);
+        (void)defInsnSet.insert(insn);
       }
     }
   }
@@ -361,7 +361,7 @@ void AArch64ReachingDefinition::FindMemDefInBB(uint32 offset, BB &bb, InsnSet &d
 
     if (insn->IsCall()) {
       if (CallInsnClearDesignateStackRef(*insn, offset)) {
-        defInsnSet.insert(insn);
+        (void)defInsnSet.insert(insn);
       }
       continue;
     }
@@ -385,11 +385,11 @@ void AArch64ReachingDefinition::FindMemDefInBB(uint32 offset, BB &bb, InsnSet &d
         ASSERT(memOpnd.GetOffsetImmediate() != nullptr, "offset must be a immediate value");
         int64 memOffset = memOpnd.GetOffsetImmediate()->GetOffsetValue();
         if (offset == memOffset) {
-          defInsnSet.insert(insn);
+          (void)defInsnSet.insert(insn);
           break;
         }
         if (insn->IsStorePair() && offset == memOffset + GetEachMemSizeOfPair(insn->GetMachineOpcode())) {
-          defInsnSet.insert(insn);
+          (void)defInsnSet.insert(insn);
           break;
         }
       }
@@ -557,7 +557,7 @@ bool AArch64ReachingDefinition::FindRegUseBetweenInsn(uint32 regNO, Insn *startI
           RegOperand *regOpnd = static_cast<RegOperand*>(listElem);
           ASSERT(regOpnd != nullptr, "parameter operand must be RegOperand");
           if (regNO == regOpnd->GetRegisterNumber()) {
-            regUseInsnSet.insert(insn);
+            (void)regUseInsnSet.insert(insn);
           }
         }
         continue;
@@ -589,16 +589,16 @@ bool AArch64ReachingDefinition::FindRegUseBetweenInsn(uint32 regNO, Insn *startI
         RegOperand *index = memOpnd.GetIndexRegister();
         if ((base != nullptr && base->GetRegisterNumber() == regNO) ||
             (index != nullptr && index->GetRegisterNumber() == regNO)) {
-          regUseInsnSet.insert(insn);
+          (void)regUseInsnSet.insert(insn);
         }
       } else if (opnd.IsConditionCode()) {
         Operand &rflagOpnd = cgFunc->GetOrCreateRflag();
         RegOperand &rflagReg = static_cast<RegOperand&>(rflagOpnd);
         if (rflagReg.GetRegisterNumber() == regNO) {
-          regUseInsnSet.insert(insn);
+          (void)regUseInsnSet.insert(insn);
         }
       } else if (opnd.IsRegister() && (static_cast<RegOperand&>(opnd).GetRegisterNumber() == regNO)) {
-        regUseInsnSet.insert(insn);
+        (void)regUseInsnSet.insert(insn);
       }
     }
 
@@ -671,9 +671,9 @@ bool AArch64ReachingDefinition::FindMemUseBetweenInsn(uint32 offset, Insn *start
       }
 
       if (offset == memOffset) {
-        memUseInsnSet.insert(insn);
+        (void)memUseInsnSet.insert(insn);
       } else if (insn->IsLoadPair() && offset == memOffset + GetEachMemSizeOfPair(insn->GetMachineOpcode())) {
-        memUseInsnSet.insert(insn);
+        (void)memUseInsnSet.insert(insn);
       }
     }
 
diff --git a/src/maple_be/src/cg/aarch64/aarch64_reg_alloc.cpp b/src/maple_be/src/cg/aarch64/aarch64_reg_alloc.cpp
index d83c1cd9e6071ecf3156e882524cf037111cf975..f2b314fc8dc94258d8ef20555a2821e278cc0b2a 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_reg_alloc.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_reg_alloc.cpp
@@ -35,7 +35,7 @@ Operand *AArch64RegAllocator::HandleRegOpnd(Operand &opnd) {
   }
   if (!regOpnd.IsVirtualRegister()) {
     availRegSet[regOpnd.GetRegisterNumber()] = false;
-    liveReg.insert(regOpnd.GetRegisterNumber());
+    (void)liveReg.insert(regOpnd.GetRegisterNumber());
     return static_cast<AArch64RegOperand*>(&regOpnd);
   }
   auto regMapIt = regMap.find(regOpnd.GetRegisterNumber());
@@ -44,12 +44,12 @@ Operand *AArch64RegAllocator::HandleRegOpnd(Operand &opnd) {
     ASSERT(AArch64isa::IsPhysicalRegister(regMapIt->second), "must be a physical register");
     AArch64reg newRegNO = regMapIt->second;
     availRegSet[newRegNO] = false;  /* make sure the real register can not be allocated and live */
-    liveReg.insert(newRegNO);
-    allocatedSet.insert(&opnd);
+    (void)liveReg.insert(newRegNO);
+    (void)allocatedSet.insert(&opnd);
     return &a64CGFunc->GetOrCreatePhysicalRegisterOperand(newRegNO, regOpnd.GetSize(), regOpnd.GetRegisterType());
   }
   if (AllocatePhysicalRegister(regOpnd)) {
-    allocatedSet.insert(&opnd);
+    (void)allocatedSet.insert(&opnd);
     auto regMapItSecond = regMap.find(regOpnd.GetRegisterNumber());
     ASSERT(regMapItSecond != regMap.end(), " ERROR: can not find register number in regmap ");
     return &a64CGFunc->GetOrCreatePhysicalRegisterOperand(regMapItSecond->second, regOpnd.GetSize(),
@@ -95,7 +95,7 @@ Operand *AArch64RegAllocator::HandleMemOpnd(Operand &opnd) {
       ASSERT(false, "ERROR: should not run here");
       break;
   }
-  allocatedSet.insert(&opnd);
+  (void)allocatedSet.insert(&opnd);
   return memOpnd;
 }
 
@@ -148,7 +148,7 @@ Operand *AArch64RegAllocator::AllocDestOpnd(Operand &opnd, const Insn &insn) {
                                                             regOpnd.GetRegisterType());
     }
   }
-  allocatedSet.insert(&opnd);
+  (void)allocatedSet.insert(&opnd);
   return &a64CGFunc->GetOrCreatePhysicalRegisterOperand(regMapIt->second, regOpnd.GetSize(), regOpnd.GetRegisterType());
 }
 
@@ -199,7 +199,7 @@ void AArch64RegAllocator::AllocHandleCallee(Insn &insn, const AArch64MD &md) {
       ASSERT(!regOpnd->IsVirtualRegister(), "not be a virtual register");
       auto physicalReg = static_cast<AArch64reg>(regOpnd->GetRegisterNumber());
       availRegSet[physicalReg] = false;
-      liveReg.insert(physicalReg);
+      (void)liveReg.insert(physicalReg);
       srcOpndsNew->PushOpnd(
           a64CGFunc->GetOrCreatePhysicalRegisterOperand(physicalReg, regOpnd->GetSize(), regOpnd->GetRegisterType()));
     }
@@ -329,7 +329,7 @@ bool AArch64RegAllocator::AllocatePhysicalRegister(RegOperand &opnd) {
 
     regMap[opnd.GetRegisterNumber()] = AArch64reg(reg);
     availRegSet[reg] = false;
-    liveReg.insert(reg);  /* this register is live now */
+    (void)liveReg.insert(reg);  /* this register is live now */
     return true;
   }
   return false;
@@ -586,7 +586,7 @@ bool DefaultO0RegAllocator::AllocateRegisters() {
           auto &regOpnd = static_cast<RegOperand&>(opnd);
           AArch64reg reg = regMap[regOpnd.GetRegisterNumber()];
           availRegSet[reg] = false;
-          liveReg.insert(reg);  /* this register is live now */
+          (void)liveReg.insert(reg);  /* this register is live now */
           insn->SetOperand(i, a64CGFunc->GetOrCreatePhysicalRegisterOperand(reg, regOpnd.GetSize(),
                                                                             regOpnd.GetRegisterType()));
         } else {
diff --git a/src/maple_be/src/cg/aarch64/aarch64_schedule.cpp b/src/maple_be/src/cg/aarch64/aarch64_schedule.cpp
index 9f5ac140529edef422400176c561df4a0c57a8f3..5ddfdaf71b06f5e932c556f44ef702014ecda367 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_schedule.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_schedule.cpp
@@ -285,7 +285,7 @@ uint32 AArch64Schedule::ComputeEstart(uint32 cycle) {
   ASSERT(nodes[maxIndex]->GetType() == kNodeTypeSeparator,
          "CG internal error, nodes[maxIndex] should be a separator node.");
 
-  readyNodes.insert(readyNodes.begin(), readyList.begin(), readyList.end());
+  (void)readyNodes.insert(readyNodes.begin(), readyList.begin(), readyList.end());
 
   uint32 maxEstart = cycle;
   for (uint32 i = lastSeparatorIndex; i <= maxIndex; ++i) {
@@ -681,7 +681,7 @@ uint32 AArch64Schedule::DoSchedule() {
   ASSERT(scheduleInfo.SizeOfScheduledNodes() == nodes.size(), "CG internal error, Not all nodes scheduled.");
 
   nodes.clear();
-  nodes.insert(nodes.begin(), scheduleInfo.GetScheduledNodes().begin(), scheduleInfo.GetScheduledNodes().end());
+  (void)nodes.insert(nodes.begin(), scheduleInfo.GetScheduledNodes().begin(), scheduleInfo.GetScheduledNodes().end());
   /* the second to last node is the true last node, because the last is kNodeTypeSeparator node */
   ASSERT(nodes.size() - 2 >= 0, "size of nodes should be greater than or equal 2");
   return (nodes[nodes.size() - 2]->GetSchedCycle());
diff --git a/src/maple_be/src/cg/cg.cpp b/src/maple_be/src/cg/cg.cpp
index 26f42af98453ea5a47aa86f46af14f3afb0d110c..8a577f25f445f2c7e3405e6a1348ba1841dd8c2f 100644
--- a/src/maple_be/src/cg/cg.cpp
+++ b/src/maple_be/src/cg/cg.cpp
@@ -59,7 +59,7 @@ void CG::GenExtraTypeMetadata(const std::string &classListFileName, const std::s
         continue;  /* Skip duplicated class definitions. */
       }
 
-      visited.insert(name);
+      (void)visited.insert(name);
       classesToGenerate.emplace_back(classType);
     }
   } else {
diff --git a/src/maple_be/src/cg/cg_cfg.cpp b/src/maple_be/src/cg/cg_cfg.cpp
index 02cd4347d39c6faf4e9070984c223e9fe9142f67..7315b222b8a78e6117346cb718b82f147d3a00e7 100644
--- a/src/maple_be/src/cg/cg_cfg.cpp
+++ b/src/maple_be/src/cg/cg_cfg.cpp
@@ -278,20 +278,20 @@ void CGCFG::FindAndMarkUnreachable(CGFunc &func) {
   while (!toBeAnalyzedBBs.empty()) {
     bb = toBeAnalyzedBBs.top();
     toBeAnalyzedBBs.pop();
-    instackBBs.insert(bb);
+    (void)instackBBs.insert(bb);
 
     bb->SetUnreachable(false);
 
     for (BB *succBB : bb->GetSuccs()) {
       if (instackBBs.count(succBB) == 0) {
         toBeAnalyzedBBs.push(succBB);
-        instackBBs.insert(succBB);
+        (void)instackBBs.insert(succBB);
       }
     }
     for (BB *succBB : bb->GetEhSuccs()) {
       if (instackBBs.count(succBB) == 0) {
         toBeAnalyzedBBs.push(succBB);
-        instackBBs.insert(succBB);
+        (void)instackBBs.insert(succBB);
       }
     }
   }
@@ -317,7 +317,7 @@ void CGCFG::FlushUnReachableStatusAndRemoveRelations(BB &bb, const CGFunc &func)
   BB *it = nullptr;
   while (!toBeAnalyzedBBs.empty()) {
     it = toBeAnalyzedBBs.top();
-    instackBBs.insert(it->GetId());
+    (void)instackBBs.insert(it->GetId());
     toBeAnalyzedBBs.pop();
     /* Check if bb is the first or the last BB of the function */
     isFirstBBInfunc = (it == func.GetFirstBB());
@@ -337,7 +337,7 @@ void CGCFG::FlushUnReachableStatusAndRemoveRelations(BB &bb, const CGFunc &func)
     for (BB *succ : it->GetSuccs()) {
       if (instackBBs.count(succ->GetId()) == 0) {
         toBeAnalyzedBBs.push(succ);
-        instackBBs.insert(succ->GetId());
+        (void)instackBBs.insert(succ->GetId());
       }
       succ->RemovePreds(*it);
       succ->RemoveEhPreds(*it);
@@ -346,7 +346,7 @@ void CGCFG::FlushUnReachableStatusAndRemoveRelations(BB &bb, const CGFunc &func)
     for (BB *succ : it->GetEhSuccs()) {
       if (instackBBs.count(succ->GetId()) == 0) {
         toBeAnalyzedBBs.push(succ);
-        instackBBs.insert(succ->GetId());
+        (void)instackBBs.insert(succ->GetId());
       }
       succ->RemoveEhPreds(*it);
       succ->RemovePreds(*it);
@@ -513,7 +513,7 @@ void CGCFG::UnreachCodeAnalysis() {
         bb == cgFunc->GetFirstBB() || bb == cgFunc->GetLastBB() || bb->GetKind() == BB::kBBReturn) {
       toBeAnalyzedBBs.push_front(bb);
     } else {
-      unreachBBs.insert(bb);
+      (void)unreachBBs.insert(bb);
     }
     bb->SetUnreachable(true);
     bb = bb->GetNext();
diff --git a/src/maple_be/src/cg/cg_option.cpp b/src/maple_be/src/cg/cg_option.cpp
index e78f9353bb000251eb8a93bf45ba6fca35acded0..539413f9fa391c7dbb9e8b7623f59cffdd60de09 100644
--- a/src/maple_be/src/cg/cg_option.cpp
+++ b/src/maple_be/src/cg/cg_option.cpp
@@ -919,19 +919,19 @@ bool CGOptions::SolveOptions(const std::vector<Option> &opts, bool isDebug) {
         SetClassListFile(opt.Args());
         break;
       case kGenDef:
-        SetOrClear(GetGenerateFlags(), CGOptions::kCMacroDef, opt.Type());
+        SetOrClear(GetGenerateFlags(), CGOptions::kCMacroDef, static_cast<bool>(opt.Type()));
         break;
       case kGenGctib:
-        SetOrClear(GetGenerateFlags(), CGOptions::kGctib, opt.Type());
+        SetOrClear(GetGenerateFlags(), CGOptions::kGctib, static_cast<bool>(opt.Type()));
         break;
       case kGenPrimorList:
-        SetOrClear(GetGenerateFlags(), CGOptions::kPrimorList, opt.Type());
+        SetOrClear(GetGenerateFlags(), CGOptions::kPrimorList, static_cast<bool>(opt.Type()));
         break;
       case kYieldPoing:
-        SetOrClear(GetGenerateFlags(), CGOptions::kGenYieldPoint, opt.Type());
+        SetOrClear(GetGenerateFlags(), CGOptions::kGenYieldPoint, static_cast<bool>(opt.Type()));
         break;
       case kLocalRc:
-        SetOrClear(GetGenerateFlags(), CGOptions::kGenLocalRc, opt.Type());
+        SetOrClear(GetGenerateFlags(), CGOptions::kGenLocalRc, static_cast<bool>(opt.Type()));
         break;
       case kEhList: {
         const std::string &ehList = opt.Args();
@@ -1125,7 +1125,7 @@ void CGOptions::EnableO2() {
 void CGOptions::SplitPhases(const std::string &str, std::unordered_set<std::string> &set) {
   const std::string& tmpStr{ str };
   if ((tmpStr.compare("*") == 0) || (tmpStr.compare("cgir") == 0)) {
-    set.insert(tmpStr);
+    (void)set.insert(tmpStr);
     return;
   }
   StringUtils::Split(tmpStr, set, ',');
diff --git a/src/maple_be/src/cg/cg_phasemanager.cpp b/src/maple_be/src/cg/cg_phasemanager.cpp
index 03122c2657ec2a0a3c52275659d8389538ebeaec..2c2bbc78fec5d3d461cc1720aee75d0382423d2a 100644
--- a/src/maple_be/src/cg/cg_phasemanager.cpp
+++ b/src/maple_be/src/cg/cg_phasemanager.cpp
@@ -286,6 +286,7 @@ int64 CgFuncPhaseManager::GetOptimizeTotalTime() const {
 int64 CgFuncPhaseManager::DumpCGTimers() {
   int64 total = GetOptimizeTotalTime();
   total += extraTotal;
+  std::ios::fmtflags flag(std::cout.flags());
   for (size_t i = 0; i < phaseTimers.size(); ++i) {
     CHECK_FATAL(total != 0, "calculation check");
     /*
@@ -297,7 +298,7 @@ int64 CgFuncPhaseManager::DumpCGTimers() {
                               (kPercent * phaseTimers[i] / total) << "%" << std::setw(10) << std::setprecision(0) <<
                               (phaseTimers[i] / kMicroSecPerMilliSec) << "ms" << "\n";
   }
-  LogInfo::Flags();
+  (void)std::cout.flags(flag);
   return total;
 }
 }  /* namespace maplebe */
diff --git a/src/maple_be/src/cg/ebo.cpp b/src/maple_be/src/cg/ebo.cpp
index 76616c39801c609f7cd9e002788db281b14da3ad..a16aa3739cb6f3b783ac56cbca0808af0a6e1f35 100644
--- a/src/maple_be/src/cg/ebo.cpp
+++ b/src/maple_be/src/cg/ebo.cpp
@@ -151,7 +151,7 @@ bool Ebo::OpndAvailableInBB(const BB &bb, OpndInfo *info) {
   return true;
 }
 
-bool Ebo::ForwardPropCheck(const Operand *opndReplace, OpndInfo &opndInfo, const Operand &opnd, Insn &insn) {
+bool Ebo::ForwardPropCheck(const Operand *opndReplace, const OpndInfo &opndInfo, const Operand &opnd, Insn &insn) {
   if (opndReplace == nullptr) {
     return false;
   }
diff --git a/src/maple_be/src/cg/emit.cpp b/src/maple_be/src/cg/emit.cpp
index fef3beb098ebb68504c4580fe0016ce1268778b2..279ebe673725e72e48a5cd5c4bb141e57e04184c 100644
--- a/src/maple_be/src/cg/emit.cpp
+++ b/src/maple_be/src/cg/emit.cpp
@@ -499,7 +499,7 @@ void Emitter::EmitScalarConstant(MIRConst &mirConst, bool newLine, bool flag32)
       MIRAddroffuncConst &funcAddr = static_cast<MIRAddroffuncConst&>(mirConst);
       MIRFunction *func = GlobalTables::GetFunctionTable().GetFuncTable().at(funcAddr.GetValue());
       MIRSymbol *symAddrSym = GlobalTables::GetGsymTable().GetSymbolFromStidx(func->GetStIdx().Idx());
-      Emit("\t.quad\t" + symAddrSym->GetName());
+      (void)Emit("\t.quad\t" + symAddrSym->GetName());
       break;
     }
     default:
@@ -1141,12 +1141,12 @@ void Emitter::EmitIntConst(const MIRSymbol &mirSymbol, MIRAggConst &aggConst, ui
       bool isDefTabIndex = (muidDataTabAddr & kFromDefIndexMask32Mod) == kFromDefIndexMask32Mod;
       std::string muidDataTabPrefix = isDefTabIndex ? kMuidDataDefTabPrefixStr : kMuidDataUndefTabPrefixStr;
       std::string muidDataTabName = muidDataTabPrefix + cg->GetMIRModule()->GetFileNameAsPostfix();
-      Emit(muidDataTabName + "+");
+      (void)Emit(muidDataTabName + "+");
       uint32 muidDataTabIndex = muidDataTabAddr & 0x3FFFFFFF; // high 2 bit is the mask of muid tab
-      Emit(std::to_string(muidDataTabIndex * width));
-      Emit("-.\n");
+      (void)Emit(std::to_string(muidDataTabIndex * width));
+      (void)Emit("-.\n");
     } else {
-      Emit(muidDataTabAddr);
+      (void)Emit(muidDataTabAddr);
       Emit("\n");
     }
     return;
@@ -1154,7 +1154,7 @@ void Emitter::EmitIntConst(const MIRSymbol &mirSymbol, MIRAggConst &aggConst, ui
     std::string strTabName = kRegJNITabPrefixStr + cg->GetMIRModule()->GetFileNameAsPostfix();
     EmitScalarConstant(*elemConst, false);
 #ifdef TARGARM32
-    Emit("+" + strTabName).Emit("+").Emit(MByteRef::kPositiveOffsetBias).Emit("-.\n");
+    (void)Emit("+" + strTabName).Emit("+").Emit(MByteRef::kPositiveOffsetBias).Emit("-.\n");
 #else
     Emit("+" + strTabName + "\n");
 #endif
@@ -1326,9 +1326,9 @@ void Emitter::EmitConstantTable(const MIRSymbol &mirSymbol, MIRConst &mirConst,
         Emit("\t.quad\t");
 #endif
         if (i == 0) {
-          Emit(namemangler::kVtabOffsetTabStr + cg->GetMIRModule()->GetFileNameAsPostfix() + " - .\n");
+          (void)Emit(namemangler::kVtabOffsetTabStr + cg->GetMIRModule()->GetFileNameAsPostfix() + " - .\n");
         } else {
-          Emit(namemangler::kFieldOffsetTabStr + cg->GetMIRModule()->GetFileNameAsPostfix() + " - .\n");
+          (void)Emit(namemangler::kFieldOffsetTabStr + cg->GetMIRModule()->GetFileNameAsPostfix() + " - .\n");
         }
       } else {
         EmitConstantTable(mirSymbol, *elemConst, strIdx2Type);
@@ -1465,7 +1465,7 @@ void Emitter::EmitLiteral(const MIRSymbol &literal, const std::map<GStrIdx, MIRT
   EmitAsmLabel(literal, kAsmType);
   /* literal should always be fstatic and readonly? */
   EmitAsmLabel(literal, kAsmLocal);  /* alwasy fstatic */
-  Emit("\t.section\t." + std::string(kMapleLiteralString) + ",\"aw\", %progbits\n");
+  (void)Emit("\t.section\t." + std::string(kMapleLiteralString) + ",\"aw\", %progbits\n");
   EmitAsmLabel(literal, kAsmAlign);
   EmitAsmLabel(literal, kAsmSyname);
   /* literal is an array */
@@ -1659,7 +1659,7 @@ void Emitter::EmitGlobalVars(std::vector<std::pair<MIRSymbol*, bool>> &globalVar
   }
   std::string globalVarName;
   while (inFile >> globalVarName) {
-    hotVars.insert(globalVarName);
+    (void)hotVars.insert(globalVarName);
   }
   inFile.close();
   bool hotBeginSet = false;
@@ -1899,7 +1899,7 @@ void Emitter::EmitGlobalVariable() {
         secName.erase(0, 2);
         Emit("\t.section\t." + secName + ",\"a\",%progbits\n");
       } else {
-        Emit("\t.section\t." + std::string(kMapleGlobalVariable) + ",\"aw\", %progbits\n");
+        (void)Emit("\t.section\t." + std::string(kMapleGlobalVariable) + ",\"aw\", %progbits\n");
       }
       /* Emit size and align by type */
       if (mirSymbol->GetStorageClass() == kScGlobal) {
@@ -2323,12 +2323,12 @@ void Emitter::EmitHexUnsigned(uint64 num) {
 #define str(s) #s
 
 void Emitter::EmitDIHeader() {
-  Emit("\t.section ." + std::string(namemangler::kMuidJavatextPrefixStr) + ",\"ax\"\n");
+  (void)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");
+  (void)Emit("\t.section ." + std::string(namemangler::kMuidJavatextPrefixStr) + ",\"ax\"\n");
   Emit(".L" XSTR(TEXT_END) ":\n");
 }
 
@@ -2345,7 +2345,7 @@ void Emitter::EmitHugeSoRoutines(bool lastRoutine) {
     return;
   }
   for (auto &target : hugeSoTargets) {
-    Emit("\t.section ." + std::string(namemangler::kMuidJavatextPrefixStr) + ",\"ax\"\n");
+    (void)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");
@@ -2365,7 +2365,7 @@ void ImmOperand::Dump() const {
 
 void LabelOperand::Emit(Emitter &emitter, const OpndProp *opndProp) const {
   (void)opndProp;
-  emitter.Emit(".L.").Emit(parentFunc).Emit(".").Emit(labelIndex);
+  (void)emitter.Emit(".L.").Emit(parentFunc).Emit(".").Emit(labelIndex);
 }
 
 void LabelOperand::Dump() const {
diff --git a/src/maple_be/src/cg/loop.cpp b/src/maple_be/src/cg/loop.cpp
index 520e80e6518ec3a68da67af558e16fa9d91cb5cd..fc267552970cd98618c1177e2cadeca89d27b46a 100644
--- a/src/maple_be/src/cg/loop.cpp
+++ b/src/maple_be/src/cg/loop.cpp
@@ -92,7 +92,7 @@ bool LoopFinder::DetectLoopSub(BB &header,  BB &back, std::set<BB*, BBIdCmp> &tr
     return true;
   }
 
-  traversed.insert(&header);
+  (void)traversed.insert(&header);
   for (auto succ : header.GetSuccs()) {
     bool alreadyInLoop = false;
     for (auto candi : candidate) {
@@ -142,7 +142,7 @@ bool LoopFinder::DetectLoopSub(BB &header,  BB &back, std::set<BB*, BBIdCmp> &tr
 /* backege -> header */
 void LoopFinder::DetectLoop(BB &header, BB &back) {
   std::set<BB*, BBIdCmp> traversed;
-  traversed.insert(&header);
+  (void)traversed.insert(&header);
   candidate.push_back(&header);
   candidate.push_back(&back);
 
diff --git a/src/maple_be/src/cg/optimize_common.cpp b/src/maple_be/src/cg/optimize_common.cpp
index 2c657e6a698bf8fcb3aa01d6bc2977922b879537..fcf9378f2698f210c0844b4fd125bfc1dcf7187a 100644
--- a/src/maple_be/src/cg/optimize_common.cpp
+++ b/src/maple_be/src/cg/optimize_common.cpp
@@ -254,13 +254,13 @@ void OptimizeLogger::Log(const std::string &patternName) {
   if (itemInGlobal != globalStat.end()) {
     itemInGlobal->second++;
   } else {
-    globalStat.insert(std::pair<const std::string, int>(patternName, 1));
+    (void)globalStat.insert(std::pair<const std::string, int>(patternName, 1));
   }
   auto itemInLocal = localStat.find(patternName);
   if (itemInLocal != localStat.end()) {
     itemInLocal->second++;
   } else {
-    localStat.insert(std::pair<const std::string, int>(patternName, 1));
+    (void)localStat.insert(std::pair<const std::string, int>(patternName, 1));
   }
 }
 
diff --git a/src/maple_be/src/cg/reaching.cpp b/src/maple_be/src/cg/reaching.cpp
index 52628bfc5cffe03ab1788f6c0f6eb9cbcfbd93b1..082977bea9d9cfcecb9c07a7ca69dcbe992b0f28 100644
--- a/src/maple_be/src/cg/reaching.cpp
+++ b/src/maple_be/src/cg/reaching.cpp
@@ -562,9 +562,9 @@ void ReachingDefinition::Initialize() {
       if (bb->GetFirstStmt() == cgFunc->GetCleanupLabel()) {
         firstCleanUpBB = bb;
       }
-      cleanUpBBSet.insert(bb);
+      (void)cleanUpBBSet.insert(bb);
     } else {
-      normalBBSet.insert(bb);
+      (void)normalBBSet.insert(bb);
     }
   }
   maxInsnNO = 0;
@@ -597,16 +597,16 @@ void ReachingDefinition::BuildInOutForFuncBody() {
     setItr = normalBBSetBak.begin();
     BB *bb = *setItr;
     ASSERT(bb != nullptr, "null ptr check");
-    normalBBSetBak.erase(setItr);
+    (void)normalBBSetBak.erase(setItr);
 
     if (GenerateIn(*bb)) {
       if (GenerateOut(*bb)) {
         for (auto succ : bb->GetSuccs()) {
-          normalBBSetBak.insert(succ);
+          (void)normalBBSetBak.insert(succ);
         }
 
         for (auto ehSucc : bb->GetEhSuccs()) {
-          normalBBSetBak.insert(ehSucc);
+          (void)normalBBSetBak.insert(ehSucc);
         }
       }
     }
@@ -625,11 +625,11 @@ void ReachingDefinition::UpdateInOut(BB &changedBB) {
   std::set<BB*, BBIdCmp>::iterator setItr;
 
   for (auto succ : changedBB.GetSuccs()) {
-    bbSet.insert(succ);
+    (void)bbSet.insert(succ);
   }
 
   for (auto ehSucc : changedBB.GetEhSuccs()) {
-    bbSet.insert(ehSucc);
+    (void)bbSet.insert(ehSucc);
   }
 
   while (!bbSet.empty()) {
@@ -641,11 +641,11 @@ void ReachingDefinition::UpdateInOut(BB &changedBB) {
     if (GenerateIn(*bb)) {
       if (GenerateOut(*bb)) {
         for (auto succ : bb->GetSuccs()) {
-          bbSet.insert(succ);
+          (void)bbSet.insert(succ);
         }
 
         for (auto ehSucc : bb->GetEhSuccs()) {
-          bbSet.insert(ehSucc);
+          (void)bbSet.insert(ehSucc);
         }
       }
     }
@@ -678,11 +678,11 @@ void ReachingDefinition::UpdateInOut(BB &changedBB, bool isReg) {
   std::set<BB*, BBIdCmp> bbSet;
   std::set<BB*, BBIdCmp>::iterator setItr;
   for (auto &succ : changedBB.GetSuccs()) {
-    bbSet.insert(succ);
+    (void)bbSet.insert(succ);
   }
 
   for (auto &ehSucc : changedBB.GetEhSuccs()) {
-    bbSet.insert(ehSucc);
+    (void)bbSet.insert(ehSucc);
   }
   while (!bbSet.empty()) {
     setItr = bbSet.begin();
@@ -691,10 +691,10 @@ void ReachingDefinition::UpdateInOut(BB &changedBB, bool isReg) {
     if (GenerateIn(*bb, changedInfoIndex, isReg)) {
       if (GenerateOut(*bb, changedInfoIndex, isReg)) {
         for (auto &succ : bb->GetSuccs()) {
-          bbSet.insert(succ);
+          (void)bbSet.insert(succ);
         }
         for (auto &ehSucc : bb->GetEhSuccs()) {
-          bbSet.insert(ehSucc);
+          (void)bbSet.insert(ehSucc);
         }
       }
     }
@@ -722,10 +722,10 @@ void ReachingDefinition::BuildInOutForCleanUpBB() {
     if (GenerateIn(*bb)) {
       if (GenerateOut(*bb)) {
         for (auto succ : bb->GetSuccs()) {
-          cleanupBBSetBak.insert(succ);
+          (void)cleanupBBSetBak.insert(succ);
         }
         for (auto ehSucc : bb->GetEhSuccs()) {
-          cleanupBBSetBak.insert(ehSucc);
+          (void)cleanupBBSetBak.insert(ehSucc);
         }
       }
     }
@@ -747,10 +747,10 @@ void ReachingDefinition::BuildInOutForCleanUpBB(bool isReg, const std::set<uint3
     if (GenerateIn(*bb, index, isReg)) {
       if (GenerateOut(*bb, index, isReg)) {
         for (auto &succ : bb->GetSuccs()) {
-          cleanupBBSetBak.insert(succ);
+          (void)cleanupBBSetBak.insert(succ);
         }
         for (auto &ehSucc : bb->GetEhSuccs()) {
-          cleanupBBSetBak.insert(ehSucc);
+          (void)cleanupBBSetBak.insert(ehSucc);
         }
       }
     }
diff --git a/src/maple_be/src/cg/schedule.cpp b/src/maple_be/src/cg/schedule.cpp
index e23cb5fcee2181bf6c60385a9b0d8498ef9fc2be..a1c47ea4c9d2c83278c8c73e529ff4b01c048bca 100644
--- a/src/maple_be/src/cg/schedule.cpp
+++ b/src/maple_be/src/cg/schedule.cpp
@@ -225,7 +225,7 @@ void RegPressureSchedule::CalculatePressure(DepNode &node, regno_t reg, bool def
 void RegPressureSchedule::UpdateLiveReg(const DepNode &node, regno_t reg, bool def) {
   if (def) {
     if (liveReg.find(reg) == liveReg.end()) {
-      liveReg.insert(reg);
+      (void)liveReg.insert(reg);
     }
     /* if no use list, a register is only defined, not be used */
     size_t i = 0;
@@ -311,7 +311,7 @@ void RegPressureSchedule::UpdatePriority(DepNode &node) {
   node.SetPriority(maxPriority++);
   do {
     DepNode *nowNode = workQueue.front();
-    workQueue.erase(workQueue.begin());
+    (void)workQueue.erase(workQueue.begin());
     for (auto pred : nowNode->GetPreds()) {
       DepNode &from = pred->GetFrom();
       if (from.GetState() != kScheduled && from.GetPriority() < maxPriority) {
diff --git a/src/maple_driver/include/driver_runner.h b/src/maple_driver/include/driver_runner.h
index f7647879a9842bd818bfe912a7a17ae200656b9b..8ed6b444feb22914178baebcff0af0cf5647f784 100644
--- a/src/maple_driver/include/driver_runner.h
+++ b/src/maple_driver/include/driver_runner.h
@@ -76,7 +76,8 @@ class DriverRunner final {
   std::string cgInput;
   BECommon *beCommon = nullptr;
   CG *CreateCGAndBeCommon(const std::string &outputFile, const std::string &oriBasename);
-  void RunCGFunctions(CG &cg, CgFuncPhaseManager &cgfpm) const;
+  void RunCGFunctions(CG &cg, CgFuncPhaseManager &cgfpm, std::vector<long> &extraPhasesTime,
+                      std::vector<std::string> &extraPhasesName) const;
   void EmitGlobalInfo(CG &cg) const;
   void EmitDuplicatedAsmFunc(const CG &cg) const;
   void ProcessExtraTime(const std::vector<long> &extraPhasesTime, const std::vector<std::string> &extraPhasesName,
diff --git a/src/maple_driver/include/option_parser.h b/src/maple_driver/include/option_parser.h
index 86916f80922fc6e1eed30df594d2e795e6bf7f37..8fe7c25c99ab29aaf68f764ff6c0cf4df08a541b 100644
--- a/src/maple_driver/include/option_parser.h
+++ b/src/maple_driver/include/option_parser.h
@@ -63,7 +63,7 @@ class OptionParser {
                 std::vector<mapleOption::Option> &inputOption, const std::string &exeName);
   void InsertOption(const std::string &opt, const Descriptor &usage) {
     if (usage.IsEnabledForCurrentBuild()) {
-      usages.insert(make_pair(opt, usage));
+      (void)usages.insert(make_pair(opt, usage));
     }
   }
   bool CheckSpecialOption(const std::string &option, std::string &key, std::string &value);
diff --git a/src/maple_driver/include/safe_exe.h b/src/maple_driver/include/safe_exe.h
index bc512341fd409c8b15a92e9d69c901a997c8f403..91007b8d02c80393c44a8c07f551bf2a72fc2d5e 100644
--- a/src/maple_driver/include/safe_exe.h
+++ b/src/maple_driver/include/safe_exe.h
@@ -143,7 +143,7 @@ class SafeExe {
         ++iter;
       }
     }
-    tmpArgs.insert(tmpArgs.begin(), cmd);
+    (void)tmpArgs.insert(tmpArgs.begin(), cmd);
     return tmpArgs;
   }
 };
diff --git a/src/maple_driver/src/compiler.cpp b/src/maple_driver/src/compiler.cpp
index f7f6820bec7600cee3f39ee75cb920deaf62393f..08dbbdb991f539d53f514f27f5cd3a8032e963be 100644
--- a/src/maple_driver/src/compiler.cpp
+++ b/src/maple_driver/src/compiler.cpp
@@ -81,7 +81,7 @@ std::string Compiler::MakeOption(const MplOptions &options) const {
 void Compiler::AppendDefaultOptions(std::map<std::string, MplOption> &finalOptions,
                                     const std::map<std::string, MplOption> &defaultOptions) const {
   for (const auto &defaultIt : defaultOptions) {
-    finalOptions.insert(make_pair(defaultIt.first, defaultIt.second));
+    (void)finalOptions.insert(make_pair(defaultIt.first, defaultIt.second));
   }
 }
 
@@ -102,7 +102,7 @@ std::map<std::string, MplOption> Compiler::MakeDefaultOptions(const MplOptions &
   std::map<std::string, MplOption> defaultOptions;
   if (rawDefaultOptions.mplOptions != nullptr) {
     for (uint32_t i = 0; i < rawDefaultOptions.length; ++i) {
-      defaultOptions.insert(std::make_pair(rawDefaultOptions.mplOptions[i].GetKey(),
+      (void)defaultOptions.insert(std::make_pair(rawDefaultOptions.mplOptions[i].GetKey(),
           rawDefaultOptions.mplOptions[i]));
     }
   }
@@ -116,7 +116,7 @@ void Compiler::AppendOptions(std::map<std::string, MplOption> &finalOptions, con
     finalOpt->second.SetValue(value);
   } else {
     MplOption option(key, value);
-    finalOptions.insert(make_pair(key, option));
+    (void)finalOptions.insert(make_pair(key, option));
   }
 }
 }  // namespace maple
diff --git a/src/maple_driver/src/compiler_factory.cpp b/src/maple_driver/src/compiler_factory.cpp
index f57081ffc41142204ae4d02ea5976b4075320900..e2a1bd1e5fc3e867147b235a752aea2c947c6537 100644
--- a/src/maple_driver/src/compiler_factory.cpp
+++ b/src/maple_driver/src/compiler_factory.cpp
@@ -60,7 +60,7 @@ CompilerFactory::~CompilerFactory() {
 }
 
 void CompilerFactory::Insert(const std::string &name, Compiler *value) {
-  supportedCompilers.insert(make_pair(name, value));
+  (void)supportedCompilers.insert(make_pair(name, value));
 }
 
 ErrorCode CompilerFactory::DeleteTmpFiles(const MplOptions &mplOptions, const std::vector<std::string> &tempFiles,
diff --git a/src/maple_driver/src/driver_runner.cpp b/src/maple_driver/src/driver_runner.cpp
index b002cfb57a50dcc679084d678694d7e42b4fe727..c64b617a3e0591e56615ef4a8310f76cfcbc6f7b 100644
--- a/src/maple_driver/src/driver_runner.cpp
+++ b/src/maple_driver/src/driver_runner.cpp
@@ -257,21 +257,17 @@ void DriverRunner::ProcessCGPhase(const std::string &outputFile, const std::stri
   CG *cg = CreateCGAndBeCommon(outputFile, originBaseName);
 
   if (cgOptions->IsRunCG()) {
-    std::chrono::system_clock::time_point timeStart = std::chrono::system_clock::now();
-
     // Generate the output file
     CHECK_FATAL(cg != nullptr, "cg is null");
     CHECK_FATAL(cg->GetEmitter(), "emitter is null");
     if (!cgOptions->SuppressFileInfo()) {
       cg->GetEmitter()->EmitFileInfo(actualInput);
     }
-    ADD_EXTRA_PHASE("lowerir", CGOptions::IsEnableTimePhases(), timeStart);
-
     // Run the cg optimizations phases
-    RunCGFunctions(*cg, cgfpm);
+    RunCGFunctions(*cg, cgfpm, extraPhasesTime, extraPhasesName);
 
     // Emit global info
-    timeStart = std::chrono::system_clock::now();
+    std::chrono::system_clock::time_point timeStart = std::chrono::system_clock::now();
     EmitGlobalInfo(*cg);
     ADD_EXTRA_PHASE("emitglobalinfo", CGOptions::IsEnableTimePhases(), timeStart);
   } else {
@@ -327,7 +323,12 @@ CG *DriverRunner::CreateCGAndBeCommon(const std::string &outputFile, const std::
 }
 
 
-void DriverRunner::RunCGFunctions(CG &cg, CgFuncPhaseManager &cgfpm) const {
+void DriverRunner::RunCGFunctions(CG &cg, CgFuncPhaseManager &cgfpm, std::vector<long> &extraPhasesTime,
+                                  std::vector<std::string> &extraPhasesName) const {
+  MPLTimer timer;
+  long lowerTime = 0;
+  long constFoldTime = 0;
+  timer.Start();
   MIRLower mirLowerer(*theModule, nullptr);
   mirLowerer.Init();
   CGLowerer theLowerer(*theModule, *beCommon, cg.GenerateExceptionHandlingCode(), cg.GenerateVerboseCG());
@@ -335,6 +336,8 @@ void DriverRunner::RunCGFunctions(CG &cg, CgFuncPhaseManager &cgfpm) const {
   theLowerer.InitArrayClassCacheTableIndex();
   theLowerer.RegisterExternalLibraryFunctions();
   theLowerer.SetCheckLoadStore(CGOptions::IsCheckArrayStore());
+  timer.Stop();
+  lowerTime += timer.ElapsedMicroseconds();
 
   if (cg.AddStackGuard()) {
     cg.AddStackGuardvar();
@@ -351,6 +354,7 @@ void DriverRunner::RunCGFunctions(CG &cg, CgFuncPhaseManager &cgfpm) const {
 
     // LowerIR.
     theModule->SetCurFunction(mirFunc);
+    timer.Start();
     // if maple_me not run, needs extra lowering
     if (theModule->GetFlavor() <= kFeProduced) {
       mirLowerer.SetLowerCG();
@@ -371,6 +375,8 @@ void DriverRunner::RunCGFunctions(CG &cg, CgFuncPhaseManager &cgfpm) const {
       mirFunc->Dump();
       LogInfo::MapleLogger() << "************* end    CGLowerer **************" << '\n';
     }
+    timer.Stop();
+    lowerTime += timer.ElapsedMicroseconds();
 
     MIRSymbol *funcSt = GlobalTables::GetGsymTable().GetSymbolFromStidx(mirFunc->GetStIdx().Idx());
     MemPool *funcMp = memPoolCtrler.NewMemPool(funcSt->GetName());
@@ -397,6 +403,12 @@ void DriverRunner::RunCGFunctions(CG &cg, CgFuncPhaseManager &cgfpm) const {
     ++rangeNum;
   }
   cg.GetEmitter()->EmitHugeSoRoutines(true);
+  extraPhasesTime.push_back(lowerTime);
+  std::string lowerName = "lowerir";
+  extraPhasesName.push_back(lowerName);
+  extraPhasesTime.push_back(constFoldTime);
+  std::string constFoldName = "constFold";
+  extraPhasesName.push_back(constFoldName);
 }
 
 void DriverRunner::EmitGlobalInfo(CG &cg) const {
diff --git a/src/maple_driver/src/maple_comb_compiler.cpp b/src/maple_driver/src/maple_comb_compiler.cpp
index b64ba13b08cfaadb0592f32eecce737faa8447cb..52ae7fcac69d20f772daaad258b56e8814933ee9 100644
--- a/src/maple_driver/src/maple_comb_compiler.cpp
+++ b/src/maple_driver/src/maple_comb_compiler.cpp
@@ -60,7 +60,7 @@ void MapleCombCompiler::GetTmpFilesToDelete(const MplOptions &mplOptions, std::v
 
 std::unordered_set<std::string> MapleCombCompiler::GetFinalOutputs(const MplOptions &mplOptions) const {
   std::unordered_set<std::string> finalOutputs;
-  finalOutputs.insert(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".VtableImpl.mpl");
+  (void)finalOutputs.insert(mplOptions.GetOutputFolder() + mplOptions.GetOutputName() + ".VtableImpl.mpl");
   return finalOutputs;
 }
 
diff --git a/src/maple_driver/src/mplcg_compiler.cpp b/src/maple_driver/src/mplcg_compiler.cpp
index 449b1e06384c6e6243fc3bedd55e001ec698737d..516fca1cb160b8d4d7535c7df9f3c48a4d757e8d 100644
--- a/src/maple_driver/src/mplcg_compiler.cpp
+++ b/src/maple_driver/src/mplcg_compiler.cpp
@@ -16,6 +16,7 @@
 #include "compiler.h"
 #include "default_options.def"
 #include "mpl_logging.h"
+#include "mpl_timer.h"
 #include "driver_runner.h"
 
 namespace maple {
@@ -109,6 +110,8 @@ ErrorCode MplcgCompiler::Compile(const MplOptions &options, MIRModulePtr &theMod
   bool parsed = false;
   std::unique_ptr<MIRParser> theParser;
   if (theModule == nullptr) {
+    MPLTimer timer;
+    timer.Start();
     theModule = new MIRModule(fileName);
     theModule->SetWithMe(
         std::find(options.GetRunningExes().begin(), options.GetRunningExes().end(),
@@ -126,6 +129,8 @@ ErrorCode MplcgCompiler::Compile(const MplOptions &options, MIRModulePtr &theMod
       memPoolCtrler.DeleteMemPool(optMp);
       return kErrorCompileFail;
     }
+    timer.Stop();
+    LogInfo::MapleLogger() << "Mplcg Parser consumed " << timer.ElapsedMilliseconds() << "ms\n";
   }
 
   LogInfo::MapleLogger() << "Starting mplcg\n";
diff --git a/src/maple_ipa/include/call_graph.h b/src/maple_ipa/include/call_graph.h
index 671b34fbd4d5435a4bc77096f7664755259c7522..4868523956e0e5f1a5db4fc70e8797d1230040fc 100644
--- a/src/maple_ipa/include/call_graph.h
+++ b/src/maple_ipa/include/call_graph.h
@@ -172,11 +172,11 @@ class CGNode {
 
   // add caller to CGNode
   void AddCaller(CGNode *caller) {
-    callerSet.insert(caller);
+    (void)callerSet.insert(caller);
   }
 
   void DelCaller(CGNode *caller) {
-    callerSet.erase(caller);
+    (void)callerSet.erase(caller);
   }
 
   bool HasCaller() const {
@@ -253,7 +253,7 @@ class CGNode {
   }
 
   void AddVcallCandidate(CGNode *item) {
-    vcallCandidates.insert(item);
+    (void)vcallCandidates.insert(item);
   }
 
   MapleSet<CGNode*, Comparator<CGNode>> &GetVcallCandidates() {
@@ -269,7 +269,7 @@ class CGNode {
   }
 
   void AddIcallCandidate(CGNode *item) {
-    icallCandidates.insert(item);
+    (void)icallCandidates.insert(item);
   }
 
   MapleSet<CGNode*, Comparator<CGNode>> &GetIcallCandidates() {
diff --git a/src/maple_ipa/src/call_graph.cpp b/src/maple_ipa/src/call_graph.cpp
index 1cbd9232e18c6ec8abdc84a9e36d00a62369bc73..63ab1026ee15ec5ccf80a14ccbf1ef9b0ab37270 100644
--- a/src/maple_ipa/src/call_graph.cpp
+++ b/src/maple_ipa/src/call_graph.cpp
@@ -153,7 +153,7 @@ void CGNode::Dump(std::ofstream &fout) const {
 }
 
 void CGNode::AddCallsite(CallInfo *ci, MapleSet<CGNode*, Comparator<CGNode>> *callee) {
-  callees.insert(std::pair<CallInfo*, MapleSet<CGNode*, Comparator<CGNode>>*>(ci, callee));
+  (void)callees.insert(std::pair<CallInfo*, MapleSet<CGNode*, Comparator<CGNode>>*>(ci, callee));
 }
 
 void CGNode::AddCallsite(CallInfo &ci, CGNode *node) {
@@ -326,7 +326,7 @@ CGNode *CallGraph::GetOrGenCGNode(PUIdx puIdx, bool isVcall, bool isIcall) {
   if (node == nullptr) {
     MIRFunction *mirFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
     node = cgAlloc.GetMemPool()->New<CGNode>(mirFunc, cgAlloc, numOfNodes++);
-    nodesMap.insert(std::make_pair(mirFunc, node));
+    (void)nodesMap.insert(std::make_pair(mirFunc, node));
   }
   if (isVcall && !node->IsVcallCandidatesValid()) {
     MIRFunction *mirFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
@@ -1515,7 +1515,7 @@ void SCCNode::Setup() {
         if (calleeNode->GetSCCNode() == this) {
           continue;
         }
-        calleeScc.insert(calleeNode->GetSCCNode());
+        (void)calleeScc.insert(calleeNode->GetSCCNode());
       }
     }
     for (auto itCaller = node->CallerBegin(); itCaller != node->CallerEnd(); ++itCaller) {
@@ -1523,7 +1523,7 @@ void SCCNode::Setup() {
       if (callerNode->GetSCCNode() == this) {
         continue;
       }
-      callerScc.insert(callerNode->GetSCCNode());
+      (void)callerScc.insert(callerNode->GetSCCNode());
     }
   }
 }
@@ -1619,7 +1619,7 @@ void CallGraph::SCCTopologicalSort(const std::vector<SCCNode*> &sccNodes) {
   for (SCCNode * const &node : sccNodes) {
     if (!node->HasCaller()) {
       sccTopologicalVec.push_back(node);
-      inQueue.insert(node);
+      (void)inQueue.insert(node);
     }
   }
   // Top-down iterates all nodes
@@ -1638,7 +1638,7 @@ void CallGraph::SCCTopologicalSort(const std::vector<SCCNode*> &sccNodes) {
         }
         if (callerAllVisited) {
           sccTopologicalVec.push_back(callee);
-          inQueue.insert(callee);
+          (void)inQueue.insert(callee);
         }
       }
     }
diff --git a/src/maple_ipa/src/clone.cpp b/src/maple_ipa/src/clone.cpp
index 60e2b352db93373b4491d245dab35d5d476175ad..96a4eeea0f202b94fb992a49e242bf7e3e4aec34 100644
--- a/src/maple_ipa/src/clone.cpp
+++ b/src/maple_ipa/src/clone.cpp
@@ -230,7 +230,7 @@ void Clone::DoClone() {
       GStrIdx gStrIdxOfFunc = GlobalTables::GetStrTable().GetStrIdxFromName(std::string(funcName.c_str()));
       MIRFunction *oriFunc = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(gStrIdxOfFunc)->GetFunction();
       mirModule->SetCurFunction(oriFunc);
-      clonedNewFuncMap.insert(CloneFunctionNoReturn(*oriFunc)->GetName());
+      (void)clonedNewFuncMap.insert(CloneFunctionNoReturn(*oriFunc)->GetName());
     }
   }
 }
diff --git a/src/maple_ir/include/global_tables.h b/src/maple_ir/include/global_tables.h
index 4a4242d5d3c29768e1c5663f07192895a02ecd64..12e0403963f140788802d01445aedeb562dc5798 100644
--- a/src/maple_ir/include/global_tables.h
+++ b/src/maple_ir/include/global_tables.h
@@ -298,7 +298,7 @@ class TypeTable {
   }
 
   // Get or Create derived types.
-  MIRType *GetOrCreatePointerType(TyIdx pointedTyIdx, PrimType primType = PTY_ptr,
+  MIRType *GetOrCreatePointerType(const TyIdx &pointedTyIdx, PrimType primType = PTY_ptr,
                                   const std::vector<TypeAttrs> attrs = std::vector<TypeAttrs>());
   MIRType *GetOrCreatePointerType(const MIRType &pointTo, PrimType primType = PTY_ptr,
                                   const std::vector<TypeAttrs> attrs = std::vector<TypeAttrs>());
@@ -625,7 +625,7 @@ class ConstPool {
   }
 
   void InsertConstPool(GStrIdx strIdx, MIRConst *cst) {
-    constMap.insert(std::pair<GStrIdx, MIRConst*>(strIdx, cst));
+    (void)constMap.insert(std::pair<GStrIdx, MIRConst*>(strIdx, cst));
   }
 
   MIRConst *GetConstFromPool(GStrIdx strIdx) {
@@ -633,7 +633,7 @@ class ConstPool {
   }
 
   void PutLiteralNameAsImported(GStrIdx gIdx) {
-    importedLiteralNames.insert(gIdx);
+    (void)importedLiteralNames.insert(gIdx);
   }
 
   bool LookUpLiteralNameFromImported(GStrIdx gIdx) {
diff --git a/src/maple_ir/include/mir_function.h b/src/maple_ir/include/mir_function.h
index c2f14d2a2631717a2eb5d85e1c35bb21b0d60b6e..80e1aa7c8a1cea52b48348be4528cdf0aabac8dd 100644
--- a/src/maple_ir/include/mir_function.h
+++ b/src/maple_ir/include/mir_function.h
@@ -163,7 +163,7 @@ class MIRFunction {
   }
 
   void UpdateFuncTypeAndFormals(const std::vector<MIRSymbol*> &symbols, bool clearOldArgs = false);
-  void UpdateFuncTypeAndFormalsAndReturnType(const std::vector<MIRSymbol*> &symbols, TyIdx retTyIdx,
+  void UpdateFuncTypeAndFormalsAndReturnType(const std::vector<MIRSymbol*> &symbols, const TyIdx &retTyIdx,
                                              bool clearOldArgs = false);
   LabelIdx GetOrCreateLableIdxFromName(const std::string &name);
   GStrIdx GetLabelStringIndex(LabelIdx labelIdx) const {
@@ -736,7 +736,7 @@ class MIRFunction {
     return retRefSym;
   }
   void InsertMIRSymbol(MIRSymbol *sym) {
-    retRefSym.insert(sym);
+    (void)retRefSym.insert(sym);
   }
 
   MemPool *GetDataMemPool() const {
@@ -772,7 +772,7 @@ class MIRFunction {
     genericRet = r;
   }
 
-  void AddFuncLocalGenericVar(GStrIdx str, AnnotationType *at) {
+  void AddFuncLocalGenericVar(const GStrIdx &str, AnnotationType *at) {
     genericLocalVar[str] = at;
   }
 
@@ -788,7 +788,7 @@ class MIRFunction {
     return genericRet;
   }
 
-  AnnotationType *GetFuncLocalGenericVar(GStrIdx str) {
+  AnnotationType *GetFuncLocalGenericVar(const GStrIdx &str) {
     if (genericLocalVar.find(str) == genericLocalVar.end()) {
       return nullptr;
     }
diff --git a/src/maple_ir/include/mir_module.h b/src/maple_ir/include/mir_module.h
index 56137a8fbab8d2d2b035870cf908e4c4a97dea63..86173a1c04e75a4a2726a5af6709c87d6adc5939 100644
--- a/src/maple_ir/include/mir_module.h
+++ b/src/maple_ir/include/mir_module.h
@@ -274,7 +274,7 @@ class MIRModule {
   }
 
   void addSuperCall(const std::string &func) {
-    superCallSet.insert(func);
+    (void)superCallSet.insert(func);
   }
 
   bool findSuperCall(const std::string &func) const {
@@ -485,7 +485,7 @@ class MIRModule {
     return it->second.find(key) != it->second.end();
   }
   void InsertTargetHash(PUIdx idx, uint32 key) {
-    method2TargetHash[idx].insert(key);
+    (void)method2TargetHash[idx].insert(key);
   }
   void AddValueToMethod2TargetHash(PUIdx idx, const std::unordered_set<uint32> &value) {
     method2TargetHash[idx] = value;
diff --git a/src/maple_ir/include/mir_nodes.h b/src/maple_ir/include/mir_nodes.h
index 762ca054db579981377842fbf9f67676931f0666..237dfc8a583abe69446b690ae399c5be862d5fcc 100644
--- a/src/maple_ir/include/mir_nodes.h
+++ b/src/maple_ir/include/mir_nodes.h
@@ -1675,7 +1675,7 @@ class TryNode : public StmtNode {
 
   void OffsetsInsert(MapleVector<LabelIdx>::iterator a, MapleVector<LabelIdx>::iterator b,
                      MapleVector<LabelIdx>::iterator c) {
-    offsets.insert(a, b, c);
+    (void)offsets.insert(a, b, c);
   }
 
   TryNode *CloneTree(MapleAllocator &allocator) const override {
@@ -2712,7 +2712,7 @@ class NaryStmtNode : public StmtNode, public NaryOpnds {
     for (size_t i = 0; i < idx; ++i) {
       ++begin;
     }
-    GetNopnd().insert(begin, node);
+    (void)GetNopnd().insert(begin, node);
     SetNumOpnds(GetNopndSize());
   }
 };
@@ -3101,7 +3101,7 @@ class LabelNode : public StmtNode {
 
 class CommentNode : public StmtNode {
  public:
-  explicit CommentNode(MapleAllocator &allocator) : StmtNode(OP_comment), comment(allocator.GetMemPool()) {}
+  explicit CommentNode(const MapleAllocator &allocator) : StmtNode(OP_comment), comment(allocator.GetMemPool()) {}
 
   explicit CommentNode(const MIRModule &mod) : CommentNode(mod.GetCurFuncCodeMPAllocator()) {}
 
@@ -3110,7 +3110,7 @@ class CommentNode : public StmtNode {
 
   CommentNode(const MIRModule &mod, const std::string &cmt) : CommentNode(mod.GetCurFuncCodeMPAllocator(), cmt) {}
 
-  CommentNode(MapleAllocator &allocator, const CommentNode &node)
+  CommentNode(const MapleAllocator &allocator, const CommentNode &node)
       : StmtNode(node.GetOpCode(), node.GetPrimType(), node.numOpnds),
         comment(node.comment, allocator.GetMemPool()) {}
 
diff --git a/src/maple_ir/include/mir_symbol.h b/src/maple_ir/include/mir_symbol.h
index ccd5e6f627d93f5cdc70e18e852f8b3e54fa35aa..ab3901fd982626be498108899bc24587cb84994a 100644
--- a/src/maple_ir/include/mir_symbol.h
+++ b/src/maple_ir/include/mir_symbol.h
@@ -94,6 +94,30 @@ class MIRSymbol {
     return isImported;
   }
 
+  void SetWPOFakeParm() {
+    wpoFakeParam = true;
+  }
+
+  bool IsWpoFakeParm() const {
+    return wpoFakeParam;
+  }
+
+  bool IsWpoFakeRet() const {
+    return wpoFakeRet;
+  }
+
+  void SetWPOFakeRet() {
+    wpoFakeRet = true;
+  }
+
+  void SetIsTmpUnused(bool used) {
+    isTmpUnused = used;
+  }
+
+  bool IsTmpUnused() const {
+    return isTmpUnused;
+  }
+
   void SetTyIdx(TyIdx tyIdx) {
     this->tyIdx = tyIdx;
   }
@@ -282,6 +306,10 @@ class MIRSymbol {
     value.preg = preg;
   }
 
+  bool CanBeIgnored() const {
+    return isDeleted;
+  }
+
   void SetLocalRefVar() {
     SetAttr(ATTR_localrefvar);
   }
@@ -375,9 +403,12 @@ class MIRSymbol {
   MIRSymKind sKind{ kStInvalid };
   bool isTmp = false;
   bool needForwDecl = false;  // addrof of this symbol used in initialization, NOT serialized
+  bool wpoFakeParam = false;  // fake symbol introduced in wpo phase for a parameter, NOT serialized
+  bool wpoFakeRet = false;    // fake symbol introduced in wpo phase for return value, NOT serialized
   bool isDeleted = false;     // tell if it is deleted, NOT serialized
   bool instrumented = false;  // a local ref pointer instrumented by RC opt, NOT serialized
   bool isImported = false;
+  bool isTmpUnused = false;  // when parse the mplt_inline file, mark all the new symbol as tmpunused
   StIdx stIdx { 0, 0 };
   TypeAttrs typeAttrs;
   GStrIdx nameStrIdx{ 0 };
diff --git a/src/maple_ir/include/mir_type.h b/src/maple_ir/include/mir_type.h
index e3f6f337149a544a478cb34889a4aa6f3c727732..cdaa18c32e7646452fc066cefa831580d10220b5 100755
--- a/src/maple_ir/include/mir_type.h
+++ b/src/maple_ir/include/mir_type.h
@@ -385,8 +385,8 @@ class GenericAttrs {
 };
 
 #if MIR_FEATURE_FULL
-constexpr int kShiftNumOfTypeKind = 8;
-constexpr int kShiftNumOfNameStrIdx = 6;
+constexpr size_t kShiftNumOfTypeKind = 8;
+constexpr size_t kShiftNumOfNameStrIdx = 6;
 class MIRType {
  public:
   MIRType(MIRTypeKind kind, PrimType pType) : typeKind(kind), primType(pType) {}
@@ -546,7 +546,7 @@ class MIRPtrType : public MIRType {
     return typeAttrs;
   }
 
-  void SetTypeAttrs(TypeAttrs attrs) {
+  void SetTypeAttrs(const TypeAttrs &attrs) {
     typeAttrs = attrs;
   }
 
@@ -932,7 +932,7 @@ class MIRStructType : public MIRType {
 
   void SetElemInferredTyIdx(size_t n, TyIdx tyIdx) {
     if (n >= fieldInferredTyIdx.size()) {
-      fieldInferredTyIdx.insert(fieldInferredTyIdx.end(), n + 1 - fieldInferredTyIdx.size(), kInitTyIdx);
+      (void)fieldInferredTyIdx.insert(fieldInferredTyIdx.end(), n + 1 - fieldInferredTyIdx.size(), kInitTyIdx);
     }
     ASSERT(n < fieldInferredTyIdx.size(), "array index out of range");
     fieldInferredTyIdx.at(n) = tyIdx;
@@ -940,7 +940,7 @@ class MIRStructType : public MIRType {
 
   TyIdx GetElemInferredTyIdx(size_t n) {
     if (n >= fieldInferredTyIdx.size()) {
-      fieldInferredTyIdx.insert(fieldInferredTyIdx.end(), n + 1 - fieldInferredTyIdx.size(), kInitTyIdx);
+      (void)fieldInferredTyIdx.insert(fieldInferredTyIdx.end(), n + 1 - fieldInferredTyIdx.size(), kInitTyIdx);
     }
     ASSERT(n < fieldInferredTyIdx.size(), "array index out of range");
     return fieldInferredTyIdx.at(n);
@@ -1008,14 +1008,14 @@ class MIRStructType : public MIRType {
     genericDeclare.push_back(gd);
   }
 
-  void AddFieldGenericDeclare(GStrIdx g, AnnotationType *a) {
+  void AddFieldGenericDeclare(const GStrIdx &g, AnnotationType *a) {
     if (fieldGenericDeclare.find(g) != fieldGenericDeclare.end()) {
       CHECK_FATAL(fieldGenericDeclare[g] == a, "MUST BE");
     }
     fieldGenericDeclare[g] = a;
   }
 
-  AnnotationType *GetFieldGenericDeclare(GStrIdx g) {
+  AnnotationType *GetFieldGenericDeclare(const GStrIdx &g) {
     if (fieldGenericDeclare.find(g) == fieldGenericDeclare.end()) {
       return nullptr;
     }
diff --git a/src/maple_ir/src/bin_mpl_export.cpp b/src/maple_ir/src/bin_mpl_export.cpp
index 175047f39f698499300ac8cfc77f4b4a607b232d..4e5a1635a09263cd7f4bae8f41b787be26acf924 100755
--- a/src/maple_ir/src/bin_mpl_export.cpp
+++ b/src/maple_ir/src/bin_mpl_export.cpp
@@ -66,7 +66,7 @@ void OutputConstStr16(const MIRConst &constVal, BinaryMplExport &mplExport) {
   const auto &mirStr16 = static_cast<const MIRStr16Const&>(constVal);
   std::u16string str16 = GlobalTables::GetU16StrTable().GetStringFromStrIdx(mirStr16.GetValue());
   std::string str;
-  namemangler::UTF16ToUTF8(str, str16);
+  (void)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 5f7f9b66f654b604914b71a6c25c4796a747d65a..5f709e928a2dd53c88f6ca661913ee33742fc1bb 100755
--- a/src/maple_ir/src/bin_mpl_import.cpp
+++ b/src/maple_ir/src/bin_mpl_import.cpp
@@ -144,7 +144,7 @@ MIRConst *BinaryMplImport::ImportConst(MIRFunction *func) {
         ostr << Read();
       }
       std::u16string str16;
-      namemangler::UTF8ToUTF16(str16, ostr.str());
+      (void)namemangler::UTF8ToUTF16(str16, ostr.str());
       cs->SetStrIdx(GlobalTables::GetU16StrTable().GetOrCreateStrIdxFromName(str16));
       return memPool->New<MIRStr16Const>(cs->GetStrIdx(), *type);
     }
@@ -385,9 +385,9 @@ void BinaryMplImport::ImportInfoIsStringOfStructType(MIRStructType &type) {
 }
 
 void BinaryMplImport::ImportInfoOfStructType(MIRStructType &type) {
-  int64 size = ReadNum();
+  uint64 size = static_cast<uint64>(ReadNum());
   bool isEmpty = type.GetInfo().empty();
-  for (int64 i = 0; i < size; ++i) {
+  for (size_t i = 0; i < size; ++i) {
     GStrIdx idx = ImportStr();
     int64 x = (type.GetInfoIsStringElemt(i)) ? static_cast<int64>(ImportStr()) : ReadNum();
     CHECK_FATAL(x >= 0, "ReadNum nagative, x: %d", x);
diff --git a/src/maple_ir/src/driver.cpp b/src/maple_ir/src/driver.cpp
index 4dcd1807be2d0154eacccb847fcc793d2c1072e5..5e04174ea74b68c2e3c0742fef8c5fe829b3e866 100644
--- a/src/maple_ir/src/driver.cpp
+++ b/src/maple_ir/src/driver.cpp
@@ -40,7 +40,7 @@ void ConstantFoldModule(MIRModule &module) {
 int main(int argc, char **argv) {
   constexpr int judgeNumber = 2;
   if (argc < judgeNumber) {
-    MIR_PRINTF(
+    (void)MIR_PRINTF(
         "usage: ./irbuild [i|e] <any number of mpl files>\n\n"
         "The optional 'i' flag will convert the binary mplt input file to ascii\n\n"
         "The optional 'e' flag will convert the textual mplt input file to binary\n");
@@ -83,7 +83,7 @@ int main(int argc, char **argv) {
       BinaryMplImport binMplt(module);
       binMplt.SetImported(false);
       const std::string &modID = module.GetFileName();
-      binMplt.Import(modID, true);
+      (void)binMplt.Import(modID, true);
       module.OutputAsciiMpl(".irb");
     }
     ++i;
diff --git a/src/maple_ir/src/global_tables.cpp b/src/maple_ir/src/global_tables.cpp
index d9c437d44ff82a243b2019131c8f428042c7bf5c..b5d3c5855cd9dec40f5df21d7add97142e832638 100755
--- a/src/maple_ir/src/global_tables.cpp
+++ b/src/maple_ir/src/global_tables.cpp
@@ -60,7 +60,7 @@ TypeTable::~TypeTable() {
 }
 
 void TypeTable::PutToHashTable(MIRType *mirType) {
-  typeHashTable.insert(mirType);
+  (void)typeHashTable.insert(mirType);
 }
 
 MIRType *TypeTable::CreateAndUpdateMirTypeNode(MIRType &pType) {
@@ -78,7 +78,7 @@ MIRType *TypeTable::CreateAndUpdateMirTypeNode(MIRType &pType) {
       }
     }
   } else {
-    typeHashTable.insert(nType);
+    (void)typeHashTable.insert(nType);
   }
   return nType;
 }
@@ -113,7 +113,7 @@ MIRType* TypeTable::GetOrCreateMIRTypeNode(MIRType &pType) {
 
 MIRType *TypeTable::voidPtrType = nullptr;
 // get or create a type that pointing to pointedTyIdx
-  MIRType *TypeTable::GetOrCreatePointerType(TyIdx pointedTyIdx, PrimType primType,
+  MIRType *TypeTable::GetOrCreatePointerType(const TyIdx &pointedTyIdx, PrimType primType,
                                              const std::vector<TypeAttrs> attrs) {
   MIRPtrType type(pointedTyIdx, primType);
   if (!attrs.empty()) {
diff --git a/src/maple_ir/src/mir_builder.cpp b/src/maple_ir/src/mir_builder.cpp
index 697b54f29f6c97f5a4bef0beeafd58f7c066e042..b0ecdc4d85f2e7b66b3b6e898411ea339a3326e2 100644
--- a/src/maple_ir/src/mir_builder.cpp
+++ b/src/maple_ir/src/mir_builder.cpp
@@ -61,7 +61,7 @@ bool MIRBuilder::TraverseToNamedField(MIRStructType &structType, GStrIdx nameIdx
 void MIRBuilder::TraverseToNamedFieldWithType(MIRStructType &structType, GStrIdx nameIdx, TyIdx typeIdx,
                                               uint32 &fieldID, uint32 &idx) {
   if (structType.IsIncomplete()) {
-    incompleteTypeRefedSet.insert(structType.GetTypeIndex());
+    (void)incompleteTypeRefedSet.insert(structType.GetTypeIndex());
   }
   // process parent
   if (structType.GetKind() == kTypeClass || structType.GetKind() == kTypeClassIncomplete) {
@@ -108,7 +108,7 @@ void MIRBuilder::TraverseToNamedFieldWithType(MIRStructType &structType, GStrIdx
 bool MIRBuilder::TraverseToNamedFieldWithTypeAndMatchStyle(MIRStructType &structType, GStrIdx nameIdx, TyIdx typeIdx,
                                                            uint32 &fieldID, unsigned int matchStyle) {
   if (structType.IsIncomplete()) {
-    incompleteTypeRefedSet.insert(structType.GetTypeIndex());
+    (void)incompleteTypeRefedSet.insert(structType.GetTypeIndex());
   }
   if (matchStyle & kParentFirst) {
     // process parent
diff --git a/src/maple_ir/src/mir_const.cpp b/src/maple_ir/src/mir_const.cpp
index 9e80873b80b3e7fac7b05e855fdc4d7699dd67e0..94137283628a3c4581f3ca88b8938cd77d93fa46 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);
+  (void)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 8bc0209832518119712853d39e192ede3af4e7aa..bf6f98dad3a09a17ef0ebdcf6b69a24d36a17bdc 100644
--- a/src/maple_ir/src/mir_function.cpp
+++ b/src/maple_ir/src/mir_function.cpp
@@ -116,7 +116,7 @@ void MIRFunction::UpdateFuncTypeAndFormals(const std::vector<MIRSymbol*> &symbol
   delete newFuncType;
 }
 
-void MIRFunction::UpdateFuncTypeAndFormalsAndReturnType(const std::vector<MIRSymbol*> &symbols, TyIdx retTyIdx,
+void MIRFunction::UpdateFuncTypeAndFormalsAndReturnType(const std::vector<MIRSymbol*> &symbols, const TyIdx &retTyIdx,
                                                         bool clearOldArgs) {
   auto *newFuncType = ReconstructFormals(symbols, clearOldArgs);
   newFuncType->SetRetTyIdx(retTyIdx);
diff --git a/src/maple_ir/src/mir_module.cpp b/src/maple_ir/src/mir_module.cpp
index a7a731b305d03b50d3101458771d2784bfa4e23e..e14241106337058272de8c8fe886ce060769cdba 100644
--- a/src/maple_ir/src/mir_module.cpp
+++ b/src/maple_ir/src/mir_module.cpp
@@ -67,24 +67,24 @@ MemPool *MIRModule::CurFuncCodeMemPool() const {
 }
 
 MapleAllocator *MIRModule::CurFuncCodeMemPoolAllocator() const {
-  MIRFunction *curFunction = CurFunction();
-  CHECK_FATAL(curFunction != nullptr, "curFunction is null");
-  return &curFunction->GetCodeMempoolAllocator();
+  MIRFunction *curFunc = CurFunction();
+  CHECK_FATAL(curFunc != nullptr, "curFunction is null");
+  return &curFunc->GetCodeMempoolAllocator();
 }
 
 MapleAllocator &MIRModule::GetCurFuncCodeMPAllocator() const {
-  MIRFunction *curFunction = CurFunction();
-  CHECK_FATAL(curFunction != nullptr, "curFunction is null");
-  return curFunction->GetCodeMPAllocator();
+  MIRFunction *curFunc = CurFunction();
+  CHECK_FATAL(curFunc != nullptr, "curFunction is null");
+  return curFunc->GetCodeMPAllocator();
 }
 
 void MIRModule::AddExternStructType(TyIdx tyIdx) {
-  externStructTypeSet.insert(tyIdx);
+  (void)externStructTypeSet.insert(tyIdx);
 }
 
 void MIRModule::AddExternStructType(const MIRType *t) {
   ASSERT(t != nullptr, "MIRType is null");
-  externStructTypeSet.insert(t->GetTypeIndex());
+  (void)externStructTypeSet.insert(t->GetTypeIndex());
 }
 
 void MIRModule::AddSymbol(StIdx stIdx) {
@@ -92,7 +92,7 @@ void MIRModule::AddSymbol(StIdx stIdx) {
   if (it == symbolSet.end()) {
     symbolDefOrder.push_back(stIdx);
   }
-  symbolSet.insert(stIdx);
+  (void)symbolSet.insert(stIdx);
 }
 
 void MIRModule::AddSymbol(const MIRSymbol *s) {
@@ -431,7 +431,7 @@ void MIRModule::DumpClassToFile(const std::string &path) const {
     std::string outClassFile(name);
     /* replace class name / with - */
     std::replace(outClassFile.begin(), outClassFile.end(), '/', '-');
-    outClassFile.insert(0, strPath);
+    (void)outClassFile.insert(0, strPath);
     outClassFile.append(".mpl");
     std::ofstream mplFile;
     mplFile.open(outClassFile, std::ios::trunc);
@@ -517,11 +517,11 @@ std::string MIRModule::GetFileNameAsPostfix() const {
 }
 
 void MIRModule::AddClass(TyIdx tyIdx) {
-  classList.insert(tyIdx);
+  (void)classList.insert(tyIdx);
 }
 
 void MIRModule::RemoveClass(TyIdx tyIdx) {
-  classList.erase(tyIdx);
+  (void)classList.erase(tyIdx);
 }
 
 #endif  // MIR_FEATURE_FULL
diff --git a/src/maple_ir/src/mir_nodes.cpp b/src/maple_ir/src/mir_nodes.cpp
index 8fc9f2abc8e4cb30ef8521539e126964dab35cf1..9613d045f02ef3f0373b57dab7728976369c1c39 100644
--- a/src/maple_ir/src/mir_nodes.cpp
+++ b/src/maple_ir/src/mir_nodes.cpp
@@ -195,14 +195,14 @@ void BlockNode::ReplaceStmt1WithStmt2(const StmtNode *stmtNode1, StmtNode *stmtN
   } else {
     // replace stmtNode1 with stmtNode2
     stmtNodeList.insert(stmtNode1, stmtNode2);
-    stmtNodeList.erase(stmtNode1);
+    (void)stmtNodeList.erase(stmtNode1);
   }
 }
 
 // remove sstmtNode1 from block
 void BlockNode::RemoveStmt(StmtNode *stmtNode1) {
   ASSERT(stmtNode1 != nullptr, "delete a null stmtment");
-  stmtNodeList.erase(stmtNode1);
+  (void)stmtNodeList.erase(stmtNode1);
 }
 
 /// Insert stmtNode2 before stmtNode1 in current block.
@@ -513,7 +513,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);
+  (void)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 997381311aba9dd129d57497fc425262efe0128c..8d14fe8c2fbb5aecdcdc61a6de305d1bca5b59b4 100644
--- a/src/maple_ir/src/mir_parser.cpp
+++ b/src/maple_ir/src/mir_parser.cpp
@@ -556,7 +556,7 @@ bool MIRParser::ParseStmtSwitch(StmtNodePtr &stmt) {
       return false;
     }
     switchNode->InsertCasePair(CasePair(constVal, lbl));
-    casesSet.insert(constVal);
+    (void)casesSet.insert(constVal);
     tk = lexer.GetTokenKind();
   }
   lexer.NextToken();
@@ -616,7 +616,7 @@ bool MIRParser::ParseStmtRangegoto(StmtNodePtr &stmt) {
       maxIdx = constVal;
     }
     rangeGotoNode->AddRangeGoto(static_cast<uint32>(constVal), static_cast<uint32>(lbl));
-    casesSet.insert(constVal);
+    (void)casesSet.insert(constVal);
     tk = lexer.GetTokenKind();
   }
   ASSERT(rangeGotoNode->GetNumOpnds() == 1, "Rangegoto is a UnaryOpnd; numOpnds must be 1");
@@ -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);
+  (void)namemangler::UTF8ToUTF16(str16, str);
   str16Const->SetStrIdx(GlobalTables::GetU16StrTable().GetOrCreateStrIdxFromName(str16));
   expr = str16Const;
   lexer.NextToken();
diff --git a/src/maple_ir/src/parser.cpp b/src/maple_ir/src/parser.cpp
index 8287f2c1b37c95922bc36255efd01871369757a6..8fb3200792a24894d071acfe251fcdce9a8a4ae9 100755
--- a/src/maple_ir/src/parser.cpp
+++ b/src/maple_ir/src/parser.cpp
@@ -2689,7 +2689,7 @@ bool MIRParser::ParseMIRForImport() {
   }
   GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(importFileName);
   auto it = mod.GetImportFiles().begin();
-  mod.GetImportFiles().insert(it, strIdx);
+  (void)mod.GetImportFiles().insert(it, strIdx);
   // record the imported file for later reading summary info, if exists
   mod.PushbackImportedMplt(importFileName);
   lexer.NextToken();
diff --git a/src/maple_me/include/alias_analysis_table.h b/src/maple_me/include/alias_analysis_table.h
index ada71c325b3223b992aa81c7bbbcd64fefcd5bf5..9748f06ef0a54f75dac53a313da4835ccad39181 100644
--- a/src/maple_me/include/alias_analysis_table.h
+++ b/src/maple_me/include/alias_analysis_table.h
@@ -21,7 +21,7 @@
 namespace maple {
 class AliasAnalysisTable {
  public:
-  AliasAnalysisTable(SSATab &ssaTable, MapleAllocator allocator, KlassHierarchy &kh)
+  AliasAnalysisTable(SSATab &ssaTable, const MapleAllocator &allocator, KlassHierarchy &kh)
       : ssaTab(ssaTable),
         alloc(allocator),
         prevLevelNode(alloc.Adapter()),
diff --git a/src/maple_me/include/me_cfg.h b/src/maple_me/include/me_cfg.h
index cc7c61c594de81589add13071e60a653e75355dc..cd5340f7113d6c2ba9c9adc4771d234940fbb63b 100755
--- a/src/maple_me/include/me_cfg.h
+++ b/src/maple_me/include/me_cfg.h
@@ -27,7 +27,7 @@ class MeCFG {
   void BuildMirCFG();
   void FixMirCFG();
   void ConvertPhis2IdentityAssigns(BB &meBB) const;
-  void UnreachCodeAnalysis(bool updatePhi = false);
+  bool UnreachCodeAnalysis(bool updatePhi = false);
   void WontExitAnalysis();
   void Verify() const;
   void VerifyLabels() const;
diff --git a/src/maple_me/include/me_inequality_graph.h b/src/maple_me/include/me_inequality_graph.h
index d307444ca4b0bfc0008dcba3f2fcfa7ce1cc1ba2..c87bc87df09589258c9466dc01b7d36fb0857d37 100755
--- a/src/maple_me/include/me_inequality_graph.h
+++ b/src/maple_me/include/me_inequality_graph.h
@@ -202,19 +202,19 @@ class ESSABaseNode {
   }
 
   virtual void InsertOutWithConstEdgeMap(ESSABaseNode &node, InequalEdge &e) {
-    outWithConstEdge.insert(std::pair<ESSABaseNode*, InequalEdge*>(&node, &e));
+    (void)outWithConstEdge.insert(std::pair<ESSABaseNode*, InequalEdge*>(&node, &e));
   }
 
   virtual void InsertOutWithVarEdgeMap(ESSABaseNode &node, InequalEdge &e) {
-    outWithVarEdge.insert(std::pair<ESSABaseNode*, InequalEdge*>(&node, &e));
+    (void)outWithVarEdge.insert(std::pair<ESSABaseNode*, InequalEdge*>(&node, &e));
   }
 
   virtual void InsertInWithConstEdgeMap(ESSABaseNode &node, InequalEdge &e) {
-    inWithConstEdge.insert(std::pair<ESSABaseNode*, InequalEdge*>(&node, &e));
+    (void)inWithConstEdge.insert(std::pair<ESSABaseNode*, InequalEdge*>(&node, &e));
   }
 
   virtual void InsertInWithVarEdgeMap(ESSABaseNode &node, InequalEdge &e) {
-    inWithVarEdge.insert(std::pair<ESSABaseNode*, InequalEdge*>(&node, &e));
+    (void)inWithVarEdge.insert(std::pair<ESSABaseNode*, InequalEdge*>(&node, &e));
   }
 
   virtual void InsertEdges(std::unique_ptr<InequalEdge> e) {
@@ -292,10 +292,10 @@ class ESSAPhiNode : public ESSABaseNode {
     return outPhiNodes;
   }
   void InsertInPhiEdgeMap(ESSABaseNode &node, InequalEdge &e) {
-    inPhiNodes.insert(std::pair<ESSABaseNode*, InequalEdge*>(&node, &e));
+    (void)inPhiNodes.insert(std::pair<ESSABaseNode*, InequalEdge*>(&node, &e));
   }
   void InsertOutPhiEdgeMap(ESSABaseNode &node, InequalEdge &e) {
-    outPhiNodes.insert(std::pair<ESSABaseNode*, InequalEdge*>(&node, &e));
+    (void)outPhiNodes.insert(std::pair<ESSABaseNode*, InequalEdge*>(&node, &e));
   }
 
  private:
diff --git a/src/maple_me/include/me_ir.h b/src/maple_me/include/me_ir.h
index e01ceaceeef6ec99312f66d5dd39bbf2152e3983..23afe7ccca209c98358dc6317086133b9f12bb6a 100755
--- a/src/maple_me/include/me_ir.h
+++ b/src/maple_me/include/me_ir.h
@@ -197,7 +197,7 @@ class IassignMeStmt;  // circular dependency exists, no other choice
 // base class for VarMeExpr and RegMeExpr
 class ScalarMeExpr : public MeExpr {
  public:
-  ScalarMeExpr(int32 exprid, OStIdx oidx, uint32 vidx, MeExprOp meop)
+  ScalarMeExpr(int32 exprid, const OStIdx &oidx, uint32 vidx, MeExprOp meop)
       : MeExpr(exprid, meop),
         ostIdx(oidx),
         vstIdx(vidx),
@@ -246,7 +246,7 @@ class ScalarMeExpr : public MeExpr {
   }
 
   void SetVstIdx(size_t vstIdxVal) {
-    vstIdx = vstIdxVal;
+    vstIdx = static_cast<uint32>(vstIdxVal);
   }
 
   MeDefBy GetDefBy() const {
@@ -1902,15 +1902,15 @@ class NaryMeStmt : public MeStmt {
   }
 
   void EraseOpnds(const MapleVector<MeExpr*>::const_iterator begin, const MapleVector<MeExpr*>::const_iterator end) {
-    opnds.erase(begin, end);
+    (void)opnds.erase(begin, end);
   }
 
   void EraseOpnds(const MapleVector<MeExpr *>::const_iterator it) {
-    opnds.erase(it);
+    (void)opnds.erase(it);
   }
 
   void InsertOpnds(const MapleVector<MeExpr*>::const_iterator begin, MeExpr *expr) {
-    opnds.insert(begin, expr);
+    (void)opnds.insert(begin, expr);
   }
 
   void DumpOpnds(const IRMap*) const;
@@ -2492,7 +2492,7 @@ class SwitchMeStmt : public UnaryMeStmt {
 
 class CommentMeStmt : public MeStmt {
  public:
-  CommentMeStmt(MapleAllocator *alloc, const StmtNode *stt) : MeStmt(stt), comment(alloc->GetMemPool()) {
+  CommentMeStmt(const MapleAllocator *alloc, const StmtNode *stt) : MeStmt(stt), comment(alloc->GetMemPool()) {
     comment = static_cast<const CommentNode*>(stt)->GetComment();
   }
 
diff --git a/src/maple_me/include/ssa_mir_nodes.h b/src/maple_me/include/ssa_mir_nodes.h
index 31b680ef197d7e4396c31164e5ff0800c3bbf92f..e9606d7c0e9a57abca2daf0c9fc48faa6618ba46 100644
--- a/src/maple_me/include/ssa_mir_nodes.h
+++ b/src/maple_me/include/ssa_mir_nodes.h
@@ -189,7 +189,7 @@ class AccessSSANodes {
 
   virtual void InsertMayDefNode(VersionSt *vst, StmtNode *stmtNode) {
     CHECK_FATAL(vst != nullptr, "null ptr check");
-    GetMayDefNodes().insert(std::make_pair(vst->GetOrigSt()->GetIndex(), MayDefNode(vst, stmtNode)));
+    (void)GetMayDefNodes().insert(std::make_pair(vst->GetOrigSt()->GetIndex(), MayDefNode(vst, stmtNode)));
   }
 
   virtual void InsertMustDefNode(VersionSt *sym, StmtNode *s) {
diff --git a/src/maple_me/src/alias_analysis_table.cpp b/src/maple_me/src/alias_analysis_table.cpp
index 3a1b14d80cab28bd21070f7a9d2d35f162c51acb..5374429d93b7de1c1d00320b7c56034c8e478d2e 100644
--- a/src/maple_me/src/alias_analysis_table.cpp
+++ b/src/maple_me/src/alias_analysis_table.cpp
@@ -31,7 +31,7 @@ MapleVector<OriginalSt*> *AliasAnalysisTable::GetNextLevelNodes(const OriginalSt
 
   MapleVector<OriginalSt*> *newOriginalStVec =
       alloc.GetMemPool()->New<MapleVector<OriginalSt*>>(alloc.Adapter());
-  nextLevelNodes.insert(std::make_pair(ost.GetIndex(), newOriginalStVec));
+  (void)nextLevelNodes.insert(std::make_pair(ost.GetIndex(), newOriginalStVec));
   return newOriginalStVec;
 }
 
@@ -51,7 +51,7 @@ OriginalSt *AliasAnalysisTable::FindOrCreateAddrofSymbolOriginalSt(OriginalSt &o
   prevLevelOst->SetTyIdx(newTyIdx);
   prevLevelOst->SetFieldID(ost.GetFieldID());
   GetNextLevelNodes(*prevLevelOst)->push_back(&ost);
-  prevLevelNode.insert(std::make_pair(ost.GetIndex(), prevLevelOst));
+  (void)prevLevelNode.insert(std::make_pair(ost.GetIndex(), prevLevelOst));
   return prevLevelOst;
 }
 
@@ -79,7 +79,7 @@ OriginalSt *AliasAnalysisTable::FindOrCreateExtraLevSymOrRegOriginalSt(OriginalS
   originalStTab.GetOriginalStVector().push_back(nextLevOst);
   CHECK_FATAL(ost.GetIndirectLev() < INT8_MAX, "boundary check");
   nextLevOst->SetIndirectLev(ost.GetIndirectLev() + 1);
-  prevLevelNode.insert(std::make_pair(nextLevOst->GetIndex(), &ost));
+  (void)prevLevelNode.insert(std::make_pair(nextLevOst->GetIndex(), &ost));
   tyIdx = (tyIdx == 0u) ? ost.GetTyIdx() : tyIdx;
   if (tyIdx != 0u) {
     // use the tyIdx info from the instruction
diff --git a/src/maple_me/src/alias_class.cpp b/src/maple_me/src/alias_class.cpp
index 023b031d3500760444564a0e140baef0cda6f025..87c01f75fe974340dee69b2c2c80a3bb41975c3e 100644
--- a/src/maple_me/src/alias_class.cpp
+++ b/src/maple_me/src/alias_class.cpp
@@ -67,10 +67,10 @@ AliasElem *AliasClass::FindOrCreateAliasElem(OriginalSt &ost) {
   if (ost.IsSymbolOst() && ost.GetIndirectLev() >= 0) {
     const MIRSymbol *sym = ost.GetMIRSymbol();
     if (sym->IsGlobal() && !sym->HasAddrOfValues() && !sym->GetIsTmp()) {
-      globalsMayAffectedByClinitCheck.insert(ostIdx);
+      (void)globalsMayAffectedByClinitCheck.insert(ostIdx);
       if (!sym->IsReflectionClassInfo()) {
         if (!ost.IsFinal() || InConstructorLikeFunc()) {
-          globalsAffectedByCalls.insert(aliasElem->GetClassID());
+          (void)globalsAffectedByCalls.insert(aliasElem->GetClassID());
         }
         aliasElem->SetNextLevNotAllDefsSeen(true);
       }
@@ -233,7 +233,7 @@ void AliasClass::ApplyUnionForCopies(StmtNode &stmt) {
       auto &call = static_cast<CallNode&>(stmt);
       ASSERT(call.GetPUIdx() < GlobalTables::GetFunctionTable().GetFuncTable().size(),
              "index out of range in AliasClass::ApplyUnionForCopies");
-      SetPtrOpndsNextLevNADS(0, call.NumOpnds(), call.GetNopnd(), false);
+      SetPtrOpndsNextLevNADS(0, static_cast<unsigned int>(call.NumOpnds()), call.GetNopnd(), false);
       break;
     }
     case OP_icall:
@@ -254,7 +254,8 @@ void AliasClass::ApplyUnionForCopies(StmtNode &stmt) {
     case OP_polymorphiccallassigned: {
       auto &call = static_cast<CallNode&>(stmt);
       if (CallHasSideEffect(call)) {
-        SetPtrOpndsNextLevNADS(1, call.NumOpnds(), call.GetNopnd(), CallHasNoPrivateDefEffect(call));
+        SetPtrOpndsNextLevNADS(1, static_cast<unsigned int>(call.NumOpnds()),
+                               call.GetNopnd(), CallHasNoPrivateDefEffect(call));
       }
       break;
     }
@@ -262,7 +263,7 @@ void AliasClass::ApplyUnionForCopies(StmtNode &stmt) {
     case OP_intrinsiccallassigned: {
       auto &intrnNode = static_cast<IntrinsiccallNode&>(stmt);
       if (intrnNode.GetIntrinsic() == INTRN_JAVA_POLYMORPHIC_CALL) {
-        SetPtrOpndsNextLevNADS(0, intrnNode.NumOpnds(), intrnNode.GetNopnd(), false);
+        SetPtrOpndsNextLevNADS(0, static_cast<unsigned int>(intrnNode.NumOpnds()), intrnNode.GetNopnd(), false);
         break;
       }
       //  fallthrough;
@@ -371,7 +372,7 @@ void AliasClass::CollectRootIDOfNextLevelNodes(const OriginalSt &ost,
   for (OriginalSt *nextLevelNode : *(GetAliasAnalysisTable()->GetNextLevelNodes(ost))) {
     if (!nextLevelNode->IsFinal()) {
       uint32 id = FindAliasElem(*nextLevelNode)->GetClassID();
-      rootIDOfNADSs.insert(unionFind.Root(id));
+      (void)rootIDOfNADSs.insert(unionFind.Root(id));
     }
   }
 }
@@ -442,9 +443,9 @@ void AliasClass::CollectAliasGroups(std::map<unsigned int, std::set<unsigned int
 
     if (aliasGroups.find(rootID) == aliasGroups.end()) {
       std::set<unsigned int> idsAliasWithRoot;
-      aliasGroups.insert(make_pair(rootID, idsAliasWithRoot));
+      (void)aliasGroups.insert(make_pair(rootID, idsAliasWithRoot));
     }
-    aliasGroups[rootID].insert(id);
+    (void)aliasGroups[rootID].insert(id);
   }
 }
 
@@ -631,7 +632,7 @@ void AliasClass::InsertMayUseExpr(BaseNode &expr) {
 // collect the mayUses caused by globalsAffectedByCalls.
 void AliasClass::CollectMayUseFromGlobalsAffectedByCalls(std::set<OriginalSt*> &mayUseOsts) {
   for (unsigned int elemID : globalsAffectedByCalls) {
-    mayUseOsts.insert(&id2Elem[elemID]->GetOriginalSt());
+    (void)mayUseOsts.insert(&id2Elem[elemID]->GetOriginalSt());
   }
 }
 
@@ -640,11 +641,11 @@ void AliasClass::CollectMayUseFromNADS(std::set<OriginalSt*> &mayUseOsts) {
   for (AliasElem *notAllDefsSeenAE : notAllDefsSeenClassSetRoots) {
     if (notAllDefsSeenAE->GetClassSet() == nullptr) {
       // single mayUse
-      mayUseOsts.insert(&notAllDefsSeenAE->GetOriginalSt());
+      (void)mayUseOsts.insert(&notAllDefsSeenAE->GetOriginalSt());
     } else {
       for (unsigned int elemID : *(notAllDefsSeenAE->GetClassSet())) {
         AliasElem *aliasElem = id2Elem[elemID];
-        mayUseOsts.insert(&aliasElem->GetOriginalSt());
+        (void)mayUseOsts.insert(&aliasElem->GetOriginalSt());
       }
     }
   }
@@ -669,7 +670,7 @@ void AliasClass::CollectMayUseFromDefinedFinalField(std::set<OriginalSt*> &mayUs
     ASSERT(ptrType->IsMIRPtrType(), "Type of pointer must be MIRPtrType!");
     tyIdx = static_cast<MIRPtrType*>(ptrType)->GetPointedTyIdx();
     if (tyIdx == mirModule.CurFunction()->GetClassTyIdx()) {
-      mayUseOsts.insert(&ost);
+      (void)mayUseOsts.insert(&ost);
     }
   }
 }
@@ -677,7 +678,7 @@ void AliasClass::CollectMayUseFromDefinedFinalField(std::set<OriginalSt*> &mayUs
 // insert the ost of mayUseOsts into mayUseNodes
 void AliasClass::InsertMayUseNode(std::set<OriginalSt*> &mayUseOsts, MapleMap<OStIdx, MayUseNode> &mayUseNodes) {
   for (OriginalSt *ost : mayUseOsts) {
-    mayUseNodes.insert(std::make_pair(
+    (void)mayUseNodes.insert(std::make_pair(
         ost->GetIndex(), MayUseNode(ssaTab.GetVersionStTable().GetVersionStFromID(ost->GetZeroVersionIndex()))));
   }
 }
@@ -707,10 +708,10 @@ void AliasClass::CollectPtsToOfReturnOpnd(const OriginalSt &ost, std::set<Origin
     AliasElem *aliasElem = FindAliasElem(*nextLevelOst);
     if (!aliasElem->IsNotAllDefsSeen() && !aliasElem->GetOriginalSt().IsFinal()) {
       if (aliasElem->GetClassSet() == nullptr) {
-        mayUseOsts.insert(&aliasElem->GetOriginalSt());
+        (void)mayUseOsts.insert(&aliasElem->GetOriginalSt());
       } else {
         for (unsigned int elemID : *(aliasElem->GetClassSet())) {
-          mayUseOsts.insert(&id2Elem[elemID]->GetOriginalSt());
+          (void)mayUseOsts.insert(&id2Elem[elemID]->GetOriginalSt());
         }
       }
     }
@@ -744,7 +745,7 @@ void AliasClass::InsertMayUseAll(const StmtNode &stmt) {
   MapleMap<OStIdx, MayUseNode> &mayUseNodes = ssaTab.GetStmtsSSAPart().GetMayUseNodesOf(stmt);
   for (AliasElem *aliasElem : id2Elem) {
     if (aliasElem->GetOriginalSt().GetIndirectLev() >= 0 && !aliasElem->GetOriginalSt().IsPregOst()) {
-      mayUseNodes.insert(std::make_pair(
+      (void)mayUseNodes.insert(std::make_pair(
           aliasElem->GetOriginalSt().GetIndex(),
           MayUseNode(ssaTab.GetVersionStTable().GetVersionStFromID(aliasElem->GetOriginalSt().GetZeroVersionIndex()))));
     }
@@ -771,7 +772,7 @@ void AliasClass::CollectMayDefForDassign(const StmtNode &stmt, std::set<Original
 void AliasClass::InsertMayDefNode(std::set<OriginalSt*> &mayDefOsts, MapleMap<OStIdx, MayDefNode> &mayDefNodes,
                                   StmtNode &stmt) {
   for (OriginalSt *mayDefOst : mayDefOsts) {
-    mayDefNodes.insert(std::make_pair(
+    (void)mayDefNodes.insert(std::make_pair(
         mayDefOst->GetIndex(),
         MayDefNode(ssaTab.GetVersionStTable().GetVersionStFromID(mayDefOst->GetZeroVersionIndex()), &stmt)));
   }
@@ -816,13 +817,13 @@ void AliasClass::CollectMayDefForIassign(StmtNode &stmt, std::set<OriginalSt*> &
   }
   // lhsAe does not alias with any aliasElem
   if (lhsAe->GetClassSet() == nullptr) {
-    mayDefOsts.insert(&lhsAe->GetOriginalSt());
+    (void)mayDefOsts.insert(&lhsAe->GetOriginalSt());
     return;
   }
   for (unsigned int elemID : *(lhsAe->GetClassSet())) {
     AliasElem *aliasElem = id2Elem[elemID];
     OriginalSt &ostOfAliasAE = aliasElem->GetOriginalSt();
-    mayDefOsts.insert(&ostOfAliasAE);
+    (void)mayDefOsts.insert(&ostOfAliasAE);
   }
 }
 
@@ -830,7 +831,7 @@ void AliasClass::InsertMayDefNodeExcludeFinalOst(std::set<OriginalSt*> &mayDefOs
                                                  MapleMap<OStIdx, MayDefNode> &mayDefNodes, StmtNode &stmt) {
   for (OriginalSt *mayDefOst : mayDefOsts) {
     if (!mayDefOst->IsFinal()) {
-      mayDefNodes.insert(std::make_pair(
+      (void)mayDefNodes.insert(std::make_pair(
           mayDefOst->GetIndex(),
           MayDefNode(ssaTab.GetVersionStTable().GetVersionStFromID(mayDefOst->GetZeroVersionIndex()), &stmt)));
     }
@@ -874,7 +875,7 @@ void AliasClass::InsertMayDefUseSyncOps(StmtNode &stmt) {
         if (notAllDefsSeenAE->GetClassSet() != nullptr) {
           aliasSet.insert(notAllDefsSeenAE->GetClassSet()->cbegin(), notAllDefsSeenAE->GetClassSet()->cend());
         } else {
-          aliasSet.insert(notAllDefsSeenAE->GetClassID());
+          (void)aliasSet.insert(notAllDefsSeenAE->GetClassID());
         }
       }
     }
@@ -887,8 +888,8 @@ void AliasClass::InsertMayDefUseSyncOps(StmtNode &stmt) {
     if (!ostOfAliasAE.IsFinal()) {
       OStIdx ostIdx = ostOfAliasAE.GetIndex();
       VersionSt *vst0 = ssaTab.GetVersionStTable().GetVersionStFromID(ostOfAliasAE.GetZeroVersionIndex());
-      theSSAPart->GetMayUseNodes().insert(std::make_pair(ostIdx, MayUseNode(vst0)));
-      theSSAPart->GetMayDefNodes().insert(std::make_pair(ostIdx, MayDefNode(vst0, &stmt)));
+      (void)theSSAPart->GetMayUseNodes().insert(std::make_pair(ostIdx, MayUseNode(vst0)));
+      (void)theSSAPart->GetMayDefNodes().insert(std::make_pair(ostIdx, MayDefNode(vst0, &stmt)));
     }
   }
 }
@@ -907,7 +908,7 @@ void AliasClass::CollectMayDefForMustDefs(const StmtNode &stmt, std::set<Origina
       AliasElem *aliasElem = id2Elem[elemID];
       if (elemID != lhsAe->GetClassID() &&
           aliasElem->GetOriginalSt().GetTyIdx() == lhsAe->GetOriginalSt().GetMIRSymbol()->GetTyIdx()) {
-        mayDefOsts.insert(&aliasElem->GetOriginalSt());
+        (void)mayDefOsts.insert(&aliasElem->GetOriginalSt());
       }
     }
   }
@@ -955,10 +956,10 @@ void AliasClass::CollectMayUseForCallOpnd(const StmtNode &stmt, std::set<Origina
       }
 
       if (indAe->GetClassSet() == nullptr) {
-        mayUseOsts.insert(&indAe->GetOriginalSt());
+        (void)mayUseOsts.insert(&indAe->GetOriginalSt());
       } else {
         for (unsigned int elemID : *(indAe->GetClassSet())) {
-          mayUseOsts.insert(&id2Elem[elemID]->GetOriginalSt());
+          (void)mayUseOsts.insert(&id2Elem[elemID]->GetOriginalSt());
         }
       }
     }
@@ -969,7 +970,7 @@ void AliasClass::InsertMayDefNodeForCall(std::set<OriginalSt*> &mayDefOsts, Mapl
                                          StmtNode &stmt, bool hasNoPrivateDefEffect) {
   for (OriginalSt *mayDefOst : mayDefOsts) {
     if (!hasNoPrivateDefEffect || !mayDefOst->IsPrivate()) {
-      mayDefNodes.insert(std::make_pair(
+      (void)mayDefNodes.insert(std::make_pair(
           mayDefOst->GetIndex(),
           MayDefNode(ssaTab.GetVersionStTable().GetVersionStFromID(mayDefOst->GetZeroVersionIndex()), &stmt)));
     }
@@ -1011,7 +1012,7 @@ void AliasClass::InsertMayUseNodeExcludeFinalOst(const std::set<OriginalSt*> &ma
                                                  MapleMap<OStIdx, MayUseNode> &mayUseNodes) {
   for (OriginalSt *mayUseOst : mayUseOsts) {
     if (!mayUseOst->IsFinal()) {
-      mayUseNodes.insert(
+      (void)mayUseNodes.insert(
           std::make_pair(mayUseOst->GetIndex(),
                          MayUseNode(ssaTab.GetVersionStTable().GetVersionStFromID(mayUseOst->GetZeroVersionIndex()))));
     }
@@ -1050,7 +1051,7 @@ void AliasClass::InsertMayDefUseClinitCheck(IntrinsiccallNode &stmt) {
     std::string typeNameOfOst = ostOfAE.GetMIRSymbol()->GetName();
     std::string typeNameOfStmt = GlobalTables::GetTypeTable().GetTypeFromTyIdx(stmt.GetTyIdx())->GetName();
     if (typeNameOfOst.find(typeNameOfStmt) != std::string::npos) {
-      mayDefNodes.insert(std::make_pair(
+      (void)mayDefNodes.insert(std::make_pair(
           ostOfAE.GetIndex(),
           MayDefNode(ssaTab.GetVersionStTable().GetVersionStFromID(ostOfAE.GetZeroVersionIndex()), &stmt)));
     }
diff --git a/src/maple_me/src/bb.cpp b/src/maple_me/src/bb.cpp
index 97bf17bacd2c53d09da0256b83bc1535cf07c912..b8abc89c8ae4e23262be7b3792b6d3256013cbba 100755
--- a/src/maple_me/src/bb.cpp
+++ b/src/maple_me/src/bb.cpp
@@ -120,7 +120,7 @@ void BB::InsertPhi(MapleAllocator *alloc, VersionSt *versionSt) {
   for (auto prevIt = pred.begin(); prevIt != pred.end(); ++prevIt) {
     phiNode.GetPhiOpnds().push_back(versionSt);
   }
-  phiList.insert(std::make_pair(versionSt->GetOrigSt()->GetIndex(), phiNode));
+  (void)phiList.insert(std::make_pair(versionSt->GetOrigSt()->GetIndex(), phiNode));
 }
 
 bool BB::IsInList(const MapleVector<BB*> &bbList) const {
diff --git a/src/maple_me/src/dse.cpp b/src/maple_me/src/dse.cpp
index e4ef3f0813abc357dfbd29acc0f45fd061282476..f54b8094d93e2d928b0c56eefe64d6171820816b 100644
--- a/src/maple_me/src/dse.cpp
+++ b/src/maple_me/src/dse.cpp
@@ -390,7 +390,7 @@ void DSE::MarkSpecialStmtRequired() {
 // Find all not null expr used as ivar's base、OP_array's or OP_assertnonnull's opnd
 // And save to notNullExpr2Stmt
 void DSE::CollectNotNullNode(StmtNode &stmt, BB &bb) {
-  uint8 opndNum = stmt.NumOpnds();
+  uint8 opndNum = static_cast<uint8>(stmt.NumOpnds());
   uint8 nodeType = kNodeTypeNormal;
   for (uint8 i = 0; i < opndNum; ++i) {
     BaseNode *opnd = stmt.Opnd(i);
diff --git a/src/maple_me/src/irmap.cpp b/src/maple_me/src/irmap.cpp
index daa0c774d3ef728101944edcdea71142e76c7b2d..8489cac08e8995e95ace053bda4bc581b01943d0 100755
--- a/src/maple_me/src/irmap.cpp
+++ b/src/maple_me/src/irmap.cpp
@@ -56,7 +56,7 @@ void IRMap::BuildPhiMeNode(BB &bb) {
 
     auto *phiMeNode = NewInPool<MePhiNode>();
     phiMeNode->SetDefBB(&bb);
-    bb.GetMePhiList().insert(std::make_pair(oSt->GetIndex(), phiMeNode));
+    (void)bb.GetMePhiList().insert(std::make_pair(oSt->GetIndex(), phiMeNode));
     if (oSt->IsPregOst()) {
       RegMeExpr *meDef = GetOrCreateRegFromVerSt(*vSt);
       phiMeNode->UpdateLHS(*meDef);
diff --git a/src/maple_me/src/me_abco.cpp b/src/maple_me/src/me_abco.cpp
index ed8879e3b206a5dbf68082b718276e5054c47c37..1519db914d35fb5f81e30223dcae27760a0399fa 100755
--- a/src/maple_me/src/me_abco.cpp
+++ b/src/maple_me/src/me_abco.cpp
@@ -662,7 +662,7 @@ bool MeABC::HasRelativeWithLength(MeExpr &meExpr) {
       if (visited.find(&defPhi) != visited.end()) {
         return false;
       }
-      visited.insert(&defPhi);
+      (void)visited.insert(&defPhi);
       for (MeExpr *expr : defPhi.GetOpnds()) {
         if (HasRelativeWithLength(*expr)) {
           return true;
diff --git a/src/maple_me/src/me_cfg.cpp b/src/maple_me/src/me_cfg.cpp
index d1a5498ca5ab9d77c908a2d463b3de456397c8bc..648d75957f512288e501aaaa54b0e6b7d724fff1 100755
--- a/src/maple_me/src/me_cfg.cpp
+++ b/src/maple_me/src/me_cfg.cpp
@@ -535,93 +535,89 @@ void MeCFG::FixTryBB(maple::BB &startBB, maple::BB &nextBB) {
 
 // analyse the CFG to find the BBs that are not reachable from function entries
 // and delete them
-void MeCFG::UnreachCodeAnalysis(bool updatePhi) {
+bool MeCFG::UnreachCodeAnalysis(bool updatePhi) {
   std::vector<bool> visitedBBs(func.NumBBs(), false);
   func.GetCommonEntryBB()->FindReachableBBs(visitedBBs);
   // delete the unreached bb
+  bool cfgChanged = false;
   auto eIt = func.valid_end();
   for (auto bIt = func.valid_begin(); bIt != eIt; ++bIt) {
     if (bIt == func.common_exit()) {
       continue;
     }
     auto *bb = *bIt;
+    if (bb->GetAttributes(kBBAttrIsEntry)) {
+      continue;
+    }
     BBId idx = bb->GetBBId();
-    if (!visitedBBs[idx] && !bb->GetAttributes(kBBAttrIsEntry)) {
-      // if bb is StartTryBB, relationship between endtry and try should be maintained
-      if (IsStartTryBB(*bb)) {
-        bool needFixTryBB = false;
-        size_t size = func.GetAllBBs().size();
-        for (size_t nextIdx = idx + 1; nextIdx < size; ++nextIdx) {
-          auto nextBB = func.GetBBFromID(BBId(nextIdx));
-          if (nextBB == nullptr) {
-            continue;
-          }
-          if (!visitedBBs[nextIdx] && nextBB->GetAttributes(kBBAttrIsTryEnd)) {
-            break;
-          }
-          if (visitedBBs[nextIdx]) {
-            needFixTryBB = true;
-            visitedBBs[idx] = true;
-            FixTryBB(*bb, *nextBB);
-            break;
-          }
-        }
-        if (needFixTryBB) {
+    if (visitedBBs[idx]) {
+      continue;
+    }
+
+    // if bb is StartTryBB, relationship between endtry and try should be maintained
+    if (IsStartTryBB(*bb)) {
+      bool needFixTryBB = false;
+      size_t size = func.GetAllBBs().size();
+      for (size_t nextIdx = idx + 1; nextIdx < size; ++nextIdx) {
+        auto nextBB = func.GetBBFromID(BBId(nextIdx));
+        if (nextBB == nullptr) {
           continue;
         }
-      }
-      bb->SetAttributes(kBBAttrWontExit);
-      // avoid redundant pred before adding to common_exit_bb's pred list
-      size_t pi = 0;
-      for (; pi < func.GetCommonExitBB()->GetPred().size(); ++pi) {
-        if (bb == func.GetCommonExitBB()->GetPred(pi)) {
+        if (!visitedBBs[nextIdx] && nextBB->GetAttributes(kBBAttrIsTryEnd)) {
           break;
         }
-      }
-      if (pi == func.GetCommonExitBB()->GetPred().size()) {
-        func.GetCommonExitBB()->AddExit(*bb);
-      }
-      if (!MeOption::quiet) {
-        LogInfo::MapleLogger() << "#### BB " << bb->GetBBId() << " deleted because unreachable\n";
-      }
-      if (bb->GetAttributes(kBBAttrIsTryEnd)) {
-        // unreachable bb has try end info
-        auto bbIt = std::find(func.rbegin(), func.rend(), bb);
-        auto prevIt = ++bbIt;
-        for (auto it = prevIt; it != func.rend(); ++it) {
-          if (*it != nullptr) {
-            // move entrytry tag to previous bb with try
-            if ((*it)->GetAttributes(kBBAttrIsTry) && !(*it)->GetAttributes(kBBAttrIsTryEnd)) {
-              (*it)->SetAttributes(kBBAttrIsTryEnd);
-              func.SetTryBBByOtherEndTryBB(*it, bb);
-            }
-            break;
-          }
+        if (visitedBBs[nextIdx]) {
+          needFixTryBB = true;
+          visitedBBs[idx] = true;
+          FixTryBB(*bb, *nextBB);
+          cfgChanged = true;
+          break;
         }
       }
-      func.DeleteBasicBlock(*bb);
-      // remove the bb from its succ's pred_ list
-      while (bb->GetSucc().size() > 0) {
-        BB *sucBB = bb->GetSucc(0);
-        sucBB->RemovePred(*bb, updatePhi);
-        if (updatePhi) {
-          if (sucBB->GetPred().empty()) {
-            sucBB->ClearPhiList();
-          } else if (sucBB->GetPred().size() == 1) {
-            ConvertPhis2IdentityAssigns(*sucBB);
+      if (needFixTryBB) {
+        continue;
+      }
+    }
+    if (!MeOption::quiet) {
+      LogInfo::MapleLogger() << "#### BB " << bb->GetBBId() << " deleted because unreachable\n";
+    }
+    if (bb->GetAttributes(kBBAttrIsTryEnd)) {
+      // unreachable bb has try end info
+      auto bbIt = std::find(func.rbegin(), func.rend(), bb);
+      auto prevIt = ++bbIt;
+      for (auto it = prevIt; it != func.rend(); ++it) {
+        if (*it != nullptr) {
+          // move entrytry tag to previous bb with try
+          if ((*it)->GetAttributes(kBBAttrIsTry) && !(*it)->GetAttributes(kBBAttrIsTryEnd)) {
+            (*it)->SetAttributes(kBBAttrIsTryEnd);
+            func.SetTryBBByOtherEndTryBB(*it, bb);
           }
+          break;
         }
       }
-      // remove the bb from common_exit_bb's pred list if it is there
-      for (auto it = func.GetCommonExitBB()->GetPred().begin();
-           it != func.GetCommonExitBB()->GetPred().end(); ++it) {
-        if (*it == bb) {
-          func.GetCommonExitBB()->RemoveExit(*bb);
-          break;
+    }
+    func.DeleteBasicBlock(*bb);
+    cfgChanged = true;
+    // remove the bb from its succ's pred_ list
+    while (bb->GetSucc().size() > 0) {
+      BB *sucBB = bb->GetSucc(0);
+      sucBB->RemovePred(*bb, updatePhi);
+      if (updatePhi) {
+        if (sucBB->GetPred().empty()) {
+          sucBB->ClearPhiList();
+        } else if (sucBB->GetPred().size() == 1) {
+          ConvertPhis2IdentityAssigns(*sucBB);
         }
       }
     }
+    // remove the bb from common_exit_bb's pred list if it is there
+    auto &predsOfCommonExit = func.GetCommonExitBB()->GetPred();
+    auto it = std::find(predsOfCommonExit.begin(), predsOfCommonExit.end(), bb);
+    if (it != predsOfCommonExit.end()) {
+      func.GetCommonExitBB()->RemoveExit(*bb);
+    }
   }
+  return cfgChanged;
 }
 
 void MeCFG::ConvertPhiList2IdentityAssigns(BB &meBB) const {
diff --git a/src/maple_me/src/me_delegate_rc.cpp b/src/maple_me/src/me_delegate_rc.cpp
index d2aea5721adf9c83869c10100b4e19d3784bd85a..4b29ddc709ffe815748f8bf8af039abc221843fc 100755
--- a/src/maple_me/src/me_delegate_rc.cpp
+++ b/src/maple_me/src/me_delegate_rc.cpp
@@ -264,7 +264,7 @@ bool DelegateRC::MayThrowException(const MeStmt &stmt) const {
 // make use of verStUseCounts in its determination. In addition, if it comes
 // across any stmt that can raise exception, also return false.
 bool DelegateRC::ContainAllTheUses(const VarMeExpr &rhsVar, const MeStmt &fromStmt, const MeStmt &toStmt) const {
-  int32 remainingUses = static_cast<uint32>(verStUseCounts[rhsVar.GetVstIdx()]) - 1;
+  int32 remainingUses = static_cast<int32>(verStUseCounts[rhsVar.GetVstIdx()]) - 1;
   for (MeStmt *cur = fromStmt.GetPrev(); cur != &toStmt; cur = cur->GetPrev()) {
     // do not count decref operands
     if (IsVarDecRefStmt(*cur)) {
diff --git a/src/maple_me/src/me_hdse.cpp b/src/maple_me/src/me_hdse.cpp
index 03a444e53678a61532ef3145409a8ef232d7ae7a..a5b5e06c9c8e4e81dbf39c735d1152c14d8b4734 100755
--- a/src/maple_me/src/me_hdse.cpp
+++ b/src/maple_me/src/me_hdse.cpp
@@ -101,8 +101,9 @@ AnalysisResult *MeDoHDSE::Run(MeFunction *func, MeFuncResultMgr *m, ModuleResult
   MeHDSE hdse(*func, *postDom, *hMap, DEBUGFUNC(func));
   hdse.RunHDSE();
   MakeEmptyTrysUnreachable(*func);
-  func->GetTheCfg()->UnreachCodeAnalysis(true);
-  m->InvalidAnalysisResult(MeFuncPhase_DOMINANCE, func);
+  if (func->GetTheCfg()->UnreachCodeAnalysis(true)) {
+    m->InvalidAnalysisResult(MeFuncPhase_DOMINANCE, func);
+  }
   if (DEBUGFUNC(func)) {
     LogInfo::MapleLogger() << "\n============== HDSE =============" << '\n';
     func->Dump(false);
diff --git a/src/maple_me/src/me_ssa_update.cpp b/src/maple_me/src/me_ssa_update.cpp
index 28636a66d4deba9d7dc56bc1025d1d2363a1fd44..cdd982c554ba7e95fd3641f5b3954768f4c8b6ef 100755
--- a/src/maple_me/src/me_ssa_update.cpp
+++ b/src/maple_me/src/me_ssa_update.cpp
@@ -56,7 +56,7 @@ void MeSSAUpdate::InsertPhis() {
       auto *phiMeNode = irMap.NewInPool<MePhiNode>();
       phiMeNode->SetDefBB(bb);
       phiMeNode->GetOpnds().resize(bb->GetPred().size());
-      bb->GetMePhiList().insert(std::make_pair(it->first, phiMeNode));
+      (void)bb->GetMePhiList().insert(std::make_pair(it->first, phiMeNode));
     }
     // initialize its rename stack
     renameStacks[it->first] = ssaUpdateMp.New<MapleStack<ScalarMeExpr*>>(ssaUpdateAlloc.Adapter());
diff --git a/src/maple_me/src/me_stmt_pre.cpp b/src/maple_me/src/me_stmt_pre.cpp
index 6a55d9667ee5e70e5085e236167dbafe9aa1ef4b..73e116d9f0b7cf59f1878bd7e5ce83231f5805e1 100755
--- a/src/maple_me/src/me_stmt_pre.cpp
+++ b/src/maple_me/src/me_stmt_pre.cpp
@@ -921,7 +921,7 @@ void MeStmtPre::BuildWorkListBB(BB *bb) {
         if (!unaryStmt.GetOpnd()->IsLeaf()) {
           break;
         }
-        (void)CreateStmtRealOcc(stmt, seqStmt);
+        (void)CreateStmtRealOcc(stmt, static_cast<int>(seqStmt));
         break;
       }
       case OP_dassign: {
@@ -943,7 +943,7 @@ void MeStmtPre::BuildWorkListBB(BB *bb) {
           stmtWkCand->SetLHSIsFinal(true);
         } else if (!dassMeStmt.GetRHS()->SymAppears(varMeExpr->GetOStIdx()) && dassMeStmt.GetRHS()->Pure()) {
           if (NoPriorUseInBB(dassMeStmt.GetVarLHS(), &stmt)) {
-            (void)CreateStmtRealOcc(stmt, seqStmt);
+            (void)CreateStmtRealOcc(stmt, static_cast<int>(seqStmt));
           }
         } else if (dassMeStmt.GetLHS() != nullptr && dassMeStmt.GetLHS()->IsUseSameSymbol(*dassMeStmt.GetRHS())) {
           RemoveUnnecessaryDassign(dassMeStmt);
@@ -962,7 +962,7 @@ void MeStmtPre::BuildWorkListBB(BB *bb) {
           break;
         }
         if (intrnStmt.GetIntrinsic() == INTRN_JAVA_CLINIT_CHECK) {
-          (void)CreateStmtRealOcc(stmt, seqStmt);
+          (void)CreateStmtRealOcc(stmt, static_cast<int>(seqStmt));
         }
         break;
       }
@@ -979,7 +979,7 @@ void MeStmtPre::BuildWorkListBB(BB *bb) {
           break;
         }
         if (intrnStmt.GetIntrinsic() == INTRN_MPL_BOUNDARY_CHECK) {
-          (void)CreateStmtRealOcc(stmt, seqStmt);
+          (void)CreateStmtRealOcc(stmt, static_cast<int>(seqStmt));
         }
         VersionStackChiListUpdate(*intrnStmt.GetChiList());
         break;
diff --git a/src/maple_me/src/prop.cpp b/src/maple_me/src/prop.cpp
index c3b34dc0fb7bc899e49fb262a942a575ec9d147e..efbf5b2e310ba6d8f4455d66970ea0b8e8b7aa1c 100755
--- a/src/maple_me/src/prop.cpp
+++ b/src/maple_me/src/prop.cpp
@@ -632,9 +632,7 @@ void Prop::TraversalBB(BB &bb) {
     return;
   }
   bbVisited[bb.GetBBId()] = true;
-
   curBB = &bb;
-  UpdateCurFunction(bb);
 
   // record stack size for variable versions before processing rename. It is used for stack pop up.
   std::vector<size_t> curStackSizeVec(vstLiveStackVec.size());
diff --git a/src/maple_me/src/ssa.cpp b/src/maple_me/src/ssa.cpp
index 927e736e619624a0f910e30e833a9c65d5480e19..b37b0a7d81f2f8a2c07920e26e2ad527d915aab8 100644
--- a/src/maple_me/src/ssa.cpp
+++ b/src/maple_me/src/ssa.cpp
@@ -126,7 +126,7 @@ void SSA::RenameUses(StmtNode &stmt) {
   if (kOpcodeInfo.HasSSAUse(stmt.GetOpCode())) {
     RenameMayUses(stmt);
   }
-  for (int i = 0; i < stmt.NumOpnds(); ++i) {
+  for (size_t i = 0; i < stmt.NumOpnds(); ++i) {
     RenameExpr(*stmt.Opnd(i));
   }
 }
diff --git a/src/maple_me/src/ssa_pre.cpp b/src/maple_me/src/ssa_pre.cpp
index efef5fc6378eaabedac92a539a21e10ca914c511..a8439ee16c51dc7eb80e4ea5fba91a1f8f4a27d5 100755
--- a/src/maple_me/src/ssa_pre.cpp
+++ b/src/maple_me/src/ssa_pre.cpp
@@ -1407,42 +1407,43 @@ void SSAPre::BuildWorkListStmt(MeStmt &stmt, uint32 seqStmt, bool isRebuilt, MeE
       break;
     case OP_throw: {
       auto *thrMeStmt = static_cast<ThrowMeStmt*>(meStmt);
-      BuildWorkListExpr(*meStmt, seqStmt, *thrMeStmt->GetOpnd(), isRebuilt, tempVar, true);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *thrMeStmt->GetOpnd(), isRebuilt, tempVar, true);
       break;
     }
     case OP_iassign: {
       auto *ivarStmt = static_cast<IassignMeStmt*>(meStmt);
-      BuildWorkListExpr(*meStmt, seqStmt, *ivarStmt->GetRHS(), isRebuilt, tempVar, true);
-      BuildWorkListExpr(*meStmt, seqStmt, *ivarStmt->GetLHSVal()->GetBase(), isRebuilt, tempVar, true);
-      BuildWorkListIvarLHSOcc(*meStmt, seqStmt, isRebuilt, tempVar);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *ivarStmt->GetRHS(), isRebuilt, tempVar, true);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt),
+                        *ivarStmt->GetLHSVal()->GetBase(), isRebuilt, tempVar, true);
+      BuildWorkListIvarLHSOcc(*meStmt, static_cast<int32>(seqStmt), isRebuilt, tempVar);
       break;
     }
     case OP_brtrue:
     case OP_brfalse: {
       auto *condGotoStmt = static_cast<CondGotoMeStmt*>(meStmt);
-      BuildWorkListExpr(*meStmt, seqStmt, *condGotoStmt->GetOpnd(), isRebuilt, tempVar, true);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *condGotoStmt->GetOpnd(), isRebuilt, tempVar, true);
       break;
     }
     case OP_switch: {
       auto *switchStmt = static_cast<SwitchMeStmt*>(meStmt);
-      BuildWorkListExpr(*meStmt, seqStmt, *switchStmt->GetOpnd(), isRebuilt, tempVar, true);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *switchStmt->GetOpnd(), isRebuilt, tempVar, true);
       break;
     }
     case OP_dassign: {
       auto *dassMeStmt = static_cast<DassignMeStmt*>(meStmt);
-      BuildWorkListExpr(*meStmt, seqStmt, *dassMeStmt->GetRHS(), isRebuilt, tempVar, true);
-      BuildWorkListLHSOcc(*meStmt, seqStmt);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *dassMeStmt->GetRHS(), isRebuilt, tempVar, true);
+      BuildWorkListLHSOcc(*meStmt, static_cast<int32>(seqStmt));
       break;
     }
     case OP_regassign: {
       auto *rassMeStmt = static_cast<RegassignMeStmt*>(meStmt);
-      BuildWorkListExpr(*meStmt, seqStmt, *rassMeStmt->GetRHS(), isRebuilt, tempVar, true);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *rassMeStmt->GetRHS(), isRebuilt, tempVar, true);
       break;
     }
     case OP_maydassign: {
       auto *dassMeStmt = static_cast<MaydassignMeStmt*>(meStmt);
-      BuildWorkListExpr(*meStmt, seqStmt, *dassMeStmt->GetRHS(), isRebuilt, tempVar, true);
-      BuildWorkListLHSOcc(*meStmt, seqStmt);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *dassMeStmt->GetRHS(), isRebuilt, tempVar, true);
+      BuildWorkListLHSOcc(*meStmt, static_cast<int32>(seqStmt));
       break;
     }
     case OP_decref: {
@@ -1451,7 +1452,7 @@ void SSAPre::BuildWorkListStmt(MeStmt &stmt, uint32 seqStmt, bool isRebuilt, MeE
         // affects LPRE only; will cause CI failure if this is allowed
         break;
       }
-      BuildWorkListExpr(*meStmt, seqStmt, *unaryStmt->GetOpnd(), isRebuilt, tempVar, true);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *unaryStmt->GetOpnd(), isRebuilt, tempVar, true);
       break;
     }
     case OP_incref:
@@ -1460,7 +1461,7 @@ void SSAPre::BuildWorkListStmt(MeStmt &stmt, uint32 seqStmt, bool isRebuilt, MeE
     case OP_assertnonnull:
     case OP_free: {
       auto *unaryStmt = static_cast<UnaryMeStmt*>(meStmt);
-      BuildWorkListExpr(*meStmt, seqStmt, *unaryStmt->GetOpnd(), isRebuilt, tempVar, true);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *unaryStmt->GetOpnd(), isRebuilt, tempVar, true);
       break;
     }
     case OP_syncenter:
@@ -1468,7 +1469,7 @@ void SSAPre::BuildWorkListStmt(MeStmt &stmt, uint32 seqStmt, bool isRebuilt, MeE
       auto *syncMeStmt = static_cast<SyncMeStmt*>(meStmt);
       const MapleVector<MeExpr*> &opnds = syncMeStmt->GetOpnds();
       for (auto it = opnds.begin(); it != opnds.end(); ++it) {
-        BuildWorkListExpr(*meStmt, seqStmt, **it, isRebuilt, tempVar, true);
+        BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), **it, isRebuilt, tempVar, true);
       }
       break;
     }
@@ -1491,7 +1492,7 @@ void SSAPre::BuildWorkListStmt(MeStmt &stmt, uint32 seqStmt, bool isRebuilt, MeE
             }
           }
         }
-        BuildWorkListExpr(*meStmt, seqStmt, **it, isRebuilt, tempVar, true);
+        BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), **it, isRebuilt, tempVar, true);
       }
       break;
     }
@@ -1516,7 +1517,7 @@ void SSAPre::BuildWorkListStmt(MeStmt &stmt, uint32 seqStmt, bool isRebuilt, MeE
       auto *naryMeStmt = static_cast<NaryMeStmt*>(meStmt);
       const MapleVector<MeExpr*> &opnds = naryMeStmt->GetOpnds();
       for (auto it = opnds.begin(); it != opnds.end(); ++it) {
-        BuildWorkListExpr(*meStmt, seqStmt, **it, isRebuilt, tempVar, true);
+        BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), **it, isRebuilt, tempVar, true);
       }
       break;
     }
@@ -1548,15 +1549,15 @@ void SSAPre::BuildWorkListStmt(MeStmt &stmt, uint32 seqStmt, bool isRebuilt, MeE
             continue;
           }
         }
-        BuildWorkListExpr(*meStmt, seqStmt, **it, isRebuilt, tempVar, true);
+        BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), **it, isRebuilt, tempVar, true);
       }
       break;
     }
     case OP_assertlt:
     case OP_assertge: {
       auto *assMeStmt = static_cast<AssertMeStmt*>(meStmt);
-      BuildWorkListExpr(*meStmt, seqStmt, *assMeStmt->GetOpnd(0), isRebuilt, tempVar, true);
-      BuildWorkListExpr(*meStmt, seqStmt, *assMeStmt->GetOpnd(1), isRebuilt, tempVar, true);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *assMeStmt->GetOpnd(0), isRebuilt, tempVar, true);
+      BuildWorkListExpr(*meStmt, static_cast<int32>(seqStmt), *assMeStmt->GetOpnd(1), isRebuilt, tempVar, true);
       break;
     }
     default:
@@ -1564,7 +1565,7 @@ void SSAPre::BuildWorkListStmt(MeStmt &stmt, uint32 seqStmt, bool isRebuilt, MeE
       break;
   }
   if (kOpcodeInfo.IsCallAssigned(op)) {
-    BuildWorkListLHSOcc(*meStmt, seqStmt);
+    BuildWorkListLHSOcc(*meStmt, static_cast<int32>(seqStmt));
   }
 }
 
diff --git a/src/maple_util/include/utils/meta.h b/src/maple_util/include/utils/meta.h
index 9d7fbe5987297cd7ee7821981ef12b8d174013ee..32ce6a902905233817674d9ac2af3ff3f8fb28de 100644
--- a/src/maple_util/include/utils/meta.h
+++ b/src/maple_util/include/utils/meta.h
@@ -20,26 +20,26 @@ namespace maple {
 namespace utils {
 template <typename T, typename U>
 struct meta_and
-    : std::conditional_t<T::value, U, T> {};
+    : public std::conditional_t<T::value, U, T> {};
 
 template <typename T, typename U>
 struct meta_or
-    : std::conditional_t<T::value, T, U> {};
+    : public std::conditional_t<T::value, T, U> {};
 
 template <typename T>
 struct meta_not
-    : std::integral_constant<bool, !static_cast<bool>(T::value)>::type {};
+    : public std::integral_constant<bool, !static_cast<bool>(T::value)>::type {};
 
 template <typename ...>
 struct is_signed;
 
 template <typename T>
 struct is_signed<T>
-    : std::is_signed<T>::type {};
+    : public std::is_signed<T>::type {};
 
 template <typename T, typename U>
 struct is_signed<T, U>
-    : meta_and<std::is_signed<T>, std::is_signed<U>>::type {};
+    : public meta_and<std::is_signed<T>, std::is_signed<U>>::type {};
 
 template <typename ...T>
 constexpr bool is_signed_v = is_signed<T...>::value;
@@ -49,47 +49,47 @@ struct is_unsigned;
 
 template <typename T>
 struct is_unsigned<T>
-    : std::is_unsigned<T>::type {};
+    : public std::is_unsigned<T>::type {};
 
 template <typename T, typename U>
 struct is_unsigned<T, U>
-    : meta_and<std::is_unsigned<T>, std::is_unsigned<U>>::type {};
+    : public meta_and<std::is_unsigned<T>, std::is_unsigned<U>>::type {};
 
 template <typename ...T>
 constexpr bool is_unsigned_v = is_unsigned<T...>::value;
 
 template <typename T, typename U>
 struct is_same_sign
-    : meta_or<is_signed<T, U>, is_unsigned<T, U>>::type {};
+    : public meta_or<is_signed<T, U>, is_unsigned<T, U>>::type {};
 
 template <typename T, typename U>
 struct is_diff_sign
-    : meta_not<is_same_sign<T, U>>::type {};
+    : public meta_not<is_same_sign<T, U>>::type {};
 
 template <typename ...>
 struct is_pointer;
 
 template <typename T>
 struct is_pointer<T>
-    : std::is_pointer<T>::type {};
+    : public std::is_pointer<T>::type {};
 
 template <typename T, typename U>
 struct is_pointer<T, U>
-    : meta_and<is_pointer<T>, is_pointer<U>>::type {};
+    : public meta_and<is_pointer<T>, is_pointer<U>>::type {};
 
 template <typename ...T>
 constexpr bool is_pointer_v = is_pointer<T...>::value;
 
 template <typename T, typename U>
 struct const_of
-    : meta_and<std::is_const<U>, std::is_same<std::add_const_t<T>, U>>::type {};
+    : public meta_and<std::is_const<U>, std::is_same<std::add_const_t<T>, U>>::type {};
 
 template <typename T, typename U>
 constexpr bool const_of_v = const_of<T, U>::value;
 
 template <typename T, typename U>
 struct is_ncv_same
-    : std::is_same<std::remove_cv_t<T>, std::remove_cv_t<U>>::type {};
+    : public std::is_same<std::remove_cv_t<T>, std::remove_cv_t<U>>::type {};
 
 template <typename T, typename U>
 constexpr bool is_ncv_same_v = is_ncv_same<T, U>::value;
@@ -97,14 +97,14 @@ constexpr bool is_ncv_same_v = is_ncv_same<T, U>::value;
 namespace ptr {
 template <typename T, typename U, typename = std::enable_if_t<is_pointer_v<T, U>>>
 struct const_of
-    : utils::const_of<std::remove_pointer_t<T>, std::remove_pointer_t<U>>::type {};
+    : public utils::const_of<std::remove_pointer_t<T>, std::remove_pointer_t<U>>::type {};
 
 template <typename T, typename U, typename = std::enable_if_t<is_pointer_v<T, U>>>
 constexpr bool const_of_v = const_of<T, U>::value;
 
 template <typename T, typename U, typename = std::enable_if_t<is_pointer_v<T, U>>>
 struct is_ncv_same
-    : utils::is_ncv_same<std::remove_pointer_t<T>, std::remove_pointer_t<U>>::type {};
+    : public utils::is_ncv_same<std::remove_pointer_t<T>, std::remove_pointer_t<U>>::type {};
 
 template <typename T, typename U, typename = std::enable_if_t<is_pointer_v<T, U>>>
 constexpr bool is_ncv_same_v = is_ncv_same<T, U>::value;
diff --git a/src/mpl2mpl/include/annotation_analysis.h b/src/mpl2mpl/include/annotation_analysis.h
index 429bf5f306749ec615a4e0578642b12571d3ffc1..7d11285cb47ebe6c059ab4a83b0ebe4c0f122585 100644
--- a/src/mpl2mpl/include/annotation_analysis.h
+++ b/src/mpl2mpl/include/annotation_analysis.h
@@ -209,7 +209,7 @@ class AnnotationParser {
  public:
   explicit AnnotationParser(std::string &s) : signature(s), curIndex(0) {}
   ~AnnotationParser() = default;
-  ATokenKind GetNextToken(char *endC = nullptr);
+  ATokenKind GetNextToken(const char *endC = nullptr);
   GenericDeclare *GetOrCreateDeclare(GStrIdx gStrIdx, MemPool &mp, bool check = false, MIRStructType *sType = nullptr);
   AnnotationType *GetOrCreateArrayType(AnnotationType *containsType, MemPool &pragmaMemPool);
   void BackOne() {
@@ -234,7 +234,7 @@ class AnnotationParser {
 
  private:
   std::string &signature;
-  int curIndex;
+  size_t curIndex;
   std::map<GStrIdx, GenericDeclare*> created;
   std::map<AnnotationType*, ExtendGeneric*> createdArrayType;
   std::string curStrToken;
@@ -260,9 +260,9 @@ class AnnotationAnalysis : public AnalysisResult {
   void Run();
  private:
   void AnalysisAnnotation();
-  void AnalysisAnnotationForClass(MIRPragma &classPragma);
+  void AnalysisAnnotationForClass(const MIRPragma &classPragma);
   void AnalysisAnnotationForVar(const MIRPragma &varPragma, MIRStructType &structType);
-  void AnalysisAnnotationForFunc(MIRPragma &funcPragma, MIRStructType &structType);
+  void AnalysisAnnotationForFunc(const MIRPragma &funcPragma, MIRStructType &structType);
   AnnotationType *ReadInGenericType(AnnotationParser &aParser, MIRStructType *sType);
   GenericDeclare *ReadInGenericDeclare(AnnotationParser &aParser, MIRStructType *mirStructType = nullptr);
   std::string ReadInAllSubString(const MIRPragma &classPragma);
diff --git a/src/mpl2mpl/src/annotation_analysis.cpp b/src/mpl2mpl/src/annotation_analysis.cpp
index 456005d8b74c80825afc7732742c830c6546082c..47009a6f9a1fe9e86369e192b3e5a6dbc2ef3cdf 100644
--- a/src/mpl2mpl/src/annotation_analysis.cpp
+++ b/src/mpl2mpl/src/annotation_analysis.cpp
@@ -69,8 +69,8 @@ void AnnotationType::Dump() {
 
 void GenericType::ReWriteType(std::string &subClass) {
   std::string className = mirStructType->GetName();
-  int ClassMethodSplitterStrSize = strlen(namemangler::kClassMethodSplitterStr);
-  className.replace(className.size() - ClassMethodSplitterStrSize, ClassMethodSplitterStrSize, subClass);
+  size_t ClassMethodSplitterStrSize = strlen(namemangler::kClassMethodSplitterStr);
+  (void)className.replace(className.size() - ClassMethodSplitterStrSize, ClassMethodSplitterStrSize, subClass);
   mirStructType = GetClassTypeFromName(className);
   typeName = GlobalTables::GetStrTable().GetStrIdxFromName(className);
   GenericArg.clear();
@@ -96,7 +96,7 @@ GenericDeclare *AnnotationParser::GetOrCreateDeclare(GStrIdx gStrIdx, MemPool &m
   return gd;
 }
 
-ATokenKind AnnotationParser::GetNextToken(char *endC) {
+ATokenKind AnnotationParser::GetNextToken(const char *endC) {
   if (curIndex == signature.size()) {
     ++curIndex;
     return kEnd;
@@ -147,8 +147,8 @@ ATokenKind AnnotationParser::GetNextToken(char *endC) {
   size_t endPos = signature.find_first_of(endC, curIndex);
   CHECK_FATAL(endPos != std::string::npos, "must be");
   curStrToken = signature.substr(curIndex, endPos - curIndex);
-  curIndex = endPos + 1;
-  if (*endC == ':' && signature[endPos + 1] == ':') {
+  curIndex = endPos + 1u;
+  if (*endC == ':' && signature[curIndex] == ':') {
     ++curIndex;
   }
   return kString;
@@ -164,7 +164,7 @@ std::string AnnotationParser::GetNextClassName(bool forSubClass) {
   curStrToken += ";";
   curIndex = pos;
   if (forSubClass) {
-    for (int i = 0; i < curStrToken.size(); ++i) {
+    for (size_t i = 0; i < curStrToken.size(); ++i) {
       if (curStrToken[i] == '.') {
         curStrToken[i] = '$';
       }
@@ -222,20 +222,20 @@ void AnnotationAnalysis::ByPassFollowingInfo(AnnotationParser &aParser, MIRStruc
     t = aParser.GetNextToken();
     while (t != kTemplateEnd) {
       aParser.BackOne();
-      ReadInGenericType(aParser, sType);
+      (void)ReadInGenericType(aParser, sType);
       t = aParser.GetNextToken();
     }
     CHECK_FATAL(t == kTemplateEnd, "must be");
     t = aParser.GetNextToken();
   }
   while (t == kSubClass) {
-    std::string subClassName = aParser.GetNextClassName(true);
+    (void)aParser.GetNextClassName(true);
     t = aParser.GetNextToken();
     if (t == kTemplateStart) {
       t = aParser.GetNextToken();
       while (t != kTemplateEnd) {
         aParser.BackOne();
-        ReadInGenericType(aParser, sType);
+        (void)ReadInGenericType(aParser, sType);
         t = aParser.GetNextToken();
       }
       CHECK_FATAL(t == kTemplateEnd, "must be");
@@ -272,14 +272,14 @@ AnnotationType *AnnotationAnalysis::ReadInGenericType(AnnotationParser &aParser,
       ATokenKind t = aParser.GetNextToken();
       if (t == kTemplateStart) {
         AAForClassInfo(*mirStruct);
-        for (int i = 0; i < gdVector.size(); ++i) {
+        for (size_t i = 0; i < gdVector.size(); ++i) {
           AnnotationType *tmp = ReadInGenericType(aParser, sType);
           gt->AddGenericPair(gdVector[i], tmp);
         }
         t = aParser.GetNextToken();
         while (t != kTemplateEnd) {
           aParser.BackOne();
-          ReadInGenericType(aParser, sType);
+          (void)ReadInGenericType(aParser, sType);
           t = aParser.GetNextToken();
         }
         CHECK_FATAL(t == kTemplateEnd, "must be");
@@ -292,14 +292,14 @@ AnnotationType *AnnotationAnalysis::ReadInGenericType(AnnotationParser &aParser,
         if (t == kTemplateStart) {
           AAForClassInfo(*gt->GetMIRStructType());
           std::vector<GenericDeclare*>& gdTmpVector = gt->GetMIRStructType()->GetGenericDeclare();
-          for (int i = 0; i < gdTmpVector.size(); ++i) {
+          for (size_t i = 0; i < gdTmpVector.size(); ++i) {
             AnnotationType *tmp = ReadInGenericType(aParser, sType);
             gt->AddGenericPair(gdTmpVector[i], tmp);
           }
           t = aParser.GetNextToken();
           while (t != kTemplateEnd) {
             aParser.BackOne();
-            ReadInGenericType(aParser, sType);
+            (void)ReadInGenericType(aParser, sType);
             t = aParser.GetNextToken();
           }
           CHECK_FATAL(t == kTemplateEnd, "must be");
@@ -311,7 +311,7 @@ AnnotationType *AnnotationAnalysis::ReadInGenericType(AnnotationParser &aParser,
       break;
     }
     case kTemplateName: {
-      aParser.GetNextToken(&annoSemiColon);
+      (void)aParser.GetNextToken(&annoSemiColon);
       GStrIdx s = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(aParser.GetCurStrToken());
       retType = aParser.GetOrCreateDeclare(s, *pragmaMemPool, true, sType);
       if (retType == nullptr) {
@@ -345,7 +345,7 @@ AnnotationType *AnnotationAnalysis::ReadInGenericType(AnnotationParser &aParser,
 }
 
 GenericDeclare *AnnotationAnalysis::ReadInGenericDeclare(AnnotationParser &aParser, MIRStructType *mirStructType) {
-  aParser.GetNextToken(&annoDeclare);
+  (void)aParser.GetNextToken(&annoDeclare);
   GenericDeclare *gDeclare = nullptr;
   if (aParser.GetCurStrToken() != "") {
     GStrIdx gStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(aParser.GetCurStrToken());
@@ -367,7 +367,7 @@ std::string AnnotationAnalysis::ReadInAllSubString(const MIRPragma &classPragma)
     CHECK_FATAL(pragmaElement->GetType() == kValueArray, "must be");
     for (MIRPragmaElement *subPragmaEle : pragmaElement->GetSubElemVec()) {
       CHECK_FATAL(subPragmaEle->GetType() == kValueString, "must be");
-      gStrIdx.reset(subPragmaEle->GetU64Val());
+      gStrIdx.reset(static_cast<uint32>(subPragmaEle->GetU64Val()));
       const std::string &str = GlobalTables::GetStrTable().GetStringFromStrIdx(gStrIdx);
       signature += str;
     }
@@ -414,10 +414,10 @@ void AnnotationAnalysis::AnalysisAnnotationForFuncLocalVar(MIRFunction &func, An
   }
 }
 
-void AnnotationAnalysis::AnalysisAnnotationForFunc(MIRPragma &funcPragma, MIRStructType &structType) {
+void AnnotationAnalysis::AnalysisAnnotationForFunc(const MIRPragma &funcPragma, MIRStructType &structType) {
   MIRSymbol *funcSymbol = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(funcPragma.GetStrIdx());
   MIRFunction *func = funcSymbol->GetFunction();
-  analysisedFunc.insert(func);
+  (void)analysisedFunc.insert(func);
   CHECK_FATAL(func->GetFuncGenericDeclare().size() == 0, "must be");
   CHECK_FATAL(func->GetFuncGenericArg().size() == 0, "must be");
   std::string signature = ReadInAllSubString(funcPragma);
@@ -427,7 +427,7 @@ void AnnotationAnalysis::AnalysisAnnotationForFunc(MIRPragma &funcPragma, MIRStr
     aParser.InitFuncGenericDeclare(*pragmaMemPool, *func);
     while (aParser.GetNextToken() != kTemplateEnd) {
       aParser.BackOne();
-      ReadInGenericDeclare(aParser, &structType);
+      (void)ReadInGenericDeclare(aParser, &structType);
     }
     tk = aParser.GetNextToken();
   }
@@ -454,7 +454,7 @@ void AnnotationAnalysis::AnalysisAnnotationForVar(const MIRPragma &varPragma, MI
   structType.AddFieldGenericDeclare(varPragma.GetStrIdx(), at);
 }
 
-void AnnotationAnalysis::AnalysisAnnotationForClass(MIRPragma &classPragma) {
+void AnnotationAnalysis::AnalysisAnnotationForClass(const MIRPragma &classPragma) {
   TyIdx classTyIdx = GlobalTables::GetTypeNameTable().GetTyIdxFromGStrIdx(classPragma.GetStrIdx());
   MIRType &classType = GetTypeFromTyIdx(classTyIdx);
   CHECK_FATAL(classType.GetKind() == kTypeClass || classType.GetKind() == kTypeInterface, "must be");
@@ -467,7 +467,7 @@ void AnnotationAnalysis::AnalysisAnnotationForClass(MIRPragma &classPragma) {
   aParser.InitClassGenericDeclare(*pragmaMemPool, static_cast<MIRStructType&>(classType));
   while (aParser.GetNextToken() != kTemplateEnd) {
     aParser.BackOne();
-    ReadInGenericDeclare(aParser);
+    (void)ReadInGenericDeclare(aParser);
   }
   while (aParser.GetNextToken() != kEnd) {
     aParser.BackOne();
@@ -484,7 +484,7 @@ void AnnotationAnalysis::AAForClassInfo(MIRStructType &structType) {
   if (analysised.find(&structType) != analysised.end() || structType.IsIncomplete()) {
     return;
   }
-  analysised.insert(&structType);
+  (void)analysised.insert(&structType);
   std::vector<MIRPragma*> &pragmaVec = structType.GetPragmaVec();
   for (MIRPragma *pragma : pragmaVec) {
     MIRType *pragmaType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(pragma->GetTyIdx());
diff --git a/src/mpl2mpl/src/constantfold.cpp b/src/mpl2mpl/src/constantfold.cpp
index 68f7a9dddabfaa2d0bdb8a13a863cd0213d716af..9486fe0a1af46ea69c9f5dfdd549e9f34b2d817e 100644
--- a/src/mpl2mpl/src/constantfold.cpp
+++ b/src/mpl2mpl/src/constantfold.cpp
@@ -356,7 +356,7 @@ ConstvalNode *ConstantFold::FoldIntConstBinary(Opcode opcode, PrimType resultTyp
       if (useResult64) {
         result64 = intValueOfConst0 + intValueOfConst1;
       } else {
-        result32 = static_cast<int32>(intValueOfConst0) + static_cast<int32>(intValueOfConst1);
+        result32 = static_cast<uint32>(static_cast<int32>(intValueOfConst0) + static_cast<int32>(intValueOfConst1));
       }
       break;
     }
@@ -370,7 +370,7 @@ ConstvalNode *ConstantFold::FoldIntConstBinary(Opcode opcode, PrimType resultTyp
     }
     case OP_mul: {
       if (useResult64) {
-        result64 = intValueOfConst0 * intValueOfConst1;
+        result64 = static_cast<uint64>(intValueOfConst0 * intValueOfConst1);
       } else {
         result32 = static_cast<uint32>(static_cast<int32>(intValueOfConst0) * static_cast<int32>(intValueOfConst1));
       }
@@ -531,7 +531,7 @@ ConstvalNode *ConstantFold::FoldIntConstBinary(Opcode opcode, PrimType resultTyp
     constValue = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, type);
     constValue->SetValue(kJsTypeNumberInHigh32Bit | (static_cast<uint64>(result32)));
   } else if (useResult64) {
-    constValue = GlobalTables::GetIntConstTable().GetOrCreateIntConst(result64, type);
+    constValue = GlobalTables::GetIntConstTable().GetOrCreateIntConst(static_cast<int64>(result64), type);
   } else {
     constValue = GlobalTables::GetIntConstTable().GetOrCreateIntConst(result32, type);
   }
@@ -875,7 +875,7 @@ ConstvalNode *ConstantFold::FoldIntConstUnary(Opcode opcode, PrimType resultType
     constValue = GlobalTables::GetIntConstTable().GetOrCreateIntConst(0, type);
     constValue->SetValue(kJsTypeNumberInHigh32Bit | (static_cast<uint64>(result32)));
   } else if (useResult64) {
-    constValue = GlobalTables::GetIntConstTable().GetOrCreateIntConst(result64, type);
+    constValue = GlobalTables::GetIntConstTable().GetOrCreateIntConst(static_cast<int64>(result64), type);
   } else {
     constValue = GlobalTables::GetIntConstTable().GetOrCreateIntConst(result32, type);
   }
@@ -1252,7 +1252,7 @@ MIRConst *ConstantFold::FoldSignExtendMIRConst(Opcode opcode, PrimType resultTyp
     result64 = ((static_cast<uint64>(constVal->GetValue())) << (64u - size)) >> (64u - size);
   }
   MIRType &type = *GlobalTables::GetTypeTable().GetPrimType(resultType);
-  MIRIntConst *constValue = GlobalTables::GetIntConstTable().GetOrCreateIntConst(result64, type);
+  MIRIntConst *constValue = GlobalTables::GetIntConstTable().GetOrCreateIntConst(static_cast<int64>(result64), type);
   return constValue;
 }
 
diff --git a/src/mpl2mpl/src/java_intrn_lowering.cpp b/src/mpl2mpl/src/java_intrn_lowering.cpp
index 9ea10a31558b8fe6d7d0e91359b8283a8dbb9989..428eccb342c1750d98aa0a22ada5fdb1b5417c56 100644
--- a/src/mpl2mpl/src/java_intrn_lowering.cpp
+++ b/src/mpl2mpl/src/java_intrn_lowering.cpp
@@ -162,7 +162,7 @@ void JavaIntrnLowering::ProcessJavaIntrnFillNewArray(IntrinsiccallNode &intrinCa
   CHECK_FATAL(retType->GetKind() == kTypePointer,
               "Return type of INTRN_JAVA_FILL_NEW_ARRAY should point to a Jarray");
   auto *arrayType = static_cast<MIRPtrType*>(retType)->GetPointedType();
-  BaseNode *lenNode = builder->CreateIntConst(intrinCall.NumOpnds(), PTY_i32);
+  BaseNode *lenNode = builder->CreateIntConst(static_cast<int64>(intrinCall.NumOpnds()), PTY_i32);
   JarrayMallocNode *newArrayNode = builder->CreateExprJarrayMalloc(OP_gcmallocjarray, *retType, *arrayType, lenNode);
   // Then fill each array element one by one.
   BaseNode *addrExpr = nullptr;
@@ -181,8 +181,9 @@ void JavaIntrnLowering::ProcessJavaIntrnFillNewArray(IntrinsiccallNode &intrinCa
   }
   assignStmt->SetSrcPos(intrinCall.GetSrcPos());
   StmtNode *stmt = assignStmt;
-  for (int i = 0; i < intrinCall.NumOpnds(); ++i) {
-    ArrayNode *arrayexpr = builder->CreateExprArray(*arrayType, addrExpr, builder->CreateIntConst(i, PTY_i32));
+  for (size_t i = 0; i < intrinCall.NumOpnds(); ++i) {
+    ArrayNode *arrayexpr = builder->CreateExprArray(*arrayType, addrExpr,
+                                                    builder->CreateIntConst(static_cast<int64>(i), PTY_i32));
     arrayexpr->SetBoundsCheck(false);
     StmtNode *storeStmt = builder->CreateStmtIassign(*retType, 0, arrayexpr, intrinCall.Opnd(i));
     currFunc->GetBody()->InsertAfter(stmt, storeStmt);
diff --git a/src/mpl2mpl/src/native_stub_func.cpp b/src/mpl2mpl/src/native_stub_func.cpp
index 437fced020ec92ea8e086c3f375b3a11c0fe7530..8a9651fddfdc5303ef866ae8414b7428b5759610 100644
--- a/src/mpl2mpl/src/native_stub_func.cpp
+++ b/src/mpl2mpl/src/native_stub_func.cpp
@@ -548,7 +548,6 @@ void NativeStubFuncGeneration::GenerateHelperFuncDecl() {
   MRTCheckThrowPendingExceptionFunc->SetAttr(FUNCATTR_nosideeffect);
   MRTCheckThrowPendingExceptionFunc->SetBody(nullptr);
   // MRT_PreNativeCall
-  ArgVector preArgs(GetMIRModule().GetMPAllocator().Adapter());
   MRTPreNativeFunc = builder->GetOrCreateFunction(namemangler::kPreNativeFunc, voidType->GetTypeIndex());
   CHECK_FATAL(MRTPreNativeFunc != nullptr, "MRTPreNativeFunc is null.");
   MRTPreNativeFunc->SetBody(nullptr);
diff --git a/src/mpl2mpl/src/reflection_analysis.cpp b/src/mpl2mpl/src/reflection_analysis.cpp
index 57cdaef3bcc5f66921ffdf2fd6e93b74a2fbad9e..adf0d51d6e2b1570c01937b46fc6e031b7e2bf1d 100755
--- a/src/mpl2mpl/src/reflection_analysis.cpp
+++ b/src/mpl2mpl/src/reflection_analysis.cpp
@@ -349,7 +349,8 @@ uint32 GetClassAccessFlags(const MIRStructType &classType) {
         const std::string &name = GlobalTables::GetStrTable().GetStringFromStrIdx(elem->GetNameStrIdx());
         if (name == kAccessFlags) {
           accessFlag = elem->GetI32Val();
-          accessFlag |= (originAF & kModPublic) << (kModifierAFOriginPublic - 1);
+          accessFlag |= static_cast<int32>((originAF & static_cast<uint32>(kModPublic)) <<
+                                           static_cast<uint32>(kModifierAFOriginPublic - 1));
           return static_cast<uint32>(accessFlag);
         }
       }
diff --git a/src/mplfe/BUILD.gn b/src/mplfe/BUILD.gn
index 895da36d0c3187b91725d2b2ba2851290fb24c8f..7bb822e155d58b3f986b09b396021b176669c517 100644
--- a/src/mplfe/BUILD.gn
+++ b/src/mplfe/BUILD.gn
@@ -15,8 +15,8 @@
 configs = [ "${MAPLEALL_ROOT}:mapleallcompilecfg" ]
 
 include_directories = [
-  "${MAPLEALL_ROOT}/mplfe/common/include",
-  "${MAPLEALL_ROOT}/mplfe/jbc_input/include",
+  "${MPLFE_ROOT}/common/include",
+  "${MPLFE_ROOT}/jbc_input/include",
   "${MAPLEALL_ROOT}/maple_ir/include",
   "${MAPLEALL_ROOT}/maple_ipa/include",
   "${MAPLEALL_ROOT}/maple_util/include",
@@ -30,56 +30,56 @@ include_directories = [
 
 static_library("lib_mplfe_util") {
   sources = [
-    "${MAPLEALL_ROOT}/mplfe/common/src/base64.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/basic_io.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/fe_config_parallel.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/fe_file_ops.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/fe_file_type.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/fe_function.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/fe_function_phase_result.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/fe_input_helper.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/fe_manager.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/fe_options.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/fe_java_string_manager.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/fe_timer_ns.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/fe_type_hierarchy.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/fe_type_manager.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/fe_struct_elem_info.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/fe_utils.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/fe_utils_java.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/feir_builder.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/feir_dfg.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/feir_stmt.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/feir_type.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/feir_type_helper.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/feir_type_infer.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/feir_var.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/feir_var_name.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/feir_var_reg.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/feir_var_type_scatter.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/general_bb.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/general_cfg.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/general_stmt.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/mplfe_compiler.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/mplfe_compiler_component.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/mplfe_env.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/mplfe_options.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/simple_xml.cpp",
-    "${MAPLEALL_ROOT}/mplfe/common/src/simple_zip.cpp",
+    "${MPLFE_ROOT}/common/src/base64.cpp",
+    "${MPLFE_ROOT}/common/src/basic_io.cpp",
+    "${MPLFE_ROOT}/common/src/fe_config_parallel.cpp",
+    "${MPLFE_ROOT}/common/src/fe_file_ops.cpp",
+    "${MPLFE_ROOT}/common/src/fe_file_type.cpp",
+    "${MPLFE_ROOT}/common/src/fe_function.cpp",
+    "${MPLFE_ROOT}/common/src/fe_function_phase_result.cpp",
+    "${MPLFE_ROOT}/common/src/fe_input_helper.cpp",
+    "${MPLFE_ROOT}/common/src/fe_manager.cpp",
+    "${MPLFE_ROOT}/common/src/fe_options.cpp",
+    "${MPLFE_ROOT}/common/src/fe_java_string_manager.cpp",
+    "${MPLFE_ROOT}/common/src/fe_timer_ns.cpp",
+    "${MPLFE_ROOT}/common/src/fe_type_hierarchy.cpp",
+    "${MPLFE_ROOT}/common/src/fe_type_manager.cpp",
+    "${MPLFE_ROOT}/common/src/fe_struct_elem_info.cpp",
+    "${MPLFE_ROOT}/common/src/fe_utils.cpp",
+    "${MPLFE_ROOT}/common/src/fe_utils_java.cpp",
+    "${MPLFE_ROOT}/common/src/feir_builder.cpp",
+    "${MPLFE_ROOT}/common/src/feir_dfg.cpp",
+    "${MPLFE_ROOT}/common/src/feir_stmt.cpp",
+    "${MPLFE_ROOT}/common/src/feir_type.cpp",
+    "${MPLFE_ROOT}/common/src/feir_type_helper.cpp",
+    "${MPLFE_ROOT}/common/src/feir_type_infer.cpp",
+    "${MPLFE_ROOT}/common/src/feir_var.cpp",
+    "${MPLFE_ROOT}/common/src/feir_var_name.cpp",
+    "${MPLFE_ROOT}/common/src/feir_var_reg.cpp",
+    "${MPLFE_ROOT}/common/src/feir_var_type_scatter.cpp",
+    "${MPLFE_ROOT}/common/src/general_bb.cpp",
+    "${MPLFE_ROOT}/common/src/general_cfg.cpp",
+    "${MPLFE_ROOT}/common/src/general_stmt.cpp",
+    "${MPLFE_ROOT}/common/src/mplfe_compiler.cpp",
+    "${MPLFE_ROOT}/common/src/mplfe_compiler_component.cpp",
+    "${MPLFE_ROOT}/common/src/mplfe_env.cpp",
+    "${MPLFE_ROOT}/common/src/mplfe_options.cpp",
+    "${MPLFE_ROOT}/common/src/simple_xml.cpp",
+    "${MPLFE_ROOT}/common/src/simple_zip.cpp",
   ]
   include_dirs = include_directories
 }
 
 static_library("lib_mplfe_input") {
   sources = [
-    "${MAPLEALL_ROOT}/mplfe/common/src/fe_input_helper.cpp",
+    "${MPLFE_ROOT}/common/src/fe_input_helper.cpp",
   ]
   include_dirs = include_directories
 }
 
 executable("mplfe") {
   sources = [
-    "${MAPLEALL_ROOT}/mplfe/common/src/mplfe.cpp",
+    "${MPLFE_ROOT}/common/src/mplfe.cpp",
   ]
   include_dirs = include_directories
   deps = [
@@ -99,8 +99,8 @@ executable("mplfe") {
 }
 
 include_jbc_input_directories = [
-  "${MAPLEALL_ROOT}/mplfe/common/include",
-  "${MAPLEALL_ROOT}/mplfe/jbc_input/include",
+  "${MPLFE_ROOT}/common/include",
+  "${MPLFE_ROOT}/jbc_input/include",
   "${MAPLEALL_ROOT}/maple_ir/include",
   "${MAPLEALL_ROOT}/maple_util/include",
   "${MAPLEALL_ROOT}/maple_driver/include",
@@ -110,23 +110,23 @@ include_jbc_input_directories = [
 
 static_library("lib_mplfe_jbc_input") {
   sources = [
-    "${MAPLEALL_ROOT}/mplfe/jbc_input/src/jbc_attr.cpp",
-    "${MAPLEALL_ROOT}/mplfe/jbc_input/src/jbc_attr_item.cpp",
-    "${MAPLEALL_ROOT}/mplfe/jbc_input/src/jbc_bb.cpp",
-    "${MAPLEALL_ROOT}/mplfe/jbc_input/src/jbc_class.cpp",
-    "${MAPLEALL_ROOT}/mplfe/jbc_input/src/jbc_class2fe_helper.cpp",
-    "${MAPLEALL_ROOT}/mplfe/jbc_input/src/jbc_class_const.cpp",
-    "${MAPLEALL_ROOT}/mplfe/jbc_input/src/jbc_class_const_pool.cpp",
-    "${MAPLEALL_ROOT}/mplfe/jbc_input/src/jbc_compiler_component.cpp",
-    "${MAPLEALL_ROOT}/mplfe/jbc_input/src/jbc_function.cpp",
-    "${MAPLEALL_ROOT}/mplfe/jbc_input/src/jbc_function_context.cpp",
-    "${MAPLEALL_ROOT}/mplfe/jbc_input/src/jbc_input.cpp",
-    "${MAPLEALL_ROOT}/mplfe/jbc_input/src/jbc_opcode.cpp",
-    "${MAPLEALL_ROOT}/mplfe/jbc_input/src/jbc_opcode_helper.cpp",
-    "${MAPLEALL_ROOT}/mplfe/jbc_input/src/jbc_stack2fe_helper.cpp",
-    "${MAPLEALL_ROOT}/mplfe/jbc_input/src/jbc_stack_helper.cpp",
-    "${MAPLEALL_ROOT}/mplfe/jbc_input/src/jbc_stmt.cpp",
-    "${MAPLEALL_ROOT}/mplfe/jbc_input/src/jbc_util.cpp",
+    "${MPLFE_ROOT}/jbc_input/src/jbc_attr.cpp",
+    "${MPLFE_ROOT}/jbc_input/src/jbc_attr_item.cpp",
+    "${MPLFE_ROOT}/jbc_input/src/jbc_bb.cpp",
+    "${MPLFE_ROOT}/jbc_input/src/jbc_class.cpp",
+    "${MPLFE_ROOT}/jbc_input/src/jbc_class2fe_helper.cpp",
+    "${MPLFE_ROOT}/jbc_input/src/jbc_class_const.cpp",
+    "${MPLFE_ROOT}/jbc_input/src/jbc_class_const_pool.cpp",
+    "${MPLFE_ROOT}/jbc_input/src/jbc_compiler_component.cpp",
+    "${MPLFE_ROOT}/jbc_input/src/jbc_function.cpp",
+    "${MPLFE_ROOT}/jbc_input/src/jbc_function_context.cpp",
+    "${MPLFE_ROOT}/jbc_input/src/jbc_input.cpp",
+    "${MPLFE_ROOT}/jbc_input/src/jbc_opcode.cpp",
+    "${MPLFE_ROOT}/jbc_input/src/jbc_opcode_helper.cpp",
+    "${MPLFE_ROOT}/jbc_input/src/jbc_stack2fe_helper.cpp",
+    "${MPLFE_ROOT}/jbc_input/src/jbc_stack_helper.cpp",
+    "${MPLFE_ROOT}/jbc_input/src/jbc_stmt.cpp",
+    "${MPLFE_ROOT}/jbc_input/src/jbc_util.cpp",
   ]
   include_dirs = include_jbc_input_directories
 }
diff --git a/src/mplfe/common/src/mplfe_compiler_component.cpp b/src/mplfe/common/src/mplfe_compiler_component.cpp
index 8a0ecdc90822e901e6de50f15c9416243c3dbcef..5979c8d323def4e9836f4031b34019fde36b00f6 100644
--- a/src/mplfe/common/src/mplfe_compiler_component.cpp
+++ b/src/mplfe/common/src/mplfe_compiler_component.cpp
@@ -78,6 +78,7 @@ bool MPLFECompilerComponent::ProcessFunctionParallelImpl(uint32 nthreads) {
   timer.StartAndDump(ss.str());
   FE_INFO_LEVEL(FEOptions::kDumpLevelInfo, "===== Process %s =====", ss.str().c_str());
   FEFunctionProcessSchedular schedular(ss.str());
+  schedular.Init();
   for (const std::unique_ptr<FEFunction> &function : functions) {
     schedular.AddFunctionProcessTask(function);
   }
@@ -99,4 +100,4 @@ void MPLFECompilerComponent::DumpPhaseTimeTotalImpl() const {
   CHECK_NULL_FATAL(phaseResultTotal);
   phaseResultTotal->DumpMS();
 }
-}  // namespace maple
\ No newline at end of file
+}  // namespace maple