diff --git a/src/bin/jbc2mpl b/src/bin/jbc2mpl
index 987e803daa6887157a3cb72c75a45b40439d0d4f..4648a2ecdc3a48d41a2dcc95231eadae5be84561 100755
Binary files a/src/bin/jbc2mpl and b/src/bin/jbc2mpl differ
diff --git a/src/bin/maple b/src/bin/maple
index 368895a8fdb51d5a134967b87917e07a11b3c753..90ab14cab8007777b5eb5280d35c635d8b76cd11 100755
Binary files a/src/bin/maple and b/src/bin/maple differ
diff --git a/src/deplibs/libmempool.a b/src/deplibs/libmempool.a
index 29f0ae940ee9106b52e72e9c7db0436de9b29540..f21d024ae004a397bb7b63b60f46934352a697b1 100644
Binary files a/src/deplibs/libmempool.a and b/src/deplibs/libmempool.a differ
diff --git a/src/deplibs/libmplphase.a b/src/deplibs/libmplphase.a
index d98a9bb6defcfa1ed8d7cda606caec939ec40bf7..854853dc1f8e27d8c168654fc31a1cfcfa7a09c7 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 9fd0079a236a7ae934f7cf345654c9251d325bcd..974d497c5d03105a7b39502370144ffb77d0f786 100644
Binary files a/src/deplibs/libmplutil.a and b/src/deplibs/libmplutil.a differ
diff --git a/src/maple_be/include/cg/aarch64/aarch64_cgfunc.h b/src/maple_be/include/cg/aarch64/aarch64_cgfunc.h
index 319bfa89892a5cecbf51af21dd542734b4451689..84aaf981c8bba37e81908354d64e10b43b36a337 100644
--- a/src/maple_be/include/cg/aarch64/aarch64_cgfunc.h
+++ b/src/maple_be/include/cg/aarch64/aarch64_cgfunc.h
@@ -231,6 +231,9 @@ class AArch64CGFunc : public CGFunc {
     return GetOrCreateFpZeroOperand(GetPrimTypeBitSize(ptyp));
   }
 
