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 6ac641001a7e4240d78b3a908b5f530b98885154..e1ad3fe679de0a5367451b847bd6f4b859d2421b 100644
--- a/src/mapleall/maple_be/src/cg/aarch64/aarch64_ebo.cpp
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_ebo.cpp
@@ -293,7 +293,7 @@ bool AArch64Ebo::DoConstProp(Insn &insn, uint32 idx, Operand &opnd) {
         CHECK_FATAL(src != nullptr, "pointer result is null");
         src->SetSize(targetSize);
       }
-      if (src->IsSingleInstructionMovable()) {
+      if (src->IsSingleInstructionMovable() && (insn.GetOperand(kInsnFirstOpnd).GetSize() == targetSize)) {
         if (EBO_DUMP) {
           LogInfo::MapleLogger() << " Do constprop:Prop constval " << src->GetValue() << "into insn:\n";
           insn.Dump();
diff --git a/src/mplfe/ast_input/include/ast_expr.h b/src/mplfe/ast_input/include/ast_expr.h
index 02947e5f099c5eb48df36fc2cbe5b8b2121b6d5f..beb8d31211faf689a0e5d20e92e02ac0c2cd3c68 100644
--- a/src/mplfe/ast_input/include/ast_expr.h
+++ b/src/mplfe/ast_input/include/ast_expr.h
@@ -616,6 +616,7 @@ class ASTBinaryOperatorExpr : public ASTExpr {
   }
 
  protected:
+  MIRConst *GenerateMIRConstImpl() const override;
   UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
 
   Opcode opcode;
@@ -941,7 +942,14 @@ class ASTCallExpr : public ASTExpr {
     return isIcall;
   }
 
+  bool IsNeedRetExpr() const {
+    return retType->GetPrimType() != PTY_void;
+  }
+
   std::string CvtBuiltInFuncName(std::string builtInName) const;
+  std::unique_ptr<FEIRStmtAssign> GenCallStmt() const;
+  void AddArgsExpr(std::unique_ptr<FEIRStmtAssign> &callStmt, std::list<UniqueFEIRStmt> &stmts) const;
+  UniqueFEIRExpr AddRetExpr(std::unique_ptr<FEIRStmtAssign> &callStmt, std::list<UniqueFEIRStmt> &stmts) const;
 
  private:
   using FuncPtrBuiltinFunc = UniqueFEIRExpr (ASTCallExpr::*)(std::list<UniqueFEIRStmt> &stmts) const;
@@ -954,8 +962,6 @@ class ASTCallExpr : public ASTExpr {
   UniqueFEIRExpr EMIT_BUILTIIN_FUNC(Expect);
 
   UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
-  UniqueFEIRExpr Emit2FEExprCall(std::list<UniqueFEIRStmt> &stmts) const;
-  UniqueFEIRExpr Emit2FEExprICall(std::list<UniqueFEIRStmt> &stmts) const;
 
   static std::map<std::string, FuncPtrBuiltinFunc> builtingFuncPtrMap;
   std::vector<ASTExpr*> args;
@@ -998,6 +1004,9 @@ class ASTIntegerLiteral : public ASTExpr {
     type = pType;
   }
 
+ protected:
+  MIRConst *GenerateMIRConstImpl() const override;
+
  private:
   UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
 
diff --git a/src/mplfe/ast_input/include/ast_stmt.h b/src/mplfe/ast_input/include/ast_stmt.h
index 9c9e25a026e2440fa6e4678d21ebb62557f7e20e..a1d441b52d5ffcc58c1a18e6dd680f478b41c1d6 100644
--- a/src/mplfe/ast_input/include/ast_stmt.h
+++ b/src/mplfe/ast_input/include/ast_stmt.h
@@ -505,8 +505,6 @@ class ASTCallExprStmt : public ASTStmt {
   using FuncPtrBuiltinFunc = std::list<UniqueFEIRStmt> (ASTCallExprStmt::*)() const;
   static std::map<std::string, FuncPtrBuiltinFunc> InitFuncPtrMap();
   std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
-  std::list<UniqueFEIRStmt> Emit2FEStmtCall() const;
-  std::list<UniqueFEIRStmt> Emit2FEStmtICall() const;
   std::list<UniqueFEIRStmt> ProcessBuiltinVaStart() const;
   std::list<UniqueFEIRStmt> ProcessBuiltinVaEnd() const;
   std::list<UniqueFEIRStmt> ProcessBuiltinVaCopy() const;
diff --git a/src/mplfe/ast_input/src/ast_expr.cpp b/src/mplfe/ast_input/src/ast_expr.cpp
index 804198fc763061ccd9c2e53869fc58738d4af42a..44569e78642e4c1b33e13713a3096e5161a5d4d9 100644
--- a/src/mplfe/ast_input/src/ast_expr.cpp
+++ b/src/mplfe/ast_input/src/ast_expr.cpp
@@ -176,75 +176,66 @@ std::string ASTCallExpr::CvtBuiltInFuncName(std::string builtInName) const {
   }
 }
 
-UniqueFEIRExpr ASTCallExpr::Emit2FEExprCall(std::list<UniqueFEIRStmt> &stmts) const {
-  // callassigned &funcName
-  StructElemNameIdx *nameIdx = FEManager::GetManager().GetStructElemMempool()->New<StructElemNameIdx>(funcName);
-  FEStructMethodInfo *info = static_cast<FEStructMethodInfo*>(
-      FEManager::GetTypeManager().RegisterStructMethodInfo(*nameIdx, kSrcLangC, false));
-  Opcode op;
-  if (retType->GetPrimType() != PTY_void) {
-    op = OP_callassigned;
-  } else {
-    op = OP_call;
-  }
-  std::unique_ptr<FEIRStmtCallAssign> callStmt = std::make_unique<FEIRStmtCallAssign>(*info, op, nullptr, false);
-  // args
+std::map<std::string, ASTCallExpr::FuncPtrBuiltinFunc> ASTCallExpr::builtingFuncPtrMap =
+     ASTCallExpr::InitBuiltinFuncPtrMap();
+
+void ASTCallExpr::AddArgsExpr(std::unique_ptr<FEIRStmtAssign> &callStmt, std::list<UniqueFEIRStmt> &stmts) const {
   for (int32 i = args.size() - 1; i >= 0; --i) {
     UniqueFEIRExpr expr = args[i]->Emit2FEExpr(stmts);
     callStmt->AddExprArgReverse(std::move(expr));
   }
-  // attrs
-  info->SetFuncAttrs(funcAttrs);
-  // return
-  FEIRTypeNative *retTypeInfo = FEManager::GetManager().GetModule().GetMemPool()->New<FEIRTypeNative>(*retType);
-  info->SetReturnType(retTypeInfo);
-  if (retType->GetPrimType() != PTY_void) {
-    UniqueFEIRVar var = FEIRBuilder::CreateVarNameForC(varName, *retType, false, false);
-    UniqueFEIRVar dreadVar = var->Clone();
-    callStmt->SetVar(std::move(var));
-    stmts.emplace_back(std::move(callStmt));
-    return FEIRBuilder::CreateExprDRead(std::move(dreadVar));
+  if (isIcall) {
+    UniqueFEIRExpr expr = calleeExpr->Emit2FEExpr(stmts);
+    callStmt->AddExprArgReverse(std::move(expr));
   }
-  stmts.emplace_back(std::move(callStmt));
-  return nullptr;
 }
 
-UniqueFEIRExpr ASTCallExpr::Emit2FEExprICall(std::list<UniqueFEIRStmt> &stmts) const {
-  std::unique_ptr<FEIRStmtICallAssign> icallStmt = std::make_unique<FEIRStmtICallAssign>();
-  CHECK_NULL_FATAL(calleeExpr);
-  // args
-  for (int32 i = args.size() - 1; i >= 0; --i) {
-    UniqueFEIRExpr exprArg = args[i]->Emit2FEExpr(stmts);
-    icallStmt->AddExprArgReverse(std::move(exprArg));
-  }
-  UniqueFEIRExpr expr = calleeExpr->Emit2FEExpr(stmts);
-  icallStmt->AddExprArgReverse(std::move(expr));
-  // return
-  if (retType->GetPrimType() != PTY_void) {
-    UniqueFEIRVar var = FEIRBuilder::CreateVarNameForC(varName, *retType, false, false);
-    UniqueFEIRVar dreadVar = var->Clone();
-    icallStmt->SetVar(std::move(var));
-    stmts.emplace_back(std::move(icallStmt));
-    return FEIRBuilder::CreateExprDRead(std::move(dreadVar));
-  }
-  stmts.emplace_back(std::move(icallStmt));
-  return nullptr;
+UniqueFEIRExpr ASTCallExpr::AddRetExpr(std::unique_ptr<FEIRStmtAssign> &callStmt,
+                                       std::list<UniqueFEIRStmt> &stmts) const {
+  UniqueFEIRVar var = FEIRBuilder::CreateVarNameForC(varName, *retType, false, false);
+  UniqueFEIRVar dreadVar = var->Clone();
+  callStmt->SetVar(std::move(var));
+  stmts.emplace_back(std::move(callStmt));
+  return FEIRBuilder::CreateExprDRead(std::move(dreadVar));
 }
 
-std::map<std::string, ASTCallExpr::FuncPtrBuiltinFunc> ASTCallExpr::builtingFuncPtrMap =
-     ASTCallExpr::InitBuiltinFuncPtrMap();
-
-
-UniqueFEIRExpr ASTCallExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+std::unique_ptr<FEIRStmtAssign> ASTCallExpr::GenCallStmt() const {
+  MemPool *mp = FEManager::GetManager().GetStructElemMempool();
+  std::unique_ptr<FEIRStmtAssign> callStmt;
   if (isIcall) {
-    return Emit2FEExprICall(stmts);
+    callStmt = std::make_unique<FEIRStmtICallAssign>();
   } else {
+    StructElemNameIdx *nameIdx = mp->New<StructElemNameIdx>(funcName);
+    FEStructMethodInfo *info = static_cast<FEStructMethodInfo*>(
+        FEManager::GetTypeManager().RegisterStructMethodInfo(*nameIdx, kSrcLangC, false));
+    info->SetFuncAttrs(funcAttrs);
+    Opcode op;
+    if (IsNeedRetExpr()) {
+      op = OP_callassigned;
+    } else {
+      op = OP_call;
+    }
+    FEIRTypeNative *retTypeInfo = mp->New<FEIRTypeNative>(*retType);
+    info->SetReturnType(retTypeInfo);
+    callStmt = std::make_unique<FEIRStmtCallAssign>(*info, op, nullptr, false);
+  }
+  return callStmt;
+}
+
+UniqueFEIRExpr ASTCallExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  if (!isIcall) {
     auto ptrFunc = builtingFuncPtrMap.find(funcName);
     if (ptrFunc != builtingFuncPtrMap.end()) {
       return EmitBuiltinFunc(stmts);
     }
-    return Emit2FEExprCall(stmts);
   }
+  std::unique_ptr<FEIRStmtAssign> callStmt = GenCallStmt();
+  AddArgsExpr(callStmt, stmts);
+  if (IsNeedRetExpr()) {
+    return AddRetExpr(callStmt, stmts);
+  }
+  stmts.emplace_back(std::move(callStmt));
+  return nullptr;
 }
 
 // ---------- ASTImplicitCastExpr ----------
@@ -541,80 +532,21 @@ MIRConst *ASTUOAddrOfExpr::GenerateMIRConstImpl() const {
 
 UniqueFEIRExpr ASTUOAddrOfExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
   ASTExpr *childExpr = expr;
-  CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr");
   UniqueFEIRExpr addrOfExpr;
-  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);
-    if (refedDecl != nullptr) {
-      auto attrs = refedDecl->GetGenericAttrs();
-      addrOfVar->SetAttrs(attrs);
-      if (attrs.GetAttr(GENATTR_static) && !refedDecl->IsGlobal() &&
-          static_cast<ASTVar*>(refedDecl)->GetInitExpr() != nullptr) {
-        addrOfVar->SetConst(refedDecl->Translate2MIRConst());
-      }
-    }
-    addrOfExpr = FEIRBuilder::CreateExprAddrofVar(std::move(addrOfVar));
-  } else if (astOp == kASTMemberExpr) {
-    ASTMemberExpr *memberExpr = static_cast<ASTMemberExpr*>(childExpr);
-    ASTExpr *baseExpr = memberExpr->GetBaseExpr();
-    UniqueFEIRExpr baseFEExpr;
-    std::string fieldName = memberExpr->GetMemberName();
-    bool isArrow = memberExpr->GetIsArrow();
-    MIRType *baseType = memberExpr->GetBaseType();
-    if (baseExpr->GetASTOp() == kASTMemberExpr) {
-      std::list<std::string> memberNameList;
-      memberNameList.emplace_back(memberExpr->GetMemberName());
-      ASTMemberExpr *finalMember = memberExpr->findFinalMember(static_cast<ASTMemberExpr*>(baseExpr), memberNameList);
-      baseFEExpr = finalMember->GetBaseExpr()->Emit2FEExpr(stmts);
-      isArrow = finalMember->GetIsArrow();
-      baseType = finalMember->GetBaseType();
-      fieldName = ASTUtil::Join(memberNameList, ".");
-    } else {
-      baseFEExpr = baseExpr->Emit2FEExpr(stmts);
-    }
-    FieldID fieldID = 0;
-    if (isArrow) {
-      CHECK_FATAL(baseType->IsMIRPtrType(), "Must be ptr type!");
-      MIRPtrType *mirPtrType = static_cast<MIRPtrType*>(baseType);
-      MIRType *pointedMirType = mirPtrType->GetPointedType();
-      CHECK_FATAL(pointedMirType->IsStructType(), "pointedMirType must be StructType");
-      MIRStructType *structType = static_cast<MIRStructType*>(pointedMirType);
-      fieldID = FEUtils::GetStructFieldID(structType, fieldName);
-      UniqueFEIRType baseFEType = std::make_unique<FEIRTypeNative>(*baseType);
-      addrOfExpr = std::make_unique<FEIRExprIAddrof>(std::move(baseFEType), fieldID, std::move(baseFEExpr));
-    } else {
-       // other potential expr should concern
-      CHECK_FATAL(baseFEExpr->GetKind() == kExprDRead, "baseFEExpr kind isn't DRead");
-      auto dreadFEExpr = static_cast<FEIRExprDRead*>(baseFEExpr.get());
-      UniqueFEIRVar tmpVar = dreadFEExpr->GetVar()->Clone();
-      CHECK_FATAL(baseType->IsStructType(), "basetype must be StructType");
-      MIRStructType *structType = static_cast<MIRStructType*>(baseType);
-      fieldID = FEUtils::GetStructFieldID(structType, fieldName);
-      addrOfExpr = FEIRBuilder::CreateExprAddrofVar(std::move(tmpVar));
-      static_cast<FEIRExprAddrofVar*>(addrOfExpr.get())->SetFieldID(fieldID);
-    }
-  } else if (astOp == kASTSubscriptExpr) {
-    auto childFEExpr = childExpr->Emit2FEExpr(stmts);
-    auto iread = static_cast<FEIRExprIRead*>(childFEExpr.get());
-    if (iread->GetFieldID() == 0) {
-      return iread->GetClonedOpnd();
-    } else {
-      return std::make_unique<FEIRExprIAddrof>(iread->GetClonedPtrType(), iread->GetFieldID(),
-                                               iread->GetClonedOpnd());
-    }
-  } else { // other potential expr should concern
-    UniqueFEIRExpr childFEIRExpr;
-    childFEIRExpr = childExpr->Emit2FEExpr(stmts);
-    if (childFEIRExpr->GetKind() == kExprDRead && childFEIRExpr->GetPrimType() == PTY_agg) {
-      FEIRExprDRead *dread = static_cast<FEIRExprDRead*>(childFEIRExpr.get());
-      UniqueFEIRVar dreadVar = dread->GetVar()->Clone();
-      addrOfExpr = FEIRBuilder::CreateExprAddrofVar(std::move(dreadVar));
-    } else {
-      addrOfExpr = std::make_unique<FEIRExprUnary>(OP_addrof, uoType, std::move(childFEIRExpr));
-    }
+  CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr");
+  UniqueFEIRExpr childFEIRExpr = childExpr->Emit2FEExpr(stmts);
+  if (childFEIRExpr->GetKind() == kExprDRead) {
+    addrOfExpr = std::make_unique<FEIRExprAddrofVar>(
+        static_cast<FEIRExprDRead*>(childFEIRExpr.get())->GetVar()->Clone(), childFEIRExpr->GetFieldID());
+  } else if (childFEIRExpr->GetKind() == kExprIRead) {
+    auto ireadExpr = static_cast<FEIRExprIRead*>(childFEIRExpr.get());
+    addrOfExpr = std::make_unique<FEIRExprIAddrof>(ireadExpr->GetClonedPtrType(), ireadExpr->GetFieldID(),
+        ireadExpr->GetClonedOpnd());
+  } else if (childFEIRExpr->GetKind() == kExprIAddrof || childFEIRExpr->GetKind() == kExprAddrofVar ||
+      childFEIRExpr->GetKind() == kExprAddrofFunc) {
+    return childFEIRExpr;
+  } else {
+    CHECK_FATAL(false, "unsupported expr kind %d", childFEIRExpr->GetKind());
   }
   return addrOfExpr;
 }
@@ -1294,6 +1226,71 @@ UniqueFEIRExpr ASTDesignatedInitUpdateExpr::Emit2FEExprImpl(std::list<UniqueFEIR
   return nullptr;
 }
 
+MIRConst *ASTBinaryOperatorExpr::GenerateMIRConstImpl() const {
+  auto leftConst = leftExpr->GenerateMIRConst();
+  auto rightConst = rightExpr->GenerateMIRConst();
+  if (leftConst->GetKind() == rightConst->GetKind()) {
+    switch (leftConst->GetKind()) {
+      case kConstInt: {
+        return MIRConstGenerator(FEManager::GetModule().GetMemPool(), static_cast<MIRIntConst*>(leftConst),
+                                 static_cast<MIRIntConst*>(rightConst), opcode);
+      }
+      case kConstFloatConst: {
+        return MIRConstGenerator(FEManager::GetModule().GetMemPool(), static_cast<MIRFloatConst*>(leftConst),
+                                 static_cast<MIRFloatConst*>(rightConst), opcode);
+      }
+      case kConstDoubleConst: {
+        return MIRConstGenerator(FEManager::GetModule().GetMemPool(), static_cast<MIRDoubleConst*>(leftConst),
+                                 static_cast<MIRDoubleConst*>(rightConst), opcode);
+      }
+      default: {
+        CHECK_FATAL(false, "Unsupported yet");
+        return nullptr;
+      }
+    }
+  }
+  if (opcode == OP_add) {
+    MIRIntConst *constInt = nullptr;
+    MIRConst *baseConst = nullptr;
+    if (leftConst->GetKind() == kConstInt) {
+      constInt = static_cast<MIRIntConst*>(leftConst);
+      baseConst = rightConst;
+    } else if (rightConst->GetKind() == kConstInt) {
+      constInt = static_cast<MIRIntConst*>(rightConst);
+      baseConst = leftConst;
+    } else {
+      CHECK_FATAL(false, "Unsupported yet");
+    }
+    int64 value = constInt->GetValue();
+    if (baseConst->GetKind() == kConstStrConst) {
+      std::string str =
+          GlobalTables::GetUStrTable().GetStringFromStrIdx(static_cast<MIRStrConst*>(baseConst)->GetValue());
+      CHECK_FATAL(str.length() >= static_cast<std::size_t>(value), "Invalid operation");
+      str = str.substr(value);
+      UStrIdx strIdx = GlobalTables::GetUStrTable().GetOrCreateStrIdxFromName(str);
+      return FEManager::GetModule().GetMemPool()->New<MIRStrConst>(
+          strIdx, *GlobalTables::GetTypeTable().GetPrimType(PTY_a64));
+    } else if (baseConst->GetKind() == kConstAddrof) {
+#ifndef USE_OPS
+      CHECK_FATAL(false, "Unsupported");
+      return nullptr;
+#else
+      MIRAddrofConst *konst = static_cast<MIRAddrofConst*>(baseConst);
+      auto idx = konst->GetSymbolIndex();
+      auto id = konst->GetFieldID();
+      auto ty = konst->GetType();
+      auto offset = konst->GetOffset();
+      return FEManager::GetModule().GetMemPool()->New<MIRAddrofConst>(idx, id, ty, offset + value);
+#endif
+    } else {
+      CHECK_FATAL(false, "NIY");
+    }
+  } else {
+    CHECK_FATAL(false, "NIY");
+  }
+  return nullptr;
+}
+
 UniqueFEIRExpr ASTBinaryOperatorExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
   if (complexElementType != nullptr) {
     UniqueFEIRVar tempVar = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("Complex_"), *retType);
@@ -1406,10 +1403,12 @@ UniqueFEIRExpr ASTAssignExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts)
 
 UniqueFEIRExpr ASTBOComma::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
   auto leftFEExpr = leftExpr->Emit2FEExpr(stmts);
-  std::list<UniqueFEIRExpr> exprs;
-  exprs.emplace_back(std::move(leftFEExpr));
-  auto leftStmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(exprs));
-  stmts.emplace_back(std::move(leftStmt));
+  if (leftFEExpr != nullptr) {
+    std::list<UniqueFEIRExpr> exprs;
+    exprs.emplace_back(std::move(leftFEExpr));
+    auto leftStmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(exprs));
+    stmts.emplace_back(std::move(leftStmt));
+  }
   return rightExpr->Emit2FEExpr(stmts);
 }
 
@@ -1427,6 +1426,10 @@ UniqueFEIRExpr ASTParenExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) c
 }
 
 // ---------- ASTIntegerLiteral ----------
