diff --git a/src/mapleall/bin/dex2mpl b/src/mapleall/bin/dex2mpl
index b602ad47b27403c4dc150d87325cb3c3688e5114..ba57f29f006133e956d2740b61a3193173157b1b 100755
Binary files a/src/mapleall/bin/dex2mpl and b/src/mapleall/bin/dex2mpl differ
diff --git a/src/mapleall/bin/dex2mpl_android b/src/mapleall/bin/dex2mpl_android
index 5ef3ac904ca550c14e9c011aeb2d2a2cd22e02f7..ad8c77a033ed1abff3cc72ec1b98367a6c8876cc 100755
Binary files a/src/mapleall/bin/dex2mpl_android and b/src/mapleall/bin/dex2mpl_android differ
diff --git a/src/mapleall/bin/jbc2mpl b/src/mapleall/bin/jbc2mpl
index 0baefe58f577f524bca2f9a0f51c27ca21e546e3..f343cf01202d8b80072776d06738294ee904503a 100755
Binary files a/src/mapleall/bin/jbc2mpl and b/src/mapleall/bin/jbc2mpl differ
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_color_ra.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_color_ra.cpp
index ef364ed9156f473c08e2f35c7b04ee8061c76001..adacfc0b708e68a9d63be421fbe8fa07936a7169 100644
--- a/src/mapleall/maple_be/src/cg/aarch64/aarch64_color_ra.cpp
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_color_ra.cpp
@@ -947,10 +947,10 @@ MemOperand *GraphColorRegAllocator::CreateSpillMem(uint32 spillIdx, SpillMemChec
   }
 
   if (operandSpilled[spillIdx]) {
-    // For this insn, spill slot already used, need to find next available slot.
+    /* For this insn, spill slot already used, need to find next available slot. */
     uint32 i;
     for (i = spillIdx + 1; i < kSpillMemOpndNum; ++i) {
-      if (operandSpilled[i] == false) {
+      if (!operandSpilled[i]) {
         break;
       }
     }
@@ -3209,6 +3209,7 @@ void GraphColorRegAllocator::FinalizeRegisters() {
       if (insn->GetId() == 0) {
         continue;
       }
+
       for (uint32 i = 0; i < kSpillMemOpndNum; ++i) {
         operandSpilled[i] = false;
       }
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_ebo.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_ebo.cpp
index b1658b0fca22fdea1bb65fd48851d841ea0efa5e..6ac641001a7e4240d78b3a908b5f530b98885154 100644
--- a/src/mapleall/maple_be/src/cg/aarch64/aarch64_ebo.cpp
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_ebo.cpp
@@ -935,8 +935,10 @@ bool AArch64Ebo::ChangeLdrMop(Insn &insn, const Operand &opnd) const {
   ASSERT(opnd.IsRegister(), "expect opnd is a register in ChangeLdrMop");
 
   const RegOperand *regOpnd = static_cast<const RegOperand*>(&opnd);
-  ASSERT(static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd)).GetRegisterType() != regOpnd->GetRegisterType(),
-         "expected matched register type in AArch64Ebo::ChangeLdrMop");
+  if (static_cast<RegOperand&>(insn.GetOperand(kInsnFirstOpnd)).GetRegisterType() != regOpnd->GetRegisterType()) {
+    return false;
+  }
+
   if (static_cast<MemOperand&>(insn.GetOperand(kInsnSecondOpnd)).GetIndexRegister()) {
     return false;
   }
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_proepilog.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_proepilog.cpp
index a6d0351360e5f1d957960f4105b4842c19be5a71..a2c9af8ef6a0158d50ee320100b7926b0780cd2d 100644
--- a/src/mapleall/maple_be/src/cg/aarch64/aarch64_proepilog.cpp
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_proepilog.cpp
@@ -1032,7 +1032,8 @@ void AArch64GenProEpilog::AppendInstructionAllocateCallFrame(AArch64reg reg0, AA
   if (cgFunc.GenCfi()) {
     BB *curBB = cgFunc.GetCurBB();
     ipoint = curBB->InsertInsnAfter(*ipoint, aarchCGFunc.CreateCfiOffsetInsn(RFP, -cfiOffsetSecond, k64BitSize));
-    curBB->InsertInsnAfter(*ipoint, aarchCGFunc.CreateCfiOffsetInsn(RLR, -cfiOffsetSecond + kOffset8MemPos, k64BitSize));
+    curBB->InsertInsnAfter(*ipoint,
+                           aarchCGFunc.CreateCfiOffsetInsn(RLR, -cfiOffsetSecond + kOffset8MemPos, k64BitSize));
   }
 }
 
diff --git a/src/mapleall/maple_be/src/cg/ebo.cpp b/src/mapleall/maple_be/src/cg/ebo.cpp
index 6b159c31e46fcd002a36aa07a27ce3eee14576dd..78969438b99becb9068d19fd0162bf82c92405c9 100644
--- a/src/mapleall/maple_be/src/cg/ebo.cpp
+++ b/src/mapleall/maple_be/src/cg/ebo.cpp
@@ -993,7 +993,7 @@ void Ebo::RemoveUnusedInsns(BB &bb, bool normal) {
                 bool pattern3 = false;
                 bool pattern4 = false;
                 if (opInfo->refCount == 1) {
-                  if (IsOfSameClass(*reg, *res1)) {
+                  if (IsOfSameClass(*reg, *res1) && insn->IsMove()) {
                     pattern3 = true;
                     pattern1 = true;
                   } else if (prev->IsLoad() && ChangeLdrMop(*prev, *res1)) {
diff --git a/src/mplfe/ast_input/include/ast_expr.h b/src/mplfe/ast_input/include/ast_expr.h
index 5625146c23e67dee63cde459ca88bbad396176af..38d558b7eeaa0fa4a35f2df6a7fbee76e216e85b 100644
--- a/src/mplfe/ast_input/include/ast_expr.h
+++ b/src/mplfe/ast_input/include/ast_expr.h
@@ -432,7 +432,7 @@ class ASTBinaryOperatorExpr : public ASTExpr {
   UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
 
   Opcode opcode;
-  MIRType *retType;
+  MIRType *retType = nullptr;
   ASTExpr *leftExpr = nullptr;
   ASTExpr *rightExpr = nullptr;
 };
@@ -512,11 +512,16 @@ class ASTArraySubscriptExpr : public ASTExpr {
     return memberExpr;
   }
 
+  void SetAddrOfFlag(bool flag) {
+    isAddrOf = flag;
+  }
+
  private:
   UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
   ASTExpr *baseExpr;
   ASTExpr *memberExpr = nullptr;
   std::vector<ASTExpr*> idxExprs;
+  bool isAddrOf = false;
 };
 
 class ASTExprUnaryExprOrTypeTraitExpr : public ASTExpr {
@@ -584,6 +589,10 @@ class ASTMemberExpr : public ASTExpr {
     isArrow = arrow;
   }
 
+  bool GetIsArrow() const {
+    return isArrow;
+  }
+
  private:
   UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
   ASTExpr *baseExpr;
@@ -799,9 +808,14 @@ class ASTCharacterLiteral : public ASTExpr {
     val = valIn;
   }
 
+  void SetPrimType(PrimType primType) {
+    type = primType;
+  }
+
  private:
   UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
   int8 val;
+  PrimType type;
 };
 
 class ASTVAArgExpr : public ASTExpr {
diff --git a/src/mplfe/ast_input/src/ast_expr.cpp b/src/mplfe/ast_input/src/ast_expr.cpp
index 90e706323dfbda6bb3ee3c6faa8fdddc1165aff9..fd57a42974726953a22e1ddefeac4cd879db64a0 100644
--- a/src/mplfe/ast_input/src/ast_expr.cpp
+++ b/src/mplfe/ast_input/src/ast_expr.cpp
@@ -233,10 +233,10 @@ UniqueFEIRExpr ASTUOMinusExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts)
   UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts);
   PrimType dstType = uoType->GetPrimType();
   if (childFEIRExpr->GetPrimType() != dstType) {
-    UniqueFEIRExpr minusExpr = FEIRBuilder::CreateExprMathUnary(OP_neg, std::move(childFEIRExpr));
+    UniqueFEIRExpr minusExpr = std::make_unique<FEIRExprUnary>(OP_neg, subType, std::move(childFEIRExpr));
     return FEIRBuilder::CreateExprCvtPrim(std::move(minusExpr), dstType);
   }
-  return FEIRBuilder::CreateExprMathUnary(OP_neg, std::move(childFEIRExpr));
+  return std::make_unique<FEIRExprUnary>(OP_neg, subType, std::move(childFEIRExpr));
 }
 
 UniqueFEIRExpr ASTUOPlusExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
@@ -252,10 +252,10 @@ UniqueFEIRExpr ASTUONotExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) c
   UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts);
   PrimType dstType = uoType->GetPrimType();
   if (childFEIRExpr->GetPrimType() != dstType) {
-    UniqueFEIRExpr notExpr = FEIRBuilder::CreateExprMathUnary(OP_bnot, std::move(childFEIRExpr));
+    UniqueFEIRExpr notExpr = std::make_unique<FEIRExprUnary>(OP_bnot, subType, std::move(childFEIRExpr));
     return FEIRBuilder::CreateExprCvtPrim(std::move(notExpr), dstType);
   }
-  return FEIRBuilder::CreateExprMathUnary(OP_bnot, std::move(childFEIRExpr));
+  return std::make_unique<FEIRExprUnary>(OP_bnot, subType, std::move(childFEIRExpr));
 }
 
 UniqueFEIRExpr ASTUOLNotExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