+  const Operand *GetFloatRflag() const override {
+    return nullptr;
+  }
   /* create an integer immediate operand */
   AArch64ImmOperand &CreateImmOperand(int64 val, uint32 size, bool isSigned, VaryType varyType = kNotVary,
                                       bool isFmov = false) {
diff --git a/src/maple_be/include/cg/aarch64/aarch64_ebo.h b/src/maple_be/include/cg/aarch64/aarch64_ebo.h
index f785cac5f21f4f145e0ca2f72a3566106c4e21c6..79fa21e7ed264b4819ae2af45d0bb5d2a141fa21 100644
--- a/src/maple_be/include/cg/aarch64/aarch64_ebo.h
+++ b/src/maple_be/include/cg/aarch64/aarch64_ebo.h
@@ -41,8 +41,9 @@ class AArch64Ebo : public Ebo {
   bool IsGlobalNeeded(Insn &insn) const override;
   bool OperandEqSpecial(const Operand &op1, const Operand &op2) const override;
   bool DoConstProp(Insn &insn, uint32 i, Operand &opnd) override;
-  bool DoConstantFold(Insn &insn, const MapleVector<Operand*> &opnds) override;
-  bool ConstantOperand(Insn &insn, const MapleVector<Operand*> &opnds, const MapleVector<OpndInfo*> &opndInfo) override;
+  bool Csel2Cset(Insn &insn, const MapleVector<Operand*> &opnds) override;
+  bool SimplifyConstOperand(Insn &insn, const MapleVector<Operand*> &opnds,
+                            const MapleVector<OpndInfo*> &opndInfo) override;
   void BuildCallerSaveRegisters() override;
   void DefineCallerSaveRegisters(InsnInfo &insnInfo) override;
   void DefineReturnUseRegister(Insn &insn) override;
diff --git a/src/maple_be/include/cg/cgfunc.h b/src/maple_be/include/cg/cgfunc.h
index 337b9c86707162e4121b9a53fe2d49a0dbf013ff..31f90329af438b67821c2d059634887caa2083af 100644
--- a/src/maple_be/include/cg/cgfunc.h
+++ b/src/maple_be/include/cg/cgfunc.h
@@ -234,6 +234,7 @@ class CGFunc {
 
   virtual Operand &GetOrCreateRflag() = 0;
   virtual const Operand *GetRflag() const = 0;
+  virtual const Operand *GetFloatRflag() const = 0;
   virtual const LabelOperand *GetLabelOperand(LabelIdx labIdx) const = 0;
   virtual LabelOperand &GetOrCreateLabelOperand(LabelIdx labIdx) = 0;
   virtual LabelOperand &GetOrCreateLabelOperand(BB &bb) = 0;
diff --git a/src/maple_be/include/cg/ebo.h b/src/maple_be/include/cg/ebo.h
index 19d81d910d53d3674628ace71443e7ddc6c9dc64..c3151581b05f7fc16969218e1421ab1b7518af25 100644
--- a/src/maple_be/include/cg/ebo.h
+++ b/src/maple_be/include/cg/ebo.h
@@ -188,9 +188,9 @@ class Ebo {
   virtual bool IsFmov(const Insn &insn) const = 0;
   virtual bool SpecialSequence(Insn &insn, const MapleVector<OpndInfo*> &origInfos) = 0;
   virtual bool DoConstProp(Insn &insn, uint32 i, Operand &opnd) = 0;
-  virtual bool DoConstantFold(Insn &insn, const MapleVector<Operand*> &opnds) = 0;
-  virtual bool ConstantOperand(Insn &insn, const MapleVector<Operand*> &opnds,
-                               const MapleVector<OpndInfo*> &opndInfo) = 0;
+  virtual bool Csel2Cset(Insn &insn, const MapleVector<Operand*> &opnds) = 0;
+  virtual bool SimplifyConstOperand(Insn &insn, const MapleVector<Operand*> &opnds,
+                                    const MapleVector<OpndInfo*> &opndInfo) = 0;
   virtual int32 GetOffsetVal(const MemOperand &mem) const = 0;
   virtual bool OperandEqSpecial(const Operand &op1, const Operand &op2) const = 0;
   virtual void BuildCallerSaveRegisters() = 0;
diff --git a/src/maple_be/src/be/lower.cpp b/src/maple_be/src/be/lower.cpp
index e68d1c9f1c0869222f398b5c1adc55008af39e96..6de2d313c635e705d488bba74256f784c3780e66 100644
--- a/src/maple_be/src/be/lower.cpp
+++ b/src/maple_be/src/be/lower.cpp
@@ -2441,8 +2441,8 @@ StmtNode *CGLowerer::LowerIntrinsiccall(IntrinsiccallNode &intrincall, BlockNode
   }
   /* default lowers intrinsic call to real function call. */
   MIRSymbol *st = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
-  const std::string name = intrinDesc->name;
   CHECK_FATAL(intrinDesc->name != nullptr, "intrinsic's name should not be nullptr");
+  const std::string name = intrinDesc->name;
   st->SetNameStrIdx(name);
   st->SetStorageClass(kScText);
   st->SetSKind(kStFunc);
diff --git a/src/maple_be/src/cg/aarch64/aarch64_ebo.cpp b/src/maple_be/src/cg/aarch64/aarch64_ebo.cpp
index 1c8efbd37ff53c39ca0a314e5dfe7ea191c5b023..9fd8f0fef8ee834893e4d4104f6ea6e11b369599 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_ebo.cpp
+++ b/src/maple_be/src/cg/aarch64/aarch64_ebo.cpp
@@ -140,12 +140,12 @@ void AArch64Ebo::BuildCallerSaveRegisters() {
   }
   for (uint32 i = V1; i <= V7; i++) {
     RegOperand &phyOpnd =
-        a64CGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(i), k64BitSize, kRegTyInt);
+        a64CGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(i), k64BitSize, kRegTyFloat);
     callerSaveRegTable.push_back(&phyOpnd);
   }
   for (uint32 i = V16; i <= V31; i++) {
     RegOperand &phyOpnd =
-        a64CGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(i), k64BitSize, kRegTyInt);
+        a64CGFunc->GetOrCreatePhysicalRegisterOperand(static_cast<AArch64reg>(i), k64BitSize, kRegTyFloat);
     callerSaveRegTable.push_back(&phyOpnd);
   }
   CHECK_FATAL(callerSaveRegTable.size() < kMaxCallerSaveReg,
@@ -253,10 +253,11 @@ int32 AArch64Ebo::GetOffsetVal(const MemOperand &mem) const {
 }
 
 /*
- * move vreg, 0
- * store vreg, mem
+ * move vreg1, #1
+ * move vreg2, vreg1
  * ===>
- * store wzr, mem
+ * move vreg1, #1
+ * move vreg2, #1
  * return true if do simplify successfully.
  */
 bool AArch64Ebo::DoConstProp(Insn &insn, uint32 idx, Operand &opnd) {
@@ -337,8 +338,8 @@ bool AArch64Ebo::DoConstProp(Insn &insn, uint32 idx, Operand &opnd) {
   return false;
 }
 
-/* Constant folding */
-bool AArch64Ebo::DoConstantFold(Insn &insn, const MapleVector<Operand*> &opnds) {
+/* optimize csel to cset */
+bool AArch64Ebo::Csel2Cset(Insn &insn, const MapleVector<Operand*> &opnds) {
   MOperator opCode = insn.GetMachineOpcode();
 
   if (insn.GetOpndNum() == 0) {
@@ -405,9 +406,9 @@ bool AArch64Ebo::DoConstantFold(Insn &insn, const MapleVector<Operand*> &opnds)
   return false;
 }
 
-/* Look at an exression that has a constant second operand and attempt to simplify the computations. */
-bool AArch64Ebo::ConstantOperand(Insn &insn, const MapleVector<Operand*> &opnds,
-                                 const MapleVector<OpndInfo*> &opndInfo) {
+/* Look at an expression that has a constant operand and attempt to simplify the computations. */
+bool AArch64Ebo::SimplifyConstOperand(Insn &insn, const MapleVector<Operand*> &opnds,
+                                      const MapleVector<OpndInfo*> &opndInfo) {
   BB *bb = insn.GetBB();
   bool result = false;
   if (insn.GetOpndNum() < 1) {
@@ -420,29 +421,78 @@ bool AArch64Ebo::ConstantOperand(Insn &insn, const MapleVector<Operand*> &opnds,
   CHECK_FATAL(res != nullptr, "null ptr check");
   const AArch64MD *md = &AArch64CG::kMd[static_cast<AArch64Insn*>(&insn)->GetMachineOpcode()];
   uint32 opndSize = md->GetOperandSize();
-  bool first = op0->IsConstant() && !op1->IsConstant();
-  ASSERT((op1->IsConstant() && !op0->IsConstant()) || (op0->IsConstant() && !op1->IsConstant()),
-         "op0 or op1 must be constant op");
+  bool op0IsConstant = op0->IsConstant() && !op1->IsConstant();
+  bool op1IsConstant = !op0->IsConstant() && op1->IsConstant();
+  bool bothConstant = op0->IsConstant() && op1->IsConstant();
   AArch64ImmOperand *immOpnd = nullptr;
   Operand *op = nullptr;
   int32 idx0 = kInsnSecondOpnd;
-  if (first) {
+  if (op0IsConstant) {
     immOpnd = static_cast<AArch64ImmOperand*>(op0);
     op = op1;
     if (op->IsMemoryAccessOperand()) {
       op = &(insn.GetOperand(kInsnThirdOpnd));
     }
     idx0 = kInsnThirdOpnd;
-  } else {
+  } else if (op1IsConstant) {
     immOpnd = static_cast<AArch64ImmOperand*>(op1);
     op = op0;
     if (op->IsMemoryAccessOperand()) {
       op = &(insn.GetOperand(kInsnSecondOpnd));
     }
+  } else if (bothConstant) {
+    /* special orr insn :
+     * orr resOp, imm1, 0
+     * =======>
+     * mov resOp, #0 */
+    if ((insn.GetMachineOpcode() == MOP_wiorrri12) || (insn.GetMachineOpcode() == MOP_xiorrri13) ||
+        (insn.GetMachineOpcode() == MOP_xiorri13r) || (insn.GetMachineOpcode() == MOP_wiorri12r)) {
+      immOpnd = static_cast<AArch64ImmOperand*>(op1);
+      op = op0;
+      if (op->IsMemoryAccessOperand()) {
+        op = &(insn.GetOperand(kInsnSecondOpnd));
+      }
+    } else {
+      return false;
+    }
+  } else if (bothConstant) {
+    /* i) special orr insn, one of imm is 0:
+     * orr resOp, imm1, #0  |  orr resOp, #0, imm1
+     * =======>
+     * mov resOp, imm1
+     *
+     * ii) special orr insn, both of imm is 0:
+     * orr resOp, #0, #0
+     * =======>
+     * mov resOp, #0 */
+    if ((insn.GetMachineOpcode() == MOP_wiorrri12) || (insn.GetMachineOpcode() == MOP_xiorrri13) ||
+        (insn.GetMachineOpcode() == MOP_xiorri13r) || (insn.GetMachineOpcode() == MOP_wiorri12r)) {
+      AArch64ImmOperand *immOpnd0 = static_cast<AArch64ImmOperand*>(op0);
+      AArch64ImmOperand *immOpnd1 = static_cast<AArch64ImmOperand*>(op1);
+      if (immOpnd0->IsZero() && immOpnd1->IsZero()) {
+        immOpnd = immOpnd0;
+        op = op0;
+      } else if (immOpnd0->IsZero()) {
+        immOpnd = immOpnd0;
+        op = op1;
+      } else if (immOpnd1->IsZero()) {
+        immOpnd = immOpnd1;
+        op = op0;
+      } else {
+        return false;
+      }
+      if (op->IsMemoryAccessOperand()) {
+        op = &(insn.GetOperand(kInsnSecondOpnd));
+      }
+    } else {
+      return false;
+    }
   }
+  CHECK_FATAL(immOpnd != nullptr, "constant operand required!");
+  CHECK_FATAL(op != nullptr, "constant operand required!");
   /* For orr insn and one of the opnd is zero */
   if (((insn.GetMachineOpcode() == MOP_wiorrri12) || (insn.GetMachineOpcode() == MOP_xiorrri13) ||
-      (insn.GetMachineOpcode() == MOP_xiorri13r) || (insn.GetMachineOpcode() == MOP_wiorri12r)) &&
+       (insn.GetMachineOpcode() == MOP_xiorri13r) || (insn.GetMachineOpcode() == MOP_wiorri12r)) &&
        immOpnd->IsZero()) {
     MOperator mOp = opndSize == k64BitSize ? MOP_xmovrr : MOP_wmovrr;
     Insn &newInsn = cgFunc->GetCG()->BuildInstruction<AArch64Insn>(mOp, *res, *op);
@@ -451,7 +501,7 @@ bool AArch64Ebo::ConstantOperand(Insn &insn, const MapleVector<Operand*> &opnds,
   }
   /* For the imm is 0. Then replace the insn by a move insn. */
   if (((MOP_xaddrrr <= insn.GetMachineOpcode()) && (insn.GetMachineOpcode() <= MOP_sadd) && immOpnd->IsZero()) ||
-      (!first && (MOP_xsubrrr <= insn.GetMachineOpcode()) && (insn.GetMachineOpcode() <= MOP_ssub) &&
+      (op1IsConstant && (MOP_xsubrrr <= insn.GetMachineOpcode()) && (insn.GetMachineOpcode() <= MOP_ssub) &&
        immOpnd->IsZero())) {
     Insn &newInsn = cgFunc->GetCG()->BuildInstruction<AArch64Insn>(opndSize == k64BitSize ? MOP_xmovrr : MOP_wmovrr,
                                                                    *res, *op);
diff --git a/src/maple_be/src/cg/aarch64/aarch64_md.def b/src/maple_be/src/cg/aarch64/aarch64_md.def
index fe89f03404e628524d7edac977309436fc850c1d..0e2b3c71f24ef506282423d5c3278b5f1a316970 100644
--- a/src/maple_be/src/cg/aarch64/aarch64_md.def
+++ b/src/maple_be/src/cg/aarch64/aarch64_md.def
@@ -706,7 +706,7 @@
  * stlxr  w2, w3, [xt]
  * cbnz   w2, label
  */
-{MOP_get_and_setI, {mopdReg32ID,mopdReg64ID,mopdReg32ID,mopdReg64IS,mopdReg64IDS,mopdReg32IS,mopdLabel},HASLOOP|CANTHROW,kLtBranch,"intrinsic_get_set_int","0,1,2,3,4",4},
+{MOP_get_and_setI, {mopdReg32ID,mopdReg64ID,mopdReg32ID,mopdReg64IS,mopdReg64IS,mopdReg32IS,mopdLabel},HASLOOP|CANTHROW,kLtBranch,"intrinsic_get_set_int","0,1,2,3,4",4},
 /*
  * intrinsic Unsafe.getAndSetLong
  * intrinsic_get_set_long x0, x1, x2, x3, label
@@ -716,7 +716,7 @@
  * stlxr  w2, x3, [xt]
  * cbnz   w2, label
  */
-{MOP_get_and_setL, {mopdReg64ID,mopdReg64ID,mopdReg32ID,mopdReg64IS,mopdReg64IDS,mopdReg64IS,mopdLabel},HASLOOP|CANTHROW,kLtBranch,"intrinsic_get_set_long","0,1,2,3,4",4},
+{MOP_get_and_setL, {mopdReg64ID,mopdReg64ID,mopdReg32ID,mopdReg64IS,mopdReg64IS,mopdReg64IS,mopdLabel},HASLOOP|CANTHROW,kLtBranch,"intrinsic_get_set_long","0,1,2,3,4",4},
 
 /*
  * intrinsic Unsafe.compareAndSwapInt
diff --git a/src/maple_be/src/cg/ebo.cpp b/src/maple_be/src/cg/ebo.cpp
index f62115bf75577dc34240226d0acc105bbbaaaf69..5e675ebcd3f15d7560d4f967e42ba294a25bfcb9 100644
--- a/src/maple_be/src/cg/ebo.cpp
+++ b/src/maple_be/src/cg/ebo.cpp
@@ -482,7 +482,6 @@ OpndInfo *Ebo::BuildOperandInfo(BB &bb, Insn &insn, Operand &opnd, uint32 opndIn
 bool Ebo::ForwardPropagateOpnd(Insn &insn, Operand *&opnd, uint32 opndIndex,
                                OpndInfo *&opndInfo, MapleVector<OpndInfo*> &origInfos) {
   CHECK_FATAL(opnd != nullptr, "nullptr check");
-  bool replaceInsnExist = false;
   Operand *opndReplace = opndInfo->replacementOpnd;
   /* Don't propagate physical registers before register allocation. */
   if (beforeRegAlloc && (opndReplace != nullptr) && (IsPhysicalReg(*opndReplace) || IsPhysicalReg(*opnd))) {
@@ -509,6 +508,24 @@ bool Ebo::ForwardPropagateOpnd(Insn &insn, Operand *&opnd, uint32 opndIndex,
         origInfos.at(opndIndex) = opndInfo;
       }
     }
+    /* move reg, wzr, store vreg, mem ==> store wzr, mem */
+#if TARGAARCH64
+    if (opnd->IsZeroRegister() && opndIndex == 0 &&
+        (insn.GetMachineOpcode() == MOP_wstr || insn.GetMachineOpcode() == MOP_xstr)) {
+      if (EBO_DUMP) {
+        LogInfo::MapleLogger() << "===replace operand " << opndIndex << " of insn: \n";
+        insn.Dump();
+        LogInfo::MapleLogger() << "the new insn is:\n";
+      }
+      insn.SetOperand(opndIndex, *opnd);
+      DecRef(*origInfos.at(opndIndex));
+      /* Update the actual expression info. */
+      origInfos.at(opndIndex) = opndInfo;
+      if (EBO_DUMP) {
+        insn.Dump();
+      }
+    }
+#endif
     /* forward prop for registers. */
     if (!opnd->IsConstant() &&
         (!beforeRegAlloc || (HasAssignedReg(*oldOpnd) == HasAssignedReg(*opndReplace)) || opnd->IsConstReg() ||
@@ -527,8 +544,7 @@ bool Ebo::ForwardPropagateOpnd(Insn &insn, Operand *&opnd, uint32 opndIndex,
           insn.Dump();
           LogInfo::MapleLogger() << "===Remove the new insn because Copies to and from the same register. \n";
         }
-        replaceInsnExist = true;
-        return replaceInsnExist;
+        return true;
       }
 
       if (EBO_DUMP) {
@@ -552,7 +568,7 @@ bool Ebo::ForwardPropagateOpnd(Insn &insn, Operand *&opnd, uint32 opndIndex,
     }
   }
 
-  return replaceInsnExist;
+  return false;
 }
 
 /*
@@ -581,16 +597,19 @@ void Ebo::SimplifyInsn(Insn &insn, bool &insnReplaced, bool opndsConstant,
     uint32 opndNum = insn.GetOpndNum();
     if (opndsConstant && (opndNum > 1)) {
       if (insn.GetResultNum() >= 1) {
-        insnReplaced = DoConstantFold(insn, opnds);
+        insnReplaced = Csel2Cset(insn, opnds);
       }
-    } else if (opndNum >= 1) {
+    }
+    if (insnReplaced) {
+      return;
+    }
+    if (opndNum >= 1) {
       /* special case */
       if (insn.GetResultNum() > 0 && ResIsNotDefAndUse(insn)) {
-        /* Here mainly to do is optimizatinn of "add" with two source operands when only one operand is constant */
         if ((opndNum == 2) && (insn.GetResultNum() == 1) &&
             (((opnds[kInsnSecondOpnd] != nullptr) && opnds[kInsnSecondOpnd]->IsConstant()) ||
              ((opnds[kInsnThirdOpnd] != nullptr) && opnds[kInsnThirdOpnd]->IsConstant()))) {
-          insnReplaced = ConstantOperand(insn, opnds, opndInfos);
+          insnReplaced = SimplifyConstOperand(insn, opnds, opndInfos);
         }
       }
       if (!insnReplaced) {
diff --git a/src/maple_be/src/cg/emit.cpp b/src/maple_be/src/cg/emit.cpp
index 51aec39d7f12728bfbe854535e3fea504f1eaf63..262b9397e73ad8caeb3b50a96e155f17c8f832ab 100644
--- a/src/maple_be/src/cg/emit.cpp
+++ b/src/maple_be/src/cg/emit.cpp
@@ -26,6 +26,7 @@ using namespace NameMangler;
 namespace {
 using namespace maple;
 constexpr uint32 kSizeOfHugesoRoutine = 3;
+constexpr uint32 kFromDefIndexMask32Mod = 0x40000000;
 
 int32 GetPrimitiveTypeSize(const std::string &name) {
   if (name.length() != 1) {
@@ -696,11 +697,17 @@ void Emitter::EmitAddrofSymbolConst(const MIRSymbol &mirSymbol, MIRConst &elemCo
   }
 
   if ((idx == static_cast<uint32>(FieldProperty::kDeclarclass)) && mirSymbol.IsReflectionFieldsInfo()) {
+#if USE_32BIT_REF
+    Emit("\t.long\t");
+#else
+
 #if TARGAARCH64
     Emit("\t.quad\t");
 #else
     Emit("\t.word\t");
 #endif
+
+#endif  /* USE_32BIT_REF */
     Emit(symAddrName + " - .\n");
     return;
   }
@@ -1066,7 +1073,7 @@ void Emitter::EmitIntConst(const MIRSymbol &mirSymbol, MIRAggConst &aggConst, ui
       } else if (idx == static_cast<uint32>(ClassRO::kClassName)) {
         /* output in hex format to show it is a flag of bits. */
         std::stringstream ss;
-        ss << std::hex << "0x" << MByteRef::PositiveOffsetBias;
+        ss << std::hex << "0x" << MByteRef::kPositiveOffsetBias;
         Emit(" - . + " + ss.str());
       }
     }
@@ -1076,7 +1083,7 @@ void Emitter::EmitIntConst(const MIRSymbol &mirSymbol, MIRAggConst &aggConst, ui
     if (StringUtils::StartsWith(stName, ITAB_CONFLICT_PREFIX_STR)) {
       /* output in hex format to show it is a flag of bits. */
       std::stringstream ss;
-      ss << std::hex << "0x" << MByteRef32::PositiveOffsetBias;
+      ss << std::hex << "0x" << MByteRef32::kPositiveOffsetBias;
       Emit(" - . + " + ss.str());
     }
     if ((idx == 1 || idx == methodTypeIdx) && StringUtils::StartsWith(stName, kVtabOffsetTabStr)) {
@@ -1105,11 +1112,33 @@ void Emitter::EmitIntConst(const MIRSymbol &mirSymbol, MIRAggConst &aggConst, ui
     } else {
       Emit("0\n");
     }
+  } else if (idx == static_cast<uint32>(FieldProperty::kPClassType) && mirSymbol.IsReflectionFieldsInfo()) {
+#ifdef USE_32BIT_REF
+    Emit("\t.long\t");
+    const int width = 4;
+#else
+    Emit("\t.quad\t");
+    const int width = 8;
+#endif  /* USE_32BIT_REF */
+    uint32 muidDataTabAddr = static_cast<uint32>((safe_cast<MIRIntConst>(elemConst))->GetValue());
+    if (muidDataTabAddr != 0) {
+      bool isDefTabIndex = (muidDataTabAddr & kFromDefIndexMask32Mod) == kFromDefIndexMask32Mod;
+      std::string muidDataTabPrefix = isDefTabIndex ? kMuidDataDefTabPrefixStr : kMuidDataUndefTabPrefixStr;
+      std::string muidDataTabName = muidDataTabPrefix + cg->GetMIRModule()->GetFileNameAsPostfix();
+      Emit(muidDataTabName + "+");
+      uint32 muidDataTabIndex = muidDataTabAddr & 0x3FFFFFFF; // high 2 bit is the mask of muid tab
+      Emit(std::to_string(muidDataTabIndex * width));
+      Emit("-.\n");
+    } else {
+      Emit(muidDataTabAddr);
+      Emit("\n");
+    }
+    return;
   } else if (mirSymbol.IsRegJNIFuncTab()) {
     std::string strTabName = kRegJNITabPrefixStr + cg->GetMIRModule()->GetFileNameAsPostfix();
     EmitScalarConstant(*elemConst, false);
 #ifdef TARGARM32
-    Emit("+" + strTabName).Emit("+").Emit(MByteRef::PositiveOffsetBias).Emit("-.\n");
+    Emit("+" + strTabName).Emit("+").Emit(MByteRef::kPositiveOffsetBias).Emit("-.\n");
 #else
     Emit("+" + strTabName + "\n");
 #endif
@@ -1270,7 +1299,7 @@ void Emitter::EmitConstantTable(const MIRSymbol &mirSymbol, MIRConst &mirConst,
       } else if (elemConst->GetKind() == kConstAddrof) {  /* addrof symbol const */
         EmitAddrofSymbolConst(mirSymbol, *elemConst, i);
       } else {                                            /* intconst */
-        EmitIntConst(mirSymbol, aggConst, itabConflictIndex,  strIdx2Type, i);
+        EmitIntConst(mirSymbol, aggConst, itabConflictIndex, strIdx2Type, i);
       }
     } else if (elemConst->GetType().GetKind() == kTypeArray || elemConst->GetType().GetKind() == kTypeStruct) {
       if (StringUtils::StartsWith(mirSymbol.GetName(), NameMangler::kOffsetTabStr) && (i == 0 || i == 1)) {
@@ -1678,6 +1707,7 @@ void Emitter::EmitGlobalVariable() {
   std::vector<MIRSymbol*> methodAddrDatas;
   std::vector<MIRSymbol*> staticDecoupleKeyVec;
   std::vector<MIRSymbol*> staticDecoupleValueVec;
+  std::vector<MIRSymbol*> superClassStVec;
 
   for (size_t i = 0; i < size; ++i) {
     MIRSymbol *mirSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(i);
@@ -1746,6 +1776,9 @@ void Emitter::EmitGlobalVariable() {
     } else if (mirSymbol->IsReflectionMethodAddrData()) {
       methodAddrDatas.push_back(mirSymbol);
       continue;
+    } else if (mirSymbol->IsReflectionSuperclassInfo()) {
+      superClassStVec.push_back(mirSymbol);
+      continue;
     }
 
     if (mirSymbol->IsReflectionInfo()) {
@@ -1895,7 +1928,6 @@ void Emitter::EmitGlobalVariable() {
   EmitMuidTable(constStrVec, strIdx2Type, kMuidConststrPrefixStr);
 
   /* emit classinfo, field, method */
-  std::vector<MIRSymbol*> superClassStVec;
   std::vector<MIRSymbol*> fieldInfoStVec;
   std::vector<MIRSymbol*> fieldInfoStCompactVec;
   std::vector<MIRSymbol*> methodInfoStVec;
@@ -1926,9 +1958,6 @@ void Emitter::EmitGlobalVariable() {
         GlobalTables::GetStrTable().GetStrIdxFromName(kMethodsInfoPrefixStr + className));
       MIRSymbol *methodStCompact = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
         GlobalTables::GetStrTable().GetStrIdxFromName(kMethodsInfoCompactPrefixStr + className));
-      /* Get superclass */
-      MIRSymbol *superClassSt = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(
-        GlobalTables::GetStrTable().GetStrIdxFromName(SUPERCLASSINFO_PREFIX_STR + className));
 
       if (fieldSt != nullptr) {
         fieldInfoStVec.push_back(fieldSt);
@@ -1942,9 +1971,6 @@ void Emitter::EmitGlobalVariable() {
       if (methodStCompact != nullptr) {
         methodInfoStCompactVec.push_back(methodStCompact);
       }
-      if (superClassSt != nullptr) {
-        superClassStVec.push_back(superClassSt);
-      }
     }
   }
   Emit(sectionName + "_end:\n");
@@ -1959,16 +1985,12 @@ void Emitter::EmitGlobalVariable() {
   std::vector<MIRSymbol*> coldMethodsInfoCStVec;
   std::vector<MIRSymbol*> hotFieldsInfoCStVec;
   std::vector<MIRSymbol*> coldFieldsInfoCStVec;
-  std::vector<MIRSymbol*> hotSuperClassStVec;
-  std::vector<MIRSymbol*> coldSuperClassStVec;
   GetHotAndColdMetaSymbolInfo(vtabVec, hotVtabStVec, coldVtabStVec, VTAB_PREFIX_STR,
                               ((CGOptions::IsLazyBinding() || CGOptions::IsHotFix()) && !cg->IsLibcore()));
   GetHotAndColdMetaSymbolInfo(itabVec, hotItabStVec, coldItabStVec, ITAB_PREFIX_STR,
                               ((CGOptions::IsLazyBinding() || CGOptions::IsHotFix()) && !cg->IsLibcore()));
   GetHotAndColdMetaSymbolInfo(itabConflictVec, hotItabCStVec, coldItabCStVec, ITAB_CONFLICT_PREFIX_STR,
                               ((CGOptions::IsLazyBinding() || CGOptions::IsHotFix()) && !cg->IsLibcore()));
-  GetHotAndColdMetaSymbolInfo(superClassStVec, hotSuperClassStVec, coldSuperClassStVec, SUPERCLASSINFO_PREFIX_STR,
-                              ((CGOptions::IsLazyBinding() || CGOptions::IsHotFix()) && !cg->IsLibcore()));
   GetHotAndColdMetaSymbolInfo(fieldInfoStVec, hotFieldsInfoCStVec, coldFieldsInfoCStVec, kFieldsInfoPrefixStr);
   GetHotAndColdMetaSymbolInfo(methodInfoStVec, hotMethodsInfoCStVec, coldMethodsInfoCStVec, kMethodsInfoPrefixStr);
 
@@ -2019,9 +2041,7 @@ void Emitter::EmitGlobalVariable() {
   EmitMuidTable(staticDecoupleValueVec, strIdx2Type, kDecoupleStaticValueStr);
 
   /* super class */
-  EmitMuidTable(hotSuperClassStVec, strIdx2Type, kMuidSuperclassPrefixStr);
-  EmitMetaDataSymbolWithMarkFlag(coldSuperClassStVec, strIdx2Type, SUPERCLASSINFO_PREFIX_STR, sectionNameIsEmpty,
-                                 false);
+  EmitMuidTable(superClassStVec, strIdx2Type, kMuidSuperclassPrefixStr);
 
   /* field offset rw */
   EmitMetaDataSymbolWithMarkFlag(fieldOffsetDatas, strIdx2Type, kFieldOffsetDataPrefixStr, sectionNameIsEmpty, false);
diff --git a/src/maple_driver/include/mpl_options.h b/src/maple_driver/include/mpl_options.h
index 4ba6e2786a761338d45d56a77efb971ec323e128..19a848a83b90deed56320e327cfa4a7379a39be1 100644
--- a/src/maple_driver/include/mpl_options.h
+++ b/src/maple_driver/include/mpl_options.h
@@ -170,10 +170,6 @@ class MplOptions {
     return genVtableImpl;
   }
 
-  bool HasSetVerify() const {
-    return verify;
-  }
-
  private:
   bool Init(const std::string &inputFile);
   ErrorCode HandleGeneralOptions();
@@ -210,7 +206,6 @@ class MplOptions {
   bool timePhases = false;
   bool genMeMpl = false;
   bool genVtableImpl = false;
-  bool verify = false;
   unsigned int helpLevel = mapleOption::kBuildTypeDefault;
 };
 }  // namespace maple
diff --git a/src/maple_driver/src/maple_comb_compiler.cpp b/src/maple_driver/src/maple_comb_compiler.cpp
index 002bca9e0ed065ac84e065c08e34df115d673f9b..b64ba13b08cfaadb0592f32eecce737faa8447cb 100644
--- a/src/maple_driver/src/maple_comb_compiler.cpp
+++ b/src/maple_driver/src/maple_comb_compiler.cpp
@@ -119,8 +119,7 @@ bool MapleCombCompiler::MakeMpl2MplOptions(const MplOptions &options) {
     LogInfo::MapleLogger() << "no mpl2mpl input options\n";
     return false;
   }
-  bool result = mpl2mplOption.SolveOptions(it->second,
-                                           options.HasSetDebugFlag());
+  bool result = mpl2mplOption.SolveOptions(it->second, options.HasSetDebugFlag());
   if (result == false) {
     LogInfo::MapleLogger() << "Meet error mpl2mpl options\n";
     return false;
diff --git a/src/maple_ipa/include/callgraph.h b/src/maple_ipa/include/callgraph.h
index 7db64edcfe2ba30005798eabb88f4cf436077a86..f48142cf750d3e77505a5b72a0a29a8da55ff217 100644
--- a/src/maple_ipa/include/callgraph.h
+++ b/src/maple_ipa/include/callgraph.h
@@ -95,9 +95,6 @@ class CallInfo {
   uint32 id;
 };
 
-class CGNode;
-using Callsite = std::pair<CallInfo*, MapleSet<CGNode*, Comparator<CGNode>>*>;
-using CalleeIt = MapleMap<CallInfo*, MapleSet<CGNode*, Comparator<CGNode>>*, Comparator<CallInfo>>::iterator;
 // Node in callgraph
 class CGNode {
  public:
@@ -152,11 +149,11 @@ class CGNode {
   }
 
   int32 GetPuIdx() const {
-    return mirFunc ? mirFunc->GetPuidx() : -1;
+    return (mirFunc != nullptr) ? mirFunc->GetPuidx() : -1;
   }
 
   const std::string &GetMIRFuncName() const {
-    return mirFunc ? mirFunc->GetName() : GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(0));
+    return (mirFunc != nullptr) ? mirFunc->GetName() : GlobalTables::GetStrTable().GetStringFromStrIdx(GStrIdx(0));
   }
 
   void AddCandsForCallNode(const KlassHierarchy &kh);
@@ -305,6 +302,9 @@ class CGNode {
   MapleVector<MIRFunction*> vcallCands;
 };
 
+using Callsite = std::pair<CallInfo*, MapleSet<CGNode*, Comparator<CGNode>>*>;
+using CalleeIt = MapleMap<CallInfo*, MapleSet<CGNode*, Comparator<CGNode>>*, Comparator<CallInfo>>::iterator;
+
 class SCCNode {
  public:
   uint32 id;
@@ -345,6 +345,7 @@ class SCCNode {
     return id;
   }
 };
+
 class CallGraph : public AnalysisResult {
  public:
   CallGraph(MIRModule &m, MemPool &memPool, KlassHierarchy &kh, const std::string &fn);
diff --git a/src/maple_ipa/src/callgraph.cpp b/src/maple_ipa/src/callgraph.cpp
index 9bfbe5d8c1ec67fa5c5b1d68c5d059bde7c1025c..57e344af0392abbfde3a2bddbc8568ff66413289 100644
--- a/src/maple_ipa/src/callgraph.cpp
+++ b/src/maple_ipa/src/callgraph.cpp
@@ -310,7 +310,7 @@ CGNode *CallGraph::GetCGNode(PUIdx puIdx) const {
 
 SCCNode *CallGraph::GetSCCNode(MIRFunction *func) const {
   CGNode *cgNode = GetCGNode(func);
-  return cgNode != nullptr ? cgNode->GetSCCNode() : nullptr;
+  return (cgNode != nullptr) ? cgNode->GetSCCNode() : nullptr;
 }
 
 bool CallGraph::IsRootNode(MIRFunction *func) const {
@@ -688,6 +688,14 @@ void IPODevirtulize::SearchDefInClinit(const Klass &klass) {
           GCMallocNode *gcmallocNode = static_cast<GCMallocNode*>(dassignNode->GetRHS());
           TyIdx inferredTypeIdx = gcmallocNode->GetTyIdx();
           SetInferredType(gcmallocSymbols, *leftSymbol, inferredTypeIdx);
+        } else if (dassignNode->GetRHS()->GetOpCode() == OP_retype) {
+          if (dassignNode->GetRHS()->Opnd(0)->GetOpCode() == OP_dread) {
+            DreadNode *dreadNode = static_cast<DreadNode*>(dassignNode->GetRHS()->Opnd(0));
+            MIRSymbol *rightSymbol = func->GetLocalOrGlobalSymbol(dreadNode->GetStIdx());
+            if (rightSymbol->GetInferredTyIdx() != kInitTyIdx && rightSymbol->GetInferredTyIdx() != kNoneTyIdx) {
+              SetInferredType(gcmallocSymbols, *leftSymbol, rightSymbol->GetInferredTyIdx());
+            }
+          }
         } else {
           ResetInferredType(gcmallocSymbols, leftSymbol);
         }
@@ -697,7 +705,8 @@ void IPODevirtulize::SearchDefInClinit(const Klass &klass) {
       case OP_callassigned: {
         CallNode *callNode = static_cast<CallNode*>(stmt);
         MIRFunction *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(callNode->GetPUIdx());
-        if (calleeFunc->GetName().find(NameMangler::kClinitSubStr, 0) != std::string::npos) {
+        if (calleeFunc->GetName().find(NameMangler::kClinitSubStr, 0) != std::string::npos ||
+            calleeFunc->GetName().find("MCC_", 0) == 0) {
           // ignore all side effect of initizlizor
           continue;
         }
@@ -880,6 +889,8 @@ void DoDevirtual(const Klass &klass, const KlassHierarchy &klassh) {
         case OP_assertnonnull:
         case OP_brtrue:
         case OP_brfalse:
+        case OP_try:
+        case OP_endtry:
           break;
         case OP_dassign: {
           DassignNode *dassignNode = static_cast<DassignNode*>(stmt);
@@ -1667,7 +1678,7 @@ MIRFunction *CGNode::HasOneCandidate() const {
       }
     }
   }
-  return count == 1 ? cand : nullptr;
+  return (count == 1) ? cand : nullptr;
 }
 
 AnalysisResult *DoCallGraph::Run(MIRModule *module, ModuleResultMgr *m) {
diff --git a/src/maple_ipa/src/clone.cpp b/src/maple_ipa/src/clone.cpp
index 361be9893750d0575bd583c3f94e4b0271db386e..56d1de62b8cd34f490cc9f5610c2f8fcd5e997ba 100644
--- a/src/maple_ipa/src/clone.cpp
+++ b/src/maple_ipa/src/clone.cpp
@@ -101,10 +101,8 @@ MIRFunction *Clone::CloneFunction(MIRFunction &originalFunction, const std::stri
   }
   std::string fullName = originalFunction.GetBaseClassName();
   const std::string &signature = originalFunction.GetSignature();
-  fullName = fullName.append(NameMangler::kNameSplitterStr)
-                     .append(newBaseFuncName)
-                     .append(NameMangler::kNameSplitterStr)
-                     .append(signature);
+  fullName = fullName.append(
+      NameMangler::kNameSplitterStr).append(newBaseFuncName).append(NameMangler::kNameSplitterStr).append(signature);
   MIRFunction *newFunc =
       dexBuilder.CreateFunction(fullName, *retType, argument, false, originalFunction.GetBody() != nullptr);
   CHECK_FATAL(newFunc != nullptr, "create cloned function failed");
diff --git a/src/maple_ir/include/global_tables.h b/src/maple_ir/include/global_tables.h
index 5e8bce42e95cc339968460f27df720b4e0e94fd7..f8864c348d46c11e9bc64a359a8c57a0a5b06897 100644
--- a/src/maple_ir/include/global_tables.h
+++ b/src/maple_ir/include/global_tables.h
@@ -116,9 +116,9 @@ class TypeTable {
 
   void SetTypeWithTyIdx(const TyIdx &tyIdx, MIRType &type);
 
-  MIRType *CreateAndUpdateMirTypeNode(MIRType *pType);
-  MIRType *GetOrCreateMIRTypeNode(MIRType *ptype);
-  TyIdx GetOrCreateMIRType(MIRType *pType) { return GetOrCreateMIRTypeNode(pType)->GetTypeIndex(); }
+  TyIdx GetOrCreateMIRType(MIRType *pType) {
+    return GetOrCreateMIRTypeNode(*pType)->GetTypeIndex();
+  }
 
   size_t GetTypeTableSize() const {
     return typeTable.size();
@@ -356,6 +356,8 @@ class TypeTable {
     return newType;
   }
 
+  MIRType *CreateAndUpdateMirTypeNode(MIRType &pType);
+  MIRType *GetOrCreateMIRTypeNode(MIRType &ptype);
   MIRType *GetOrCreateStructOrUnion(const std::string &name, const FieldVector &fields, const FieldVector &printFields,
                                     MIRModule &module, bool forStruct = true);
   MIRType *GetOrCreateClassOrInterface(const std::string &name, MIRModule &module, bool forClass);
diff --git a/src/maple_ir/include/metadata_layout.h b/src/maple_ir/include/metadata_layout.h
index b4b89ce3509ddde588b9640be3f51ea8eafc2abe..a704c581279befc9f37cbb73c718a77b55b97cf2 100644
--- a/src/maple_ir/include/metadata_layout.h
+++ b/src/maple_ir/include/metadata_layout.h
@@ -159,26 +159,26 @@ struct MByteRef {
 
 #if defined(__arm__) || defined(USE_ARM32_MACRO)
   // assume address range 0 ~ 256MB is unused in arm runtime
-  // EncodedOffsetMin ~ EncodedOffsetMax is the value range of encoded offset
-  static constexpr intptr_t OffsetBound = 128 * 1024 * 1024;
-  static constexpr intptr_t OffsetMin = -OffsetBound;
-  static constexpr intptr_t OffsetMax = OffsetBound;
-
-  static constexpr intptr_t PositiveOffsetBias = 128 * 1024 * 1024;
-  static constexpr intptr_t EncodedOffsetMin = PositiveOffsetBias + OffsetMin;
-  static constexpr intptr_t EncodedOffsetMax = PositiveOffsetBias + OffsetMax;
+  // kEncodedOffsetMin ~ kEncodedOffsetMax is the value range of encoded offset
+  static constexpr intptr_t kOffsetBound = 128 * 1024 * 1024;
+  static constexpr intptr_t kOffsetMin = -kOffsetBound;
+  static constexpr intptr_t kOffsetMax = kOffsetBound;
+
+  static constexpr intptr_t kPositiveOffsetBias = 128 * 1024 * 1024;
+  static constexpr intptr_t kEncodedOffsetMin = kPositiveOffsetBias + kOffsetMin;
+  static constexpr intptr_t kEncodedOffsetMax = kPositiveOffsetBias + kOffsetMax;
 #else
   enum {
     kBiasBitPosition = sizeof(refVal) * 8 - 4, // the most significant 4 bits
   };
 
-  static constexpr uintptr_t OffsetBound = 256 * 1024 * 1024; // according to kDsoLoadedAddessEnd = 0xF0000000
-  static constexpr uintptr_t PositiveOffsetMin = 0;
-  static constexpr uintptr_t PositiveOffsetMax = OffsetBound;
+  static constexpr uintptr_t kOffsetBound = 256 * 1024 * 1024; // according to kDsoLoadedAddessEnd = 0xF0000000
+  static constexpr uintptr_t kPositiveOffsetMin = 0;
+  static constexpr uintptr_t kPositiveOffsetMax = kOffsetBound;
 
-  static constexpr uintptr_t PositiveOffsetBias = static_cast<uintptr_t>(6) << kBiasBitPosition;
-  static constexpr uintptr_t EncodedPosOffsetMin = PositiveOffsetMin + PositiveOffsetBias;
-  static constexpr uintptr_t EncodedPosOffsetMax = PositiveOffsetMax + PositiveOffsetBias;
+  static constexpr uintptr_t kPositiveOffsetBias = static_cast<uintptr_t>(6) << kBiasBitPosition;
+  static constexpr uintptr_t kEncodedPosOffsetMin = kPositiveOffsetMin + kPositiveOffsetBias;
+  static constexpr uintptr_t kEncodedPosOffsetMax = kPositiveOffsetMax + kPositiveOffsetBias;
 #endif
 
   template<typename T>
@@ -190,19 +190,19 @@ struct MByteRef {
 
 struct MByteRef32 {
   uint32_t refVal;
-  static constexpr uint32_t OffsetBound = 256 * 1024 * 1024; // according to kDsoLoadedAddessEnd = 0xF0000000
-  static constexpr uint32_t PositiveOffsetMin = 0;
-  static constexpr uint32_t PositiveOffsetMax = OffsetBound;
+  static constexpr uint32_t kOffsetBound = 256 * 1024 * 1024; // according to kDsoLoadedAddessEnd = 0xF0000000
+  static constexpr uint32_t kPositiveOffsetMin = 0;
+  static constexpr uint32_t kPositiveOffsetMax = kOffsetBound;
 
-  static constexpr uint32_t PositiveOffsetBias = 0x60000000; // the most significant 4 bits 0110
-  static constexpr uint32_t EncodedPosOffsetMin = PositiveOffsetMin + PositiveOffsetBias;
-  static constexpr uint32_t EncodedPosOffsetMax = PositiveOffsetMax + PositiveOffsetBias;
+  static constexpr uint32_t kPositiveOffsetBias = 0x60000000; // the most significant 4 bits 0110
+  static constexpr uint32_t kEncodedPosOffsetMin = kPositiveOffsetMin + kPositiveOffsetBias;
+  static constexpr uint32_t kEncodedPosOffsetMax = kPositiveOffsetMax + kPositiveOffsetBias;
 
-  static constexpr uint32_t DirectRefMin = 0xC0000000; // according to kDsoLoadedAddessStart = 0xC0000000
-  static constexpr uint32_t DirectRefMax = 0xF0000000; // according to kDsoLoadedAddessEnd = 0xF0000000
+  static constexpr uint32_t kDirectRefMin = 0xC0000000; // according to kDsoLoadedAddessStart = 0xC0000000
+  static constexpr uint32_t kDirectRefMax = 0xF0000000; // according to kDsoLoadedAddessEnd = 0xF0000000
 
-  static constexpr int32_t NegativeOffsetMin = -OffsetBound;
-  static constexpr int32_t NegativeOffsetMax = 0;
+  static constexpr int32_t kNegativeOffsetMin = -(256 * 1024 * 1024); // -kOffsetBound
+  static constexpr int32_t kNegativeOffsetMax = 0;
 
   template<typename T>
   inline T GetRef() const;
@@ -213,7 +213,7 @@ struct MByteRef32 {
   inline bool IsNegativeOffset() const;
 };
 
-// MethodMeta defined in MethodMeta.h
+// MethodMeta defined in methodmeta.h
 // FieldMeta  defined in FieldMeta.h
 // MethodDesc contains MethodMetadata and stack map
 struct MethodDesc {
@@ -252,7 +252,7 @@ struct ClassMetadataRO {
   DataRefOffset32 clinitAddr;
 };
 
-static constexpr size_t PageSize = 4096;
+static constexpr size_t kPageSize = 4096;
 static constexpr size_t kCacheLine = 64;
 
 // according to kSpaceAnchor and kFireBreak defined in bpallocator.cpp
@@ -280,7 +280,7 @@ enum ClassInitState {
 };
 
 enum SEGVAddr {
-  kSEGVAddrRangeStart            = PageSize + 0,
+  kSEGVAddrRangeStart            = kPageSize + 0,
 
   // Note any readable address is treated as Initialized.
   kSEGVAddrForClassInitStateMin  = kSEGVAddrRangeStart + kClassInitStateMin,
diff --git a/src/maple_ir/include/mir_type.h b/src/maple_ir/include/mir_type.h
index 688856536dee71e77a5b74d15beef8cd4b3b2019..faa9b0aa44b2c87ad3c5cd319633bb55739a8256 100644
--- a/src/maple_ir/include/mir_type.h
+++ b/src/maple_ir/include/mir_type.h
@@ -962,6 +962,10 @@ class MIRStructType : public MIRType {
     CHECK_FATAL(false, "can not use GetInfoIsString");
   }
 
+  virtual bool GetInfoIsStringElemt(size_t) const {
+    CHECK_FATAL(false, "can not use GetInfoIsStringElemt");
+  }
+
   virtual const std::vector<MIRPragma*> &GetPragmaVec() const {
     CHECK_FATAL(false, "can not use GetPragmaVec");
   }
@@ -1100,13 +1104,16 @@ class MIRClassType : public MIRStructType {
   const std::vector<bool> &GetInfoIsString() const override {
     return infoIsString;
   }
+
   void PushbackIsString(bool isString) override {
     infoIsString.push_back(isString);
   }
+
   size_t GetInfoIsStringSize() const {
     return infoIsString.size();
   }
-  bool GetInfoIsStringElemt(size_t n) const {
+
+  bool GetInfoIsStringElemt(size_t n) const override {
     ASSERT(n < infoIsString.size(), "array index out of range");
     return infoIsString.at(n);
   }
@@ -1248,7 +1255,7 @@ class MIRInterfaceType : public MIRStructType {
   size_t GetInfoIsStringSize() const {
     return infoIsString.size();
   }
-  bool GetInfoIsStringElemt(size_t n) const {
+  bool GetInfoIsStringElemt(size_t n) const override {
     ASSERT(n < infoIsString.size(), "array index out of range");
     return infoIsString.at(n);
   }
diff --git a/src/maple_ir/include/option.h b/src/maple_ir/include/option.h
index 12998d24c484e809367ff3f35fca263551803488..fe9137f2afc073b153668196f053c2f4f55c1cc6 100644
--- a/src/maple_ir/include/option.h
+++ b/src/maple_ir/include/option.h
@@ -32,8 +32,7 @@ class Options : public MapleDriverOptionBase {
 
   bool ParseOptions(int argc, char **argv, std::string &fileName) const;
 
-  bool SolveOptions(const std::vector<mapleOption::Option> &opts,
-                    bool isDebug) const;
+  bool SolveOptions(const std::vector<mapleOption::Option> &opts, bool isDebug) const;
   ~Options() = default;
 
   void DumpOptions() const;
diff --git a/src/maple_ir/src/bin_mpl_import.cpp b/src/maple_ir/src/bin_mpl_import.cpp
index 214816c6791b00d9fadae35aa320fb65da08010a..059acecdeeb2d3954e8445e4c95b61bfbacabdfe 100644
--- a/src/maple_ir/src/bin_mpl_import.cpp
+++ b/src/maple_ir/src/bin_mpl_import.cpp
@@ -389,7 +389,7 @@ void BinaryMplImport::ImportInfoOfStructType(MIRStructType &type) {
   bool isEmpty = type.GetInfo().empty();
   for (int64 i = 0; i < size; ++i) {
     GStrIdx idx = ImportStr();
-    int64 x = (type.GetInfoIsString()[i]) ? static_cast<int64>(ImportStr()) : ReadNum();
+    int64 x = (type.GetInfoIsStringElemt(i)) ? static_cast<int64>(ImportStr()) : ReadNum();
     CHECK_FATAL(x >= 0, "ReadNum nagative, x: %d", x);
     CHECK_FATAL(x <= std::numeric_limits<uint32_t>::max(), "ReadNum too large, x: %d", x);
     if (isEmpty) {
diff --git a/src/maple_ir/src/global_tables.cpp b/src/maple_ir/src/global_tables.cpp
index e29f6ff170b6c519ed7b3d1307f0e446b172f8dc..e51ecd2a67cd14d262e02027f367d34933f16bed 100644
--- a/src/maple_ir/src/global_tables.cpp
+++ b/src/maple_ir/src/global_tables.cpp
@@ -27,7 +27,7 @@ MIRType *TypeTable::CreateMirType(uint32 primTypeIdx) const {
   return mirType;
 }
 
-TypeTable::TypeTable() : ptrTypeMap(), refTypeMap() {
+TypeTable::TypeTable() {
   // enter the primitve types in type_table_
   typeTable.push_back(static_cast<MIRType*>(nullptr));
   ASSERT(typeTable.size() == static_cast<size_t>(PTY_void), "use PTY_void as the first index to type table");
@@ -63,43 +63,48 @@ void TypeTable::PutToHashTable(MIRType *mirType) {
   typeHashTable.insert(mirType);
 }
 
-MIRType *TypeTable::CreateAndUpdateMirTypeNode(MIRType *ptype) {
-  MIRType *ntype = ptype->CopyMIRTypeNode();
-  ntype->SetTypeIndex(TyIdx(typeTable.size()));
-  typeTable.push_back(ntype);
+MIRType *TypeTable::CreateAndUpdateMirTypeNode(MIRType &pType) {
+  MIRType *nType = pType.CopyMIRTypeNode();
+  nType->SetTypeIndex(TyIdx(typeTable.size()));
+  typeTable.push_back(nType);
 
-  if (ptype->GetKind() == kTypePointer) {
-    MIRPtrType *pty = static_cast<MIRPtrType*>(ptype);
-    if (pty->GetPrimType() == PTY_ptr) {
-      ptrTypeMap[pty->GetPointedTyIdx()] = ntype->GetTypeIndex();
+  if (pType.IsMIRPtrType()) {
+    MIRPtrType &pty = static_cast<MIRPtrType&>(pType);
+    if (pty.GetPrimType() == PTY_ptr) {
+      ptrTypeMap[pty.GetPointedTyIdx()] = nType->GetTypeIndex();
     } else {
-      refTypeMap[pty->GetPointedTyIdx()] = ntype->GetTypeIndex();
+      refTypeMap[pty.GetPointedTyIdx()] = nType->GetTypeIndex();
     }
   } else {
-    typeHashTable.insert(ntype);
+    typeHashTable.insert(nType);
   }
-  return ntype;
-}
-
-MIRType* TypeTable::GetOrCreateMIRTypeNode(MIRType *ptype) {
-  if (ptype->GetKind() == kTypePointer) {
-    MIRPtrType *type = static_cast<MIRPtrType *>(ptype);
-    auto *pMap = (type->GetPrimType() == PTY_ptr ? &ptrTypeMap : &refTypeMap);
-    auto *otherPMap = (type->GetPrimType() == PTY_ref ? &ptrTypeMap : &refTypeMap);
-    auto it = pMap->find(type->GetPointedTyIdx());
-    if (it != pMap->end()) {
-      return GetTypeFromTyIdx(it->second);
+  return nType;
+}
+
+MIRType* TypeTable::GetOrCreateMIRTypeNode(MIRType &pType) {
+  if (pType.IsMIRPtrType()) {
+    auto &type = static_cast<MIRPtrType&>(pType);
+    auto *pMap = (type.GetPrimType() == PTY_ptr ? &ptrTypeMap : &refTypeMap);
+    auto *otherPMap = (type.GetPrimType() == PTY_ref ? &ptrTypeMap : &refTypeMap);
+    {
+      const auto it = pMap->find(type.GetPointedTyIdx());
+      if (it != pMap->end()) {
+        return GetTypeFromTyIdx(it->second);
+      }
     }
-    CHECK_FATAL(!((PrimType)(type->GetPointedTyIdx().GetIdx()) >= kPtyDerived && type->GetPrimType() == PTY_ref &&
-        otherPMap->find(type->GetPointedTyIdx()) != otherPMap->end()), "GetOrCreateMIRType: ref pointed-to type %d has previous ptr occurrence", type->GetPointedTyIdx().GetIdx());
-    return CreateAndUpdateMirTypeNode(ptype);
+    CHECK_FATAL(!(type.GetPointedTyIdx().GetIdx() >= kPtyDerived && type.GetPrimType() == PTY_ref &&
+                  otherPMap->find(type.GetPointedTyIdx()) != otherPMap->end()),
+                "GetOrCreateMIRType: ref pointed-to type %d has previous ptr occurrence",
+                type.GetPointedTyIdx().GetIdx());
+    return CreateAndUpdateMirTypeNode(pType);
   }
-
-  auto it = typeHashTable.find(ptype);
-  if (it != typeHashTable.end()) {
-    return *it;
+  {
+    const auto it = typeHashTable.find(&pType);
+    if (it != typeHashTable.end()) {
+      return *it;
+    }
   }
-  return CreateAndUpdateMirTypeNode(ptype);
+  return CreateAndUpdateMirTypeNode(pType);
 }
 
 MIRType *TypeTable::voidPtrType = nullptr;
diff --git a/src/maple_ir/src/mir_symbol_builder.cpp b/src/maple_ir/src/mir_symbol_builder.cpp
index 48dc386b42151e970b4987460779c20777a07cdd..f396114ed50bc132b0849e686fe0340badd60e45 100644
--- a/src/maple_ir/src/mir_symbol_builder.cpp
+++ b/src/maple_ir/src/mir_symbol_builder.cpp
@@ -88,7 +88,7 @@ MIRSymbol *MIRSymbolBuilder::GetSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind m
 MIRSymbol *MIRSymbolBuilder::CreateSymbol(TyIdx tyIdx, GStrIdx strIdx, MIRSymKind mClass, MIRStorageClass sClass,
                                           MIRFunction *func, uint8 scpID) const {
   MIRSymbol *st =
-      func != nullptr ? func->GetSymTab()->CreateSymbol(scpID) : GlobalTables::GetGsymTable().CreateSymbol(scpID);
+      (func != nullptr) ? func->GetSymTab()->CreateSymbol(scpID) : GlobalTables::GetGsymTable().CreateSymbol(scpID);
   CHECK_FATAL(st != nullptr, "Failed to create MIRSymbol");
   st->SetStorageClass(sClass);
   st->SetSKind(mClass);
diff --git a/src/maple_ir/src/option.cpp b/src/maple_ir/src/option.cpp
index 197faf9b558a1dbdfc08d4c849ba9d38618716a0..79843c750e959f918f0925117db65459a4e4980d 100644
--- a/src/maple_ir/src/option.cpp
+++ b/src/maple_ir/src/option.cpp
@@ -486,8 +486,7 @@ void Options::DecideMpl2MplRealLevel(const std::vector<mapleOption::Option> &inp
   }
 }
 
-bool Options::SolveOptions(const std::vector<Option> &opts,
-                           bool isDebug) const {
+bool Options::SolveOptions(const std::vector<Option> &opts, bool isDebug) const {
   DecideMpl2MplRealLevel(opts);
   bool result = true;
   for (const mapleOption::Option &opt : opts) {
@@ -666,8 +665,7 @@ bool Options::ParseOptions(int argc, char **argv, std::string &fileName) const {
   optionParser.RegisteUsages(Options::GetInstance());
   int ret = optionParser.Parse(argc, argv, "mpl2mpl");
   CHECK_FATAL(ret == kErrorNoError, "option parser error");
-  bool result = SolveOptions(optionParser.GetOptions(),
-                             false);
+  bool result = SolveOptions(optionParser.GetOptions(), false);
   if (!result) {
     return result;
   }
diff --git a/src/maple_me/include/alias_analysis_table.h b/src/maple_me/include/alias_analysis_table.h
index 33c8f8fabc16a9598f6d9294011a799aa5cb6e36..ada71c325b3223b992aa81c7bbbcd64fefcd5bf5 100644
--- a/src/maple_me/include/alias_analysis_table.h
+++ b/src/maple_me/include/alias_analysis_table.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) [2019] Huawei Technologies Co.,Ltd.All rights reserved.
+ * Copyright (c) [2019-2020] Huawei Technologies Co.,Ltd.All rights reserved.
  *
  * OpenArkCompiler is licensed under the Mulan PSL v1.
  * You can use this software according to the terms and conditions of the Mulan PSL v1.
@@ -21,10 +21,9 @@
 namespace maple {
 class AliasAnalysisTable {
  public:
-  AliasAnalysisTable(SSATab &ssaTable, MapleAllocator allocator, MIRModule &module, KlassHierarchy &kh)
+  AliasAnalysisTable(SSATab &ssaTable, MapleAllocator allocator, KlassHierarchy &kh)
       : ssaTab(ssaTable),
         alloc(allocator),
-        mirModule(module),
         prevLevelNode(alloc.Adapter()),
         nextLevelNodes(alloc.Adapter()),
         memPool(ssaTab.GetMempool()),
@@ -42,7 +41,6 @@ class AliasAnalysisTable {
   OriginalSt *FindExtraLevOriginalSt(const MapleVector<OriginalSt*> &nextLevelOsts, FieldID fld);
   SSATab &ssaTab;
   MapleAllocator alloc;
-  MIRModule &mirModule;
   MapleMap<OStIdx, OriginalSt*> prevLevelNode;                 // index is the OStIdx
   MapleMap<OStIdx, MapleVector<OriginalSt*>*> nextLevelNodes;  // index is the OStIdx
   MemPool *memPool;
diff --git a/src/maple_me/include/alias_class.h b/src/maple_me/include/alias_class.h
index aec1cae8f8bdae4fcca3f9c69cc98d96a00ed5ea..d2f3526491a8e328d53b95f9c2d591d3b888eb10 100644
--- a/src/maple_me/include/alias_class.h
+++ b/src/maple_me/include/alias_class.h
@@ -107,7 +107,7 @@ class AliasClass : public AnalysisResult {
 
   AliasAnalysisTable *GetAliasAnalysisTable() {
     if (aliasAnalysisTable == nullptr) {
-      aliasAnalysisTable = acMemPool.New<AliasAnalysisTable>(ssaTab, acAlloc, mirModule, *klassHierarchy);
+      aliasAnalysisTable = acMemPool.New<AliasAnalysisTable>(ssaTab, acAlloc, *klassHierarchy);
     }
     return aliasAnalysisTable;
   }
@@ -183,6 +183,7 @@ class AliasClass : public AnalysisResult {
   void InsertMayUseExpr(BaseNode &expr);
   void CollectMayUseFromGlobalsAffectedByCalls(std::set<OriginalSt*> &mayUseOsts);
   void CollectMayUseFromNADS(std::set<OriginalSt*> &mayUseOsts);
+  void CollectMayUseFromDefinedFinalField(std::set<OriginalSt*> &mayUseOsts);
   void InsertMayUseNode(std::set<OriginalSt*> &mayUseOsts, MapleMap<OStIdx, MayUseNode> &mayUseNodes);
   void InsertMayUseReturn(const StmtNode &stmt);
   void CollectPtsToOfReturnOpnd(const OriginalSt &ost, std::set<OriginalSt*> &mayUseOsts);
diff --git a/src/maple_me/include/bb.h b/src/maple_me/include/bb.h
index 50df279479abfea0542973fd107a0a21cf01da48..f489882c9997bbe7a829b79dbeccb7650dc6330e 100644
--- a/src/maple_me/include/bb.h
+++ b/src/maple_me/include/bb.h
@@ -383,10 +383,10 @@ class BB {
     succ[cnt] = ss;
   }
 
-  const MapleMap<const OriginalSt*, PhiNode> &GetPhiList() const {
+  const MapleMap<OStIdx, PhiNode> &GetPhiList() const {
     return phiList;
   }
-  MapleMap<const OriginalSt*, PhiNode> &GetPhiList() {
+  MapleMap<OStIdx, PhiNode> &GetPhiList() {
     return phiList;
   }
   void ClearPhiList() {
@@ -461,7 +461,7 @@ class BB {
   MapleVector<BB*> succ;  // successor list
   // record the edge freq from curBB to succ BB
   MapleVector<uint64> succFreq;
-  MapleMap<const OriginalSt*, PhiNode> phiList;
+  MapleMap<OStIdx, PhiNode> phiList;
   MapleMap<OStIdx, MeVarPhiNode*> meVarPhiList;
   MapleMap<OStIdx, MeRegPhiNode*> meRegPhiList;
   MapleMap<BB*, std::vector<PiassignMeStmt*>> meVarPiList;
diff --git a/src/maple_me/include/me_critical_edge.h b/src/maple_me/include/me_critical_edge.h
index 03edfd995d1bc212fed75c2fff30b43c58ac62fd..fa1c516aafda2c791047d46d3b4789319518ccca 100644
--- a/src/maple_me/include/me_critical_edge.h
+++ b/src/maple_me/include/me_critical_edge.h
@@ -32,6 +32,9 @@ class MeDoSplitCEdge : public MeFuncPhase {
   }
 
  private:
+  void UpdateNewBBInTry(BB &newBB, BB &pred) const;
+  void UpdateGotoLabel(BB &newBB, MeFunction &func, BB &pred, BB &succ) const;
+  void UpdateCaseLabel(BB &newBB, MeFunction &func, BB &pred, BB &succ) const;
   void BreakCriticalEdge(MeFunction &func, BB &pred, BB &succ) const;
 };
 }  // namespace maple
diff --git a/src/maple_me/include/me_ir.h b/src/maple_me/include/me_ir.h
index 3a2356a0c0050860a4027211cea501a4ea5debcc..47c61efd3e380f8cd93ed9712f9d6790387c0568 100644
--- a/src/maple_me/include/me_ir.h
+++ b/src/maple_me/include/me_ir.h
@@ -146,7 +146,7 @@ class MeExpr {
     ASSERT(false, "Should not reach here");
   }
 
-  virtual MeExpr *GetIdenticalExpr(MeExpr&) const {
+  virtual MeExpr *GetIdenticalExpr(MeExpr&, bool) const {
     ASSERT(false, "Should not reach here");
     return nullptr;
   }
@@ -634,7 +634,7 @@ class ConstMeExpr : public MeExpr {
     return constVal;
   }
 
-  MeExpr *GetIdenticalExpr(MeExpr &expr) const override;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool) const override;
 
   uint32 GetHashIndex() const override {
     CHECK_FATAL(constVal != nullptr, "constVal is null");
@@ -674,7 +674,7 @@ class ConststrMeExpr : public MeExpr {
 
   void Dump(const IRMap*, int32 indent = 0) const override;
   BaseNode &EmitExpr(SSATab&) override;
-  MeExpr *GetIdenticalExpr(MeExpr &expr) const override;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool) const override;
 
   UStrIdx GetStrIdx() const {
     return strIdx;
@@ -696,7 +696,7 @@ class Conststr16MeExpr : public MeExpr {
 
   void Dump(const IRMap*, int32 indent = 0) const override;
   BaseNode &EmitExpr(SSATab&) override;
-  MeExpr *GetIdenticalExpr(MeExpr &expr) const override;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool) const override;
 
   U16StrIdx GetStrIdx() {
     return strIdx;
@@ -718,7 +718,7 @@ class SizeoftypeMeExpr : public MeExpr {
 
   void Dump(const IRMap*, int32 indent = 0) const override;
   BaseNode &EmitExpr(SSATab&) override;
-  MeExpr *GetIdenticalExpr(MeExpr &expr) const override;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool) const override;
 
   TyIdx GetTyIdx() const {
     return tyIdx;
@@ -741,7 +741,7 @@ class FieldsDistMeExpr : public MeExpr {
   ~FieldsDistMeExpr() = default;
   void Dump(const IRMap*, int32 indent = 0) const override;
   BaseNode &EmitExpr(SSATab&) override;
-  MeExpr *GetIdenticalExpr(MeExpr &expr) const override;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool) const override;
 
   TyIdx GetTyIdx() const {
     return tyIdx;
@@ -777,7 +777,7 @@ class AddrofMeExpr : public MeExpr {
   void Dump(const IRMap*, int32 indent = 0) const override;
   bool IsUseSameSymbol(const MeExpr&) const override;
   BaseNode &EmitExpr(SSATab&) override;
-  MeExpr *GetIdenticalExpr(MeExpr &expr) const override;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool) const override;
 
   OStIdx GetOstIdx() const {
     return ostIdx;
@@ -809,7 +809,7 @@ class AddroffuncMeExpr : public MeExpr {
 
   void Dump(const IRMap*, int32 indent = 0) const override;
   BaseNode &EmitExpr(SSATab&) override;
-  MeExpr *GetIdenticalExpr(MeExpr &expr) const override;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool) const override;
 
   PUIdx GetPuIdx() const {
     return puIdx;
@@ -871,7 +871,7 @@ class OpMeExpr : public MeExpr {
   bool IsCompareIdentical(const OpMeExpr &meExpr) const;
   void Dump(const IRMap*, int32 indent = 0) const override;
   bool IsUseSameSymbol(const MeExpr&) const override;
-  MeExpr *GetIdenticalExpr(MeExpr &expr) const override;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool) const override;
   BaseNode &EmitExpr(SSATab&) override;
   MeExpr *GetOpnd(size_t i) const override {
     CHECK_FATAL(i < kOperandNumTernary, "OpMeExpr cannot have more than 3 operands");
@@ -977,8 +977,8 @@ class IvarMeExpr : public MeExpr {
   bool IsFinal();
   bool IsRCWeak() const;
   bool IsUseSameSymbol(const MeExpr&) const override;
-  bool IsIdentical(IvarMeExpr &expr) const;
-  MeExpr *GetIdenticalExpr(MeExpr &expr) const override;
+  bool IsIdentical(IvarMeExpr &expr, bool inConstructor) const;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool inConstructor) const override;
   MeExpr *GetOpnd(size_t) const override {
     return base;
   }
@@ -1084,7 +1084,7 @@ class NaryMeExpr : public MeExpr {
   bool IsIdentical(NaryMeExpr&) const;
   bool IsUseSameSymbol(const MeExpr&) const override;
   BaseNode &EmitExpr(SSATab&) override;
-  MeExpr *GetIdenticalExpr(MeExpr &expr) const override;
+  MeExpr *GetIdenticalExpr(MeExpr &expr, bool) const override;
   MeExpr *GetOpnd(size_t idx) const override {
     ASSERT(idx < opnds.size(), "NaryMeExpr operand out of bounds");
     return opnds[idx];
diff --git a/src/maple_me/src/alias_analysis_table.cpp b/src/maple_me/src/alias_analysis_table.cpp
index 11c2d358a7de40f23dcb04935fa58c216c3974d6..3a1b14d80cab28bd21070f7a9d2d35f162c51acb 100644
--- a/src/maple_me/src/alias_analysis_table.cpp
+++ b/src/maple_me/src/alias_analysis_table.cpp
@@ -88,7 +88,7 @@ OriginalSt *AliasAnalysisTable::FindOrCreateExtraLevSymOrRegOriginalSt(OriginalS
       const auto *ptType = static_cast<const MIRPtrType*>(mirType);
       TyIdxFieldAttrPair fieldPair = ptType->GetPointedTyIdxFldAttrPairWithFieldID(fld);
       nextLevOst->SetTyIdx(fieldPair.first);
-      nextLevOst->SetIsFinal(fieldPair.second.GetAttr(FLDATTR_final) && !mirModule.CurFunction()->IsConstructor());
+      nextLevOst->SetIsFinal(fieldPair.second.GetAttr(FLDATTR_final));
       nextLevOst->SetIsPrivate(fieldPair.second.GetAttr(FLDATTR_private));
     } else {
       nextLevOst->SetTyIdx(TyIdx(PTY_void));
diff --git a/src/maple_me/src/alias_class.cpp b/src/maple_me/src/alias_class.cpp
index 6106a6fdbae73568a7e4b8ae312f1e1ca7df3e82..c8bdbc877bc34976f1fdcec54150c400263807d0 100644
--- a/src/maple_me/src/alias_class.cpp
+++ b/src/maple_me/src/alias_class.cpp
@@ -649,6 +649,30 @@ void AliasClass::CollectMayUseFromNADS(std::set<OriginalSt*> &mayUseOsts) {
   }
 }
 
+// collect the mayUses caused by defined final field.
+void AliasClass::CollectMayUseFromDefinedFinalField(std::set<OriginalSt*> &mayUseOsts) {
+  for (AliasElem *aliasElem : id2Elem) {
+    ASSERT(aliasElem != nullptr, "null ptr check");
+    auto &ost = aliasElem->GetOriginalSt();
+    if (!ost.IsFinal()) {
+      continue;
+    }
+
+    auto *prevLevelOst = aliasAnalysisTable->GetPrevLevelNode(ost);
+    if (prevLevelOst == nullptr) {
+      continue;
+    }
+
+    TyIdx tyIdx = prevLevelOst->GetTyIdx();
+    auto *ptrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    ASSERT(ptrType->IsMIRPtrType(), "Type of pointer must be MIRPtrType!");
+    tyIdx = static_cast<MIRPtrType*>(ptrType)->GetPointedTyIdx();
+    if (tyIdx == mirModule.CurFunction()->GetClassTyIdx()) {
+      mayUseOsts.insert(&ost);
+    }
+  }
+}
+
 // insert the ost of mayUseOsts into mayUseNodes
 void AliasClass::InsertMayUseNode(std::set<OriginalSt*> &mayUseOsts, MapleMap<OStIdx, MayUseNode> &mayUseNodes) {
   for (OriginalSt *ost : mayUseOsts) {
@@ -660,13 +684,18 @@ void AliasClass::InsertMayUseNode(std::set<OriginalSt*> &mayUseOsts, MapleMap<OS
 // insert mayUse for Return-statement.
 // two kinds of mayUse's are insert into the mayUseNodes:
 // 1. mayUses caused by not_all_def_seen_ae;
-// 2. mayUses caused by globalsAffectedByCalls.
+// 2. mayUses caused by globalsAffectedByCalls;
+// 3. collect mayUses caused by defined final field for constructor.
 void AliasClass::InsertMayUseReturn(const StmtNode &stmt) {
   std::set<OriginalSt*> mayUseOsts;
   // 1. collect mayUses caused by not_all_def_seen_ae.
   CollectMayUseFromNADS(mayUseOsts);
   // 2. collect mayUses caused by globals_affected_by_call.
   CollectMayUseFromGlobalsAffectedByCalls(mayUseOsts);
+  // 3. collect mayUses caused by defined final field for constructor
+  if (mirModule.CurFunction()->IsConstructor()) {
+    CollectMayUseFromDefinedFinalField(mayUseOsts);
+  }
   MapleMap<OStIdx, MayUseNode> &mayUseNodes = ssaTab.GetStmtsSSAPart().GetMayUseNodesOf(stmt);
   InsertMayUseNode(mayUseOsts, mayUseNodes);
 }
@@ -903,7 +932,25 @@ void AliasClass::CollectMayUseForCallOpnd(const StmtNode &stmt, std::set<Origina
       AliasElem *indAe = FindAliasElem(*nextLevelOst);
 
       if (indAe->GetOriginalSt().IsFinal()) {
-        continue;
+        // only final fields pointed to by the first opnd(this) are considered.
+        if (i != 0) {
+          continue;
+        }
+
+        auto *callerFunc = mirModule.CurFunction();
+        if (!callerFunc->IsConstructor()) {
+          continue;
+        }
+
+        PUIdx puIdx = static_cast<const CallNode&>(stmt).GetPUIdx();
+        auto *calleeFunc = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+        if (!calleeFunc->IsConstructor()) {
+          continue;
+        }
+
+        if (callerFunc->GetBaseClassNameStrIdx() != calleeFunc->GetBaseClassNameStrIdx()) {
+          continue;
+        }
       }
 
       if (indAe->GetClassSet() == nullptr) {
diff --git a/src/maple_me/src/bb.cpp b/src/maple_me/src/bb.cpp
index 50911b386ae1c86d1f6c39746d3d51501bdb9daf..11a153e60199d52833a9ac2e9dc9326bb84ccb6b 100644
--- a/src/maple_me/src/bb.cpp
+++ b/src/maple_me/src/bb.cpp
@@ -111,7 +111,7 @@ void BB::DumpPhi() {
 }
 
 const PhiNode *BB::PhiofVerStInserted(const VersionSt &versionSt) const {
-  auto phiIt = phiList.find(versionSt.GetOrigSt());
+  auto phiIt = phiList.find(versionSt.GetOrigSt()->GetIndex());
   return (phiIt != phiList.end()) ? &(phiIt->second) : nullptr;
 }
 
@@ -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(), phiNode));
+  phiList.insert(std::make_pair(versionSt->GetOrigSt()->GetIndex(), phiNode));
 }
 
 bool BB::IsInList(const MapleVector<BB*> &bbList) const {
diff --git a/src/maple_me/src/irmap.cpp b/src/maple_me/src/irmap.cpp
index c85e5e1a9ca6fb449a0ac7a8430041de61e995f7..50a6af2a29442fe56d4b62b5b0122088fa096e9a 100644
--- a/src/maple_me/src/irmap.cpp
+++ b/src/maple_me/src/irmap.cpp
@@ -51,7 +51,7 @@ void IRMap::BuildBB(BB &bb, std::vector<bool> &bbIRMapProcessed) {
 
 void IRMap::BuildPhiMeNode(BB &bb) {
   for (auto &phi : bb.GetPhiList()) {
-    const OriginalSt *oSt = phi.first;
+    const OriginalSt *oSt = ssaTab.GetOriginalStFromID(phi.first);
     VersionSt *vSt = phi.second.GetResult();
     if (oSt->IsPregOst()) {
       auto *phiMeNode = NewInPool<MeRegPhiNode>();
@@ -671,7 +671,7 @@ MeExpr *IRMap::HashMeExpr(MeExpr &meExpr) {
   MeExpr *hashedExpr = hashTable[hashIdx];
 
   if (hashedExpr != nullptr && meExpr.GetMeOp() != kMeOpGcmalloc) {
-    resultExpr = meExpr.GetIdenticalExpr(*hashedExpr);
+    resultExpr = meExpr.GetIdenticalExpr(*hashedExpr, mirModule.CurFunction()->IsConstructor());
   }
 
   if (resultExpr == nullptr) {
diff --git a/src/maple_me/src/me_analyze_rc.cpp b/src/maple_me/src/me_analyze_rc.cpp
index e6ef614d5656a3dfcd1b33455cebbecc9bf6bcd2..afdccf2934af77ab06337a22769587266081fc00 100644
--- a/src/maple_me/src/me_analyze_rc.cpp
+++ b/src/maple_me/src/me_analyze_rc.cpp
@@ -370,6 +370,9 @@ bool AnalyzeRC::NeedDecRef(IvarMeExpr &ivar) const {
   }
   // check the ivar's mu is zero version
   OriginalSt *ost = GetOriginalSt(ivar);
+  if (ivar.GetMu() == nullptr) {
+    return false;
+  }
   return ivar.GetMu()->GetVstIdx() != ost->GetZeroVersionIndex() && ivar.GetMu()->GetDefBy() != kDefByNo;
 }
 
diff --git a/src/maple_me/src/me_cfg.cpp b/src/maple_me/src/me_cfg.cpp
index f5dd09577c652d9691f82ca68230a947f28dda06..42a026a95bbab9219cb56e38d2408352137633bd 100644
--- a/src/maple_me/src/me_cfg.cpp
+++ b/src/maple_me/src/me_cfg.cpp
@@ -535,7 +535,7 @@ void MeCFG::ConvertPhiList2IdentityAssigns(BB &meBB) const {
   auto phiIt = meBB.GetPhiList().begin();
   while (phiIt != meBB.GetPhiList().end()) {
     // replace phi with identify assignment as it only has 1 opnd
-    const OriginalSt *ost = (*phiIt).first;
+    const OriginalSt *ost = func.GetMeSSATab()->GetOriginalStFromID(phiIt->first);
     if (ost->IsSymbolOst() && ost->GetIndirectLev() == 0) {
       const MIRSymbol *st = ost->GetMIRSymbol();
       MIRType *type = GlobalTables::GetTypeTable().GetTypeFromTyIdx(st->GetTyIdx());
diff --git a/src/maple_me/src/me_critical_edge.cpp b/src/maple_me/src/me_critical_edge.cpp
index 6fba7f6fe2f589f7577ee8536cc52188dd7eb91a..40c28e3322d81eca931406b5a5d768e662583127 100644
--- a/src/maple_me/src/me_critical_edge.cpp
+++ b/src/maple_me/src/me_critical_edge.cpp
@@ -32,6 +32,53 @@
 // newbb is always appended at the end of bb_vec_ and pred/succ will be updated.
 // The bblayout phase will determine the final layout order of the bbs.
 namespace maple {
+void MeDoSplitCEdge::UpdateNewBBInTry(BB &newBB, BB &pred) const {
+  newBB.SetAttributes(kBBAttrIsTry);
+  for (auto *candCatch : pred.GetSucc()) {
+    if (candCatch != nullptr && candCatch->GetAttributes(kBBAttrIsCatch)) {
+      newBB.AddSucc(*candCatch);
+    }
+  }
+}
+
+void MeDoSplitCEdge::UpdateGotoLabel(BB &newBB, MeFunction &func, BB &pred, BB &succ) const {
+  auto &gotoStmt = static_cast<CondGotoNode&>(pred.GetStmtNodes().back());
+  BB *gotoBB = pred.GetSucc().at(1);
+  LabelIdx oldLabelIdx = gotoStmt.GetOffset();
+  if (oldLabelIdx != gotoBB->GetBBLabel()) {
+    // original gotoBB is replaced by newBB
+    LabelIdx label = func.GetOrCreateBBLabel(*gotoBB);
+    gotoStmt.SetOffset(label);
+  }
+  if (DEBUGFUNC(&func)) {
+    LogInfo::MapleLogger() << "******after break: dump updated condgoto_BB *****\n";
+    pred.Dump(&func.GetMIRModule());
+    newBB.Dump(&func.GetMIRModule());
+    succ.Dump(&func.GetMIRModule());
+  }
+}
+
+void MeDoSplitCEdge::UpdateCaseLabel(BB &newBB, MeFunction &func, BB &pred, BB &succ) const {
+  auto &switchStmt = static_cast<SwitchNode&>(pred.GetStmtNodes().back());
+  LabelIdx oldLabelIdx = succ.GetBBLabel();
+  LabelIdx label = func.GetOrCreateBBLabel(newBB);
+  if (switchStmt.GetDefaultLabel() == oldLabelIdx) {
+    switchStmt.SetDefaultLabel(label);
+  }
+  for (size_t i = 0; i < switchStmt.GetSwitchTable().size(); ++i) {
+    LabelIdx labelIdx = switchStmt.GetCasePair(i).second;
+    if (labelIdx == oldLabelIdx) {
+      switchStmt.UpdateCaseLabelAt(i, label);
+    }
+  }
+  if (DEBUGFUNC(&func)) {
+    LogInfo::MapleLogger() << "******after break: dump updated switchBB *****\n";
+    pred.Dump(&func.GetMIRModule());
+    newBB.Dump(&func.GetMIRModule());
+    succ.Dump(&func.GetMIRModule());
+  }
+}
+
 void MeDoSplitCEdge::BreakCriticalEdge(MeFunction &func, BB &pred, BB &succ) const {
   if (DEBUGFUNC(&func)) {
     LogInfo::MapleLogger() << "******before break : critical edge : BB" << pred.GetBBId() << " -> BB" <<
@@ -67,41 +114,14 @@ void MeDoSplitCEdge::BreakCriticalEdge(MeFunction &func, BB &pred, BB &succ) con
   newBB->SetKind(kBBFallthru);  // default kind
   newBB->SetAttributes(kBBAttrArtificial);
 
+  if (pred.GetAttributes(kBBAttrIsTry)) {
+    UpdateNewBBInTry(*newBB, pred);
+  }
   // update statement offset if succ is goto target
   if (pred.GetKind() == kBBCondGoto) {
-    auto &gotoStmt = static_cast<CondGotoNode&>(pred.GetStmtNodes().back());
-    BB *gotoBB = pred.GetSucc().at(1);
-    LabelIdx oldLabelIdx = gotoStmt.GetOffset();
-    if (oldLabelIdx != gotoBB->GetBBLabel()) {
-      // original gotoBB is replaced by newBB
-      LabelIdx label = func.GetOrCreateBBLabel(*gotoBB);
-      gotoStmt.SetOffset(label);
-    }
-    if (DEBUGFUNC(&func)) {
-      LogInfo::MapleLogger() << "******after break: dump updated condgoto_BB *****\n";
-      pred.Dump(&func.GetMIRModule());
-      newBB->Dump(&func.GetMIRModule());
-      succ.Dump(&func.GetMIRModule());
-    }
+    UpdateGotoLabel(*newBB, func, pred, succ);
   } else if (pred.GetKind() == kBBSwitch) {
-    auto &switchStmt = static_cast<SwitchNode&>(pred.GetStmtNodes().back());
-    LabelIdx oldLabelIdx = succ.GetBBLabel();
-    LabelIdx label = func.GetOrCreateBBLabel(*newBB);
-    if (switchStmt.GetDefaultLabel() == oldLabelIdx) {
-      switchStmt.SetDefaultLabel(label);
-    }
-    for (size_t i = 0; i < switchStmt.GetSwitchTable().size(); ++i) {
-      LabelIdx labelIdx = switchStmt.GetCasePair(i).second;
-      if (labelIdx == oldLabelIdx) {
-        switchStmt.UpdateCaseLabelAt(i, label);
-      }
-    }
-    if (DEBUGFUNC(&func)) {
-      LogInfo::MapleLogger() << "******after break: dump updated switchBB *****\n";
-      pred.Dump(&func.GetMIRModule());
-      newBB->Dump(&func.GetMIRModule());
-      succ.Dump(&func.GetMIRModule());
-    }
+    UpdateCaseLabel(*newBB, func, pred, succ);
   }
 }
 
diff --git a/src/maple_me/src/me_dse.cpp b/src/maple_me/src/me_dse.cpp
index 55a193e0331d1b0130d8ceb8eaa48e72ed6d2561..1c849bbfa67006c10d7bbad3d7674e621fcf4042 100644
--- a/src/maple_me/src/me_dse.cpp
+++ b/src/maple_me/src/me_dse.cpp
@@ -34,7 +34,7 @@ void MeDSE::VerifyPhi() const {
     for (auto &pair : bb->GetPhiList()) {
       if (IsSymbolLived(*pair.second.GetResult())) {
         if (predBBNums <= 1) {  // phi is live and non-virtual in bb with 0 or 1 pred
-          const OriginalSt *ost = pair.first;
+          const OriginalSt *ost = func.GetMeSSATab()->GetOriginalStFromID(pair.first);
           CHECK_FATAL(!ost->IsSymbolOst() || ost->GetIndirectLev() != 0,
               "phi is live and non-virtual in bb with zero or one pred");
         } else if (pair.second.GetPhiOpnds().size() != predBBNums) {
diff --git a/src/maple_me/src/me_ir.cpp b/src/maple_me/src/me_ir.cpp
index 2dd4a2edd3bded0a209d55311e4190cf3aa0d9f0..111a57d94e49bdebbbd7dc6302a85720f54c6ec4 100644
--- a/src/maple_me/src/me_ir.cpp
+++ b/src/maple_me/src/me_ir.cpp
@@ -397,12 +397,24 @@ bool IvarMeExpr::IsRCWeak() const {
 
 // If self is the first use of the same ivar coming from an iassign
 // (argument expr), then update its mu: expr->mu = this->mu.
-bool IvarMeExpr::IsIdentical(IvarMeExpr &expr) const {
+bool IvarMeExpr::IsIdentical(IvarMeExpr &expr, bool inConstructor) const {
   CHECK_FATAL(expr.base != nullptr, "null ptr check");
   if (base->GetExprID() != expr.base->GetExprID() || fieldID != expr.fieldID || tyIdx != expr.tyIdx) {
     return false;
   }
 
+  if (!inConstructor) {
+    auto *ptrType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    ASSERT(ptrType->IsMIRPtrType(), "Type of ivar must be poniter");
+    auto *pointedType = static_cast<MIRPtrType*>(ptrType)->GetPointedType();
+    if (pointedType->IsStructType()) {
+      auto attr = static_cast<MIRStructType*>(pointedType)->GetFieldAttrs(fieldID);
+      if (attr.GetAttr(FLDATTR_final)) {
+        return true;
+      }
+    }
+  }
+
   // check the two mu being identical
   if (mu != expr.mu) {
     if (mu != nullptr && expr.mu != nullptr && mu->GetDefBy() == kDefByChi && expr.mu->GetDefBy() == kDefByChi) {
@@ -430,11 +442,11 @@ bool IvarMeExpr::IsIdentical(IvarMeExpr &expr) const {
   return true;
 }
 
-MeExpr *IvarMeExpr::GetIdenticalExpr(MeExpr &expr) const {
+MeExpr *IvarMeExpr::GetIdenticalExpr(MeExpr &expr, bool inConstructor) const {
   auto *ivarExpr = static_cast<IvarMeExpr*>(&expr);
 
   while (ivarExpr != nullptr) {
-    if (ivarExpr->GetMeOp() == kMeOpIvar && IsIdentical(*ivarExpr)) {
+    if (ivarExpr->GetMeOp() == kMeOpIvar && IsIdentical(*ivarExpr, inConstructor)) {
       return ivarExpr;
     }
     ivarExpr = static_cast<IvarMeExpr*>(ivarExpr->GetNext());
@@ -542,7 +554,8 @@ bool OpMeExpr::IsUseSameSymbol(const MeExpr &expr) const {
   return true;
 }
 
-MeExpr *OpMeExpr::GetIdenticalExpr(MeExpr &expr) const {
+MeExpr *OpMeExpr::GetIdenticalExpr(MeExpr &expr, bool isConstructor) const {
+  (void)isConstructor;
   if (!kOpcodeInfo.NotPure(GetOp())) {
     auto *opExpr = static_cast<OpMeExpr*>(&expr);
 
@@ -588,7 +601,8 @@ int64 ConstMeExpr::GetIntValue() const {
   return safe_cast<MIRIntConst>(constVal)->GetValue();
 }
 
-MeExpr *ConstMeExpr::GetIdenticalExpr(MeExpr &expr) const {
+MeExpr *ConstMeExpr::GetIdenticalExpr(MeExpr &expr, bool isConstructor) const {
+  (void)isConstructor;
   auto *constExpr = static_cast<ConstMeExpr*>(&expr);
 
   while (constExpr != nullptr) {
@@ -602,7 +616,8 @@ MeExpr *ConstMeExpr::GetIdenticalExpr(MeExpr &expr) const {
   return nullptr;
 }
 
-MeExpr *ConststrMeExpr::GetIdenticalExpr(MeExpr &expr) const {
+MeExpr *ConststrMeExpr::GetIdenticalExpr(MeExpr &expr, bool isConstructor) const {
+  (void)isConstructor;
   auto *constStrExpr = static_cast<ConststrMeExpr*>(&expr);
 
   while (constStrExpr != nullptr) {
@@ -615,7 +630,8 @@ MeExpr *ConststrMeExpr::GetIdenticalExpr(MeExpr &expr) const {
   return nullptr;
 }
 
-MeExpr *Conststr16MeExpr::GetIdenticalExpr(MeExpr &expr) const {
+MeExpr *Conststr16MeExpr::GetIdenticalExpr(MeExpr &expr, bool isConstructor) const {
+  (void)isConstructor;
   auto *constStr16Expr = static_cast<Conststr16MeExpr*>(&expr);
 
   while (constStr16Expr != nullptr) {
@@ -628,7 +644,8 @@ MeExpr *Conststr16MeExpr::GetIdenticalExpr(MeExpr &expr) const {
   return nullptr;
 }
 
-MeExpr *SizeoftypeMeExpr::GetIdenticalExpr(MeExpr &expr) const {
+MeExpr *SizeoftypeMeExpr::GetIdenticalExpr(MeExpr &expr, bool isConstructor) const {
+  (void)isConstructor;
   auto *sizeoftypeExpr = static_cast<SizeoftypeMeExpr*>(&expr);
 
   while (sizeoftypeExpr != nullptr) {
@@ -641,7 +658,8 @@ MeExpr *SizeoftypeMeExpr::GetIdenticalExpr(MeExpr &expr) const {
   return nullptr;
 }
 
-MeExpr *FieldsDistMeExpr::GetIdenticalExpr(MeExpr &expr) const {
+MeExpr *FieldsDistMeExpr::GetIdenticalExpr(MeExpr &expr, bool isConstructor) const {
+  (void)isConstructor;
   auto *fieldsDistExpr = static_cast<FieldsDistMeExpr*>(&expr);
 
   while (fieldsDistExpr != nullptr) {
@@ -655,7 +673,8 @@ MeExpr *FieldsDistMeExpr::GetIdenticalExpr(MeExpr &expr) const {
   return nullptr;
 }
 
-MeExpr *AddrofMeExpr::GetIdenticalExpr(MeExpr &expr) const {
+MeExpr *AddrofMeExpr::GetIdenticalExpr(MeExpr &expr, bool isConstructor) const {
+  (void)isConstructor;
   auto *addrofExpr = static_cast<AddrofMeExpr*>(&expr);
 
   while (addrofExpr != nullptr) {
@@ -669,7 +688,8 @@ MeExpr *AddrofMeExpr::GetIdenticalExpr(MeExpr &expr) const {
   return nullptr;
 }
 
-MeExpr *NaryMeExpr::GetIdenticalExpr(MeExpr &expr) const {
+MeExpr *NaryMeExpr::GetIdenticalExpr(MeExpr &expr, bool isConstructor) const {
+  (void)isConstructor;
   auto *naryExpr = static_cast<NaryMeExpr*>(&expr);
 
   while (naryExpr != nullptr) {
@@ -684,7 +704,8 @@ MeExpr *NaryMeExpr::GetIdenticalExpr(MeExpr &expr) const {
   return nullptr;
 }
 
-MeExpr *AddroffuncMeExpr::GetIdenticalExpr(MeExpr &expr) const {
+MeExpr *AddroffuncMeExpr::GetIdenticalExpr(MeExpr &expr, bool isConstructor) const {
+  (void)isConstructor;
   auto *addroffuncExpr = static_cast<AddroffuncMeExpr*>(&expr);
 
   while (addroffuncExpr != nullptr) {
diff --git a/src/maple_me/src/ssa_devirtual.cpp b/src/maple_me/src/ssa_devirtual.cpp
index 9d672b4fbd246c4256954271d2f90e7ed00cb8d5..2f96e6e544be65a620c3d8ae84c3900808e30df0 100644
--- a/src/maple_me/src/ssa_devirtual.cpp
+++ b/src/maple_me/src/ssa_devirtual.cpp
@@ -271,7 +271,9 @@ void SSADevirtual::PropVarInferredType(VarMeExpr &varMeExpr) const {
         }
       }
     }
-    if (varMeExpr.GetInferredTyIdx() != 0u) {
+    // Parallel me will skip the setting for symbol's inferredTyIdx because it is independent of the function
+    // optimization order
+    if (!skipReturnTypeOpt && varMeExpr.GetInferredTyIdx() != 0u) {
       OriginalSt *ost = irMap->GetSSATab().GetOriginalStFromID(defStmt.GetVarLHS()->GetOStIdx());
       MIRSymbol *mirSym = ost->GetMIRSymbol();
       if (mirSym->IsStatic() && mirSym->IsFinal()) {
@@ -631,16 +633,6 @@ void SSADevirtual::Perform(BB &entryBB) {
   if (!skipReturnTypeOpt && retTy == kSeen) {
     mirFunc->SetInferredReturnTyIdx(this->inferredRetTyIdx);
   }
-  // Simple rule: if method's declared returning type is a final class, then
-  // the actual returning type is same with the declared returning type.
-  MIRType *declReturnType = mirFunc->GetReturnType();
-  if (declReturnType->GetPrimType() == PTY_ref && declReturnType->GetKind() == kTypePointer) {
-    MIRType *pointedType = static_cast<MIRPtrType*>(declReturnType)->GetPointedType();
-    MIRClassType *declReturnClass = safe_cast<MIRClassType>(pointedType);
-    if (declReturnClass != nullptr && declReturnClass->IsFinal()) {
-      mirFunc->SetInferredReturnTyIdx(declReturnClass->GetTypeIndex());
-    }
-  }
   if (SSADevirtual::debug) {
     LogInfo::MapleLogger() << "[SSA-DEVIRT]" << " {virtualcalls: total " << (totalVirtualCalls - totalInterfaceCalls) <<
         ", devirtualized " << optedVirtualCalls << "}" << " {interfacecalls: total " <<
diff --git a/src/maple_util/include/mpl_number.h b/src/maple_util/include/mpl_number.h
index f10ddffa4c8b53c3d3ce6422dec8cb13ac64a326..377f1011396991e983aeeba510ed975a2d85f14e 100644
--- a/src/maple_util/include/mpl_number.h
+++ b/src/maple_util/include/mpl_number.h
@@ -278,7 +278,6 @@ inline OS &operator<<(OS &os, const Number<T, Tag> &num) {
 
 template <typename Type, typename T = size_t>
 using Index = Number<T, Type>;
-
 }}
 
 namespace std {
diff --git a/src/maple_util/include/muid.h b/src/maple_util/include/muid.h
index 53931226ae4b4f452febc90abf20abc51bae22c4..2a7acdebd19ed1ecdd5b0505bd59097d6e393881 100644
--- a/src/maple_util/include/muid.h
+++ b/src/maple_util/include/muid.h
@@ -47,7 +47,7 @@ union DigestHash {
   struct {
     uint64_t first;
     uint64_t second;
-  } d;
+  } data;
 };
 
 // muid-related files are shared between maple compiler and runtime, thus not in
diff --git a/src/maple_util/include/profile.h b/src/maple_util/include/profile.h
index ce57b764069f237141200e23ecebeefa3de67a30..385250771a0d7b10ccc66ce8aa7288d74dce9660 100644
--- a/src/maple_util/include/profile.h
+++ b/src/maple_util/include/profile.h
@@ -24,7 +24,6 @@
 #include "option.h"
 
 namespace maple {
-
 struct IRProfileDesc {
   uint32 counterStart = 0;
   uint32 counterEnd = 0;
@@ -33,7 +32,6 @@ struct IRProfileDesc {
   IRProfileDesc(uint64 hash, uint32 start, uint32 end) : counterStart(start), counterEnd(end), funcHash(hash) {}
 };
 
-
 class Profile {
  public:
   struct FuncItem {
diff --git a/src/maple_util/include/ptr.h b/src/maple_util/include/ptr.h
index 3291fb9edc0d59f5e850e85704eceeb38d852ae4..0094fc74d4349f1c3900de9809242a6c3f3a4117 100644
--- a/src/maple_util/include/ptr.h
+++ b/src/maple_util/include/ptr.h
@@ -16,7 +16,8 @@
 #define MAPLE_UTIL_PTR_H
 #include <functional>
 
-namespace maple { namespace utils {
+namespace maple {
+namespace utils {
 template<typename T>
 using PtrCheckerType = void (*)(const T*);
 
@@ -127,7 +128,7 @@ class Ptr {
   }
 
   Ptr &operator=(const Ptr &ptr) noexcept {
-    if (this != &ptr) {
+    if (&ptr != this) {
       pointer = ptr.pointer;
     }
     return *this;
@@ -265,7 +266,7 @@ inline bool operator<(std::nullptr_t, const Ptr<T, CheckT> &rhs) {
 
 template<typename T, PtrCheckerType<T> CheckT>
 inline bool operator<=(const Ptr<T, CheckT> &lhs, std::nullptr_t) {
-  return !(nullptr < lhs);
+  return !(lhs > nullptr);
 }
 
 template<typename T, PtrCheckerType<T> CheckT>
@@ -280,7 +281,7 @@ inline bool operator>(const Ptr<T, CheckT> &lhs, std::nullptr_t) {
 
 template<typename T, PtrCheckerType<T> CheckT>
 inline bool operator>(std::nullptr_t, const Ptr<T, CheckT> &rhs) {
-  return !(nullptr <= rhs);
+  return !(rhs >= nullptr);
 }
 
 template<typename T, PtrCheckerType<T> CheckT>
@@ -290,7 +291,7 @@ inline bool operator>=(const Ptr<T, CheckT> &lhs, std::nullptr_t) {
 
 template<typename T, PtrCheckerType<T> CheckT>
 inline bool operator>=(std::nullptr_t, const Ptr<T, CheckT> &rhs) {
-  return !(nullptr < rhs);
+  return !(rhs > nullptr);
 }
 }}
 
diff --git a/src/maple_util/include/safe_ptr.h b/src/maple_util/include/safe_ptr.h
index 827038d789429d52de3e3e14a4a589c45e64e7c7..76b537fe9ff5c96e467da2b87c203d2749f4be1f 100644
--- a/src/maple_util/include/safe_ptr.h
+++ b/src/maple_util/include/safe_ptr.h
@@ -17,7 +17,8 @@
 #include <mpl_logging.h>
 #include "ptr.h"
 
-namespace maple { namespace utils {
+namespace maple {
+namespace utils {
 template<typename T>
 inline void AssertNotNull(const T *ptr) {
   CHECK_FATAL(ptr != nullptr, "nullptr was assigned to SafePtr.");
diff --git a/src/maple_util/include/utils.h b/src/maple_util/include/utils.h
index b6dd340220b8744cf0d06f7e62c13912916fdf4b..9bdb7f111e0d97629435cf658b5d9b1e439242a8 100644
--- a/src/maple_util/include/utils.h
+++ b/src/maple_util/include/utils.h
@@ -18,7 +18,8 @@
 #include <limits>
 #include "mpl_logging.h"
 
-namespace maple { namespace utils {
+namespace maple {
+namespace utils {
 // Operations on char
 constexpr bool IsDigit(char c) {
   return (c >= '0' && c <= '9');
diff --git a/src/maple_util/include/utils/iterator.h b/src/maple_util/include/utils/iterator.h
index 6f8e42912888aad3431ffddd7075567c1d75f7d7..15f21392764098757bccec531faaf6f98d946be6 100644
--- a/src/maple_util/include/utils/iterator.h
+++ b/src/maple_util/include/utils/iterator.h
@@ -17,7 +17,8 @@
 #include <iterator>
 #include "meta.h"
 
-namespace maple { namespace utils {
+namespace maple {
+namespace utils {
 template <typename Iterator, typename Container>
 struct mpl_iterator_traits {
   using iterator_category = typename std::iterator_traits<Iterator>::iterator_category;
diff --git a/src/maple_util/include/utils/meta.h b/src/maple_util/include/utils/meta.h
index b2ce82cf79a0bd5c955954a4fb7c8db719a817d6..9d7fbe5987297cd7ee7821981ef12b8d174013ee 100644
--- a/src/maple_util/include/utils/meta.h
+++ b/src/maple_util/include/utils/meta.h
@@ -16,7 +16,8 @@
 #define MAPLE_UTIL_INCLUDE_META_H
 #include <type_traits>
 
-namespace maple { namespace utils {
+namespace maple {
+namespace utils {
 template <typename T, typename U>
 struct meta_and
     : std::conditional_t<T::value, U, T> {};
diff --git a/src/maple_util/include/utils/ref_vector.h b/src/maple_util/include/utils/ref_vector.h
index 31c47178e3d4c84465c11a806b5a43d7296fb9f9..0a040454334b3a0fb92136cb6ce90be412f07745 100644
--- a/src/maple_util/include/utils/ref_vector.h
+++ b/src/maple_util/include/utils/ref_vector.h
@@ -24,7 +24,8 @@
 // to check nullptr, it will make the code more confusion and hard to maintain.
 // Based on that, the ref_vector picks up the meaning of keeping objects' reference, it won't destory any of its
 // elements or require to check null(Never to be nullptr).
-namespace maple { namespace utils {
+namespace maple {
+namespace utils {
 class ref_vector_tag;
 template <typename Iterator>
 struct mpl_iterator_traits<Iterator, ref_vector_tag> {
diff --git a/src/maple_util/src/profile.cpp b/src/maple_util/src/profile.cpp
index 6f024ce5d7c695aefed439cc5f5d1146f106146d..c204c7d57bfde3a074b0d0b0c9eac3e27a02b14f 100644
--- a/src/maple_util/src/profile.cpp
+++ b/src/maple_util/src/profile.cpp
@@ -84,7 +84,7 @@ bool Profile::CheckDexValid(uint32 idx) const {
 }
 
 void Profile::ParseLiteral(const char *data, const char *end) {
-  if(data > end) {
+  if (data > end) {
     LogInfo::MapleLogger() << "parse Literal error" << '\n';
   }
   const std::string str(data, end - data);
@@ -309,7 +309,7 @@ bool Profile::DeCompress(const std::string &path, const std::string &dexNameInne
     if (type != kAll && type != profileDataInfo->profileType) {
       continue; // only parse the indicated type
     }
-    switch(profileDataInfo->profileType) {
+    switch (profileDataInfo->profileType) {
       case kFunction:
         ParseFunc(proFileData, profileDataInfo->mapleFileNum);
         break;
@@ -326,7 +326,7 @@ bool Profile::DeCompress(const std::string &path, const std::string &dexNameInne
         ParseReflectionStr(proFileData, profileDataInfo->mapleFileNum);
         break;
       case kLiteral:
-        ParseLiteral(proFileData,strBuf);
+        ParseLiteral(proFileData, strBuf);
         break;
       case kBBInfo:
         ParseIRFuncDesc(proFileData, profileDataInfo->mapleFileNum);
diff --git a/src/mpl2mpl/include/muid_replacement.h b/src/mpl2mpl/include/muid_replacement.h
old mode 100644
new mode 100755
index fa47f938c5fd06db88fa5f90d9d150d41546d0f0..b03a9ca7b5a568500766fa434e192bac9f018839
--- a/src/mpl2mpl/include/muid_replacement.h
+++ b/src/mpl2mpl/include/muid_replacement.h
@@ -93,13 +93,14 @@ class MUIDReplacement : public FuncOptimizeImpl {
   uint32 FindIndexFromUndefTable(const MIRSymbol &mirSymbol, bool isFunc);
   void ReplaceAddroffuncConst(MIRConst *&entry, uint32 fieldID, bool isVtab);
   void ReplaceFuncTable(const std::string &name);
-  void ReplaceAddrofConst(MIRConst *&entry);
+  void ReplaceAddrofConst(MIRConst *&entry, bool muidIndex32Mod = false);
   void ReplaceDataTable(const std::string &name);
   void ReplaceDirectInvokeOrAddroffunc(MIRFunction &currentFunc, StmtNode &stmt);
   void ReplaceDassign(MIRFunction &currentFunc, const DassignNode &dassignNode);
   void ReplaceDreadStmt(MIRFunction *currentFunc, StmtNode *stmt);
   void ClearVtabItab(const std::string &name);
   void ReplaceDecoupleKeyTable(MIRAggConst *oldConst);
+  void ReplaceFieldTypeTable(const std::string &name);
   BaseNode *ReplaceDreadExpr(MIRFunction *currentFunc, StmtNode *stmt, BaseNode *expr);
   BaseNode *ReplaceDread(MIRFunction &currentFunc, const StmtNode *stmt, BaseNode *opnd);
   void CollectDread(MIRFunction &currentFunc, StmtNode &stmt, BaseNode &opnd);
@@ -113,7 +114,8 @@ class MUIDReplacement : public FuncOptimizeImpl {
   void CollectFuncAndDataFromGlobalTab();
   void CollectFuncAndDataFromFuncList();
   void GenerateCompilerVersionNum();
-  int64 GetDefOrUndefOffsetWithMask(uint64, bool isDef) const;
+  int64 GetDefOrUndefOffsetWithMask(uint64, bool isDef, bool muidIndex32Mod = false) const;
+  void CollectSuperClassArraySymbolData();
   static MIRSymbol *GetSymbolFromName(const std::string &name);
   ConstvalNode* GetConstvalNode(int64 index);
   // The following sets are for internal uses. Sorting order does not matter here.
@@ -121,6 +123,7 @@ class MUIDReplacement : public FuncOptimizeImpl {
   std::unordered_set<MIRFunction*> funcUndefSet;
   std::unordered_set<MIRSymbol*> dataDefSet;
   std::unordered_set<MIRSymbol*> dataUndefSet;
+  std::unordered_set<MIRSymbol*> superClassArraySymbolSet;
   void AddDefFunc(MIRFunction *func) {
     funcDefSet.insert(func);
   }
diff --git a/src/mpl2mpl/include/reflection_analysis.h b/src/mpl2mpl/include/reflection_analysis.h
old mode 100644
new mode 100755
index dce515ee1ca39e263af8c6a8a11d9a61d8272ce6..479353a105eb94a4408552a4c8863fd558faad01
--- a/src/mpl2mpl/include/reflection_analysis.h
+++ b/src/mpl2mpl/include/reflection_analysis.h
@@ -88,7 +88,8 @@ enum class FieldProperty : uint32 {
   kTypeName,
   kName,
   kAnnotation,
-  kDeclarclass
+  kDeclarclass,
+  kPClassType
 };
 
 enum class FieldPropertyCompact : uint32 {
@@ -177,7 +178,7 @@ class ReflectionAnalysis : public AnalysisResult {
   std::string GetAnnoValueNoArray(const MIRPragmaElement &annoElem);
   std::string GetArrayValue(const MapleVector<MIRPragmaElement*> &subElemVector);
   std::string GetAnnotationValue(const MapleVector<MIRPragmaElement*> &subElemVector, GStrIdx typeStrIdx);
-  MIRSymbol *GenSuperClassMetaData(const Klass &klass, std::list<Klass*> superClassList);
+  MIRSymbol *GenSuperClassMetaData(std::list<Klass*> superClassList);
   MIRSymbol *GenFieldOffsetData(const Klass &klass, std::pair<FieldPair, int> &fieldInfo);
   MIRSymbol *GenFieldsMetaData(const Klass &klass);
   MIRSymbol *GenMethodsMetaData(const Klass &klass);
@@ -234,6 +235,8 @@ class ReflectionAnalysis : public AnalysisResult {
   uint32 GetTypeNameIdxFromType(const MIRType &type, const Klass &klass, const std::string &fieldName);
   bool IsMemberClass(const std::string &annotationString);
   int8_t GetAnnoFlag(const std::string &annotationString);
+  void GenFieldTypeClassInfo(const MIRType &type, const Klass &klass, std::string &classInfo,
+                             const std::string fieldName, bool &isClass);
 
   MIRModule *mirModule;
   MapleAllocator allocator;
@@ -265,6 +268,7 @@ class ReflectionAnalysis : public AnalysisResult {
   static constexpr char annoDelimiter = '!';
   static constexpr char annoArrayStartDelimiter = '{';
   static constexpr char annoArrayEndDelimiter = '}';
+  std::map<std::list<Klass*>, std::string> superClasesIdxMap;
 };
 
 class DoReflectionAnalysis : public ModulePhase {
diff --git a/src/mpl2mpl/include/vtable_analysis.h b/src/mpl2mpl/include/vtable_analysis.h
index da1477be93bdc6bf5f74516349ffd39b6b207e51..9ad5cf03068a96c9851a90caf6b902827a245167 100644
--- a/src/mpl2mpl/include/vtable_analysis.h
+++ b/src/mpl2mpl/include/vtable_analysis.h
@@ -38,6 +38,7 @@ class VtableAnalysis : public FuncOptimizeImpl {
   }
 
  private:
+  bool CheckInterfaceSpecification(const Klass &baseKlass, const Klass &currKlass) const;
   bool CheckOverrideForCrossPackage(const MIRFunction &baseMethod, const MIRFunction &currMethod) const;
   void AddMethodToTable(MethodPtrVector &methodTable, MethodPair &methodPair);
   void GenVtableList(const Klass &klass);
diff --git a/src/mpl2mpl/src/muid_replacement.cpp b/src/mpl2mpl/src/muid_replacement.cpp
old mode 100644
new mode 100755
index 9ead44929212ff8128e0fff27d0d2cca92ad428b..725a2714d7419a9957ad0e6eeef82fa9c9bcf7b1
--- a/src/mpl2mpl/src/muid_replacement.cpp
+++ b/src/mpl2mpl/src/muid_replacement.cpp
@@ -36,6 +36,8 @@ constexpr maple::uint64 kFromUndefIndexMask = 0x4000000000000000;
 constexpr maple::uint64 kFromDefIndexMask = 0x2000000000000000;
 #endif
 constexpr maple::uint64 KReservedBits = 2u;
+constexpr maple::uint32 kFromUndefIndexMask32Mod = 0x80000000;
+constexpr maple::uint32 kFromDefIndexMask32Mod = 0x40000000;
 
 
 } // namespace
@@ -168,6 +170,16 @@ void MUIDReplacement::CollectFuncAndDataFromGlobalTab() {
   }
 }
 
+void MUIDReplacement::CollectSuperClassArraySymbolData() {
+  // Iterate global symbols
+  for (size_t i = 0; i < GlobalTables::GetGsymTable().GetSymbolTableSize(); ++i) {
+    MIRSymbol *mirSymbol = GlobalTables::GetGsymTable().GetSymbolFromStidx(i);
+    if ((mirSymbol != nullptr) && mirSymbol->IsReflectionSuperclassInfo()) {
+      (void)superClassArraySymbolSet.insert(mirSymbol);
+    }
+  }
+}
+
 void MUIDReplacement::CollectFuncAndDataFromFuncList() {
   // Iterate function bodies
   for (MIRFunction *mirFunc : GetMIRModule().GetFunctionList()) {
@@ -887,6 +899,41 @@ void MUIDReplacement::ReplaceAddroffuncConst(MIRConst *&entry, uint32 fieldID, b
   entry = constNode;
 }
 
+void MUIDReplacement::ReplaceFieldTypeTable(const std::string &name) {
+  MIRSymbol *tabSym = GetSymbolFromName(name);
+  if (tabSym == nullptr) {
+    return;
+  }
+  auto *oldConst = safe_cast<MIRAggConst>(tabSym->GetKonst());
+  if (oldConst == nullptr) {
+    return;
+  }
+  for (MIRConst *&oldTabEntry : oldConst->GetConstVec()) {
+    CHECK_NULL_FATAL(oldTabEntry);
+    if (oldTabEntry->GetKind() == kConstAggConst) {
+      uint32 index = static_cast<uint32>(FieldProperty::kPClassType);
+      auto *aggrC = static_cast<MIRAggConst*>(oldTabEntry);
+      CHECK_NULL_FATAL(aggrC->GetConstVecItem(index));
+      if(aggrC->GetConstVecItem(index)->GetKind() == kConstInt) {
+        continue;
+      } else {
+        ReplaceAddrofConst(aggrC->GetConstVecItem(index), true);
+        MIRConstPtr mirConst = aggrC->GetConstVecItem(index);
+        CHECK_NULL_FATAL(mirConst);
+        if (mirConst->GetKind() == kConstInt) {
+          MIRIntConst *newIntConst = GlobalTables::GetIntConstTable().GetOrCreateIntConst(
+              static_cast<MIRIntConst*>(mirConst)->GetValue(), mirConst->GetType(), index + 1);
+          aggrC->SetConstVecItem(index, *newIntConst);
+        } else {
+          aggrC->GetConstVecItem(index)->SetFieldID(index + 1);
+        }
+      }
+    } else if (oldTabEntry->GetKind() == kConstAddrof) {
+      ReplaceAddrofConst(oldTabEntry, true);
+    }
+  }
+}
+
 void MUIDReplacement::ReplaceDataTable(const std::string &name) {
   MIRSymbol *tabSym = GetSymbolFromName(name);
   if (tabSym == nullptr) {
@@ -948,7 +995,7 @@ void MUIDReplacement::ReplaceDecoupleKeyTable(MIRAggConst* oldConst) {
   }
 }
 
-void MUIDReplacement::ReplaceAddrofConst(MIRConst *&entry) {
+void MUIDReplacement::ReplaceAddrofConst(MIRConst *&entry, bool muidIndex32Mod) {
   if (entry->GetKind() != kConstAddrof) {
     return;
   }
@@ -963,29 +1010,37 @@ void MUIDReplacement::ReplaceAddrofConst(MIRConst *&entry) {
   MIRIntConst *constNode = nullptr;
   if (addrSym->GetStorageClass() != kScExtern) {
     offset = FindIndexFromDefTable(*addrSym, false);
-    constNode = GlobalTables::GetIntConstTable().GetOrCreateIntConst(GetDefOrUndefOffsetWithMask(offset, true),
-                                                                     voidType);
+    constNode = GlobalTables::GetIntConstTable().GetOrCreateIntConst(GetDefOrUndefOffsetWithMask(offset, true,
+                                                                     muidIndex32Mod), voidType);
   } else {
     offset = FindIndexFromUndefTable(*addrSym, false);
-    constNode = GlobalTables::GetIntConstTable().GetOrCreateIntConst(GetDefOrUndefOffsetWithMask(offset, false),
-                                                                     voidType);
+    constNode = GlobalTables::GetIntConstTable().GetOrCreateIntConst(GetDefOrUndefOffsetWithMask(offset, false,
+                                                                     muidIndex32Mod), voidType);
   }
   entry = constNode;
 }
 
-int64 MUIDReplacement::GetDefOrUndefOffsetWithMask(uint64 offset, bool isDef) const {
+int64 MUIDReplacement::GetDefOrUndefOffsetWithMask(uint64 offset, bool isDef, bool muidIndex32Mod) const {
   if (isDef) {
+    if (muidIndex32Mod) {
+      return static_cast<int64>(static_cast<uint32>(offset) | kFromDefIndexMask32Mod);
+    } else {
 #ifdef USE_ARM32_MACRO
-    return static_cast<int64>((offset << KReservedBits) + kLinkerRefDef);
+      return static_cast<int64>((offset << KReservedBits) + kLinkerRefDef);
 #else
-    return static_cast<int64>(offset | kFromDefIndexMask);
+      return static_cast<int64>(offset | kFromDefIndexMask);
 #endif
+    }
   } else {
+    if (muidIndex32Mod) {
+      return static_cast<int64>(static_cast<uint32>(offset) | kFromUndefIndexMask32Mod);
+    } else {
 #ifdef USE_ARM32_MACRO
-    return static_cast<int64>((offset << KReservedBits) + kLinkerRefUnDef);
+      return static_cast<int64>((offset << KReservedBits) + kLinkerRefUnDef);
 #else
-    return static_cast<int64>(offset | kFromUndefIndexMask);
+      return static_cast<int64>(offset | kFromUndefIndexMask);
 #endif
+    }
   }
 }
 
@@ -1350,6 +1405,7 @@ void MUIDReplacement::GenerateTables() {
   CollectFuncAndDataFromKlasses();
   CollectFuncAndDataFromGlobalTab();
   CollectFuncAndDataFromFuncList();
+  CollectSuperClassArraySymbolData();
   GenerateFuncDefTable();
   GenerateDataDefTable();
   GenerateUnifiedUndefTable();
@@ -1358,9 +1414,14 @@ void MUIDReplacement::GenerateTables() {
   // phase that updates the reflection string table, thus the table
   // is emitted here.
   ReflectionAnalysis::GenStrTab(GetMIRModule());
+
+  // Replace super class array
+  for (auto superArraySymbol : superClassArraySymbolSet) {
+    ReplaceDataTable(superArraySymbol->GetName());
+  }
   // Replace undef entries in vtab/itab/reflectionMetaData
   for (Klass *klass : klassHierarchy->GetTopoSortedKlasses()) {
-    ReplaceDataTable(SUPERCLASSINFO_PREFIX_STR + klass->GetKlassName());
+    ReplaceFieldTypeTable(NameMangler::kFieldsInfoPrefixStr + klass->GetKlassName());
     ReplaceFuncTable(VTAB_PREFIX_STR + klass->GetKlassName());
     ReplaceFuncTable(ITAB_PREFIX_STR + klass->GetKlassName());
     ReplaceFuncTable(ITAB_CONFLICT_PREFIX_STR + klass->GetKlassName());
diff --git a/src/mpl2mpl/src/native_stub_func.cpp b/src/mpl2mpl/src/native_stub_func.cpp
index 249dd7a0a5b623f32ac07056a049c003837411fe..15465a5609d2380721727a403b3f8b8fe0c5ce6b 100644
--- a/src/mpl2mpl/src/native_stub_func.cpp
+++ b/src/mpl2mpl/src/native_stub_func.cpp
@@ -353,7 +353,7 @@ void NativeStubFuncGeneration::GenerateRegisteredNativeFuncCall(MIRFunction &fun
   BaseNode *checkRegExpr =
       builder->CreateExprCompare(OP_lt, *GlobalTables::GetTypeTable().GetUInt1(),
                                  *GlobalTables::GetTypeTable().GetPtr(),
-                                 regReadExpr, builder->CreateIntConst(MByteRef::PositiveOffsetBias, PTY_ptr));
+                                 regReadExpr, builder->CreateIntConst(MByteRef::kPositiveOffsetBias, PTY_ptr));
 #elif defined(TARGAARCH64)
   // define a temp register for bitwise-and operation
   constexpr int intConstLength = 1;
diff --git a/src/mpl2mpl/src/reflection_analysis.cpp b/src/mpl2mpl/src/reflection_analysis.cpp
old mode 100644
new mode 100755
index 1cbc28961f73baffcb21a768c889c9a8878e5cdb..40a743a0e4d3e2edcc09aff2eb40db90a7ba2474
--- a/src/mpl2mpl/src/reflection_analysis.cpp
+++ b/src/mpl2mpl/src/reflection_analysis.cpp
@@ -88,6 +88,7 @@ constexpr char kPaddingStr[] = "padding";
 constexpr char kInstanceOfCacheFalseStr[] = "instanceOfCacheFalse";
 #endif // ~USE_32BIT_REF
 constexpr char kTypeNameStr[] = "typeName";
+constexpr char kPClassTypeStr[] = "pClassType";
 constexpr char kClassNameStr[] = "classname";
 constexpr char kFieldNameStr[] = "fieldname";
 constexpr char kAccessFlags[] = "accessFlags";
@@ -145,6 +146,36 @@ std::string ReflectionAnalysis::strTabBothHot = std::string(1, '\0');
 std::string ReflectionAnalysis::strTabRunHot = std::string(1, '\0');
 bool ReflectionAnalysis::strTabInited = false;
 
+void ReflectionAnalysis::GenFieldTypeClassInfo(const MIRType &type, const Klass &klass, std::string &classInfo,
+                         const std::string fieldName, bool &isClass) {
+  switch (type.GetKind()) {
+    case kTypeScalar: {
+      isClass = false;
+      break;
+    }
+    case kTypePointer: {
+      auto *ptype = static_cast<const MIRPtrType&>(type).GetPointedType();
+      CHECK_NULL_FATAL(ptype);
+      if (ptype->GetKind() == kTypeArray || ptype->GetKind() == kTypeJArray ||
+          ptype->GetKind() == kTypeClassIncomplete || ptype->GetKind() == kTypeInterfaceIncomplete) {
+        isClass = false;
+      } else if (ptype->GetKind() == kTypeByName || ptype->GetKind() == kTypeClass ||
+                 ptype->GetKind() == kTypeInterface || ptype->GetKind() == kTypeConstString) {
+        MIRStructType *classTypeSecond = static_cast<MIRStructType*>(ptype);
+        classInfo = CLASSINFO_PREFIX_STR + classTypeSecond->GetName();
+        isClass = true;
+      } else {
+        CHECK_FATAL(false, "In class %s: field %s 's type is UNKNOWN", klass.GetKlassName().c_str(),
+                    fieldName.c_str());
+      }
+      break;
+    }
+    default: {
+      CHECK_FATAL(false, "In class %s: field %s 's type is UNKNOWN", klass.GetKlassName().c_str(), fieldName.c_str());
+    }
+  }
+}
+
 bool ReflectionAnalysis::IsMemberClass(const std::string &annotationString) {
   uint32_t idx = ReflectionAnalysis::FindOrInsertReflectString(kEnclosingClassStr);
   std::string target = annoDelimiterPrefix + std::to_string(idx) + annoDelimiter;
@@ -450,7 +481,7 @@ void ReflectionAnalysis::ConvertMethodSig(std::string &signature) {
   size_t signatureSize = signature.size();
   for (size_t i = 1; i < signatureSize; ++i) {
     if (signature[i] == 'L') {
-      while (signature[++i] != ';') {} // eg. Ljava/io/InputStream; so we do not check the boundary.
+      while (++i < signatureSize && signature[i] != ';') {}
     } else if (signature[i] == 'A') {
       signature[i] = '[';
     }
@@ -504,7 +535,14 @@ uint16 GetFieldHash(const std::vector<std::pair<FieldPair, uint16>> &fieldV, con
 
 MIRSymbol *ReflectionAnalysis::GetOrCreateSymbol(const std::string &name, TyIdx tyIdx, bool needInit = false) {
   const GStrIdx strIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(name);
-  MIRSymbol *st = GetSymbol(strIdx, tyIdx);
+  MIRSymbol *st;
+  std::string symbolOfJavaLangString(NameMangler::kJavaLangStringStr);
+  if (name == CLASSINFO_PREFIX_STR + symbolOfJavaLangString) {
+    // Previous String Symbol have been generated in dex2mpl, so this Symbol won't create again here
+    st = GlobalTables::GetGsymTable().GetSymbolFromStrIdx(strIdx);
+  } else {
+    st = GetSymbol(strIdx, tyIdx);
+  }
   if (st != nullptr && !needInit) {
     // Previous symbol is a forward declaration, create a new symbol for definiton.
     return st;
@@ -898,24 +936,34 @@ MIRSymbol *ReflectionAnalysis::GenFieldOffsetData(const Klass &klass, std::pair<
   return fieldsOffsetSt;
 }
 
-MIRSymbol *ReflectionAnalysis::GenSuperClassMetaData(const Klass &klass, std::list<Klass*> superClassList) {
+MIRSymbol *ReflectionAnalysis::GenSuperClassMetaData(std::list<Klass*> superClassList) {
   MIRModule &module = *mirModule;
   size_t size = superClassList.size();
   auto &superclassMetadataType =
       static_cast<MIRStructType&>(*GlobalTables::GetTypeTable().GetTypeFromTyIdx(superclassMetadataTyIdx));
   MIRArrayType &arrayType = *GlobalTables::GetTypeTable().GetOrCreateArrayType(superclassMetadataType, size);
-  MIRAggConst *aggconst = module.GetMemPool()->New<MIRAggConst>(module, arrayType);
-  for (auto it = superClassList.begin(); it != superClassList.end(); ++it) {
-    MIRSymbol *dklassSt = GetOrCreateSymbol(CLASSINFO_PREFIX_STR + (*it)->GetKlassName(), classMetadataTyIdx);
-    MIRAggConst *newConst = module.GetMemPool()->New<MIRAggConst>(module, superclassMetadataType);
-    mirBuilder.AddAddrofFieldConst(superclassMetadataType, *newConst, 1, *dklassSt);
-    aggconst->PushBack(newConst);
-  }
-  MIRSymbol *superclassArraySt =
-      GetOrCreateSymbol(SUPERCLASSINFO_PREFIX_STR + klass.GetKlassName(), arrayType.GetTypeIndex(), true);
-  // Direct access to superclassinfo is only possible within a .so.
-  superclassArraySt->SetStorageClass(kScFstatic);
-  superclassArraySt->SetKonst(aggconst);
+  MIRSymbol *superclassArraySt = nullptr;
+
+  auto itFindSuper = superClasesIdxMap.find(superClassList);
+  if (itFindSuper == superClasesIdxMap.end()) {
+    std::string superClassArrayInfo = SUPERCLASSINFO_PREFIX_STR + std::to_string(superClasesIdxMap.size());
+    superClasesIdxMap[superClassList] = superClassArrayInfo;
+
+    MIRAggConst *aggconst = module.GetMemPool()->New<MIRAggConst>(module, arrayType);
+    for (auto it = superClassList.begin(); it != superClassList.end(); ++it) {
+      MIRSymbol *dklassSt = GetOrCreateSymbol(CLASSINFO_PREFIX_STR + (*it)->GetKlassName(), classMetadataTyIdx);
+      MIRAggConst *newConst = module.GetMemPool()->New<MIRAggConst>(module, superclassMetadataType);
+      mirBuilder.AddAddrofFieldConst(superclassMetadataType, *newConst, 1, *dklassSt);
+      aggconst->PushBack(newConst);
+    }
+    superclassArraySt = GetOrCreateSymbol(superClassArrayInfo, arrayType.GetTypeIndex(), true);
+    // Direct access to superclassinfo is only possible within a .so.
+    superclassArraySt->SetStorageClass(kScFstatic);
+    superclassArraySt->SetKonst(aggconst);
+  } else {
+    std::string superClassArrayInfo = superClasesIdxMap[superClassList];
+    superclassArraySt = GetOrCreateSymbol(superClassArrayInfo, arrayType.GetTypeIndex());
+  }
   return superclassArraySt;
 }
 
@@ -965,7 +1013,7 @@ void ReflectionAnalysis::GenFieldMeta(const Klass &klass, MIRStructType &fieldsI
   mirBuilder.AddIntFieldConst(fieldsInfoType, *newConst, fieldID++, flag);
   // @index
   mirBuilder.AddIntFieldConst(fieldsInfoType, *newConst, fieldID++, idx);
-  // @type
+  // @typeName
   TyIdx fieldTyIdx = fieldP.second.first;
   std::string fieldName = GlobalTables::GetStrTable().GetStringFromStrIdx(fieldP.first);
   MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(fieldTyIdx);
@@ -985,7 +1033,17 @@ void ReflectionAnalysis::GenFieldMeta(const Klass &klass, MIRStructType &fieldsI
   mirBuilder.AddIntFieldConst(fieldsInfoType, *newConst, fieldID++, annotationIdx);
   // @declaring class
   MIRSymbol *dklassSt = GetOrCreateSymbol(CLASSINFO_PREFIX_STR + klass.GetKlassName(), classMetadataTyIdx);
-  mirBuilder.AddAddrofFieldConst(fieldsInfoType, *newConst, fieldID, *dklassSt);
+  mirBuilder.AddAddrofFieldConst(fieldsInfoType, *newConst, fieldID++, *dklassSt);
+  // @class type
+  std::string classInfo;
+  bool isClass = false;
+  GenFieldTypeClassInfo(*ty, klass, classInfo, fieldName, isClass);
+  if (isClass) {
+    MIRSymbol *typeSym = GetOrCreateSymbol(classInfo, classMetadataTyIdx);
+    mirBuilder.AddAddrofFieldConst(fieldsInfoType, *newConst, fieldID, *typeSym);
+  } else {
+    mirBuilder.AddIntFieldConst(fieldsInfoType, *newConst, fieldID, 0);
+  }
   aggConst.GetConstVec().push_back(newConst);
 }
 
@@ -1426,7 +1484,7 @@ void ReflectionAnalysis::GenClassMetaData(Klass &klass) {
 
   size_t superClassSize = superClassList.size();
   if (superClassSize >= 1) {
-    MIRSymbol *superClassSymbolType = GenSuperClassMetaData(klass, superClassList);
+    MIRSymbol *superClassSymbolType = GenSuperClassMetaData(superClassList);
     mirBuilder.AddAddrofFieldConst(classMetadataROType, *newConst, fieldID++, *superClassSymbolType);
   } else {
     mirBuilder.AddIntFieldConst(classMetadataROType, *newConst, fieldID++, 0);
@@ -1688,7 +1746,13 @@ void ReflectionAnalysis::GenMetadataType(MIRModule &mirModule) {
 #endif  // USE_32BIT_REF
   GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kFieldNameStr, *typeU32);
   GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kAnnotationStr, *typeU32);
-  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kDeclaringclassStr, *GetRefFieldType());
+#ifndef USE_32BIT_REF
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kDeclaringclassStr, *typeU64);
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kPClassTypeStr, *typeU64);
+#else
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kDeclaringclassStr, *typeU32);
+  GlobalTables::GetTypeTable().AddFieldToStructType(fieldInfoType, kPClassTypeStr, *typeU32);
+#endif  // USE_32BIT_REF
   fieldsInfoTyIdx = GenMetaStructType(mirModule, fieldInfoType, kFieldInfoTypeName);
   // FieldInfoType Compact.
   MIRStructType fieldInfoCompactType(kTypeStruct);
diff --git a/src/mpl2mpl/src/vtable_analysis.cpp b/src/mpl2mpl/src/vtable_analysis.cpp
index c09aeade6d69f6af1ecba23e4e82306269cf2457..90e51aa158542d036ae89e60e3a992b09e20f0d6 100644
--- a/src/mpl2mpl/src/vtable_analysis.cpp
+++ b/src/mpl2mpl/src/vtable_analysis.cpp
@@ -55,6 +55,11 @@ bool VtableAnalysis::IsVtableCandidate(const MIRFunction &func) {
   return func.GetAttr(FUNCATTR_virtual) && !func.GetAttr(FUNCATTR_private) && !func.GetAttr(FUNCATTR_static);
 }
 
+// Return true if currMethod is more specific than baseMethod
+bool VtableAnalysis::CheckInterfaceSpecification(const Klass &baseKlass, const Klass &currKlass) const {
+  return !(klassHierarchy->IsSuperKlassForInterface(&currKlass, &baseKlass));
+}
+
 // Return true if virtual functions can be set override relationship cross package
 bool VtableAnalysis::CheckOverrideForCrossPackage(const MIRFunction &baseMethod,
     const MIRFunction &currMethod) const {
@@ -64,10 +69,14 @@ bool VtableAnalysis::CheckOverrideForCrossPackage(const MIRFunction &baseMethod,
   const std::string &currClassName = currMethod.GetBaseClassName();
   size_t currPos = currClassName.rfind(NameMangler::kPackageNameSplitterStr);
   std::string currPackageName = (currPos != std::string::npos) ? currClassName.substr(0, currPos) : "";
-  // For the corss package inheritance, only if the base func is declared
+  // 1. For the cross package inheritance, only if the base func is declared
   // as either 'public' or 'protected', we shall set override relationship.
-  return (currPackageName == basePackageName) || baseMethod.GetAttr(FUNCATTR_public) ||
-          baseMethod.GetAttr(FUNCATTR_protected);
+  // 2. For interface methods, override relationship would be set only if
+  // currMethod is more specific.
+  Klass *baseKlass = klassHierarchy->GetKlassFromFunc(&baseMethod);
+  Klass *currKlass = klassHierarchy->GetKlassFromFunc(&currMethod);
+  return ((currPackageName == basePackageName) || baseMethod.GetAttr(FUNCATTR_public) ||
+          baseMethod.GetAttr(FUNCATTR_protected)) && (CheckInterfaceSpecification(*baseKlass, *currKlass));
 }
 
 // If the method is not in method_table yet, add it in, otherwise update it.
@@ -93,7 +102,6 @@ void VtableAnalysis::AddMethodToTable(MethodPtrVector &methodTable, MethodPair &
 void VtableAnalysis::GenVtableList(const Klass &klass) {
   if (klass.IsInterface() || klass.IsInterfaceIncomplete()) {
     MIRInterfaceType *iType = klass.GetMIRInterfaceType();
-    // add in methods from parent interfaces, note interfaces can declare/define same methods
     for (const Klass *parentKlass : klass.GetSuperKlasses()) {
       MIRInterfaceType *parentInterfaceType = parentKlass->GetMIRInterfaceType();
       for (MethodPair *methodPair : parentInterfaceType->GetVTableMethods()) {
diff --git a/src/mplfe/common/include/fe_macros.h b/src/mplfe/common/include/fe_macros.h
index 50eac19b1b8c4f6f576f3d2bad02e2a67b4777a1..732fea0f10c36480377cff50c22c106930888f30 100644
--- a/src/mplfe/common/include/fe_macros.h
+++ b/src/mplfe/common/include/fe_macros.h
@@ -23,7 +23,7 @@
 #include "fe_options.h"
 #include "mpl_logging.h"
 
-#define TIMEIT(message, stmt)                                                                                      \
+#define TIMEIT(message, stmt) do {                                                                                 \
   if (FEOptions::GetInstance().IsDumpTime()) {                                                                     \
     struct timeval start, end;                                                                                     \
     (void)gettimeofday(&start, NULL);                                                                              \
@@ -33,9 +33,10 @@
     INFO(kLncInfo, "[TIME] %s: %.3f sec", message, t);                                                             \
   } else {                                                                                                         \
     stmt;                                                                                                          \
-  }
+  }                                                                                                                \
+} while (0)                                                                                                        \
 
-#define PHASE_TIMER(message, stmt)                                                    \
+#define PHASE_TIMER(message, stmt) do {                                               \
   if (FEOptions::GetInstance().IsDumpPhaseTime()) {                                   \
     struct timespec start = {0, 0};                                                   \
     struct timespec end = {0, 0};                                                     \
@@ -47,12 +48,14 @@
     INFO(kLncInfo, "[PhaseTime]   %s: %lld ns", message, t);                          \
   } else {                                                                            \
     stmt;                                                                             \
-  }
+  }                                                                                   \
+} while (0)                                                                           \
 
-#define FE_INFO_LEVEL(level, fmt, ...)                    \
+#define FE_INFO_LEVEL(level, fmt, ...) do {               \
   if (FEOptions::GetInstance().GetDumpLevel() >= level) { \
     INFO(kLncInfo, fmt, ##__VA_ARGS__);                   \
-  }
+  }                                                       \
+} while (0)                                               \
 
 #define BIT_XOR(v1, v2) (((v1) && (!(v2))) || ((!(v1)) && (v2)))
 #endif  // ~MPLFE_INCLUDE_FE_MACROS_H
\ No newline at end of file
diff --git a/src/mplfe/common/src/basic_io.cpp b/src/mplfe/common/src/basic_io.cpp
index 596f3e53f2293c780aaa87ea09419c04d410be3d..a21e25f5822d5265cc6d8616912403f492fe4be6 100644
--- a/src/mplfe/common/src/basic_io.cpp
+++ b/src/mplfe/common/src/basic_io.cpp
@@ -266,7 +266,7 @@ void BasicIORead::ReadBufferUInt8(uint8 *dst, uint32 length, bool &success) {
   pos += length;
   success = true;
   errno_t err = memcpy_s(dst, length, p, length);
-  CHECK_FATAL(err == 0, "memcpy_s failed");
+  CHECK_FATAL(err == EOK, "memcpy_s failed");
 }
 
 void BasicIORead::ReadBufferInt8(int8 *dst, uint32 length) {
@@ -274,7 +274,7 @@ void BasicIORead::ReadBufferInt8(int8 *dst, uint32 length) {
   const uint8 *p = GetSafeBuffer(length);
   pos += length;
   errno_t err = memcpy_s(dst, length, p, length);
-  CHECK_FATAL(err == 0, "memcpy_s failed");
+  CHECK_FATAL(err == EOK, "memcpy_s failed");
 }
 
 void BasicIORead::ReadBufferInt8(int8 *dst, uint32 length, bool &success) {
@@ -287,14 +287,14 @@ void BasicIORead::ReadBufferInt8(int8 *dst, uint32 length, bool &success) {
   pos += length;
   success = true;
   errno_t err = memcpy_s(dst, length, p, length);
-  CHECK_FATAL(err == 0, "memcpy_s failed");
+  CHECK_FATAL(err == EOK, "memcpy_s failed");
 }
 
 void BasicIORead::ReadBufferChar(char *dst, uint32 length) {
   const uint8 *p = GetSafeBuffer(length);
   pos += length;
   errno_t err = memcpy_s(dst, length, p, length);
-  CHECK_FATAL(err == 0, "memcpy_s failed");
+  CHECK_FATAL(err == EOK, "memcpy_s failed");
 }
 
 void BasicIORead::ReadBufferChar(char *dst, uint32 length, bool &success) {
@@ -306,7 +306,7 @@ void BasicIORead::ReadBufferChar(char *dst, uint32 length, bool &success) {
   pos += length;
   success = true;
   errno_t err = memcpy_s(dst, length, p, length);
-  CHECK_FATAL(err == 0, "memcpy_s failed");
+  CHECK_FATAL(err == EOK, "memcpy_s failed");
 }
 
 std::string BasicIORead::ReadString(uint32 length) {