+MIRConst *ASTIntegerLiteral::GenerateMIRConstImpl() const {
+  return GlobalTables::GetIntConstTable().GetOrCreateIntConst(val, *GlobalTables::GetTypeTable().GetPrimType(PTY_i64));
+}
+
 UniqueFEIRExpr ASTIntegerLiteral::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
   UniqueFEIRExpr constExpr = std::make_unique<FEIRExprConst>(val, type);
   return constExpr;
@@ -1702,9 +1705,12 @@ void ASTVAArgExpr::CvtHFA2Struct(MIRStructType &type, MIRType &fieldType, Unique
 UniqueFEIRExpr ASTCStyleCastExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
   if (destType->GetPrimType() == PTY_void) {
     std::list<UniqueFEIRExpr> feExprs;
-    feExprs.emplace_back(child->Emit2FEExpr(stmts));
-    UniqueFEIRStmt stmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(feExprs));
-    stmts.emplace_back(std::move(stmt));
+    auto expr = child->Emit2FEExpr(stmts);
+    if (expr != nullptr) {
+      feExprs.emplace_back(std::move(expr));
+      UniqueFEIRStmt stmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(feExprs));
+      stmts.emplace_back(std::move(stmt));
+    }
     return nullptr;
   }
   MIRType *src = canCastArray ? decl->GetTypeDesc().front() : srcType;
