diff --git a/src/mapleall/bin/dex2mpl b/src/mapleall/bin/dex2mpl
index 5174665b4f0eb3132871557c1342e98c4f435b7a..6f68dc5596479d81c0c9cebb857bd5e61c6d00bc 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 92d72e120484a5d198121e4a58dab5da74778d8d..22712adc9a6e33d974ae714f66e1dd9233b651c7 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 ed17e9c55644883ca698a82f29869877ad31f1e2..94253141a2abf7901d05cfae7f0d8729b8f01dcb 100755
Binary files a/src/mapleall/bin/jbc2mpl and b/src/mapleall/bin/jbc2mpl differ
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_dependence.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_dependence.h
index 0470eece41dd53a3fdb55195c6c1868406d3d20b..2c0c1766cff697ed4a44ef3f67b45b5683d2a123 100644
--- a/src/mapleall/maple_be/include/cg/aarch64/aarch64_dependence.h
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_dependence.h
@@ -49,8 +49,8 @@ class AArch64DepAnalysis : public DepAnalysis {
   bool NeedBuildDepsMem(const AArch64MemOperand &memOpnd, const AArch64MemOperand *nextMemOpnd, Insn &memInsn) const;
   void BuildDepsUseMem(Insn &insn, MemOperand &memOpnd) override;
   void BuildDepsDefMem(Insn &insn, MemOperand &memOpnd) override;
-  void BuildAntiDepsDefStackMem(Insn &insn, const AArch64MemOperand &memOpnd, const AArch64MemOperand *nextMemOpnd);
-  void BuildOutputDepsDefStackMem(Insn &insn, const AArch64MemOperand &memOpnd, const AArch64MemOperand *nextMemOpnd);
+  void BuildAntiDepsDefStackMem(Insn &insn, AArch64MemOperand &memOpnd, const AArch64MemOperand *nextMemOpnd);
+  void BuildOutputDepsDefStackMem(Insn &insn, AArch64MemOperand &memOpnd, const AArch64MemOperand *nextMemOpnd);
   void BuildDepsMemBar(Insn &insn) override;
   void BuildDepsSeparator(DepNode &newSepNode, MapleVector<DepNode*> &nodes) override;
   void BuildDepsControlAll(DepNode &depNode, const MapleVector<DepNode*> &nodes) override;
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_insn.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_insn.h
index a6d3512233a787c549f23a843b22fb22344ac4ae..3159b0da733a23420e1b6bbfb0cf273dcfc82568 100644
--- a/src/mapleall/maple_be/include/cg/aarch64/aarch64_insn.h
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_insn.h
@@ -163,6 +163,8 @@ class AArch64Insn : public Insn {
 
   bool CheckRefField(size_t opndIndex, bool isEmit) const;
 
+  uint8 GetLoadStoreSize() const;
+
  private:
   void CheckOpnd(Operand &opnd, OpndProp &mopd) const;
   void EmitClinit(const CG&, Emitter&) const;
diff --git a/src/mapleall/maple_be/include/cg/aarch64/aarch64_operand.h b/src/mapleall/maple_be/include/cg/aarch64/aarch64_operand.h
index 02f9a7e1f28b2e635f77f4c9b99c6b100ef5e07c..fd4ae2a9df244255abba33a3ed43b49011796322 100644
--- a/src/mapleall/maple_be/include/cg/aarch64/aarch64_operand.h
+++ b/src/mapleall/maple_be/include/cg/aarch64/aarch64_operand.h
@@ -739,6 +739,8 @@ class AArch64MemOperand : public MemOperand {
 
   bool NoAlias(AArch64MemOperand &rightOpnd) const;
 
+  bool NoOverlap(const AArch64MemOperand &rightOpnd) const;
+
   VaryType GetMemVaryType() override {
     Operand *ofstOpnd = GetOffsetOperand();
     if (ofstOpnd != nullptr) {
diff --git a/src/mapleall/maple_be/include/cg/insn.h b/src/mapleall/maple_be/include/cg/insn.h
index 50f24668f5f06f0449981385ebbf93c940a70ac2..2a17b56f268cdabeecd52e02b4f8ac7f7cd019b2 100644
--- a/src/mapleall/maple_be/include/cg/insn.h
+++ b/src/mapleall/maple_be/include/cg/insn.h
@@ -285,6 +285,10 @@ class Insn {
     return false;
   }
 
+  virtual bool NoOverlap() const {
+    return false;
+  }
+
   virtual bool IsVolatile() const {
     return false;
   }
diff --git a/src/mapleall/maple_be/include/cg/operand.h b/src/mapleall/maple_be/include/cg/operand.h
index 5c9e47337f4dc36ec47fd467b6c05662e30df83e..8b43f80f568e512037c58b72aee906089dc6802c 100644
--- a/src/mapleall/maple_be/include/cg/operand.h
+++ b/src/mapleall/maple_be/include/cg/operand.h
@@ -555,6 +555,14 @@ class MemOperand : public Operand {
     return kNotVary;
   }
 
+  void SetAccessSize(uint8 size) {
+    accessSize = size;
+  }
+
+  uint8 GetAccessSize() const {
+    return accessSize;
+  }
+
   bool Less(const Operand &right) const override = 0;
 
   MemOperand(uint32 size, const MIRSymbol &mirSymbol)
@@ -591,6 +599,7 @@ class MemOperand : public Operand {
   Operand *scaleOpnd = nullptr;
   const MIRSymbol *symbol;  /* AddrMode_Literal */
   uint32 memoryOrder = 0;
+  uint8 accessSize = 0;  /* temp, must be set right before use everytime. */
 };
 
 class LabelOperand : public Operand {
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_dependence.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_dependence.cpp
index b4e38bf6834bd6b40a407d682af8747298411d71..f8bb239dc90eaa7c5b243906fb0806c348f9c5cb 100644
--- a/src/mapleall/maple_be/src/cg/aarch64/aarch64_dependence.cpp
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_dependence.cpp
@@ -408,6 +408,7 @@ void AArch64DepAnalysis::BuildDepsUseMem(Insn &insn, MemOperand &memOpnd) {
   AArch64MemOperand &aarchMemOpnd = static_cast<AArch64MemOperand&>(memOpnd);
   AArch64MemOperand *nextMemOpnd = GetNextMemOperand(insn, aarchMemOpnd);
 
+  memOpnd.SetAccessSize(static_cast<AArch64Insn &>(insn).GetLoadStoreSize());
   /* Stack memory address */
   for (auto defInsn : stackDefs) {
     if (defInsn->IsCall() || NeedBuildDepsMem(aarchMemOpnd, nextMemOpnd, *defInsn)) {
@@ -434,6 +435,11 @@ bool AArch64DepAnalysis::NeedBuildDepsMem(const AArch64MemOperand &memOpnd, cons
   if (!memOpnd.NoAlias(*memOpndOfmemInsn) || ((nextMemOpnd != nullptr) && !nextMemOpnd->NoAlias(*memOpndOfmemInsn))) {
     return true;
   }
+  if (cgFunc.GetMirModule().GetSrcLang() == kSrcLangC && memInsn.IsCall() == false) {
+    static_cast<MemOperand*>(memInsn.GetMemOpnd())->SetAccessSize(
+        static_cast<AArch64Insn&>(memInsn).GetLoadStoreSize());
+    return (memOpnd.NoOverlap(*memOpndOfmemInsn) == false);
+  }
   AArch64MemOperand *nextMemOpndOfmemInsn = GetNextMemOperand(memInsn, *memOpndOfmemInsn);
   if (nextMemOpndOfmemInsn != nullptr) {
     if (!memOpnd.NoAlias(*nextMemOpndOfmemInsn) ||
@@ -450,8 +456,9 @@ bool AArch64DepAnalysis::NeedBuildDepsMem(const AArch64MemOperand &memOpnd, cons
  * memOpnd     : insn's memOpnd
  * nextMemOpnd : some memory pair operator instruction (like ldp/stp) defines two memory.
  */
-void AArch64DepAnalysis::BuildAntiDepsDefStackMem(Insn &insn, const AArch64MemOperand &memOpnd,
+void AArch64DepAnalysis::BuildAntiDepsDefStackMem(Insn &insn, AArch64MemOperand &memOpnd,
                                                   const AArch64MemOperand *nextMemOpnd) {
+  memOpnd.SetAccessSize(static_cast<AArch64Insn &>(insn).GetLoadStoreSize());
   for (auto *useInsn : stackUses) {
     if (NeedBuildDepsMem(memOpnd, nextMemOpnd, *useInsn)) {
       AddDependence(*useInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeAnti);
@@ -465,8 +472,9 @@ void AArch64DepAnalysis::BuildAntiDepsDefStackMem(Insn &insn, const AArch64MemOp
  * memOpnd     : insn's memOpnd
  * nextMemOpnd : some memory pair operator instruction (like ldp/stp) defines two memory.
  */
-void AArch64DepAnalysis::BuildOutputDepsDefStackMem(Insn &insn, const AArch64MemOperand &memOpnd,
+void AArch64DepAnalysis::BuildOutputDepsDefStackMem(Insn &insn, AArch64MemOperand &memOpnd,
                                                     const AArch64MemOperand *nextMemOpnd) {
+  memOpnd.SetAccessSize(static_cast<AArch64Insn &>(insn).GetLoadStoreSize());
   for (auto defInsn : stackDefs) {
     if (defInsn->IsCall() || NeedBuildDepsMem(memOpnd, nextMemOpnd, *defInsn)) {
       AddDependence(*defInsn->GetDepNode(), *insn.GetDepNode(), kDependenceTypeOutput);
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_insn.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_insn.cpp
index 7488ed7a7c6d3e45b5521561960d197767843095..ff31eb4a690aa5df39375c1047f232a0efc4697c 100644
--- a/src/mapleall/maple_be/src/cg/aarch64/aarch64_insn.cpp
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_insn.cpp
@@ -1129,6 +1129,54 @@ bool AArch64Insn::CheckRefField(size_t opndIndex, bool isEmit) const {
   return false;
 }
 
+uint8 AArch64Insn::GetLoadStoreSize() const {
+  if (IsLoadStorePair()) {
+    return k16ByteSize;
+  }
+  /* These are the loads and stores possible from PickLdStInsn() */
+  switch (mOp) {
+  case MOP_wldarb:
+  case MOP_wldrb:
+  case MOP_wldrsb:
+  case MOP_wstrb:
+  case MOP_wstlrb:
+    return k1ByteSize;
+  case MOP_wldrh:
+  case MOP_wldarh:
+  case MOP_wldrsh:
+  case MOP_wstrh:
+  case MOP_wstlrh:
+    return k2ByteSize;
+  case MOP_sldr:
+  case MOP_wldr:
+  case MOP_wldar:
+  case MOP_sstr:
+  case MOP_wstr:
+  case MOP_wstlr:
+    return k4ByteSize;
+  case MOP_dstr:
+  case MOP_xstr:
+  case MOP_xstlr:
+  case MOP_wstp:
+  case MOP_sstp:
+  case MOP_dldr:
+  case MOP_xldr:
+  case MOP_xldar:
+  case MOP_wldp:
+  case MOP_sldp:
+    return k8ByteSize;
+  case MOP_xldp:
+  case MOP_xldpsw:
+  case MOP_dldp:
+  case MOP_xstp:
+  case MOP_dstp:
+    return k16ByteSize;
+
+  default:
+    CHECK_FATAL(false, "Unsupported load/store op");
+  }
+}
+
 Operand *AArch64Insn::GetResult(uint32 id) const {
   ASSERT(id < GetResultNum(), "index out of range");
   const AArch64MD *md = &AArch64CG::kMd[mOp];
diff --git a/src/mapleall/maple_be/src/cg/aarch64/aarch64_operand.cpp b/src/mapleall/maple_be/src/cg/aarch64/aarch64_operand.cpp
index ed22795ad93ec655c8dd085b806cdf27fd0849f5..8076213897aa611bc4e48dc61afd30d861fe2b10 100644
--- a/src/mapleall/maple_be/src/cg/aarch64/aarch64_operand.cpp
+++ b/src/mapleall/maple_be/src/cg/aarch64/aarch64_operand.cpp
@@ -490,6 +490,23 @@ bool AArch64MemOperand::NoAlias(AArch64MemOperand &rightOpnd) const {
   return false;
 }
 
+bool AArch64MemOperand::NoOverlap(const AArch64MemOperand &rightOpnd) const {
+  if (addrMode != kAddrModeBOi || rightOpnd.addrMode != kAddrModeBOi || idxOpt != kIntact ||
+      rightOpnd.idxOpt != kIntact) {
+    return false;
+  }
+  if (GetBaseRegister()->GetRegisterNumber() != RFP || rightOpnd.GetBaseRegister()->GetRegisterNumber() != RFP) {
+    return false;
+  }
+  int64 ofset1 = GetOffsetOperand()->GetValue();
+  int64 ofset2 = rightOpnd.GetOffsetOperand()->GetValue();
+  if (ofset1 < ofset2) {
+    return ((ofset1 + GetAccessSize()) <= ofset2);
+  } else {
+    return ((ofset2 + rightOpnd.GetAccessSize()) <= ofset1);
+  }
+}
+
 /* sort the register operand according to their number */
 void AArch64ListOperand::Emit(Emitter &emitter, const OpndProp *opndProp) const {
   (void)opndProp;
diff --git a/src/mapleall/maple_driver/defs/default/O0_options_mpl2mpl_c.def b/src/mapleall/maple_driver/defs/default/O0_options_mpl2mpl_c.def
new file mode 100644
index 0000000000000000000000000000000000000000..c015aa6e5225dc457651ad1c1e5570cee881ba39
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O0_options_mpl2mpl_c.def
@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * 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 v1 for more details.
+ */
+// option name, option value, append maple root path?
+{ "--quiet", "", false },
diff --git a/src/mapleall/maple_driver/defs/default/O2_options_mpl2mpl_c.def b/src/mapleall/maple_driver/defs/default/O2_options_mpl2mpl_c.def
new file mode 100644
index 0000000000000000000000000000000000000000..83c259a8086271412158d2716f8bfe626c2259d0
--- /dev/null
+++ b/src/mapleall/maple_driver/defs/default/O2_options_mpl2mpl_c.def
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) [2021] Huawei Technologies Co.,Ltd.All rights reserved.
+ *
+ * OpenArkCompiler is licensed under the Mulan PSL v1.
+ * You can use this software according to the terms and conditions of the Mulan PSL v1.
+ * You may obtain a copy of Mulan PSL v1 at:
+ *
+ *     http://license.coscl.org.cn/MulanPSL
+ *
+ * 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 v1 for more details.
+ */
+// option name, option value, append maple root path?
+{ "-O2", "", false },
+{ "--quiet", "", false },
\ No newline at end of file
diff --git a/src/mapleall/maple_driver/defs/default_options.def b/src/mapleall/maple_driver/defs/default_options.def
index ca4fa79ff66a381c3bda07a0f90558765805534b..fd0cfa0f3fa8d6a676cf732b289f3f126c2c24b6 100644
--- a/src/mapleall/maple_driver/defs/default_options.def
+++ b/src/mapleall/maple_driver/defs/default_options.def
@@ -24,6 +24,10 @@ static MplOption kMeDefaultOptionsO0[] = {
 static MplOption kMpl2MplDefaultOptionsO0[] = {
 #include "default/O0_options_mpl2mpl.def"
 };
+// O0 mpl2mpl options for C language
+static MplOption kMpl2MplDefaultOptionsO0ForC[] = {
+#include "default/O0_options_mpl2mpl_c.def"
+};
 // O0 mplcg options
 static MplOption kMplcgDefaultOptionsO0[] = {
 #include "default/O0_options_mplcg.def"
@@ -36,6 +40,10 @@ static MplOption kMeDefaultOptionsO2[] = {
 static MplOption kMpl2MplDefaultOptionsO2[] = {
 #include "default/O2_options_mpl2mpl.def"
 };
+// O2 mpl2mpl options for C language
+static MplOption kMpl2MplDefaultOptionsO2ForC[] = {
+#include "default/O2_options_mpl2mpl_c.def"
+};
 // O2 mplcg options
 static MplOption kMplcgDefaultOptionsO2[] = {
 #include "default/O2_options_mplcg.def"
diff --git a/src/mapleall/maple_driver/src/mpl_options.cpp b/src/mapleall/maple_driver/src/mpl_options.cpp
index ea14f179e12fc3030113b0094d992d096b2ccd58..67b41809b9dd0838c455856b5b18ba3156ab1e7a 100644
--- a/src/mapleall/maple_driver/src/mpl_options.cpp
+++ b/src/mapleall/maple_driver/src/mpl_options.cpp
@@ -342,7 +342,12 @@ ErrorCode MplOptions::AppendCombOptions(MIRSrcLang srcLang) {
       ret = AppendDefaultOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO0,
                                  sizeof(kMpl2MplDefaultOptionsO0) / sizeof(MplOption));
       UpdatePhaseOption(mpl2mplOptArgs, kBinNameMpl2mpl);
+    } else {
+      ret = AppendDefaultOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO0ForC,
+                                 sizeof(kMpl2MplDefaultOptionsO0ForC) / sizeof(MplOption));
+      UpdatePhaseOption(mpl2mplOptArgs, kBinNameMpl2mpl);
     }
+
     if (ret != kErrorNoError) {
       return ret;
     }
@@ -355,6 +360,10 @@ ErrorCode MplOptions::AppendCombOptions(MIRSrcLang srcLang) {
       ret = AppendDefaultOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO2,
                                  sizeof(kMpl2MplDefaultOptionsO2) / sizeof(MplOption));
       UpdatePhaseOption(mpl2mplOptArgs, kBinNameMpl2mpl);
+    } else {
+      ret = AppendDefaultOptions(kBinNameMpl2mpl, kMpl2MplDefaultOptionsO2ForC,
+                                 sizeof(kMpl2MplDefaultOptionsO2ForC) / sizeof(MplOption));
+      UpdatePhaseOption(mpl2mplOptArgs, kBinNameMpl2mpl);
     }
     if (ret != kErrorNoError) {
       return ret;
diff --git a/src/mapleall/maple_ipa/src/inline.cpp b/src/mapleall/maple_ipa/src/inline.cpp
index 6317fdf496f30f2ffca7a787cb7473bdc7126eb5..9714344d2ceb4ca1f2d26598b4c8704d5b6293c3 100644
--- a/src/mapleall/maple_ipa/src/inline.cpp
+++ b/src/mapleall/maple_ipa/src/inline.cpp
@@ -1125,6 +1125,9 @@ InlineResult MInline::AnalyzeCallsite(const MIRFunction &caller, MIRFunction &ca
   if (!FuncInlinable(callee)) {
     return InlineResult(false, "ATTR");
   }
+  if (!callee.GetLabelTab()->GetAddrTakenLabels().empty()) {
+    return InlineResult(false, "ADDR_TAKEN_LABELS");
+  }
   // For inlineList function.
   if (inlineListCallee.find(calleeStrIdx) != inlineListCallee.end()) {
     auto callerList = inlineListCallee[calleeStrIdx];
diff --git a/src/mapleall/maple_ir/include/mir_builder.h b/src/mapleall/maple_ir/include/mir_builder.h
index 9e58210fa230824ee050007d82084c48409d2200..2a25bc92659f728beb6250c1a4b318c844c12d96 100644
--- a/src/mapleall/maple_ir/include/mir_builder.h
+++ b/src/mapleall/maple_ir/include/mir_builder.h
@@ -213,6 +213,7 @@ class MIRBuilder {
   ArrayNode *CreateExprArray(const MIRType &arrayType);
   ArrayNode *CreateExprArray(const MIRType &arrayType, BaseNode *op);
   ArrayNode *CreateExprArray(const MIRType &arrayType, BaseNode *op1, BaseNode *op2);
+  ArrayNode *CreateExprArray(const MIRType &arrayType, std::vector<BaseNode *> ops);
   IntrinsicopNode *CreateExprIntrinsicop(MIRIntrinsicID idx, Opcode opcode, const MIRType &type,
                                          const MapleVector<BaseNode*> &ops);
   // for creating Statement.
diff --git a/src/mapleall/maple_ir/src/mir_builder.cpp b/src/mapleall/maple_ir/src/mir_builder.cpp
index 4513dd624a25d2446795fdebc3c2b325b9e365ee..96fcd947375a6f426a7714ff23b986c6c4ec452c 100644
--- a/src/mapleall/maple_ir/src/mir_builder.cpp
+++ b/src/mapleall/maple_ir/src/mir_builder.cpp
@@ -715,6 +715,16 @@ ArrayNode *MIRBuilder::CreateExprArray(const MIRType &arrayType, BaseNode *op1,
   return arrayNode;
 }
 
+ArrayNode *MIRBuilder::CreateExprArray(const MIRType &arrayType, std::vector<BaseNode *> ops) {
+  MIRType *addrType = GlobalTables::GetTypeTable().GetOrCreatePointerType(arrayType);
+  ASSERT(addrType != nullptr, "addrType is null");
+  auto *arrayNode = GetCurrentFuncCodeMp()->New<ArrayNode>(*GetCurrentFuncCodeMpAllocator(),
+                                                           addrType->GetPrimType(), addrType->GetTypeIndex());
+  arrayNode->GetNopnd().insert(arrayNode->GetNopnd().begin(), ops.begin(), ops.end());
+  arrayNode->SetNumOpnds(ops.size());
+  return arrayNode;
+}
+
 IntrinsicopNode *MIRBuilder::CreateExprIntrinsicop(MIRIntrinsicID idx, Opcode opCode, const MIRType &type,
                                                    const MapleVector<BaseNode*> &ops) {
   auto *expr =
diff --git a/src/mapleall/maple_ir/src/mir_parser.cpp b/src/mapleall/maple_ir/src/mir_parser.cpp
index fcafffaa598d77f9195ff2d23a7cb4213150e946..44d0f93b7923b619e8c043b564bb0e317d41009e 100644
--- a/src/mapleall/maple_ir/src/mir_parser.cpp
+++ b/src/mapleall/maple_ir/src/mir_parser.cpp
@@ -1746,9 +1746,13 @@ bool MIRParser::ParseDeclaredSt(StIdx &stidx) {
   stidx.SetFullIdx(0);
   GStrIdx stridx = GlobalTables::GetStrTable().GetStrIdxFromName(lexer.GetName());
   if (stridx == 0u) {
-    Error("symbol not declared ");
-    stidx.SetFullIdx(0);
-    return false;
+    GStrIdx newStridx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+    MIRSymbol *st = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+    st->SetNameStrIdx(newStridx);
+    st->SetSKind(kStVar);
+    (void)GlobalTables::GetGsymTable().AddToStringSymbolMap(*st);
+    stidx = GlobalTables::GetGsymTable().GetStIdxFromStrIdx(newStridx);
+    return true;
   }
   if (varTk == TK_gname) {
     stidx = GlobalTables::GetGsymTable().GetStIdxFromStrIdx(stridx);
@@ -1772,8 +1776,19 @@ bool MIRParser::ParseDeclaredSt(StIdx &stidx) {
 bool MIRParser::ParseDeclaredFunc(PUIdx &puidx) {
   GStrIdx stridx = GlobalTables::GetStrTable().GetStrIdxFromName(lexer.GetName());
   if (stridx == 0u) {
-    Error("symbol not declared ");
-    return false;
+    GStrIdx newStrIdx = GlobalTables::GetStrTable().GetOrCreateStrIdxFromName(lexer.GetName());
+    MIRSymbol *funcSt = GlobalTables::GetGsymTable().CreateSymbol(kScopeGlobal);
+    funcSt->SetNameStrIdx(newStrIdx);
+    (void)GlobalTables::GetGsymTable().AddToStringSymbolMap(*funcSt);
+    funcSt->SetStorageClass(kScText);
+    funcSt->SetSKind(kStFunc);
+    funcSt->SetNeedForwDecl();
+    auto *fn = mod.GetMemPool()->New<MIRFunction>(&mod, funcSt->GetStIdx());
+    puidx = GlobalTables::GetFunctionTable().GetFuncTable().size();
+    fn->SetPuidx(puidx);
+    GlobalTables::GetFunctionTable().GetFuncTable().push_back(fn);
+    funcSt->SetFunction(fn);
+    return true;
   }
   StIdx stidx = GlobalTables::GetGsymTable().GetStIdxFromStrIdx(stridx);
   if (stidx.FullIdx() == 0) {
diff --git a/src/mapleall/maple_ir/src/parser.cpp b/src/mapleall/maple_ir/src/parser.cpp
index 6b5deb5867a2589867d42ad541e8fa0292890b57..1b87e20761ef2a9eeddda39d87f039faca6ba88a 100644
--- a/src/mapleall/maple_ir/src/parser.cpp
+++ b/src/mapleall/maple_ir/src/parser.cpp
@@ -1889,6 +1889,14 @@ bool MIRParser::ParseFunction(uint32 fileIdx) {
     Error("bad function attribute in function declaration at ");
     return false;
   }
+  if (funcSymbol != nullptr && funcSymbol->GetSKind() == kStFunc &&
+      funcSymbol->IsNeedForwDecl() == true && !funcSymbol->GetFunction()->GetBody()) {
+    SetSrcPos(funcSymbol->GetSrcPosition(), lexer.GetLineNum());
+    // when parsing func in mplt_inline file, set it as tmpunused.
+    if (options & kParseInlineFuncBody) {
+      funcSymbol->SetIsTmpUnused(true);
+    }
+  }
   if (funcSymbol != nullptr) {
     // there has been an earlier forward declaration, so check consistency
     if (funcSymbol->GetStorageClass() != kScText || funcSymbol->GetSKind() != kStFunc) {
@@ -2449,6 +2457,12 @@ bool MIRParser::ParseMIRForVar() {
       if (prevSt->GetStorageClass() == kScExtern) {
         prevSt->SetStorageClass(st.GetStorageClass());
       }
+    } else if (prevSt->GetSKind() == maple::kStVar && prevSt->GetStorageClass() ==  maple::kScInvalid) {
+      prevSt->SetStorageClass(kScGlobal);
+      prevSt->SetAttrs(st.GetAttrs());
+      prevSt->SetNameStrIdx(st.GetNameStrIdx());
+      prevSt->SetValue(st.GetValue());
+      SetSrcPos(prevSt->GetSrcPosition(), lexer.GetLineNum());
     }
   } else {  // seeing the first time
     maple::MIRBuilder mirBuilder(&mod);
diff --git a/src/mapleall/maple_me/src/bb.cpp b/src/mapleall/maple_me/src/bb.cpp
index fe8cc5807dabff06e369d05f6dc0e88e5934b854..5e0856b70e8a50f7d562b65c94473b184aeb0090 100644
--- a/src/mapleall/maple_me/src/bb.cpp
+++ b/src/mapleall/maple_me/src/bb.cpp
@@ -430,6 +430,7 @@ bool ControlFlowInInfiniteLoop(const BB &bb, Opcode opcode) {
   switch (opcode) {
     // goto always return true
     case OP_goto:
+    case OP_igoto:
       return true;
     case OP_brtrue:
     case OP_brfalse:
diff --git a/src/mapleall/maple_me/src/irmap.cpp b/src/mapleall/maple_me/src/irmap.cpp
index dfe805bfed05bf72f548dfff7c0763356dff2970..930f8657f3636daea077f953257e05cdfecaf6c9 100644
--- a/src/mapleall/maple_me/src/irmap.cpp
+++ b/src/mapleall/maple_me/src/irmap.cpp
@@ -197,7 +197,15 @@ IvarMeExpr *IRMap::BuildLHSIvar(MeExpr &baseAddr, PrimType primType, const TyIdx
 }
 
 IvarMeExpr *IRMap::BuildLHSIvar(MeExpr &baseAddr, IassignMeStmt &iassignMeStmt, FieldID fieldID) {
-  auto *meDef = New<IvarMeExpr>(exprID++, iassignMeStmt.GetRHS()->GetPrimType(), iassignMeStmt.GetTyIdx(), fieldID);
+  MIRType *ptrMIRType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(iassignMeStmt.GetTyIdx());
+  auto *realMIRType = static_cast<MIRPtrType*>(ptrMIRType);
+  MIRType *ty = nullptr;
+  if (fieldID > 0) {
+    ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(realMIRType->GetPointedTyIdxWithFieldID(fieldID));
+  } else {
+    ty = realMIRType->GetPointedType();
+  }
+  auto *meDef = New<IvarMeExpr>(exprID++, ty->GetPrimType(), iassignMeStmt.GetTyIdx(), fieldID);
   meDef->SetBase(&baseAddr);
   meDef->SetDefStmt(&iassignMeStmt);
   PutToBucket(meDef->GetHashIndex() % mapHashLength, *meDef);
diff --git a/src/mapleall/maple_me/src/me_ir.cpp b/src/mapleall/maple_me/src/me_ir.cpp
index 08f5f27a0d5e7a25970884e2145736ca3b9b45a1..b2b52abe06351ec3c9b2dd9f3faa92195d7296ca 100644
--- a/src/mapleall/maple_me/src/me_ir.cpp
+++ b/src/mapleall/maple_me/src/me_ir.cpp
@@ -577,7 +577,20 @@ bool ConstMeExpr::GtZero() const {
 }
 
 bool ConstMeExpr::IsZero() const {
-  return (GetIntValue() == 0);
+  if (constVal->GetKind() == kConstInt) {
+    auto *intConst = safe_cast<MIRIntConst>(constVal);
+    CHECK_NULL_FATAL(intConst);
+    return (intConst->GetValue() == 0);
+  } else if (constVal->GetKind() == kConstFloatConst) {
+    auto *floatConst = safe_cast<MIRFloatConst>(constVal);
+    CHECK_NULL_FATAL(floatConst);
+    return (floatConst->GetIntValue() == 0);
+  } else if (constVal->GetKind() == kConstDoubleConst) {
+    auto *doubleConst = safe_cast<MIRDoubleConst>(constVal);
+    CHECK_NULL_FATAL(doubleConst);
+    return (doubleConst->GetIntValue() == 0);
+  }
+  return false;
 }
 
 bool ConstMeExpr::IsOne() const {
diff --git a/src/mapleall/maple_me/src/me_loop_canon.cpp b/src/mapleall/maple_me/src/me_loop_canon.cpp
index a4585b4f4105e1545f4b5ebe2642546c88b6c1ea..ed7232d16413c865fa1059f3e3c7fc4e2c34c71f 100644
--- a/src/mapleall/maple_me/src/me_loop_canon.cpp
+++ b/src/mapleall/maple_me/src/me_loop_canon.cpp
@@ -281,9 +281,10 @@ void MeDoLoopCanon::FindHeadBBs(MeFunction &func, Dominance &dom, const BB *bb)
       hasTry = true;
     }
   }
-  // backedge is constructed by igoto 
+  // backedge is constructed by igoto
   if (bb->GetBBLabel() != 0) {
-    const MapleUnorderedSet<LabelIdx> &addrTakenLabels = func.GetMirFunc()->GetLabelTab()->GetAddrTakenLabels();
+    const MapleUnorderedSet<LabelIdx> &addrTakenLabels =
+        func.GetMirFunc()->GetLabelTab()->GetAddrTakenLabels();
     if (addrTakenLabels.find(bb->GetBBLabel()) != addrTakenLabels.end()) {
       hasIgoto = true;
     }
diff --git a/src/mapleall/maple_me/src/prop.cpp b/src/mapleall/maple_me/src/prop.cpp
index 9fbd34c3b2bfb67fa6c3b0aec5dd302ae50a0f5a..d7bd5a41e87ab1d79ad85fe1f21770f0fa6d1212 100644
--- a/src/mapleall/maple_me/src/prop.cpp
+++ b/src/mapleall/maple_me/src/prop.cpp
@@ -218,6 +218,13 @@ bool Prop::Propagatable(const MeExpr &expr, const BB &fromBB, bool atParm) const
       }
       break;
     }
+    case kMeOpConststr:
+    case kMeOpConststr16: {
+      if (mirModule.IsCModule()) {
+        return false;
+      }
+      break;
+    }
     default:
       break;
   }
diff --git a/src/mplfe/ast_input/include/ast_decl.h b/src/mplfe/ast_input/include/ast_decl.h
index 86fcfb3ced6dbb75e23d140123b3af1966d605ab..7603bd46ae16b965bd9fc2e93dc55f5868c60af6 100644
--- a/src/mplfe/ast_input/include/ast_decl.h
+++ b/src/mplfe/ast_input/include/ast_decl.h
@@ -23,6 +23,7 @@
 #include "fe_function.h"
 
 namespace maple {
+using Pos = std::pair<uint32, uint32>;
 class ASTDecl {
  public:
   ASTDecl(const std::string &srcFile, const std::string &nameIn, const std::vector<MIRType*> &typeDescIn)
@@ -43,17 +44,33 @@ class ASTDecl {
     return isGlobalDecl;
   }
 
+  void SetIsParam(bool flag) {
+    isParam = flag;
+  }
+
+  bool IsParam() const {
+    return isParam;
+  }
+
   void GenerateInitStmt(std::list<UniqueFEIRStmt> &stmts) {
     return GenerateInitStmtImpl(stmts);
   }
 
+  void SetDeclPos(Pos p) {
+    pos = p;
+  }
+
+  std::string GenerateUniqueVarName();
+
  protected:
   virtual void GenerateInitStmtImpl(std::list<UniqueFEIRStmt> &stmts) {}
   bool isGlobalDecl;
+  bool isParam = false;
   const std::string srcFileName;
   std::string name;
   std::vector<MIRType*> typeDesc;
   GenericAttrs genAttrs;
+  Pos pos = { 0, 0 };
 };
 
 class ASTField : public ASTDecl {
diff --git a/src/mplfe/ast_input/include/ast_expr.h b/src/mplfe/ast_input/include/ast_expr.h
index db23967aa9a3fecd2b64807d7473310def43ec01..f049707bc138757facdfca94dee718711d5909da 100644
--- a/src/mplfe/ast_input/include/ast_expr.h
+++ b/src/mplfe/ast_input/include/ast_expr.h
@@ -33,6 +33,14 @@ class ASTExpr {
     mirType = type;
   }
 
+  void SetASTDecl(ASTDecl *astDecl) {
+    refedDecl = astDecl;
+  }
+
+  ASTDecl *GetASTDecl() const {
+    return refedDecl;
+  }
+
   ASTOp GetASTOp() {
     return op;
   }
@@ -40,7 +48,8 @@ class ASTExpr {
  protected:
   virtual UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const = 0;
   ASTOp op;
-  MIRType *mirType;
+  MIRType *mirType = nullptr;
+  ASTDecl *refedDecl = nullptr;
 };
 
 class ASTImplicitCastExpr : public ASTExpr {
@@ -69,15 +78,9 @@ class ASTDeclRefExpr : public ASTExpr {
  public:
   ASTDeclRefExpr() : ASTExpr(kASTOpRef) {}
   ~ASTDeclRefExpr() = default;
-  void SetASTDecl(ASTDecl *astDecl);
-
-  ASTDecl *GetASTDecl() const {
-    return var;
-  }
 
  protected:
   UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
-  ASTDecl *var = nullptr;
 };
 
 class ASTUnaryOperatorExpr : public ASTExpr {
@@ -86,13 +89,6 @@ class ASTUnaryOperatorExpr : public ASTExpr {
   ~ASTUnaryOperatorExpr() = default;
   void SetUOExpr(ASTExpr*);
   void SetSubType(MIRType *type);
-  void SetRefName(std::string name) {
-    refName = name;
-  }
-
-  std::string GetRefName() {
-    return refName;
-  }
 
   MIRType *GetMIRType() {
     return subType;
@@ -127,7 +123,6 @@ class ASTUnaryOperatorExpr : public ASTExpr {
   ASTExpr *expr = nullptr;
   MIRType *subType;
   MIRType *uoType;
-  std::string refName;
   int64 pointeeLen;
 };
 
@@ -338,6 +333,8 @@ class ASTInitListExpr : public ASTExpr {
 
  private:
   UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
+  void Emit2FEExprForArray(std::list<UniqueFEIRStmt> &stmts) const;
+  void Emit2FEExprForStruct(std::list<UniqueFEIRStmt> &stmts) const;
   std::vector<ASTExpr*> fillers;
   MIRType *initListType;
   std::string varName;
@@ -446,14 +443,22 @@ class ASTArraySubscriptExpr : public ASTExpr {
     baseExpr = astExpr;
   }
 
+  ASTExpr *GetBaseExpr() const {
+    return baseExpr;
+  }
+
   void SetIdxExpr(ASTExpr *astExpr) {
-    idxExpr = astExpr;
+    idxExprs.push_back(astExpr);
+  }
+
+  std::vector<ASTExpr*> GetIdxExpr() const {
+    return idxExprs;
   }
 
  private:
   UniqueFEIRExpr Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const override;
   ASTExpr *baseExpr;
-  ASTExpr *idxExpr;
+  std::vector<ASTExpr*> idxExprs;
 };
 
 class ASTExprUnaryExprOrTypeTraitExpr : public ASTExpr {
diff --git a/src/mplfe/ast_input/lib/ast_interface.cpp b/src/mplfe/ast_input/lib/ast_interface.cpp
index 5ace6038b89dd9a96cdd445446c4ffc1c3332c03..3e743b1447ea720ad16c3982e7baa50fe475546c 100644
--- a/src/mplfe/ast_input/lib/ast_interface.cpp
+++ b/src/mplfe/ast_input/lib/ast_interface.cpp
@@ -69,6 +69,12 @@ std::string LibAstFile::GetMangledName(const clang::NamedDecl &decl) {
   return mangledName;
 }
 
+Pos LibAstFile::GetDeclPosInfo(const clang::Decl &decl) {
+  clang::FullSourceLoc fullLocation = astContext->getFullLoc(decl.getBeginLoc());
+  return std::make_pair(static_cast<uint32>(fullLocation.getSpellingLineNumber()),
+                        static_cast<uint32>(fullLocation.getSpellingColumnNumber()));
+}
+
 void LibAstFile::GetCVRAttrs(uint32_t qualifiers, GenericAttrs &genAttrs) {
   if (qualifiers & clang::Qualifiers::Const) {
     genAttrs.SetAttr(GENATTR_const);
diff --git a/src/mplfe/ast_input/lib/ast_interface.h b/src/mplfe/ast_input/lib/ast_interface.h
index 3ebbb9abec3f965472ab4f6d20f89207a687fb53..baf79b0b7efcf9edf74b18b21edecf29e53fd2a8 100644
--- a/src/mplfe/ast_input/lib/ast_interface.h
+++ b/src/mplfe/ast_input/lib/ast_interface.h
@@ -22,6 +22,7 @@
 #include "mpl_logging.h"
 
 namespace maple {
+using Pos = std::pair<uint32, uint32>;
 enum AccessKind {
   kPublic,
   kProtected,
@@ -74,6 +75,8 @@ class LibAstFile {
     return astContext;
   }
 
+  Pos GetDeclPosInfo(const clang::Decl &decl);
+
  private:
   using RecordDeclMap = std::map<TyIdx, const clang::RecordDecl*>;
   RecordDeclMap recordDeclMap;
diff --git a/src/mplfe/ast_input/src/ast_decl.cpp b/src/mplfe/ast_input/src/ast_decl.cpp
index cdaa357930a3ceb3c1f1e32067f524a07541ea9c..d26d0b7011e4fd2e4a123e7937c4ecc8cac4a697 100644
--- a/src/mplfe/ast_input/src/ast_decl.cpp
+++ b/src/mplfe/ast_input/src/ast_decl.cpp
@@ -33,10 +33,22 @@ const std::vector<MIRType*> &ASTDecl::GetTypeDesc() const {
   return typeDesc;
 }
 
+std::string ASTDecl::GenerateUniqueVarName() {
+  // add `_line_column` suffix for avoiding local var name conflict
+  if (isGlobalDecl || isParam) {
+    return name;
+  } else {
+    return name + "_" + std::to_string(pos.first) + "_" + std::to_string(pos.second);
+  }
+}
+
 // ---------- ASTVar ----------
 std::unique_ptr<FEIRVar> ASTVar::Translate2FEIRVar() {
   CHECK_FATAL(typeDesc.size() == 1, "Invalid ASTVar");
-  return std::make_unique<FEIRVarName>(name, std::make_unique<FEIRTypeNative>(*(typeDesc[0])));
+  auto feirVar =
+      std::make_unique<FEIRVarName>(GenerateUniqueVarName(), std::make_unique<FEIRTypeNative>(*(typeDesc[0])));
+  feirVar->SetGlobal(isGlobalDecl);
+  return feirVar;
 }
 
 void ASTVar::GenerateInitStmtImpl(std::list<UniqueFEIRStmt> &stmts) {
diff --git a/src/mplfe/ast_input/src/ast_expr.cpp b/src/mplfe/ast_input/src/ast_expr.cpp
index 577683d8006bbd86c0d3946fea67ed1e36273607..5e8731a537d338c7bf073de4d89ea93df675e44e 100644
--- a/src/mplfe/ast_input/src/ast_expr.cpp
+++ b/src/mplfe/ast_input/src/ast_expr.cpp
@@ -29,18 +29,15 @@ UniqueFEIRExpr ASTExpr::Emit2FEExpr(std::list<UniqueFEIRStmt> &stmts) const {
 }
 
 // ---------- ASTDeclRefExpr ---------
-void ASTDeclRefExpr::SetASTDecl(ASTDecl *astDecl) {
-  var = astDecl;
-}
-
 UniqueFEIRExpr ASTDeclRefExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
-  MIRType *mirType = var->GetTypeDesc().front();
+  MIRType *mirType = refedDecl->GetTypeDesc().front();
   UniqueFEIRExpr feirRefExpr;
   if (mirType->GetKind() == kTypePointer &&
       static_cast<MIRPtrType*>(mirType)->GetPointedType()->GetKind() == kTypeFunction) {
-    feirRefExpr = FEIRBuilder::CreateExprAddrofFunc(var->GetName());
+    feirRefExpr = FEIRBuilder::CreateExprAddrofFunc(refedDecl->GetName());
   } else {
-    UniqueFEIRVar feirVar = FEIRBuilder::CreateVarNameForC(var->GetName(), *mirType, var->IsGlobal(), false);
+    UniqueFEIRVar feirVar =
+        FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), *mirType, refedDecl->IsGlobal(), false);
     feirRefExpr = FEIRBuilder::CreateExprDRead(std::move(feirVar));
   }
   return feirRefExpr;
@@ -154,7 +151,7 @@ UniqueFEIRExpr ASTUOPostIncExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmt
   CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr");
   PrimType subPrimType = subType->GetPrimType();
 
-  UniqueFEIRVar selfVar = FEIRBuilder::CreateVarNameForC(refName, *subType, isGlobal, false);
+  UniqueFEIRVar selfVar = FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), *subType, isGlobal, false);
   UniqueFEIRVar selfMoveVar = selfVar->Clone();
   UniqueFEIRVar tempVar = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("postinc_"), *subType);
   UniqueFEIRVar tempMoveVar = tempVar->Clone();
@@ -180,7 +177,7 @@ UniqueFEIRExpr ASTUOPostDecExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmt
   CHECK_FATAL(childExpr != nullptr, "childExpr is nullptr");
   PrimType subPrimType = subType->GetPrimType();
 
-  UniqueFEIRVar selfVar = FEIRBuilder::CreateVarNameForC(refName, *subType, isGlobal, false);
+  UniqueFEIRVar selfVar = FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), *subType, isGlobal, false);
   UniqueFEIRVar selfMoveVar = selfVar->Clone();
   UniqueFEIRVar tempVar = FEIRBuilder::CreateVarNameForC(FEUtils::GetSequentialName("postinc_"), *subType);
   UniqueFEIRVar tempMoveVar = tempVar->Clone();
@@ -212,7 +209,7 @@ UniqueFEIRExpr ASTUOPreIncExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts
       FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1);
   UniqueFEIRExpr astUOPreIncExpr = FEIRBuilder::CreateExprMathBinary(OP_add, std::move(childFEIRExpr),
                                                                      std::move(incIecExpr));
-  UniqueFEIRVar selfVar = FEIRBuilder::CreateVarNameForC(refName, *subType, isGlobal, false);
+  UniqueFEIRVar selfVar = FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), *subType, isGlobal, false);
   UniqueFEIRVar selfMoveVar = selfVar->Clone();
   UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(std::move(selfMoveVar), std::move(astUOPreIncExpr));
   stmts.emplace_back(std::move(stmt));
@@ -231,7 +228,7 @@ UniqueFEIRExpr ASTUOPreDecExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts
       FEIRBuilder::CreateExprConstAnyScalar(subPrimType, 1);
   UniqueFEIRExpr astUOPreIncExpr = FEIRBuilder::CreateExprMathBinary(OP_sub, std::move(childFEIRExpr),
                                                                      std::move(incDecExpr));
-  UniqueFEIRVar selfVar = FEIRBuilder::CreateVarNameForC(refName, *subType, isGlobal, false);
+  UniqueFEIRVar selfVar = FEIRBuilder::CreateVarNameForC(refedDecl->GenerateUniqueVarName(), *subType, isGlobal, false);
   UniqueFEIRVar selfMoveVar = selfVar->Clone();
   UniqueFEIRStmt stmt = FEIRBuilder::CreateStmtDAssign(std::move(selfMoveVar), std::move(astUOPreIncExpr));
   stmts.emplace_back(std::move(stmt));
@@ -246,7 +243,8 @@ UniqueFEIRExpr ASTUOAddrOfExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts
   UniqueFEIRExpr addrOfExpr;
   if (childExpr->GetASTOp() == kASTOpRef) {
     ASTDecl *var = static_cast<ASTDeclRefExpr*>(childExpr)->GetASTDecl();
-    UniqueFEIRVar addrOfVar = FEIRBuilder::CreateVarNameForC(var->GetName(), *(var->GetTypeDesc().front()),
+    UniqueFEIRVar addrOfVar = FEIRBuilder::CreateVarNameForC(var->GenerateUniqueVarName(),
+                                                             *(var->GetTypeDesc().front()),
                                                              var->IsGlobal(), false);
     addrOfExpr = FEIRBuilder::CreateExprAddrofVar(std::move(addrOfVar));
   } else { // other potential expr should concern
@@ -448,10 +446,35 @@ UniqueFEIRExpr ASTOffsetOfExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts
 // ---------- ASTInitListExpr ----------
 UniqueFEIRExpr ASTInitListExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
   if (!initListType->IsStructType()) {
-    UniqueFEIRType typeNative = FEIRTypeHelper::CreateTypeNative(*initListType);
-    UniqueFEIRVar feirVar = FEIRBuilder::CreateVarNameForC(varName, *initListType);
-    UniqueFEIRExpr arrayExpr = FEIRBuilder::CreateExprDRead(std::move(feirVar));
-    for (int i = 0; i < fillers.size(); ++i) {
+    Emit2FEExprForArray(stmts);
+  } else {
+    Emit2FEExprForStruct(stmts);
+  }
+  return nullptr;
+}
+
+void ASTInitListExpr::Emit2FEExprForArray(std::list<UniqueFEIRStmt> &stmts) const {
+  UniqueFEIRVar feirVar = FEIRBuilder::CreateVarNameForC(varName, *initListType);
+  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) {
+      MIRType *mirType = static_cast<ASTInitListExpr*>(fillers[i])->initListType;
+      std::string tmpName = FEUtils::GetSequentialName("subArray_");
+      UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpName, *mirType);
+      static_cast<ASTInitListExpr*>(fillers[i])->SetInitListVarName(tmpName);
+      (void)(fillers[i])->Emit2FEExpr(stmts);
+      UniqueFEIRType elemType = tmpVar->GetType()->Clone();
+      UniqueFEIRExpr dreadAgg = FEIRBuilder::CreateExprDRead(std::move(tmpVar));
+      UniqueFEIRExpr arrayExprTmp = arrayExpr->Clone();
+      UniqueFEIRExpr exprIndex = FEIRBuilder::CreateExprConstI32(i);
+      UniqueFEIRType typeNativeTmp = typeNative->Clone();
+      auto fieldStmt = FEIRBuilder::CreateStmtArrayStoreOneStmtForC(std::move(dreadAgg), std::move(arrayExprTmp),
+                                                                    std::move(exprIndex), std::move(typeNativeTmp),
+                                                                    std::move(elemType));
+      stmts.emplace_back(std::move(fieldStmt));
+    } else {
       UniqueFEIRExpr exprIndex = FEIRBuilder::CreateExprConstI32(i);
       UniqueFEIRExpr exprElem = fillers[i]->Emit2FEExpr(stmts);
       UniqueFEIRType typeNativeTmp = typeNative->Clone();
@@ -460,40 +483,41 @@ UniqueFEIRExpr ASTInitListExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts
                                                                std::move(exprIndex), std::move(typeNativeTmp));
       stmts.emplace_back(std::move(stmt));
     }
-  } else {
-    UniqueFEIRVar feirVar = FEIRBuilder::CreateVarNameForC(varName, *initListType);
-    MIRStructType *structType = static_cast<MIRStructType*>(initListType);
-    for (uint32 i = 0; i < fillers.size(); i++) {
-      uint32 fieldID = 0;
-      if (fillers[i]->GetASTOp() == kASTOpInitListExpr) {
-        MIRType *mirType = static_cast<ASTInitListExpr*>(fillers[i])->GetInitListType();
-        std::string tmpName = FEUtils::GetSequentialName("subInitListVar_");
-        UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpName, *mirType);
-        static_cast<ASTInitListExpr*>(fillers[i])->SetInitListVarName(tmpName);
-        (void)(fillers[i])->Emit2FEExpr(stmts);
-        UniqueFEIRExpr dreadAgg = FEIRBuilder::CreateExprDRead(std::move(tmpVar));
-        FEManager::GetMIRBuilder().TraverseToNamedField(*structType, structType->GetElemStrIdx(i), fieldID);
-        UniqueFEIRStmt fieldStmt = std::make_unique<FEIRStmtDAssign>(feirVar->Clone(), std::move(dreadAgg), fieldID);
-        stmts.emplace_back(std::move(fieldStmt));
-      } else if (fillers[i]->GetASTOp() == kASTASTDesignatedInitUpdateExpr) {
-        MIRType *mirType = static_cast<ASTDesignatedInitUpdateExpr*>(fillers[i])->GetInitListType();
-        std::string tmpName = FEUtils::GetSequentialName("subVarToBeUpdate_");
-        UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpName, *mirType);
-        static_cast<ASTDesignatedInitUpdateExpr*>(fillers[i])->SetInitListVarName(tmpName);
-        (void)(fillers[i])->Emit2FEExpr(stmts);
-        UniqueFEIRExpr dreadAgg = FEIRBuilder::CreateExprDRead(std::move(tmpVar));
-        FEManager::GetMIRBuilder().TraverseToNamedField(*structType, structType->GetElemStrIdx(i), fieldID);
-        UniqueFEIRStmt fieldStmt = std::make_unique<FEIRStmtDAssign>(feirVar->Clone(), std::move(dreadAgg), fieldID);
-        stmts.emplace_back(std::move(fieldStmt));
-      } else {
-        FEManager::GetMIRBuilder().TraverseToNamedField(*structType, structType->GetElemStrIdx(i), fieldID);
-        UniqueFEIRExpr fieldFEExpr = fillers[i]->Emit2FEExpr(stmts);
-        UniqueFEIRStmt fieldStmt = std::make_unique<FEIRStmtDAssign>(feirVar->Clone(), fieldFEExpr->Clone(), fieldID);
-        stmts.emplace_back(std::move(fieldStmt));
-      }
+  }
+}
+
+void ASTInitListExpr::Emit2FEExprForStruct(std::list<UniqueFEIRStmt> &stmts) const {
+  UniqueFEIRVar feirVar = FEIRBuilder::CreateVarNameForC(varName, *initListType);
+  MIRStructType *structType = static_cast<MIRStructType*>(initListType);
+  for (uint32 i = 0; i < fillers.size(); i++) {
+    uint32 fieldID = 0;
+    if (fillers[i]->GetASTOp() == kASTOpInitListExpr) {
+      MIRType *mirType = static_cast<ASTInitListExpr*>(fillers[i])->GetInitListType();
+      std::string tmpName = FEUtils::GetSequentialName("subInitListVar_");
+      UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpName, *mirType);
+      static_cast<ASTInitListExpr*>(fillers[i])->SetInitListVarName(tmpName);
+      (void)(fillers[i])->Emit2FEExpr(stmts);
+      UniqueFEIRExpr dreadAgg = FEIRBuilder::CreateExprDRead(std::move(tmpVar));
+      FEManager::GetMIRBuilder().TraverseToNamedField(*structType, structType->GetElemStrIdx(i), fieldID);
+      UniqueFEIRStmt fieldStmt = std::make_unique<FEIRStmtDAssign>(feirVar->Clone(), std::move(dreadAgg), fieldID);
+      stmts.emplace_back(std::move(fieldStmt));
+    } else if (fillers[i]->GetASTOp() == kASTASTDesignatedInitUpdateExpr) {
+      MIRType *mirType = static_cast<ASTDesignatedInitUpdateExpr*>(fillers[i])->GetInitListType();
+      std::string tmpName = FEUtils::GetSequentialName("subVarToBeUpdate_");
+      UniqueFEIRVar tmpVar = FEIRBuilder::CreateVarNameForC(tmpName, *mirType);
+      static_cast<ASTDesignatedInitUpdateExpr*>(fillers[i])->SetInitListVarName(tmpName);
+      (void)(fillers[i])->Emit2FEExpr(stmts);
+      UniqueFEIRExpr dreadAgg = FEIRBuilder::CreateExprDRead(std::move(tmpVar));
+      FEManager::GetMIRBuilder().TraverseToNamedField(*structType, structType->GetElemStrIdx(i), fieldID);
+      UniqueFEIRStmt fieldStmt = std::make_unique<FEIRStmtDAssign>(feirVar->Clone(), std::move(dreadAgg), fieldID);
+      stmts.emplace_back(std::move(fieldStmt));
+    } else {
+      FEManager::GetMIRBuilder().TraverseToNamedField(*structType, structType->GetElemStrIdx(i), fieldID);
+      UniqueFEIRExpr fieldFEExpr = fillers[i]->Emit2FEExpr(stmts);
+      UniqueFEIRStmt fieldStmt = std::make_unique<FEIRStmtDAssign>(feirVar->Clone(), fieldFEExpr->Clone(), fieldID);
+      stmts.emplace_back(std::move(fieldStmt));
     }
   }
-  return nullptr;
 }
 
 void ASTInitListExpr::SetFillerExprs(ASTExpr *astExpr) {
@@ -516,10 +540,13 @@ UniqueFEIRExpr ASTStringLiteral::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmt
 }
 
 UniqueFEIRExpr ASTArraySubscriptExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
-  UniqueFEIRExpr baseFEExpr = baseExpr->Emit2FEExpr(stmts); // ImplicitCastExpr
-  UniqueFEIRExpr idxFEExpr = idxExpr->Emit2FEExpr(stmts); // DeclRefExpr
+  std::stack<uint64> idxVals;
   UniqueFEIRType typeNative = FEIRTypeHelper::CreateTypeNative(*baseExpr->GetType());
-  return FEIRBuilder::CreateExprArrayStoreForC(std::move(baseFEExpr), std::move(idxFEExpr), std::move(typeNative));
+  UniqueFEIRExpr baseFEExpr = baseExpr->Emit2FEExpr(stmts);
+  for (auto index : idxExprs) {
+    idxVals.push(static_cast<ASTIntegerLiteral*>(index)->GetVal());
+  }
+  return FEIRBuilder::CreateExprArrayStoreForC(std::move(baseFEExpr), idxVals, std::move(typeNative));
 }
 
 UniqueFEIRExpr ASTExprUnaryExprOrTypeTraitExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stmts) const {
@@ -592,14 +619,13 @@ UniqueFEIRExpr ASTAssignExpr::ProcessAssign(std::list<UniqueFEIRStmt> &stmts, Un
   } else if (leftFEExpr->GetKind() == FEIRNodeKind::kExprArrayStoreForC) {
     auto arrayStoreForC = static_cast<FEIRExprArrayStoreForC*>(leftFEExpr.get());
     FEIRExpr &exprArray = arrayStoreForC->GetExprArray();
-    FEIRExpr &exprIndex = arrayStoreForC->GetExprIndex();
+    auto indexs = arrayStoreForC->GetIndexs();
     FEIRType &typeArray = arrayStoreForC->GetTypeArray();
     UniqueFEIRExpr uExprArray = exprArray.Clone();
-    UniqueFEIRExpr uExprIndex = exprIndex.Clone();
     UniqueFEIRType uTypeArray = typeArray.Clone();
     UniqueFEIRStmt stmt = std::make_unique<FEIRStmtArrayStore>(std::move(rightFEExpr),
                                                                std::move(uExprArray),
-                                                               std::move(uExprIndex),
+                                                               indexs,
                                                                std::move(uTypeArray));
     stmts.emplace_back(std::move(stmt));
   }
@@ -743,7 +769,7 @@ UniqueFEIRExpr ASTCStyleCastExpr::Emit2FEExprImpl(std::list<UniqueFEIRStmt> &stm
                                                                  child->Emit2FEExpr(stmts),
                                                                  canCastArray);
   if (decl != nullptr) {
-    feirCStyleCastExpr->SetRefName(decl->GetName());
+    feirCStyleCastExpr->SetRefName(decl->GenerateUniqueVarName());
   }
   return feirCStyleCastExpr;
 }
diff --git a/src/mplfe/ast_input/src/ast_parser.cpp b/src/mplfe/ast_input/src/ast_parser.cpp
index 584b004b1d8da237ac66873a641a9068d43fecf5..55d9793baee7c7c3abfb9a9007f6538895d6c95d 100644
--- a/src/mplfe/ast_input/src/ast_parser.cpp
+++ b/src/mplfe/ast_input/src/ast_parser.cpp
@@ -489,6 +489,7 @@ ASTStmt *ASTParser::ProcessStmtDeclStmt(MapleAllocator &allocator, const clang::
     const clang::Decl *decl = declStmt.getSingleDecl();
     if (decl != nullptr) {
       ASTDecl *ad = ProcessDecl(allocator, *decl);
+      ad->SetDeclPos(astFile->GetDeclPosInfo(*decl));
       if (ad != nullptr) {
         astStmt->SetSubDecl(ad);
       }
@@ -499,6 +500,7 @@ ASTStmt *ASTParser::ProcessStmtDeclStmt(MapleAllocator &allocator, const clang::
     clang::DeclGroupRef::const_iterator it;
     for (it = declGroupRef.begin(); it != declGroupRef.end(); ++it) {
       ASTDecl *ad = ProcessDecl(allocator, **it);
+      ad->SetDeclPos(astFile->GetDeclPosInfo(**it));
       if (ad != nullptr) {
         astStmt->SetSubDecl(ad);
       }
@@ -624,9 +626,6 @@ ASTExpr *ASTParser::ProcessExprUnaryOperator(MapleAllocator &allocator, const cl
   if (clangOpCode == clang::UO_PostInc || clangOpCode == clang::UO_PostDec ||
       clangOpCode == clang::UO_PreInc || clangOpCode == clang::UO_PreDec) {
     const auto *declRefExpr = llvm::dyn_cast<clang::DeclRefExpr>(subExpr);
-    const auto *namedDecl = llvm::dyn_cast<clang::NamedDecl>(declRefExpr->getDecl()->getCanonicalDecl());
-    std::string refName = astFile->GetMangledName(*namedDecl);
-    astUOExpr->SetRefName(refName);
     if (declRefExpr->getDecl()->getKind() == clang::Decl::Var) {
       const auto *varDecl = llvm::cast<clang::VarDecl>(declRefExpr->getDecl()->getCanonicalDecl());
       astUOExpr->SetGlobal(!varDecl->isLocalVarDeclOrParm());
@@ -649,6 +648,7 @@ ASTExpr *ASTParser::ProcessExprUnaryOperator(MapleAllocator &allocator, const cl
   if (astExpr == nullptr) {
     return nullptr;
   }
+  astUOExpr->SetASTDecl(astExpr->GetASTDecl());
   astUOExpr->SetUOExpr(astExpr);
   return astUOExpr;
 }
@@ -810,16 +810,24 @@ ASTExpr *ASTParser::ProcessExprStringLiteral(MapleAllocator &allocator, const cl
 ASTExpr *ASTParser::ProcessExprArraySubscriptExpr(MapleAllocator &allocator, const clang::ArraySubscriptExpr &expr) {
   auto *astArraySubscriptExpr = ASTDeclsBuilder::ASTExprBuilder<ASTArraySubscriptExpr>(allocator);
   CHECK_FATAL(astArraySubscriptExpr != nullptr, "astArraySubscriptExpr is nullptr");
-  ASTExpr *baseExpr = ProcessExpr(allocator, expr.getBase());
+  clang::ArraySubscriptExpr *exprTmp = const_cast<clang::ArraySubscriptExpr*>(&expr);
+  auto base = exprTmp->getBase();
+  while (exprTmp != nullptr && exprTmp->getStmtClass() == clang::Stmt::ArraySubscriptExprClass) {
+    base = exprTmp->getBase();
+    ASTExpr *idxExpr = ProcessExpr(allocator, exprTmp->getIdx());
+    astArraySubscriptExpr->SetIdxExpr(idxExpr);
+    if (idxExpr == nullptr) {
+      return nullptr;
+    }
+    base = static_cast<clang::ImplicitCastExpr*>(base)->getSubExpr();
+    exprTmp = static_cast<clang::ArraySubscriptExpr*>(base);
+  }
+  // base is DeclRefExpr
+  ASTExpr *baseExpr = ProcessExpr(allocator, base);
   if (baseExpr == nullptr) {
     return nullptr;
   }
   astArraySubscriptExpr->SetBaseExpr(baseExpr);
-  ASTExpr *idxExpr = ProcessExpr(allocator, expr.getIdx());
-  if (idxExpr == nullptr) {
-    return nullptr;
-  }
-  astArraySubscriptExpr->SetIdxExpr(idxExpr);
   return astArraySubscriptExpr;
 }
 
@@ -1151,6 +1159,7 @@ ASTExpr *ASTParser::ProcessExprDeclRefExpr(MapleAllocator &allocator, const clan
       clang::QualType qualType = expr.getDecl()->getType();
       MIRType *refType = astFile->CvtType(qualType);
       ASTDecl *astDecl = ASTDeclsBuilder::ASTDeclBuilder(allocator, fileName, refName, std::vector<MIRType*>{refType});
+      astDecl->SetDeclPos(astFile->GetDeclPosInfo(*namedDecl));
       auto declKind = expr.getDecl()->getKind();
       if (declKind == clang::Decl::Var) {
         const auto *varDecl = llvm::cast<clang::VarDecl>(expr.getDecl()->getCanonicalDecl());
@@ -1162,6 +1171,7 @@ ASTExpr *ASTParser::ProcessExprDeclRefExpr(MapleAllocator &allocator, const clan
         // For comes from `EnumConstant`
         astDecl->SetGlobal(expr.getDecl()->getParentFunctionOrMethod() == nullptr);
       }
+      astDecl->SetIsParam(declKind == clang::Decl::ParmVar);
       astRefExpr->SetASTDecl(astDecl);
       astRefExpr->SetType(refType);
       return astRefExpr;
@@ -1551,11 +1561,14 @@ ASTDecl *ASTParser::ProcessDeclVarDecl(MapleAllocator &allocator, const clang::V
   GenericAttrs attrs;
   astFile->CollectAttrs(varDecl, attrs, kPublic);
   ASTVar *astVar = ASTDeclsBuilder::ASTVarBuilder(allocator, fileName, varName, std::vector<MIRType*>{varType}, attrs);
+  astVar->SetDeclPos(astFile->GetDeclPosInfo(varDecl));
+  astVar->SetGlobal(!varDecl.isLocalVarDecl());
+
   if (varDecl.hasInit()) {
     auto initExpr = varDecl.getInit();
     auto astInitExpr = ProcessExpr(allocator, initExpr);
     if (initExpr->getStmtClass() == clang::Stmt::InitListExprClass) {
-      static_cast<ASTInitListExpr*>(astInitExpr)->SetInitListVarName(varName);
+      static_cast<ASTInitListExpr*>(astInitExpr)->SetInitListVarName(astVar->GenerateUniqueVarName());
     }
     astVar->SetInitExpr(astInitExpr);
   }
@@ -1576,6 +1589,7 @@ ASTDecl *ASTParser::ProcessDeclEnumDecl(MapleAllocator &allocator, const clang::
     MIRType *mirType = astFile->CvtType(clang::dyn_cast<clang::ValueDecl>(child)->getType());
     ASTVar *astVar =
         ASTDeclsBuilder::ASTVarBuilder(allocator, fileName, varName, std::vector<MIRType*>{mirType}, attrs0);
+    astVar->SetDeclPos(astFile->GetDeclPosInfo(*child));
     auto constExpr = ASTDeclsBuilder::ASTExprBuilder<ASTIntegerLiteral>(allocator);
     constExpr->SetVal(
         static_cast<uint64>(clang::dyn_cast<clang:: EnumConstantDecl>(child)->getInitVal().getExtValue()));
diff --git a/src/mplfe/common/include/feir_builder.h b/src/mplfe/common/include/feir_builder.h
index 2999580315be5c7374c3de16881026677039fc2f..633a8308a07ae4ec785d691b842dd1789538d527 100644
--- a/src/mplfe/common/include/feir_builder.h
+++ b/src/mplfe/common/include/feir_builder.h
@@ -81,6 +81,8 @@ class FEIRBuilder {
   static UniqueFEIRExpr CreateExprJavaArrayLength(UniqueFEIRExpr exprArray);
   static UniqueFEIRExpr CreateExprArrayStoreForC(UniqueFEIRExpr argExprArray, UniqueFEIRExpr argExprIndex,
                                                  UniqueFEIRType argTypeNative);
+  static UniqueFEIRExpr CreateExprArrayStoreForC(UniqueFEIRExpr argExprArray, std::stack<uint64> argIndexs,
+                                                 UniqueFEIRType argTypeNative);
   // Stmt
   static UniqueFEIRStmt CreateStmtDAssign(UniqueFEIRVar dstVar, UniqueFEIRExpr srcExpr, bool hasException = false);
   static UniqueFEIRStmt CreateStmtGoto(uint32 targetLabelIdx);
@@ -106,6 +108,9 @@ class FEIRBuilder {
                                                     UniqueFEIRExpr exprIndex);
   static UniqueFEIRStmt CreateStmtArrayStoreOneStmtForC(UniqueFEIRExpr exprElem, UniqueFEIRExpr exprArray,
                                                         UniqueFEIRExpr exprIndex, UniqueFEIRType arrayType);
+  static UniqueFEIRStmt CreateStmtArrayStoreOneStmtForC(UniqueFEIRExpr exprElem, UniqueFEIRExpr exprArray,
+                                                        UniqueFEIRExpr exprIndex, UniqueFEIRType arrayType,
+                                                        UniqueFEIRType elemType);
   static std::list<UniqueFEIRStmt> CreateStmtArrayLoad(UniqueFEIRVar varElem, UniqueFEIRVar varArray,
                                                        UniqueFEIRVar varIndex);
   static UniqueFEIRStmt CreateStmtArrayLength(UniqueFEIRVar varLength, UniqueFEIRVar varArray);
diff --git a/src/mplfe/common/include/feir_stmt.h b/src/mplfe/common/include/feir_stmt.h
index 6456f93d8be450ef9b03b80c912c8b6aa446b67d..e3d01d3069890caa24ad61a44e70567ba933ba21 100644
--- a/src/mplfe/common/include/feir_stmt.h
+++ b/src/mplfe/common/include/feir_stmt.h
@@ -856,7 +856,8 @@ class FEIRExprJavaArrayLength : public FEIRExpr {
 // ---------- FEIRExprArrayStoreForC ----------
 class FEIRExprArrayStoreForC : public FEIRExpr {
  public:
-  FEIRExprArrayStoreForC(UniqueFEIRExpr argExprArray, UniqueFEIRExpr argExprIndex, UniqueFEIRType argTypeNative);
+  FEIRExprArrayStoreForC(UniqueFEIRExpr argExprArray, std::stack<uint64> argIndexs,
+                         UniqueFEIRType argTypeNative);
   ~FEIRExprArrayStoreForC() = default;
 
   FEIRExpr &GetExprArray() const {
@@ -864,9 +865,9 @@ class FEIRExprArrayStoreForC : public FEIRExpr {
     return *exprArray.get();
   }
 
-  FEIRExpr &GetExprIndex() const {
-    ASSERT(exprIndex != nullptr, "exprIndex is nullptr");
-    return *exprIndex.get();
+  std::stack<uint64> GetIndexs() const {
+    ASSERT(!indexs.empty(), "exprIndex is nullptr");
+    return indexs;
   }
 
   FEIRType &GetTypeArray() const {
@@ -880,7 +881,7 @@ class FEIRExprArrayStoreForC : public FEIRExpr {
 
  private:
   UniqueFEIRExpr exprArray;
-  UniqueFEIRExpr exprIndex;
+  mutable std::stack<uint64> indexs;
   UniqueFEIRType typeNative;
 };
 
@@ -1667,6 +1668,13 @@ class FEIRStmtArrayStore : public FEIRStmt {
  public:
   FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray, UniqueFEIRExpr argExprIndex,
                      UniqueFEIRType argTypeArray);
+  // for C mul array
+  FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray, UniqueFEIRExpr argExprIndex,
+                     UniqueFEIRType argTypeArray, UniqueFEIRType argTypeElem);
+  // for C mul array
+  FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray, std::stack<uint64> argIndexs,
+                     UniqueFEIRType argTypeArray);
+
   ~FEIRStmtArrayStore() = default;
 
  protected:
@@ -1675,12 +1683,17 @@ class FEIRStmtArrayStore : public FEIRStmt {
   bool CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &checkPoint, FEIRUseDefChain &udChain) override;
   void InitTrans4AllVarsImpl() override;
   std::list<StmtNode*> GenMIRStmtsImpl(MIRBuilder &mirBuilder) const override;
+  void GenMIRStmtsImplForCPart(MIRBuilder &mirBuilder, MIRType *ptrMIRArrayType, MIRType **mIRElemType,
+                               BaseNode **arrayExpr) const;
 
  private:
   UniqueFEIRExpr exprElem;
   UniqueFEIRExpr exprArray;
   UniqueFEIRExpr exprIndex;
+  // for C mul array
+  mutable std::stack<uint64> indexs;
   UniqueFEIRType typeArray;
+  mutable UniqueFEIRType typeElem = nullptr;
 };
 
 // ---------- FEIRStmtFieldStore ----------
diff --git a/src/mplfe/common/src/feir_builder.cpp b/src/mplfe/common/src/feir_builder.cpp
index 2755aa633748a0a9b2585d63053389d8b0fca8c7..74789e254c3221061b51f9f3745766277d609e5b 100644
--- a/src/mplfe/common/src/feir_builder.cpp
+++ b/src/mplfe/common/src/feir_builder.cpp
@@ -286,9 +286,9 @@ UniqueFEIRExpr FEIRBuilder::CreateExprJavaArrayLength(UniqueFEIRExpr exprArray)
   return expr;
 }
 
-UniqueFEIRExpr FEIRBuilder::CreateExprArrayStoreForC(UniqueFEIRExpr argExprArray, UniqueFEIRExpr argExprIndex,
+UniqueFEIRExpr FEIRBuilder::CreateExprArrayStoreForC(UniqueFEIRExpr argExprArray, std::stack<uint64> argIndexs,
                                                      UniqueFEIRType argTypeNative) {
-  UniqueFEIRExpr expr = std::make_unique<FEIRExprArrayStoreForC>(std::move(argExprArray), std::move(argExprIndex),
+  UniqueFEIRExpr expr = std::make_unique<FEIRExprArrayStoreForC>(std::move(argExprArray), argIndexs,
                                                                                           std::move(argTypeNative));
   CHECK_NULL_FATAL(expr);
   return expr;
@@ -423,6 +423,15 @@ UniqueFEIRStmt FEIRBuilder::CreateStmtArrayStoreOneStmtForC(UniqueFEIRExpr exprE
   return stmt;
 }
 
+UniqueFEIRStmt FEIRBuilder::CreateStmtArrayStoreOneStmtForC(UniqueFEIRExpr exprElem, UniqueFEIRExpr exprArray,
+                                                            UniqueFEIRExpr exprIndex, UniqueFEIRType arrayType,
+                                                            UniqueFEIRType elemType) {
+  UniqueFEIRStmt stmt = std::make_unique<FEIRStmtArrayStore>(std::move(exprElem), std::move(exprArray),
+                                                             std::move(exprIndex), std::move(arrayType),
+                                                             std::move(elemType));
+  return stmt;
+}
+
 std::list<UniqueFEIRStmt> FEIRBuilder::CreateStmtArrayLoad(UniqueFEIRVar varElem, UniqueFEIRVar varArray,
                                                            UniqueFEIRVar varIndex) {
   std::list<UniqueFEIRStmt> ans;
diff --git a/src/mplfe/common/src/feir_stmt.cpp b/src/mplfe/common/src/feir_stmt.cpp
index 0bdfbfbc3b1ad68c8c1cc34235154d2987ddbe7c..c6e42db32ada6ab8c77fc0b54333b1f4e461c191 100644
--- a/src/mplfe/common/src/feir_stmt.cpp
+++ b/src/mplfe/common/src/feir_stmt.cpp
@@ -1105,6 +1105,24 @@ FEIRStmtArrayStore::FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExp
       exprIndex(std::move(argExprIndex)),
       typeArray(std::move(argTypeArray)) {}
 
+FEIRStmtArrayStore::FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray,
+                                       UniqueFEIRExpr argExprIndex, UniqueFEIRType argTypeArray,
+                                       UniqueFEIRType argTypeElem)
+    : FEIRStmt(FEIRNodeKind::kStmtArrayStore),
+      exprElem(std::move(argExprElem)),
+      exprArray(std::move(argExprArray)),
+      exprIndex(std::move(argExprIndex)),
+      typeArray(std::move(argTypeArray)),
+      typeElem(std::move(argTypeElem)) {}
+
+FEIRStmtArrayStore::FEIRStmtArrayStore(UniqueFEIRExpr argExprElem, UniqueFEIRExpr argExprArray,
+                                       std::stack<uint64> argIndexs, UniqueFEIRType argTypeArray)
+    : FEIRStmt(FEIRNodeKind::kStmtArrayStore),
+      exprElem(std::move(argExprElem)),
+      exprArray(std::move(argExprArray)),
+      indexs(argIndexs),
+      typeArray(std::move(argTypeArray)) {}
+
 void FEIRStmtArrayStore::RegisterDFGNodes2CheckPointImpl(FEIRStmtCheckPoint &checkPoint) {
   exprArray->RegisterDFGNodes2CheckPoint(checkPoint);
   exprIndex->RegisterDFGNodes2CheckPoint(checkPoint);
@@ -1130,24 +1148,22 @@ void FEIRStmtArrayStore::InitTrans4AllVarsImpl() {
 }
 
 std::list<StmtNode*> FEIRStmtArrayStore::GenMIRStmtsImpl(MIRBuilder &mirBuilder) const {
-  CHECK_FATAL(exprArray->GetKind() == kExprDRead, "only support dread expr for exprArray");
-  CHECK_FATAL((exprIndex->GetKind() == kExprDRead) || (exprIndex->GetKind() == kExprConst), "only support dread/const"\
-                                                                                            "expr for exprIndex");
-  CHECK_FATAL(exprElem->GetKind() == kExprDRead || (exprIndex->GetKind() == kExprConst),
-      "only support dread/const expr for exprElem");
-  BaseNode *addrBase = exprArray->GenMIRNode(mirBuilder);
-  BaseNode *indexBn = exprIndex->GenMIRNode(mirBuilder);
+  CHECK_FATAL(((exprIndex == nullptr) && (indexs.size() != 0))||
+              (exprIndex->GetKind() == kExprDRead) ||
+              (exprIndex->GetKind() == kExprConst), "only support dread/const expr for exprIndex");
+  CHECK_FATAL(exprElem == nullptr ||
+              (exprElem->GetKind() == kExprDRead) ||
+              (exprElem->GetKind() == kExprConst), "only support dread/const expr for exprElem");
   MIRType *ptrMIRArrayType = typeArray->GenerateMIRType(false);
-  BaseNode *arrayExpr = mirBuilder.CreateExprArray(*ptrMIRArrayType, addrBase, indexBn);
+  BaseNode *arrayExpr = nullptr;
   MIRType *mIRElemType = nullptr;
   if (exprArray->GetType()->GetSrcLang() == kSrcLangC) {
-    UniqueFEIRType typeElem =
-        std::make_unique<FEIRTypeNative>(*static_cast<MIRArrayType*>(ptrMIRArrayType)->GetElemType());
-    mIRElemType = typeElem->GenerateMIRType(true);
-    MIRSymbol *mirSymbol = exprArray->GetVarUses().front()->GenerateLocalMIRSymbol(mirBuilder);
-    BaseNode * arrayAddrOfExpr = mirBuilder.CreateExprAddrof(0, *mirSymbol);
-    arrayExpr = mirBuilder.CreateExprArray(*ptrMIRArrayType, arrayAddrOfExpr, indexBn);
+    GenMIRStmtsImplForCPart(mirBuilder, ptrMIRArrayType, &mIRElemType, &arrayExpr);
   } else {
+    BaseNode *addrBase = exprArray->GenMIRNode(mirBuilder);
+    BaseNode *indexBn = exprIndex->GenMIRNode(mirBuilder);
+    MIRType *ptrMIRArrayType = typeArray->GenerateMIRType(false);
+    arrayExpr = mirBuilder.CreateExprArray(*ptrMIRArrayType, addrBase, indexBn);
     UniqueFEIRType typeElem = typeArray->Clone();
     if ((exprIndex->GetKind() != kExprConst) || (!FEOptions::GetInstance().IsAOT())) {
       (void)typeElem->ArrayDecrDim();
@@ -1156,7 +1172,8 @@ std::list<StmtNode*> FEIRStmtArrayStore::GenMIRStmtsImpl(MIRBuilder &mirBuilder)
   }
   BaseNode *elemBn = exprElem->GenMIRNode(mirBuilder);
   IassignNode *stmt = nullptr;
-  if ((exprIndex->GetKind() != kExprConst) || (!FEOptions::GetInstance().IsAOT())) {
+  if ((exprArray->GetType()->GetSrcLang() == kSrcLangC) ||
+      (exprIndex->GetKind() != kExprConst) || (!FEOptions::GetInstance().IsAOT())) {
     MIRType *ptrMIRElemType = GlobalTables::GetTypeTable().GetOrCreatePointerType(*mIRElemType, PTY_ptr);
     stmt = mirBuilder.CreateStmtIassign(*ptrMIRElemType, 0, arrayExpr, elemBn);
   } else {
@@ -1166,6 +1183,30 @@ std::list<StmtNode*> FEIRStmtArrayStore::GenMIRStmtsImpl(MIRBuilder &mirBuilder)
   return std::list<StmtNode*>({ stmt });
 }
 
+void FEIRStmtArrayStore::GenMIRStmtsImplForCPart(MIRBuilder &mirBuilder, MIRType *ptrMIRArrayType,
+                                                 MIRType **mIRElemType, BaseNode **arrayExpr) const {
+  if (typeElem == nullptr) {
+    typeElem = std::make_unique<FEIRTypeNative>(*static_cast<MIRArrayType*>(ptrMIRArrayType)->GetElemType());
+  }
+  *mIRElemType = typeElem->GenerateMIRType(true);
+  MIRSymbol *mirSymbol = exprArray->GetVarUses().front()->GenerateLocalMIRSymbol(mirBuilder);
+  BaseNode *arrayAddrOfExpr = mirBuilder.CreateExprAddrof(0, *mirSymbol);
+  if (exprIndex == nullptr) {
+    std::vector<BaseNode*> nds;
+    nds.push_back(arrayAddrOfExpr);
+    while (!indexs.empty()) {
+      auto expr1 = FEIRBuilder::CreateExprConstI32(indexs.top());
+      BaseNode *no = expr1->GenMIRNode(mirBuilder);
+      nds.push_back(no);
+      indexs.pop();
+    }
+    *arrayExpr = mirBuilder.CreateExprArray(*ptrMIRArrayType, nds);
+  } else {
+    BaseNode *indexBn = exprIndex->GenMIRNode(mirBuilder);
+    *arrayExpr = mirBuilder.CreateExprArray(*ptrMIRArrayType, arrayAddrOfExpr, indexBn);
+  }
+}
+
 std::string FEIRStmtArrayStore::DumpDotStringImpl() const {
   std::stringstream ss;
   ss << "<stmt" << id << "> " << id << ": " << GetFEIRNodeKindDescription(kind);
@@ -3026,20 +3067,30 @@ bool FEIRExprJavaArrayLength::CalculateDefs4AllUsesImpl(FEIRStmtCheckPoint &chec
 }
 
 // ---------- FEIRExprArrayStoreForC ----------
-FEIRExprArrayStoreForC::FEIRExprArrayStoreForC(UniqueFEIRExpr argExprArray, UniqueFEIRExpr argExprIndex,
+FEIRExprArrayStoreForC::FEIRExprArrayStoreForC(UniqueFEIRExpr argExprArray, std::stack<uint64> argIndexs,
                                                UniqueFEIRType argTypeNative)
     : FEIRExpr(FEIRNodeKind::kExprArrayStoreForC),
       exprArray(std::move(argExprArray)),
-      exprIndex(std::move(argExprIndex)),
+      indexs(argIndexs),
       typeNative(std::move(argTypeNative)) {}
 
 // only ArraySubscriptExpr is right value, left not need
 BaseNode *FEIRExprArrayStoreForC::GenMIRNodeImpl(MIRBuilder &mirBuilder) const {
-  BaseNode *indexBn = exprIndex->GenMIRNode(mirBuilder);
   MIRType *ptrMIRArrayType = typeNative->GenerateMIRType(false);
-  MIRSymbol *mirSymbol = exprArray->GetVarUses().front()->GenerateLocalMIRSymbol(mirBuilder);
+  std::unique_ptr<FEIRVar> tmpVar = std::make_unique<FEIRVarName>(exprArray->GetVarUses().front()->GetNameRaw(),
+                                                                  typeNative->Clone());
+  MIRSymbol *mirSymbol = tmpVar->GenerateLocalMIRSymbol(mirBuilder);
   BaseNode *nodeAddrof = mirBuilder.CreateExprAddrof(0, *mirSymbol);
-  BaseNode *arrayExpr = mirBuilder.CreateExprArray(*ptrMIRArrayType, nodeAddrof, indexBn);
+  std::vector<BaseNode*> nds;
+  nds.push_back(nodeAddrof);
+  while (!indexs.empty()) {
+    auto expr1 = FEIRBuilder::CreateExprConstI32(indexs.top());
+    BaseNode *no = expr1->GenMIRNode(mirBuilder);
+    nds.push_back(no);
+    indexs.pop();
+  }
+  BaseNode *arrayExpr = mirBuilder.CreateExprArray(*ptrMIRArrayType, nds);
+
   UniqueFEIRType typeElem =
       std::make_unique<FEIRTypeNative>(*static_cast<MIRArrayType*>(ptrMIRArrayType)->GetElemType());
   MIRType *mirElemType = typeElem->GenerateMIRType(true);
diff --git a/src/mplfe/test/mplfe_ut_regx.cpp b/src/mplfe/test/mplfe_ut_regx.cpp
index 6150b43ff6bc1f21de526f46dd4a4509ea182e0c..3099ec05fe83009695c59212dc5d6304d6d91aab 100644
--- a/src/mplfe/test/mplfe_ut_regx.cpp
+++ b/src/mplfe/test/mplfe_ut_regx.cpp
@@ -46,4 +46,14 @@ std::string MPLFEUTRegx::RefIndex(uint32 typeIdx) {
   }
   return ss.str();
 }
+
+std::string MPLFEUTRegx::AnyNum(uint32 typeIdx) {
+  std::stringstream ss;
+  if (typeIdx == kAnyNumber) {
+    ss << "[0-9]+";
+  } else {
+    ss << "" << typeIdx;
+  }
+  return ss.str();
+}
 }  // namespace maple
\ No newline at end of file