@@ -264,10 +264,10 @@ UniqueFEIRExpr ASTUOLNotExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts)
   UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts);
   PrimType dstType = uoType->GetPrimType();
   if (childFEIRExpr->GetPrimType() != dstType) {
-    UniqueFEIRExpr lnotExpr = FEIRBuilder::CreateExprMathUnary(OP_lnot, std::move(childFEIRExpr));
+    UniqueFEIRExpr lnotExpr = std::make_unique<FEIRExprUnary>(OP_lnot, subType, std::move(childFEIRExpr));
     return FEIRBuilder::CreateExprCvtPrim(std::move(lnotExpr), dstType);
   }
-  return FEIRBuilder::CreateExprMathUnary(OP_lnot, std::move(childFEIRExpr));
+  return std::make_unique<FEIRExprUnary>(OP_lnot, subType, std::move(childFEIRExpr));
 }
 
 UniqueFEIRExpr ASTUOPostIncExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
@@ -365,16 +365,37 @@ UniqueFEIRExpr ASTUOAddrOfExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts
   ASTExpr *childExpr = expr;
   CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr");
   UniqueFEIRExpr addrOfExpr;
-  if (childExpr->GetASTOp() == kASTOpRef) {
+  auto astOp = childExpr->GetASTOp();
+  if (astOp == kASTOpRef) {
     ASTDecl *var = static_cast<ASTDeclRefExpr*>(childExpr)->GetASTDecl();
     UniqueFEIRVar addrOfVar = FEIRBuilder::CreateVarNameForC(var->GenerateUniqueVarName(),
                                                              *(var->GetTypeDesc().front()),
                                                              var->IsGlobal(), false);
     addrOfExpr = FEIRBuilder::CreateExprAddrofVar(std::move(addrOfVar));
+  } else if (astOp == kASTMemberExpr) {
+    ASTMemberExpr *memberExpr = static_cast<ASTMemberExpr*>(childExpr);
+    UniqueFEIRExpr baseFEExpr = memberExpr->GetBaseExpr()->Emit2FEExpr(stmts);
+    if (memberExpr->GetIsArrow()) {
+      addrOfExpr = std::move(baseFEExpr);
+      static_cast<FEIRExprAddrofVar*>(addrOfExpr.get())->SetFieldName(memberExpr->GetMemberName());
+    } else {
+      UniqueFEIRVar tmpVar;
+      if (baseFEExpr->GetKind() == kExprDRead) { // other potential expr should concern
+        auto dreadFEExpr = static_cast<FEIRExprDRead*>(baseFEExpr.get());
+        tmpVar = dreadFEExpr->GetVar()->Clone();
+        addrOfExpr = FEIRBuilder::CreateExprAddrofVar(std::move(tmpVar));
+        static_cast<FEIRExprAddrofVar*>(addrOfExpr.get())->SetFieldName(memberExpr->GetMemberName());
+        static_cast<FEIRExprAddrofVar*>(addrOfExpr.get())->SetFieldType(memberExpr->GetMemberType());
+      }
+    }
+  } else if (astOp == kASTSubscriptExpr) {
+    ASTArraySubscriptExpr *arraySubExpr = static_cast<ASTArraySubscriptExpr*>(childExpr);
+    arraySubExpr->SetAddrOfFlag(true);
+    addrOfExpr = childExpr->Emit2FEExpr(stmts);
   } else { // other potential expr should concern
     UniqueFEIRExpr childFEIRExpr;
     childFEIRExpr = childExpr->Emit2FEExpr(stmts);
-    addrOfExpr = FEIRBuilder::CreateExprMathUnary(OP_addrof, std::move(childFEIRExpr));
+    addrOfExpr = std::make_unique<FEIRExprUnary>(OP_addrof, uoType, std::move(childFEIRExpr));
   }
   return addrOfExpr;
 }
