diff --git a/src/mapleall/maple_me/include/alias_class.h b/src/mapleall/maple_me/include/alias_class.h
index 4b2784ac258bea72dd5c7d76bbda05101232795f..c8f7cacb8de47c2f4878bb4bf0566cd2d7591a38 100644
--- a/src/mapleall/maple_me/include/alias_class.h
+++ b/src/mapleall/maple_me/include/alias_class.h
@@ -152,7 +152,7 @@ class AliasClass : public AnalysisResult {
   void CollectNotAllDefsSeenAes();
   void CreateClassSets();
   void DumpClassSets();
-  void InsertMayDefUseCall(StmtNode &stmt, bool hasSideEffect, bool hasNoPrivateDefEffect);
+  void InsertMayDefUseCall(StmtNode &stmt, BBId bbid, bool hasSideEffect, bool hasNoPrivateDefEffect);
   void GenericInsertMayDefUse(StmtNode &stmt, BBId bbID);
 
  protected:
@@ -179,7 +179,7 @@ class AliasClass : public AnalysisResult {
   void CollectMayDefForMustDefs(const StmtNode &stmt, std::set<OriginalSt*> &mayDefOsts);
   void CollectMayUseForCallOpnd(const StmtNode &stmt, std::set<OriginalSt*> &mayUseOsts);
   void InsertMayDefNodeForCall(std::set<OriginalSt*> &mayDefOsts, TypeOfMayDefList &mayDefNodes,
-                               StmtNode &stmt, bool hasNoPrivateDefEffect);
+                               StmtNode &stmt, BBId bbid, bool hasNoPrivateDefEffect);
   void InsertMayUseExpr(BaseNode &expr);
   void CollectMayUseFromGlobalsAffectedByCalls(std::set<OriginalSt*> &mayUseOsts);
   void CollectMayUseFromNADS(std::set<OriginalSt*> &mayUseOsts);
@@ -190,17 +190,17 @@ class AliasClass : public AnalysisResult {
   void InsertReturnOpndMayUse(const StmtNode &stmt);
   void InsertMayUseAll(const StmtNode &stmt);
   void CollectMayDefForDassign(const StmtNode &stmt, std::set<OriginalSt*> &mayDefOsts);
-  void InsertMayDefNode(std::set<OriginalSt*> &mayDefOsts, TypeOfMayDefList &mayDefNodes, StmtNode &stmt);
-  void InsertMayDefDassign(StmtNode &stmt);
+  void InsertMayDefNode(std::set<OriginalSt*> &mayDefOsts, TypeOfMayDefList &mayDefNodes, StmtNode &stmt, BBId bbid);
+  void InsertMayDefDassign(StmtNode &stmt, BBId bbid);
   bool IsEquivalentField(TyIdx tyIdxA, FieldID fldA, TyIdx tyIdxB, FieldID fldB) const;
   void CollectMayDefForIassign(StmtNode &stmt, std::set<OriginalSt*> &mayDefOsts);
   void InsertMayDefNodeExcludeFinalOst(std::set<OriginalSt*> &mayDefOsts, TypeOfMayDefList &mayDefNodes,
-                                       StmtNode &stmt);
-  void InsertMayDefIassign(StmtNode &stmt);
-  void InsertMayDefUseSyncOps(StmtNode &stmt);
+                                       StmtNode &stmt, BBId bbid);
+  void InsertMayDefIassign(StmtNode &stmt, BBId bbid);
+  void InsertMayDefUseSyncOps(StmtNode &stmt, BBId bbid);
   void InsertMayUseNodeExcludeFinalOst(const std::set<OriginalSt*> &mayUseOsts, TypeOfMayUseList &mayUseNodes);
-  void InsertMayDefUseIntrncall(StmtNode &stmt);
-  void InsertMayDefUseClinitCheck(IntrinsiccallNode &stmt);
+  void InsertMayDefUseIntrncall(StmtNode &stmt, BBId bbid);
+  void InsertMayDefUseClinitCheck(IntrinsiccallNode &stmt, BBId bbid);
   virtual BB *GetBB(BBId id) = 0;
   void ProcessIdsAliasWithRoot(const std::set<unsigned int> &idsAliasWithRoot, std::vector<unsigned int> &newGroups);
   void UpdateNextLevelNodes(std::vector<OriginalSt*> &nextLevelOsts, const AliasElem &aliasElem);
diff --git a/src/mapleall/maple_me/include/dominance.h b/src/mapleall/maple_me/include/dominance.h
index fd03e215788c666ca0054dddd6db464f0b2e1c23..f00e779e305d4f49816d3ef3736a8ef83dfc8cb3 100644
--- a/src/mapleall/maple_me/include/dominance.h
+++ b/src/mapleall/maple_me/include/dominance.h
@@ -35,10 +35,12 @@ class Dominance : public AnalysisResult {
         pdoms(domAllocator.Adapter()),
         domFrontier(bbVec.size(), MapleSet<BBId>(domAllocator.Adapter()), domAllocator.Adapter()),
         domChildren(bbVec.size(), MapleSet<BBId>(domAllocator.Adapter()), domAllocator.Adapter()),
+        iterDomFrontier(bbVec.size(), MapleSet<BBId>(domAllocator.Adapter()), domAllocator.Adapter()),
         dtPreOrder(bbVec.size(), BBId(0), domAllocator.Adapter()),
         dtDfn(bbVec.size(), -1, domAllocator.Adapter()),
         pdomFrontier(bbVec.size(), MapleSet<BBId>(domAllocator.Adapter()), domAllocator.Adapter()),
         pdomChildren(bbVec.size(), MapleSet<BBId>(domAllocator.Adapter()), domAllocator.Adapter()),
+        iterPdomFrontier(bbVec.size(), MapleSet<BBId>(domAllocator.Adapter()), domAllocator.Adapter()),
         pdtPreOrder(bbVec.size(), BBId(0), domAllocator.Adapter()),
         pdtDfn(bbVec.size(), -1, domAllocator.Adapter()) {}
 
@@ -48,6 +50,8 @@ class Dominance : public AnalysisResult {
   void ComputeDominance();
   void ComputeDomFrontiers();
   void ComputeDomChildren();
+  void GetIterDomFrontier(BB *bb, MapleSet<BBId> *dfset, BBId bbidMarker, std::vector<bool> &visitedMap);
+  void ComputeIterDomFrontiers();
   void ComputeDtPreorder(const BB &bb, size_t &num);
   void ComputeDtDfn();
   bool Dominate(const BB &bb1, const BB &bb2);  // true if bb1 dominates bb2
@@ -56,6 +60,8 @@ class Dominance : public AnalysisResult {
   void ComputePostDominance();
   void ComputePdomFrontiers();
   void ComputePdomChildren();
+  void GetIterPdomFrontier(BB *bb, MapleSet<BBId> *dfset, BBId bbidMarker, std::vector<bool> &visitedMap);
+  void ComputeIterPdomFrontiers();
   void ComputePdtPreorder(const BB &bb, size_t &num);
   void ComputePdtDfn();
   bool PostDominate(const BB &bb1, const BB &bb2);  // true if bb1 postdominates bb2
@@ -211,11 +217,17 @@ class Dominance : public AnalysisResult {
   MapleVector<BB*> pdomReversePostOrder;     // an ordering of the BB in reverse postorder
   MapleUnorderedMap<BBId, BB*> pdoms;        // index is bb id; immediate dominator for each BB
   MapleVector<MapleSet<BBId>> domFrontier;   // index is bb id
+ public:
   MapleVector<MapleSet<BBId>> domChildren;   // index is bb id; for dom tree
+  MapleVector<MapleSet<BBId>> iterDomFrontier;   // index is bb id
+ private:
   MapleVector<BBId> dtPreOrder;              // ordering of the BBs in a preorder traversal of the dominator tree
   MapleVector<uint32> dtDfn;                 // gives position of each BB in dt_preorder
   MapleVector<MapleSet<BBId>> pdomFrontier;  // index is bb id
+ public:
   MapleVector<MapleSet<BBId>> pdomChildren;  // index is bb id; for pdom tree
+  MapleVector<MapleSet<BBId>> iterPdomFrontier;  // index is bb id
+ private:
   MapleVector<BBId> pdtPreOrder;             // ordering of the BBs in a preorder traversal of the post-dominator tree
   MapleVector<uint32> pdtDfn;                // gives position of each BB in pdt_preorder
 };
diff --git a/src/mapleall/maple_me/include/me_abco.h b/src/mapleall/maple_me/include/me_abco.h
index d931b220ef2d9e5cb56c1418b0e5873a0272036c..d006dc18bc9d95714775357a4009a91e03a120f4 100644
--- a/src/mapleall/maple_me/include/me_abco.h
+++ b/src/mapleall/maple_me/include/me_abco.h
@@ -19,6 +19,7 @@
 #include "me_ir.h"
 #include "me_inequality_graph.h"
 #include "me_cfg.h"
+#include "dominance.h"
 #include "mir_module.h"
 #include "mir_builder.h"
 #include "me_ssi.h"
diff --git a/src/mapleall/maple_me/include/me_function.h b/src/mapleall/maple_me/include/me_function.h
index e7bbc8d2680b42267f0dbc84034ad9025c4fcf9c..6fe34a2f9555110d41a496d8b904686f42982695 100644
--- a/src/mapleall/maple_me/include/me_function.h
+++ b/src/mapleall/maple_me/include/me_function.h
@@ -25,7 +25,6 @@
 #include "ssa_tab.h"
 #include "func_emit.h"
 #include "me_ir.h"
-#include "me_ssa.h"
 #include "profile.h"
 
 namespace maple {
diff --git a/src/mapleall/maple_me/include/me_irmap.h b/src/mapleall/maple_me/include/me_irmap.h
index eef5b97f8458dcf28d75bfe967e303d4720e9dbb..f15232655bfacc3446df055fd63a6b9473c0ab99 100644
--- a/src/mapleall/maple_me/include/me_irmap.h
+++ b/src/mapleall/maple_me/include/me_irmap.h
@@ -14,6 +14,8 @@
  */
 #ifndef MAPLE_ME_INCLUDE_ME_IRMAP_H
 #define MAPLE_ME_INCLUDE_ME_IRMAP_H
+#include "me_option.h"
+#include "me_phase.h"
 #include "ssa_tab.h"
 #include "me_function.h"
 #include "irmap.h"
diff --git a/src/mapleall/maple_me/include/me_ssa.h b/src/mapleall/maple_me/include/me_ssa.h
index 97d47068c36000a419fbbf97d8895566c4b1fa0a..17040ae23f8559801216d670e00365e1416b654f 100644
--- a/src/mapleall/maple_me/include/me_ssa.h
+++ b/src/mapleall/maple_me/include/me_ssa.h
@@ -14,31 +14,28 @@
  */
 #ifndef MAPLE_ME_INCLUDE_ME_SSA_H
 #define MAPLE_ME_INCLUDE_ME_SSA_H
-#include <iostream>
 #include "mir_module.h"
 #include "mir_nodes.h"
+#include "me_function.h"
 #include "me_phase.h"
 #include "ssa.h"
-#include "bb.h"
 #include "dominance.h"
 
 namespace maple {
 class MeSSA : public SSA, public AnalysisResult {
  public:
-  MeSSA(MeFunction &func, Dominance &dom, MemPool &memPool, bool enabledDebug);
+  MeSSA(MeFunction &func, SSATab *stab, Dominance &dom, MemPool &memPool) :
+    SSA(memPool, *stab, func.GetAllBBs(), &dom), AnalysisResult(&memPool), func(&func), dom(&dom) {}
+
   ~MeSSA() = default;
 
-  void BuildSSA();
   void VerifySSA() const;
+  void InsertPhiNode();
 
  private:
   void VerifySSAOpnd(const BaseNode &node) const;
-  void CollectDefBBs(std::map<OStIdx, std::set<BBId>> &ostDefBBs);
-  void InsertPhiNode();
-  void RenameBB(BB&);
   MeFunction *func;
   Dominance *dom;
-  bool enabledDebug;
 };
 
 class MeDoSSA : public MeFuncPhase {
diff --git a/src/mapleall/maple_me/include/me_ssi.h b/src/mapleall/maple_me/include/me_ssi.h
index 6cbd8d54cfd0446e8223e1691e8210d47017c5a9..221e4ea229348177df4839a2c9ea5edf405d89ef 100644
--- a/src/mapleall/maple_me/include/me_ssi.h
+++ b/src/mapleall/maple_me/include/me_ssi.h
@@ -17,6 +17,7 @@
 #include "me_function.h"
 #include "me_irmap.h"
 #include "me_ir.h"
+#include "dominance.h"
 
 namespace maple {
 struct StmtComparator {
diff --git a/src/mapleall/maple_me/include/occur.h b/src/mapleall/maple_me/include/occur.h
index c114cbc4e5873f769896062abb30c6b603dac9d7..695be3b9a8f4132a99bc707ffc8639014a278d25 100644
--- a/src/mapleall/maple_me/include/occur.h
+++ b/src/mapleall/maple_me/include/occur.h
@@ -17,6 +17,7 @@
 // the data structures that represent occurrences and work candidates for SSAPRE
 #include "me_function.h"
 #include "irmap.h"
+#include "dominance.h"
 
 namespace maple {
 enum OccType {
diff --git a/src/mapleall/maple_me/include/orig_symbol.h b/src/mapleall/maple_me/include/orig_symbol.h
index 612e18fdeb294aadf4ea19c2f53959b9274f0c73..e4670ba4b05f794b42c9c176a37c00fd651cf12e 100644
--- a/src/mapleall/maple_me/include/orig_symbol.h
+++ b/src/mapleall/maple_me/include/orig_symbol.h
@@ -134,15 +134,15 @@ class OriginalSt {
   }
 
   size_t GetVersionIndex(size_t version) const {
-    ASSERT(version < versionsIndex.size(), "version out of range");
-    return versionsIndex.at(version);
+    ASSERT(version < versionsIndices.size(), "version out of range");
+    return versionsIndices.at(version);
   }
 
-  const MapleVector<size_t> &GetVersionsIndex() const {
-    return versionsIndex;
+  const MapleVector<size_t> &GetVersionsIndices() const {
+    return versionsIndices;
   }
-  void PushbackVersionIndex(size_t index) {
-    versionsIndex.push_back(index);
+  void PushbackVersionsIndices(size_t index) {
+    versionsIndices.push_back(index);
   }
 
   size_t GetZeroVersionIndex() const {
@@ -207,7 +207,7 @@ class OriginalSt {
       OSTType ostType, bool ignoreRC, SymOrPreg sysOrPreg)
       : ostType(ostType),
         index(index),
-        versionsIndex(alloc.Adapter()),
+        versionsIndices(alloc.Adapter()),
         fieldID(fieldID),
         isLocal(local),
         isFormal(isFormal),
@@ -217,8 +217,8 @@ class OriginalSt {
 
   OSTType ostType;
   OStIdx index;                       // index number in originalStVector
-  MapleVector<size_t> versionsIndex;  // the i-th element refers the index of versionst in versionst table
-  size_t zeroVersionIndex = 0;            // same as versionsIndex[0]
+  MapleVector<size_t> versionsIndices;  // the i-th element refers the index of versionst in versionst table
+  size_t zeroVersionIndex = 0;            // same as versionsIndices[0]
   TyIdx tyIdx{ 0 };                        // type of this symbol at this level; 0 for unknown
   FieldID fieldID;                    // at each level of indirection
   int8 indirectLev = 0;                   // level of indirection; -1 for address, 0 for itself
@@ -316,9 +316,9 @@ class OriginalStTable {
     originalStVector[id]->SetZeroVersionIndex(zeroVersionIndexParam);
   }
 
-  size_t GetVersionsIndexSize(const OStIdx &id) const {
+  size_t GetVersionsIndicesSize(const OStIdx &id) const {
     ASSERT(id < originalStVector.size(), "symbol table index out of range");
-    return originalStVector[id]->GetVersionsIndex().size();
+    return originalStVector[id]->GetVersionsIndices().size();
   }
 
   void UpdateVarOstMap(const OStIdx &id, std::map<OStIdx, OriginalSt*> &varOstMap) {
diff --git a/src/mapleall/maple_me/include/ssa.h b/src/mapleall/maple_me/include/ssa.h
index 80392f951961026dda0f30d8c5c026d55f39bb32..35d4c126da7bdbcdc579405d153308bd4a169cbc 100644
--- a/src/mapleall/maple_me/include/ssa.h
+++ b/src/mapleall/maple_me/include/ssa.h
@@ -24,6 +24,7 @@ class VersionSt;  // circular dependency exists, no other choice
 class OriginalStTable;  // circular dependency exists, no other choice
 class VersionStTable;  // circular dependency exists, no other choice
 class SSATab;  // circular dependency exists, no other choice
+class Dominance;  // circular dependency exists, no other choice
 class PhiNode {
  public:
   PhiNode(MapleAllocator &alloc, VersionSt &vsym) : result(&vsym), phiOpnds(kNumOpnds, nullptr, alloc.Adapter()) {
@@ -79,12 +80,13 @@ class PhiNode {
 
 class SSA {
  public:
-  SSA(MemPool &memPool, SSATab &stab)
+  SSA(MemPool &memPool, SSATab &stab, MapleVector<BB *> &bbvec, Dominance *dm)
       : ssaAlloc(&memPool),
         vstStacks(ssaAlloc.Adapter()),
-        vstVersions(ssaAlloc.Adapter()),
         bbRenamed(ssaAlloc.Adapter()),
-        ssaTab(&stab) {}
+        ssaTab(&stab),
+        bbVec(bbvec),
+        dom(dm) {}
 
   virtual ~SSA() = default;
 
@@ -97,6 +99,7 @@ class SSA {
   void RenameUses(StmtNode &stmt);
   void RenamePhiUseInSucc(const BB &bb);
   void RenameMayUses(BaseNode &node);
+  void RenameBB(BB &bb);
 
   MapleAllocator &GetSSAAlloc() {
     return ssaAlloc;
@@ -132,12 +135,13 @@ class SSA {
     return ssaTab;
   }
 
- private:
+ protected:
   MapleAllocator ssaAlloc;
   MapleVector<MapleStack<VersionSt*>*> vstStacks;    // rename stack for variable versions
-  MapleVector<int32> vstVersions;                    // maxium version for variables
   MapleVector<bool> bbRenamed;                       // indicate bb is renamed or not
   SSATab *ssaTab;
+  MapleVector<BB *> &bbVec;
+  Dominance *dom;
 };
 }  // namespace maple
 #endif  // MAPLE_ME_INCLUDE_SSA_H
diff --git a/src/mapleall/maple_me/include/ssa_mir_nodes.h b/src/mapleall/maple_me/include/ssa_mir_nodes.h
index fc7a996c47c14491f005f7fbd5494658a3faef9b..605297adfe00e85ac127a8259d9a9bd513f73dc9 100644
--- a/src/mapleall/maple_me/include/ssa_mir_nodes.h
+++ b/src/mapleall/maple_me/include/ssa_mir_nodes.h
@@ -469,7 +469,7 @@ class SSANode : public BaseNode {
 
   // MIRSymbol query
   const MIRSymbol &GetMIRSymbol() const {
-    return *(GetSSAVar()->GetOrigSt()->GetMIRSymbol());
+    return *(GetSSAVar()->GetOst()->GetMIRSymbol());
   }
 
  protected:
diff --git a/src/mapleall/maple_me/include/ssa_tab.h b/src/mapleall/maple_me/include/ssa_tab.h
index 7ba125bcda96cc1e9f0defe0bfb5dfa409c50856..f7b34be5f752ed35dee796f96b379f39067d4c91 100644
--- a/src/mapleall/maple_me/include/ssa_tab.h
+++ b/src/mapleall/maple_me/include/ssa_tab.h
@@ -27,16 +27,37 @@ class SSATab : public AnalysisResult {
   SSATab(MemPool *memPool, MemPool *versMp, MIRModule *mod)
       : AnalysisResult(memPool),
         mirModule(*mod),
+        versAlloc(versMp),
         versionStTable(*versMp),
         originalStTable(*memPool, *mod),
-        stmtsSSAPart(versMp) {}
+        stmtsSSAPart(versMp),
+        defBBs4Ost(16, nullptr, versAlloc.Adapter()) {}
 
   ~SSATab() = default;
 
   BaseNode *CreateSSAExpr(BaseNode &expr);
-  void CreateSSAStmt(StmtNode &stmt);
+  void CreateSSAStmt(StmtNode &stmt, BB *curbb);
+  bool HasDefBB(OStIdx oidx) {
+    return oidx < defBBs4Ost.size() && defBBs4Ost[oidx] && !defBBs4Ost[oidx]->empty();
+  }
+  void AddDefBB4Ost(OStIdx oidx, BBId bbid) {
+    if (oidx >= defBBs4Ost.size()) {
+      defBBs4Ost.resize(oidx + 16, nullptr);
+    }
+    if (defBBs4Ost[oidx] == nullptr) {
+      defBBs4Ost[oidx] = versAlloc.GetMemPool()->New<MapleSet<BBId>>(versAlloc.Adapter());
+    }
+    defBBs4Ost[oidx]->insert(bbid);
+  }
+  MapleSet<BBId> *GetDefBBs4Ost(OStIdx oidx) {
+    return defBBs4Ost[oidx];
+  }
   VersionSt *GetVerSt(size_t verIdx) {
-    return versionStTable.GetVersionStFromID(verIdx);
+    return versionStTable.GetVersionStVectorItem(verIdx);
+  }
+
+  MapleAllocator &GetVersAlloc() {
+    return versAlloc;
   }
 
   // following are handles to methods in originalStTable
@@ -134,8 +155,8 @@ class SSATab : public AnalysisResult {
     originalStTable.SetZeroVersionIndex(ostIdx, zeroVersionIndexParam);
   }
 
-  size_t GetVersionsIndexSize(const OStIdx &ostIdx) const {
-    return originalStTable.GetVersionsIndexSize(ostIdx);
+  size_t GetVersionsIndicesSize(const OStIdx &ostIdx) const {
+    return originalStTable.GetVersionsIndicesSize(ostIdx);
   }
 
   void UpdateVarOstMap(const OStIdx &ostIdx, std::map<OStIdx, OriginalSt*> &varOstMap) {
@@ -144,7 +165,7 @@ class SSATab : public AnalysisResult {
 
   // MIRSymbol query
   const MIRSymbol &GetStmtMIRSymbol(const StmtNode &stmt) const {
-    return *(GetStmtsSSAPart().GetAssignedVarOf(stmt)->GetOrigSt()->GetMIRSymbol());
+    return *(GetStmtsSSAPart().GetAssignedVarOf(stmt)->GetOst()->GetMIRSymbol());
   }
 
   bool IsInitVersion(size_t vstIdx, const OStIdx &ostIdx) const {
@@ -154,9 +175,11 @@ class SSATab : public AnalysisResult {
   }
  private:
   MIRModule &mirModule;
+  MapleAllocator versAlloc;
   VersionStTable versionStTable;  // this uses special versMp because it will be freed earlier
   OriginalStTable originalStTable;
   StmtsSSAPart stmtsSSAPart;  // this uses special versMp because it will be freed earlier
+  MapleVector<MapleSet<BBId> *> defBBs4Ost; // gives the set of BBs that has def for each original symbol
   bool wholeProgramScope = false;
 };
 }  // namespace maple
diff --git a/src/mapleall/maple_me/include/ver_symbol.h b/src/mapleall/maple_me/include/ver_symbol.h
index e6de1f79c96e8429644abf9d8469af8c0269fff1..769cea87c257bb5526fdf20909f5f8982937dbc5 100644
--- a/src/mapleall/maple_me/include/ver_symbol.h
+++ b/src/mapleall/maple_me/include/ver_symbol.h
@@ -29,10 +29,11 @@ class MayDefNode;  // circular dependency exists, no other choice
 class MustDefNode;  // circular dependency exists, no other choice
 class VersionStTable;  // circular dependency exists, no other choice
 class OriginalSt;  // circular dependency exists, no other choice
-constexpr size_t kInvalidVersionID = static_cast<size_t>(-1);
+
 class VersionSt {
  public:
   enum DefType {
+    kUnknown,
     kAssign,
     kPhi,
     kMayDef,
@@ -81,13 +82,11 @@ class VersionSt {
     return ost->GetIndex();
   }
 
-  const OriginalSt *GetOrigSt() const {
-    return ost;
-  }
-  OriginalSt *GetOst() {
+  OriginalSt *GetOst() const {
     return ost;
   }
-  void SetOrigSt(OriginalSt *ost) {
+
+  void SetOst(OriginalSt *ost) {
     this->ost = ost;
   }
 
@@ -153,7 +152,7 @@ class VersionSt {
   int version;      // starts from 0 for each symbol
   OriginalSt *ost;  // the index of related originalst in originalst_table
   BB *defBB = nullptr;
-  DefType defType = kAssign;
+  DefType defType = kUnknown;
 
   union DefStmt {
     StmtNode *assign;
@@ -168,32 +167,18 @@ class VersionSt {
 class VersionStTable {
  public:
   explicit VersionStTable(MemPool &vstMp) : vstAlloc(&vstMp), versionStVector(vstAlloc.Adapter()) {
-    versionStVector.push_back(&dummyVST);
+    versionStVector.push_back(static_cast<VersionSt*>(nullptr));
   }
 
   ~VersionStTable() = default;
 
-  VersionSt *CreateVersionSt(OriginalSt *ost, size_t version);
-  VersionSt *FindOrCreateVersionSt(OriginalSt *ost, size_t version);
-  VersionSt *GetVersionStFromID(size_t id, bool checkFirst = false) const {
-    if (checkFirst && id >= versionStVector.size()) {
-      return nullptr;
-    }
-    ASSERT(id < versionStVector.size(), "symbol table index out of range");
-    return versionStVector[id];
-  }
-
-  VersionSt &GetDummyVersionSt() {
-    return dummyVST;
-  }
+  VersionSt *CreateNextVersionSt(OriginalSt *ost);
 
-  VersionSt *CreateVSymbol(VersionSt *vst, size_t version) {
-    OriginalSt *ost = vst->GetOst();
-    return CreateVersionSt(ost, version);
-  }
+  void CreateZeroVersionSt(OriginalSt *ost);
 
-  bool Verify() const {
-    return true;
+  VersionSt *GetZeroVersionSt(OriginalSt *ost) {
+    CHECK_FATAL(ost->GetVersionsIndices().size() != 0, "GetZeroVersionSt:: zero version has not been created");
+    return versionStVector[ost->GetZeroVersionIndex()];
   }
 
   size_t GetVersionStVectorSize() const {
@@ -219,7 +204,6 @@ class VersionStTable {
  private:
   MapleAllocator vstAlloc;                   // this stores versionStVector
   MapleVector<VersionSt*> versionStVector;   // the vector that map a versionst's index to its pointer
-  static VersionSt dummyVST;
 };
 }       // namespace maple
 #endif  // MAPLE_ME_INCLUDE_VER_SYMBOL_H
diff --git a/src/mapleall/maple_me/src/alias_class.cpp b/src/mapleall/maple_me/src/alias_class.cpp
index 57b0eac6c683ab52500bb05cb58e49610c6d72e0..adb9c0f9659ff7f55083eecaa35a2dcc80c81ff1 100644
--- a/src/mapleall/maple_me/src/alias_class.cpp
+++ b/src/mapleall/maple_me/src/alias_class.cpp
@@ -98,7 +98,7 @@ AliasElem *AliasClass::FindOrCreateExtraLevAliasElem(BaseNode &expr, TyIdx tyIdx
   CHECK_FATAL(newOst != nullptr, "null ptr check");
   if (newOst->GetIndex() == osym2Elem.size()) {
     osym2Elem.push_back(nullptr);
-    ssaTab.GetVersionStTable().CreateVersionSt(newOst, kInitVersion);
+    ssaTab.GetVersionStTable().CreateZeroVersionSt(newOst);
   }
   return FindOrCreateAliasElem(*newOst);
 }
@@ -427,7 +427,7 @@ AliasElem *AliasClass::FindOrCreateDummyNADSAe() {
   dummySym->SetIsTmp(true);
   dummySym->SetIsDeleted();
   OriginalSt *dummyOst = ssaTab.GetOriginalStTable().CreateSymbolOriginalSt(*dummySym, 0, 0);
-  ssaTab.GetVersionStTable().FindOrCreateVersionSt(dummyOst, kInitVersion);
+  ssaTab.GetVersionStTable().CreateZeroVersionSt(dummyOst);
   if (osym2Elem.size() == dummyOst->GetIndex()) {
     AliasElem *dummyAe = acMemPool.New<AliasElem>(osym2Elem.size(), *dummyOst);
     dummyAe->SetNotAllDefsSeen(true);
@@ -633,7 +633,7 @@ void AliasClass::InsertMayUseExpr(BaseNode &expr) {
     rhsAe = FindOrCreateDummyNADSAe();
   }
   auto &ireadNode = static_cast<IreadSSANode&>(expr);
-  ireadNode.SetSSAVar(*ssaTab.GetVersionStTable().GetVersionStFromID(rhsAe->GetOriginalSt().GetZeroVersionIndex()));
+  ireadNode.SetSSAVar(*ssaTab.GetVersionStTable().GetZeroVersionSt(&rhsAe->GetOriginalSt()));
   ASSERT(ireadNode.GetSSAVar() != nullptr, "AliasClass::InsertMayUseExpr(): iread cannot have empty mayuse");
 }
 
@@ -687,7 +687,7 @@ void AliasClass::CollectMayUseFromDefinedFinalField(std::set<OriginalSt*> &mayUs
 void AliasClass::InsertMayUseNode(std::set<OriginalSt*> &mayUseOsts, TypeOfMayUseList &mayUseNodes) {
   for (OriginalSt *ost : mayUseOsts) {
     mayUseNodes.emplace_back(
-        MayUseNode(ssaTab.GetVersionStTable().GetVersionStFromID(ost->GetZeroVersionIndex())));
+        MayUseNode(ssaTab.GetVersionStTable().GetVersionStVectorItem(ost->GetZeroVersionIndex())));
   }
 }
 
@@ -754,7 +754,7 @@ void AliasClass::InsertMayUseAll(const StmtNode &stmt) {
   for (AliasElem *aliasElem : id2Elem) {
     if (aliasElem->GetOriginalSt().GetIndirectLev() >= 0 && !aliasElem->GetOriginalSt().IsPregOst()) {
       mayUseNodes.emplace_back(
-          MayUseNode(ssaTab.GetVersionStTable().GetVersionStFromID(aliasElem->GetOriginalSt().GetZeroVersionIndex())));
+          MayUseNode(ssaTab.GetVersionStTable().GetVersionStVectorItem(aliasElem->GetOriginalSt().GetZeroVersionIndex())));
     }
   }
 }
@@ -777,18 +777,19 @@ void AliasClass::CollectMayDefForDassign(const StmtNode &stmt, std::set<Original
 }
 
 void AliasClass::InsertMayDefNode(std::set<OriginalSt*> &mayDefOsts, TypeOfMayDefList &mayDefNodes,
-                                  StmtNode &stmt) {
+                                  StmtNode &stmt, BBId bbid) {
   for (OriginalSt *mayDefOst : mayDefOsts) {
     mayDefNodes.emplace_back(
-        MayDefNode(ssaTab.GetVersionStTable().GetVersionStFromID(mayDefOst->GetZeroVersionIndex()), &stmt));
+        MayDefNode(ssaTab.GetVersionStTable().GetVersionStVectorItem(mayDefOst->GetZeroVersionIndex()), &stmt));
+    ssaTab.AddDefBB4Ost(mayDefOst->GetIndex(), bbid);
   }
 }
 
-void AliasClass::InsertMayDefDassign(StmtNode &stmt) {
+void AliasClass::InsertMayDefDassign(StmtNode &stmt, BBId bbid) {
   std::set<OriginalSt*> mayDefOsts;
   CollectMayDefForDassign(stmt, mayDefOsts);
   TypeOfMayDefList &mayDefNodes = ssaTab.GetStmtsSSAPart().GetMayDefNodesOf(stmt);
-  InsertMayDefNode(mayDefOsts, mayDefNodes, stmt);
+  InsertMayDefNode(mayDefOsts, mayDefNodes, stmt, bbid);
 }
 
 bool AliasClass::IsEquivalentField(TyIdx tyIdxA, FieldID fldA, TyIdx tyIdxB, FieldID fldB) const {
@@ -834,28 +835,30 @@ void AliasClass::CollectMayDefForIassign(StmtNode &stmt, std::set<OriginalSt*> &
 }
 
 void AliasClass::InsertMayDefNodeExcludeFinalOst(std::set<OriginalSt*> &mayDefOsts,
-                                                 TypeOfMayDefList &mayDefNodes, StmtNode &stmt) {
+                                                 TypeOfMayDefList &mayDefNodes, StmtNode &stmt,
+                                                 BBId bbid) {
   for (OriginalSt *mayDefOst : mayDefOsts) {
     if (!mayDefOst->IsFinal()) {
       mayDefNodes.emplace_back(
-          MayDefNode(ssaTab.GetVersionStTable().GetVersionStFromID(mayDefOst->GetZeroVersionIndex()), &stmt));
+          MayDefNode(ssaTab.GetVersionStTable().GetVersionStVectorItem(mayDefOst->GetZeroVersionIndex()), &stmt));
+      ssaTab.AddDefBB4Ost(mayDefOst->GetIndex(), bbid);
     }
   }
 }
 
-void AliasClass::InsertMayDefIassign(StmtNode &stmt) {
+void AliasClass::InsertMayDefIassign(StmtNode &stmt, BBId bbid) {
   std::set<OriginalSt*> mayDefOsts;
   CollectMayDefForIassign(stmt, mayDefOsts);
   TypeOfMayDefList &mayDefNodes = ssaTab.GetStmtsSSAPart().GetMayDefNodesOf(stmt);
   if (mayDefOsts.size() == 1) {
-    InsertMayDefNode(mayDefOsts, mayDefNodes, stmt);
+    InsertMayDefNode(mayDefOsts, mayDefNodes, stmt, bbid);
   } else {
-    InsertMayDefNodeExcludeFinalOst(mayDefOsts, mayDefNodes, stmt);
+    InsertMayDefNodeExcludeFinalOst(mayDefOsts, mayDefNodes, stmt, bbid);
   }
   ASSERT(!mayDefNodes.empty(), "AliasClass::InsertMayUseIassign(): iassign cannot have empty maydef");
 }
 
-void AliasClass::InsertMayDefUseSyncOps(StmtNode &stmt) {
+void AliasClass::InsertMayDefUseSyncOps(StmtNode &stmt, BBId bbid) {
   std::set<unsigned int> aliasSet;
   // collect the full alias set first
   for (size_t i = 0; i < stmt.NumOpnds(); ++i) {
@@ -891,9 +894,10 @@ void AliasClass::InsertMayDefUseSyncOps(StmtNode &stmt) {
     AliasElem *aliasElem = id2Elem[elemID];
     OriginalSt &ostOfAliasAE = aliasElem->GetOriginalSt();
     if (!ostOfAliasAE.IsFinal()) {
-      VersionSt *vst0 = ssaTab.GetVersionStTable().GetVersionStFromID(ostOfAliasAE.GetZeroVersionIndex());
+      VersionSt *vst0 = ssaTab.GetVersionStTable().GetVersionStVectorItem(ostOfAliasAE.GetZeroVersionIndex());
       theSSAPart->GetMayUseNodes().emplace_back(MayUseNode(vst0));
       theSSAPart->GetMayDefNodes().emplace_back(MayDefNode(vst0, &stmt));
+      ssaTab.AddDefBB4Ost(ostOfAliasAE.GetIndex(), bbid);
     }
   }
 }
@@ -972,11 +976,13 @@ void AliasClass::CollectMayUseForCallOpnd(const StmtNode &stmt, std::set<Origina
 }
 
 void AliasClass::InsertMayDefNodeForCall(std::set<OriginalSt*> &mayDefOsts, TypeOfMayDefList &mayDefNodes,
-                                         StmtNode &stmt, bool hasNoPrivateDefEffect) {
+                                         StmtNode &stmt, BBId bbid,
+                                         bool hasNoPrivateDefEffect) {
   for (OriginalSt *mayDefOst : mayDefOsts) {
     if (!hasNoPrivateDefEffect || !mayDefOst->IsPrivate()) {
       mayDefNodes.emplace_back(
-          MayDefNode(ssaTab.GetVersionStTable().GetVersionStFromID(mayDefOst->GetZeroVersionIndex()), &stmt));
+          MayDefNode(ssaTab.GetVersionStTable().GetVersionStVectorItem(mayDefOst->GetZeroVersionIndex()), &stmt));
+      ssaTab.AddDefBB4Ost(mayDefOst->GetIndex(), bbid);
     }
   }
 }
@@ -984,7 +990,7 @@ void AliasClass::InsertMayDefNodeForCall(std::set<OriginalSt*> &mayDefOsts, Type
 // Insert mayDefs and mayUses for the callees.
 // Four kinds of mayDefs and mayUses are inserted, which are caused by callee
 // opnds, not_all_def_seen_ae, globalsAffectedByCalls, and mustDefs.
-void AliasClass::InsertMayDefUseCall(StmtNode &stmt, bool hasSideEffect, bool hasNoPrivateDefEffect) {
+void AliasClass::InsertMayDefUseCall(StmtNode &stmt, BBId bbid, bool hasSideEffect, bool hasNoPrivateDefEffect) {
   auto *theSSAPart = static_cast<MayDefMayUsePart*>(ssaTab.GetStmtsSSAPart().SSAPartOf(stmt));
   std::set<OriginalSt*> mayDefUseOstsA;
   // 1. collect mayDefs and mayUses caused by callee-opnds
@@ -994,7 +1000,7 @@ void AliasClass::InsertMayDefUseCall(StmtNode &stmt, bool hasSideEffect, bool ha
   InsertMayUseNode(mayDefUseOstsA, theSSAPart->GetMayUseNodes());
   // insert may def node, if the callee has side-effect.
   if (hasSideEffect) {
-    InsertMayDefNodeForCall(mayDefUseOstsA, theSSAPart->GetMayDefNodes(), stmt, hasNoPrivateDefEffect);
+    InsertMayDefNodeForCall(mayDefUseOstsA, theSSAPart->GetMayDefNodes(), stmt, bbid, hasNoPrivateDefEffect);
   }
   // 3. insert mayDefs and mayUses caused by globalsAffectedByCalls
   std::set<OriginalSt*> mayDefUseOstsB;
@@ -1002,12 +1008,12 @@ void AliasClass::InsertMayDefUseCall(StmtNode &stmt, bool hasSideEffect, bool ha
   InsertMayUseNode(mayDefUseOstsB, theSSAPart->GetMayUseNodes());
   // insert may def node, if the callee has side-effect.
   if (hasSideEffect) {
-    InsertMayDefNodeExcludeFinalOst(mayDefUseOstsB, theSSAPart->GetMayDefNodes(), stmt);
+    InsertMayDefNodeExcludeFinalOst(mayDefUseOstsB, theSSAPart->GetMayDefNodes(), stmt, bbid);
     if (kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) {
       // 4. insert mayDefs caused by the mustDefs
       std::set<OriginalSt*> mayDefOstsC;
       CollectMayDefForMustDefs(stmt, mayDefOstsC);
-      InsertMayDefNodeExcludeFinalOst(mayDefOstsC, theSSAPart->GetMayDefNodes(), stmt);
+      InsertMayDefNodeExcludeFinalOst(mayDefOstsC, theSSAPart->GetMayDefNodes(), stmt, bbid);
     }
   }
 }
@@ -1017,7 +1023,7 @@ void AliasClass::InsertMayUseNodeExcludeFinalOst(const std::set<OriginalSt*> &ma
   for (OriginalSt *mayUseOst : mayUseOsts) {
     if (!mayUseOst->IsFinal()) {
       mayUseNodes.emplace_back(
-          MayUseNode(ssaTab.GetVersionStTable().GetVersionStFromID(mayUseOst->GetZeroVersionIndex())));
+          MayUseNode(ssaTab.GetVersionStTable().GetVersionStVectorItem(mayUseOst->GetZeroVersionIndex())));
     }
   }
 }
@@ -1025,7 +1031,7 @@ void AliasClass::InsertMayUseNodeExcludeFinalOst(const std::set<OriginalSt*> &ma
 // Insert mayDefs and mayUses for intrinsiccall.
 // Four kinds of mayDefs and mayUses are inserted, which are caused by callee
 // opnds, not_all_def_seen_ae, globalsAffectedByCalls, and mustDefs.
-void AliasClass::InsertMayDefUseIntrncall(StmtNode &stmt) {
+void AliasClass::InsertMayDefUseIntrncall(StmtNode &stmt, BBId bbid) {
   auto *theSSAPart = static_cast<MayDefMayUsePart*>(ssaTab.GetStmtsSSAPart().SSAPartOf(stmt));
   auto &intrinNode = static_cast<IntrinsiccallNode&>(stmt);
   IntrinDesc *intrinDesc = &IntrinDesc::intrinTable[intrinNode.GetIntrinsic()];
@@ -1036,17 +1042,17 @@ void AliasClass::InsertMayDefUseIntrncall(StmtNode &stmt) {
   CollectMayUseFromGlobalsAffectedByCalls(mayDefUseOsts);
   InsertMayUseNodeExcludeFinalOst(mayDefUseOsts, theSSAPart->GetMayUseNodes());
   if (!intrinDesc->HasNoSideEffect() || calleeHasSideEffect) {
-    InsertMayDefNodeExcludeFinalOst(mayDefUseOsts, theSSAPart->GetMayDefNodes(), stmt);
+    InsertMayDefNodeExcludeFinalOst(mayDefUseOsts, theSSAPart->GetMayDefNodes(), stmt, bbid);
   }
   if (kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) {
     // 3. insert maydefs caused by the mustdefs
     std::set<OriginalSt*> mayDefOsts;
     CollectMayDefForMustDefs(stmt, mayDefOsts);
-    InsertMayDefNodeExcludeFinalOst(mayDefOsts, theSSAPart->GetMayDefNodes(), stmt);
+    InsertMayDefNodeExcludeFinalOst(mayDefOsts, theSSAPart->GetMayDefNodes(), stmt, bbid);
   }
 }
 
-void AliasClass::InsertMayDefUseClinitCheck(IntrinsiccallNode &stmt) {
+void AliasClass::InsertMayDefUseClinitCheck(IntrinsiccallNode &stmt, BBId bbid) {
   TypeOfMayDefList &mayDefNodes = ssaTab.GetStmtsSSAPart().GetMayDefNodesOf(stmt);
   for (OStIdx ostIdx : globalsMayAffectedByClinitCheck) {
     AliasElem *aliasElem = osym2Elem[ostIdx];
@@ -1055,7 +1061,8 @@ void AliasClass::InsertMayDefUseClinitCheck(IntrinsiccallNode &stmt) {
     std::string typeNameOfStmt = GlobalTables::GetTypeTable().GetTypeFromTyIdx(stmt.GetTyIdx())->GetName();
     if (typeNameOfOst.find(typeNameOfStmt) != std::string::npos) {
       mayDefNodes.emplace_back(
-          MayDefNode(ssaTab.GetVersionStTable().GetVersionStFromID(ostOfAE.GetZeroVersionIndex()), &stmt));
+          MayDefNode(ssaTab.GetVersionStTable().GetVersionStVectorItem(ostOfAE.GetZeroVersionIndex()), &stmt));
+      ssaTab.AddDefBB4Ost(ostOfAE.GetIndex(), bbid);
     }
   }
 }
@@ -1110,15 +1117,15 @@ void AliasClass::GenericInsertMayDefUse(StmtNode &stmt, BBId bbID) {
     case OP_customcall:
     case OP_polymorphiccall:
     case OP_icall: {
-      InsertMayDefUseCall(stmt, true, false);
+      InsertMayDefUseCall(stmt, bbID, true, false);
       return;
     }
     case OP_intrinsiccallwithtype: {
       auto &intrnNode = static_cast<IntrinsiccallNode&>(stmt);
       if (intrnNode.GetIntrinsic() == INTRN_JAVA_CLINIT_CHECK) {
-        InsertMayDefUseClinitCheck(intrnNode);
+        InsertMayDefUseClinitCheck(intrnNode, bbID);
       }
-      InsertMayDefUseIntrncall(stmt);
+      InsertMayDefUseIntrncall(stmt, bbID);
       return;
     }
     case OP_intrinsiccall:
@@ -1126,21 +1133,21 @@ void AliasClass::GenericInsertMayDefUse(StmtNode &stmt, BBId bbID) {
     case OP_intrinsiccallassigned:
     case OP_xintrinsiccallassigned:
     case OP_intrinsiccallwithtypeassigned: {
-      InsertMayDefUseIntrncall(stmt);
+      InsertMayDefUseIntrncall(stmt, bbID);
       return;
     }
     case OP_maydassign:
     case OP_dassign: {
-      InsertMayDefDassign(stmt);
+      InsertMayDefDassign(stmt, bbID);
       return;
     }
     case OP_iassign: {
-      InsertMayDefIassign(stmt);
+      InsertMayDefIassign(stmt, bbID);
       return;
     }
     case OP_syncenter:
     case OP_syncexit: {
-      InsertMayDefUseSyncOps(stmt);
+      InsertMayDefUseSyncOps(stmt, bbID);
       return;
     }
     default:
diff --git a/src/mapleall/maple_me/src/bb.cpp b/src/mapleall/maple_me/src/bb.cpp
index 134428a03973b42cabad65e84828dca322dcec73..fe8cc5807dabff06e369d05f6dc0e88e5934b854 100644
--- a/src/mapleall/maple_me/src/bb.cpp
+++ b/src/mapleall/maple_me/src/bb.cpp
@@ -113,7 +113,7 @@ void BB::DumpPhi() {
 }
 
 const PhiNode *BB::PhiofVerStInserted(const VersionSt &versionSt) const {
-  auto phiIt = phiList.find(versionSt.GetOrigSt()->GetIndex());
+  auto phiIt = phiList.find(versionSt.GetOst()->GetIndex());
   return (phiIt != phiList.end()) ? &(phiIt->second) : nullptr;
 }
 
@@ -122,7 +122,7 @@ void BB::InsertPhi(MapleAllocator *alloc, VersionSt *versionSt) {
   for (auto prevIt = pred.begin(); prevIt != pred.end(); ++prevIt) {
     phiNode.GetPhiOpnds().push_back(versionSt);
   }
-  (void)phiList.insert(std::make_pair(versionSt->GetOrigSt()->GetIndex(), phiNode));
+  (void)phiList.insert(std::make_pair(versionSt->GetOst()->GetIndex(), phiNode));
 }
 
 bool BB::IsInList(const MapleVector<BB*> &bbList) const {
diff --git a/src/mapleall/maple_me/src/dominance.cpp b/src/mapleall/maple_me/src/dominance.cpp
index d4f8dc2cde61a43493ccb44ca0cc1161d08cffdc..fca5116a3a205582dadcf8f2fcadee15b3a122fe 100644
--- a/src/mapleall/maple_me/src/dominance.cpp
+++ b/src/mapleall/maple_me/src/dominance.cpp
@@ -139,6 +139,34 @@ void Dominance::ComputeDomChildren() {
   }
 }
 
+// bbidMarker indicates that the iterDomFrontier results for bbid < bbidMarker
+// have been computed
+void Dominance::GetIterDomFrontier(BB *bb, MapleSet<BBId> *dfset, BBId bbidMarker, std::vector<bool> &visitedMap) {
+  if (visitedMap[bb->GetBBId()]) {
+    return;
+  }
+  visitedMap[bb->GetBBId()] = true;
+  for (BBId frontierbbid : domFrontier[bb->GetBBId()]) {
+    dfset->insert(frontierbbid);
+    if (frontierbbid < bbidMarker) {  // union with its computed result
+      dfset->insert(iterDomFrontier[frontierbbid].begin(), iterDomFrontier[frontierbbid].end());
+    } else {  // recursive call
+      BB *frontierbb = bbVec[frontierbbid];
+      GetIterDomFrontier(frontierbb, dfset, bbidMarker, visitedMap);
+    }
+  }
+}
+
+void Dominance::ComputeIterDomFrontiers() {
+  for (BB *bb : bbVec) {
+    if (bb == nullptr || bb == &commonExitBB) {
+      continue;
+    }
+    std::vector<bool> visitedMap(bbVec.size(), false);
+    GetIterDomFrontier(bb, &iterDomFrontier[bb->GetBBId()], bb->GetBBId(), visitedMap);
+  }
+}
+
 void Dominance::ComputeDtPreorder(const BB &bb, size_t &num) {
   CHECK_FATAL(num < dtPreOrder.size(), "index out of range in Dominance::ComputeDtPreorder");
   dtPreOrder[num++] = bb.GetBBId();
@@ -293,6 +321,34 @@ void Dominance::ComputePdomChildren() {
   }
 }
 
+// bbidMarker indicates that the iterPdomFrontier results for bbid < bbidMarker
+// have been computed
+void Dominance::GetIterPdomFrontier(BB *bb, MapleSet<BBId> *dfset, BBId bbidMarker, std::vector<bool> &visitedMap) {
+  if (visitedMap[bb->GetBBId()]) {
+    return;
+  }
+  visitedMap[bb->GetBBId()] = true;
+  for (BBId frontierbbid : pdomFrontier[bb->GetBBId()]) {
+    dfset->insert(frontierbbid);
+    if (frontierbbid < bbidMarker) {  // union with its computed result
+      dfset->insert(iterPdomFrontier[frontierbbid].begin(), iterPdomFrontier[frontierbbid].end());
+    } else {  // recursive call
+      BB *frontierbb = bbVec[frontierbbid];
+      GetIterPdomFrontier(frontierbb, dfset, bbidMarker, visitedMap);
+    }
+  }
+}
+
+void Dominance::ComputeIterPdomFrontiers() {
+  for (BB *bb : bbVec) {
+    if (bb == nullptr || bb == &commonEntryBB) {
+      continue;
+    }
+    std::vector<bool> visitedMap(bbVec.size(), false);
+    GetIterPdomFrontier(bb, &iterPdomFrontier[bb->GetBBId()], bb->GetBBId(), visitedMap);
+  }
+}
+
 void Dominance::ComputePdtPreorder(const BB &bb, size_t &num) {
   ASSERT(num < pdtPreOrder.size(), "index out of range in Dominance::ComputePdtPreOrder");
   pdtPreOrder[num++] = bb.GetBBId();
@@ -337,6 +393,10 @@ void Dominance::DumpDoms() {
     for (BBId id : domFrontier[bb->GetBBId()]) {
       LogInfo::MapleLogger() << id << " ";
     }
+    LogInfo::MapleLogger() << "] iterDomFrontier: [";
+    for (BBId id : iterDomFrontier[bb->GetBBId()]) {
+      LogInfo::MapleLogger() << id << " ";
+    }
     LogInfo::MapleLogger() << "] domchildren: [";
     for (BBId id : domChildren[bb->GetBBId()]) {
       LogInfo::MapleLogger() << id << " ";
@@ -359,6 +419,10 @@ void Dominance::DumpPdoms() {
     for (BBId id : pdomFrontier[bb->GetBBId()]) {
       LogInfo::MapleLogger() << id << " ";
     }
+    LogInfo::MapleLogger() << "] iterPdomFrontier: [";
+    for (BBId id : iterPdomFrontier[bb->GetBBId()]) {
+      LogInfo::MapleLogger() << id << " ";
+    }
     LogInfo::MapleLogger() << "] pdomchildren: [";
     for (BBId id : pdomChildren[bb->GetBBId()]) {
       LogInfo::MapleLogger() << id << " ";
diff --git a/src/mapleall/maple_me/src/irmap.cpp b/src/mapleall/maple_me/src/irmap.cpp
index 74f5cca5df0f171578c17902b592ad709189a22c..e33973e356f240828382c77438b28a17d6d2b435 100644
--- a/src/mapleall/maple_me/src/irmap.cpp
+++ b/src/mapleall/maple_me/src/irmap.cpp
@@ -87,6 +87,9 @@ VarMeExpr *IRMap::CreateNewGlobalTmp(GStrIdx strIdx, PrimType pType) {
       mirModule.GetMIRBuilder()->CreateSymbol((TyIdx)pType, strIdx, kStVar, kScGlobal, nullptr, kScopeGlobal);
   st->SetIsTmp(true);
   OriginalSt *oSt = ssaTab.CreateSymbolOriginalSt(*st, 0, 0);
+  oSt->SetZeroVersionIndex(vst2MeExprTable.size());
+  vst2MeExprTable.push_back(nullptr);
+  oSt->PushbackVersionsIndices(oSt->GetZeroVersionIndex());
   auto *varx = New<VarMeExpr>(exprID++, oSt, oSt->GetZeroVersionIndex(), pType);
   return varx;
 }
@@ -98,7 +101,7 @@ VarMeExpr *IRMap::CreateNewLocalRefVarTmp(GStrIdx strIdx, TyIdx tIdx) {
   OriginalSt *oSt = ssaTab.CreateSymbolOriginalSt(*st, mirModule.CurFunction()->GetPuidx(), 0);
   oSt->SetZeroVersionIndex(vst2MeExprTable.size());
   vst2MeExprTable.push_back(nullptr);
-  oSt->PushbackVersionIndex(oSt->GetZeroVersionIndex());
+  oSt->PushbackVersionsIndices(oSt->GetZeroVersionIndex());
   auto *newLocalRefVar = New<VarMeExpr>(exprID++, oSt, vst2MeExprTable.size(), PTY_ref);
   vst2MeExprTable.push_back(newLocalRefVar);
   return newLocalRefVar;
@@ -553,6 +556,12 @@ IntrinsiccallMeStmt *IRMap::CreateIntrinsicCallAssignedMeStmt(MIRIntrinsicID idx
 
 MeExpr *IRMap::CreateAddrofMeExprFromSymbol(MIRSymbol &st, PUIdx puIdx) {
   OriginalSt *baseOst = ssaTab.FindOrCreateSymbolOriginalSt(st, puIdx, 0);
+  if (baseOst->GetZeroVersionIndex() == 0) {
+    baseOst->SetZeroVersionIndex(vst2MeExprTable.size());
+    vst2MeExprTable.push_back(nullptr);
+    baseOst->PushbackVersionsIndices(baseOst->GetZeroVersionIndex());
+  }
+
   AddrofMeExpr addrOfMe(kInvalidExprID, PTY_ptr, baseOst->GetIndex());
   return HashMeExpr(addrOfMe);
 }
diff --git a/src/mapleall/maple_me/src/irmap_build.cpp b/src/mapleall/maple_me/src/irmap_build.cpp
index a035dabf33725200821ab32b0dac81b21d7839c8..c2287f8ec237b12fb9a96a32bf4ef7e120bd3b28 100644
--- a/src/mapleall/maple_me/src/irmap_build.cpp
+++ b/src/mapleall/maple_me/src/irmap_build.cpp
@@ -160,7 +160,7 @@ void IRMapBuild::SetMeExprOpnds(MeExpr &meExpr, BaseNode &mirNode, bool atParm,
 MeExpr *IRMapBuild::BuildAddrofMeExpr(const BaseNode &mirNode) const {
   auto &addrofNode = static_cast<const AddrofSSANode&>(mirNode);
   auto meExpr = new AddrofMeExpr(kInvalidExprID, addrofNode.GetPrimType(),
-                                 addrofNode.GetSSAVar()->GetOrigSt()->GetIndex());
+                                 addrofNode.GetSSAVar()->GetOst()->GetIndex());
   meExpr->SetFieldID(addrofNode.GetFieldID());
   return meExpr;
 }
@@ -296,8 +296,8 @@ MeExpr *IRMapBuild::BuildExpr(BaseNode &mirNode, bool atParm, bool noProp) {
     auto &addrOfNode = static_cast<AddrofSSANode&>(mirNode);
     VersionSt *vst = addrOfNode.GetSSAVar();
     VarMeExpr *varMeExpr = GetOrCreateVarFromVerSt(*vst);
-    ASSERT(!vst->GetOrigSt()->IsPregOst(), "not expect preg symbol here");
-    varMeExpr->SetPtyp(GlobalTables::GetTypeTable().GetTypeFromTyIdx(vst->GetOrigSt()->GetTyIdx())->GetPrimType());
+    ASSERT(!vst->GetOst()->IsPregOst(), "not expect preg symbol here");
+    varMeExpr->SetPtyp(GlobalTables::GetTypeTable().GetTypeFromTyIdx(vst->GetOst()->GetTyIdx())->GetPrimType());
     varMeExpr->GetOst()->SetFieldID(addrOfNode.GetFieldID());
     MeExpr *retmeexpr;
     if (propagater && !noProp) {
@@ -347,7 +347,7 @@ MeExpr *IRMapBuild::BuildExpr(BaseNode &mirNode, bool atParm, bool noProp) {
     if (verSt != nullptr) {
       VarMeExpr *varMeExpr = GetOrCreateVarFromVerSt(*verSt);
       ivarMeExpr->SetMuVal(varMeExpr);
-      if (verSt->GetOrigSt()->IsVolatile()) {
+      if (verSt->GetOst()->IsVolatile()) {
         ivarMeExpr->SetVolatileFromBaseSymbol(true);
       }
     }
@@ -537,7 +537,7 @@ MeStmt *IRMapBuild::BuildIassignMeStmt(StmtNode &stmt, AccessSSANodes &ssaPart)
   if (mirModule.IsCModule()) {
     bool isVolt = false;
     for (MayDefNode maydef : ssaPart.GetMayDefNodes()) {
-      const OriginalSt *ost = maydef.GetResult()->GetOrigSt();
+      const OriginalSt *ost = maydef.GetResult()->GetOst();
       if (ost->IsVolatile()) {
         isVolt = true;
         break;
diff --git a/src/mapleall/maple_me/src/me_analyzector.cpp b/src/mapleall/maple_me/src/me_analyzector.cpp
index bdcb5df99a22bfc811424afb54c4251576a6dac9..ecb27376ed07b7bb9223512025e1d669a4a1a38b 100644
--- a/src/mapleall/maple_me/src/me_analyzector.cpp
+++ b/src/mapleall/maple_me/src/me_analyzector.cpp
@@ -12,6 +12,7 @@
  * FIT FOR A PARTICULAR PURPOSE.
  * See the Mulan PSL v2 for more details.
  */
+#include "dominance.h"
 #include "me_analyzector.h"
 #include "utils.h"
 
@@ -81,7 +82,7 @@ void AnalyzeCtor::ProcessStmt(MeStmt &stmt) {
 }
 
 AnalysisResult *MeDoAnalyzeCtor::Run(MeFunction *func, MeFuncResultMgr *m, ModuleResultMgr *moduleResultMgr) {
-  auto *dom = static_cast<Dominance*>(m->GetAnalysisResult(MeFuncPhase_DOMINANCE, func));
+  Dominance *dom = static_cast<Dominance*>(m->GetAnalysisResult(MeFuncPhase_DOMINANCE, func));
   auto *kh = static_cast<KlassHierarchy*>(moduleResultMgr->GetAnalysisResult(MoPhase_CHA, &func->GetMIRModule()));
   ASSERT_NOT_NULL(dom);
   ASSERT_NOT_NULL(m->GetAnalysisResult(MeFuncPhase_IRMAPBUILD, func));
diff --git a/src/mapleall/maple_me/src/me_cond_based_opt.cpp b/src/mapleall/maple_me/src/me_cond_based_opt.cpp
index e40417a6d23530eaef7128e07f0203e817fe4ad1..7035bd5098514c208fb1c345fecb29cb4f430443 100644
--- a/src/mapleall/maple_me/src/me_cond_based_opt.cpp
+++ b/src/mapleall/maple_me/src/me_cond_based_opt.cpp
@@ -15,6 +15,7 @@
 #include "me_cond_based_rc.h"
 #include "me_cond_based_npc.h"
 #include "me_const.h"
+#include "dominance.h"
 
 // We do two types of condition based optimization here:
 // 1. condition based null pointer check(NPC) elimination
diff --git a/src/mapleall/maple_me/src/me_delegate_rc.cpp b/src/mapleall/maple_me/src/me_delegate_rc.cpp
index a4b1d627471c5ebd47d67c5fd071d6fcc9a490fa..fc73cdeb24e35fd1fd1e08c7a50114fc0e362a53 100644
--- a/src/mapleall/maple_me/src/me_delegate_rc.cpp
+++ b/src/mapleall/maple_me/src/me_delegate_rc.cpp
@@ -308,7 +308,7 @@ RegMeExpr *DelegateRC::RHSTempDelegated(MeExpr &rhs, const MeStmt &useStmt) {
     return nullptr;
   }
   // The index number in originalStVector is bigger than two.
-  if ((func.GetHints() & kPlacementRCed) && ssaTab.GetVersionsIndexSize(ost->GetIndex()) > 2) {
+  if ((func.GetHints() & kPlacementRCed) && ssaTab.GetVersionsIndicesSize(ost->GetIndex()) > 2) {
     return nullptr;
   }
   if (rhsVar.GetDefBy() == kDefByMustDef) {
diff --git a/src/mapleall/maple_me/src/me_dominance.cpp b/src/mapleall/maple_me/src/me_dominance.cpp
index fc316bcb2b84fa92157696a7781607d75d28ff89..3f0e968cf571142760d68d4fb5acdbf8dab72deb 100644
--- a/src/mapleall/maple_me/src/me_dominance.cpp
+++ b/src/mapleall/maple_me/src/me_dominance.cpp
@@ -30,14 +30,17 @@ AnalysisResult *MeDoDominance::Run(MeFunction *func, MeFuncResultMgr*, ModuleRes
   dom->ComputeDominance();
   dom->ComputeDomFrontiers();
   dom->ComputeDomChildren();
+  dom->ComputeIterDomFrontiers();
   size_t num = 0;
   dom->ComputeDtPreorder(*func->GetCommonEntryBB(), num);
   dom->GetDtPreOrder().resize(num);
   dom->ComputeDtDfn();
+
   dom->PdomGenPostOrderID();
   dom->ComputePostDominance();
   dom->ComputePdomFrontiers();
   dom->ComputePdomChildren();
+  dom->ComputeIterPdomFrontiers();
   num = 0;
   dom->ComputePdtPreorder(*func->GetCommonExitBB(), num);
   dom->ResizePdtPreOrder(num);
diff --git a/src/mapleall/maple_me/src/me_function.cpp b/src/mapleall/maple_me/src/me_function.cpp
index 58259e14e48dada488dcdde1f7ee371b1b9a2366..0bca6e30ef7409809d8fa3804c8fe782386077b2 100644
--- a/src/mapleall/maple_me/src/me_function.cpp
+++ b/src/mapleall/maple_me/src/me_function.cpp
@@ -565,7 +565,7 @@ void MeFunction::CloneBasicBlock(BB &newBB, const BB &orig) {
     newStmt->SetPrev(nullptr);
     newBB.AddStmtNode(newStmt);
     if (meSSATab != nullptr) {
-      meSSATab->CreateSSAStmt(*newStmt);
+      meSSATab->CreateSSAStmt(*newStmt, &newBB);
     }
   }
 }
@@ -579,7 +579,7 @@ void MeFunction::SplitBBPhysically(BB &bb, StmtNode &splitPoint, BB &newBB) {
       StmtNode *nextStmt = stmt->GetNext();
       newBB.AddStmtNode(stmt);
       if (meSSATab != nullptr) {
-        meSSATab->CreateSSAStmt(*stmt);
+        meSSATab->CreateSSAStmt(*stmt, &newBB);
       }
       stmt = nextStmt;
     }
diff --git a/src/mapleall/maple_me/src/me_rc_lowering.cpp b/src/mapleall/maple_me/src/me_rc_lowering.cpp
index 61952f37ca97aac569b80b0608cdd9a0cd3bf0ac..4f41cc1f4ef570dd8a3f8ced4bce148247978286 100644
--- a/src/mapleall/maple_me/src/me_rc_lowering.cpp
+++ b/src/mapleall/maple_me/src/me_rc_lowering.cpp
@@ -1000,7 +1000,7 @@ VarMeExpr *RCLowering::CreateNewTmpVarMeExpr(bool isLocalRefVar) {
   if (ost->GetZeroVersionIndex() == 0) {
     ost->SetZeroVersionIndex(irMap.GetVerst2MeExprTableSize());
     irMap.PushBackVerst2MeExprTable(nullptr);
-    ost->PushbackVersionIndex(ost->GetZeroVersionIndex());
+    ost->PushbackVersionsIndices(ost->GetZeroVersionIndex());
   }
   VarMeExpr *varMeExpr = irMap.CreateNewVarMeExpr(ost, PTY_ref);
   if (isLocalRefVar) {
diff --git a/src/mapleall/maple_me/src/me_ssa.cpp b/src/mapleall/maple_me/src/me_ssa.cpp
index e6b596eeaf6f25cd448b63a1ba42d93508acfe36..b17f52639ddff9196d5f30f9ea391e258e980d1a 100644
--- a/src/mapleall/maple_me/src/me_ssa.cpp
+++ b/src/mapleall/maple_me/src/me_ssa.cpp
@@ -45,135 +45,28 @@
 // returns from those recursive calls, we restores the stack of current SSA names to
 // the state that existed before the current block was visited.
 namespace maple {
-void MeSSA::BuildSSA() {
-  InsertPhiNode();
-  InitRenameStack(func->GetMeSSATab()->GetOriginalStTable(), func->GetAllBBs().size(),
-                  func->GetMeSSATab()->GetVersionStTable());
-  // recurse down dominator tree in pre-order traversal
-  const MapleSet<BBId> &children = dom->GetDomChildren(func->GetCommonEntryBB()->GetBBId());
-  for (const auto &child : children) {
-    RenameBB(*func->GetBBFromID(child));
-  }
-}
-
-void MeSSA::CollectDefBBs(std::map<OStIdx, std::set<BBId>> &ostDefBBs) {
-  // to prevent valid_end from being called repeatedly, don't modify the definition of eIt
-  for (auto bIt = func->valid_begin(), eIt = func->valid_end(); bIt != eIt; ++bIt) {
-    auto *bb = *bIt;
-    for (auto &stmt : bb->GetStmtNodes()) {
-      if (!kOpcodeInfo.HasSSADef(stmt.GetOpCode())) {
-        continue;
-      }
-      TypeOfMayDefList &mayDefs = GetSSATab()->GetStmtsSSAPart().GetMayDefNodesOf(stmt);
-      for (auto iter = mayDefs.begin(); iter != mayDefs.end(); ++iter) {
-        auto &mayDef = *iter;
-        OStIdx ostIdx = mayDef.GetResult()->GetOrigIdx();
-        const OriginalSt *ost = func->GetMeSSATab()->GetOriginalStFromID(ostIdx);
-        if (ost != nullptr && (!ost->IsFinal() || func->GetMirFunc()->IsConstructor())) {
-          ostDefBBs[ostIdx].insert(bb->GetBBId());
-        } else if (stmt.GetOpCode() == OP_intrinsiccallwithtype) {
-          auto &inNode = static_cast<IntrinsiccallNode&>(stmt);
-          if (inNode.GetIntrinsic() == INTRN_JAVA_CLINIT_CHECK) {
-            ostDefBBs[ostIdx].insert(bb->GetBBId());
-          }
-        }
-      }
-      if (stmt.GetOpCode() == OP_dassign || stmt.GetOpCode() == OP_maydassign) {
-        VersionSt *vst = GetSSATab()->GetStmtsSSAPart().GetAssignedVarOf(stmt);
-        OriginalSt *ost = vst->GetOst();
-        if (ost != nullptr && (!ost->IsFinal() || func->GetMirFunc()->IsConstructor())) {
-          ostDefBBs[vst->GetOrigIdx()].insert(bb->GetBBId());
-        }
-      }
-      // Needs to handle mustDef in callassigned stmt
-      if (!kOpcodeInfo.IsCallAssigned(stmt.GetOpCode())) {
-        continue;
-      }
-      MapleVector<MustDefNode> &mustDefs = GetSSATab()->GetStmtsSSAPart().GetMustDefNodesOf(stmt);
-      for (auto iter = mustDefs.begin(); iter != mustDefs.end(); ++iter) {
-        OriginalSt *ost = iter->GetResult()->GetOst();
-        if (ost != nullptr && (!ost->IsFinal() || func->GetMirFunc()->IsConstructor())) {
-          ostDefBBs[ost->GetIndex()].insert(bb->GetBBId());
-        }
-      }
-    }
-  }
-}
 
 void MeSSA::InsertPhiNode() {
-  std::map<OStIdx, std::set<BBId>> ost2DefBBs;
-  CollectDefBBs(ost2DefBBs);
-  OriginalStTable *otable = &func->GetMeSSATab()->GetOriginalStTable();
-  for (size_t i = 1; i < otable->Size(); ++i) {
-    OriginalSt *ost = otable->GetOriginalStFromID(OStIdx(i));
-    VersionSt *vst = func->GetMeSSATab()->GetVersionStTable().GetVersionStFromID(ost->GetZeroVersionIndex(), true);
-    CHECK_FATAL(vst != nullptr, "null ptr check");
-    if (ost2DefBBs[ost->GetIndex()].empty()) {
+  for (size_t i = 1; i < ssaTab->GetOriginalStTable().Size(); ++i) {
+    OriginalSt *ost = ssaTab->GetOriginalStFromID(OStIdx(i));
+    if (ost->GetIndirectLev() < 0) {
       continue;
     }
-    // volatile variables will not have ssa form.
-    if (ost->IsVolatile()) {
+    if (!ssaTab->HasDefBB(ost->GetIndex())) {
       continue;
     }
-    std::deque<BB*> workList;
-    for (auto it = ost2DefBBs[ost->GetIndex()].begin(); it != ost2DefBBs[ost->GetIndex()].end(); ++it) {
-      BB *defBB = func->GetAllBBs()[*it];
-      if (defBB != nullptr) {
-        workList.push_back(defBB);
-      }
+    if (ost->IsVolatile()) { // volatile variables will not have ssa form.
+      continue;
     }
-    while (!workList.empty()) {
-      BB *defBB = workList.front();
-      workList.pop_front();
-      MapleSet<BBId> &dfs = dom->GetDomFrontier(defBB->GetBBId());
-      for (auto bbID : dfs) {
-        BB *dfBB = func->GetBBFromID(bbID);
-        CHECK_FATAL(dfBB != nullptr, "null ptr check");
-        if (dfBB->PhiofVerStInserted(*vst) == nullptr) {
-          workList.push_back(dfBB);
-          dfBB->InsertPhi(&func->GetAlloc(), vst);
-          if (enabledDebug) {
-            ost->Dump();
-            LogInfo::MapleLogger() << " Defined In: BB" << defBB->GetBBId() << " Insert Phi Here: BB"
-                                   << dfBB->GetBBId() << '\n';
-          }
-        }
-      }
+    std::set<BBId> phibbs;
+    for (BBId bbid : *ssaTab->GetDefBBs4Ost(ost->GetIndex())) {
+      phibbs.insert(dom->iterDomFrontier[bbid].begin(), dom->iterDomFrontier[bbid].end());
     }
-  }
-}
-
-MeSSA::MeSSA(MeFunction &func, Dominance &dom, MemPool &memPool, bool enabledDebug)
-    : SSA(memPool, *func.GetMeSSATab()), AnalysisResult(&memPool), func(&func), dom(&dom), enabledDebug(enabledDebug) {}
-
-void MeSSA::RenameBB(BB &bb) {
-  if (GetBBRenamed(bb.GetBBId())) {
-    return;
-  }
-
-  SetBBRenamed(bb.GetBBId(), true);
-
-  // record stack size for variable versions before processing rename. It is used for stack pop up.
-  std::vector<uint32> oriStackSize(GetVstStacks().size());
-  for (size_t i = 1; i < GetVstStacks().size(); ++i) {
-    oriStackSize[i] = GetVstStack(i)->size();
-  }
-  RenamePhi(bb);
-  for (auto &stmt : bb.GetStmtNodes()) {
-    RenameUses(stmt);
-    RenameDefs(stmt, bb);
-    RenameMustDefs(stmt, bb);
-  }
-  RenamePhiUseInSucc(bb);
-  // Rename child in Dominator Tree.
-  ASSERT(bb.GetBBId() < dom->GetDomChildrenSize(), "index out of range in MeSSA::RenameBB");
-  const MapleSet<BBId> &children = dom->GetDomChildren(bb.GetBBId());
-  for (const BBId &child : children) {
-    RenameBB(*func->GetBBFromID(child));
-  }
-  for (size_t i = 1; i < GetVstStacks().size(); ++i) {
-    while (GetVstStack(i)->size() > oriStackSize[i]) {
-      PopVersionSt(i);
+    VersionSt *vst = ssaTab->GetVersionStTable().GetZeroVersionSt(ost);
+    for (BBId bbid : phibbs) {
+      BB *phiBB = bbVec[bbid];
+      CHECK_FATAL(phiBB != nullptr, "MeSSA::InsertPhiNode: non-existent BB for definition");
+      phiBB->InsertPhi(&func->GetMeSSATab()->GetVersAlloc(), vst);
     }
   }
 }
@@ -224,9 +117,20 @@ AnalysisResult *MeDoSSA::Run(MeFunction *func, MeFuncResultMgr *funcResMgr, Modu
   auto *ssaTab = static_cast<SSATab*>(funcResMgr->GetAnalysisResult(MeFuncPhase_SSATAB, func));
   CHECK_FATAL(ssaTab != nullptr, "ssaTab phase has problem");
   MemPool *ssaMp = NewMemPool();
-  auto *ssa = ssaMp->New<MeSSA>(*func, *dom, *ssaMp, DEBUGFUNC(func));
-  ssa->BuildSSA();
+  auto *ssa = ssaMp->New<MeSSA>(*func, func->GetMeSSATab(), *dom, *ssaMp);
+
+  ssa->InsertPhiNode();
+
+  ssa->InitRenameStack(func->GetMeSSATab()->GetOriginalStTable(), func->GetAllBBs().size(), func->GetMeSSATab()->GetVersionStTable());
+
+  // recurse down dominator tree in pre-order traversal
+  MapleSet<BBId> *children = &dom->domChildren[func->GetCommonEntryBB()->GetBBId()];
+  for (BBId child : *children) {
+    ssa->RenameBB(*func->GetBBFromID(child));
+  }
+
   ssa->VerifySSA();
+
   if (DEBUGFUNC(func)) {
     ssaTab->GetVersionStTable().Dump(&ssaTab->GetModule());
   }
diff --git a/src/mapleall/maple_me/src/me_ssa_tab.cpp b/src/mapleall/maple_me/src/me_ssa_tab.cpp
index da77c4d9d7420ee1cf5e4cbfd153d3c3f0bd48f1..b34372132f3b23f011928861c905b466340e7f4a 100644
--- a/src/mapleall/maple_me/src/me_ssa_tab.cpp
+++ b/src/mapleall/maple_me/src/me_ssa_tab.cpp
@@ -35,7 +35,7 @@ AnalysisResult *MeDoSSATab::Run(MeFunction *func, MeFuncResultMgr*, ModuleResult
   for (auto bIt = func->valid_begin(); bIt != func->valid_end(); ++bIt) {
     auto *bb = *bIt;
     for (auto &stmt : bb->GetStmtNodes()) {
-      ssaTab->CreateSSAStmt(stmt);  // this adds the SSANodes for exprs
+      ssaTab->CreateSSAStmt(stmt, bb);  // this adds the SSANodes for exprs
     }
   }
   if (DEBUGFUNC(func)) {
diff --git a/src/mapleall/maple_me/src/me_ssa_update.cpp b/src/mapleall/maple_me/src/me_ssa_update.cpp
index 9bc7e93f39614bf48256d4ce0660d9825e52fd9e..ac4357fbcbfd2352ef9e97ec1314110a5f0acf81 100644
--- a/src/mapleall/maple_me/src/me_ssa_update.cpp
+++ b/src/mapleall/maple_me/src/me_ssa_update.cpp
@@ -20,29 +20,16 @@
 // If some assignments have been deleted, the current implementation does not
 // delete useless phi's, and these useless phi's may end up hving identical
 // phi operands.
+
 namespace maple {
-// accumulate the BBs that are in the iterated dominance frontiers of bb in
-// the set dfSet, visiting each BB only once
-void MeSSAUpdate::GetIterDomFrontier(const BB &bb, MapleSet<BBId> &dfSet, std::vector<bool> &visitedMap) const {
-  CHECK_FATAL(bb.GetBBId() < visitedMap.size(), "index out of range in MeSSAUpdate::GetIterDomFrontier");
-  if (visitedMap[bb.GetBBId()]) {
-    return;
-  }
-  visitedMap[bb.GetBBId()] = true;
-  for (auto frontierBBId : dom.GetDomFrontier(bb.GetBBId())) {
-    dfSet.insert(frontierBBId);
-    BB *frontierBB = func.GetBBFromID(frontierBBId);
-    GetIterDomFrontier(*frontierBB, dfSet, visitedMap);
-  }
-}
 
 void MeSSAUpdate::InsertPhis() {
+  MapleMap<OStIdx, MapleSet<BBId> *>::iterator it = updateCands.begin();
   MapleSet<BBId> dfSet(ssaUpdateAlloc.Adapter());
-  for (auto it = updateCands.begin(); it != updateCands.end(); ++it) {
-    std::vector<bool> visitedMap(func.GetAllBBs().size(), false);
+  for (; it != updateCands.end(); ++it) {
     dfSet.clear();
     for (const auto &bbId : *it->second) {
-      GetIterDomFrontier(*func.GetBBFromID(bbId), dfSet, visitedMap);
+      dfSet.insert(dom.iterDomFrontier[bbId].begin(), dom.iterDomFrontier[bbId].end());
     }
     for (const auto &bbId : dfSet) {
       // insert a phi node
diff --git a/src/mapleall/maple_me/src/me_ssi.cpp b/src/mapleall/maple_me/src/me_ssi.cpp
index e79d526d8ac6430a3d851c935b4e3ef382657f48..6b0766a5f46f429195e8ca6881d075de5c9aab1b 100644
--- a/src/mapleall/maple_me/src/me_ssi.cpp
+++ b/src/mapleall/maple_me/src/me_ssi.cpp
@@ -31,7 +31,7 @@ VarMeExpr *MeSSI::CreateNewPiExpr(const MeExpr &opnd) {
                                          irMap->GetVerst2MeExprTable().size(), opnd.GetPrimType());
   irMap->SetExprID(irMap->GetExprID() + 1);
   irMap->PushBackVerst2MeExprTable(var);
-  ost->PushbackVersionIndex(var->GetVstIdx());
+  ost->PushbackVersionsIndices(var->GetVstIdx());
   return var;
 }
 
diff --git a/src/mapleall/maple_me/src/me_stmt_fre.cpp b/src/mapleall/maple_me/src/me_stmt_fre.cpp
index 5ab5dd1c55e1142ade4bc2014b0c4621778c9f1f..bce4839118cf5988202a791444ffce01a51cc8e8 100644
--- a/src/mapleall/maple_me/src/me_stmt_fre.cpp
+++ b/src/mapleall/maple_me/src/me_stmt_fre.cpp
@@ -12,6 +12,7 @@
  * FIT FOR A PARTICULAR PURPOSE.
  * See the Mulan PSL v2 for more details.
  */
+#include "me_option.h"
 #include "me_stmt_pre.h"
 
 namespace maple {
diff --git a/src/mapleall/maple_me/src/me_stmt_pre.cpp b/src/mapleall/maple_me/src/me_stmt_pre.cpp
index 1f37bf9fb97a7cf74fc35ad59c5cb203971fefdd..7755d95889dbb1743346389e51195f9d2583e45f 100644
--- a/src/mapleall/maple_me/src/me_stmt_pre.cpp
+++ b/src/mapleall/maple_me/src/me_stmt_pre.cpp
@@ -12,11 +12,11 @@
  * FIT FOR A PARTICULAR PURPOSE.
  * See the Mulan PSL v2 for more details.
  */
-#include "me_stmt_pre.h"
 #include "utils.h"
 #include "me_dominance.h"
 #include "me_option.h"
 #include "me_ssa_update.h"
+#include "me_stmt_pre.h"
 
 // Note: after the movement of assignments, some phi nodes that used to be dead
 // can become live.  Before we run another round of dead store elimination, we
diff --git a/src/mapleall/maple_me/src/ssa.cpp b/src/mapleall/maple_me/src/ssa.cpp
index 79223c5042f9d7d1c9228aa89ad8eb90b4b36ff0..99e56e9241180ba4520f191410bbf4188cb29f42 100644
--- a/src/mapleall/maple_me/src/ssa.cpp
+++ b/src/mapleall/maple_me/src/ssa.cpp
@@ -17,17 +17,19 @@
 #include "ssa_tab.h"
 #include "ssa_mir_nodes.h"
 #include "ver_symbol.h"
+#include "dominance.h"
 
 namespace maple {
 void SSA::InitRenameStack(OriginalStTable &oTable, size_t bbSize, VersionStTable &verStTab) {
   vstStacks.resize(oTable.Size());
-  vstVersions.resize(oTable.Size(), 0);
   bbRenamed.resize(bbSize, false);
   for (size_t i = 1; i < oTable.Size(); ++i) {
-    MapleStack<VersionSt*> *vStack = ssaAlloc.GetMemPool()->New<MapleStack<VersionSt*>>(ssaAlloc.Adapter());
     const OriginalSt *ost = oTable.GetOriginalStFromID(OStIdx(i));
-    VersionSt *temp = (ost->GetIndirectLev() >= 0) ? verStTab.GetVersionStFromID(ost->GetZeroVersionIndex(), true)
-                                                   : &verStTab.GetDummyVersionSt();
+    if (ost->GetIndirectLev() < 0) {
+      continue;
+    }
+    MapleStack<VersionSt*> *vStack = ssaAlloc.GetMemPool()->New<MapleStack<VersionSt*>>(ssaAlloc.Adapter());
+    VersionSt *temp = verStTab.GetVersionStVectorItem(ost->GetZeroVersionIndex());
     vStack->push(temp);
     vstStacks[i] = vStack;
   }
@@ -36,13 +38,13 @@ void SSA::InitRenameStack(OriginalStTable &oTable, size_t bbSize, VersionStTable
 VersionSt *SSA::CreateNewVersion(VersionSt &vSym, BB &defBB) {
   CHECK_FATAL(vSym.GetVersion() == 0, "rename before?");
   // volatile variables will keep zero version.
-  OriginalSt *oSt = vSym.GetOst();
+  const OriginalSt *oSt = vSym.GetOst();
   if (oSt->IsVolatile() || oSt->IsSpecialPreg()) {
     return &vSym;
   }
-  CHECK_FATAL(vSym.GetOrigIdx() < vstVersions.size(), "index out of range in SSA::CreateNewVersion");
+  ASSERT(vSym.GetVersion() == kInitVersion, "renamed before");
   VersionSt *newVersionSym =
-      ssaTab->GetVersionStTable().CreateVSymbol(&vSym, ++vstVersions[vSym.GetOrigIdx()]);
+      ssaTab->GetVersionStTable().CreateNextVersionSt(vSym.GetOst());
   vstStacks[vSym.GetOrigIdx()]->push(newVersionSym);
   newVersionSym->SetDefBB(&defBB);
   return newVersionSym;
@@ -51,10 +53,7 @@ VersionSt *SSA::CreateNewVersion(VersionSt &vSym, BB &defBB) {
 void SSA::RenamePhi(BB &bb) {
   for (auto phiIt = bb.GetPhiList().begin(); phiIt != bb.GetPhiList().end(); ++phiIt) {
     VersionSt *vSym = (*phiIt).second.GetResult();
-    // It shows that this BB has been renamed.
-    if (vSym->GetVersion() > 0) {
-      return;
-    }
+
     VersionSt *newVersionSym = CreateNewVersion(*vSym, bb);
     (*phiIt).second.SetResult(*newVersionSym);
     newVersionSym->SetDefType(VersionSt::kPhi);
@@ -152,6 +151,44 @@ void SSA::RenamePhiUseInSucc(const BB &bb) {
   }
 }
 
+void SSA::RenameBB(BB &bb) {
+  if (GetBBRenamed(bb.GetBBId())) {
+    return;
+  }
+
+  SetBBRenamed(bb.GetBBId(), true);
+
+  // record stack size for variable versions before processing rename. It is used for stack pop up.
+  std::vector<uint32> oriStackSize(GetVstStacks().size());
+  for (size_t i = 1; i < GetVstStacks().size(); ++i) {
+    if (GetVstStacks()[i] == nullptr) {
+      continue;
+    }
+    oriStackSize[i] = GetVstStack(i)->size();
+  }
+  RenamePhi(bb);
+  for (auto &stmt : bb.GetStmtNodes()) {
+    RenameUses(stmt);
+    RenameDefs(stmt, bb);
+    RenameMustDefs(stmt, bb);
+  }
+  RenamePhiUseInSucc(bb);
+  // Rename child in Dominator Tree.
+  ASSERT(bb.GetBBId() < dom->GetDomChildrenSize(), "index out of range in MeSSA::RenameBB");
+  const MapleSet<BBId> &children = dom->GetDomChildren(bb.GetBBId());
+  for (const BBId &child : children) {
+    RenameBB(*bbVec[child]);
+  }
+  for (size_t i = 1; i < GetVstStacks().size(); ++i) {
+    if (GetVstStacks()[i] == nullptr) {
+      continue;
+    }
+    while (GetVstStack(i)->size() > oriStackSize[i]) {
+      PopVersionSt(i);
+    }
+  }
+}
+
 void PhiNode::Dump() {
   GetResult()->Dump();
   LogInfo::MapleLogger() << " = PHI(";
diff --git a/src/mapleall/maple_me/src/ssa_tab.cpp b/src/mapleall/maple_me/src/ssa_tab.cpp
index 0d4629cfb7b5845c17d210912ca214202d663055..c83029a254b3b175f78ccb03c390a083934410a8 100644
--- a/src/mapleall/maple_me/src/ssa_tab.cpp
+++ b/src/mapleall/maple_me/src/ssa_tab.cpp
@@ -34,16 +34,16 @@ BaseNode *SSATab::CreateSSAExpr(BaseNode &expr) {
     AddrofSSANode *ssaNode = mirModule.CurFunction()->GetCodeMemPool()->New<AddrofSSANode>(addrofNode);
     MIRSymbol *st = mirModule.CurFunction()->GetLocalOrGlobalSymbol(ssaNode->GetStIdx());
     OriginalSt *ost = FindOrCreateSymbolOriginalSt(*st, mirModule.CurFunction()->GetPuidx(), ssaNode->GetFieldID());
-    VersionSt *vst = versionStTable.FindOrCreateVersionSt(ost, kInitVersion);
-    ssaNode->SetSSAVar(*vst);
+    versionStTable.CreateZeroVersionSt(ost);
+    ssaNode->SetSSAVar(*versionStTable.GetZeroVersionSt(ost));
     return ssaNode;
   } else if (expr.GetOpCode() == OP_regread) {
     auto &regReadNode = static_cast<RegreadNode&>(expr);
     RegreadSSANode *ssaNode = mirModule.CurFunction()->GetCodeMemPool()->New<RegreadSSANode>(regReadNode);
     OriginalSt *ost =
         originalStTable.FindOrCreatePregOriginalSt(ssaNode->GetRegIdx(), mirModule.CurFunction()->GetPuidx());
-    VersionSt *vst = versionStTable.FindOrCreateVersionSt(ost, kInitVersion);
-    ssaNode->SetSSAVar(*vst);
+    versionStTable.CreateZeroVersionSt(ost);
+    ssaNode->SetSSAVar(*versionStTable.GetZeroVersionSt(ost));
     return ssaNode;
   } else if (expr.GetOpCode() == OP_iread) {
     auto &ireadNode = static_cast<IreadNode&>(expr);
@@ -63,7 +63,7 @@ BaseNode *SSATab::CreateSSAExpr(BaseNode &expr) {
   return nullptr;
 }
 
-void SSATab::CreateSSAStmt(StmtNode &stmt) {
+void SSATab::CreateSSAStmt(StmtNode &stmt, BB *curbb) {
   for (size_t i = 0; i < stmt.NumOpnds(); ++i) {
     BaseNode *newOpnd = CreateSSAExpr(*stmt.Opnd(i));
     if (newOpnd != nullptr) {
@@ -81,8 +81,9 @@ void SSATab::CreateSSAStmt(StmtNode &stmt) {
       CHECK_FATAL(st != nullptr, "null ptr check");
 
       OriginalSt *ost = FindOrCreateSymbolOriginalSt(*st, mirModule.CurFunction()->GetPuidx(), dNode.GetFieldID());
-      VersionSt *vst = versionStTable.FindOrCreateVersionSt(ost, kInitVersion);
-      theSSAPart->SetSSAVar(*vst);
+      AddDefBB4Ost(ost->GetIndex(), curbb->GetBBId());
+      versionStTable.CreateZeroVersionSt(ost);
+      theSSAPart->SetSSAVar(*versionStTable.GetZeroVersionSt(ost));
       // if the rhs may throw exception, we insert MayDef of the lhs var
       if (stmt.GetOpCode() == OP_maydassign) {
         theSSAPart->InsertMayDefNode(theSSAPart->GetSSAVar(), &dNode);
@@ -93,7 +94,9 @@ void SSATab::CreateSSAStmt(StmtNode &stmt) {
       auto &regNode = static_cast<RegassignNode&>(stmt);
       OriginalSt *ost =
           originalStTable.FindOrCreatePregOriginalSt(regNode.GetRegIdx(), mirModule.CurFunction()->GetPuidx());
-      VersionSt *vst = versionStTable.FindOrCreateVersionSt(ost, kInitVersion);
+      AddDefBB4Ost(ost->GetIndex(), curbb->GetBBId());
+      versionStTable.CreateZeroVersionSt(ost);
+      VersionSt *vst = versionStTable.GetZeroVersionSt(ost);
       stmtsSSAPart.SetSSAPartOf(stmt, vst);
       return;
     }
@@ -117,23 +120,25 @@ void SSATab::CreateSSAStmt(StmtNode &stmt) {
             stmtsSSAPart.GetSSAPartMp()->New<MayDefMayUseMustDefPart>(&stmtsSSAPart.GetSSAPartAlloc());
         stmtsSSAPart.SetSSAPartOf(stmt, theSSAPart);
         // insert the mustdefs
-        auto *nrets = static_cast<NaryStmtNode&>(stmt).GetCallReturnVector();
+        CallReturnVector *nrets = static_cast<NaryStmtNode&>(stmt).GetCallReturnVector();
         CHECK_FATAL(nrets != nullptr, "CreateSSAStmt: failed to retrieve call return vector");
         if (nrets->empty()) {
           return;
         }
         for (CallReturnPair &retPair : *nrets) {
+          OriginalSt *ost = nullptr;
           if (!retPair.second.IsReg()) {
             StIdx stidx = retPair.first;
             MIRSymbolTable *symTab = mirModule.CurFunction()->GetSymTab();
             MIRSymbol *st = symTab->GetSymbolFromStIdx(stidx.Idx());
-            OriginalSt *ost =
-                FindOrCreateSymbolOriginalSt(*st, mirModule.CurFunction()->GetPuidx(), retPair.second.GetFieldID());
-            VersionSt *vst = versionStTable.FindOrCreateVersionSt(ost, kInitVersion);
-            theSSAPart->InsertMustDefNode(vst, &stmt);
+            ost = FindOrCreateSymbolOriginalSt(*st, mirModule.CurFunction()->GetPuidx(), retPair.second.GetFieldID());
           } else {
-            ASSERT(false, "NYI");
+            ost = originalStTable.FindOrCreatePregOriginalSt(retPair.second.GetPregIdx(), mirModule.CurFunction()->GetPuidx());
           }
+          versionStTable.CreateZeroVersionSt(ost);
+          VersionSt *vst = versionStTable.GetZeroVersionSt(ost);
+          AddDefBB4Ost(ost->GetIndex(), curbb->GetBBId());
+          theSSAPart->InsertMustDefNode(vst, &stmt);
         }
       } else if (kOpcodeInfo.IsCall(stmt.GetOpCode())) {
         stmtsSSAPart.SetSSAPartOf(stmt,
diff --git a/src/mapleall/maple_me/src/ver_symbol.cpp b/src/mapleall/maple_me/src/ver_symbol.cpp
index 4702f9264caf1745f600c4f0d02a9e49085ed88b..7b71e03cf0dc726fc33a97a68601954323a30891 100644
--- a/src/mapleall/maple_me/src/ver_symbol.cpp
+++ b/src/mapleall/maple_me/src/ver_symbol.cpp
@@ -18,7 +18,7 @@
 #include "ssa_mir_nodes.h"
 
 namespace maple {
-VersionSt VersionStTable::dummyVST(0, 0, nullptr);
+
 void VersionSt::DumpDefStmt(const MIRModule*) const {
   if (version <= 0) {
     return;
@@ -41,28 +41,26 @@ void VersionSt::DumpDefStmt(const MIRModule*) const {
   }
 }
 
-VersionSt *VersionStTable::CreateVersionSt(OriginalSt *ost, size_t version) {
-  ASSERT(ost != nullptr, "nullptr check");
-  ASSERT(ost->GetVersionsIndex().size() == version, "ssa version need to be created incrementally!");
-  auto *vst = vstAlloc.GetMemPool()->New<VersionSt>(versionStVector.size(), version, ost);
+VersionSt *VersionStTable::CreateNextVersionSt(OriginalSt *ost) {
+  ASSERT(ost->GetVersionsIndices().size() != 0, "CreateNextVersionSt: zero version must have been created first");
+  VersionSt *vst = vstAlloc.GetMemPool()->New<VersionSt>(versionStVector.size(), ost->GetVersionsIndices().size(), ost);
   versionStVector.push_back(vst);
-  ost->PushbackVersionIndex(vst->GetIndex());
-  if (version == kInitVersion) {
-    ost->SetZeroVersionIndex(vst->GetIndex());
-  }
-  vst->SetOrigSt(ost);
+  ost->PushbackVersionsIndices(vst->GetIndex());
+  vst->SetOst(ost);
   return vst;
 }
 
-VersionSt *VersionStTable::FindOrCreateVersionSt(OriginalSt *ost, size_t version) {
-  // this version already exists...
-  ASSERT(ost != nullptr, "nullptr check");
-  if (ost->GetVersionsIndex().size() > version) {
-    size_t versionIndex = ost->GetVersionIndex(version);
-    ASSERT(versionStVector.size() > versionIndex, "versionStVector out of range");
-    return versionStVector.at(versionIndex);
+void VersionStTable::CreateZeroVersionSt(OriginalSt *ost) {
+  if (ost->GetZeroVersionIndex() != 0) {
+    return;  // already created
   }
-  return CreateVersionSt(ost, version);
+  ASSERT(ost->GetVersionsIndices().size() == 0, "ssa version need to be created incrementally!");
+  VersionSt *vst = vstAlloc.GetMemPool()->New<VersionSt>(versionStVector.size(), kInitVersion, ost);
+  versionStVector.push_back(vst);
+  ost->PushbackVersionsIndices(vst->GetIndex());
+  ost->SetZeroVersionIndex(vst->GetIndex());
+  vst->SetOst(ost);
+  return;
 }
 
 void VersionStTable::Dump(const MIRModule *mod) const {