diff --git a/src/mplfe/ast_input/src/ast_stmt.cpp b/src/mplfe/ast_input/src/ast_stmt.cpp
index 33fcae486dc17a1db1989b6f0d6277515c6970e5..9df82da445fb173888d2220ce5e803d3dbf23293 100644
--- a/src/mplfe/ast_input/src/ast_stmt.cpp
+++ b/src/mplfe/ast_input/src/ast_stmt.cpp
@@ -109,9 +109,11 @@ std::list<UniqueFEIRStmt> ASTForStmt::Emit2FEStmtImpl() const {
     std::list<UniqueFEIRExpr> exprs;
     std::list<UniqueFEIRStmt> incStmts;
     UniqueFEIRExpr incFEExpr = incExpr->Emit2FEExpr(incStmts);
-    exprs.emplace_back(std::move(incFEExpr));
-    auto incStmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(exprs));
-    incStmts.emplace_back(std::move(incStmt));
+    if (incFEExpr != nullptr) {
+      exprs.emplace_back(std::move(incFEExpr));
+      auto incStmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(exprs));
+      incStmts.emplace_back(std::move(incStmt));
+    }
     bodyFEStmts.splice(bodyFEStmts.cend(), incStmts);
   }
   if (condExpr != nullptr) {
@@ -303,67 +305,10 @@ std::map<std::string, ASTCallExprStmt::FuncPtrBuiltinFunc> ASTCallExprStmt::Init
   return ans;
 }
 
