diff --git a/src/mapleall/bin/dex2mpl b/src/mapleall/bin/dex2mpl
index 1952b581fc19dd9168aa378f58e2cd878ca81cca..5174665b4f0eb3132871557c1342e98c4f435b7a 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 7725026ec4e02f5b49d354481d3a2837e6df133a..92d72e120484a5d198121e4a58dab5da74778d8d 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 d0e4db782cd4372c688e7df79850de6762c946a5..ed17e9c55644883ca698a82f29869877ad31f1e2 100755
Binary files a/src/mapleall/bin/jbc2mpl and b/src/mapleall/bin/jbc2mpl differ
diff --git a/src/mapleall/maple_driver/defs/phases.def b/src/mapleall/maple_driver/defs/phases.def
index 1d7c88cca7635e7ed1538ea4d008ab193d324c51..1e3cf0c4ae07d35535da104d6cff1236797ed32a 100644
--- a/src/mapleall/maple_driver/defs/phases.def
+++ b/src/mapleall/maple_driver/defs/phases.def
@@ -43,6 +43,7 @@ ADD_PHASE("analyzerc", JAVALANG && MeOption::optLevel == 2)
 ADD_PHASE("rclowering", JAVALANG)
 ADD_PHASE("rename2preg", MeOption::optLevel == 2)
 ADD_PHASE("lpre", MeOption::optLevel == 2)
+ADD_PHASE("storepre", MeOption::optLevel == 2)
 ADD_PHASE("pregrename", MeOption::optLevel == 2)
 ADD_PHASE("bblayout", MeOption::optLevel == 2 || JAVALANG)
 ADD_PHASE("emit", MeOption::optLevel == 2 || JAVALANG)
diff --git a/src/mapleall/maple_ir/include/mir_type.h b/src/mapleall/maple_ir/include/mir_type.h
index dbbb85d8622925ca4c4eb8d098b9a72a333e408d..2d82d431e4c902ba9cbaa2d695b60bb130d3901a 100644
--- a/src/mapleall/maple_ir/include/mir_type.h
+++ b/src/mapleall/maple_ir/include/mir_type.h
@@ -24,9 +24,6 @@
 #include "mempool_allocator.h"
 #endif  // MIR_FEATURE_FULL
 