@@ -477,8 +498,6 @@ UniqueFEIRExpr ASTBinaryConditionalOperator::Emit2FEExprImpl(std::list<UniqueFEI
     // the conditional expr will be assigned var used for comparative expr and true expr meanwhile
     MIRType *condType = condFEIRExpr->GetType()->GenerateMIRTypeAuto();
     ASSERT_NOT_NULL(condType);
-    CHECK_FATAL(condType->GetPrimType() == PTY_u1,
-                "invalid type of comparative conditional expr, %u", condType->GetPrimType());
     UniqueFEIRVar condVar = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("condVal_"), *condType);
     UniqueFEIRVar condVarCloned = condVar->Clone();
     UniqueFEIRVar condVarCloned2 = condVar->Clone();
@@ -582,8 +601,8 @@ void ASTInitListExpr::Emit2FEExprForArray(std::list<UniqueFEIRStmt> &stmts) cons
   UniqueFEIRVar feirVarTmp = feirVar->Clone();
   UniqueFEIRType typeNative = FEIRTypeHelper::CreateTypeNative(*initListType);
   UniqueFEIRExpr arrayExpr = FEIRBuilder::CreateExprDRead(std::move(feirVarTmp));
-  for (int i = 0; i < fillers.size(); ++i) {
-    if (fillers[i]->GetASTOp() == kASTOpInitListExpr) {
+  if (fillers[0]->GetASTOp() == kASTOpInitListExpr) {
+    for (int i = 0; i < fillers.size(); ++i) {
       MIRType *mirType = static_cast<ASTInitListExpr*>(fillers[i])->initListType;
       std::string tmpName = FEUtils::GetSequentialName("subArray_");
       UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpName, *mirType);
@@ -598,7 +617,9 @@ void ASTInitListExpr::Emit2FEExprForArray(std::list<UniqueFEIRStmt> &stmts) cons
                                                                     std::move(exprIndex), std::move(typeNativeTmp),
                                                                     std::move(elemType));
       stmts.emplace_back(std::move(fieldStmt));
-    } else {
+    }
+  } else {
+    for (int i = 0; i < fillers.size(); ++i) {
       UniqueFEIRExpr exprIndex = FEIRBuilder::CreateExprConstI32(i);
       UniqueFEIRExpr exprElem = fillers[i]->Emit2FEExpr(stmts);
       UniqueFEIRType typeNativeTmp = typeNative->Clone();
@@ -607,6 +628,23 @@ void ASTInitListExpr::Emit2FEExprForArray(std::list<UniqueFEIRStmt> &stmts) cons
                                                                std::move(exprIndex), std::move(typeNativeTmp));
       stmts.emplace_back(std::move(stmt));
     }