-std::list<UniqueFEIRStmt> ASTCallExprStmt::Emit2FEStmtCall() const {
-  std::list<UniqueFEIRStmt> stmts;
-  ASTCallExpr *callExpr = static_cast<ASTCallExpr*>(exprs.front());
-  // callassigned &funcName
-  std::string funcName = callExpr->GetFuncName();
-  StructElemNameIdx *nameIdx = FEManager::GetManager().GetStructElemMempool()->New<StructElemNameIdx>(funcName);
-  FEStructMethodInfo *info = static_cast<FEStructMethodInfo*>(
-      FEManager::GetTypeManager().RegisterStructMethodInfo(*nameIdx, kSrcLangC, false));
-  MIRType *retType = callExpr->GetRetType();
-  Opcode op;
-  if (retType->GetPrimType() != PTY_void) {
-    op = OP_callassigned;
-  } else {
-    op = OP_call;
-  }
-  std::unique_ptr<FEIRStmtCallAssign> callStmt = std::make_unique<FEIRStmtCallAssign>(*info, op, nullptr, false);
-  callStmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum());
-  // args
-  std::vector<ASTExpr*> argsExprs = callExpr->GetArgsExpr();
-  for (int32 i = argsExprs.size() - 1; i >= 0; --i) {
-    UniqueFEIRExpr expr = argsExprs[i]->Emit2FEExpr(stmts);
-    callStmt->AddExprArgReverse(std::move(expr));
-  }
-  // attrs
-  info->SetFuncAttrs(callExpr->GetFuncAttrs());
-  // return
-  FEIRTypeNative *retTypeInfo = FEManager::GetManager().GetModule().GetMemPool()->New<FEIRTypeNative>(*retType);
-  info->SetReturnType(retTypeInfo);
-  if (retType->GetPrimType() != PTY_void) {
-    UniqueFEIRVar var = FEIRBuilder::CreateVarNameForC(varName, *retType, false, false);
-    callStmt->SetVar(std::move(var));
-  }
-  stmts.emplace_back(std::move(callStmt));
-  return stmts;
-}
-
-std::list<UniqueFEIRStmt> ASTCallExprStmt::Emit2FEStmtICall() const {
-  std::list<UniqueFEIRStmt> stmts;
-  std::unique_ptr<FEIRStmtICallAssign> icallStmt = std::make_unique<FEIRStmtICallAssign>();
-  icallStmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum());
-  ASTCallExpr *callExpr = static_cast<ASTCallExpr*>(exprs.front());
-  ASTExpr *calleeExpr = callExpr->GetCalleeExpr();
-  CHECK_NULL_FATAL(calleeExpr);
-  // args
-  UniqueFEIRExpr expr = calleeExpr->Emit2FEExpr(stmts);
-  icallStmt->AddExprArgReverse(std::move(expr));
-  // return
-  MIRType *retType = callExpr->GetRetType();
-  if (retType->GetPrimType() != PTY_void) {
-    UniqueFEIRVar var = FEIRBuilder::CreateVarNameForC(varName, *retType, false, false);
-    icallStmt->SetVar(std::move(var));
-  }
-  stmts.emplace_back(std::move(icallStmt));
-  return stmts;
-}
-
 std::list<UniqueFEIRStmt> ASTCallExprStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
   ASTCallExpr *callExpr = static_cast<ASTCallExpr*>(exprs.front());
