diff --git a/src/mapleall/maple_me/include/irmap.h b/src/mapleall/maple_me/include/irmap.h
index 59e649e293e66b744d3d67e0c842e8854773a943..289317a4472d535e80d960a251aca093649c4be9 100644
--- a/src/mapleall/maple_me/include/irmap.h
+++ b/src/mapleall/maple_me/include/irmap.h
@@ -32,7 +32,7 @@ class IRMap : public AnalysisResult {
         irMapAlloc(&memPool),
         mapHashLength(hashTableSize),
         hashTable(mapHashLength, nullptr, irMapAlloc.Adapter()),
-        vst2MeExprTable(ssaTab.GetVersionStTableSize(), nullptr, irMapAlloc.Adapter()),
+        verst2MeExprTable(ssaTab.GetVersionStTableSize(), nullptr, irMapAlloc.Adapter()),
         lpreTmps(irMapAlloc.Adapter()),
         vst2Decrefs(irMapAlloc.Adapter()) {}
 
@@ -40,40 +40,53 @@ class IRMap : public AnalysisResult {
   virtual BB *GetBB(BBId id) = 0;
   virtual BB *GetBBForLabIdx(LabelIdx lidx, PUIdx pidx = 0) = 0;
   MeExpr *HashMeExpr(MeExpr &meExpr);
-  IvarMeExpr *BuildIvarFromOpMeExpr(OpMeExpr &opMeExpr);
   IvarMeExpr *BuildLHSIvarFromIassMeStmt(IassignMeStmt &iassignMeStmt);
   IvarMeExpr *BuildLHSIvar(MeExpr &baseAddr, IassignMeStmt &iassignMeStmt, FieldID fieldID);
-  RegMeExpr *CreateRegRefMeExpr(const MeExpr&);
-  RegMeExpr *CreateRegRefMeExpr(MIRType&);
-  VarMeExpr *CreateVarMeExprVersion(const VarMeExpr&);
-  MeExpr *CreateAddrofMeExpr(OStIdx ostIdx);
   MeExpr *CreateAddrofMeExpr(MeExpr&);
   MeExpr *CreateAddroffuncMeExpr(PUIdx);
   MeExpr *CreateAddrofMeExprFromSymbol(MIRSymbol& sym, PUIdx  puIdx);
   MeExpr *CreateIaddrofMeExpr(MeExpr &expr, TyIdx tyIdx, MeExpr &base);
   MeExpr *CreateIvarMeExpr(MeExpr &expr, TyIdx tyIdx, MeExpr &base);
-  RegMeExpr *CreateRegMeExpr(PrimType);
+
+  // for creating VarMeExpr
+  VarMeExpr *CreateVarMeExprVersion(OriginalSt *ost);
+  VarMeExpr *CreateVarMeExprVersion(const VarMeExpr &varx) {
+    return CreateVarMeExprVersion(varx.GetOst());
+  }
+  VarMeExpr *GetOrCreateZeroVersionVarMeExpr(OriginalSt &ost);
+  VarMeExpr *CreateNewVar(GStrIdx strIdx, PrimType primType, bool isGlobal);
+  VarMeExpr *CreateNewLocalRefVarTmp(GStrIdx strIdx, TyIdx tIdx);
+
+  // for creating RegMeExpr
   RegMeExpr *CreateRegMeExprVersion(OriginalSt&);
-  RegMeExpr *CreateRegMeExprVersion(const RegMeExpr&);
+  RegMeExpr *CreateRegMeExprVersion(const RegMeExpr &regx) {
+    return CreateRegMeExprVersion(*regx.GetOst());
+  }
+  RegMeExpr *CreateRegMeExpr(PrimType);
+  RegMeExpr *CreateRegMeExpr(MIRType&);
+  RegMeExpr *CreateRegMeExpr(const MeExpr &meexpr) {
+    MIRType *mirType = meexpr.GetType();
+    if (mirType == nullptr || mirType->GetPrimType() == PTY_agg) {
+      return CreateRegMeExpr(meexpr.GetPrimType());
+    }
+    return CreateRegMeExpr(*mirType);
+  }
+
   MeExpr *ReplaceMeExprExpr(MeExpr&, const MeExpr&, MeExpr&);
   bool ReplaceMeExprStmt(MeStmt&, const MeExpr&, MeExpr&);
   MeExpr *GetMeExprByVerID(uint32 verid) const {
-    return vst2MeExprTable[verid];
+    return verst2MeExprTable[verid];
   }
 
-  VarMeExpr *GetOrCreateZeroVersionVarMeExpr(OriginalSt &ost);
   MeExpr *GetMeExpr(size_t index) {
-    ASSERT(index < vst2MeExprTable.size(), "index out of range");
-    MeExpr *meExpr = vst2MeExprTable.at(index);
+    ASSERT(index < verst2MeExprTable.size(), "index out of range");
+    MeExpr *meExpr = verst2MeExprTable.at(index);
     if (meExpr != nullptr) {
       ASSERT(meExpr->GetMeOp() == kMeOpVar || meExpr->GetMeOp() == kMeOpReg, "opcode error");
     }
     return meExpr;
   }
 
-  VarMeExpr *CreateNewVarMeExpr(OriginalSt *ost, PrimType pType);
-  VarMeExpr *CreateNewGlobalTmp(GStrIdx strIdx, PrimType pType);
-  VarMeExpr *CreateNewLocalRefVarTmp(GStrIdx strIdx, TyIdx tIdx);
   DassignMeStmt *CreateDassignMeStmt(MeExpr&, MeExpr&, BB&);
   IassignMeStmt *CreateIassignMeStmt(TyIdx, IvarMeExpr&, MeExpr&, const MapleMap<OStIdx, ChiMeNode*>&);
   RegassignMeStmt *CreateRegassignMeStmt(MeExpr&, MeExpr&, BB&);
@@ -95,6 +108,7 @@ class IRMap : public AnalysisResult {
 
   MeExpr *CreateIntConstMeExpr(int64, PrimType);
   MeExpr *CreateConstMeExpr(PrimType, MIRConst&);
+  MeExpr *CreateMeExprUnary(Opcode, PrimType, MeExpr&);
   MeExpr *CreateMeExprBinary(Opcode, PrimType, MeExpr&, MeExpr&);
   MeExpr *CreateMeExprCompare(Opcode, PrimType, PrimType, MeExpr&, MeExpr&);
   MeExpr *CreateMeExprSelect(PrimType, MeExpr&, MeExpr&, MeExpr&);
@@ -146,20 +160,12 @@ class IRMap : public AnalysisResult {
     exprID = id;
   }
 
-  const MapleVector<MeExpr*> &GetVerst2MeExprTable() const {
-    return vst2MeExprTable;
+  MapleVector<MeExpr*> &GetVerst2MeExprTable() {
+    return verst2MeExprTable;
   }
 
   MeExpr *GetVerst2MeExprTableItem(int i) {
-    return vst2MeExprTable[i];
-  }
-
-  size_t GetVerst2MeExprTableSize() const {
-    return vst2MeExprTable.size();
-  }
-
-  void PushBackVerst2MeExprTable(MeExpr *item) {
-    vst2MeExprTable.push_back(item);
+    return verst2MeExprTable[i];
   }
 
   MapleUnorderedMap<OStIdx, RegMeExpr*>::iterator GetLpreTmpsEnd() {
@@ -213,7 +219,7 @@ class IRMap : public AnalysisResult {
   int32 exprID = 0;                                // for allocating exprid_ in MeExpr
   uint32 mapHashLength;                            // size of hashTable
   MapleVector<MeExpr*> hashTable;                  // the value number hash table
-  MapleVector<MeExpr*> vst2MeExprTable;            // map versionst to MeExpr.
+  MapleVector<MeExpr*> verst2MeExprTable;          // map versionst to MeExpr.
   MapleUnorderedMap<OStIdx, RegMeExpr*> lpreTmps;  // for passing LPRE's temp usage to SPRE
   MapleUnorderedMap<VarMeExpr*, MapleSet<MeStmt*>*> vst2Decrefs;  // map versionst to decrefreset.
   bool needAnotherPass = false;                    // set to true if CFG has changed
@@ -222,7 +228,6 @@ class IRMap : public AnalysisResult {
 
   bool ReplaceMeExprStmtOpnd(uint32, MeStmt&, const MeExpr&, MeExpr&);
   void PutToBucket(uint32, MeExpr&);
-  RegMeExpr *CreateRefRegMeExpr(const MIRSymbol&);
   BB *GetFalseBrBB(const CondGotoMeStmt&);
   MeExpr *ReplaceMeExprExpr(MeExpr &origExpr, MeExpr &newExpr, size_t opndsSize, const MeExpr &meExpr, MeExpr &repExpr);
 };
diff --git a/src/mapleall/maple_me/include/me_analyze_rc.h b/src/mapleall/maple_me/include/me_analyze_rc.h
index b289a75ea4eebe9607a1a05247dc1c7c3d3176b6..d06cd17dfc9ca1c80417865c8444b6cee0e858ad 100644
--- a/src/mapleall/maple_me/include/me_analyze_rc.h
+++ b/src/mapleall/maple_me/include/me_analyze_rc.h
@@ -70,7 +70,9 @@ class AnalyzeRC {
   void RenameUses(MeStmt &meStmt);
   RCItem *FindOrCreateRCItem(OriginalSt &ost);
   OriginalSt *GetOriginalSt(const MeExpr &refLHS) const;
+#if 1
   VarMeExpr *GetZeroVersionVarMeExpr(const VarMeExpr &var);
+#endif
   bool NeedIncref(const MeStmt &stmt) const;
   UnaryMeStmt *CreateIncrefZeroVersion(OriginalSt &ost);
   DassignMeStmt *CreateDassignInit(OriginalSt &ost, BB &bb);
diff --git a/src/mapleall/maple_me/include/me_delegate_rc.h b/src/mapleall/maple_me/include/me_delegate_rc.h
index 77e067c796bd4f22045d505ec41bc5848ba5169c..2f9be3a1d605853fcf2290b9b93f28f1932257fa 100644
--- a/src/mapleall/maple_me/include/me_delegate_rc.h
+++ b/src/mapleall/maple_me/include/me_delegate_rc.h
@@ -27,11 +27,11 @@ class DelegateRC {
         ssaTab(*func.GetMeSSATab()),
         dominance(dom),
         delegateRCAllocator(memPool),
-        verStCantDelegate(irMap.GetVerst2MeExprTableSize(), false, delegateRCAllocator.Adapter()),
-        verStUseCounts(irMap.GetVerst2MeExprTableSize(), 0, delegateRCAllocator.Adapter()),
+        verStCantDelegate(irMap.GetVerst2MeExprTable().size(), false, delegateRCAllocator.Adapter()),
+        verStUseCounts(irMap.GetVerst2MeExprTable().size(), 0, delegateRCAllocator.Adapter()),
         refVar2RegMap(delegateRCAllocator.Adapter()),
-        verStDerefedCopied(irMap.GetVerst2MeExprTableSize(), false, delegateRCAllocator.Adapter()),
-        verStCantDecrefEarly(irMap.GetVerst2MeExprTableSize(), false, delegateRCAllocator.Adapter()),
+        verStDerefedCopied(irMap.GetVerst2MeExprTable().size(), false, delegateRCAllocator.Adapter()),
+        verStCantDecrefEarly(irMap.GetVerst2MeExprTable().size(), false, delegateRCAllocator.Adapter()),
         enabledDebug(enabledDebug) {}
 
   virtual ~DelegateRC() = default;
diff --git a/src/mapleall/maple_me/include/me_ir.h b/src/mapleall/maple_me/include/me_ir.h
index 195f33c1e81275e599384bd422b105474fd6d6c7..60be26f98ec41718282b571691f45c3aaa8f4043 100644
--- a/src/mapleall/maple_me/include/me_ir.h
+++ b/src/mapleall/maple_me/include/me_ir.h
@@ -145,6 +145,8 @@ class MeExpr {
     return nullptr;
   }
 
+  virtual MIRType *GetType() const { return nullptr; }
+
   MeExpr &GetAddrExprBase();               // get the base of the address expression
   // in the expression; nullptr otherwise
   bool SymAppears(OStIdx oidx);  // check if symbol appears in the expression
@@ -314,7 +316,7 @@ class ScalarMeExpr : public MeExpr {
   bool IsSameVariableValue(const VarMeExpr&) const override;
   ScalarMeExpr *FindDefByStmt(std::set<ScalarMeExpr*> &visited);
 
- private:
+ protected:
   OriginalSt *ost;
   uint32 vstIdx;    // the index in MEOptimizer's VersionStTable, 0 if not in VersionStTable
   MeDefBy defBy : 3;
@@ -383,6 +385,10 @@ class VarMeExpr final : public ScalarMeExpr {
     noSubsumeRC = noSubsumeRCVal;
   }
 
+  MIRType *GetType() const override {
+    return GlobalTables::GetTypeTable().GetTypeFromTyIdx(ost->GetTyIdx());
+  }
+
  private:
   bool noDelegateRC = false;  // true if this cannot be optimized by delegaterc
   bool noSubsumeRC = false;   // true if this cannot be optimized by subsumrc
@@ -466,6 +472,10 @@ class MePhiNode {
     return isPiAdded;
   }
 
+  bool UseReg() const {
+    return lhs->GetMeOp() == kMeOpReg;
+  }
+
  private:
   ScalarMeExpr *lhs = nullptr;
   MapleVector<ScalarMeExpr*> opnds;
@@ -686,6 +696,11 @@ class AddroffuncMeExpr : public MeExpr {
     return puIdx << addroffuncHashShift;
   }
 
+  MIRType *GetType() const override {
+    MIRFunction *func = GlobalTables::GetFunctionTable().GetFunctionFromPuidx(puIdx);
+    return GlobalTables::GetTypeTable().GetOrCreatePointerType(*func->GetMIRFuncType(), PTY_ptr);
+  }
+
  private:
   PUIdx puIdx;
 };
@@ -843,6 +858,13 @@ class OpMeExpr : public MeExpr {
     return hashIdx;
   }
 
+  MIRType *GetType() const override {
+    if (tyIdx != TyIdx(0)) {
+      return GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx);
+    }
+    return nullptr;
+  }
+
  private:
   std::array<MeExpr*, kOperandNumTernary> opnds = { nullptr };  // kid
   PrimType opndType = kPtyInvalid;  // from type
@@ -960,6 +982,14 @@ class IvarMeExpr : public MeExpr {
     return static_cast<uint32>(OP_iread) + fieldID + (static_cast<uint32>(base->GetExprID()) << kIvarHashShift);
   }
 
+  MIRType *GetType() const override {
+    MIRPtrType *ptrtype = static_cast<MIRPtrType *>(GlobalTables::GetTypeTable().GetTypeFromTyIdx(tyIdx));
+    if (fieldID == 0) {
+      return ptrtype->GetPointedType();
+    }
+    return GlobalTables::GetTypeTable().GetTypeFromTyIdx(ptrtype->GetPointedTyIdxWithFieldID(fieldID));
+  }
+
  private:
   IassignMeStmt *defStmt = nullptr;
   MeExpr *base = nullptr;
diff --git a/src/mapleall/maple_me/include/me_rename2preg.h b/src/mapleall/maple_me/include/me_rename2preg.h
index 9eab8c22ca89e055fcdf38fb97f6ce7724c0e6f0..72d6c1f1606d57d786ed8c36580423250bc05d60 100644
--- a/src/mapleall/maple_me/include/me_rename2preg.h
+++ b/src/mapleall/maple_me/include/me_rename2preg.h
@@ -18,13 +18,70 @@
 #include "me_function.h"
 
 namespace maple {
+
+class SSARename2Preg {
+ public:
+  SSARename2Preg(MemPool *mp, MeFunction *f, MeIRMap *hmap, AliasClass *alias)
+    : alloc(mp),
+      func(f),
+      meirmap(hmap),
+      ssaTab(f->GetMeSSATab()),
+      mirModule(&f->GetMIRModule()),
+      aliasclass(alias),  // ostidx2reg_map(alloc.Adapter()),
+
+      sym2reg_map(std::less<OStIdx>(), alloc.Adapter()),
+      vstidx2reg_map(alloc.Adapter()),
+      parm_used_vec(alloc.Adapter()),
+      reg_formal_vec(alloc.Adapter()) {}
+
+  void RunSelf();
+  void PromoteEmptyFunction();
+
+ private:
+  AliasElem *GetAliasElem(const OriginalSt *ost) {
+    if (ost->GetIndex() >= aliasclass->GetAliasElemCount()) {
+      return nullptr;
+    }
+    return aliasclass->FindAliasElem(*ost);
+  }
+
+  void Rename2PregStmt(MeStmt *);
+  void Rename2PregExpr(MeStmt *, MeExpr *);
+  void Rename2PregLeafRHS(MeStmt *, VarMeExpr *);
+  void Rename2PregLeafLHS(MeStmt *, VarMeExpr *);
+  void Rename2PregPhi(BB *, MePhiNode *, MapleMap<OStIdx, MePhiNode *> &);
+  void UpdateRegPhi(MePhiNode *, MePhiNode *, const RegMeExpr *, const VarMeExpr *);
+  void Rename2PregCallReturn(MapleVector<MustDefMeNode> &);
+  RegMeExpr *RenameVar(VarMeExpr *);
+  void UpdateMirFunctionFormal();
+  void SetupParmUsed(const VarMeExpr *);
+  void Init();
+  std::string PhaseName() const {
+    return "rename2preg";
+  }
+
+  MapleAllocator alloc;
+  MeFunction *func;
+  MeIRMap *meirmap;
+  SSATab *ssaTab;
+  MIRModule *mirModule;
+  AliasClass *aliasclass;
+  MapleMap<OStIdx, OriginalSt *> sym2reg_map;      // map var to reg in original symbol
+  MapleUnorderedMap<int32, RegMeExpr *> vstidx2reg_map;  // maps the VarMeExpr's exprID to RegMeExpr
+  MapleVector<bool> parm_used_vec;                       // if parameter is not used, it's false, otherwise true
+  // if the parameter got promoted, the nth of func->mirFunc->_formal is the nth of reg_formal_vec, otherwise nullptr;
+  MapleVector<RegMeExpr *> reg_formal_vec;
+};
+
 class MeDoSSARename2Preg : public MeFuncPhase {
  public:
   explicit MeDoSSARename2Preg(MePhaseID id) : MeFuncPhase(id) {}
 
   virtual ~MeDoSSARename2Preg() = default;
   AnalysisResult *Run(MeFunction *func, MeFuncResultMgr *funcRst, ModuleResultMgr*) override;
-  std::string PhaseName() const override;
+  std::string PhaseName() const override {
+    return "rename2preg";
+  }
 };
 }  // namespace maple
 #endif  // MAPLE_ME_INCLUDE_MERENAME2PREG_H
diff --git a/src/mapleall/maple_me/src/irmap.cpp b/src/mapleall/maple_me/src/irmap.cpp
index e33973e356f240828382c77438b28a17d6d2b435..a66b4d2d91a8f631ef966478653e4f7841e84232 100644
--- a/src/mapleall/maple_me/src/irmap.cpp
+++ b/src/mapleall/maple_me/src/irmap.cpp
@@ -19,25 +19,18 @@
 #include "constantfold.h"
 
 namespace maple {
-VarMeExpr *IRMap::CreateVarMeExprVersion(const VarMeExpr &origExpr) {
-  auto *varMeExpr = New<VarMeExpr>(exprID++, origExpr.GetOst(),
-                                   vst2MeExprTable.size(), origExpr.GetPrimType());
-  vst2MeExprTable.push_back(varMeExpr);
+VarMeExpr *IRMap::CreateVarMeExprVersion(OriginalSt *ost) {
+  VarMeExpr *varMeExpr = New<VarMeExpr>(exprID++, ost, verst2MeExprTable.size(),
+        GlobalTables::GetTypeTable().GetTypeFromTyIdx(ost->GetTyIdx())->GetPrimType());
+  verst2MeExprTable.push_back(varMeExpr);
   return varMeExpr;
 }
 
-MeExpr *IRMap::CreateAddrofMeExpr(OStIdx ostIdx) {
-  AddrofMeExpr addrofMeExpr(-1, PTY_ptr, ostIdx);
-  addrofMeExpr.SetOp(OP_addrof);
-  addrofMeExpr.SetPtyp(PTY_ptr);
-  addrofMeExpr.SetNumOpnds(0);
-  return HashMeExpr(addrofMeExpr);
-}
-
 MeExpr *IRMap::CreateAddrofMeExpr(MeExpr &expr) {
   if (expr.GetMeOp() == kMeOpVar) {
     auto &varMeExpr = static_cast<VarMeExpr&>(expr);
-    return CreateAddrofMeExpr(varMeExpr.GetOstIdx());
+    AddrofMeExpr addrofme(-1, PTY_ptr, varMeExpr.GetOst()->GetIndex());
+    return HashMeExpr(addrofme);
   } else {
     ASSERT(expr.GetMeOp() == kMeOpIvar, "expecting IVarMeExpr");
     auto &ivarExpr = static_cast<IvarMeExpr&>(expr);
@@ -76,21 +69,22 @@ MeExpr *IRMap::CreateIvarMeExpr(MeExpr &expr, TyIdx tyIdx, MeExpr &base) {
   return HashMeExpr(ivarMeExpr);
 }
 
-VarMeExpr *IRMap::CreateNewVarMeExpr(OriginalSt *ost, PrimType pType) {
-  VarMeExpr *varMeExpr = New<VarMeExpr>(exprID++, ost, vst2MeExprTable.size(), pType);
-  PushBackVerst2MeExprTable(varMeExpr);
-  return varMeExpr;
-}
-
-VarMeExpr *IRMap::CreateNewGlobalTmp(GStrIdx strIdx, PrimType pType) {
+VarMeExpr *IRMap::CreateNewVar(GStrIdx strIdx, PrimType pType, bool isGlobal) {
   MIRSymbol *st =
-      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);
+      mirModule.GetMIRBuilder()->CreateSymbol((TyIdx)pType, strIdx, kStVar,
+        isGlobal ? kScGlobal : kScAuto,
+        isGlobal ? nullptr : mirModule.CurFunction(),
+        isGlobal ? kScopeGlobal : kScopeLocal);
+  if (isGlobal) {
+    st->SetIsTmp(true);
+  }
+  OriginalSt *oSt = ssaTab.CreateSymbolOriginalSt(*st, isGlobal ? 0 : mirModule.CurFunction()->GetPuidx(), 0);
+  oSt->SetZeroVersionIndex(verst2MeExprTable.size());
+  verst2MeExprTable.push_back(nullptr);
   oSt->PushbackVersionsIndices(oSt->GetZeroVersionIndex());
-  auto *varx = New<VarMeExpr>(exprID++, oSt, oSt->GetZeroVersionIndex(), pType);
+
+  VarMeExpr *varx = New<VarMeExpr>(exprID++, oSt, verst2MeExprTable.size(), pType);
+  verst2MeExprTable.push_back(varx);
   return varx;
 }
 
@@ -99,116 +93,59 @@ VarMeExpr *IRMap::CreateNewLocalRefVarTmp(GStrIdx strIdx, TyIdx tIdx) {
       mirModule.GetMIRBuilder()->CreateSymbol(tIdx, strIdx, kStVar, kScAuto, mirModule.CurFunction(), kScopeLocal);
   st->SetInstrumented();
   OriginalSt *oSt = ssaTab.CreateSymbolOriginalSt(*st, mirModule.CurFunction()->GetPuidx(), 0);
-  oSt->SetZeroVersionIndex(vst2MeExprTable.size());
-  vst2MeExprTable.push_back(nullptr);
+  oSt->SetZeroVersionIndex(verst2MeExprTable.size());
+  verst2MeExprTable.push_back(nullptr);
   oSt->PushbackVersionsIndices(oSt->GetZeroVersionIndex());
-  auto *newLocalRefVar = New<VarMeExpr>(exprID++, oSt, vst2MeExprTable.size(), PTY_ref);
-  vst2MeExprTable.push_back(newLocalRefVar);
+  auto *newLocalRefVar = New<VarMeExpr>(exprID++, oSt, verst2MeExprTable.size(), PTY_ref);
+  verst2MeExprTable.push_back(newLocalRefVar);
   return newLocalRefVar;
 }
 
 RegMeExpr *IRMap::CreateRegMeExprVersion(OriginalSt &pregOSt) {
-  auto *regReadExpr =
-      New<RegMeExpr>(exprID++, &pregOSt, 0, kMeOpReg, OP_regread, pregOSt.GetMIRPreg()->GetPrimType());
-  return regReadExpr;
-}
-
-RegMeExpr *IRMap::CreateRegMeExprVersion(const RegMeExpr &origExpr) {
-  auto *regReadExpr = New<RegMeExpr>(exprID++, origExpr.GetOst(), 0, kMeOpReg, OP_regread, origExpr.GetPrimType());
+  RegMeExpr *regReadExpr =
+      New<RegMeExpr>(exprID++, &pregOSt, verst2MeExprTable.size(), kMeOpReg, OP_regread, pregOSt.GetMIRPreg()->GetPrimType());
+  verst2MeExprTable.push_back(regReadExpr);
   return regReadExpr;
 }
 
-RegMeExpr *IRMap::CreateRefRegMeExpr(const MIRSymbol &mirSt) {
-  MIRFunction *mirFunc = mirModule.CurFunction();
-  MIRType *stType = mirSt.GetType();
-  PrimType pType = stType->GetPrimType();
-  ASSERT(pType == PTY_ref, "only PTY_ref needed");
-  PregIdx regIdx = mirFunc->GetPregTab()->CreatePreg(PTY_ref, stType);
-  ASSERT(regIdx <= 0xffff, "register oversized");
-  MIRPreg *preg = mirFunc->GetPregTab()->PregFromPregIdx(regIdx);
-  if (!mirSt.IgnoreRC()) {
-    preg->SetNeedRC();
-  }
-  OriginalSt *oSt = ssaTab.GetOriginalStTable().CreatePregOriginalSt(regIdx, mirFunc->GetPuidx());
-  auto *regreadexpr = New<RegMeExpr>(exprID++, oSt, 0, kMeOpReg, OP_regread, pType);
-  return regreadexpr;
-}
-
 RegMeExpr *IRMap::CreateRegMeExpr(PrimType pType) {
   MIRFunction *mirFunc = mirModule.CurFunction();
   PregIdx regIdx = mirFunc->GetPregTab()->CreatePreg(pType);
   ASSERT(regIdx <= 0xffff, "register oversized");
   OriginalSt *ost = ssaTab.GetOriginalStTable().CreatePregOriginalSt(regIdx, mirFunc->GetPuidx());
-  auto *regReadExpr = New<RegMeExpr>(exprID++, ost, 0, kMeOpReg, OP_regread, pType);
-  return regReadExpr;
+  return CreateRegMeExprVersion(*ost);
 }
 
-RegMeExpr *IRMap::CreateRegRefMeExpr(MIRType &mirType) {
+RegMeExpr *IRMap::CreateRegMeExpr(MIRType &mirType) {
+  if (mirType.GetPrimType() != PTY_ref && mirType.GetPrimType() != PTY_ptr) {
+    return CreateRegMeExpr(mirType.GetPrimType());
+  }
+  if (mirType.GetPrimType() == PTY_ptr) {
+    MIRType *pointedType = static_cast<MIRPtrType &>(mirType).GetPointedType();
+    if (pointedType == nullptr || pointedType->GetKind() != kTypeFunction) {
+      return CreateRegMeExpr(mirType.GetPrimType());
+    }
+  }
   MIRFunction *mirFunc = mirModule.CurFunction();
   PregIdx regIdx = mirFunc->GetPregTab()->CreatePreg(PTY_ref, &mirType);
   ASSERT(regIdx <= 0xffff, "register oversized");
   OriginalSt *ost = ssaTab.GetOriginalStTable().CreatePregOriginalSt(regIdx, mirFunc->GetPuidx());
-  auto *regReadExpr = New<RegMeExpr>(exprID++, ost, 0, kMeOpReg, OP_regread, mirType.GetPrimType());
-  return regReadExpr;
-}
-
-RegMeExpr *IRMap::CreateRegRefMeExpr(const MeExpr &meExpr) {
-  MIRType *mirType = nullptr;
-  switch (meExpr.GetMeOp()) {
-    case kMeOpVar: {
-      auto &varMeExpr = static_cast<const VarMeExpr&>(meExpr);
-      const OriginalSt *ost = varMeExpr.GetOst();
-      ASSERT(ost->GetTyIdx() != 0u, "expect ost->tyIdx to be initialized");
-      mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ost->GetTyIdx());
-      break;
-    }
-    case kMeOpIvar: {
-      auto &ivarMeExpr = static_cast<const IvarMeExpr&>(meExpr);
-      MIRType *ptrMirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(ivarMeExpr.GetTyIdx());
-      ASSERT(ptrMirType->GetKind() == kTypePointer, "must be point type for ivar");
-      auto *realMirType = static_cast<MIRPtrType*>(ptrMirType);
-      FieldID fieldID = ivarMeExpr.GetFieldID();
-      if (fieldID > 0) {
-        mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(realMirType->GetPointedTyIdxWithFieldID(fieldID));
-      } else {
-        mirType = realMirType->GetPointedType();
-      }
-      ASSERT(mirType->GetPrimType() == meExpr.GetPrimType() ||
-             !(IsAddress(mirType->GetPrimType()) && IsAddress(meExpr.GetPrimType())),
-             "inconsistent type");
-      ASSERT(mirType->GetPrimType() == PTY_ref, "CreateRegRefMeExpr: only ref type expected");
-      break;
-    }
-    case kMeOpOp:
-      if (meExpr.GetOp() == OP_retype) {
-        auto &opMeExpr = static_cast<const OpMeExpr&>(meExpr);
-        ASSERT(opMeExpr.GetTyIdx() != 0u, "expect opMeExpr.tyIdx to be initialized");
-        mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(opMeExpr.GetTyIdx());
-        break;
-      }
-    // fall thru
-    [[clang::fallthrough]];
-    default:
-      return CreateRegMeExpr(PTY_ptr);
-  }
-  return CreateRegRefMeExpr(*mirType);
+  return CreateRegMeExprVersion(*ost);
 }
 
 VarMeExpr *IRMap::GetOrCreateZeroVersionVarMeExpr(OriginalSt &ost) {
-  ASSERT(ost.GetZeroVersionIndex() < vst2MeExprTable.size(),
+  ASSERT(ost.GetZeroVersionIndex() != 0,
+         "GetOrCreateZeroVersionVarMeExpr: version index of osym's kInitVersion not set");
+  ASSERT(ost.GetZeroVersionIndex() < verst2MeExprTable.size(),
          "GetOrCreateZeroVersionVarMeExpr: version index of osym's kInitVersion out of range");
-  if (ost.GetZeroVersionIndex() == 0) {
-    ssaTab.SetZeroVersionIndex(ost.GetIndex(), vst2MeExprTable.size());
-    vst2MeExprTable.push_back(nullptr);
-  }
-  if (vst2MeExprTable[ost.GetZeroVersionIndex()] == nullptr) {
+  if (verst2MeExprTable[ost.GetZeroVersionIndex()] == nullptr) {
     auto *varMeExpr = New<VarMeExpr>(exprID++, &ost, ost.GetZeroVersionIndex(),
         GlobalTables::GetTypeTable().GetTypeFromTyIdx(ost.GetTyIdx())->GetPrimType());
     ASSERT(!GlobalTables::GetTypeTable().GetTypeTable().empty(), "container check");
-    vst2MeExprTable[ost.GetZeroVersionIndex()] = varMeExpr;
+    verst2MeExprTable[ost.GetZeroVersionIndex()] = varMeExpr;
     return varMeExpr;
   }
-  return static_cast<VarMeExpr*>(vst2MeExprTable[ost.GetZeroVersionIndex()]);
+  return static_cast<VarMeExpr*>(verst2MeExprTable[ost.GetZeroVersionIndex()]);
 }
 
 IvarMeExpr *IRMap::BuildLHSIvar(MeExpr &baseAddr, IassignMeStmt &iassignMeStmt, FieldID fieldID) {
@@ -219,12 +156,6 @@ IvarMeExpr *IRMap::BuildLHSIvar(MeExpr &baseAddr, IassignMeStmt &iassignMeStmt,
   return meDef;
 }
 
-IvarMeExpr *IRMap::BuildIvarFromOpMeExpr(OpMeExpr &opMeExpr) {
-  IvarMeExpr *ivar = New<IvarMeExpr>(exprID++, opMeExpr.GetPrimType(), opMeExpr.GetTyIdx(), opMeExpr.GetFieldID());
-  ivar->SetBase(opMeExpr.GetOpnd(0));
-  return ivar;
-}
-
 IvarMeExpr *IRMap::BuildLHSIvarFromIassMeStmt(IassignMeStmt &iassignMeStmt) {
   IvarMeExpr *ivarx = BuildLHSIvar(*iassignMeStmt.GetLHSVal()->GetBase(), iassignMeStmt,
                                    iassignMeStmt.GetLHSVal()->GetFieldID());
@@ -485,6 +416,12 @@ MeExpr *IRMap::CreateIntConstMeExpr(int64 value, PrimType pType) {
   return CreateConstMeExpr(pType, *intConst);
 }
 
+MeExpr *IRMap::CreateMeExprUnary(Opcode op, PrimType pType, MeExpr &expr0) {
+  OpMeExpr opMeExpr(kInvalidExprID, op, pType, kOperandNumUnary);
+  opMeExpr.SetOpnd(0, &expr0);
+  return HashMeExpr(opMeExpr);
+}
+
 MeExpr *IRMap::CreateMeExprBinary(Opcode op, PrimType pType, MeExpr &expr0, MeExpr &expr1) {
   OpMeExpr opMeExpr(kInvalidExprID, op, pType, kOperandNumBinary);
   opMeExpr.SetOpnd(0, &expr0);
diff --git a/src/mapleall/maple_me/src/irmap_build.cpp b/src/mapleall/maple_me/src/irmap_build.cpp
index c2287f8ec237b12fb9a96a32bf4ef7e120bd3b28..57b9feb2e74c227c1a37da26d65de53652798884 100644
--- a/src/mapleall/maple_me/src/irmap_build.cpp
+++ b/src/mapleall/maple_me/src/irmap_build.cpp
@@ -25,8 +25,8 @@ using MeStmtFactory = FunctionFactory<Opcode, MeStmt*, IRMapBuild*, StmtNode&, A
 
 VarMeExpr *IRMapBuild::GetOrCreateVarFromVerSt(VersionSt &vst) {
   size_t vindex = vst.GetIndex();
-  ASSERT(vindex < irMap->vst2MeExprTable.size(), "GetOrCreateVarFromVerSt: index %d is out of range", vindex);
-  MeExpr *meExpr = irMap->vst2MeExprTable.at(vindex);
+  ASSERT(vindex < irMap->verst2MeExprTable.size(), "GetOrCreateVarFromVerSt: index %d is out of range", vindex);
+  MeExpr *meExpr = irMap->verst2MeExprTable.at(vindex);
   if (meExpr != nullptr) {
     return static_cast<VarMeExpr*>(meExpr);
   }
@@ -35,14 +35,14 @@ VarMeExpr *IRMapBuild::GetOrCreateVarFromVerSt(VersionSt &vst) {
   auto *varx = irMap->New<VarMeExpr>(irMap->exprID++, ost, vindex,
       GlobalTables::GetTypeTable().GetTypeTable()[ost->GetTyIdx().GetIdx()]->GetPrimType());
   ASSERT(!GlobalTables::GetTypeTable().GetTypeTable().empty(), "container check");
-  irMap->vst2MeExprTable[vindex] = varx;
+  irMap->verst2MeExprTable[vindex] = varx;
   return varx;
 }
 
 RegMeExpr *IRMapBuild::GetOrCreateRegFromVerSt(VersionSt &vst) {
   size_t vindex = vst.GetIndex();
-  ASSERT(vindex < irMap->vst2MeExprTable.size(), " GetOrCreateRegFromVerSt: index %d is out of range", vindex);
-  MeExpr *meExpr = irMap->vst2MeExprTable[vindex];
+  ASSERT(vindex < irMap->verst2MeExprTable.size(), " GetOrCreateRegFromVerSt: index %d is out of range", vindex);
+  MeExpr *meExpr = irMap->verst2MeExprTable[vindex];
   if (meExpr != nullptr) {
     return static_cast<RegMeExpr*>(meExpr);
   }
@@ -50,7 +50,7 @@ RegMeExpr *IRMapBuild::GetOrCreateRegFromVerSt(VersionSt &vst) {
   ASSERT(ost->IsPregOst(), "GetOrCreateRegFromVerSt: PregOST expected");
   auto *regx = irMap->New<RegMeExpr>(irMap->exprID++,
                                      ost, vindex, kMeOpReg, OP_regread, ost->GetMIRPreg()->GetPrimType());
-  irMap->vst2MeExprTable[vindex] = regx;
+  irMap->verst2MeExprTable[vindex] = regx;
   return regx;
 }
 
@@ -58,7 +58,7 @@ MeExpr *IRMapBuild::BuildLHSVar(VersionSt &vst, DassignMeStmt &defMeStmt) {
   VarMeExpr *meDef = GetOrCreateVarFromVerSt(vst);
   meDef->SetDefStmt(&defMeStmt);
   meDef->SetDefBy(kDefByStmt);
-  irMap->vst2MeExprTable.at(vst.GetIndex()) = meDef;
+  irMap->verst2MeExprTable.at(vst.GetIndex()) = meDef;
   return meDef;
 }
 
@@ -67,7 +67,7 @@ MeExpr *IRMapBuild::BuildLHSReg(VersionSt &vst, RegassignMeStmt &defMeStmt, cons
   meDef->SetPtyp(regassign.GetPrimType());
   meDef->SetDefStmt(&defMeStmt);
   meDef->SetDefBy(kDefByStmt);
-  irMap->vst2MeExprTable.at(vst.GetIndex()) = meDef;
+  irMap->verst2MeExprTable.at(vst.GetIndex()) = meDef;
   return meDef;
 }
 
diff --git a/src/mapleall/maple_me/src/me_analyze_rc.cpp b/src/mapleall/maple_me/src/me_analyze_rc.cpp
index f6574758fbdaeba9da7b7468185bad88ea8a9bef..71e991bdba9a7ca28cf19c06088205f08645b36c 100644
--- a/src/mapleall/maple_me/src/me_analyze_rc.cpp
+++ b/src/mapleall/maple_me/src/me_analyze_rc.cpp
@@ -120,10 +120,12 @@ OriginalSt *AnalyzeRC::GetOriginalSt(const MeExpr &refLHS) const {
   return iass->GetChiList()->begin()->second->GetLHS()->GetOst();
 }
 
+#if 1
 VarMeExpr *AnalyzeRC::GetZeroVersionVarMeExpr(const VarMeExpr &var) {
   OriginalSt *ost = var.GetOst();
   return irMap.GetOrCreateZeroVersionVarMeExpr(*ost);
 }
+#endif
 
 // check if incref needs to be inserted after this ref pointer assignment;
 // if it is callassigned, the incref has already been done in the callee;
@@ -154,7 +156,11 @@ void AnalyzeRC::IdentifyRCStmts() {
         if (lhsRef->GetMeOp() == kMeOpVar) {
           // insert a decref statement
           UnaryMeStmt *decrefStmt = irMap.CreateUnaryMeStmt(
+#if 1
               OP_decref, GetZeroVersionVarMeExpr(static_cast<const VarMeExpr&>(*lhsRef)), &bb, &stmt.GetSrcPosition());
+#else
+              OP_decref, irMap.GetOrCreateZeroVersionVarMeExpr(*ost), &bb, &stmt.GetSrcPosition());
+#endif
           // insertion position is before stmt
           bb.InsertMeStmtBefore(&stmt, decrefStmt);
         } else {
@@ -287,7 +293,7 @@ void AnalyzeRC::RenameUses(MeStmt &meStmt) {
 }
 
 DassignMeStmt *AnalyzeRC::CreateDassignInit(OriginalSt &ost, BB &bb) {
-  VarMeExpr *lhs = irMap.CreateNewVarMeExpr(&ost, PTY_ref);
+  VarMeExpr *lhs = irMap.CreateVarMeExprVersion(&ost);
   MeExpr *rhs = irMap.CreateIntConstMeExpr(0, PTY_ref);
   return irMap.CreateDassignMeStmt(utils::ToRef(lhs), utils::ToRef(rhs), bb);
 }
diff --git a/src/mapleall/maple_me/src/me_delegate_rc.cpp b/src/mapleall/maple_me/src/me_delegate_rc.cpp
index fc73cdeb24e35fd1fd1e08c7a50114fc0e362a53..1bd5206d26fc2331e00bad868718526a9813eb86 100644
--- a/src/mapleall/maple_me/src/me_delegate_rc.cpp
+++ b/src/mapleall/maple_me/src/me_delegate_rc.cpp
@@ -332,7 +332,7 @@ RegMeExpr *DelegateRC::RHSTempDelegated(MeExpr &rhs, const MeStmt &useStmt) {
     if (ost->GetMIRSymbol()->GetType()->GetPrimType() == PTY_ptr) {
       curReg = irMap.CreateRegMeExpr(PTY_ptr);
     } else {
-      curReg = irMap.CreateRegRefMeExpr(rhsVar);
+      curReg = irMap.CreateRegMeExpr(rhsVar);
     }
     refVar2RegMap[&rhsVar] = curReg;  // record this replacement
     mustDef.UpdateLHS(*curReg);
@@ -361,7 +361,7 @@ RegMeExpr *DelegateRC::RHSTempDelegated(MeExpr &rhs, const MeStmt &useStmt) {
     }
     // replace temp by a new preg
     rhsVar.SetDefBy(kDefByNo);
-    RegMeExpr *curReg = irMap.CreateRegRefMeExpr(rhsVar);
+    RegMeExpr *curReg = irMap.CreateRegMeExpr(rhsVar);
     refVar2RegMap[&rhsVar] = curReg;  // record this replacement
     // create new regassign statement
     MeStmt *regass = irMap.CreateRegassignMeStmt(*curReg, *rhsExpr, *defStmt->GetBB());
@@ -632,7 +632,7 @@ void DelegateRC::DelegateHandleNoRCStmt(MeStmt &stmt, bool addDecref) {
   // replace temp by a new preg
   MeStmt *newStmt = &stmt;
   theLhs->SetDefBy(kDefByNo);
-  RegMeExpr *curReg = irMap.CreateRegRefMeExpr(*theLhs);
+  RegMeExpr *curReg = irMap.CreateRegMeExpr(*theLhs);
   refVar2RegMap[theLhs] = curReg;  // record this replacement
   if (rhsExpr != nullptr) {
     // create new regassign statement
diff --git a/src/mapleall/maple_me/src/me_lower_globals.cpp b/src/mapleall/maple_me/src/me_lower_globals.cpp
index 0ff564814f0bcb78fcb98912b26c523eb7a0f70d..be4041d5891c994e7e44bdd5dde2d5d6b61d8639 100644
--- a/src/mapleall/maple_me/src/me_lower_globals.cpp
+++ b/src/mapleall/maple_me/src/me_lower_globals.cpp
@@ -122,7 +122,9 @@ void MeLowerGlobals::Run() {
           baseOst = ssaTable->FindOrCreateSymbolOriginalSt(*ost->GetMIRSymbol(),
               func.GetMirFunc()->GetPuidx(), 0);
         }
-        MeExpr *addrof = irMap->CreateAddrofMeExpr(baseOst->GetIndex());
+        AddrofMeExpr addrofmeexpr(-1, PTY_ptr, baseOst->GetIndex());
+        AddrofMeExpr *addrof = static_cast<AddrofMeExpr *>(irMap->HashMeExpr(addrofmeexpr));
+
         MIRPtrType ptrType(baseOst->GetTyIdx(), PTY_ptr);
         if (ost->IsVolatile()) {
           TypeAttrs attrs;
diff --git a/src/mapleall/maple_me/src/me_placement_rc.cpp b/src/mapleall/maple_me/src/me_placement_rc.cpp
index 1195a4734ff8511814c70ab2d847b237e3f6fa81..1849c4b705c62ddec44bc2110dee33548e848cf0 100644
--- a/src/mapleall/maple_me/src/me_placement_rc.cpp
+++ b/src/mapleall/maple_me/src/me_placement_rc.cpp
@@ -472,7 +472,7 @@ void PlacementRC::UpdateCatchBlocks2Insert(const BB &lastUseBB) {
 void PlacementRC::ReplaceOpndWithReg(MeExpr &opnd, BB &lastUseBB, const SRealOcc &realOcc, uint32 idx) const {
   // Save this operand in a preg
   RegMeExpr *curReg = opnd.GetPrimType() != PTY_ref ? irMap->CreateRegMeExpr(opnd.GetPrimType())
-                                                    : irMap->CreateRegRefMeExpr(opnd);
+                                                    : irMap->CreateRegMeExpr(opnd);
   MeStmt *regAss = irMap->CreateRegassignMeStmt(*curReg, opnd, lastUseBB);
   curReg->SetDefByStmt(*regAss);
   lastUseBB.InsertMeStmtBefore(realOcc.GetStmt(), regAss);
@@ -738,7 +738,7 @@ void PlacementRC::ReplaceRHSWithPregForDassign(MeStmt &stmt, BB &bb) const {
     if (ost->IsLocal()) {
       DassignMeStmt &dass = static_cast<DassignMeStmt&>(stmt);
       if (IsDereferenced(*dass.GetRHS(), ost->GetIndex())) {
-        RegMeExpr *regTemp = irMap->CreateRegRefMeExpr(*theLHS);
+        RegMeExpr *regTemp = irMap->CreateRegMeExpr(*theLHS);
         RegassignMeStmt *rass = irMap->CreateRegassignMeStmt(*regTemp, *dass.GetRHS(), bb);
         regTemp->SetDefByStmt(*rass);
         bb.InsertMeStmtBefore(&stmt, rass);
@@ -772,7 +772,7 @@ bool PlacementRC::DoesDassignInsertedForCallAssigned(MeStmt &stmt, BB &bb) const
   if (!resAmongOpnds) {
     return false;
   }
-  RegMeExpr *regTemp = irMap->CreateRegRefMeExpr(*theLHS);
+  RegMeExpr *regTemp = irMap->CreateRegMeExpr(*theLHS);
   MapleVector<MustDefMeNode> *mustDefList = stmt.GetMustDefList();
   CHECK_NULL_FATAL(mustDefList);
   CHECK_FATAL(!mustDefList->empty(), "container check");
diff --git a/src/mapleall/maple_me/src/me_rc_lowering.cpp b/src/mapleall/maple_me/src/me_rc_lowering.cpp
index 4f41cc1f4ef570dd8a3f8ced4bce148247978286..1e814c92c8a6f94f2abe05bbce5f5a72c4603fc6 100644
--- a/src/mapleall/maple_me/src/me_rc_lowering.cpp
+++ b/src/mapleall/maple_me/src/me_rc_lowering.cpp
@@ -998,11 +998,11 @@ VarMeExpr *RCLowering::CreateNewTmpVarMeExpr(bool isLocalRefVar) {
   std::string name = std::string("__RCTemp__").append(std::to_string(++tmpCount));
   OriginalSt *ost = RetrieveOSt(name, isLocalRefVar);
   if (ost->GetZeroVersionIndex() == 0) {
-    ost->SetZeroVersionIndex(irMap.GetVerst2MeExprTableSize());
-    irMap.PushBackVerst2MeExprTable(nullptr);
+    ost->SetZeroVersionIndex(irMap.GetVerst2MeExprTable().size());
+    irMap.GetVerst2MeExprTable().push_back(nullptr);
     ost->PushbackVersionsIndices(ost->GetZeroVersionIndex());
   }
-  VarMeExpr *varMeExpr = irMap.CreateNewVarMeExpr(ost, PTY_ref);
+  VarMeExpr *varMeExpr = irMap.CreateVarMeExprVersion(ost);
   if (isLocalRefVar) {
     tmpLocalRefVars.insert(varMeExpr);
   }
diff --git a/src/mapleall/maple_me/src/me_rename2preg.cpp b/src/mapleall/maple_me/src/me_rename2preg.cpp
index 0ab02072248a73cb33d10918dd4ed48cb950d4b7..af2d77548c95a5872f0a868a3ee3a6c59fd8c20a 100644
--- a/src/mapleall/maple_me/src/me_rename2preg.cpp
+++ b/src/mapleall/maple_me/src/me_rename2preg.cpp
@@ -12,437 +12,353 @@
  * FIT FOR A PARTICULAR PURPOSE.
  * See the Mulan PSL v2 for more details.
  */
+#include "alias_class.h"
 #include "me_rename2preg.h"
-#include <utils.h>
 #include "mir_builder.h"
 #include "me_irmap.h"
-#include "alias_class.h"
 
 // This phase mainly renames the variables to pseudo register.
 // Only non-ref-type variables (including parameters) with no alias are
 // workd on here.  Remaining variables are left to LPRE phase.  This is
 // because for ref-type variables, their stores have to be left intact.
 
-namespace {
-using namespace maple;
-
-// Part1: Generalize GetAnalysisResult from MeFuncResultMgr
-template <MePhaseID id> struct ExtractPhaseClass {};
-
-template <> struct ExtractPhaseClass<MeFuncPhase_IRMAPBUILD> {
-  using Type = MeIRMap;
-};
-
-template <> struct ExtractPhaseClass<MeFuncPhase_ALIASCLASS> {
-  using Type = AliasClass;
-};
-
-template <MePhaseID id, typename RetT = std::add_pointer_t<typename ExtractPhaseClass<id>::Type>>
-inline RetT GetAnalysisResult(MeFunction &func, MeFuncResultMgr &funcRst) {
-  return static_cast<RetT>(funcRst.GetAnalysisResult(id, &func));
-}
-
-// Part2: Phase implementation.
-class OStCache final {
- public:
-  explicit OStCache(SSATab &ssaTab) : ssaTab(ssaTab) {}
-  ~OStCache() = default;
-
-  OriginalSt *Find(OStIdx ostIdx) const {
-    auto it = cache.find(ostIdx);
-    return it == cache.end() ? nullptr : it->second;
-  }
-
-  OriginalSt &CreatePregOst(const RegMeExpr &regExpr, const OriginalSt &ost) {
-    OriginalStTable &ostTbl = ssaTab.GetOriginalStTable();
-    OriginalSt *regOst = ostTbl.CreatePregOriginalSt(regExpr.GetRegIdx(), ssaTab.GetModule().CurFunction()->GetPuidx());
-    utils::ToRef(regOst).SetIsFormal(ost.IsFormal());
-    cache[ost.GetIndex()] = regOst;
-    return *regOst;
-  }
-
- private:
-  SSATab &ssaTab;
-  std::map<OStIdx, OriginalSt*> cache; // map var to reg in original symbol
-};
-
-class PregCache final {
- public:
-  explicit PregCache(MeIRMap &irMap) : irMap(irMap) {}
-  ~PregCache() = default;
-
-  RegMeExpr &CloneRegExprIfNotExist(const VarMeExpr &varExpr,
-                                    const std::function<RegMeExpr *(MeIRMap &)> &creator) {
-    auto it = cache.find(varExpr.GetExprID());
-    if (it != cache.end()) {
-      return utils::ToRef(it->second);
-    }
+namespace maple {
 
-    RegMeExpr *regExpr = creator(irMap);
-    (void)cache.insert(std::make_pair(varExpr.GetExprID(), regExpr));
-    return utils::ToRef(regExpr);
+RegMeExpr *SSARename2Preg::RenameVar(VarMeExpr *varmeexpr) {
+  if (varmeexpr->GetOst()->GetFieldID() != 0) {
+    return nullptr;
   }
-
-  RegMeExpr &CreatePregExpr(const VarMeExpr &varExpr, TyIdx symbolIdx) {
-    MIRType &ty = utils::ToRef(GlobalTables::GetTypeTable().GetTypeFromTyIdx(symbolIdx));
-    RegMeExpr *regExpr = ty.GetPrimType() == PTY_ref ? irMap.CreateRegRefMeExpr(ty)
-                                                     : irMap.CreateRegMeExpr(varExpr.GetPrimType());
-    (void)cache.insert(std::make_pair(varExpr.GetExprID(), regExpr));
-    return utils::ToRef(regExpr);
+  const OriginalSt *ost = varmeexpr->GetOst();
+  if (ost->GetIndirectLev() != 0) {
+    return nullptr;
   }
-
- private:
-  MeIRMap &irMap;
-  std::unordered_map<int32, RegMeExpr*> cache; // maps the VarMeExpr's exprID to RegMeExpr
-};
-
-class CacheProxy final {
- public:
-  CacheProxy() = default;
-  ~CacheProxy() = default;
-
-  void Init(SSATab &ssaTab, MeIRMap &irMap) {
-    ost = std::make_unique<OStCache>(ssaTab);
-    preg = std::make_unique<PregCache>(irMap);
+  const MIRSymbol *mirst = ost->GetMIRSymbol();
+  if (mirst->GetAttr(ATTR_localrefvar)) {
+    return nullptr;
   }
-
-  OStCache &OSt() const {
-    return utils::ToRef(ost);
+  if (ost->IsFormal() && varmeexpr->GetPrimType() == PTY_ref) {
+    return nullptr;
   }
-
-  PregCache &Preg() const {
-    return utils::ToRef(preg);
+  if (ost->IsVolatile()) {
+    return nullptr;
   }
-
- private:
-  std::unique_ptr<OStCache> ost;
-  std::unique_ptr<PregCache> preg;
-};
-
-class FormalRenaming final {
- public:
-  explicit FormalRenaming(MIRFunction &irFunc)
-      : irFunc(irFunc),
-        paramUsed(irFunc.GetFormalCount(), false),
-        renamedReg(irFunc.GetFormalCount(), nullptr) {}
-
-  ~FormalRenaming() = default;
-
-  void MarkUsed(OriginalSt &ost) {
-    if (ost.IsFormal() && ost.IsSymbolOst()) {
-      const MIRSymbol *sym = ost.GetMIRSymbol();
-      uint32 idx = irFunc.GetFormalIndex(sym);
-      paramUsed[idx] = true;
+  if (sym2reg_map.find(ost->GetIndex()) != sym2reg_map.end()) {
+    // replaced previously
+    MapleUnorderedMap<int, RegMeExpr *>::iterator verit = vstidx2reg_map.find(varmeexpr->GetExprID());
+    RegMeExpr *varreg = nullptr;
+    if (verit != vstidx2reg_map.end()) {
+      varreg = verit->second;
+    } else {
+      OriginalSt *pregOst = sym2reg_map[ost->GetIndex()];
+      varreg = meirmap->CreateRegMeExprVersion(*pregOst);
+      vstidx2reg_map.insert(std::make_pair(varmeexpr->GetExprID(), varreg));
     }
-  }
-
-  void MarkRenamed(const OriginalSt &ost, const MIRSymbol &irSymbol, RegMeExpr &regExpr) {
-    if (ost.IsFormal()) {
-      uint32 idx = irFunc.GetFormalIndex(&irSymbol);
-      CHECK_FATAL(paramUsed[idx], "param used not set correctly.");
-      if (!renamedReg[idx]) {
-        renamedReg[idx] = &regExpr;
-      }
+    return varreg;
+  } else {
+    const OriginalSt *origOst = ost;
+    if (origOst->GetIndex() >= aliasclass->GetAliasElemCount()) {
+      return nullptr;
     }
-  }
-
-  void Rename(const MIRBuilder &irBuilder) {
-    for (size_t i = 0; i < irFunc.GetFormalCount(); ++i) {
-      if (!paramUsed[i]) {
-        // in this case, the paramter is not used by any statement, promote it
-        MIRType &irTy = utils::ToRef(irFunc.GetNthParamType(i));
-        MIRPregTable &irPregTbl = utils::ToRef(irFunc.GetPregTab());
-        PregIdx16 regIdx = (irTy.GetPrimType() == PTY_ref) ?
-            static_cast<PregIdx16>(irPregTbl.CreatePreg(PTY_ref, &irTy)) :
-            static_cast<PregIdx16>(irPregTbl.CreatePreg(irTy.GetPrimType()));
-        irFunc.GetFormalDefVec()[i].formalSym = irBuilder.CreatePregFormalSymbol(irTy.GetTypeIndex(), regIdx, irFunc);
-      } else {
-        RegMeExpr *regExpr = renamedReg[i];
-        if (regExpr != nullptr) {
-          PregIdx16 regIdx = regExpr->GetRegIdx();
-          MIRSymbol &irSym = utils::ToRef(irFunc.GetFormal(i));
-          MIRSymbol *newIrSym = irBuilder.CreatePregFormalSymbol(irSym.GetTyIdx(), regIdx, irFunc);
-          irFunc.GetFormalDefVec()[i].formalSym = newIrSym;
-        }
-      }
+    if (!mirst->IsLocal() || mirst->GetStorageClass() == kScPstatic || mirst->GetStorageClass() == kScFstatic) {
+      return nullptr;
     }
-  }
-
- private:
-  MIRFunction &irFunc;
-  std::vector<bool> paramUsed; // if parameter is not used, it's false, otherwise true
-  // if the parameter got promoted, the nth of func->mirfunc->_formal is the nth of reg_formal_vec, otherwise nullptr;
-  std::vector<RegMeExpr*> renamedReg;
-};
-
-class SSARename2Preg {
- public:
-  SSARename2Preg(MIRFunction &irFunc, SSATab *ssaTab, bool enabledDebug)
-      : ssaTab(ssaTab),
-        enabledDebug(enabledDebug),
-        formal(irFunc) {}
-
-  virtual ~SSARename2Preg() = default;
-
-  static const std::string &PhaseName() {
-    static const std::string name = "rename2preg";
-    return name;
-  }
-
-  void Run(MeFunction &func, MeFuncResultMgr *pFuncRst) {
-    bool emptyFunc = func.empty();
-    if (!emptyFunc) {
-      MeFuncResultMgr &funcRst = utils::ToRef(pFuncRst);
-      MeIRMap &irMap = utils::ToRef(GetAnalysisResult<MeFuncPhase_IRMAPBUILD>(func, funcRst));
-      const AliasClass &aliasClass = utils::ToRef(GetAnalysisResult<MeFuncPhase_ALIASCLASS>(func, funcRst));
-
-      cacheProxy.Init(utils::ToRef(ssaTab), irMap);
-
-      for (auto it = func.valid_begin(), eIt = func.valid_end(); it != eIt; ++it) {
-        BB &bb = utils::ToRef(*it);
-
-        // rename the phi's
-        if (enabledDebug) {
-          LogInfo::MapleLogger() << " working on phi part of BB" << bb.GetBBId() << '\n';
-        }
-        for (auto &phiList : bb.GetMePhiList()) {
-          if (phiList.second->GetLHS()->GetMeOp() != kMeOpReg) {
-            Rename2PregPhi(aliasClass, utils::ToRef(phiList.second), irMap);
-          }
-        }
-
-        if (enabledDebug) {
-          LogInfo::MapleLogger() << " working on stmt part of BB" << bb.GetBBId() << '\n';
-        }
-        for (MeStmt &stmt : bb.GetMeStmts()) {
-          Rename2PregStmt(aliasClass, irMap, stmt);
-        }
-      }
+    if (origOst->IsAddressTaken()) {
+      return nullptr;
     }
-
-    MIRBuilder &irBuilder = utils::ToRef(func.GetMIRModule().GetMIRBuilder());
-    formal.Rename(irBuilder);
-
-    if (!emptyFunc && enabledDebug) {
-      func.Dump(false);
+    AliasElem *aliaselem = GetAliasElem(origOst);
+    if (aliaselem && aliaselem->GetClassSet()) {
+      return nullptr;
     }
-  }
-
- private:
-  void Rename2PregStmt(const AliasClass &aliasClass, MeIRMap &irMap, MeStmt &stmt) {
-    Opcode code = stmt.GetOp();
-    if (IsDAssign(code)) {
-      Rename2PregExpr(aliasClass, irMap, stmt, utils::ToRef(stmt.GetRHS()));
-      Rename2PregLeafLHS(aliasClass, utils::ToRef(stmt.GetVarLHS()), stmt, irMap);
-    } else if (IsCallAssigned(code)) {
-      for (size_t i = 0; i < stmt.NumMeStmtOpnds(); ++i) {
-        Rename2PregExpr(aliasClass, irMap, stmt, utils::ToRef(stmt.GetOpnd(i)));
-      }
-      Rename2PregCallReturn(aliasClass, utils::ToRef(stmt.GetMustDefList()));
-    } else if (instance_of<IassignMeStmt>(stmt)) {
-      auto *iAssignStmt = static_cast<IassignMeStmt*>(&stmt);
-      Rename2PregExpr(aliasClass, irMap, stmt, utils::ToRef(iAssignStmt->GetRHS()));
-      Rename2PregExpr(aliasClass, irMap, stmt, utils::ToRef(utils::ToRef(iAssignStmt->GetLHSVal()).GetBase()));
-    } else {
-      for (size_t i = 0; i < stmt.NumMeStmtOpnds(); ++i) {
-        Rename2PregExpr(aliasClass, irMap, stmt, utils::ToRef(stmt.GetOpnd(i)));
+    RegMeExpr *curtemp = nullptr;
+    MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(mirst->GetTyIdx());
+    if (ty->GetKind() != kTypeScalar && ty->GetKind() != kTypePointer) {
+      return nullptr;
+    }
+    curtemp = meirmap->CreateRegMeExpr(*ty);
+    OriginalSt *pregOst = ssaTab->GetOriginalStTable().CreatePregOriginalSt(curtemp->GetRegIdx(), func->GetMirFunc()->GetPuidx());
+    pregOst->SetIsFormal(ost->IsFormal());
+    sym2reg_map[ost->GetIndex()] = pregOst;
+    vstidx2reg_map.insert(std::make_pair(varmeexpr->GetExprID(), curtemp));
+    if (ost->IsFormal()) {
+      uint32 parmindex = func->GetMirFunc()->GetFormalIndex(mirst);
+      CHECK_FATAL(parm_used_vec[parmindex], "parm_used_vec not set correctly");
+      if (!reg_formal_vec[parmindex]) {
+        reg_formal_vec[parmindex] = curtemp;
       }
     }
+    if (DEBUGFUNC(func)) {
+      ost->Dump();
+      LogInfo::MapleLogger() << "(ost idx " << ost->GetIndex() << ") renamed to ";
+      pregOst->Dump();
+      LogInfo::MapleLogger() << std::endl;
+    }
+    return curtemp;
   }
+}
 
-  void Rename2PregCallReturn(const AliasClass &aliasClass, MapleVector<MustDefMeNode> &mustDefNodes) {
-    if (mustDefNodes.empty()) {
+void SSARename2Preg::Rename2PregCallReturn(MapleVector<MustDefMeNode> &mustdeflist) {
+  if (mustdeflist.empty()) {
+    return;
+  }
+  CHECK_FATAL(mustdeflist.size() == 1, "NYI");
+  {
+    MustDefMeNode &mustdefmenode = mustdeflist.front();
+    MeExpr *melhs = mustdefmenode.GetLHS();
+    if (melhs->GetMeOp() != kMeOpVar) {
       return;
-    }
+    };
+    VarMeExpr *lhs = static_cast<VarMeExpr *>(melhs);
+    SetupParmUsed(lhs);
 
-    CHECK_FATAL(mustDefNodes.size() == 1, "NYI");
-    MustDefMeNode &mustDefNode = mustDefNodes.front();
-    auto *lhs = safe_cast<VarMeExpr>(mustDefNode.GetLHS());
-    if (lhs == nullptr) {
-      return;
+    RegMeExpr *varreg = RenameVar(lhs);
+    if (varreg != nullptr) {
+      mustdefmenode.UpdateLHS(*varreg);
     }
+  }
+}
 
-    OriginalSt *ost = lhs->GetOst();
-    RegMeExpr *regExpr = RenameVar(aliasClass, *lhs);
-    if (regExpr != nullptr) {
-      mustDefNode.UpdateLHS(*regExpr);
+// update regphinode operands
+void SSARename2Preg::UpdateRegPhi(MePhiNode *mevarphinode, MePhiNode *regphinode, const RegMeExpr *curtemp,
+                                  const VarMeExpr *lhs) {
+  // update phi's opnds
+  for (uint32 i = 0; i < mevarphinode->GetOpnds().size(); i++) {
+    ScalarMeExpr *opndexpr = mevarphinode->GetOpnds()[i];
+    ASSERT(opndexpr->GetOst()->GetIndex() == lhs->GetOst()->GetIndex(), "phi is not correct");
+    MapleUnorderedMap<int, RegMeExpr *>::iterator verit = vstidx2reg_map.find(opndexpr->GetExprID());
+    RegMeExpr *opndtemp = nullptr;
+    if (verit == vstidx2reg_map.end()) {
+      opndtemp = meirmap->CreateRegMeExprVersion(*curtemp);
+      vstidx2reg_map.insert(std::make_pair(opndexpr->GetExprID(), opndtemp));
     } else {
-      CHECK_FATAL(ost->IsRealSymbol(), "NYI");
+      opndtemp = verit->second;
     }
+    regphinode->GetOpnds().push_back(opndtemp);
   }
+}
 
-  // only handle the leaf of load, because all other expressions has been done by previous SSAPre
-  void Rename2PregExpr(const AliasClass &aliasClass, MeIRMap &irMap, MeStmt &stmt, MeExpr &expr) {
-    if (instance_of<OpMeExpr>(expr)) {
-      auto *opExpr = static_cast<OpMeExpr*>(&expr);
-      for (size_t i = 0; i < kOperandNumTernary; ++i) {
-        MeExpr *opnd = opExpr->GetOpnd(i);
-        if (opnd != nullptr) {
-          Rename2PregExpr(aliasClass, irMap, stmt, *opnd);
-        }
-      }
-    } else if (instance_of<NaryMeExpr>(expr)) {
-      auto *naryExpr = static_cast<NaryMeExpr*>(&expr);
-      MapleVector<MeExpr*> &opnds = naryExpr->GetOpnds();
-      for (auto *opnd : opnds) {
-        Rename2PregExpr(aliasClass, irMap, stmt, utils::ToRef(opnd));
-      }
-    } else if (instance_of<IvarMeExpr>(expr)) {
-      auto *ivarExpr = static_cast<IvarMeExpr*>(&expr);
-      Rename2PregExpr(aliasClass, irMap, stmt, utils::ToRef(ivarExpr->GetBase()));
-    } else if (instance_of<VarMeExpr>(expr)) {
-      auto *varExpr = static_cast<VarMeExpr*>(&expr);
-      Rename2PregLeafRHS(aliasClass, irMap, stmt, *varExpr);
-    }
+void SSARename2Preg::Rename2PregPhi(BB *mebb, MePhiNode *mevarphinode,
+       MapleMap<OStIdx, MePhiNode *> &regPhiList) {
+  VarMeExpr *lhs = static_cast<VarMeExpr*>(mevarphinode->GetLHS());
+  SetupParmUsed(lhs);
+  RegMeExpr *lhsreg = RenameVar(lhs);
+  if (lhsreg != nullptr) {
+    MePhiNode *regphinode = meirmap->CreateMePhi(*lhsreg);
+    regphinode->SetDefBB(mevarphinode->GetDefBB());
+    UpdateRegPhi(mevarphinode, regphinode, lhsreg, lhs);
+    regPhiList.insert(std::make_pair(lhsreg->GetOst()->GetIndex(), regphinode));
   }
+}
 
-  void Rename2PregLeafRHS(const AliasClass &aliasClass, MeIRMap &irMap, MeStmt &stmt, const VarMeExpr &varExpr) {
-    RegMeExpr *regExpr = RenameVar(aliasClass, varExpr);
-    if (regExpr != nullptr) {
-      (void)irMap.ReplaceMeExprStmt(stmt, varExpr, *regExpr);
-    }
+void SSARename2Preg::Rename2PregLeafRHS(MeStmt *mestmt, VarMeExpr *varmeexpr) {
+  SetupParmUsed(varmeexpr);
+  RegMeExpr *varreg = RenameVar(varmeexpr);
+  if (varreg != nullptr) {
+    meirmap->ReplaceMeExprStmt(*mestmt, *varmeexpr, *varreg);
   }
+}
 
-  void Rename2PregLeafLHS(const AliasClass &aliasClass,
-                          const VarMeExpr &varExpr,
-                          MeStmt &stmt,
-                          MeIRMap &irMap) {
-    RegMeExpr *regExpr = RenameVar(aliasClass, varExpr);
-    if (regExpr != nullptr) {
-      MeExpr *oldRhs = nullptr;
-      if (instance_of<DassignMeStmt>(stmt)) {
-        auto *dassStmt = static_cast<DassignMeStmt*>(&stmt);
-        oldRhs = dassStmt->GetRHS();
-      } else if (instance_of<MaydassignMeStmt>(stmt)) {
-        auto *mayDassStmt = static_cast<MaydassignMeStmt*>(&stmt);
-        oldRhs = mayDassStmt->GetRHS();
+void SSARename2Preg::Rename2PregLeafLHS(MeStmt *mestmt, VarMeExpr *varmeexpr) {
+  SetupParmUsed(varmeexpr);
+  RegMeExpr *varreg = RenameVar(varmeexpr);
+  if (varreg != nullptr) {
+    Opcode desop = mestmt->GetOp();
+    CHECK_FATAL(desop == OP_dassign || desop == OP_maydassign, "NYI");
+    MeExpr *oldrhs = (desop == OP_dassign) ? (static_cast<DassignMeStmt *>(mestmt)->GetRHS())
+                                           : (static_cast<MaydassignMeStmt *>(mestmt)->GetRHS());
+    if (GetPrimTypeSize(oldrhs->GetPrimType()) > GetPrimTypeSize(varreg->GetPrimType())) {
+      // insert integer truncation
+      if (GetPrimTypeSize(varreg->GetPrimType()) >= 4) {
+        oldrhs = meirmap->CreateMeExprTypeCvt(varreg->GetPrimType(), oldrhs->GetPrimType(), *oldrhs);
       } else {
-        CHECK_FATAL(false, "NYI");
+        Opcode extOp = IsSignedInteger(varreg->GetPrimType()) ? OP_sext : OP_zext;
+        PrimType newPrimType = PTY_u32;
+        if (IsSignedInteger(varreg->GetPrimType())) {
+          newPrimType = PTY_i32;
+        }
+        OpMeExpr opmeexpr(-1, extOp, newPrimType, 1);
+        opmeexpr.SetBitsSize(GetPrimTypeSize(varreg->GetPrimType()) * 8);
+        opmeexpr.SetOpnd(0, oldrhs);
+        oldrhs = meirmap->HashMeExpr(opmeexpr);
       }
-
-      auto &regAssignStmt = utils::ToRef(irMap.New<RegassignMeStmt>(regExpr, oldRhs));
-      regAssignStmt.CopyBase(stmt);
-      utils::ToRef(stmt.GetBB()).InsertMeStmtBefore(&stmt, &regAssignStmt);
-      utils::ToRef(stmt.GetBB()).RemoveMeStmt(&stmt);
     }
+    RegassignMeStmt *regssmestmt = meirmap->New<RegassignMeStmt>(varreg, oldrhs);
+    regssmestmt->CopyBase(*mestmt);
+    mestmt->GetBB()->InsertMeStmtBefore(mestmt, regssmestmt);
+    mestmt->GetBB()->RemoveMeStmt(mestmt);
   }
+}
 
-  void Rename2PregPhi(const AliasClass &aliasClass, MePhiNode &varPhiNode, MeIRMap &irMap) {
-    VarMeExpr *lhs = static_cast<VarMeExpr*>(varPhiNode.GetLHS());
-    if (lhs == nullptr) {
-      return;
-    }
-
-    VarMeExpr &varExpr = (utils::ToRef(lhs));
-    RegMeExpr *pRegExpr = RenameVar(aliasClass, varExpr);
-    if (pRegExpr == nullptr) {
-      return;
-    }
-    RegMeExpr &regExpr = *pRegExpr;
-    MePhiNode &regPhiNode = utils::ToRef(irMap.CreateMePhi(regExpr));
-    regPhiNode.SetDefBB(varPhiNode.GetDefBB());
-    UpdateRegPhi(regExpr, varPhiNode.GetOpnds(), regPhiNode);
+void SSARename2Preg::SetupParmUsed(const VarMeExpr *varmeexpr) {
+  const OriginalSt *ost = varmeexpr->GetOst();
+  if (ost->IsFormal() && ost->IsSymbolOst()) {
+    const MIRSymbol *mirst = ost->GetMIRSymbol();
+    uint32 index = func->GetMirFunc()->GetFormalIndex(mirst);
+    parm_used_vec[index] = true;
   }
+}
 
-  // update regphinode operands
-  void UpdateRegPhi(const RegMeExpr &curRegExpr, const MapleVector<ScalarMeExpr*> &phiNodeOpnds,
-                    MePhiNode &regPhiNode) const {
-    PregCache &pregCache = cacheProxy.Preg();
-    for (ScalarMeExpr *phiOpnd : phiNodeOpnds) {
-      const VarMeExpr &varExpr = utils::ToRef(static_cast<VarMeExpr*>(phiOpnd));
-      RegMeExpr &regExpr = pregCache.CloneRegExprIfNotExist(varExpr, [&curRegExpr](MeIRMap &irMap) {
-        return irMap.CreateRegMeExprVersion(curRegExpr);
-      });
-      regPhiNode.GetOpnds().push_back(&regExpr);
+// only handle the leaf of load, because all other expressions has been done by previous SSAPre
+void SSARename2Preg::Rename2PregExpr(MeStmt *mestmt, MeExpr *meexpr) {
+  MeExprOp meOp = meexpr->GetMeOp();
+  switch (meOp) {
+    case kMeOpIvar:
+    case kMeOpOp:
+    case kMeOpNary: {
+      for (int32 i = 0; i < meexpr->GetNumOpnds(); i++) {
+        Rename2PregExpr(mestmt, meexpr->GetOpnd(i));
+      }
+      break;
+    }
+    case kMeOpVar:
+      Rename2PregLeafRHS(mestmt, static_cast<VarMeExpr *>(meexpr));
+      break;
+    case kMeOpAddrof: {
+      AddrofMeExpr *addrofx = static_cast<AddrofMeExpr *>(meexpr);
+      const OriginalSt *ost = ssaTab->GetOriginalStFromID(addrofx->GetOstIdx());
+      if (ost->IsFormal()) {
+        const MIRSymbol *mirst = ost->GetMIRSymbol();
+        uint32 index = func->GetMirFunc()->GetFormalIndex(mirst);
+        parm_used_vec[index] = true;
+      }
+      break;
     }
+    default:
+      break;
   }
+  return;
+}
 
-  RegMeExpr *RenameVar(const AliasClass &aliasClass, const VarMeExpr &varExpr) {
-    OriginalSt *ost = varExpr.GetOst();
-    formal.MarkUsed(*ost);
-
-    if (varExpr.GetOst()->GetFieldID() != 0) {
-      return nullptr;
+void SSARename2Preg::Rename2PregStmt(MeStmt *stmt) {
+  Opcode op = stmt->GetOp();
+  switch (op) {
+    case OP_dassign:
+    case OP_maydassign: {
+      CHECK_FATAL(stmt->GetRHS() && stmt->GetVarLHS(), "null ptr check");
+      Rename2PregExpr(stmt, stmt->GetRHS());
+      Rename2PregLeafLHS(stmt, static_cast<VarMeExpr *>(stmt->GetVarLHS()));
+      break;
     }
-
-    if (varExpr.GetPrimType() == PTY_agg) {
-      return nullptr;
+    case OP_callassigned:
+    case OP_virtualcallassigned:
+    case OP_virtualicallassigned:
+    case OP_superclasscallassigned:
+    case OP_interfacecallassigned:
+    case OP_interfaceicallassigned:
+    case OP_customcallassigned:
+    case OP_polymorphiccallassigned:
+    case OP_icallassigned:
+    case OP_intrinsiccallassigned:
+    case OP_xintrinsiccallassigned:
+    case OP_intrinsiccallwithtypeassigned: {
+      for (int32 i = 0; i < stmt->NumMeStmtOpnds(); i++) {
+        Rename2PregExpr(stmt, stmt->GetOpnd(i));
+      }
+      MapleVector<MustDefMeNode> *mustdeflist = stmt->GetMustDefList();
+      Rename2PregCallReturn(*mustdeflist);
+      break;
     }
-
-    if (ost->GetIndirectLev() != 0) {
-      return nullptr;
+    case OP_iassign: {
+      IassignMeStmt *ivarstmt = static_cast<IassignMeStmt *>(stmt);
+      Rename2PregExpr(stmt, ivarstmt->GetRHS());
+      Rename2PregExpr(stmt, ivarstmt->GetLHS()->GetBase());
+      break;
     }
+    default:
+      for (int32 i = 0; i < stmt->NumMeStmtOpnds(); i++) {
+        Rename2PregExpr(stmt, stmt->GetOpnd(i));
+      }
+      break;
+  }
+}
 
-    CHECK_FATAL(ost->IsRealSymbol(), "NYI");
-    const MIRSymbol &irSymbol = utils::ToRef(ost->GetMIRSymbol());
-    if (irSymbol.GetAttr(ATTR_localrefvar)) {
-      return nullptr;
-    }
-    if (ost->IsFormal() && varExpr.GetPrimType() == PTY_ref) {
-      return nullptr;
+void SSARename2Preg::UpdateMirFunctionFormal() {
+  MIRFunction *mirFunc = func->GetMirFunc();
+  const MIRBuilder *mirbuilder = mirModule->GetMIRBuilder();
+  for (uint32 i = 0; i < mirFunc->GetFormalDefVec().size(); i++) {
+    if (!parm_used_vec[i]) {
+      // in this case, the paramter is not used by any statement, promote it
+      MIRType *mirType = GlobalTables::GetTypeTable().GetTypeFromTyIdx(mirFunc->GetFormalDefVec()[i].formalTyIdx);
+      if (mirType->GetPrimType() != PTY_agg) {
+        PregIdx16 regIdx = mirFunc->GetPregTab()->CreatePreg(mirType->GetPrimType(), mirType->GetPrimType() == PTY_ref ? mirType : nullptr);
+        mirFunc->GetFormalDefVec()[i].formalSym = mirbuilder->CreatePregFormalSymbol(mirType->GetTypeIndex(), regIdx, *mirFunc);
+      }
+    } else {
+      RegMeExpr *regformal = reg_formal_vec[i];
+      if (regformal) {
+        PregIdx16 regIdx = regformal->GetRegIdx();
+        MIRSymbol *oldformalst = mirFunc->GetFormalDefVec()[i].formalSym;
+        MIRSymbol *newformalst = mirbuilder->CreatePregFormalSymbol(oldformalst->GetTyIdx(), regIdx, *mirFunc);
+        mirFunc->GetFormalDefVec()[i].formalSym = newformalst;
+      }
     }
+  }
+}
 
-    OriginalSt *cacheOSt = cacheProxy.OSt().Find(ost->GetIndex());
-    if (cacheOSt != nullptr) {
-      // replaced previously
-      return &cacheProxy.Preg().CloneRegExprIfNotExist(varExpr, [cacheOSt](MeIRMap &irMap) {
-        return irMap.CreateRegMeExprVersion(*cacheOSt);
-      });
-    }
+void SSARename2Preg::Init() {
+  uint32 formalsize = func->GetMirFunc()->GetFormalDefVec().size();
+  parm_used_vec.resize(formalsize);
+  reg_formal_vec.resize(formalsize);
+}
 
-    if (!irSymbol.IsLocal()) {
-      return nullptr;
+void SSARename2Preg::RunSelf() {
+  Init();
+  for (BB *mebb : func->GetAllBBs()) {
+    if (mebb == nullptr) {
+      continue;
     }
-    if (ost->IsAddressTaken()) {
-      return nullptr;
+    // rename the phi'ss
+    if (DEBUGFUNC(func)) {
+      LogInfo::MapleLogger() << " working on phi part of BB" << mebb->GetBBId() << std::endl;
     }
-    const AliasElem *aliasElem = GetAliasElem(aliasClass, *ost);
-    if (aliasElem == nullptr || aliasElem->GetClassSet() != nullptr) {
-      return nullptr;
+    MapleMap<OStIdx, MePhiNode *> &phiList = mebb->GetMePhiList();
+    MapleMap<OStIdx, MePhiNode *> regPhiList(func->GetIRMap()->GetIRMapAlloc().Adapter());
+    for (std::pair<const OStIdx, MePhiNode *> apair : phiList) {
+      if (!apair.second->UseReg()) {
+        Rename2PregPhi(mebb, apair.second, regPhiList);
+      }
     }
+    phiList.insert(regPhiList.begin(), regPhiList.end());
 
-    RegMeExpr &newRegExpr = cacheProxy.Preg().CreatePregExpr(varExpr, irSymbol.GetTyIdx());
-    OriginalSt &pregOst = cacheProxy.OSt().CreatePregOst(newRegExpr, *ost);
-
-    formal.MarkRenamed(*ost, irSymbol, newRegExpr);
-
-    if (enabledDebug) {
-      ost->Dump();
-      LogInfo::MapleLogger() << "(ost idx " << ost->GetIndex() << ") renamed to ";
-      pregOst.Dump();
-      LogInfo::MapleLogger() << '\n';
+    if (DEBUGFUNC(func)) {
+      LogInfo::MapleLogger() << " working on stmt part of BB" << mebb->GetBBId() << std::endl;
     }
-    return &newRegExpr;
-  }
-
-  const AliasElem *GetAliasElem(const AliasClass &aliasClass, const OriginalSt &ost) const {
-    if (ost.GetIndex() >= aliasClass.GetAliasElemCount()) {
-      return nullptr;
+    for (MeStmt &stmt : mebb->GetMeStmts()) {
+      Rename2PregStmt(&stmt);
     }
-    return aliasClass.FindAliasElem(ost);
   }
 
- private:
-  SSATab *ssaTab;
-  bool enabledDebug;
+  UpdateMirFunctionFormal();
+}
 
-  CacheProxy cacheProxy;
-  FormalRenaming formal;
-};
-} // namespace
+void SSARename2Preg::PromoteEmptyFunction() {
+  Init();
+  UpdateMirFunctionFormal();
+}
 
-namespace maple {
+AnalysisResult *MeDoSSARename2Preg::Run(MeFunction *func, MeFuncResultMgr *m, ModuleResultMgr *mrMgr) {
+  MeIRMap *irMap = static_cast<MeIRMap *>(m->GetAnalysisResult(MeFuncPhase_IRMAPBUILD, func));
+  ASSERT(irMap != nullptr, "");
+
+  MemPool *renamemp = memPoolCtrler.NewMemPool(PhaseName().c_str());
+  if (func->GetAllBBs().size() == 0) {
+    // empty function, we only promote the parameter
+    SSARename2Preg emptyrenamer(renamemp, func, nullptr, nullptr);
+    emptyrenamer.PromoteEmptyFunction();
+    memPoolCtrler.DeleteMemPool(renamemp);
+    return nullptr;
+  }
 
-AnalysisResult *MeDoSSARename2Preg::Run(MeFunction *func, MeFuncResultMgr *funcRst, ModuleResultMgr *) {
-  MeFunction &rFunc = utils::ToRef(func);
-  SSARename2Preg phase(utils::ToRef(rFunc.GetMirFunc()), rFunc.GetMeSSATab(), DEBUGFUNC(func));
-  phase.Run(rFunc, funcRst);
+  AliasClass *aliasclass = static_cast<AliasClass *>(m->GetAnalysisResult(MeFuncPhase_ALIASCLASS, func));
+  ASSERT(aliasclass != nullptr, "");
+
+  SSARename2Preg ssarename2preg(renamemp, func, irMap, aliasclass);
+  ssarename2preg.RunSelf();
+  if (DEBUGFUNC(func)) {
+    irMap->Dump();
+  }
+  memPoolCtrler.DeleteMemPool(renamemp);
 
   return nullptr;
 }
 
-std::string MeDoSSARename2Preg::PhaseName() const {
-  return SSARename2Preg::PhaseName();
-}
 }  // namespace maple
-
diff --git a/src/mapleall/maple_me/src/me_ssa_update.cpp b/src/mapleall/maple_me/src/me_ssa_update.cpp
index ac4357fbcbfd2352ef9e97ec1314110a5f0acf81..29f0da3a6854a1bf81dadfdd5eaf6226fd39fd66 100644
--- a/src/mapleall/maple_me/src/me_ssa_update.cpp
+++ b/src/mapleall/maple_me/src/me_ssa_update.cpp
@@ -61,8 +61,7 @@ void MeSSAUpdate::RenamePhi(const BB &bb) {
     phi->SetIsLive(true);  // always make it live, for correctness
     if (phi->GetLHS() == nullptr) {
       // create a new VarMeExpr defined by this phi
-      VarMeExpr *newVar =
-          irMap.CreateNewVarMeExpr(ssaTab.GetOriginalStFromID(it2->first), ssaTab.GetPrimType(it2->first));
+      VarMeExpr *newVar = irMap.CreateVarMeExprVersion(ssaTab.GetOriginalStFromID(it2->first));
       phi->UpdateLHS(*newVar);
       it1->second->push(newVar);  // push the stack
     } else {
diff --git a/src/mapleall/maple_me/src/me_ssi.cpp b/src/mapleall/maple_me/src/me_ssi.cpp
index 6b0766a5f46f429195e8ca6881d075de5c9aab1b..48d9b69d5bde0e0fe5d1242b8356f3a67269f6a3 100644
--- a/src/mapleall/maple_me/src/me_ssi.cpp
+++ b/src/mapleall/maple_me/src/me_ssi.cpp
@@ -30,7 +30,7 @@ VarMeExpr *MeSSI::CreateNewPiExpr(const MeExpr &opnd) {
   VarMeExpr *var = irMap->New<VarMeExpr>(irMap->GetExprID(), ost,
                                          irMap->GetVerst2MeExprTable().size(), opnd.GetPrimType());
   irMap->SetExprID(irMap->GetExprID() + 1);
-  irMap->PushBackVerst2MeExprTable(var);
+  irMap->GetVerst2MeExprTable().push_back(var);
   ost->PushbackVersionsIndices(var->GetVstIdx());
   return var;
 }
diff --git a/src/mapleall/maple_me/src/ssa_pre.cpp b/src/mapleall/maple_me/src/ssa_pre.cpp
index 3c4961fa91bb9d9e6564cd2ada64f626ec00e77a..c298f490947590ab9f7cd7f16a1e50fdce1dde5e 100644
--- a/src/mapleall/maple_me/src/ssa_pre.cpp
+++ b/src/mapleall/maple_me/src/ssa_pre.cpp
@@ -53,7 +53,7 @@ MeExpr *SSAPre::CreateNewCurTemp(const MeExpr &meExpr) {
       auto *varMeExpr = static_cast<const VarMeExpr*>(&meExpr);
       const MIRSymbol *sym = varMeExpr->GetOst()->GetMIRSymbol();
       MIRType *ty = GlobalTables::GetTypeTable().GetTypeFromTyIdx(sym->GetTyIdx());
-      regVar = ty->GetPrimType() == PTY_ref ? irMap->CreateRegRefMeExpr(*ty)
+      regVar = ty->GetPrimType() == PTY_ref ? irMap->CreateRegMeExpr(*ty)
                                             : irMap->CreateRegMeExpr(ty->GetPrimType());
     } else if (meExpr.GetMeOp() == kMeOpIvar) {
       auto *ivarMeExpr = static_cast<const IvarMeExpr*>(&meExpr);
@@ -72,11 +72,11 @@ MeExpr *SSAPre::CreateNewCurTemp(const MeExpr &meExpr) {
                   (ty->GetPrimType() == PTY_ptr && meExpr.GetPrimType() == PTY_ref) ||
                   (ty->GetPrimType() == PTY_ref && meExpr.GetPrimType() == PTY_ptr),
                   "inconsistent type");
-      regVar = (ty->GetPrimType() == PTY_ref) ? (irMap->CreateRegRefMeExpr(*ty))
+      regVar = (ty->GetPrimType() == PTY_ref) ? (irMap->CreateRegMeExpr(*ty))
                                               : (irMap->CreateRegMeExpr(ty->GetPrimType()));
     } else {
       regVar = meExpr.GetPrimType() != PTY_ref ? irMap->CreateRegMeExpr(meExpr.GetPrimType())
-                                                : irMap->CreateRegRefMeExpr(meExpr);
+                                                : irMap->CreateRegMeExpr(meExpr);
     }
     curTemp = regVar;
     if (preKind == kLoadPre) {
@@ -84,7 +84,7 @@ MeExpr *SSAPre::CreateNewCurTemp(const MeExpr &meExpr) {
     }
     return regVar;
   } else {
-    VarMeExpr *tempVar = irMap->CreateNewGlobalTmp(NewTempStrIdx(), meExpr.GetPrimType());
+    VarMeExpr *tempVar = irMap->CreateNewVar(NewTempStrIdx(), meExpr.GetPrimType(), true);
     curTemp = tempVar;
     return tempVar;
   }