diff --git a/src/mapleall/maple_be/include/cg/proepilog.h b/src/mapleall/maple_be/include/cg/proepilog.h
index 445dcb3b268918f3ee27ce99652d046c9195af75..094986dd19a1b650ced4257d6c4375cc7edc67c1 100644
--- a/src/mapleall/maple_be/include/cg/proepilog.h
+++ b/src/mapleall/maple_be/include/cg/proepilog.h
@@ -39,8 +39,6 @@ class GenProEpilog {
     return true;
   }
 
-
-
   /* CFI related routines */
   int64 GetOffsetFromCFA() const {
     return offsetFromCfa;
@@ -62,4 +60,4 @@ class GenProEpilog {
 CGFUNCPHASE(CgDoGenProEpiLog, "generateproepilog")
 }  /* namespace maplebe */
 
-#endif  /* MAPLEBE_INCLUDE_CG_PROEPILOG_H */
+#endif  /* MAPLEBE_INCLUDE_CG_PROEPILOG_H */
\ No newline at end of file
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 45bbe7ff2ee4cc39286d78b9ad63b026e120dc12..42fb4c66ec055b4f2c5d0bf4dc6d04c37f1069a6 100644
--- a/src/mapleall/maple_be/src/cg/aarch64/aarch64_proepilog.cpp
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_proepilog.cpp
@@ -214,7 +214,7 @@ bool AArch64GenProEpilog::NeedProEpilog() {
   if (cgFunc.GetMirModule().GetSrcLang() != kSrcLangC) {
     return true;
   } else if (static_cast<AArch64MemLayout *>(cgFunc.GetMemlayout())->GetSizeOfLocals() > 0 ||
-       cgFunc.GetFunction().GetAttr(FUNCATTR_varargs) || cgFunc.HasVLAOrAlloca()) {
+             cgFunc.GetFunction().GetAttr(FUNCATTR_varargs) || cgFunc.HasVLAOrAlloca()) {
     return true;
   }
   auto &aarchCGFunc = static_cast<AArch64CGFunc&>(cgFunc);
diff --git a/src/mapleall/maple_be/src/cg/emit.cpp b/src/mapleall/maple_be/src/cg/emit.cpp
index 46f16dbb1a849edabb7f6833c76d3d2f4fe2ae50..d89ca5e8266b6a9cbb95f8760459adb5fff8063b 100644
--- a/src/mapleall/maple_be/src/cg/emit.cpp
+++ b/src/mapleall/maple_be/src/cg/emit.cpp
@@ -419,6 +419,11 @@ void Emitter::EmitBitFieldConstant(StructEmitInfo &structEmitInfo, MIRConst &mir
   if (fieldSize < fieldValue.GetBitWidth()) {
     fieldValue.Trunc(fieldSize);
   }
+  /* Clear higher Bits for signed value  */
+  if (structEmitInfo.GetCombineBitFieldValue() != 0) {
+    structEmitInfo.SetCombineBitFieldValue((~(~0ULL << structEmitInfo.GetCombineBitFieldWidth())) &
+                                           structEmitInfo.GetCombineBitFieldValue());
+  }
   structEmitInfo.SetCombineBitFieldValue(
       (static_cast<uint64>(fieldValue.GetValue()) << structEmitInfo.GetCombineBitFieldWidth()) +
       structEmitInfo.GetCombineBitFieldValue());
diff --git a/src/mplfe/BUILD.gn b/src/mplfe/BUILD.gn
index bd674d1fd3395a887de98f38d29d999eb6aa25c2..44d4a9d8d7fe546ec0776cf98e9f404a47374fc6 100644
--- a/src/mplfe/BUILD.gn
+++ b/src/mplfe/BUILD.gn
@@ -298,6 +298,7 @@ static_library("lib_mplfe_ast_input") {
     "${MPLFE_ROOT}/ast_input/src/ast_function.cpp",
     "${MPLFE_ROOT}/ast_input/src/ast_input.cpp",
     "${MPLFE_ROOT}/ast_input/src/ast_parser.cpp",
+    "${MPLFE_ROOT}/ast_input/src/ast_parser_builting_func.cpp",
     "${MPLFE_ROOT}/ast_input/src/ast_struct2fe_helper.cpp",
     "${MPLFE_ROOT}/ast_input/lib/ast_type.cpp",
     "${MPLFE_ROOT}/ast_input/lib/ast_util.cpp",
diff --git a/src/mplfe/ast_input/include/ast_parser.h b/src/mplfe/ast_input/include/ast_parser.h
index 5d167b6b5a1dce65195fa4895e05c1d16732b7f9..bd9884557ea6395258b63254fa1e822348b8b5a4 100644
--- a/src/mplfe/ast_input/include/ast_parser.h
+++ b/src/mplfe/ast_input/include/ast_parser.h
@@ -154,6 +154,18 @@ class ASTParser {
   uint32_t GetAlignOfType(const clang::QualType currQualType, clang::UnaryExprOrTypeTrait exprKind);
   uint32_t GetAlignOfExpr(const clang::Expr &expr, clang::UnaryExprOrTypeTrait exprKind);
   ASTExpr *ProcessExprBinaryOperatorComplex(MapleAllocator &allocator, const clang::BinaryOperator &bo);
+  using ParseBuiltinFunc = ASTExpr *(ASTParser::*)(MapleAllocator &allocator, const clang::CallExpr &expr) const;
+  static std::map<std::string, ParseBuiltinFunc> InitFuncPtrMap();
+  ASTExpr *ParseBuiltingClassifyType(MapleAllocator &allocator, const clang::CallExpr &expr) const;
+  ASTExpr *ParseBuiltingCtz(MapleAllocator &allocator, const clang::CallExpr &expr) const;
+  ASTExpr *ParseBuiltingClz(MapleAllocator &allocator, const clang::CallExpr &expr) const;
+  ASTExpr *ParseBuiltingAlloca(MapleAllocator &allocator, const clang::CallExpr &expr) const;
+  ASTExpr *ParseBuiltingConstantP(MapleAllocator &allocator, const clang::CallExpr &expr) const;
+  ASTExpr *ParseBuiltingExpect(MapleAllocator &allocator, const clang::CallExpr &expr) const;
+  ASTExpr *ParseBuiltingSignbit(MapleAllocator &allocator, const clang::CallExpr &expr) const;
+  ASTExpr *ParseBuiltingIsinfSign(MapleAllocator &allocator, const clang::CallExpr &expr) const;
+
+  static std::map<std::string, ParseBuiltinFunc> builtingFuncPtrMap;
   uint32 fileIdx;
   const std::string fileName;
   std::unique_ptr<LibAstFile> astFile;
diff --git a/src/mplfe/ast_input/src/ast_expr.cpp b/src/mplfe/ast_input/src/ast_expr.cpp
index 4f19b49916cd6ee30372ff3eecf1e56d99e30a6a..3450698dd3f8ddf6d5451ea0b4b1a0839acb90bb 100644
--- a/src/mplfe/ast_input/src/ast_expr.cpp
+++ b/src/mplfe/ast_input/src/ast_expr.cpp
@@ -338,6 +338,9 @@ UniqueFEIRExpr ASTImplicitCastExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &s
   UniqueFEIRExpr subExpr = childExpr->Emit2FEExpr(stmts);
   if (complexType == nullptr) {
     if (IsNeededCvt(subExpr)) {
+      if (IsPrimitiveFloat(subExpr->GetPrimType()) && IsPrimitiveInteger(dst->GetPrimType())) {
+        return FEIRBuilder::CreateExprCvtPrim(OP_trunc, std::move(subExpr), dst->GetPrimType());
+      }
       return FEIRBuilder::CreateExprCvtPrim(std::move(subExpr), dst->GetPrimType());
     }
   } else {
@@ -1070,7 +1073,16 @@ UniqueFEIRExpr ASTArraySubscriptExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt>
   std::list<UniqueFEIRExpr> indexExprs;
   UniqueFEIRExpr arrayStoreForCExpr;
   UniqueFEIRType typeNative = FEIRTypeHelper::CreateTypeNative(*baseExpr->GetType());
-  UniqueFEIRExpr baseFEExpr = baseExpr->Emit2FEExpr(stmts);
+  UniqueFEIRExpr baseFEExpr;
+  if (baseExpr->GetASTOp() == kASTStringLiteral) {
+    UniqueFEIRVar unamedVar = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("unamedstr_"),
+                                                             *baseExpr->GetType(), true, false);
+    baseFEExpr = FEIRBuilder::CreateExprAddrofVar(std::move(unamedVar));
+    FEIRExprAddrofVar *addrofVarExpr = static_cast<FEIRExprAddrofVar*>(baseFEExpr.get());
+    addrofVarExpr->SetVarValue(baseExpr->GenerateMIRConst());
+  } else {
+    baseFEExpr = baseExpr->Emit2FEExpr(stmts);
+  }
   for (auto expr : idxExprs) {
     UniqueFEIRExpr feirExpr = expr->Emit2FEExpr(stmts);
     indexExprs.emplace_front(std::move(feirExpr));
diff --git a/src/mplfe/ast_input/src/ast_parser.cpp b/src/mplfe/ast_input/src/ast_parser.cpp
index ec29e60d43ecb470db9d441c9591b368b12891b6..bb9a0a79fa2bbcffc5776b736635830d30774de3 100644
--- a/src/mplfe/ast_input/src/ast_parser.cpp
+++ b/src/mplfe/ast_input/src/ast_parser.cpp
@@ -1218,6 +1218,8 @@ ASTExpr *ASTParser::ProcessExprImaginaryLiteral(MapleAllocator &allocator, const
   return astImaginaryLiteral;
 }
 
+std::map<std::string, ASTParser::ParseBuiltinFunc> ASTParser::builtingFuncPtrMap = ASTParser::InitFuncPtrMap();
+
 ASTExpr *ASTParser::ProcessExprCallExpr(MapleAllocator &allocator, const clang::CallExpr &expr) {
   ASTCallExpr *astCallExpr = ASTDeclsBuilder::ASTExprBuilder<ASTCallExpr>(allocator);
   ASSERT(astCallExpr != nullptr, "astCallExpr is nullptr");
@@ -1246,6 +1248,10 @@ ASTExpr *ASTParser::ProcessExprCallExpr(MapleAllocator &allocator, const clang::
     if (!ASTUtil::IsValidName(funcName)) {
       ASTUtil::AdjustName(funcName);
     }
+    auto ptrFunc = builtingFuncPtrMap.find(funcName);
+    if (ptrFunc != builtingFuncPtrMap.end()) {
+      return (this->*(ptrFunc->second))(allocator, expr);
+    }
     astCallExpr->SetFuncName(funcName);
     GenericAttrs attrs;
     astFile->CollectFuncAttrs(*funcDecl, attrs, kPublic);
diff --git a/src/mplfe/ast_input/src/ast_parser_builting_func.cpp b/src/mplfe/ast_input/src/ast_parser_builting_func.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..f6654b4ae14bffdb39417d6406a6557246f65358
--- /dev/null
+++ b/src/mplfe/ast_input/src/ast_parser_builting_func.cpp
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) [2020-2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL2
+ *
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND, EITHER
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT, MERCHANTABILITY OR
+ * FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+#include "ast_parser.h"
+#include "mpl_logging.h"
+#include "mir_module.h"
+#include "mpl_logging.h"
+#include "ast_decl_builder.h"
+#include "ast_interface.h"
+#include "ast_decl.h"
+#include "ast_macros.h"
+#include "ast_util.h"
+#include "ast_input.h"
+#include "fe_manager.h"
+
+namespace maple {
+std::map<std::string, ASTParser::ParseBuiltinFunc> ASTParser::InitFuncPtrMap() {
+  std::map<std::string, ParseBuiltinFunc> ans;
+  ans["__builtin_classify_type"] = &ASTParser::ParseBuiltingClassifyType;
+  ans["__builtin_ctz"] = &ASTParser::ParseBuiltingCtz;
+  ans["__builtin_clz"] = &ASTParser::ParseBuiltingClz;
+  ans["__builtin_alloca"] = &ASTParser::ParseBuiltingAlloca;
+  ans["__builtin_constant_p"] = &ASTParser::ParseBuiltingConstantP;
+  ans["__builtin_expect"] = &ASTParser::ParseBuiltingExpect;
+  ans["__builtin_signbit"] = &ASTParser::ParseBuiltingSignbit;
+  ans["__builtin_isinf_sign"] = &ASTParser::ParseBuiltingIsinfSign;
+  return ans;
+}
+
+ASTExpr *ASTParser::ParseBuiltingClassifyType(MapleAllocator &allocator, const clang::CallExpr &expr) const {
+  clang::Expr::EvalResult res;
+  bool success = expr.EvaluateAsInt(res, *(astFile->GetContext()));
+  CHECK_FATAL(success, "Failed to evaluate __builtin_classify_type");
+  llvm::APSInt apVal = res.Val.getInt();
+  ASTIntegerLiteral *astIntegerLiteral = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
+  astIntegerLiteral->SetVal(static_cast<uint64>(apVal.getExtValue()));
+  astIntegerLiteral->SetType(PTY_i32);
+  return astIntegerLiteral;
+}
+
+ASTExpr *ASTParser::ParseBuiltingCtz(MapleAllocator &allocator, const clang::CallExpr &expr) const {
+  return nullptr;
+}
+
+ASTExpr *ASTParser::ParseBuiltingClz(MapleAllocator &allocator, const clang::CallExpr &expr) const {
+  return nullptr;
+}
+
+ASTExpr *ASTParser::ParseBuiltingAlloca(MapleAllocator &allocator, const clang::CallExpr &expr) const {
+  return nullptr;
+}
+
+ASTExpr *ASTParser::ParseBuiltingConstantP(MapleAllocator &allocator, const clang::CallExpr &expr) const {
+  return nullptr;
+}
+
+ASTExpr *ASTParser::ParseBuiltingExpect(MapleAllocator &allocator, const clang::CallExpr &expr) const {
+  return nullptr;
+}
+
+ASTExpr *ASTParser::ParseBuiltingSignbit(MapleAllocator &allocator, const clang::CallExpr &expr) const {
+  return nullptr;
+}
+
+ASTExpr *ASTParser::ParseBuiltingIsinfSign(MapleAllocator &allocator, const clang::CallExpr &expr) const {
+  return nullptr;
+}
+} // namespace maple
\ No newline at end of file
diff --git a/src/mplfe/common/include/feir_stmt.h b/src/mplfe/common/include/feir_stmt.h
index 2311a6c0e60d08e9fcb79333dfafcb36981e41c3..1e77ea0107f49a5137bad15aa9c7428518153661 100644
--- a/src/mplfe/common/include/feir_stmt.h
+++ b/src/mplfe/common/include/feir_stmt.h
@@ -515,6 +515,14 @@ class FEIRExprAddrofVar : public FEIRExpr {
     fieldID = id;
   }
 
+  void SetVarValue(MIRConst *val) {
+    cst = val;
+  }
+
+  MIRConst *GetVarValue() const {
+    return cst;
+  }
+
  protected:
   std::unique_ptr<FEIRExpr> CloneImpl() const override;
   BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
@@ -525,6 +533,7 @@ class FEIRExprAddrofVar : public FEIRExpr {
   FieldID fieldID = 0;
   std::string fieldName;
   MIRType *fieldType = nullptr;
+  MIRConst *cst = nullptr;
 };
 
 // ---------- FEIRExprIAddrof ----------
diff --git a/src/mplfe/common/src/feir_stmt.cpp b/src/mplfe/common/src/feir_stmt.cpp
index 4df9fc977d96faa3d13f8a758a1b5c57388b8b21..bebf62418b7353645243e6ac98ec4824764f5c7b 100644
--- a/src/mplfe/common/src/feir_stmt.cpp
+++ b/src/mplfe/common/src/feir_stmt.cpp
@@ -2360,6 +2360,9 @@ std::unique_ptr<FEIRExpr> FEIRExprAddrofVar::CloneImpl() const {
 
 BaseNode *FEIRExprAddrofVar::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
   MIRSymbol *varSymbol = varSrc->GenerateMIRSymbol(mirBuilder);
+  if (cst != nullptr) {
+    varSymbol->SetKonst(cst);
+  }
   MIRType *type = varSrc->GetType()->GenerateMIRTypeAuto();
   AddrofNode *node = mirBuilder.CreateExprAddrof(fieldID, *varSymbol);
   FieldID fieldID = this->fieldID;
@@ -3370,6 +3373,9 @@ BaseNode *FEIRExprArrayStoreForC::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
   if (mirtype->GetKind() == kTypePointer) {
     nodeAddrof = exprArray->GenMIRNode(mirBuilder);
   } else {
+    if (mirSymbol->GetKonst() == nullptr && exprArray->GetKind() == kExprAddrofVar) {
+      mirSymbol->SetKonst(static_cast<FEIRExprAddrofVar*>(exprArray.get())->GetVarValue());
+    }
     nodeAddrof = mirBuilder.CreateExprAddrof(fieldID, *mirSymbol);
   }
   nds.push_back(nodeAddrof);
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