+
+    MIRType *ptrMIRArrayType = typeNative->GenerateMIRType(false);
+    auto allSize = static_cast<MIRArrayType*>(ptrMIRArrayType)->GetSize();
+    auto elemSize = static_cast<MIRArrayType*>(ptrMIRArrayType)->GetElemType()->GetSize();
+    auto allElemCnt = allSize / elemSize;
+    uint32 needInitFurtherCnt = allElemCnt - fillers.size();
+    PrimType elemPrimType = static_cast<MIRArrayType*>(ptrMIRArrayType)->GetElemType()->GetPrimType();
+    for (int i = 0; i < needInitFurtherCnt; ++i) {
+      UniqueFEIRExpr exprIndex = FEIRBuilder::CreateExprConstI32(fillers.size() + i);
+      UniqueFEIRType typeNativeTmp = typeNative->Clone();
+      UniqueFEIRExpr arrayExprTmp = arrayExpr->Clone();
+
+      UniqueFEIRExpr exprElemOther = std::make_unique<FEIRExprConst>(static_cast<int64>(0), elemPrimType);
+      auto stmt = FEIRBuilder::CreateStmtArrayStoreOneStmtForC(std::move(exprElemOther), std::move(arrayExprTmp),
+                                                               std::move(exprIndex), std::move(typeNativeTmp));
+      stmts.emplace_back(std::move(stmt));
+    }
   }
 }
 