-  if (callExpr->IsIcall()) {
-    return Emit2FEStmtICall();
-  } else {
+  if (!callExpr->IsIcall()) {
     if (callExpr->GetCalleeExpr() != nullptr && callExpr->GetCalleeExpr()->GetASTOp() == kASTOpCast &&
         static_cast<ASTImplicitCastExpr*>(callExpr->GetCalleeExpr())->IsBuilinFunc()) {
       auto ptrFunc = funcPtrMap.find(callExpr->GetFuncName());
@@ -371,8 +316,16 @@ std::list<UniqueFEIRStmt> ASTCallExprStmt::Emit2FEStmtImpl() const {
         return (this->*(ptrFunc->second))();
       }
     }
-    return Emit2FEStmtCall();
   }
+  std::unique_ptr<FEIRStmtAssign> callStmt = callExpr->GenCallStmt();
+  callStmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum());
+  callExpr->AddArgsExpr(callStmt, stmts);
+  if (callExpr->IsNeedRetExpr()) {
+    UniqueFEIRVar var = FEIRBuilder::CreateVarNameForC(varName, *callExpr->GetRetType(), false, false);
+    callStmt->SetVar(std::move(var));
+  }
+  stmts.emplace_back(std::move(callStmt));
+  return stmts;
 }
 
 std::list<UniqueFEIRStmt> ASTCallExprStmt::ProcessBuiltinVaStart() const {
@@ -455,11 +408,13 @@ std::list<UniqueFEIRStmt> ASTImplicitCastExprStmt::Emit2FEStmtImpl() const {
   CHECK_FATAL(exprs.size() == 1, "Only one sub expr supported!");
   std::list<UniqueFEIRStmt> stmts;
   UniqueFEIRExpr feirExpr = exprs.front()->Emit2FEExpr(stmts);
-  std::list<UniqueFEIRExpr> feirExprs;
-  feirExprs.emplace_back(std::move(feirExpr));
-  auto stmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(feirExprs));
-  stmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum());
-  stmts.emplace_back(std::move(stmt));
+  if (feirExpr != nullptr) {
+    std::list<UniqueFEIRExpr> feirExprs;
+    feirExprs.emplace_back(std::move(feirExpr));
+    auto stmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(feirExprs));
+    stmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum());
+    stmts.emplace_back(std::move(stmt));
+  }
   return stmts;
 }
 