-#define POINTER_SIZE 8
-#define POINTER_P2SIZE 3
-
 namespace maple {
 constexpr int kTypeHashLength = 12289;  // hash length for mirtype, ref: planetmath.org/goodhashtableprimes
 
@@ -591,8 +588,8 @@ class MIRPtrType : public MIRType {
   bool IsPointedTypeVolatile(int fieldID) const;
 
   void Dump(int indent, bool dontUseName = false) const override;
-  size_t GetSize() const override { return POINTER_SIZE; }
-  uint32 GetAlign() const override { return POINTER_SIZE; }
+  size_t GetSize() const override;
+  uint32 GetAlign() const override;
   TyIdxFieldAttrPair GetPointedTyIdxFldAttrPairWithFieldID(FieldID fldId) const;
   TyIdx GetPointedTyIdxWithFieldID(FieldID fieldID) const;
   size_t GetHashIndex() const override {
diff --git a/src/mapleall/maple_ir/src/bin_mpl_import.cpp b/src/mapleall/maple_ir/src/bin_mpl_import.cpp
index 2e62652ed9ee0fb9a75bfb781d82fae7a67ddef7..7b9d6f020550006c3fd8b1befad2fb94abfc23e6 100644
--- a/src/mapleall/maple_ir/src/bin_mpl_import.cpp
+++ b/src/mapleall/maple_ir/src/bin_mpl_import.cpp
@@ -1186,7 +1186,7 @@ void BinaryMplImport::ReadTypeField() {
     }
   } else {
     for (int64 i = 0; i < size; ++i) {
-      ImportTypeNonJava();
+      (void)ImportTypeNonJava();
     }
   }
   int64 tag = 0;
diff --git a/src/mapleall/maple_ir/src/global_tables.cpp b/src/mapleall/maple_ir/src/global_tables.cpp
index 39127331bf8b46373e5da23296839d2a06724372..3ec7a9d9bb5e32e089809b17bf778cda250be985 100644
--- a/src/mapleall/maple_ir/src/global_tables.cpp
+++ b/src/mapleall/maple_ir/src/global_tables.cpp
@@ -75,7 +75,8 @@ void TypeTable::UpdateMIRType(const MIRType &pType, const TyIdx tyIdx) {
 }
 
 // used only by bin_mpl_import
-void TypeTable::CreateMirTypeNodeAt(MIRType &pType, TyIdx tyIdxUsed, MIRModule *module, bool isObject, bool isIncomplete) {
+void TypeTable::CreateMirTypeNodeAt(MIRType &pType, TyIdx tyIdxUsed, MIRModule *module,
+                                    bool isObject, bool isIncomplete) {
   MIRType *nType = pType.CopyMIRTypeNode();
   nType->SetTypeIndex(tyIdxUsed);
   typeTable[tyIdxUsed] = nType;
diff --git a/src/mapleall/maple_ir/src/mir_parser.cpp b/src/mapleall/maple_ir/src/mir_parser.cpp
index 59dc785d93fe760d4a5ec69d9781c00c5449b075..fcafffaa598d77f9195ff2d23a7cb4213150e946 100644
--- a/src/mapleall/maple_ir/src/mir_parser.cpp
+++ b/src/mapleall/maple_ir/src/mir_parser.cpp
@@ -2664,7 +2664,8 @@ bool MIRParser::ParseConstAddrLeafExpr(MIRConstPtr &cexpr) {
       }
       lexer.NextToken();
     }
-    cexpr = mod.GetMemPool()->New<MIRAddrofConst>(anode->GetStIdx(), anode->GetFieldID(), *exprTy, ofst);
+    cexpr = mod.CurFunction()->GetDataMemPool()->New<MIRAddrofConst>(
+        anode->GetStIdx(), anode->GetFieldID(), *exprTy, ofst);
   } else if (expr->GetOpCode() == OP_addroffunc) {
     auto *aof = static_cast<AddroffuncNode*>(expr);
     MIRFunction *f = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(aof->GetPUIdx());
@@ -2673,11 +2674,14 @@ bool MIRParser::ParseConstAddrLeafExpr(MIRConstPtr &cexpr) {
     MIRPtrType ptrType(ptyIdx);
     ptyIdx = GlobalTables::GetTypeTable().GetOrCreateMIRType(&ptrType);
     MIRType *exprTy = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptyIdx);
-    cexpr = mod.GetMemPool()->New<MIRAddroffuncConst>(aof->GetPUIdx(), *exprTy);
+    cexpr = mod.CurFunction()->GetDataMemPool()->New<MIRAddroffuncConst>(aof->GetPUIdx(), *exprTy);
   } else if (expr->op == OP_addroflabel) {
     AddroflabelNode *aol = static_cast<AddroflabelNode *>(expr);
     MIRType *mirtype = GlobalTables::GetTypeTable().GetTypeFromTyIdx(TyIdx(PTY_ptr));
-    cexpr = mod.GetMemPool()->New<MIRLblConst>(aol->GetOffset(), mod.CurFunction()->GetPuidx(), *mirtype);
+    // func code mempool will be released after irmap, but MIRLblConst won't be passed to me ir.
+    // So MIRLblConst can NOT be allocated in func code mempool.
+    cexpr = mod.CurFunction()->GetDataMemPool()->New<MIRLblConst>(
+        aol->GetOffset(), mod.CurFunction()->GetPuidx(), *mirtype);
   } else if (expr->GetOpCode() == OP_conststr) {
     auto *cs = static_cast<ConststrNode*>(expr);
     UStrIdx stridx = cs->GetStrIdx();
diff --git a/src/mapleall/maple_ir/src/mir_type.cpp b/src/mapleall/maple_ir/src/mir_type.cpp
index 4b28e026315a33a5d7a64c11a4ac05728384816e..6aeb01a96478d28d5cf79de9fe8e0933dc860238 100644
--- a/src/mapleall/maple_ir/src/mir_type.cpp
+++ b/src/mapleall/maple_ir/src/mir_type.cpp
@@ -158,17 +158,15 @@ bool IsNoCvtNeeded(PrimType toType, PrimType fromType) {
   }
 }
 
-// answer in bytes; 0 if unknown
-uint32 GetPrimTypeSize(PrimType primType) {
-  if (primType == PTY_ref || primType == PTY_ptr) {
 #if TARGX86_64 || TARGAARCH64
-    primType = PTY_a64;
+  #define POINTER_SIZE 8
+  #define POINTER_P2SIZE 3
 #elif TARGX86 || TARGARM32 || TARGVM
-    primType = PTY_a32;
-#else
-    ASSERT(false, "NIY");
+  #define POINTER_SIZE 4
+  #define POINTER_P2SIZE 2
 #endif
-  }
+// answer in bytes; 0 if unknown
+uint32 GetPrimTypeSize(PrimType primType) {
   switch (primType) {
     case PTY_void:
     case PTY_agg:
@@ -1646,6 +1644,9 @@ bool MIRPtrType::IsPointedTypeVolatile(int fieldID) const {
   return pointedTy->IsVolatile(fieldID);
 }
 
+size_t MIRPtrType::GetSize() const { return POINTER_SIZE; }
+uint32 MIRPtrType::GetAlign() const { return POINTER_SIZE; }
+
 TyIdxFieldAttrPair MIRPtrType::GetPointedTyIdxFldAttrPairWithFieldID(FieldID fldId) const {
   if (fldId == 0) {
     return TyIdxFieldAttrPair(pointedTyIdx, FieldAttrs());
diff --git a/src/mapleall/maple_me/include/alias_analysis_table.h b/src/mapleall/maple_me/include/alias_analysis_table.h
index 6c02e20b8a75dcae44c9ef0a813625905f3d3546..71f1ca37093970d12e3128fdd5aecffe70d313d8 100644
--- a/src/mapleall/maple_me/include/alias_analysis_table.h
+++ b/src/mapleall/maple_me/include/alias_analysis_table.h
@@ -36,14 +36,13 @@ class AliasAnalysisTable {
   OriginalSt *FindOrCreateAddrofSymbolOriginalSt(OriginalSt &ost);
   OriginalSt *FindOrCreateExtraLevOriginalSt(OriginalSt &ost, TyIdx ptyidx, FieldID fld);
 
- private:
-  OriginalSt *FindOrCreateExtraLevSymOrRegOriginalSt(OriginalSt &ost, TyIdx tyIdx, FieldID fld);
-  OriginalSt *FindExtraLevOriginalSt(const MapleVector<OriginalSt*> &nextLevelOsts, FieldID fld);
   SSATab &ssaTab;
   MapleAllocator alloc;
- public:
   MapleMap<OStIdx, OriginalSt*> prevLevelNode;                 // index is the OStIdx
  private:
+  OriginalSt *FindOrCreateExtraLevSymOrRegOriginalSt(OriginalSt &ost, TyIdx tyIdx, FieldID fld);
+  OriginalSt *FindExtraLevOriginalSt(const MapleVector<OriginalSt*> &nextLevelOsts, FieldID fld);
+
   MapleMap<OStIdx, MapleVector<OriginalSt*>*> nextLevelNodes;  // index is the OStIdx
   MemPool *memPool;
   KlassHierarchy &klassHierarchy;
diff --git a/src/mapleall/maple_me/include/alias_class.h b/src/mapleall/maple_me/include/alias_class.h
index 85bfd8dec1891f2f1af579e16b87e64b10ab8679..53b3556ec42a2a397d4884ffeb89c1cbe018c188 100644
--- a/src/mapleall/maple_me/include/alias_class.h
+++ b/src/mapleall/maple_me/include/alias_class.h
@@ -165,6 +165,7 @@ class AliasClass : public AnalysisResult {
   bool AliasAccordingToFieldID(const OriginalSt &ostA, const OriginalSt &ostB);
   void ReconstructAliasGroups();
   void CollectNotAllDefsSeenAes();
+  void UnionNextLevelOfAliasOst();
   void CreateClassSets();
   void DumpClassSets();
   void InsertMayDefUseCall(StmtNode &stmt, BBId bbid, bool hasSideEffect, bool hasNoPrivateDefEffect);
diff --git a/src/mapleall/maple_me/src/alias_class.cpp b/src/mapleall/maple_me/src/alias_class.cpp
index fa0aeb108236bf9a0f3e118b0c4afe3705c26a2a..675db0e9d04df234a06c1f88feb162c58f1e42f5 100644
--- a/src/mapleall/maple_me/src/alias_class.cpp
+++ b/src/mapleall/maple_me/src/alias_class.cpp
@@ -208,11 +208,11 @@ AliasElem &AliasClass::FindOrCreateAliasElemOfAddrofZeroFieldIDOSt(OriginalSt &o
     osym2Elem.push_back(nullptr);
     ssaTab.GetVersionStTable().CreateZeroVersionSt(zeroFieldIDOst);
   }
-  FindOrCreateAliasElem(*zeroFieldIDOst);
+  (void)FindOrCreateAliasElem(*zeroFieldIDOst);
 
   OriginalSt *addrofOst = GetAliasAnalysisTable()->FindOrCreateAddrofSymbolOriginalSt(*zeroFieldIDOst);
   if (ost.GetFieldID() != 0) {
-    GetAliasAnalysisTable()->prevLevelNode.insert(std::make_pair(ost.GetIndex(), addrofOst));
+    (void)GetAliasAnalysisTable()->prevLevelNode.insert(std::make_pair(ost.GetIndex(), addrofOst));
     GetAliasAnalysisTable()->GetNextLevelNodes(*addrofOst)->push_back(&ost);
   }
   if (addrofOst->GetIndex() == osym2Elem.size()) {
@@ -234,7 +234,7 @@ AliasInfo AliasClass::CreateAliasElemsExpr(BaseNode &expr) {
     case OP_dread: {
       OriginalSt *ost = static_cast<AddrofSSANode&>(expr).GetSSAVar()->GetOst();
       if (ost->GetFieldID() != 0) {
-        FindOrCreateAliasElemOfAddrofZeroFieldIDOSt(*ost);
+        (void)FindOrCreateAliasElemOfAddrofZeroFieldIDOSt(*ost);
       }
 
       AliasElem *ae = FindOrCreateAliasElem(*ost);
@@ -373,7 +373,7 @@ void AliasClass::ApplyUnionForCopies(StmtNode &stmt) {
       // LHS
       OriginalSt *ost = ssaTab.GetStmtsSSAPart().GetAssignedVarOf(stmt)->GetOst();
       if (ost->GetFieldID() != 0) {
-        FindOrCreateAliasElemOfAddrofZeroFieldIDOSt(*ost);
+        (void)FindOrCreateAliasElemOfAddrofZeroFieldIDOSt(*ost);
       }
 
       AliasElem *lhsAe = FindOrCreateAliasElem(*ost);
@@ -994,6 +994,46 @@ void AliasClass::CollectNotAllDefsSeenAes() {
   }
 }
 
+void AliasClass::UnionNextLevelOfAliasOst() {
+  std::map<uint32, std::vector<OriginalSt*>> rootId2AliasedOsts;
+  for (AliasElem *aliasElem : id2Elem) {
+    uint32 id = aliasElem->GetClassID();
+    uint32 rootID = unionFind.Root(id);
+    if (id != rootID) {
+      auto &ost = aliasElem->GetOriginalSt();
+      auto *nextLevelOsts = GetAliasAnalysisTable()->GetNextLevelNodes(ost);
+      (void)rootId2AliasedOsts[rootID].insert(
+          rootId2AliasedOsts[rootID].end(), nextLevelOsts->begin(), nextLevelOsts->end());
+    }
+  }
+  for (auto &rootIdPair : rootId2AliasedOsts) {
+    auto &nextLevelOsts = rootIdPair.second;
+    if (nextLevelOsts.empty()) {
+      continue;
+    }
+    auto &rootOst = id2Elem[rootIdPair.first]->GetOriginalSt();
+    auto *nextLevelOstOfRoot = GetAliasAnalysisTable()->GetNextLevelNodes(rootOst);
+    (void)nextLevelOsts.insert(nextLevelOsts.end(), nextLevelOstOfRoot->begin(), nextLevelOstOfRoot->end());
+
+    for (uint32 idA = 0; idA < nextLevelOsts.size(); ++idA) {
+      auto *ostA = nextLevelOsts[idA];
+      for (uint32 idB = idA + 1; idB < nextLevelOsts.size(); ++idB) {
+        auto *ostB = nextLevelOsts[idB];
+        bool hasFieldid0 = ostA->GetFieldID() == 0 || ostB->GetFieldID() == 0;
+        if ((ostA->GetFieldID() != ostB->GetFieldID()) && !hasFieldid0) {
+          continue;
+        }
+        if ((ostA->IsFinal() || ostB->IsFinal())) {
+          continue;
+        }
+        AliasElem *indaeA = FindAliasElem(*ostA);
+        AliasElem *indaeB = FindAliasElem(*ostB);
+        unionFind.Union(indaeA->GetClassID(), indaeB->GetClassID());
+      }
+    }
+  }
+}
+
 void AliasClass::CreateClassSets() {
   // iterate through all the alias elems
   for (AliasElem *aliasElem : id2Elem) {
diff --git a/src/mapleall/maple_me/src/me_alias_class.cpp b/src/mapleall/maple_me/src/me_alias_class.cpp
index d2ff55d57fbdb76b68de27499dfac8dd735d2789..29d0ddeee45fdc763efb97c8d2684434c6360760 100644
--- a/src/mapleall/maple_me/src/me_alias_class.cpp
+++ b/src/mapleall/maple_me/src/me_alias_class.cpp
@@ -73,6 +73,7 @@ void MeAliasClass::DoAliasAnalysis() {
   if (!MeOption::noTBAA && mirModule.IsJavaModule()) {
     ReconstructAliasGroups();
   }
+  UnionNextLevelOfAliasOst();
   CreateClassSets();
   if (enabledDebug) {
     DumpClassSets();
diff --git a/src/mapleall/maple_me/src/me_rename2preg.cpp b/src/mapleall/maple_me/src/me_rename2preg.cpp
index 79b27b6cada8b0725e2a4594f4f9ac8c0126a252..466b1f740faa9385b5fdd592c432d5e32ca0a796 100644
--- a/src/mapleall/maple_me/src/me_rename2preg.cpp
+++ b/src/mapleall/maple_me/src/me_rename2preg.cpp
@@ -91,7 +91,7 @@ RegMeExpr *SSARename2Preg::RenameVar(const VarMeExpr *varmeexpr) {
         reg_formal_vec[parmindex] = curtemp;
       }
     }
-    rename2pregCount++;
+    ++rename2pregCount;
     if (DEBUGFUNC(func)) {
       ost->Dump();
       LogInfo::MapleLogger() << "(ost idx " << ost->GetIndex() << ") renamed to ";
diff --git a/src/mapleall/maple_me/src/me_store_pre.cpp b/src/mapleall/maple_me/src/me_store_pre.cpp
index f69e9829e185b37e39c242ffea283b80ad382751..672e6cb31aa61623c41f70963671be19a98492fa 100644
--- a/src/mapleall/maple_me/src/me_store_pre.cpp
+++ b/src/mapleall/maple_me/src/me_store_pre.cpp
@@ -370,6 +370,9 @@ AnalysisResult *MeDoStorePre::Run(MeFunction *func, MeFuncResultMgr *m, ModuleRe
   ASSERT(aliasClass != nullptr, "aliasClass phase has problem");
   auto *meIrMap = static_cast<MeIRMap*>(m->GetAnalysisResult(MeFuncPhase_IRMAPBUILD, func));
   CHECK_FATAL(meIrMap != nullptr, "irmap phase has problem");
+  if (!meIrMap->GetMIRModule().IsCModule()) {
+    return nullptr;
+  }
   MeStorePre storePre(*func, *dom, *aliasClass, *NewMemPool(), DEBUGFUNC(func));
   storePre.ApplySSUPre();
   if (DEBUGFUNC(func)) {
diff --git a/src/mplfe/ast_input/include/ast_expr.h b/src/mplfe/ast_input/include/ast_expr.h
index 044dd12eccc014ff83d1304e6d573ce1d51016f8..db23967aa9a3fecd2b64807d7473310def43ec01 100644
--- a/src/mplfe/ast_input/include/ast_expr.h
+++ b/src/mplfe/ast_input/include/ast_expr.h
@@ -619,13 +619,24 @@ class ASTCallExpr : public ASTExpr {
     return funcName;
   }
 
+  void SetIcall(bool icall) {
+    isIcall = icall;
+  }
+
+  bool IsIcall() const {
+    return isIcall;
+  }
+
  private:
   UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  UniqueFEIRExpr Emit2FEExprCall(std::list<UniqueFEIRStmt> &stmts) const;
+  UniqueFEIRExpr Emit2FEExprICall(std::list<UniqueFEIRStmt> &stmts) const;
 
   std::vector<ASTExpr*> args;
   ASTExpr *calleeExpr = nullptr;
   MIRType *retType = nullptr;
   std::string funcName;
+  bool isIcall = false;
 };
 
 class ASTParenExpr : public ASTExpr {
@@ -996,6 +1007,13 @@ class ASTAtomicExpr : public ASTExpr {
     val2Type = ty;
   }
 
+  void SetFromStmt(bool fromStmt) {
+    isFromStmt = fromStmt;
+  }
+
+  bool IsFromStmt() const {
+    return isFromStmt;
+  }
  private:
   UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
   MIRType *type = nullptr;
@@ -1006,6 +1024,7 @@ class ASTAtomicExpr : public ASTExpr {
   ASTExpr *valExpr1 = nullptr;
   ASTExpr *valExpr2 = nullptr;
   ASTAtomicOp atomicOp;
+  bool isFromStmt = false;
 };
 }
 #endif //MPLFE_AST_INPUT_INCLUDE_AST_EXPR_H
diff --git a/src/mplfe/ast_input/include/ast_op.h b/src/mplfe/ast_input/include/ast_op.h
index cbf71db489898a1c582e38bfa703befecc6c0d81..76c2590ec4f6bca51d86182e9b153ec4f1d46c66 100644
--- a/src/mplfe/ast_input/include/ast_op.h
+++ b/src/mplfe/ast_input/include/ast_op.h
@@ -157,6 +157,7 @@ enum ASTStmtOp {
   kASTStmtStmtExpr,
   kASTStmtCStyleCastExpr,
   kASTStmtCallExpr,
+  kASTStmtAtomicExpr
 };
 }  // namespace maple
 #endif  // MPLFE_AST_INPUT_INCLUDE_AST_OP_H
diff --git a/src/mplfe/ast_input/include/ast_parser.h b/src/mplfe/ast_input/include/ast_parser.h
index 75696ff16a091fca15513e42211a5c997b46527e..3e85331e31ec6dbfc1f2224043156b6775f6a6ed 100644
--- a/src/mplfe/ast_input/include/ast_parser.h
+++ b/src/mplfe/ast_input/include/ast_parser.h
@@ -75,6 +75,7 @@ class ASTParser {
   ASTStmt *PROCESS_STMT(NullStmt);
   ASTStmt *PROCESS_STMT(CStyleCastExpr);
   ASTStmt *PROCESS_STMT(DeclStmt);
+  ASTStmt *PROCESS_STMT(AtomicExpr);
   bool HasDefault(const clang::Stmt &stmt);
 
   // ProcessExpr
diff --git a/src/mplfe/ast_input/include/ast_stmt.h b/src/mplfe/ast_input/include/ast_stmt.h
index daa94214acd1300b69636a67963b75ea735b22c3..737753170329adb39a24c0ab90aab4ac349eeed1 100644
--- a/src/mplfe/ast_input/include/ast_stmt.h
+++ b/src/mplfe/ast_input/include/ast_stmt.h
@@ -452,6 +452,17 @@ class ASTCallExprStmt : public ASTStmt {
   ASTCallExprStmt() : ASTStmt(kASTStmtCallExpr) {}
   ~ASTCallExprStmt() override = default;
 
+ private:
+  std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
+  std::list<UniqueFEIRStmt> Emit2FEStmtCall() const;
+  std::list<UniqueFEIRStmt> Emit2FEStmtICall() const;
+};
+
+class ASTAtomicExprStmt : public ASTStmt {
+ public:
+  ASTAtomicExprStmt() : ASTStmt(kASTStmtAtomicExpr) {}
+  ~ASTAtomicExprStmt() override = default;
+
  private:
   std::list<UniqueFEIRStmt> Emit2FEStmtImpl() const override;
 };
diff --git a/src/mplfe/ast_input/src/ast_expr.cpp b/src/mplfe/ast_input/src/ast_expr.cpp
index b80d8896b58c8cd55dcf23cc18e2d0b8c4b74fa3..577683d8006bbd86c0d3946fea67ed1e36273607 100644
--- a/src/mplfe/ast_input/src/ast_expr.cpp
+++ b/src/mplfe/ast_input/src/ast_expr.cpp
@@ -47,7 +47,7 @@ UniqueFEIRExpr ASTDeclRefExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts)
 }
 
 // ---------- ASTCallExpr ----------
-UniqueFEIRExpr ASTCallExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+UniqueFEIRExpr ASTCallExpr::Emit2FEExprCall(std::list<UniqueFEIRStmt> &stmts) const {
   // callassigned &funcName
   StructElemNameIdx *nameIdx = FEManager::GetManager().GetStructElemMempool()->New<StructElemNameIdx>(funcName);
   FEStructMethodInfo *info = static_cast<FEStructMethodInfo*>(
@@ -60,6 +60,8 @@ UniqueFEIRExpr ASTCallExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) co
     callStmt->AddExprArgReverse(std::move(expr));
   }
   // return
+  FEIRTypeNative *retTypeInfo = FEManager::GetManager().GetModule().GetMemPool()->New<FEIRTypeNative>(*retType);
+  info->SetReturnType(retTypeInfo);
   if (retType->GetPrimType() != PTY_void) {
     const std::string &varName = FEUtils::GetSequentialName("retVar_");
     UniqueFEIRVar var = FEIRBuilder::CreateVarNameForC(varName, *retType, false, false);
@@ -68,9 +70,37 @@ UniqueFEIRExpr ASTCallExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) co
     stmts.emplace_back(std::move(callStmt));
     return FEIRBuilder::CreateExprDRead(std::move(dreadVar));
   }
+  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
+  UniqueFEIRExpr expr = calleeExpr->Emit2FEExpr(stmts);
+  icallStmt->AddExprArgReverse(std::move(expr));
+  // return
+  if (retType->GetPrimType() != PTY_void) {
+    const std::string &varName = FEUtils::GetSequentialName("retVar_");
+    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::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
+  if (isIcall) {
+    return Emit2FEExprICall(stmts);
+  } else {
+    return Emit2FEExprCall(stmts);
+  }
+}
+
 // ---------- ASTImplicitCastExpr ----------
 UniqueFEIRExpr ASTImplicitCastExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
   const ASTExpr *childExpr = child;
@@ -756,12 +786,25 @@ UniqueFEIRExpr ASTDependentScopeDeclRefExpr::Emit2FEExprImpl(std::list<UniqueFEI
 
 // ---------- ASTAtomicExpr ----------
 UniqueFEIRExpr ASTAtomicExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
-  UniqueFEIRExpr atomicExpr = std::make_unique<FEIRExprAtomic>(type, refType, objExpr->Emit2FEExpr(stmts),
-                                                               valExpr1->Emit2FEExpr(stmts),
-                                                               valExpr2->Emit2FEExpr(stmts),
-                                                               atomicOp);
-  static_cast<FEIRExprAtomic*>(atomicExpr.get())->SetVal1Type(val1Type);
-  static_cast<FEIRExprAtomic*>(atomicExpr.get())->SetVal2Type(val2Type);
+  auto atomicExpr = std::make_unique<FEIRExprAtomic>(type, refType, objExpr->Emit2FEExpr(stmts), atomicOp);
+  if (atomicOp != kAtomicOpLoad) {
+    static_cast<FEIRExprAtomic*>(atomicExpr.get())->SetVal1Expr(valExpr1->Emit2FEExpr(stmts));
+    static_cast<FEIRExprAtomic*>(atomicExpr.get())->SetVal1Type(val1Type);
+  }
+
+  if (atomicOp == kAtomicOpCompareExchange) {
+    static_cast<FEIRExprAtomic*>(atomicExpr.get())->SetVal2Expr(valExpr2->Emit2FEExpr(stmts));
+    static_cast<FEIRExprAtomic*>(atomicExpr.get())->SetVal2Type(val2Type);
+  }
+  auto lock = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("lockVar"), *type, false, false);
+  auto var = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("valueVar"), *refType, false, false);
+  atomicExpr->SetLockVar(lock->Clone());
+  atomicExpr->SetValVar(var->Clone());
+  if (!isFromStmt) {
+    auto stmt = std::make_unique<FEIRStmtAtomic>(std::move(atomicExpr));
+    stmts.emplace_back(std::move(stmt));
+    return FEIRBuilder::CreateExprDRead(var->Clone());
+  }
   return atomicExpr;
 }
 }
diff --git a/src/mplfe/ast_input/src/ast_parser.cpp b/src/mplfe/ast_input/src/ast_parser.cpp
index c0b25b3226a585da19be97debdc8cbd3a1f3f2f1..584b004b1d8da237ac66873a641a9068d43fecf5 100644
--- a/src/mplfe/ast_input/src/ast_parser.cpp
+++ b/src/mplfe/ast_input/src/ast_parser.cpp
@@ -121,6 +121,7 @@ ASTStmt *ASTParser::ProcessStmt(MapleAllocator &allocator, const clang::Stmt &st
     STMT_CASE(CStyleCastExpr);
     STMT_CASE(DeclStmt);
     STMT_CASE(NullStmt);
+    STMT_CASE(AtomicExpr);
     default:
       return nullptr;
   }
@@ -265,6 +266,18 @@ ASTStmt *ASTParser::ProcessStmtCompoundAssignOperator(MapleAllocator &allocator,
   return astCAOStmt;
 }
 
+ASTStmt *ASTParser::ProcessStmtAtomicExpr(MapleAllocator &allocator, const clang::AtomicExpr &atomicExpr) {
+  ASTAtomicExprStmt *astAtomicExprStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTAtomicExprStmt>(allocator);
+  CHECK_FATAL(astAtomicExprStmt != nullptr, "astAtomicExprStmt is nullptr");
+  ASTExpr *astExpr = ProcessExpr(allocator, &atomicExpr);
+  if (astExpr == nullptr) {
+    return nullptr;
+  }
+  static_cast<ASTAtomicExpr*>(astExpr)->SetFromStmt(true);
+  astAtomicExprStmt->SetASTExpr(astExpr);
+  return astAtomicExprStmt;
+}
+
 ASTStmt *ASTParser::ProcessStmtReturnStmt(MapleAllocator &allocator, const clang::ReturnStmt &retStmt) {
   ASTReturnStmt *astStmt = ASTDeclsBuilder::ASTStmtBuilder<ASTReturnStmt>(allocator);
   CHECK_FATAL(astStmt != nullptr, "astStmt is nullptr");
@@ -1034,7 +1047,7 @@ ASTExpr *ASTParser::ProcessExprCallExpr(MapleAllocator &allocator, const clang::
     }
     astCallExpr->SetFuncName(funcName);
   } else {
-    CHECK_FATAL(false, "funcDecl is nullptr NYI.");
+    astCallExpr->SetIcall(true);
   }
   return astCallExpr;
 }
@@ -1275,10 +1288,11 @@ ASTExpr *ASTParser::ProcessExprAtomicExpr(MapleAllocator &allocator,
   astExpr->SetObjExpr(ProcessExpr(allocator, atomicExpr.getPtr()));
   astExpr->SetType(astFile->CvtType(atomicExpr.getPtr()->getType()));
   astExpr->SetRefType(astFile->CvtType(atomicExpr.getPtr()->getType()->getPointeeType()));
-  astExpr->SetValExpr1(ProcessExpr(allocator, atomicExpr.getVal1()));
-  astExpr->SetValExpr2(ProcessExpr(allocator, atomicExpr.getVal2()));
-  astExpr->SetVal1Type(astFile->CvtType(atomicExpr.getVal1()->getType()));
-  astExpr->SetVal2Type(astFile->CvtType(atomicExpr.getVal2()->getType()));
+  if (atomicExpr.getOp() != clang::AtomicExpr::AO__atomic_load_n &&
+      atomicExpr.getOp() != clang::AtomicExpr::AO__c11_atomic_load) {
+    astExpr->SetValExpr1(ProcessExpr(allocator, atomicExpr.getVal1()));
+    astExpr->SetVal1Type(astFile->CvtType(atomicExpr.getVal1()->getType()));
+  }
   switch (atomicExpr.getOp()) {
     case clang::AtomicExpr::AO__atomic_add_fetch:
     case clang::AtomicExpr::AO__atomic_fetch_add:
@@ -1318,6 +1332,8 @@ ASTExpr *ASTParser::ProcessExprAtomicExpr(MapleAllocator &allocator,
     case clang::AtomicExpr::AO__atomic_compare_exchange_n:
     case clang::AtomicExpr::AO__c11_atomic_compare_exchange_weak:
     case clang::AtomicExpr::AO__c11_atomic_compare_exchange_strong:
+      astExpr->SetValExpr2(ProcessExpr(allocator, atomicExpr.getVal2()));
+      astExpr->SetVal2Type(astFile->CvtType(atomicExpr.getVal2()->getType()));
       astExpr->SetAtomicOp(kAtomicOpCompareExchange);
       break;
     default:
diff --git a/src/mplfe/ast_input/src/ast_stmt.cpp b/src/mplfe/ast_input/src/ast_stmt.cpp
index 66b5b3e68569a7af07b0cacaca61237a6d16111d..1adee71e4f65ced6809e17c16290816d0f5b4c50 100644
--- a/src/mplfe/ast_input/src/ast_stmt.cpp
+++ b/src/mplfe/ast_input/src/ast_stmt.cpp
@@ -238,7 +238,7 @@ std::list<UniqueFEIRStmt> ASTDeclStmt::Emit2FEStmtImpl() const {
 }
 
 // ---------- ASTCallExprStmt ----------
-std::list<UniqueFEIRStmt> ASTCallExprStmt::Emit2FEStmtImpl() const {
+std::list<UniqueFEIRStmt> ASTCallExprStmt::Emit2FEStmtCall() const {
   std::list<UniqueFEIRStmt> stmts;
   ASTCallExpr *callExpr = static_cast<ASTCallExpr*>(exprs.front());
   // callassigned &funcName
@@ -255,16 +255,47 @@ std::list<UniqueFEIRStmt> ASTCallExprStmt::Emit2FEStmtImpl() const {
     callStmt->AddExprArgReverse(std::move(expr));
   }
   // return
-  PrimType primType = callExpr->GetRetType()->GetPrimType();
-  if (primType != PTY_void) {
+  MIRType *retType = callExpr->GetRetType();
+  FEIRTypeNative *retTypeInfo = FEManager::GetManager().GetModule().GetMemPool()->New<FEIRTypeNative>(*retType);
+  info->SetReturnType(retTypeInfo);
+  if (retType->GetPrimType() != PTY_void) {
     const std::string &varName = FEUtils::GetSequentialName("retVar_");
-    UniqueFEIRVar var = FEIRBuilder::CreateVarNameForC(varName, *(callExpr->GetRetType()), false, false);
+    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>();
+  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) {
+    const std::string &varName = FEUtils::GetSequentialName("retVar_");
+    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 {
+  ASTCallExpr *callExpr = static_cast<ASTCallExpr*>(exprs.front());
+  if (callExpr->IsIcall()) {
+    return Emit2FEStmtICall();
+  } else {
+    return Emit2FEStmtCall();
+  }
+}
+
 // ---------- ASTImplicitCastExprStmt ----------
 std::list<UniqueFEIRStmt> ASTImplicitCastExprStmt::Emit2FEStmtImpl() const {
   CHECK_FATAL(exprs.size() == 1, "Only one sub expr supported!");
@@ -279,8 +310,8 @@ std::list<UniqueFEIRStmt> ASTImplicitCastExprStmt::Emit2FEStmtImpl() const {
 
 // ---------- ASTParenExprStmt ----------
 std::list<UniqueFEIRStmt> ASTParenExprStmt::Emit2FEStmtImpl() const {
-  CHECK_FATAL(false, "NYI");
   std::list<UniqueFEIRStmt> stmts;
+  exprs.front()->Emit2FEExpr(stmts);
   return stmts;
 }
 
@@ -353,4 +384,14 @@ std::list<UniqueFEIRStmt> ASTBinaryOperatorStmt::Emit2FEStmtImpl() const {
   }
   return stmts;
 }
+
+// ---------- ASTAtomicExprStmt ----------
+std::list<UniqueFEIRStmt> ASTAtomicExprStmt::Emit2FEStmtImpl() const {
+  std::list<UniqueFEIRStmt> stmts;
+  auto astExpr = exprs.front();
+  UniqueFEIRExpr feExpr = astExpr->Emit2FEExpr(stmts);
+  auto stmt = std::make_unique<FEIRStmtAtomic>(std::move(feExpr));
+  stmts.emplace_back(std::move(stmt));
+  return stmts;
+}
 } // namespace maple
diff --git a/src/mplfe/common/include/fe_struct_elem_info.h b/src/mplfe/common/include/fe_struct_elem_info.h
index a7e8e0efedd3f28b62dc2057f6706bf94596b5e0..e61eab49ea32c34397281c12a8940b0cae42230d 100644
--- a/src/mplfe/common/include/fe_struct_elem_info.h
+++ b/src/mplfe/common/include/fe_struct_elem_info.h
@@ -208,6 +208,10 @@ class FEStructMethodInfo : public FEStructElemInfo {
     return retType;
   }
 
+  void SetReturnType(FEIRType *type) {
+    retType = type;
+  }
+
   const FEIRType *GetOwnerType() const {
     return ownerType;
   }
@@ -216,6 +220,10 @@ class FEStructMethodInfo : public FEStructElemInfo {
     return argTypes;
   }
 
+  void SetArgTypes(const MapleVector<FEIRType*> &argTypesIn) {
+    argTypes = argTypesIn;
+  }
+
  LLT_PROTECTED:
   void PrepareImpl(MIRBuilder &mirBuilder, bool argIsStatic) override;
 
@@ -223,6 +231,7 @@ class FEStructMethodInfo : public FEStructElemInfo {
   void LoadMethodType();
   void LoadMethodTypeJava();
   void PrepareMethod();
+  void PrepareMethodC();
   void PrepareImplJava(MIRBuilder &mirBuilder, bool argIsStatic);
   bool SearchStructMethodJava(MIRStructType &structType, MIRBuilder &mirBuilder, bool argIsStatic,
                               bool allowPrivate = true);
diff --git a/src/mplfe/common/include/fe_type_manager.h b/src/mplfe/common/include/fe_type_manager.h
index e3208c823b8299bedde073e77dea5d82660579c6..bc649f1099904880fc7f6ef38da031518183a590 100644
--- a/src/mplfe/common/include/fe_type_manager.h
+++ b/src/mplfe/common/include/fe_type_manager.h
@@ -144,6 +144,8 @@ class FETypeManager {
       const StructElemNameIdx &argStructElemNameIdx, MIRSrcLang argSrcLang, bool isStatic);
   FEStructElemInfo *RegisterStructMethodInfo(
       const StructElemNameIdx &argStructElemNameIdx, MIRSrcLang argSrcLang, bool isStatic);
+  FEStructElemInfo *RegisterStructMethodInfoC(
+      const std::string &name, MIRSrcLang argSrcLang, bool isStatic);
   FEStructElemInfo *GetStructElemInfo(const GStrIdx &fullNameIdx) const;
 
   // ---------- methods for MIRFunction ----------
diff --git a/src/mplfe/common/include/feir_node_kind.def b/src/mplfe/common/include/feir_node_kind.def
index 2b306546a224bf14f8d45ccb9abdcc68f9821e41..4877152e73f26dfe366301448bf669f773b8489a 100644
--- a/src/mplfe/common/include/feir_node_kind.def
+++ b/src/mplfe/common/include/feir_node_kind.def
@@ -10,6 +10,7 @@ FEIR_NODE_KIND(StmtJavaConstClass, "StmtJavaConstClass")
 FEIR_NODE_KIND(StmtJavaConstString, "StmtJavaConstString")
 FEIR_NODE_KIND(StmtJavaMultiANewArray, "StmtJavaMultiANewArray")
 FEIR_NODE_KIND(StmtCallAssign, "StmtCallAssign")
+FEIR_NODE_KIND(StmtICallAssign, "StmtICallAssign")
 FEIR_NODE_KIND(StmtJavaDynamicCallAssign, "StmtJavaDynamicCallAssign")
 FEIR_NODE_KIND(StmtIntrinsicCallAssign, "StmtIntrinsicCallAssign")
 FEIR_NODE_KIND(StmtIAssign, "StmtIAssign")
@@ -70,3 +71,4 @@ FEIR_NODE_KIND(StmtDoWhile, "StmtDoWhile")
 FEIR_NODE_KIND(StmtBreak, "StmtBreak")
 FEIR_NODE_KIND(StmtContinue, "StmtContinue")
 FEIR_NODE_KIND(StmtLabel, "StmtLabel")
+FEIR_NODE_KIND(StmtAtomic, "StmtAtomic")
diff --git a/src/mplfe/common/include/feir_stmt.h b/src/mplfe/common/include/feir_stmt.h
index f0847424d535a662196b0d3a5edefe5f70360862..6456f93d8be450ef9b03b80c912c8b6aa446b67d 100644
--- a/src/mplfe/common/include/feir_stmt.h
+++ b/src/mplfe/common/include/feir_stmt.h
@@ -957,17 +957,33 @@ enum ASTAtomicOp {
 
 class FEIRExprAtomic : public FEIRExpr {
  public:
-  FEIRExprAtomic(MIRType *ty, MIRType *ref, UniqueFEIRExpr obj, UniqueFEIRExpr val1,
-                 UniqueFEIRExpr val2,
-                 ASTAtomicOp atomOp);
+  FEIRExprAtomic(MIRType *ty, MIRType *ref, UniqueFEIRExpr obj, ASTAtomicOp atomOp);
   ~FEIRExprAtomic() = default;
+
   void SetVal1Type(MIRType *ty) {
     val1Type = ty;
   }
+
+  void SetVal1Expr(UniqueFEIRExpr expr) {
+    valExpr1 = std::move(expr);
+  }
+
   void SetVal2Type(MIRType *ty) {
     val2Type = ty;
   }
 
+  void SetVal2Expr(UniqueFEIRExpr expr) {
+    valExpr2 = std::move(expr);
+  }
+
+  void SetValVar(UniqueFEIRVar value) {
+    val = std::move(value);
+  }
+
+  void SetLockVar(UniqueFEIRVar value) {
+    lock = std::move(value);
+  }
+
  protected:
   std::unique_ptr<FEIRExpr> CloneImpl() const override;
   BaseNode *GenMIRNodeImpl(MIRBuilder &mirBuilder) const override;
@@ -990,6 +1006,8 @@ class FEIRExprAtomic : public FEIRExpr {
   UniqueFEIRExpr valExpr1;
   UniqueFEIRExpr valExpr2;
   ASTAtomicOp atomicOp;
+  UniqueFEIRVar lock;
+  UniqueFEIRVar val;
 };
 
 // ---------- FEIRStmtNary ----------
@@ -1761,6 +1779,29 @@ class FEIRStmtCallAssign : public FEIRStmtAssign {
   static std::map<Opcode, Opcode> mapOpToOpAssign;
 };
 
+// ---------- FEIRStmtICallAssign ----------
+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 ----------
 class FEIRStmtIntrinsicCallAssign : public FEIRStmtAssign {
  public:
@@ -2095,5 +2136,15 @@ class FEIRStmtLabel : public FEIRStmt {
  private:
   std::string labelName;
 };
+
+class FEIRStmtAtomic : public FEIRStmt {
+ public:
+  FEIRStmtAtomic(UniqueFEIRExpr expr);
+  ~FEIRStmtAtomic() = default;
+
+ protected:
+  std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+  UniqueFEIRExpr atomicExpr;
+};
 }  // namespace maple
 #endif  // MPLFE_INCLUDE_COMMON_FEIR_STMT_H
diff --git a/src/mplfe/common/src/fe_struct_elem_info.cpp b/src/mplfe/common/src/fe_struct_elem_info.cpp
index 3855f40fc76a7b14971c730fb8c17c6b95e31c38..b854ce68b16d3f61ed09d5eebbe329daa17cbd89 100644
--- a/src/mplfe/common/src/fe_struct_elem_info.cpp
+++ b/src/mplfe/common/src/fe_struct_elem_info.cpp
@@ -248,7 +248,8 @@ void FEStructMethodInfo::PrepareImpl(MIRBuilder &mirBuilder, bool argIsStatic) {
       PrepareImplJava(mirBuilder, argIsStatic);
       break;
     case kSrcLangC:
-      break;
+      PrepareMethodC();
+      return;
     default:
       CHECK_FATAL(false, "unsupported src lang");
   }
@@ -320,6 +321,23 @@ void FEStructMethodInfo::LoadMethodTypeJava() {
   static_cast<FEIRTypeDefault*>(ownerType)->LoadFromJavaTypeName(GetStructName(), true);
 }
 
+void FEStructMethodInfo::PrepareMethodC() {
+  mirFunc = FEManager::GetTypeManager().GetMIRFunction(methodNameIdx, isStatic);
+  if (mirFunc == nullptr) {
+    // This branch should not be used for C languages, and mirFunc must not be nullptr.
+    MIRType *mirRetType = retType->GenerateMIRTypeAuto(srcLang);
+    bool isVarg = false; // need to update
+    std::vector<TyIdx> argsTypeIdx;
+    for (const FEIRType *argType : argTypes) {
+      MIRType *mirArgType = argType->GenerateMIRTypeAuto(srcLang);
+      argsTypeIdx.push_back(mirArgType->GetTypeIndex());
+    }
+    mirFunc = FEManager::GetTypeManager().CreateFunction(methodNameIdx, mirRetType->GetTypeIndex(),
+                                                         argsTypeIdx, isVarg, isStatic);
+  }
+  isPrepared = true;
+}
+
 void FEStructMethodInfo::PrepareMethod() {
   mirFunc = FEManager::GetTypeManager().GetMIRFunction(methodNameIdx, isStatic);
   if (mirFunc == nullptr) {
diff --git a/src/mplfe/common/src/feir_stmt.cpp b/src/mplfe/common/src/feir_stmt.cpp
index be01d77ebf9d6460864e9c759c70541b5d36051f..0bdfbfbc3b1ad68c8c1cc34235154d2987ddbe7c 100644
--- a/src/mplfe/common/src/feir_stmt.cpp
+++ b/src/mplfe/common/src/feir_stmt.cpp
@@ -1678,6 +1678,57 @@ std::string FEIRStmtCallAssign::DumpDotStringImpl() const {
   return ss.str();
 }
 
+// ---------- FEIRStmtICallAssign ----------
+FEIRStmtICallAssign::FEIRStmtICallAssign()
+    : FEIRStmtAssign(FEIRNodeKind::kStmtICallAssign, nullptr) {}
+
+void FEIRStmtICallAssign::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
+  CHECK_FATAL(false, "NYI");
+}
+
+bool FEIRStmtICallAssign::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) {
+  bool success = true;
+  for (const UniqueFEIRExpr &exprArg : exprArgs) {
+    success = success && exprArg->CalculateDefs4AllUses(checkPoint, udChain);
+  }
+  return success;
+}
+
+std::list<StmtNode*> FEIRStmtICallAssign::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> ans;
+  StmtNode *stmtICall = nullptr;
+  MapleVector<BaseNode*> args(mirBuilder.GetCurrentFuncCodeMpAllocator()->Adapter());
+  args.reserve(exprArgs.size());
+  for (const UniqueFEIRExpr &exprArg : exprArgs) {
+    BaseNode *node = exprArg->GenMIRNode(mirBuilder);
+    args.push_back(node);
+  }
+  MIRSymbol *retVarSym = nullptr;
+  if (var != nullptr) {
+    retVarSym = var->GenerateLocalMIRSymbol(mirBuilder);
+    stmtICall = mirBuilder.CreateStmtIcallAssigned(std::move(args), *retVarSym);
+  } else {
+    stmtICall = mirBuilder.CreateStmtIcall(std::move(args));
+  }
+  ans.push_back(stmtICall);
+  return ans;
+}
+
+std::string FEIRStmtICallAssign::DumpDotStringImpl() const {
+  std::stringstream ss;
+  ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
+  if (var != nullptr) {
+    ss << " def : " << var->GetNameRaw() << ", ";
+  }
+  if (exprArgs.size() > 0) {
+    ss << " uses : ";
+    for (const UniqueFEIRExpr &exprArg : exprArgs) {
+      ss << exprArg->DumpDotString() << ", ";
+    }
+  }
+  return ss.str();
+}
+
 // ---------- FEIRStmtIntrinsicCallAssign ----------
 FEIRStmtIntrinsicCallAssign::FEIRStmtIntrinsicCallAssign(MIRIntrinsicID id, UniqueFEIRType typeIn,
                                                          UniqueFEIRVar argVarRet)
@@ -3138,20 +3189,23 @@ BaseNode *FEIRExprCStyleCast::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
 }
 
 // ---------- FEIRExprAtomic ----------
-FEIRExprAtomic::FEIRExprAtomic(MIRType *ty, MIRType *ref, UniqueFEIRExpr obj, UniqueFEIRExpr val1,
-                               UniqueFEIRExpr val2,
-                               ASTAtomicOp atomOp)
+FEIRExprAtomic::FEIRExprAtomic(MIRType *ty, MIRType *ref, UniqueFEIRExpr obj, ASTAtomicOp atomOp)
     : FEIRExpr(FEIRNodeKind::kExprAtomic),
       mirType(ty),
       refType(ref),
       objExpr(std::move(obj)),
-      valExpr1(std::move(val1)),
-      valExpr2(std::move(val2)),
       atomicOp(atomOp) {}
 
 std::unique_ptr<FEIRExpr> FEIRExprAtomic::CloneImpl() const {
-  std::unique_ptr<FEIRExpr> expr = std::make_unique<FEIRExprAtomic>(mirType, refType, objExpr->Clone(),
-                                                                    valExpr1->Clone(), valExpr2->Clone(), atomicOp);
+  std::unique_ptr<FEIRExpr> expr = std::make_unique<FEIRExprAtomic>(mirType, refType, objExpr->Clone(), atomicOp);
+  static_cast<FEIRExprAtomic*>(expr.get())->SetVal1Type(val1Type);
+  if (valExpr1.get() != nullptr) {
+    static_cast<FEIRExprAtomic*>(expr.get())->SetVal1Expr(valExpr1->Clone());
+  }
+  static_cast<FEIRExprAtomic*>(expr.get())->SetVal1Type(val2Type);
+  if (valExpr2.get() != nullptr) {
+    static_cast<FEIRExprAtomic*>(expr.get())->SetVal1Expr(valExpr2->Clone());
+  }
   return expr;
 }
 
@@ -3207,6 +3261,7 @@ void FEIRExprAtomic::ProcessAtomicExchange(MIRBuilder &mirBuilder, BlockNode &bl
   StmtNode *setStmt = mirBuilder.CreateStmtIassign(*mirType, 0, &lockNode, constNode);
   block.AddStatement(setStmt);
 }
+
 void FEIRExprAtomic::ProcessAtomicCompareExchange(MIRBuilder &mirBuilder, BlockNode &block, BaseNode &lockNode,
                                                   const MIRSymbol *valueVar) const {
 #ifndef USE_OPS
@@ -3233,23 +3288,14 @@ void FEIRExprAtomic::ProcessAtomicCompareExchange(MIRBuilder &mirBuilder, BlockN
 }
 
 BaseNode *FEIRExprAtomic::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
-  BlockNode *block = nullptr;
+  MIRModule &module = FEManager::GetModule();
+  BlockNode *block = module.CurFuncCodeMemPool()->New<BlockNode>();
   BaseNode *objNode = objExpr.get()->GenMIRNode(mirBuilder);
-#ifndef USE_OPS
-  MIRSymbol *lockVar = SymbolBuilder::Instance().GetOrCreateLocalSymbol(*mirType, FEUtils::GetSequentialName("lockVar"),
-                                                                        *mirBuilder.GetCurrentFunction());
-  MIRSymbol *valueVar = SymbolBuilder::Instance().GetOrCreateLocalSymbol(*refType,
-                                                                         FEUtils::GetSequentialName("valueVar"),
-                                                                         *mirBuilder.GetCurrentFunction());
-#else
-  MIRSymbol *lockVar = mirBuilder.GetOrCreateLocalDecl(FEUtils::GetSequentialName("lockVar").c_str(), *mirType);
-  MIRSymbol *valueVar = mirBuilder.GetOrCreateLocalDecl(FEUtils::GetSequentialName("valueVar").c_str(), *refType);
-#endif
+  MIRSymbol *lockVar = lock->GenerateMIRSymbol(mirBuilder);
+  MIRSymbol *valueVar = val->GenerateMIRSymbol(mirBuilder);
   BaseNode *lockNode = mirBuilder.CreateExprDread(*lockVar);
   StmtNode *fetchStmt = mirBuilder.CreateStmtIassign(*mirType, 0, lockNode, objNode);
   ASSERT_NOT_NULL(fetchStmt);
-  MIRModule &module = FEManager::GetModule();
-  block = module.CurFuncCodeMemPool()->New<BlockNode>();
   block->AddStatement(fetchStmt);
   NaryStmtNode *syncenter = mirBuilder.CreateStmtNary(OP_syncenter, lockNode);
   block->AddStatement(syncenter);
@@ -3285,8 +3331,7 @@ BaseNode *FEIRExprAtomic::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
   }
   NaryStmtNode *syncExit = mirBuilder.CreateStmtNary(OP_syncexit, lockNode);
   block->AddStatement(syncExit);
-  BaseNode *valueNode = mirBuilder.CreateExprDread(*valueVar);
-  return valueNode;
+  return block;
 }
 
 // ---------- FEIRStmtPesudoLabel ----------
@@ -3576,4 +3621,18 @@ std::list<StmtNode*> FEIRStmtContinue::GenMIRStmtsImpl(MIRBuilder &mirBuilder) c
 std::list<StmtNode*> FEIRStmtLabel::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
   return std::list<StmtNode*>{mirBuilder.CreateStmtLabel(mirBuilder.GetOrCreateMIRLabel(labelName))};
 }
+
+FEIRStmtAtomic::FEIRStmtAtomic(UniqueFEIRExpr expr)
+    : FEIRStmt(FEIRNodeKind::kStmtAtomic),
+      atomicExpr(std::move(expr)) {}
+
+std::list<StmtNode*> FEIRStmtAtomic::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
+  std::list<StmtNode*> stmts;
+  FEIRExprAtomic *atom = static_cast<FEIRExprAtomic*>(atomicExpr.get());
+  auto block = static_cast<BlockNode*>(atom->GenMIRNode(mirBuilder));
+  for (auto &it : block->GetStmtNodes()) {
+    stmts.emplace_back(&it);
+  }
+  return stmts;
+}
 }  // namespace maple