@@ -664,6 +702,7 @@ UniqueFEIRExpr ASTStringLiteral::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmt
 
 UniqueFEIRExpr ASTArraySubscriptExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
   std::list<UniqueFEIRExpr> indexExprs;
+  UniqueFEIRExpr arrayStoreForCExpr;
   UniqueFEIRType typeNative = FEIRTypeHelper::CreateTypeNative(*baseExpr->GetType());
   UniqueFEIRExpr baseFEExpr = baseExpr->Emit2FEExpr(stmts);
   for (auto expr : idxExprs) {
@@ -674,11 +713,14 @@ UniqueFEIRExpr ASTArraySubscriptExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt>
     auto memExpr = static_cast<ASTMemberExpr*>(memberExpr)->Emit2FEExpr(stmts);
     auto memType = FEIRTypeHelper::CreateTypeNative(*static_cast<ASTMemberExpr*>(memberExpr)->GetMemberType());
     UniqueFEIRType typeArrayNative = FEIRTypeHelper::CreateTypeNative(*baseExpr->GetType());
-    return FEIRBuilder::CreateExprArrayStoreForC(std::move(memExpr), indexExprs, std::move(memType),
-                                                 std::move(baseFEExpr), std::move(typeNative));
+    arrayStoreForCExpr = FEIRBuilder::CreateExprArrayStoreForC(std::move(memExpr), indexExprs, std::move(memType),
+                                                               std::move(baseFEExpr), std::move(typeNative));
   } else {
-    return FEIRBuilder::CreateExprArrayStoreForC(std::move(baseFEExpr), indexExprs, std::move(typeNative));
+    arrayStoreForCExpr = FEIRBuilder::CreateExprArrayStoreForC(std::move(baseFEExpr), indexExprs,
+                                                               std::move(typeNative));
   }
+  static_cast<FEIRExprArrayStoreForC*>(arrayStoreForCExpr.get())->SetAddrOfFlag(isAddrOf);
+  return arrayStoreForCExpr;
 }
 
 UniqueFEIRExpr ASTExprUnaryExprOrTypeTraitExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
@@ -826,7 +868,7 @@ UniqueFEIRExpr ASTFloatingLiteral::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &st
 
 // ---------- ASTCharacterLiteral ----------
 UniqueFEIRExpr ASTCharacterLiteral::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
-  UniqueFEIRExpr constExpr = FEIRBuilder::CreateExprConstI8(val);
+  UniqueFEIRExpr constExpr = FEIRBuilder::CreateExprConstAnyScalar(type, val);
   return constExpr;
 }
 