@@ -545,11 +500,13 @@ std::list<UniqueFEIRStmt> ASTBinaryOperatorStmt::Emit2FEStmtImpl() const {
   auto boExpr = static_cast<ASTBinaryOperatorExpr*>(exprs.front());
   if (boExpr->GetASTOp() == kASTOpBO) {
     UniqueFEIRExpr boFEExpr = boExpr->Emit2FEExpr(stmts);
-    std::list<UniqueFEIRExpr> exprs;
-    exprs.emplace_back(std::move(boFEExpr));
-    auto stmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(exprs));
-    stmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum());
-    stmts.emplace_back(std::move(stmt));
+    if (boFEExpr != nullptr) {
+      std::list<UniqueFEIRExpr> exprs;
+      exprs.emplace_back(std::move(boFEExpr));
+      auto stmt = std::make_unique<FEIRStmtNary>(OP_eval, std::move(exprs));
+      stmt->SetSrcFileInfo(GetSrcFileIdx(), GetSrcFileLineNum());
+      stmts.emplace_back(std::move(stmt));
+    }
   } else {
     // has been processed by child expr emit, skip here
     UniqueFEIRExpr boFEExpr = boExpr->Emit2FEExpr(stmts);
diff --git a/src/mplfe/common/include/fe_utils_ast.h b/src/mplfe/common/include/fe_utils_ast.h
index 81136a728ab9c06b9b468c0f449063fb65220a20..de15fc932f8866f9230847347c820dfe196cdb64 100644
--- a/src/mplfe/common/include/fe_utils_ast.h
+++ b/src/mplfe/common/include/fe_utils_ast.h
@@ -18,6 +18,9 @@
 #include <vector>
 #include "types_def.h"
 #include "cfg_primitive_types.h"
+#include "mempool.h"
+#include "opcodes.h"
+#include "mir_const.h"
 
 namespace maple {
 class FEUtilAST {
@@ -29,5 +32,45 @@ class FEUtilAST {
   FEUtilAST() = default;
   ~FEUtilAST() = default;
 };
+
+template <class T>
+std::function<T()> OpGenerator(Opcode op, T p0, T p1) {
+  switch (op) {
+    case OP_add: {
+       return [&]() { return p0 + p1; };
+    }
+    case OP_sub: {
+      return [&]() { return p0 - p1; };
+    }
+    case OP_mul: {
+      return [&]() { return p0 * p1; };
+    }
+    case OP_div: {
+      return [&]() { return p0 / p1; };
+    }
+    case OP_shl: {
+      return [&]() { return static_cast<int64>(p0) << static_cast<int64>(p1); };
+    }
+    case OP_lshr:
+    case OP_ashr: {
+      return [&]() { return static_cast<int64>(p0) >> static_cast<int64>(p1); };
+    }
+    case OP_bior: {
+      return [&]() { return static_cast<int64>(p0) | static_cast<int64>(p1); };
+    }
+    case OP_bxor: {
+      return [&]() { return static_cast<int64>(p0) ^ static_cast<int64>(p1); };
+    }
+    default: {
+      return nullptr;
+    }
+  }
+  return nullptr;
+}
+
+template <class T>
+T *MIRConstGenerator(MemPool *mp, T *konst0, T *konst1, Opcode op) {
+  return mp->New<T>(OpGenerator(op, konst0->GetValue(), konst1->GetValue())(), konst0->GetType());
+}
 }  // namespace maple
 #endif  // MPLFE_INCLUDE_FE_UTILS_AST_H
diff --git a/src/mplfe/common/include/feir_stmt.h b/src/mplfe/common/include/feir_stmt.h
index a763e22d9686570a64ab9957255282cd6e99e170..9b542ff709351c128000ccb6ee1f8622739d3aaf 100644
--- a/src/mplfe/common/include/feir_stmt.h
+++ b/src/mplfe/common/include/feir_stmt.h
@@ -555,6 +555,11 @@ class FEIRExprAddrofVar : public FEIRExpr {
       : FEIRExpr(FEIRNodeKind::kExprAddrofVar,
                  FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetPtrType())),
         varSrc(std::move(argVarSrc)) {}
+
+  FEIRExprAddrofVar(std::unique_ptr<FEIRVar> argVarSrc, FieldID id)
+      : FEIRExpr(FEIRNodeKind::kExprAddrofVar,
+                 FEIRTypeHelper::CreateTypeNative(*GlobalTables::GetTypeTable().GetPtrType())),
+        varSrc(std::move(argVarSrc)), fieldID(id) {}
   ~FEIRExprAddrofVar() = default;
 
   void SetVarValue(MIRConst *val) {
@@ -1303,6 +1308,14 @@ class FEIRStmtAssign : public FEIRStmt {
     var->SetDef(HasDef());
   }
 
+  void AddExprArg(UniqueFEIRExpr exprArg) {
+    exprArgs.push_back(std::move(exprArg));
+  }
+
+  void AddExprArgReverse(UniqueFEIRExpr exprArg) {
+    exprArgs.push_front(std::move(exprArg));
+  }
+
   bool HasException() const {
     return hasException;
   }
@@ -1331,6 +1344,7 @@ class FEIRStmtAssign : public FEIRStmt {
   void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
   bool hasException;
   std::unique_ptr<FEIRVar> var = nullptr;
+  std::list<UniqueFEIRExpr> exprArgs;
 };
 
 // ---------- FEIRStmtDAssign ----------
@@ -2155,13 +2169,6 @@ class FEIRStmtCallAssign : public FEIRStmtAssign {
  public:
   FEIRStmtCallAssign(FEStructMethodInfo &argMethodInfo, Opcode argMIROp, UniqueFEIRVar argVarRet, bool argIsStatic);
   ~FEIRStmtCallAssign() = default;
-  void AddExprArg(UniqueFEIRExpr exprArg) {
-    exprArgs.push_back(std::move(exprArg));
-  }
-
-  void AddExprArgReverse(UniqueFEIRExpr exprArg) {
-    exprArgs.push_front(std::move(exprArg));
-  }
 
   static std::map<Opcode, Opcode> InitMapOpAssignToOp();
   static std::map<Opcode, Opcode> InitMapOpToOpAssign();
@@ -2179,7 +2186,6 @@ class FEIRStmtCallAssign : public FEIRStmtAssign {
   FEStructMethodInfo &methodInfo;
   Opcode mirOp;
   bool isStatic;
-  std::list<UniqueFEIRExpr> exprArgs;
   static std::map<Opcode, Opcode> mapOpAssignToOp;
   static std::map<Opcode, Opcode> mapOpToOpAssign;
 };
@@ -2189,22 +2195,12 @@ class FEIRStmtICallAssign : public FEIRStmtAssign {
  public:
   FEIRStmtICallAssign();
   ~FEIRStmtICallAssign() = default;
-  void AddExprArg(UniqueFEIRExpr exprArg) {
-    exprArgs.push_back(std::move(exprArg));
-  }
-
-  void AddExprArgReverse(UniqueFEIRExpr exprArg) {
-    exprArgs.push_front(std::move(exprArg));
-  }
 
  protected:
   std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
   std::string DumpDotStringImpl() const override;
   void RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) override;
   bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
-
- private:
-  std::list<UniqueFEIRExpr> exprArgs;
 };
 
 // ---------- FEIRStmtIntrinsicCallAssign ----------