diff --git a/src/mplfe/ast_input/src/ast_parser.cpp b/src/mplfe/ast_input/src/ast_parser.cpp
index 16ee1dad626c5452cf57e64744b12e4f821728be..6b9a0dcfe4d7ef8ba6fb1ed4f0e867efd769d71a 100644
--- a/src/mplfe/ast_input/src/ast_parser.cpp
+++ b/src/mplfe/ast_input/src/ast_parser.cpp
@@ -631,9 +631,13 @@ const clang::Expr *ASTParser::PeelParen(const clang::Expr &expr) {
   const clang::Expr *exprPtr = &expr;
   while (llvm::isa<clang::ParenExpr>(exprPtr) ||
          (llvm::isa<clang::UnaryOperator>(exprPtr) &&
-          llvm::cast<clang::UnaryOperator>(exprPtr)->getOpcode() == clang::UO_Extension)) {
+          llvm::cast<clang::UnaryOperator>(exprPtr)->getOpcode() == clang::UO_Extension) ||
+         (llvm::isa<clang::ImplicitCastExpr>(exprPtr) &&
+          llvm::cast<clang::ImplicitCastExpr>(exprPtr)->getCastKind() == clang::CK_LValueToRValue)) {
     if (llvm::isa<clang::ParenExpr>(exprPtr)) {
       exprPtr = llvm::cast<clang::ParenExpr>(exprPtr)->getSubExpr();
+    } else if (llvm::isa<clang::ImplicitCastExpr>(exprPtr)) {
+      exprPtr = llvm::cast<clang::ImplicitCastExpr>(exprPtr)->getSubExpr();
     } else {
       exprPtr = llvm::cast<clang::UnaryOperator>(exprPtr)->getSubExpr();
     }
@@ -1120,7 +1124,27 @@ ASTExpr *ASTParser::ProcessExprCharacterLiteral(MapleAllocator &allocator, const
   if (qualType->isPromotableIntegerType()) {
     kind = clang::BuiltinType::Int;
   }
+  PrimType primType = PTY_i32;
+  switch (kind) {
+    case clang::BuiltinType::UInt:
+      primType = PTY_u32;
+      break;
+    case clang::BuiltinType::Int:
+      primType = PTY_i32;
+      break;
+    case clang::BuiltinType::ULong:
+    case clang::BuiltinType::ULongLong:
+      primType = PTY_u64;
+      break;
+    case clang::BuiltinType::Long:
+    case clang::BuiltinType::LongLong:
+      primType = PTY_i64;
+      break;
+    default:
+      break;
+  }
   astCharacterLiteral->SetVal(expr.getValue());
+  astCharacterLiteral->SetPrimType(primType);
   return astCharacterLiteral;
 }
 
@@ -1173,6 +1197,8 @@ ASTExpr *ASTParser::ProcessExprImplicitCastExpr(MapleAllocator &allocator, const
     case clang::CK_FunctionToPointerDecay:
     case clang::CK_LValueToRValue:
     case clang::CK_BitCast:
+    case clang::CK_NullToPointer:
+    case clang::CK_IntegralToPointer:
       break;
     case clang::CK_BuiltinFnToFnPtr:
       astImplicitCastExpr->SetBuilinFunc(true);
@@ -1181,6 +1207,7 @@ ASTExpr *ASTParser::ProcessExprImplicitCastExpr(MapleAllocator &allocator, const
     case clang::CK_IntegralToFloating:
     case clang::CK_FloatingCast:
     case clang::CK_IntegralCast:
+    case clang::CK_IntegralToBoolean:
       astImplicitCastExpr->SetSrcType(astFile->CvtType(expr.getSubExpr()->getType()));
       astImplicitCastExpr->SetDstType(astFile->CvtType(expr.getType()));
       astImplicitCastExpr->SetNeededCvt(true);
diff --git a/src/mplfe/common/include/feir_stmt.h b/src/mplfe/common/include/feir_stmt.h
index 69f048a6b6f2f8b60602a5be8daed19db415e2d9..7636abc159838085b53acf80cde5b6f899e24597 100644
--- a/src/mplfe/common/include/feir_stmt.h
+++ b/src/mplfe/common/include/feir_stmt.h
@@ -486,12 +486,23 @@ class FEIRExprAddrofVar : public FEIRExpr {
       : FEIRExpr(FEIRNodeKind::kExprAddrofVar), varSrc(std::move(argVarSrc)) {}
   ~FEIRExprAddrofVar() = default;
 
+  void SetFieldName(const std::string &argFieldName) {
+    fieldName = argFieldName;
+  }
+
+  void SetFieldType(MIRType *type) {
+    fieldType = type;
+  }
+
  protected:
   std::unique_ptr<FEIRExpr> CloneImpl() const override;
   BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
 
  private:
   std::unique_ptr<FEIRVar> varSrc;
+  FieldID fieldID = 0;
+  std::string fieldName;
+  MIRType *fieldType = nullptr;
 };
 
 class FEIRExprAddrofFunc : public FEIRExpr {
@@ -512,6 +523,7 @@ class FEIRExprAddrofFunc : public FEIRExpr {
 class FEIRExprUnary : public FEIRExpr {
  public:
   FEIRExprUnary(Opcode argOp, std::unique_ptr<FEIRExpr> argOpnd);
+  FEIRExprUnary(Opcode argOp, MIRType *type, std::unique_ptr<FEIRExpr> argOpnd);
   FEIRExprUnary(std::unique_ptr<FEIRType> argType, Opcode argOp, std::unique_ptr<FEIRExpr> argOpnd);
   ~FEIRExprUnary() = default;
   void SetOpnd(std::unique_ptr<FEIRExpr> argOpnd);
@@ -526,9 +538,11 @@ class FEIRExprUnary : public FEIRExpr {
 
   Opcode op;
   std::unique_ptr<FEIRExpr> opnd;
+  std::unique_ptr<FEIRVar> var;
 
  private:
   void SetExprTypeByOp();
+  MIRType *subType = nullptr;
 
   static std::map<Opcode, bool> mapOpNestable;
 };  // class FEIRExprUnary
@@ -909,6 +923,10 @@ class FEIRExprArrayStoreForC : public FEIRExpr {
     return typeNativeStruct != nullptr;
   }
 
+  void SetAddrOfFlag(bool flag) {
+    isAddrOf = flag;
+  }
+
  protected:
   std::unique_ptr<FEIRExpr> CloneImpl() const override;
   BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
@@ -918,6 +936,7 @@ class FEIRExprArrayStoreForC : public FEIRExpr {
   UniqueFEIRExpr exprArray;
   mutable std::list<UniqueFEIRExpr> exprIndexs;
   UniqueFEIRType typeNative = nullptr;
+  bool isAddrOf = false;
 
   // for array in struct
   UniqueFEIRExpr exprStruct = nullptr;
diff --git a/src/mplfe/common/src/feir_stmt.cpp b/src/mplfe/common/src/feir_stmt.cpp
index 964c9a5ab815b7cba7f440cce2f6b2399f44523b..e1f53f66dc3ec83214e1fa0602f70b403381b873 100644
--- a/src/mplfe/common/src/feir_stmt.cpp
+++ b/src/mplfe/common/src/feir_stmt.cpp
@@ -1164,9 +1164,6 @@ std::list<StmtNode*> FEIRStmtArrayStore::GenMIRStmtsImpl(MIRBuilder &mirBuilder)
   CHECK_FATAL(((exprIndex == nullptr) && (exprIndexs.size() != 0))||
               (exprIndex->GetKind() == kExprDRead) ||
               (exprIndex->GetKind() == kExprConst), "only support dread/const expr for exprIndex");
-  CHECK_FATAL(exprElem == nullptr || exprElem->GetKind() == kExprUnary ||
-              (exprElem->GetKind() == kExprDRead) ||
-              (exprElem->GetKind() == kExprConst), "only support dread/const expr for exprElem");
   MIRType *ptrMIRArrayType = typeArray->GenerateMIRType(false);
   BaseNode *arrayExpr = nullptr;
   MIRType *mIRElemType = nullptr;
@@ -2213,7 +2210,17 @@ std::unique_ptr<FEIRExpr> FEIRExprAddrofVar::CloneImpl() const {
 
 BaseNode *FEIRExprAddrofVar::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
   MIRSymbol *varSymbol = varSrc->GenerateMIRSymbol(mirBuilder);
-  return mirBuilder.CreateExprAddrof(0, *varSymbol);
+  MIRType *type = varSrc->GetType()->GenerateMIRTypeAuto();
+  AddrofNode *node = mirBuilder.CreateExprAddrof(fieldID, *varSymbol);
+  if ((type->IsMIRStructType() || type->GetKind() == MIRTypeKind::kTypeUnion) &&
+      (!fieldName.empty() || (fieldID != 0))) {
+    FieldID fieldIdVar = fieldID;
+    if (fieldIdVar == 0) {
+      fieldIdVar = mirBuilder.GetStructFieldIDFromFieldName(*type, fieldName);
+    }
+    node = mirBuilder.CreateExprAddrof(fieldIdVar, *varSymbol);
+  }
+  return node;
 }
 
 // ---------- FEIRExprAddrofFunc ----------
@@ -2271,6 +2278,14 @@ FEIRExprUnary::FEIRExprUnary(std::unique_ptr<FEIRType> argType, Opcode argOp, st
   SetExprTypeByOp();
 }
 
+FEIRExprUnary::FEIRExprUnary(Opcode argOp, MIRType *type, std::unique_ptr<FEIRExpr> argOpnd)
+    : FEIRExpr(kExprUnary),
+      op(argOp),
+      subType(type) {
+  SetOpnd(std::move(argOpnd));
+  SetExprTypeByOp();
+}
+
 std::map<Opcode, bool> FEIRExprUnary::InitMapOpNestableForExprUnary() {
   std::map<Opcode, bool> ans;
   ans[OP_abs] = true;
@@ -2289,8 +2304,12 @@ std::unique_ptr<FEIRExpr> FEIRExprUnary::CloneImpl() const {
 }
 
 BaseNode *FEIRExprUnary::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
-  MIRType *mirType =
-      GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(static_cast<uint32>(GetTypeRef().GetPrimType())));
+  MIRType *mirType = nullptr;
+  if (subType == nullptr) {
+    mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(static_cast<uint32>(GetTypeRef().GetPrimType())));
+  } else {
+    mirType = subType;
+  }
   ASSERT(mirType != nullptr, "mir type is nullptr");
   BaseNode *nodeOpnd = opnd->GenMIRNode(mirBuilder);
   BaseNode *expr = mirBuilder.CreateExprUnary(op, *mirType, nodeOpnd);
@@ -2638,7 +2657,14 @@ BaseNode *FEIRExprBinary::GenMIRNodeCompareU1(MIRBuilder &mirBuilder) const {
   CHECK_FATAL(nodeOpnd0->GetPrimType() == nodeOpnd1->GetPrimType(), "primtype of opnds must be the same");
   MIRType *mirTypeSrc = GlobalTables::GetTypeTable().GetTypeFromTyIdx(
       TyIdx(static_cast<uint32>(nodeOpnd0->GetPrimType())));
-  MIRType *mirTypeU1 = GlobalTables::GetTypeTable().GetUInt1();
+  // When the int32 is used to process Java, an error will be reported during the verification.
+  // The verification will need to be updated later.
+  MIRType *mirTypeU1;
+  if (mirBuilder.GetMirModule().GetSrcLang() == kSrcLangC) {
+    mirTypeU1 = GlobalTables::GetTypeTable().GetInt32();
+  } else {
+    mirTypeU1 = GlobalTables::GetTypeTable().GetUInt1();
+  }
   BaseNode *expr = mirBuilder.CreateExprCompare(op, *mirTypeU1, *mirTypeSrc, nodeOpnd0, nodeOpnd1);
   return expr;
 }
@@ -2716,11 +2742,7 @@ void FEIRExprBinary::SetExprTypeByOpLogic() {
 }
 
 void FEIRExprBinary::SetExprTypeByOpCompare() {
-  if (op == OP_cmp || op == OP_cmpl || op == OP_cmpg) {
-    type->SetPrimType(PTY_i32);
-  } else {
-    type->SetPrimType(PTY_u1);
-  }
+  type->SetPrimType(PTY_i32);
 }
 
 // ---------- FEIRExprTernary ----------
@@ -3154,6 +3176,9 @@ BaseNode *FEIRExprArrayStoreForC::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
     nds.push_back(no);
   }
   BaseNode *arrayExpr = mirBuilder.CreateExprArray(*ptrMIRArrayType, nds);
+  if (isAddrOf) {
+    return arrayExpr;
+  }
   UniqueFEIRType typeElem =
       std::make_unique<FEIRTypeNative>(*static_cast<MIRArrayType*>(ptrMIRArrayType)->GetElemType());
   MIRType *mirElemType = typeElem->GenerateMIRType(true);
@@ -3171,7 +3196,11 @@ std::unique_ptr<FEIRExpr> FEIRExprArrayStoreForC::CloneImpl() const {
 PrimType FEIRExprArrayStoreForC::GetPrimTypeImpl() const {
   CHECK_NULL_FATAL(typeNative);
   MIRType *ptrMIRArrayType = typeNative->GenerateMIRType(false);
-  return static_cast<MIRArrayType*>(ptrMIRArrayType)->GetElemType()->GetPrimType();
+  if (isAddrOf) {
+    return PTY_ptr;
+  } else {
+    return static_cast<MIRArrayType*>(ptrMIRArrayType)->GetElemType()->GetPrimType();
+  }
 }
 
 // ---------- FEIRExprArrayLoad ----------
diff --git a/src/mrt/deplibs/libmplandroid.so b/src/mrt/deplibs/libmplandroid.so
index 69ce02e3388c0780bc66cfed65f426cc7e61ec6c..48552d4c7d630b5a718984b1cd2a20c40f042154 100755
Binary files a/src/mrt/deplibs/libmplandroid.so and b/src/mrt/deplibs/libmplandroid.so differ